@enjoys/context-engine 1.0.0 → 1.0.1

package/data/completion/cpp.json

@@ -0,0 +1,824 @@
+{
+  "language": "cpp",
+  "completions": [
+    {
+      "label": "std::cout",
+      "kind": 5,
+      "detail": "Standard output stream",
+      "documentation": { "value": "The standard output stream object.\n\n```cpp\nstd::cout << \"Hello\" << std::endl;\nstd::cout << \"x = \" << x << '\\n';\n```" },
+      "insertText": "std::cout << ${1:value}",
+      "insertTextRules": 4,
+      "sortText": "00_cout"
+    },
+    {
+      "label": "std::cin",
+      "kind": 5,
+      "detail": "Standard input stream",
+      "documentation": { "value": "The standard input stream object.\n\n```cpp\nint x;\nstd::cin >> x;\nstd::string line;\nstd::getline(std::cin, line);\n```" },
+      "insertText": "std::cin >> ${1:variable}",
+      "insertTextRules": 4,
+      "sortText": "00_cin"
+    },
+    {
+      "label": "std::cerr",
+      "kind": 5,
+      "detail": "Standard error stream",
+      "documentation": { "value": "The standard error output stream (unbuffered).\n\n```cpp\nstd::cerr << \"Error: \" << msg << std::endl;\n```" },
+      "insertText": "std::cerr << ${1:message}",
+      "insertTextRules": 4,
+      "sortText": "00_cerr"
+    },
+    {
+      "label": "std::endl",
+      "kind": 5,
+      "detail": "End-of-line and flush",
+      "documentation": { "value": "Inserts a newline character and flushes the stream.\n\n```cpp\nstd::cout << \"Hello\" << std::endl;\n```\n\n**Note:** Prefer `'\\n'` when flushing is not needed for better performance." },
+      "insertText": "std::endl",
+      "insertTextRules": 0,
+      "sortText": "00_endl"
+    },
+    {
+      "label": "std::getline",
+      "kind": 1,
+      "detail": "Read a line from stream",
+      "documentation": { "value": "Reads a full line from an input stream into a string.\n\n```cpp\nstd::string line;\nstd::getline(std::cin, line);\nstd::getline(std::cin, line, ','); // custom delimiter\n```" },
+      "insertText": "std::getline(${1:std::cin}, ${2:str})",
+      "insertTextRules": 4,
+      "sortText": "00_getline"
+    },
+    {
+      "label": "std::string",
+      "kind": 6,
+      "detail": "String class (std::basic_string<char>)",
+      "documentation": { "value": "Dynamic character string with automatic memory management.\n\n```cpp\nstd::string s = \"hello\";\nstd::string s2(5, 'a'); // \"aaaaa\"\ns.append(\" world\");\nstd::cout << s.size() << std::endl;\n```" },
+      "insertText": "std::string ${1:name}",
+      "insertTextRules": 4,
+      "sortText": "01_string"
+    },
+    {
+      "label": "std::string_view",
+      "kind": 6,
+      "detail": "Non-owning string reference (C++17)",
+      "documentation": { "value": "A lightweight non-owning reference to a string or substring. Zero-copy.\n\n```cpp\nstd::string_view sv = \"hello world\";\nauto sub = sv.substr(0, 5); // \"hello\"\nvoid process(std::string_view s); // pass by value\n```" },
+      "insertText": "std::string_view ${1:name}",
+      "insertTextRules": 4,
+      "sortText": "01_string_view"
+    },
+    {
+      "label": "std::vector",
+      "kind": 6,
+      "detail": "Dynamic array container",
+      "documentation": { "value": "Sequence container with dynamic contiguous storage.\n\n```cpp\nstd::vector<int> v = {1, 2, 3};\nv.push_back(4);\nv.emplace_back(5);\nfor (auto& x : v) std::cout << x;\n```" },
+      "insertText": "std::vector<${1:int}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "02_vector"
+    },
+    {
+      "label": "std::map",
+      "kind": 6,
+      "detail": "Sorted associative container",
+      "documentation": { "value": "Sorted key-value container using a red-black tree.\n\n```cpp\nstd::map<std::string, int> m;\nm[\"apple\"] = 1;\nm.insert({\"banana\", 2});\nfor (auto& [key, val] : m) { ... }\n```" },
+      "insertText": "std::map<${1:std::string}, ${2:int}> ${3:name}",
+      "insertTextRules": 4,
+      "sortText": "02_map"
+    },
+    {
+      "label": "std::unordered_map",
+      "kind": 6,
+      "detail": "Hash-based associative container",
+      "documentation": { "value": "Unordered key-value container using hash table. O(1) average lookup.\n\n```cpp\nstd::unordered_map<std::string, int> m;\nm[\"key\"] = 42;\nif (m.count(\"key\")) { ... }\nauto it = m.find(\"key\");\n```" },
+      "insertText": "std::unordered_map<${1:std::string}, ${2:int}> ${3:name}",
+      "insertTextRules": 4,
+      "sortText": "02_unordered_map"
+    },
+    {
+      "label": "std::set",
+      "kind": 6,
+      "detail": "Sorted unique-element container",
+      "documentation": { "value": "Sorted container of unique elements (red-black tree).\n\n```cpp\nstd::set<int> s = {3, 1, 4, 1, 5};\ns.insert(9);\nif (s.count(3)) { ... }\nfor (auto& x : s) std::cout << x;\n```" },
+      "insertText": "std::set<${1:int}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "02_set"
+    },
+    {
+      "label": "std::unordered_set",
+      "kind": 6,
+      "detail": "Hash-based unique-element container",
+      "documentation": { "value": "Unordered container of unique elements using hash table.\n\n```cpp\nstd::unordered_set<std::string> s;\ns.insert(\"hello\");\nif (s.contains(\"hello\")) { ... } // C++20\n```" },
+      "insertText": "std::unordered_set<${1:int}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "02_unordered_set"
+    },
+    {
+      "label": "std::array",
+      "kind": 6,
+      "detail": "Fixed-size array container",
+      "documentation": { "value": "Fixed-size array with STL interface. Stack-allocated.\n\n```cpp\nstd::array<int, 5> a = {1, 2, 3, 4, 5};\na[0] = 10;\nstd::cout << a.size(); // 5\nstd::sort(a.begin(), a.end());\n```" },
+      "insertText": "std::array<${1:int}, ${2:size}> ${3:name}",
+      "insertTextRules": 4,
+      "sortText": "02_array"
+    },
+    {
+      "label": "std::deque",
+      "kind": 6,
+      "detail": "Double-ended queue",
+      "documentation": { "value": "Double-ended queue with efficient insertion/removal at both ends.\n\n```cpp\nstd::deque<int> d = {1, 2, 3};\nd.push_front(0);\nd.push_back(4);\nd.pop_front();\n```" },
+      "insertText": "std::deque<${1:int}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "02_deque"
+    },
+    {
+      "label": "std::list",
+      "kind": 6,
+      "detail": "Doubly-linked list",
+      "documentation": { "value": "Doubly-linked list with O(1) insertion/removal anywhere.\n\n```cpp\nstd::list<int> lst = {1, 2, 3};\nlst.push_back(4);\nlst.push_front(0);\nlst.sort();\n```" },
+      "insertText": "std::list<${1:int}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "02_list"
+    },
+    {
+      "label": "std::stack",
+      "kind": 6,
+      "detail": "LIFO stack adapter",
+      "documentation": { "value": "Container adapter providing LIFO (last-in, first-out) access.\n\n```cpp\nstd::stack<int> s;\ns.push(1);\ns.push(2);\nint top = s.top(); // 2\ns.pop();\n```" },
+      "insertText": "std::stack<${1:int}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "02_stack"
+    },
+    {
+      "label": "std::queue",
+      "kind": 6,
+      "detail": "FIFO queue adapter",
+      "documentation": { "value": "Container adapter providing FIFO (first-in, first-out) access.\n\n```cpp\nstd::queue<int> q;\nq.push(1);\nq.push(2);\nint front = q.front(); // 1\nq.pop();\n```" },
+      "insertText": "std::queue<${1:int}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "02_queue"
+    },
+    {
+      "label": "std::priority_queue",
+      "kind": 6,
+      "detail": "Priority queue (max-heap by default)",
+      "documentation": { "value": "Container adapter providing priority-based access (max-heap).\n\n```cpp\nstd::priority_queue<int> pq;\npq.push(3); pq.push(1); pq.push(4);\nint top = pq.top(); // 4\n// Min-heap:\nstd::priority_queue<int, std::vector<int>, std::greater<int>> minpq;\n```" },
+      "insertText": "std::priority_queue<${1:int}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "02_priority_queue"
+    },
+    {
+      "label": "std::pair",
+      "kind": 6,
+      "detail": "Pair of two values",
+      "documentation": { "value": "Holds two heterogeneous objects as a single unit.\n\n```cpp\nstd::pair<int, std::string> p = {1, \"hello\"};\nauto p2 = std::make_pair(42, 3.14);\nstd::cout << p.first << \" \" << p.second;\n```" },
+      "insertText": "std::pair<${1:int}, ${2:int}> ${3:name}",
+      "insertTextRules": 4,
+      "sortText": "02_pair"
+    },
+    {
+      "label": "std::tuple",
+      "kind": 6,
+      "detail": "Fixed-size heterogeneous collection",
+      "documentation": { "value": "Holds a fixed number of heterogeneous values.\n\n```cpp\nstd::tuple<int, double, std::string> t = {1, 3.14, \"hi\"};\nauto [a, b, c] = t; // structured bindings\nstd::cout << std::get<0>(t);\n```" },
+      "insertText": "std::tuple<${1:Types}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "02_tuple"
+    },
+    {
+      "label": "std::sort",
+      "kind": 1,
+      "detail": "Sort elements in range",
+      "documentation": { "value": "Sorts elements in [first, last) range. Average O(n log n).\n\n```cpp\nstd::vector<int> v = {3, 1, 4, 1, 5};\nstd::sort(v.begin(), v.end());\nstd::sort(v.begin(), v.end(), std::greater<>()); // descending\nstd::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });\n```" },
+      "insertText": "std::sort(${1:container}.begin(), ${1:container}.end())",
+      "insertTextRules": 4,
+      "sortText": "03_sort"
+    },
+    {
+      "label": "std::find",
+      "kind": 1,
+      "detail": "Find element in range",
+      "documentation": { "value": "Finds the first element equal to the given value.\n\n```cpp\nstd::vector<int> v = {1, 2, 3, 4};\nauto it = std::find(v.begin(), v.end(), 3);\nif (it != v.end()) { /* found */ }\n```" },
+      "insertText": "std::find(${1:container}.begin(), ${1:container}.end(), ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "03_find"
+    },
+    {
+      "label": "std::for_each",
+      "kind": 1,
+      "detail": "Apply function to range",
+      "documentation": { "value": "Applies a function to each element in [first, last).\n\n```cpp\nstd::vector<int> v = {1, 2, 3};\nstd::for_each(v.begin(), v.end(), [](int x) {\n    std::cout << x << ' ';\n});\n```" },
+      "insertText": "std::for_each(${1:container}.begin(), ${1:container}.end(), [](${2:auto}& ${3:elem}) {\n\t$0\n})",
+      "insertTextRules": 4,
+      "sortText": "03_for_each"
+    },
+    {
+      "label": "std::transform",
+      "kind": 1,
+      "detail": "Transform elements in range",
+      "documentation": { "value": "Applies a function and stores the result in a destination range.\n\n```cpp\nstd::vector<int> v = {1, 2, 3};\nstd::vector<int> result(v.size());\nstd::transform(v.begin(), v.end(), result.begin(), [](int x) {\n    return x * 2;\n});\n```" },
+      "insertText": "std::transform(${1:src}.begin(), ${1:src}.end(), ${2:dst}.begin(), [](${3:auto} ${4:elem}) {\n\treturn ${5:elem};\n})",
+      "insertTextRules": 4,
+      "sortText": "03_transform"
+    },
+    {
+      "label": "std::accumulate",
+      "kind": 1,
+      "detail": "Accumulate values in range",
+      "documentation": { "value": "Computes the sum (or custom fold) of elements in a range.\n\n```cpp\n#include <numeric>\nstd::vector<int> v = {1, 2, 3, 4};\nint sum = std::accumulate(v.begin(), v.end(), 0);\nint product = std::accumulate(v.begin(), v.end(), 1, std::multiplies<>());\n```" },
+      "insertText": "std::accumulate(${1:container}.begin(), ${1:container}.end(), ${2:0})",
+      "insertTextRules": 4,
+      "sortText": "03_accumulate"
+    },
+    {
+      "label": "std::count",
+      "kind": 1,
+      "detail": "Count occurrences in range",
+      "documentation": { "value": "Counts elements equal to a given value.\n\n```cpp\nstd::vector<int> v = {1, 2, 2, 3, 2};\nauto n = std::count(v.begin(), v.end(), 2); // 3\n```" },
+      "insertText": "std::count(${1:container}.begin(), ${1:container}.end(), ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "03_count"
+    },
+    {
+      "label": "std::count_if",
+      "kind": 1,
+      "detail": "Count elements satisfying predicate",
+      "documentation": { "value": "Counts elements for which the predicate returns true.\n\n```cpp\nstd::vector<int> v = {1, 2, 3, 4, 5};\nauto n = std::count_if(v.begin(), v.end(), [](int x) { return x > 3; }); // 2\n```" },
+      "insertText": "std::count_if(${1:container}.begin(), ${1:container}.end(), [](${2:auto} ${3:elem}) {\n\treturn ${4:condition};\n})",
+      "insertTextRules": 4,
+      "sortText": "03_count_if"
+    },
+    {
+      "label": "std::remove_if",
+      "kind": 1,
+      "detail": "Remove elements satisfying predicate",
+      "documentation": { "value": "Moves elements not satisfying the predicate to the front. Use with erase (erase-remove idiom).\n\n```cpp\nstd::vector<int> v = {1, 2, 3, 4, 5};\nv.erase(std::remove_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; }), v.end());\n// v = {1, 3, 5}\n```" },
+      "insertText": "${1:container}.erase(std::remove_if(${1:container}.begin(), ${1:container}.end(), [](${2:auto} ${3:elem}) {\n\treturn ${4:condition};\n}), ${1:container}.end())",
+      "insertTextRules": 4,
+      "sortText": "03_remove_if"
+    },
+    {
+      "label": "std::unique",
+      "kind": 1,
+      "detail": "Remove consecutive duplicates",
+      "documentation": { "value": "Removes consecutive duplicate elements. Typically used after sorting.\n\n```cpp\nstd::vector<int> v = {1, 1, 2, 2, 3};\nauto last = std::unique(v.begin(), v.end());\nv.erase(last, v.end()); // v = {1, 2, 3}\n```" },
+      "insertText": "auto ${1:last} = std::unique(${2:container}.begin(), ${2:container}.end())",
+      "insertTextRules": 4,
+      "sortText": "03_unique"
+    },
+    {
+      "label": "std::reverse",
+      "kind": 1,
+      "detail": "Reverse elements in range",
+      "documentation": { "value": "Reverses the order of elements in [first, last).\n\n```cpp\nstd::vector<int> v = {1, 2, 3, 4};\nstd::reverse(v.begin(), v.end()); // {4, 3, 2, 1}\n```" },
+      "insertText": "std::reverse(${1:container}.begin(), ${1:container}.end())",
+      "insertTextRules": 4,
+      "sortText": "03_reverse"
+    },
+    {
+      "label": "std::min_element",
+      "kind": 1,
+      "detail": "Find minimum element",
+      "documentation": { "value": "Returns an iterator to the smallest element in [first, last).\n\n```cpp\nstd::vector<int> v = {3, 1, 4, 1, 5};\nauto it = std::min_element(v.begin(), v.end());\nstd::cout << *it; // 1\n```" },
+      "insertText": "std::min_element(${1:container}.begin(), ${1:container}.end())",
+      "insertTextRules": 4,
+      "sortText": "03_min_element"
+    },
+    {
+      "label": "std::max_element",
+      "kind": 1,
+      "detail": "Find maximum element",
+      "documentation": { "value": "Returns an iterator to the largest element in [first, last).\n\n```cpp\nstd::vector<int> v = {3, 1, 4, 1, 5};\nauto it = std::max_element(v.begin(), v.end());\nstd::cout << *it; // 5\n```" },
+      "insertText": "std::max_element(${1:container}.begin(), ${1:container}.end())",
+      "insertTextRules": 4,
+      "sortText": "03_max_element"
+    },
+    {
+      "label": "std::binary_search",
+      "kind": 1,
+      "detail": "Binary search in sorted range",
+      "documentation": { "value": "Checks if a value exists in a sorted range. O(log n).\n\n```cpp\nstd::vector<int> v = {1, 2, 3, 4, 5};\nbool found = std::binary_search(v.begin(), v.end(), 3); // true\n```" },
+      "insertText": "std::binary_search(${1:container}.begin(), ${1:container}.end(), ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "03_binary_search"
+    },
+    {
+      "label": "std::lower_bound",
+      "kind": 1,
+      "detail": "Find first not-less-than element",
+      "documentation": { "value": "Returns iterator to the first element not less than value in a sorted range.\n\n```cpp\nstd::vector<int> v = {1, 2, 4, 5, 6};\nauto it = std::lower_bound(v.begin(), v.end(), 3);\n// *it == 4\n```" },
+      "insertText": "std::lower_bound(${1:container}.begin(), ${1:container}.end(), ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "03_lower_bound"
+    },
+    {
+      "label": "std::upper_bound",
+      "kind": 1,
+      "detail": "Find first greater-than element",
+      "documentation": { "value": "Returns iterator to the first element greater than value in a sorted range.\n\n```cpp\nstd::vector<int> v = {1, 2, 3, 3, 5};\nauto it = std::upper_bound(v.begin(), v.end(), 3);\n// *it == 5\n```" },
+      "insertText": "std::upper_bound(${1:container}.begin(), ${1:container}.end(), ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "03_upper_bound"
+    },
+    {
+      "label": "std::unique_ptr",
+      "kind": 6,
+      "detail": "Exclusive-ownership smart pointer",
+      "documentation": { "value": "Smart pointer with exclusive ownership semantics. Cannot be copied.\n\n```cpp\nauto ptr = std::make_unique<int>(42);\nstd::unique_ptr<MyClass> p(new MyClass());\nstd::cout << *ptr;\nptr.reset(); // release ownership\n```" },
+      "insertText": "std::unique_ptr<${1:Type}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "04_unique_ptr"
+    },
+    {
+      "label": "std::shared_ptr",
+      "kind": 6,
+      "detail": "Shared-ownership smart pointer",
+      "documentation": { "value": "Smart pointer with shared (reference-counted) ownership.\n\n```cpp\nauto ptr = std::make_shared<int>(42);\nstd::shared_ptr<MyClass> p2 = ptr; // refcount = 2\nstd::cout << ptr.use_count();\n```" },
+      "insertText": "std::shared_ptr<${1:Type}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "04_shared_ptr"
+    },
+    {
+      "label": "std::weak_ptr",
+      "kind": 6,
+      "detail": "Non-owning smart pointer observer",
+      "documentation": { "value": "Non-owning reference to a `std::shared_ptr`-managed object. Breaks circular references.\n\n```cpp\nstd::shared_ptr<int> sp = std::make_shared<int>(10);\nstd::weak_ptr<int> wp = sp;\nif (auto locked = wp.lock()) {\n    std::cout << *locked;\n}\n```" },
+      "insertText": "std::weak_ptr<${1:Type}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "04_weak_ptr"
+    },
+    {
+      "label": "std::make_unique",
+      "kind": 1,
+      "detail": "Create unique_ptr (C++14)",
+      "documentation": { "value": "Creates a `std::unique_ptr` with a new heap-allocated object.\n\n```cpp\nauto p = std::make_unique<int>(42);\nauto obj = std::make_unique<MyClass>(arg1, arg2);\nauto arr = std::make_unique<int[]>(10); // array of 10\n```" },
+      "insertText": "std::make_unique<${1:Type}>(${2:args})",
+      "insertTextRules": 4,
+      "sortText": "04_make_unique"
+    },
+    {
+      "label": "std::make_shared",
+      "kind": 1,
+      "detail": "Create shared_ptr",
+      "documentation": { "value": "Creates a `std::shared_ptr` with a single allocation for object and control block.\n\n```cpp\nauto p = std::make_shared<int>(42);\nauto obj = std::make_shared<MyClass>(arg1, arg2);\n```" },
+      "insertText": "std::make_shared<${1:Type}>(${2:args})",
+      "insertTextRules": 4,
+      "sortText": "04_make_shared"
+    },
+    {
+      "label": "std::move",
+      "kind": 1,
+      "detail": "Cast to rvalue reference",
+      "documentation": { "value": "Casts its argument to an rvalue reference, enabling move semantics.\n\n```cpp\nstd::string s = \"hello\";\nstd::string s2 = std::move(s); // s is now in a moved-from state\nvec.push_back(std::move(obj));\n```" },
+      "insertText": "std::move(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "05_move"
+    },
+    {
+      "label": "std::forward",
+      "kind": 1,
+      "detail": "Perfect forwarding",
+      "documentation": { "value": "Forwards lvalues as lvalues and rvalues as rvalues (perfect forwarding).\n\n```cpp\ntemplate<typename T>\nvoid wrapper(T&& arg) {\n    inner(std::forward<T>(arg));\n}\n```" },
+      "insertText": "std::forward<${1:T}>(${2:arg})",
+      "insertTextRules": 4,
+      "sortText": "05_forward"
+    },
+    {
+      "label": "std::swap",
+      "kind": 1,
+      "detail": "Swap two values",
+      "documentation": { "value": "Exchanges the values of two objects.\n\n```cpp\nint a = 1, b = 2;\nstd::swap(a, b); // a=2, b=1\n```" },
+      "insertText": "std::swap(${1:a}, ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "05_swap"
+    },
+    {
+      "label": "std::optional",
+      "kind": 6,
+      "detail": "Optional value wrapper (C++17)",
+      "documentation": { "value": "Manages an optional contained value (may or may not hold a value).\n\n```cpp\nstd::optional<int> opt = 42;\nif (opt.has_value()) std::cout << *opt;\nstd::optional<std::string> empty = std::nullopt;\nauto val = opt.value_or(0);\n```" },
+      "insertText": "std::optional<${1:Type}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "05_optional"
+    },
+    {
+      "label": "std::variant",
+      "kind": 6,
+      "detail": "Type-safe union (C++17)",
+      "documentation": { "value": "Type-safe discriminated union. Holds one of several alternative types.\n\n```cpp\nstd::variant<int, double, std::string> v = \"hello\";\nstd::cout << std::get<std::string>(v);\nstd::visit([](auto&& arg) { std::cout << arg; }, v);\n```" },
+      "insertText": "std::variant<${1:Types}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "05_variant"
+    },
+    {
+      "label": "std::any",
+      "kind": 6,
+      "detail": "Type-safe container for any value (C++17)",
+      "documentation": { "value": "Type-safe container for single values of any type.\n\n```cpp\nstd::any a = 42;\na = std::string(\"hello\");\nstd::string s = std::any_cast<std::string>(a);\n```" },
+      "insertText": "std::any ${1:name}",
+      "insertTextRules": 4,
+      "sortText": "05_any"
+    },
+    {
+      "label": "std::function",
+      "kind": 6,
+      "detail": "General-purpose function wrapper",
+      "documentation": { "value": "Polymorphic function wrapper. Stores any callable target.\n\n```cpp\nstd::function<int(int, int)> add = [](int a, int b) { return a + b; };\nstd::function<void()> callback = &myFunc;\nstd::cout << add(2, 3); // 5\n```" },
+      "insertText": "std::function<${1:ReturnType}(${2:Args})> ${3:name}",
+      "insertTextRules": 4,
+      "sortText": "05_function"
+    },
+    {
+      "label": "std::bind",
+      "kind": 1,
+      "detail": "Bind arguments to callable",
+      "documentation": { "value": "Creates a function object with some arguments bound.\n\n```cpp\nusing namespace std::placeholders;\nauto bound = std::bind(&MyClass::method, &obj, _1, 42);\nbound(10); // calls obj.method(10, 42)\n```\n\n**Note:** Prefer lambdas over `std::bind` in modern C++." },
+      "insertText": "std::bind(${1:callable}, ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "05_bind"
+    },
+    {
+      "label": "std::format",
+      "kind": 1,
+      "detail": "Format string (C++20)",
+      "documentation": { "value": "Type-safe string formatting (Python-style).\n\n```cpp\n#include <format>\nstd::string s = std::format(\"Hello, {}! x = {:.2f}\", name, 3.14159);\nstd::cout << std::format(\"{:>10}\", \"right\");\n```" },
+      "insertText": "std::format(\"${1:format_string}\", ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "05_format"
+    },
+    {
+      "label": "std::span",
+      "kind": 6,
+      "detail": "Non-owning view over contiguous sequence (C++20)",
+      "documentation": { "value": "A lightweight non-owning view over a contiguous sequence of objects.\n\n```cpp\nvoid process(std::span<int> data) {\n    for (auto x : data) std::cout << x;\n}\nstd::vector<int> v = {1, 2, 3};\nprocess(v);\nint arr[] = {4, 5, 6};\nprocess(arr);\n```" },
+      "insertText": "std::span<${1:Type}> ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "05_span"
+    },
+    {
+      "label": "auto",
+      "kind": 14,
+      "detail": "Automatic type deduction",
+      "documentation": { "value": "Deduces the type of a variable from its initializer.\n\n```cpp\nauto x = 42;          // int\nauto s = \"hello\"s;    // std::string\nauto it = v.begin();  // iterator\nauto [key, val] = pair; // structured bindings\n```" },
+      "insertText": "auto ${1:name} = ${2:value}",
+      "insertTextRules": 4,
+      "sortText": "06_auto"
+    },
+    {
+      "label": "constexpr",
+      "kind": 14,
+      "detail": "Compile-time constant expression",
+      "documentation": { "value": "Specifies that a value or function can be evaluated at compile time.\n\n```cpp\nconstexpr int square(int x) { return x * x; }\nconstexpr auto val = square(5); // evaluated at compile time\nstatic_assert(square(3) == 9);\n```" },
+      "insertText": "constexpr ${1:type} ${2:name} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "06_constexpr"
+    },
+    {
+      "label": "if constexpr",
+      "kind": 14,
+      "detail": "Compile-time conditional (C++17)",
+      "documentation": { "value": "Compile-time conditional statement. Discards the false branch at compile time.\n\n```cpp\ntemplate<typename T>\nvoid process(T val) {\n    if constexpr (std::is_integral_v<T>) {\n        std::cout << \"integer: \" << val;\n    } else {\n        std::cout << \"other: \" << val;\n    }\n}\n```" },
+      "insertText": "if constexpr (${1:condition}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "06_if_constexpr"
+    },
+    {
+      "label": "class",
+      "kind": 14,
+      "detail": "Class declaration keyword",
+      "documentation": { "value": "Declares a class type (members default to private).\n\n```cpp\nclass MyClass {\npublic:\n    MyClass() = default;\n    void method();\nprivate:\n    int data_;\n};\n```" },
+      "insertText": "class",
+      "insertTextRules": 0,
+      "sortText": "06_class"
+    },
+    {
+      "label": "struct",
+      "kind": 14,
+      "detail": "Struct declaration keyword",
+      "documentation": { "value": "Declares a struct type (members default to public).\n\n```cpp\nstruct Point {\n    double x;\n    double y;\n};\n```" },
+      "insertText": "struct",
+      "insertTextRules": 0,
+      "sortText": "06_struct"
+    },
+    {
+      "label": "template",
+      "kind": 14,
+      "detail": "Template declaration keyword",
+      "documentation": { "value": "Declares a generic template.\n\n```cpp\ntemplate<typename T>\nT max(T a, T b) { return (a > b) ? a : b; }\n\ntemplate<typename T, int N>\nclass FixedArray { T data[N]; };\n```" },
+      "insertText": "template<typename ${1:T}>",
+      "insertTextRules": 4,
+      "sortText": "06_template"
+    },
+    {
+      "label": "typename",
+      "kind": 14,
+      "detail": "Template type parameter keyword",
+      "documentation": { "value": "Specifies a type template parameter or disambiguates dependent types.\n\n```cpp\ntemplate<typename T>\nvoid foo(T val);\n\ntypename Container::iterator it; // dependent name\n```" },
+      "insertText": "typename",
+      "insertTextRules": 0,
+      "sortText": "06_typename"
+    },
+    {
+      "label": "namespace",
+      "kind": 14,
+      "detail": "Namespace declaration keyword",
+      "documentation": { "value": "Declares a namespace scope.\n\n```cpp\nnamespace mylib {\n    void func();\n    class Widget {};\n}\nnamespace mylib::detail { /* nested C++17 */ }\n```" },
+      "insertText": "namespace ${1:name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "06_namespace"
+    },
+    {
+      "label": "virtual",
+      "kind": 14,
+      "detail": "Virtual function keyword",
+      "documentation": { "value": "Declares a virtual (polymorphic) member function.\n\n```cpp\nclass Base {\npublic:\n    virtual void draw() { /* default */ }\n    virtual ~Base() = default;\n};\n```" },
+      "insertText": "virtual",
+      "insertTextRules": 0,
+      "sortText": "06_virtual"
+    },
+    {
+      "label": "override",
+      "kind": 14,
+      "detail": "Override specifier",
+      "documentation": { "value": "Ensures a function overrides a virtual function in a base class.\n\n```cpp\nclass Derived : public Base {\npublic:\n    void draw() override { /* ... */ }\n};\n```" },
+      "insertText": "override",
+      "insertTextRules": 0,
+      "sortText": "06_override"
+    },
+    {
+      "label": "final",
+      "kind": 14,
+      "detail": "Final specifier",
+      "documentation": { "value": "Prevents further overriding of a virtual function or derivation from a class.\n\n```cpp\nclass Base final { }; // no derived classes\nvoid method() final; // no further override\n```" },
+      "insertText": "final",
+      "insertTextRules": 0,
+      "sortText": "06_final"
+    },
+    {
+      "label": "const",
+      "kind": 14,
+      "detail": "Const qualifier keyword",
+      "documentation": { "value": "Specifies that an object/variable cannot be modified.\n\n```cpp\nconst int x = 42;\nconst std::string& ref = str;\nvoid method() const; // does not modify *this\n```" },
+      "insertText": "const",
+      "insertTextRules": 0,
+      "sortText": "06_const"
+    },
+    {
+      "label": "static",
+      "kind": 14,
+      "detail": "Static specifier keyword",
+      "documentation": { "value": "Specifies static storage duration or class-level member.\n\n```cpp\nstatic int count = 0;        // file/function scope\nclass C { static int val; }; // shared across instances\n```" },
+      "insertText": "static",
+      "insertTextRules": 0,
+      "sortText": "06_static"
+    },
+    {
+      "label": "inline",
+      "kind": 14,
+      "detail": "Inline specifier keyword",
+      "documentation": { "value": "Suggests inline expansion and allows multiple definitions across translation units.\n\n```cpp\ninline int square(int x) { return x * x; }\ninline constexpr int val = 42; // inline variable (C++17)\n```" },
+      "insertText": "inline",
+      "insertTextRules": 0,
+      "sortText": "06_inline"
+    },
+    {
+      "label": "noexcept",
+      "kind": 14,
+      "detail": "No-exception specifier",
+      "documentation": { "value": "Specifies that a function does not throw exceptions.\n\n```cpp\nvoid func() noexcept;\nvoid cond_func() noexcept(sizeof(int) >= 4);\nbool is_ne = noexcept(func()); // operator form\n```" },
+      "insertText": "noexcept",
+      "insertTextRules": 0,
+      "sortText": "06_noexcept"
+    },
+    {
+      "label": "explicit",
+      "kind": 14,
+      "detail": "Explicit specifier keyword",
+      "documentation": { "value": "Prevents implicit conversions or copy-initialization for constructors.\n\n```cpp\nclass Foo {\npublic:\n    explicit Foo(int x);\n    explicit operator bool() const;\n};\n```" },
+      "insertText": "explicit",
+      "insertTextRules": 0,
+      "sortText": "06_explicit"
+    },
+    {
+      "label": "mutable",
+      "kind": 14,
+      "detail": "Mutable specifier keyword",
+      "documentation": { "value": "Allows modification of a member even in a const context.\n\n```cpp\nclass Cache {\n    mutable std::map<int, int> cache_;\npublic:\n    int get(int key) const { cache_[key]++; return cache_[key]; }\n};\n```" },
+      "insertText": "mutable",
+      "insertTextRules": 0,
+      "sortText": "06_mutable"
+    },
+    {
+      "label": "friend",
+      "kind": 14,
+      "detail": "Friend declaration keyword",
+      "documentation": { "value": "Grants a function or class access to private/protected members.\n\n```cpp\nclass MyClass {\n    friend class OtherClass;\n    friend std::ostream& operator<<(std::ostream&, const MyClass&);\n};\n```" },
+      "insertText": "friend",
+      "insertTextRules": 0,
+      "sortText": "06_friend"
+    },
+    {
+      "label": "using",
+      "kind": 14,
+      "detail": "Using declaration/directive",
+      "documentation": { "value": "Introduces names from namespaces or creates type aliases.\n\n```cpp\nusing std::cout;\nusing namespace std;\nusing StringVec = std::vector<std::string>;\ntemplate<typename T> using Vec = std::vector<T>;\n```" },
+      "insertText": "using",
+      "insertTextRules": 0,
+      "sortText": "06_using"
+    },
+    {
+      "label": "decltype",
+      "kind": 14,
+      "detail": "Decltype specifier",
+      "documentation": { "value": "Yields the type of an expression at compile time.\n\n```cpp\nint x = 42;\ndecltype(x) y = 10;   // int\ndecltype(auto) z = x; // int\n```" },
+      "insertText": "decltype(${1:expr})",
+      "insertTextRules": 4,
+      "sortText": "06_decltype"
+    },
+    {
+      "label": "nullptr",
+      "kind": 14,
+      "detail": "Null pointer literal",
+      "documentation": { "value": "The null pointer literal (type `std::nullptr_t`).\n\n```cpp\nint* p = nullptr;\nif (p == nullptr) { /* ... */ }\nvoid func(int*); func(nullptr);\n```" },
+      "insertText": "nullptr",
+      "insertTextRules": 0,
+      "sortText": "06_nullptr"
+    },
+    {
+      "label": "static_cast",
+      "kind": 14,
+      "detail": "Static cast operator",
+      "documentation": { "value": "Performs compile-time checked type conversion.\n\n```cpp\ndouble d = 3.14;\nint i = static_cast<int>(d);\nBase* b = static_cast<Base*>(derived_ptr);\n```" },
+      "insertText": "static_cast<${1:Type}>(${2:expr})",
+      "insertTextRules": 4,
+      "sortText": "06_static_cast"
+    },
+    {
+      "label": "dynamic_cast",
+      "kind": 14,
+      "detail": "Dynamic cast operator",
+      "documentation": { "value": "Performs runtime-checked polymorphic type conversion.\n\n```cpp\nBase* b = getBase();\nDerived* d = dynamic_cast<Derived*>(b);\nif (d) { /* safe to use d */ }\n```" },
+      "insertText": "dynamic_cast<${1:Type}>(${2:expr})",
+      "insertTextRules": 4,
+      "sortText": "06_dynamic_cast"
+    },
+    {
+      "label": "reinterpret_cast",
+      "kind": 14,
+      "detail": "Reinterpret cast operator",
+      "documentation": { "value": "Performs low-level reinterpretation of bit patterns.\n\n```cpp\nint i = 42;\nvoid* p = reinterpret_cast<void*>(&i);\nauto fp = reinterpret_cast<void(*)(int)>(addr);\n```\n\n**Warning:** Potentially unsafe. Use only when necessary." },
+      "insertText": "reinterpret_cast<${1:Type}>(${2:expr})",
+      "insertTextRules": 4,
+      "sortText": "06_reinterpret_cast"
+    },
+    {
+      "label": "class definition",
+      "kind": 27,
+      "detail": "Snippet: class with constructor/destructor",
+      "documentation": { "value": "Generates a full class definition skeleton.\n\n```cpp\nclass MyClass {\npublic:\n    MyClass();\n    ~MyClass();\nprivate:\n    int member_;\n};\n```" },
+      "insertText": "class ${1:ClassName} {\npublic:\n\t${1:ClassName}(${2:}) {\n\t\t$3\n\t}\n\n\t~${1:ClassName}() = default;\n\nprivate:\n\t${4:int member_};\n};",
+      "insertTextRules": 4,
+      "sortText": "07_class_def"
+    },
+    {
+      "label": "template class",
+      "kind": 27,
+      "detail": "Snippet: template class definition",
+      "documentation": { "value": "Generates a template class skeleton.\n\n```cpp\ntemplate<typename T>\nclass Container {\npublic:\n    void add(const T& item);\nprivate:\n    std::vector<T> items_;\n};\n```" },
+      "insertText": "template<typename ${1:T}>\nclass ${2:ClassName} {\npublic:\n\t${2:ClassName}(${3:}) {\n\t\t$4\n\t}\n\nprivate:\n\t${5:T data_};\n};",
+      "insertTextRules": 4,
+      "sortText": "07_template_class"
+    },
+    {
+      "label": "range-based for",
+      "kind": 15,
+      "detail": "Snippet: range-based for loop",
+      "documentation": { "value": "Generates a range-based for loop.\n\n```cpp\nfor (const auto& item : container) {\n    // process item\n}\n```" },
+      "insertText": "for (const auto& ${1:item} : ${2:container}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "07_range_for"
+    },
+    {
+      "label": "lambda",
+      "kind": 15,
+      "detail": "Snippet: lambda expression",
+      "documentation": { "value": "Generates a lambda expression.\n\n```cpp\nauto fn = [](int x) { return x * 2; };\nauto fn2 = [&](auto x) { return x + offset; };\n```" },
+      "insertText": "[${1:&}](${2:auto} ${3:param}) {\n\t${4:return $3;}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_lambda"
+    },
+    {
+      "label": "try-catch",
+      "kind": 15,
+      "detail": "Snippet: try-catch block",
+      "documentation": { "value": "Generates a try-catch exception handling block.\n\n```cpp\ntry {\n    // risky code\n} catch (const std::exception& e) {\n    std::cerr << e.what();\n}\n```" },
+      "insertText": "try {\n\t${1:// code}\n} catch (const ${2:std::exception}& ${3:e}) {\n\t${4:std::cerr << $3.what() << std::endl;}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_try_catch"
+    },
+    {
+      "label": "smart pointer creation",
+      "kind": 15,
+      "detail": "Snippet: create smart pointer",
+      "documentation": { "value": "Creates a smart pointer using make_unique or make_shared.\n\n```cpp\nauto ptr = std::make_unique<MyClass>(args...);\nauto sptr = std::make_shared<MyClass>(args...);\n```" },
+      "insertText": "auto ${1:ptr} = std::make_${2|unique,shared|}<${3:Type}>(${4:args})",
+      "insertTextRules": 4,
+      "sortText": "07_smart_ptr"
+    },
+    {
+      "label": "main function",
+      "kind": 15,
+      "detail": "Snippet: int main()",
+      "documentation": { "value": "Generates the main function entry point.\n\n```cpp\nint main(int argc, char* argv[]) {\n    return 0;\n}\n```" },
+      "insertText": "int main(${1:int argc, char* argv[]}) {\n\t$0\n\treturn 0;\n}",
+      "insertTextRules": 4,
+      "sortText": "07_main"
+    },
+    {
+      "label": "co_await",
+      "kind": 14,
+      "detail": "Coroutine await expression (C++20)",
+      "documentation": { "value": "Suspends a coroutine and waits for a result.\n\n```cpp\ntask<int> fetch_data() {\n    auto result = co_await async_read();\n    co_return result;\n}\n```" },
+      "insertText": "co_await ${1:expr}",
+      "insertTextRules": 4,
+      "sortText": "06_co_await"
+    },
+    {
+      "label": "concept",
+      "kind": 14,
+      "detail": "Concept declaration (C++20)",
+      "documentation": { "value": "Defines a named set of constraints for template arguments.\n\n```cpp\ntemplate<typename T>\nconcept Addable = requires(T a, T b) {\n    { a + b } -> std::convertible_to<T>;\n};\n\ntemplate<Addable T>\nT add(T a, T b) { return a + b; }\n```" },
+      "insertText": "template<typename ${1:T}>\nconcept ${2:ConceptName} = requires(${1:T} ${3:a}) {\n\t${4:{ $3.method() \\} -> std::same_as<void>};\n};",
+      "insertTextRules": 4,
+      "sortText": "06_concept"
+    },
+    {
+      "label": "ranges::views",
+      "kind": 5,
+      "detail": "Ranges views (C++20)",
+      "documentation": { "value": "Composable lazy range adaptors.\n\n```cpp\n#include <ranges>\nnamespace rv = std::ranges::views;\nauto evens = v | rv::filter([](int x) { return x % 2 == 0; });\nauto squares = v | rv::transform([](int x) { return x * x; });\nauto first5 = v | rv::take(5);\n```" },
+      "insertText": "${1:container} | std::ranges::views::${2|filter,transform,take,drop,reverse|}(${3:predicate})",
+      "insertTextRules": 4,
+      "sortText": "05_ranges"
+    },
+    {
+      "label": "structured bindings",
+      "kind": 15,
+      "detail": "Snippet: structured bindings (C++17)",
+      "documentation": { "value": "Decompose an object into named variables.\n\n```cpp\nauto [x, y] = std::make_pair(1, 2);\nfor (auto& [key, value] : myMap) {\n    std::cout << key << \": \" << value;\n}\n```" },
+      "insertText": "auto [${1:a}, ${2:b}] = ${3:expr}",
+      "insertTextRules": 4,
+      "sortText": "07_structured_bindings"
+    },
+    {
+      "label": "#include",
+      "kind": 15,
+      "detail": "Snippet: include header",
+      "documentation": { "value": "Include a header file.\n\n```cpp\n#include <iostream>\n#include <vector>\n#include \"myheader.h\"\n```" },
+      "insertText": "#include <${1:iostream}>",
+      "insertTextRules": 4,
+      "sortText": "07_include"
+    },
+    {
+      "label": "enum class",
+      "kind": 15,
+      "detail": "Snippet: scoped enumeration",
+      "documentation": { "value": "Declares a scoped (strongly-typed) enumeration.\n\n```cpp\nenum class Color : uint8_t {\n    Red,\n    Green,\n    Blue\n};\nColor c = Color::Red;\n```" },
+      "insertText": "enum class ${1:Name} {\n\t${2:Value1},\n\t${3:Value2},\n\t${4:Value3}\n};",
+      "insertTextRules": 4,
+      "sortText": "07_enum_class"
+    },
+    {
+      "label": "static_assert",
+      "kind": 14,
+      "detail": "Compile-time assertion",
+      "documentation": { "value": "Asserts a condition at compile time.\n\n```cpp\nstatic_assert(sizeof(int) >= 4, \"int must be at least 4 bytes\");\nstatic_assert(std::is_integral_v<int>);\n```" },
+      "insertText": "static_assert(${1:condition}, \"${2:message}\")",
+      "insertTextRules": 4,
+      "sortText": "06_static_assert"
+    },
+    {
+      "label": "std::thread",
+      "kind": 6,
+      "detail": "Thread of execution",
+      "documentation": { "value": "Manages a separate thread of execution.\n\n```cpp\n#include <thread>\nstd::thread t([]{ std::cout << \"Hello from thread\"; });\nt.join();\n// or t.detach();\n```" },
+      "insertText": "std::thread ${1:t}(${2:callable})",
+      "insertTextRules": 4,
+      "sortText": "05_thread"
+    },
+    {
+      "label": "std::mutex",
+      "kind": 6,
+      "detail": "Mutual exclusion",
+      "documentation": { "value": "Provides mutual exclusion for protecting shared data.\n\n```cpp\n#include <mutex>\nstd::mutex mtx;\n{\n    std::lock_guard<std::mutex> lock(mtx);\n    // critical section\n}\n```" },
+      "insertText": "std::mutex ${1:mtx}",
+      "insertTextRules": 4,
+      "sortText": "05_mutex"
+    },
+    {
+      "label": "std::lock_guard",
+      "kind": 6,
+      "detail": "RAII mutex lock",
+      "documentation": { "value": "RAII wrapper that locks a mutex on construction and unlocks on destruction.\n\n```cpp\nstd::mutex mtx;\n{\n    std::lock_guard<std::mutex> lock(mtx);\n    // safe access to shared data\n}\n```" },
+      "insertText": "std::lock_guard<std::mutex> ${1:lock}(${2:mtx})",
+      "insertTextRules": 4,
+      "sortText": "05_lock_guard"
+    }
+  ]
+}