@enjoys/context-engine 1.0.0 → 1.0.2

package/data/defination/java.json

@@ -0,0 +1,184 @@
+{
+  "language": "java",
+  "definitions": {
+    "String": {
+      "signature": "public final class String implements Serializable, Comparable<String>, CharSequence",
+      "description": "The String class represents character strings. All string literals in Java programs are implemented as instances of this class. Strings are immutable; their values cannot be changed after they are created.",
+      "type": "class",
+      "module": "java.lang",
+      "members": {
+        "length": { "signature": "public int length()", "description": "Returns the length of this string. The length is equal to the number of Unicode code units in the string.", "type": "method" },
+        "charAt": { "signature": "public char charAt(int index)", "description": "Returns the char value at the specified index. An index ranges from 0 to length() - 1.", "type": "method" },
+        "substring": { "signature": "public String substring(int beginIndex, int endIndex)", "description": "Returns a string that is a substring of this string. The substring begins at beginIndex and extends to the character at endIndex - 1.", "type": "method" },
+        "equals": { "signature": "public boolean equals(Object anObject)", "description": "Compares this string to the specified object. Returns true if the argument is a String object with the same character sequence.", "type": "method" },
+        "equalsIgnoreCase": { "signature": "public boolean equalsIgnoreCase(String anotherString)", "description": "Compares this String to another String, ignoring case considerations.", "type": "method" },
+        "compareTo": { "signature": "public int compareTo(String anotherString)", "description": "Compares two strings lexicographically. Returns a negative integer, zero, or positive integer.", "type": "method" },
+        "contains": { "signature": "public boolean contains(CharSequence s)", "description": "Returns true if this string contains the specified sequence of char values.", "type": "method" },
+        "startsWith": { "signature": "public boolean startsWith(String prefix)", "description": "Tests if this string starts with the specified prefix.", "type": "method" },
+        "endsWith": { "signature": "public boolean endsWith(String suffix)", "description": "Tests if this string ends with the specified suffix.", "type": "method" },
+        "indexOf": { "signature": "public int indexOf(String str)", "description": "Returns the index within this string of the first occurrence of the specified substring. Returns -1 if not found.", "type": "method" },
+        "lastIndexOf": { "signature": "public int lastIndexOf(String str)", "description": "Returns the index within this string of the last occurrence of the specified substring. Returns -1 if not found.", "type": "method" },
+        "replace": { "signature": "public String replace(CharSequence target, CharSequence replacement)", "description": "Replaces each substring of this string that matches the literal target sequence with the specified replacement sequence.", "type": "method" },
+        "replaceAll": { "signature": "public String replaceAll(String regex, String replacement)", "description": "Replaces each substring of this string that matches the given regular expression with the given replacement.", "type": "method" },
+        "split": { "signature": "public String[] split(String regex)", "description": "Splits this string around matches of the given regular expression.", "type": "method" },
+        "trim": { "signature": "public String trim()", "description": "Returns a string whose value is this string, with all leading and trailing space removed, where space is defined as any character whose codepoint is less than or equal to 'U+0020'.", "type": "method" },
+        "strip": { "signature": "public String strip()", "description": "(Java 11+) Returns a string whose value is this string, with all leading and trailing white space removed. Uses Character.isWhitespace() for Unicode-aware trimming.", "type": "method" },
+        "toUpperCase": { "signature": "public String toUpperCase()", "description": "Converts all of the characters in this String to upper case using the rules of the default locale.", "type": "method" },
+        "toLowerCase": { "signature": "public String toLowerCase()", "description": "Converts all of the characters in this String to lower case using the rules of the default locale.", "type": "method" },
+        "isEmpty": { "signature": "public boolean isEmpty()", "description": "Returns true if, and only if, length() is 0.", "type": "method" },
+        "isBlank": { "signature": "public boolean isBlank()", "description": "(Java 11+) Returns true if the string is empty or contains only white space codepoints.", "type": "method" },
+        "toCharArray": { "signature": "public char[] toCharArray()", "description": "Converts this string to a new character array.", "type": "method" },
+        "matches": { "signature": "public boolean matches(String regex)", "description": "Tells whether or not this string matches the given regular expression.", "type": "method" },
+        "format": { "signature": "public static String format(String format, Object... args)", "description": "Returns a formatted string using the specified format string and arguments.", "type": "method" },
+        "join": { "signature": "public static String join(CharSequence delimiter, CharSequence... elements)", "description": "Returns a new String composed of copies of the CharSequence elements joined together with the specified delimiter.", "type": "method" },
+        "valueOf": { "signature": "public static String valueOf(Object obj)", "description": "Returns the string representation of the Object argument. Returns \"null\" if the argument is null.", "type": "method" },
+        "repeat": { "signature": "public String repeat(int count)", "description": "(Java 11+) Returns a string whose value is the concatenation of this string repeated count times.", "type": "method" },
+        "chars": { "signature": "public IntStream chars()", "description": "Returns an IntStream of char values from this sequence. The values are zero-extended to int.", "type": "method" }
+      }
+    },
+    "ArrayList": {
+      "signature": "public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable",
+      "description": "Resizable-array implementation of the List interface. Implements all optional list operations and permits all elements, including null. Provides constant-time positional access and amortized constant-time addition.",
+      "type": "class",
+      "module": "java.util",
+      "members": {
+        "add": { "signature": "public boolean add(E e)", "description": "Appends the specified element to the end of this list. Returns true.", "type": "method" },
+        "get": { "signature": "public E get(int index)", "description": "Returns the element at the specified position in this list. Throws IndexOutOfBoundsException if the index is out of range.", "type": "method" },
+        "set": { "signature": "public E set(int index, E element)", "description": "Replaces the element at the specified position in this list with the specified element. Returns the element previously at the position.", "type": "method" },
+        "remove": { "signature": "public E remove(int index)", "description": "Removes the element at the specified position in this list. Shifts any subsequent elements to the left.", "type": "method" },
+        "size": { "signature": "public int size()", "description": "Returns the number of elements in this list.", "type": "method" },
+        "isEmpty": { "signature": "public boolean isEmpty()", "description": "Returns true if this list contains no elements.", "type": "method" },
+        "contains": { "signature": "public boolean contains(Object o)", "description": "Returns true if this list contains the specified element, as determined by equals().", "type": "method" },
+        "indexOf": { "signature": "public int indexOf(Object o)", "description": "Returns the index of the first occurrence of the specified element in this list, or -1 if not found.", "type": "method" },
+        "clear": { "signature": "public void clear()", "description": "Removes all of the elements from this list. The list will be empty after this call returns.", "type": "method" },
+        "sort": { "signature": "public void sort(Comparator<? super E> c)", "description": "Sorts this list according to the order induced by the specified Comparator. The sort is stable.", "type": "method" },
+        "toArray": { "signature": "public Object[] toArray()", "description": "Returns an array containing all of the elements in this list in proper sequence (from first to last element).", "type": "method" },
+        "subList": { "signature": "public List<E> subList(int fromIndex, int toIndex)", "description": "Returns a view of the portion of this list between the specified fromIndex (inclusive) and toIndex (exclusive).", "type": "method" },
+        "iterator": { "signature": "public Iterator<E> iterator()", "description": "Returns an iterator over the elements in this list in proper sequence.", "type": "method" },
+        "forEach": { "signature": "public void forEach(Consumer<? super E> action)", "description": "Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception.", "type": "method" },
+        "stream": { "signature": "public Stream<E> stream()", "description": "Returns a sequential Stream with this collection as its source.", "type": "method" },
+        "addAll": { "signature": "public boolean addAll(Collection<? extends E> c)", "description": "Appends all of the elements in the specified collection to the end of this list, in the order returned by the collection's iterator.", "type": "method" }
+      }
+    },
+    "HashMap": {
+      "signature": "public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable",
+      "description": "Hash table based implementation of the Map interface. This implementation permits null values and the null key. Makes no guarantees as to the order of the map. Provides constant-time performance for basic operations (get and put).",
+      "type": "class",
+      "module": "java.util",
+      "members": {
+        "put": { "signature": "public V put(K key, V value)", "description": "Associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced.", "type": "method" },
+        "get": { "signature": "public V get(Object key)", "description": "Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.", "type": "method" },
+        "getOrDefault": { "signature": "public V getOrDefault(Object key, V defaultValue)", "description": "Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.", "type": "method" },
+        "remove": { "signature": "public V remove(Object key)", "description": "Removes the mapping for the specified key from this map if present. Returns the previous value, or null.", "type": "method" },
+        "containsKey": { "signature": "public boolean containsKey(Object key)", "description": "Returns true if this map contains a mapping for the specified key.", "type": "method" },
+        "containsValue": { "signature": "public boolean containsValue(Object value)", "description": "Returns true if this map maps one or more keys to the specified value.", "type": "method" },
+        "keySet": { "signature": "public Set<K> keySet()", "description": "Returns a Set view of the keys contained in this map. The set is backed by the map.", "type": "method" },
+        "values": { "signature": "public Collection<V> values()", "description": "Returns a Collection view of the values contained in this map. The collection is backed by the map.", "type": "method" },
+        "entrySet": { "signature": "public Set<Map.Entry<K,V>> entrySet()", "description": "Returns a Set view of the mappings contained in this map. Each element is a Map.Entry.", "type": "method" },
+        "size": { "signature": "public int size()", "description": "Returns the number of key-value mappings in this map.", "type": "method" },
+        "isEmpty": { "signature": "public boolean isEmpty()", "description": "Returns true if this map contains no key-value mappings.", "type": "method" },
+        "clear": { "signature": "public void clear()", "description": "Removes all of the mappings from this map. The map will be empty after this call returns.", "type": "method" },
+        "putIfAbsent": { "signature": "public V putIfAbsent(K key, V value)", "description": "If the specified key is not already associated with a value, associates it with the given value and returns null, else returns the current value.", "type": "method" },
+        "computeIfAbsent": { "signature": "public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)", "description": "If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map.", "type": "method" },
+        "merge": { "signature": "public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)", "description": "If the specified key is not already associated with a value, associates it with the given value. Otherwise, replaces the value with the results of the given remapping function.", "type": "method" },
+        "forEach": { "signature": "public void forEach(BiConsumer<? super K, ? super V> action)", "description": "Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.", "type": "method" }
+      }
+    },
+    "Optional": {
+      "signature": "public final class Optional<T>",
+      "description": "A container object which may or may not contain a non-null value. If a value is present, isPresent() returns true. If no value is present, the object is considered empty. Introduced in Java 8 to help avoid NullPointerException.",
+      "type": "class",
+      "module": "java.util",
+      "members": {
+        "of": { "signature": "public static <T> Optional<T> of(T value)", "description": "Returns an Optional describing the given non-null value. Throws NullPointerException if the value is null.", "type": "method" },
+        "ofNullable": { "signature": "public static <T> Optional<T> ofNullable(T value)", "description": "Returns an Optional describing the given value, or an empty Optional if the value is null.", "type": "method" },
+        "empty": { "signature": "public static <T> Optional<T> empty()", "description": "Returns an empty Optional instance. No value is present for this Optional.", "type": "method" },
+        "isPresent": { "signature": "public boolean isPresent()", "description": "Returns true if a value is present, otherwise false.", "type": "method" },
+        "isEmpty": { "signature": "public boolean isEmpty()", "description": "(Java 11+) Returns true if a value is not present, otherwise false.", "type": "method" },
+        "get": { "signature": "public T get()", "description": "If a value is present, returns the value, otherwise throws NoSuchElementException. Prefer orElse/orElseThrow over get().", "type": "method" },
+        "orElse": { "signature": "public T orElse(T other)", "description": "If a value is present, returns the value, otherwise returns other.", "type": "method" },
+        "orElseGet": { "signature": "public T orElseGet(Supplier<? extends T> supplier)", "description": "If a value is present, returns the value, otherwise invokes supplier and returns the result.", "type": "method" },
+        "orElseThrow": { "signature": "public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)", "description": "If a value is present, returns the value, otherwise throws the exception created by the supplier.", "type": "method" },
+        "map": { "signature": "public <U> Optional<U> map(Function<? super T, ? extends U> mapper)", "description": "If a value is present, applies the provided mapping function to it, and if the result is non-null, returns an Optional describing the result.", "type": "method" },
+        "flatMap": { "signature": "public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper)", "description": "If a value is present, applies the provided Optional-bearing mapping function to it and returns the result, otherwise returns an empty Optional.", "type": "method" },
+        "filter": { "signature": "public Optional<T> filter(Predicate<? super T> predicate)", "description": "If a value is present and matches the given predicate, returns an Optional describing the value, otherwise returns an empty Optional.", "type": "method" },
+        "ifPresent": { "signature": "public void ifPresent(Consumer<? super T> action)", "description": "If a value is present, performs the given action with the value, otherwise does nothing.", "type": "method" },
+        "ifPresentOrElse": { "signature": "public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)", "description": "(Java 9+) If a value is present, performs the given action with the value, otherwise performs the given empty-based action.", "type": "method" },
+        "stream": { "signature": "public Stream<T> stream()", "description": "(Java 9+) If a value is present, returns a sequential Stream containing only that value, otherwise returns an empty Stream.", "type": "method" }
+      }
+    },
+    "Stream": {
+      "signature": "public interface Stream<T> extends BaseStream<T, Stream<T>>",
+      "description": "A sequence of elements supporting sequential and parallel aggregate operations. Stream operations are divided into intermediate (lazy) and terminal (eager) operations. Streams are created from collections, arrays, or generator functions.",
+      "type": "interface",
+      "module": "java.util.stream",
+      "members": {
+        "filter": { "signature": "Stream<T> filter(Predicate<? super T> predicate)", "description": "Returns a stream consisting of the elements of this stream that match the given predicate. Intermediate operation.", "type": "method" },
+        "map": { "signature": "<R> Stream<R> map(Function<? super T, ? extends R> mapper)", "description": "Returns a stream consisting of the results of applying the given function to the elements of this stream. Intermediate operation.", "type": "method" },
+        "flatMap": { "signature": "<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)", "description": "Returns a stream of the results of replacing each element with the contents of a mapped stream. Intermediate operation.", "type": "method" },
+        "collect": { "signature": "<R, A> R collect(Collector<? super T, A, R> collector)", "description": "Performs a mutable reduction operation using a Collector. Terminal operation.", "type": "method" },
+        "reduce": { "signature": "T reduce(T identity, BinaryOperator<T> accumulator)", "description": "Performs a reduction on the elements using the given identity value and an associative accumulation function. Terminal operation.", "type": "method" },
+        "forEach": { "signature": "void forEach(Consumer<? super T> action)", "description": "Performs an action for each element of this stream. Terminal operation.", "type": "method" },
+        "sorted": { "signature": "Stream<T> sorted()", "description": "Returns a stream consisting of the elements of this stream, sorted according to natural order. Stateful intermediate operation.", "type": "method" },
+        "distinct": { "signature": "Stream<T> distinct()", "description": "Returns a stream consisting of the distinct elements (according to Object.equals) of this stream. Stateful intermediate operation.", "type": "method" },
+        "limit": { "signature": "Stream<T> limit(long maxSize)", "description": "Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length. Short-circuiting stateful intermediate operation.", "type": "method" },
+        "skip": { "signature": "Stream<T> skip(long n)", "description": "Returns a stream consisting of the remaining elements of this stream after discarding the first n elements. Stateful intermediate operation.", "type": "method" },
+        "count": { "signature": "long count()", "description": "Returns the count of elements in this stream. Terminal operation.", "type": "method" },
+        "findFirst": { "signature": "Optional<T> findFirst()", "description": "Returns an Optional describing the first element of this stream, or an empty Optional if the stream is empty. Short-circuiting terminal operation.", "type": "method" },
+        "findAny": { "signature": "Optional<T> findAny()", "description": "Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty. Non-deterministic in parallel streams. Short-circuiting terminal operation.", "type": "method" },
+        "anyMatch": { "signature": "boolean anyMatch(Predicate<? super T> predicate)", "description": "Returns whether any elements of this stream match the provided predicate. Short-circuiting terminal operation.", "type": "method" },
+        "allMatch": { "signature": "boolean allMatch(Predicate<? super T> predicate)", "description": "Returns whether all elements of this stream match the provided predicate. Short-circuiting terminal operation.", "type": "method" },
+        "noneMatch": { "signature": "boolean noneMatch(Predicate<? super T> predicate)", "description": "Returns whether no elements of this stream match the provided predicate. Short-circuiting terminal operation.", "type": "method" },
+        "toArray": { "signature": "Object[] toArray()", "description": "Returns an array containing the elements of this stream. Terminal operation.", "type": "method" },
+        "peek": { "signature": "Stream<T> peek(Consumer<? super T> action)", "description": "Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as they are consumed. Intermediate operation mainly for debugging.", "type": "method" },
+        "min": { "signature": "Optional<T> min(Comparator<? super T> comparator)", "description": "Returns the minimum element of this stream according to the provided Comparator. Terminal operation.", "type": "method" },
+        "max": { "signature": "Optional<T> max(Comparator<? super T> comparator)", "description": "Returns the maximum element of this stream according to the provided Comparator. Terminal operation.", "type": "method" },
+        "of": { "signature": "static <T> Stream<T> of(T... values)", "description": "Returns a sequential ordered stream whose elements are the specified values.", "type": "method" },
+        "iterate": { "signature": "static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)", "description": "Returns an infinite sequential ordered Stream produced by iterative application of a function f to an initial element seed.", "type": "method" },
+        "generate": { "signature": "static <T> Stream<T> generate(Supplier<? extends T> s)", "description": "Returns an infinite sequential unordered stream where each element is generated by the provided Supplier.", "type": "method" },
+        "concat": { "signature": "static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)", "description": "Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.", "type": "method" }
+      }
+    },
+    "List": {
+      "signature": "public interface List<E> extends Collection<E>",
+      "description": "An ordered collection (also known as a sequence). The user can access elements by their integer index and search for elements in the list. Unlike sets, lists typically allow duplicate elements.",
+      "type": "interface",
+      "module": "java.util",
+      "members": {
+        "of": { "signature": "static <E> List<E> of(E... elements)", "description": "(Java 9+) Returns an unmodifiable list containing the specified elements. Throws NullPointerException if any element is null.", "type": "method" },
+        "copyOf": { "signature": "static <E> List<E> copyOf(Collection<? extends E> coll)", "description": "(Java 10+) Returns an unmodifiable List containing the elements of the given Collection, in its iteration order.", "type": "method" }
+      }
+    },
+    "Map": {
+      "signature": "public interface Map<K,V>",
+      "description": "An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value. This interface takes the place of the Dictionary class.",
+      "type": "interface",
+      "module": "java.util",
+      "members": {
+        "of": { "signature": "static <K,V> Map<K,V> of(K k1, V v1, ...)", "description": "(Java 9+) Returns an unmodifiable map containing the specified key-value pairs. Does not permit null keys or values.", "type": "method" },
+        "ofEntries": { "signature": "static <K,V> Map<K,V> ofEntries(Map.Entry<? extends K, ? extends V>... entries)", "description": "(Java 9+) Returns an unmodifiable map containing keys and values extracted from the given entries. Does not permit duplicate keys.", "type": "method" },
+        "entry": { "signature": "static <K,V> Map.Entry<K,V> entry(K k, V v)", "description": "(Java 9+) Returns an unmodifiable Map.Entry containing the given key and value. These entries are suitable for populating Map instances using the Map.ofEntries() method.", "type": "method" }
+      }
+    },
+    "CompletableFuture": {
+      "signature": "public class CompletableFuture<T> implements Future<T>, CompletionStage<T>",
+      "description": "A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion. Provides a rich API for composing asynchronous operations.",
+      "type": "class",
+      "module": "java.util.concurrent",
+      "members": {
+        "supplyAsync": { "signature": "public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)", "description": "Returns a new CompletableFuture that is asynchronously completed by a task running in the ForkJoinPool.commonPool() with the value obtained by calling the given Supplier.", "type": "method" },
+        "thenApply": { "signature": "public <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn)", "description": "Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied function.", "type": "method" },
+        "thenAccept": { "signature": "public CompletableFuture<Void> thenAccept(Consumer<? super T> action)", "description": "Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied action.", "type": "method" },
+        "thenRun": { "signature": "public CompletableFuture<Void> thenRun(Runnable action)", "description": "Returns a new CompletionStage that, when this stage completes normally, executes the given action. The result is not passed to the action.", "type": "method" },
+        "thenCompose": { "signature": "public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn)", "description": "Returns a new CompletionStage that is completed with the same value as the CompletionStage returned by the given function. Equivalent to flatMap for futures.", "type": "method" },
+        "thenCombine": { "signature": "public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other, BiFunction<? super T, ? super U, ? extends V> fn)", "description": "Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed with the two results as arguments to the supplied function.", "type": "method" },
+        "exceptionally": { "signature": "public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)", "description": "Returns a new CompletableFuture that, when this stage completes exceptionally, is executed with the exception as the argument to the supplied function.", "type": "method" },
+        "join": { "signature": "public T join()", "description": "Returns the result value when complete, or throws an (unchecked) exception if completed exceptionally. Unlike get(), does not throw checked exceptions.", "type": "method" },
+        "get": { "signature": "public T get() throws InterruptedException, ExecutionException", "description": "Waits if necessary for this future to complete, and then returns its result. Throws ExecutionException if the computation threw an exception.", "type": "method" },
+        "allOf": { "signature": "public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)", "description": "Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete.", "type": "method" },
+        "anyOf": { "signature": "public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)", "description": "Returns a new CompletableFuture that is completed when any of the given CompletableFutures complete, with the same result.", "type": "method" },
+        "completedFuture": { "signature": "public static <U> CompletableFuture<U> completedFuture(U value)", "description": "Returns a new CompletableFuture that is already completed with the given value.", "type": "method" }
+      }
+    }
+  }
+}

package/data/defination/javascript.json

@@ -0,0 +1,265 @@
+{
+  "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"
+    }
+  }
+}