@enjoys/context-engine 1.1.1 → 1.2.0

package/data/signatureHelp/pascal.json

@@ -0,0 +1,114 @@
+{
+  "language": "pascal",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "WriteLn(args: ...): void",
+      "documentation": { "value": "Writes one or more values to standard output followed by a newline character." },
+      "parameters": [
+        { "label": "args", "documentation": { "value": "One or more expressions to write. Supports strings, integers, reals, booleans, and chars." } }
+      ]
+    },
+    {
+      "label": "ReadLn(var s: string): void",
+      "documentation": { "value": "Reads a line of text from standard input into a variable." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The variable to store the input. Reads until end of line." } }
+      ]
+    },
+    {
+      "label": "Length(s: string): Integer",
+      "documentation": { "value": "Returns the number of characters in a string or elements in a dynamic array." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string or dynamic array whose length is returned." } }
+      ]
+    },
+    {
+      "label": "Copy(s: string, index: Integer, count: Integer): string",
+      "documentation": { "value": "Returns a substring of a string, starting at the given index for the given number of characters." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The source string." } },
+        { "label": "index", "documentation": { "value": "The 1-based starting position." } },
+        { "label": "count", "documentation": { "value": "The number of characters to copy." } }
+      ]
+    },
+    {
+      "label": "Pos(substr: string, s: string): Integer",
+      "documentation": { "value": "Returns the position of the first occurrence of a substring in a string. Returns 0 if not found." },
+      "parameters": [
+        { "label": "substr", "documentation": { "value": "The substring to search for." } },
+        { "label": "s", "documentation": { "value": "The string to search in." } }
+      ]
+    },
+    {
+      "label": "Delete(var s: string, index: Integer, count: Integer): void",
+      "documentation": { "value": "Removes count characters from string s starting at position index." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string to modify (passed by reference)." } },
+        { "label": "index", "documentation": { "value": "The 1-based starting position to delete from." } },
+        { "label": "count", "documentation": { "value": "The number of characters to delete." } }
+      ]
+    },
+    {
+      "label": "Insert(source: string, var s: string, index: Integer): void",
+      "documentation": { "value": "Inserts a substring into a string at the specified position." },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "The substring to insert." } },
+        { "label": "s", "documentation": { "value": "The target string to insert into (passed by reference)." } },
+        { "label": "index", "documentation": { "value": "The 1-based position where the source string will be inserted." } }
+      ]
+    },
+    {
+      "label": "IntToStr(value: Integer): string",
+      "documentation": { "value": "Converts an integer value to its string representation." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The integer value to convert." } }
+      ]
+    },
+    {
+      "label": "StrToInt(s: string): Integer",
+      "documentation": { "value": "Converts a string to an integer value. Raises an exception if the string is not a valid integer." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string containing an integer representation." } }
+      ]
+    },
+    {
+      "label": "Concat(s1: string, s2: string, ...): string",
+      "documentation": { "value": "Concatenates two or more strings and returns the result." },
+      "parameters": [
+        { "label": "s1", "documentation": { "value": "The first string." } },
+        { "label": "s2", "documentation": { "value": "The second string." } },
+        { "label": "...", "documentation": { "value": "Additional strings to concatenate." } }
+      ]
+    },
+    {
+      "label": "Ord(c: Char): Integer",
+      "documentation": { "value": "Returns the ordinal (ASCII) value of a character." },
+      "parameters": [
+        { "label": "c", "documentation": { "value": "The character whose ordinal value is returned." } }
+      ]
+    },
+    {
+      "label": "Chr(x: Integer): Char",
+      "documentation": { "value": "Returns the character corresponding to the specified ASCII value." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "An integer value representing the ASCII code (0-255)." } }
+      ]
+    },
+    {
+      "label": "Abs(x: number): number",
+      "documentation": { "value": "Returns the absolute value of a numeric expression." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "An integer or real number." } }
+      ]
+    },
+    {
+      "label": "Random(range: Integer): Integer",
+      "documentation": { "value": "Returns a random integer between 0 and range-1. Call Randomize first to seed the generator." },
+      "parameters": [
+        { "label": "range", "documentation": { "value": "The upper bound (exclusive). If omitted, returns a real number between 0.0 and 1.0." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/pascaligo.json

@@ -0,0 +1,77 @@
+{
+  "language": "pascaligo",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "Map.find_opt(key: 'key, map: map('key, 'value)): option('value)",
+      "documentation": { "value": "Returns the value associated with a key in the map as Some(value), or None if the key is not present." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to look up in the map." } },
+        { "label": "map", "documentation": { "value": "The map to search in." } }
+      ]
+    },
+    {
+      "label": "Map.update(key: 'key, value: option('value), map: map('key, 'value)): map('key, 'value)",
+      "documentation": { "value": "Updates the value associated with a key. If value is Some(v), the binding is updated; if None, the key is removed." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to update." } },
+        { "label": "value", "documentation": { "value": "Some(new_value) to set, or None to remove the binding." } },
+        { "label": "map", "documentation": { "value": "The map to update." } }
+      ]
+    },
+    {
+      "label": "Map.mem(key: 'key, map: map('key, 'value)): bool",
+      "documentation": { "value": "Tests whether a key exists in the map. Returns true if the key is present." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to test for membership." } },
+        { "label": "map", "documentation": { "value": "The map to test." } }
+      ]
+    },
+    {
+      "label": "List.map(f: ('a -> 'b), list: list('a)): list('b)",
+      "documentation": { "value": "Applies a function to each element of a list and returns a new list with the results." },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "The function to apply to each element." } },
+        { "label": "list", "documentation": { "value": "The input list." } }
+      ]
+    },
+    {
+      "label": "List.fold(f: (('acc, 'a) -> 'acc), list: list('a), init: 'acc): 'acc",
+      "documentation": { "value": "Reduces a list to a single value by applying a function to each element and an accumulator." },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "The folding function that takes an accumulator and an element." } },
+        { "label": "list", "documentation": { "value": "The list to fold over." } },
+        { "label": "init", "documentation": { "value": "The initial accumulator value." } }
+      ]
+    },
+    {
+      "label": "Tezos.transaction(parameter: 'param, amount: tez, contract: contract('param)): operation",
+      "documentation": { "value": "Creates a transaction operation to send tokens to a contract with a parameter." },
+      "parameters": [
+        { "label": "parameter", "documentation": { "value": "The parameter to pass to the destination contract's entrypoint." } },
+        { "label": "amount", "documentation": { "value": "The amount of tez to transfer." } },
+        { "label": "contract", "documentation": { "value": "The target contract handle." } }
+      ]
+    },
+    {
+      "label": "Tezos.get_sender(): address",
+      "documentation": { "value": "Returns the address of the account that initiated the current transaction (may differ from source)." },
+      "parameters": []
+    },
+    {
+      "label": "abs(value: int): nat",
+      "documentation": { "value": "Returns the absolute value of an integer as a natural number (nat)." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The integer value to take the absolute value of." } }
+      ]
+    },
+    {
+      "label": "int(value: nat): int",
+      "documentation": { "value": "Converts a natural number (nat) to an integer." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The natural number to convert to int." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/perl.json

@@ -0,0 +1,132 @@
+{
+  "language": "perl",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "print(LIST): Boolean",
+      "documentation": { "value": "Prints a string or a list of strings to the selected output handle (default STDOUT). Returns true on success." },
+      "parameters": [
+        { "label": "LIST", "documentation": { "value": "A list of strings to print. Without arguments, prints $_." } }
+      ]
+    },
+    {
+      "label": "chomp(STRING): Integer",
+      "documentation": { "value": "Removes the trailing newline from a string (if present). Returns the number of characters removed." },
+      "parameters": [
+        { "label": "STRING", "documentation": { "value": "The string or variable to remove the trailing newline from. Modifies the variable in-place." } }
+      ]
+    },
+    {
+      "label": "split(PATTERN, STRING, LIMIT): List",
+      "documentation": { "value": "Splits a string into a list of substrings based on a delimiter pattern." },
+      "parameters": [
+        { "label": "PATTERN", "documentation": { "value": "The regex pattern or string delimiter to split on (e.g., /,/, /\\s+/)." } },
+        { "label": "STRING", "documentation": { "value": "The string to split. Defaults to $_ if omitted." } },
+        { "label": "LIMIT", "documentation": { "value": "Optional maximum number of fields. If negative, treated as arbitrarily large." } }
+      ]
+    },
+    {
+      "label": "join(SEPARATOR, LIST): String",
+      "documentation": { "value": "Joins the elements of a list into a single string with the specified separator." },
+      "parameters": [
+        { "label": "SEPARATOR", "documentation": { "value": "The string to place between each element." } },
+        { "label": "LIST", "documentation": { "value": "The list of values to join." } }
+      ]
+    },
+    {
+      "label": "push(@ARRAY, LIST): Integer",
+      "documentation": { "value": "Appends one or more values to the end of an array. Returns the new number of elements." },
+      "parameters": [
+        { "label": "@ARRAY", "documentation": { "value": "The array to append to." } },
+        { "label": "LIST", "documentation": { "value": "The values to push onto the array." } }
+      ]
+    },
+    {
+      "label": "pop(@ARRAY): Scalar",
+      "documentation": { "value": "Removes and returns the last element of an array, shortening the array by one." },
+      "parameters": [
+        { "label": "@ARRAY", "documentation": { "value": "The array to pop from. Defaults to @_ inside subroutines." } }
+      ]
+    },
+    {
+      "label": "shift(@ARRAY): Scalar",
+      "documentation": { "value": "Removes and returns the first element of an array, shifting all other elements down by one." },
+      "parameters": [
+        { "label": "@ARRAY", "documentation": { "value": "The array to shift from. Defaults to @ARGV outside subroutines, @_ inside." } }
+      ]
+    },
+    {
+      "label": "unshift(@ARRAY, LIST): Integer",
+      "documentation": { "value": "Prepends one or more values to the beginning of an array. Returns the new number of elements." },
+      "parameters": [
+        { "label": "@ARRAY", "documentation": { "value": "The array to prepend to." } },
+        { "label": "LIST", "documentation": { "value": "The values to add to the beginning of the array." } }
+      ]
+    },
+    {
+      "label": "length(EXPR): Integer",
+      "documentation": { "value": "Returns the length in characters of the value of EXPR." },
+      "parameters": [
+        { "label": "EXPR", "documentation": { "value": "The string expression. Defaults to $_ if omitted." } }
+      ]
+    },
+    {
+      "label": "substr(EXPR, OFFSET, LENGTH, REPLACEMENT): String",
+      "documentation": { "value": "Extracts a substring from a string. Can optionally replace the extracted portion." },
+      "parameters": [
+        { "label": "EXPR", "documentation": { "value": "The source string." } },
+        { "label": "OFFSET", "documentation": { "value": "The 0-based starting position. Negative values count from the end." } },
+        { "label": "LENGTH", "documentation": { "value": "Optional. The number of characters. Negative values leave that many characters at the end." } },
+        { "label": "REPLACEMENT", "documentation": { "value": "Optional. A string to replace the extracted portion with." } }
+      ]
+    },
+    {
+      "label": "index(STRING, SUBSTR, POSITION): Integer",
+      "documentation": { "value": "Returns the position of the first occurrence of SUBSTR in STRING. Returns -1 if not found." },
+      "parameters": [
+        { "label": "STRING", "documentation": { "value": "The string to search in." } },
+        { "label": "SUBSTR", "documentation": { "value": "The substring to search for." } },
+        { "label": "POSITION", "documentation": { "value": "Optional. The position to start searching from (0-based)." } }
+      ]
+    },
+    {
+      "label": "open(FILEHANDLE, MODE, FILENAME): Boolean",
+      "documentation": { "value": "Opens a file and associates it with a filehandle. Returns true on success." },
+      "parameters": [
+        { "label": "FILEHANDLE", "documentation": { "value": "The filehandle to associate (e.g., my $fh or a bareword)." } },
+        { "label": "MODE", "documentation": { "value": "The open mode: '<' (read), '>' (write), '>>' (append), '+<' (read/write)." } },
+        { "label": "FILENAME", "documentation": { "value": "The path to the file to open." } }
+      ]
+    },
+    {
+      "label": "close(FILEHANDLE): Boolean",
+      "documentation": { "value": "Closes an opened filehandle. Returns true on success." },
+      "parameters": [
+        { "label": "FILEHANDLE", "documentation": { "value": "The filehandle to close." } }
+      ]
+    },
+    {
+      "label": "die(LIST): void",
+      "documentation": { "value": "Raises an exception. Outside an eval, prints the message to STDERR and exits with the current $! value." },
+      "parameters": [
+        { "label": "LIST", "documentation": { "value": "The error message or object to die with. If it doesn't end in a newline, file and line are appended." } }
+      ]
+    },
+    {
+      "label": "warn(LIST): Boolean",
+      "documentation": { "value": "Prints a warning message to STDERR but does not exit the program." },
+      "parameters": [
+        { "label": "LIST", "documentation": { "value": "The warning message. If it doesn't end in a newline, file and line number are appended." } }
+      ]
+    },
+    {
+      "label": "sprintf(FORMAT, LIST): String",
+      "documentation": { "value": "Returns a formatted string (like printf but returns the string instead of printing it)." },
+      "parameters": [
+        { "label": "FORMAT", "documentation": { "value": "The format string with printf-style specifiers (%s, %d, %f, %x, etc.)." } },
+        { "label": "LIST", "documentation": { "value": "The values to substitute into the format string." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/pgsql.json

@@ -0,0 +1,126 @@
+{
+  "language": "pgsql",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "SELECT column1, column2 FROM table_name WHERE condition",
+      "documentation": { "value": "Retrieves rows from one or more tables. The most commonly used SQL command in PostgreSQL." },
+      "parameters": [
+        { "label": "column1, column2", "documentation": { "value": "The columns to retrieve. Use * for all columns." } },
+        { "label": "table_name", "documentation": { "value": "The table or view to query from." } },
+        { "label": "condition", "documentation": { "value": "Optional WHERE clause to filter results." } }
+      ]
+    },
+    {
+      "label": "INSERT INTO table_name (column1, column2) VALUES (value1, value2) RETURNING *",
+      "documentation": { "value": "Inserts new rows into a table. PostgreSQL supports RETURNING clause to return inserted rows." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The target table." } },
+        { "label": "column1, column2", "documentation": { "value": "The columns to insert values into." } },
+        { "label": "value1, value2", "documentation": { "value": "The values to insert." } }
+      ]
+    },
+    {
+      "label": "UPDATE table_name SET column1 = value1 WHERE condition RETURNING *",
+      "documentation": { "value": "Modifies existing rows in a table. Supports RETURNING to return the updated rows." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The table to update." } },
+        { "label": "column1 = value1", "documentation": { "value": "The column-value assignments." } },
+        { "label": "condition", "documentation": { "value": "The WHERE clause to identify rows to update." } }
+      ]
+    },
+    {
+      "label": "CREATE TABLE table_name (column1 type, column2 type, ...)",
+      "documentation": { "value": "Creates a new table in the database. Supports PostgreSQL-specific types like SERIAL, JSONB, UUID, ARRAY." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The name of the new table (optionally schema-qualified)." } },
+        { "label": "column1 type", "documentation": { "value": "Column definitions with name and type (e.g., id SERIAL PRIMARY KEY, data JSONB)." } }
+      ]
+    },
+    {
+      "label": "ALTER TABLE table_name ADD COLUMN column_name type",
+      "documentation": { "value": "Modifies an existing table definition. Supports ADD/DROP COLUMN, RENAME, SET DEFAULT, constraints." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The table to alter." } },
+        { "label": "column_name", "documentation": { "value": "The name of the column to add." } },
+        { "label": "type", "documentation": { "value": "The PostgreSQL data type for the new column." } }
+      ]
+    },
+    {
+      "label": "COALESCE(value1, value2, ...): any",
+      "documentation": { "value": "Returns the first non-NULL argument. Often used to provide default values for nullable columns." },
+      "parameters": [
+        { "label": "value1", "documentation": { "value": "The first expression to evaluate." } },
+        { "label": "value2", "documentation": { "value": "The fallback expression if value1 is NULL." } }
+      ]
+    },
+    {
+      "label": "NULLIF(value1, value2): any",
+      "documentation": { "value": "Returns NULL if value1 equals value2; otherwise returns value1. Useful to avoid division-by-zero." },
+      "parameters": [
+        { "label": "value1", "documentation": { "value": "The value to return if not equal to value2." } },
+        { "label": "value2", "documentation": { "value": "The value to compare against." } }
+      ]
+    },
+    {
+      "label": "array_agg(expression ORDER BY ...): anyarray",
+      "documentation": { "value": "Aggregate function that collects all input values into an array." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The expression to aggregate into an array." } }
+      ]
+    },
+    {
+      "label": "string_agg(expression, delimiter ORDER BY ...): text",
+      "documentation": { "value": "Concatenates input values into a string separated by a delimiter." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The text expression to aggregate." } },
+        { "label": "delimiter", "documentation": { "value": "The separator string placed between values." } }
+      ]
+    },
+    {
+      "label": "json_build_object(key1, value1, key2, value2, ...): json",
+      "documentation": { "value": "Builds a JSON object from a variadic argument list of alternating keys and values." },
+      "parameters": [
+        { "label": "key1", "documentation": { "value": "The key for the first entry (must be text)." } },
+        { "label": "value1", "documentation": { "value": "The value for the first entry (any SQL type)." } },
+        { "label": "key2", "documentation": { "value": "The key for the second entry." } },
+        { "label": "value2", "documentation": { "value": "The value for the second entry." } }
+      ]
+    },
+    {
+      "label": "to_char(value, format): text",
+      "documentation": { "value": "Converts a timestamp, interval, integer, or numeric value to a string using a format pattern." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to format (timestamp, interval, numeric)." } },
+        { "label": "format", "documentation": { "value": "The format pattern (e.g., 'YYYY-MM-DD HH24:MI:SS', 'FM999,999.00')." } }
+      ]
+    },
+    {
+      "label": "date_trunc(field, source): timestamp",
+      "documentation": { "value": "Truncates a timestamp or interval to the specified precision." },
+      "parameters": [
+        { "label": "field", "documentation": { "value": "The precision: 'microseconds', 'milliseconds', 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'." } },
+        { "label": "source", "documentation": { "value": "The timestamp or interval value to truncate." } }
+      ]
+    },
+    {
+      "label": "generate_series(start, stop, step): setof",
+      "documentation": { "value": "Generates a series of values from start to stop with an optional step. Works with integer, bigint, and timestamp types." },
+      "parameters": [
+        { "label": "start", "documentation": { "value": "The start value of the series." } },
+        { "label": "stop", "documentation": { "value": "The end value of the series (inclusive)." } },
+        { "label": "step", "documentation": { "value": "Optional step increment. Defaults to 1 for integers or '1 day' for timestamps." } }
+      ]
+    },
+    {
+      "label": "regexp_matches(string, pattern, flags): text[]",
+      "documentation": { "value": "Returns all captured substrings from a POSIX regular expression match." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The string to match against." } },
+        { "label": "pattern", "documentation": { "value": "The POSIX regular expression pattern." } },
+        { "label": "flags", "documentation": { "value": "Optional flags: 'g' (global), 'i' (case-insensitive), 'n' (newline-sensitive)." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/php.json

@@ -0,0 +1,137 @@
+{
+  "language": "php",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "echo(string ...$expressions): void",
+      "documentation": { "value": "Outputs one or more strings. Not actually a function but a language construct; parentheses are optional." },
+      "parameters": [
+        { "label": "$expressions", "documentation": { "value": "One or more string expressions to output." } }
+      ]
+    },
+    {
+      "label": "var_dump(mixed ...$values): void",
+      "documentation": { "value": "Dumps information about one or more variables, including type and value. Useful for debugging." },
+      "parameters": [
+        { "label": "$values", "documentation": { "value": "One or more variables to dump. Outputs type, length, and values recursively." } }
+      ]
+    },
+    {
+      "label": "print_r(mixed $value, bool $return = false): string|true",
+      "documentation": { "value": "Prints human-readable information about a variable. When $return is true, returns the output as a string." },
+      "parameters": [
+        { "label": "$value", "documentation": { "value": "The variable to print." } },
+        { "label": "$return", "documentation": { "value": "If true, returns the output as a string instead of printing it." } }
+      ]
+    },
+    {
+      "label": "array_map(?callable $callback, array $array, array ...$arrays): array",
+      "documentation": { "value": "Applies a callback function to each element of an array and returns a new array with the results." },
+      "parameters": [
+        { "label": "$callback", "documentation": { "value": "The callback function to apply. Receives array values as arguments. NULL creates an array of arrays." } },
+        { "label": "$array", "documentation": { "value": "The input array to map over." } },
+        { "label": "$arrays", "documentation": { "value": "Optional additional arrays. If passed, the callback receives corresponding elements from each." } }
+      ]
+    },
+    {
+      "label": "array_filter(array $array, ?callable $callback = null, int $mode = 0): array",
+      "documentation": { "value": "Filters elements of an array using a callback function. If no callback is supplied, removes falsy values." },
+      "parameters": [
+        { "label": "$array", "documentation": { "value": "The array to filter." } },
+        { "label": "$callback", "documentation": { "value": "The callback function. Return true to keep, false to remove." } },
+        { "label": "$mode", "documentation": { "value": "Flag: ARRAY_FILTER_USE_KEY (pass key), ARRAY_FILTER_USE_BOTH (pass value and key)." } }
+      ]
+    },
+    {
+      "label": "array_merge(array ...$arrays): array",
+      "documentation": { "value": "Merges one or more arrays. Values with numeric keys are renumbered; string keys are overwritten by later arrays." },
+      "parameters": [
+        { "label": "$arrays", "documentation": { "value": "The arrays to merge." } }
+      ]
+    },
+    {
+      "label": "array_push(array &$array, mixed ...$values): int",
+      "documentation": { "value": "Pushes one or more elements onto the end of an array. Returns the new number of elements." },
+      "parameters": [
+        { "label": "$array", "documentation": { "value": "The input array (passed by reference)." } },
+        { "label": "$values", "documentation": { "value": "The values to push." } }
+      ]
+    },
+    {
+      "label": "strlen(string $string): int",
+      "documentation": { "value": "Returns the length of a string in bytes." },
+      "parameters": [
+        { "label": "$string", "documentation": { "value": "The string to measure." } }
+      ]
+    },
+    {
+      "label": "strpos(string $haystack, string $needle, int $offset = 0): int|false",
+      "documentation": { "value": "Finds the position of the first occurrence of a substring. Returns false if not found." },
+      "parameters": [
+        { "label": "$haystack", "documentation": { "value": "The string to search in." } },
+        { "label": "$needle", "documentation": { "value": "The substring to search for." } },
+        { "label": "$offset", "documentation": { "value": "Optional starting position for the search." } }
+      ]
+    },
+    {
+      "label": "str_replace(array|string $search, array|string $replace, array|string $subject, int &$count = null): array|string",
+      "documentation": { "value": "Replaces all occurrences of the search string with the replacement string." },
+      "parameters": [
+        { "label": "$search", "documentation": { "value": "The value to search for (string or array of strings)." } },
+        { "label": "$replace", "documentation": { "value": "The replacement value (string or array of strings)." } },
+        { "label": "$subject", "documentation": { "value": "The string or array to perform replacements on." } },
+        { "label": "$count", "documentation": { "value": "Optional. Set to the number of replacements performed." } }
+      ]
+    },
+    {
+      "label": "preg_match(string $pattern, string $subject, array &$matches = null, int $flags = 0, int $offset = 0): int|false",
+      "documentation": { "value": "Performs a regular expression match. Returns 1 if matched, 0 if not, false on error." },
+      "parameters": [
+        { "label": "$pattern", "documentation": { "value": "The regex pattern to search for (e.g., '/\\d+/')." } },
+        { "label": "$subject", "documentation": { "value": "The input string to match against." } },
+        { "label": "$matches", "documentation": { "value": "Optional. Filled with the results of the match." } },
+        { "label": "$flags", "documentation": { "value": "Optional flags: PREG_OFFSET_CAPTURE, PREG_UNMATCHED_AS_NULL." } },
+        { "label": "$offset", "documentation": { "value": "Optional offset in bytes to start the search." } }
+      ]
+    },
+    {
+      "label": "json_encode(mixed $value, int $flags = 0, int $depth = 512): string|false",
+      "documentation": { "value": "Returns the JSON representation of a value." },
+      "parameters": [
+        { "label": "$value", "documentation": { "value": "The value to encode. Can be any type except a resource." } },
+        { "label": "$flags", "documentation": { "value": "Bitmask of JSON_* constants (e.g., JSON_PRETTY_PRINT, JSON_UNESCAPED_UNICODE)." } },
+        { "label": "$depth", "documentation": { "value": "Maximum nesting depth. Must be greater than zero." } }
+      ]
+    },
+    {
+      "label": "json_decode(string $json, ?bool $associative = null, int $depth = 512, int $flags = 0): mixed",
+      "documentation": { "value": "Decodes a JSON string into a PHP value." },
+      "parameters": [
+        { "label": "$json", "documentation": { "value": "The JSON string to decode." } },
+        { "label": "$associative", "documentation": { "value": "When true, JSON objects are returned as associative arrays instead of objects." } },
+        { "label": "$depth", "documentation": { "value": "Maximum nesting depth of the structure being decoded." } },
+        { "label": "$flags", "documentation": { "value": "Bitmask of JSON_* constants (e.g., JSON_BIGINT_AS_STRING, JSON_THROW_ON_ERROR)." } }
+      ]
+    },
+    {
+      "label": "file_get_contents(string $filename, bool $use_include_path = false, ?resource $context = null, int $offset = 0, ?int $length = null): string|false",
+      "documentation": { "value": "Reads the entire contents of a file into a string. Also supports reading from URLs via stream wrappers." },
+      "parameters": [
+        { "label": "$filename", "documentation": { "value": "The file path or URL to read." } },
+        { "label": "$use_include_path", "documentation": { "value": "Whether to search the include_path for the file." } },
+        { "label": "$context", "documentation": { "value": "A stream context resource created with stream_context_create()." } },
+        { "label": "$offset", "documentation": { "value": "The offset to start reading from in the original stream." } },
+        { "label": "$length", "documentation": { "value": "Maximum number of bytes to read." } }
+      ]
+    },
+    {
+      "label": "date(string $format, ?int $timestamp = null): string",
+      "documentation": { "value": "Formats a Unix timestamp (or the current time) according to the given format string." },
+      "parameters": [
+        { "label": "$format", "documentation": { "value": "The date format string (e.g., 'Y-m-d H:i:s', 'D, d M Y')." } },
+        { "label": "$timestamp", "documentation": { "value": "Optional Unix timestamp. Defaults to the current time." } }
+      ]
+    }
+  ]
+}