@enjoys/context-engine 1.4.2 → 1.5.0

package/data/definition/javascript.json

@@ -1,265 +1,941 @@
-{
-  "language": "javascript",
-  "definitions": {
-    "console": {
-      "signature": "interface Console",
-      "description": "The Console object provides access to the browser's debugging console (e.g. the Web console in Firefox). Implementations available in Node.js, Deno, and browsers.",
-      "type": "object",
-      "module": "global",
-      "members": {
-        "log": { "signature": "console.log(...data: any[]): void", "description": "Outputs a message to the console.", "type": "method" },
-        "error": { "signature": "console.error(...data: any[]): void", "description": "Outputs an error message. May include stack trace.", "type": "method" },
-        "warn": { "signature": "console.warn(...data: any[]): void", "description": "Outputs a warning message.", "type": "method" },
-        "info": { "signature": "console.info(...data: any[]): void", "description": "Informative logging of information.", "type": "method" },
-        "debug": { "signature": "console.debug(...data: any[]): void", "description": "Outputs a debug-level message.", "type": "method" },
-        "table": { "signature": "console.table(tabularData: any, properties?: string[]): void", "description": "Displays tabular data as a table.", "type": "method" },
-        "dir": { "signature": "console.dir(item: any, options?: object): void", "description": "Displays an interactive listing of properties of a specified object.", "type": "method" },
-        "time": { "signature": "console.time(label?: string): void", "description": "Starts a timer you can use to track how long an operation takes.", "type": "method" },
-        "timeEnd": { "signature": "console.timeEnd(label?: string): void", "description": "Stops a timer and logs elapsed time.", "type": "method" },
-        "timeLog": { "signature": "console.timeLog(label?: string, ...data: any[]): void", "description": "Logs the current value of a timer started by console.time().", "type": "method" },
-        "assert": { "signature": "console.assert(condition?: boolean, ...data: any[]): void", "description": "Log an error message if the assertion is false.", "type": "method" },
-        "clear": { "signature": "console.clear(): void", "description": "Clear the console.", "type": "method" },
-        "count": { "signature": "console.count(label?: string): void", "description": "Log the number of times this line has been called with the given label.", "type": "method" },
-        "countReset": { "signature": "console.countReset(label?: string): void", "description": "Resets the value of the counter with the given label.", "type": "method" },
-        "group": { "signature": "console.group(...label: any[]): void", "description": "Creates a new inline group, indenting all following output.", "type": "method" },
-        "groupCollapsed": { "signature": "console.groupCollapsed(...label: any[]): void", "description": "Creates a new inline group (collapsed by default).", "type": "method" },
-        "groupEnd": { "signature": "console.groupEnd(): void", "description": "Exits the current inline group.", "type": "method" },
-        "trace": { "signature": "console.trace(...data: any[]): void", "description": "Outputs a stack trace.", "type": "method" }
-      }
-    },
-    "JSON": {
-      "signature": "namespace JSON",
-      "description": "An intrinsic object that provides functions to convert JavaScript values to and from JSON format.",
-      "type": "namespace",
-      "module": "global",
-      "members": {
-        "parse": { "signature": "JSON.parse(text: string, reviver?: Function): any", "description": "Converts a JSON string into an object.", "type": "method", "parameters": [{"name": "text", "type": "string", "description": "A valid JSON string"}, {"name": "reviver", "type": "Function", "description": "Optional function that transforms the results", "optional": true}], "returns": "any" },
-        "stringify": { "signature": "JSON.stringify(value: any, replacer?: Function | (string|number)[], space?: string | number): string", "description": "Converts a JavaScript value to a JSON string.", "type": "method", "parameters": [{"name": "value", "type": "any", "description": "The value to convert"}, {"name": "replacer", "type": "Function | Array", "description": "Function or whitelist array", "optional": true}, {"name": "space", "type": "string | number", "description": "Indentation", "optional": true}], "returns": "string | undefined" }
-      }
-    },
-    "Array": {
-      "signature": "class Array<T>",
-      "description": "The Array object enables storing a collection of multiple items under a single variable name. Provides numerous instance methods for traversing and mutation.",
-      "type": "class",
-      "module": "global",
-      "members": {
-        "from": { "signature": "Array.from<T, U>(arrayLike: Iterable<T> | ArrayLike<T>, mapFn?: (v: T, k: number) => U): U[]", "description": "Creates a new, shallow-copied Array from an iterable or array-like object.", "type": "static method" },
-        "isArray": { "signature": "Array.isArray(value: any): value is any[]", "description": "Determines whether the passed value is an Array.", "type": "static method" },
-        "of": { "signature": "Array.of<T>(...items: T[]): T[]", "description": "Creates a new Array instance from a variable number of arguments.", "type": "static method" },
-        "fromAsync": { "signature": "Array.fromAsync<T>(asyncIterable: AsyncIterable<T>): Promise<T[]>", "description": "ES2024 — Creates a new Array from an async iterable.", "type": "static method" },
-        "map": { "signature": "Array<T>.map<U>(callbackfn: (value: T, index: number, array: T[]) => U): U[]", "description": "Creates a new array with the results of calling a function on every element.", "type": "method" },
-        "filter": { "signature": "Array<T>.filter(predicate: (value: T, index: number) => boolean): T[]", "description": "Creates a new array with all elements that pass the test.", "type": "method" },
-        "reduce": { "signature": "Array<T>.reduce<U>(callbackfn: (acc: U, cur: T, idx: number) => U, initialValue: U): U", "description": "Reduces the array to a single value by running a reducer on each element.", "type": "method" },
-        "forEach": { "signature": "Array<T>.forEach(callbackfn: (value: T, index: number) => void): void", "description": "Executes a provided function once for each array element.", "type": "method" },
-        "find": { "signature": "Array<T>.find(predicate: (value: T, index: number) => boolean): T | undefined", "description": "Returns the first element satisfying the testing function.", "type": "method" },
-        "findIndex": { "signature": "Array<T>.findIndex(predicate: (value: T, index: number) => boolean): number", "description": "Returns the index of the first element satisfying the testing function, or -1.", "type": "method" },
-        "findLast": { "signature": "Array<T>.findLast(predicate: (value: T, index: number) => boolean): T | undefined", "description": "Returns the last element satisfying the testing function.", "type": "method" },
-        "findLastIndex": { "signature": "Array<T>.findLastIndex(predicate: (value: T, index: number) => boolean): number", "description": "Returns the index of the last element satisfying the testing function, or -1.", "type": "method" },
-        "some": { "signature": "Array<T>.some(predicate: (value: T, index: number) => boolean): boolean", "description": "Tests whether at least one element passes the test.", "type": "method" },
-        "every": { "signature": "Array<T>.every(predicate: (value: T, index: number) => boolean): boolean", "description": "Tests whether all elements pass the test.", "type": "method" },
-        "includes": { "signature": "Array<T>.includes(searchElement: T, fromIndex?: number): boolean", "description": "Determines whether an array includes a certain value.", "type": "method" },
-        "indexOf": { "signature": "Array<T>.indexOf(searchElement: T, fromIndex?: number): number", "description": "Returns the first index at which a given element can be found, or -1.", "type": "method" },
-        "flat": { "signature": "Array<T>.flat(depth?: number): FlatArray[]", "description": "Creates a new array with all sub-array elements concatenated recursively up to depth.", "type": "method" },
-        "flatMap": { "signature": "Array<T>.flatMap<U>(callback: (value: T, index: number) => U | U[]): U[]", "description": "Maps each element then flattens the result (depth 1).", "type": "method" },
-        "sort": { "signature": "Array<T>.sort(compareFn?: (a: T, b: T) => number): T[]", "description": "Sorts elements in place.", "type": "method" },
-        "reverse": { "signature": "Array<T>.reverse(): T[]", "description": "Reverses an array in place.", "type": "method" },
-        "splice": { "signature": "Array<T>.splice(start: number, deleteCount?: number, ...items: T[]): T[]", "description": "Changes contents by removing or replacing existing elements.", "type": "method" },
-        "slice": { "signature": "Array<T>.slice(start?: number, end?: number): T[]", "description": "Returns a shallow copy of a portion of an array.", "type": "method" },
-        "concat": { "signature": "Array<T>.concat(...items: (T | T[])[]): T[]", "description": "Merges two or more arrays into a new array.", "type": "method" },
-        "join": { "signature": "Array<T>.join(separator?: string): string", "description": "Joins all elements into a string with separator.", "type": "method" },
-        "push": { "signature": "Array<T>.push(...items: T[]): number", "description": "Adds elements to the end and returns the new length.", "type": "method" },
-        "pop": { "signature": "Array<T>.pop(): T | undefined", "description": "Removes the last element and returns it.", "type": "method" },
-        "shift": { "signature": "Array<T>.shift(): T | undefined", "description": "Removes the first element and returns it.", "type": "method" },
-        "unshift": { "signature": "Array<T>.unshift(...items: T[]): number", "description": "Adds elements to the beginning and returns the new length.", "type": "method" },
-        "at": { "signature": "Array<T>.at(index: number): T | undefined", "description": "Returns the element at index, accepting negative integers.", "type": "method" },
-        "fill": { "signature": "Array<T>.fill(value: T, start?: number, end?: number): T[]", "description": "Fills all positions from start to end with a static value.", "type": "method" },
-        "entries": { "signature": "Array<T>.entries(): IterableIterator<[number, T]>", "description": "Returns a new array iterator with key/value pairs.", "type": "method" },
-        "keys": { "signature": "Array<T>.keys(): IterableIterator<number>", "description": "Returns a new array iterator with the keys (indices).", "type": "method" },
-        "values": { "signature": "Array<T>.values(): IterableIterator<T>", "description": "Returns a new array iterator with the values.", "type": "method" },
-        "toSorted": { "signature": "Array<T>.toSorted(compareFn?: (a: T, b: T) => number): T[]", "description": "ES2023 — Returns a new sorted array without modifying the original.", "type": "method" },
-        "toReversed": { "signature": "Array<T>.toReversed(): T[]", "description": "ES2023 — Returns a new reversed array without modifying the original.", "type": "method" },
-        "toSpliced": { "signature": "Array<T>.toSpliced(start: number, deleteCount?: number, ...items: T[]): T[]", "description": "ES2023 — Returns a new array with some elements removed/replaced, without modifying the original.", "type": "method" },
-        "with": { "signature": "Array<T>.with(index: number, value: T): T[]", "description": "ES2023 — Returns a new array with the element at index replaced.", "type": "method" }
-      }
-    },
-    "Object": {
-      "signature": "class Object",
-      "description": "The Object type represents one of JavaScript's data types. It is used to store various keyed collections and more complex entities.",
-      "type": "class",
-      "module": "global",
-      "members": {
-        "keys": { "signature": "Object.keys(obj: object): string[]", "description": "Returns own enumerable property names.", "type": "static method" },
-        "values": { "signature": "Object.values(obj: object): any[]", "description": "Returns own enumerable property values.", "type": "static method" },
-        "entries": { "signature": "Object.entries(obj: object): [string, any][]", "description": "Returns own enumerable [key, value] pairs.", "type": "static method" },
-        "assign": { "signature": "Object.assign(target: object, ...sources: object[]): object", "description": "Copies enumerable own properties from sources to target.", "type": "static method" },
-        "freeze": { "signature": "Object.freeze<T>(obj: T): Readonly<T>", "description": "Freezes an object (prevents modifications).", "type": "static method" },
-        "fromEntries": { "signature": "Object.fromEntries(entries: Iterable<[string, any]>): object", "description": "Transforms key-value pairs into an object.", "type": "static method" },
-        "create": { "signature": "Object.create(proto: object | null, propertiesObject?: object): any", "description": "Creates a new object with the specified prototype.", "type": "static method" },
-        "defineProperty": { "signature": "Object.defineProperty(obj: object, prop: string | symbol, descriptor: PropertyDescriptor): object", "description": "Defines a new property directly on an object.", "type": "static method" },
-        "getOwnPropertyNames": { "signature": "Object.getOwnPropertyNames(obj: object): string[]", "description": "Returns all own property names (including non-enumerable).", "type": "static method" },
-        "getPrototypeOf": { "signature": "Object.getPrototypeOf(obj: any): any", "description": "Returns the prototype of the specified object.", "type": "static method" },
-        "hasOwn": { "signature": "Object.hasOwn(obj: object, prop: string | symbol): boolean", "description": "ES2022 — Returns true if the object has the specified own property.", "type": "static method" },
-        "groupBy": { "signature": "Object.groupBy<T>(items: Iterable<T>, callbackFn: (el: T, idx: number) => string): Record<string, T[]>", "description": "ES2024 — Groups elements by a callback's return value.", "type": "static method" }
-      }
-    },
-    "Promise": {
-      "signature": "class Promise<T>",
-      "description": "Represents the eventual completion or failure of an asynchronous operation and its resulting value.",
-      "type": "class",
-      "module": "global",
-      "members": {
-        "all": { "signature": "Promise.all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>", "description": "Resolves when all promises resolve; rejects when any rejects.", "type": "static method" },
-        "allSettled": { "signature": "Promise.allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<T>[]>", "description": "Resolves when all promises settle (fulfilled or rejected).", "type": "static method" },
-        "race": { "signature": "Promise.race<T>(values: Iterable<T | PromiseLike<T>>): Promise<T>", "description": "Settles as soon as any promise settles.", "type": "static method" },
-        "any": { "signature": "Promise.any<T>(values: Iterable<T | PromiseLike<T>>): Promise<T>", "description": "Resolves with the first fulfilling promise. Rejects with AggregateError if all reject.", "type": "static method" },
-        "resolve": { "signature": "Promise.resolve<T>(value: T | PromiseLike<T>): Promise<T>", "description": "Returns a Promise resolved with the given value.", "type": "static method" },
-        "reject": { "signature": "Promise.reject<T>(reason?: any): Promise<T>", "description": "Returns a Promise rejected with the given reason.", "type": "static method" },
-        "withResolvers": { "signature": "Promise.withResolvers<T>(): { promise: Promise<T>, resolve: (v: T) => void, reject: (r: any) => void }", "description": "ES2024 — Returns a promise with its resolve and reject functions.", "type": "static method" },
-        "then": { "signature": "Promise<T>.then<U>(onfulfilled?: (value: T) => U, onrejected?: (reason: any) => U): Promise<U>", "description": "Attaches callbacks for the resolution and/or rejection of the Promise.", "type": "method" },
-        "catch": { "signature": "Promise<T>.catch<U>(onrejected?: (reason: any) => U): Promise<T | U>", "description": "Attaches a callback for only the rejection of the Promise.", "type": "method" },
-        "finally": { "signature": "Promise<T>.finally(onfinally?: () => void): Promise<T>", "description": "Attaches a callback invoked when the Promise is settled (fulfilled or rejected).", "type": "method" }
-      }
-    },
-    "Map": {
-      "signature": "class Map<K, V>",
-      "description": "Holds key-value pairs and remembers the original insertion order. Any value may be used as key or value.",
-      "type": "class",
-      "module": "global",
-      "members": {
-        "set": { "signature": "Map<K,V>.set(key: K, value: V): Map<K,V>", "description": "Sets the value for the key. Returns the Map object.", "type": "method" },
-        "get": { "signature": "Map<K,V>.get(key: K): V | undefined", "description": "Returns the value associated with the key, or undefined.", "type": "method" },
-        "has": { "signature": "Map<K,V>.has(key: K): boolean", "description": "Returns whether a value is associated with the key.", "type": "method" },
-        "delete": { "signature": "Map<K,V>.delete(key: K): boolean", "description": "Removes the entry for the key. Returns true if an entry was removed.", "type": "method" },
-        "clear": { "signature": "Map<K,V>.clear(): void", "description": "Removes all entries.", "type": "method" },
-        "forEach": { "signature": "Map<K,V>.forEach(callbackFn: (value: V, key: K, map: Map<K,V>) => void): void", "description": "Calls callbackFn once for each key-value pair.", "type": "method" },
-        "entries": { "signature": "Map<K,V>.entries(): IterableIterator<[K, V]>", "description": "Returns an iterator of [key, value] pairs.", "type": "method" },
-        "keys": { "signature": "Map<K,V>.keys(): IterableIterator<K>", "description": "Returns an iterator of keys.", "type": "method" },
-        "values": { "signature": "Map<K,V>.values(): IterableIterator<V>", "description": "Returns an iterator of values.", "type": "method" },
-        "size": { "signature": "Map<K,V>.size: number", "description": "Returns the number of entries.", "type": "property" }
-      }
-    },
-    "Set": {
-      "signature": "class Set<T>",
-      "description": "Stores unique values of any type.",
-      "type": "class",
-      "module": "global",
-      "members": {
-        "add": { "signature": "Set<T>.add(value: T): Set<T>", "description": "Appends value. Returns the Set.", "type": "method" },
-        "has": { "signature": "Set<T>.has(value: T): boolean", "description": "Returns whether the value exists.", "type": "method" },
-        "delete": { "signature": "Set<T>.delete(value: T): boolean", "description": "Removes the value. Returns true if removed.", "type": "method" },
-        "clear": { "signature": "Set<T>.clear(): void", "description": "Removes all values.", "type": "method" },
-        "forEach": { "signature": "Set<T>.forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void): void", "description": "Calls callbackFn once for each value.", "type": "method" },
-        "entries": { "signature": "Set<T>.entries(): IterableIterator<[T, T]>", "description": "Returns an iterator of [value, value] pairs.", "type": "method" },
-        "values": { "signature": "Set<T>.values(): IterableIterator<T>", "description": "Returns an iterator of values.", "type": "method" },
-        "size": { "signature": "Set<T>.size: number", "description": "Returns the number of values.", "type": "property" },
-        "union": { "signature": "Set<T>.union(other: Set<T>): Set<T>", "description": "ES2025 — Returns a new set with elements in either this or other.", "type": "method" },
-        "intersection": { "signature": "Set<T>.intersection(other: Set<T>): Set<T>", "description": "ES2025 — Returns a new set with elements in both this and other.", "type": "method" },
-        "difference": { "signature": "Set<T>.difference(other: Set<T>): Set<T>", "description": "ES2025 — Returns a new set with elements in this but not in other.", "type": "method" },
-        "isSubsetOf": { "signature": "Set<T>.isSubsetOf(other: Set<T>): boolean", "description": "ES2025 — Returns whether this is a subset of other.", "type": "method" }
-      }
-    },
-    "String": {
-      "signature": "class String",
-      "description": "The String object is used to represent and manipulate a sequence of characters.",
-      "type": "class",
-      "module": "global",
-      "members": {
-        "charAt": { "signature": "String.charAt(index: number): string", "description": "Returns the character at the specified index.", "type": "method" },
-        "charCodeAt": { "signature": "String.charCodeAt(index: number): number", "description": "Returns the UTF-16 code unit at the specified index.", "type": "method" },
-        "codePointAt": { "signature": "String.codePointAt(pos: number): number | undefined", "description": "Returns the Unicode code point at the specified position.", "type": "method" },
-        "concat": { "signature": "String.concat(...strings: string[]): string", "description": "Concatenates the string arguments.", "type": "method" },
-        "includes": { "signature": "String.includes(searchString: string, position?: number): boolean", "description": "Determines whether the string contains the search string.", "type": "method" },
-        "startsWith": { "signature": "String.startsWith(searchString: string, position?: number): boolean", "description": "Determines whether the string begins with the search string.", "type": "method" },
-        "endsWith": { "signature": "String.endsWith(searchString: string, endPosition?: number): boolean", "description": "Determines whether the string ends with the search string.", "type": "method" },
-        "indexOf": { "signature": "String.indexOf(searchString: string, position?: number): number", "description": "Returns the index of the first occurrence, or -1.", "type": "method" },
-        "lastIndexOf": { "signature": "String.lastIndexOf(searchString: string, position?: number): number", "description": "Returns the index of the last occurrence, or -1.", "type": "method" },
-        "match": { "signature": "String.match(regexp: string | RegExp): RegExpMatchArray | null", "description": "Retrieves the result of matching against a regular expression.", "type": "method" },
-        "matchAll": { "signature": "String.matchAll(regexp: RegExp): IterableIterator<RegExpMatchArray>", "description": "Returns an iterator of all results matching a regex (must have 'g' flag).", "type": "method" },
-        "replace": { "signature": "String.replace(searchValue: string | RegExp, replaceValue: string | Function): string", "description": "Returns a new string with one or all matches replaced.", "type": "method" },
-        "replaceAll": { "signature": "String.replaceAll(searchValue: string | RegExp, replaceValue: string | Function): string", "description": "Returns a new string with all matches replaced.", "type": "method" },
-        "search": { "signature": "String.search(regexp: string | RegExp): number", "description": "Searches for a match and returns the index of the match.", "type": "method" },
-        "slice": { "signature": "String.slice(start?: number, end?: number): string", "description": "Extracts a section of a string and returns it as a new string.", "type": "method" },
-        "split": { "signature": "String.split(separator: string | RegExp, limit?: number): string[]", "description": "Divides a string into an ordered list of substrings.", "type": "method" },
-        "substring": { "signature": "String.substring(start: number, end?: number): string", "description": "Returns the part of the string between the start and end indexes.", "type": "method" },
-        "toLowerCase": { "signature": "String.toLowerCase(): string", "description": "Returns the calling string value converted to lowercase.", "type": "method" },
-        "toUpperCase": { "signature": "String.toUpperCase(): string", "description": "Returns the calling string value converted to uppercase.", "type": "method" },
-        "trim": { "signature": "String.trim(): string", "description": "Removes whitespace from both ends.", "type": "method" },
-        "trimStart": { "signature": "String.trimStart(): string", "description": "Removes whitespace from the beginning.", "type": "method" },
-        "trimEnd": { "signature": "String.trimEnd(): string", "description": "Removes whitespace from the end.", "type": "method" },
-        "padStart": { "signature": "String.padStart(targetLength: number, padString?: string): string", "description": "Pads the current string from the start.", "type": "method" },
-        "padEnd": { "signature": "String.padEnd(targetLength: number, padString?: string): string", "description": "Pads the current string from the end.", "type": "method" },
-        "repeat": { "signature": "String.repeat(count: number): string", "description": "Returns a string consisting of count copies of the string.", "type": "method" },
-        "at": { "signature": "String.at(index: number): string | undefined", "description": "Returns the character at the given index, supporting negative indexing.", "type": "method" }
-      }
-    },
-    "Math": {
-      "signature": "namespace Math",
-      "description": "A built-in object that has properties and methods for mathematical constants and functions.",
-      "type": "namespace",
-      "module": "global",
-      "members": {
-        "abs": { "signature": "Math.abs(x: number): number", "description": "Returns the absolute value.", "type": "method" },
-        "ceil": { "signature": "Math.ceil(x: number): number", "description": "Returns the smallest integer >= x.", "type": "method" },
-        "floor": { "signature": "Math.floor(x: number): number", "description": "Returns the largest integer <= x.", "type": "method" },
-        "round": { "signature": "Math.round(x: number): number", "description": "Returns the value of x rounded to the nearest integer.", "type": "method" },
-        "trunc": { "signature": "Math.trunc(x: number): number", "description": "Returns the integer part of x by removing any fractional digits.", "type": "method" },
-        "max": { "signature": "Math.max(...values: number[]): number", "description": "Returns the largest of zero or more numbers.", "type": "method" },
-        "min": { "signature": "Math.min(...values: number[]): number", "description": "Returns the smallest of zero or more numbers.", "type": "method" },
-        "random": { "signature": "Math.random(): number", "description": "Returns a pseudo-random number between 0 (inclusive) and 1 (exclusive).", "type": "method" },
-        "pow": { "signature": "Math.pow(base: number, exponent: number): number", "description": "Returns base raised to the exponent power.", "type": "method" },
-        "sqrt": { "signature": "Math.sqrt(x: number): number", "description": "Returns the square root of x.", "type": "method" },
-        "cbrt": { "signature": "Math.cbrt(x: number): number", "description": "Returns the cube root of x.", "type": "method" },
-        "log": { "signature": "Math.log(x: number): number", "description": "Returns the natural logarithm (ln) of x.", "type": "method" },
-        "log2": { "signature": "Math.log2(x: number): number", "description": "Returns the base-2 logarithm of x.", "type": "method" },
-        "log10": { "signature": "Math.log10(x: number): number", "description": "Returns the base-10 logarithm of x.", "type": "method" },
-        "sign": { "signature": "Math.sign(x: number): number", "description": "Returns the sign of x: -1, 0, or 1.", "type": "method" },
-        "PI": { "signature": "Math.PI: number", "description": "The ratio of a circle's circumference to its diameter (~3.14159).", "type": "property" },
-        "E": { "signature": "Math.E: number", "description": "Euler's number (~2.71828).", "type": "property" }
-      }
-    },
-    "fetch": {
-      "signature": "function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>",
-      "description": "Starts the process of fetching a resource from the network, returning a promise that resolves with the Response.",
-      "type": "function",
-      "module": "global",
-      "parameters": [
-        { "name": "input", "type": "RequestInfo | URL", "description": "The resource to fetch (URL string, URL object, or Request object)" },
-        { "name": "init", "type": "RequestInit", "description": "Optional settings: method, headers, body, signal, mode, credentials, cache, redirect", "optional": true }
-      ],
-      "returns": "Promise<Response>"
-    },
-    "setTimeout": {
-      "signature": "function setTimeout(callback: Function, delay?: number, ...args: any[]): number",
-      "description": "Sets a timer which executes a function once the timer expires.",
-      "type": "function",
-      "module": "global",
-      "parameters": [
-        { "name": "callback", "type": "Function", "description": "Function to execute after delay" },
-        { "name": "delay", "type": "number", "description": "Milliseconds to wait (default 0)", "optional": true }
-      ],
-      "returns": "number (timeout ID)"
-    },
-    "setInterval": {
-      "signature": "function setInterval(callback: Function, delay?: number, ...args: any[]): number",
-      "description": "Repeatedly calls a function with a fixed time delay between each call.",
-      "type": "function",
-      "module": "global",
-      "parameters": [
-        { "name": "callback", "type": "Function", "description": "Function to execute repeatedly" },
-        { "name": "delay", "type": "number", "description": "Milliseconds between each call", "optional": true }
-      ],
-      "returns": "number (interval ID)"
-    },
-    "structuredClone": {
-      "signature": "function structuredClone<T>(value: T, options?: { transfer: Transferable[] }): T",
-      "description": "Creates a deep clone of a given value using the structured clone algorithm.",
-      "type": "function",
-      "module": "global",
-      "parameters": [
-        { "name": "value", "type": "T", "description": "The value to clone" },
-        { "name": "options", "type": "object", "description": "Optional object containing transfer list", "optional": true }
-      ],
-      "returns": "T"
-    }
-  }
-}
+{
+  "language": "javascript",
+  "definitions": {
+    "console": {
+      "signature": "interface Console",
+      "description": "The Console object provides access to the browser's debugging console (e.g. the Web console in Firefox). Implementations available in Node.js, Deno, and browsers.",
+      "type": "object",
+      "module": "global",
+      "members": {
+        "log": {
+          "signature": "console.log(...data: any[]): void",
+          "description": "Outputs a message to the console.",
+          "type": "method"
+        },
+        "error": {
+          "signature": "console.error(...data: any[]): void",
+          "description": "Outputs an error message. May include stack trace.",
+          "type": "method"
+        },
+        "warn": {
+          "signature": "console.warn(...data: any[]): void",
+          "description": "Outputs a warning message.",
+          "type": "method"
+        },
+        "info": {
+          "signature": "console.info(...data: any[]): void",
+          "description": "Informative logging of information.",
+          "type": "method"
+        },
+        "debug": {
+          "signature": "console.debug(...data: any[]): void",
+          "description": "Outputs a debug-level message.",
+          "type": "method"
+        },
+        "table": {
+          "signature": "console.table(tabularData: any, properties?: string[]): void",
+          "description": "Displays tabular data as a table.",
+          "type": "method"
+        },
+        "dir": {
+          "signature": "console.dir(item: any, options?: object): void",
+          "description": "Displays an interactive listing of properties of a specified object.",
+          "type": "method"
+        },
+        "time": {
+          "signature": "console.time(label?: string): void",
+          "description": "Starts a timer you can use to track how long an operation takes.",
+          "type": "method"
+        },
+        "timeEnd": {
+          "signature": "console.timeEnd(label?: string): void",
+          "description": "Stops a timer and logs elapsed time.",
+          "type": "method"
+        },
+        "timeLog": {
+          "signature": "console.timeLog(label?: string, ...data: any[]): void",
+          "description": "Logs the current value of a timer started by console.time().",
+          "type": "method"
+        },
+        "assert": {
+          "signature": "console.assert(condition?: boolean, ...data: any[]): void",
+          "description": "Log an error message if the assertion is false.",
+          "type": "method"
+        },
+        "clear": {
+          "signature": "console.clear(): void",
+          "description": "Clear the console.",
+          "type": "method"
+        },
+        "count": {
+          "signature": "console.count(label?: string): void",
+          "description": "Log the number of times this line has been called with the given label.",
+          "type": "method"
+        },
+        "countReset": {
+          "signature": "console.countReset(label?: string): void",
+          "description": "Resets the value of the counter with the given label.",
+          "type": "method"
+        },
+        "group": {
+          "signature": "console.group(...label: any[]): void",
+          "description": "Creates a new inline group, indenting all following output.",
+          "type": "method"
+        },
+        "groupCollapsed": {
+          "signature": "console.groupCollapsed(...label: any[]): void",
+          "description": "Creates a new inline group (collapsed by default).",
+          "type": "method"
+        },
+        "groupEnd": {
+          "signature": "console.groupEnd(): void",
+          "description": "Exits the current inline group.",
+          "type": "method"
+        },
+        "trace": {
+          "signature": "console.trace(...data: any[]): void",
+          "description": "Outputs a stack trace.",
+          "type": "method"
+        }
+      }
+    },
+    "JSON": {
+      "signature": "namespace JSON",
+      "description": "An intrinsic object that provides functions to convert JavaScript values to and from JSON format.",
+      "type": "namespace",
+      "module": "global",
+      "members": {
+        "parse": {
+          "signature": "JSON.parse(text: string, reviver?: Function): any",
+          "description": "Converts a JSON string into an object.",
+          "type": "method",
+          "parameters": [
+            {
+              "name": "text",
+              "type": "string",
+              "description": "A valid JSON string"
+            },
+            {
+              "name": "reviver",
+              "type": "Function",
+              "description": "Optional function that transforms the results",
+              "optional": true
+            }
+          ],
+          "returns": "any"
+        },
+        "stringify": {
+          "signature": "JSON.stringify(value: any, replacer?: Function | (string|number)[], space?: string | number): string",
+          "description": "Converts a JavaScript value to a JSON string.",
+          "type": "method",
+          "parameters": [
+            {
+              "name": "value",
+              "type": "any",
+              "description": "The value to convert"
+            },
+            {
+              "name": "replacer",
+              "type": "Function | Array",
+              "description": "Function or whitelist array",
+              "optional": true
+            },
+            {
+              "name": "space",
+              "type": "string | number",
+              "description": "Indentation",
+              "optional": true
+            }
+          ],
+          "returns": "string | undefined"
+        }
+      }
+    },
+    "Array": {
+      "signature": "class Array<T>",
+      "description": "The Array object enables storing a collection of multiple items under a single variable name. Provides numerous instance methods for traversing and mutation.",
+      "type": "class",
+      "module": "global",
+      "members": {
+        "from": {
+          "signature": "Array.from<T, U>(arrayLike: Iterable<T> | ArrayLike<T>, mapFn?: (v: T, k: number) => U): U[]",
+          "description": "Creates a new, shallow-copied Array from an iterable or array-like object.",
+          "type": "static method"
+        },
+        "isArray": {
+          "signature": "Array.isArray(value: any): value is any[]",
+          "description": "Determines whether the passed value is an Array.",
+          "type": "static method"
+        },
+        "of": {
+          "signature": "Array.of<T>(...items: T[]): T[]",
+          "description": "Creates a new Array instance from a variable number of arguments.",
+          "type": "static method"
+        },
+        "fromAsync": {
+          "signature": "Array.fromAsync<T>(asyncIterable: AsyncIterable<T>): Promise<T[]>",
+          "description": "ES2024 — Creates a new Array from an async iterable.",
+          "type": "static method"
+        },
+        "map": {
+          "signature": "Array<T>.map<U>(callbackfn: (value: T, index: number, array: T[]) => U): U[]",
+          "description": "Creates a new array with the results of calling a function on every element.",
+          "type": "method"
+        },
+        "filter": {
+          "signature": "Array<T>.filter(predicate: (value: T, index: number) => boolean): T[]",
+          "description": "Creates a new array with all elements that pass the test.",
+          "type": "method"
+        },
+        "reduce": {
+          "signature": "Array<T>.reduce<U>(callbackfn: (acc: U, cur: T, idx: number) => U, initialValue: U): U",
+          "description": "Reduces the array to a single value by running a reducer on each element.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "Array<T>.forEach(callbackfn: (value: T, index: number) => void): void",
+          "description": "Executes a provided function once for each array element.",
+          "type": "method"
+        },
+        "find": {
+          "signature": "Array<T>.find(predicate: (value: T, index: number) => boolean): T | undefined",
+          "description": "Returns the first element satisfying the testing function.",
+          "type": "method"
+        },
+        "findIndex": {
+          "signature": "Array<T>.findIndex(predicate: (value: T, index: number) => boolean): number",
+          "description": "Returns the index of the first element satisfying the testing function, or -1.",
+          "type": "method"
+        },
+        "findLast": {
+          "signature": "Array<T>.findLast(predicate: (value: T, index: number) => boolean): T | undefined",
+          "description": "Returns the last element satisfying the testing function.",
+          "type": "method"
+        },
+        "findLastIndex": {
+          "signature": "Array<T>.findLastIndex(predicate: (value: T, index: number) => boolean): number",
+          "description": "Returns the index of the last element satisfying the testing function, or -1.",
+          "type": "method"
+        },
+        "some": {
+          "signature": "Array<T>.some(predicate: (value: T, index: number) => boolean): boolean",
+          "description": "Tests whether at least one element passes the test.",
+          "type": "method"
+        },
+        "every": {
+          "signature": "Array<T>.every(predicate: (value: T, index: number) => boolean): boolean",
+          "description": "Tests whether all elements pass the test.",
+          "type": "method"
+        },
+        "includes": {
+          "signature": "Array<T>.includes(searchElement: T, fromIndex?: number): boolean",
+          "description": "Determines whether an array includes a certain value.",
+          "type": "method"
+        },
+        "indexOf": {
+          "signature": "Array<T>.indexOf(searchElement: T, fromIndex?: number): number",
+          "description": "Returns the first index at which a given element can be found, or -1.",
+          "type": "method"
+        },
+        "flat": {
+          "signature": "Array<T>.flat(depth?: number): FlatArray[]",
+          "description": "Creates a new array with all sub-array elements concatenated recursively up to depth.",
+          "type": "method"
+        },
+        "flatMap": {
+          "signature": "Array<T>.flatMap<U>(callback: (value: T, index: number) => U | U[]): U[]",
+          "description": "Maps each element then flattens the result (depth 1).",
+          "type": "method"
+        },
+        "sort": {
+          "signature": "Array<T>.sort(compareFn?: (a: T, b: T) => number): T[]",
+          "description": "Sorts elements in place.",
+          "type": "method"
+        },
+        "reverse": {
+          "signature": "Array<T>.reverse(): T[]",
+          "description": "Reverses an array in place.",
+          "type": "method"
+        },
+        "splice": {
+          "signature": "Array<T>.splice(start: number, deleteCount?: number, ...items: T[]): T[]",
+          "description": "Changes contents by removing or replacing existing elements.",
+          "type": "method"
+        },
+        "slice": {
+          "signature": "Array<T>.slice(start?: number, end?: number): T[]",
+          "description": "Returns a shallow copy of a portion of an array.",
+          "type": "method"
+        },
+        "concat": {
+          "signature": "Array<T>.concat(...items: (T | T[])[]): T[]",
+          "description": "Merges two or more arrays into a new array.",
+          "type": "method"
+        },
+        "join": {
+          "signature": "Array<T>.join(separator?: string): string",
+          "description": "Joins all elements into a string with separator.",
+          "type": "method"
+        },
+        "push": {
+          "signature": "Array<T>.push(...items: T[]): number",
+          "description": "Adds elements to the end and returns the new length.",
+          "type": "method"
+        },
+        "pop": {
+          "signature": "Array<T>.pop(): T | undefined",
+          "description": "Removes the last element and returns it.",
+          "type": "method"
+        },
+        "shift": {
+          "signature": "Array<T>.shift(): T | undefined",
+          "description": "Removes the first element and returns it.",
+          "type": "method"
+        },
+        "unshift": {
+          "signature": "Array<T>.unshift(...items: T[]): number",
+          "description": "Adds elements to the beginning and returns the new length.",
+          "type": "method"
+        },
+        "at": {
+          "signature": "Array<T>.at(index: number): T | undefined",
+          "description": "Returns the element at index, accepting negative integers.",
+          "type": "method"
+        },
+        "fill": {
+          "signature": "Array<T>.fill(value: T, start?: number, end?: number): T[]",
+          "description": "Fills all positions from start to end with a static value.",
+          "type": "method"
+        },
+        "entries": {
+          "signature": "Array<T>.entries(): IterableIterator<[number, T]>",
+          "description": "Returns a new array iterator with key/value pairs.",
+          "type": "method"
+        },
+        "keys": {
+          "signature": "Array<T>.keys(): IterableIterator<number>",
+          "description": "Returns a new array iterator with the keys (indices).",
+          "type": "method"
+        },
+        "values": {
+          "signature": "Array<T>.values(): IterableIterator<T>",
+          "description": "Returns a new array iterator with the values.",
+          "type": "method"
+        },
+        "toSorted": {
+          "signature": "Array<T>.toSorted(compareFn?: (a: T, b: T) => number): T[]",
+          "description": "ES2023 — Returns a new sorted array without modifying the original.",
+          "type": "method"
+        },
+        "toReversed": {
+          "signature": "Array<T>.toReversed(): T[]",
+          "description": "ES2023 — Returns a new reversed array without modifying the original.",
+          "type": "method"
+        },
+        "toSpliced": {
+          "signature": "Array<T>.toSpliced(start: number, deleteCount?: number, ...items: T[]): T[]",
+          "description": "ES2023 — Returns a new array with some elements removed/replaced, without modifying the original.",
+          "type": "method"
+        },
+        "with": {
+          "signature": "Array<T>.with(index: number, value: T): T[]",
+          "description": "ES2023 — Returns a new array with the element at index replaced.",
+          "type": "method"
+        }
+      }
+    },
+    "Object": {
+      "signature": "class Object",
+      "description": "The Object type represents one of JavaScript's data types. It is used to store various keyed collections and more complex entities.",
+      "type": "class",
+      "module": "global",
+      "members": {
+        "keys": {
+          "signature": "Object.keys(obj: object): string[]",
+          "description": "Returns own enumerable property names.",
+          "type": "static method"
+        },
+        "values": {
+          "signature": "Object.values(obj: object): any[]",
+          "description": "Returns own enumerable property values.",
+          "type": "static method"
+        },
+        "entries": {
+          "signature": "Object.entries(obj: object): [string, any][]",
+          "description": "Returns own enumerable [key, value] pairs.",
+          "type": "static method"
+        },
+        "assign": {
+          "signature": "Object.assign(target: object, ...sources: object[]): object",
+          "description": "Copies enumerable own properties from sources to target.",
+          "type": "static method"
+        },
+        "freeze": {
+          "signature": "Object.freeze<T>(obj: T): Readonly<T>",
+          "description": "Freezes an object (prevents modifications).",
+          "type": "static method"
+        },
+        "fromEntries": {
+          "signature": "Object.fromEntries(entries: Iterable<[string, any]>): object",
+          "description": "Transforms key-value pairs into an object.",
+          "type": "static method"
+        },
+        "create": {
+          "signature": "Object.create(proto: object | null, propertiesObject?: object): any",
+          "description": "Creates a new object with the specified prototype.",
+          "type": "static method"
+        },
+        "defineProperty": {
+          "signature": "Object.defineProperty(obj: object, prop: string | symbol, descriptor: PropertyDescriptor): object",
+          "description": "Defines a new property directly on an object.",
+          "type": "static method"
+        },
+        "getOwnPropertyNames": {
+          "signature": "Object.getOwnPropertyNames(obj: object): string[]",
+          "description": "Returns all own property names (including non-enumerable).",
+          "type": "static method"
+        },
+        "getPrototypeOf": {
+          "signature": "Object.getPrototypeOf(obj: any): any",
+          "description": "Returns the prototype of the specified object.",
+          "type": "static method"
+        },
+        "hasOwn": {
+          "signature": "Object.hasOwn(obj: object, prop: string | symbol): boolean",
+          "description": "ES2022 — Returns true if the object has the specified own property.",
+          "type": "static method"
+        },
+        "groupBy": {
+          "signature": "Object.groupBy<T>(items: Iterable<T>, callbackFn: (el: T, idx: number) => string): Record<string, T[]>",
+          "description": "ES2024 — Groups elements by a callback's return value.",
+          "type": "static method"
+        }
+      }
+    },
+    "Promise": {
+      "signature": "class Promise<T>",
+      "description": "Represents the eventual completion or failure of an asynchronous operation and its resulting value.",
+      "type": "class",
+      "module": "global",
+      "members": {
+        "all": {
+          "signature": "Promise.all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>",
+          "description": "Resolves when all promises resolve; rejects when any rejects.",
+          "type": "static method"
+        },
+        "allSettled": {
+          "signature": "Promise.allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<T>[]>",
+          "description": "Resolves when all promises settle (fulfilled or rejected).",
+          "type": "static method"
+        },
+        "race": {
+          "signature": "Promise.race<T>(values: Iterable<T | PromiseLike<T>>): Promise<T>",
+          "description": "Settles as soon as any promise settles.",
+          "type": "static method"
+        },
+        "any": {
+          "signature": "Promise.any<T>(values: Iterable<T | PromiseLike<T>>): Promise<T>",
+          "description": "Resolves with the first fulfilling promise. Rejects with AggregateError if all reject.",
+          "type": "static method"
+        },
+        "resolve": {
+          "signature": "Promise.resolve<T>(value: T | PromiseLike<T>): Promise<T>",
+          "description": "Returns a Promise resolved with the given value.",
+          "type": "static method"
+        },
+        "reject": {
+          "signature": "Promise.reject<T>(reason?: any): Promise<T>",
+          "description": "Returns a Promise rejected with the given reason.",
+          "type": "static method"
+        },
+        "withResolvers": {
+          "signature": "Promise.withResolvers<T>(): { promise: Promise<T>, resolve: (v: T) => void, reject: (r: any) => void }",
+          "description": "ES2024 — Returns a promise with its resolve and reject functions.",
+          "type": "static method"
+        },
+        "then": {
+          "signature": "Promise<T>.then<U>(onfulfilled?: (value: T) => U, onrejected?: (reason: any) => U): Promise<U>",
+          "description": "Attaches callbacks for the resolution and/or rejection of the Promise.",
+          "type": "method"
+        },
+        "catch": {
+          "signature": "Promise<T>.catch<U>(onrejected?: (reason: any) => U): Promise<T | U>",
+          "description": "Attaches a callback for only the rejection of the Promise.",
+          "type": "method"
+        },
+        "finally": {
+          "signature": "Promise<T>.finally(onfinally?: () => void): Promise<T>",
+          "description": "Attaches a callback invoked when the Promise is settled (fulfilled or rejected).",
+          "type": "method"
+        }
+      }
+    },
+    "Map": {
+      "signature": "class Map<K, V>",
+      "description": "Holds key-value pairs and remembers the original insertion order. Any value may be used as key or value.",
+      "type": "class",
+      "module": "global",
+      "members": {
+        "set": {
+          "signature": "Map<K,V>.set(key: K, value: V): Map<K,V>",
+          "description": "Sets the value for the key. Returns the Map object.",
+          "type": "method"
+        },
+        "get": {
+          "signature": "Map<K,V>.get(key: K): V | undefined",
+          "description": "Returns the value associated with the key, or undefined.",
+          "type": "method"
+        },
+        "has": {
+          "signature": "Map<K,V>.has(key: K): boolean",
+          "description": "Returns whether a value is associated with the key.",
+          "type": "method"
+        },
+        "delete": {
+          "signature": "Map<K,V>.delete(key: K): boolean",
+          "description": "Removes the entry for the key. Returns true if an entry was removed.",
+          "type": "method"
+        },
+        "clear": {
+          "signature": "Map<K,V>.clear(): void",
+          "description": "Removes all entries.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "Map<K,V>.forEach(callbackFn: (value: V, key: K, map: Map<K,V>) => void): void",
+          "description": "Calls callbackFn once for each key-value pair.",
+          "type": "method"
+        },
+        "entries": {
+          "signature": "Map<K,V>.entries(): IterableIterator<[K, V]>",
+          "description": "Returns an iterator of [key, value] pairs.",
+          "type": "method"
+        },
+        "keys": {
+          "signature": "Map<K,V>.keys(): IterableIterator<K>",
+          "description": "Returns an iterator of keys.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "Map<K,V>.values(): IterableIterator<V>",
+          "description": "Returns an iterator of values.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "Map<K,V>.size: number",
+          "description": "Returns the number of entries.",
+          "type": "property"
+        }
+      }
+    },
+    "Set": {
+      "signature": "class Set<T>",
+      "description": "Stores unique values of any type.",
+      "type": "class",
+      "module": "global",
+      "members": {
+        "add": {
+          "signature": "Set<T>.add(value: T): Set<T>",
+          "description": "Appends value. Returns the Set.",
+          "type": "method"
+        },
+        "has": {
+          "signature": "Set<T>.has(value: T): boolean",
+          "description": "Returns whether the value exists.",
+          "type": "method"
+        },
+        "delete": {
+          "signature": "Set<T>.delete(value: T): boolean",
+          "description": "Removes the value. Returns true if removed.",
+          "type": "method"
+        },
+        "clear": {
+          "signature": "Set<T>.clear(): void",
+          "description": "Removes all values.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "Set<T>.forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void): void",
+          "description": "Calls callbackFn once for each value.",
+          "type": "method"
+        },
+        "entries": {
+          "signature": "Set<T>.entries(): IterableIterator<[T, T]>",
+          "description": "Returns an iterator of [value, value] pairs.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "Set<T>.values(): IterableIterator<T>",
+          "description": "Returns an iterator of values.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "Set<T>.size: number",
+          "description": "Returns the number of values.",
+          "type": "property"
+        },
+        "union": {
+          "signature": "Set<T>.union(other: Set<T>): Set<T>",
+          "description": "ES2025 — Returns a new set with elements in either this or other.",
+          "type": "method"
+        },
+        "intersection": {
+          "signature": "Set<T>.intersection(other: Set<T>): Set<T>",
+          "description": "ES2025 — Returns a new set with elements in both this and other.",
+          "type": "method"
+        },
+        "difference": {
+          "signature": "Set<T>.difference(other: Set<T>): Set<T>",
+          "description": "ES2025 — Returns a new set with elements in this but not in other.",
+          "type": "method"
+        },
+        "isSubsetOf": {
+          "signature": "Set<T>.isSubsetOf(other: Set<T>): boolean",
+          "description": "ES2025 — Returns whether this is a subset of other.",
+          "type": "method"
+        }
+      }
+    },
+    "String": {
+      "signature": "class String",
+      "description": "The String object is used to represent and manipulate a sequence of characters.",
+      "type": "class",
+      "module": "global",
+      "members": {
+        "charAt": {
+          "signature": "String.charAt(index: number): string",
+          "description": "Returns the character at the specified index.",
+          "type": "method"
+        },
+        "charCodeAt": {
+          "signature": "String.charCodeAt(index: number): number",
+          "description": "Returns the UTF-16 code unit at the specified index.",
+          "type": "method"
+        },
+        "codePointAt": {
+          "signature": "String.codePointAt(pos: number): number | undefined",
+          "description": "Returns the Unicode code point at the specified position.",
+          "type": "method"
+        },
+        "concat": {
+          "signature": "String.concat(...strings: string[]): string",
+          "description": "Concatenates the string arguments.",
+          "type": "method"
+        },
+        "includes": {
+          "signature": "String.includes(searchString: string, position?: number): boolean",
+          "description": "Determines whether the string contains the search string.",
+          "type": "method"
+        },
+        "startsWith": {
+          "signature": "String.startsWith(searchString: string, position?: number): boolean",
+          "description": "Determines whether the string begins with the search string.",
+          "type": "method"
+        },
+        "endsWith": {
+          "signature": "String.endsWith(searchString: string, endPosition?: number): boolean",
+          "description": "Determines whether the string ends with the search string.",
+          "type": "method"
+        },
+        "indexOf": {
+          "signature": "String.indexOf(searchString: string, position?: number): number",
+          "description": "Returns the index of the first occurrence, or -1.",
+          "type": "method"
+        },
+        "lastIndexOf": {
+          "signature": "String.lastIndexOf(searchString: string, position?: number): number",
+          "description": "Returns the index of the last occurrence, or -1.",
+          "type": "method"
+        },
+        "match": {
+          "signature": "String.match(regexp: string | RegExp): RegExpMatchArray | null",
+          "description": "Retrieves the result of matching against a regular expression.",
+          "type": "method"
+        },
+        "matchAll": {
+          "signature": "String.matchAll(regexp: RegExp): IterableIterator<RegExpMatchArray>",
+          "description": "Returns an iterator of all results matching a regex (must have 'g' flag).",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "String.replace(searchValue: string | RegExp, replaceValue: string | Function): string",
+          "description": "Returns a new string with one or all matches replaced.",
+          "type": "method"
+        },
+        "replaceAll": {
+          "signature": "String.replaceAll(searchValue: string | RegExp, replaceValue: string | Function): string",
+          "description": "Returns a new string with all matches replaced.",
+          "type": "method"
+        },
+        "search": {
+          "signature": "String.search(regexp: string | RegExp): number",
+          "description": "Searches for a match and returns the index of the match.",
+          "type": "method"
+        },
+        "slice": {
+          "signature": "String.slice(start?: number, end?: number): string",
+          "description": "Extracts a section of a string and returns it as a new string.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "String.split(separator: string | RegExp, limit?: number): string[]",
+          "description": "Divides a string into an ordered list of substrings.",
+          "type": "method"
+        },
+        "substring": {
+          "signature": "String.substring(start: number, end?: number): string",
+          "description": "Returns the part of the string between the start and end indexes.",
+          "type": "method"
+        },
+        "toLowerCase": {
+          "signature": "String.toLowerCase(): string",
+          "description": "Returns the calling string value converted to lowercase.",
+          "type": "method"
+        },
+        "toUpperCase": {
+          "signature": "String.toUpperCase(): string",
+          "description": "Returns the calling string value converted to uppercase.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "String.trim(): string",
+          "description": "Removes whitespace from both ends.",
+          "type": "method"
+        },
+        "trimStart": {
+          "signature": "String.trimStart(): string",
+          "description": "Removes whitespace from the beginning.",
+          "type": "method"
+        },
+        "trimEnd": {
+          "signature": "String.trimEnd(): string",
+          "description": "Removes whitespace from the end.",
+          "type": "method"
+        },
+        "padStart": {
+          "signature": "String.padStart(targetLength: number, padString?: string): string",
+          "description": "Pads the current string from the start.",
+          "type": "method"
+        },
+        "padEnd": {
+          "signature": "String.padEnd(targetLength: number, padString?: string): string",
+          "description": "Pads the current string from the end.",
+          "type": "method"
+        },
+        "repeat": {
+          "signature": "String.repeat(count: number): string",
+          "description": "Returns a string consisting of count copies of the string.",
+          "type": "method"
+        },
+        "at": {
+          "signature": "String.at(index: number): string | undefined",
+          "description": "Returns the character at the given index, supporting negative indexing.",
+          "type": "method"
+        }
+      }
+    },
+    "Math": {
+      "signature": "namespace Math",
+      "description": "A built-in object that has properties and methods for mathematical constants and functions.",
+      "type": "namespace",
+      "module": "global",
+      "members": {
+        "abs": {
+          "signature": "Math.abs(x: number): number",
+          "description": "Returns the absolute value.",
+          "type": "method"
+        },
+        "ceil": {
+          "signature": "Math.ceil(x: number): number",
+          "description": "Returns the smallest integer >= x.",
+          "type": "method"
+        },
+        "floor": {
+          "signature": "Math.floor(x: number): number",
+          "description": "Returns the largest integer <= x.",
+          "type": "method"
+        },
+        "round": {
+          "signature": "Math.round(x: number): number",
+          "description": "Returns the value of x rounded to the nearest integer.",
+          "type": "method"
+        },
+        "trunc": {
+          "signature": "Math.trunc(x: number): number",
+          "description": "Returns the integer part of x by removing any fractional digits.",
+          "type": "method"
+        },
+        "max": {
+          "signature": "Math.max(...values: number[]): number",
+          "description": "Returns the largest of zero or more numbers.",
+          "type": "method"
+        },
+        "min": {
+          "signature": "Math.min(...values: number[]): number",
+          "description": "Returns the smallest of zero or more numbers.",
+          "type": "method"
+        },
+        "random": {
+          "signature": "Math.random(): number",
+          "description": "Returns a pseudo-random number between 0 (inclusive) and 1 (exclusive).",
+          "type": "method"
+        },
+        "pow": {
+          "signature": "Math.pow(base: number, exponent: number): number",
+          "description": "Returns base raised to the exponent power.",
+          "type": "method"
+        },
+        "sqrt": {
+          "signature": "Math.sqrt(x: number): number",
+          "description": "Returns the square root of x.",
+          "type": "method"
+        },
+        "cbrt": {
+          "signature": "Math.cbrt(x: number): number",
+          "description": "Returns the cube root of x.",
+          "type": "method"
+        },
+        "log": {
+          "signature": "Math.log(x: number): number",
+          "description": "Returns the natural logarithm (ln) of x.",
+          "type": "method"
+        },
+        "log2": {
+          "signature": "Math.log2(x: number): number",
+          "description": "Returns the base-2 logarithm of x.",
+          "type": "method"
+        },
+        "log10": {
+          "signature": "Math.log10(x: number): number",
+          "description": "Returns the base-10 logarithm of x.",
+          "type": "method"
+        },
+        "sign": {
+          "signature": "Math.sign(x: number): number",
+          "description": "Returns the sign of x: -1, 0, or 1.",
+          "type": "method"
+        },
+        "PI": {
+          "signature": "Math.PI: number",
+          "description": "The ratio of a circle's circumference to its diameter (~3.14159).",
+          "type": "property"
+        },
+        "E": {
+          "signature": "Math.E: number",
+          "description": "Euler's number (~2.71828).",
+          "type": "property"
+        }
+      }
+    },
+    "fetch": {
+      "signature": "function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>",
+      "description": "Starts the process of fetching a resource from the network, returning a promise that resolves with the Response.",
+      "type": "function",
+      "module": "global",
+      "parameters": [
+        {
+          "name": "input",
+          "type": "RequestInfo | URL",
+          "description": "The resource to fetch (URL string, URL object, or Request object)"
+        },
+        {
+          "name": "init",
+          "type": "RequestInit",
+          "description": "Optional settings: method, headers, body, signal, mode, credentials, cache, redirect",
+          "optional": true
+        }
+      ],
+      "returns": "Promise<Response>"
+    },
+    "setTimeout": {
+      "signature": "function setTimeout(callback: Function, delay?: number, ...args: any[]): number",
+      "description": "Sets a timer which executes a function once the timer expires.",
+      "type": "function",
+      "module": "global",
+      "parameters": [
+        {
+          "name": "callback",
+          "type": "Function",
+          "description": "Function to execute after delay"
+        },
+        {
+          "name": "delay",
+          "type": "number",
+          "description": "Milliseconds to wait (default 0)",
+          "optional": true
+        }
+      ],
+      "returns": "number (timeout ID)"
+    },
+    "setInterval": {
+      "signature": "function setInterval(callback: Function, delay?: number, ...args: any[]): number",
+      "description": "Repeatedly calls a function with a fixed time delay between each call.",
+      "type": "function",
+      "module": "global",
+      "parameters": [
+        {
+          "name": "callback",
+          "type": "Function",
+          "description": "Function to execute repeatedly"
+        },
+        {
+          "name": "delay",
+          "type": "number",
+          "description": "Milliseconds between each call",
+          "optional": true
+        }
+      ],
+      "returns": "number (interval ID)"
+    },
+    "structuredClone": {
+      "signature": "function structuredClone<T>(value: T, options?: { transfer: Transferable[] }): T",
+      "description": "Creates a deep clone of a given value using the structured clone algorithm.",
+      "type": "function",
+      "module": "global",
+      "parameters": [
+        {
+          "name": "value",
+          "type": "T",
+          "description": "The value to clone"
+        },
+        {
+          "name": "options",
+          "type": "object",
+          "description": "Optional object containing transfer list",
+          "optional": true
+        }
+      ],
+      "returns": "T"
+    },
+    "Number": {
+      "signature": "Number",
+      "description": "Numeric data type for integer and floating-point values.",
+      "type": "type"
+    },
+    "Boolean": {
+      "signature": "Boolean",
+      "description": "Logical type with two values: true and false.",
+      "type": "type"
+    },
+    "null": {
+      "signature": "null",
+      "description": "Represents the intentional absence of any value.",
+      "type": "constant"
+    },
+    "undefined": {
+      "signature": "undefined",
+      "description": "Represents an uninitialized or missing value.",
+      "type": "constant"
+    },
+    "print": {
+      "signature": "print(value)",
+      "description": "Output a value to the standard output stream.",
+      "type": "function"
+    },
+    "length": {
+      "signature": "length",
+      "description": "Returns the number of elements in a collection or characters in a string.",
+      "type": "property"
+    }
+  }
+}