@enjoys/context-engine 1.0.0 → 1.0.1

package/data/completion/php.json

@@ -0,0 +1,1535 @@
+{
+  "language": "php",
+  "completions": [
+    {
+      "label": "echo",
+      "kind": 14,
+      "detail": "Output one or more strings",
+      "documentation": { "value": "Outputs one or more expressions, with no additional newline or space.\n\n```php\necho 'Hello, World!';\necho $name, ' is ', $age;\necho \"Value: {$var}\";\n```" },
+      "insertText": "echo ${1:expression};",
+      "insertTextRules": 4,
+      "sortText": "00_echo"
+    },
+    {
+      "label": "print",
+      "kind": 14,
+      "detail": "Output a string",
+      "documentation": { "value": "Outputs a string. Unlike echo, print accepts only one argument and always returns 1.\n\n```php\nprint 'Hello, World!';\nprint(\"Value: $var\");\n$result = print 'test';\n```" },
+      "insertText": "print ${1:expression};",
+      "insertTextRules": 4,
+      "sortText": "00_print"
+    },
+    {
+      "label": "var_dump",
+      "kind": 1,
+      "detail": "Dump variable information",
+      "documentation": { "value": "Displays structured information about one or more expressions including its type and value.\n\n```php\nvar_dump($variable);\nvar_dump($arr, $obj, $bool);\nvar_dump(['a' => 1, 'b' => 2]);\n```" },
+      "insertText": "var_dump(${1:\\$variable});",
+      "insertTextRules": 4,
+      "sortText": "00_var_dump"
+    },
+    {
+      "label": "print_r",
+      "kind": 1,
+      "detail": "Print human-readable variable info",
+      "documentation": { "value": "Prints human-readable information about a variable. Especially useful for arrays and objects.\n\n```php\nprint_r($array);\n$output = print_r($array, true);\nprint_r(['name' => 'John', 'age' => 30]);\n```" },
+      "insertText": "print_r(${1:\\$variable});",
+      "insertTextRules": 4,
+      "sortText": "00_print_r"
+    },
+    {
+      "label": "var_export",
+      "kind": 1,
+      "detail": "Output parsable string representation",
+      "documentation": { "value": "Outputs or returns a parsable string representation of a variable.\n\n```php\nvar_export($array);\n$code = var_export($array, true);\nvar_export(['key' => 'value']);\n```" },
+      "insertText": "var_export(${1:\\$variable}, ${2:false});",
+      "insertTextRules": 4,
+      "sortText": "00_var_export"
+    },
+    {
+      "label": "printf",
+      "kind": 1,
+      "detail": "Output a formatted string",
+      "documentation": { "value": "Outputs a formatted string using format specifiers.\n\n```php\nprintf('Name: %s, Age: %d', $name, $age);\nprintf('Price: $%.2f', $price);\nprintf('%05d', $number);\n```" },
+      "insertText": "printf('${1:%s}', ${2:\\$value});",
+      "insertTextRules": 4,
+      "sortText": "00_printf"
+    },
+    {
+      "label": "sprintf",
+      "kind": 1,
+      "detail": "Return a formatted string",
+      "documentation": { "value": "Returns a formatted string without outputting it.\n\n```php\n$msg = sprintf('Hello, %s!', $name);\n$price = sprintf('$%.2f', 19.99);\n$padded = sprintf('%05d', 42);\n```" },
+      "insertText": "sprintf('${1:%s}', ${2:\\$value})",
+      "insertTextRules": 4,
+      "sortText": "00_sprintf"
+    },
+    {
+      "label": "strlen",
+      "kind": 1,
+      "detail": "Get string length",
+      "documentation": { "value": "Returns the length of the given string in bytes.\n\n```php\n$len = strlen('Hello'); // 5\n$len = strlen($str);\nif (strlen($input) > 0) { ... }\n```" },
+      "insertText": "strlen(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_strlen"
+    },
+    {
+      "label": "strpos",
+      "kind": 1,
+      "detail": "Find position of first occurrence",
+      "documentation": { "value": "Finds the position of the first occurrence of a substring in a string.\n\n```php\n$pos = strpos('Hello World', 'World'); // 6\nif (strpos($haystack, $needle) !== false) { ... }\n$pos = strpos($str, 'x', 5);\n```" },
+      "insertText": "strpos(${1:\\$haystack}, ${2:\\$needle})",
+      "insertTextRules": 4,
+      "sortText": "01_strpos"
+    },
+    {
+      "label": "strrpos",
+      "kind": 1,
+      "detail": "Find position of last occurrence",
+      "documentation": { "value": "Finds the position of the last occurrence of a substring in a string.\n\n```php\n$pos = strrpos('Hello World Hello', 'Hello'); // 12\n$pos = strrpos($path, '/');\n```" },
+      "insertText": "strrpos(${1:\\$haystack}, ${2:\\$needle})",
+      "insertTextRules": 4,
+      "sortText": "01_strrpos"
+    },
+    {
+      "label": "substr",
+      "kind": 1,
+      "detail": "Return part of a string",
+      "documentation": { "value": "Returns the portion of string specified by the offset and length parameters.\n\n```php\n$part = substr('Hello World', 0, 5); // 'Hello'\n$last = substr($str, -3);\n$rest = substr($str, 6);\n```" },
+      "insertText": "substr(${1:\\$string}, ${2:offset}, ${3:length})",
+      "insertTextRules": 4,
+      "sortText": "01_substr"
+    },
+    {
+      "label": "str_replace",
+      "kind": 1,
+      "detail": "Replace all occurrences of a string",
+      "documentation": { "value": "Replaces all occurrences of the search string with the replacement string.\n\n```php\n$result = str_replace('world', 'PHP', 'Hello world');\n$clean = str_replace([' ', '-'], '_', $str);\n$result = str_replace($search, $replace, $subject, $count);\n```" },
+      "insertText": "str_replace(${1:\\$search}, ${2:\\$replace}, ${3:\\$subject})",
+      "insertTextRules": 4,
+      "sortText": "01_str_replace"
+    },
+    {
+      "label": "str_contains",
+      "kind": 1,
+      "detail": "Check if string contains substring (PHP 8.0+)",
+      "documentation": { "value": "Determines if a string contains a given substring.\n\n```php\nif (str_contains('Hello World', 'World')) { ... }\nif (str_contains($haystack, $needle)) { ... }\n```" },
+      "insertText": "str_contains(${1:\\$haystack}, ${2:\\$needle})",
+      "insertTextRules": 4,
+      "sortText": "01_str_contains"
+    },
+    {
+      "label": "str_starts_with",
+      "kind": 1,
+      "detail": "Check if string starts with substring (PHP 8.0+)",
+      "documentation": { "value": "Checks if a string starts with a given substring.\n\n```php\nif (str_starts_with($url, 'https://')) { ... }\nif (str_starts_with($line, '#')) { ... }\n```" },
+      "insertText": "str_starts_with(${1:\\$haystack}, ${2:\\$needle})",
+      "insertTextRules": 4,
+      "sortText": "01_str_starts_with"
+    },
+    {
+      "label": "str_ends_with",
+      "kind": 1,
+      "detail": "Check if string ends with substring (PHP 8.0+)",
+      "documentation": { "value": "Checks if a string ends with a given substring.\n\n```php\nif (str_ends_with($file, '.php')) { ... }\nif (str_ends_with($url, '/')) { ... }\n```" },
+      "insertText": "str_ends_with(${1:\\$haystack}, ${2:\\$needle})",
+      "insertTextRules": 4,
+      "sortText": "01_str_ends_with"
+    },
+    {
+      "label": "strtolower",
+      "kind": 1,
+      "detail": "Convert string to lowercase",
+      "documentation": { "value": "Returns a string with all ASCII alphabetic characters converted to lowercase.\n\n```php\n$lower = strtolower('Hello World'); // 'hello world'\n$lower = strtolower($input);\n```" },
+      "insertText": "strtolower(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_strtolower"
+    },
+    {
+      "label": "strtoupper",
+      "kind": 1,
+      "detail": "Convert string to uppercase",
+      "documentation": { "value": "Returns a string with all ASCII alphabetic characters converted to uppercase.\n\n```php\n$upper = strtoupper('Hello World'); // 'HELLO WORLD'\n$upper = strtoupper($input);\n```" },
+      "insertText": "strtoupper(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_strtoupper"
+    },
+    {
+      "label": "trim",
+      "kind": 1,
+      "detail": "Strip whitespace from both ends",
+      "documentation": { "value": "Strips whitespace (or other characters) from the beginning and end of a string.\n\n```php\n$clean = trim('  Hello  '); // 'Hello'\n$clean = trim($input, '/');\n```" },
+      "insertText": "trim(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_trim"
+    },
+    {
+      "label": "ltrim",
+      "kind": 1,
+      "detail": "Strip whitespace from the beginning",
+      "documentation": { "value": "Strips whitespace (or other characters) from the beginning of a string.\n\n```php\n$clean = ltrim('  Hello'); // 'Hello'\n$clean = ltrim($path, '/');\n```" },
+      "insertText": "ltrim(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_ltrim"
+    },
+    {
+      "label": "rtrim",
+      "kind": 1,
+      "detail": "Strip whitespace from the end",
+      "documentation": { "value": "Strips whitespace (or other characters) from the end of a string.\n\n```php\n$clean = rtrim('Hello  '); // 'Hello'\n$clean = rtrim($path, '/');\n```" },
+      "insertText": "rtrim(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_rtrim"
+    },
+    {
+      "label": "explode",
+      "kind": 1,
+      "detail": "Split a string by a delimiter",
+      "documentation": { "value": "Splits a string by a string delimiter and returns an array.\n\n```php\n$parts = explode(',', 'a,b,c'); // ['a', 'b', 'c']\n$words = explode(' ', $sentence);\n$parts = explode('/', $path, 3);\n```" },
+      "insertText": "explode(${1:'${2:delimiter}'}, ${3:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_explode"
+    },
+    {
+      "label": "implode",
+      "kind": 1,
+      "detail": "Join array elements with a string",
+      "documentation": { "value": "Joins array elements with a glue string.\n\n```php\n$str = implode(', ', ['a', 'b', 'c']); // 'a, b, c'\n$csv = implode(',', $values);\n$path = implode('/', $segments);\n```" },
+      "insertText": "implode(${1:'${2:glue}'}, ${3:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "01_implode"
+    },
+    {
+      "label": "str_pad",
+      "kind": 1,
+      "detail": "Pad a string to a certain length",
+      "documentation": { "value": "Pads a string to a certain length with another string.\n\n```php\n$padded = str_pad('42', 5, '0', STR_PAD_LEFT); // '00042'\n$padded = str_pad($str, 20);\n```" },
+      "insertText": "str_pad(${1:\\$string}, ${2:length}, ${3:' '}, ${4:STR_PAD_RIGHT})",
+      "insertTextRules": 4,
+      "sortText": "01_str_pad"
+    },
+    {
+      "label": "str_repeat",
+      "kind": 1,
+      "detail": "Repeat a string",
+      "documentation": { "value": "Repeats a string a given number of times.\n\n```php\n$line = str_repeat('-', 40);\n$indent = str_repeat('  ', $level);\n```" },
+      "insertText": "str_repeat(${1:\\$string}, ${2:times})",
+      "insertTextRules": 4,
+      "sortText": "01_str_repeat"
+    },
+    {
+      "label": "str_word_count",
+      "kind": 1,
+      "detail": "Count words in a string",
+      "documentation": { "value": "Counts the number of words in a string.\n\n```php\n$count = str_word_count('Hello beautiful world'); // 3\n$words = str_word_count($text, 1); // array of words\n```" },
+      "insertText": "str_word_count(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_str_word_count"
+    },
+    {
+      "label": "str_split",
+      "kind": 1,
+      "detail": "Split string into array of chunks",
+      "documentation": { "value": "Converts a string to an array, splitting into chunks of given length.\n\n```php\n$chars = str_split('Hello'); // ['H','e','l','l','o']\n$chunks = str_split($str, 3);\n```" },
+      "insertText": "str_split(${1:\\$string}, ${2:1})",
+      "insertTextRules": 4,
+      "sortText": "01_str_split"
+    },
+    {
+      "label": "ucfirst",
+      "kind": 1,
+      "detail": "Uppercase first character",
+      "documentation": { "value": "Returns a string with the first character uppercased.\n\n```php\n$name = ucfirst('hello'); // 'Hello'\n```" },
+      "insertText": "ucfirst(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_ucfirst"
+    },
+    {
+      "label": "lcfirst",
+      "kind": 1,
+      "detail": "Lowercase first character",
+      "documentation": { "value": "Returns a string with the first character lowercased.\n\n```php\n$name = lcfirst('Hello'); // 'hello'\n```" },
+      "insertText": "lcfirst(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_lcfirst"
+    },
+    {
+      "label": "ucwords",
+      "kind": 1,
+      "detail": "Uppercase first letter of each word",
+      "documentation": { "value": "Returns a string with the first character of each word uppercased.\n\n```php\n$title = ucwords('hello world'); // 'Hello World'\n$title = ucwords($str, '-');\n```" },
+      "insertText": "ucwords(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_ucwords"
+    },
+    {
+      "label": "nl2br",
+      "kind": 1,
+      "detail": "Insert HTML line breaks",
+      "documentation": { "value": "Inserts HTML line breaks before all newlines in a string.\n\n```php\n$html = nl2br(\"Hello\\nWorld\");\necho nl2br($text);\n```" },
+      "insertText": "nl2br(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_nl2br"
+    },
+    {
+      "label": "htmlspecialchars",
+      "kind": 1,
+      "detail": "Convert special characters to HTML entities",
+      "documentation": { "value": "Converts special characters to HTML entities for safe output.\n\n```php\n$safe = htmlspecialchars($input, ENT_QUOTES, 'UTF-8');\necho htmlspecialchars($userInput);\n```" },
+      "insertText": "htmlspecialchars(${1:\\$string}, ENT_QUOTES, 'UTF-8')",
+      "insertTextRules": 4,
+      "sortText": "01_htmlspecialchars"
+    },
+    {
+      "label": "htmlentities",
+      "kind": 1,
+      "detail": "Convert all applicable characters to HTML entities",
+      "documentation": { "value": "Converts all applicable characters to HTML entities.\n\n```php\n$safe = htmlentities($input, ENT_QUOTES, 'UTF-8');\n```" },
+      "insertText": "htmlentities(${1:\\$string}, ENT_QUOTES, 'UTF-8')",
+      "insertTextRules": 4,
+      "sortText": "01_htmlentities"
+    },
+    {
+      "label": "urlencode",
+      "kind": 1,
+      "detail": "URL-encode a string",
+      "documentation": { "value": "URL-encodes a string, replacing special characters with percent-encoded values.\n\n```php\n$encoded = urlencode('Hello World'); // 'Hello+World'\n$url = 'search?q=' . urlencode($query);\n```" },
+      "insertText": "urlencode(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_urlencode"
+    },
+    {
+      "label": "urldecode",
+      "kind": 1,
+      "detail": "Decode a URL-encoded string",
+      "documentation": { "value": "Decodes any percent-encoded characters in the given string.\n\n```php\n$decoded = urldecode('Hello+World'); // 'Hello World'\n$decoded = urldecode($encodedStr);\n```" },
+      "insertText": "urldecode(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_urldecode"
+    },
+    {
+      "label": "base64_encode",
+      "kind": 1,
+      "detail": "Encode data with Base64",
+      "documentation": { "value": "Encodes the given data with Base64.\n\n```php\n$encoded = base64_encode('Hello World');\n$encoded = base64_encode($binaryData);\n```" },
+      "insertText": "base64_encode(${1:\\$data})",
+      "insertTextRules": 4,
+      "sortText": "01_base64_encode"
+    },
+    {
+      "label": "base64_decode",
+      "kind": 1,
+      "detail": "Decode Base64-encoded data",
+      "documentation": { "value": "Decodes a Base64-encoded string.\n\n```php\n$decoded = base64_decode($encoded);\n$data = base64_decode($base64String, true);\n```" },
+      "insertText": "base64_decode(${1:\\$data})",
+      "insertTextRules": 4,
+      "sortText": "01_base64_decode"
+    },
+    {
+      "label": "md5",
+      "kind": 1,
+      "detail": "Calculate the MD5 hash of a string",
+      "documentation": { "value": "Calculates the MD5 hash of a string and returns a 32-character hexadecimal number.\n\n```php\n$hash = md5('password');\n$hash = md5($data, true); // raw binary\n```" },
+      "insertText": "md5(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_md5"
+    },
+    {
+      "label": "sha1",
+      "kind": 1,
+      "detail": "Calculate the SHA-1 hash of a string",
+      "documentation": { "value": "Calculates the SHA-1 hash of a string.\n\n```php\n$hash = sha1('data');\n$hash = sha1($data, true); // raw binary\n```" },
+      "insertText": "sha1(${1:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "01_sha1"
+    },
+    {
+      "label": "number_format",
+      "kind": 1,
+      "detail": "Format a number with grouped thousands",
+      "documentation": { "value": "Formats a number with grouped thousands and decimal places.\n\n```php\n$formatted = number_format(1234567.891, 2, '.', ','); // '1,234,567.89'\n$formatted = number_format($price, 2);\n```" },
+      "insertText": "number_format(${1:\\$number}, ${2:2}, ${3:'.'}, ${4:','})",
+      "insertTextRules": 4,
+      "sortText": "01_number_format"
+    },
+    {
+      "label": "array_push",
+      "kind": 1,
+      "detail": "Push elements onto end of array",
+      "documentation": { "value": "Pushes one or more elements onto the end of an array.\n\n```php\narray_push($stack, 'apple', 'banana');\n$arr[] = 'value'; // shorthand for single push\n```" },
+      "insertText": "array_push(${1:\\$array}, ${2:\\$value})",
+      "insertTextRules": 4,
+      "sortText": "02_array_push"
+    },
+    {
+      "label": "array_pop",
+      "kind": 1,
+      "detail": "Pop the last element off an array",
+      "documentation": { "value": "Pops and returns the last element of the array, shortening it by one.\n\n```php\n$last = array_pop($stack);\n$item = array_pop($arr);\n```" },
+      "insertText": "array_pop(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_pop"
+    },
+    {
+      "label": "array_shift",
+      "kind": 1,
+      "detail": "Shift the first element off an array",
+      "documentation": { "value": "Shifts the first value of the array off and returns it, shortening the array by one.\n\n```php\n$first = array_shift($queue);\n```" },
+      "insertText": "array_shift(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_shift"
+    },
+    {
+      "label": "array_unshift",
+      "kind": 1,
+      "detail": "Prepend elements to the beginning of array",
+      "documentation": { "value": "Prepends one or more elements to the beginning of an array.\n\n```php\narray_unshift($arr, 'first');\narray_unshift($arr, 'a', 'b');\n```" },
+      "insertText": "array_unshift(${1:\\$array}, ${2:\\$value})",
+      "insertTextRules": 4,
+      "sortText": "02_array_unshift"
+    },
+    {
+      "label": "array_merge",
+      "kind": 1,
+      "detail": "Merge one or more arrays",
+      "documentation": { "value": "Merges one or more arrays. Values with numeric keys are re-indexed; string keys are overwritten.\n\n```php\n$merged = array_merge($arr1, $arr2);\n$all = array_merge($a, $b, $c);\n```" },
+      "insertText": "array_merge(${1:\\$array1}, ${2:\\$array2})",
+      "insertTextRules": 4,
+      "sortText": "02_array_merge"
+    },
+    {
+      "label": "array_combine",
+      "kind": 1,
+      "detail": "Create array using keys and values arrays",
+      "documentation": { "value": "Creates an array by using one array for keys and another for its values.\n\n```php\n$result = array_combine(['a', 'b', 'c'], [1, 2, 3]);\n// ['a' => 1, 'b' => 2, 'c' => 3]\n```" },
+      "insertText": "array_combine(${1:\\$keys}, ${2:\\$values})",
+      "insertTextRules": 4,
+      "sortText": "02_array_combine"
+    },
+    {
+      "label": "array_map",
+      "kind": 1,
+      "detail": "Apply callback to each element",
+      "documentation": { "value": "Applies the callback to the elements of the given arrays and returns a new array.\n\n```php\n$doubled = array_map(fn($n) => $n * 2, [1, 2, 3]);\n$upper = array_map('strtoupper', $words);\n```" },
+      "insertText": "array_map(${1:fn(\\$item) => \\$item}, ${2:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_map"
+    },
+    {
+      "label": "array_filter",
+      "kind": 1,
+      "detail": "Filter array elements using a callback",
+      "documentation": { "value": "Filters elements of an array using a callback function.\n\n```php\n$even = array_filter([1,2,3,4], fn($n) => $n % 2 === 0);\n$nonEmpty = array_filter($arr); // removes falsy values\n```" },
+      "insertText": "array_filter(${1:\\$array}, ${2:fn(\\$item) => \\$item})",
+      "insertTextRules": 4,
+      "sortText": "02_array_filter"
+    },
+    {
+      "label": "array_reduce",
+      "kind": 1,
+      "detail": "Reduce array to a single value",
+      "documentation": { "value": "Iteratively reduces the array to a single value using a callback function.\n\n```php\n$sum = array_reduce([1,2,3], fn($carry, $item) => $carry + $item, 0);\n```" },
+      "insertText": "array_reduce(${1:\\$array}, fn(\\$carry, \\$item) => ${2:\\$carry}, ${3:null})",
+      "insertTextRules": 4,
+      "sortText": "02_array_reduce"
+    },
+    {
+      "label": "array_keys",
+      "kind": 1,
+      "detail": "Return all keys of an array",
+      "documentation": { "value": "Returns all the keys or a subset of keys of an array.\n\n```php\n$keys = array_keys(['a' => 1, 'b' => 2]); // ['a', 'b']\n$keys = array_keys($arr, 'search_value');\n```" },
+      "insertText": "array_keys(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_keys"
+    },
+    {
+      "label": "array_values",
+      "kind": 1,
+      "detail": "Return all values of an array",
+      "documentation": { "value": "Returns all the values of an array with numeric indexing.\n\n```php\n$values = array_values(['a' => 1, 'b' => 2]); // [1, 2]\n$reindexed = array_values($filtered);\n```" },
+      "insertText": "array_values(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_values"
+    },
+    {
+      "label": "array_unique",
+      "kind": 1,
+      "detail": "Remove duplicate values from array",
+      "documentation": { "value": "Removes duplicate values from an array.\n\n```php\n$unique = array_unique([1, 2, 2, 3, 3]); // [1, 2, 3]\n```" },
+      "insertText": "array_unique(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_unique"
+    },
+    {
+      "label": "array_reverse",
+      "kind": 1,
+      "detail": "Return array in reverse order",
+      "documentation": { "value": "Returns an array with elements in reverse order.\n\n```php\n$reversed = array_reverse([1, 2, 3]); // [3, 2, 1]\n$reversed = array_reverse($arr, true); // preserve keys\n```" },
+      "insertText": "array_reverse(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_reverse"
+    },
+    {
+      "label": "array_slice",
+      "kind": 1,
+      "detail": "Extract a slice of the array",
+      "documentation": { "value": "Extracts a slice of the array.\n\n```php\n$slice = array_slice([1,2,3,4,5], 1, 3); // [2,3,4]\n$last3 = array_slice($arr, -3);\n```" },
+      "insertText": "array_slice(${1:\\$array}, ${2:offset}, ${3:length})",
+      "insertTextRules": 4,
+      "sortText": "02_array_slice"
+    },
+    {
+      "label": "array_splice",
+      "kind": 1,
+      "detail": "Remove and replace part of an array",
+      "documentation": { "value": "Removes a portion of the array and replaces it with something else.\n\n```php\narray_splice($arr, 2, 1); // remove 1 element at index 2\narray_splice($arr, 1, 0, ['inserted']);\n```" },
+      "insertText": "array_splice(${1:\\$array}, ${2:offset}, ${3:length})",
+      "insertTextRules": 4,
+      "sortText": "02_array_splice"
+    },
+    {
+      "label": "array_search",
+      "kind": 1,
+      "detail": "Search array for a value",
+      "documentation": { "value": "Searches the array for a given value and returns the corresponding key if found.\n\n```php\n$key = array_search('apple', $fruits);\nif (($key = array_search($val, $arr)) !== false) { ... }\n```" },
+      "insertText": "array_search(${1:\\$needle}, ${2:\\$haystack})",
+      "insertTextRules": 4,
+      "sortText": "02_array_search"
+    },
+    {
+      "label": "array_flip",
+      "kind": 1,
+      "detail": "Exchange keys and values",
+      "documentation": { "value": "Exchanges all keys with their associated values in an array.\n\n```php\n$flipped = array_flip(['a' => 1, 'b' => 2]); // [1 => 'a', 2 => 'b']\n```" },
+      "insertText": "array_flip(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_flip"
+    },
+    {
+      "label": "array_chunk",
+      "kind": 1,
+      "detail": "Split array into chunks",
+      "documentation": { "value": "Splits an array into chunks of the specified size.\n\n```php\n$chunks = array_chunk([1,2,3,4,5], 2); // [[1,2],[3,4],[5]]\n$pages = array_chunk($items, 10, true);\n```" },
+      "insertText": "array_chunk(${1:\\$array}, ${2:size})",
+      "insertTextRules": 4,
+      "sortText": "02_array_chunk"
+    },
+    {
+      "label": "array_column",
+      "kind": 1,
+      "detail": "Return values from a single column",
+      "documentation": { "value": "Returns the values from a single column in a multi-dimensional array.\n\n```php\n$names = array_column($users, 'name');\n$indexed = array_column($records, 'value', 'key');\n```" },
+      "insertText": "array_column(${1:\\$array}, ${2:'column_key'})",
+      "insertTextRules": 4,
+      "sortText": "02_array_column"
+    },
+    {
+      "label": "array_diff",
+      "kind": 1,
+      "detail": "Compute the difference of arrays",
+      "documentation": { "value": "Computes the difference of arrays using values for comparison.\n\n```php\n$diff = array_diff([1,2,3,4], [2,4]); // [1, 3]\n```" },
+      "insertText": "array_diff(${1:\\$array1}, ${2:\\$array2})",
+      "insertTextRules": 4,
+      "sortText": "02_array_diff"
+    },
+    {
+      "label": "array_intersect",
+      "kind": 1,
+      "detail": "Compute the intersection of arrays",
+      "documentation": { "value": "Computes the intersection of arrays using values for comparison.\n\n```php\n$common = array_intersect([1,2,3], [2,3,4]); // [2, 3]\n```" },
+      "insertText": "array_intersect(${1:\\$array1}, ${2:\\$array2})",
+      "insertTextRules": 4,
+      "sortText": "02_array_intersect"
+    },
+    {
+      "label": "in_array",
+      "kind": 1,
+      "detail": "Check if a value exists in an array",
+      "documentation": { "value": "Checks if a value exists in an array.\n\n```php\nif (in_array('apple', $fruits)) { ... }\nif (in_array($val, $arr, true)) { ... } // strict comparison\n```" },
+      "insertText": "in_array(${1:\\$needle}, ${2:\\$haystack})",
+      "insertTextRules": 4,
+      "sortText": "02_in_array"
+    },
+    {
+      "label": "count",
+      "kind": 1,
+      "detail": "Count elements in array or Countable",
+      "documentation": { "value": "Counts all elements in an array or a Countable object.\n\n```php\n$total = count($arr);\n$depth = count($matrix, COUNT_RECURSIVE);\nif (count($items) > 0) { ... }\n```" },
+      "insertText": "count(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_count"
+    },
+    {
+      "label": "sort",
+      "kind": 1,
+      "detail": "Sort an array in ascending order",
+      "documentation": { "value": "Sorts an array in place in ascending order.\n\n```php\nsort($arr);\nsort($numbers, SORT_NUMERIC);\n```" },
+      "insertText": "sort(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_sort"
+    },
+    {
+      "label": "rsort",
+      "kind": 1,
+      "detail": "Sort an array in descending order",
+      "documentation": { "value": "Sorts an array in place in descending order.\n\n```php\nrsort($arr);\nrsort($numbers, SORT_NUMERIC);\n```" },
+      "insertText": "rsort(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_rsort"
+    },
+    {
+      "label": "asort",
+      "kind": 1,
+      "detail": "Sort array in ascending order, maintain keys",
+      "documentation": { "value": "Sorts an array in ascending order, maintaining key association.\n\n```php\nasort($prices);\n```" },
+      "insertText": "asort(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_asort"
+    },
+    {
+      "label": "arsort",
+      "kind": 1,
+      "detail": "Sort array in descending order, maintain keys",
+      "documentation": { "value": "Sorts an array in descending order, maintaining key association.\n\n```php\narsort($prices);\n```" },
+      "insertText": "arsort(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_arsort"
+    },
+    {
+      "label": "ksort",
+      "kind": 1,
+      "detail": "Sort array by key in ascending order",
+      "documentation": { "value": "Sorts an array by key in ascending order.\n\n```php\nksort($config);\n```" },
+      "insertText": "ksort(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_ksort"
+    },
+    {
+      "label": "krsort",
+      "kind": 1,
+      "detail": "Sort array by key in descending order",
+      "documentation": { "value": "Sorts an array by key in descending order.\n\n```php\nkrsort($config);\n```" },
+      "insertText": "krsort(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_krsort"
+    },
+    {
+      "label": "usort",
+      "kind": 1,
+      "detail": "Sort array using a comparison function",
+      "documentation": { "value": "Sorts an array by values using a user-defined comparison function.\n\n```php\nusort($arr, fn($a, $b) => $a - $b);\nusort($users, fn($a, $b) => strcmp($a['name'], $b['name']));\n```" },
+      "insertText": "usort(${1:\\$array}, fn(\\$a, \\$b) => ${2:\\$a - \\$b})",
+      "insertTextRules": 4,
+      "sortText": "02_usort"
+    },
+    {
+      "label": "array_walk",
+      "kind": 1,
+      "detail": "Apply callback to each array element",
+      "documentation": { "value": "Applies a user-supplied function to every member of an array (by reference).\n\n```php\narray_walk($arr, function(&$val, $key) { $val = strtoupper($val); });\n```" },
+      "insertText": "array_walk(${1:\\$array}, function(&\\$value, \\$key) {\n\t${2}\n})",
+      "insertTextRules": 4,
+      "sortText": "02_array_walk"
+    },
+    {
+      "label": "array_key_exists",
+      "kind": 1,
+      "detail": "Check if key exists in array",
+      "documentation": { "value": "Checks if the given key or index exists in the array.\n\n```php\nif (array_key_exists('name', $data)) { ... }\nif (array_key_exists(0, $arr)) { ... }\n```" },
+      "insertText": "array_key_exists(${1:'key'}, ${2:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_key_exists"
+    },
+    {
+      "label": "array_fill",
+      "kind": 1,
+      "detail": "Fill an array with values",
+      "documentation": { "value": "Fills an array with values, specifying start index and number of entries.\n\n```php\n$filled = array_fill(0, 5, 'default'); // 5 elements of 'default'\n$zeros = array_fill(0, 10, 0);\n```" },
+      "insertText": "array_fill(${1:0}, ${2:count}, ${3:\\$value})",
+      "insertTextRules": 4,
+      "sortText": "02_array_fill"
+    },
+    {
+      "label": "compact",
+      "kind": 1,
+      "detail": "Create array from variables and their values",
+      "documentation": { "value": "Creates an array containing variables and their values.\n\n```php\n$name = 'John';\n$age = 30;\n$data = compact('name', 'age'); // ['name' => 'John', 'age' => 30]\n```" },
+      "insertText": "compact(${1:'var1'}, ${2:'var2'})",
+      "insertTextRules": 4,
+      "sortText": "02_compact"
+    },
+    {
+      "label": "extract",
+      "kind": 1,
+      "detail": "Import variables from an array",
+      "documentation": { "value": "Import variables into the current symbol table from an array.\n\n```php\n$data = ['name' => 'John', 'age' => 30];\nextract($data);\necho $name; // 'John'\n```" },
+      "insertText": "extract(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_extract"
+    },
+    {
+      "label": "range",
+      "kind": 1,
+      "detail": "Create an array of sequential values",
+      "documentation": { "value": "Creates an array containing a range of elements.\n\n```php\n$nums = range(1, 10); // [1,2,3,...,10]\n$letters = range('a', 'z');\n$evens = range(0, 20, 2);\n```" },
+      "insertText": "range(${1:start}, ${2:end})",
+      "insertTextRules": 4,
+      "sortText": "02_range"
+    },
+    {
+      "label": "array_sum",
+      "kind": 1,
+      "detail": "Calculate sum of array values",
+      "documentation": { "value": "Calculates the sum of values in an array.\n\n```php\n$total = array_sum([1, 2, 3]); // 6\n$total = array_sum($prices);\n```" },
+      "insertText": "array_sum(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_sum"
+    },
+    {
+      "label": "array_product",
+      "kind": 1,
+      "detail": "Calculate product of array values",
+      "documentation": { "value": "Calculates the product of values in an array.\n\n```php\n$product = array_product([2, 3, 4]); // 24\n```" },
+      "insertText": "array_product(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_product"
+    },
+    {
+      "label": "array_count_values",
+      "kind": 1,
+      "detail": "Count occurrences of each value",
+      "documentation": { "value": "Counts all the values of an array and returns an associative array.\n\n```php\n$counts = array_count_values(['a','b','a','c','b','a']);\n// ['a' => 3, 'b' => 2, 'c' => 1]\n```" },
+      "insertText": "array_count_values(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_array_count_values"
+    },
+    {
+      "label": "file_get_contents",
+      "kind": 1,
+      "detail": "Read entire file into a string",
+      "documentation": { "value": "Reads entire file into a string. Preferred way to read the contents of a file into a string.\n\n```php\n$content = file_get_contents('file.txt');\n$html = file_get_contents('https://example.com');\n$json = file_get_contents('data.json');\n```" },
+      "insertText": "file_get_contents(${1:'filename'})",
+      "insertTextRules": 4,
+      "sortText": "03_file_get_contents"
+    },
+    {
+      "label": "file_put_contents",
+      "kind": 1,
+      "detail": "Write data to a file",
+      "documentation": { "value": "Write data to a file. Identical to calling fopen(), fwrite(), and fclose() successively.\n\n```php\nfile_put_contents('file.txt', $data);\nfile_put_contents('log.txt', $msg, FILE_APPEND);\n```" },
+      "insertText": "file_put_contents(${1:'filename'}, ${2:\\$data})",
+      "insertTextRules": 4,
+      "sortText": "03_file_put_contents"
+    },
+    {
+      "label": "fopen",
+      "kind": 1,
+      "detail": "Open file or URL",
+      "documentation": { "value": "Opens a file or URL and returns a file pointer resource.\n\n```php\n$fp = fopen('file.txt', 'r');\n$fp = fopen('output.csv', 'w');\n$fp = fopen('log.txt', 'a');\n```" },
+      "insertText": "fopen(${1:'filename'}, ${2:'r'})",
+      "insertTextRules": 4,
+      "sortText": "03_fopen"
+    },
+    {
+      "label": "fclose",
+      "kind": 1,
+      "detail": "Close an open file pointer",
+      "documentation": { "value": "Closes an open file pointer.\n\n```php\nfclose($fp);\n```" },
+      "insertText": "fclose(${1:\\$handle})",
+      "insertTextRules": 4,
+      "sortText": "03_fclose"
+    },
+    {
+      "label": "fread",
+      "kind": 1,
+      "detail": "Binary-safe file read",
+      "documentation": { "value": "Reads up to length bytes from a file pointer.\n\n```php\n$data = fread($fp, filesize('file.txt'));\n$chunk = fread($handle, 1024);\n```" },
+      "insertText": "fread(${1:\\$handle}, ${2:length})",
+      "insertTextRules": 4,
+      "sortText": "03_fread"
+    },
+    {
+      "label": "fwrite",
+      "kind": 1,
+      "detail": "Binary-safe file write",
+      "documentation": { "value": "Writes the contents of string to the file stream pointed to by handle.\n\n```php\nfwrite($fp, 'Hello World');\nfwrite($handle, $data, strlen($data));\n```" },
+      "insertText": "fwrite(${1:\\$handle}, ${2:\\$string})",
+      "insertTextRules": 4,
+      "sortText": "03_fwrite"
+    },
+    {
+      "label": "fgets",
+      "kind": 1,
+      "detail": "Get line from file pointer",
+      "documentation": { "value": "Gets a line from file pointer.\n\n```php\nwhile (($line = fgets($fp)) !== false) {\n    echo $line;\n}\n```" },
+      "insertText": "fgets(${1:\\$handle})",
+      "insertTextRules": 4,
+      "sortText": "03_fgets"
+    },
+    {
+      "label": "file_exists",
+      "kind": 1,
+      "detail": "Check whether a file or directory exists",
+      "documentation": { "value": "Checks whether a file or directory exists.\n\n```php\nif (file_exists('config.php')) { ... }\nif (file_exists($path)) { ... }\n```" },
+      "insertText": "file_exists(${1:'filename'})",
+      "insertTextRules": 4,
+      "sortText": "03_file_exists"
+    },
+    {
+      "label": "is_file",
+      "kind": 1,
+      "detail": "Check if path is a regular file",
+      "documentation": { "value": "Tells whether the given filename is a regular file.\n\n```php\nif (is_file($path)) { ... }\n```" },
+      "insertText": "is_file(${1:\\$filename})",
+      "insertTextRules": 4,
+      "sortText": "03_is_file"
+    },
+    {
+      "label": "is_dir",
+      "kind": 1,
+      "detail": "Check if path is a directory",
+      "documentation": { "value": "Tells whether the given filename is a directory.\n\n```php\nif (is_dir($path)) { ... }\n```" },
+      "insertText": "is_dir(${1:\\$path})",
+      "insertTextRules": 4,
+      "sortText": "03_is_dir"
+    },
+    {
+      "label": "mkdir",
+      "kind": 1,
+      "detail": "Create a directory",
+      "documentation": { "value": "Creates a directory.\n\n```php\nmkdir('new_folder');\nmkdir('path/to/dir', 0755, true); // recursive\n```" },
+      "insertText": "mkdir(${1:'directory'}, ${2:0755}, ${3:true})",
+      "insertTextRules": 4,
+      "sortText": "03_mkdir"
+    },
+    {
+      "label": "unlink",
+      "kind": 1,
+      "detail": "Delete a file",
+      "documentation": { "value": "Deletes a file.\n\n```php\nunlink('temp.txt');\nif (file_exists($file)) { unlink($file); }\n```" },
+      "insertText": "unlink(${1:'filename'})",
+      "insertTextRules": 4,
+      "sortText": "03_unlink"
+    },
+    {
+      "label": "glob",
+      "kind": 1,
+      "detail": "Find pathnames matching a pattern",
+      "documentation": { "value": "Finds pathnames matching a pattern.\n\n```php\n$phpFiles = glob('*.php');\n$files = glob('src/**/*.php');\n```" },
+      "insertText": "glob(${1:'pattern'})",
+      "insertTextRules": 4,
+      "sortText": "03_glob"
+    },
+    {
+      "label": "scandir",
+      "kind": 1,
+      "detail": "List files and directories inside a path",
+      "documentation": { "value": "Lists files and directories inside the specified path.\n\n```php\n$files = scandir('/path/to/dir');\n$files = scandir('.', SCANDIR_SORT_DESCENDING);\n```" },
+      "insertText": "scandir(${1:'directory'})",
+      "insertTextRules": 4,
+      "sortText": "03_scandir"
+    },
+    {
+      "label": "basename",
+      "kind": 1,
+      "detail": "Return filename component of path",
+      "documentation": { "value": "Returns the trailing name component of a file path.\n\n```php\n$name = basename('/var/www/index.php'); // 'index.php'\n$name = basename($path, '.php'); // without extension\n```" },
+      "insertText": "basename(${1:\\$path})",
+      "insertTextRules": 4,
+      "sortText": "03_basename"
+    },
+    {
+      "label": "dirname",
+      "kind": 1,
+      "detail": "Return directory name component of path",
+      "documentation": { "value": "Returns the parent directory's path.\n\n```php\n$dir = dirname('/var/www/index.php'); // '/var/www'\n$dir = dirname(__FILE__);\n```" },
+      "insertText": "dirname(${1:\\$path})",
+      "insertTextRules": 4,
+      "sortText": "03_dirname"
+    },
+    {
+      "label": "pathinfo",
+      "kind": 1,
+      "detail": "Return information about a file path",
+      "documentation": { "value": "Returns information about a file path as an associative array.\n\n```php\n$info = pathinfo('/var/www/index.php');\n// ['dirname'=>'/var/www','basename'=>'index.php','extension'=>'php','filename'=>'index']\n```" },
+      "insertText": "pathinfo(${1:\\$path})",
+      "insertTextRules": 4,
+      "sortText": "03_pathinfo"
+    },
+    {
+      "label": "realpath",
+      "kind": 1,
+      "detail": "Return canonicalized absolute pathname",
+      "documentation": { "value": "Returns the canonicalized absolute pathname.\n\n```php\n$real = realpath('./relative/path');\n$real = realpath(__DIR__ . '/../config');\n```" },
+      "insertText": "realpath(${1:\\$path})",
+      "insertTextRules": 4,
+      "sortText": "03_realpath"
+    },
+    {
+      "label": "json_encode",
+      "kind": 1,
+      "detail": "Encode value as JSON",
+      "documentation": { "value": "Returns the JSON representation of a value.\n\n```php\n$json = json_encode(['name' => 'John', 'age' => 30]);\n$json = json_encode($data, JSON_PRETTY_PRINT);\n$json = json_encode($obj, JSON_UNESCAPED_UNICODE);\n```" },
+      "insertText": "json_encode(${1:\\$value})",
+      "insertTextRules": 4,
+      "sortText": "04_json_encode"
+    },
+    {
+      "label": "json_decode",
+      "kind": 1,
+      "detail": "Decode a JSON string",
+      "documentation": { "value": "Takes a JSON encoded string and converts it into a PHP variable.\n\n```php\n$data = json_decode($json, true); // associative array\n$obj = json_decode($json); // stdClass object\n$data = json_decode($json, true, 512, JSON_THROW_ON_ERROR);\n```" },
+      "insertText": "json_decode(${1:\\$json}, ${2:true})",
+      "insertTextRules": 4,
+      "sortText": "04_json_decode"
+    },
+    {
+      "label": "abs",
+      "kind": 1,
+      "detail": "Absolute value",
+      "documentation": { "value": "Returns the absolute value of a number.\n\n```php\n$abs = abs(-5); // 5\n$abs = abs($number);\n```" },
+      "insertText": "abs(${1:\\$number})",
+      "insertTextRules": 4,
+      "sortText": "05_abs"
+    },
+    {
+      "label": "ceil",
+      "kind": 1,
+      "detail": "Round fractions up",
+      "documentation": { "value": "Returns the next highest integer value by rounding up.\n\n```php\n$rounded = ceil(4.3); // 5\n$pages = ceil($total / $perPage);\n```" },
+      "insertText": "ceil(${1:\\$number})",
+      "insertTextRules": 4,
+      "sortText": "05_ceil"
+    },
+    {
+      "label": "floor",
+      "kind": 1,
+      "detail": "Round fractions down",
+      "documentation": { "value": "Returns the next lowest integer value by rounding down.\n\n```php\n$rounded = floor(4.9); // 4\n```" },
+      "insertText": "floor(${1:\\$number})",
+      "insertTextRules": 4,
+      "sortText": "05_floor"
+    },
+    {
+      "label": "round",
+      "kind": 1,
+      "detail": "Round a float",
+      "documentation": { "value": "Rounds a float to a specified precision.\n\n```php\n$rounded = round(3.14159, 2); // 3.14\n$rounded = round($value);\n```" },
+      "insertText": "round(${1:\\$number}, ${2:0})",
+      "insertTextRules": 4,
+      "sortText": "05_round"
+    },
+    {
+      "label": "max",
+      "kind": 1,
+      "detail": "Find highest value",
+      "documentation": { "value": "Finds the highest value from the given values.\n\n```php\n$max = max(1, 5, 3); // 5\n$max = max($arr);\n```" },
+      "insertText": "max(${1:\\$values})",
+      "insertTextRules": 4,
+      "sortText": "05_max"
+    },
+    {
+      "label": "min",
+      "kind": 1,
+      "detail": "Find lowest value",
+      "documentation": { "value": "Finds the lowest value from the given values.\n\n```php\n$min = min(1, 5, 3); // 1\n$min = min($arr);\n```" },
+      "insertText": "min(${1:\\$values})",
+      "insertTextRules": 4,
+      "sortText": "05_min"
+    },
+    {
+      "label": "pow",
+      "kind": 1,
+      "detail": "Exponential expression",
+      "documentation": { "value": "Returns base raised to the power of exponent.\n\n```php\n$result = pow(2, 8); // 256\n$result = 2 ** 8; // preferred syntax\n```" },
+      "insertText": "pow(${1:\\$base}, ${2:\\$exponent})",
+      "insertTextRules": 4,
+      "sortText": "05_pow"
+    },
+    {
+      "label": "sqrt",
+      "kind": 1,
+      "detail": "Square root",
+      "documentation": { "value": "Returns the square root of a number.\n\n```php\n$root = sqrt(16); // 4\n$root = sqrt($number);\n```" },
+      "insertText": "sqrt(${1:\\$number})",
+      "insertTextRules": 4,
+      "sortText": "05_sqrt"
+    },
+    {
+      "label": "rand",
+      "kind": 1,
+      "detail": "Generate a random integer",
+      "documentation": { "value": "Generates a random integer.\n\n```php\n$num = rand(); // random int\n$num = rand(1, 100); // between 1 and 100\n```" },
+      "insertText": "rand(${1:min}, ${2:max})",
+      "insertTextRules": 4,
+      "sortText": "05_rand"
+    },
+    {
+      "label": "random_int",
+      "kind": 1,
+      "detail": "Generate cryptographically secure random integer",
+      "documentation": { "value": "Generates cryptographically secure pseudo-random integers.\n\n```php\n$num = random_int(1, 100);\n$token = random_int(100000, 999999);\n```" },
+      "insertText": "random_int(${1:min}, ${2:max})",
+      "insertTextRules": 4,
+      "sortText": "05_random_int"
+    },
+    {
+      "label": "isset",
+      "kind": 14,
+      "detail": "Determine if a variable is set and is not null",
+      "documentation": { "value": "Determines if a variable is declared and is different than null.\n\n```php\nif (isset($var)) { ... }\nif (isset($arr['key'])) { ... }\nif (isset($a, $b, $c)) { ... } // all must be set\n```" },
+      "insertText": "isset(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_isset"
+    },
+    {
+      "label": "unset",
+      "kind": 14,
+      "detail": "Unset a given variable",
+      "documentation": { "value": "Destroys the specified variables.\n\n```php\nunset($var);\nunset($arr['key']);\nunset($a, $b, $c);\n```" },
+      "insertText": "unset(${1:\\$var});",
+      "insertTextRules": 4,
+      "sortText": "06_unset"
+    },
+    {
+      "label": "empty",
+      "kind": 14,
+      "detail": "Determine whether a variable is empty",
+      "documentation": { "value": "Determines whether a variable is considered empty. A variable is empty if it doesn't exist or its value equals false.\n\n```php\nif (empty($var)) { ... }\nif (!empty($arr)) { ... }\n```" },
+      "insertText": "empty(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_empty"
+    },
+    {
+      "label": "is_array",
+      "kind": 1,
+      "detail": "Check if variable is an array",
+      "documentation": { "value": "Finds whether the given variable is an array.\n\n```php\nif (is_array($data)) { ... }\n```" },
+      "insertText": "is_array(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_is_array"
+    },
+    {
+      "label": "is_string",
+      "kind": 1,
+      "detail": "Check if variable is a string",
+      "documentation": { "value": "Finds whether the type of a variable is string.\n\n```php\nif (is_string($data)) { ... }\n```" },
+      "insertText": "is_string(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_is_string"
+    },
+    {
+      "label": "is_int",
+      "kind": 1,
+      "detail": "Check if variable is an integer",
+      "documentation": { "value": "Finds whether the type of a variable is integer.\n\n```php\nif (is_int($value)) { ... }\n```" },
+      "insertText": "is_int(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_is_int"
+    },
+    {
+      "label": "is_null",
+      "kind": 1,
+      "detail": "Check if variable is null",
+      "documentation": { "value": "Finds whether the given variable is null.\n\n```php\nif (is_null($value)) { ... }\n```" },
+      "insertText": "is_null(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_is_null"
+    },
+    {
+      "label": "is_numeric",
+      "kind": 1,
+      "detail": "Check if variable is numeric",
+      "documentation": { "value": "Finds whether a variable is a number or a numeric string.\n\n```php\nif (is_numeric($input)) { ... }\nis_numeric('42'); // true\nis_numeric('3.14'); // true\n```" },
+      "insertText": "is_numeric(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_is_numeric"
+    },
+    {
+      "label": "is_bool",
+      "kind": 1,
+      "detail": "Check if variable is a boolean",
+      "documentation": { "value": "Finds out whether a variable is a boolean.\n\n```php\nif (is_bool($value)) { ... }\n```" },
+      "insertText": "is_bool(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_is_bool"
+    },
+    {
+      "label": "gettype",
+      "kind": 1,
+      "detail": "Get the type of a variable",
+      "documentation": { "value": "Gets the type of a variable as a string.\n\n```php\necho gettype(42); // 'integer'\necho gettype([]); // 'array'\n```" },
+      "insertText": "gettype(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_gettype"
+    },
+    {
+      "label": "intval",
+      "kind": 1,
+      "detail": "Get integer value of a variable",
+      "documentation": { "value": "Gets the integer value of a variable.\n\n```php\n$int = intval('42'); // 42\n$int = intval('0x1A', 16); // 26\n```" },
+      "insertText": "intval(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_intval"
+    },
+    {
+      "label": "floatval",
+      "kind": 1,
+      "detail": "Get float value of a variable",
+      "documentation": { "value": "Gets the float value of a variable.\n\n```php\n$float = floatval('3.14'); // 3.14\n```" },
+      "insertText": "floatval(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_floatval"
+    },
+    {
+      "label": "strval",
+      "kind": 1,
+      "detail": "Get string value of a variable",
+      "documentation": { "value": "Gets the string value of a variable.\n\n```php\n$str = strval(42); // '42'\n$str = strval($number);\n```" },
+      "insertText": "strval(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_strval"
+    },
+    {
+      "label": "boolval",
+      "kind": 1,
+      "detail": "Get boolean value of a variable",
+      "documentation": { "value": "Gets the boolean value of a variable.\n\n```php\n$bool = boolval(1); // true\n$bool = boolval(''); // false\n```" },
+      "insertText": "boolval(${1:\\$var})",
+      "insertTextRules": 4,
+      "sortText": "06_boolval"
+    },
+    {
+      "label": "class",
+      "kind": 7,
+      "detail": "Define a class",
+      "documentation": { "value": "Defines a class with properties, methods, and optional constructor.\n\n```php\nclass User {\n    public function __construct(\n        private string $name,\n        private int $age,\n    ) {}\n\n    public function getName(): string {\n        return $this->name;\n    }\n}\n```" },
+      "insertText": "class ${1:ClassName}\n{\n\tpublic function __construct(\n\t\t${2}\n\t) {}\n\n\t${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_class"
+    },
+    {
+      "label": "interface",
+      "kind": 7,
+      "detail": "Define an interface",
+      "documentation": { "value": "Defines an interface that classes can implement.\n\n```php\ninterface Loggable {\n    public function log(string $message): void;\n}\n```" },
+      "insertText": "interface ${1:InterfaceName}\n{\n\t${2:public function method(): void;}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_interface"
+    },
+    {
+      "label": "trait",
+      "kind": 7,
+      "detail": "Define a trait",
+      "documentation": { "value": "Defines a trait for horizontal code reuse.\n\n```php\ntrait HasTimestamps {\n    public DateTime $createdAt;\n    public DateTime $updatedAt;\n}\n```" },
+      "insertText": "trait ${1:TraitName}\n{\n\t${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_trait"
+    },
+    {
+      "label": "abstract class",
+      "kind": 7,
+      "detail": "Define an abstract class",
+      "documentation": { "value": "Defines an abstract class that cannot be instantiated directly.\n\n```php\nabstract class Shape {\n    abstract public function area(): float;\n\n    public function describe(): string {\n        return 'Area: ' . $this->area();\n    }\n}\n```" },
+      "insertText": "abstract class ${1:ClassName}\n{\n\tabstract public function ${2:method}(): ${3:void};\n\n\t${4}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_abstract_class"
+    },
+    {
+      "label": "enum",
+      "kind": 7,
+      "detail": "Define an enumeration (PHP 8.1+)",
+      "documentation": { "value": "Defines an enumeration, a restrictive type with a fixed set of possible values.\n\n```php\nenum Status: string {\n    case Active = 'active';\n    case Inactive = 'inactive';\n    case Pending = 'pending';\n}\n```" },
+      "insertText": "enum ${1:Name}: ${2:string}\n{\n\tcase ${3:Value} = '${4:value}';\n}",
+      "insertTextRules": 4,
+      "sortText": "07_enum"
+    },
+    {
+      "label": "public function",
+      "kind": 1,
+      "detail": "Define a public method",
+      "documentation": { "value": "Defines a public method accessible from anywhere.\n\n```php\npublic function getName(): string\n{\n    return $this->name;\n}\n```" },
+      "insertText": "public function ${1:name}(${2}): ${3:void}\n{\n\t${4}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_public_function"
+    },
+    {
+      "label": "private function",
+      "kind": 1,
+      "detail": "Define a private method",
+      "documentation": { "value": "Defines a private method accessible only within the declaring class.\n\n```php\nprivate function validate(): bool\n{\n    return $this->value > 0;\n}\n```" },
+      "insertText": "private function ${1:name}(${2}): ${3:void}\n{\n\t${4}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_private_function"
+    },
+    {
+      "label": "protected function",
+      "kind": 1,
+      "detail": "Define a protected method",
+      "documentation": { "value": "Defines a protected method accessible within the class and its subclasses.\n\n```php\nprotected function process(): void\n{\n    // ...\n}\n```" },
+      "insertText": "protected function ${1:name}(${2}): ${3:void}\n{\n\t${4}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_protected_function"
+    },
+    {
+      "label": "__construct",
+      "kind": 1,
+      "detail": "Constructor method",
+      "documentation": { "value": "Defines the constructor, called when an object is created.\n\n```php\npublic function __construct(\n    private string $name,\n    private int $age = 0,\n) {}\n```" },
+      "insertText": "public function __construct(\n\t${1:private string \\$name},\n) {\n\t${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "07___construct"
+    },
+    {
+      "label": "__destruct",
+      "kind": 1,
+      "detail": "Destructor method",
+      "documentation": { "value": "Called when there are no more references to an object or during shutdown.\n\n```php\npublic function __destruct()\n{\n    fclose($this->handle);\n}\n```" },
+      "insertText": "public function __destruct()\n{\n\t${1}\n}",
+      "insertTextRules": 4,
+      "sortText": "07___destruct"
+    },
+    {
+      "label": "__toString",
+      "kind": 1,
+      "detail": "String representation method",
+      "documentation": { "value": "Called when an object is converted to a string.\n\n```php\npublic function __toString(): string\n{\n    return $this->name;\n}\n```" },
+      "insertText": "public function __toString(): string\n{\n\treturn ${1:\\$this->name};\n}",
+      "insertTextRules": 4,
+      "sortText": "07___toString"
+    },
+    {
+      "label": "__get",
+      "kind": 1,
+      "detail": "Magic getter method",
+      "documentation": { "value": "Called when reading inaccessible or non-existing properties.\n\n```php\npublic function __get(string $name): mixed\n{\n    return $this->data[$name] ?? null;\n}\n```" },
+      "insertText": "public function __get(string \\$name): mixed\n{\n\t${1:return \\$this->data[\\$name] ?? null;}\n}",
+      "insertTextRules": 4,
+      "sortText": "07___get"
+    },
+    {
+      "label": "__set",
+      "kind": 1,
+      "detail": "Magic setter method",
+      "documentation": { "value": "Called when writing to inaccessible or non-existing properties.\n\n```php\npublic function __set(string $name, mixed $value): void\n{\n    $this->data[$name] = $value;\n}\n```" },
+      "insertText": "public function __set(string \\$name, mixed \\$value): void\n{\n\t${1:\\$this->data[\\$name] = \\$value;}\n}",
+      "insertTextRules": 4,
+      "sortText": "07___set"
+    },
+    {
+      "label": "__call",
+      "kind": 1,
+      "detail": "Magic method call",
+      "documentation": { "value": "Called when invoking inaccessible methods in an object context.\n\n```php\npublic function __call(string $name, array $arguments): mixed\n{\n    // ...\n}\n```" },
+      "insertText": "public function __call(string \\$name, array \\$arguments): mixed\n{\n\t${1}\n}",
+      "insertTextRules": 4,
+      "sortText": "07___call"
+    },
+    {
+      "label": "__callStatic",
+      "kind": 1,
+      "detail": "Magic static method call",
+      "documentation": { "value": "Called when invoking inaccessible methods in a static context.\n\n```php\npublic static function __callStatic(string $name, array $arguments): mixed\n{\n    // ...\n}\n```" },
+      "insertText": "public static function __callStatic(string \\$name, array \\$arguments): mixed\n{\n\t${1}\n}",
+      "insertTextRules": 4,
+      "sortText": "07___callStatic"
+    },
+    {
+      "label": "__invoke",
+      "kind": 1,
+      "detail": "Called when object used as function",
+      "documentation": { "value": "Called when a script tries to call an object as a function.\n\n```php\npublic function __invoke(mixed ...$args): mixed\n{\n    return $this->handle(...$args);\n}\n```" },
+      "insertText": "public function __invoke(${1}): ${2:mixed}\n{\n\t${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "07___invoke"
+    },
+    {
+      "label": "readonly",
+      "kind": 14,
+      "detail": "Readonly property modifier (PHP 8.1+)",
+      "documentation": { "value": "Declares a property that can only be initialized once.\n\n```php\nclass User {\n    public function __construct(\n        public readonly string $name,\n        public readonly int $id,\n    ) {}\n}\n```" },
+      "insertText": "readonly ${1:string} ${2:\\$property}",
+      "insertTextRules": 4,
+      "sortText": "07_readonly"
+    },
+    {
+      "label": "match",
+      "kind": 14,
+      "detail": "Match expression (PHP 8.0+)",
+      "documentation": { "value": "Evaluates a subject and returns a value based on an identity check.\n\n```php\n$result = match($status) {\n    'active' => 'Active',\n    'inactive', 'disabled' => 'Inactive',\n    default => 'Unknown',\n};\n```" },
+      "insertText": "match(${1:\\$value}) {\n\t${2:'case'} => ${3:'result'},\n\tdefault => ${4:'default'},\n}",
+      "insertTextRules": 4,
+      "sortText": "07_match"
+    },
+    {
+      "label": "date",
+      "kind": 1,
+      "detail": "Format a local date/time",
+      "documentation": { "value": "Returns a string formatted according to the given format string.\n\n```php\necho date('Y-m-d'); // '2024-01-15'\necho date('H:i:s'); // '14:30:00'\necho date('D, d M Y', $timestamp);\n```" },
+      "insertText": "date('${1:Y-m-d H:i:s}')",
+      "insertTextRules": 4,
+      "sortText": "08_date"
+    },
+    {
+      "label": "time",
+      "kind": 1,
+      "detail": "Return current Unix timestamp",
+      "documentation": { "value": "Returns the current time measured in seconds since the Unix Epoch.\n\n```php\n$now = time();\n$future = time() + 3600; // 1 hour from now\n```" },
+      "insertText": "time()",
+      "insertTextRules": 4,
+      "sortText": "08_time"
+    },
+    {
+      "label": "strtotime",
+      "kind": 1,
+      "detail": "Parse date/time string to timestamp",
+      "documentation": { "value": "Parses an English textual date/time description into a Unix timestamp.\n\n```php\n$ts = strtotime('next Monday');\n$ts = strtotime('+1 week');\n$ts = strtotime('2024-12-31');\n```" },
+      "insertText": "strtotime('${1:+1 day}')",
+      "insertTextRules": 4,
+      "sortText": "08_strtotime"
+    },
+    {
+      "label": "mktime",
+      "kind": 1,
+      "detail": "Get Unix timestamp for a date",
+      "documentation": { "value": "Returns the Unix timestamp corresponding to the arguments given.\n\n```php\n$ts = mktime(12, 0, 0, 6, 15, 2024);\n```" },
+      "insertText": "mktime(${1:hour}, ${2:minute}, ${3:second}, ${4:month}, ${5:day}, ${6:year})",
+      "insertTextRules": 4,
+      "sortText": "08_mktime"
+    },
+    {
+      "label": "new DateTime",
+      "kind": 4,
+      "detail": "Create a new DateTime object",
+      "documentation": { "value": "Creates a new DateTime object representing the specified date and time.\n\n```php\n$now = new DateTime();\n$date = new DateTime('2024-01-15');\n$date = new DateTime('tomorrow');\n```" },
+      "insertText": "new DateTime(${1:'now'})",
+      "insertTextRules": 4,
+      "sortText": "08_datetime"
+    },
+    {
+      "label": "new DateTimeImmutable",
+      "kind": 4,
+      "detail": "Create an immutable DateTime object",
+      "documentation": { "value": "Creates an immutable DateTime object. Modification methods return a new instance.\n\n```php\n$now = new DateTimeImmutable();\n$date = new DateTimeImmutable('2024-01-15 14:30:00');\n$tomorrow = $date->modify('+1 day');\n```" },
+      "insertText": "new DateTimeImmutable(${1:'now'})",
+      "insertTextRules": 4,
+      "sortText": "08_datetime_immutable"
+    },
+    {
+      "label": "die",
+      "kind": 14,
+      "detail": "Output message and terminate",
+      "documentation": { "value": "Outputs a message and terminates the current script. Equivalent to exit.\n\n```php\ndie('Fatal error occurred');\n$result or die('Failed');\n```" },
+      "insertText": "die(${1:'message'});",
+      "insertTextRules": 4,
+      "sortText": "09_die"
+    },
+    {
+      "label": "exit",
+      "kind": 14,
+      "detail": "Output message and terminate",
+      "documentation": { "value": "Outputs a message and terminates the current script.\n\n```php\nexit(0); // success\nexit('Error message');\n```" },
+      "insertText": "exit(${1:0});",
+      "insertTextRules": 4,
+      "sortText": "09_exit"
+    },
+    {
+      "label": "sleep",
+      "kind": 1,
+      "detail": "Delay execution in seconds",
+      "documentation": { "value": "Delays the program execution for the given number of seconds.\n\n```php\nsleep(2); // pause for 2 seconds\n```" },
+      "insertText": "sleep(${1:seconds})",
+      "insertTextRules": 4,
+      "sortText": "09_sleep"
+    },
+    {
+      "label": "usleep",
+      "kind": 1,
+      "detail": "Delay execution in microseconds",
+      "documentation": { "value": "Delays the program execution for the given number of microseconds.\n\n```php\nusleep(500000); // 0.5 seconds\n```" },
+      "insertText": "usleep(${1:microseconds})",
+      "insertTextRules": 4,
+      "sortText": "09_usleep"
+    },
+    {
+      "label": "class_exists",
+      "kind": 1,
+      "detail": "Check if class has been defined",
+      "documentation": { "value": "Checks if the class has been defined.\n\n```php\nif (class_exists('App\\\\Models\\\\User')) { ... }\n```" },
+      "insertText": "class_exists(${1:'ClassName'})",
+      "insertTextRules": 4,
+      "sortText": "09_class_exists"
+    },
+    {
+      "label": "function_exists",
+      "kind": 1,
+      "detail": "Check if function has been defined",
+      "documentation": { "value": "Checks if the given function has been defined.\n\n```php\nif (function_exists('curl_init')) { ... }\n```" },
+      "insertText": "function_exists(${1:'functionName'})",
+      "insertTextRules": 4,
+      "sortText": "09_function_exists"
+    },
+    {
+      "label": "method_exists",
+      "kind": 1,
+      "detail": "Check if class method exists",
+      "documentation": { "value": "Checks if the class method exists in the given object or class.\n\n```php\nif (method_exists($obj, 'render')) { ... }\n```" },
+      "insertText": "method_exists(${1:\\$object}, ${2:'methodName'})",
+      "insertTextRules": 4,
+      "sortText": "09_method_exists"
+    },
+    {
+      "label": "property_exists",
+      "kind": 1,
+      "detail": "Check if property exists in object or class",
+      "documentation": { "value": "Checks if the object or class has a property.\n\n```php\nif (property_exists($obj, 'name')) { ... }\n```" },
+      "insertText": "property_exists(${1:\\$object}, ${2:'propertyName'})",
+      "insertTextRules": 4,
+      "sortText": "09_property_exists"
+    },
+    {
+      "label": "header",
+      "kind": 1,
+      "detail": "Send a raw HTTP header",
+      "documentation": { "value": "Send a raw HTTP header. Must be called before any output.\n\n```php\nheader('Content-Type: application/json');\nheader('Location: /dashboard');\nheader('HTTP/1.1 404 Not Found');\n```" },
+      "insertText": "header('${1:Content-Type: application/json}');",
+      "insertTextRules": 4,
+      "sortText": "09_header"
+    },
+    {
+      "label": "setcookie",
+      "kind": 1,
+      "detail": "Send a cookie",
+      "documentation": { "value": "Sends a cookie. Must be called before any output.\n\n```php\nsetcookie('name', 'value', time() + 3600);\nsetcookie('user', $name, [\n    'expires' => time() + 86400,\n    'path' => '/',\n    'secure' => true,\n    'httponly' => true,\n]);\n```" },
+      "insertText": "setcookie('${1:name}', ${2:\\$value}, ${3:time() + 3600})",
+      "insertTextRules": 4,
+      "sortText": "09_setcookie"
+    },
+    {
+      "label": "sizeof",
+      "kind": 1,
+      "detail": "Alias of count()",
+      "documentation": { "value": "Alias of count(). Counts all elements in an array.\n\n```php\n$total = sizeof($arr);\n```" },
+      "insertText": "sizeof(${1:\\$array})",
+      "insertTextRules": 4,
+      "sortText": "02_sizeof"
+    },
+    {
+      "label": "copy",
+      "kind": 1,
+      "detail": "Copy a file",
+      "documentation": { "value": "Copies a file.\n\n```php\ncopy('source.txt', 'dest.txt');\nif (copy($src, $dst)) { echo 'Copied'; }\n```" },
+      "insertText": "copy(${1:'source'}, ${2:'dest'})",
+      "insertTextRules": 4,
+      "sortText": "03_copy"
+    },
+    {
+      "label": "rename",
+      "kind": 1,
+      "detail": "Rename a file or directory",
+      "documentation": { "value": "Renames a file or directory.\n\n```php\nrename('old.txt', 'new.txt');\nrename($oldPath, $newPath);\n```" },
+      "insertText": "rename(${1:'oldname'}, ${2:'newname'})",
+      "insertTextRules": 4,
+      "sortText": "03_rename"
+    },
+    {
+      "label": "rmdir",
+      "kind": 1,
+      "detail": "Remove a directory",
+      "documentation": { "value": "Removes a directory. The directory must be empty.\n\n```php\nrmdir('empty_dir');\n```" },
+      "insertText": "rmdir(${1:'directory'})",
+      "insertTextRules": 4,
+      "sortText": "03_rmdir"
+    },
+    {
+      "label": "mt_rand",
+      "kind": 1,
+      "detail": "Generate a random value via Mersenne Twister",
+      "documentation": { "value": "Generates a random value via the Mersenne Twister Random Number Generator.\n\n```php\n$num = mt_rand(1, 100);\n```" },
+      "insertText": "mt_rand(${1:min}, ${2:max})",
+      "insertTextRules": 4,
+      "sortText": "05_mt_rand"
+    },
+    {
+      "label": "random_bytes",
+      "kind": 1,
+      "detail": "Generate cryptographically secure random bytes",
+      "documentation": { "value": "Generates cryptographically secure pseudo-random bytes.\n\n```php\n$bytes = random_bytes(32);\n$hex = bin2hex(random_bytes(16));\n```" },
+      "insertText": "random_bytes(${1:length})",
+      "insertTextRules": 4,
+      "sortText": "05_random_bytes"
+    },
+    {
+      "label": "settype",
+      "kind": 1,
+      "detail": "Set the type of a variable",
+      "documentation": { "value": "Sets the type of a variable.\n\n```php\nsettype($var, 'integer');\nsettype($val, 'string');\n```" },
+      "insertText": "settype(${1:\\$var}, '${2:integer}')",
+      "insertTextRules": 4,
+      "sortText": "06_settype"
+    },
+    {
+      "label": "new",
+      "kind": 14,
+      "detail": "Create a new instance of a class",
+      "documentation": { "value": "Creates a new instance of a class.\n\n```php\n$obj = new ClassName();\n$user = new User('John', 30);\n$date = new DateTime();\n```" },
+      "insertText": "new ${1:ClassName}(${2})",
+      "insertTextRules": 4,
+      "sortText": "07_new"
+    },
+    {
+      "label": "extends",
+      "kind": 14,
+      "detail": "Inherit from a class",
+      "documentation": { "value": "A class can inherit methods and properties from another class using extends.\n\n```php\nclass Admin extends User {\n    // ...\n}\n```" },
+      "insertText": "extends ${1:ParentClass}",
+      "insertTextRules": 4,
+      "sortText": "07_extends"
+    },
+    {
+      "label": "implements",
+      "kind": 14,
+      "detail": "Implement an interface",
+      "documentation": { "value": "A class can implement one or more interfaces.\n\n```php\nclass Logger implements LoggerInterface {\n    // ...\n}\n```" },
+      "insertText": "implements ${1:InterfaceName}",
+      "insertTextRules": 4,
+      "sortText": "07_implements"
+    },
+    {
+      "label": "static",
+      "kind": 14,
+      "detail": "Static keyword",
+      "documentation": { "value": "Declares class members (properties or methods) as accessible without needing an instantiation.\n\n```php\nclass Counter {\n    public static int $count = 0;\n\n    public static function increment(): void {\n        self::$count++;\n    }\n}\n```" },
+      "insertText": "static ${1}",
+      "insertTextRules": 4,
+      "sortText": "07_static"
+    },
+    {
+      "label": "date_create",
+      "kind": 1,
+      "detail": "Create a new DateTime object (procedural)",
+      "documentation": { "value": "Creates a new DateTime object. Procedural alias of DateTime::__construct.\n\n```php\n$date = date_create('2024-01-15');\n$now = date_create();\n```" },
+      "insertText": "date_create('${1:now}')",
+      "insertTextRules": 4,
+      "sortText": "08_date_create"
+    },
+    {
+      "label": "date_format",
+      "kind": 1,
+      "detail": "Format a DateTime object",
+      "documentation": { "value": "Alias of DateTime::format. Returns a formatted date string.\n\n```php\n$formatted = date_format($date, 'Y-m-d H:i:s');\n```" },
+      "insertText": "date_format(${1:\\$date}, '${2:Y-m-d}')",
+      "insertTextRules": 4,
+      "sortText": "08_date_format"
+    },
+    {
+      "label": "date_diff",
+      "kind": 1,
+      "detail": "Return the difference between two dates",
+      "documentation": { "value": "Returns a DateInterval representing the difference between two DateTime objects.\n\n```php\n$diff = date_diff($date1, $date2);\necho $diff->days . ' days';\n```" },
+      "insertText": "date_diff(${1:\\$date1}, ${2:\\$date2})",
+      "insertTextRules": 4,
+      "sortText": "08_date_diff"
+    }
+  ]
+}