@enjoys/context-engine 1.0.0 → 1.0.2

package/data/hover/cpp.json

@@ -0,0 +1,210 @@
+{
+  "language": "cpp",
+  "hovers": {
+    "std::vector": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, class Allocator = std::allocator<T>>\nclass vector;\n```\nDynamic contiguous array. Automatic memory management with amortized O(1) `push_back`. O(1) random access. Most commonly used container in C++.\n\n**Header:** `<vector>`" }
+      ]
+    },
+    "std::map": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class Key, class T, class Compare = std::less<Key>,\n         class Allocator = std::allocator<std::pair<const Key, T>>>\nclass map;\n```\nSorted associative container storing unique key-value pairs using a red-black tree. O(log n) lookup, insertion, and removal. Keys are ordered by `Compare`.\n\n**Header:** `<map>`" }
+      ]
+    },
+    "std::unordered_map": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class Key, class T, class Hash = std::hash<Key>,\n         class KeyEqual = std::equal_to<Key>,\n         class Allocator = std::allocator<std::pair<const Key, T>>>\nclass unordered_map;\n```\nHash-based associative container with unique keys. Average O(1) lookup, insertion, and removal. Unordered iteration.\n\n**Header:** `<unordered_map>`" }
+      ]
+    },
+    "std::set": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class Key, class Compare = std::less<Key>,\n         class Allocator = std::allocator<Key>>\nclass set;\n```\nSorted container of unique elements using a red-black tree. O(log n) insertion, removal, and lookup.\n\n**Header:** `<set>`" }
+      ]
+    },
+    "std::unordered_set": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class Key, class Hash = std::hash<Key>,\n         class KeyEqual = std::equal_to<Key>,\n         class Allocator = std::allocator<Key>>\nclass unordered_set;\n```\nHash-based container of unique elements. Average O(1) insertion, removal, and lookup.\n\n**Header:** `<unordered_set>`" }
+      ]
+    },
+    "std::string": {
+      "contents": [
+        { "value": "```cpp\nusing string = std::basic_string<char>;\n```\nDynamic character string with automatic memory management. Supports concatenation, comparison, searching, and SSO (Small String Optimization).\n\n**Header:** `<string>`" }
+      ]
+    },
+    "std::string_view": {
+      "contents": [
+        { "value": "```cpp\nusing string_view = std::basic_string_view<char>;\n```\nLightweight non-owning read-only reference to a character sequence. Zero-copy. Use instead of `const std::string&` for function parameters. **(C++17)**\n\n**Header:** `<string_view>`" }
+      ]
+    },
+    "std::array": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, std::size_t N>\nstruct array;\n```\nFixed-size aggregate array with STL interface. Stack-allocated with zero overhead over C-style arrays. Supports `at()` for bounds checking.\n\n**Header:** `<array>`" }
+      ]
+    },
+    "std::deque": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, class Allocator = std::allocator<T>>\nclass deque;\n```\nDouble-ended queue with O(1) insertion and removal at both front and back. Does not guarantee contiguous storage.\n\n**Header:** `<deque>`" }
+      ]
+    },
+    "std::list": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, class Allocator = std::allocator<T>>\nclass list;\n```\nDoubly-linked list with O(1) insertion and removal at any position (given an iterator). No random access.\n\n**Header:** `<list>`" }
+      ]
+    },
+    "std::stack": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, class Container = std::deque<T>>\nclass stack;\n```\nContainer adapter providing LIFO (last-in, first-out) stack operations: `push`, `pop`, `top`.\n\n**Header:** `<stack>`" }
+      ]
+    },
+    "std::queue": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, class Container = std::deque<T>>\nclass queue;\n```\nContainer adapter providing FIFO (first-in, first-out) queue operations: `push`, `pop`, `front`, `back`.\n\n**Header:** `<queue>`" }
+      ]
+    },
+    "std::priority_queue": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, class Container = std::vector<T>,\n         class Compare = std::less<typename Container::value_type>>\nclass priority_queue;\n```\nContainer adapter providing constant-time access to the largest (by default) element. Implemented as a max-heap.\n\n**Header:** `<queue>`" }
+      ]
+    },
+    "std::pair": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T1, class T2>\nstruct pair;\n```\nHolds two heterogeneous objects. Access via `.first` and `.second` or structured bindings `auto [a, b] = p;`.\n\n**Header:** `<utility>`" }
+      ]
+    },
+    "std::tuple": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class... Types>\nclass tuple;\n```\nFixed-size heterogeneous collection. Access via `std::get<N>(t)` or structured bindings. Generalizes `std::pair`.\n\n**Header:** `<tuple>`" }
+      ]
+    },
+    "std::optional": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T>\nclass optional;\n```\nManages an optional contained value — may or may not hold a value. Use `.value()`, `.value_or(default)`, or `*opt` to access. **(C++17)**\n\n**Header:** `<optional>`" }
+      ]
+    },
+    "std::variant": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class... Types>\nclass variant;\n```\nType-safe discriminated union. Holds exactly one of the alternative types at any time. Access via `std::get<T>(v)` or `std::visit`. **(C++17)**\n\n**Header:** `<variant>`" }
+      ]
+    },
+    "std::any": {
+      "contents": [
+        { "value": "```cpp\nclass any;\n```\nType-safe container for single values of any copy-constructible type. Access via `std::any_cast<T>(a)`. **(C++17)**\n\n**Header:** `<any>`" }
+      ]
+    },
+    "std::unique_ptr": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, class Deleter = std::default_delete<T>>\nclass unique_ptr;\n```\nSmart pointer with exclusive ownership semantics. Non-copyable, movable. Automatically deletes the managed object when it goes out of scope. Use `std::make_unique<T>()` to create.\n\n**Header:** `<memory>`" }
+      ]
+    },
+    "std::shared_ptr": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T>\nclass shared_ptr;\n```\nSmart pointer with shared (reference-counted) ownership. Object is destroyed when the last `shared_ptr` owning it is destroyed. Use `std::make_shared<T>()` to create.\n\n**Header:** `<memory>`" }
+      ]
+    },
+    "std::weak_ptr": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T>\nclass weak_ptr;\n```\nNon-owning smart pointer that references a `shared_ptr`-managed object without affecting the reference count. Use `.lock()` to obtain a `shared_ptr`. Breaks circular references.\n\n**Header:** `<memory>`" }
+      ]
+    },
+    "std::function": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class R, class... Args>\nclass function<R(Args...)>;\n```\nGeneral-purpose polymorphic function wrapper. Stores any callable target: functions, lambdas, bind expressions, member function pointers. Type-erased.\n\n**Header:** `<functional>`" }
+      ]
+    },
+    "std::span": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, std::size_t Extent = std::dynamic_extent>\nclass span;\n```\nNon-owning view over a contiguous sequence of objects. Replaces `(T* ptr, size_t len)` pairs. Works with arrays, vectors, and C-arrays. **(C++20)**\n\n**Header:** `<span>`" }
+      ]
+    },
+    "std::sort": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class RandomIt>\nvoid sort(RandomIt first, RandomIt last);\n\ntemplate<class RandomIt, class Compare>\nvoid sort(RandomIt first, RandomIt last, Compare comp);\n```\nSorts elements in [first, last) in ascending order using introsort. O(n log n) guaranteed.\n\n**Header:** `<algorithm>`" }
+      ]
+    },
+    "std::find": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class InputIt, class T>\nInputIt find(InputIt first, InputIt last, const T& value);\n```\nReturns an iterator to the first element equal to `value` in [first, last). Returns `last` if not found. O(n).\n\n**Header:** `<algorithm>`" }
+      ]
+    },
+    "std::transform": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class InputIt, class OutputIt, class UnaryOp>\nOutputIt transform(InputIt first, InputIt last,\n                   OutputIt d_first, UnaryOp op);\n```\nApplies `op` to each element and writes the result to `d_first`. Functional-style map operation.\n\n**Header:** `<algorithm>`" }
+      ]
+    },
+    "std::accumulate": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class InputIt, class T>\nT accumulate(InputIt first, InputIt last, T init);\n\ntemplate<class InputIt, class T, class BinaryOp>\nT accumulate(InputIt first, InputIt last, T init, BinaryOp op);\n```\nComputes a left fold over [first, last) starting with `init`. Default operation is addition.\n\n**Header:** `<numeric>`" }
+      ]
+    },
+    "std::move": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T>\nconstexpr std::remove_reference_t<T>&& move(T&& t) noexcept;\n```\nCasts to an rvalue reference, indicating the argument may be \"moved from.\" Enables efficient resource transfer via move constructors/assignment operators.\n\n**Header:** `<utility>`" }
+      ]
+    },
+    "std::forward": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T>\nconstexpr T&& forward(std::remove_reference_t<T>& t) noexcept;\n```\nForwards lvalues as lvalues and rvalues as rvalues. Essential for perfect forwarding in template code.\n\n**Header:** `<utility>`" }
+      ]
+    },
+    "std::make_unique": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, class... Args>\nunique_ptr<T> make_unique(Args&&... args); // (C++14)\n```\nCreates a `std::unique_ptr` managing a new object constructed with the given arguments. Exception-safe. Preferred over raw `new`.\n\n**Header:** `<memory>`" }
+      ]
+    },
+    "std::make_shared": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class T, class... Args>\nshared_ptr<T> make_shared(Args&&... args);\n```\nCreates a `std::shared_ptr` with a single allocation for both the object and the control block. More efficient than `shared_ptr<T>(new T(...))`.\n\n**Header:** `<memory>`" }
+      ]
+    },
+    "std::cout": {
+      "contents": [
+        { "value": "```cpp\nextern std::ostream cout;\n```\nThe standard output stream associated with the C stream `stdout`. Thread-safe for individual operations when synchronized with C I/O (default).\n\n**Header:** `<iostream>`" }
+      ]
+    },
+    "std::cin": {
+      "contents": [
+        { "value": "```cpp\nextern std::istream cin;\n```\nThe standard input stream associated with the C stream `stdin`. Tied to `std::cout` by default for prompt flushing.\n\n**Header:** `<iostream>`" }
+      ]
+    },
+    "std::endl": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class CharT, class Traits>\nstd::basic_ostream<CharT, Traits>&\n  endl(std::basic_ostream<CharT, Traits>& os);\n```\nInserts `'\\n'` and flushes the stream. Use `'\\n'` instead when flushing is not needed for better performance.\n\n**Header:** `<ostream>`" }
+      ]
+    },
+    "std::format": {
+      "contents": [
+        { "value": "```cpp\ntemplate<class... Args>\nstd::string format(std::format_string<Args...> fmt, Args&&... args);\n```\nType-safe Python-style string formatting. Supports positional args, alignment, fill, precision, and type specifiers. **(C++20)**\n\n**Header:** `<format>`" }
+      ]
+    },
+    "std::ranges": {
+      "contents": [
+        { "value": "```cpp\nnamespace std::ranges { ... }\n```\nThe Ranges library providing composable, lazy range adaptors and constrained algorithms. Includes `views::filter`, `views::transform`, `views::take`, `views::drop`, `views::reverse`, and more. **(C++20)**\n\n**Header:** `<ranges>`" }
+      ]
+    },
+    "constexpr": {
+      "contents": [
+        { "value": "```cpp\nconstexpr int factorial(int n) {\n    return (n <= 1) ? 1 : n * factorial(n - 1);\n}\n```\nSpecifies that a value or function can be evaluated at compile time. Extended in C++14 (relaxed rules), C++17 (`if constexpr`), and C++20 (`constexpr` virtual, dynamic allocation)." }
+      ]
+    },
+    "auto": {
+      "contents": [
+        { "value": "```cpp\nauto x = 42;           // int\nauto s = \"hello\"s;     // std::string\nauto [k, v] = pair;    // structured bindings (C++17)\nauto fn = [](auto x) { return x; }; // generic lambda (C++14)\n```\nAutomatic type deduction from the initializer expression. Also used for function return type deduction and generic lambdas." }
+      ]
+    },
+    "nullptr": {
+      "contents": [
+        { "value": "```cpp\nconstexpr std::nullptr_t nullptr;\n```\nThe null pointer literal of type `std::nullptr_t`. Preferred over `NULL` or `0` for pointer initialization. Unambiguous in overload resolution." }
+      ]
+    },
+    "std::thread": {
+      "contents": [
+        { "value": "```cpp\nclass thread;\n```\nRepresents a single thread of execution. Construct with a callable. Must be `join()`ed or `detach()`ed before destruction.\n\n**Header:** `<thread>`" }
+      ]
+    },
+    "std::mutex": {
+      "contents": [
+        { "value": "```cpp\nclass mutex;\n```\nProvides basic mutual exclusion. Non-recursive. Use `std::lock_guard` or `std::unique_lock` for RAII-style locking.\n\n**Header:** `<mutex>`" }
+      ]
+    }
+  }
+}

package/data/hover/csharp.json

@@ -0,0 +1,290 @@
+{
+  "language": "csharp",
+  "hovers": {
+    "Console.WriteLine": {
+      "contents": [
+        { "value": "```csharp\npublic static void WriteLine(string? value)\n```\nWrites the specified string value, followed by the current line terminator, to the standard output stream." }
+      ]
+    },
+    "Console.Write": {
+      "contents": [
+        { "value": "```csharp\npublic static void Write(string? value)\n```\nWrites the specified string value to the standard output stream without a trailing line terminator." }
+      ]
+    },
+    "Console.ReadLine": {
+      "contents": [
+        { "value": "```csharp\npublic static string? ReadLine()\n```\nReads the next line of characters from the standard input stream. Returns null if no more lines are available." }
+      ]
+    },
+    "Console.ReadKey": {
+      "contents": [
+        { "value": "```csharp\npublic static ConsoleKeyInfo ReadKey(bool intercept = false)\n```\nObtains the next character or function key pressed by the user. Optionally suppresses display of the pressed key." }
+      ]
+    },
+    "Debug.WriteLine": {
+      "contents": [
+        { "value": "```csharp\npublic static void WriteLine(string? message)\n```\nWrites a message followed by a line terminator to the trace listeners in the Debug.Listeners collection." }
+      ]
+    },
+    "string.Format": {
+      "contents": [
+        { "value": "```csharp\npublic static string Format(string format, params object?[] args)\n```\nReplaces one or more format items in a string with the string representation of corresponding objects. Supports composite formatting with alignment and format specifiers." }
+      ]
+    },
+    "string.Join": {
+      "contents": [
+        { "value": "```csharp\npublic static string Join(string? separator, IEnumerable<string?> values)\n```\nConcatenates the members of a collection, using the specified separator between each member." }
+      ]
+    },
+    "string.IsNullOrEmpty": {
+      "contents": [
+        { "value": "```csharp\npublic static bool IsNullOrEmpty(string? value)\n```\nIndicates whether the specified string is null or an empty string (\"\"). Equivalent to `value == null || value.Length == 0`." }
+      ]
+    },
+    "string.IsNullOrWhiteSpace": {
+      "contents": [
+        { "value": "```csharp\npublic static bool IsNullOrWhiteSpace(string? value)\n```\nIndicates whether a specified string is null, empty, or consists only of white-space characters." }
+      ]
+    },
+    "string.Concat": {
+      "contents": [
+        { "value": "```csharp\npublic static string Concat(params string?[] values)\n```\nConcatenates one or more instances of String, or the String representations of the values of one or more objects." }
+      ]
+    },
+    "string.Compare": {
+      "contents": [
+        { "value": "```csharp\npublic static int Compare(string? strA, string? strB, StringComparison comparisonType)\n```\nCompares two specified String objects using the specified comparison rules, and returns an integer indicating their relative position in the sort order." }
+      ]
+    },
+    "Substring": {
+      "contents": [
+        { "value": "```csharp\npublic string Substring(int startIndex, int length)\n```\nRetrieves a substring from this instance starting at a specified character position with a specified length." }
+      ]
+    },
+    "Contains": {
+      "contents": [
+        { "value": "```csharp\npublic bool Contains(string value, StringComparison comparisonType)\n```\nReturns a value indicating whether a specified substring occurs within this string, using the specified comparison rules." }
+      ]
+    },
+    "StartsWith": {
+      "contents": [
+        { "value": "```csharp\npublic bool StartsWith(string value, StringComparison comparisonType)\n```\nDetermines whether the beginning of this string instance matches the specified string when compared using the specified comparison option." }
+      ]
+    },
+    "EndsWith": {
+      "contents": [
+        { "value": "```csharp\npublic bool EndsWith(string value, StringComparison comparisonType)\n```\nDetermines whether the end of this string instance matches the specified string when compared using the specified comparison option." }
+      ]
+    },
+    "IndexOf": {
+      "contents": [
+        { "value": "```csharp\npublic int IndexOf(string value, StringComparison comparisonType)\n```\nReports the zero-based index of the first occurrence of the specified string within this instance. Returns -1 if not found." }
+      ]
+    },
+    "Replace": {
+      "contents": [
+        { "value": "```csharp\npublic string Replace(string oldValue, string? newValue)\n```\nReturns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string." }
+      ]
+    },
+    "Split": {
+      "contents": [
+        { "value": "```csharp\npublic string[] Split(char separator, StringSplitOptions options = None)\n```\nSplits a string into substrings based on a specified delimiting character and, optionally, options to trim and remove empty entries." }
+      ]
+    },
+    "Trim": {
+      "contents": [
+        { "value": "```csharp\npublic string Trim()\n```\nRemoves all leading and trailing white-space characters from the current string." }
+      ]
+    },
+    "ToUpper": {
+      "contents": [
+        { "value": "```csharp\npublic string ToUpper()\n```\nReturns a copy of this string converted to uppercase, using the casing rules of the current culture." }
+      ]
+    },
+    "ToLower": {
+      "contents": [
+        { "value": "```csharp\npublic string ToLower()\n```\nReturns a copy of this string converted to lowercase, using the casing rules of the current culture." }
+      ]
+    },
+    "List": {
+      "contents": [
+        { "value": "```csharp\npublic class List<T> : IList<T>, IReadOnlyList<T>\n```\nRepresents a strongly typed list of objects that can be accessed by index. Provides methods to search, sort, and manipulate lists." }
+      ]
+    },
+    "Dictionary": {
+      "contents": [
+        { "value": "```csharp\npublic class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, IReadOnlyDictionary<TKey, TValue>\n```\nRepresents a collection of keys and values. Provides O(1) average-time lookups by key." }
+      ]
+    },
+    "HashSet": {
+      "contents": [
+        { "value": "```csharp\npublic class HashSet<T> : ISet<T>, IReadOnlySet<T>\n```\nRepresents a set of values. Provides high-performance set operations such as union, intersection, and difference." }
+      ]
+    },
+    "Queue": {
+      "contents": [
+        { "value": "```csharp\npublic class Queue<T> : IEnumerable<T>, IReadOnlyCollection<T>\n```\nRepresents a first-in, first-out (FIFO) collection of objects." }
+      ]
+    },
+    "Stack": {
+      "contents": [
+        { "value": "```csharp\npublic class Stack<T> : IEnumerable<T>, IReadOnlyCollection<T>\n```\nRepresents a variable size last-in, first-out (LIFO) collection of instances of the same specified type." }
+      ]
+    },
+    "Where": {
+      "contents": [
+        { "value": "```csharp\npublic static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)\n```\nFilters a sequence of values based on a predicate. Returns elements for which the predicate returns true." }
+      ]
+    },
+    "Select": {
+      "contents": [
+        { "value": "```csharp\npublic static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)\n```\nProjects each element of a sequence into a new form by applying a transform function." }
+      ]
+    },
+    "SelectMany": {
+      "contents": [
+        { "value": "```csharp\npublic static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)\n```\nProjects each element to an IEnumerable<T> and flattens the resulting sequences into one sequence." }
+      ]
+    },
+    "OrderBy": {
+      "contents": [
+        { "value": "```csharp\npublic static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)\n```\nSorts the elements of a sequence in ascending order according to a key." }
+      ]
+    },
+    "GroupBy": {
+      "contents": [
+        { "value": "```csharp\npublic static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)\n```\nGroups the elements of a sequence according to a specified key selector function." }
+      ]
+    },
+    "First": {
+      "contents": [
+        { "value": "```csharp\npublic static TSource First<TSource>(this IEnumerable<TSource> source)\n```\nReturns the first element of a sequence. Throws InvalidOperationException if the sequence contains no elements." }
+      ]
+    },
+    "FirstOrDefault": {
+      "contents": [
+        { "value": "```csharp\npublic static TSource? FirstOrDefault<TSource>(this IEnumerable<TSource> source)\n```\nReturns the first element of a sequence, or a default value if the sequence contains no elements." }
+      ]
+    },
+    "Any": {
+      "contents": [
+        { "value": "```csharp\npublic static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)\n```\nDetermines whether any element of a sequence satisfies a condition." }
+      ]
+    },
+    "All": {
+      "contents": [
+        { "value": "```csharp\npublic static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)\n```\nDetermines whether all elements of a sequence satisfy a condition." }
+      ]
+    },
+    "Count": {
+      "contents": [
+        { "value": "```csharp\npublic static int Count<TSource>(this IEnumerable<TSource> source)\n```\nReturns the number of elements in a sequence. An overload accepts a predicate to count only matching elements." }
+      ]
+    },
+    "Sum": {
+      "contents": [
+        { "value": "```csharp\npublic static int Sum(this IEnumerable<int> source)\n```\nComputes the sum of a sequence of numeric values. Overloads exist for int, long, float, double, and decimal." }
+      ]
+    },
+    "Distinct": {
+      "contents": [
+        { "value": "```csharp\npublic static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source)\n```\nReturns distinct elements from a sequence by using the default equality comparer to compare values." }
+      ]
+    },
+    "Task.Run": {
+      "contents": [
+        { "value": "```csharp\npublic static Task Run(Action action)\npublic static Task<TResult> Run<TResult>(Func<TResult> function)\n```\nQueues the specified work to run on the ThreadPool and returns a Task or Task<TResult> handle for that work." }
+      ]
+    },
+    "Task.WhenAll": {
+      "contents": [
+        { "value": "```csharp\npublic static Task WhenAll(IEnumerable<Task> tasks)\npublic static Task<TResult[]> WhenAll<TResult>(IEnumerable<Task<TResult>> tasks)\n```\nCreates a task that will complete when all of the supplied tasks have completed." }
+      ]
+    },
+    "Task.WhenAny": {
+      "contents": [
+        { "value": "```csharp\npublic static Task<Task> WhenAny(IEnumerable<Task> tasks)\n```\nCreates a task that will complete when any of the supplied tasks have completed." }
+      ]
+    },
+    "Task.Delay": {
+      "contents": [
+        { "value": "```csharp\npublic static Task Delay(int millisecondsDelay)\npublic static Task Delay(TimeSpan delay)\n```\nCreates a task that completes after a specified time interval." }
+      ]
+    },
+    "Task.FromResult": {
+      "contents": [
+        { "value": "```csharp\npublic static Task<TResult> FromResult<TResult>(TResult result)\n```\nCreates a Task<TResult> that is completed successfully with the specified result." }
+      ]
+    },
+    "Math.Max": {
+      "contents": [
+        { "value": "```csharp\npublic static int Max(int val1, int val2)\n```\nReturns the larger of two specified numbers. Overloads exist for all numeric types." }
+      ]
+    },
+    "Math.Min": {
+      "contents": [
+        { "value": "```csharp\npublic static int Min(int val1, int val2)\n```\nReturns the smaller of two specified numbers. Overloads exist for all numeric types." }
+      ]
+    },
+    "Math.Abs": {
+      "contents": [
+        { "value": "```csharp\npublic static int Abs(int value)\n```\nReturns the absolute value of a specified number. Overloads exist for all signed numeric types." }
+      ]
+    },
+    "Math.Sqrt": {
+      "contents": [
+        { "value": "```csharp\npublic static double Sqrt(double d)\n```\nReturns the square root of a specified number. Returns NaN if d is negative." }
+      ]
+    },
+    "Math.Pow": {
+      "contents": [
+        { "value": "```csharp\npublic static double Pow(double x, double y)\n```\nReturns a specified number raised to the specified power." }
+      ]
+    },
+    "Math.Round": {
+      "contents": [
+        { "value": "```csharp\npublic static double Round(double value, int digits)\n```\nRounds a double-precision floating-point value to a specified number of fractional digits using banker's rounding by default." }
+      ]
+    },
+    "int.Parse": {
+      "contents": [
+        { "value": "```csharp\npublic static int Parse(string s)\n```\nConverts the string representation of a number to its 32-bit signed integer equivalent. Throws FormatException if the string is not valid." }
+      ]
+    },
+    "int.TryParse": {
+      "contents": [
+        { "value": "```csharp\npublic static bool TryParse(string? s, out int result)\n```\nConverts the string representation of a number to its 32-bit signed integer equivalent. Returns whether the conversion succeeded without throwing an exception." }
+      ]
+    },
+    "Guid.NewGuid": {
+      "contents": [
+        { "value": "```csharp\npublic static Guid NewGuid()\n```\nInitializes a new instance of the Guid structure with a cryptographically random value (version 4 UUID)." }
+      ]
+    },
+    "DateTime.Now": {
+      "contents": [
+        { "value": "```csharp\npublic static DateTime Now { get; }\n```\nGets a DateTime object that is set to the current date and time on this computer, expressed as the local time." }
+      ]
+    },
+    "DateTime.UtcNow": {
+      "contents": [
+        { "value": "```csharp\npublic static DateTime UtcNow { get; }\n```\nGets a DateTime object that is set to the current date and time on this computer, expressed as Coordinated Universal Time (UTC)." }
+      ]
+    },
+    "Enumerable.Range": {
+      "contents": [
+        { "value": "```csharp\npublic static IEnumerable<int> Range(int start, int count)\n```\nGenerates a sequence of integral numbers within a specified range, starting from start and containing count sequential integers." }
+      ]
+    },
+    "Enumerable.Empty": {
+      "contents": [
+        { "value": "```csharp\npublic static IEnumerable<TResult> Empty<TResult>()\n```\nReturns an empty IEnumerable<T> that has the specified type argument. The returned singleton is cached." }
+      ]
+    },
+    "Enumerable.Repeat": {
+      "contents": [
+        { "value": "```csharp\npublic static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)\n```\nGenerates a sequence that contains one repeated value a specified number of times." }
+      ]
+    }
+  }
+}