@enjoys/context-engine 1.0.0 → 1.0.2

package/data/completion/lua.json

@@ -0,0 +1,968 @@
+{
+  "language": "lua",
+  "completions": [
+    {
+      "label": "print",
+      "kind": 1,
+      "detail": "Print values to stdout",
+      "documentation": { "value": "Receives any number of arguments and prints their values to stdout, converting each with `tostring`.\n\n```lua\nprint(\"Hello, world!\")\nprint(\"x =\", x, \"y =\", y)\n```" },
+      "insertText": "print(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "00_print"
+    },
+    {
+      "label": "type",
+      "kind": 1,
+      "detail": "Return type of a value as a string",
+      "documentation": { "value": "Returns the type of its argument as a string. Possible results are `\"nil\"`, `\"number\"`, `\"string\"`, `\"boolean\"`, `\"table\"`, `\"function\"`, `\"thread\"`, and `\"userdata\"`.\n\n```lua\nprint(type(42))        -- \"number\"\nprint(type(\"hello\"))   -- \"string\"\nprint(type(nil))       -- \"nil\"\n```" },
+      "insertText": "type(${1:v})",
+      "insertTextRules": 4,
+      "sortText": "00_type"
+    },
+    {
+      "label": "tostring",
+      "kind": 1,
+      "detail": "Convert a value to a string",
+      "documentation": { "value": "Receives a value of any type and converts it to a string in a human-readable format. If the metatable has a `__tostring` metamethod, it is called with the value as argument.\n\n```lua\ntostring(123)    -- \"123\"\ntostring(true)   -- \"true\"\ntostring(nil)    -- \"nil\"\n```" },
+      "insertText": "tostring(${1:v})",
+      "insertTextRules": 4,
+      "sortText": "00_tostring"
+    },
+    {
+      "label": "tonumber",
+      "kind": 1,
+      "detail": "Convert a value to a number",
+      "documentation": { "value": "Tries to convert its argument to a number. If the argument is already a number or a convertible string, returns the number; otherwise returns `nil`. An optional base (2–36) specifies the base for interpretation.\n\n```lua\ntonumber(\"42\")       -- 42\ntonumber(\"0xff\")     -- 255\ntonumber(\"1010\", 2)  -- 10\n```" },
+      "insertText": "tonumber(${1:e}${2:, ${3:base}})",
+      "insertTextRules": 4,
+      "sortText": "00_tonumber"
+    },
+    {
+      "label": "pairs",
+      "kind": 1,
+      "detail": "Iterate over all key-value pairs in a table",
+      "documentation": { "value": "Returns an iterator function, the table, and `nil`, so that the construction `for k, v in pairs(t) do ... end` iterates over all key–value pairs of table `t`.\n\n```lua\nfor k, v in pairs(myTable) do\n    print(k, v)\nend\n```" },
+      "insertText": "pairs(${1:t})",
+      "insertTextRules": 4,
+      "sortText": "00_pairs"
+    },
+    {
+      "label": "ipairs",
+      "kind": 1,
+      "detail": "Iterate over integer-keyed elements of a table",
+      "documentation": { "value": "Returns an iterator function, the table, and `0`, so that the construction `for i, v in ipairs(t) do ... end` iterates over the integer keys 1, 2, ... of table `t`.\n\n```lua\nlocal fruits = {\"apple\", \"banana\", \"cherry\"}\nfor i, v in ipairs(fruits) do\n    print(i, v)\nend\n```" },
+      "insertText": "ipairs(${1:t})",
+      "insertTextRules": 4,
+      "sortText": "00_ipairs"
+    },
+    {
+      "label": "next",
+      "kind": 1,
+      "detail": "Get next key-value pair from a table",
+      "documentation": { "value": "Allows a program to traverse all fields of a table. Its first argument is a table and its second argument is an index. Returns the next index and its value. When called with `nil` as second argument, returns the first index.\n\n```lua\nlocal k, v = next(t)       -- first pair\nlocal k2, v2 = next(t, k)  -- next pair\n```" },
+      "insertText": "next(${1:table}${2:, ${3:index}})",
+      "insertTextRules": 4,
+      "sortText": "00_next"
+    },
+    {
+      "label": "select",
+      "kind": 1,
+      "detail": "Select from argument list",
+      "documentation": { "value": "If `index` is a number, returns all arguments after argument number `index`. If `index` is `\"#\"`, returns the total number of extra arguments received.\n\n```lua\nselect(2, \"a\", \"b\", \"c\")  -- \"b\", \"c\"\nselect(\"#\", \"a\", \"b\", \"c\") -- 3\n```" },
+      "insertText": "select(${1:index}, ${2:...})",
+      "insertTextRules": 4,
+      "sortText": "00_select"
+    },
+    {
+      "label": "unpack",
+      "kind": 1,
+      "detail": "Unpack elements from a table (Lua 5.1/LuaJIT)",
+      "documentation": { "value": "Returns the elements from the given list. In Lua 5.1 and LuaJIT this is a global function. In Lua 5.2+ it has been moved to `table.unpack`.\n\n```lua\nlocal a, b, c = unpack({10, 20, 30})\n-- a=10, b=20, c=30\n```\n\n**Note:** Use `table.unpack` in Lua 5.2+." },
+      "insertText": "unpack(${1:list}${2:, ${3:i}${4:, ${5:j}}})",
+      "insertTextRules": 4,
+      "sortText": "00_unpack"
+    },
+    {
+      "label": "pcall",
+      "kind": 1,
+      "detail": "Protected call — catch errors",
+      "documentation": { "value": "Calls function `f` with the given arguments in protected mode. If there are no errors, returns `true` plus results. If there is an error, returns `false` plus the error object.\n\n```lua\nlocal ok, result = pcall(function()\n    return riskyOperation()\nend)\nif not ok then\n    print(\"Error:\", result)\nend\n```" },
+      "insertText": "pcall(${1:f}${2:, ${3:args}})",
+      "insertTextRules": 4,
+      "sortText": "00_pcall"
+    },
+    {
+      "label": "xpcall",
+      "kind": 1,
+      "detail": "Protected call with error handler",
+      "documentation": { "value": "Similar to `pcall`, but sets a message handler `msgh` for errors. Any error inside `f` is not propagated; instead, `xpcall` catches the error, calls `msgh` with the original error, and returns the status code plus the result from `msgh`.\n\n```lua\nlocal ok, result = xpcall(riskyFunc, function(err)\n    return debug.traceback(err, 2)\nend)\n```\n\n**Note:** In Lua 5.1, `xpcall` does not accept arguments for the called function. Lua 5.2+ and LuaJIT 2.1 support extra arguments." },
+      "insertText": "xpcall(${1:f}, ${2:msgh}${3:, ${4:args}})",
+      "insertTextRules": 4,
+      "sortText": "00_xpcall"
+    },
+    {
+      "label": "error",
+      "kind": 1,
+      "detail": "Raise an error",
+      "documentation": { "value": "Raises an error with `message` as the error object. `level` specifies where the error points (1 = current function, 2 = caller, etc., 0 = no position info).\n\n```lua\nerror(\"something went wrong\")\nerror(\"invalid argument\", 2)\nerror({code = 404, msg = \"not found\"})\n```" },
+      "insertText": "error(${1:message}${2:, ${3:level}})",
+      "insertTextRules": 4,
+      "sortText": "00_error"
+    },
+    {
+      "label": "assert",
+      "kind": 1,
+      "detail": "Assert a condition, raising error if false/nil",
+      "documentation": { "value": "Calls `error` if the value of its argument `v` is false (i.e., `nil` or `false`); otherwise returns all its arguments.\n\n```lua\nassert(type(x) == \"number\", \"x must be a number\")\nlocal f = assert(io.open(filename, \"r\"))\n```" },
+      "insertText": "assert(${1:v}${2:, ${3:message}})",
+      "insertTextRules": 4,
+      "sortText": "00_assert"
+    },
+    {
+      "label": "require",
+      "kind": 1,
+      "detail": "Load a module",
+      "documentation": { "value": "Loads the given module. Searches for a loader using `package.searchers` (Lua 5.2+) or `package.loaders` (Lua 5.1). Caches results in `package.loaded`.\n\n```lua\nlocal json = require(\"cjson\")\nlocal utils = require(\"mylib.utils\")\n```" },
+      "insertText": "require(\"${1:modname}\")",
+      "insertTextRules": 4,
+      "sortText": "00_require"
+    },
+    {
+      "label": "dofile",
+      "kind": 1,
+      "detail": "Execute a Lua file",
+      "documentation": { "value": "Opens the named file and executes its contents as a Lua chunk. Returns any values returned by the chunk. In case of errors, propagates them to the caller.\n\n```lua\ndofile(\"config.lua\")\nlocal result = dofile(\"script.lua\")\n```" },
+      "insertText": "dofile(\"${1:filename}\")",
+      "insertTextRules": 4,
+      "sortText": "00_dofile"
+    },
+    {
+      "label": "loadfile",
+      "kind": 1,
+      "detail": "Load a Lua file as a chunk without executing",
+      "documentation": { "value": "Loads a chunk from file `filename` without running it. Returns the compiled chunk as a function, or `nil` plus error message on failure.\n\n```lua\nlocal chunk, err = loadfile(\"script.lua\")\nif chunk then chunk() end\n```\n\n**Lua 5.2+:** Accepts optional `mode` and `env` parameters." },
+      "insertText": "loadfile(\"${1:filename}\")",
+      "insertTextRules": 4,
+      "sortText": "00_loadfile"
+    },
+    {
+      "label": "load",
+      "kind": 1,
+      "detail": "Load a chunk from a string or function",
+      "documentation": { "value": "Loads a chunk. If `chunk` is a string, loads that string. If it is a function, calls it repeatedly to get pieces. Returns the compiled chunk as a function.\n\n```lua\nlocal fn = load(\"return 2 + 2\")\nprint(fn())  -- 4\n```\n\n**Lua 5.1:** Use `loadstring` for strings. Lua 5.2+ unified into `load`." },
+      "insertText": "load(${1:chunk}${2:, ${3:chunkname}${4:, ${5:mode}${6:, ${7:env}}}})",
+      "insertTextRules": 4,
+      "sortText": "00_load"
+    },
+    {
+      "label": "rawget",
+      "kind": 1,
+      "detail": "Get a table value without invoking metamethods",
+      "documentation": { "value": "Gets the real value of `table[index]` without invoking the `__index` metamethod.\n\n```lua\nlocal v = rawget(t, \"key\")\n```" },
+      "insertText": "rawget(${1:table}, ${2:index})",
+      "insertTextRules": 4,
+      "sortText": "00_rawget"
+    },
+    {
+      "label": "rawset",
+      "kind": 1,
+      "detail": "Set a table value without invoking metamethods",
+      "documentation": { "value": "Sets the real value of `table[index]` to `value` without invoking the `__newindex` metamethod. Returns `table`.\n\n```lua\nrawset(t, \"key\", 42)\n```" },
+      "insertText": "rawset(${1:table}, ${2:index}, ${3:value})",
+      "insertTextRules": 4,
+      "sortText": "00_rawset"
+    },
+    {
+      "label": "rawequal",
+      "kind": 1,
+      "detail": "Check equality without invoking metamethods",
+      "documentation": { "value": "Checks whether `v1` is equal to `v2`, without invoking the `__eq` metamethod.\n\n```lua\nrawequal(a, b)\n```" },
+      "insertText": "rawequal(${1:v1}, ${2:v2})",
+      "insertTextRules": 4,
+      "sortText": "00_rawequal"
+    },
+    {
+      "label": "rawlen",
+      "kind": 1,
+      "detail": "Get length without invoking metamethods (Lua 5.2+)",
+      "documentation": { "value": "Returns the length of the object `v`, which must be a table or a string, without invoking the `__len` metamethod.\n\n```lua\nlocal n = rawlen(t)\n```\n\n**Note:** Available in Lua 5.2+ only. Not available in Lua 5.1 or LuaJIT (unless patched)." },
+      "insertText": "rawlen(${1:v})",
+      "insertTextRules": 4,
+      "sortText": "00_rawlen"
+    },
+    {
+      "label": "setmetatable",
+      "kind": 1,
+      "detail": "Set the metatable for a table",
+      "documentation": { "value": "Sets the metatable for the given table. If `metatable` is `nil`, removes the metatable. If the original metatable has a `__metatable` field, raises an error. Returns `table`.\n\n```lua\nlocal mt = { __index = baseClass }\nsetmetatable(obj, mt)\n```" },
+      "insertText": "setmetatable(${1:table}, ${2:metatable})",
+      "insertTextRules": 4,
+      "sortText": "00_setmetatable"
+    },
+    {
+      "label": "getmetatable",
+      "kind": 1,
+      "detail": "Get the metatable of an object",
+      "documentation": { "value": "Returns the metatable of the given object, or `nil` if it does not have one. If the metatable has a `__metatable` field, returns that value instead.\n\n```lua\nlocal mt = getmetatable(obj)\n```" },
+      "insertText": "getmetatable(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "00_getmetatable"
+    },
+    {
+      "label": "collectgarbage",
+      "kind": 1,
+      "detail": "Control the garbage collector",
+      "documentation": { "value": "Generic interface to the garbage collector. Performs different functions depending on `opt`: `\"collect\"`, `\"stop\"`, `\"restart\"`, `\"count\"`, `\"step\"`, `\"isrunning\"`, `\"incremental\"`, `\"generational\"`.\n\n```lua\ncollectgarbage(\"collect\")\nlocal kb = collectgarbage(\"count\")\n```\n\n**Lua 5.4:** Added `\"incremental\"` and `\"generational\"` options." },
+      "insertText": "collectgarbage(\"${1:opt}\"${2:, ${3:arg}})",
+      "insertTextRules": 4,
+      "sortText": "00_collectgarbage"
+    },
+    {
+      "label": "string.format",
+      "kind": 1,
+      "detail": "Format a string",
+      "documentation": { "value": "Returns a formatted version of its variable number of arguments following the description given in `formatstring`. Similar to C `sprintf`.\n\n```lua\nstring.format(\"%s is %d years old\", name, age)\nstring.format(\"%02x\", 255)  -- \"ff\"\nstring.format(\"%.2f\", 3.14159)  -- \"3.14\"\n```" },
+      "insertText": "string.format(\"${1:fmt}\", ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "01_string.format"
+    },
+    {
+      "label": "string.find",
+      "kind": 1,
+      "detail": "Find a pattern in a string",
+      "documentation": { "value": "Looks for the first match of `pattern` in `s`. Returns the start and end indices of the match, plus any captures. Returns `nil` if no match.\n\n```lua\nlocal i, j = string.find(\"hello world\", \"world\")  -- 7, 11\nlocal s, e, cap = string.find(\"abc123\", \"(%d+)\")  -- 4, 6, \"123\"\n```" },
+      "insertText": "string.find(${1:s}, \"${2:pattern}\"${3:, ${4:init}${5:, ${6:plain}}})",
+      "insertTextRules": 4,
+      "sortText": "01_string.find"
+    },
+    {
+      "label": "string.match",
+      "kind": 1,
+      "detail": "Extract pattern matches from a string",
+      "documentation": { "value": "Looks for the first match of `pattern` in `s`. Returns the captures, or the whole match if no captures. Returns `nil` if no match.\n\n```lua\nlocal year, month, day = string.match(\"2026-03-03\", \"(%d+)-(%d+)-(%d+)\")\nlocal word = string.match(\"hello world\", \"%a+\")  -- \"hello\"\n```" },
+      "insertText": "string.match(${1:s}, \"${2:pattern}\"${3:, ${4:init}})",
+      "insertTextRules": 4,
+      "sortText": "01_string.match"
+    },
+    {
+      "label": "string.gmatch",
+      "kind": 1,
+      "detail": "Iterate over all pattern matches",
+      "documentation": { "value": "Returns an iterator function that each time returns the next captures from `pattern` over the string `s`.\n\n```lua\nfor word in string.gmatch(\"Hello Lua World\", \"%a+\") do\n    print(word)\nend\nfor k, v in string.gmatch(s, \"(%w+)=(%w+)\") do\n    t[k] = v\nend\n```" },
+      "insertText": "string.gmatch(${1:s}, \"${2:pattern}\")",
+      "insertTextRules": 4,
+      "sortText": "01_string.gmatch"
+    },
+    {
+      "label": "string.gsub",
+      "kind": 1,
+      "detail": "Global substitution — replace pattern matches",
+      "documentation": { "value": "Returns a copy of `s` in which all (or the first `n`) occurrences of `pattern` have been replaced. `repl` can be a string, table, or function. Returns the result string and the number of substitutions.\n\n```lua\nstring.gsub(\"hello world\", \"(%w+)\", string.upper)  -- \"HELLO WORLD\"\nstring.gsub(\"abc\", \"b\", \"B\")  -- \"aBc\"\n```" },
+      "insertText": "string.gsub(${1:s}, \"${2:pattern}\", ${3:repl}${4:, ${5:n}})",
+      "insertTextRules": 4,
+      "sortText": "01_string.gsub"
+    },
+    {
+      "label": "string.sub",
+      "kind": 1,
+      "detail": "Extract a substring",
+      "documentation": { "value": "Returns the substring of `s` that starts at `i` and continues until `j` (inclusive). Negative indices count from the end.\n\n```lua\nstring.sub(\"Hello\", 2, 4)   -- \"ell\"\nstring.sub(\"Hello\", -3)     -- \"llo\"\n```" },
+      "insertText": "string.sub(${1:s}, ${2:i}${3:, ${4:j}})",
+      "insertTextRules": 4,
+      "sortText": "01_string.sub"
+    },
+    {
+      "label": "string.rep",
+      "kind": 1,
+      "detail": "Repeat a string",
+      "documentation": { "value": "Returns a string that is the concatenation of `n` copies of `s`, separated by `sep` (Lua 5.2+).\n\n```lua\nstring.rep(\"ab\", 3)       -- \"ababab\"\nstring.rep(\"ab\", 3, \",\")  -- \"ab,ab,ab\" (Lua 5.2+)\n```" },
+      "insertText": "string.rep(${1:s}, ${2:n}${3:, ${4:sep}})",
+      "insertTextRules": 4,
+      "sortText": "01_string.rep"
+    },
+    {
+      "label": "string.reverse",
+      "kind": 1,
+      "detail": "Reverse a string",
+      "documentation": { "value": "Returns a string that is the reverse of `s`.\n\n```lua\nstring.reverse(\"hello\")  -- \"olleh\"\n```" },
+      "insertText": "string.reverse(${1:s})",
+      "insertTextRules": 4,
+      "sortText": "01_string.reverse"
+    },
+    {
+      "label": "string.upper",
+      "kind": 1,
+      "detail": "Convert string to uppercase",
+      "documentation": { "value": "Returns a copy of `s` with all lowercase letters changed to uppercase. The definition of what a lowercase letter is depends on the current locale.\n\n```lua\nstring.upper(\"hello\")  -- \"HELLO\"\n```" },
+      "insertText": "string.upper(${1:s})",
+      "insertTextRules": 4,
+      "sortText": "01_string.upper"
+    },
+    {
+      "label": "string.lower",
+      "kind": 1,
+      "detail": "Convert string to lowercase",
+      "documentation": { "value": "Returns a copy of `s` with all uppercase letters changed to lowercase.\n\n```lua\nstring.lower(\"HELLO\")  -- \"hello\"\n```" },
+      "insertText": "string.lower(${1:s})",
+      "insertTextRules": 4,
+      "sortText": "01_string.lower"
+    },
+    {
+      "label": "string.len",
+      "kind": 1,
+      "detail": "Get string length",
+      "documentation": { "value": "Returns the length of the string `s`. The empty string has length 0. Embedded zeros are counted.\n\n```lua\nstring.len(\"hello\")  -- 5\n(\"hello\"):len()      -- 5\n#\"hello\"             -- 5 (idiomatic)\n```" },
+      "insertText": "string.len(${1:s})",
+      "insertTextRules": 4,
+      "sortText": "01_string.len"
+    },
+    {
+      "label": "string.byte",
+      "kind": 1,
+      "detail": "Get numeric byte values of characters",
+      "documentation": { "value": "Returns the internal numeric codes of the characters `s[i]` through `s[j]`.\n\n```lua\nstring.byte(\"A\")          -- 65\nstring.byte(\"ABC\", 1, 3)  -- 65, 66, 67\n```" },
+      "insertText": "string.byte(${1:s}${2:, ${3:i}${4:, ${5:j}}})",
+      "insertTextRules": 4,
+      "sortText": "01_string.byte"
+    },
+    {
+      "label": "string.char",
+      "kind": 1,
+      "detail": "Convert numeric codes to a string",
+      "documentation": { "value": "Returns a string with characters having the internal numeric codes equal to the arguments.\n\n```lua\nstring.char(65, 66, 67)  -- \"ABC\"\nstring.char(72, 101, 108, 108, 111)  -- \"Hello\"\n```" },
+      "insertText": "string.char(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_string.char"
+    },
+    {
+      "label": "string.dump",
+      "kind": 1,
+      "detail": "Dump a function as binary string",
+      "documentation": { "value": "Returns a string containing a binary representation of the given function, so that a later `load` can return a copy of the function. The function must be a Lua function without upvalues.\n\n```lua\nlocal s = string.dump(function() return 42 end)\nlocal f = load(s)\nprint(f())  -- 42\n```\n\n**Lua 5.3+:** Optional `strip` parameter to strip debug info." },
+      "insertText": "string.dump(${1:function}${2:, ${3:strip}})",
+      "insertTextRules": 4,
+      "sortText": "01_string.dump"
+    },
+    {
+      "label": "table.insert",
+      "kind": 1,
+      "detail": "Insert an element into a table",
+      "documentation": { "value": "Inserts element `value` at position `pos` in `list`, shifting up other elements. The default value for `pos` is `#list+1` (append).\n\n```lua\nlocal t = {1, 2, 3}\ntable.insert(t, 4)       -- {1, 2, 3, 4}\ntable.insert(t, 2, 10)   -- {1, 10, 2, 3, 4}\n```" },
+      "insertText": "table.insert(${1:list}, ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "02_table.insert"
+    },
+    {
+      "label": "table.remove",
+      "kind": 1,
+      "detail": "Remove an element from a table",
+      "documentation": { "value": "Removes from `list` the element at position `pos`, returning the removed value. Default `pos` is `#list` (last element).\n\n```lua\nlocal t = {1, 2, 3, 4}\nlocal v = table.remove(t)     -- v=4, t={1,2,3}\nlocal w = table.remove(t, 1)  -- w=1, t={2,3}\n```" },
+      "insertText": "table.remove(${1:list}${2:, ${3:pos}})",
+      "insertTextRules": 4,
+      "sortText": "02_table.remove"
+    },
+    {
+      "label": "table.sort",
+      "kind": 1,
+      "detail": "Sort a table in-place",
+      "documentation": { "value": "Sorts the list elements in-place, from `list[1]` to `list[#list]`. An optional comparison function `comp` can be provided.\n\n```lua\nlocal t = {3, 1, 4, 1, 5}\ntable.sort(t)  -- {1, 1, 3, 4, 5}\ntable.sort(t, function(a, b) return a > b end)  -- descending\n```" },
+      "insertText": "table.sort(${1:list}${2:, ${3:comp}})",
+      "insertTextRules": 4,
+      "sortText": "02_table.sort"
+    },
+    {
+      "label": "table.concat",
+      "kind": 1,
+      "detail": "Concatenate table elements into a string",
+      "documentation": { "value": "Returns a string made by concatenating `list[i]..list[j]` with `sep` between each element.\n\n```lua\nlocal t = {\"Hello\", \"Lua\", \"World\"}\ntable.concat(t, \" \")      -- \"Hello Lua World\"\ntable.concat(t, \", \", 2)   -- \"Lua, World\"\n```" },
+      "insertText": "table.concat(${1:list}${2:, ${3:sep}${4:, ${5:i}${6:, ${7:j}}}})",
+      "insertTextRules": 4,
+      "sortText": "02_table.concat"
+    },
+    {
+      "label": "table.move",
+      "kind": 1,
+      "detail": "Move elements within or between tables (Lua 5.3+)",
+      "documentation": { "value": "Moves elements from table `a1` to table `a2`. Equivalent to `a2[t], ... = a1[f], ..., a1[e]` with appropriate destination indexing. Returns `a2`.\n\n```lua\nlocal t = {1, 2, 3, 4, 5}\ntable.move(t, 3, 5, 1)  -- {3, 4, 5, 4, 5}\n```\n\n**Note:** Available in Lua 5.3+ only." },
+      "insertText": "table.move(${1:a1}, ${2:f}, ${3:e}, ${4:t}${5:, ${6:a2}})",
+      "insertTextRules": 4,
+      "sortText": "02_table.move"
+    },
+    {
+      "label": "table.pack",
+      "kind": 1,
+      "detail": "Pack arguments into a table (Lua 5.2+)",
+      "documentation": { "value": "Returns a new table with all arguments stored at numeric keys and a field `n` with the total number of arguments.\n\n```lua\nlocal t = table.pack(1, 2, nil, 4)\nprint(t.n)  -- 4\n```\n\n**Note:** Available in Lua 5.2+ and LuaJIT with compatibility flag." },
+      "insertText": "table.pack(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "02_table.pack"
+    },
+    {
+      "label": "table.unpack",
+      "kind": 1,
+      "detail": "Unpack elements from a table (Lua 5.2+)",
+      "documentation": { "value": "Returns the elements from the given table. Equivalent to `return list[i], list[i+1], ..., list[j]`.\n\n```lua\nlocal a, b, c = table.unpack({10, 20, 30})\n```\n\n**Note:** In Lua 5.1 this is the global `unpack` function." },
+      "insertText": "table.unpack(${1:list}${2:, ${3:i}${4:, ${5:j}}})",
+      "insertTextRules": 4,
+      "sortText": "02_table.unpack"
+    },
+    {
+      "label": "math.abs",
+      "kind": 1,
+      "detail": "Absolute value",
+      "documentation": { "value": "Returns the absolute value of `x`.\n\n```lua\nmath.abs(-42)   -- 42\nmath.abs(3.14)  -- 3.14\n```" },
+      "insertText": "math.abs(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_math.abs"
+    },
+    {
+      "label": "math.ceil",
+      "kind": 1,
+      "detail": "Round up to nearest integer",
+      "documentation": { "value": "Returns the smallest integral value greater than or equal to `x`.\n\n```lua\nmath.ceil(4.2)   -- 5\nmath.ceil(-4.8)  -- -4\n```" },
+      "insertText": "math.ceil(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_math.ceil"
+    },
+    {
+      "label": "math.floor",
+      "kind": 1,
+      "detail": "Round down to nearest integer",
+      "documentation": { "value": "Returns the largest integral value less than or equal to `x`.\n\n```lua\nmath.floor(4.8)   -- 4\nmath.floor(-4.2)  -- -5\n```" },
+      "insertText": "math.floor(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_math.floor"
+    },
+    {
+      "label": "math.max",
+      "kind": 1,
+      "detail": "Return the maximum value",
+      "documentation": { "value": "Returns the argument with the maximum value, according to the Lua `<` operator.\n\n```lua\nmath.max(1, 5, 3)  -- 5\n```" },
+      "insertText": "math.max(${1:x}, ${2:...})",
+      "insertTextRules": 4,
+      "sortText": "03_math.max"
+    },
+    {
+      "label": "math.min",
+      "kind": 1,
+      "detail": "Return the minimum value",
+      "documentation": { "value": "Returns the argument with the minimum value, according to the Lua `<` operator.\n\n```lua\nmath.min(1, 5, 3)  -- 1\n```" },
+      "insertText": "math.min(${1:x}, ${2:...})",
+      "insertTextRules": 4,
+      "sortText": "03_math.min"
+    },
+    {
+      "label": "math.sqrt",
+      "kind": 1,
+      "detail": "Square root",
+      "documentation": { "value": "Returns the square root of `x`. Equivalent to `x^0.5`.\n\n```lua\nmath.sqrt(144)  -- 12.0\nmath.sqrt(2)    -- 1.4142135623731\n```" },
+      "insertText": "math.sqrt(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_math.sqrt"
+    },
+    {
+      "label": "math.random",
+      "kind": 1,
+      "detail": "Generate a pseudo-random number",
+      "documentation": { "value": "When called without arguments, returns a uniform pseudo-random real in [0,1). With `m`, returns integer in [1,m]. With `m` and `n`, returns integer in [m,n].\n\n```lua\nmath.random()       -- 0.0 to 1.0\nmath.random(6)      -- 1 to 6\nmath.random(1, 100) -- 1 to 100\n```\n\n**Lua 5.4:** Uses xoshiro256** algorithm. Older versions use C `rand()`." },
+      "insertText": "math.random(${1:m}${2:, ${3:n}})",
+      "insertTextRules": 4,
+      "sortText": "03_math.random"
+    },
+    {
+      "label": "math.randomseed",
+      "kind": 1,
+      "detail": "Set random seed",
+      "documentation": { "value": "Sets `x` as the seed for the pseudo-random generator.\n\n```lua\nmath.randomseed(os.time())\n```\n\n**Lua 5.4:** If called without arguments, seeds with a system-dependent somewhat-random value." },
+      "insertText": "math.randomseed(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_math.randomseed"
+    },
+    {
+      "label": "math.huge",
+      "kind": 5,
+      "detail": "Positive infinity",
+      "documentation": { "value": "The float value `HUGE_VAL`, a value greater than any other numeric value (positive infinity).\n\n```lua\nprint(math.huge)       -- inf\nprint(-math.huge)      -- -inf\nprint(1 / 0 == math.huge)  -- true\n```" },
+      "insertText": "math.huge",
+      "insertTextRules": 0,
+      "sortText": "03_math.huge"
+    },
+    {
+      "label": "math.pi",
+      "kind": 5,
+      "detail": "The value of π",
+      "documentation": { "value": "The value of π (3.14159265358979...).\n\n```lua\nprint(math.pi)  -- 3.1415926535898\nlocal circumference = 2 * math.pi * radius\n```" },
+      "insertText": "math.pi",
+      "insertTextRules": 0,
+      "sortText": "03_math.pi"
+    },
+    {
+      "label": "math.sin",
+      "kind": 1,
+      "detail": "Sine (radians)",
+      "documentation": { "value": "Returns the sine of `x` (assumed to be in radians).\n\n```lua\nmath.sin(0)           -- 0.0\nmath.sin(math.pi/2)   -- 1.0\n```" },
+      "insertText": "math.sin(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_math.sin"
+    },
+    {
+      "label": "math.cos",
+      "kind": 1,
+      "detail": "Cosine (radians)",
+      "documentation": { "value": "Returns the cosine of `x` (assumed to be in radians).\n\n```lua\nmath.cos(0)        -- 1.0\nmath.cos(math.pi)  -- -1.0\n```" },
+      "insertText": "math.cos(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_math.cos"
+    },
+    {
+      "label": "math.log",
+      "kind": 1,
+      "detail": "Logarithm",
+      "documentation": { "value": "Returns the logarithm of `x` in the given base. The default for `base` is `e` (natural logarithm).\n\n```lua\nmath.log(math.exp(1))  -- 1.0\nmath.log(1000, 10)     -- 3.0 (Lua 5.2+ base parameter)\n```\n\n**Lua 5.1:** Use `math.log10` for base-10. Lua 5.2+ accepts optional base." },
+      "insertText": "math.log(${1:x}${2:, ${3:base}})",
+      "insertTextRules": 4,
+      "sortText": "03_math.log"
+    },
+    {
+      "label": "math.exp",
+      "kind": 1,
+      "detail": "Exponential function (e^x)",
+      "documentation": { "value": "Returns the value e^x (where `e` is the base of natural logarithms).\n\n```lua\nmath.exp(0)  -- 1.0\nmath.exp(1)  -- 2.718281828...\n```" },
+      "insertText": "math.exp(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_math.exp"
+    },
+    {
+      "label": "io.open",
+      "kind": 1,
+      "detail": "Open a file",
+      "documentation": { "value": "Opens a file in the specified mode. Returns a file handle, or `nil` plus an error message. Mode can be `\"r\"` (read), `\"w\"` (write), `\"a\"` (append), with optional `\"b\"` for binary.\n\n```lua\nlocal f = io.open(\"data.txt\", \"r\")\nlocal content = f:read(\"*a\")\nf:close()\n```" },
+      "insertText": "io.open(\"${1:filename}\", \"${2:r}\")",
+      "insertTextRules": 4,
+      "sortText": "04_io.open"
+    },
+    {
+      "label": "io.read",
+      "kind": 1,
+      "detail": "Read from default input",
+      "documentation": { "value": "Reads from the default input file according to the given formats.\n\n```lua\nlocal line = io.read()        -- read one line\nlocal all = io.read(\"*a\")     -- read entire file\nlocal num = io.read(\"*n\")     -- read a number\n```\n\n**Lua 5.3+:** Use `\"a\"`, `\"l\"`, `\"L\"`, `\"n\"` (without `*` prefix)." },
+      "insertText": "io.read(\"${1:*l}\")",
+      "insertTextRules": 4,
+      "sortText": "04_io.read"
+    },
+    {
+      "label": "io.write",
+      "kind": 1,
+      "detail": "Write to default output",
+      "documentation": { "value": "Writes the value of each argument to the default output file.\n\n```lua\nio.write(\"Hello, world!\\n\")\nio.write(string.format(\"Value: %d\\n\", x))\n```" },
+      "insertText": "io.write(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "04_io.write"
+    },
+    {
+      "label": "io.close",
+      "kind": 1,
+      "detail": "Close a file",
+      "documentation": { "value": "Closes `file` or the default output file.\n\n```lua\nio.close(file)\nio.close()  -- close default output\n```" },
+      "insertText": "io.close(${1:file})",
+      "insertTextRules": 4,
+      "sortText": "04_io.close"
+    },
+    {
+      "label": "io.lines",
+      "kind": 1,
+      "detail": "Iterate over lines of a file",
+      "documentation": { "value": "Opens the given file name and returns an iterator function that returns a new line from the file each time it is called. The file is automatically closed when the loop ends.\n\n```lua\nfor line in io.lines(\"data.txt\") do\n    print(line)\nend\n```" },
+      "insertText": "io.lines(\"${1:filename}\")",
+      "insertTextRules": 4,
+      "sortText": "04_io.lines"
+    },
+    {
+      "label": "os.time",
+      "kind": 1,
+      "detail": "Get current time or convert a date table",
+      "documentation": { "value": "Returns the current time when called without arguments, or a time representing the date and time specified by the given table.\n\n```lua\nlocal now = os.time()\nlocal t = os.time({year=2026, month=3, day=3})\n```" },
+      "insertText": "os.time(${1:})",
+      "insertTextRules": 4,
+      "sortText": "05_os.time"
+    },
+    {
+      "label": "os.date",
+      "kind": 1,
+      "detail": "Format date/time as a string",
+      "documentation": { "value": "Returns a string or table with date and time, formatted according to the given string `format`. If `format` starts with `!`, it is formatted in UTC.\n\n```lua\nos.date(\"%Y-%m-%d %H:%M:%S\")  -- \"2026-03-03 12:00:00\"\nos.date(\"%A\")                  -- \"Tuesday\"\nos.date(\"*t\")                  -- returns a table\n```" },
+      "insertText": "os.date(\"${1:%Y-%m-%d %H:%M:%S}\"${2:, ${3:time}})",
+      "insertTextRules": 4,
+      "sortText": "05_os.date"
+    },
+    {
+      "label": "os.clock",
+      "kind": 1,
+      "detail": "Get CPU time used by the program",
+      "documentation": { "value": "Returns an approximation of the amount of CPU time used by the program, in seconds.\n\n```lua\nlocal start = os.clock()\n-- ... do work ...\nprint(string.format(\"Elapsed: %.3f s\", os.clock() - start))\n```" },
+      "insertText": "os.clock()",
+      "insertTextRules": 0,
+      "sortText": "05_os.clock"
+    },
+    {
+      "label": "os.execute",
+      "kind": 1,
+      "detail": "Execute a shell command",
+      "documentation": { "value": "Passes `command` to be executed by the operating system shell. Returns `true` (or `nil`), a string describing the exit status, and the exit code.\n\n```lua\nos.execute(\"mkdir mydir\")\nlocal ok, exittype, code = os.execute(\"ls -la\")\n```\n\n**Lua 5.1:** Returns only the exit status number." },
+      "insertText": "os.execute(\"${1:command}\")",
+      "insertTextRules": 4,
+      "sortText": "05_os.execute"
+    },
+    {
+      "label": "os.getenv",
+      "kind": 1,
+      "detail": "Get an environment variable",
+      "documentation": { "value": "Returns the value of the environment variable `varname`, or `nil` if not defined.\n\n```lua\nlocal home = os.getenv(\"HOME\")\nlocal path = os.getenv(\"PATH\")\n```" },
+      "insertText": "os.getenv(\"${1:varname}\")",
+      "insertTextRules": 4,
+      "sortText": "05_os.getenv"
+    },
+    {
+      "label": "os.rename",
+      "kind": 1,
+      "detail": "Rename a file or directory",
+      "documentation": { "value": "Renames the file or directory named `oldname` to `newname`. Returns `true` on success, or `nil` plus error message.\n\n```lua\nos.rename(\"old.txt\", \"new.txt\")\n```" },
+      "insertText": "os.rename(\"${1:oldname}\", \"${2:newname}\")",
+      "insertTextRules": 4,
+      "sortText": "05_os.rename"
+    },
+    {
+      "label": "os.remove",
+      "kind": 1,
+      "detail": "Remove a file",
+      "documentation": { "value": "Deletes the file with the given name. If it fails, returns `nil` plus an error message and error number.\n\n```lua\nos.remove(\"temp.txt\")\n```" },
+      "insertText": "os.remove(\"${1:filename}\")",
+      "insertTextRules": 4,
+      "sortText": "05_os.remove"
+    },
+    {
+      "label": "os.tmpname",
+      "kind": 1,
+      "detail": "Generate a temporary file name",
+      "documentation": { "value": "Returns a string with a file name that can be used for a temporary file.\n\n```lua\nlocal tmpfile = os.tmpname()\n```" },
+      "insertText": "os.tmpname()",
+      "insertTextRules": 0,
+      "sortText": "05_os.tmpname"
+    },
+    {
+      "label": "os.exit",
+      "kind": 1,
+      "detail": "Terminate the program",
+      "documentation": { "value": "Calls the ISO C function `exit` to terminate the host program. If `code` is `true`, the exit status is `EXIT_SUCCESS`; if `false`, it is `EXIT_FAILURE`; if a number, it is used as exit code.\n\n```lua\nos.exit()      -- success\nos.exit(1)     -- failure\nos.exit(true)  -- Lua 5.2+ success\n```\n\n**Lua 5.2+:** Optional `close` parameter to close the Lua state." },
+      "insertText": "os.exit(${1:code})",
+      "insertTextRules": 4,
+      "sortText": "05_os.exit"
+    },
+    {
+      "label": "if",
+      "kind": 14,
+      "detail": "Conditional keyword",
+      "documentation": { "value": "Begins a conditional statement. Must be followed by `then` and closed with `end`.\n\n```lua\nif condition then\n    -- code\nelseif other then\n    -- code\nelse\n    -- code\nend\n```" },
+      "insertText": "if",
+      "insertTextRules": 0,
+      "sortText": "06_if"
+    },
+    {
+      "label": "then",
+      "kind": 14,
+      "detail": "Conditional body keyword",
+      "documentation": { "value": "Follows an `if` or `elseif` condition to begin the conditional body." },
+      "insertText": "then",
+      "insertTextRules": 0,
+      "sortText": "06_then"
+    },
+    {
+      "label": "else",
+      "kind": 14,
+      "detail": "Else branch keyword",
+      "documentation": { "value": "Begins an alternative branch in an `if` statement." },
+      "insertText": "else",
+      "insertTextRules": 0,
+      "sortText": "06_else"
+    },
+    {
+      "label": "elseif",
+      "kind": 14,
+      "detail": "Else-if branch keyword",
+      "documentation": { "value": "Combines an `else` and `if` into a single keyword for chaining conditions." },
+      "insertText": "elseif",
+      "insertTextRules": 0,
+      "sortText": "06_elseif"
+    },
+    {
+      "label": "end",
+      "kind": 14,
+      "detail": "Block terminator keyword",
+      "documentation": { "value": "Closes a block opened by `function`, `if`, `for`, `while`, or `do`." },
+      "insertText": "end",
+      "insertTextRules": 0,
+      "sortText": "06_end"
+    },
+    {
+      "label": "for",
+      "kind": 14,
+      "detail": "Loop keyword",
+      "documentation": { "value": "Begins a numeric or generic `for` loop.\n\n```lua\nfor i = 1, 10 do ... end\nfor k, v in pairs(t) do ... end\n```" },
+      "insertText": "for",
+      "insertTextRules": 0,
+      "sortText": "06_for"
+    },
+    {
+      "label": "while",
+      "kind": 14,
+      "detail": "While-loop keyword",
+      "documentation": { "value": "Begins a while loop.\n\n```lua\nwhile condition do\n    -- code\nend\n```" },
+      "insertText": "while",
+      "insertTextRules": 0,
+      "sortText": "06_while"
+    },
+    {
+      "label": "do",
+      "kind": 14,
+      "detail": "Block start keyword",
+      "documentation": { "value": "Begins a block. Used with `while`, `for`, or standalone for scoping.\n\n```lua\ndo\n    local x = 10\nend  -- x is out of scope\n```" },
+      "insertText": "do",
+      "insertTextRules": 0,
+      "sortText": "06_do"
+    },
+    {
+      "label": "repeat",
+      "kind": 14,
+      "detail": "Repeat-until loop keyword",
+      "documentation": { "value": "Begins a repeat-until loop. The body executes at least once.\n\n```lua\nrepeat\n    -- code\nuntil condition\n```" },
+      "insertText": "repeat",
+      "insertTextRules": 0,
+      "sortText": "06_repeat"
+    },
+    {
+      "label": "until",
+      "kind": 14,
+      "detail": "Repeat-until terminator keyword",
+      "documentation": { "value": "Terminates a `repeat` block and specifies the loop condition." },
+      "insertText": "until",
+      "insertTextRules": 0,
+      "sortText": "06_until"
+    },
+    {
+      "label": "function",
+      "kind": 14,
+      "detail": "Function definition keyword",
+      "documentation": { "value": "Defines a function.\n\n```lua\nfunction foo(a, b)\n    return a + b\nend\n\nlocal bar = function(x) return x * 2 end\n```" },
+      "insertText": "function",
+      "insertTextRules": 0,
+      "sortText": "06_function"
+    },
+    {
+      "label": "local",
+      "kind": 14,
+      "detail": "Local variable declaration keyword",
+      "documentation": { "value": "Declares a local variable or function, limiting its scope to the enclosing block.\n\n```lua\nlocal x = 10\nlocal function helper() end\n```" },
+      "insertText": "local",
+      "insertTextRules": 0,
+      "sortText": "06_local"
+    },
+    {
+      "label": "return",
+      "kind": 14,
+      "detail": "Return from function keyword",
+      "documentation": { "value": "Returns values from a function. Must be the last statement in a block.\n\n```lua\nreturn x, y\n```" },
+      "insertText": "return",
+      "insertTextRules": 0,
+      "sortText": "06_return"
+    },
+    {
+      "label": "break",
+      "kind": 14,
+      "detail": "Break out of a loop keyword",
+      "documentation": { "value": "Terminates the execution of a `while`, `repeat`, or `for` loop, skipping to the next statement after the loop." },
+      "insertText": "break",
+      "insertTextRules": 0,
+      "sortText": "06_break"
+    },
+    {
+      "label": "goto",
+      "kind": 14,
+      "detail": "Jump to a label (Lua 5.2+)",
+      "documentation": { "value": "Transfers the program control to the statement after the given label. Uses `::label::` syntax for label definitions.\n\n```lua\ngoto continue\n::continue::\n```\n\n**Note:** Available in Lua 5.2+ and LuaJIT 2.x." },
+      "insertText": "goto",
+      "insertTextRules": 0,
+      "sortText": "06_goto"
+    },
+    {
+      "label": "in",
+      "kind": 14,
+      "detail": "Generic for-loop keyword",
+      "documentation": { "value": "Used in generic `for` loops to specify the iterator.\n\n```lua\nfor k, v in pairs(t) do ... end\n```" },
+      "insertText": "in",
+      "insertTextRules": 0,
+      "sortText": "06_in"
+    },
+    {
+      "label": "and",
+      "kind": 14,
+      "detail": "Logical AND operator",
+      "documentation": { "value": "Logical conjunction. Returns its first argument if it is false or nil; otherwise returns its second argument.\n\n```lua\nlocal x = a and b  -- short-circuit evaluation\n```" },
+      "insertText": "and",
+      "insertTextRules": 0,
+      "sortText": "06_and"
+    },
+    {
+      "label": "or",
+      "kind": 14,
+      "detail": "Logical OR operator",
+      "documentation": { "value": "Logical disjunction. Returns its first argument if it is not false/nil; otherwise returns its second argument.\n\n```lua\nlocal x = a or default_value\n```" },
+      "insertText": "or",
+      "insertTextRules": 0,
+      "sortText": "06_or"
+    },
+    {
+      "label": "not",
+      "kind": 14,
+      "detail": "Logical NOT operator",
+      "documentation": { "value": "Logical negation. Returns `true` if the argument is false or nil, otherwise returns `false`.\n\n```lua\nif not done then ... end\n```" },
+      "insertText": "not",
+      "insertTextRules": 0,
+      "sortText": "06_not"
+    },
+    {
+      "label": "nil",
+      "kind": 14,
+      "detail": "Nil value keyword",
+      "documentation": { "value": "The type `nil` has one single value, `nil`, whose main property is to be different from any other value. It represents the absence of a useful value." },
+      "insertText": "nil",
+      "insertTextRules": 0,
+      "sortText": "06_nil"
+    },
+    {
+      "label": "true",
+      "kind": 14,
+      "detail": "Boolean true keyword",
+      "documentation": { "value": "The boolean value `true`." },
+      "insertText": "true",
+      "insertTextRules": 0,
+      "sortText": "06_true"
+    },
+    {
+      "label": "false",
+      "kind": 14,
+      "detail": "Boolean false keyword",
+      "documentation": { "value": "The boolean value `false`. Together with `nil`, it is considered false in conditional tests; all other values are true." },
+      "insertText": "false",
+      "insertTextRules": 0,
+      "sortText": "06_false"
+    },
+    {
+      "label": "function definition",
+      "kind": 15,
+      "detail": "Define a named function",
+      "documentation": { "value": "Snippet for a named function definition.\n\n```lua\nfunction name(args)\n    -- body\nend\n```" },
+      "insertText": "function ${1:name}(${2:args})\n\t${3:-- body}\nend",
+      "insertTextRules": 4,
+      "sortText": "07_function_definition"
+    },
+    {
+      "label": "local function",
+      "kind": 15,
+      "detail": "Define a local function",
+      "documentation": { "value": "Snippet for a local function definition.\n\n```lua\nlocal function name(args)\n    -- body\nend\n```" },
+      "insertText": "local function ${1:name}(${2:args})\n\t${3:-- body}\nend",
+      "insertTextRules": 4,
+      "sortText": "07_local_function"
+    },
+    {
+      "label": "for i = ...",
+      "kind": 15,
+      "detail": "Numeric for loop",
+      "documentation": { "value": "Snippet for a numeric `for` loop.\n\n```lua\nfor i = 1, 10 do\n    -- body\nend\n```" },
+      "insertText": "for ${1:i} = ${2:1}, ${3:10}${4:, ${5:1}} do\n\t${6:-- body}\nend",
+      "insertTextRules": 4,
+      "sortText": "07_for_numeric"
+    },
+    {
+      "label": "for k, v in pairs",
+      "kind": 15,
+      "detail": "Generic for loop with pairs()",
+      "documentation": { "value": "Snippet to iterate over all key-value pairs in a table.\n\n```lua\nfor k, v in pairs(t) do\n    -- body\nend\n```" },
+      "insertText": "for ${1:k}, ${2:v} in pairs(${3:t}) do\n\t${4:-- body}\nend",
+      "insertTextRules": 4,
+      "sortText": "07_for_pairs"
+    },
+    {
+      "label": "for i, v in ipairs",
+      "kind": 15,
+      "detail": "Generic for loop with ipairs()",
+      "documentation": { "value": "Snippet to iterate over integer-keyed elements of a table.\n\n```lua\nfor i, v in ipairs(t) do\n    -- body\nend\n```" },
+      "insertText": "for ${1:i}, ${2:v} in ipairs(${3:t}) do\n\t${4:-- body}\nend",
+      "insertTextRules": 4,
+      "sortText": "07_for_ipairs"
+    },
+    {
+      "label": "while loop",
+      "kind": 15,
+      "detail": "While loop",
+      "documentation": { "value": "Snippet for a `while` loop.\n\n```lua\nwhile condition do\n    -- body\nend\n```" },
+      "insertText": "while ${1:condition} do\n\t${2:-- body}\nend",
+      "insertTextRules": 4,
+      "sortText": "07_while_loop"
+    },
+    {
+      "label": "repeat until",
+      "kind": 15,
+      "detail": "Repeat-until loop",
+      "documentation": { "value": "Snippet for a `repeat-until` loop. The body runs at least once.\n\n```lua\nrepeat\n    -- body\nuntil condition\n```" },
+      "insertText": "repeat\n\t${1:-- body}\nuntil ${2:condition}",
+      "insertTextRules": 4,
+      "sortText": "07_repeat_until"
+    },
+    {
+      "label": "if then end",
+      "kind": 15,
+      "detail": "If-then-end block",
+      "documentation": { "value": "Snippet for a simple `if` block.\n\n```lua\nif condition then\n    -- body\nend\n```" },
+      "insertText": "if ${1:condition} then\n\t${2:-- body}\nend",
+      "insertTextRules": 4,
+      "sortText": "07_if_then_end"
+    },
+    {
+      "label": "if else",
+      "kind": 15,
+      "detail": "If-else block",
+      "documentation": { "value": "Snippet for an `if-else` block.\n\n```lua\nif condition then\n    -- then body\nelse\n    -- else body\nend\n```" },
+      "insertText": "if ${1:condition} then\n\t${2:-- then body}\nelse\n\t${3:-- else body}\nend",
+      "insertTextRules": 4,
+      "sortText": "07_if_else"
+    },
+    {
+      "label": "module pattern",
+      "kind": 15,
+      "detail": "Lua module pattern",
+      "documentation": { "value": "Creates a module using the standard Lua module pattern (returning a table).\n\n```lua\nlocal M = {}\n\nfunction M.myFunc()\n    -- ...\nend\n\nreturn M\n```" },
+      "insertText": "local ${1:M} = {}\n\nfunction ${1:M}.${2:name}(${3:args})\n\t${4:-- body}\nend\n\nreturn ${1:M}",
+      "insertTextRules": 4,
+      "sortText": "07_module_pattern"
+    },
+    {
+      "label": "class with metatables",
+      "kind": 15,
+      "detail": "OOP class pattern using metatables",
+      "documentation": { "value": "Creates a class-like structure using metatables and `__index`.\n\n```lua\nlocal MyClass = {}\nMyClass.__index = MyClass\n\nfunction MyClass.new(value)\n    local self = setmetatable({}, MyClass)\n    self.value = value\n    return self\nend\n\nfunction MyClass:getValue()\n    return self.value\nend\n```" },
+      "insertText": "local ${1:MyClass} = {}\n${1:MyClass}.__index = ${1:MyClass}\n\nfunction ${1:MyClass}.new(${2:args})\n\tlocal self = setmetatable({}, ${1:MyClass})\n\t${3:-- initialize}\n\treturn self\nend\n\nfunction ${1:MyClass}:${4:method}(${5:})\n\t${6:-- body}\nend\n\nreturn ${1:MyClass}",
+      "insertTextRules": 4,
+      "sortText": "07_class_metatables"
+    },
+    {
+      "label": "coroutine pattern",
+      "kind": 15,
+      "detail": "Coroutine creation and resumption pattern",
+      "documentation": { "value": "Creates and uses a coroutine.\n\n```lua\nlocal co = coroutine.create(function()\n    for i = 1, 5 do\n        coroutine.yield(i)\n    end\nend)\n\nwhile coroutine.status(co) ~= \"dead\" do\n    local ok, value = coroutine.resume(co)\n    if ok then print(value) end\nend\n```" },
+      "insertText": "local ${1:co} = coroutine.create(function(${2:})\n\t${3:coroutine.yield(${4:value})}\nend)\n\nlocal ${5:ok}, ${6:value} = coroutine.resume(${1:co})",
+      "insertTextRules": 4,
+      "sortText": "07_coroutine_pattern"
+    }
+  ]
+}