@enjoys/context-engine 1.1.1 → 1.2.0

package/data/signatureHelp/sparql.json

@@ -0,0 +1,116 @@
+{
+  "language": "sparql",
+  "triggerCharacters": [" ", "("],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "SELECT [DISTINCT] variable [variable ...] WHERE { pattern }",
+      "documentation": { "value": "Selects specified variables from the results of matching graph patterns." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "One or more variables (e.g. `?name`, `?age`) to project from the result set" } },
+        { "label": "pattern", "documentation": { "value": "A graph pattern containing triple patterns and constraints" } }
+      ]
+    },
+    {
+      "label": "WHERE { pattern }",
+      "documentation": { "value": "Specifies the graph pattern to match against the RDF dataset." },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "Triple patterns, filters, optionals, and other pattern elements" } }
+      ]
+    },
+    {
+      "label": "FILTER(expression)",
+      "documentation": { "value": "Restricts solutions to those for which the expression evaluates to true." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A boolean expression, e.g. `?age > 18`, `regex(?name, 'pattern')`, `isURI(?x)`" } }
+      ]
+    },
+    {
+      "label": "OPTIONAL { pattern }",
+      "documentation": { "value": "Extends solutions with bindings from the optional pattern. Solutions are not rejected if the optional does not match." },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "A graph pattern that is optionally matched" } }
+      ]
+    },
+    {
+      "label": "UNION { pattern1 } { pattern2 }",
+      "documentation": { "value": "Combines results from two graph patterns (logical OR)." },
+      "parameters": [
+        { "label": "pattern1", "documentation": { "value": "The first alternative graph pattern" } },
+        { "label": "pattern2", "documentation": { "value": "The second alternative graph pattern" } }
+      ]
+    },
+    {
+      "label": "GROUP BY variable [variable ...]",
+      "documentation": { "value": "Groups query solutions by one or more variables for use with aggregate functions." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The variable(s) to group by" } }
+      ]
+    },
+    {
+      "label": "ORDER BY [ASC|DESC](expression) [...]",
+      "documentation": { "value": "Sorts the result set by the given expression(s) in ascending or descending order." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The expression or variable to sort by, optionally wrapped in ASC() or DESC()" } }
+      ]
+    },
+    {
+      "label": "LIMIT integer",
+      "documentation": { "value": "Restricts the number of solutions returned." },
+      "parameters": [
+        { "label": "integer", "documentation": { "value": "The maximum number of results to return" } }
+      ]
+    },
+    {
+      "label": "OFFSET integer",
+      "documentation": { "value": "Skips the specified number of solutions before returning results." },
+      "parameters": [
+        { "label": "integer", "documentation": { "value": "The number of results to skip" } }
+      ]
+    },
+    {
+      "label": "CONSTRUCT { template } WHERE { pattern }",
+      "documentation": { "value": "Constructs an RDF graph from a template for each solution to the graph pattern." },
+      "parameters": [
+        { "label": "template", "documentation": { "value": "A set of triple patterns forming the output graph template" } },
+        { "label": "pattern", "documentation": { "value": "The graph pattern to match" } }
+      ]
+    },
+    {
+      "label": "ASK WHERE { pattern }",
+      "documentation": { "value": "Returns a boolean indicating whether the query pattern has a solution." },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "The graph pattern to test for existence" } }
+      ]
+    },
+    {
+      "label": "DESCRIBE resource",
+      "documentation": { "value": "Returns an RDF graph that describes the specified resource(s)." },
+      "parameters": [
+        { "label": "resource", "documentation": { "value": "A URI or variable identifying the resource to describe" } }
+      ]
+    },
+    {
+      "label": "BIND(expression AS ?variable)",
+      "documentation": { "value": "Assigns the value of an expression to a variable within a graph pattern." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The expression to evaluate" } },
+        { "label": "?variable", "documentation": { "value": "The variable to bind the result to" } }
+      ]
+    },
+    {
+      "label": "COUNT(expression): integer",
+      "documentation": { "value": "Aggregate function that counts the number of solutions or distinct values." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A variable or `*` to count, optionally with DISTINCT" } }
+      ]
+    },
+    {
+      "label": "SUM(expression): numeric",
+      "documentation": { "value": "Aggregate function that returns the sum of numeric values." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A numeric expression or variable to sum" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/sql.json

@@ -0,0 +1,132 @@
+{
+  "language": "sql",
+  "triggerCharacters": [" ", "(", ","],
+  "retriggerCharacters": [" ", ","],
+  "signatures": [
+    {
+      "label": "SELECT [DISTINCT] columns FROM table [WHERE condition] [ORDER BY column]",
+      "documentation": { "value": "Retrieves rows from one or more tables based on specified columns and optional conditions." },
+      "parameters": [
+        { "label": "columns", "documentation": { "value": "Column names, expressions, or `*` for all columns" } },
+        { "label": "table", "documentation": { "value": "The table or view to query from" } },
+        { "label": "condition", "documentation": { "value": "Optional WHERE clause to filter rows" } }
+      ]
+    },
+    {
+      "label": "INSERT INTO table (col1, col2, ...) VALUES (val1, val2, ...)",
+      "documentation": { "value": "Inserts one or more new rows into a table." },
+      "parameters": [
+        { "label": "table", "documentation": { "value": "The target table name" } },
+        { "label": "(col1, col2, ...)", "documentation": { "value": "The columns to insert values into" } },
+        { "label": "(val1, val2, ...)", "documentation": { "value": "The values to insert" } }
+      ]
+    },
+    {
+      "label": "UPDATE table SET col1 = val1 [, col2 = val2 ...] [WHERE condition]",
+      "documentation": { "value": "Modifies existing rows in a table." },
+      "parameters": [
+        { "label": "table", "documentation": { "value": "The table to update" } },
+        { "label": "col1 = val1", "documentation": { "value": "Column-value pairs to set" } },
+        { "label": "condition", "documentation": { "value": "Optional WHERE clause to specify which rows to update" } }
+      ]
+    },
+    {
+      "label": "DELETE FROM table [WHERE condition]",
+      "documentation": { "value": "Removes rows from a table that match the optional condition." },
+      "parameters": [
+        { "label": "table", "documentation": { "value": "The table to delete from" } },
+        { "label": "condition", "documentation": { "value": "Optional WHERE clause to specify which rows to delete" } }
+      ]
+    },
+    {
+      "label": "CREATE TABLE table_name (col1 datatype [constraints], ...)",
+      "documentation": { "value": "Creates a new table with specified columns, data types, and constraints." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The name of the new table" } },
+        { "label": "col1 datatype", "documentation": { "value": "Column definitions with data types and optional constraints (PRIMARY KEY, NOT NULL, etc.)" } }
+      ]
+    },
+    {
+      "label": "ALTER TABLE table_name ADD|DROP|MODIFY column definition",
+      "documentation": { "value": "Modifies the structure of an existing table (add, drop, or modify columns)." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The table to alter" } },
+        { "label": "column definition", "documentation": { "value": "The column change: ADD column datatype, DROP COLUMN name, MODIFY COLUMN name datatype" } }
+      ]
+    },
+    {
+      "label": "JOIN table ON condition",
+      "documentation": { "value": "Combines rows from two or more tables based on a related column. Types: INNER, LEFT, RIGHT, FULL OUTER, CROSS." },
+      "parameters": [
+        { "label": "table", "documentation": { "value": "The table to join with" } },
+        { "label": "condition", "documentation": { "value": "The join condition, e.g. `t1.id = t2.foreign_id`" } }
+      ]
+    },
+    {
+      "label": "COUNT(expression): integer",
+      "documentation": { "value": "Returns the number of rows that match the specified criteria." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A column name, `*` for all rows, or `DISTINCT column` for unique values" } }
+      ]
+    },
+    {
+      "label": "SUM(expression): numeric",
+      "documentation": { "value": "Returns the total sum of a numeric column." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A numeric column or expression to sum" } }
+      ]
+    },
+    {
+      "label": "AVG(expression): numeric",
+      "documentation": { "value": "Returns the average value of a numeric column." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A numeric column or expression to average" } }
+      ]
+    },
+    {
+      "label": "MAX(expression): value",
+      "documentation": { "value": "Returns the maximum value in a set of values." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A column or expression to find the maximum of" } }
+      ]
+    },
+    {
+      "label": "MIN(expression): value",
+      "documentation": { "value": "Returns the minimum value in a set of values." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A column or expression to find the minimum of" } }
+      ]
+    },
+    {
+      "label": "COALESCE(val1, val2, ...): value",
+      "documentation": { "value": "Returns the first non-NULL value in the list of arguments." },
+      "parameters": [
+        { "label": "val1", "documentation": { "value": "The first value to check" } },
+        { "label": "val2", "documentation": { "value": "The second value to check (and so on)" } }
+      ]
+    },
+    {
+      "label": "CASE WHEN condition THEN result [WHEN ...] [ELSE result] END",
+      "documentation": { "value": "Evaluates a list of conditions and returns one of multiple possible results." },
+      "parameters": [
+        { "label": "condition", "documentation": { "value": "A boolean expression to test" } },
+        { "label": "result", "documentation": { "value": "The value to return when the condition is true" } }
+      ]
+    },
+    {
+      "label": "CAST(expression AS datatype): value",
+      "documentation": { "value": "Converts an expression from one data type to another." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The value to convert" } },
+        { "label": "datatype", "documentation": { "value": "The target data type (e.g. INT, VARCHAR, DATE, DECIMAL)" } }
+      ]
+    },
+    {
+      "label": "GROUP BY column1 [, column2 ...]",
+      "documentation": { "value": "Groups rows that have the same values in specified columns, typically used with aggregate functions." },
+      "parameters": [
+        { "label": "column1", "documentation": { "value": "The column(s) to group by" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/ssh_config.json

@@ -0,0 +1,79 @@
+{
+  "language": "ssh_config",
+  "triggerCharacters": [" "],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "Host pattern [pattern ...]",
+      "documentation": { "value": "Restricts the following declarations to hosts matching the given patterns. Use `*` for wildcard matching." },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "A hostname pattern. `*` matches any string, `?` matches any single character, `!` negates the pattern." } }
+      ]
+    },
+    {
+      "label": "HostName hostname",
+      "documentation": { "value": "Specifies the real hostname to log into. Numeric IP addresses are also permitted. This allows aliases in the Host directive." },
+      "parameters": [
+        { "label": "hostname", "documentation": { "value": "The actual hostname or IP address to connect to" } }
+      ]
+    },
+    {
+      "label": "User username",
+      "documentation": { "value": "Specifies the user to log in as on the remote machine." },
+      "parameters": [
+        { "label": "username", "documentation": { "value": "The remote username for SSH login" } }
+      ]
+    },
+    {
+      "label": "Port number",
+      "documentation": { "value": "Specifies the port number to connect to on the remote host." },
+      "parameters": [
+        { "label": "number", "documentation": { "value": "The port number (default is 22)" } }
+      ]
+    },
+    {
+      "label": "IdentityFile path",
+      "documentation": { "value": "Specifies a file from which the user's identity key is read for public key authentication." },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "Path to the private key file, e.g. `~/.ssh/id_ed25519`" } }
+      ]
+    },
+    {
+      "label": "ProxyJump destination [, destination ...]",
+      "documentation": { "value": "Specifies one or more jump proxies to connect through before reaching the target host." },
+      "parameters": [
+        { "label": "destination", "documentation": { "value": "A jump host in the format `[user@]host[:port]`, or comma-separated list for chained jumps" } }
+      ]
+    },
+    {
+      "label": "ForwardAgent yes|no",
+      "documentation": { "value": "Specifies whether the authentication agent connection will be forwarded to the remote machine." },
+      "parameters": [
+        { "label": "yes|no", "documentation": { "value": "`yes` to forward the agent, `no` to disable forwarding (default: no)" } }
+      ]
+    },
+    {
+      "label": "LocalForward [bind_address:]port host:hostport",
+      "documentation": { "value": "Specifies that a TCP port on the local machine be forwarded over the secure channel to a specified host and port from the remote machine." },
+      "parameters": [
+        { "label": "[bind_address:]port", "documentation": { "value": "Local address and port to listen on" } },
+        { "label": "host:hostport", "documentation": { "value": "Remote host and port to forward to" } }
+      ]
+    },
+    {
+      "label": "RemoteForward [bind_address:]port host:hostport",
+      "documentation": { "value": "Specifies that a TCP port on the remote machine be forwarded over the secure channel to a specified host and port from the local machine." },
+      "parameters": [
+        { "label": "[bind_address:]port", "documentation": { "value": "Remote address and port to listen on" } },
+        { "label": "host:hostport", "documentation": { "value": "Local host and port to forward to" } }
+      ]
+    },
+    {
+      "label": "StrictHostKeyChecking yes|no|ask|accept-new",
+      "documentation": { "value": "Controls whether SSH automatically adds host keys to the known_hosts file and whether it refuses connections to hosts with changed keys." },
+      "parameters": [
+        { "label": "yes|no|ask|accept-new", "documentation": { "value": "`yes` never auto-add, `no` auto-add, `ask` prompt user, `accept-new` auto-add new but reject changed" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/st.json

@@ -0,0 +1,111 @@
+{
+  "language": "st",
+  "triggerCharacters": ["(", ",", " "],
+  "retriggerCharacters": [",", " "],
+  "signatures": [
+    {
+      "label": "IF condition THEN statements [ELSIF condition THEN statements] [ELSE statements] END_IF",
+      "documentation": { "value": "Conditional branching statement. Executes statements if the condition evaluates to TRUE." },
+      "parameters": [
+        { "label": "condition", "documentation": { "value": "A BOOL expression to evaluate" } },
+        { "label": "statements", "documentation": { "value": "One or more statements to execute when the condition is TRUE" } }
+      ]
+    },
+    {
+      "label": "CASE expression OF value1: statements; [value2: statements;] [ELSE statements;] END_CASE",
+      "documentation": { "value": "Selects one of several groups of statements depending on the value of an expression." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "An integer or enumeration expression to evaluate" } },
+        { "label": "value1: statements", "documentation": { "value": "A case label followed by statements to execute" } }
+      ]
+    },
+    {
+      "label": "FOR variable := start TO end [BY step] DO statements END_FOR",
+      "documentation": { "value": "Repeats statements for a counter variable from a start value to an end value." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The loop counter variable (must be an integer type)" } },
+        { "label": "start", "documentation": { "value": "The initial value of the counter" } },
+        { "label": "end", "documentation": { "value": "The final value of the counter (inclusive)" } },
+        { "label": "step", "documentation": { "value": "Optional increment value (default is 1)" } }
+      ]
+    },
+    {
+      "label": "WHILE condition DO statements END_WHILE",
+      "documentation": { "value": "Repeats statements as long as the condition evaluates to TRUE." },
+      "parameters": [
+        { "label": "condition", "documentation": { "value": "A BOOL expression evaluated before each iteration" } },
+        { "label": "statements", "documentation": { "value": "Statements to execute in each iteration" } }
+      ]
+    },
+    {
+      "label": "REPEAT statements UNTIL condition END_REPEAT",
+      "documentation": { "value": "Repeats statements until the condition evaluates to TRUE. Body is executed at least once." },
+      "parameters": [
+        { "label": "statements", "documentation": { "value": "Statements to execute in each iteration" } },
+        { "label": "condition", "documentation": { "value": "A BOOL expression evaluated after each iteration" } }
+      ]
+    },
+    {
+      "label": "FUNCTION_BLOCK name VAR ... END_VAR ... END_FUNCTION_BLOCK",
+      "documentation": { "value": "Declares a function block - a POU with persistent state between calls. Can have input, output, and internal variables." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the function block" } }
+      ]
+    },
+    {
+      "label": "VAR [CONSTANT|RETAIN] variable : type [:= initial_value]; END_VAR",
+      "documentation": { "value": "Declares local variables within a POU. Optional qualifiers: CONSTANT for read-only, RETAIN for persistent values." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The variable identifier" } },
+        { "label": "type", "documentation": { "value": "The data type (BOOL, INT, REAL, STRING, etc.)" } },
+        { "label": "initial_value", "documentation": { "value": "Optional initial value for the variable" } }
+      ]
+    },
+    {
+      "label": "ABS(value: ANY_NUM): ANY_NUM",
+      "documentation": { "value": "Returns the absolute value of a numeric input." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "A numeric value (INT, REAL, DINT, LREAL, etc.)" } }
+      ]
+    },
+    {
+      "label": "SQRT(value: ANY_REAL): ANY_REAL",
+      "documentation": { "value": "Returns the square root of a real number." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "A non-negative REAL or LREAL value" } }
+      ]
+    },
+    {
+      "label": "MAX(value1: ANY_NUM, value2: ANY_NUM): ANY_NUM",
+      "documentation": { "value": "Returns the larger of two numeric values." },
+      "parameters": [
+        { "label": "value1", "documentation": { "value": "The first numeric value" } },
+        { "label": "value2", "documentation": { "value": "The second numeric value" } }
+      ]
+    },
+    {
+      "label": "MIN(value1: ANY_NUM, value2: ANY_NUM): ANY_NUM",
+      "documentation": { "value": "Returns the smaller of two numeric values." },
+      "parameters": [
+        { "label": "value1", "documentation": { "value": "The first numeric value" } },
+        { "label": "value2", "documentation": { "value": "The second numeric value" } }
+      ]
+    },
+    {
+      "label": "LEN(str: STRING): INT",
+      "documentation": { "value": "Returns the length of a string in characters." },
+      "parameters": [
+        { "label": "str", "documentation": { "value": "The input string" } }
+      ]
+    },
+    {
+      "label": "MID(str: STRING, length: INT, position: INT): STRING",
+      "documentation": { "value": "Returns a substring of the given length starting at the specified position." },
+      "parameters": [
+        { "label": "str", "documentation": { "value": "The input string" } },
+        { "label": "length", "documentation": { "value": "The number of characters to extract" } },
+        { "label": "position", "documentation": { "value": "The 1-based starting position" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/swift.json

@@ -0,0 +1,111 @@
+{
+  "language": "swift",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "print(_: items: Any..., separator: String, terminator: String)",
+      "documentation": { "value": "Writes the textual representations of the given items to the standard output." },
+      "parameters": [
+        { "label": "items", "documentation": { "value": "Zero or more items to print" } },
+        { "label": "separator", "documentation": { "value": "A string to print between each item (default: `\" \"`)" } },
+        { "label": "terminator", "documentation": { "value": "A string to print after all items (default: `\"\\n\"`)" } }
+      ]
+    },
+    {
+      "label": "String(_ value: some LosslessStringConvertible): String",
+      "documentation": { "value": "Creates a string representing the given value." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "A value conforming to `LosslessStringConvertible`" } }
+      ]
+    },
+    {
+      "label": "Int(_ source: String): Int?",
+      "documentation": { "value": "Creates a new integer value from the given string. Returns nil if the string is not a valid integer." },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "An ASCII representation of a number" } }
+      ]
+    },
+    {
+      "label": "Double(_ source: String): Double?",
+      "documentation": { "value": "Creates a new double-precision floating-point value from the given string." },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "An ASCII representation of a number" } }
+      ]
+    },
+    {
+      "label": "Array.append(_ newElement: Element)",
+      "documentation": { "value": "Adds a new element at the end of the array." },
+      "parameters": [
+        { "label": "newElement", "documentation": { "value": "The element to append to the array" } }
+      ]
+    },
+    {
+      "label": "Array.map<T>(_ transform: (Element) throws -> T) rethrows -> [T]",
+      "documentation": { "value": "Returns an array containing the results of mapping the given closure over the sequence's elements." },
+      "parameters": [
+        { "label": "transform", "documentation": { "value": "A mapping closure that accepts an element and returns a transformed value" } }
+      ]
+    },
+    {
+      "label": "Array.filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]",
+      "documentation": { "value": "Returns an array containing only the elements that satisfy the given predicate." },
+      "parameters": [
+        { "label": "isIncluded", "documentation": { "value": "A closure that takes an element and returns a Boolean value indicating whether to include it" } }
+      ]
+    },
+    {
+      "label": "Array.contains(_ element: Element) -> Bool",
+      "documentation": { "value": "Returns a Boolean value indicating whether the sequence contains the given element." },
+      "parameters": [
+        { "label": "element", "documentation": { "value": "The element to search for in the collection" } }
+      ]
+    },
+    {
+      "label": "Dictionary(uniqueKeysWithValues: [(Key, Value)])",
+      "documentation": { "value": "Creates a new dictionary from the key-value pairs in the given sequence." },
+      "parameters": [
+        { "label": "uniqueKeysWithValues", "documentation": { "value": "A sequence of `(Key, Value)` tuples with unique keys" } }
+      ]
+    },
+    {
+      "label": "guard let unwrapped = optional else { return }",
+      "documentation": { "value": "Conditionally unwraps an optional. If the optional is nil, the else branch must exit the current scope." },
+      "parameters": [
+        { "label": "unwrapped", "documentation": { "value": "The unwrapped non-optional variable name" } },
+        { "label": "optional", "documentation": { "value": "The optional value to unwrap" } }
+      ]
+    },
+    {
+      "label": "if let unwrapped = optional { ... }",
+      "documentation": { "value": "Conditionally unwraps an optional. The body executes only if the optional contains a value." },
+      "parameters": [
+        { "label": "unwrapped", "documentation": { "value": "The unwrapped non-optional variable name" } },
+        { "label": "optional", "documentation": { "value": "The optional value to unwrap" } }
+      ]
+    },
+    {
+      "label": "URLSession.shared.dataTask(with: URL, completionHandler: (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask",
+      "documentation": { "value": "Creates a task that retrieves the contents of a URL, then calls a handler upon completion." },
+      "parameters": [
+        { "label": "with", "documentation": { "value": "The URL to retrieve" } },
+        { "label": "completionHandler", "documentation": { "value": "A closure called with `(data, response, error)` when the task completes" } }
+      ]
+    },
+    {
+      "label": "JSONDecoder().decode<T>(_ type: T.Type, from: Data) throws -> T",
+      "documentation": { "value": "Decodes a top-level value of the given type from the given JSON representation." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The type of the value to decode (must conform to `Decodable`)" } },
+        { "label": "from", "documentation": { "value": "The JSON data to decode" } }
+      ]
+    },
+    {
+      "label": "Array.sorted(by: (Element, Element) throws -> Bool) rethrows -> [Element]",
+      "documentation": { "value": "Returns the elements of the sequence, sorted using the given predicate as the comparison." },
+      "parameters": [
+        { "label": "by", "documentation": { "value": "A predicate that returns `true` if the first argument should be ordered before the second" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/systemd.json

@@ -0,0 +1,80 @@
+{
+  "language": "systemd",
+  "triggerCharacters": ["=", " "],
+  "retriggerCharacters": ["="],
+  "signatures": [
+    {
+      "label": "[Unit] - Unit section header",
+      "documentation": { "value": "Defines generic information about the unit that is not dependent on the type of unit. Contains metadata and dependency configuration." },
+      "parameters": []
+    },
+    {
+      "label": "[Service] - Service section header",
+      "documentation": { "value": "Contains information about the service and the process it supervises. Only applicable for service unit files." },
+      "parameters": []
+    },
+    {
+      "label": "[Install] - Install section header",
+      "documentation": { "value": "Contains installation information for the unit. Used by `systemctl enable` and `systemctl disable`." },
+      "parameters": []
+    },
+    {
+      "label": "ExecStart=command [arguments]",
+      "documentation": { "value": "Commands with arguments that are executed when this service is started. Must be an absolute path." },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The absolute path to the executable to run" } },
+        { "label": "arguments", "documentation": { "value": "Optional command-line arguments" } }
+      ]
+    },
+    {
+      "label": "ExecStop=command [arguments]",
+      "documentation": { "value": "Commands to execute to stop the service started via ExecStart=." },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The absolute path to the executable for stopping the service" } },
+        { "label": "arguments", "documentation": { "value": "Optional command-line arguments" } }
+      ]
+    },
+    {
+      "label": "Type=simple|exec|forking|oneshot|dbus|notify|idle",
+      "documentation": { "value": "Configures the process start-up type for this service unit." },
+      "parameters": [
+        { "label": "simple|exec|forking|oneshot|dbus|notify|idle", "documentation": { "value": "`simple` (default): process is the main service. `forking`: the process forks and the parent exits. `oneshot`: the process exits after doing its work. `notify`: the service sends a notification when ready." } }
+      ]
+    },
+    {
+      "label": "Restart=no|on-success|on-failure|on-abnormal|on-watchdog|on-abort|always",
+      "documentation": { "value": "Configures whether the service shall be restarted when the service process exits, is killed, or a timeout is reached." },
+      "parameters": [
+        { "label": "no|on-success|on-failure|on-abnormal|on-watchdog|on-abort|always", "documentation": { "value": "`no` (default): service will not be restarted. `on-failure`: restart on non-zero exit code, signal, or timeout. `always`: always restart regardless of exit reason." } }
+      ]
+    },
+    {
+      "label": "WantedBy=target [target ...]",
+      "documentation": { "value": "Creates a symbolic link in the `.wants/` directory of the listed targets when `systemctl enable` is used." },
+      "parameters": [
+        { "label": "target", "documentation": { "value": "The target unit(s), e.g. `multi-user.target`, `graphical.target`" } }
+      ]
+    },
+    {
+      "label": "After=unit [unit ...]",
+      "documentation": { "value": "Configures ordering dependencies. This unit will be started after the listed units have been started." },
+      "parameters": [
+        { "label": "unit", "documentation": { "value": "One or more unit names to order after, e.g. `network.target`, `syslog.service`" } }
+      ]
+    },
+    {
+      "label": "Before=unit [unit ...]",
+      "documentation": { "value": "The inverse of After=. This unit will be started before the listed units." },
+      "parameters": [
+        { "label": "unit", "documentation": { "value": "One or more unit names to order before" } }
+      ]
+    },
+    {
+      "label": "Environment=KEY=value [KEY=value ...]",
+      "documentation": { "value": "Sets environment variables for executed processes." },
+      "parameters": [
+        { "label": "KEY=value", "documentation": { "value": "Space-separated list of variable assignments, e.g. `FOO=bar BAZ=qux`" } }
+      ]
+    }
+  ]
+}