@enjoys/context-engine 1.1.0 → 1.1.2

package/data/hover/flow9.json

@@ -0,0 +1,75 @@
+{
+  "language": "flow9",
+  "hovers": {
+    "import": {
+      "contents": [
+        {
+          "value": "**import** — Flow9 keyword."
+        }
+      ]
+    },
+    "export": {
+      "contents": [
+        {
+          "value": "**export** — Flow9 keyword."
+        }
+      ]
+    },
+    "if": {
+      "contents": [
+        {
+          "value": "**if** — Flow9 keyword."
+        }
+      ]
+    },
+    "else": {
+      "contents": [
+        {
+          "value": "**else** — Flow9 keyword."
+        }
+      ]
+    },
+    "switch": {
+      "contents": [
+        {
+          "value": "**switch** — Flow9 keyword."
+        }
+      ]
+    },
+    "println": {
+      "contents": [
+        {
+          "value": "**println** — Built-in function/command in Flow9."
+        }
+      ]
+    },
+    "i2s": {
+      "contents": [
+        {
+          "value": "**i2s** — Built-in function/command in Flow9."
+        }
+      ]
+    },
+    "d2s": {
+      "contents": [
+        {
+          "value": "**d2s** — Built-in function/command in Flow9."
+        }
+      ]
+    },
+    "s2i": {
+      "contents": [
+        {
+          "value": "**s2i** — Built-in function/command in Flow9."
+        }
+      ]
+    },
+    "s2d": {
+      "contents": [
+        {
+          "value": "**s2d** — Built-in function/command in Flow9."
+        }
+      ]
+    }
+  }
+}

package/data/hover/freemarker2.json

@@ -0,0 +1,75 @@
+{
+  "language": "freemarker2",
+  "hovers": {
+    "if": {
+      "contents": [
+        {
+          "value": "**if** — FreeMarker keyword."
+        }
+      ]
+    },
+    "else": {
+      "contents": [
+        {
+          "value": "**else** — FreeMarker keyword."
+        }
+      ]
+    },
+    "elseif": {
+      "contents": [
+        {
+          "value": "**elseif** — FreeMarker keyword."
+        }
+      ]
+    },
+    "list": {
+      "contents": [
+        {
+          "value": "**list** — FreeMarker keyword."
+        }
+      ]
+    },
+    "as": {
+      "contents": [
+        {
+          "value": "**as** — FreeMarker keyword."
+        }
+      ]
+    },
+    "?string": {
+      "contents": [
+        {
+          "value": "**?string** — Built-in function/command in FreeMarker."
+        }
+      ]
+    },
+    "?number": {
+      "contents": [
+        {
+          "value": "**?number** — Built-in function/command in FreeMarker."
+        }
+      ]
+    },
+    "?c": {
+      "contents": [
+        {
+          "value": "**?c** — Built-in function/command in FreeMarker."
+        }
+      ]
+    },
+    "?html": {
+      "contents": [
+        {
+          "value": "**?html** — Built-in function/command in FreeMarker."
+        }
+      ]
+    },
+    "?xml": {
+      "contents": [
+        {
+          "value": "**?xml** — Built-in function/command in FreeMarker."
+        }
+      ]
+    }
+  }
+}

package/data/hover/julia.json

@@ -0,0 +1,75 @@
+{
+  "language": "julia",
+  "hovers": {
+    "function": {
+      "contents": [
+        {
+          "value": "**function** — Julia keyword."
+        }
+      ]
+    },
+    "end": {
+      "contents": [
+        {
+          "value": "**end** — Julia keyword."
+        }
+      ]
+    },
+    "if": {
+      "contents": [
+        {
+          "value": "**if** — Julia keyword."
+        }
+      ]
+    },
+    "elseif": {
+      "contents": [
+        {
+          "value": "**elseif** — Julia keyword."
+        }
+      ]
+    },
+    "else": {
+      "contents": [
+        {
+          "value": "**else** — Julia keyword."
+        }
+      ]
+    },
+    "println": {
+      "contents": [
+        {
+          "value": "**println** — Built-in function/command in Julia."
+        }
+      ]
+    },
+    "print": {
+      "contents": [
+        {
+          "value": "**print** — Built-in function/command in Julia."
+        }
+      ]
+    },
+    "typeof": {
+      "contents": [
+        {
+          "value": "**typeof** — Built-in function/command in Julia."
+        }
+      ]
+    },
+    "sizeof": {
+      "contents": [
+        {
+          "value": "**sizeof** — Built-in function/command in Julia."
+        }
+      ]
+    },
+    "length": {
+      "contents": [
+        {
+          "value": "**length** — Built-in function/command in Julia."
+        }
+      ]
+    }
+  }
+}

package/data/hover/kotlin.json

@@ -0,0 +1,341 @@
+{
+  "language": "kotlin",
+  "hovers": {
+    "println": {
+      "contents": [{"value": "```kotlin\nfun println(message: Any?): Unit\n```\nPrints the given message and a newline to standard output."}]
+    },
+    "print": {
+      "contents": [{"value": "```kotlin\nfun print(message: Any?): Unit\n```\nPrints the given message to standard output without a newline."}]
+    },
+    "readLine": {
+      "contents": [{"value": "```kotlin\nfun readLine(): String?\n```\nReads a line from standard input, returns null if EOF reached."}]
+    },
+    "listOf": {
+      "contents": [{"value": "```kotlin\nfun <T> listOf(vararg elements: T): List<T>\n```\nReturns a new read-only list of given elements."}]
+    },
+    "mutableListOf": {
+      "contents": [{"value": "```kotlin\nfun <T> mutableListOf(vararg elements: T): MutableList<T>\n```\nReturns a new MutableList with the given elements."}]
+    },
+    "mapOf": {
+      "contents": [{"value": "```kotlin\nfun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>\n```\nReturns a new read-only map with the specified key-value pairs."}]
+    },
+    "mutableMapOf": {
+      "contents": [{"value": "```kotlin\nfun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>\n```\nReturns a new MutableMap with the specified key-value pairs."}]
+    },
+    "setOf": {
+      "contents": [{"value": "```kotlin\nfun <T> setOf(vararg elements: T): Set<T>\n```\nReturns a new read-only set with the given elements."}]
+    },
+    "mutableSetOf": {
+      "contents": [{"value": "```kotlin\nfun <T> mutableSetOf(vararg elements: T): MutableSet<T>\n```\nReturns a new MutableSet with the given elements."}]
+    },
+    "arrayOf": {
+      "contents": [{"value": "```kotlin\nfun <T> arrayOf(vararg elements: T): Array<T>\n```\nReturns an array containing the specified elements."}]
+    },
+    "intArrayOf": {
+      "contents": [{"value": "```kotlin\nfun intArrayOf(vararg elements: Int): IntArray\n```\nReturns an IntArray containing the specified elements."}]
+    },
+    "let": {
+      "contents": [{"value": "```kotlin\nfun <T, R> T.let(block: (T) -> R): R\n```\nCalls the specified function block with `this` value as its argument and returns its result. Often used for null checks and transformations."}]
+    },
+    "run": {
+      "contents": [{"value": "```kotlin\nfun <T, R> T.run(block: T.() -> R): R\n```\nCalls the specified function block with `this` value as its receiver and returns its result."}]
+    },
+    "with": {
+      "contents": [{"value": "```kotlin\nfun <T, R> with(receiver: T, block: T.() -> R): R\n```\nCalls the specified function block with the given receiver as `this` and returns its result."}]
+    },
+    "apply": {
+      "contents": [{"value": "```kotlin\nfun <T> T.apply(block: T.() -> Unit): T\n```\nCalls the specified function block with `this` as its receiver and returns `this`. Used for object configuration."}]
+    },
+    "also": {
+      "contents": [{"value": "```kotlin\nfun <T> T.also(block: (T) -> Unit): T\n```\nCalls the specified function block with `this` as its argument and returns `this`. Used for performing side effects."}]
+    },
+    "takeIf": {
+      "contents": [{"value": "```kotlin\nfun <T> T.takeIf(predicate: (T) -> Boolean): T?\n```\nReturns `this` if it satisfies the given predicate or null if it doesn't."}]
+    },
+    "takeUnless": {
+      "contents": [{"value": "```kotlin\nfun <T> T.takeUnless(predicate: (T) -> Boolean): T?\n```\nReturns `this` if it does NOT satisfy the given predicate or null if it does."}]
+    },
+    "repeat": {
+      "contents": [{"value": "```kotlin\nfun repeat(times: Int, action: (Int) -> Unit)\n```\nExecutes the given function action the specified number of times."}]
+    },
+    "require": {
+      "contents": [{"value": "```kotlin\nfun require(value: Boolean, lazyMessage: () -> Any): Unit\n```\nThrows an IllegalArgumentException if the value is false."}]
+    },
+    "check": {
+      "contents": [{"value": "```kotlin\nfun check(value: Boolean, lazyMessage: () -> Any): Unit\n```\nThrows an IllegalStateException if the value is false."}]
+    },
+    "error": {
+      "contents": [{"value": "```kotlin\nfun error(message: Any): Nothing\n```\nThrows an IllegalStateException with the given message."}]
+    },
+    "TODO": {
+      "contents": [{"value": "```kotlin\nfun TODO(reason: String): Nothing\n```\nAlways throws NotImplementedError stating that operation is not implemented."}]
+    },
+    "lazy": {
+      "contents": [{"value": "```kotlin\nfun <T> lazy(initializer: () -> T): Lazy<T>\n```\nCreates a new Lazy instance that uses the specified initialization function. Value computed on first access."}]
+    },
+    "sequence": {
+      "contents": [{"value": "```kotlin\nfun <T> sequence(block: suspend SequenceScope<T>.() -> Unit): Sequence<T>\n```\nBuilds a Sequence lazily yielding values one by one."}]
+    },
+    "buildList": {
+      "contents": [{"value": "```kotlin\nfun <E> buildList(builderAction: MutableList<E>.() -> Unit): List<E>\n```\nBuilds a new read-only List by populating a MutableList using the given builder action."}]
+    },
+    "buildMap": {
+      "contents": [{"value": "```kotlin\nfun <K, V> buildMap(builderAction: MutableMap<K, V>.() -> Unit): Map<K, V>\n```\nBuilds a new read-only Map by populating a MutableMap using the given builder action."}]
+    },
+    "buildSet": {
+      "contents": [{"value": "```kotlin\nfun <E> buildSet(builderAction: MutableSet<E>.() -> Unit): Set<E>\n```\nBuilds a new read-only Set by populating a MutableSet using the given builder action."}]
+    },
+    "emptyList": {
+      "contents": [{"value": "```kotlin\nfun <T> emptyList(): List<T>\n```\nReturns an empty read-only list."}]
+    },
+    "emptyMap": {
+      "contents": [{"value": "```kotlin\nfun <K, V> emptyMap(): Map<K, V>\n```\nReturns an empty read-only map."}]
+    },
+    "emptySet": {
+      "contents": [{"value": "```kotlin\nfun <T> emptySet(): Set<T>\n```\nReturns an empty read-only set."}]
+    },
+    "forEach": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.forEach(action: (T) -> Unit)\n```\nPerforms the given action on each element."}]
+    },
+    "map": {
+      "contents": [{"value": "```kotlin\nfun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>\n```\nReturns a list containing the results of applying the given transform function to each element."}]
+    },
+    "filter": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>\n```\nReturns a list containing only elements matching the given predicate."}]
+    },
+    "flatMap": {
+      "contents": [{"value": "```kotlin\nfun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>\n```\nReturns a single list of all elements yielded from results of transform function on each element."}]
+    },
+    "reduce": {
+      "contents": [{"value": "```kotlin\nfun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S\n```\nAccumulates value starting with the first element and applying operation from left to right."}]
+    },
+    "fold": {
+      "contents": [{"value": "```kotlin\nfun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R\n```\nAccumulates value starting with initial value and applying operation from left to right."}]
+    },
+    "groupBy": {
+      "contents": [{"value": "```kotlin\nfun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>\n```\nGroups elements of the collection by the key returned by the given function."}]
+    },
+    "sortedBy": {
+      "contents": [{"value": "```kotlin\nfun <T, R : Comparable<R>> Iterable<T>.sortedBy(selector: (T) -> R?): List<T>\n```\nReturns a list of all elements sorted according to natural sort order of the value returned by the selector."}]
+    },
+    "associate": {
+      "contents": [{"value": "```kotlin\nfun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>\n```\nReturns a Map containing key-value pairs provided by transform function applied to elements."}]
+    },
+    "first": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.first(): T\n```\nReturns the first element. Throws NoSuchElementException if the collection is empty."}]
+    },
+    "firstOrNull": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.firstOrNull(): T?\n```\nReturns the first element, or null if the collection is empty."}]
+    },
+    "any": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean\n```\nReturns true if at least one element matches the given predicate."}]
+    },
+    "all": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean\n```\nReturns true if all elements match the given predicate."}]
+    },
+    "none": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean\n```\nReturns true if no elements match the given predicate."}]
+    },
+    "count": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.count(): Int\n```\nReturns the number of elements in the collection."}]
+    },
+    "joinToString": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.joinToString(separator: CharSequence = \", \"): String\n```\nCreates a string from all the elements separated using separator."}]
+    },
+    "toList": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.toList(): List<T>\n```\nReturns a List containing all elements."}]
+    },
+    "toMutableList": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.toMutableList(): MutableList<T>\n```\nReturns a MutableList filled with all elements of this collection."}]
+    },
+    "toSet": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.toSet(): Set<T>\n```\nReturns a Set of all elements."}]
+    },
+    "toMap": {
+      "contents": [{"value": "```kotlin\nfun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>\n```\nReturns a new map containing all key-value pairs from the given collection of pairs."}]
+    },
+    "toInt": {
+      "contents": [{"value": "```kotlin\nfun String.toInt(): Int\n```\nParses the string as a signed Int number and returns the result. Throws NumberFormatException if not valid."}]
+    },
+    "toDouble": {
+      "contents": [{"value": "```kotlin\nfun String.toDouble(): Double\n```\nParses the string as a Double number and returns the result. Throws NumberFormatException if not valid."}]
+    },
+    "toIntOrNull": {
+      "contents": [{"value": "```kotlin\nfun String.toIntOrNull(): Int?\n```\nParses the string as a signed Int number and returns the result or null if the string is not a valid integer."}]
+    },
+    "runBlocking": {
+      "contents": [{"value": "```kotlin\nfun <T> runBlocking(block: suspend CoroutineScope.() -> T): T\n```\nRuns a new coroutine and blocks the current thread until its completion."}]
+    },
+    "launch": {
+      "contents": [{"value": "```kotlin\nfun CoroutineScope.launch(block: suspend CoroutineScope.() -> Unit): Job\n```\nLaunches a new coroutine without blocking the current thread and returns a Job."}]
+    },
+    "async": {
+      "contents": [{"value": "```kotlin\nfun <T> CoroutineScope.async(block: suspend CoroutineScope.() -> T): Deferred<T>\n```\nCreates a coroutine and returns its future result as an implementation of Deferred."}]
+    },
+    "withContext": {
+      "contents": [{"value": "```kotlin\nsuspend fun <T> withContext(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T\n```\nCalls the specified suspending block with a given coroutine context and returns the result."}]
+    },
+    "delay": {
+      "contents": [{"value": "```kotlin\nsuspend fun delay(timeMillis: Long)\n```\nDelays coroutine for a given time without blocking a thread."}]
+    },
+    "fun": {
+      "contents": [{"value": "```kotlin\nfun name(params): ReturnType { }\n```\n**Keyword** — Declares a function."}]
+    },
+    "val": {
+      "contents": [{"value": "```kotlin\nval name: Type = value\n```\n**Keyword** — Declares a read-only (immutable) property or local variable."}]
+    },
+    "var": {
+      "contents": [{"value": "```kotlin\nvar name: Type = value\n```\n**Keyword** — Declares a mutable property or local variable."}]
+    },
+    "class": {
+      "contents": [{"value": "```kotlin\nclass Name(params) { }\n```\n**Keyword** — Declares a class."}]
+    },
+    "object": {
+      "contents": [{"value": "```kotlin\nobject Name { }\n```\n**Keyword** — Declares a singleton object or object expression."}]
+    },
+    "interface": {
+      "contents": [{"value": "```kotlin\ninterface Name { }\n```\n**Keyword** — Declares an interface that classes can implement."}]
+    },
+    "when": {
+      "contents": [{"value": "```kotlin\nwhen (value) {\n    pattern -> result\n    else -> default\n}\n```\n**Keyword** — Pattern matching expression, similar to switch in other languages."}]
+    },
+    "if": {
+      "contents": [{"value": "```kotlin\nif (condition) { } else { }\n```\n**Keyword** — Conditional expression. Can also be used as an expression that returns a value."}]
+    },
+    "for": {
+      "contents": [{"value": "```kotlin\nfor (item in collection) { }\n```\n**Keyword** — For loop that iterates through anything that provides an iterator."}]
+    },
+    "while": {
+      "contents": [{"value": "```kotlin\nwhile (condition) { }\n```\n**Keyword** — Loop that executes body while condition is true."}]
+    },
+    "return": {
+      "contents": [{"value": "**Keyword** — Returns from the nearest enclosing function. Supports labeled returns with `return@label`."}]
+    },
+    "throw": {
+      "contents": [{"value": "```kotlin\nthrow Exception(\"message\")\n```\n**Keyword** — Throws an exception. Throw expression has type Nothing."}]
+    },
+    "try": {
+      "contents": [{"value": "```kotlin\ntry { } catch (e: Exception) { } finally { }\n```\n**Keyword** — Begins a try-catch exception handling block. Can also be used as an expression."}]
+    },
+    "catch": {
+      "contents": [{"value": "**Keyword** — Handles an exception type in a try block. Kotlin does not have checked exceptions."}]
+    },
+    "finally": {
+      "contents": [{"value": "**Keyword** — Block that always executes after try/catch, regardless of whether an exception was thrown."}]
+    },
+    "suspend": {
+      "contents": [{"value": "**Keyword** — Marks a function or lambda as suspending (callable from within coroutines)."}]
+    },
+    "data": {
+      "contents": [{"value": "```kotlin\ndata class Name(val prop: Type)\n```\n**Keyword** — Marks a class as a data class. Auto-generates equals(), hashCode(), toString(), copy(), and componentN()."}]
+    },
+    "sealed": {
+      "contents": [{"value": "```kotlin\nsealed class/interface Name { }\n```\n**Keyword** — Restricts class hierarchy. All direct subclasses must be in the same package."}]
+    },
+    "enum": {
+      "contents": [{"value": "```kotlin\nenum class Name { VALUE1, VALUE2 }\n```\n**Keyword** — Declares an enum class with a fixed set of instances."}]
+    },
+    "override": {
+      "contents": [{"value": "**Keyword** — Marks a member as overriding a superclass member or interface member. Required in Kotlin."}]
+    },
+    "open": {
+      "contents": [{"value": "**Keyword** — Allows a class to be inherited from or a member to be overridden. Classes are final by default."}]
+    },
+    "abstract": {
+      "contents": [{"value": "**Keyword** — Marks a class or member as abstract. Abstract members have no implementation and must be overridden."}]
+    },
+    "companion": {
+      "contents": [{"value": "```kotlin\ncompanion object { }\n```\n**Keyword** — Declares a companion object inside a class, providing static-like members."}]
+    },
+    "inline": {
+      "contents": [{"value": "**Keyword** — Requests the compiler to inline the function and its lambda parameters at call sites."}]
+    },
+    "infix": {
+      "contents": [{"value": "**Keyword** — Allows calling a function with infix notation: `a func b` instead of `a.func(b)`."}]
+    },
+    "operator": {
+      "contents": [{"value": "**Keyword** — Marks a function as an operator overload (e.g., plus, get, invoke)."}]
+    },
+    "typealias": {
+      "contents": [{"value": "```kotlin\ntypealias Name = ExistingType\n```\n**Keyword** — Provides alternative names for existing types."}]
+    },
+    "lateinit": {
+      "contents": [{"value": "```kotlin\nlateinit var name: Type\n```\n**Keyword** — Allows initializing a non-null var property outside of a constructor body."}]
+    },
+    "const": {
+      "contents": [{"value": "```kotlin\nconst val NAME = value\n```\n**Keyword** — Marks a property as a compile-time constant. Must be top-level or companion object val of primitive/String."}]
+    },
+    "Int": {
+      "contents": [{"value": "```kotlin\nclass Int : Number, Comparable<Int>\n```\nRepresents a 32-bit signed integer. Range: -2,147,483,648 to 2,147,483,647."}]
+    },
+    "Long": {
+      "contents": [{"value": "```kotlin\nclass Long : Number, Comparable<Long>\n```\nRepresents a 64-bit signed integer."}]
+    },
+    "Double": {
+      "contents": [{"value": "```kotlin\nclass Double : Number, Comparable<Double>\n```\nRepresents a double-precision 64-bit IEEE 754 floating point number."}]
+    },
+    "Float": {
+      "contents": [{"value": "```kotlin\nclass Float : Number, Comparable<Float>\n```\nRepresents a single-precision 32-bit IEEE 754 floating point number."}]
+    },
+    "Boolean": {
+      "contents": [{"value": "```kotlin\nclass Boolean : Comparable<Boolean>\n```\nRepresents a value which is either `true` or `false`."}]
+    },
+    "String": {
+      "contents": [{"value": "```kotlin\nclass String : Comparable<String>, CharSequence\n```\nRepresents an array of characters. Strings are immutable in Kotlin."}]
+    },
+    "Char": {
+      "contents": [{"value": "```kotlin\nclass Char : Comparable<Char>\n```\nRepresents a 16-bit Unicode character."}]
+    },
+    "Unit": {
+      "contents": [{"value": "```kotlin\nobject Unit\n```\nThe type with only one value: the Unit object. Corresponds to `void` in Java."}]
+    },
+    "Nothing": {
+      "contents": [{"value": "```kotlin\nclass Nothing\n```\nNothing has no instances. Used as return type of functions that never return (e.g., throw, infinite loops)."}]
+    },
+    "Any": {
+      "contents": [{"value": "```kotlin\nopen class Any\n```\nThe root of the Kotlin class hierarchy. Every Kotlin class has `Any` as a superclass."}]
+    },
+    "Array": {
+      "contents": [{"value": "```kotlin\nclass Array<T>\n```\nRepresents an array. Use `arrayOf()` to create an array."}]
+    },
+    "List": {
+      "contents": [{"value": "```kotlin\ninterface List<out E> : Collection<E>\n```\nA generic ordered collection of elements. Read-only; use MutableList for modification."}]
+    },
+    "MutableList": {
+      "contents": [{"value": "```kotlin\ninterface MutableList<E> : List<E>, MutableCollection<E>\n```\nA generic ordered mutable collection supporting add and remove operations."}]
+    },
+    "Map": {
+      "contents": [{"value": "```kotlin\ninterface Map<K, out V>\n```\nA collection that holds pairs of objects (keys and values). Read-only."}]
+    },
+    "MutableMap": {
+      "contents": [{"value": "```kotlin\ninterface MutableMap<K, V> : Map<K, V>\n```\nA modifiable collection that holds pairs of objects and supports adding/removing entries."}]
+    },
+    "Set": {
+      "contents": [{"value": "```kotlin\ninterface Set<out E> : Collection<E>\n```\nA generic unordered collection that does not support duplicate elements. Read-only."}]
+    },
+    "MutableSet": {
+      "contents": [{"value": "```kotlin\ninterface MutableSet<E> : Set<E>, MutableCollection<E>\n```\nA modifiable collection of unique elements supporting add and remove operations."}]
+    },
+    "Pair": {
+      "contents": [{"value": "```kotlin\ndata class Pair<out A, out B>(val first: A, val second: B)\n```\nRepresents a generic pair of two values. Create with `to` infix function."}]
+    },
+    "Triple": {
+      "contents": [{"value": "```kotlin\ndata class Triple<out A, out B, out C>(val first: A, val second: B, val third: C)\n```\nRepresents a triad of three values."}]
+    },
+    "Sequence": {
+      "contents": [{"value": "```kotlin\ninterface Sequence<out T>\n```\nA sequence that returns values lazily through its iterator."}]
+    },
+    "Regex": {
+      "contents": [{"value": "```kotlin\nclass Regex\n```\nRepresents an immutable regular expression. Create with `Regex(pattern)` or `\"pattern\".toRegex()`."}]
+    },
+    "Comparable": {
+      "contents": [{"value": "```kotlin\ninterface Comparable<in T>\n```\nClasses that implement this interface have a defined total ordering between their instances."}]
+    },
+    "Iterable": {
+      "contents": [{"value": "```kotlin\ninterface Iterable<out T>\n```\nClasses that inherit from this interface can be represented as a sequence of elements that can be iterated over."}]
+    },
+    "Collection": {
+      "contents": [{"value": "```kotlin\ninterface Collection<out E> : Iterable<E>\n```\nA generic collection of elements providing read-only methods."}]
+    }
+  }
+}

package/data/hover/less.json

@@ -0,0 +1,75 @@
+{
+  "language": "less",
+  "hovers": {
+    "@import": {
+      "contents": [
+        {
+          "value": "**@import** — Less keyword."
+        }
+      ]
+    },
+    "@media": {
+      "contents": [
+        {
+          "value": "**@media** — Less keyword."
+        }
+      ]
+    },
+    "@font-face": {
+      "contents": [
+        {
+          "value": "**@font-face** — Less keyword."
+        }
+      ]
+    },
+    "@keyframes": {
+      "contents": [
+        {
+          "value": "**@keyframes** — Less keyword."
+        }
+      ]
+    },
+    "@charset": {
+      "contents": [
+        {
+          "value": "**@charset** — Less keyword."
+        }
+      ]
+    },
+    "lighten": {
+      "contents": [
+        {
+          "value": "**lighten** — Built-in function/command in Less."
+        }
+      ]
+    },
+    "darken": {
+      "contents": [
+        {
+          "value": "**darken** — Built-in function/command in Less."
+        }
+      ]
+    },
+    "saturate": {
+      "contents": [
+        {
+          "value": "**saturate** — Built-in function/command in Less."
+        }
+      ]
+    },
+    "desaturate": {
+      "contents": [
+        {
+          "value": "**desaturate** — Built-in function/command in Less."
+        }
+      ]
+    },
+    "fadein": {
+      "contents": [
+        {
+          "value": "**fadein** — Built-in function/command in Less."
+        }
+      ]
+    }
+  }
+}