@enjoys/context-engine 1.0.7 → 1.0.9

package/data/completion/lua.json

@@ -1,11 +1,1212 @@
 {
   "language": "lua",
   "completions": [
+    {
+      "label": "for numeric",
+      "kind": 15,
+      "detail": "Numeric for loop",
+      "documentation": {
+        "value": "Standard numeric for loop.\n\n```lua\nfor i = 1, 10 do\n    print(i)\nend\n```"
+      },
+      "insertText": "for ${1:i} = ${2:1}, ${3:10} do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_for_numeric"
+    },
+    {
+      "label": "for pairs",
+      "kind": 15,
+      "detail": "Generic for loop (pairs)",
+      "documentation": {
+        "value": "Iterate over all key-value pairs.\n\n```lua\nfor k, v in pairs(t) do\n    print(k, v)\nend\n```"
+      },
+      "insertText": "for ${1:k}, ${2:v} in pairs(${3:t}) do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_for_pairs"
+    },
+    {
+      "label": "for ipairs",
+      "kind": 15,
+      "detail": "Generic for loop (ipairs)",
+      "documentation": {
+        "value": "Iterate over integer-keyed array elements.\n\n```lua\nfor i, v in ipairs(list) do\n    print(i, v)\nend\n```"
+      },
+      "insertText": "for ${1:i}, ${2:v} in ipairs(${3:list}) do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_for_ipairs"
+    },
+    {
+      "label": "for next",
+      "kind": 15,
+      "detail": "Generic for loop (next)",
+      "documentation": {
+        "value": "Low-level iteration using next.\n\n```lua\nfor k, v in next, t do\n    print(k, v)\nend\n```"
+      },
+      "insertText": "for ${1:k}, ${2:v} in next, ${3:t} do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_for_next"
+    },
+    {
+      "label": "while",
+      "kind": 15,
+      "detail": "While loop",
+      "documentation": {
+        "value": "Loop that repeats while a condition is true.\n\n```lua\nwhile condition do\n    -- body\nend\n```"
+      },
+      "insertText": "while ${1:condition} do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_while"
+    },
+    {
+      "label": "repeat until",
+      "kind": 15,
+      "detail": "Repeat-until loop",
+      "documentation": {
+        "value": "Loop that executes at least once, repeating until the condition is true.\n\n```lua\nrepeat\n    -- body\nuntil condition\n```"
+      },
+      "insertText": "repeat\n\t$0\nuntil ${1:condition}",
+      "insertTextRules": 4,
+      "sortText": "00_repeat_until"
+    },
+    {
+      "label": "if",
+      "kind": 15,
+      "detail": "If statement",
+      "documentation": {
+        "value": "Conditional execution.\n\n```lua\nif condition then\n    -- body\nend\n```"
+      },
+      "insertText": "if ${1:condition} then\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_if"
+    },
+    {
+      "label": "if else",
+      "kind": 15,
+      "detail": "If-else statement",
+      "documentation": {
+        "value": "Conditional with alternative.\n\n```lua\nif condition then\n    -- true branch\nelse\n    -- false branch\nend\n```"
+      },
+      "insertText": "if ${1:condition} then\n\t${2:-- body}\nelse\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_if_else"
+    },
+    {
+      "label": "if elseif else",
+      "kind": 15,
+      "detail": "If-elseif-else statement",
+      "documentation": {
+        "value": "Multi-branch conditional.\n\n```lua\nif cond1 then\n    ...\nelseif cond2 then\n    ...\nelse\n    ...\nend\n```"
+      },
+      "insertText": "if ${1:cond1} then\n\t${2:-- body}\nelseif ${3:cond2} then\n\t${4:-- body}\nelse\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_if_elseif_else"
+    },
+    {
+      "label": "do end",
+      "kind": 15,
+      "detail": "Do-end block",
+      "documentation": {
+        "value": "Creates a new scope block.\n\n```lua\ndo\n    local x = 1\n    -- x is scoped here\nend\n```"
+      },
+      "insertText": "do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_do_end"
+    },
+    {
+      "label": "function",
+      "kind": 15,
+      "detail": "Function declaration",
+      "documentation": {
+        "value": "Declares a named function.\n\n```lua\nfunction greet(name)\n    print(\"Hello, \" .. name)\nend\n```"
+      },
+      "insertText": "function ${1:name}(${2:params})\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_function"
+    },
+    {
+      "label": "local function",
+      "kind": 15,
+      "detail": "Local function declaration",
+      "documentation": {
+        "value": "Declares a local function visible only in the current scope.\n\n```lua\nlocal function helper(x)\n    return x * 2\nend\n```"
+      },
+      "insertText": "local function ${1:name}(${2:params})\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_local_function"
+    },
+    {
+      "label": "anonymous function",
+      "kind": 15,
+      "detail": "Anonymous function",
+      "documentation": {
+        "value": "Creates an anonymous function value.\n\n```lua\nlocal fn = function(x) return x + 1 end\n```"
+      },
+      "insertText": "function(${1:params})\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_anonymous_function"
+    },
+    {
+      "label": "variadic function",
+      "kind": 15,
+      "detail": "Variadic function",
+      "documentation": {
+        "value": "Function accepting variable number of arguments.\n\n```lua\nfunction printf(fmt, ...)\n    io.write(string.format(fmt, ...))\nend\n```"
+      },
+      "insertText": "function ${1:name}(${2:...})\n\tlocal args = {...}\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_variadic_function"
+    },
+    {
+      "label": "function return",
+      "kind": 15,
+      "detail": "Function with return",
+      "documentation": {
+        "value": "Function that returns a value.\n\n```lua\nfunction square(x)\n    return x * x\nend\n```"
+      },
+      "insertText": "function ${1:name}(${2:params})\n\treturn ${0:value}\nend",
+      "insertTextRules": 4,
+      "sortText": "00_function_return"
+    },
+    {
+      "label": "method (colon)",
+      "kind": 15,
+      "detail": "Method using colon syntax",
+      "documentation": {
+        "value": "Defines a method on a table using colon syntax. Implicitly receives `self`.\n\n```lua\nfunction MyClass:greet()\n    print(self.name)\nend\n```"
+      },
+      "insertText": "function ${1:Class}:${2:method}(${3:params})\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_method_(colon)"
+    },
+    {
+      "label": "closure",
+      "kind": 15,
+      "detail": "Closure / factory function",
+      "documentation": {
+        "value": "A function that returns another function capturing upvalues.\n\n```lua\nfunction counter(start)\n    local n = start\n    return function()\n        n = n + 1\n        return n\n    end\nend\n```"
+      },
+      "insertText": "function ${1:factory}(${2:params})\n\tlocal ${3:state} = ${4:init}\n\treturn function(${5:})\n\t\t$0\n\tend\nend",
+      "insertTextRules": 4,
+      "sortText": "00_closure"
+    },
+    {
+      "label": "IIFE",
+      "kind": 15,
+      "detail": "Immediately invoked function expression",
+      "documentation": {
+        "value": "Executes an anonymous function immediately.\n\n```lua\nlocal result = (function()\n    return 42\nend)()\n```"
+      },
+      "insertText": "(function()\n\t$0\nend)()",
+      "insertTextRules": 4,
+      "sortText": "00_IIFE"
+    },
+    {
+      "label": "local function recursive",
+      "kind": 15,
+      "detail": "Local recursive function",
+      "documentation": {
+        "value": "Pattern for a recursive local function.\n\n```lua\nlocal function factorial(n)\n    if n <= 1 then return 1 end\n    return n * factorial(n - 1)\nend\n```"
+      },
+      "insertText": "local function ${1:name}(${2:n})\n\tif ${3:base_case} then return ${4:base_value} end\n\treturn ${0:recursive_call}\nend",
+      "insertTextRules": 4,
+      "sortText": "00_local_function_recursive"
+    },
+    {
+      "label": "table empty",
+      "kind": 15,
+      "detail": "Empty table constructor",
+      "documentation": {
+        "value": "Creates an empty table.\n\n```lua\nlocal t = {}\n```"
+      },
+      "insertText": "local ${1:t} = {}",
+      "insertTextRules": 4,
+      "sortText": "00_table_empty"
+    },
+    {
+      "label": "table array",
+      "kind": 15,
+      "detail": "Array-style table",
+      "documentation": {
+        "value": "Creates a table with sequential integer keys.\n\n```lua\nlocal list = {1, 2, 3, 4, 5}\n```"
+      },
+      "insertText": "local ${1:list} = {${2:items}}",
+      "insertTextRules": 4,
+      "sortText": "00_table_array"
+    },
+    {
+      "label": "table hash",
+      "kind": 15,
+      "detail": "Hash-style table",
+      "documentation": {
+        "value": "Creates a table with named keys.\n\n```lua\nlocal obj = {\n    name = \"Lua\",\n    version = 5.4,\n}\n```"
+      },
+      "insertText": "local ${1:obj} = {\n\t${2:key} = ${3:value},\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "00_table_hash"
+    },
+    {
+      "label": "table mixed",
+      "kind": 15,
+      "detail": "Mixed table (array + hash)",
+      "documentation": {
+        "value": "Table with both sequential and named keys.\n\n```lua\nlocal t = {\n    \"first\",\n    name = \"mixed\",\n    42,\n}\n```"
+      },
+      "insertText": "local ${1:t} = {\n\t${2:array_val},\n\t${3:key} = ${4:value},\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "00_table_mixed"
+    },
+    {
+      "label": "table nested",
+      "kind": 15,
+      "detail": "Nested table",
+      "documentation": {
+        "value": "Table containing other tables.\n\n```lua\nlocal config = {\n    db = { host = \"localhost\", port = 5432 },\n    app = { debug = true },\n}\n```"
+      },
+      "insertText": "local ${1:config} = {\n\t${2:key} = {\n\t\t${3:inner_key} = ${4:inner_value},\n\t},\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "00_table_nested"
+    },
+    {
+      "label": "metatable __index",
+      "kind": 15,
+      "detail": "Metatable with __index",
+      "documentation": {
+        "value": "Sets a metatable with __index for prototype-based lookup.\n\n```lua\nlocal mt = { __index = proto }\nsetmetatable(obj, mt)\n```"
+      },
+      "insertText": "local ${1:mt} = { __index = ${2:proto} }\nsetmetatable(${3:obj}, $1)",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___index"
+    },
+    {
+      "label": "metatable __newindex",
+      "kind": 15,
+      "detail": "Metatable with __newindex",
+      "documentation": {
+        "value": "Sets a metatable with __newindex to intercept assignments.\n\n```lua\nlocal mt = {\n    __newindex = function(t, k, v)\n        rawset(t, k, v)\n    end\n}\n```"
+      },
+      "insertText": "local ${1:mt} = {\n\t__newindex = function(${2:t}, ${3:k}, ${4:v})\n\t\t$0\n\tend\n}",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___newindex"
+    },
+    {
+      "label": "metatable __tostring",
+      "kind": 15,
+      "detail": "Metatable with __tostring",
+      "documentation": {
+        "value": "Custom string representation.\n\n```lua\nlocal mt = {\n    __tostring = function(self)\n        return string.format(\"Obj(%s)\", self.name)\n    end\n}\n```"
+      },
+      "insertText": "local ${1:mt} = {\n\t__tostring = function(${2:self})\n\t\treturn ${0:string.format(\"${3:Obj(%s)}\", $2.${4:name})}\n\tend\n}",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___tostring"
+    },
+    {
+      "label": "metatable __call",
+      "kind": 15,
+      "detail": "Metatable with __call",
+      "documentation": {
+        "value": "Makes a table callable.\n\n```lua\nlocal mt = {\n    __call = function(self, ...)\n        return self:new(...)\n    end\n}\n```"
+      },
+      "insertText": "local ${1:mt} = {\n\t__call = function(${2:self}, ${3:...})\n\t\t$0\n\tend\n}",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___call"
+    },
+    {
+      "label": "metatable __add",
+      "kind": 15,
+      "detail": "Metatable with __add",
+      "documentation": {
+        "value": "Overloads the `+` operator.\n\n```lua\nlocal mt = {\n    __add = function(a, b)\n        return Vector(a.x + b.x, a.y + b.y)\n    end\n}\n```"
+      },
+      "insertText": "local ${1:mt} = {\n\t__add = function(${2:a}, ${3:b})\n\t\treturn $0\n\tend\n}",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___add"
+    },
+    {
+      "label": "metatable __eq",
+      "kind": 15,
+      "detail": "Metatable with __eq",
+      "documentation": {
+        "value": "Overloads the `==` operator.\n\n```lua\nlocal mt = {\n    __eq = function(a, b)\n        return a.id == b.id\n    end\n}\n```"
+      },
+      "insertText": "local ${1:mt} = {\n\t__eq = function(${2:a}, ${3:b})\n\t\treturn $0\n\tend\n}",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___eq"
+    },
+    {
+      "label": "metatable __len",
+      "kind": 15,
+      "detail": "Metatable with __len",
+      "documentation": {
+        "value": "Overloads the `#` (length) operator.\n\n```lua\nlocal mt = {\n    __len = function(self)\n        return self.count\n    end\n}\n```"
+      },
+      "insertText": "local ${1:mt} = {\n\t__len = function(${2:self})\n\t\treturn ${0:self.count}\n\tend\n}",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___len"
+    },
+    {
+      "label": "metatable __concat",
+      "kind": 15,
+      "detail": "Metatable with __concat",
+      "documentation": {
+        "value": "Overloads the `..` (concatenation) operator.\n\n```lua\nlocal mt = {\n    __concat = function(a, b)\n        return tostring(a) .. tostring(b)\n    end\n}\n```"
+      },
+      "insertText": "local ${1:mt} = {\n\t__concat = function(${2:a}, ${3:b})\n\t\treturn $0\n\tend\n}",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___concat"
+    },
+    {
+      "label": "metatable __lt",
+      "kind": 15,
+      "detail": "Metatable with __lt",
+      "documentation": {
+        "value": "Overloads the `<` operator for ordering.\n\n```lua\nlocal mt = {\n    __lt = function(a, b)\n        return a.value < b.value\n    end\n}\n```"
+      },
+      "insertText": "local ${1:mt} = {\n\t__lt = function(${2:a}, ${3:b})\n\t\treturn $0\n\tend\n}",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___lt"
+    },
+    {
+      "label": "metatable __gc",
+      "kind": 15,
+      "detail": "Metatable with __gc (finalizer)",
+      "documentation": {
+        "value": "Finalizer called when a userdata/table is garbage collected (Lua 5.2+).\n\n```lua\nlocal mt = {\n    __gc = function(self)\n        self:close()\n    end\n}\n```"
+      },
+      "insertText": "local ${1:mt} = {\n\t__gc = function(${2:self})\n\t\t$0\n\tend\n}",
+      "insertTextRules": 4,
+      "sortText": "00_metatable___gc"
+    },
+    {
+      "label": "class pattern",
+      "kind": 15,
+      "detail": "OOP class pattern",
+      "documentation": {
+        "value": "Basic class/prototype pattern using metatables.\n\n```lua\nlocal MyClass = {}\nMyClass.__index = MyClass\n\nfunction MyClass.new(name)\n    return setmetatable({ name = name }, MyClass)\nend\n\nfunction MyClass:greet()\n    print(\"Hello, \" .. self.name)\nend\n```"
+      },
+      "insertText": "local ${1:MyClass} = {}\n$1.__index = $1\n\nfunction $1.new(${2:params})\n\treturn setmetatable({${3:fields}}, $1)\nend\n\nfunction $1:${4:method}(${5:})\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_class_pattern"
+    },
+    {
+      "label": "inheritance pattern",
+      "kind": 15,
+      "detail": "OOP inheritance pattern",
+      "documentation": {
+        "value": "Single inheritance using metatables.\n\n```lua\nlocal Child = setmetatable({}, { __index = Parent })\nChild.__index = Child\n\nfunction Child.new(...)\n    local self = Parent.new(...)\n    return setmetatable(self, Child)\nend\n```"
+      },
+      "insertText": "local ${1:Child} = setmetatable({}, { __index = ${2:Parent} })\n$1.__index = $1\n\nfunction $1.new(${3:params})\n\tlocal self = $2.new(${4:params})\n\treturn setmetatable(self, $1)\nend\n\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_inheritance_pattern"
+    },
+    {
+      "label": "mixin pattern",
+      "kind": 15,
+      "detail": "Mixin pattern",
+      "documentation": {
+        "value": "Copies methods from a mixin table into a target.\n\n```lua\nlocal function mixin(target, ...)\n    for _, mix in ipairs({...}) do\n        for k, v in pairs(mix) do\n            target[k] = v\n        end\n    end\n    return target\nend\n```"
+      },
+      "insertText": "local function mixin(${1:target}, ...)\n\tfor _, mix in ipairs({...}) do\n\t\tfor k, v in pairs(mix) do\n\t\t\t$1[k] = v\n\t\tend\n\tend\n\treturn $1\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_mixin_pattern"
+    },
+    {
+      "label": "local",
+      "kind": 15,
+      "detail": "Local variable declaration",
+      "documentation": {
+        "value": "Declares a local variable.\n\n```lua\nlocal x = 42\n```"
+      },
+      "insertText": "local ${1:name} = ${0:value}",
+      "insertTextRules": 4,
+      "sortText": "00_local"
+    },
+    {
+      "label": "local multiple",
+      "kind": 15,
+      "detail": "Local multiple assignment",
+      "documentation": {
+        "value": "Assigns multiple local variables at once.\n\n```lua\nlocal x, y, z = 1, 2, 3\n```"
+      },
+      "insertText": "local ${1:a}, ${2:b} = ${3:val1}, ${4:val2}",
+      "insertTextRules": 4,
+      "sortText": "00_local_multiple"
+    },
+    {
+      "label": "local destructure",
+      "kind": 15,
+      "detail": "Local destructure from function return",
+      "documentation": {
+        "value": "Captures multiple return values.\n\n```lua\nlocal ok, err = pcall(fn)\n```"
+      },
+      "insertText": "local ${1:ok}, ${2:err} = ${0:pcall(fn)}",
+      "insertTextRules": 4,
+      "sortText": "00_local_destructure"
+    },
+    {
+      "label": "module pattern",
+      "kind": 15,
+      "detail": "Module pattern (return table)",
+      "documentation": {
+        "value": "Standard Lua module that returns a table.\n\n```lua\nlocal M = {}\n\nfunction M.greet(name)\n    return \"Hello, \" .. name\nend\n\nreturn M\n```"
+      },
+      "insertText": "local ${1:M} = {}\n\n$0\n\nreturn $1",
+      "insertTextRules": 4,
+      "sortText": "00_module_pattern"
+    },
+    {
+      "label": "require",
+      "kind": 15,
+      "detail": "Require module",
+      "documentation": {
+        "value": "Load and cache a module.\n\n```lua\nlocal json = require(\"dkjson\")\n```"
+      },
+      "insertText": "local ${1:mod} = require(\"${2:modname}\")",
+      "insertTextRules": 4,
+      "sortText": "00_require"
+    },
+    {
+      "label": "module with local",
+      "kind": 15,
+      "detail": "Module with local cache",
+      "documentation": {
+        "value": "Module pattern caching frequently used functions locally.\n\n```lua\nlocal M = {}\nlocal format = string.format\n\nfunction M.hello(name)\n    return format(\"Hello, %s!\", name)\nend\n\nreturn M\n```"
+      },
+      "insertText": "local ${1:M} = {}\nlocal ${2:format} = string.${3:format}\n\n$0\n\nreturn $1",
+      "insertTextRules": 4,
+      "sortText": "00_module_with_local"
+    },
+    {
+      "label": "string.find",
+      "kind": 15,
+      "detail": "string.find usage",
+      "documentation": {
+        "value": "Find a pattern in a string.\n\n```lua\nlocal s, e = string.find(str, pattern)\n```"
+      },
+      "insertText": "local ${1:s}, ${2:e} = string.find(${3:str}, \"${4:pattern}\")",
+      "insertTextRules": 4,
+      "sortText": "00_string.find"
+    },
+    {
+      "label": "string.match",
+      "kind": 15,
+      "detail": "string.match usage",
+      "documentation": {
+        "value": "Extract the first match of a pattern.\n\n```lua\nlocal result = string.match(str, pattern)\n```"
+      },
+      "insertText": "local ${1:result} = string.match(${2:str}, \"${3:pattern}\")",
+      "insertTextRules": 4,
+      "sortText": "00_string.match"
+    },
+    {
+      "label": "string.gmatch",
+      "kind": 15,
+      "detail": "string.gmatch iteration",
+      "documentation": {
+        "value": "Iterate over all pattern matches.\n\n```lua\nfor word in string.gmatch(str, \"%S+\") do\n    print(word)\nend\n```"
+      },
+      "insertText": "for ${1:match} in string.gmatch(${2:str}, \"${3:pattern}\") do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_string.gmatch"
+    },
+    {
+      "label": "string.gsub",
+      "kind": 15,
+      "detail": "string.gsub replacement",
+      "documentation": {
+        "value": "Replace pattern occurrences.\n\n```lua\nlocal result = string.gsub(str, pattern, repl)\n```"
+      },
+      "insertText": "local ${1:result} = string.gsub(${2:str}, \"${3:pattern}\", ${4:repl})",
+      "insertTextRules": 4,
+      "sortText": "00_string.gsub"
+    },
+    {
+      "label": "string.format",
+      "kind": 15,
+      "detail": "string.format usage",
+      "documentation": {
+        "value": "Format a string.\n\n```lua\nlocal s = string.format(\"%s = %d\", name, value)\n```"
+      },
+      "insertText": "local ${1:s} = string.format(\"${2:%s}\", ${3:args})",
+      "insertTextRules": 4,
+      "sortText": "00_string.format"
+    },
+    {
+      "label": "coroutine.create",
+      "kind": 15,
+      "detail": "Create a coroutine",
+      "documentation": {
+        "value": "Creates a new coroutine from a function.\n\n```lua\nlocal co = coroutine.create(function()\n    coroutine.yield(1)\n    return 2\nend)\n```"
+      },
+      "insertText": "local ${1:co} = coroutine.create(function(${2:})\n\t$0\nend)",
+      "insertTextRules": 4,
+      "sortText": "00_coroutine.create"
+    },
+    {
+      "label": "coroutine.wrap",
+      "kind": 15,
+      "detail": "Wrap a coroutine",
+      "documentation": {
+        "value": "Creates a coroutine wrapped as a callable function.\n\n```lua\nlocal gen = coroutine.wrap(function()\n    coroutine.yield(1)\n    coroutine.yield(2)\nend)\nprint(gen()) -- 1\nprint(gen()) -- 2\n```"
+      },
+      "insertText": "local ${1:gen} = coroutine.wrap(function(${2:})\n\t$0\nend)",
+      "insertTextRules": 4,
+      "sortText": "00_coroutine.wrap"
+    },
+    {
+      "label": "coroutine resume/yield",
+      "kind": 15,
+      "detail": "Coroutine resume/yield pattern",
+      "documentation": {
+        "value": "Basic producer-consumer with resume and yield.\n\n```lua\nlocal co = coroutine.create(function()\n    for i = 1, 5 do\n        coroutine.yield(i)\n    end\nend)\n\nwhile true do\n    local ok, val = coroutine.resume(co)\n    if not ok then break end\n    print(val)\nend\n```"
+      },
+      "insertText": "local ${1:co} = coroutine.create(function()\n\tfor ${2:i} = ${3:1}, ${4:n} do\n\t\tcoroutine.yield(${5:i})\n\tend\nend)\n\nwhile true do\n\tlocal ok, val = coroutine.resume($1)\n\tif not ok then break end\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_coroutine_resume/yield"
+    },
+    {
+      "label": "producer-consumer",
+      "kind": 15,
+      "detail": "Producer-consumer coroutine pattern",
+      "documentation": {
+        "value": "Coroutine-based producer-consumer.\n\n```lua\nlocal function producer()\n    return coroutine.wrap(function()\n        while true do\n            local item = produce()\n            coroutine.yield(item)\n        end\n    end)\nend\n\nfor item in producer() do\n    consume(item)\nend\n```"
+      },
+      "insertText": "local function ${1:producer}()\n\treturn coroutine.wrap(function()\n\t\t${2:-- produce items}\n\t\tcoroutine.yield(${3:item})\n\tend)\nend\n\nfor ${4:item} in $1() do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_producer-consumer"
+    },
+    {
+      "label": "io.open read",
+      "kind": 15,
+      "detail": "Read file with io.open",
+      "documentation": {
+        "value": "Open a file for reading and read its contents.\n\n```lua\nlocal f = io.open(\"file.txt\", \"r\")\nif f then\n    local content = f:read(\"*a\")\n    f:close()\nend\n```"
+      },
+      "insertText": "local ${1:f} = io.open(\"${2:filename}\", \"r\")\nif $1 then\n\tlocal ${3:content} = $1:read(\"*a\")\n\t$1:close()\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_io.open_read"
+    },
+    {
+      "label": "io.open write",
+      "kind": 15,
+      "detail": "Write file with io.open",
+      "documentation": {
+        "value": "Open a file for writing.\n\n```lua\nlocal f = io.open(\"file.txt\", \"w\")\nif f then\n    f:write(\"Hello\\n\")\n    f:close()\nend\n```"
+      },
+      "insertText": "local ${1:f} = io.open(\"${2:filename}\", \"w\")\nif $1 then\n\t$1:write(${3:data})\n\t$1:close()\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_io.open_write"
+    },
+    {
+      "label": "io.open append",
+      "kind": 15,
+      "detail": "Append to file with io.open",
+      "documentation": {
+        "value": "Open a file for appending.\n\n```lua\nlocal f = io.open(\"log.txt\", \"a\")\nif f then\n    f:write(os.date() .. \" entry\\n\")\n    f:close()\nend\n```"
+      },
+      "insertText": "local ${1:f} = io.open(\"${2:filename}\", \"a\")\nif $1 then\n\t$1:write(${3:data})\n\t$1:close()\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_io.open_append"
+    },
+    {
+      "label": "io.lines",
+      "kind": 15,
+      "detail": "Iterate lines of a file",
+      "documentation": {
+        "value": "Read a file line by line.\n\n```lua\nfor line in io.lines(\"file.txt\") do\n    print(line)\nend\n```"
+      },
+      "insertText": "for ${1:line} in io.lines(\"${2:filename}\") do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_io.lines"
+    },
+    {
+      "label": "io.read stdin",
+      "kind": 15,
+      "detail": "Read from stdin",
+      "documentation": {
+        "value": "Read a line from standard input.\n\n```lua\nio.write(\"Enter name: \")\nlocal name = io.read()\n```"
+      },
+      "insertText": "io.write(\"${1:prompt: }\")\nlocal ${2:input} = io.read(${3:\"*l\"})",
+      "insertTextRules": 4,
+      "sortText": "00_io.read_stdin"
+    },
+    {
+      "label": "os.execute",
+      "kind": 15,
+      "detail": "Execute a shell command",
+      "documentation": {
+        "value": "Execute a command in the OS shell.\n\n```lua\nos.execute(\"ls -la\")\n```"
+      },
+      "insertText": "os.execute(\"${1:command}\")",
+      "insertTextRules": 4,
+      "sortText": "00_os.execute"
+    },
+    {
+      "label": "os.clock",
+      "kind": 15,
+      "detail": "Measure elapsed CPU time",
+      "documentation": {
+        "value": "Returns CPU time used by the program.\n\n```lua\nlocal start = os.clock()\n-- work\nprint(string.format(\"Elapsed: %.3f s\", os.clock() - start))\n```"
+      },
+      "insertText": "local ${1:start} = os.clock()\n$0\nprint(string.format(\"Elapsed: %.3f s\", os.clock() - $1))",
+      "insertTextRules": 4,
+      "sortText": "00_os.clock"
+    },
+    {
+      "label": "os.time",
+      "kind": 15,
+      "detail": "Get current time",
+      "documentation": {
+        "value": "Returns the current time as a number (epoch seconds).\n\n```lua\nlocal now = os.time()\n```"
+      },
+      "insertText": "local ${1:now} = os.time()",
+      "insertTextRules": 4,
+      "sortText": "00_os.time"
+    },
+    {
+      "label": "os.date",
+      "kind": 15,
+      "detail": "Format date/time",
+      "documentation": {
+        "value": "Format a date/time string.\n\n```lua\nprint(os.date(\"%Y-%m-%d %H:%M:%S\"))\n```"
+      },
+      "insertText": "os.date(\"${1:%Y-%m-%d %H:%M:%S}\"${2:, os.time()})",
+      "insertTextRules": 4,
+      "sortText": "00_os.date"
+    },
+    {
+      "label": "pcall",
+      "kind": 15,
+      "detail": "Protected call",
+      "documentation": {
+        "value": "Call a function in protected mode.\n\n```lua\nlocal ok, result = pcall(function()\n    -- code that may error\nend)\nif not ok then\n    print(\"Error: \" .. result)\nend\n```"
+      },
+      "insertText": "local ${1:ok}, ${2:result} = pcall(function()\n\t$0\nend)\nif not $1 then\n\tprint(\"Error: \" .. tostring($2))\nend",
+      "insertTextRules": 4,
+      "sortText": "00_pcall"
+    },
+    {
+      "label": "xpcall",
+      "kind": 15,
+      "detail": "Extended protected call",
+      "documentation": {
+        "value": "Call a function in protected mode with error handler.\n\n```lua\nlocal ok, result = xpcall(function()\n    error(\"oops\")\nend, debug.traceback)\n```"
+      },
+      "insertText": "local ${1:ok}, ${2:result} = xpcall(function()\n\t$0\nend, ${3:debug.traceback})",
+      "insertTextRules": 4,
+      "sortText": "00_xpcall"
+    },
+    {
+      "label": "error",
+      "kind": 15,
+      "detail": "Raise an error",
+      "documentation": {
+        "value": "Terminates the last protected call with the error message.\n\n```lua\nerror(\"something went wrong\", 2)\n```"
+      },
+      "insertText": "error(\"${1:message}\"${2:, ${3:level}})",
+      "insertTextRules": 4,
+      "sortText": "00_error"
+    },
+    {
+      "label": "assert",
+      "kind": 15,
+      "detail": "Assert a condition",
+      "documentation": {
+        "value": "Raises an error if the value is falsy.\n\n```lua\nlocal f = assert(io.open(filename, \"r\"))\n```"
+      },
+      "insertText": "assert(${1:value}, \"${2:assertion failed}\")",
+      "insertTextRules": 4,
+      "sortText": "00_assert"
+    },
+    {
+      "label": "debug.traceback",
+      "kind": 15,
+      "detail": "Get stack traceback",
+      "documentation": {
+        "value": "Returns a string with a traceback of the call stack.\n\n```lua\nprint(debug.traceback(\"Error occurred\", 2))\n```"
+      },
+      "insertText": "debug.traceback(\"${1:message}\", ${2:2})",
+      "insertTextRules": 4,
+      "sortText": "00_debug.traceback"
+    },
+    {
+      "label": "debug.getinfo",
+      "kind": 15,
+      "detail": "Get function information",
+      "documentation": {
+        "value": "Returns a table with information about a function.\n\n```lua\nlocal info = debug.getinfo(1, \"Sln\")\nprint(info.short_src, info.currentline)\n```"
+      },
+      "insertText": "local ${1:info} = debug.getinfo(${2:1}, \"${3:Sln}\")",
+      "insertTextRules": 4,
+      "sortText": "00_debug.getinfo"
+    },
+    {
+      "label": "math.random range",
+      "kind": 15,
+      "detail": "Random number in range",
+      "documentation": {
+        "value": "Generate a random integer in a range.\n\n```lua\nlocal n = math.random(1, 100)\n```"
+      },
+      "insertText": "math.random(${1:1}, ${2:100})",
+      "insertTextRules": 4,
+      "sortText": "00_math.random_range"
+    },
+    {
+      "label": "math.floor division",
+      "kind": 15,
+      "detail": "Floor division",
+      "documentation": {
+        "value": "Integer division using math.floor.\n\n```lua\nlocal q = math.floor(a / b)\n```"
+      },
+      "insertText": "math.floor(${1:a} / ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "00_math.floor_division"
+    },
+    {
+      "label": "math.max min clamp",
+      "kind": 15,
+      "detail": "Clamp value to range",
+      "documentation": {
+        "value": "Clamp a value between min and max.\n\n```lua\nlocal clamped = math.max(lo, math.min(hi, value))\n```"
+      },
+      "insertText": "math.max(${1:lo}, math.min(${2:hi}, ${3:value}))",
+      "insertTextRules": 4,
+      "sortText": "00_math.max_min_clamp"
+    },
+    {
+      "label": "iterator stateless",
+      "kind": 15,
+      "detail": "Stateless iterator",
+      "documentation": {
+        "value": "A stateless custom iterator function.\n\n```lua\nlocal function squares(max, i)\n    i = i + 1\n    if i > max then return nil end\n    return i, i * i\nend\n\nfor i, sq in squares, 5, 0 do\n    print(i, sq)\nend\n```"
+      },
+      "insertText": "local function ${1:iter}(${2:invariant}, ${3:control})\n\t$3 = $3 + 1\n\tif $3 > $2 then return nil end\n\treturn $3, ${0:value}\nend",
+      "insertTextRules": 4,
+      "sortText": "00_iterator_stateless"
+    },
+    {
+      "label": "iterator stateful",
+      "kind": 15,
+      "detail": "Stateful iterator (closure)",
+      "documentation": {
+        "value": "A stateful custom iterator using a closure.\n\n```lua\nlocal function range(n)\n    local i = 0\n    return function()\n        i = i + 1\n        if i <= n then return i end\n    end\nend\n\nfor v in range(5) do print(v) end\n```"
+      },
+      "insertText": "local function ${1:range}(${2:n})\n\tlocal ${3:i} = 0\n\treturn function()\n\t\t$3 = $3 + 1\n\t\tif $3 <= $2 then return $3 end\n\tend\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_iterator_stateful"
+    },
+    {
+      "label": "generic for custom",
+      "kind": 15,
+      "detail": "Generic for with custom iterator",
+      "documentation": {
+        "value": "Using a custom iterator in a generic for loop.\n\n```lua\nfor value in myiter(args) do\n    print(value)\nend\n```"
+      },
+      "insertText": "for ${1:value} in ${2:iterator}(${3:args}) do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_generic_for_custom"
+    },
+    {
+      "label": "integer division //",
+      "kind": 15,
+      "detail": "Integer division (5.3+)",
+      "documentation": {
+        "value": "Floor division operator available since Lua 5.3.\n\n```lua\nlocal q = 7 // 2  -- 3\n```"
+      },
+      "insertText": "${1:a} // ${2:b}",
+      "insertTextRules": 4,
+      "sortText": "00_integer_division_//"
+    },
+    {
+      "label": "bitwise and &",
+      "kind": 15,
+      "detail": "Bitwise AND (5.3+)",
+      "documentation": {
+        "value": "Bitwise AND operator.\n\n```lua\nlocal result = a & b\n```"
+      },
+      "insertText": "${1:a} & ${2:b}",
+      "insertTextRules": 4,
+      "sortText": "00_bitwise_and_&"
+    },
+    {
+      "label": "bitwise or |",
+      "kind": 15,
+      "detail": "Bitwise OR (5.3+)",
+      "documentation": {
+        "value": "Bitwise OR operator.\n\n```lua\nlocal result = a | b\n```"
+      },
+      "insertText": "${1:a} | ${2:b}",
+      "insertTextRules": 4,
+      "sortText": "00_bitwise_or_|"
+    },
+    {
+      "label": "bitwise xor ~",
+      "kind": 15,
+      "detail": "Bitwise XOR (5.3+)",
+      "documentation": {
+        "value": "Bitwise XOR operator (tilde).\n\n```lua\nlocal result = a ~ b\n```"
+      },
+      "insertText": "${1:a} ~ ${2:b}",
+      "insertTextRules": 4,
+      "sortText": "00_bitwise_xor_~"
+    },
+    {
+      "label": "bitwise not ~",
+      "kind": 15,
+      "detail": "Bitwise NOT (5.3+)",
+      "documentation": {
+        "value": "Bitwise NOT (unary tilde).\n\n```lua\nlocal result = ~a\n```"
+      },
+      "insertText": "~${1:a}",
+      "insertTextRules": 4,
+      "sortText": "00_bitwise_not_~"
+    },
+    {
+      "label": "bitwise shift",
+      "kind": 15,
+      "detail": "Bitwise shift (5.3+)",
+      "documentation": {
+        "value": "Left/right bit shift operators.\n\n```lua\nlocal l = a << n\nlocal r = a >> n\n```"
+      },
+      "insertText": "${1:a} ${2:<<} ${3:n}",
+      "insertTextRules": 4,
+      "sortText": "00_bitwise_shift"
+    },
+    {
+      "label": "goto label",
+      "kind": 15,
+      "detail": "Goto and label (5.2+)",
+      "documentation": {
+        "value": "Jump to a label.\n\n```lua\ngoto done\n-- skipped code\n::done::\n```"
+      },
+      "insertText": "goto ${1:label}\n$0\n::$1::",
+      "insertTextRules": 4,
+      "sortText": "00_goto_label"
+    },
+    {
+      "label": "string.pack",
+      "kind": 15,
+      "detail": "string.pack (5.3+)",
+      "documentation": {
+        "value": "Pack values into a binary string.\n\n```lua\nlocal data = string.pack(\"i4i4\", 42, 99)\n```"
+      },
+      "insertText": "local ${1:data} = string.pack(\"${2:fmt}\", ${3:values})",
+      "insertTextRules": 4,
+      "sortText": "00_string.pack"
+    },
+    {
+      "label": "string.unpack",
+      "kind": 15,
+      "detail": "string.unpack (5.3+)",
+      "documentation": {
+        "value": "Unpack values from a binary string.\n\n```lua\nlocal a, b = string.unpack(\"i4i4\", data)\n```"
+      },
+      "insertText": "local ${1:a}, ${2:b} = string.unpack(\"${3:fmt}\", ${4:data})",
+      "insertTextRules": 4,
+      "sortText": "00_string.unpack"
+    },
+    {
+      "label": "utf8.codes",
+      "kind": 15,
+      "detail": "utf8.codes iteration (5.3+)",
+      "documentation": {
+        "value": "Iterate over UTF-8 codepoints.\n\n```lua\nfor pos, code in utf8.codes(s) do\n    print(pos, code)\nend\n```"
+      },
+      "insertText": "for ${1:pos}, ${2:code} in utf8.codes(${3:s}) do\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_utf8.codes"
+    },
+    {
+      "label": "utf8.len",
+      "kind": 15,
+      "detail": "utf8.len (5.3+)",
+      "documentation": {
+        "value": "Get the number of UTF-8 characters.\n\n```lua\nlocal n = utf8.len(s)\n```"
+      },
+      "insertText": "local ${1:n} = utf8.len(${2:s})",
+      "insertTextRules": 4,
+      "sortText": "00_utf8.len"
+    },
+    {
+      "label": "ffi.cdef",
+      "kind": 15,
+      "detail": "FFI C definition (LuaJIT)",
+      "documentation": {
+        "value": "Declare C types and functions for FFI.\n\n```lua\nlocal ffi = require(\"ffi\")\nffi.cdef[[\n    int printf(const char *fmt, ...);\n]]\n```"
+      },
+      "insertText": "local ffi = require(\"ffi\")\nffi.cdef[[\n\t${1:int printf(const char *fmt, ...);}\n]]",
+      "insertTextRules": 4,
+      "sortText": "00_ffi.cdef"
+    },
+    {
+      "label": "ffi.new",
+      "kind": 15,
+      "detail": "FFI allocate C data (LuaJIT)",
+      "documentation": {
+        "value": "Allocate a new C data object.\n\n```lua\nlocal buf = ffi.new(\"char[?]\", 256)\n```"
+      },
+      "insertText": "local ${1:ptr} = ffi.new(\"${2:type}\"${3:, ${4:size}})",
+      "insertTextRules": 4,
+      "sortText": "00_ffi.new"
+    },
+    {
+      "label": "ffi.cast",
+      "kind": 15,
+      "detail": "FFI cast pointer (LuaJIT)",
+      "documentation": {
+        "value": "Cast a pointer to another type.\n\n```lua\nlocal p = ffi.cast(\"int*\", buf)\n```"
+      },
+      "insertText": "local ${1:p} = ffi.cast(\"${2:type}\", ${3:ptr})",
+      "insertTextRules": 4,
+      "sortText": "00_ffi.cast"
+    },
+    {
+      "label": "ffi.load",
+      "kind": 15,
+      "detail": "FFI load shared library (LuaJIT)",
+      "documentation": {
+        "value": "Load a shared library.\n\n```lua\nlocal lib = ffi.load(\"mylib\")\n```"
+      },
+      "insertText": "local ${1:lib} = ffi.load(\"${2:libname}\")",
+      "insertTextRules": 4,
+      "sortText": "00_ffi.load"
+    },
+    {
+      "label": "enum pattern",
+      "kind": 15,
+      "detail": "Enum / constants pattern",
+      "documentation": {
+        "value": "Use a table of constants as an enum.\n\n```lua\nlocal Color = {\n    RED   = 1,\n    GREEN = 2,\n    BLUE  = 3,\n}\n```"
+      },
+      "insertText": "local ${1:Enum} = {\n\t${2:VALUE1} = ${3:1},\n\t${4:VALUE2} = ${5:2},\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "00_enum_pattern"
+    },
+    {
+      "label": "singleton pattern",
+      "kind": 15,
+      "detail": "Singleton pattern",
+      "documentation": {
+        "value": "Ensure a single instance via module caching.\n\n```lua\nlocal instance\nlocal M = {}\nfunction M.getInstance()\n    if not instance then instance = M.new() end\n    return instance\nend\nreturn M\n```"
+      },
+      "insertText": "local instance\nlocal ${1:M} = {}\n\nfunction $1.getInstance()\n\tif not instance then\n\t\tinstance = $1.new()\n\tend\n\treturn instance\nend\n\n$0\n\nreturn $1",
+      "insertTextRules": 4,
+      "sortText": "00_singleton_pattern"
+    },
+    {
+      "label": "callback event",
+      "kind": 15,
+      "detail": "Callback / event emitter pattern",
+      "documentation": {
+        "value": "Simple event/callback registration.\n\n```lua\nlocal listeners = {}\nfunction on(event, fn)\n    listeners[event] = listeners[event] or {}\n    table.insert(listeners[event], fn)\nend\nfunction emit(event, ...)\n    for _, fn in ipairs(listeners[event] or {}) do\n        fn(...)\n    end\nend\n```"
+      },
+      "insertText": "local ${1:listeners} = {}\n\nfunction ${2:on}(${3:event}, ${4:fn})\n\t$1[$3] = $1[$3] or {}\n\ttable.insert($1[$3], $4)\nend\n\nfunction ${5:emit}($3, ...)\n\tfor _, fn in ipairs($1[$3] or {}) do\n\t\tfn(...)\n\tend\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_callback_event"
+    },
+    {
+      "label": "type check guard",
+      "kind": 15,
+      "detail": "Type checking guard",
+      "documentation": {
+        "value": "Guard clause checking argument type.\n\n```lua\nif type(x) ~= \"string\" then\n    error(\"expected string, got \" .. type(x), 2)\nend\n```"
+      },
+      "insertText": "if type(${1:x}) ~= \"${2:string}\" then\n\terror(\"expected $2, got \" .. type($1), 2)\nend",
+      "insertTextRules": 4,
+      "sortText": "00_type_check_guard"
+    },
+    {
+      "label": "deep copy",
+      "kind": 15,
+      "detail": "Deep copy table",
+      "documentation": {
+        "value": "Recursively copy a table and its metatables.\n\n```lua\nlocal function deepcopy(orig)\n    if type(orig) ~= \"table\" then return orig end\n    local copy = {}\n    for k, v in next, orig, nil do\n        copy[deepcopy(k)] = deepcopy(v)\n    end\n    return setmetatable(copy, getmetatable(orig))\nend\n```"
+      },
+      "insertText": "local function deepcopy(orig)\n\tif type(orig) ~= \"table\" then return orig end\n\tlocal copy = {}\n\tfor k, v in next, orig, nil do\n\t\tcopy[deepcopy(k)] = deepcopy(v)\n\tend\n\treturn setmetatable(copy, getmetatable(orig))\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_deep_copy"
+    },
+    {
+      "label": "shallow copy",
+      "kind": 15,
+      "detail": "Shallow copy table",
+      "documentation": {
+        "value": "Copy top-level keys from a table.\n\n```lua\nlocal function shallowcopy(t)\n    local copy = {}\n    for k, v in pairs(t) do copy[k] = v end\n    return setmetatable(copy, getmetatable(t))\nend\n```"
+      },
+      "insertText": "local function shallowcopy(${1:t})\n\tlocal copy = {}\n\tfor k, v in pairs($1) do copy[k] = v end\n\treturn setmetatable(copy, getmetatable($1))\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_shallow_copy"
+    },
+    {
+      "label": "switch pattern",
+      "kind": 15,
+      "detail": "Switch/case pattern",
+      "documentation": {
+        "value": "Simulate switch/case with a table of handlers.\n\n```lua\nlocal actions = {\n    add = function(a, b) return a + b end,\n    sub = function(a, b) return a - b end,\n}\nlocal fn = actions[op]\nif fn then fn(a, b) end\n```"
+      },
+      "insertText": "local ${1:actions} = {\n\t${2:case1} = function(${3:})\n\t\t${4:-- handler}\n\tend,\n\t$0\n}\nlocal fn = $1[${5:key}]\nif fn then fn(${6:}) end",
+      "insertTextRules": 4,
+      "sortText": "00_switch_pattern"
+    },
+    {
+      "label": "try-catch pattern",
+      "kind": 15,
+      "detail": "Try-catch pattern (pcall wrapper)",
+      "documentation": {
+        "value": "Wrap pcall into a try-catch-like construct.\n\n```lua\nlocal ok, err = pcall(function()\n    -- try\nend)\nif not ok then\n    -- catch\n    print(\"Error: \" .. tostring(err))\nend\n```"
+      },
+      "insertText": "local ok, err = pcall(function()\n\t${1:-- try}\nend)\nif not ok then\n\t${0:-- catch}\nend",
+      "insertTextRules": 4,
+      "sortText": "00_try-catch_pattern"
+    },
+    {
+      "label": "protected require",
+      "kind": 15,
+      "detail": "Protected require",
+      "documentation": {
+        "value": "Safely require a module.\n\n```lua\nlocal ok, mod = pcall(require, \"modname\")\nif not ok then\n    print(\"Module not found\")\nend\n```"
+      },
+      "insertText": "local ok, ${1:mod} = pcall(require, \"${2:modname}\")\nif not ok then\n\t${0:-- fallback}\nend",
+      "insertTextRules": 4,
+      "sortText": "00_protected_require"
+    },
+    {
+      "label": "table merge",
+      "kind": 15,
+      "detail": "Merge tables",
+      "documentation": {
+        "value": "Merge keys from source tables into a target.\n\n```lua\nlocal function merge(target, ...)\n    for _, src in ipairs({...}) do\n        for k, v in pairs(src) do\n            target[k] = v\n        end\n    end\n    return target\nend\n```"
+      },
+      "insertText": "local function merge(${1:target}, ...)\n\tfor _, src in ipairs({...}) do\n\t\tfor k, v in pairs(src) do\n\t\t\t$1[k] = v\n\t\tend\n\tend\n\treturn $1\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_table_merge"
+    },
+    {
+      "label": "table filter",
+      "kind": 15,
+      "detail": "Filter table elements",
+      "documentation": {
+        "value": "Filter array elements by a predicate.\n\n```lua\nlocal function filter(t, predicate)\n    local result = {}\n    for _, v in ipairs(t) do\n        if predicate(v) then result[#result + 1] = v end\n    end\n    return result\nend\n```"
+      },
+      "insertText": "local function filter(${1:t}, ${2:predicate})\n\tlocal result = {}\n\tfor _, v in ipairs($1) do\n\t\tif $2(v) then result[#result + 1] = v end\n\tend\n\treturn result\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_table_filter"
+    },
+    {
+      "label": "table map",
+      "kind": 15,
+      "detail": "Map over table elements",
+      "documentation": {
+        "value": "Apply a function to each element of an array.\n\n```lua\nlocal function map(t, fn)\n    local result = {}\n    for i, v in ipairs(t) do result[i] = fn(v, i) end\n    return result\nend\n```"
+      },
+      "insertText": "local function map(${1:t}, ${2:fn})\n\tlocal result = {}\n\tfor i, v in ipairs($1) do result[i] = $2(v, i) end\n\treturn result\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_table_map"
+    },
+    {
+      "label": "table reduce",
+      "kind": 15,
+      "detail": "Reduce / fold table",
+      "documentation": {
+        "value": "Reduce an array to a single value.\n\n```lua\nlocal function reduce(t, fn, init)\n    local acc = init\n    for _, v in ipairs(t) do acc = fn(acc, v) end\n    return acc\nend\n```"
+      },
+      "insertText": "local function reduce(${1:t}, ${2:fn}, ${3:init})\n\tlocal acc = $3\n\tfor _, v in ipairs($1) do acc = $2(acc, v) end\n\treturn acc\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_table_reduce"
+    },
+    {
+      "label": "string split",
+      "kind": 15,
+      "detail": "Split string into parts",
+      "documentation": {
+        "value": "Split a string by a delimiter.\n\n```lua\nlocal function split(str, sep)\n    local parts = {}\n    for part in str:gmatch(\"[^\" .. sep .. \"]+\") do\n        parts[#parts + 1] = part\n    end\n    return parts\nend\n```"
+      },
+      "insertText": "local function split(${1:str}, ${2:sep})\n\tlocal parts = {}\n\tfor part in $1:gmatch(\"[^\" .. $2 .. \"]+\") do\n\t\tparts[#parts + 1] = part\n\tend\n\treturn parts\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_string_split"
+    },
+    {
+      "label": "string trim",
+      "kind": 15,
+      "detail": "Trim whitespace from string",
+      "documentation": {
+        "value": "Remove leading and trailing whitespace.\n\n```lua\nlocal function trim(s)\n    return s:match(\"^%s*(.-)%s*$\")\nend\n```"
+      },
+      "insertText": "local function trim(${1:s})\n\treturn $1:match(\"^%%s*(.-)%%s*$\")\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_string_trim"
+    },
+    {
+      "label": "table keys",
+      "kind": 15,
+      "detail": "Get table keys",
+      "documentation": {
+        "value": "Collect all keys of a table into an array.\n\n```lua\nlocal function keys(t)\n    local ks = {}\n    for k in pairs(t) do ks[#ks + 1] = k end\n    return ks\nend\n```"
+      },
+      "insertText": "local function keys(${1:t})\n\tlocal ks = {}\n\tfor k in pairs($1) do ks[#ks + 1] = k end\n\treturn ks\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_table_keys"
+    },
+    {
+      "label": "table values",
+      "kind": 15,
+      "detail": "Get table values",
+      "documentation": {
+        "value": "Collect all values of a table into an array.\n\n```lua\nlocal function values(t)\n    local vs = {}\n    for _, v in pairs(t) do vs[#vs + 1] = v end\n    return vs\nend\n```"
+      },
+      "insertText": "local function values(${1:t})\n\tlocal vs = {}\n\tfor _, v in pairs($1) do vs[#vs + 1] = v end\n\treturn vs\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_table_values"
+    },
+    {
+      "label": "table contains",
+      "kind": 15,
+      "detail": "Check if table contains value",
+      "documentation": {
+        "value": "Check if an array-like table contains a value.\n\n```lua\nlocal function contains(t, value)\n    for _, v in ipairs(t) do\n        if v == value then return true end\n    end\n    return false\nend\n```"
+      },
+      "insertText": "local function contains(${1:t}, ${2:value})\n\tfor _, v in ipairs($1) do\n\t\tif v == $2 then return true end\n\tend\n\treturn false\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_table_contains"
+    },
+    {
+      "label": "readonly table",
+      "kind": 15,
+      "detail": "Read-only table proxy",
+      "documentation": {
+        "value": "Create a proxy table that prevents modification.\n\n```lua\nlocal function readonly(t)\n    return setmetatable({}, {\n        __index = t,\n        __newindex = function() error(\"attempt to modify read-only table\", 2) end,\n    })\nend\n```"
+      },
+      "insertText": "local function readonly(${1:t})\n\treturn setmetatable({}, {\n\t\t__index = $1,\n\t\t__newindex = function() error(\"attempt to modify read-only table\", 2) end,\n\t})\nend\n$0",
+      "insertTextRules": 4,
+      "sortText": "00_readonly_table"
+    },
+    {
+      "label": "weak table",
+      "kind": 15,
+      "detail": "Weak reference table",
+      "documentation": {
+        "value": "Create a table with weak references.\n\n```lua\nlocal cache = setmetatable({}, { __mode = \"v\" }) -- weak values\n```"
+      },
+      "insertText": "local ${1:cache} = setmetatable({}, { __mode = \"${2:v}\" })",
+      "insertTextRules": 4,
+      "sortText": "00_weak_table"
+    },
+    {
+      "label": "class with constructor",
+      "kind": 15,
+      "detail": "Class with constructor and methods",
+      "documentation": {
+        "value": "Full OOP class pattern with new, init, and methods.\n\n```lua\nlocal MyClass = {}\nMyClass.__index = MyClass\n\nfunction MyClass.new(name, value)\n    local self = setmetatable({}, MyClass)\n    self.name = name\n    self.value = value\n    return self\nend\n\nfunction MyClass:getName()\n    return self.name\nend\n```"
+      },
+      "insertText": "local ${1:MyClass} = {}\n$1.__index = $1\n\nfunction $1.new(${2:args})\n\tlocal self = setmetatable({}, $1)\n\t${3:self.field = args}\n\treturn self\nend\n\nfunction $1:${4:method}()\n\t$0\nend",
+      "insertTextRules": 4,
+      "sortText": "00_class_with_constructor"
+    },
     {
       "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```" },
+      "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"
@@ -14,79 +1215,196 @@
       "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```" },
+      "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\"\n```"
+      },
       "insertText": "type(${1:v})",
       "insertTextRules": 4,
       "sortText": "00_type"
     },
     {
-      "label": "tostring",
+      "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.\n\n```lua\ntostring(123)    -- \"123\"\ntostring(true)   -- \"true\"\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. An optional base (2–36) for string interpretation.\n\n```lua\ntonumber(\"42\")       -- 42\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",
+      "documentation": {
+        "value": "Returns an iterator function, the table, and `nil` for `for k, v in pairs(t) do ... end`.\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",
+      "documentation": {
+        "value": "Returns an iterator for integer keys 1, 2, ... until a nil value.\n\n```lua\nfor i, v in ipairs(list) do\n    print(i, v)\nend\n```"
+      },
+      "insertText": "ipairs(${1:t})",
+      "insertTextRules": 4,
+      "sortText": "00_ipairs"
+    },
+    {
+      "label": "next",
+      "kind": 1,
+      "detail": "Traverse table fields",
+      "documentation": {
+        "value": "Returns the next index and value. When called with nil, returns an initial index.\n\n```lua\nlocal k, v = next(t)\n```"
+      },
+      "insertText": "next(${1:table}${2:, ${3:index}})",
+      "insertTextRules": 4,
+      "sortText": "00_next"
+    },
+    {
+      "label": "select",
+      "kind": 1,
+      "detail": "Select arguments by position",
+      "documentation": {
+        "value": "If index is a number, returns all arguments after that index. If `\"#\"`, returns the count.\n\n```lua\nselect(2, \"a\", \"b\", \"c\")  -- \"b\", \"c\"\nselect(\"#\", \"a\", \"b\")     -- 2\n```"
+      },
+      "insertText": "select(${1:index}, ${2:...})",
+      "insertTextRules": 4,
+      "sortText": "00_select"
+    },
+    {
+      "label": "rawget",
+      "kind": 1,
+      "detail": "Get table value without __index",
+      "documentation": {
+        "value": "Gets `table[index]` without invoking the `__index` metamethod.\n\n```lua\nrawget(t, \"key\")\n```"
+      },
+      "insertText": "rawget(${1:table}, ${2:index})",
+      "insertTextRules": 4,
+      "sortText": "00_rawget"
+    },
+    {
+      "label": "rawset",
+      "kind": 1,
+      "detail": "Set table value without __newindex",
+      "documentation": {
+        "value": "Sets `table[index] = value` without invoking the `__newindex` metamethod.\n\n```lua\nrawset(t, \"key\", value)\n```"
+      },
+      "insertText": "rawset(${1:table}, ${2:index}, ${3:value})",
+      "insertTextRules": 4,
+      "sortText": "00_rawset"
+    },
+    {
+      "label": "rawequal",
+      "kind": 1,
+      "detail": "Equality without __eq",
+      "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": "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})",
+      "detail": "Length without __len (5.2+)",
+      "documentation": {
+        "value": "Returns the length of table or string without invoking the `__len` metamethod.\n\n```lua\nrawlen(t)\n```"
+      },
+      "insertText": "rawlen(${1:v})",
       "insertTextRules": 4,
-      "sortText": "00_tostring"
+      "sortText": "00_rawlen"
     },
     {
-      "label": "tonumber",
+      "label": "setmetatable",
       "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}})",
+      "detail": "Set metatable for a table",
+      "documentation": {
+        "value": "Sets the metatable for the given table. If metatable is nil, removes it.\n\n```lua\nsetmetatable(obj, { __index = proto })\n```"
+      },
+      "insertText": "setmetatable(${1:table}, ${2:metatable})",
       "insertTextRules": 4,
-      "sortText": "00_tonumber"
+      "sortText": "00_setmetatable"
     },
     {
-      "label": "pairs",
+      "label": "getmetatable",
       "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})",
+      "detail": "Get metatable of an object",
+      "documentation": {
+        "value": "Returns the metatable of the object, or nil if none. If __metatable is set, returns that value.\n\n```lua\nlocal mt = getmetatable(obj)\n```"
+      },
+      "insertText": "getmetatable(${1:object})",
       "insertTextRules": 4,
-      "sortText": "00_pairs"
+      "sortText": "00_getmetatable"
     },
     {
-      "label": "ipairs",
+      "label": "require",
       "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})",
+      "detail": "Load and cache a module",
+      "documentation": {
+        "value": "Loads the given module. Checks `package.loaded` first, then uses `package.searchers`.\n\n```lua\nlocal json = require(\"dkjson\")\n```"
+      },
+      "insertText": "require(\"${1:modname}\")",
       "insertTextRules": 4,
-      "sortText": "00_ipairs"
+      "sortText": "00_require"
     },
     {
-      "label": "next",
+      "label": "dofile",
       "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}})",
+      "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.\n\n```lua\ndofile(\"config.lua\")\n```"
+      },
+      "insertText": "dofile(\"${1:filename}\")",
       "insertTextRules": 4,
-      "sortText": "00_next"
+      "sortText": "00_dofile"
     },
     {
-      "label": "select",
+      "label": "loadfile",
       "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:...})",
+      "detail": "Load a Lua file without executing",
+      "documentation": {
+        "value": "Loads a file as a Lua chunk without executing it. Returns the chunk as a function.\n\n```lua\nlocal fn = loadfile(\"script.lua\")\n```"
+      },
+      "insertText": "loadfile(\"${1:filename}\"${2:, ${3:mode}${4:, ${5:env}}})",
       "insertTextRules": 4,
-      "sortText": "00_select"
+      "sortText": "00_loadfile"
     },
     {
-      "label": "unpack",
+      "label": "load",
       "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}}})",
+      "detail": "Load a chunk from string or function",
+      "documentation": {
+        "value": "Loads a chunk. If chunk is a string, loads it. If a function, calls it to get pieces.\n\n```lua\nlocal fn = load(\"return 42\")\nprint(fn()) -- 42\n```"
+      },
+      "insertText": "load(${1:chunk}${2:, ${3:chunkname}${4:, ${5:mode}${6:, ${7:env}}}})",
       "insertTextRules": 4,
-      "sortText": "00_unpack"
+      "sortText": "00_load"
     },
     {
       "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```" },
+      "detail": "Protected call",
+      "documentation": {
+        "value": "Calls function f in protected mode. Returns true + results on success, false + error on failure.\n\n```lua\nlocal ok, result = pcall(myFunc, arg1)\n```"
+      },
       "insertText": "pcall(${1:f}${2:, ${3:args}})",
       "insertTextRules": 4,
       "sortText": "00_pcall"
@@ -94,8 +1412,10 @@
     {
       "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." },
+      "detail": "Extended protected call",
+      "documentation": {
+        "value": "Like pcall but sets an error handler function.\n\n```lua\nlocal ok, result = xpcall(myFunc, debug.traceback, arg1)\n```"
+      },
       "insertText": "xpcall(${1:f}, ${2:msgh}${3:, ${4:args}})",
       "insertTextRules": 4,
       "sortText": "00_xpcall"
@@ -104,7 +1424,9 @@
       "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```" },
+      "documentation": {
+        "value": "Terminates the last protected call with the given message. Level controls error position.\n\n```lua\nerror(\"invalid input\", 2)\n```"
+      },
       "insertText": "error(${1:message}${2:, ${3:level}})",
       "insertTextRules": 4,
       "sortText": "00_error"
@@ -112,857 +1434,1201 @@
     {
       "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```" },
+      "detail": "Assert a condition",
+      "documentation": {
+        "value": "Raises error if value is false/nil, otherwise returns all arguments.\n\n```lua\nassert(x > 0, \"x must be positive\")\n```"
+      },
       "insertText": "assert(${1:v}${2:, ${3:message}})",
       "insertTextRules": 4,
       "sortText": "00_assert"
     },
     {
-      "label": "require",
+      "label": "collectgarbage",
       "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}\")",
+      "detail": "Control garbage collector",
+      "documentation": {
+        "value": "Generic interface to the GC. Options: \"collect\", \"stop\", \"restart\", \"count\", \"step\", etc.\n\n```lua\ncollectgarbage(\"collect\")\n```"
+      },
+      "insertText": "collectgarbage(\"${1:opt}\"${2:, ${3:arg}})",
       "insertTextRules": 4,
-      "sortText": "00_require"
+      "sortText": "00_collectgarbage"
     },
     {
-      "label": "dofile",
+      "label": "unpack",
       "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}\")",
+      "detail": "Unpack table elements (5.1)",
+      "documentation": {
+        "value": "Returns elements from the given table. In Lua 5.2+ use `table.unpack`.\n\n```lua\nlocal a, b, c = unpack({1, 2, 3})\n```"
+      },
+      "insertText": "unpack(${1:list}${2:, ${3:i}${4:, ${5:j}}})",
       "insertTextRules": 4,
-      "sortText": "00_dofile"
+      "sortText": "00_unpack"
     },
     {
-      "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}\")",
+      "label": "and",
+      "kind": 14,
+      "detail": "keyword and",
+      "documentation": {
+        "value": "Lua keyword `and`."
+      },
+      "insertText": "and",
       "insertTextRules": 4,
-      "sortText": "00_loadfile"
+      "sortText": "00_kw_and"
     },
     {
-      "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}}}})",
+      "label": "break",
+      "kind": 14,
+      "detail": "keyword break",
+      "documentation": {
+        "value": "Lua keyword `break`."
+      },
+      "insertText": "break",
       "insertTextRules": 4,
-      "sortText": "00_load"
+      "sortText": "00_kw_break"
     },
     {
-      "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})",
+      "label": "do",
+      "kind": 14,
+      "detail": "keyword do",
+      "documentation": {
+        "value": "Lua keyword `do`."
+      },
+      "insertText": "do",
       "insertTextRules": 4,
-      "sortText": "00_rawget"
+      "sortText": "00_kw_do"
     },
     {
-      "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})",
+      "label": "else",
+      "kind": 14,
+      "detail": "keyword else",
+      "documentation": {
+        "value": "Lua keyword `else`."
+      },
+      "insertText": "else",
       "insertTextRules": 4,
-      "sortText": "00_rawset"
+      "sortText": "00_kw_else"
     },
     {
-      "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})",
+      "label": "elseif",
+      "kind": 14,
+      "detail": "keyword elseif",
+      "documentation": {
+        "value": "Lua keyword `elseif`."
+      },
+      "insertText": "elseif",
       "insertTextRules": 4,
-      "sortText": "00_rawequal"
+      "sortText": "00_kw_elseif"
     },
     {
-      "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})",
+      "label": "end",
+      "kind": 14,
+      "detail": "keyword end",
+      "documentation": {
+        "value": "Lua keyword `end`."
+      },
+      "insertText": "end",
       "insertTextRules": 4,
-      "sortText": "00_rawlen"
+      "sortText": "00_kw_end"
     },
     {
-      "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})",
+      "label": "false",
+      "kind": 14,
+      "detail": "keyword false",
+      "documentation": {
+        "value": "Lua keyword `false`."
+      },
+      "insertText": "false",
       "insertTextRules": 4,
-      "sortText": "00_setmetatable"
+      "sortText": "00_kw_false"
     },
     {
-      "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})",
+      "label": "for",
+      "kind": 14,
+      "detail": "keyword for",
+      "documentation": {
+        "value": "Lua keyword `for`."
+      },
+      "insertText": "for",
       "insertTextRules": 4,
-      "sortText": "00_getmetatable"
+      "sortText": "00_kw_for"
     },
     {
-      "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}})",
+      "label": "function",
+      "kind": 14,
+      "detail": "keyword function",
+      "documentation": {
+        "value": "Lua keyword `function`."
+      },
+      "insertText": "function",
       "insertTextRules": 4,
-      "sortText": "00_collectgarbage"
+      "sortText": "00_kw_function"
     },
     {
-      "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})",
+      "label": "goto",
+      "kind": 14,
+      "detail": "keyword goto",
+      "documentation": {
+        "value": "Lua keyword `goto`."
+      },
+      "insertText": "goto",
       "insertTextRules": 4,
-      "sortText": "01_string.format"
+      "sortText": "00_kw_goto"
     },
     {
-      "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}}})",
+      "label": "if",
+      "kind": 14,
+      "detail": "keyword if",
+      "documentation": {
+        "value": "Lua keyword `if`."
+      },
+      "insertText": "if",
       "insertTextRules": 4,
-      "sortText": "01_string.find"
+      "sortText": "00_kw_if"
     },
     {
-      "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}})",
+      "label": "in",
+      "kind": 14,
+      "detail": "keyword in",
+      "documentation": {
+        "value": "Lua keyword `in`."
+      },
+      "insertText": "in",
       "insertTextRules": 4,
-      "sortText": "01_string.match"
+      "sortText": "00_kw_in"
     },
     {
-      "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}\")",
+      "label": "local",
+      "kind": 14,
+      "detail": "keyword local",
+      "documentation": {
+        "value": "Lua keyword `local`."
+      },
+      "insertText": "local",
       "insertTextRules": 4,
-      "sortText": "01_string.gmatch"
+      "sortText": "00_kw_local"
     },
     {
-      "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}})",
+      "label": "nil",
+      "kind": 14,
+      "detail": "keyword nil",
+      "documentation": {
+        "value": "Lua keyword `nil`."
+      },
+      "insertText": "nil",
       "insertTextRules": 4,
-      "sortText": "01_string.gsub"
+      "sortText": "00_kw_nil"
     },
     {
-      "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}})",
+      "label": "not",
+      "kind": 14,
+      "detail": "keyword not",
+      "documentation": {
+        "value": "Lua keyword `not`."
+      },
+      "insertText": "not",
       "insertTextRules": 4,
-      "sortText": "01_string.sub"
+      "sortText": "00_kw_not"
     },
     {
-      "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}})",
+      "label": "or",
+      "kind": 14,
+      "detail": "keyword or",
+      "documentation": {
+        "value": "Lua keyword `or`."
+      },
+      "insertText": "or",
       "insertTextRules": 4,
-      "sortText": "01_string.rep"
+      "sortText": "00_kw_or"
     },
     {
-      "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})",
+      "label": "repeat",
+      "kind": 14,
+      "detail": "keyword repeat",
+      "documentation": {
+        "value": "Lua keyword `repeat`."
+      },
+      "insertText": "repeat",
       "insertTextRules": 4,
-      "sortText": "01_string.reverse"
+      "sortText": "00_kw_repeat"
     },
     {
-      "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})",
+      "label": "return",
+      "kind": 14,
+      "detail": "keyword return",
+      "documentation": {
+        "value": "Lua keyword `return`."
+      },
+      "insertText": "return",
       "insertTextRules": 4,
-      "sortText": "01_string.upper"
+      "sortText": "00_kw_return"
     },
     {
-      "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})",
+      "label": "then",
+      "kind": 14,
+      "detail": "keyword then",
+      "documentation": {
+        "value": "Lua keyword `then`."
+      },
+      "insertText": "then",
       "insertTextRules": 4,
-      "sortText": "01_string.lower"
+      "sortText": "00_kw_then"
     },
     {
-      "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})",
+      "label": "true",
+      "kind": 14,
+      "detail": "keyword true",
+      "documentation": {
+        "value": "Lua keyword `true`."
+      },
+      "insertText": "true",
       "insertTextRules": 4,
-      "sortText": "01_string.len"
+      "sortText": "00_kw_true"
     },
     {
-      "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}}})",
+      "label": "until",
+      "kind": 14,
+      "detail": "keyword until",
+      "documentation": {
+        "value": "Lua keyword `until`."
+      },
+      "insertText": "until",
       "insertTextRules": 4,
-      "sortText": "01_string.byte"
+      "sortText": "00_kw_until"
     },
     {
-      "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:...})",
+      "label": "while",
+      "kind": 14,
+      "detail": "keyword while",
+      "documentation": {
+        "value": "Lua keyword `while`."
+      },
+      "insertText": "while",
       "insertTextRules": 4,
-      "sortText": "01_string.char"
+      "sortText": "00_kw_while"
     },
     {
-      "label": "string.dump",
+      "label": "string",
+      "kind": 9,
+      "detail": "string library",
+      "documentation": {
+        "value": "The Lua `string` standard library module."
+      },
+      "insertText": "string",
+      "insertTextRules": 4,
+      "sortText": "01_string"
+    },
+    {
+      "label": "table",
+      "kind": 9,
+      "detail": "table library",
+      "documentation": {
+        "value": "The Lua `table` standard library module."
+      },
+      "insertText": "table",
+      "insertTextRules": 4,
+      "sortText": "01_table"
+    },
+    {
+      "label": "math",
+      "kind": 9,
+      "detail": "math library",
+      "documentation": {
+        "value": "The Lua `math` standard library module."
+      },
+      "insertText": "math",
+      "insertTextRules": 4,
+      "sortText": "01_math"
+    },
+    {
+      "label": "io",
+      "kind": 9,
+      "detail": "io library",
+      "documentation": {
+        "value": "The Lua `io` standard library module."
+      },
+      "insertText": "io",
+      "insertTextRules": 4,
+      "sortText": "01_io"
+    },
+    {
+      "label": "os",
+      "kind": 9,
+      "detail": "os library",
+      "documentation": {
+        "value": "The Lua `os` standard library module."
+      },
+      "insertText": "os",
+      "insertTextRules": 4,
+      "sortText": "01_os"
+    },
+    {
+      "label": "coroutine",
+      "kind": 9,
+      "detail": "coroutine library",
+      "documentation": {
+        "value": "The Lua `coroutine` standard library module."
+      },
+      "insertText": "coroutine",
+      "insertTextRules": 4,
+      "sortText": "01_coroutine"
+    },
+    {
+      "label": "debug",
+      "kind": 9,
+      "detail": "debug library",
+      "documentation": {
+        "value": "The Lua `debug` standard library module."
+      },
+      "insertText": "debug",
+      "insertTextRules": 4,
+      "sortText": "01_debug"
+    },
+    {
+      "label": "package",
+      "kind": 9,
+      "detail": "package library",
+      "documentation": {
+        "value": "The Lua `package` standard library module."
+      },
+      "insertText": "package",
+      "insertTextRules": 4,
+      "sortText": "01_package"
+    },
+    {
+      "label": "utf8",
+      "kind": 9,
+      "detail": "utf8 library",
+      "documentation": {
+        "value": "The Lua `utf8` standard library module."
+      },
+      "insertText": "utf8",
+      "insertTextRules": 4,
+      "sortText": "01_utf8"
+    },
+    {
+      "label": "warn",
       "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}})",
+      "detail": "Issue a warning message (Lua 5.4+)",
+      "documentation": {
+        "value": "Issue a warning message.\n\n```lua\nwarn(\"something suspicious\")\nwarn(\"@on\") -- enable warnings\nwarn(\"@off\") -- disable warnings\n```"
+      },
+      "insertText": "warn(${1:msg})",
+      "insertTextRules": 4,
+      "sortText": "01_warn"
+    },
+    {
+      "label": "metatable __sub",
+      "kind": 15,
+      "detail": "Subtraction metamethod",
+      "documentation": {
+        "value": "Subtraction metamethod.\n\n```lua\nmetatable.__sub = function(a, b)\n\treturn a - b\nend\n```"
+      },
+      "insertText": "metatable.__sub = function(a, b)\n\t${0:return a - b}\nend",
+      "insertTextRules": 4,
+      "sortText": "04_metatable___sub"
+    },
+    {
+      "label": "metatable __mul",
+      "kind": 15,
+      "detail": "Multiplication metamethod",
+      "documentation": {
+        "value": "Multiplication metamethod.\n\n```lua\nmetatable.__mul = function(a, b)\n\treturn a * b\nend\n```"
+      },
+      "insertText": "metatable.__mul = function(a, b)\n\t${0:return a * b}\nend",
+      "insertTextRules": 4,
+      "sortText": "04_metatable___mul"
+    },
+    {
+      "label": "metatable __div",
+      "kind": 15,
+      "detail": "Division metamethod",
+      "documentation": {
+        "value": "Division metamethod.\n\n```lua\nmetatable.__div = function(a, b)\n\treturn a / b\nend\n```"
+      },
+      "insertText": "metatable.__div = function(a, b)\n\t${0:return a / b}\nend",
+      "insertTextRules": 4,
+      "sortText": "04_metatable___div"
+    },
+    {
+      "label": "metatable __mod",
+      "kind": 15,
+      "detail": "Modulo metamethod",
+      "documentation": {
+        "value": "Modulo metamethod.\n\n```lua\nmetatable.__mod = function(a, b)\n\treturn a % b\nend\n```"
+      },
+      "insertText": "metatable.__mod = function(a, b)\n\t${0:return a % b}\nend",
+      "insertTextRules": 4,
+      "sortText": "04_metatable___mod"
+    },
+    {
+      "label": "metatable __pow",
+      "kind": 15,
+      "detail": "Exponentiation metamethod",
+      "documentation": {
+        "value": "Exponentiation metamethod.\n\n```lua\nmetatable.__pow = function(a, b)\n\treturn a ^ b\nend\n```"
+      },
+      "insertText": "metatable.__pow = function(a, b)\n\t${0:return a ^ b}\nend",
+      "insertTextRules": 4,
+      "sortText": "04_metatable___pow"
+    },
+    {
+      "label": "metatable __unm",
+      "kind": 15,
+      "detail": "Unary minus metamethod",
+      "documentation": {
+        "value": "Unary minus metamethod.\n\n```lua\nmetatable.__unm = function(a)\n\treturn -a\nend\n```"
+      },
+      "insertText": "metatable.__unm = function(a)\n\t${0:return -a}\nend",
+      "insertTextRules": 4,
+      "sortText": "04_metatable___unm"
+    },
+    {
+      "label": "metatable __le",
+      "kind": 15,
+      "detail": "Less-than-or-equal metamethod",
+      "documentation": {
+        "value": "Less-than-or-equal metamethod.\n\n```lua\nmetatable.__le = function(a, b)\n\treturn a <= b\nend\n```"
+      },
+      "insertText": "metatable.__le = function(a, b)\n\t${0:return a <= b}\nend",
+      "insertTextRules": 4,
+      "sortText": "04_metatable___le"
+    },
+    {
+      "label": "metatable __close",
+      "kind": 15,
+      "detail": "To-be-closed metamethod (5.4)",
+      "documentation": {
+        "value": "To-be-closed metamethod (5.4).\n\n```lua\nmetatable.__close = function(obj, err)\n\t-- cleanup\nend\n```"
+      },
+      "insertText": "metatable.__close = function(obj, err)\n\t${0:-- cleanup}\nend",
+      "insertTextRules": 4,
+      "sortText": "04_metatable___close"
+    },
+    {
+      "label": "metatable __metatable",
+      "kind": 15,
+      "detail": "Metatable protection",
+      "documentation": {
+        "value": "Metatable protection.\n\n```lua\nmetatable.__metatable = \"protected\"\n```"
+      },
+      "insertText": "metatable.__metatable = ${0:\"protected\"}",
       "insertTextRules": 4,
-      "sortText": "01_string.dump"
+      "sortText": "04_metatable___metatable"
     },
     {
       "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})",
+      "kind": 15,
+      "detail": "Insert element into table",
+      "documentation": {
+        "value": "Insert element into table.\n\n```lua\nlocal t = {1,2,3}\ntable.insert(t, 4) -- {1,2,3,4}\ntable.insert(t, 1, 0) -- {0,1,2,3,4}\n```"
+      },
+      "insertText": "table.insert(${1:t}, ${2:value})",
       "insertTextRules": 4,
-      "sortText": "02_table.insert"
+      "sortText": "05_table_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}})",
+      "kind": 15,
+      "detail": "Remove element from table",
+      "documentation": {
+        "value": "Remove element from table.\n\n```lua\nlocal t = {1,2,3}\nlocal v = table.remove(t, 2) -- v=2, t={1,3}\ntable.remove(t) -- removes last\n```"
+      },
+      "insertText": "table.remove(${1:t}, ${2:pos})",
       "insertTextRules": 4,
-      "sortText": "02_table.remove"
+      "sortText": "05_table_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}})",
+      "kind": 15,
+      "detail": "Sort table in-place",
+      "documentation": {
+        "value": "Sort table in-place.\n\n```lua\nlocal t = {3,1,2}\ntable.sort(t) -- {1,2,3}\ntable.sort(t, function(a,b) return a > b end) -- {3,2,1}\n```"
+      },
+      "insertText": "table.sort(${1:t}, ${2:function(a, b) return a < b end})",
       "insertTextRules": 4,
-      "sortText": "02_table.sort"
+      "sortText": "05_table_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}}}})",
+      "kind": 15,
+      "detail": "Concatenate table elements into string",
+      "documentation": {
+        "value": "Concatenate table elements into string.\n\n```lua\nlocal t = {'a','b','c'}\nprint(table.concat(t, ',')) -- a,b,c\nprint(table.concat(t, ', ', 2, 3)) -- b, c\n```"
+      },
+      "insertText": "table.concat(${1:t}, ${2:sep})",
       "insertTextRules": 4,
-      "sortText": "02_table.concat"
+      "sortText": "05_table_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}})",
+      "kind": 15,
+      "detail": "Move elements between tables (5.3+)",
+      "documentation": {
+        "value": "Move elements between tables (5.3+).\n\n```lua\nlocal src = {1,2,3,4,5}\nlocal dst = {}\ntable.move(src, 2, 4, 1, dst) -- dst = {2,3,4}\n```"
+      },
+      "insertText": "table.move(${1:a1}, ${2:f}, ${3:e}, ${4:t}, ${5:a2})",
       "insertTextRules": 4,
-      "sortText": "02_table.move"
+      "sortText": "05_table_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." },
+      "kind": 15,
+      "detail": "Pack arguments into a table with .n field",
+      "documentation": {
+        "value": "Pack arguments into a table with .n field.\n\n```lua\nlocal t = table.pack(1,2,3) -- {1,2,3, n=3}\nprint(t.n) -- 3\n```"
+      },
       "insertText": "table.pack(${1:...})",
       "insertTextRules": 4,
-      "sortText": "02_table.pack"
+      "sortText": "05_table_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}}})",
+      "kind": 15,
+      "detail": "Unpack table to multiple values",
+      "documentation": {
+        "value": "Unpack table to multiple values.\n\n```lua\nlocal t = {10,20,30}\nprint(table.unpack(t)) -- 10 20 30\nprint(table.unpack(t, 2, 3)) -- 20 30\n```"
+      },
+      "insertText": "table.unpack(${1:t}, ${2:i}, ${3:j})",
       "insertTextRules": 4,
-      "sortText": "02_table.unpack"
+      "sortText": "05_table_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})",
+      "label": "string.sub",
+      "kind": 15,
+      "detail": "Extract substring",
+      "documentation": {
+        "value": "Extract substring.\n\n```lua\nlocal s = 'hello world'\nprint(string.sub(s, 1, 5)) -- hello\nprint(string.sub(s, -5)) -- world\n```"
+      },
+      "insertText": "string.sub(${1:s}, ${2:i}, ${3:j})",
       "insertTextRules": 4,
-      "sortText": "03_math.abs"
+      "sortText": "05_string_string.sub"
     },
     {
-      "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})",
+      "label": "string.rep",
+      "kind": 15,
+      "detail": "Repeat string n times",
+      "documentation": {
+        "value": "Repeat string n times.\n\n```lua\nprint(string.rep('ab', 3)) -- ababab\nprint(string.rep('ab', 3, ',')) -- ab,ab,ab\n```"
+      },
+      "insertText": "string.rep(${1:s}, ${2:n}, ${3:sep})",
       "insertTextRules": 4,
-      "sortText": "03_math.ceil"
+      "sortText": "05_string_string.rep"
     },
     {
-      "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})",
+      "label": "string.reverse",
+      "kind": 15,
+      "detail": "Reverse a string",
+      "documentation": {
+        "value": "Reverse a string.\n\n```lua\nprint(string.reverse('hello')) -- olleh\n```"
+      },
+      "insertText": "string.reverse(${1:s})",
       "insertTextRules": 4,
-      "sortText": "03_math.floor"
+      "sortText": "05_string_string.reverse"
     },
     {
-      "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:...})",
+      "label": "string.upper",
+      "kind": 15,
+      "detail": "Convert to uppercase",
+      "documentation": {
+        "value": "Convert to uppercase.\n\n```lua\nprint(string.upper('hello')) -- HELLO\n```"
+      },
+      "insertText": "string.upper(${1:s})",
       "insertTextRules": 4,
-      "sortText": "03_math.max"
+      "sortText": "05_string_string.upper"
     },
     {
-      "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:...})",
+      "label": "string.lower",
+      "kind": 15,
+      "detail": "Convert to lowercase",
+      "documentation": {
+        "value": "Convert to lowercase.\n\n```lua\nprint(string.lower('HELLO')) -- hello\n```"
+      },
+      "insertText": "string.lower(${1:s})",
       "insertTextRules": 4,
-      "sortText": "03_math.min"
+      "sortText": "05_string_string.lower"
     },
     {
-      "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})",
+      "label": "string.len",
+      "kind": 15,
+      "detail": "Get string length in bytes",
+      "documentation": {
+        "value": "Get string length in bytes.\n\n```lua\nprint(string.len('hello')) -- 5\nprint(#'hello') -- 5 (operator shorthand)\n```"
+      },
+      "insertText": "string.len(${1:s})",
       "insertTextRules": 4,
-      "sortText": "03_math.sqrt"
+      "sortText": "05_string_string.len"
     },
     {
-      "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}})",
+      "label": "string.byte",
+      "kind": 15,
+      "detail": "Get byte values of characters",
+      "documentation": {
+        "value": "Get byte values of characters.\n\n```lua\nprint(string.byte('A')) -- 65\nprint(string.byte('abc', 1, 3)) -- 97 98 99\n```"
+      },
+      "insertText": "string.byte(${1:s}, ${2:i}, ${3:j})",
       "insertTextRules": 4,
-      "sortText": "03_math.random"
+      "sortText": "05_string_string.byte"
     },
     {
-      "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})",
+      "label": "string.char",
+      "kind": 15,
+      "detail": "Convert byte values to characters",
+      "documentation": {
+        "value": "Convert byte values to characters.\n\n```lua\nprint(string.char(72,101,108,108,111)) -- Hello\n```"
+      },
+      "insertText": "string.char(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "05_string_string.char"
+    },
+    {
+      "label": "string.dump",
+      "kind": 15,
+      "detail": "Dump function as binary string",
+      "documentation": {
+        "value": "Dump function as binary string.\n\n```lua\nlocal f = function() return 42 end\nlocal s = string.dump(f)\nlocal f2 = load(s)\nprint(f2()) -- 42\n```"
+      },
+      "insertText": "string.dump(${1:func}, ${2:strip})",
+      "insertTextRules": 4,
+      "sortText": "05_string_string.dump"
+    },
+    {
+      "label": "string.packsize",
+      "kind": 15,
+      "detail": "Get packed size for format string (5.3+)",
+      "documentation": {
+        "value": "Get packed size for format string (5.3+).\n\n```lua\nprint(string.packsize('ii')) -- 8 (two ints)\nprint(string.packsize('Bs4')) -- varies\n```"
+      },
+      "insertText": "string.packsize(${1:fmt})",
+      "insertTextRules": 4,
+      "sortText": "05_string_string.packsize"
+    },
+    {
+      "label": "math.abs",
+      "kind": 15,
+      "detail": "Absolute value",
+      "documentation": {
+        "value": "Absolute value.\n\n```lua\nprint(math.abs(-5)) -- 5\n```"
+      },
+      "insertText": "math.abs(${1:x})",
       "insertTextRules": 4,
-      "sortText": "03_math.randomseed"
+      "sortText": "05_math_math.abs"
     },
     {
-      "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.ceil",
+      "kind": 15,
+      "detail": "Round up to integer",
+      "documentation": {
+        "value": "Round up to integer.\n\n```lua\nprint(math.ceil(3.2)) -- 4\n```"
+      },
+      "insertText": "math.ceil(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "05_math_math.ceil"
     },
     {
-      "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.sqrt",
+      "kind": 15,
+      "detail": "Square root",
+      "documentation": {
+        "value": "Square root.\n\n```lua\nprint(math.sqrt(16)) -- 4.0\n```"
+      },
+      "insertText": "math.sqrt(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "05_math_math.sqrt"
     },
     {
       "label": "math.sin",
-      "kind": 1,
+      "kind": 15,
       "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```" },
+      "documentation": {
+        "value": "Sine (radians).\n\n```lua\nprint(math.sin(math.pi/2)) -- 1.0\n```"
+      },
       "insertText": "math.sin(${1:x})",
       "insertTextRules": 4,
-      "sortText": "03_math.sin"
+      "sortText": "05_math_math.sin"
     },
     {
       "label": "math.cos",
-      "kind": 1,
+      "kind": 15,
       "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```" },
+      "documentation": {
+        "value": "Cosine (radians).\n\n```lua\nprint(math.cos(0)) -- 1.0\n```"
+      },
       "insertText": "math.cos(${1:x})",
       "insertTextRules": 4,
-      "sortText": "03_math.cos"
+      "sortText": "05_math_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}})",
+      "label": "math.tan",
+      "kind": 15,
+      "detail": "Tangent (radians)",
+      "documentation": {
+        "value": "Tangent (radians).\n\n```lua\nprint(math.tan(math.pi/4)) -- ~1.0\n```"
+      },
+      "insertText": "math.tan(${1:x})",
       "insertTextRules": 4,
-      "sortText": "03_math.log"
+      "sortText": "05_math_math.tan"
     },
     {
       "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```" },
+      "kind": 15,
+      "detail": "e^x",
+      "documentation": {
+        "value": "e^x.\n\n```lua\nprint(math.exp(1)) -- 2.718...\n```"
+      },
       "insertText": "math.exp(${1:x})",
       "insertTextRules": 4,
-      "sortText": "03_math.exp"
+      "sortText": "05_math_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}\")",
+      "label": "math.log",
+      "kind": 15,
+      "detail": "Logarithm (natural or custom base)",
+      "documentation": {
+        "value": "Logarithm (natural or custom base).\n\n```lua\nprint(math.log(math.exp(1))) -- 1.0\nprint(math.log(100, 10)) -- 2.0\n```"
+      },
+      "insertText": "math.log(${1:x}, ${2:base})",
       "insertTextRules": 4,
-      "sortText": "04_io.open"
+      "sortText": "05_math_math.log"
     },
     {
-      "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}\")",
+      "label": "math.fmod",
+      "kind": 15,
+      "detail": "Float modulo",
+      "documentation": {
+        "value": "Float modulo.\n\n```lua\nprint(math.fmod(7, 3)) -- 1.0\n```"
+      },
+      "insertText": "math.fmod(${1:x}, ${2:y})",
       "insertTextRules": 4,
-      "sortText": "04_io.read"
+      "sortText": "05_math_math.fmod"
     },
     {
-      "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})",
+      "label": "math.tointeger",
+      "kind": 15,
+      "detail": "Convert to integer or nil (5.3+)",
+      "documentation": {
+        "value": "Convert to integer or nil (5.3+).\n\n```lua\nprint(math.tointeger(5.0)) -- 5\nprint(math.tointeger(5.5)) -- nil\n```"
+      },
+      "insertText": "math.tointeger(${1:x})",
       "insertTextRules": 4,
-      "sortText": "04_io.write"
+      "sortText": "05_math_math.tointeger"
     },
     {
-      "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})",
+      "label": "math.randomseed",
+      "kind": 15,
+      "detail": "Set random seed",
+      "documentation": {
+        "value": "Set random seed.\n\n```lua\nmath.randomseed(os.time())\nprint(math.random(1, 100))\n```"
+      },
+      "insertText": "math.randomseed(${1:seed})",
       "insertTextRules": 4,
-      "sortText": "04_io.close"
+      "sortText": "05_math_math.randomseed"
     },
     {
-      "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}\")",
+      "label": "io.flush",
+      "kind": 15,
+      "detail": "Flush default output",
+      "documentation": {
+        "value": "Flush default output.\n\n```lua\nio.write('buffered')\nio.flush() -- force write\n```"
+      },
+      "insertText": "io.flush()",
       "insertTextRules": 4,
-      "sortText": "04_io.lines"
+      "sortText": "05_io_io.flush"
     },
     {
-      "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:})",
+      "label": "io.input",
+      "kind": 15,
+      "detail": "Set/get default input file",
+      "documentation": {
+        "value": "Set/get default input file.\n\n```lua\nio.input('data.txt')\nlocal content = io.read('*a')\n```"
+      },
+      "insertText": "io.input(${1:file})",
       "insertTextRules": 4,
-      "sortText": "05_os.time"
+      "sortText": "05_io_io.input"
     },
     {
-      "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}})",
+      "label": "io.output",
+      "kind": 15,
+      "detail": "Set/get default output file",
+      "documentation": {
+        "value": "Set/get default output file.\n\n```lua\nio.output('out.txt')\nio.write('hello')\n```"
+      },
+      "insertText": "io.output(${1:file})",
       "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"
+      "sortText": "05_io_io.output"
     },
     {
-      "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}\")",
+      "label": "io.tmpfile",
+      "kind": 15,
+      "detail": "Create temporary file",
+      "documentation": {
+        "value": "Create temporary file.\n\n```lua\nlocal f = io.tmpfile()\nf:write('temp data')\nf:seek('set')\nprint(f:read('*a'))\n```"
+      },
+      "insertText": "io.tmpfile()",
       "insertTextRules": 4,
-      "sortText": "05_os.execute"
+      "sortText": "05_io_io.tmpfile"
     },
     {
-      "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}\")",
+      "label": "io.type",
+      "kind": 15,
+      "detail": "Check file handle type",
+      "documentation": {
+        "value": "Check file handle type.\n\n```lua\nlocal f = io.open('test.txt')\nprint(io.type(f)) -- 'file'\nf:close()\nprint(io.type(f)) -- 'closed file'\n```"
+      },
+      "insertText": "io.type(${1:obj})",
       "insertTextRules": 4,
-      "sortText": "05_os.getenv"
+      "sortText": "05_io_io.type"
     },
     {
-      "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}\")",
+      "label": "io.popen",
+      "kind": 15,
+      "detail": "Execute command and get pipe",
+      "documentation": {
+        "value": "Execute command and get pipe.\n\n```lua\nlocal f = io.popen('ls', 'r')\nlocal output = f:read('*a')\nf:close()\n```"
+      },
+      "insertText": "io.popen(${1:cmd}, ${2:mode})",
       "insertTextRules": 4,
-      "sortText": "05_os.rename"
+      "sortText": "05_io_io.popen"
     },
     {
-      "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}\")",
+      "label": "os.getenv",
+      "kind": 15,
+      "detail": "Get environment variable",
+      "documentation": {
+        "value": "Get environment variable.\n\n```lua\nlocal home = os.getenv('HOME')\nlocal path = os.getenv('PATH')\n```"
+      },
+      "insertText": "os.getenv(${1:varname})",
       "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"
+      "sortText": "05_os_os.getenv"
     },
     {
       "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})",
+      "kind": 15,
+      "detail": "Exit the program",
+      "documentation": {
+        "value": "Exit the program.\n\n```lua\nos.exit(0) -- success\nos.exit(1) -- failure\nos.exit(true, true) -- close Lua state\n```"
+      },
+      "insertText": "os.exit(${1:code}, ${2:close})",
       "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"
+      "sortText": "05_os_os.exit"
     },
     {
-      "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": "os.remove",
+      "kind": 15,
+      "detail": "Remove a file",
+      "documentation": {
+        "value": "Remove a file.\n\n```lua\nlocal ok, err = os.remove('temp.txt')\nif not ok then print(err) end\n```"
+      },
+      "insertText": "os.remove(${1:filename})",
+      "insertTextRules": 4,
+      "sortText": "05_os_os.remove"
     },
     {
-      "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": "os.rename",
+      "kind": 15,
+      "detail": "Rename a file",
+      "documentation": {
+        "value": "Rename a file.\n\n```lua\nos.rename('old.txt', 'new.txt')\n```"
+      },
+      "insertText": "os.rename(${1:oldname}, ${2:newname})",
+      "insertTextRules": 4,
+      "sortText": "05_os_os.rename"
     },
     {
-      "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": "os.difftime",
+      "kind": 15,
+      "detail": "Difference in seconds between two times",
+      "documentation": {
+        "value": "Difference in seconds between two times.\n\n```lua\nlocal t1 = os.time()\n-- ... work ...\nlocal t2 = os.time()\nprint(os.difftime(t2, t1) .. ' seconds')\n```"
+      },
+      "insertText": "os.difftime(${1:t2}, ${2:t1})",
+      "insertTextRules": 4,
+      "sortText": "05_os_os.difftime"
     },
     {
-      "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": "os.tmpname",
+      "kind": 15,
+      "detail": "Generate temporary filename",
+      "documentation": {
+        "value": "Generate temporary filename.\n\n```lua\nlocal tmp = os.tmpname()\nprint(tmp) -- e.g. /tmp/lua_XXXXX\n```"
+      },
+      "insertText": "os.tmpname()",
+      "insertTextRules": 4,
+      "sortText": "05_os_os.tmpname"
     },
     {
-      "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": "coroutine.status",
+      "kind": 15,
+      "detail": "Get coroutine status",
+      "documentation": {
+        "value": "Get coroutine status.\n\n```lua\nlocal co = coroutine.create(function() end)\nprint(coroutine.status(co)) -- 'suspended'\n```"
+      },
+      "insertText": "coroutine.status(${1:co})",
+      "insertTextRules": 4,
+      "sortText": "05_coroutine_coroutine.status"
     },
     {
-      "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": "coroutine.isyieldable",
+      "kind": 15,
+      "detail": "Check if current coroutine can yield",
+      "documentation": {
+        "value": "Check if current coroutine can yield.\n\n```lua\nprint(coroutine.isyieldable()) -- false (main thread)\n```"
+      },
+      "insertText": "coroutine.isyieldable()",
+      "insertTextRules": 4,
+      "sortText": "05_coroutine_coroutine.isyieldable"
     },
     {
-      "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": "coroutine.running",
+      "kind": 15,
+      "detail": "Get running coroutine and main thread flag",
+      "documentation": {
+        "value": "Get running coroutine and main thread flag.\n\n```lua\nlocal co, main = coroutine.running()\nprint(main) -- true if main thread\n```"
+      },
+      "insertText": "coroutine.running()",
+      "insertTextRules": 4,
+      "sortText": "05_coroutine_coroutine.running"
     },
     {
-      "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": "coroutine.close",
+      "kind": 15,
+      "detail": "Close a coroutine (5.4+)",
+      "documentation": {
+        "value": "Close a coroutine (5.4+).\n\n```lua\nlocal co = coroutine.create(function() coroutine.yield() end)\ncoroutine.resume(co)\ncoroutine.close(co)\n```"
+      },
+      "insertText": "coroutine.close(${1:co})",
+      "insertTextRules": 4,
+      "sortText": "05_coroutine_coroutine.close"
     },
     {
-      "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": "debug.sethook",
+      "kind": 15,
+      "detail": "Set debug hook",
+      "documentation": {
+        "value": "Set debug hook.\n\n```lua\ndebug.sethook(function(event, line)\n  print(event, line)\nend, 'l') -- line hook\n```"
+      },
+      "insertText": "debug.sethook(${1:hook}, ${2:mask}, ${3:count})",
+      "insertTextRules": 4,
+      "sortText": "05_debug_debug.sethook"
     },
     {
-      "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": "debug.getlocal",
+      "kind": 15,
+      "detail": "Get local variable name and value",
+      "documentation": {
+        "value": "Get local variable name and value.\n\n```lua\nlocal x = 42\nprint(debug.getlocal(1, 1)) -- 'x', 42\n```"
+      },
+      "insertText": "debug.getlocal(${1:level}, ${2:local_idx})",
+      "insertTextRules": 4,
+      "sortText": "05_debug_debug.getlocal"
     },
     {
-      "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": "debug.setlocal",
+      "kind": 15,
+      "detail": "Set local variable value",
+      "documentation": {
+        "value": "Set local variable value.\n\n```lua\n-- Modify local in running function\ndebug.setlocal(1, 1, 'new_value')\n```"
+      },
+      "insertText": "debug.setlocal(${1:level}, ${2:local_idx}, ${3:value})",
+      "insertTextRules": 4,
+      "sortText": "05_debug_debug.setlocal"
     },
     {
-      "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": "debug.getupvalue",
+      "kind": 15,
+      "detail": "Get upvalue name and value",
+      "documentation": {
+        "value": "Get upvalue name and value.\n\n```lua\nlocal x = 10\nlocal f = function() return x end\nprint(debug.getupvalue(f, 1)) -- 'x', 10\n```"
+      },
+      "insertText": "debug.getupvalue(${1:f}, ${2:up})",
+      "insertTextRules": 4,
+      "sortText": "05_debug_debug.getupvalue"
     },
     {
-      "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": "debug.setupvalue",
+      "kind": 15,
+      "detail": "Set upvalue value",
+      "documentation": {
+        "value": "Set upvalue value.\n\n```lua\nlocal x = 10\nlocal f = function() return x end\ndebug.setupvalue(f, 1, 20)\n```"
+      },
+      "insertText": "debug.setupvalue(${1:f}, ${2:up}, ${3:value})",
+      "insertTextRules": 4,
+      "sortText": "05_debug_debug.setupvalue"
     },
     {
-      "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": "debug.getmetatable",
+      "kind": 15,
+      "detail": "Get metatable (bypasses __metatable)",
+      "documentation": {
+        "value": "Get metatable (bypasses __metatable).\n\n```lua\nlocal mt = debug.getmetatable(obj) -- ignores __metatable\n```"
+      },
+      "insertText": "debug.getmetatable(${1:obj})",
+      "insertTextRules": 4,
+      "sortText": "05_debug_debug.getmetatable"
     },
     {
-      "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": "debug.setmetatable",
+      "kind": 15,
+      "detail": "Set metatable on any value",
+      "documentation": {
+        "value": "Set metatable on any value.\n\n```lua\ndebug.setmetatable(obj, mt)\n```"
+      },
+      "insertText": "debug.setmetatable(${1:obj}, ${2:mt})",
+      "insertTextRules": 4,
+      "sortText": "05_debug_debug.setmetatable"
     },
     {
-      "label": "true",
-      "kind": 14,
-      "detail": "Boolean true keyword",
-      "documentation": { "value": "The boolean value `true`." },
-      "insertText": "true",
-      "insertTextRules": 0,
-      "sortText": "06_true"
+      "label": "debug.getuservalue",
+      "kind": 15,
+      "detail": "Get userdata value",
+      "documentation": {
+        "value": "Get userdata value.\n\n```lua\nlocal val = debug.getuservalue(ud, 1)\n```"
+      },
+      "insertText": "debug.getuservalue(${1:u}, ${2:n})",
+      "insertTextRules": 4,
+      "sortText": "05_debug_debug.getuservalue"
     },
     {
-      "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": "debug.setuservalue",
+      "kind": 15,
+      "detail": "Set userdata value",
+      "documentation": {
+        "value": "Set userdata value.\n\n```lua\ndebug.setuservalue(ud, myvalue, 1)\n```"
+      },
+      "insertText": "debug.setuservalue(${1:u}, ${2:value}, ${3:n})",
+      "insertTextRules": 4,
+      "sortText": "05_debug_debug.setuservalue"
     },
     {
-      "label": "function definition",
+      "label": "utf8.char",
       "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",
+      "detail": "Create UTF-8 string from codepoints",
+      "documentation": {
+        "value": "Create UTF-8 string from codepoints.\n\n```lua\nprint(utf8.char(72,233,108,108,244)) -- Héllô\n```"
+      },
+      "insertText": "utf8.char(${1:...})",
       "insertTextRules": 4,
-      "sortText": "07_function_definition"
+      "sortText": "05_utf8_utf8.char"
     },
     {
-      "label": "local function",
+      "label": "utf8.codepoint",
       "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",
+      "detail": "Get codepoints from UTF-8 string",
+      "documentation": {
+        "value": "Get codepoints from UTF-8 string.\n\n```lua\nprint(utf8.codepoint('é', 1, -1)) -- 233\n```"
+      },
+      "insertText": "utf8.codepoint(${1:s}, ${2:i}, ${3:j})",
       "insertTextRules": 4,
-      "sortText": "07_local_function"
+      "sortText": "05_utf8_utf8.codepoint"
     },
     {
-      "label": "for i = ...",
+      "label": "utf8.offset",
       "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",
+      "detail": "Get byte offset of nth character",
+      "documentation": {
+        "value": "Get byte offset of nth character.\n\n```lua\nlocal s = 'héllo'\nprint(utf8.offset(s, 3)) -- byte pos of 3rd char\n```"
+      },
+      "insertText": "utf8.offset(${1:s}, ${2:n}, ${3:i})",
       "insertTextRules": 4,
-      "sortText": "07_for_numeric"
+      "sortText": "05_utf8_utf8.offset"
     },
     {
-      "label": "for k, v in pairs",
+      "label": "utf8.charpattern",
       "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",
+      "detail": "Pattern matching a single UTF-8 character",
+      "documentation": {
+        "value": "Pattern matching a single UTF-8 character.\n\n```lua\nfor c in string.gmatch(s, utf8.charpattern) do\n  print(c)\nend\n```"
+      },
+      "insertText": "utf8.charpattern",
       "insertTextRules": 4,
-      "sortText": "07_for_pairs"
+      "sortText": "05_utf8_utf8.charpattern"
     },
     {
-      "label": "for i, v in ipairs",
+      "label": "package.path",
       "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",
+      "detail": "Lua module search path",
+      "documentation": {
+        "value": "Lua module search path.\n\n```lua\nprint(package.path)\npackage.path = package.path .. ';./libs/?.lua'\n```"
+      },
+      "insertText": "package.path",
       "insertTextRules": 4,
-      "sortText": "07_for_ipairs"
+      "sortText": "05_package_package.path"
     },
     {
-      "label": "while loop",
+      "label": "package.cpath",
       "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",
+      "detail": "C module search path",
+      "documentation": {
+        "value": "C module search path.\n\n```lua\nprint(package.cpath)\npackage.cpath = package.cpath .. ';./libs/?.so'\n```"
+      },
+      "insertText": "package.cpath",
       "insertTextRules": 4,
-      "sortText": "07_while_loop"
+      "sortText": "05_package_package.cpath"
     },
     {
-      "label": "repeat until",
+      "label": "package.loaded",
       "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}",
+      "detail": "Table of loaded modules",
+      "documentation": {
+        "value": "Table of loaded modules.\n\n```lua\n-- Check if a module is loaded\nif package.loaded['socket'] then\n  print('socket loaded')\nend\n-- Force re-require\npackage.loaded['mymod'] = nil\nrequire('mymod')\n```"
+      },
+      "insertText": "package.loaded",
       "insertTextRules": 4,
-      "sortText": "07_repeat_until"
+      "sortText": "05_package_package.loaded"
     },
     {
-      "label": "if then end",
+      "label": "package.preload",
       "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",
+      "detail": "Table of module loaders",
+      "documentation": {
+        "value": "Table of module loaders.\n\n```lua\npackage.preload['mymod'] = function()\n  return { hello = function() print('hi') end }\nend\n```"
+      },
+      "insertText": "package.preload",
       "insertTextRules": 4,
-      "sortText": "07_if_then_end"
+      "sortText": "05_package_package.preload"
     },
     {
-      "label": "if else",
+      "label": "package.searchers",
       "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",
+      "detail": "Table of module searcher functions",
+      "documentation": {
+        "value": "Table of module searcher functions.\n\n```lua\n-- Add custom searcher\ntable.insert(package.searchers, 2, function(name)\n  -- custom logic\nend)\n```"
+      },
+      "insertText": "package.searchers",
       "insertTextRules": 4,
-      "sortText": "07_if_else"
+      "sortText": "05_package_package.searchers"
     },
     {
-      "label": "module pattern",
+      "label": "package.searchpath",
       "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}",
+      "detail": "Search for file in path",
+      "documentation": {
+        "value": "Search for file in path.\n\n```lua\nlocal file = package.searchpath('socket', package.path)\nprint(file) -- /usr/local/share/lua/5.4/socket.lua\n```"
+      },
+      "insertText": "package.searchpath(${1:name}, ${2:path})",
       "insertTextRules": 4,
-      "sortText": "07_module_pattern"
+      "sortText": "05_package_package.searchpath"
     },
     {
-      "label": "class with metatables",
+      "label": "package.config",
       "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}",
+      "detail": "Path configuration string",
+      "documentation": {
+        "value": "Path configuration string.\n\n```lua\n-- First char: dir separator\n-- Second char: path separator\nprint(package.config:sub(1,1)) -- '/' or '\\\\'\n```"
+      },
+      "insertText": "package.config",
       "insertTextRules": 4,
-      "sortText": "07_class_metatables"
+      "sortText": "05_package_package.config"
     },
     {
-      "label": "coroutine pattern",
+      "label": "local close",
       "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})",
+      "detail": "To-be-closed variable (Lua 5.4)",
+      "documentation": {
+        "value": "To-be-closed variable with automatic cleanup.\n\n```lua\nlocal f <close> = io.open('file.txt')\n-- f:close() called automatically when f goes out of scope\n```"
+      },
+      "insertText": "local ${1:var} <close> = ${0}",
       "insertTextRules": 4,
-      "sortText": "07_coroutine_pattern"
+      "sortText": "02_local_close"
     }
   ]
-}
+}