@enjoys/context-engine 1.0.0 → 1.0.1

package/data/completion/java.json

@@ -0,0 +1,1112 @@
+{
+  "language": "java",
+  "completions": [
+    {
+      "label": "System.out.println",
+      "kind": 1,
+      "detail": "Print to standard output with newline",
+      "documentation": { "value": "Prints a message to the standard output stream followed by a newline.\n\n```java\nSystem.out.println(\"Hello, World!\");\nSystem.out.println(42);\nSystem.out.println(\"Value: \" + x);\n```" },
+      "insertText": "System.out.println(${1:message});",
+      "insertTextRules": 4,
+      "sortText": "00_sysout"
+    },
+    {
+      "label": "System.out.print",
+      "kind": 1,
+      "detail": "Print to standard output without newline",
+      "documentation": { "value": "Prints a message to the standard output stream without a trailing newline.\n\n```java\nSystem.out.print(\"Enter name: \");\nSystem.out.print(value);\n```" },
+      "insertText": "System.out.print(${1:message});",
+      "insertTextRules": 4,
+      "sortText": "00_sysprint"
+    },
+    {
+      "label": "System.out.printf",
+      "kind": 1,
+      "detail": "Formatted print to standard output",
+      "documentation": { "value": "Prints a formatted string to the standard output stream using format specifiers.\n\n```java\nSystem.out.printf(\"Name: %s, Age: %d%n\", name, age);\nSystem.out.printf(\"%.2f%n\", 3.14159);\nSystem.out.printf(\"%10s | %5d%n\", item, count);\n```" },
+      "insertText": "System.out.printf(\"${1:%s}%n\", ${2:args});",
+      "insertTextRules": 4,
+      "sortText": "00_sysprintf"
+    },
+    {
+      "label": "System.err.println",
+      "kind": 1,
+      "detail": "Print to standard error with newline",
+      "documentation": { "value": "Prints a message to the standard error stream followed by a newline.\n\n```java\nSystem.err.println(\"Error: something went wrong\");\nSystem.err.println(exception.getMessage());\n```" },
+      "insertText": "System.err.println(${1:message});",
+      "insertTextRules": 4,
+      "sortText": "00_syserr"
+    },
+    {
+      "label": "public class",
+      "kind": 7,
+      "detail": "Declare a public class",
+      "documentation": { "value": "Declares a new public class. The file name must match the class name.\n\n```java\npublic class MyClass {\n    // fields and methods\n}\n```" },
+      "insertText": "public class ${1:ClassName} {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_class"
+    },
+    {
+      "label": "private",
+      "kind": 13,
+      "detail": "Private access modifier",
+      "documentation": { "value": "Restricts access to the declaring class only.\n\n```java\nprivate int count;\nprivate void helper() { }\n```" },
+      "insertText": "private ",
+      "insertTextRules": 0,
+      "sortText": "01_private"
+    },
+    {
+      "label": "protected",
+      "kind": 13,
+      "detail": "Protected access modifier",
+      "documentation": { "value": "Allows access within the same package and subclasses.\n\n```java\nprotected String name;\nprotected void init() { }\n```" },
+      "insertText": "protected ",
+      "insertTextRules": 0,
+      "sortText": "01_protected"
+    },
+    {
+      "label": "static",
+      "kind": 13,
+      "detail": "Static modifier",
+      "documentation": { "value": "Declares a class-level member that belongs to the class rather than instances.\n\n```java\npublic static int count = 0;\npublic static void main(String[] args) { }\n```" },
+      "insertText": "static ",
+      "insertTextRules": 0,
+      "sortText": "01_static"
+    },
+    {
+      "label": "final",
+      "kind": 13,
+      "detail": "Final modifier",
+      "documentation": { "value": "Prevents modification: final variables cannot be reassigned, final methods cannot be overridden, final classes cannot be extended.\n\n```java\nfinal int MAX = 100;\nfinal List<String> items = new ArrayList<>();\n```" },
+      "insertText": "final ",
+      "insertTextRules": 0,
+      "sortText": "01_final"
+    },
+    {
+      "label": "abstract",
+      "kind": 13,
+      "detail": "Abstract modifier",
+      "documentation": { "value": "Declares an abstract class or method. Abstract classes cannot be instantiated; abstract methods must be implemented by subclasses.\n\n```java\npublic abstract class Shape {\n    public abstract double area();\n}\n```" },
+      "insertText": "abstract ",
+      "insertTextRules": 0,
+      "sortText": "01_abstract"
+    },
+    {
+      "label": "interface",
+      "kind": 7,
+      "detail": "Declare an interface",
+      "documentation": { "value": "Declares an interface that classes can implement.\n\n```java\npublic interface Drawable {\n    void draw();\n    default void reset() { }\n}\n```" },
+      "insertText": "public interface ${1:InterfaceName} {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_interface"
+    },
+    {
+      "label": "extends",
+      "kind": 13,
+      "detail": "Extend a class",
+      "documentation": { "value": "Indicates that a class inherits from a superclass.\n\n```java\npublic class Dog extends Animal {\n    // inherited and new members\n}\n```" },
+      "insertText": "extends ${1:SuperClass}",
+      "insertTextRules": 4,
+      "sortText": "01_extends"
+    },
+    {
+      "label": "implements",
+      "kind": 13,
+      "detail": "Implement an interface",
+      "documentation": { "value": "Indicates that a class implements one or more interfaces.\n\n```java\npublic class Circle implements Drawable, Serializable {\n    // implement interface methods\n}\n```" },
+      "insertText": "implements ${1:Interface}",
+      "insertTextRules": 4,
+      "sortText": "01_implements"
+    },
+    {
+      "label": "new",
+      "kind": 13,
+      "detail": "Create a new instance",
+      "documentation": { "value": "Creates a new instance of a class by invoking its constructor.\n\n```java\nList<String> list = new ArrayList<>();\nMyClass obj = new MyClass(arg1, arg2);\n```" },
+      "insertText": "new ${1:ClassName}(${2})",
+      "insertTextRules": 4,
+      "sortText": "01_new"
+    },
+    {
+      "label": "return",
+      "kind": 13,
+      "detail": "Return statement",
+      "documentation": { "value": "Returns a value from a method or exits a void method.\n\n```java\nreturn result;\nreturn x + y;\nreturn;\n```" },
+      "insertText": "return ${1:value};",
+      "insertTextRules": 4,
+      "sortText": "01_return"
+    },
+    {
+      "label": "throw",
+      "kind": 13,
+      "detail": "Throw an exception",
+      "documentation": { "value": "Throws an exception to be caught by a try-catch block or propagated up the call stack.\n\n```java\nthrow new IllegalArgumentException(\"Invalid value: \" + value);\nthrow new RuntimeException(\"Unexpected error\", cause);\n```" },
+      "insertText": "throw new ${1:RuntimeException}(${2:\"message\"});",
+      "insertTextRules": 4,
+      "sortText": "01_throw"
+    },
+    {
+      "label": "throws",
+      "kind": 13,
+      "detail": "Declare thrown exceptions",
+      "documentation": { "value": "Declares that a method may throw checked exceptions.\n\n```java\npublic void readFile(String path) throws IOException {\n    // may throw IOException\n}\n```" },
+      "insertText": "throws ${1:Exception}",
+      "insertTextRules": 4,
+      "sortText": "01_throws"
+    },
+    {
+      "label": "try-catch",
+      "kind": 14,
+      "detail": "Try-catch block",
+      "documentation": { "value": "Wraps code that may throw exceptions and handles them gracefully.\n\n```java\ntry {\n    // risky code\n} catch (Exception e) {\n    e.printStackTrace();\n} finally {\n    // cleanup\n}\n```" },
+      "insertText": "try {\n\t${1}\n} catch (${2:Exception} ${3:e}) {\n\t${4:e.printStackTrace();}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_trycatch"
+    },
+    {
+      "label": "try-with-resources",
+      "kind": 14,
+      "detail": "Try-with-resources block",
+      "documentation": { "value": "Automatically closes resources that implement AutoCloseable when the block exits.\n\n```java\ntry (var reader = new BufferedReader(new FileReader(path))) {\n    String line = reader.readLine();\n} catch (IOException e) {\n    e.printStackTrace();\n}\n```" },
+      "insertText": "try (${1:var resource = new Resource()}) {\n\t${2}\n} catch (${3:Exception} ${4:e}) {\n\t${5:e.printStackTrace();}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_trywith"
+    },
+    {
+      "label": "synchronized",
+      "kind": 13,
+      "detail": "Synchronized block or method",
+      "documentation": { "value": "Ensures only one thread at a time can execute the synchronized code, providing mutual exclusion.\n\n```java\nsynchronized (lock) {\n    // thread-safe code\n}\n\npublic synchronized void update() { }\n```" },
+      "insertText": "synchronized (${1:this}) {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_synchronized"
+    },
+    {
+      "label": "volatile",
+      "kind": 13,
+      "detail": "Volatile field modifier",
+      "documentation": { "value": "Ensures that reads and writes to the variable are visible across threads, preventing caching in CPU registers.\n\n```java\nprivate volatile boolean running = true;\n```" },
+      "insertText": "volatile ",
+      "insertTextRules": 0,
+      "sortText": "01_volatile"
+    },
+    {
+      "label": "transient",
+      "kind": 13,
+      "detail": "Transient field modifier",
+      "documentation": { "value": "Marks a field to be excluded from serialization.\n\n```java\nprivate transient int cachedValue;\n```" },
+      "insertText": "transient ",
+      "insertTextRules": 0,
+      "sortText": "01_transient"
+    },
+    {
+      "label": "instanceof",
+      "kind": 13,
+      "detail": "Type check operator",
+      "documentation": { "value": "Tests whether an object is an instance of a specific type. Supports pattern matching (Java 16+).\n\n```java\nif (obj instanceof String s) {\n    System.out.println(s.length());\n}\nif (animal instanceof Dog) { }\n```" },
+      "insertText": "instanceof ${1:Type} ${2:var}",
+      "insertTextRules": 4,
+      "sortText": "01_instanceof"
+    },
+    {
+      "label": "switch expression",
+      "kind": 14,
+      "detail": "Switch expression (Java 14+)",
+      "documentation": { "value": "A switch expression that yields a value using arrow syntax.\n\n```java\nString result = switch (day) {\n    case MONDAY, FRIDAY -> \"Work\";\n    case SATURDAY, SUNDAY -> \"Rest\";\n    default -> \"Unknown\";\n};\n```" },
+      "insertText": "switch (${1:variable}) {\n\tcase ${2:value1} -> ${3:result1};\n\tcase ${4:value2} -> ${5:result2};\n\tdefault -> ${6:defaultResult};\n}",
+      "insertTextRules": 4,
+      "sortText": "01_switch"
+    },
+    {
+      "label": "record",
+      "kind": 7,
+      "detail": "Record class (Java 16+)",
+      "documentation": { "value": "Declares a record — a concise immutable data carrier that auto-generates equals, hashCode, toString, and accessor methods.\n\n```java\npublic record Point(int x, int y) { }\npublic record Person(String name, int age) { }\n```" },
+      "insertText": "public record ${1:RecordName}(${2:fields}) {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_record"
+    },
+    {
+      "label": "sealed",
+      "kind": 13,
+      "detail": "Sealed class modifier (Java 17+)",
+      "documentation": { "value": "Restricts which classes can extend or implement the declared type.\n\n```java\npublic sealed class Shape permits Circle, Rectangle, Triangle { }\n```" },
+      "insertText": "sealed ",
+      "insertTextRules": 0,
+      "sortText": "01_sealed"
+    },
+    {
+      "label": "permits",
+      "kind": 13,
+      "detail": "Permitted subclasses (Java 17+)",
+      "documentation": { "value": "Specifies the allowed subclasses of a sealed class.\n\n```java\npublic sealed class Shape permits Circle, Rectangle { }\n```" },
+      "insertText": "permits ${1:SubClass}",
+      "insertTextRules": 4,
+      "sortText": "01_permits"
+    },
+    {
+      "label": "var",
+      "kind": 13,
+      "detail": "Local variable type inference (Java 10+)",
+      "documentation": { "value": "Infers the type of a local variable from the initializer expression.\n\n```java\nvar list = new ArrayList<String>();\nvar map = Map.of(\"key\", \"value\");\nvar count = 0;\n```" },
+      "insertText": "var ${1:name} = ${2:value};",
+      "insertTextRules": 4,
+      "sortText": "01_var"
+    },
+    {
+      "label": "String.valueOf",
+      "kind": 1,
+      "detail": "Convert to String",
+      "documentation": { "value": "Returns the string representation of the argument.\n\n```java\nString s = String.valueOf(42);\nString s = String.valueOf(true);\nString s = String.valueOf(charArray);\n```" },
+      "insertText": "String.valueOf(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_string_valueof"
+    },
+    {
+      "label": "String.format",
+      "kind": 1,
+      "detail": "Create a formatted String",
+      "documentation": { "value": "Returns a formatted string using the specified format string and arguments.\n\n```java\nString s = String.format(\"Name: %s, Age: %d\", name, age);\nString s = String.format(\"%.2f\", price);\n```" },
+      "insertText": "String.format(\"${1:%s}\", ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "02_string_format"
+    },
+    {
+      "label": "String.join",
+      "kind": 1,
+      "detail": "Join strings with delimiter",
+      "documentation": { "value": "Returns a new String composed of elements joined together with the specified delimiter.\n\n```java\nString csv = String.join(\", \", \"a\", \"b\", \"c\");\nString path = String.join(\"/\", parts);\n```" },
+      "insertText": "String.join(\"${1:, }\", ${2:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_string_join"
+    },
+    {
+      "label": ".length()",
+      "kind": 1,
+      "detail": "String length",
+      "documentation": { "value": "Returns the number of characters in the string.\n\n```java\nint len = str.length();\nif (name.length() > 0) { }\n```" },
+      "insertText": ".length()",
+      "insertTextRules": 0,
+      "sortText": "02_length"
+    },
+    {
+      "label": ".charAt()",
+      "kind": 1,
+      "detail": "Get character at index",
+      "documentation": { "value": "Returns the char value at the specified index.\n\n```java\nchar c = str.charAt(0);\nchar last = str.charAt(str.length() - 1);\n```" },
+      "insertText": ".charAt(${1:index})",
+      "insertTextRules": 4,
+      "sortText": "02_charat"
+    },
+    {
+      "label": ".substring()",
+      "kind": 1,
+      "detail": "Extract substring",
+      "documentation": { "value": "Returns a substring from the specified begin index to the end index.\n\n```java\nString sub = str.substring(0, 5);\nString rest = str.substring(3);\n```" },
+      "insertText": ".substring(${1:beginIndex}, ${2:endIndex})",
+      "insertTextRules": 4,
+      "sortText": "02_substring"
+    },
+    {
+      "label": ".equals()",
+      "kind": 1,
+      "detail": "Compare string equality",
+      "documentation": { "value": "Compares this string to the specified object for content equality.\n\n```java\nif (str.equals(\"hello\")) { }\nif (a.equals(b)) { }\n```" },
+      "insertText": ".equals(${1:other})",
+      "insertTextRules": 4,
+      "sortText": "02_equals"
+    },
+    {
+      "label": ".equalsIgnoreCase()",
+      "kind": 1,
+      "detail": "Compare strings ignoring case",
+      "documentation": { "value": "Compares this string to another string, ignoring case differences.\n\n```java\nif (input.equalsIgnoreCase(\"yes\")) { }\n```" },
+      "insertText": ".equalsIgnoreCase(${1:other})",
+      "insertTextRules": 4,
+      "sortText": "02_equalsignorecase"
+    },
+    {
+      "label": ".contains()",
+      "kind": 1,
+      "detail": "Check if string contains a sequence",
+      "documentation": { "value": "Returns true if this string contains the specified sequence of characters.\n\n```java\nif (str.contains(\"search\")) { }\nboolean found = text.contains(keyword);\n```" },
+      "insertText": ".contains(${1:sequence})",
+      "insertTextRules": 4,
+      "sortText": "02_contains"
+    },
+    {
+      "label": ".startsWith()",
+      "kind": 1,
+      "detail": "Check if string starts with prefix",
+      "documentation": { "value": "Tests if this string starts with the specified prefix.\n\n```java\nif (url.startsWith(\"https://\")) { }\n```" },
+      "insertText": ".startsWith(${1:prefix})",
+      "insertTextRules": 4,
+      "sortText": "02_startswith"
+    },
+    {
+      "label": ".endsWith()",
+      "kind": 1,
+      "detail": "Check if string ends with suffix",
+      "documentation": { "value": "Tests if this string ends with the specified suffix.\n\n```java\nif (file.endsWith(\".java\")) { }\n```" },
+      "insertText": ".endsWith(${1:suffix})",
+      "insertTextRules": 4,
+      "sortText": "02_endswith"
+    },
+    {
+      "label": ".indexOf()",
+      "kind": 1,
+      "detail": "Find index of substring",
+      "documentation": { "value": "Returns the index of the first occurrence of the specified substring, or -1 if not found.\n\n```java\nint idx = str.indexOf(\"find\");\nint pos = str.indexOf('@');\n```" },
+      "insertText": ".indexOf(${1:str})",
+      "insertTextRules": 4,
+      "sortText": "02_indexof"
+    },
+    {
+      "label": ".replace()",
+      "kind": 1,
+      "detail": "Replace characters or sequences",
+      "documentation": { "value": "Returns a string with all occurrences of the target replaced by the replacement.\n\n```java\nString result = str.replace(\"old\", \"new\");\nString clean = str.replace(\" \", \"\");\n```" },
+      "insertText": ".replace(${1:target}, ${2:replacement})",
+      "insertTextRules": 4,
+      "sortText": "02_replace"
+    },
+    {
+      "label": ".replaceAll()",
+      "kind": 1,
+      "detail": "Replace all regex matches",
+      "documentation": { "value": "Replaces each substring matching the given regular expression with the replacement.\n\n```java\nString clean = str.replaceAll(\"\\\\s+\", \" \");\nString digits = str.replaceAll(\"[^0-9]\", \"\");\n```" },
+      "insertText": ".replaceAll(${1:regex}, ${2:replacement})",
+      "insertTextRules": 4,
+      "sortText": "02_replaceall"
+    },
+    {
+      "label": ".split()",
+      "kind": 1,
+      "detail": "Split string by regex",
+      "documentation": { "value": "Splits this string around matches of the given regular expression.\n\n```java\nString[] parts = str.split(\",\");\nString[] words = str.split(\"\\\\s+\");\n```" },
+      "insertText": ".split(\"${1:regex}\")",
+      "insertTextRules": 4,
+      "sortText": "02_split"
+    },
+    {
+      "label": ".trim()",
+      "kind": 1,
+      "detail": "Remove leading and trailing whitespace",
+      "documentation": { "value": "Returns a string with leading and trailing whitespace (char <= ' ') removed.\n\n```java\nString clean = input.trim();\n```" },
+      "insertText": ".trim()",
+      "insertTextRules": 0,
+      "sortText": "02_trim"
+    },
+    {
+      "label": ".strip()",
+      "kind": 1,
+      "detail": "Strip whitespace (Unicode-aware)",
+      "documentation": { "value": "Returns a string with all leading and trailing Unicode whitespace removed. Preferred over trim() for Unicode support (Java 11+).\n\n```java\nString clean = input.strip();\n```" },
+      "insertText": ".strip()",
+      "insertTextRules": 0,
+      "sortText": "02_strip"
+    },
+    {
+      "label": ".toUpperCase()",
+      "kind": 1,
+      "detail": "Convert to uppercase",
+      "documentation": { "value": "Converts all characters to upper case using the rules of the default locale.\n\n```java\nString upper = str.toUpperCase();\n```" },
+      "insertText": ".toUpperCase()",
+      "insertTextRules": 0,
+      "sortText": "02_touppercase"
+    },
+    {
+      "label": ".toLowerCase()",
+      "kind": 1,
+      "detail": "Convert to lowercase",
+      "documentation": { "value": "Converts all characters to lower case using the rules of the default locale.\n\n```java\nString lower = str.toLowerCase();\n```" },
+      "insertText": ".toLowerCase()",
+      "insertTextRules": 0,
+      "sortText": "02_tolowercase"
+    },
+    {
+      "label": ".isEmpty()",
+      "kind": 1,
+      "detail": "Check if string is empty",
+      "documentation": { "value": "Returns true if length() is 0.\n\n```java\nif (str.isEmpty()) { }\n```" },
+      "insertText": ".isEmpty()",
+      "insertTextRules": 0,
+      "sortText": "02_isempty"
+    },
+    {
+      "label": ".isBlank()",
+      "kind": 1,
+      "detail": "Check if string is blank (Java 11+)",
+      "documentation": { "value": "Returns true if the string is empty or contains only whitespace characters.\n\n```java\nif (str.isBlank()) { }\n\"   \".isBlank(); // true\n```" },
+      "insertText": ".isBlank()",
+      "insertTextRules": 0,
+      "sortText": "02_isblank"
+    },
+    {
+      "label": ".toCharArray()",
+      "kind": 1,
+      "detail": "Convert string to char array",
+      "documentation": { "value": "Converts this string to a new character array.\n\n```java\nchar[] chars = str.toCharArray();\nfor (char c : str.toCharArray()) { }\n```" },
+      "insertText": ".toCharArray()",
+      "insertTextRules": 0,
+      "sortText": "02_tochararray"
+    },
+    {
+      "label": ".matches()",
+      "kind": 1,
+      "detail": "Match against regex",
+      "documentation": { "value": "Tells whether this string matches the given regular expression.\n\n```java\nboolean valid = email.matches(\"[\\\\w.]+@[\\\\w.]+\");\nif (str.matches(\"\\\\d+\")) { }\n```" },
+      "insertText": ".matches(\"${1:regex}\")",
+      "insertTextRules": 4,
+      "sortText": "02_matches"
+    },
+    {
+      "label": "List.of",
+      "kind": 1,
+      "detail": "Create immutable list (Java 9+)",
+      "documentation": { "value": "Returns an unmodifiable list containing the specified elements.\n\n```java\nList<String> names = List.of(\"Alice\", \"Bob\", \"Charlie\");\nList<Integer> nums = List.of(1, 2, 3);\n```" },
+      "insertText": "List.of(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "03_list_of"
+    },
+    {
+      "label": "List.copyOf",
+      "kind": 1,
+      "detail": "Create immutable copy of list (Java 10+)",
+      "documentation": { "value": "Returns an unmodifiable list containing the elements of the given collection.\n\n```java\nList<String> copy = List.copyOf(mutableList);\n```" },
+      "insertText": "List.copyOf(${1:collection})",
+      "insertTextRules": 4,
+      "sortText": "03_list_copyof"
+    },
+    {
+      "label": "ArrayList",
+      "kind": 7,
+      "detail": "Resizable array list",
+      "documentation": { "value": "A resizable-array implementation of the List interface.\n\n```java\nList<String> list = new ArrayList<>();\nList<Integer> nums = new ArrayList<>(List.of(1, 2, 3));\nlist.add(\"item\");\n```" },
+      "insertText": "new ArrayList<${1:Type}>(${2})",
+      "insertTextRules": 4,
+      "sortText": "03_arraylist"
+    },
+    {
+      "label": "LinkedList",
+      "kind": 7,
+      "detail": "Doubly-linked list",
+      "documentation": { "value": "A doubly-linked list implementation of the List and Deque interfaces.\n\n```java\nLinkedList<String> list = new LinkedList<>();\nlist.addFirst(\"first\");\nlist.addLast(\"last\");\n```" },
+      "insertText": "new LinkedList<${1:Type}>()",
+      "insertTextRules": 4,
+      "sortText": "03_linkedlist"
+    },
+    {
+      "label": "HashMap",
+      "kind": 7,
+      "detail": "Hash table based map",
+      "documentation": { "value": "Hash table based implementation of the Map interface. Permits null keys and values.\n\n```java\nMap<String, Integer> map = new HashMap<>();\nmap.put(\"key\", 42);\nint val = map.getOrDefault(\"key\", 0);\n```" },
+      "insertText": "new HashMap<${1:Key}, ${2:Value}>()",
+      "insertTextRules": 4,
+      "sortText": "03_hashmap"
+    },
+    {
+      "label": "TreeMap",
+      "kind": 7,
+      "detail": "Sorted map (red-black tree)",
+      "documentation": { "value": "A NavigableMap implementation based on a Red-Black tree. Keys are sorted in natural order or by a provided Comparator.\n\n```java\nTreeMap<String, Integer> map = new TreeMap<>();\nmap.put(\"banana\", 2);\nmap.firstKey(); // smallest key\n```" },
+      "insertText": "new TreeMap<${1:Key}, ${2:Value}>()",
+      "insertTextRules": 4,
+      "sortText": "03_treemap"
+    },
+    {
+      "label": "HashSet",
+      "kind": 7,
+      "detail": "Hash table based set",
+      "documentation": { "value": "Implements the Set interface backed by a hash table. Does not guarantee iteration order.\n\n```java\nSet<String> set = new HashSet<>();\nset.add(\"item\");\nboolean exists = set.contains(\"item\");\n```" },
+      "insertText": "new HashSet<${1:Type}>()",
+      "insertTextRules": 4,
+      "sortText": "03_hashset"
+    },
+    {
+      "label": "TreeSet",
+      "kind": 7,
+      "detail": "Sorted set (red-black tree)",
+      "documentation": { "value": "A NavigableSet implementation based on a TreeMap. Elements are sorted in natural order or by a provided Comparator.\n\n```java\nTreeSet<Integer> sorted = new TreeSet<>();\nsorted.add(3);\nsorted.add(1);\nsorted.first(); // 1\n```" },
+      "insertText": "new TreeSet<${1:Type}>()",
+      "insertTextRules": 4,
+      "sortText": "03_treeset"
+    },
+    {
+      "label": "Collections.sort",
+      "kind": 1,
+      "detail": "Sort a list",
+      "documentation": { "value": "Sorts the specified list into ascending order according to natural ordering or a provided Comparator.\n\n```java\nCollections.sort(list);\nCollections.sort(list, Comparator.reverseOrder());\n```" },
+      "insertText": "Collections.sort(${1:list})",
+      "insertTextRules": 4,
+      "sortText": "03_collections_sort"
+    },
+    {
+      "label": "Collections.unmodifiableList",
+      "kind": 1,
+      "detail": "Create unmodifiable list view",
+      "documentation": { "value": "Returns an unmodifiable view of the specified list.\n\n```java\nList<String> readOnly = Collections.unmodifiableList(mutableList);\n```" },
+      "insertText": "Collections.unmodifiableList(${1:list})",
+      "insertTextRules": 4,
+      "sortText": "03_collections_unmod"
+    },
+    {
+      "label": "Arrays.asList",
+      "kind": 1,
+      "detail": "Convert array to fixed-size list",
+      "documentation": { "value": "Returns a fixed-size list backed by the specified array.\n\n```java\nList<String> list = Arrays.asList(\"a\", \"b\", \"c\");\n```" },
+      "insertText": "Arrays.asList(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "03_arrays_aslist"
+    },
+    {
+      "label": "Arrays.sort",
+      "kind": 1,
+      "detail": "Sort an array",
+      "documentation": { "value": "Sorts the specified array into ascending numerical order.\n\n```java\nArrays.sort(arr);\nArrays.sort(arr, Comparator.reverseOrder());\n```" },
+      "insertText": "Arrays.sort(${1:array})",
+      "insertTextRules": 4,
+      "sortText": "03_arrays_sort"
+    },
+    {
+      "label": "Arrays.stream",
+      "kind": 1,
+      "detail": "Create stream from array",
+      "documentation": { "value": "Returns a sequential Stream with the specified array as its source.\n\n```java\nArrays.stream(arr).filter(x -> x > 0).forEach(System.out::println);\n```" },
+      "insertText": "Arrays.stream(${1:array})",
+      "insertTextRules": 4,
+      "sortText": "03_arrays_stream"
+    },
+    {
+      "label": "Map.of",
+      "kind": 1,
+      "detail": "Create immutable map (Java 9+)",
+      "documentation": { "value": "Returns an unmodifiable map containing the specified key-value pairs.\n\n```java\nMap<String, Integer> map = Map.of(\"a\", 1, \"b\", 2);\n```" },
+      "insertText": "Map.of(${1:key}, ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "03_map_of"
+    },
+    {
+      "label": "Map.entry",
+      "kind": 1,
+      "detail": "Create immutable Map.Entry (Java 9+)",
+      "documentation": { "value": "Returns an unmodifiable Map.Entry containing the specified key and value.\n\n```java\nMap.Entry<String, Integer> e = Map.entry(\"key\", 42);\nMap<String, Integer> map = Map.ofEntries(Map.entry(\"a\", 1));\n```" },
+      "insertText": "Map.entry(${1:key}, ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "03_map_entry"
+    },
+    {
+      "label": "Set.of",
+      "kind": 1,
+      "detail": "Create immutable set (Java 9+)",
+      "documentation": { "value": "Returns an unmodifiable set containing the specified elements.\n\n```java\nSet<String> set = Set.of(\"a\", \"b\", \"c\");\n```" },
+      "insertText": "Set.of(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "03_set_of"
+    },
+    {
+      "label": ".stream()",
+      "kind": 1,
+      "detail": "Create stream from collection",
+      "documentation": { "value": "Returns a sequential Stream with this collection as its source.\n\n```java\nlist.stream().filter(x -> x > 0).collect(Collectors.toList());\nset.stream().map(String::toUpperCase).toList();\n```" },
+      "insertText": ".stream()",
+      "insertTextRules": 0,
+      "sortText": "04_stream"
+    },
+    {
+      "label": ".filter()",
+      "kind": 1,
+      "detail": "Filter stream elements",
+      "documentation": { "value": "Returns a stream consisting of elements that match the given predicate.\n\n```java\nlist.stream().filter(s -> s.length() > 3)\nlist.stream().filter(Objects::nonNull)\n```" },
+      "insertText": ".filter(${1:element} -> ${2:condition})",
+      "insertTextRules": 4,
+      "sortText": "04_filter"
+    },
+    {
+      "label": ".map()",
+      "kind": 1,
+      "detail": "Transform stream elements",
+      "documentation": { "value": "Returns a stream with each element transformed by the given function.\n\n```java\nlist.stream().map(String::toUpperCase)\nlist.stream().map(x -> x * 2)\n```" },
+      "insertText": ".map(${1:element} -> ${2:transform})",
+      "insertTextRules": 4,
+      "sortText": "04_map"
+    },
+    {
+      "label": ".flatMap()",
+      "kind": 1,
+      "detail": "Flatten and transform stream elements",
+      "documentation": { "value": "Returns a stream where each element is replaced with the contents of a mapped stream.\n\n```java\nlist.stream().flatMap(Collection::stream)\nlist.stream().flatMap(s -> Arrays.stream(s.split(\",\")))\n```" },
+      "insertText": ".flatMap(${1:element} -> ${2:stream})",
+      "insertTextRules": 4,
+      "sortText": "04_flatmap"
+    },
+    {
+      "label": ".collect()",
+      "kind": 1,
+      "detail": "Collect stream into a container",
+      "documentation": { "value": "Performs a mutable reduction operation on stream elements using a Collector.\n\n```java\nList<String> result = stream.collect(Collectors.toList());\nMap<String, List<Item>> grouped = items.stream()\n    .collect(Collectors.groupingBy(Item::category));\n```" },
+      "insertText": ".collect(Collectors.${1:toList}())",
+      "insertTextRules": 4,
+      "sortText": "04_collect"
+    },
+    {
+      "label": ".reduce()",
+      "kind": 1,
+      "detail": "Reduce stream to a single value",
+      "documentation": { "value": "Performs a reduction on the elements using an associative accumulation function.\n\n```java\nint sum = list.stream().reduce(0, Integer::sum);\nOptional<String> concat = list.stream().reduce(String::concat);\n```" },
+      "insertText": ".reduce(${1:identity}, ${2:accumulator})",
+      "insertTextRules": 4,
+      "sortText": "04_reduce"
+    },
+    {
+      "label": ".forEach()",
+      "kind": 1,
+      "detail": "Perform action for each element",
+      "documentation": { "value": "Performs an action for each element of the stream.\n\n```java\nlist.forEach(System.out::println);\nmap.forEach((k, v) -> System.out.println(k + \"=\" + v));\n```" },
+      "insertText": ".forEach(${1:element} -> ${2:action})",
+      "insertTextRules": 4,
+      "sortText": "04_foreach"
+    },
+    {
+      "label": ".sorted()",
+      "kind": 1,
+      "detail": "Sort stream elements",
+      "documentation": { "value": "Returns a stream with elements sorted in natural order or by a comparator.\n\n```java\nlist.stream().sorted()\nlist.stream().sorted(Comparator.comparing(Person::name))\n```" },
+      "insertText": ".sorted(${1})",
+      "insertTextRules": 4,
+      "sortText": "04_sorted"
+    },
+    {
+      "label": ".distinct()",
+      "kind": 1,
+      "detail": "Remove duplicates from stream",
+      "documentation": { "value": "Returns a stream with distinct elements (by Object.equals).\n\n```java\nList<Integer> unique = list.stream().distinct().toList();\n```" },
+      "insertText": ".distinct()",
+      "insertTextRules": 0,
+      "sortText": "04_distinct"
+    },
+    {
+      "label": ".limit()",
+      "kind": 1,
+      "detail": "Limit stream to n elements",
+      "documentation": { "value": "Returns a stream consisting of at most maxSize elements.\n\n```java\nlist.stream().limit(10).forEach(System.out::println);\n```" },
+      "insertText": ".limit(${1:maxSize})",
+      "insertTextRules": 4,
+      "sortText": "04_limit"
+    },
+    {
+      "label": ".skip()",
+      "kind": 1,
+      "detail": "Skip first n elements",
+      "documentation": { "value": "Returns a stream with the first n elements discarded.\n\n```java\nlist.stream().skip(5).forEach(System.out::println);\n```" },
+      "insertText": ".skip(${1:n})",
+      "insertTextRules": 4,
+      "sortText": "04_skip"
+    },
+    {
+      "label": ".count()",
+      "kind": 1,
+      "detail": "Count stream elements",
+      "documentation": { "value": "Returns the count of elements in the stream.\n\n```java\nlong n = list.stream().filter(x -> x > 0).count();\n```" },
+      "insertText": ".count()",
+      "insertTextRules": 0,
+      "sortText": "04_count"
+    },
+    {
+      "label": ".findFirst()",
+      "kind": 1,
+      "detail": "Find first element",
+      "documentation": { "value": "Returns an Optional describing the first element, or empty if the stream is empty.\n\n```java\nOptional<String> first = list.stream().filter(s -> s.startsWith(\"A\")).findFirst();\n```" },
+      "insertText": ".findFirst()",
+      "insertTextRules": 0,
+      "sortText": "04_findfirst"
+    },
+    {
+      "label": ".findAny()",
+      "kind": 1,
+      "detail": "Find any element",
+      "documentation": { "value": "Returns an Optional describing some element of the stream. May return any match in parallel streams.\n\n```java\nOptional<String> any = list.parallelStream().filter(s -> s.length() > 3).findAny();\n```" },
+      "insertText": ".findAny()",
+      "insertTextRules": 0,
+      "sortText": "04_findany"
+    },
+    {
+      "label": ".anyMatch()",
+      "kind": 1,
+      "detail": "Check if any element matches",
+      "documentation": { "value": "Returns whether any element matches the provided predicate.\n\n```java\nboolean hasNegative = list.stream().anyMatch(x -> x < 0);\n```" },
+      "insertText": ".anyMatch(${1:element} -> ${2:condition})",
+      "insertTextRules": 4,
+      "sortText": "04_anymatch"
+    },
+    {
+      "label": ".allMatch()",
+      "kind": 1,
+      "detail": "Check if all elements match",
+      "documentation": { "value": "Returns whether all elements match the provided predicate.\n\n```java\nboolean allPositive = list.stream().allMatch(x -> x > 0);\n```" },
+      "insertText": ".allMatch(${1:element} -> ${2:condition})",
+      "insertTextRules": 4,
+      "sortText": "04_allmatch"
+    },
+    {
+      "label": ".noneMatch()",
+      "kind": 1,
+      "detail": "Check if no elements match",
+      "documentation": { "value": "Returns whether no elements match the provided predicate.\n\n```java\nboolean noNulls = list.stream().noneMatch(Objects::isNull);\n```" },
+      "insertText": ".noneMatch(${1:element} -> ${2:condition})",
+      "insertTextRules": 4,
+      "sortText": "04_nonematch"
+    },
+    {
+      "label": "Collectors.toList()",
+      "kind": 1,
+      "detail": "Collect stream to List",
+      "documentation": { "value": "Returns a Collector that accumulates elements into a new List.\n\n```java\nList<String> result = stream.collect(Collectors.toList());\n```" },
+      "insertText": "Collectors.toList()",
+      "insertTextRules": 0,
+      "sortText": "04_collectors_tolist"
+    },
+    {
+      "label": "Collectors.toMap()",
+      "kind": 1,
+      "detail": "Collect stream to Map",
+      "documentation": { "value": "Returns a Collector that accumulates elements into a Map.\n\n```java\nMap<String, Integer> map = items.stream()\n    .collect(Collectors.toMap(Item::name, Item::price));\n```" },
+      "insertText": "Collectors.toMap(${1:keyMapper}, ${2:valueMapper})",
+      "insertTextRules": 4,
+      "sortText": "04_collectors_tomap"
+    },
+    {
+      "label": "Collectors.groupingBy()",
+      "kind": 1,
+      "detail": "Group stream elements",
+      "documentation": { "value": "Returns a Collector that groups elements by a classifier function.\n\n```java\nMap<String, List<Person>> byCity = people.stream()\n    .collect(Collectors.groupingBy(Person::city));\n```" },
+      "insertText": "Collectors.groupingBy(${1:classifier})",
+      "insertTextRules": 4,
+      "sortText": "04_collectors_groupingby"
+    },
+    {
+      "label": "Collectors.joining()",
+      "kind": 1,
+      "detail": "Join stream elements to String",
+      "documentation": { "value": "Returns a Collector that concatenates stream elements into a single String.\n\n```java\nString csv = list.stream().collect(Collectors.joining(\", \"));\nString wrapped = list.stream().collect(Collectors.joining(\", \", \"[\", \"]\"));\n```" },
+      "insertText": "Collectors.joining(\"${1:, }\")",
+      "insertTextRules": 4,
+      "sortText": "04_collectors_joining"
+    },
+    {
+      "label": "Optional.of",
+      "kind": 1,
+      "detail": "Create Optional with non-null value",
+      "documentation": { "value": "Returns an Optional describing the specified non-null value. Throws NullPointerException if value is null.\n\n```java\nOptional<String> opt = Optional.of(\"hello\");\n```" },
+      "insertText": "Optional.of(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "05_optional_of"
+    },
+    {
+      "label": "Optional.ofNullable",
+      "kind": 1,
+      "detail": "Create Optional that may be null",
+      "documentation": { "value": "Returns an Optional describing the value, or empty if null.\n\n```java\nOptional<String> opt = Optional.ofNullable(getValue());\n```" },
+      "insertText": "Optional.ofNullable(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "05_optional_ofnullable"
+    },
+    {
+      "label": "Optional.empty",
+      "kind": 1,
+      "detail": "Create empty Optional",
+      "documentation": { "value": "Returns an empty Optional instance.\n\n```java\nOptional<String> opt = Optional.empty();\n```" },
+      "insertText": "Optional.empty()",
+      "insertTextRules": 0,
+      "sortText": "05_optional_empty"
+    },
+    {
+      "label": ".isPresent()",
+      "kind": 1,
+      "detail": "Check if Optional has value",
+      "documentation": { "value": "Returns true if a value is present.\n\n```java\nif (opt.isPresent()) {\n    System.out.println(opt.get());\n}\n```" },
+      "insertText": ".isPresent()",
+      "insertTextRules": 0,
+      "sortText": "05_ispresent"
+    },
+    {
+      "label": ".orElse()",
+      "kind": 1,
+      "detail": "Get value or default",
+      "documentation": { "value": "Returns the value if present, otherwise returns the specified default.\n\n```java\nString name = opt.orElse(\"Unknown\");\nint val = optInt.orElse(0);\n```" },
+      "insertText": ".orElse(${1:defaultValue})",
+      "insertTextRules": 4,
+      "sortText": "05_orelse"
+    },
+    {
+      "label": ".orElseGet()",
+      "kind": 1,
+      "detail": "Get value or compute default",
+      "documentation": { "value": "Returns the value if present, otherwise invokes the supplier and returns its result.\n\n```java\nString name = opt.orElseGet(() -> computeDefault());\n```" },
+      "insertText": ".orElseGet(() -> ${1:defaultSupplier})",
+      "insertTextRules": 4,
+      "sortText": "05_orelseget"
+    },
+    {
+      "label": ".orElseThrow()",
+      "kind": 1,
+      "detail": "Get value or throw exception",
+      "documentation": { "value": "Returns the value if present, otherwise throws an exception produced by the supplier.\n\n```java\nString name = opt.orElseThrow(() -> new NoSuchElementException(\"Not found\"));\nString val = opt.orElseThrow();\n```" },
+      "insertText": ".orElseThrow(() -> new ${1:RuntimeException}(${2:\"message\"}))",
+      "insertTextRules": 4,
+      "sortText": "05_orelsethrow"
+    },
+    {
+      "label": ".ifPresent()",
+      "kind": 1,
+      "detail": "Execute action if value present",
+      "documentation": { "value": "If a value is present, performs the given action with the value.\n\n```java\nopt.ifPresent(System.out::println);\nopt.ifPresent(val -> process(val));\n```" },
+      "insertText": ".ifPresent(${1:value} -> ${2:action})",
+      "insertTextRules": 4,
+      "sortText": "05_ifpresent"
+    },
+    {
+      "label": "Thread",
+      "kind": 7,
+      "detail": "Create a new thread",
+      "documentation": { "value": "Creates and starts a new thread of execution.\n\n```java\nThread t = new Thread(() -> {\n    System.out.println(\"Running in thread\");\n});\nt.start();\n```" },
+      "insertText": "new Thread(() -> {\n\t${1}\n}).start();",
+      "insertTextRules": 4,
+      "sortText": "06_thread"
+    },
+    {
+      "label": "Runnable",
+      "kind": 7,
+      "detail": "Runnable functional interface",
+      "documentation": { "value": "A functional interface for tasks that can be executed by a thread.\n\n```java\nRunnable task = () -> System.out.println(\"task\");\nnew Thread(task).start();\n```" },
+      "insertText": "Runnable ${1:task} = () -> {\n\t${2}\n};",
+      "insertTextRules": 4,
+      "sortText": "06_runnable"
+    },
+    {
+      "label": "CompletableFuture",
+      "kind": 7,
+      "detail": "Asynchronous computation",
+      "documentation": { "value": "A Future that can be explicitly completed, composed, and combined for asynchronous programming.\n\n```java\nCompletableFuture.supplyAsync(() -> fetchData())\n    .thenApply(data -> process(data))\n    .thenAccept(result -> System.out.println(result));\n```" },
+      "insertText": "CompletableFuture.supplyAsync(() -> ${1:value})",
+      "insertTextRules": 4,
+      "sortText": "06_completablefuture"
+    },
+    {
+      "label": "ExecutorService",
+      "kind": 7,
+      "detail": "Thread pool executor",
+      "documentation": { "value": "Manages a pool of threads for executing tasks.\n\n```java\nExecutorService executor = Executors.newFixedThreadPool(4);\nexecutor.submit(() -> doWork());\nexecutor.shutdown();\n```" },
+      "insertText": "ExecutorService ${1:executor} = Executors.newFixedThreadPool(${2:4});",
+      "insertTextRules": 4,
+      "sortText": "06_executorservice"
+    },
+    {
+      "label": "Executors.newFixedThreadPool",
+      "kind": 1,
+      "detail": "Create fixed-size thread pool",
+      "documentation": { "value": "Creates a thread pool that reuses a fixed number of threads.\n\n```java\nExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());\n```" },
+      "insertText": "Executors.newFixedThreadPool(${1:nThreads})",
+      "insertTextRules": 4,
+      "sortText": "06_executors_fixed"
+    },
+    {
+      "label": "Future",
+      "kind": 7,
+      "detail": "Future result of async computation",
+      "documentation": { "value": "Represents the result of an asynchronous computation. Use get() to retrieve the result.\n\n```java\nFuture<String> future = executor.submit(() -> compute());\nString result = future.get();\n```" },
+      "insertText": "Future<${1:Type}> ${2:future} = ${3:executor}.submit(() -> ${4:value});",
+      "insertTextRules": 4,
+      "sortText": "06_future"
+    },
+    {
+      "label": "Callable",
+      "kind": 7,
+      "detail": "Callable task returning a result",
+      "documentation": { "value": "A task that returns a result and may throw an exception. Like Runnable but with a return value.\n\n```java\nCallable<Integer> task = () -> {\n    return computeValue();\n};\nFuture<Integer> future = executor.submit(task);\n```" },
+      "insertText": "Callable<${1:Type}> ${2:task} = () -> {\n\treturn ${3:value};\n};",
+      "insertTextRules": 4,
+      "sortText": "06_callable"
+    },
+    {
+      "label": "Files.readString",
+      "kind": 1,
+      "detail": "Read file contents as String (Java 11+)",
+      "documentation": { "value": "Reads all content from a file into a string.\n\n```java\nString content = Files.readString(Path.of(\"file.txt\"));\nString data = Files.readString(path, StandardCharsets.UTF_8);\n```" },
+      "insertText": "Files.readString(Path.of(\"${1:file.txt}\"))",
+      "insertTextRules": 4,
+      "sortText": "07_files_readstring"
+    },
+    {
+      "label": "Files.writeString",
+      "kind": 1,
+      "detail": "Write String to file (Java 11+)",
+      "documentation": { "value": "Writes a CharSequence to a file.\n\n```java\nFiles.writeString(Path.of(\"output.txt\"), content);\nFiles.writeString(path, data, StandardOpenOption.APPEND);\n```" },
+      "insertText": "Files.writeString(Path.of(\"${1:file.txt}\"), ${2:content})",
+      "insertTextRules": 4,
+      "sortText": "07_files_writestring"
+    },
+    {
+      "label": "Files.readAllLines",
+      "kind": 1,
+      "detail": "Read all lines from a file",
+      "documentation": { "value": "Reads all lines from a file as a List of Strings.\n\n```java\nList<String> lines = Files.readAllLines(Path.of(\"data.txt\"));\n```" },
+      "insertText": "Files.readAllLines(Path.of(\"${1:file.txt}\"))",
+      "insertTextRules": 4,
+      "sortText": "07_files_readalllines"
+    },
+    {
+      "label": "Path.of",
+      "kind": 1,
+      "detail": "Create a Path instance (Java 11+)",
+      "documentation": { "value": "Returns a Path by converting a path string or URI.\n\n```java\nPath p = Path.of(\"src\", \"main\", \"java\");\nPath file = Path.of(\"/tmp/data.txt\");\n```" },
+      "insertText": "Path.of(\"${1:path}\")",
+      "insertTextRules": 4,
+      "sortText": "07_path_of"
+    },
+    {
+      "label": "BufferedReader",
+      "kind": 7,
+      "detail": "Buffered character-input stream reader",
+      "documentation": { "value": "Reads text from a character-input stream with buffering for efficient reading.\n\n```java\ntry (var reader = new BufferedReader(new FileReader(\"file.txt\"))) {\n    String line;\n    while ((line = reader.readLine()) != null) {\n        System.out.println(line);\n    }\n}\n```" },
+      "insertText": "new BufferedReader(new FileReader(\"${1:file.txt}\"))",
+      "insertTextRules": 4,
+      "sortText": "07_bufferedreader"
+    },
+    {
+      "label": "Scanner",
+      "kind": 7,
+      "detail": "Simple text scanner",
+      "documentation": { "value": "A simple text scanner for parsing primitive types and strings using regular expressions.\n\n```java\nScanner scanner = new Scanner(System.in);\nString name = scanner.nextLine();\nint num = scanner.nextInt();\nscanner.close();\n```" },
+      "insertText": "new Scanner(${1:System.in})",
+      "insertTextRules": 4,
+      "sortText": "07_scanner"
+    },
+    {
+      "label": "Math.max",
+      "kind": 1,
+      "detail": "Return the greater of two values",
+      "documentation": { "value": "Returns the greater of two values.\n\n```java\nint max = Math.max(a, b);\ndouble bigger = Math.max(3.14, 2.71);\n```" },
+      "insertText": "Math.max(${1:a}, ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "08_math_max"
+    },
+    {
+      "label": "Math.min",
+      "kind": 1,
+      "detail": "Return the smaller of two values",
+      "documentation": { "value": "Returns the smaller of two values.\n\n```java\nint min = Math.min(a, b);\n```" },
+      "insertText": "Math.min(${1:a}, ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "08_math_min"
+    },
+    {
+      "label": "Math.abs",
+      "kind": 1,
+      "detail": "Return absolute value",
+      "documentation": { "value": "Returns the absolute value of the argument.\n\n```java\nint pos = Math.abs(-5); // 5\ndouble d = Math.abs(-3.14); // 3.14\n```" },
+      "insertText": "Math.abs(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "08_math_abs"
+    },
+    {
+      "label": "Math.sqrt",
+      "kind": 1,
+      "detail": "Return square root",
+      "documentation": { "value": "Returns the correctly rounded positive square root of a double value.\n\n```java\ndouble root = Math.sqrt(16); // 4.0\n```" },
+      "insertText": "Math.sqrt(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "08_math_sqrt"
+    },
+    {
+      "label": "Math.pow",
+      "kind": 1,
+      "detail": "Return base raised to exponent",
+      "documentation": { "value": "Returns the value of the first argument raised to the power of the second argument.\n\n```java\ndouble result = Math.pow(2, 10); // 1024.0\n```" },
+      "insertText": "Math.pow(${1:base}, ${2:exponent})",
+      "insertTextRules": 4,
+      "sortText": "08_math_pow"
+    },
+    {
+      "label": "Math.random",
+      "kind": 1,
+      "detail": "Return random double [0.0, 1.0)",
+      "documentation": { "value": "Returns a random double value between 0.0 (inclusive) and 1.0 (exclusive).\n\n```java\ndouble r = Math.random();\nint dice = (int)(Math.random() * 6) + 1;\n```" },
+      "insertText": "Math.random()",
+      "insertTextRules": 0,
+      "sortText": "08_math_random"
+    },
+    {
+      "label": "Integer.parseInt",
+      "kind": 1,
+      "detail": "Parse string to int",
+      "documentation": { "value": "Parses the string argument as a signed decimal integer.\n\n```java\nint num = Integer.parseInt(\"42\");\nint hex = Integer.parseInt(\"FF\", 16);\n```" },
+      "insertText": "Integer.parseInt(${1:str})",
+      "insertTextRules": 4,
+      "sortText": "08_integer_parseint"
+    },
+    {
+      "label": "Integer.valueOf",
+      "kind": 1,
+      "detail": "Parse string to Integer object",
+      "documentation": { "value": "Returns an Integer object holding the value of the specified String.\n\n```java\nInteger num = Integer.valueOf(\"42\");\nInteger cached = Integer.valueOf(127); // uses cache\n```" },
+      "insertText": "Integer.valueOf(${1:str})",
+      "insertTextRules": 4,
+      "sortText": "08_integer_valueof"
+    },
+    {
+      "label": "Double.parseDouble",
+      "kind": 1,
+      "detail": "Parse string to double",
+      "documentation": { "value": "Returns a new double initialized to the value represented by the specified String.\n\n```java\ndouble d = Double.parseDouble(\"3.14\");\n```" },
+      "insertText": "Double.parseDouble(${1:str})",
+      "insertTextRules": 4,
+      "sortText": "08_double_parsedouble"
+    },
+    {
+      "label": "Objects.requireNonNull",
+      "kind": 1,
+      "detail": "Check for null with message",
+      "documentation": { "value": "Checks that the specified object reference is not null, throws NullPointerException if it is.\n\n```java\nthis.name = Objects.requireNonNull(name, \"name must not be null\");\n```" },
+      "insertText": "Objects.requireNonNull(${1:obj}, \"${2:message}\")",
+      "insertTextRules": 4,
+      "sortText": "08_objects_requirenonnull"
+    },
+    {
+      "label": "Objects.equals",
+      "kind": 1,
+      "detail": "Null-safe equality check",
+      "documentation": { "value": "Returns true if the arguments are equal to each other and false otherwise. Handles null safely.\n\n```java\nboolean eq = Objects.equals(a, b);\nif (Objects.equals(name, \"admin\")) { }\n```" },
+      "insertText": "Objects.equals(${1:a}, ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "08_objects_equals"
+    },
+    {
+      "label": "public static void main",
+      "kind": 1,
+      "detail": "Main method entry point",
+      "documentation": { "value": "The entry point for a Java application.\n\n```java\npublic static void main(String[] args) {\n    System.out.println(\"Hello, World!\");\n}\n```" },
+      "insertText": "public static void main(String[] args) {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_main"
+    },
+    {
+      "label": "for-each loop",
+      "kind": 14,
+      "detail": "Enhanced for loop",
+      "documentation": { "value": "Iterates over each element of an array or Iterable.\n\n```java\nfor (String item : list) {\n    System.out.println(item);\n}\n```" },
+      "insertText": "for (${1:Type} ${2:item} : ${3:collection}) {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_foreach_loop"
+    },
+    {
+      "label": "for loop",
+      "kind": 14,
+      "detail": "Classic for loop",
+      "documentation": { "value": "A traditional index-based for loop.\n\n```java\nfor (int i = 0; i < n; i++) {\n    System.out.println(i);\n}\n```" },
+      "insertText": "for (int ${1:i} = 0; ${1:i} < ${2:n}; ${1:i}++) {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_for_loop"
+    }
+  ]
+}