@enjoys/context-engine 1.1.2 → 1.3.1

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." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/javascript.json

@@ -0,0 +1,126 @@
+{
+  "language": "javascript",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "console.log(data: ...any): void",
+      "documentation": { "value": "Outputs a message to the console. Multiple arguments are joined with spaces." },
+      "parameters": [
+        { "label": "data", "documentation": { "value": "Values to output. Objects are formatted with util.inspect." } }
+      ]
+    },
+    {
+      "label": "setTimeout(callback: Function, delay?: number, ...args: any[]): number",
+      "documentation": { "value": "Schedules a function to be called after the specified delay in milliseconds. Returns a timeout ID." },
+      "parameters": [
+        { "label": "callback", "documentation": { "value": "The function to execute after the delay." } },
+        { "label": "delay?", "documentation": { "value": "Milliseconds to wait before executing. Defaults to 0." } },
+        { "label": "...args", "documentation": { "value": "Additional arguments passed to the callback." } }
+      ]
+    },
+    {
+      "label": "setInterval(callback: Function, delay?: number, ...args: any[]): number",
+      "documentation": { "value": "Repeatedly calls a function with a fixed time delay between each call. Returns an interval ID." },
+      "parameters": [
+        { "label": "callback", "documentation": { "value": "The function to execute repeatedly." } },
+        { "label": "delay?", "documentation": { "value": "Milliseconds between each call." } },
+        { "label": "...args", "documentation": { "value": "Additional arguments passed to the callback." } }
+      ]
+    },
+    {
+      "label": "fetch(input: RequestInfo, init?: RequestInit): Promise<Response>",
+      "documentation": { "value": "Starts the process of fetching a resource from the network, returning a promise that resolves to a Response." },
+      "parameters": [
+        { "label": "input", "documentation": { "value": "The URL string or Request object to fetch." } },
+        { "label": "init?", "documentation": { "value": "An object containing request settings: method, headers, body, mode, credentials, etc." } }
+      ]
+    },
+    {
+      "label": "JSON.stringify(value: any, replacer?: Function | Array, space?: number | string): string",
+      "documentation": { "value": "Converts a JavaScript value to a JSON string, optionally replacing values or adding indentation." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to convert to a JSON string." } },
+        { "label": "replacer?", "documentation": { "value": "A function that alters serialization behavior, or an array of property names to include." } },
+        { "label": "space?", "documentation": { "value": "Number of spaces or a string used for indentation." } }
+      ]
+    },
+    {
+      "label": "JSON.parse(text: string, reviver?: Function): any",
+      "documentation": { "value": "Parses a JSON string, constructing the JavaScript value or object described by the string." },
+      "parameters": [
+        { "label": "text", "documentation": { "value": "The JSON string to parse." } },
+        { "label": "reviver?", "documentation": { "value": "A function that transforms the results before returning." } }
+      ]
+    },
+    {
+      "label": "Array.prototype.map(callback: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]",
+      "documentation": { "value": "Creates a new array populated with the results of calling the provided function on every element." },
+      "parameters": [
+        { "label": "callback", "documentation": { "value": "Function that produces an element of the new array, taking the current value, index, and array." } },
+        { "label": "thisArg?", "documentation": { "value": "Value to use as 'this' when executing callback." } }
+      ]
+    },
+    {
+      "label": "Array.prototype.filter(callback: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[]",
+      "documentation": { "value": "Creates a new array with all elements that pass the test implemented by the provided function." },
+      "parameters": [
+        { "label": "callback", "documentation": { "value": "Function to test each element. Return true to keep the element." } },
+        { "label": "thisArg?", "documentation": { "value": "Value to use as 'this' when executing callback." } }
+      ]
+    },
+    {
+      "label": "Array.prototype.reduce(callback: (accumulator: U, currentValue: T, index: number, array: T[]) => U, initialValue?: U): U",
+      "documentation": { "value": "Executes a reducer function on each element of the array, resulting in a single output value." },
+      "parameters": [
+        { "label": "callback", "documentation": { "value": "Reducer function taking accumulator, current value, current index, and source array." } },
+        { "label": "initialValue?", "documentation": { "value": "Value to use as the first argument to the first call of the callback." } }
+      ]
+    },
+    {
+      "label": "Promise.all(iterable: Iterable<Promise<T>>): Promise<T[]>",
+      "documentation": { "value": "Returns a promise that resolves when all of the input promises have resolved, or rejects when any input promise rejects." },
+      "parameters": [
+        { "label": "iterable", "documentation": { "value": "An iterable of promises to wait for." } }
+      ]
+    },
+    {
+      "label": "Object.keys(obj: object): string[]",
+      "documentation": { "value": "Returns an array of a given object's own enumerable string-keyed property names." },
+      "parameters": [
+        { "label": "obj", "documentation": { "value": "The object whose enumerable own properties are to be returned." } }
+      ]
+    },
+    {
+      "label": "Object.assign(target: object, ...sources: object[]): object",
+      "documentation": { "value": "Copies all enumerable own properties from one or more source objects to a target object. Returns the modified target." },
+      "parameters": [
+        { "label": "target", "documentation": { "value": "The target object to copy to." } },
+        { "label": "...sources", "documentation": { "value": "Source objects from which to copy properties." } }
+      ]
+    },
+    {
+      "label": "String.prototype.split(separator: string | RegExp, limit?: number): string[]",
+      "documentation": { "value": "Divides a string into an ordered list of substrings and returns them as an array." },
+      "parameters": [
+        { "label": "separator", "documentation": { "value": "The pattern describing where each split should occur." } },
+        { "label": "limit?", "documentation": { "value": "Maximum number of substrings to return." } }
+      ]
+    },
+    {
+      "label": "Math.max(...values: number[]): number",
+      "documentation": { "value": "Returns the largest of zero or more numbers. Returns -Infinity if no arguments are provided." },
+      "parameters": [
+        { "label": "...values", "documentation": { "value": "Numbers to compare." } }
+      ]
+    },
+    {
+      "label": "parseInt(string: string, radix?: number): number",
+      "documentation": { "value": "Parses a string argument and returns an integer of the specified radix (base)." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The value to parse." } },
+        { "label": "radix?", "documentation": { "value": "An integer between 2 and 36 specifying the base. Defaults to 10." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/json.json

@@ -0,0 +1,56 @@
+{
+  "language": "json",
+  "triggerCharacters": ["{", "[", ":"],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "{ \"key\": value }",
+      "documentation": { "value": "A JSON object containing key-value pairs. Keys must be double-quoted strings." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "A double-quoted string serving as the property name." } },
+        { "label": "value", "documentation": { "value": "A valid JSON value: string, number, boolean, null, object, or array." } }
+      ]
+    },
+    {
+      "label": "[ value1, value2, ... ]",
+      "documentation": { "value": "A JSON array containing an ordered list of values." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "Any valid JSON value: string, number, boolean, null, object, or array." } }
+      ]
+    },
+    {
+      "label": "\"string\"",
+      "documentation": { "value": "A JSON string value enclosed in double quotes. Supports escape sequences: \\n, \\t, \\\\, \\\", \\uXXXX." },
+      "parameters": []
+    },
+    {
+      "label": "number",
+      "documentation": { "value": "A JSON number. Can be integer or floating point, with optional exponent (e.g., 42, 3.14, 1.5e10). No leading zeros, NaN, or Infinity." },
+      "parameters": []
+    },
+    {
+      "label": "true | false",
+      "documentation": { "value": "JSON boolean literals. Must be lowercase." },
+      "parameters": []
+    },
+    {
+      "label": "null",
+      "documentation": { "value": "Represents an empty or non-existent value in JSON." },
+      "parameters": []
+    },
+    {
+      "label": "{ \"$schema\": \"url\" }",
+      "documentation": { "value": "Specifies a JSON Schema URL for validation and editor autocompletion support." },
+      "parameters": [
+        { "label": "url", "documentation": { "value": "The URL of the JSON Schema to validate against." } }
+      ]
+    },
+    {
+      "label": "{ \"$ref\": \"#/definitions/name\" }",
+      "documentation": { "value": "A JSON Reference pointer used in JSON Schema to reference a definition." },
+      "parameters": [
+        { "label": "#/definitions/name", "documentation": { "value": "A JSON Pointer path to the referenced definition." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/julia.json

@@ -0,0 +1,128 @@
+{
+  "language": "julia",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "println(io::IO, xs...): Nothing",
+      "documentation": { "value": "Prints the arguments followed by a newline. If no IO object is given, prints to stdout." },
+      "parameters": [
+        { "label": "io::IO", "documentation": { "value": "Optional IO stream to print to. Defaults to stdout." } },
+        { "label": "xs...", "documentation": { "value": "Values to print." } }
+      ]
+    },
+    {
+      "label": "parse(type::Type, str::AbstractString; base::Integer): type",
+      "documentation": { "value": "Parses a string as the given type. For integers, an optional base can be specified." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The type to parse the string as (e.g., Int, Float64)." } },
+        { "label": "str", "documentation": { "value": "The string to parse." } },
+        { "label": "base", "documentation": { "value": "Optional base for integer parsing (default 10)." } }
+      ]
+    },
+    {
+      "label": "typeof(x): DataType",
+      "documentation": { "value": "Returns the concrete type of the argument." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "The value whose type to determine." } }
+      ]
+    },
+    {
+      "label": "length(collection): Integer",
+      "documentation": { "value": "Returns the number of elements in a collection (array, string, tuple, etc.)." },
+      "parameters": [
+        { "label": "collection", "documentation": { "value": "The collection to measure." } }
+      ]
+    },
+    {
+      "label": "push!(collection, items...): collection",
+      "documentation": { "value": "Inserts one or more items at the end of a collection. Modifies the collection in place." },
+      "parameters": [
+        { "label": "collection", "documentation": { "value": "The mutable collection to append to." } },
+        { "label": "items...", "documentation": { "value": "Items to add to the end." } }
+      ]
+    },
+    {
+      "label": "pop!(collection): item",
+      "documentation": { "value": "Removes and returns the last item from a collection." },
+      "parameters": [
+        { "label": "collection", "documentation": { "value": "The mutable collection to remove from." } }
+      ]
+    },
+    {
+      "label": "map(f::Function, collection...): Array",
+      "documentation": { "value": "Applies function f to each element of the collection(s) and returns an array of results." },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "The function to apply to each element." } },
+        { "label": "collection...", "documentation": { "value": "One or more collections to map over." } }
+      ]
+    },
+    {
+      "label": "filter(f::Function, collection): Array",
+      "documentation": { "value": "Returns an array containing only elements of the collection for which f returns true." },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "A predicate function returning a boolean." } },
+        { "label": "collection", "documentation": { "value": "The collection to filter." } }
+      ]
+    },
+    {
+      "label": "reduce(op, collection; init): value",
+      "documentation": { "value": "Reduces the collection using the binary operator op. An optional initial value can be provided." },
+      "parameters": [
+        { "label": "op", "documentation": { "value": "A binary function or operator (e.g., +, *, min)." } },
+        { "label": "collection", "documentation": { "value": "The collection to reduce." } },
+        { "label": "init", "documentation": { "value": "Optional initial value for the reduction." } }
+      ]
+    },
+    {
+      "label": "sort(v::AbstractVector; by, rev, alg): Vector",
+      "documentation": { "value": "Returns a sorted copy of the vector. Use sort! for in-place sorting." },
+      "parameters": [
+        { "label": "v", "documentation": { "value": "The vector to sort." } },
+        { "label": "by", "documentation": { "value": "A function to transform elements before comparison." } },
+        { "label": "rev", "documentation": { "value": "If true, sort in reverse order." } },
+        { "label": "alg", "documentation": { "value": "Sorting algorithm to use (e.g., QuickSort, MergeSort)." } }
+      ]
+    },
+    {
+      "label": "open(filename::AbstractString, mode::AbstractString): IOStream",
+      "documentation": { "value": "Opens a file and returns an IOStream. Mode can be \"r\" (read), \"w\" (write), \"a\" (append), etc." },
+      "parameters": [
+        { "label": "filename", "documentation": { "value": "The path to the file to open." } },
+        { "label": "mode", "documentation": { "value": "File open mode: \"r\", \"w\", \"a\", \"r+\", \"w+\", \"a+\"." } }
+      ]
+    },
+    {
+      "label": "read(io::IO, T::Type): T",
+      "documentation": { "value": "Reads a single value of the specified type from the IO stream." },
+      "parameters": [
+        { "label": "io", "documentation": { "value": "The IO stream to read from." } },
+        { "label": "T", "documentation": { "value": "The type of value to read." } }
+      ]
+    },
+    {
+      "label": "write(io::IO, x...): Integer",
+      "documentation": { "value": "Writes the canonical binary representation of the values to the IO stream. Returns number of bytes written." },
+      "parameters": [
+        { "label": "io", "documentation": { "value": "The IO stream to write to." } },
+        { "label": "x...", "documentation": { "value": "The values to write." } }
+      ]
+    },
+    {
+      "label": "zeros(T::Type, dims...): Array{T}",
+      "documentation": { "value": "Creates an array of all zeros with the specified element type and dimensions." },
+      "parameters": [
+        { "label": "T", "documentation": { "value": "Element type (e.g., Float64, Int). Defaults to Float64." } },
+        { "label": "dims...", "documentation": { "value": "Dimensions of the array (e.g., 3, 4 for a 3×4 matrix)." } }
+      ]
+    },
+    {
+      "label": "ones(T::Type, dims...): Array{T}",
+      "documentation": { "value": "Creates an array of all ones with the specified element type and dimensions." },
+      "parameters": [
+        { "label": "T", "documentation": { "value": "Element type (e.g., Float64, Int). Defaults to Float64." } },
+        { "label": "dims...", "documentation": { "value": "Dimensions of the array." } }
+      ]
+    }
+  ]
+}