@enjoys/context-engine 1.1.1 → 1.2.0

package/data/signatureHelp/freemarker2.json

@@ -0,0 +1,64 @@
+{
+  "language": "freemarker2",
+  "triggerCharacters": ["(", ",", "?"],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "?string: string",
+      "documentation": { "value": "Converts a value to its string representation. For numbers, uses the default number format. For booleans, converts to \"true\" or \"false\"." },
+      "parameters": []
+    },
+    {
+      "label": "?number: number",
+      "documentation": { "value": "Converts a string to a number. The string must be in a valid number format." },
+      "parameters": []
+    },
+    {
+      "label": "?date: date",
+      "documentation": { "value": "Converts a string to a date value using the configured date format." },
+      "parameters": []
+    },
+    {
+      "label": "?size: number",
+      "documentation": { "value": "Returns the number of elements in a sequence or the number of characters in a string." },
+      "parameters": []
+    },
+    {
+      "label": "?has_content: boolean",
+      "documentation": { "value": "Returns true if the variable exists and is not empty. For strings, checks that it's not blank; for sequences, checks length > 0." },
+      "parameters": []
+    },
+    {
+      "label": "?replace(target: string, replacement: string): string",
+      "documentation": { "value": "Replaces all occurrences of a substring within the string." },
+      "parameters": [
+        { "label": "target", "documentation": { "value": "The substring to search for." } },
+        { "label": "replacement", "documentation": { "value": "The string to replace matches with." } }
+      ]
+    },
+    {
+      "label": "?split(separator: string): sequence",
+      "documentation": { "value": "Splits a string into a sequence of substrings around the given separator." },
+      "parameters": [
+        { "label": "separator", "documentation": { "value": "The delimiter string to split on." } }
+      ]
+    },
+    {
+      "label": "?join(separator: string): string",
+      "documentation": { "value": "Joins the elements of a sequence into a single string, separated by the given delimiter." },
+      "parameters": [
+        { "label": "separator", "documentation": { "value": "The delimiter to place between elements." } }
+      ]
+    },
+    {
+      "label": "?upper_case: string",
+      "documentation": { "value": "Converts all characters in the string to upper case." },
+      "parameters": []
+    },
+    {
+      "label": "?lower_case: string",
+      "documentation": { "value": "Converts all characters in the string to lower case." },
+      "parameters": []
+    }
+  ]
+}

package/data/signatureHelp/go.json

@@ -0,0 +1,118 @@
+{
+  "language": "go",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "fmt.Println(a ...any): (n int, err error)",
+      "documentation": { "value": "Formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended." },
+      "parameters": [
+        { "label": "a ...any", "documentation": { "value": "Values to print, separated by spaces." } }
+      ]
+    },
+    {
+      "label": "fmt.Sprintf(format string, a ...any): string",
+      "documentation": { "value": "Formats according to a format specifier and returns the resulting string." },
+      "parameters": [
+        { "label": "format string", "documentation": { "value": "A format string with verbs like %s, %d, %v, etc." } },
+        { "label": "a ...any", "documentation": { "value": "Values to format into the string." } }
+      ]
+    },
+    {
+      "label": "fmt.Fprintf(w io.Writer, format string, a ...any): (n int, err error)",
+      "documentation": { "value": "Formats according to a format specifier and writes to w." },
+      "parameters": [
+        { "label": "w io.Writer", "documentation": { "value": "The writer to write the formatted output to." } },
+        { "label": "format string", "documentation": { "value": "A format string with verbs like %s, %d, %v, etc." } },
+        { "label": "a ...any", "documentation": { "value": "Values to format into the string." } }
+      ]
+    },
+    {
+      "label": "len(v Type): int",
+      "documentation": { "value": "Returns the length of v depending on its type: string (number of bytes), array/slice (number of elements), map (number of keys), channel (number of queued elements)." },
+      "parameters": [
+        { "label": "v Type", "documentation": { "value": "A string, array, slice, map, or channel." } }
+      ]
+    },
+    {
+      "label": "cap(v Type): int",
+      "documentation": { "value": "Returns the capacity of v depending on its type: array (number of elements), slice (maximum length the slice can reach), channel (channel buffer capacity)." },
+      "parameters": [
+        { "label": "v Type", "documentation": { "value": "An array, slice, or channel." } }
+      ]
+    },
+    {
+      "label": "make(t Type, size ...int): Type",
+      "documentation": { "value": "Allocates and initializes a slice, map, or channel. For slices, size specifies the length and optional capacity. For maps, size is an optional initial capacity hint. For channels, size specifies the buffer capacity." },
+      "parameters": [
+        { "label": "t Type", "documentation": { "value": "The type of slice, map, or channel to create." } },
+        { "label": "size ...int", "documentation": { "value": "Length (and optional capacity for slices), or buffer size for channels." } }
+      ]
+    },
+    {
+      "label": "append(slice []T, elems ...T): []T",
+      "documentation": { "value": "Appends elements to the end of a slice. If the slice has sufficient capacity, the destination is resliced; otherwise, a new underlying array is allocated." },
+      "parameters": [
+        { "label": "slice []T", "documentation": { "value": "The slice to append to." } },
+        { "label": "elems ...T", "documentation": { "value": "Elements to append." } }
+      ]
+    },
+    {
+      "label": "copy(dst []T, src []T): int",
+      "documentation": { "value": "Copies elements from a source slice into a destination slice. Returns the number of elements copied, which is the minimum of len(dst) and len(src)." },
+      "parameters": [
+        { "label": "dst []T", "documentation": { "value": "The destination slice." } },
+        { "label": "src []T", "documentation": { "value": "The source slice." } }
+      ]
+    },
+    {
+      "label": "delete(m map[K]V, key K)",
+      "documentation": { "value": "Deletes the element with the specified key from the map. If the map is nil or there is no such element, delete is a no-op." },
+      "parameters": [
+        { "label": "m map[K]V", "documentation": { "value": "The map to delete from." } },
+        { "label": "key K", "documentation": { "value": "The key to delete." } }
+      ]
+    },
+    {
+      "label": "close(ch chan<- Type)",
+      "documentation": { "value": "Closes a channel, indicating that no more values will be sent on it. Sending to a closed channel causes a panic." },
+      "parameters": [
+        { "label": "ch chan<- Type", "documentation": { "value": "The channel to close." } }
+      ]
+    },
+    {
+      "label": "panic(v any)",
+      "documentation": { "value": "Stops normal execution of the current goroutine. When a function calls panic, normal execution stops and any deferred functions begin running. The panic value is reported when the program terminates." },
+      "parameters": [
+        { "label": "v any", "documentation": { "value": "The value to pass to the panic." } }
+      ]
+    },
+    {
+      "label": "recover(): any",
+      "documentation": { "value": "Allows a program to manage behavior of a panicking goroutine. Must be called inside a deferred function. Returns the panic value if called during panicking, nil otherwise." },
+      "parameters": []
+    },
+    {
+      "label": "errors.New(text string): error",
+      "documentation": { "value": "Returns a new error that formats as the given text. Each call to New returns a distinct error value even if the text is identical." },
+      "parameters": [
+        { "label": "text string", "documentation": { "value": "The error message text." } }
+      ]
+    },
+    {
+      "label": "strings.Contains(s string, substr string): bool",
+      "documentation": { "value": "Reports whether substr is within s." },
+      "parameters": [
+        { "label": "s string", "documentation": { "value": "The string to search in." } },
+        { "label": "substr string", "documentation": { "value": "The substring to search for." } }
+      ]
+    },
+    {
+      "label": "strconv.Atoi(s string): (int, error)",
+      "documentation": { "value": "Converts a string to an int. Equivalent to ParseInt(s, 10, 0), converted to type int." },
+      "parameters": [
+        { "label": "s string", "documentation": { "value": "The string representation of an integer." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/graphql.json

@@ -0,0 +1,82 @@
+{
+  "language": "graphql",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "type TypeName { ...fields }",
+      "documentation": { "value": "Defines an object type with named fields. Each field has a type and optional arguments." },
+      "parameters": [
+        { "label": "TypeName", "documentation": { "value": "The name of the object type." } }
+      ]
+    },
+    {
+      "label": "query QueryName($var: Type): ReturnType",
+      "documentation": { "value": "Defines a named query operation with optional variables for parameterized data fetching." },
+      "parameters": [
+        { "label": "QueryName", "documentation": { "value": "Optional name for the query operation." } },
+        { "label": "$var: Type", "documentation": { "value": "Variable declarations with their GraphQL types." } }
+      ]
+    },
+    {
+      "label": "mutation MutationName($var: Type): ReturnType",
+      "documentation": { "value": "Defines a mutation operation for creating, updating, or deleting data." },
+      "parameters": [
+        { "label": "MutationName", "documentation": { "value": "Optional name for the mutation operation." } },
+        { "label": "$var: Type", "documentation": { "value": "Variable declarations with their GraphQL types." } }
+      ]
+    },
+    {
+      "label": "subscription SubscriptionName($var: Type): ReturnType",
+      "documentation": { "value": "Defines a subscription operation for real-time data updates via a persistent connection." },
+      "parameters": [
+        { "label": "SubscriptionName", "documentation": { "value": "Optional name for the subscription operation." } },
+        { "label": "$var: Type", "documentation": { "value": "Variable declarations with their GraphQL types." } }
+      ]
+    },
+    {
+      "label": "input InputTypeName { ...fields }",
+      "documentation": { "value": "Defines an input object type used for complex arguments in queries and mutations." },
+      "parameters": [
+        { "label": "InputTypeName", "documentation": { "value": "The name of the input type." } }
+      ]
+    },
+    {
+      "label": "enum EnumName { VALUE1, VALUE2, ... }",
+      "documentation": { "value": "Defines an enumeration type restricted to a particular set of allowed values." },
+      "parameters": [
+        { "label": "EnumName", "documentation": { "value": "The name of the enum type." } }
+      ]
+    },
+    {
+      "label": "interface InterfaceName { ...fields }",
+      "documentation": { "value": "Defines an abstract interface type that other types can implement, ensuring they include the specified fields." },
+      "parameters": [
+        { "label": "InterfaceName", "documentation": { "value": "The name of the interface." } }
+      ]
+    },
+    {
+      "label": "union UnionName = Type1 | Type2 | ...",
+      "documentation": { "value": "Defines a union type representing one of several possible object types." },
+      "parameters": [
+        { "label": "UnionName", "documentation": { "value": "The name of the union type." } }
+      ]
+    },
+    {
+      "label": "scalar ScalarName",
+      "documentation": { "value": "Defines a custom scalar type for values that aren't covered by the default scalars (Int, Float, String, Boolean, ID)." },
+      "parameters": [
+        { "label": "ScalarName", "documentation": { "value": "The name of the custom scalar type." } }
+      ]
+    },
+    {
+      "label": "directive @directiveName(arg: Type) on LOCATION",
+      "documentation": { "value": "Defines a custom directive that annotates parts of a GraphQL schema or document." },
+      "parameters": [
+        { "label": "@directiveName", "documentation": { "value": "The name of the directive (prefixed with @)." } },
+        { "label": "arg: Type", "documentation": { "value": "Optional arguments accepted by the directive." } },
+        { "label": "on LOCATION", "documentation": { "value": "Schema locations where the directive can be applied (e.g., FIELD, OBJECT, ARGUMENT_DEFINITION)." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/hcl.json

@@ -0,0 +1,107 @@
+{
+  "language": "hcl",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "resource \"type\" \"name\" { ...config }",
+      "documentation": { "value": "Declares an infrastructure resource of the given type with configuration arguments." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The resource type (e.g., \"aws_instance\", \"azurerm_resource_group\")." } },
+        { "label": "name", "documentation": { "value": "A local name used to refer to this resource elsewhere in the configuration." } }
+      ]
+    },
+    {
+      "label": "variable \"name\" { type, default, description }",
+      "documentation": { "value": "Declares an input variable that can be set when applying the configuration." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the variable, used as var.<name> in expressions." } }
+      ]
+    },
+    {
+      "label": "output \"name\" { value, description }",
+      "documentation": { "value": "Declares an output value that is displayed after apply and accessible by other configurations." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the output value." } }
+      ]
+    },
+    {
+      "label": "data \"type\" \"name\" { ...query }",
+      "documentation": { "value": "Declares a data source to fetch information from an external source or another configuration." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The data source type (e.g., \"aws_ami\", \"azurerm_subscription\")." } },
+        { "label": "name", "documentation": { "value": "A local name for this data source." } }
+      ]
+    },
+    {
+      "label": "module \"name\" { source, ...inputs }",
+      "documentation": { "value": "Calls a child module with the given source and input variables." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "A local name for this module instance." } }
+      ]
+    },
+    {
+      "label": "locals { key = value, ... }",
+      "documentation": { "value": "Declares local values that can simplify expressions and avoid repetition within a module." },
+      "parameters": []
+    },
+    {
+      "label": "terraform { required_version, required_providers, backend }",
+      "documentation": { "value": "Configures Terraform behavior including version constraints, required providers, and backend state storage." },
+      "parameters": []
+    },
+    {
+      "label": "provider \"name\" { ...config }",
+      "documentation": { "value": "Configures a provider plugin with settings such as region, credentials, and other provider-specific options." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The provider name (e.g., \"aws\", \"azurerm\", \"google\")." } }
+      ]
+    },
+    {
+      "label": "lookup(map, key, default): value",
+      "documentation": { "value": "Retrieves a value from a map by its key, returning a default value if the key is not found." },
+      "parameters": [
+        { "label": "map", "documentation": { "value": "The map to look up the value in." } },
+        { "label": "key", "documentation": { "value": "The key to look up." } },
+        { "label": "default", "documentation": { "value": "The default value to return if the key is not found." } }
+      ]
+    },
+    {
+      "label": "element(list, index): value",
+      "documentation": { "value": "Retrieves a single element from a list by its index. The index is zero-based and wraps around using modulo." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The list to retrieve from." } },
+        { "label": "index", "documentation": { "value": "The zero-based index of the element." } }
+      ]
+    },
+    {
+      "label": "merge(maps...): map",
+      "documentation": { "value": "Takes an arbitrary number of maps or objects and returns a single map containing a merged set of elements from all arguments." },
+      "parameters": [
+        { "label": "maps...", "documentation": { "value": "One or more maps to merge. Later values override earlier ones for duplicate keys." } }
+      ]
+    },
+    {
+      "label": "concat(lists...): list",
+      "documentation": { "value": "Combines two or more lists into a single list." },
+      "parameters": [
+        { "label": "lists...", "documentation": { "value": "Two or more lists to concatenate in order." } }
+      ]
+    },
+    {
+      "label": "file(path): string",
+      "documentation": { "value": "Reads the contents of a file at the given path and returns it as a string." },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "The path to the file to read, relative to the root module directory." } }
+      ]
+    },
+    {
+      "label": "templatefile(path, vars): string",
+      "documentation": { "value": "Reads a file at the given path and renders its content as a template using the supplied variables." },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "The path to the template file." } },
+        { "label": "vars", "documentation": { "value": "A map of template variables to use during rendering." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/html.json

@@ -0,0 +1,98 @@
+{
+  "language": "html",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "document.createElement(tagName: string): HTMLElement",
+      "documentation": { "value": "Creates the HTML element specified by tagName." },
+      "parameters": [
+        { "label": "tagName", "documentation": { "value": "A string specifying the type of element to create (e.g., 'div', 'span', 'p')." } }
+      ]
+    },
+    {
+      "label": "document.getElementById(id: string): HTMLElement | null",
+      "documentation": { "value": "Returns the element that has the specified ID attribute, or null if no such element exists." },
+      "parameters": [
+        { "label": "id", "documentation": { "value": "The ID of the element to locate." } }
+      ]
+    },
+    {
+      "label": "document.querySelector(selectors: string): Element | null",
+      "documentation": { "value": "Returns the first element within the document that matches the specified CSS selector(s)." },
+      "parameters": [
+        { "label": "selectors", "documentation": { "value": "A CSS selector string (e.g., '.class', '#id', 'div > p')." } }
+      ]
+    },
+    {
+      "label": "document.querySelectorAll(selectors: string): NodeList",
+      "documentation": { "value": "Returns a static NodeList of all elements matching the specified CSS selector(s)." },
+      "parameters": [
+        { "label": "selectors", "documentation": { "value": "A CSS selector string." } }
+      ]
+    },
+    {
+      "label": "element.setAttribute(name: string, value: string): void",
+      "documentation": { "value": "Sets the value of an attribute on the specified element. If the attribute already exists, the value is updated." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the attribute (e.g., 'class', 'id', 'src')." } },
+        { "label": "value", "documentation": { "value": "The value to assign to the attribute." } }
+      ]
+    },
+    {
+      "label": "element.getAttribute(name: string): string | null",
+      "documentation": { "value": "Returns the value of a specified attribute on the element, or null if the attribute does not exist." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the attribute to retrieve." } }
+      ]
+    },
+    {
+      "label": "element.addEventListener(type: string, listener: EventListener, options?: AddEventListenerOptions): void",
+      "documentation": { "value": "Registers an event handler on the element for the specified event type." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The event type to listen for (e.g., 'click', 'input', 'submit')." } },
+        { "label": "listener", "documentation": { "value": "The callback function invoked when the event fires." } },
+        { "label": "options?", "documentation": { "value": "Optional object with capture, once, passive, and signal properties." } }
+      ]
+    },
+    {
+      "label": "element.removeEventListener(type: string, listener: EventListener, options?: EventListenerOptions): void",
+      "documentation": { "value": "Removes a previously registered event listener from the element." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The event type of the listener to remove." } },
+        { "label": "listener", "documentation": { "value": "The callback function to remove." } },
+        { "label": "options?", "documentation": { "value": "Optional object specifying characteristics of the listener." } }
+      ]
+    },
+    {
+      "label": "element.classList.add(tokens: ...string): void",
+      "documentation": { "value": "Adds one or more CSS class names to the element's class list." },
+      "parameters": [
+        { "label": "tokens", "documentation": { "value": "One or more class names to add." } }
+      ]
+    },
+    {
+      "label": "element.classList.remove(tokens: ...string): void",
+      "documentation": { "value": "Removes one or more CSS class names from the element's class list." },
+      "parameters": [
+        { "label": "tokens", "documentation": { "value": "One or more class names to remove." } }
+      ]
+    },
+    {
+      "label": "element.classList.toggle(token: string, force?: boolean): boolean",
+      "documentation": { "value": "Toggles the specified class name on the element. If force is provided, adds the class when true and removes when false." },
+      "parameters": [
+        { "label": "token", "documentation": { "value": "The class name to toggle." } },
+        { "label": "force?", "documentation": { "value": "If true, add the class; if false, remove it." } }
+      ]
+    },
+    {
+      "label": "element.insertAdjacentHTML(position: InsertPosition, text: string): void",
+      "documentation": { "value": "Parses the text as HTML and inserts the resulting nodes at the specified position relative to the element." },
+      "parameters": [
+        { "label": "position", "documentation": { "value": "One of 'beforebegin', 'afterbegin', 'beforeend', 'afterend'." } },
+        { "label": "text", "documentation": { "value": "The HTML string to parse and insert." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/ini.json

@@ -0,0 +1,63 @@
+{
+  "language": "ini",
+  "triggerCharacters": ["[", "="],
+  "retriggerCharacters": [],
+  "signatures": [
+    {
+      "label": "[section]",
+      "documentation": { "value": "Declares a section header. All key-value pairs following this header belong to this section until the next section header." },
+      "parameters": [
+        { "label": "section", "documentation": { "value": "The name of the section." } }
+      ]
+    },
+    {
+      "label": "key = value",
+      "documentation": { "value": "Assigns a value to a key within the current section. The value extends to the end of the line." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The property name." } },
+        { "label": "value", "documentation": { "value": "The property value (string, number, or boolean)." } }
+      ]
+    },
+    {
+      "label": "; comment",
+      "documentation": { "value": "A line comment. Everything after the semicolon is ignored by the parser." },
+      "parameters": []
+    },
+    {
+      "label": "# comment",
+      "documentation": { "value": "An alternative line comment syntax. Everything after the hash is ignored by the parser." },
+      "parameters": []
+    },
+    {
+      "label": "key = ${other_key}",
+      "documentation": { "value": "Variable interpolation (supported by some INI parsers). References the value of another key." },
+      "parameters": [
+        { "label": "other_key", "documentation": { "value": "The key whose value to substitute." } }
+      ]
+    },
+    {
+      "label": "[section:parent]",
+      "documentation": { "value": "Section inheritance (supported by some INI parsers). The section inherits all key-value pairs from the parent section." },
+      "parameters": [
+        { "label": "section", "documentation": { "value": "The child section name." } },
+        { "label": "parent", "documentation": { "value": "The parent section to inherit from." } }
+      ]
+    },
+    {
+      "label": "key[] = value",
+      "documentation": { "value": "Array-style value assignment (supported by some INI parsers). Multiple values can be assigned to the same key as a list." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The property name for the array." } },
+        { "label": "value", "documentation": { "value": "A value to append to the array." } }
+      ]
+    },
+    {
+      "label": "key = \"quoted value\"",
+      "documentation": { "value": "A quoted string value. Use quotes to preserve leading/trailing whitespace or include special characters." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The property name." } },
+        { "label": "quoted value", "documentation": { "value": "The value enclosed in double quotes." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/java.json

@@ -0,0 +1,112 @@
+{
+  "language": "java",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "System.out.println(x: Object): void",
+      "documentation": { "value": "Prints the argument followed by a newline to standard output." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "The value to print. Calls toString() on objects." } }
+      ]
+    },
+    {
+      "label": "String.format(format: String, args: Object...): String",
+      "documentation": { "value": "Returns a formatted string using the specified format string and arguments." },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A format string with specifiers like %s, %d, %f, etc." } },
+        { "label": "args", "documentation": { "value": "Arguments referenced by the format specifiers." } }
+      ]
+    },
+    {
+      "label": "Integer.parseInt(s: String): int",
+      "documentation": { "value": "Parses the string argument as a signed decimal integer. Throws NumberFormatException if the string is not a valid integer." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The String containing the integer representation." } }
+      ]
+    },
+    {
+      "label": "Arrays.sort(a: T[], comparator?: Comparator<T>): void",
+      "documentation": { "value": "Sorts the specified array of objects according to the natural ordering or by the given comparator." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The array to be sorted." } },
+        { "label": "comparator?", "documentation": { "value": "Optional comparator to determine the order. If null, natural ordering is used." } }
+      ]
+    },
+    {
+      "label": "Collections.sort(list: List<T>, comparator?: Comparator<T>): void",
+      "documentation": { "value": "Sorts the specified list according to the natural ordering or by the given comparator." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The list to be sorted." } },
+        { "label": "comparator?", "documentation": { "value": "Optional comparator to determine the order." } }
+      ]
+    },
+    {
+      "label": "List.add(element: E): boolean",
+      "documentation": { "value": "Appends the specified element to the end of this list." },
+      "parameters": [
+        { "label": "element", "documentation": { "value": "The element to be appended to this list." } }
+      ]
+    },
+    {
+      "label": "Map.put(key: K, value: V): V",
+      "documentation": { "value": "Associates the specified value with the specified key in this map. Returns the previous value associated with key, or null." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key with which the specified value is to be associated." } },
+        { "label": "value", "documentation": { "value": "The value to be associated with the specified key." } }
+      ]
+    },
+    {
+      "label": "HashMap.get(key: Object): V",
+      "documentation": { "value": "Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key whose associated value is to be returned." } }
+      ]
+    },
+    {
+      "label": "Math.max(a: double, b: double): double",
+      "documentation": { "value": "Returns the greater of two values." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The first value." } },
+        { "label": "b", "documentation": { "value": "The second value." } }
+      ]
+    },
+    {
+      "label": "Math.min(a: double, b: double): double",
+      "documentation": { "value": "Returns the smaller of two values." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The first value." } },
+        { "label": "b", "documentation": { "value": "The second value." } }
+      ]
+    },
+    {
+      "label": "Stream.of(values: T...): Stream<T>",
+      "documentation": { "value": "Returns a sequential ordered stream whose elements are the specified values." },
+      "parameters": [
+        { "label": "values", "documentation": { "value": "The elements of the new stream." } }
+      ]
+    },
+    {
+      "label": "Optional.ofNullable(value: T): Optional<T>",
+      "documentation": { "value": "Returns an Optional describing the given value, or an empty Optional if the value is null." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The possibly-null value to describe." } }
+      ]
+    },
+    {
+      "label": "Thread.sleep(millis: long): void",
+      "documentation": { "value": "Causes the currently executing thread to sleep for the specified number of milliseconds." },
+      "parameters": [
+        { "label": "millis", "documentation": { "value": "The length of time to sleep in milliseconds." } }
+      ]
+    },
+    {
+      "label": "Files.readAllLines(path: Path, charset?: Charset): List<String>",
+      "documentation": { "value": "Reads all lines from a file. Bytes are decoded into characters using the specified or default (UTF-8) charset." },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "The path to the file." } },
+        { "label": "charset?", "documentation": { "value": "The charset to use for decoding. Defaults to UTF-8." } }
+      ]
+    }
+  ]
+}