@enjoys/context-engine 1.1.2 → 1.3.1

package/data/signatureHelp/kotlin.json

@@ -0,0 +1,108 @@
+{
+  "language": "kotlin",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "println(message: Any?): Unit",
+      "documentation": { "value": "Prints the given message and a newline to the standard output stream." },
+      "parameters": [
+        { "label": "message", "documentation": { "value": "The value to print. Calls toString() on the argument." } }
+      ]
+    },
+    {
+      "label": "listOf(vararg elements: T): List<T>",
+      "documentation": { "value": "Returns an immutable list containing the given elements." },
+      "parameters": [
+        { "label": "elements", "documentation": { "value": "The elements to include in the list." } }
+      ]
+    },
+    {
+      "label": "mapOf(vararg pairs: Pair<K, V>): Map<K, V>",
+      "documentation": { "value": "Returns an immutable map containing the given key-value pairs." },
+      "parameters": [
+        { "label": "pairs", "documentation": { "value": "Key-value pairs created with the 'to' infix function." } }
+      ]
+    },
+    {
+      "label": "setOf(vararg elements: T): Set<T>",
+      "documentation": { "value": "Returns an immutable set containing the given distinct elements." },
+      "parameters": [
+        { "label": "elements", "documentation": { "value": "The elements to include in the set." } }
+      ]
+    },
+    {
+      "label": "String.toInt(radix: Int = 10): Int",
+      "documentation": { "value": "Parses the string as an Int number in the specified radix. Throws NumberFormatException if invalid." },
+      "parameters": [
+        { "label": "radix", "documentation": { "value": "The radix (base) to use for parsing. Defaults to 10." } }
+      ]
+    },
+    {
+      "label": "String.toDouble(): Double",
+      "documentation": { "value": "Parses the string as a Double number. Throws NumberFormatException if the string is not a valid representation." },
+      "parameters": []
+    },
+    {
+      "label": "Iterable<T>.map(transform: (T) -> R): List<R>",
+      "documentation": { "value": "Returns a list containing the results of applying the given transform function to each element in the original collection." },
+      "parameters": [
+        { "label": "transform", "documentation": { "value": "A function to apply to each element." } }
+      ]
+    },
+    {
+      "label": "Iterable<T>.filter(predicate: (T) -> Boolean): List<T>",
+      "documentation": { "value": "Returns a list containing only elements matching the given predicate." },
+      "parameters": [
+        { "label": "predicate", "documentation": { "value": "A function that returns true for elements to include." } }
+      ]
+    },
+    {
+      "label": "mutableListOf(vararg elements: T): MutableList<T>",
+      "documentation": { "value": "Returns a new MutableList (ArrayList) with the given elements." },
+      "parameters": [
+        { "label": "elements", "documentation": { "value": "The initial elements for the mutable list." } }
+      ]
+    },
+    {
+      "label": "Pair(first: A, second: B): Pair<A, B>",
+      "documentation": { "value": "Creates a tuple of two values." },
+      "parameters": [
+        { "label": "first", "documentation": { "value": "The first value of the pair." } },
+        { "label": "second", "documentation": { "value": "The second value of the pair." } }
+      ]
+    },
+    {
+      "label": "Triple(first: A, second: B, third: C): Triple<A, B, C>",
+      "documentation": { "value": "Creates a tuple of three values." },
+      "parameters": [
+        { "label": "first", "documentation": { "value": "The first value." } },
+        { "label": "second", "documentation": { "value": "The second value." } },
+        { "label": "third", "documentation": { "value": "The third value." } }
+      ]
+    },
+    {
+      "label": "require(value: Boolean, lazyMessage?: () -> Any): Unit",
+      "documentation": { "value": "Throws an IllegalArgumentException if the value is false." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The condition to check." } },
+        { "label": "lazyMessage?", "documentation": { "value": "A lambda producing the exception message if the check fails." } }
+      ]
+    },
+    {
+      "label": "check(value: Boolean, lazyMessage?: () -> Any): Unit",
+      "documentation": { "value": "Throws an IllegalStateException if the value is false." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The condition to check." } },
+        { "label": "lazyMessage?", "documentation": { "value": "A lambda producing the exception message if the check fails." } }
+      ]
+    },
+    {
+      "label": "lazy(initializer: () -> T): Lazy<T>",
+      "documentation": { "value": "Creates a Lazy instance that uses the given initializer function. The value is computed on first access and cached." },
+      "parameters": [
+        { "label": "initializer", "documentation": { "value": "The function to compute the lazy value on first access." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/less.json

@@ -0,0 +1,85 @@
+{
+  "language": "less",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": ".mixin(@param1, @param2, ...)",
+      "documentation": { "value": "Calls a mixin with the specified arguments. Mixins allow reusing groups of CSS properties." },
+      "parameters": [
+        { "label": "@param1", "documentation": { "value": "The first parameter passed to the mixin." } },
+        { "label": "@param2", "documentation": { "value": "The second parameter passed to the mixin." } }
+      ]
+    },
+    {
+      "label": "color(@string): color",
+      "documentation": { "value": "Parses a color string and returns a color value. Accepts hex, rgb, rgba, hsl, and named colors." },
+      "parameters": [
+        { "label": "@string", "documentation": { "value": "A string representing a color (e.g., '#ff0000', 'red')." } }
+      ]
+    },
+    {
+      "label": "darken(@color, @amount): color",
+      "documentation": { "value": "Decreases the lightness of a color by the specified percentage." },
+      "parameters": [
+        { "label": "@color", "documentation": { "value": "The base color to darken." } },
+        { "label": "@amount", "documentation": { "value": "The percentage to decrease lightness (0-100%)." } }
+      ]
+    },
+    {
+      "label": "lighten(@color, @amount): color",
+      "documentation": { "value": "Increases the lightness of a color by the specified percentage." },
+      "parameters": [
+        { "label": "@color", "documentation": { "value": "The base color to lighten." } },
+        { "label": "@amount", "documentation": { "value": "The percentage to increase lightness (0-100%)." } }
+      ]
+    },
+    {
+      "label": "percentage(@number): percentage",
+      "documentation": { "value": "Converts a unitless number into a percentage. For example, percentage(0.5) returns 50%." },
+      "parameters": [
+        { "label": "@number", "documentation": { "value": "A unitless number to convert (e.g., 0.5 becomes 50%)." } }
+      ]
+    },
+    {
+      "label": "unit(@dimension, @unit?): number",
+      "documentation": { "value": "Removes or changes the unit of a dimension. If @unit is specified, changes to that unit." },
+      "parameters": [
+        { "label": "@dimension", "documentation": { "value": "A number with a unit (e.g., 5px)." } },
+        { "label": "@unit?", "documentation": { "value": "Optional target unit string (e.g., 'rem', 'em')." } }
+      ]
+    },
+    {
+      "label": "length(@list): number",
+      "documentation": { "value": "Returns the number of elements in a comma or space separated list." },
+      "parameters": [
+        { "label": "@list", "documentation": { "value": "A Less list value." } }
+      ]
+    },
+    {
+      "label": "extract(@list, @index): value",
+      "documentation": { "value": "Returns the value at the specified position in a list. Index is 1-based." },
+      "parameters": [
+        { "label": "@list", "documentation": { "value": "A Less list value." } },
+        { "label": "@index", "documentation": { "value": "The 1-based index of the element to extract." } }
+      ]
+    },
+    {
+      "label": "if(@condition, @trueValue, @falseValue): value",
+      "documentation": { "value": "Returns @trueValue if @condition evaluates to true, otherwise returns @falseValue." },
+      "parameters": [
+        { "label": "@condition", "documentation": { "value": "A boolean expression to evaluate." } },
+        { "label": "@trueValue", "documentation": { "value": "Value returned when the condition is true." } },
+        { "label": "@falseValue", "documentation": { "value": "Value returned when the condition is false." } }
+      ]
+    },
+    {
+      "label": "each(@list, @ruleset): void",
+      "documentation": { "value": "Iterates over a list, applying the ruleset for each element. Binds @value, @key, and @index." },
+      "parameters": [
+        { "label": "@list", "documentation": { "value": "A Less list or map to iterate over." } },
+        { "label": "@ruleset", "documentation": { "value": "A detached ruleset to apply for each element." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/lexon.json

@@ -0,0 +1,66 @@
+{
+  "language": "lexon",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "LEX contract_name.",
+      "documentation": { "value": "Declares the beginning of a Lexon legal contract with the given name." },
+      "parameters": [
+        { "label": "contract_name", "documentation": { "value": "The name of the contract." } }
+      ]
+    },
+    {
+      "label": "CLAUSE clause_name.",
+      "documentation": { "value": "Defines a named clause within the contract." },
+      "parameters": [
+        { "label": "clause_name", "documentation": { "value": "The name of the clause." } }
+      ]
+    },
+    {
+      "label": "LEXON version_number",
+      "documentation": { "value": "Specifies the Lexon language version for the contract." },
+      "parameters": [
+        { "label": "version_number", "documentation": { "value": "The Lexon version (e.g., 0.2.1)." } }
+      ]
+    },
+    {
+      "label": "party IS A person.",
+      "documentation": { "value": "Declares a party (participant) in the contract as a person entity." },
+      "parameters": [
+        { "label": "party", "documentation": { "value": "The role name for this party in the contract." } }
+      ]
+    },
+    {
+      "label": "amount IS AN amount.",
+      "documentation": { "value": "Declares a value variable as an amount (monetary or numeric quantity)." },
+      "parameters": [
+        { "label": "amount", "documentation": { "value": "The name of the amount variable." } }
+      ]
+    },
+    {
+      "label": "party MAY action.",
+      "documentation": { "value": "Grants permission to a party to perform an action." },
+      "parameters": [
+        { "label": "party", "documentation": { "value": "The party being granted permission." } },
+        { "label": "action", "documentation": { "value": "The action the party is permitted to perform." } }
+      ]
+    },
+    {
+      "label": "party SHALL action.",
+      "documentation": { "value": "Obliges a party to perform an action." },
+      "parameters": [
+        { "label": "party", "documentation": { "value": "The party being obligated." } },
+        { "label": "action", "documentation": { "value": "The action the party must perform." } }
+      ]
+    },
+    {
+      "label": "PAY amount TO party.",
+      "documentation": { "value": "Transfers the specified amount to the designated party." },
+      "parameters": [
+        { "label": "amount", "documentation": { "value": "The amount to transfer." } },
+        { "label": "party", "documentation": { "value": "The recipient of the payment." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/liquid.json

@@ -0,0 +1,94 @@
+{
+  "language": "liquid",
+  "triggerCharacters": ["{", "%", "|", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "{% assign variable = value %}",
+      "documentation": { "value": "Creates a new named variable and assigns it a value." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The name of the variable to create or overwrite." } },
+        { "label": "value", "documentation": { "value": "The value to assign (string, number, boolean, or another variable)." } }
+      ]
+    },
+    {
+      "label": "{% capture variable %}...{% endcapture %}",
+      "documentation": { "value": "Captures the rendered content between the tags and assigns it to a variable as a string." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The variable name to store the captured content." } }
+      ]
+    },
+    {
+      "label": "{% for item in collection %}...{% endfor %}",
+      "documentation": { "value": "Iterates over an array or range, rendering the enclosed block for each item." },
+      "parameters": [
+        { "label": "item", "documentation": { "value": "The loop variable name for each element." } },
+        { "label": "collection", "documentation": { "value": "The array, hash, or range to iterate over." } }
+      ]
+    },
+    {
+      "label": "{% if condition %}...{% endif %}",
+      "documentation": { "value": "Conditionally renders the enclosed block if the condition is truthy." },
+      "parameters": [
+        { "label": "condition", "documentation": { "value": "An expression that evaluates to truthy or falsy." } }
+      ]
+    },
+    {
+      "label": "{% unless condition %}...{% endunless %}",
+      "documentation": { "value": "Renders the enclosed block unless the condition is truthy (opposite of if)." },
+      "parameters": [
+        { "label": "condition", "documentation": { "value": "An expression; the block renders when this is falsy." } }
+      ]
+    },
+    {
+      "label": "{% case variable %}{% when value %}...{% endcase %}",
+      "documentation": { "value": "Creates a switch statement. Renders the block matching the variable's value." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The variable to compare against." } },
+        { "label": "value", "documentation": { "value": "The value to match in each when clause." } }
+      ]
+    },
+    {
+      "label": "{% include 'template_name' %}",
+      "documentation": { "value": "Inserts the rendered content of another template file. Deprecated in favor of render." },
+      "parameters": [
+        { "label": "template_name", "documentation": { "value": "The filename of the template to include (without extension)." } }
+      ]
+    },
+    {
+      "label": "{% render 'template_name', var: value %}",
+      "documentation": { "value": "Renders another template with its own isolated scope. Variables can be passed explicitly." },
+      "parameters": [
+        { "label": "template_name", "documentation": { "value": "The filename of the template to render (without extension)." } },
+        { "label": "var: value", "documentation": { "value": "Optional variables to pass into the rendered template." } }
+      ]
+    },
+    {
+      "label": "{% raw %}...{% endraw %}",
+      "documentation": { "value": "Outputs the enclosed content without parsing any Liquid tags. Useful for displaying Liquid code examples." },
+      "parameters": []
+    },
+    {
+      "label": "{% comment %}...{% endcomment %}",
+      "documentation": { "value": "Prevents the enclosed content from being rendered or output. Used for inline comments." },
+      "parameters": []
+    },
+    {
+      "label": "{% cycle 'val1', 'val2', ... %}",
+      "documentation": { "value": "Cycles through a group of strings and outputs them in order on each successive call. Commonly used in loops." },
+      "parameters": [
+        { "label": "val1", "documentation": { "value": "The first value in the cycle." } },
+        { "label": "val2", "documentation": { "value": "The second value in the cycle." } }
+      ]
+    },
+    {
+      "label": "{% tablerow item in collection cols:n %}...{% endtablerow %}",
+      "documentation": { "value": "Generates an HTML table by iterating over a collection. Automatically wraps output in <tr> and <td> tags." },
+      "parameters": [
+        { "label": "item", "documentation": { "value": "The loop variable for each element." } },
+        { "label": "collection", "documentation": { "value": "The array to iterate over." } },
+        { "label": "cols:n", "documentation": { "value": "Optional number of columns per table row." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/lua.json

@@ -0,0 +1,128 @@
+{
+  "language": "lua",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "print(...): void",
+      "documentation": { "value": "Receives any number of arguments and prints their values to stdout, separated by tabs, with a newline at the end." },
+      "parameters": [
+        { "label": "...", "documentation": { "value": "Values to print. Each is converted using tostring()." } }
+      ]
+    },
+    {
+      "label": "type(v): string",
+      "documentation": { "value": "Returns the type of its argument as a string: \"nil\", \"number\", \"string\", \"boolean\", \"table\", \"function\", \"thread\", or \"userdata\"." },
+      "parameters": [
+        { "label": "v", "documentation": { "value": "The value to check the type of." } }
+      ]
+    },
+    {
+      "label": "tostring(v): string",
+      "documentation": { "value": "Converts any value to a string in a human-readable format. Uses the __tostring metamethod if available." },
+      "parameters": [
+        { "label": "v", "documentation": { "value": "The value to convert to a string." } }
+      ]
+    },
+    {
+      "label": "tonumber(e, base?): number | nil",
+      "documentation": { "value": "Converts a value to a number. Returns nil if conversion is not possible. An optional base (2-36) can be specified for string conversion." },
+      "parameters": [
+        { "label": "e", "documentation": { "value": "The value to convert." } },
+        { "label": "base?", "documentation": { "value": "Optional numeric base for string conversion (2-36). Default is 10." } }
+      ]
+    },
+    {
+      "label": "string.format(formatstring, ...): string",
+      "documentation": { "value": "Returns a formatted string following the description given in formatstring, similar to C's sprintf." },
+      "parameters": [
+        { "label": "formatstring", "documentation": { "value": "A format string with specifiers like %s, %d, %f, %q, etc." } },
+        { "label": "...", "documentation": { "value": "Values to be formatted." } }
+      ]
+    },
+    {
+      "label": "string.find(s, pattern, init?, plain?): number, number | nil",
+      "documentation": { "value": "Looks for the first match of pattern in string s. Returns start and end indices, or nil if not found." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string to search in." } },
+        { "label": "pattern", "documentation": { "value": "The Lua pattern to search for." } },
+        { "label": "init?", "documentation": { "value": "Position to start the search. Defaults to 1." } },
+        { "label": "plain?", "documentation": { "value": "If true, turns off pattern matching and does a plain find." } }
+      ]
+    },
+    {
+      "label": "string.gsub(s, pattern, repl, n?): string, number",
+      "documentation": { "value": "Returns a copy of s in which all (or the first n) occurrences of the pattern have been replaced. Also returns the total number of matches." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The source string." } },
+        { "label": "pattern", "documentation": { "value": "The Lua pattern to match." } },
+        { "label": "repl", "documentation": { "value": "Replacement string, table, or function." } },
+        { "label": "n?", "documentation": { "value": "Maximum number of replacements. Defaults to all." } }
+      ]
+    },
+    {
+      "label": "table.insert(list, pos?, value): void",
+      "documentation": { "value": "Inserts element value at position pos in list, shifting up other elements. If pos is omitted, appends to the end." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The table (used as an array) to insert into." } },
+        { "label": "pos?", "documentation": { "value": "Optional position index. Defaults to end of list." } },
+        { "label": "value", "documentation": { "value": "The value to insert." } }
+      ]
+    },
+    {
+      "label": "table.remove(list, pos?): value",
+      "documentation": { "value": "Removes from list the element at position pos, shifting down other elements. Returns the removed value. If pos is omitted, removes the last element." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The table (used as an array) to remove from." } },
+        { "label": "pos?", "documentation": { "value": "The position of the element to remove. Defaults to the last element." } }
+      ]
+    },
+    {
+      "label": "table.sort(list, comp?): void",
+      "documentation": { "value": "Sorts list elements in place. If comp is given, it must be a function that receives two elements and returns true when the first should come before the second." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The table (used as an array) to sort." } },
+        { "label": "comp?", "documentation": { "value": "Optional comparison function (a, b) -> boolean." } }
+      ]
+    },
+    {
+      "label": "math.max(x, ...): number",
+      "documentation": { "value": "Returns the argument with the maximum value according to the Lua operator <." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "First number." } },
+        { "label": "...", "documentation": { "value": "Additional numbers to compare." } }
+      ]
+    },
+    {
+      "label": "math.min(x, ...): number",
+      "documentation": { "value": "Returns the argument with the minimum value according to the Lua operator <." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "First number." } },
+        { "label": "...", "documentation": { "value": "Additional numbers to compare." } }
+      ]
+    },
+    {
+      "label": "io.open(filename, mode?): file | nil, string",
+      "documentation": { "value": "Opens a file in the specified mode. Returns a file handle on success, or nil and an error message on failure." },
+      "parameters": [
+        { "label": "filename", "documentation": { "value": "The path to the file to open." } },
+        { "label": "mode?", "documentation": { "value": "Open mode: 'r' (read), 'w' (write), 'a' (append), 'r+', 'w+', 'a+'. Append 'b' for binary." } }
+      ]
+    },
+    {
+      "label": "io.read(...): string | number | nil",
+      "documentation": { "value": "Reads from the default input file according to the given formats. Common formats: '*l' (line), '*n' (number), '*a' (all)." },
+      "parameters": [
+        { "label": "...", "documentation": { "value": "Read format strings: '*l' (line), '*n' (number), '*a' (entire file), or a number for byte count." } }
+      ]
+    },
+    {
+      "label": "pcall(f, ...): boolean, ...",
+      "documentation": { "value": "Calls function f with the given arguments in protected mode. Returns true plus results on success, or false plus an error message on failure." },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "The function to call in protected mode." } },
+        { "label": "...", "documentation": { "value": "Arguments to pass to the function." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/m3.json

@@ -0,0 +1,84 @@
+{
+  "language": "m3",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "IO.Put(wr: Wr.T, txt: TEXT): void",
+      "documentation": { "value": "Writes a text string to the specified writer. If wr is omitted, writes to standard output." },
+      "parameters": [
+        { "label": "wr", "documentation": { "value": "The writer to output to. Use Stdio.stdout for standard output." } },
+        { "label": "txt", "documentation": { "value": "The TEXT string to write." } }
+      ]
+    },
+    {
+      "label": "IO.PutInt(wr: Wr.T, n: INTEGER): void",
+      "documentation": { "value": "Writes an integer to the specified writer as its decimal text representation." },
+      "parameters": [
+        { "label": "wr", "documentation": { "value": "The writer to output to." } },
+        { "label": "n", "documentation": { "value": "The integer value to write." } }
+      ]
+    },
+    {
+      "label": "Text.Length(t: TEXT): CARDINAL",
+      "documentation": { "value": "Returns the number of characters in the text." },
+      "parameters": [
+        { "label": "t", "documentation": { "value": "The TEXT value to measure." } }
+      ]
+    },
+    {
+      "label": "Text.Sub(t: TEXT, start: CARDINAL, length: CARDINAL): TEXT",
+      "documentation": { "value": "Returns a substring of t starting at position start with the given length." },
+      "parameters": [
+        { "label": "t", "documentation": { "value": "The source TEXT string." } },
+        { "label": "start", "documentation": { "value": "The zero-based starting index." } },
+        { "label": "length", "documentation": { "value": "The number of characters to extract." } }
+      ]
+    },
+    {
+      "label": "Text.Cat(t: TEXT, u: TEXT): TEXT",
+      "documentation": { "value": "Concatenates two text values and returns the result." },
+      "parameters": [
+        { "label": "t", "documentation": { "value": "The first text string." } },
+        { "label": "u", "documentation": { "value": "The second text string." } }
+      ]
+    },
+    {
+      "label": "Text.Equal(t: TEXT, u: TEXT): BOOLEAN",
+      "documentation": { "value": "Returns TRUE if the two text values contain the same characters." },
+      "parameters": [
+        { "label": "t", "documentation": { "value": "The first text to compare." } },
+        { "label": "u", "documentation": { "value": "The second text to compare." } }
+      ]
+    },
+    {
+      "label": "Text.GetChar(t: TEXT, i: CARDINAL): CHAR",
+      "documentation": { "value": "Returns the character at position i in the text. Raises an exception if i is out of range." },
+      "parameters": [
+        { "label": "t", "documentation": { "value": "The TEXT value." } },
+        { "label": "i", "documentation": { "value": "The zero-based character index." } }
+      ]
+    },
+    {
+      "label": "Math.sqrt(x: LONGREAL): LONGREAL",
+      "documentation": { "value": "Returns the square root of x." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "A non-negative real number." } }
+      ]
+    },
+    {
+      "label": "Thread.Signal(cv: Condition): void",
+      "documentation": { "value": "Wakes one thread waiting on the condition variable cv." },
+      "parameters": [
+        { "label": "cv", "documentation": { "value": "The condition variable to signal." } }
+      ]
+    },
+    {
+      "label": "Thread.Broadcast(cv: Condition): void",
+      "documentation": { "value": "Wakes all threads waiting on the condition variable cv." },
+      "parameters": [
+        { "label": "cv", "documentation": { "value": "The condition variable to broadcast on." } }
+      ]
+    }
+  ]
+}