` (or `class="language-LANG"`) elements and highlights them in place, batching via `setTimeout` when work exceeds `jush.timeout` (1000 ms).
- Keyword-to-doc-link system: `jush.links[state]` / `jush.links2[state]` (regexps matching recognized tokens) plus `jush.urls[state]` (doc URL templates) build clickable links; optional tooltip text comes from `jush.api[state][name]`, supplied by the separately-generated root file `jush-api.js` (not part of `modules/`, not touched by `compile.php`).
- MySQL/MariaDB share the `sql`, `sqlset` and `sqlstatus` states: entry keys there may be `'mysql-key maria-key'` pairs resolved in `keywords_links` by sniffing `mariadb` in the base URL (Adminer's `syntaxHighlighting()` swaps it at runtime). A missing maria key defaults to `mysqlKey.replace('.html', '/')` (the flat KB slug), `-` means "no link for that vendor", and MariaDB `$1` replacements keep underscores (KB slugs and anchors use them).
**Per-language modules – `modules/jush-.js`:**
Small, declarative files that each (a) extend `jush.tr` with new states/sub-states, (b) set `jush.urls.` doc-link templates, and (c) set `jush.links`/`jush.links2` keyword regexps. See `modules/jush-css.js` for a concise example; `modules/jush-php.js` is the largest, enumerating the entire PHP function reference. Trivial modules like `jush-txt.js` are a single line.
`jush-textarea.js` and `jush-autocomplete-sql.js` are a different layer built on top of the core: a live, syntax-highlighted, editable `
Language:
vrana-jush-d490483/demo.js 0000664 0000000 0000000 00000001342 15237625165 0015347 0 ustar 00root root 0000000 0000000 (function () {
jush.style('jush.css');
jush.style('jush-dark.css', '(prefers-color-scheme: dark)');
jush.create_links = 'target="_blank"';
const source = document.getElementById('source');
let value = '';
if (!source.value && location.hash) {
source.value = decodeURIComponent(location.hash.slice(1));
}
source.oninput = function highlight() {
if (value == source.value) {
return;
}
value = source.value;
const result = document.getElementById('result');
const language = source.form['language'].value;
result.className = 'jush-' + language;
result.innerHTML = jush.highlight(language, source.value);
};
source.form['language'].onchange = () => {
value = '';
source.oninput();
}
source.oninput();
})();
vrana-jush-d490483/jquery.jush.js 0000664 0000000 0000000 00000000752 15237625165 0016716 0 ustar 00root root 0000000 0000000 (function ($) {
// include jush.js here
$.jush = jush;
/** Highlight element content
* @param {string} [language]
* @return {jQuery}
* @this jQuery
*/
$.fn.jush = function (language) {
return this.each(function () {
let lang = language;
const $this = $(this);
if (!lang) {
const match = /(^|\s)(?:jush-|language-)(\S+)/.exec($this.attr('class'));
lang = (match ? match[2] : 'htm');
}
$this.html(jush.highlight(lang, $this.text()));
});
}
})(jQuery);
vrana-jush-d490483/json.php 0000664 0000000 0000000 00000001376 15237625165 0015556 0 ustar 00root root 0000000 0000000
JSON
vrana-jush-d490483/jush-api.js 0000664 0000000 0000000 00001326632 15237625165 0016160 0 ustar 00root root 0000000 0000000 jush.api.lowercase_keys = function (obj) {
const result = {};
for (const key in obj) {
result[key.toLowerCase()] = obj[key];
}
return result;
};
jush.api.js = {
'AggregateError': 'The AggregateError object represents an error when several errors need to be wrapped in a single error. It is thrown when multiple errors need to be reported by an operation, for example by Promise.any(), when all promises passed to it reject.',
'Array': 'The Array object, as with arrays in other programming languages, enables storing a collection of multiple items under a single variable name, and has members for performing common array operations.',
'Array.from': 'The Array.from() static method creates a new, shallow-copied Array instance from an iterable or array-like object.',
'Array.fromAsync': 'The Array.fromAsync() static method creates a new, shallow-copied Array instance from an async iterable, iterable, or array-like object.',
'Array.isArray': 'The Array.isArray() static method determines whether the passed value is an Array.',
'Array.of': 'The Array.of() static method creates a new Array instance from a variable number of arguments, regardless of number or type of the arguments.',
'ArrayBuffer': 'The ArrayBuffer object is used to represent a generic raw binary data buffer.',
'ArrayBuffer.isView': 'The ArrayBuffer.isView() static method determines whether the passed value is one of the ArrayBuffer views, such as typed array objects or a DataView.',
'AsyncDisposableStack': 'The AsyncDisposableStack object represents a stack of async disposers to run when the stack itself is disposed. Disposer functions are executed in reverse order of registration, with strong error handling guarantees. Calling its move() method will transfer responsibility for calling the current registered disposers to a new AsyncDisposableStack and prevent registering any additional disposers.',
'AsyncFunction': 'The AsyncFunction object provides methods for async functions. In JavaScript, every async function is actually an AsyncFunction object.',
'AsyncGenerator': 'The AsyncGenerator object is returned by an async generator function and it conforms to both the async iterable protocol and the async iterator protocol.',
'AsyncGeneratorFunction': 'The AsyncGeneratorFunction object provides methods for async generator functions. In JavaScript, every async generator function is actually an AsyncGeneratorFunction object.',
'AsyncIterator': 'An AsyncIterator object is an object that conforms to the async iterator protocol by providing a next() method that returns a promise fulfilling to an iterator result object. The AsyncIterator.prototype object is a hidden global object that all built-in async iterators inherit from. It provides a [Symbol.asyncIterator](/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncIterator/Symbol.asyncIterator) method that returns the async iterator object itself, making the async iterator also async iterable.',
'Atomics': 'The Atomics namespace object contains static methods for carrying out atomic operations. They are used with SharedArrayBuffer and ArrayBuffer objects.',
'Atomics.add': 'The Atomics.add() static method adds a given value at a given position in the array, and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.',
'Atomics.and': 'The Atomics.and() static method computes a bitwise AND with a given value at a given position in the array, and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.',
'Atomics.compareExchange': 'The Atomics.compareExchange() static method exchanges a given replacement value at a given position in the array, if a given expected value equals the old value. It returns the old value at that position whether it was equal to the expected value or not. This atomic operation guarantees that no other write happens until the modified value is written back.',
'Atomics.exchange': 'The Atomics.exchange() static method exchanges a given value at a given position in the array, and returns the old value at that position. This atomic operation guarantees that no other write happens between the read of the old value and the write of the new value.',
'Atomics.isLockFree': 'The Atomics.isLockFree() static method is used to determine whether the Atomics methods use locks or atomic hardware operations when applied to typed arrays with the given element byte size. It is intended as an optimization primitive, so that high-performance algorithms can determine whether to use locks or atomic operations in critical sections. If an atomic primitive is not lock-free, it is often more efficient for an algorithm to provide its own locking.',
'Atomics.load': 'The Atomics.load() static method returns a value at a given position in the array. This atomic operation guarantees that the read is tear-free, and that all atomic reads are sequentially consistent.',
'Atomics.notify': 'The Atomics.notify() static method notifies up some agents that are sleeping in the wait queue.',
'Atomics.or': 'The Atomics.or() static method computes a bitwise OR with a given value at a given position in the array, and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.',
'Atomics.pause': 'The Atomics.pause() static method provides a micro-wait primitive that hints to the CPU that the caller is spinning while waiting on access to a shared resource. This allows the system to reduce the resources allocated to the core (such as power) or thread, without yielding the current thread.',
'Atomics.store': 'The Atomics.store() static method stores a given value at a given position in the array and returns that value. This atomic operation guarantees that the write is tear-free, and that all atomic writes are sequentially consistent.',
'Atomics.sub': 'The Atomics.sub() static method subtracts a given value at a given position in the array, and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.',
'Atomics.wait': 'The Atomics.wait() static method verifies that a shared memory location contains a given value and if so sleeps, awaiting a wake-up notification or a time out. It returns a string which is "not-equal" if the memory location does not match the given value, "ok" if woken by Atomics.notify(), or "timed-out" if the timeout expires.',
'Atomics.waitAsync': 'The Atomics.waitAsync() static method verifies that a shared memory location contains a given value, immediately returning an object with the value property containing the string "not-equal" if the memory location does not match the given value, or "timed-out" if the timeout was set to zero. Otherwise the method returns an object where the value property is a Promise that fulfills with either "ok" when Atomics.notify() is called, or "timed-out" if the timeout expires.',
'Atomics.xor': 'The Atomics.xor() static method computes a bitwise XOR with a given value at a given position in the array, and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.',
'BigInt': 'BigInt values represent integer values which are too high or too low to be represented by the number primitive.',
'BigInt.asIntN': 'The BigInt.asIntN() static method truncates a BigInt value to the given number of least significant bits and returns that value as a signed integer.',
'BigInt.asUintN': 'The BigInt.asUintN() static method truncates a BigInt value to the given number of least significant bits and returns that value as an unsigned integer.',
'BigInt64Array': 'The BigInt64Array typed array represents an array of 64-bit signed integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0n unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'BigUint64Array': 'The BigUint64Array typed array represents an array of 64-bit unsigned integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0n unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'Boolean': 'Boolean values can be one of two values: true or false, representing the truth value of a logical proposition.',
'DataView': 'The DataView view provides a low-level interface for reading and writing multiple number types in a binary ArrayBuffer, without having to care about the platform\'s endianness.',
'Date': 'JavaScript Date objects represent a single moment in time in a platform-independent format. Date objects encapsulate an integral number that represents milliseconds since the midnight at the beginning of January 1, 1970, UTC (the _epoch_).',
'Date.UTC': 'The Date.UTC() static method accepts parameters representing the date and time components similar to the Date constructor, but treats them as UTC. It returns the number of milliseconds since January 1, 1970, 00:00:00 UTC.',
'Date.now': 'The Date.now() static method returns the number of milliseconds elapsed since the epoch, which is defined as the midnight at the beginning of January 1, 1970, UTC.',
'Date.parse': 'The Date.parse() static method parses a string representation of a date, and returns the date\'s timestamp.',
'DisposableStack': 'The DisposableStack object represents a stack of disposers to run when the stack itself is disposed. Disposer functions are executed in reverse order of registration, with strong error handling guarantees. Calling its move() method will transfer responsibility for calling the current registered disposers to a new DisposableStack and prevent registering any additional disposers.',
'Error': 'Error objects are thrown when runtime errors occur. The Error object can also be used as a base object for user-defined exceptions. See below for standard built-in error types.',
'Error.captureStackTrace': 'The Error.captureStackTrace() static method installs stack trace information on a provided object as the stack property.',
'Error.isError': 'The Error.isError() static method determines whether the passed value is an Error.',
'Error.stackTraceLimit': 'The Error.stackTraceLimit static data property indicates the maximum number of stack frames captured by the stack trace of an error. It can be set by user code to change the engine\'s behavior.',
'EvalError': 'The EvalError object indicates an error regarding the global eval() function. This exception is not thrown by JavaScript anymore, however the EvalError object remains for compatibility.',
'FinalizationRegistry': 'A FinalizationRegistry object lets you request a callback when a value is garbage-collected.',
'Float16Array': 'The Float16Array typed array represents an array of 16-bit floating point numbers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'Float32Array': 'The Float32Array typed array represents an array of 32-bit floating point numbers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'Float64Array': 'The Float64Array typed array represents an array of 64-bit floating point numbers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'Function': 'The Function object provides methods for functions. In JavaScript, every function is actually a Function object.',
'Generator': 'The Generator object is returned by a generator function and it conforms to both the iterable protocol and the iterator protocol.',
'GeneratorFunction': 'The GeneratorFunction object provides methods for generator functions. In JavaScript, every generator function is actually a GeneratorFunction object.',
'Infinity': 'The Infinity global property is a numeric value representing infinity.',
'Int16Array': 'The Int16Array typed array represents an array of 16-bit signed integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'Int32Array': 'The Int32Array typed array represents an array of 32-bit signed integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'Int8Array': 'The Int8Array typed array represents an array of 8-bit signed integers. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'InternalError': 'The InternalError object indicates an error that occurred internally in the JavaScript engine.',
'Intl': 'The Intl namespace object contains several constructors as well as functionality common to the internationalization constructors and other language sensitive functions. Collectively, they comprise the ECMAScript Internationalization API, which provides language sensitive string comparison, number formatting, date and time formatting, and more.',
'Intl.getCanonicalLocales': 'The Intl.getCanonicalLocales() static method returns an array containing the canonical locale names. Duplicates will be omitted and elements will be validated as structurally valid language tags.',
'Intl.supportedValuesOf': 'The Intl.supportedValuesOf() static method returns an array containing the supported calendar, collation, currency, numbering systems, or unit values supported by the implementation.',
'Iterator': 'An Iterator object is an object that conforms to the iterator protocol by providing a next() method that returns an iterator result object. All built-in iterators inherit from the Iterator class. The Iterator class provides a [Symbol.iterator](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator/Symbol.iterator) method that returns the iterator object itself, making the iterator also iterable. It also provides some helper methods for working with iterators.',
'Iterator.concat': 'The Iterator.concat() static method creates a new Iterator object from a list of iterable objects. The new iterator yields the values from each of the input iterables in sequence.',
'Iterator.from': 'The Iterator.from() static method creates a new Iterator object from an iterator or iterable object.',
'Iterator.zip': 'The Iterator.zip() static method creates a new Iterator object that aggregates elements from multiple iterable objects by yielding arrays containing elements at the same position. It essentially "zips" the input iterables together, allowing simultaneous iteration over them.',
'Iterator.zipKeyed': 'The Iterator.zipKeyed() static method creates a new Iterator object that aggregates elements from multiple iterable objects by yielding objects containing elements at the same position, with keys specified by the input. It essentially "zips" the input iterables together, allowing simultaneous iteration over them.',
'JSON': 'The JSON namespace object contains static methods for parsing values from and converting values to JavaScript Object Notation (JSON).',
'JSON.isRawJSON': 'The JSON.isRawJSON() static method tests whether a value is an object returned by JSON.rawJSON().',
'JSON.parse': 'The JSON.parse() static method parses a JSON string, constructing the JavaScript value or object described by the string. An optional _reviver_ function can be provided to perform a transformation on the resulting object before it is returned.',
'JSON.rawJSON': 'The JSON.rawJSON() static method creates a "raw JSON" object containing a piece of JSON text. When serialized to JSON, the raw JSON object is treated as if it is already a piece of JSON. This text is required to be valid JSON.',
'JSON.stringify': 'The JSON.stringify() static method converts a JavaScript value to a JSON string, optionally replacing values if a replacer function is specified or optionally including only the specified properties if a replacer array is specified.',
'Map': 'The Map object holds key-value pairs and remembers the original insertion order of the keys. Any value (both objects and primitive values) may be used as either a key or a value.',
'Map.groupBy': 'The Map.groupBy() static method groups the elements of a given iterable using the values returned by a provided callback function. The final returned Map uses the unique values from the test function as keys, which can be used to get the array of elements in each group.',
'Math': 'The Math namespace object contains static properties and methods for mathematical constants and functions.',
'Math.E': 'The Math.E static data property represents Euler\'s number, the base of natural logarithms, e, which is approximately 2.718.',
'Math.LN10': 'The Math.LN10 static data property represents the natural logarithm of 10, approximately 2.303.',
'Math.LN2': 'The Math.LN2 static data property represents the natural logarithm of 2, approximately 0.693:',
'Math.LOG10E': 'The Math.LOG10E static data property represents the base 10 logarithm of e, approximately 0.434.',
'Math.LOG2E': 'The Math.LOG2E static data property represents the base 2 logarithm of e, approximately 1.443.',
'Math.PI': 'The Math.PI static data property represents the ratio of the circumference of a circle to its diameter, approximately 3.14159.',
'Math.SQRT1_2': 'The Math.SQRT1_2 static data property represents the square root of 1/2, which is approximately 0.707.',
'Math.SQRT2': 'The Math.SQRT2 static data property represents the square root of 2, approximately 1.414.',
'Math.abs': 'The Math.abs() static method returns the absolute value of a number.',
'Math.acos': 'The Math.acos() static method returns the inverse cosine (in radians) of a number. That is,',
'Math.acosh': 'The Math.acosh() static method returns the inverse hyperbolic cosine of a number. That is,',
'Math.asin': 'The Math.asin() static method returns the inverse sine (in radians) of a number. That is,',
'Math.asinh': 'The Math.asinh() static method returns the inverse hyperbolic sine of a number. That is,',
'Math.atan': 'The Math.atan() static method returns the inverse tangent (in radians) of a number, that is',
'Math.atan2': 'The Math.atan2() static method returns the angle in the plane (in radians) between the positive x-axis and the ray from (0, 0) to the point (x, y), for Math.atan2(y, x).',
'Math.atanh': 'The Math.atanh() static method returns the inverse hyperbolic tangent of a number. That is,',
'Math.cbrt': 'The Math.cbrt() static method returns the cube root of a number. That is',
'Math.ceil': 'The Math.ceil() static method always rounds up and returns the smallest integer greater than or equal to a given number.',
'Math.clz32': 'The Math.clz32() static method returns the number of leading zero bits in the 32-bit binary representation of a number.',
'Math.cos': 'The Math.cos() static method returns the cosine of a number in radians.',
'Math.cosh': 'The Math.cosh() static method returns the hyperbolic cosine of a number. That is,',
'Math.exp': 'The Math.exp() static method returns e raised to the power of a number. That is',
'Math.expm1': 'The Math.expm1() static method returns e raised to the power of a number, subtracted by 1. That is',
'Math.f16round': 'The Math.f16round() static method returns the nearest 16-bit half precision float representation of a number.',
'Math.floor': 'The Math.floor() static method always rounds down and returns the largest integer less than or equal to a given number.',
'Math.fround': 'The Math.fround() static method returns the nearest 32-bit single precision float representation of a number.',
'Math.hypot': 'The Math.hypot() static method returns the square root of the sum of squares of its arguments. That is,',
'Math.imul': 'The Math.imul() static method returns the result of the C-like 32-bit multiplication of the two parameters.',
'Math.log': 'The Math.log() static method returns the natural logarithm (base e) of a number. That is',
'Math.log10': 'The Math.log10() static method returns the base 10 logarithm of a number. That is',
'Math.log1p': 'The Math.log1p() static method returns the natural logarithm (base e) of 1 + x, where x is the argument. That is:',
'Math.log2': 'The Math.log2() static method returns the base 2 logarithm of a number. That is',
'Math.max': 'The Math.max() static method returns the largest of the numbers given as input parameters, or -Infinity if there are no parameters.',
'Math.min': 'The Math.min() static method returns the smallest of the numbers given as input parameters, or Infinity if there are no parameters.',
'Math.pow': 'The Math.pow() static method returns the value of a base raised to a power. That is',
'Math.random': 'The Math.random() static method returns a floating-point, pseudo-random number that\'s greater than or equal to 0 and less than 1, with approximately uniform distribution over that range — which you can then scale to your desired range. The implementation selects the initial seed to the random number generation algorithm; it cannot be chosen or reset by the user.',
'Math.round': 'The Math.round() static method returns the value of a number rounded to the nearest integer.',
'Math.sign': 'The Math.sign() static method returns 1 or -1, indicating the sign of the number passed as argument. If the input is 0 or -0, it will be returned as-is.',
'Math.sin': 'The Math.sin() static method returns the sine of a number in radians.',
'Math.sinh': 'The Math.sinh() static method returns the hyperbolic sine of a number. That is,',
'Math.sqrt': 'The Math.sqrt() static method returns the square root of a number. That is',
'Math.sumPrecise': 'The Math.sumPrecise() static method takes an iterable of numbers and returns the sum of them. It is more precise than summing them up in a loop, because it avoids floating point precision loss in intermediate results.',
'Math.tan': 'The Math.tan() static method returns the tangent of a number in radians.',
'Math.tanh': 'The Math.tanh() static method returns the hyperbolic tangent of a number. That is,',
'Math.trunc': 'The Math.trunc() static method returns the integer part of a number by removing any fractional digits.',
'NaN': 'The NaN global property is a value representing Not-A-Number.',
'Number': 'Number values represent floating-point numbers like 37 or -9.25.',
'Number.EPSILON': 'The Number.EPSILON static data property represents the difference between 1 and the smallest floating point number greater than 1.',
'Number.MAX_SAFE_INTEGER': 'The Number.MAX_SAFE_INTEGER static data property represents the maximum safe integer in JavaScript (2^53 – 1).',
'Number.MAX_VALUE': 'The Number.MAX_VALUE static data property represents the maximum numeric value representable in JavaScript.',
'Number.MIN_SAFE_INTEGER': 'The Number.MIN_SAFE_INTEGER static data property represents the minimum safe integer in JavaScript, or -(2^53 - 1).',
'Number.MIN_VALUE': 'The Number.MIN_VALUE static data property represents the smallest positive numeric value representable in JavaScript.',
'Number.NEGATIVE_INFINITY': 'The Number.NEGATIVE_INFINITY static data property represents the negative Infinity value.',
'Number.NaN': 'The Number.NaN static data property represents Not-A-Number, which is equivalent to NaN. For more information about the behaviors of NaN, see the description for the global property.',
'Number.POSITIVE_INFINITY': 'The Number.POSITIVE_INFINITY static data property represents the positive Infinity value.',
'Number.isFinite': 'The Number.isFinite() static method determines whether the passed value is a finite number — that is, it checks that a given value is a number, and the number is neither positive Infinity, negative Infinity, nor NaN.',
'Number.isInteger': 'The Number.isInteger() static method determines whether the passed value is an integer.',
'Number.isNaN': 'The Number.isNaN() static method determines whether the passed value is the number value NaN, and returns false if the input is not of the Number type. It is a more robust version of the original, global isNaN() function.',
'Number.isSafeInteger': 'The Number.isSafeInteger() static method determines whether the provided value is a number that is a _safe integer_.',
'Number.parseFloat': 'The Number.parseFloat() static method parses an argument and returns a floating point number. If a number cannot be parsed from the argument, it returns NaN.',
'Number.parseInt': 'The Number.parseInt() static method parses a string argument and returns an integer of the specified radix or base.',
'Object': 'The Object type represents one of JavaScript\'s data types. It is used to store various keyed collections and more complex entities. Objects can be created using the Object() constructor or the object initializer / literal syntax.',
'Object.assign': 'The Object.assign() static method copies all enumerable own properties from one or more _source objects_ to a _target object_. It returns the modified target object.',
'Object.create': 'The Object.create() static method creates a new object, using an existing object as the prototype of the newly created object.',
'Object.defineProperties': 'The Object.defineProperties() static method defines new or modifies existing properties directly on an object, returning the object.',
'Object.defineProperty': 'The Object.defineProperty() static method defines a new property directly on an object, or modifies an existing property on an object, and returns the object.',
'Object.entries': 'The Object.entries() static method returns an array of a given object\'s own enumerable string-keyed property key-value pairs.',
'Object.freeze': 'The Object.freeze() static method _freezes_ an object. Freezing an object prevents extensions and makes existing properties non-writable and non-configurable. A frozen object can no longer be changed: new properties cannot be added, existing properties cannot be removed, their enumerability, configurability, writability, or value cannot be changed, and the object\'s prototype cannot be re-assigned. freeze() returns the same object that was passed in.',
'Object.fromEntries': 'The Object.fromEntries() static method transforms a list of key-value pairs into an object.',
'Object.getOwnPropertyDescriptor': 'The Object.getOwnPropertyDescriptor() static method returns an object describing the configuration of a specific property on a given object (that is, one directly present on an object and not in the object\'s prototype chain). The object returned is mutable but mutating it has no effect on the original property\'s configuration.',
'Object.getOwnPropertyDescriptors': 'The Object.getOwnPropertyDescriptors() static method returns all own property descriptors of a given object.',
'Object.getOwnPropertyNames': 'The Object.getOwnPropertyNames() static method returns an array of all properties (including non-enumerable properties except for those which use Symbol) found directly in a given object.',
'Object.getOwnPropertySymbols': 'The Object.getOwnPropertySymbols() static method returns an array of all symbol properties found directly upon a given object.',
'Object.getPrototypeOf': 'The Object.getPrototypeOf() static method returns the prototype (i.e., the value of the internal [[Prototype]] property) of the specified object.',
'Object.groupBy': 'The Object.groupBy() static method groups the elements of a given iterable according to the string values returned by a provided callback function. The returned object has separate properties for each group, containing arrays with the elements in the group.',
'Object.hasOwn': 'The Object.hasOwn() static method returns true if the specified object has the indicated property as its _own_ property. If the property is inherited, or does not exist, the method returns false.',
'Object.is': 'The Object.is() static method determines whether two values are the same value.',
'Object.isExtensible': 'The Object.isExtensible() static method determines if an object is extensible (whether it can have new properties added to it).',
'Object.isFrozen': 'The Object.isFrozen() static method determines if an object is frozen.',
'Object.isSealed': 'The Object.isSealed() static method determines if an object is sealed.',
'Object.keys': 'The Object.keys() static method returns an array of a given object\'s own enumerable string-keyed property names.',
'Object.preventExtensions': 'The Object.preventExtensions() static method prevents new properties from ever being added to an object (i.e., prevents future extensions to the object). It also prevents the object\'s prototype from being re-assigned.',
'Object.seal': 'The Object.seal() static method _seals_ an object. Sealing an object prevents extensions and makes existing properties non-configurable. A sealed object has a fixed set of properties: new properties cannot be added, existing properties cannot be removed, their enumerability and configurability cannot be changed, and its prototype cannot be re-assigned. Values of existing properties can still be changed as long as they are writable. seal() returns the same object that was passed in.',
'Object.setPrototypeOf': 'The Object.setPrototypeOf() static method sets the prototype (i.e., the internal [[Prototype]] property) of a specified object to another object or null.',
'Object.values': 'The Object.values() static method returns an array of a given object\'s own enumerable string-keyed property values.',
'Promise': 'The Promise object represents the eventual completion (or failure) of an asynchronous operation and its resulting value.',
'Promise.all': 'The Promise.all() static method takes an iterable of promises as input and returns a single Promise. This returned promise fulfills when all of the input\'s promises fulfill (including when an empty iterable is passed), with an array of the fulfillment values. It rejects when any of the input\'s promises rejects, with this first rejection reason.',
'Promise.allSettled': 'The Promise.allSettled() static method takes an iterable of promises as input and returns a single Promise. This returned promise fulfills when all of the input\'s promises settle (including when an empty iterable is passed), with an array of objects that describe the outcome of each promise.',
'Promise.any': 'The Promise.any() static method takes an iterable of promises as input and returns a single Promise. This returned promise fulfills when any of the input\'s promises fulfills, with this first fulfillment value. It rejects when all of the input\'s promises reject (including when an empty iterable is passed), with an AggregateError containing an array of rejection reasons.',
'Promise.race': 'The Promise.race() static method takes an iterable of promises as input and returns a single Promise. This returned promise settles with the eventual state of the first promise that settles.',
'Promise.reject': 'The Promise.reject() static method returns a Promise object that is rejected with a given reason.',
'Promise.resolve': 'The Promise.resolve() static method "resolves" a given value to a Promise. If the value is a promise, that promise is returned; if the value is a thenable, Promise.resolve() will call the then() method with two callbacks it prepared; otherwise the returned promise will be fulfilled with the value.',
'Promise.try': 'The Promise.try() static method takes a callback of any kind (returns or throws, synchronously or asynchronously) and wraps its result in a Promise.',
'Promise.withResolvers': 'The Promise.withResolvers() static method returns an object containing a new Promise object and two functions to resolve or reject it, corresponding to the two parameters passed to the executor of the Promise() constructor.',
'Proxy': 'The Proxy object enables you to create a proxy for another object, which can intercept and redefine fundamental operations for that object.',
'Proxy.revocable': 'The Proxy.revocable() static method creates a revocable Proxy object.',
'RangeError': 'The RangeError object indicates an error when a value is not in the set or range of allowed values.',
'ReferenceError': 'The ReferenceError object represents an error when a variable that doesn\'t exist (or hasn\'t yet been initialized) in the current scope is referenced.',
'Reflect': 'The Reflect namespace object contains static methods for invoking interceptable JavaScript object internal methods. The methods are the same as those of proxy handlers.',
'Reflect.apply': 'The Reflect.apply() static method calls a target function with arguments as specified.',
'Reflect.construct': 'The Reflect.construct() static method is like the new operator, but as a function. It is equivalent to calling new target(...args). It additionally allows to specify a different new.target value.',
'Reflect.defineProperty': 'The Reflect.defineProperty() static method is like Object.defineProperty() but returns a Boolean.',
'Reflect.deleteProperty': 'The Reflect.deleteProperty() static method is like the delete operator, but as a function. It deletes a property from an object.',
'Reflect.get': 'The Reflect.get() static method is like the property accessor syntax, but as a function.',
'Reflect.getOwnPropertyDescriptor': 'The Reflect.getOwnPropertyDescriptor() static method is like Object.getOwnPropertyDescriptor(). It returns a property descriptor of the given property if it exists on the object, undefined otherwise.',
'Reflect.getPrototypeOf': 'The Reflect.getPrototypeOf() static method is like Object.getPrototypeOf(). It returns the prototype of the specified object.',
'Reflect.has': 'The Reflect.has() static method is like the in operator, but as a function.',
'Reflect.isExtensible': 'The Reflect.isExtensible() static method is like Object.isExtensible(). It determines if an object is extensible (whether it can have new properties added to it).',
'Reflect.ownKeys': 'The Reflect.ownKeys() static method returns an array of the target object\'s own property keys.',
'Reflect.preventExtensions': 'The Reflect.preventExtensions() static method is like Object.preventExtensions(). It prevents new properties from ever being added to an object (i.e., prevents future extensions to the object).',
'Reflect.set': 'The Reflect.set() static method is like the property accessor and assignment syntax, but as a function.',
'Reflect.setPrototypeOf': 'The Reflect.setPrototypeOf() static method is like Object.setPrototypeOf() but returns a Boolean. It sets the prototype (i.e., the internal [[Prototype]] property) of a specified object.',
'RegExp': 'The RegExp object is used for matching text with a pattern.',
'RegExp.escape': 'The RegExp.escape() static method escapes any potential regex syntax characters in a string, and returns a new string that can be safely used as a literal pattern for the RegExp() constructor.',
'RegExp.input': 'The RegExp.input static accessor property returns the string against which a regular expression is matched. RegExp.$_ is an alias for this property.',
'RegExp.lastMatch': 'The RegExp.lastMatch static accessor property returns the last matched substring. RegExp["$&"] is an alias for this property.',
'RegExp.lastParen': 'The RegExp.lastParen static accessor property returns the last parenthesized substring match, if any. RegExp["$+"] is an alias for this property.',
'RegExp.leftContext': 'The RegExp.leftContext static accessor property returns the substring preceding the most recent match. RegExp["$"] is an alias for this property.',
'RegExp.n': 'The RegExp.$1, …, RegExp.$9 static accessor properties return parenthesized substring matches.',
'RegExp.rightContext': 'The RegExp.rightContext static accessor property returns the substring following the most recent match. RegExp["$\'"] is an alias for this property.',
'Set': 'The Set object lets you store unique values of any type, whether primitive values or object references.',
'SharedArrayBuffer': 'The SharedArrayBuffer object is used to represent a generic raw binary data buffer, similar to the ArrayBuffer object, but in a way that they can be used to create views on shared memory. A SharedArrayBuffer is not a Transferable Object, unlike an ArrayBuffer which is transferable.',
'String': 'The String object is used to represent and manipulate a sequence of characters.',
'String.fromCharCode': 'The String.fromCharCode() static method returns a string created from the specified sequence of UTF-16 code units.',
'String.fromCodePoint': 'The String.fromCodePoint() static method returns a string created from the specified sequence of code points.',
'String.raw': 'The String.raw() static method is a tag function of template literals. This is similar to the r prefix in Python, or the @ prefix in C# for string literals. It\'s used to get the raw string form of template literals — that is, substitutions (e.g., ${foo}) are processed, but escape sequences (e.g., \\n) are not.',
'SuppressedError': 'The SuppressedError object represents an error generated while handing another error. It is generated during resource disposal using using or await using.',
'Symbol': 'Symbol is a built-in object whose constructor returns a symbol primitive — also called a Symbol value or just a Symbol — that\'s guaranteed to be unique. Symbols are often used to add unique property keys to an object that won\'t collide with keys any other code might add to the object, and which are hidden from any mechanisms other code will typically use to access the object. That enables a form of weak encapsulation, or a weak form of information hiding.',
'Symbol.asyncDispose': 'The Symbol.asyncDispose static data property represents the well-known symbol Symbol.asyncDispose. The await using declaration looks up this symbol on the variable initializer for the method to call when the variable goes out of scope.',
'Symbol.asyncIterator': 'The Symbol.asyncIterator static data property represents the well-known symbol Symbol.asyncIterator. The async iterable protocol looks up this symbol for the method that returns the async iterator for an object. In order for an object to be async iterable, it must have a [Symbol.asyncIterator] key.',
'Symbol.dispose': 'The Symbol.dispose static data property represents the well-known symbol Symbol.dispose. The using declaration looks up this symbol on the variable initializer for the method to call when the variable goes out of scope.',
'Symbol.for': 'The Symbol.for() static method searches for existing symbols in a runtime-wide symbol registry with the given key and returns it if found. Otherwise a new symbol gets created in the global symbol registry with this key.',
'Symbol.hasInstance': 'The Symbol.hasInstance static data property represents the well-known symbol Symbol.hasInstance. The instanceof operator looks up this symbol on its right-hand operand for the method used to determine if the constructor object recognizes an object as its instance.',
'Symbol.isConcatSpreadable': 'The Symbol.isConcatSpreadable static data property represents the well-known symbol Symbol.isConcatSpreadable. The Array.prototype.concat() method looks up this symbol on each object being concatenated to determine if it should be treated as an array-like object and flattened to its array elements.',
'Symbol.iterator': 'The Symbol.iterator static data property represents the well-known symbol Symbol.iterator. The iterable protocol looks up this symbol for the method that returns the iterator for an object. In order for an object to be iterable, it must have a [Symbol.iterator] key.',
'Symbol.keyFor': 'The Symbol.keyFor() static method retrieves a shared symbol key from the global symbol registry for the given symbol.',
'Symbol.match': 'The Symbol.match static data property represents the well-known symbol Symbol.match. The String.prototype.match() method looks up this symbol on its first argument for the method used to match an input string against the current object. This symbol is also used to determine if an object should be treated as a regex.',
'Symbol.matchAll': 'The Symbol.matchAll static data property represents the well-known symbol Symbol.matchAll. The String.prototype.matchAll() method looks up this symbol on its first argument for the method that returns an iterator, that yields matches of the current object against a string.',
'Symbol.replace': 'The Symbol.replace static data property represents the well-known symbol Symbol.replace. The String.prototype.replace() and String.prototype.replaceAll() methods look up this symbol on their first argument for the method that replaces substrings matched by the current object.',
'Symbol.search': 'The Symbol.search static data property represents the well-known symbol Symbol.search. The String.prototype.search() method looks up this symbol on its first argument for the method that returns the index within a string that matches the current object.',
'Symbol.species': 'The Symbol.species static data property represents the well-known symbol Symbol.species. Methods that create copies of an object may look up this symbol on the object for the constructor function to use when creating the copy.',
'Symbol.split': 'The Symbol.split static data property represents the well-known symbol Symbol.split. The String.prototype.split() method looks up this symbol on its first argument for the method that splits a string at the indices that match the current object.',
'Symbol.toPrimitive': 'The Symbol.toPrimitive static data property represents the well-known symbol Symbol.toPrimitive. All type coercion algorithms look up this symbol on objects for the method that accepts a preferred type and returns a primitive representation of the object, before falling back to using the object\'s valueOf() and toString() methods.',
'Symbol.toStringTag': 'The Symbol.toStringTag static data property represents the well-known symbol Symbol.toStringTag. Object.prototype.toString() looks up this symbol on the this value for the property containing a string that represents the type of the object.',
'Symbol.unscopables': 'The Symbol.unscopables static data property represents the well-known symbol Symbol.unscopables. The with statement looks up this symbol on the scope object for a property containing a collection of properties that should not become bindings within the with environment.',
'SyntaxError': 'The SyntaxError object represents an error when trying to interpret syntactically invalid code. It is thrown when the JavaScript engine encounters tokens or token order that does not conform to the syntax of the language when parsing code.',
'Temporal': 'The Temporal object enables date and time management in various scenarios, including built-in time zone and calendar representation, wall-clock time conversions, arithmetics, formatting, and more. It is designed as a full replacement for the Date object.',
'TypeError': 'The TypeError object represents an error when an operation could not be performed, typically (but not exclusively) when a value is not of the expected type.',
'TypedArray': 'A _TypedArray_ object describes an array-like view of an underlying binary data buffer. There is no global property named TypedArray, nor is there a directly visible TypedArray constructor. Instead, there are a number of different global properties, whose values are typed array constructors for specific element types, listed below. On the following pages you will find common properties and methods that can be used with any typed array containing elements of any type.',
'TypedArray.BYTES_PER_ELEMENT': 'The TypedArray.BYTES_PER_ELEMENT static data property represents the size in bytes of each element in a typed array.',
'TypedArray.from': 'The TypedArray.from() static method creates a new typed array from an array-like or iterable object. This method is nearly the same as Array.from().',
'TypedArray.of': 'The TypedArray.of() static method creates a new typed array from a variable number of arguments. This method is nearly the same as Array.of().',
'URIError': 'The URIError object represents an error when a global URI handling function was used in a wrong way.',
'Uint16Array': 'The Uint16Array typed array represents an array of 16-bit unsigned integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'Uint32Array': 'The Uint32Array typed array represents an array of 32-bit unsigned integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'Uint8Array': 'The Uint8Array typed array represents an array of 8-bit unsigned integers. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'Uint8Array.fromBase64': 'The Uint8Array.fromBase64() static method creates a new Uint8Array object from a base64-encoded string.',
'Uint8Array.fromHex': 'The Uint8Array.fromHex() static method creates a new Uint8Array object from a hexadecimal string.',
'Uint8ClampedArray': 'The Uint8ClampedArray typed array represents an array of 8-bit unsigned integers clamped to 0–255. The contents are initialized to 0 unless initialization data is explicitly provided. Once established, you can reference elements in the array using the object\'s methods, or using standard array index syntax (that is, using bracket notation).',
'WeakMap': 'A WeakMap is a collection of key/value pairs whose keys must be objects or non-registered symbols, with values of any arbitrary JavaScript type, and which does not create strong references to its keys. That is, an object\'s presence as a key in a WeakMap does not prevent the object from being garbage collected. Once an object used as a key has been collected, its corresponding values in any WeakMap become candidates for garbage collection as well — as long as they aren\'t strongly referred to elsewhere. The only primitive type that can be used as a WeakMap key is symbol — more specifically, non-registered symbols — because non-registered symbols are guaranteed to be unique and cannot be re-created.',
'WeakRef': 'A WeakRef object lets you hold a weak reference to another object, without preventing that object from getting garbage-collected.',
'WeakSet': 'A WeakSet is a collection of garbage-collectable values, including objects and non-registered symbols. A value in the WeakSet may only occur once. It is unique in the WeakSet\'s collection.',
'XMLHttpRequest': 'XMLHttpRequest (XHR) objects are used to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing.',
'decodeURI': 'The decodeURI() function decodes a Uniform Resource Identifier (URI) previously created by encodeURI() or a similar routine.',
'decodeURIComponent': 'The decodeURIComponent() function decodes a Uniform Resource Identifier (URI) component previously created by encodeURIComponent() or by a similar routine.',
'encodeURI': 'The encodeURI() function encodes a URI by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two surrogate characters). Compared to encodeURIComponent(), this function encodes fewer characters, preserving those that are part of the URI syntax.',
'encodeURIComponent': 'The encodeURIComponent() function encodes a URI by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two surrogate characters). Compared to encodeURI(), this function encodes more characters, including those that are part of the URI syntax.',
'escape': 'The escape() function computes a new string in which certain characters have been replaced by hexadecimal escape sequences.',
'eval': 'The eval() function evaluates JavaScript code represented as a string and returns its completion value. The source is parsed as a script.',
'globalThis': 'The globalThis global property contains the global this value, which is usually akin to the global object.',
'isFinite': 'The isFinite() function determines whether a value is finite, first converting the value to a number if necessary. A finite number is one that\'s not NaN or ±Infinity. Because coercion inside the isFinite() function can be surprising, you may prefer to use Number.isFinite().',
'isNaN': 'The isNaN() function determines whether a value is NaN, first converting the value to a number if necessary. Because coercion inside the isNaN() function can be surprising, you may prefer to use Number.isNaN().',
'parseFloat': 'The parseFloat() function parses a string argument and returns a floating point number.',
'parseInt': 'The parseInt() function parses a string argument and returns an integer of the specified radix (the base in mathematical numeral systems).',
'undefined': 'The undefined global property represents the primitive value undefined. It is one of JavaScript\'s primitive types.',
'unescape': 'The unescape() function computes a new string in which hexadecimal escape sequences are replaced with the characters that they represent. The escape sequences might be introduced by a function like escape().',
};
jush.api.php2 = jush.api.lowercase_keys({
'clone': '(object $object, array $withProperties = []): object\nClone object',
'BackedEnum::from': '(int|string $value): static\nMaps a scalar to an enum instance',
'BackedEnum::tryFrom': '(int|string $value): ?static\nMaps a scalar to an enum instance or null',
'Closure::bind': '(Closure $closure, ?object $newThis, object|string|null $newScope = "static"): ?Closure\nDuplicates a closure with a specific bound object and class scope',
'Closure::fromCallable': '(callable $callback): Closure\nConverts a callable into a closure',
'Closure::getCurrent': '(): Closure\nReturns the currently executing closure',
'Fiber::getCurrent': '(): ?Fiber\nGets the currently executing Fiber instance',
'Fiber::suspend': '(mixed $value = null): mixed\nSuspends execution of the current fiber',
'UnitEnum::cases': '(): array\nGenerates a list of cases on an enum',
'WeakReference::create': '(object $object): WeakReference\nCreate a new weak reference',
'array_all': '(array $array, callable $callback): bool\nChecks if all array elements satisfy a callback function',
'array_any': '(array $array, callable $callback): bool\nChecks if at least one array element satisfies a callback function',
'array_change_key_case': '(array $array, int $case = CASE_LOWER): array\nChanges the case of all keys in an array',
'array_chunk': '(array $array, int $length, bool $preserve_keys = false): array\nSplit an array into chunks',
'array_column': '(array $array, int|string|null $column_key, int|string|null $index_key = null): array\nReturn the values from a single column in the input array',
'array_combine': '(array $keys, array $values): array\nCreates an array by using one array for keys and another for its values',
'array_count_values': '(array $array): array\nCounts the occurrences of each distinct value in an array',
'array_diff_assoc': '(array $array, array ...$arrays): array\nComputes the difference of arrays with additional index check',
'array_diff_key': '(array $array, array ...$arrays): array\nComputes the difference of arrays using keys for comparison',
'array_diff_uassoc': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the difference of arrays with additional index check which is performed by a user supplied callback function',
'array_diff_ukey': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the difference of arrays using a callback function on the keys for comparison',
'array_diff': '(array $array, array ...$arrays): array\nComputes the difference of arrays',
'array_fill_keys': '(array $keys, mixed $value): array\nFill an array with values, specifying keys',
'array_fill': '(int $start_index, int $count, mixed $value): array\nFill an array with values',
'array_filter': '(array $array, ?callable $callback = null, int $mode = ?): array\nFilters elements of an array using a callback function',
'array_find_key': '(array $array, callable $callback): mixed\nReturns the key of the first element satisfying a callback function',
'array_find': '(array $array, callable $callback): mixed\nReturns the first element satisfying a callback function',
'array_first': '(array $array): mixed\nGets the first value of an array',
'array_flip': '(array $array): array\nExchanges all keys with their associated values in an array',
'array_intersect_assoc': '(array $array, array ...$arrays): array\nComputes the intersection of arrays with additional index check',
'array_intersect_key': '(array $array, array ...$arrays): array\nComputes the intersection of arrays using keys for comparison',
'array_intersect_uassoc': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the intersection of arrays with additional index check, compares indexes by a callback function',
'array_intersect_ukey': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the intersection of arrays using a callback function on the keys for comparison',
'array_intersect': '(array $array, array ...$arrays): array\nComputes the intersection of arrays',
'array_is_list': '(array $array): bool\nChecks whether a given $array is a list',
'array_key_exists': '(string|int|float|bool|resource|null $key, array $array): bool\nChecks if the given key or index exists in the array',
'array_key_first': '(array $array): int|string|null\nGets the first key of an array',
'array_key_last': '(array $array): int|string|null\nGets the last key of an array',
'array_keys': '(array $array, mixed $filter_value, bool $strict = false): array\nReturn all the keys or a subset of the keys of an array',
'array_last': '(array $array): mixed\nGets the last value of an array',
'array_map': '(?callable $callback, array $array, array ...$arrays): array\nApplies the callback to the elements of the given arrays',
'array_merge_recursive': '(array ...$arrays): array\nMerge one or more arrays recursively',
'array_merge': '(array ...$arrays): array\nMerge one or more arrays',
'array_multisort': '(array &$array1, mixed $array1_sort_order = SORT_ASC, mixed $array1_sort_flags = SORT_REGULAR, mixed ...$rest): true\nSort multiple or multi-dimensional arrays',
'array_pad': '(array $array, int $length, mixed $value): array\nPad array to the specified length with a value',
'array_pop': '(array &$array): mixed\nPop the element off the end of array',
'array_product': '(array $array): int|float\nCalculate the product of values in an array',
'array_push': '(array &$array, mixed ...$values): int\nPush one or more elements onto the end of array',
'array_rand': '(array $array, int $num = 1): int|string|array\nPick one or more random keys out of an array',
'array_reduce': '(array $array, callable $callback, mixed $initial = null): mixed\nIteratively reduce the array to a single value using a callback function',
'array_replace_recursive': '(array $array, array ...$replacements): array\nReplaces elements from passed arrays into the first array recursively',
'array_replace': '(array $array, array ...$replacements): array\nReplaces elements from passed arrays into the first array',
'array_reverse': '(array $array, bool $preserve_keys = false): array\nReturn an array with elements in reverse order',
'array_search': '(mixed $needle, array $haystack, bool $strict = false): int|string|false\nSearches the array for a given value and returns the first corresponding key if successful',
'array_shift': '(array &$array): mixed\nShift an element off the beginning of array',
'array_slice': '(array $array, int $offset, ?int $length = null, bool $preserve_keys = false): array\nExtract a slice of the array',
'array_splice': '(array &$array, int $offset, ?int $length = null, mixed $replacement = []): array\nRemove a portion of the array and replace it with something else',
'array_sum': '(array $array): int|float\nCalculate the sum of values in an array',
'array_udiff_assoc': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the difference of arrays with additional index check, compares data by a callback function',
'array_udiff_uassoc': '(array $array, array ...$arrays, callable $value_compare_func, callable $key_compare_func): array\nComputes the difference of arrays with additional index check, compares data and indexes by a callback function',
'array_udiff': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the difference of arrays by using a callback function for data comparison',
'array_uintersect_assoc': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the intersection of arrays with additional index check, compares data by a callback function',
'array_uintersect_uassoc': '(array $array1, array ...$arrays, callable $value_compare_func, callable $key_compare_func): array\nComputes the intersection of arrays with additional index check, compares data and indexes by separate callback functions',
'array_uintersect': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the intersection of arrays, compares data by a callback function',
'array_unique': '(array $array, int $flags = SORT_STRING): array\nRemoves duplicate values from an array',
'array_unshift': '(array &$array, mixed ...$values): int\nPrepend one or more elements to the beginning of an array',
'array_values': '(array $array): array\nReturn all the values of an array',
'array_walk_recursive': '(array|object &$array, callable $callback, mixed $arg = null): true\nApply a user function recursively to every member of an array',
'array_walk': '(array|object &$array, callable $callback, mixed $arg = null): true\nApply a user supplied function to every member of an array',
'array': '(mixed ...$values): array\nCreate an array',
'arsort': '(array &$array, int $flags = SORT_REGULAR): true\nSort an array in descending order and maintain index association',
'asort': '(array &$array, int $flags = SORT_REGULAR): true\nSort an array in ascending order and maintain index association',
'compact': '(array|string $var_name, array|string ...$var_names): array\nCreate array containing variables and their values',
'count': '(Countable|array $value, int $mode = COUNT_NORMAL): int\nCounts all elements in an array or in a Countable object',
'current': '(array|object $array): mixed\nReturn the current element in an array',
'each': '(array|object &$array): array\nReturn the current key and value pair from an array and advance the array cursor',
'end': '(array|object &$array): mixed\nSet the internal pointer of an array to its last element',
'extract': '(array &$array, int $flags = EXTR_OVERWRITE, string $prefix = ""): int\nImport variables into the current symbol table from an array',
'in_array': '(mixed $needle, array $haystack, bool $strict = false): bool\nChecks if a value exists in an array',
'key_exists': 'Alias of array_key_exists',
'key': '(array|object $array): int|string|null\nFetch a key from an array',
'krsort': '(array &$array, int $flags = SORT_REGULAR): true\nSort an array by key in descending order',
'ksort': '(array &$array, int $flags = SORT_REGULAR): true\nSort an array by key in ascending order',
'list': '(mixed $var, mixed ...$vars = ?): array\nAssign variables as if they were an array',
'natcasesort': '(array &$array): true\nSort an array using a case insensitive "natural order" algorithm',
'natsort': '(array &$array): true\nSort an array using a "natural order" algorithm',
'next': '(array|object &$array): mixed\nAdvance the internal pointer of an array',
'pos': 'Alias of current',
'prev': '(array|object &$array): mixed\nRewind the internal array pointer',
'range': '(string|int|float $start, string|int|float $end, int|float $step = 1): array\nCreate an array containing a range of elements',
'reset': '(array|object &$array): mixed\nSet the internal pointer of an array to its first element',
'rsort': '(array &$array, int $flags = SORT_REGULAR): true\nSort an array in descending order',
'shuffle': '(array &$array): true\nShuffle an array',
'sizeof': 'Alias of count',
'sort': '(array &$array, int $flags = SORT_REGULAR): true\nSort an array in ascending order',
'uasort': '(array &$array, callable $callback): true\nSort an array with a user-defined comparison function and maintain index association',
'uksort': '(array &$array, callable $callback): true\nSort an array by keys using a user-defined comparison function',
'usort': '(array &$array, callable $callback): true\nSort an array by values using a user-defined comparison function',
'class_alias': '(string $class, string $alias, bool $autoload = true): bool\nCreates an alias for a class',
'class_exists': '(string $class, bool $autoload = true): bool\nChecks if the class has been defined',
'enum_exists': '(string $enum, bool $autoload = true): bool\nChecks if the enum has been defined',
'get_called_class': '(): string\nThe "Late Static Binding" class name',
'get_class_methods': '(object|string $object_or_class): array\nGets the class methods\' names',
'get_class_vars': '(string $class): array\nGet the default properties of the class',
'get_class': '(object $object = ?): string\nReturns the name of the class of an object',
'get_declared_classes': '(): array\nReturns an array with the name of the defined classes',
'get_declared_interfaces': '(): array\nReturns an array of all declared interfaces',
'get_declared_traits': '(): array\nReturns an array of all declared traits',
'get_mangled_object_vars': '(object $object): array\nReturns an array of mangled object properties',
'get_object_vars': '(object $object): array\nGets the properties of the given object',
'get_parent_class': '(object|string $object_or_class = ?): string|false\nRetrieves the parent class name for object or class',
'interface_exists': '(string $interface, bool $autoload = true): bool\nChecks if the interface has been defined',
'is_a': '(mixed $object_or_class, string $class, bool $allow_string = false): bool\nChecks whether the object is of a given type or subtype',
'is_subclass_of': '(mixed $object_or_class, string $class, bool $allow_string = true): bool\nChecks if the object has this class as one of its parents or implements it',
'method_exists': '(object|string $object_or_class, string $method): bool\nChecks if the class method exists',
'property_exists': '(object|string $object_or_class, string $property): bool\nChecks if the object or class has a property',
'trait_exists': '(string $trait, bool $autoload = true): bool\nChecks if the trait exists',
'DateInterval::createFromDateString': '(string $datetime): DateInterval\nSets up a DateInterval from the relative parts of the string',
'date_interval_create_from_date_string': 'Alias of DateInterval::createFromDateString',
'DatePeriod::createFromISO8601String': '(string $specification, int $options = ?): static\nCreates a new DatePeriod object from an ISO8601 string',
'date_add': 'Alias of DateTime::add',
'DateTime::createFromFormat': '(string $format, string $datetime, ?DateTimeZone $timezone = null): DateTime|false\nParses a time string according to a specified format',
'date_create_from_format': 'Alias of DateTime::createFromFormat',
'DateTime::createFromImmutable': '(DateTimeImmutable $object): static\nReturns new DateTime instance encapsulating the given DateTimeImmutable object',
'DateTime::createFromInterface': '(DateTimeInterface $object): DateTime\nReturns new DateTime object encapsulating the given DateTimeInterface object',
'DateTime::createFromTimestamp': '(int|float $timestamp): static\nCreates an instance from a Unix timestamp',
'date_modify': 'Alias of DateTime::modify',
'date_date_set': 'Alias of DateTime::setDate',
'date_isodate_set': 'Alias of DateTime::setISODate',
'date_time_set': 'Alias of DateTime::setTime',
'date_timestamp_set': 'Alias of DateTime::setTimestamp',
'date_timezone_set': 'Alias of DateTime::setTimezone',
'date_sub': 'Alias of DateTime::sub',
'date_create_immutable': '(string $datetime = "now", ?DateTimeZone $timezone = null): DateTimeImmutable|false\ncreate a new DateTimeImmutable object',
'DateTimeImmutable::createFromFormat': '(string $format, string $datetime, ?DateTimeZone $timezone = null): DateTimeImmutable|false\nParses a time string according to a specified format',
'date_create_immutable_from_format': 'Alias of DateTimeImmutable::createFromFormat',
'DateTimeImmutable::createFromInterface': '(DateTimeInterface $object): DateTimeImmutable\nReturns new DateTimeImmutable object encapsulating the given DateTimeInterface object',
'DateTimeImmutable::createFromMutable': '(DateTime $object): static\nReturns new DateTimeImmutable instance encapsulating the given DateTime object',
'DateTimeImmutable::createFromTimestamp': '(int|float $timestamp): static\nCreates an instance from a Unix timestamp',
'DateTimeImmutable::getLastErrors': '(): array|false\nReturns the warnings and errors',
'date_diff': 'Alias of DateTime::diff',
'date_format': 'Alias of DateTime::format',
'date_offset_get': 'Alias of DateTime::getOffset',
'date_timestamp_get': 'Alias of DateTime::getTimestamp',
'date_timezone_get': 'Alias of DateTime::getTimezone',
'timezone_open': 'Alias of DateTimeZone::__construct',
'timezone_location_get': 'Alias of DateTimeZone::getLocation',
'timezone_name_get': 'Alias of DateTimeZone::getName',
'timezone_offset_get': 'Alias of DateTimeZone::getOffset',
'timezone_transitions_get': 'Alias of DateTimeZone::getTransitions',
'DateTimeZone::listAbbreviations': '(): array\nReturns associative array containing dst, offset and the timezone name',
'timezone_abbreviations_list': 'Alias of DateTimeZone::listAbbreviations',
'DateTimeZone::listIdentifiers': '(int $timezoneGroup = DateTimeZone::ALL, ?string $countryCode = null): array\nReturns a numerically indexed array containing all defined timezone identifiers',
'timezone_identifiers_list': 'Alias of DateTimeZone::listIdentifiers',
'checkdate': '(int $month, int $day, int $year): bool\nValidate a Gregorian date',
'date_create': '(string $datetime = "now", ?DateTimeZone $timezone = null): DateTime|false\ncreate a new DateTime object',
'date_default_timezone_get': '(): string\nGets the default timezone used by all date/time functions in a script',
'date_default_timezone_set': '(string $timezoneId): bool\nSets the default timezone used by all date/time functions in a script',
'date_get_last_errors': 'Alias of DateTimeImmutable::getLastErrors',
'date_interval_format': 'Alias of DateInterval::format',
'date_parse_from_format': '(string $format, string $datetime): array\nGet info about given date formatted according to the specified format',
'date_parse': '(string $datetime): array\nReturns associative array with detailed info about given date/time',
'date_sun_info': '(int $timestamp, float $latitude, float $longitude): array\nReturns an array with information about sunset/sunrise and twilight begin/end',
'date_sunrise': '(int $timestamp, int $returnFormat = SUNFUNCS_RET_STRING, ?float $latitude = null, ?float $longitude = null, ?float $zenith = null, ?float $utcOffset = null): string|int|float|false\nReturns time of sunrise for a given day and location',
'date_sunset': '(int $timestamp, int $returnFormat = SUNFUNCS_RET_STRING, ?float $latitude = null, ?float $longitude = null, ?float $zenith = null, ?float $utcOffset = null): string|int|float|false\nReturns time of sunset for a given day and location',
'date': '(string $format, ?int $timestamp = null): string\nFormat a Unix timestamp',
'getdate': '(?int $timestamp = null): array\nGet date/time information',
'gettimeofday': '(bool $as_float = false): array|float\nGet current time',
'gmdate': '(string $format, ?int $timestamp = null): string\nFormat a GMT/UTC date/time',
'gmmktime': '(int $hour, ?int $minute = null, ?int $second = null, ?int $month = null, ?int $day = null, ?int $year = null): int|false\nGet Unix timestamp for a GMT date',
'gmstrftime': '(string $format, ?int $timestamp = null): string|false\nFormat a GMT/UTC time/date according to locale settings',
'idate': '(string $format, ?int $timestamp = null): int|false\nFormat a local time/date part as integer',
'localtime': '(?int $timestamp = null, bool $associative = false): array\nGet the local time',
'microtime': '(bool $as_float = false): string|float\nReturn current Unix timestamp with microseconds',
'mktime': '(int $hour, ?int $minute = null, ?int $second = null, ?int $month = null, ?int $day = null, ?int $year = null): int|false\nGet Unix timestamp for a date',
'strftime': '(string $format, ?int $timestamp = null): string|false\nFormat a local time/date according to locale settings',
'strptime': '(string $timestamp, string $format): array|false\nParse a time/date generated with strftime',
'strtotime': '(string $datetime, ?int $baseTimestamp = null): int|false\nParse about any English textual datetime description into a Unix timestamp',
'time': '(): int\nReturn current Unix timestamp',
'timezone_name_from_abbr': '(string $abbr, int $utcOffset = -1, int $isDST = -1): string|false\nReturns a timezone name by guessing from abbreviation and UTC offset',
'timezone_version_get': '(): string\nGets the version of the timezonedb',
'chdir': '(string $directory): bool\nChange directory',
'chroot': '(string $directory): bool\nChange the root directory',
'closedir': '(?resource $dir_handle = null): void\nClose directory handle',
'dir': '(string $directory, ?resource $context = null): Directory|false\nReturn an instance of the Directory class',
'getcwd': '(): string|false\nGets the current working directory',
'opendir': '(string $directory, ?resource $context = null): resource|false\nOpen directory handle',
'readdir': '(?resource $dir_handle = null): string|false\nRead entry from directory handle',
'rewinddir': '(?resource $dir_handle = null): void\nRewind directory handle',
'scandir': '(string $directory, int $sorting_order = SCANDIR_SORT_ASCENDING, ?resource $context = null): array|false\nList files and directories inside the specified path',
'debug_backtrace': '(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT, int $limit = ?): array\nGenerates a backtrace',
'debug_print_backtrace': '(int $options = ?, int $limit = ?): void\nPrints a backtrace',
'error_clear_last': '(): void\nClear the most recent error',
'error_get_last': '(): ?array\nGet the last occurred error',
'error_log': '(string $message, int $message_type = ?, ?string $destination = null, ?string $additional_headers = null): bool\nSend an error message to the defined error handling routines',
'error_reporting': '(?int $error_level = null): int\nSets which PHP errors are reported',
'get_error_handler': '(): ?callable\nGets the user-defined error handler function',
'get_exception_handler': '(): ?callable\nGets the user-defined exception handler function',
'restore_error_handler': '(): true\nRestores the previous error handler function',
'restore_exception_handler': '(): true\nRestores the previously defined exception handler function',
'set_error_handler': '(?callable $callback, int $error_levels = E_ALL): ?callable\nSets a user-defined error handler function',
'set_exception_handler': '(?callable $callback): ?callable\nSets a user-defined exception handler function',
'trigger_error': '(string $message, int $error_level = E_USER_NOTICE): true\nGenerates a user-level error/warning/notice message',
'user_error': 'Alias of trigger_error',
'escapeshellarg': '(string $arg): string\nEscape a string to be used as a shell argument',
'escapeshellcmd': '(string $command): string\nEscape shell metacharacters',
'exec': '(string $command, array &$output = null, int &$result_code = null): string|false\nExecute an external program',
'passthru': '(string $command, int &$result_code = null): ?false\nExecute an external program and display raw output',
'proc_close': '(resource $process): int\nClose pipes to a process opened by proc_open, wait for it to terminate, and return its exit code',
'proc_get_status': '(resource $process): array\nGet information about a process opened by proc_open',
'proc_nice': '(int $priority): bool\nChange the priority of the current process',
'proc_open': '(array|string $command, array $descriptor_spec, array &$pipes, ?string $cwd = null, ?array $env_vars = null, ?array $options = null): resource|false\nExecute a command and open file pointers for input/output',
'proc_terminate': '(resource $process, int $signal = 15): bool\nKills a process opened by proc_open',
'shell_exec': '(string $command): string|false|null\nExecute command via shell and return the complete output as a string',
'system': '(string $command, int &$result_code = null): string|false\nExecute an external program and display the output',
'basename': '(string $path, string $suffix = ""): string\nReturns trailing name component of path',
'chgrp': '(string $filename, string|int $group): bool\nChanges file group',
'chmod': '(string $filename, int $permissions): bool\nChanges file mode',
'chown': '(string $filename, string|int $user): bool\nChanges file owner',
'clearstatcache': '(bool $clear_realpath_cache = false, string $filename = ""): void\nClears file status cache',
'copy': '(string $from, string $to, ?resource $context = null): bool\nCopies file',
'dirname': '(string $path, int $levels = 1): string\nReturns a parent directory\'s path',
'disk_free_space': '(string $directory): float|false\nReturns available space on filesystem or disk partition',
'disk_total_space': '(string $directory): float|false\nReturns the total size of a filesystem or disk partition',
'diskfreespace': 'Alias of disk_free_space',
'fclose': '(resource $stream): bool\nCloses an open file pointer',
'fdatasync': '(resource $stream): bool\nSynchronizes data (but not meta-data) to the file',
'feof': '(resource $stream): bool\nTests for end-of-file on a file pointer',
'fflush': '(resource $stream): bool\nFlushes the output to a file',
'fgetc': '(resource $stream): string|false\nGets character from file pointer',
'fgetcsv': '(resource $stream, ?int $length = null, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): array|false\nGets line from file pointer and parse for CSV fields',
'fgets': '(resource $stream, ?int $length = null): string|false\nGets line from file pointer',
'fgetss': '(resource $handle, int $length = ?, string $allowable_tags = ?): string\nGets line from file pointer and strip HTML tags',
'file_exists': '(string $filename): bool\nChecks whether a file or directory exists',
'file_get_contents': '(string $filename, bool $use_include_path = false, ?resource $context = null, int $offset = ?, ?int $length = null): string|false\nReads entire file into a string',
'file_put_contents': '(string $filename, mixed $data, int $flags = ?, ?resource $context = null): int|false\nWrite data to a file',
'file': '(string $filename, int $flags = ?, ?resource $context = null): array|false\nReads entire file into an array',
'fileatime': '(string $filename): int|false\nGets last access time of file',
'filectime': '(string $filename): int|false\nGets inode change time of file',
'filegroup': '(string $filename): int|false\nGets file group',
'fileinode': '(string $filename): int|false\nGets file inode',
'filemtime': '(string $filename): int|false\nGets file modification time',
'fileowner': '(string $filename): int|false\nGets file owner',
'fileperms': '(string $filename): int|false\nGets file permissions',
'filesize': '(string $filename): int|false\nGets file size',
'filetype': '(string $filename): string|false\nGets file type',
'flock': '(resource $stream, int $operation, int &$would_block = null): bool\nPortable advisory file locking',
'fnmatch': '(string $pattern, string $filename, int $flags = ?): bool\nMatch filename against a pattern',
'fopen': '(string $filename, string $mode, bool $use_include_path = false, ?resource $context = null): resource|false\nOpens file or URL',
'fpassthru': '(resource $stream): int\nOutput all remaining data on a file pointer',
'fputcsv': '(resource $stream, array $fields, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\", string $eol = "\\n"): int|false\nFormat line as CSV and write to file pointer',
'fputs': 'Alias of fwrite',
'fread': '(resource $stream, int $length): string|false\nBinary-safe file read',
'fscanf': '(resource $stream, string $format, mixed &...$vars): array|int|false|null\nParses input from a file according to a format',
'fseek': '(resource $stream, int $offset, int $whence = SEEK_SET): int\nSeeks on a file pointer',
'fstat': '(resource $stream): array|false\nGets information about a file using an open file pointer',
'fsync': '(resource $stream): bool\nSynchronizes changes to the file (including meta-data)',
'ftell': '(resource $stream): int|false\nReturns the current position of the file read/write pointer',
'ftruncate': '(resource $stream, int $size): bool\nTruncates a file to a given length',
'fwrite': '(resource $stream, string $data, ?int $length = null): int|false\nBinary-safe file write',
'glob': '(string $pattern, int $flags = ?): array|false\nFind pathnames matching a pattern',
'is_dir': '(string $filename): bool\nTells whether the filename is a directory',
'is_executable': '(string $filename): bool\nTells whether the filename is executable',
'is_file': '(string $filename): bool\nTells whether the filename is a regular file',
'is_link': '(string $filename): bool\nTells whether the filename is a symbolic link',
'is_readable': '(string $filename): bool\nTells whether a file exists and is readable',
'is_uploaded_file': '(string $filename): bool\nTells whether the file was uploaded via HTTP POST',
'is_writable': '(string $filename): bool\nTells whether the filename is writable',
'is_writeable': 'Alias of is_writable',
'lchgrp': '(string $filename, string|int $group): bool\nChanges group ownership of symlink',
'lchown': '(string $filename, string|int $user): bool\nChanges user ownership of symlink',
'link': '(string $target, string $link): bool\nCreate a hard link',
'linkinfo': '(string $path): int|false\nGets information about a link',
'lstat': '(string $filename): array|false\nGives information about a file or symbolic link',
'mkdir': '(string $directory, int $permissions = 0777, bool $recursive = false, ?resource $context = null): bool\nMakes directory',
'move_uploaded_file': '(string $from, string $to): bool\nMoves an uploaded file to a new location',
'parse_ini_file': '(string $filename, bool $process_sections = false, int $scanner_mode = INI_SCANNER_NORMAL): array|false\nParse a configuration file',
'parse_ini_string': '(string $ini_string, bool $process_sections = false, int $scanner_mode = INI_SCANNER_NORMAL): array|false\nParse a configuration string',
'pathinfo': '(string $path, int $flags = PATHINFO_ALL): array|string\nReturns information about a file path',
'pclose': '(resource $handle): int\nCloses process file pointer',
'popen': '(string $command, string $mode): resource|false\nOpens process file pointer',
'readfile': '(string $filename, bool $use_include_path = false, ?resource $context = null): int|false\nOutputs a file',
'readlink': '(string $path): string|false\nReturns the target of a symbolic link',
'realpath_cache_get': '(): array\nGet realpath cache entries',
'realpath_cache_size': '(): int\nGet realpath cache size',
'realpath': '(string $path): string|false\nReturns canonicalized absolute pathname',
'rename': '(string $from, string $to, ?resource $context = null): bool\nRenames a file or directory',
'rewind': '(resource $stream): bool\nRewind the position of a file pointer',
'rmdir': '(string $directory, ?resource $context = null): bool\nRemoves directory',
'set_file_buffer': 'Alias of stream_set_write_buffer',
'stat': '(string $filename): array|false\nGives information about a file',
'symlink': '(string $target, string $link): bool\nCreates a symbolic link',
'tempnam': '(string $directory, string $prefix): string|false\nCreate file with unique file name',
'tmpfile': '(): resource|false\nCreates a temporary file',
'touch': '(string $filename, ?int $mtime = null, ?int $atime = null): bool\nSets access and modification time of file',
'umask': '(?int $mask = null): int\nChanges the current umask',
'unlink': '(string $filename, ?resource $context = null): bool\nDeletes a file',
'fastcgi_finish_request': '(): bool\nFlushes all response data to the client',
'fpm_get_status': '(): array|false\nReturns the current FPM pool status',
'call_user_func_array': '(callable $callback, array $args): mixed\nCall a callback with an array of parameters',
'call_user_func': '(callable $callback, mixed ...$args): mixed\nCall the callback given by the first parameter',
'create_function': '(string $args, string $code): string\nCreate a function dynamically by evaluating a string of code',
'forward_static_call_array': '(callable $callback, array $args): mixed\nCall a static method and pass the arguments as array',
'forward_static_call': '(callable $callback, mixed ...$args): mixed\nCall a static method',
'func_get_arg': '(int $position): mixed\nReturn an item from the argument list',
'func_get_args': '(): array\nReturns an array comprising a function\'s argument list',
'func_num_args': '(): int\nReturns the number of arguments passed to the function',
'function_exists': '(string $function): bool\nReturn true if the given function has been defined',
'get_defined_functions': '(bool $exclude_disabled = true): array\nReturns an array of all defined functions',
'register_shutdown_function': '(callable $callback, mixed ...$args): void\nRegister a function for execution on shutdown',
'register_tick_function': '(callable $callback, mixed ...$args): bool\nRegister a function for execution on each tick',
'unregister_tick_function': '(callable $callback): void\nDe-register a function for execution on each tick',
'hash_algos': '(): array\nReturn a list of registered hashing algorithms',
'hash_copy': '(HashContext $context): HashContext\nCopy hashing context',
'hash_equals': '(string $known_string, string $user_string): bool\nTiming attack safe string comparison',
'hash_file': '(string $algo, string $filename, bool $binary = false, array $options = []): string|false\nGenerate a hash value using the contents of a given file',
'hash_final': '(HashContext $context, bool $binary = false): string\nFinalize an incremental hash and return resulting digest',
'hash_hkdf': '(string $algo, string $key, int $length = ?, string $info = "", string $salt = ""): string\nGenerate a HKDF key derivation of a supplied key input',
'hash_hmac_algos': '(): array\nReturn a list of registered hashing algorithms suitable for hash_hmac',
'hash_hmac_file': '(string $algo, string $filename, string $key, bool $binary = false): string|false\nGenerate a keyed hash value using the HMAC method and the contents of a given file',
'hash_hmac': '(string $algo, string $data, string $key, bool $binary = false): string\nGenerate a keyed hash value using the HMAC method',
'hash_init': '(string $algo, int $flags = ?, string $key = "", array $options = []): HashContext\nInitialize an incremental hashing context',
'hash_pbkdf2': '(string $algo, string $password, string $salt, int $iterations, int $length = ?, bool $binary = false, array $options = []): string\nGenerate a PBKDF2 key derivation of a supplied password',
'hash_update_file': '(HashContext $context, string $filename, ?resource $stream_context = null): bool\nPump data into an active hashing context from a file',
'hash_update_stream': '(HashContext $context, resource $stream, int $length = -1): int\nPump data into an active hashing context from an open stream',
'hash_update': '(HashContext $context, string $data): true\nPump data into an active hashing context',
'hash': '(string $algo, string $data, bool $binary = false, array $options = []): string\nGenerate a hash value (message digest)',
'assert_options': '(int $option, mixed $value = ?): mixed\nSet/get the various assert flags',
'assert': '(mixed $assertion, Throwable|string|null $description = null): bool\nChecks an assertion',
'cli_get_process_title': '(): ?string\nReturns the current process title',
'cli_set_process_title': '(string $title): bool\nSets the process title',
'dl': '(string $extension_filename): bool\nLoads a PHP extension at runtime',
'extension_loaded': '(string $extension): bool\nFind out whether an extension is loaded',
'gc_collect_cycles': '(): int\nForces collection of any existing garbage cycles',
'gc_disable': '(): void\nDeactivates the circular reference collector',
'gc_enable': '(): void\nActivates the circular reference collector',
'gc_enabled': '(): bool\nReturns status of the circular reference collector',
'gc_mem_caches': '(): int\nReclaims memory used by the Zend Engine memory manager',
'gc_status': '(): array\nGets information about the garbage collector',
'get_cfg_var': '(string $option): string|array|false\nGets the value of a PHP configuration option',
'get_current_user': '(): string\nGets the name of the owner of the current PHP script',
'get_defined_constants': '(bool $categorize = false): array\nReturns an associative array with the names of all the constants and their values',
'get_extension_funcs': '(string $extension): array|false\nReturns an array with the names of the functions of a module',
'get_include_path': '(): string|false\nGets the current include_path configuration option',
'get_included_files': '(): array\nReturns an array with the names of included or required files',
'get_loaded_extensions': '(bool $zend_extensions = false): array\nReturns an array with the names of all modules compiled and loaded',
'get_magic_quotes_gpc': '(): false\nGets the current configuration setting of magic_quotes_gpc',
'get_magic_quotes_runtime': '(): false\nGets the current active configuration setting of magic_quotes_runtime',
'get_required_files': 'Alias of get_included_files',
'get_resources': '(?string $type = null): array\nReturns active resources',
'getenv': '(?string $name = null, bool $local_only = false): string|array|false\nGets the value of a single or all environment variables',
'getlastmod': '(): int|false\nGets time of last page modification',
'getmygid': '(): int|false\nGet PHP script owner\'s GID',
'getmyinode': '(): int|false\nGets the inode of the current script',
'getmypid': '(): int|false\nGets PHP\'s process ID',
'getmyuid': '(): int|false\nGets PHP script owner\'s UID',
'getopt': '(string $short_options, array $long_options = [], int &$rest_index = null): array|false\nGets options from the command line argument list',
'getrusage': '(int $mode = ?): array|false\nGets the current resource usages',
'ini_alter': 'Alias of ini_set',
'ini_get_all': '(?string $extension = null, bool $details = true): array|false\nGets all configuration options',
'ini_get': '(string $option): string|false\nGets the value of a configuration option',
'ini_parse_quantity': '(string $shorthand): int\nGet interpreted size from ini shorthand syntax',
'ini_restore': '(string $option): void\nRestores the value of a configuration option',
'ini_set': '(string $option, string|int|float|bool|null $value): string|false\nSets the value of a configuration option',
'memory_get_peak_usage': '(bool $real_usage = false): int\nReturns the peak of memory allocated by PHP',
'memory_get_usage': '(bool $real_usage = false): int\nReturns the amount of memory allocated to PHP',
'memory_reset_peak_usage': '(): void\nReset the peak memory usage',
'php_ini_loaded_file': '(): string|false\nRetrieve a path to the loaded php.ini file',
'php_ini_scanned_files': '(): string|false\nReturn a list of .ini files parsed from the additional ini dir',
'php_sapi_name': '(): string|false\nReturns the type of interface between web server and PHP',
'php_uname': '(string $mode = "a"): string\nReturns information about the operating system PHP is running on',
'phpcredits': '(int $flags = CREDITS_ALL): true\nPrints out the credits for PHP',
'phpinfo': '(int $flags = INFO_ALL): true\nOutputs information about PHP\'s configuration',
'phpversion': '(?string $extension = null): string|false\nGets the current PHP version',
'putenv': '(string $assignment): bool\nSets the value of an environment variable',
'restore_include_path': '(): void\nRestores the value of the include_path configuration option',
'set_include_path': '(string $include_path): string|false\nSets the include_path configuration option',
'set_time_limit': '(int $seconds): bool\nLimits the maximum execution time',
'sys_get_temp_dir': '(): string\nReturns directory path used for temporary files',
'version_compare': '(string $version1, string $version2, ?string $operator = null): int|bool\nCompares two "PHP-standardized" version number strings',
'zend_thread_id': '(): int\nReturns a unique identifier for the current thread',
'zend_version': '(): string\nGets the version of the current Zend engine',
'json_decode': '(string $json, ?bool $associative = null, int $depth = 512, int $flags = ?): mixed\nDecodes a JSON string',
'json_encode': '(mixed $value, int $flags = ?, int $depth = 512): string|false\nReturns the JSON representation of a value',
'json_last_error_msg': '(): string\nReturns the error string of the last json_validate(), json_encode() or json_decode() call',
'json_last_error': '(): int\nReturns the last error occurred',
'json_validate': '(string $json, int $depth = 512, int $flags = ?): bool\nChecks if a string contains valid JSON',
'ezmlm_hash': '(string $addr): int\nCalculate the hash value needed by EZMLM',
'mail': '(string $to, string $subject, string $message, array|string $additional_headers = [], string $additional_params = ""): bool\nSend mail',
'abs': '(int|float $num): int|float\nAbsolute value',
'acos': '(float $num): float\nArc cosine',
'acosh': '(float $num): float\nInverse hyperbolic cosine',
'asin': '(float $num): float\nArc sine',
'asinh': '(float $num): float\nInverse hyperbolic sine',
'atan': '(float $num): float\nArc tangent',
'atan2': '(float $y, float $x): float\nArc tangent of two variables',
'atanh': '(float $num): float\nInverse hyperbolic tangent',
'base_convert': '(string $num, int $from_base, int $to_base): string\nConvert a number between arbitrary bases',
'bindec': '(string $binary_string): int|float\nBinary to decimal',
'ceil': '(int|float $num): float\nRound fractions up',
'cos': '(float $num): float\nCosine',
'cosh': '(float $num): float\nHyperbolic cosine',
'decbin': '(int $num): string\nDecimal to binary',
'dechex': '(int $num): string\nDecimal to hexadecimal',
'decoct': '(int $num): string\nDecimal to octal',
'deg2rad': '(float $num): float\nConverts the number in degrees to the radian equivalent',
'exp': '(float $num): float\nCalculates the exponent of e',
'expm1': '(float $num): float\nReturns exp($num) - 1, computed in a way that is accurate even when the value of number is close to zero',
'fdiv': '(float $num1, float $num2): float\nDivides two numbers, according to IEEE 754',
'floor': '(int|float $num): float\nRound fractions down',
'fmod': '(float $num1, float $num2): float\nReturns the floating point remainder (modulo) of the division of the arguments',
'fpow': '(float $num, float $exponent): float\nRaise one number to the power of another, according to IEEE 754',
'hexdec': '(string $hex_string): int|float\nHexadecimal to decimal',
'hypot': '(float $x, float $y): float\nCalculate the length of the hypotenuse of a right-angle triangle',
'intdiv': '(int $num1, int $num2): int\nInteger division',
'is_finite': '(float $num): bool\nChecks whether a float is finite',
'is_infinite': '(float $num): bool\nChecks whether a float is infinite',
'is_nan': '(float $num): bool\nChecks whether a float is NAN',
'log': '(float $num, float $base = M_E): float\nNatural logarithm',
'log10': '(float $num): float\nBase-10 logarithm',
'log1p': '(float $num): float\nReturns log(1 + number), computed in a way that is accurate even when the value of number is close to zero',
'max': '(array $value_array): mixed\nFind highest value',
'min': '(array $value_array): mixed\nFind lowest value',
'octdec': '(string $octal_string): int|float\nOctal to decimal',
'pi': '(): float\nGet value of pi',
'pow': '(mixed $num, mixed $exponent): int|float|object\nExponential expression',
'rad2deg': '(float $num): float\nConverts the radian number to the equivalent number in degrees',
'round': '(int|float $num, int $precision = ?, int|RoundingMode $mode = RoundingMode::HalfAwayFromZero): float\nRounds a float',
'sin': '(float $num): float\nSine',
'sinh': '(float $num): float\nHyperbolic sine',
'sqrt': '(float $num): float\nSquare root',
'tan': '(float $num): float\nTangent',
'tanh': '(float $num): float\nHyperbolic tangent',
'connection_aborted': '(): int\nCheck whether client disconnected',
'connection_status': '(): int\nReturns connection status bitfield',
'constant': '(string $name): mixed\nReturns the value of a constant',
'define': '(string $constant_name, mixed $value, bool $case_insensitive = false): bool\nDefines a named constant',
'defined': '(string $constant_name): bool\nChecks whether a constant with the given name exists',
'die': 'Alias of exit',
'eval': '(string $code): mixed\nEvaluate a string as PHP code',
'exit': '(string|int $status = ?): never\nTerminate the current script with a status code or message',
'get_browser': '(?string $user_agent = null, bool $return_array = false): object|array|false\nTells what the user\'s browser is capable of',
'highlight_file': '(string $filename, bool $return = false): string|bool\nSyntax highlighting of a file',
'highlight_string': '(string $string, bool $return = false): string|true\nSyntax highlighting of a string',
'hrtime': '(bool $as_number = false): array|int|float|false\nGet the system\'s high resolution time',
'ignore_user_abort': '(?bool $enable = null): int\nSet whether a client disconnect should abort script execution',
'pack': '(string $format, mixed ...$values): string\nPack data into binary string',
'php_strip_whitespace': '(string $filename): string\nReturn source with stripped comments and whitespace',
'sapi_windows_cp_conv': '(int|string $in_codepage, int|string $out_codepage, string $subject): ?string\nConvert string from one codepage to another',
'sapi_windows_cp_get': '(string $kind = ""): int\nGet current codepage',
'sapi_windows_cp_is_utf8': '(): bool\nIndicates whether the codepage is UTF-8 compatible',
'sapi_windows_cp_set': '(int $codepage): bool\nSet process codepage',
'sapi_windows_generate_ctrl_event': '(int $event, int $pid = ?): bool\nSend a CTRL event to another process',
'sapi_windows_set_ctrl_handler': '(?callable $handler, bool $add = true): bool\nSet or remove a CTRL event handler',
'sapi_windows_vt100_support': '(resource $stream, ?bool $enable = null): bool\nGet or set VT100 support for the specified stream associated to an output buffer of a Windows console.',
'show_source': 'Alias of highlight_file',
'sleep': '(int $seconds): int\nDelay execution',
'sys_getloadavg': '(): array|false\nGets system load average',
'time_nanosleep': '(int $seconds, int $nanoseconds): array|bool\nDelay for a number of seconds and nanoseconds',
'time_sleep_until': '(float $timestamp): bool\nMake the script sleep until the specified time',
'uniqid': '(string $prefix = "", bool $more_entropy = false): string\nGenerate a time-based identifier',
'unpack': '(string $format, string $string, int $offset = ?): array|false\nUnpack data from binary string',
'usleep': '(int $microseconds): void\nDelay execution in microseconds',
'checkdnsrr': '(string $hostname, string $type = "MX"): bool\nCheck DNS records corresponding to a given Internet host name or IP address',
'closelog': '(): true\nClose connection to system logger',
'dns_check_record': 'Alias of checkdnsrr',
'dns_get_mx': 'Alias of getmxrr',
'dns_get_record': '(string $hostname, int $type = DNS_ANY, array &$authoritative_name_servers = null, array &$additional_records = null, bool $raw = false): array|false\nFetch DNS Resource Records associated with a hostname',
'fsockopen': '(string $hostname, int $port = -1, int &$error_code = null, string &$error_message = null, ?float $timeout = null): resource|false\nOpen Internet or Unix domain socket connection',
'gethostbyaddr': '(string $ip): string|false\nGet the Internet host name corresponding to a given IP address',
'gethostbyname': '(string $hostname): string\nGet the IPv4 address corresponding to a given Internet host name',
'gethostbynamel': '(string $hostname): array|false\nGet a list of IPv4 addresses corresponding to a given Internet host name',
'gethostname': '(): string|false\nGets the host name',
'getmxrr': '(string $hostname, array &$hosts, array &$weights = null): bool\nGet MX records corresponding to a given Internet host name',
'getprotobyname': '(string $protocol): int|false\nGet protocol number associated with protocol name',
'getprotobynumber': '(int $protocol): string|false\nGet protocol name associated with protocol number',
'getservbyname': '(string $service, string $protocol): int|false\nGet port number associated with an Internet service and protocol',
'getservbyport': '(int $port, string $protocol): string|false\nGet Internet service which corresponds to port and protocol',
'header_register_callback': '(callable $callback): bool\nCall a header function',
'header_remove': '(?string $name = null): void\nRemove previously set headers',
'header': '(string $header, bool $replace = true, int $response_code = ?): void\nSend a raw HTTP header',
'headers_list': '(): array\nReturns a list of response headers sent (or ready to send)',
'headers_sent': '(string &$filename = null, int &$line = null): bool\nChecks if or where headers have been sent',
'http_clear_last_response_headers': '(): void\nClears the stored HTTP response headers',
'http_get_last_response_headers': '(): ?array\nRetrieve last HTTP response headers',
'http_response_code': '(int $response_code = ?): int|bool\nGet or Set the HTTP response code',
'inet_ntop': '(string $ip): string|false\nConverts a packed internet address to a human readable representation',
'inet_pton': '(string $ip): string|false\nConverts a human readable IP address to its packed in_addr representation',
'ip2long': '(string $ip): int|false\nConverts a string containing an (IPv4) Internet Protocol dotted address into a long integer',
'long2ip': '(int $ip): string\nConverts a long integer address into a string in (IPv4) Internet standard dotted format',
'net_get_interfaces': '(): array|false\nGet network interfaces',
'openlog': '(string $prefix, int $flags, int $facility): true\nOpen connection to system logger',
'pfsockopen': '(string $hostname, int $port = -1, int &$error_code = null, string &$error_message = null, ?float $timeout = null): resource|false\nOpen persistent Internet or Unix domain socket connection',
'request_parse_body': '(?array $options = null): array\nRead and parse the request body and return the result',
'setcookie': '(string $name, string $value = "", array $options = []): bool\nSend a cookie',
'setrawcookie': '(string $name, string $value = ?, array $options = []): bool\nSend a cookie without urlencoding the cookie value',
'socket_get_status': 'Alias of stream_get_meta_data',
'socket_set_blocking': 'Alias of stream_set_blocking',
'socket_set_timeout': 'Alias of stream_set_timeout',
'syslog': '(int $priority, string $message): true\nGenerate a system log message',
'opcache_compile_file': '(string $filename): bool\nCompiles and caches a PHP script without executing it',
'opcache_get_configuration': '(): array|false\nGet configuration information about the cache',
'opcache_get_status': '(bool $include_scripts = true): array|false\nGet status information about the cache',
'opcache_invalidate': '(string $filename, bool $force = false): bool\nInvalidates a cached script',
'opcache_is_script_cached_in_file_cache': '(string $filename): bool\nTells whether a script is cached in OPCache file cache',
'opcache_is_script_cached': '(string $filename): bool\nTells whether a script is cached in OPCache',
'opcache_jit_blacklist': '(Closure $closure): void\nBlacklists a function from being JIT compiled',
'opcache_reset': '(): bool\nResets the contents of the opcode cache',
'flush': '(): void\nFlush system output buffer',
'ob_clean': '(): bool\nClean (erase) the contents of the active output buffer',
'ob_end_clean': '(): bool\nClean (erase) the contents of the active output buffer and turn it off',
'ob_end_flush': '(): bool\nFlush (send) the return value of the active output handler and turn the active output buffer off',
'ob_flush': '(): bool\nFlush (send) the return value of the active output handler',
'ob_get_clean': '(): string|false\nGet the contents of the active output buffer and turn it off',
'ob_get_contents': '(): string|false\nReturn the contents of the output buffer',
'ob_get_flush': '(): string|false\nFlush (send) the return value of the active output handler, return the contents of the active output buffer and turn it off',
'ob_get_length': '(): int|false\nReturn the length of the output buffer',
'ob_get_level': '(): int\nReturn the nesting level of the output buffering mechanism',
'ob_get_status': '(bool $full_status = false): array\nGet status of output buffers',
'ob_implicit_flush': '(bool $enable = true): void\nTurn implicit flush on/off',
'ob_list_handlers': '(): array\nList all output handlers in use',
'ob_start': '(?callable $callback = null, int $chunk_size = ?, int $flags = PHP_OUTPUT_HANDLER_STDFLAGS): bool\nTurn on output buffering',
'output_add_rewrite_var': '(string $name, string $value): bool\nAdd URL rewriter values',
'output_reset_rewrite_vars': '(): bool\nReset URL rewriter values',
'password_algos': '(): array\nGet available password hashing algorithm IDs',
'password_get_info': '(string $hash): array\nReturns information about the given hash',
'password_hash': '(string $password, string|int|null $algo, array $options = []): string\nCreates a password hash',
'password_needs_rehash': '(string $hash, string|int|null $algo, array $options = []): bool\nChecks if the given hash matches the given options',
'password_verify': '(string $password, string $hash): bool\nVerifies that a password matches a hash',
'preg_filter': '(string|array $pattern, string|array $replacement, string|array $subject, int $limit = -1, int &$count = null): string|array|null\nPerform a regular expression search and replace',
'preg_grep': '(string $pattern, array $array, int $flags = ?): array|false\nReturn array entries that match the pattern',
'preg_last_error_msg': '(): string\nReturns the error message of the last PCRE regex execution',
'preg_last_error': '(): int\nReturns the error code of the last PCRE regex execution',
'preg_match_all': '(string $pattern, string $subject, array &$matches = null, int $flags = ?, int $offset = ?): int|false\nPerform a global regular expression match',
'preg_match': '(string $pattern, string $subject, array &$matches = null, int $flags = ?, int $offset = ?): int|false\nPerform a regular expression match',
'preg_quote': '(string $str, ?string $delimiter = null): string\nQuote regular expression characters',
'preg_replace_callback_array': '(array $pattern, string|array $subject, int $limit = -1, int &$count = null, int $flags = ?): string|array|null\nPerform a regular expression search and replace using callbacks',
'preg_replace_callback': '(string|array $pattern, callable $callback, string|array $subject, int $limit = -1, int &$count = null, int $flags = ?): string|array|null\nPerform a regular expression search and replace using a callback',
'preg_replace': '(string|array $pattern, string|array $replacement, string|array $subject, int $limit = -1, int &$count = null): string|array|null\nPerform a regular expression search and replace',
'preg_split': '(string $pattern, string $subject, int $limit = -1, int $flags = ?): array|false\nSplit string by a regular expression',
'getrandmax': '(): int\nShow largest possible random value',
'lcg_value': '(): float\nCombined linear congruential generator',
'mt_getrandmax': '(): int\nShow largest possible random value',
'mt_rand': '(int $min, int $max): int\nGenerate a random value via the Mersenne Twister Random Number Generator',
'mt_srand': '(?int $seed = null, int $mode = MT_RAND_MT19937): void\nSeeds the Mersenne Twister Random Number Generator',
'rand': '(int $min, int $max): int\nGenerate a random integer',
'random_bytes': '(int $length): string\nGet cryptographically secure random bytes',
'random_int': '(int $min, int $max): int\nGet a cryptographically secure, uniformly selected integer',
'srand': '(?int $seed = null, int $mode = MT_RAND_MT19937): void\nSeed the random number generator',
'Reflection::export': '(Reflector $reflector, bool $return = false): string\nExports',
'Reflection::getModifierNames': '(int $modifiers): array\nGets modifier names',
'ReflectionClass::export': '(mixed $argument, bool $return = false): string\nExports a class',
'ReflectionClassConstant::export': '(mixed $class, string $name, bool $return = ?): string\nExport',
'ReflectionExtension::export': '(string $name, string $return = false): string\nExport',
'ReflectionFunction::export': '(string $name, string $return = ?): string\nExports function',
'ReflectionMethod::createFromMethodName': '(string $method): static\nCreates a new ReflectionMethod',
'ReflectionMethod::export': '(string $class, string $name, bool $return = false): string\nExport a reflection method',
'ReflectionObject::export': '(string $argument, bool $return = ?): string\nExport',
'ReflectionParameter::export': '(string $function, string $parameter, bool $return = ?): string\nExports',
'ReflectionProperty::export': '(mixed $class, string $name, bool $return = ?): string\nExport',
'ReflectionReference::fromArrayElement': '(array $array, int|string $key): ?ReflectionReference\nCreate a ReflectionReference from an array element',
'ReflectionZendExtension::export': '(string $name, bool $return = ?): string\nExport',
'Reflector::export': '(): string\nExports',
'class_implements': '(object|string $object_or_class, bool $autoload = true): array|false\nReturn the interfaces which are implemented by the given class or interface',
'class_parents': '(object|string $object_or_class, bool $autoload = true): array|false\nReturn the parent classes of the given class',
'class_uses': '(object|string $object_or_class, bool $autoload = true): array|false\nReturn the traits used by the given class',
'iterator_apply': '(Traversable $iterator, callable $callback, ?array $args = null): int\nCall a function for every element in an iterator',
'iterator_count': '(Traversable|array $iterator): int\nCount the elements in an iterator',
'iterator_to_array': '(Traversable|array $iterator, bool $preserve_keys = true): array\nCopy the iterator into an array',
'spl_autoload_call': '(string $class): void\nTry all registered __autoload() functions to load the requested class',
'spl_autoload_extensions': '(?string $file_extensions = null): string\nRegister and return default file extensions for spl_autoload',
'spl_autoload_functions': '(): array\nReturn all registered __autoload() functions',
'spl_autoload_register': '(?callable $callback = null, bool $throw = true, bool $prepend = false): bool\nRegister given function as __autoload() implementation',
'spl_autoload_unregister': '(callable $callback): bool\nUnregister given function as __autoload() implementation',
'spl_autoload': '(string $class, ?string $file_extensions = null): void\nDefault implementation for __autoload()',
'spl_classes': '(): array\nReturn available SPL classes',
'spl_object_hash': '(object $object): string\nReturn hash id for given object',
'spl_object_id': '(object $object): int\nReturn the integer object handle for given object',
'SplFixedArray::fromArray': '(array $array, bool $preserveKeys = true): SplFixedArray\nImport a PHP array in a SplFixedArray instance',
'stream_bucket_append': '(resource $brigade, StreamBucket $bucket): void\nAppend bucket to brigade',
'stream_bucket_make_writeable': '(resource $brigade): ?StreamBucket\nReturns a bucket object from the brigade to operate on',
'stream_bucket_new': '(resource $stream, string $buffer): StreamBucket\nCreate a new bucket for use on the current stream',
'stream_bucket_prepend': '(resource $brigade, StreamBucket $bucket): void\nPrepend bucket to brigade',
'stream_context_create': '(?array $options = null, ?array $params = null): resource\nCreates a stream context',
'stream_context_get_default': '(?array $options = null): resource\nRetrieve the default stream context',
'stream_context_get_options': '(resource $stream_or_context): array\nRetrieve options for a stream/wrapper/context',
'stream_context_get_params': '(resource $context): array\nRetrieves parameters from a context',
'stream_context_set_default': '(array $options): resource\nSet the default stream context',
'stream_context_set_option': '(resource $stream_or_context, string $wrapper, string $option_name, mixed $value): bool\nSets an option for a stream/wrapper/context',
'stream_context_set_options': '(resource $context, array $options): true\nSets options on the specified context',
'stream_context_set_params': '(resource $context, array $params): true\nSet parameters for a stream/wrapper/context',
'stream_copy_to_stream': '(resource $from, resource $to, ?int $length = null, int $offset = ?): int|false\nCopies data from one stream to another',
'stream_filter_append': '(resource $stream, string $filter_name, int $mode = ?, mixed $params = ?): resource\nAttach a filter to a stream',
'stream_filter_prepend': '(resource $stream, string $filter_name, int $mode = ?, mixed $params = ?): resource\nAttach a filter to a stream',
'stream_filter_register': '(string $filter_name, string $class): bool\nRegister a user defined stream filter',
'stream_filter_remove': '(resource $stream_filter): bool\nRemove a filter from a stream',
'stream_get_contents': '(resource $stream, ?int $length = null, int $offset = -1): string|false\nReads remainder of a stream into a string',
'stream_get_filters': '(): array\nRetrieve list of registered filters',
'stream_get_line': '(resource $stream, int $length, string $ending = ""): string|false\nGets line from stream resource up to a given delimiter',
'stream_get_meta_data': '(resource $stream): array\nRetrieves header/meta data from streams/file pointers',
'stream_get_transports': '(): array\nRetrieve list of registered socket transports',
'stream_get_wrappers': '(): array\nRetrieve list of registered streams',
'stream_is_local': '(resource|string $stream): bool\nChecks if a stream is a local stream',
'stream_isatty': '(resource $stream): bool\nCheck if a stream is a TTY',
'stream_register_wrapper': 'Alias of stream_wrapper_register',
'stream_resolve_include_path': '(string $filename): string|false\nResolve filename against the include path',
'stream_select': '(?array &$read, ?array &$write, ?array &$except, ?int $seconds, ?int $microseconds = null): int|false\nRuns the equivalent of the select() system call on the given arrays of streams with a timeout specified by seconds and microseconds',
'stream_set_blocking': '(resource $stream, bool $enable): bool\nSet blocking/non-blocking mode on a stream',
'stream_set_chunk_size': '(resource $stream, int $size): int\nSet the stream chunk size',
'stream_set_read_buffer': '(resource $stream, int $size): int\nSet read file buffering on the given stream',
'stream_set_timeout': '(resource $stream, int $seconds, int $microseconds = ?): bool\nSet timeout period on a stream',
'stream_set_write_buffer': '(resource $stream, int $size): int\nSets write file buffering on the given stream',
'stream_socket_accept': '(resource $socket, ?float $timeout = null, string &$peer_name = null): resource|false\nAccept a connection on a socket created by stream_socket_server',
'stream_socket_client': '(string $address, int &$error_code = null, string &$error_message = null, ?float $timeout = null, int $flags = STREAM_CLIENT_CONNECT, ?resource $context = null): resource|false\nOpen Internet or Unix domain socket connection',
'stream_socket_enable_crypto': '(resource $stream, bool $enable, ?int $crypto_method = null, ?resource $session_stream = null): int|bool\nTurns encryption on/off on an already connected socket',
'stream_socket_get_name': '(resource $socket, bool $remote): string|false\nRetrieve the name of the local or remote sockets',
'stream_socket_pair': '(int $domain, int $type, int $protocol): array|false\nCreates a pair of connected, indistinguishable socket streams',
'stream_socket_recvfrom': '(resource $socket, int $length, int $flags = ?, ?string &$address = null): string|false\nReceives data from a socket, connected or not',
'stream_socket_sendto': '(resource $socket, string $data, int $flags = ?, string $address = ""): int|false\nSends a message to a socket, whether it is connected or not',
'stream_socket_server': '(string $address, int &$error_code = null, string &$error_message = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, ?resource $context = null): resource|false\nCreate an Internet or Unix domain server socket',
'stream_socket_shutdown': '(resource $stream, int $mode): bool\nShutdown a full-duplex connection',
'stream_supports_lock': '(resource $stream): bool\nTells whether the stream supports locking',
'stream_wrapper_register': '(string $protocol, string $class, int $flags = ?): bool\nRegister a URL wrapper implemented as a PHP class',
'stream_wrapper_restore': '(string $protocol): bool\nRestores a previously unregistered built-in wrapper',
'stream_wrapper_unregister': '(string $protocol): bool\nUnregister a URL wrapper',
'addcslashes': '(string $string, string $characters): string\nQuote string with slashes in a C style',
'addslashes': '(string $string): string\nQuote string with slashes',
'bin2hex': '(string $string): string\nConvert binary data into hexadecimal representation',
'chop': 'Alias of rtrim',
'chr': '(int $codepoint): string\nGenerate a single-byte string from a number',
'chunk_split': '(string $string, int $length = 76, string $separator = "\\r\\n"): string\nSplit a string into smaller chunks',
'convert_cyr_string': '(string $str, string $from, string $to): string\nConvert from one Cyrillic character set to another',
'convert_uudecode': '(string $string): string|false\nDecode a uuencoded string',
'convert_uuencode': '(string $string): string\nUuencode a string',
'count_chars': '(string $string, int $mode = ?): array|string\nReturn information about characters used in a string',
'crc32': '(string $string): int\nCalculates the crc32 polynomial of a string',
'crypt': '(string $string, string $salt): string\nOne-way string hashing',
'echo': '(string ...$expressions): void\nOutput one or more strings',
'explode': '(string $separator, string $string, int $limit = PHP_INT_MAX): array\nSplit a string by a string',
'fprintf': '(resource $stream, string $format, mixed ...$values): int\nWrite a formatted string to a stream',
'get_html_translation_table': '(int $table = HTML_SPECIALCHARS, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, string $encoding = "UTF-8"): array\nReturns the translation table used by htmlspecialchars and htmlentities',
'hebrev': '(string $string, int $max_chars_per_line = ?): string\nConvert logical Hebrew text to visual text',
'hebrevc': '(string $hebrew_text, int $max_chars_per_line = ?): string\nConvert logical Hebrew text to visual text with newline conversion',
'hex2bin': '(string $string): string|false\nDecodes a hexadecimally encoded binary string',
'html_entity_decode': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, ?string $encoding = null): string\nConvert HTML entities to their corresponding characters',
'htmlentities': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, ?string $encoding = null, bool $double_encode = true): string\nConvert all applicable characters to HTML entities',
'htmlspecialchars_decode': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401): string\nConvert special HTML entities back to characters',
'htmlspecialchars': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, ?string $encoding = null, bool $double_encode = true): string\nConvert special characters to HTML entities',
'implode': '(array $array, string $separator): string\nJoin array elements with a string',
'join': 'Alias of implode',
'lcfirst': '(string $string): string\nMake a string\'s first character lowercase',
'levenshtein': '(string $string1, string $string2, int $insertion_cost = 1, int $replacement_cost = 1, int $deletion_cost = 1): int\nCalculate Levenshtein distance between two strings',
'localeconv': '(): array\nGet numeric formatting information',
'ltrim': '(string $string, string $characters = " \\n\\r\\t\\v\\x00"): string\nStrip whitespace (or other characters) from the beginning of a string',
'md5_file': '(string $filename, bool $binary = false): string|false\nCalculates the md5 hash of a given file',
'md5': '(string $string, bool $binary = false): string\nCalculate the md5 hash of a string',
'metaphone': '(string $string, int $max_phonemes = ?): string\nCalculate the metaphone key of a string',
'money_format': '(string $format, float $number): string\nFormats a number as a currency string',
'nl_langinfo': '(int $item): string|false\nQuery language and locale information',
'nl2br': '(string $string, bool $use_xhtml = true): string\nInserts HTML line breaks before all newlines in a string',
'number_format': '(float $num, int $decimals = ?, ?string $decimal_separator = ".", ?string $thousands_separator = ","): string\nFormat a number with grouped thousands',
'ord': '(string $character): int\nConvert the first byte of a string to a value between 0 and 255',
'parse_str': '(string $string, array &$result): void\nParse a string as a URL query string',
'print': '(string $expression): int\nOutput a string',
'printf': '(string $format, mixed ...$values): int\nOutput a formatted string',
'quoted_printable_decode': '(string $string): string\nConvert a quoted-printable string to an 8 bit string',
'quoted_printable_encode': '(string $string): string\nConvert a 8 bit string to a quoted-printable string',
'quotemeta': '(string $string): string\nQuote meta characters',
'rtrim': '(string $string, string $characters = " \\n\\r\\t\\v\\x00"): string\nStrip whitespace (or other characters) from the end of a string',
'setlocale': '(int $category, array $locale_array): string|false\nSet locale information',
'sha1_file': '(string $filename, bool $binary = false): string|false\nCalculate the sha1 hash of a file',
'sha1': '(string $string, bool $binary = false): string\nCalculate the sha1 hash of a string',
'similar_text': '(string $string1, string $string2, float &$percent = null): int\nCalculate the similarity between two strings',
'soundex': '(string $string): string\nCalculate the soundex key of a string',
'sprintf': '(string $format, mixed ...$values): string\nReturn a formatted string',
'sscanf': '(string $string, string $format, mixed &...$vars): array|int|null\nParses input from a string according to a format',
'str_contains': '(string $haystack, string $needle): bool\nDetermine if a string contains a given substring',
'str_decrement': '(string $string): string\nDecrement an alphanumeric string',
'str_ends_with': '(string $haystack, string $needle): bool\nChecks if a string ends with a given substring',
'str_getcsv': '(string $string, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): array\nParse a CSV string into an array',
'str_increment': '(string $string): string\nIncrement an alphanumeric string',
'str_ireplace': '(array|string $search, array|string $replace, string|array $subject, int &$count = null): string|array\nCase-insensitive version of str_replace',
'str_pad': '(string $string, int $length, string $pad_string = " ", int $pad_type = STR_PAD_RIGHT): string\nPad a string to a certain length with another string',
'str_repeat': '(string $string, int $times): string\nRepeat a string',
'str_replace': '(array|string $search, array|string $replace, string|array $subject, int &$count = null): string|array\nReplace all occurrences of the search string with the replacement string',
'str_rot13': '(string $string): string\nPerform the rot13 transform on a string',
'str_shuffle': '(string $string): string\nRandomly shuffles a string',
'str_split': '(string $string, int $length = 1): array\nConvert a string to an array',
'str_starts_with': '(string $haystack, string $needle): bool\nChecks if a string starts with a given substring',
'str_word_count': '(string $string, int $format = ?, ?string $characters = null): array|int\nReturn information about words used in a string',
'strcasecmp': '(string $string1, string $string2): int\nBinary safe case-insensitive string comparison',
'strchr': 'Alias of strstr',
'strcmp': '(string $string1, string $string2): int\nBinary safe string comparison',
'strcoll': '(string $string1, string $string2): int\nLocale based string comparison',
'strcspn': '(string $string, string $characters, int $offset = ?, ?int $length = null): int\nFind length of initial segment not matching mask',
'strip_tags': '(string $string, array|string|null $allowed_tags = null): string\nStrip HTML and PHP tags from a string',
'stripcslashes': '(string $string): string\nUn-quote string quoted with addcslashes',
'stripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the first occurrence of a case-insensitive substring in a string',
'stripslashes': '(string $string): string\nUn-quotes a quoted string',
'stristr': '(string $haystack, string $needle, bool $before_needle = false): string|false\nCase-insensitive strstr',
'strlen': '(string $string): int\nGet string length',
'strnatcasecmp': '(string $string1, string $string2): int\nCase insensitive string comparisons using a "natural order" algorithm',
'strnatcmp': '(string $string1, string $string2): int\nString comparisons using a "natural order" algorithm',
'strncasecmp': '(string $string1, string $string2, int $length): int\nBinary safe case-insensitive string comparison of the first n characters',
'strncmp': '(string $string1, string $string2, int $length): int\nBinary safe string comparison of the first n characters',
'strpbrk': '(string $string, string $characters): string|false\nSearch a string for any of a set of characters',
'strpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the first occurrence of a substring in a string',
'strrchr': '(string $haystack, string $needle, bool $before_needle = false): string|false\nFind the last occurrence of a character in a string',
'strrev': '(string $string): string\nReverse a string',
'strripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the last occurrence of a case-insensitive substring in a string',
'strrpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the last occurrence of a substring in a string',
'strspn': '(string $string, string $characters, int $offset = ?, ?int $length = null): int\nFinds the length of the initial segment of a string consisting entirely of characters contained within a given mask',
'strstr': '(string $haystack, string $needle, bool $before_needle = false): string|false\nFind the first occurrence of a string',
'strtok': '(string $token): string|false\nTokenize string',
'strtolower': '(string $string): string\nMake a string lowercase',
'strtoupper': '(string $string): string\nMake a string uppercase',
'strtr': '(string $string, array $replace_pairs): string\nTranslate characters or replace substrings',
'substr_compare': '(string $haystack, string $needle, int $offset, ?int $length = null, bool $case_insensitive = false): int\nBinary safe comparison of two strings from an offset, up to length characters',
'substr_count': '(string $haystack, string $needle, int $offset = ?, ?int $length = null): int\nCount the number of substring occurrences',
'substr_replace': '(array|string $string, array|string $replace, array|int $offset, array|int|null $length = null): string|array\nReplace text within a portion of a string',
'substr': '(string $string, int $offset, ?int $length = null): string\nReturn part of a string',
'trim': '(string $string, string $characters = " \\n\\r\\t\\v\\x00"): string\nStrip whitespace (or other characters) from the beginning and end of a string',
'ucfirst': '(string $string): string\nMake a string\'s first character uppercase',
'ucwords': '(string $string, string $separators = " \\t\\r\\n\\f\\v"): string\nUppercase the first character of each word in a string',
'utf8_decode': '(string $string): string\nConverts a string from UTF-8 to ISO-8859-1, replacing invalid or unrepresentable characters',
'utf8_encode': '(string $string): string\nConverts a string from ISO-8859-1 to UTF-8',
'vfprintf': '(resource $stream, string $format, array $values): int\nWrite a formatted string to a stream',
'vprintf': '(string $format, array $values): int\nOutput a formatted string',
'vsprintf': '(string $format, array $values): string\nReturn a formatted string',
'wordwrap': '(string $string, int $width = 75, string $break = "\\n", bool $cut_long_words = false): string\nWraps a string to a given number of characters',
'Uri\\Rfc3986\\Uri::parse': '(string $uri, ?Uri\\Rfc3986\\Uri $baseUrl = null): ?static\nParse a URI',
'Uri\\WhatWg\\Url::parse': '(string $uri, ?Uri\\WhatWg\\Url $baseUrl = null, array &$errors = null): ?static\nParse a URL',
'base64_decode': '(string $string, bool $strict = false): string|false\nDecodes data encoded with MIME base64',
'base64_encode': '(string $string): string\nEncodes data with MIME base64',
'get_headers': '(string $url, bool $associative = false, ?resource $context = null): array|false\nFetches all the headers sent by the server in response to an HTTP request',
'get_meta_tags': '(string $filename, bool $use_include_path = false): array|false\nExtracts all meta tag content attributes from a file and returns an array',
'http_build_query': '(array|object $data, string $numeric_prefix = "", ?string $arg_separator = null, int $encoding_type = PHP_QUERY_RFC1738): string\nGenerate URL-encoded query string',
'parse_url': '(string $url, int $component = -1): int|string|array|null|false\nParse a URL and return its components',
'rawurldecode': '(string $string): string\nDecode URL-encoded strings',
'rawurlencode': '(string $string): string\nURL-encode according to RFC 3986',
'urldecode': '(string $string): string\nDecodes URL-encoded string',
'urlencode': '(string $string): string\nURL-encodes string',
'boolval': '(mixed $value): bool\nGet the boolean value of a variable',
'debug_zval_dump': '(mixed $value, mixed ...$values): void\nDumps a string representation of an internal zval structure to output',
'doubleval': 'Alias of floatval',
'empty': '(mixed $var): bool\nDetermine whether a variable is empty',
'floatval': '(mixed $value): float\nGet float value of a variable',
'get_debug_type': '(mixed $value): string\nGets the type name of a variable in a way that is suitable for debugging',
'get_defined_vars': '(): array\nReturns an array of all defined variables',
'get_resource_id': '(resource $resource): int\nReturns an integer identifier for the given resource',
'get_resource_type': '(resource $resource): string\nReturns the resource type',
'gettype': '(mixed $value): string\nGet the type of a variable',
'intval': '(mixed $value, int $base = 10): int\nGet the integer value of a variable',
'is_array': '(mixed $value): bool\nFinds whether a variable is an array',
'is_bool': '(mixed $value): bool\nFinds out whether a variable is a boolean',
'is_callable': '(mixed $value, bool $syntax_only = false, string &$callable_name = null): bool\nVerify that a value can be called as a function from the current scope',
'is_countable': '(mixed $value): bool\nVerify that the contents of a variable is a countable value',
'is_double': 'Alias of is_float',
'is_float': '(mixed $value): bool\nFinds whether the type of a variable is float',
'is_int': '(mixed $value): bool\nFind whether the type of a variable is integer',
'is_integer': 'Alias of is_int',
'is_iterable': '(mixed $value): bool\nVerify that the contents of a variable is an iterable value',
'is_long': 'Alias of is_int',
'is_null': '(mixed $value): bool\nFinds whether a variable is null',
'is_numeric': '(mixed $value): bool\nFinds whether a variable is a number or a numeric string',
'is_object': '(mixed $value): bool\nFinds whether a variable is an object',
'is_real': 'Alias of is_float',
'is_resource': '(mixed $value): bool\nFinds whether a variable is a resource',
'is_scalar': '(mixed $value): bool\nFinds whether a variable is a scalar',
'is_string': '(mixed $value): bool\nFind whether the type of a variable is string',
'isset': '(mixed $var, mixed ...$vars): bool\nDetermine if a variable is declared and is different than null',
'print_r': '(mixed $value, bool $return = false): string|true\nPrints human-readable information about a variable',
'serialize': '(mixed $value): string\nGenerates a storable representation of a value',
'settype': '(mixed &$var, string $type): bool\nSet the type of a variable',
'strval': '(mixed $value): string\nGet string value of a variable',
'unserialize': '(string $data, array $options = []): mixed\nCreates a PHP value from a stored representation',
'unset': '(mixed $var, mixed ...$vars): void\nunset a given variable',
'var_dump': '(mixed $value, mixed ...$values): void\nDumps information about a variable',
'var_export': '(mixed $value, bool $return = false): ?string\nOutputs or returns a parsable string representation of a variable',
'apache_child_terminate': '(): void\nTerminate apache process after this request',
'apache_get_modules': '(): array\nGet a list of loaded Apache modules',
'apache_get_version': '(): string|false\nFetch Apache version',
'apache_getenv': '(string $variable, bool $walk_to_top = false): string|false\nGet an Apache subprocess_env variable',
'apache_lookup_uri': '(string $filename): object|false\nPerform a partial request for the specified URI and return all info about it',
'apache_note': '(string $note_name, ?string $note_value = null): string|false\nGet and set apache request notes',
'apache_request_headers': '(): array\nFetch all HTTP request headers',
'apache_response_headers': '(): array\nFetch all HTTP response headers',
'apache_setenv': '(string $variable, string $value, bool $walk_to_top = false): bool\nSet an Apache subprocess_env variable',
'getallheaders': '(): array\nFetch all HTTP request headers',
'virtual': '(string $uri): bool\nPerform an Apache sub-request',
'bcadd': '(string $num1, string $num2, ?int $scale = null): string\nAdd two arbitrary precision numbers',
'bcceil': '(string $num): string\nRound up arbitrary precision number',
'bccomp': '(string $num1, string $num2, ?int $scale = null): int\nCompare two arbitrary precision numbers',
'bcdiv': '(string $num1, string $num2, ?int $scale = null): string\nDivide two arbitrary precision numbers',
'bcdivmod': '(string $num1, string $num2, ?int $scale = null): array\nGet the quotient and modulus of an arbitrary precision number',
'bcfloor': '(string $num): string\nRound down arbitrary precision number',
'bcmod': '(string $num1, string $num2, ?int $scale = null): string\nGet modulus of an arbitrary precision number',
'bcmul': '(string $num1, string $num2, ?int $scale = null): string\nMultiply two arbitrary precision numbers',
'bcpow': '(string $num, string $exponent, ?int $scale = null): string\nRaise an arbitrary precision number to another',
'bcpowmod': '(string $num, string $exponent, string $modulus, ?int $scale = null): string\nRaise an arbitrary precision number to another, reduced by a specified modulus',
'bcround': '(string $num, int $precision = ?, RoundingMode $mode = RoundingMode::HalfAwayFromZero): string\nRound arbitrary precision number',
'bcscale': '(null $scale = null): int\nSet or get default scale parameter for all bc math functions',
'bcsqrt': '(string $num, ?int $scale = null): string\nGet the square root of an arbitrary precision number',
'bcsub': '(string $num1, string $num2, ?int $scale = null): string\nSubtract one arbitrary precision number from another',
'cal_days_in_month': '(int $calendar, int $month, int $year): int\nReturn the number of days in a month for a given year and calendar',
'cal_from_jd': '(int $julian_day, int $calendar): array\nConverts from Julian Day Count to a supported calendar',
'cal_info': '(int $calendar = -1): array\nReturns information about a particular calendar',
'cal_to_jd': '(int $calendar, int $month, int $day, int $year): int\nConverts from a supported calendar to Julian Day Count',
'easter_date': '(?int $year = null, int $mode = CAL_EASTER_DEFAULT): int\nGet Unix timestamp for local midnight on Easter of a given year',
'easter_days': '(?int $year = null, int $mode = CAL_EASTER_DEFAULT): int\nGet number of days after March 21 on which Easter falls for a given year',
'frenchtojd': '(int $month, int $day, int $year): int\nConverts a date from the French Republican Calendar to a Julian Day Count',
'gregoriantojd': '(int $month, int $day, int $year): int\nConverts a Gregorian date to Julian Day Count',
'jddayofweek': '(int $julian_day, int $mode = CAL_DOW_DAYNO): int|string\nReturns the day of the week',
'jdmonthname': '(int $julian_day, int $mode): string\nReturns a month name',
'jdtofrench': '(int $julian_day): string\nConverts a Julian Day Count to the French Republican Calendar',
'jdtogregorian': '(int $julian_day): string\nConverts Julian Day Count to Gregorian date',
'jdtojewish': '(int $julian_day, bool $hebrew = false, int $flags = ?): string\nConverts a Julian day count to a Jewish calendar date',
'jdtojulian': '(int $julian_day): string\nConverts a Julian Day Count to a Julian Calendar Date',
'jdtounix': '(int $julian_day): int\nConvert Julian Day to Unix timestamp',
'jewishtojd': '(int $month, int $day, int $year): int\nConverts a date in the Jewish Calendar to Julian Day Count',
'juliantojd': '(int $month, int $day, int $year): int\nConverts a Julian Calendar date to Julian Day Count',
'unixtojd': '(?int $timestamp = null): int|false\nConvert Unix timestamp to Julian Day',
'com_create_guid': '(): string|false\nGenerate a globally unique identifier (GUID)',
'com_event_sink': '(variant $variant, object $sink_object, array|string|null $sink_interface = null): bool\nConnect events from a COM object to a PHP object',
'com_get_active_object': '(string $prog_id, ?int $codepage = null): variant\nReturns a handle to an already running instance of a COM object',
'com_load_typelib': '(string $typelib, bool $case_insensitive = true): bool\nLoads a Typelib',
'com_message_pump': '(int $timeout_milliseconds = ?): bool\nProcess COM messages, sleeping for up to timeoutms milliseconds',
'com_print_typeinfo': '(variant|string $variant, ?string $dispatch_interface = null, bool $display_sink = false): bool\nPrint out a PHP class definition for a dispatchable interface',
'variant_abs': '(mixed $value): variant\nReturns the absolute value of a variant',
'variant_add': '(mixed $left, mixed $right): variant\n"Adds" two variant values together and returns the result',
'variant_and': '(mixed $left, mixed $right): variant\nPerforms a bitwise AND operation between two variants',
'variant_cast': '(variant $variant, int $type): variant\nConvert a variant into a new variant object of another type',
'variant_cat': '(mixed $left, mixed $right): variant\nConcatenates two variant values together and returns the result',
'variant_cmp': '(mixed $left, mixed $right, int $locale_id = LOCALE_SYSTEM_DEFAULT, int $flags = ?): int\nCompares two variants',
'variant_date_from_timestamp': '(int $timestamp): variant\nReturns a variant date representation of a Unix timestamp',
'variant_date_to_timestamp': '(variant $variant): ?int\nConverts a variant date/time value to Unix timestamp',
'variant_div': '(mixed $left, mixed $right): variant\nReturns the result from dividing two variants',
'variant_eqv': '(mixed $left, mixed $right): variant\nPerforms a bitwise equivalence on two variants',
'variant_fix': '(mixed $value): variant\nReturns the integer portion of a variant',
'variant_get_type': '(variant $variant): int\nReturns the type of a variant object',
'variant_idiv': '(mixed $left, mixed $right): variant\nConverts variants to integers and then returns the result from dividing them',
'variant_imp': '(mixed $left, mixed $right): variant\nPerforms a bitwise implication on two variants',
'variant_int': '(mixed $value): variant\nReturns the integer portion of a variant',
'variant_mod': '(mixed $left, mixed $right): variant\nDivides two variants and returns only the remainder',
'variant_mul': '(mixed $left, mixed $right): variant\nMultiplies the values of the two variants',
'variant_neg': '(mixed $value): variant\nPerforms logical negation on a variant',
'variant_not': '(mixed $value): variant\nPerforms bitwise not negation on a variant',
'variant_or': '(mixed $left, mixed $right): variant\nPerforms a logical disjunction on two variants',
'variant_pow': '(mixed $left, mixed $right): variant\nReturns the result of performing the power function with two variants',
'variant_round': '(mixed $value, int $decimals): ?variant\nRounds a variant to the specified number of decimal places',
'variant_set_type': '(variant $variant, int $type): void\nConvert a variant into another type "in-place"',
'variant_set': '(variant $variant, mixed $value): void\nAssigns a new value for a variant object',
'variant_sub': '(mixed $left, mixed $right): variant\nSubtracts the value of the right variant from the left variant value',
'variant_xor': '(mixed $left, mixed $right): variant\nPerforms a logical exclusion on two variants',
'ctype_alnum': '(mixed $text): bool\nCheck for alphanumeric character(s)',
'ctype_alpha': '(mixed $text): bool\nCheck for alphabetic character(s)',
'ctype_cntrl': '(mixed $text): bool\nCheck for control character(s)',
'ctype_digit': '(mixed $text): bool\nCheck for numeric character(s)',
'ctype_graph': '(mixed $text): bool\nCheck for any printable character(s) except space',
'ctype_lower': '(mixed $text): bool\nCheck for lowercase character(s)',
'ctype_print': '(mixed $text): bool\nCheck for printable character(s)',
'ctype_punct': '(mixed $text): bool\nCheck for any printable character which is not whitespace or an alphanumeric character',
'ctype_space': '(mixed $text): bool\nCheck for whitespace character(s)',
'ctype_upper': '(mixed $text): bool\nCheck for uppercase character(s)',
'ctype_xdigit': '(mixed $text): bool\nCheck for character(s) representing a hexadecimal digit',
'dba_close': '(Dba\\Connection $dba): void\nClose a DBA database',
'dba_delete': '(string|array $key, Dba\\Connection $dba): bool\nDelete DBA entry specified by key',
'dba_exists': '(string|array $key, Dba\\Connection $dba): bool\nCheck whether key exists',
'dba_fetch': '(string|array $key, int $skip, resource $dba): string\nFetch data specified by key',
'dba_firstkey': '(Dba\\Connection $dba): string|false\nFetch first key',
'dba_handlers': '(bool $full_info = false): array\nList all the handlers available',
'dba_insert': '(string|array $key, string $value, Dba\\Connection $dba): bool\nInsert entry',
'dba_key_split': '(string|false|null $key): array|false\nSplits a key in string representation into array representation',
'dba_list': '(): array\nList all open database files',
'dba_nextkey': '(Dba\\Connection $dba): string|false\nFetch next key',
'dba_open': '(string $path, string $mode, ?string $handler = null, int $permission = 0644, int $map_size = ?, ?int $flags = null): Dba\\Connection|false\nOpen database',
'dba_optimize': '(Dba\\Connection $dba): bool\nOptimize database',
'dba_popen': '(string $path, string $mode, ?string $handler = null, int $permission = 0644, int $map_size = ?, ?int $flags = null): Dba\\Connection|false\nOpen database persistently',
'dba_replace': '(string|array $key, string $value, Dba\\Connection $dba): bool\nReplace or insert entry',
'dba_sync': '(Dba\\Connection $dba): bool\nSynchronize database',
'exif_imagetype': '(string $filename): int|false\nDetermine the type of an image',
'exif_read_data': '(resource|string $file, ?string $required_sections = null, bool $as_arrays = false, bool $read_thumbnail = false): array|false\nReads the EXIF headers from an image file',
'exif_tagname': '(int $index): string|false\nGet the header name for an index',
'exif_thumbnail': '(resource|string $file, int &$width = null, int &$height = null, int &$image_type = null): string|false\nRetrieve the embedded thumbnail of an image',
'read_exif_data': 'Alias of exif_read_data',
'FFI::addr': '(FFI\\CData &$ptr): FFI\\CData\nCreates an unmanaged pointer to C data',
'FFI::alignof': '(FFI\\CData|FFI\\CType &$ptr): int\nGets the alignment',
'FFI::arrayType': '(FFI\\CType $type, array $dimensions): FFI\\CType\nDynamically constructs a new C array type',
'FFI::cdef': '(string $code = "", ?string $lib = null): FFI\nCreates a new FFI object',
'FFI::free': '(FFI\\CData &$ptr): void\nReleases an unmanaged data structure',
'FFI::isNull': '(FFI\\CData &$ptr): bool\nChecks whether a FFI\\CData is a null pointer',
'FFI::load': '(string $filename): ?FFI\nLoads C declarations from a C header file',
'FFI::memcmp': '(string|FFI\\CData &$ptr1, string|FFI\\CData &$ptr2, int $size): int\nCompares memory areas',
'FFI::memcpy': '(FFI\\CData &$to, FFI\\CData|string &$from, int $size): void\nCopies one memory area to another',
'FFI::memset': '(FFI\\CData &$ptr, int $value, int $size): void\nFills a memory area',
'FFI::scope': '(string $name): FFI\nInstantiates an FFI object with C declarations parsed during preloading',
'FFI::sizeof': '(FFI\\CData|FFI\\CType &$ptr): int\nGets the size of C data or types',
'FFI::string': '(FFI\\CData &$ptr, ?int $size = null): string\nCreates a PHP string from a memory area',
'FFI::typeof': '(FFI\\CData &$ptr): FFI\\CType\nGets the FFI\\CType of FFI\\CData',
'finfo_buffer': '(finfo $finfo, string $string, int $flags = FILEINFO_NONE, ?resource $context = null): string|false\nReturn information about a string buffer',
'finfo_close': '(finfo $finfo): true\nClose finfo instance',
'finfo_file': '(finfo $finfo, string $filename, int $flags = FILEINFO_NONE, ?resource $context = null): string|false\nReturn information about a file',
'finfo_open': '(int $flags = FILEINFO_NONE, ?string $magic_database = null): finfo|false\nCreate a new finfo instance',
'finfo_set_flags': '(finfo $finfo, int $flags): true\nSet libmagic configuration options',
'mime_content_type': '(resource|string $filename): string|false\nDetect MIME Content-type for a file',
'filter_has_var': '(int $input_type, string $var_name): bool\nChecks if a variable of the specified type exists',
'filter_id': '(string $name): int|false\nReturns the filter ID belonging to a named filter',
'filter_input_array': '(int $type, array|int $options = FILTER_DEFAULT, bool $add_empty = true): array|false|null\nGets external variables and optionally filters them',
'filter_input': '(int $type, string $var_name, int $filter = FILTER_DEFAULT, array|int $options = ?): mixed\nGets a specific external variable by name and optionally filters it',
'filter_list': '(): array\nReturns a list of all supported filters',
'filter_var_array': '(array $array, array|int $options = FILTER_DEFAULT, bool $add_empty = true): array|false|null\nGets multiple variables and optionally filters them',
'filter_var': '(mixed $value, int $filter = FILTER_DEFAULT, array|int $options = ?): mixed\nFilters a variable with a specified filter',
'ftp_alloc': '(FTP\\Connection $ftp, int $size, string &$response = null): bool\nAllocates space for a file to be uploaded',
'ftp_append': '(FTP\\Connection $ftp, string $remote_filename, string $local_filename, int $mode = FTP_BINARY): bool\nAppend the contents of a file to another file on the FTP server',
'ftp_cdup': '(FTP\\Connection $ftp): bool\nChanges to the parent directory',
'ftp_chdir': '(FTP\\Connection $ftp, string $directory): bool\nChanges the current directory on a FTP server',
'ftp_chmod': '(FTP\\Connection $ftp, int $permissions, string $filename): int|false\nSet permissions on a file via FTP',
'ftp_close': '(FTP\\Connection $ftp): bool\nCloses an FTP connection',
'ftp_connect': '(string $hostname, int $port = 21, int $timeout = 90): FTP\\Connection|false\nOpens an FTP connection',
'ftp_delete': '(FTP\\Connection $ftp, string $filename): bool\nDeletes a file on the FTP server',
'ftp_exec': '(FTP\\Connection $ftp, string $command): bool\nRequests execution of a command on the FTP server',
'ftp_fget': '(FTP\\Connection $ftp, resource $stream, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): bool\nDownloads a file from the FTP server and saves to an open file',
'ftp_fput': '(FTP\\Connection $ftp, string $remote_filename, resource $stream, int $mode = FTP_BINARY, int $offset = ?): bool\nUploads from an open file to the FTP server',
'ftp_get_option': '(FTP\\Connection $ftp, int $option): int|bool\nRetrieves various runtime behaviours of the current FTP connection',
'ftp_get': '(FTP\\Connection $ftp, string $local_filename, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): bool\nDownloads a file from the FTP server',
'ftp_login': '(FTP\\Connection $ftp, string $username, string $password): bool\nLogs in to an FTP connection',
'ftp_mdtm': '(FTP\\Connection $ftp, string $filename): int\nReturns the last modified time of the given file',
'ftp_mkdir': '(FTP\\Connection $ftp, string $directory): string|false\nCreates a directory',
'ftp_mlsd': '(FTP\\Connection $ftp, string $directory): array|false\nReturns a list of files in the given directory',
'ftp_nb_continue': '(FTP\\Connection $ftp): int\nContinues retrieving/sending a file (non-blocking)',
'ftp_nb_fget': '(FTP\\Connection $ftp, resource $stream, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): int\nRetrieves a file from the FTP server and writes it to an open file (non-blocking)',
'ftp_nb_fput': '(FTP\\Connection $ftp, string $remote_filename, resource $stream, int $mode = FTP_BINARY, int $offset = ?): int\nStores a file from an open file to the FTP server (non-blocking)',
'ftp_nb_get': '(FTP\\Connection $ftp, string $local_filename, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): int|false\nRetrieves a file from the FTP server and writes it to a local file (non-blocking)',
'ftp_nb_put': '(FTP\\Connection $ftp, string $remote_filename, string $local_filename, int $mode = FTP_BINARY, int $offset = ?): int|false\nStores a file on the FTP server (non-blocking)',
'ftp_nlist': '(FTP\\Connection $ftp, string $directory): array|false\nReturns a list of files in the given directory',
'ftp_pasv': '(FTP\\Connection $ftp, bool $enable): bool\nTurns passive mode on or off',
'ftp_put': '(FTP\\Connection $ftp, string $remote_filename, string $local_filename, int $mode = FTP_BINARY, int $offset = ?): bool\nUploads a file to the FTP server',
'ftp_pwd': '(FTP\\Connection $ftp): string|false\nReturns the current directory name',
'ftp_quit': 'Alias of ftp_close',
'ftp_raw': '(FTP\\Connection $ftp, string $command): ?array\nSends an arbitrary command to an FTP server',
'ftp_rawlist': '(FTP\\Connection $ftp, string $directory, bool $recursive = false): array|false\nReturns a detailed list of files in the given directory',
'ftp_rename': '(FTP\\Connection $ftp, string $from, string $to): bool\nRenames a file or a directory on the FTP server',
'ftp_rmdir': '(FTP\\Connection $ftp, string $directory): bool\nRemoves a directory',
'ftp_set_option': '(FTP\\Connection $ftp, int $option, int|bool $value): true\nSet miscellaneous runtime FTP options',
'ftp_site': '(FTP\\Connection $ftp, string $command): bool\nSends a SITE command to the server',
'ftp_size': '(FTP\\Connection $ftp, string $filename): int\nReturns the size of the given file',
'ftp_ssl_connect': '(string $hostname, int $port = 21, int $timeout = 90): FTP\\Connection|false\nOpens a Secure SSL-FTP connection',
'ftp_systype': '(FTP\\Connection $ftp): string|false\nReturns the system type identifier of the remote FTP server',
'iconv_get_encoding': '(string $type = "all"): array|string|false\nRetrieve internal configuration variables of iconv extension',
'iconv_mime_decode_headers': '(string $headers, int $mode = ?, ?string $encoding = null): array|false\nDecodes multiple MIME header fields at once',
'iconv_mime_decode': '(string $string, int $mode = ?, ?string $encoding = null): string|false\nDecodes a MIME header field',
'iconv_mime_encode': '(string $field_name, string $field_value, array $options = []): string|false\nComposes a MIME header field',
'iconv_set_encoding': '(string $type, string $encoding): bool\nSet current setting for character encoding conversion',
'iconv_strlen': '(string $string, ?string $encoding = null): int|false\nReturns the character count of string',
'iconv_strpos': '(string $haystack, string $needle, int $offset = ?, ?string $encoding = null): int|false\nFinds position of first occurrence of a needle within a haystack',
'iconv_strrpos': '(string $haystack, string $needle, ?string $encoding = null): int|false\nFinds the last occurrence of a needle within a haystack',
'iconv_substr': '(string $string, int $offset, ?int $length = null, ?string $encoding = null): string|false\nCut out part of a string',
'iconv': '(string $from_encoding, string $to_encoding, string $string): string|false\nConvert a string from one character encoding to another',
'ob_iconv_handler': '(string $contents, int $status): string\nConvert character encoding as output buffer handler',
'gd_info': '(): array\nRetrieve information about the currently installed GD library',
'getimagesize': '(string $filename, array &$image_info = null): array|false\nGet the size of an image',
'getimagesizefromstring': '(string $string, array &$image_info = null): array|false\nGet the size of an image from a string',
'image_type_to_extension': '(int $image_type, bool $include_dot = true): string|false\nGet file extension for image type',
'image_type_to_mime_type': '(int $image_type): string\nGet Mime-Type for image-type returned by getimagesize, exif_read_data, exif_thumbnail, exif_imagetype',
'image2wbmp': '(resource $image, string $filename = ?, int $foreground = ?): bool\ngd.image.output',
'imageaffine': '(GdImage $image, array $affine, ?array $clip = null): GdImage|false\nReturn an image containing the affine transformed src image, using an optional clipping area',
'imageaffinematrixconcat': '(array $matrix1, array $matrix2): array|false\nConcatenate two affine transformation matrices',
'imageaffinematrixget': '(int $type, array|float $options): array|false\nGet an affine transformation matrix',
'imagealphablending': '(GdImage $image, bool $enable): true\nSet the blending mode for an image',
'imageantialias': '(GdImage $image, bool $enable): true\nShould antialias functions be used or not',
'imagearc': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $start_angle, int $end_angle, int $color): true\nDraws an arc',
'imageavif': '(GdImage $image, resource|string|null $file = null, int $quality = -1, int $speed = -1): bool\ngd.image.output',
'imagebmp': '(GdImage $image, resource|string|null $file = null, bool $compressed = true): bool\nOutput a BMP image to browser or file',
'imagechar': '(GdImage $image, GdFont|int $font, int $x, int $y, string $char, int $color): true\nDraw a character horizontally',
'imagecharup': '(GdImage $image, GdFont|int $font, int $x, int $y, string $char, int $color): true\nDraw a character vertically',
'imagecolorallocate': '(GdImage $image, int $red, int $green, int $blue): int|false\nAllocate a color for an image',
'imagecolorallocatealpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int|false\nAllocate a color for an image',
'imagecolorat': '(GdImage $image, int $x, int $y): int|false\nGet the index of the color of a pixel',
'imagecolorclosest': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the closest color to the specified color',
'imagecolorclosestalpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int\nGet the index of the closest color to the specified color + alpha',
'imagecolorclosesthwb': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the color which has the hue, white and blackness',
'imagecolordeallocate': '(GdImage $image, int $color): true\nDe-allocate a color for an image',
'imagecolorexact': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the specified color',
'imagecolorexactalpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int\nGet the index of the specified color + alpha',
'imagecolormatch': '(GdImage $image1, GdImage $image2): true\nMakes the colors of the palette version of an image more closely match the true color version',
'imagecolorresolve': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the specified color or its closest possible alternative',
'imagecolorresolvealpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int\nGet the index of the specified color + alpha or its closest possible alternative',
'imagecolorset': '(GdImage $image, int $color, int $red, int $green, int $blue, int $alpha = ?): ?false\nSet the color for the specified palette index',
'imagecolorsforindex': '(GdImage $image, int $color): array\nGet the colors for an index',
'imagecolorstotal': '(GdImage $image): int\nFind out the number of colors in an image\'s palette',
'imagecolortransparent': '(GdImage $image, ?int $color = null): int\nDefine a color as transparent',
'imageconvolution': '(GdImage $image, array $matrix, float $divisor, float $offset): bool\nApply a 3x3 convolution matrix, using coefficient and offset',
'imagecopy': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $src_width, int $src_height): true\nCopy part of an image',
'imagecopymerge': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $src_width, int $src_height, int $pct): true\nCopy and merge part of an image',
'imagecopymergegray': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $src_width, int $src_height, int $pct): true\nCopy and merge part of an image with gray scale',
'imagecopyresampled': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $dst_width, int $dst_height, int $src_width, int $src_height): true\nCopy and resize part of an image with resampling',
'imagecopyresized': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $dst_width, int $dst_height, int $src_width, int $src_height): true\nCopy and resize part of an image',
'imagecreate': '(int $width, int $height): GdImage|false\nCreate a new palette based image',
'imagecreatefromavif': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefrombmp': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromgd': '(string $filename): GdImage|false\nCreate a new image from GD file or URL',
'imagecreatefromgd2': '(string $filename): GdImage|false\nCreate a new image from GD2 file or URL',
'imagecreatefromgd2part': '(string $filename, int $x, int $y, int $width, int $height): GdImage|false\nCreate a new image from a given part of GD2 file or URL',
'imagecreatefromgif': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromjpeg': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefrompng': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromstring': '(string $data): GdImage|false\nCreate a new image from the image stream in the string',
'imagecreatefromtga': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromwbmp': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromwebp': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromxbm': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatefromxpm': '(string $filename): GdImage|false\ngd.image.new',
'imagecreatetruecolor': '(int $width, int $height): GdImage|false\nCreate a new true color image',
'imagecrop': '(GdImage $image, array $rectangle): GdImage|false\nCrop an image to the given rectangle',
'imagecropauto': '(GdImage $image, int $mode = IMG_CROP_DEFAULT, float $threshold = 0.5, int $color = -1): GdImage|false\nCrop an image automatically using one of the available modes',
'imagedashedline': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): true\nDraw a dashed line',
'imagedestroy': '(GdImage $image): true\nDestroy an image',
'imageellipse': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $color): true\nDraw an ellipse',
'imagefill': '(GdImage $image, int $x, int $y, int $color): true\nFlood fill',
'imagefilledarc': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $start_angle, int $end_angle, int $color, int $style): true\nDraw a partial arc and fill it',
'imagefilledellipse': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $color): true\nDraw a filled ellipse',
'imagefilledpolygon': '(GdImage $image, array $points, int $num_points, int $color): bool\nDraw a filled polygon',
'imagefilledrectangle': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): true\nDraw a filled rectangle',
'imagefilltoborder': '(GdImage $image, int $x, int $y, int $border_color, int $color): true\nFlood fill to specific color',
'imagefilter': '(GdImage $image, int $filter, array|int|float|bool ...$args): bool\nApplies a filter to an image',
'imageflip': '(GdImage $image, int $mode): true\nFlips an image using a given mode',
'imagefontheight': '(GdFont|int $font): int\nGet font height',
'imagefontwidth': '(GdFont|int $font): int\nGet font width',
'imageftbbox': '(float $size, float $angle, string $font_filename, string $string, array $options = []): array|false\nGive the bounding box of a text using fonts via freetype2',
'imagefttext': '(GdImage $image, float $size, float $angle, int $x, int $y, int $color, string $font_filename, string $text, array $options = []): array|false\nWrite text to the image using fonts using FreeType 2',
'imagegammacorrect': '(GdImage $image, float $input_gamma, float $output_gamma): true\nApply a gamma correction to a GD image',
'imagegd': '(GdImage $image, ?string $file = null): bool\nOutput GD image to browser or file',
'imagegd2': '(GdImage $image, ?string $file = null, int $chunk_size = 128, int $mode = IMG_GD2_RAW): bool\nOutput GD2 image to browser or file',
'imagegetclip': '(GdImage $image): array\nGet the clipping rectangle',
'imagegetinterpolation': '(GdImage $image): int\nGet the interpolation method',
'imagegif': '(GdImage $image, resource|string|null $file = null): bool\ngd.image.output',
'imagegrabscreen': '(): GdImage|false\nCaptures the whole screen',
'imagegrabwindow': '(int $handle, bool $client_area = false): GdImage|false\nCaptures a window',
'imageinterlace': '(GdImage $image, ?bool $enable = null): bool\nEnable or disable interlace',
'imageistruecolor': '(GdImage $image): bool\nFinds whether an image is a truecolor image',
'imagejpeg': '(GdImage $image, resource|string|null $file = null, int $quality = -1): bool\ngd.image.output',
'imagelayereffect': '(GdImage $image, int $effect): true\nSet the alpha blending flag to use layering effects',
'imageline': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): true\nDraw a line',
'imageloadfont': '(string $filename): GdFont|false\nLoad a new font',
'imageopenpolygon': '(GdImage $image, array $points, int $num_points, int $color): bool\nDraws an open polygon',
'imagepalettecopy': '(GdImage $dst, GdImage $src): void\nCopy the palette from one image to another',
'imagepalettetotruecolor': '(GdImage $image): bool\nConverts a palette based image to true color',
'imagepng': '(GdImage $image, resource|string|null $file = null, int $quality = -1, int $filters = -1): bool\nOutput a PNG image to either the browser or a file',
'imagepolygon': '(GdImage $image, array $points, int $num_points, int $color): bool\nDraws a polygon',
'imagerectangle': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): true\nDraw a rectangle',
'imageresolution': '(GdImage $image, ?int $resolution_x = null, ?int $resolution_y = null): array|true\nGet or set the resolution of the image',
'imagerotate': '(GdImage $image, float $angle, int $background_color): GdImage|false\nRotate an image with a given angle',
'imagesavealpha': '(GdImage $image, bool $enable): true\nWhether to retain full alpha channel information when saving images',
'imagescale': '(GdImage $image, int $width, int $height = -1, int $mode = IMG_BILINEAR_FIXED): GdImage|false\nScale an image using the given new width and height',
'imagesetbrush': '(GdImage $image, GdImage $brush): true\nSet the brush image for line drawing',
'imagesetclip': '(GdImage $image, int $x1, int $y1, int $x2, int $y2): true\nSet the clipping rectangle',
'imagesetinterpolation': '(GdImage $image, int $method = IMG_BILINEAR_FIXED): bool\nSet the interpolation method',
'imagesetpixel': '(GdImage $image, int $x, int $y, int $color): true\nSet a single pixel',
'imagesetstyle': '(GdImage $image, array $style): bool\nSet the style for line drawing',
'imagesetthickness': '(GdImage $image, int $thickness): true\nSet the thickness for line drawing',
'imagesettile': '(GdImage $image, GdImage $tile): true\nSet the tile image for filling',
'imagestring': '(GdImage $image, GdFont|int $font, int $x, int $y, string $string, int $color): true\nDraw a string horizontally',
'imagestringup': '(GdImage $image, GdFont|int $font, int $x, int $y, string $string, int $color): true\nDraw a string vertically',
'imagesx': '(GdImage $image): int\nGet image width',
'imagesy': '(GdImage $image): int\nGet image height',
'imagetruecolortopalette': '(GdImage $image, bool $dither, int $num_colors): bool\nConvert a true color image to a palette image',
'imagettfbbox': '(float $size, float $angle, string $font_filename, string $string, array $options = []): array|false\nGive the bounding box of a text using TrueType fonts',
'imagettftext': '(GdImage $image, float $size, float $angle, int $x, int $y, int $color, string $font_filename, string $text, array $options = []): array|false\nWrite text to the image using TrueType fonts',
'imagetypes': '(): int\nReturn the image types supported by this PHP build',
'imagewbmp': '(GdImage $image, resource|string|null $file = null, ?int $foreground_color = null): bool\ngd.image.output',
'imagewebp': '(GdImage $image, resource|string|null $file = null, int $quality = -1): bool\nOutput a WebP image to browser or file',
'imagexbm': '(GdImage $image, ?string $filename, ?int $foreground_color = null): bool\nOutput an XBM image to browser or file',
'iptcembed': '(string $iptc_data, string $filename, int $spool = ?): string|bool\nEmbeds binary IPTC data into a JPEG image',
'iptcparse': '(string $iptc_block): array|false\nParse a binary IPTC block into single tags',
'jpeg2wbmp': '(string $jpegname, string $wbmpname, int $dest_height, int $dest_width, int $threshold): bool\nConvert JPEG image file to WBMP image file',
'png2wbmp': '(string $pngname, string $wbmpname, int $dest_height, int $dest_width, int $threshold): bool\nConvert PNG image file to WBMP image file',
'collator_asort': '(Collator $object, array &$array, int $flags = Collator::SORT_REGULAR): bool\nSort array maintaining index association',
'collator_compare': '(Collator $object, string $string1, string $string2): int|false\nCompare two Unicode strings',
'Collator::create': '(string $locale): ?Collator\nCreate a collator',
'collator_create': '(string $locale): ?Collator\nCreate a collator',
'collator_get_attribute': '(Collator $object, int $attribute): int|false\nGet collation attribute value',
'collator_get_error_code': '(Collator $object): int|false\nGet collator\'s last error code',
'collator_get_error_message': '(Collator $object): string|false\nGet text for collator\'s last error code',
'collator_get_locale': '(Collator $object, int $type): string|false\nGet the locale name of the collator',
'collator_get_sort_key': '(Collator $object, string $string): string|false\nGet sorting key for a string',
'collator_get_strength': '(Collator $object): int\nGet current collation strength',
'collator_set_attribute': '(Collator $object, int $attribute, int $value): bool\nSet collation attribute',
'collator_set_strength': '(Collator $object, int $strength): true\nSet collation strength',
'collator_sort_with_sort_keys': '(Collator $object, array &$array): bool\nSort array using specified collator and sort keys',
'collator_sort': '(Collator $object, array &$array, int $flags = Collator::SORT_REGULAR): bool\nSort array using specified collator',
'IntlDateFormatter::create': '(?string $locale, int $dateType = IntlDateFormatter::FULL, int $timeType = IntlDateFormatter::FULL, IntlTimeZone|DateTimeZone|string|null $timezone = null, IntlCalendar|int|null $calendar = null, ?string $pattern = null): ?IntlDateFormatter\nCreate a date formatter',
'datefmt_create': '(?string $locale, int $dateType = IntlDateFormatter::FULL, int $timeType = IntlDateFormatter::FULL, IntlTimeZone|DateTimeZone|string|null $timezone = null, IntlCalendar|int|null $calendar = null, ?string $pattern = null): ?IntlDateFormatter\nCreate a date formatter',
'datefmt_format': '(IntlDateFormatter $formatter, IntlCalendar|DateTimeInterface|array|string|int|float $datetime): string|false\nFormat the date/time value as a string',
'IntlDateFormatter::formatObject': '(IntlCalendar|DateTimeInterface $datetime, array|int|string|null $format = null, ?string $locale = null): string|false\nFormats an object',
'datefmt_format_object': '(IntlCalendar|DateTimeInterface $datetime, array|int|string|null $format = null, ?string $locale = null): string|false\nFormats an object',
'datefmt_get_calendar': '(IntlDateFormatter $formatter): int|false\nGet the calendar type used for the IntlDateFormatter',
'datefmt_get_datetype': '(IntlDateFormatter $formatter): int|false\nGet the datetype used for the IntlDateFormatter',
'datefmt_get_error_code': '(IntlDateFormatter $formatter): int\nGet the error code from last operation',
'datefmt_get_error_message': '(IntlDateFormatter $formatter): string\nGet the error text from the last operation',
'datefmt_get_locale': '(IntlDateFormatter $formatter, int $type = ULOC_ACTUAL_LOCALE): string|false\nGet the locale used by formatter',
'datefmt_get_pattern': '(IntlDateFormatter $formatter): string|false\nGet the pattern used for the IntlDateFormatter',
'datefmt_get_timetype': '(IntlDateFormatter $formatter): int|false\nGet the timetype used for the IntlDateFormatter',
'datefmt_get_timezone_id': '(IntlDateFormatter $formatter): string|false\nGet the timezone-id used for the IntlDateFormatter',
'datefmt_get_calendar_object': '(IntlDateFormatter $formatter): IntlCalendar|false|null\nGet copy of formatterʼs calendar object',
'datefmt_get_timezone': '(IntlDateFormatter $formatter): IntlTimeZone|false\nGet formatterʼs timezone',
'datefmt_is_lenient': '(IntlDateFormatter $formatter): bool\nGet the lenient used for the IntlDateFormatter',
'datefmt_localtime': '(IntlDateFormatter $formatter, string $string, int &$offset = null): array|false\nParse string to a field-based time value',
'datefmt_parse': '(IntlDateFormatter $formatter, string $string, int &$offset = null): int|float|false\nParse string to a timestamp value',
'datefmt_set_calendar': '(IntlDateFormatter $formatter, IntlCalendar|int|null $calendar): bool\nSets the calendar type used by the formatter',
'datefmt_set_lenient': '(IntlDateFormatter $formatter, bool $lenient): void\nSet the leniency of the parser',
'datefmt_set_pattern': '(IntlDateFormatter $formatter, string $pattern): bool\nSet the pattern used for the IntlDateFormatter',
'datefmt_set_timezone': '(IntlDateFormatter $formatter, IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSets formatterʼs timezone',
'intl_error_name': '(int $errorCode): string\nGet symbolic name for a given error code',
'intl_get_error_code': '(): int\nGet last error code on the object',
'intl_get_error_message': '(): string\nGet last error message on the object',
'intl_is_failure': '(int $errorCode): bool\nCheck whether the given error code indicates failure',
'grapheme_extract': '(string $haystack, int $size, int $type = GRAPHEME_EXTR_COUNT, int $offset = ?, int &$next = null): string|false\nFunction to extract a sequence of default grapheme clusters from a text buffer, which must be encoded in UTF-8',
'grapheme_str_split': '(string $string, int $length = 1): array|false\nSplit a string into an array',
'grapheme_stripos': '(string $haystack, string $needle, int $offset = ?, string $locale = ""): int|false\nFind position (in grapheme units) of first occurrence of a case-insensitive string',
'grapheme_stristr': '(string $haystack, string $needle, bool $beforeNeedle = false, string $locale = ""): string|false\nReturns part of haystack string from the first occurrence of case-insensitive needle to the end of haystack',
'grapheme_strlen': '(string $string): int|false|null\nGet string length in grapheme units',
'grapheme_strpos': '(string $haystack, string $needle, int $offset = ?, string $locale = ""): int|false\nFind position (in grapheme units) of first occurrence of a string',
'grapheme_strripos': '(string $haystack, string $needle, int $offset = ?, string $locale = ""): int|false\nFind position (in grapheme units) of last occurrence of a case-insensitive string',
'grapheme_strrpos': '(string $haystack, string $needle, int $offset = ?, string $locale = ""): int|false\nFind position (in grapheme units) of last occurrence of a string',
'grapheme_strstr': '(string $haystack, string $needle, bool $beforeNeedle = false, string $locale = ""): string|false\nReturns part of haystack string from the first occurrence of needle to the end of haystack',
'grapheme_substr': '(string $string, int $offset, ?int $length = null, string $locale = ""): string|false\nReturn part of a string',
'idn_to_ascii': '(string $domain, int $flags = IDNA_DEFAULT, int $variant = INTL_IDNA_VARIANT_UTS46, array &$idna_info = null): string|false\nConvert domain name to IDNA ASCII form',
'idn_to_utf8': '(string $domain, int $flags = IDNA_DEFAULT, int $variant = INTL_IDNA_VARIANT_UTS46, array &$idna_info = null): string|false\nConvert domain name from IDNA ASCII to Unicode',
'IntlBreakIterator::createCharacterInstance': '(?string $locale = null): ?IntlBreakIterator\nCreate break iterator for boundaries of combining character sequences',
'IntlBreakIterator::createCodePointInstance': '(): IntlCodePointBreakIterator\nCreate break iterator for boundaries of code points',
'IntlBreakIterator::createLineInstance': '(?string $locale = null): ?IntlBreakIterator\nCreate break iterator for logically possible line breaks',
'IntlBreakIterator::createSentenceInstance': '(?string $locale = null): ?IntlBreakIterator\nCreate break iterator for sentence breaks',
'IntlBreakIterator::createTitleInstance': '(?string $locale = null): ?IntlBreakIterator\nCreate break iterator for title-casing breaks',
'IntlBreakIterator::createWordInstance': '(?string $locale = null): ?IntlBreakIterator\nCreate break iterator for word breaks',
'intlcal_add': '(IntlCalendar $calendar, int $field, int $value): bool\nAdd a (signed) amount of time to a field',
'intlcal_after': '(IntlCalendar $calendar, IntlCalendar $other): bool\nWhether this objectʼs time is after that of the passed object',
'intlcal_before': '(IntlCalendar $calendar, IntlCalendar $other): bool\nWhether this objectʼs time is before that of the passed object',
'intlcal_clear': '(IntlCalendar $calendar, ?int $field = null): true\nClear a field or all fields',
'IntlCalendar::createInstance': '(IntlTimeZone|DateTimeZone|string|null $timezone = null, ?string $locale = null): ?IntlCalendar\nCreate a new IntlCalendar',
'intlcal_create_instance': '(IntlTimeZone|DateTimeZone|string|null $timezone = null, ?string $locale = null): ?IntlCalendar\nCreate a new IntlCalendar',
'intlcal_equals': '(IntlCalendar $calendar, IntlCalendar $other): bool\nCompare time of two IntlCalendar objects for equality',
'intlcal_field_difference': '(IntlCalendar $calendar, float $timestamp, int $field): int|false\nCalculate difference between given time and this objectʼs time',
'IntlCalendar::fromDateTime': '(DateTime|string $datetime, ?string $locale = null): ?IntlCalendar\nCreate an IntlCalendar from a DateTime object or string',
'intlcal_from_date_time': '(DateTime|string $datetime, ?string $locale = null): ?IntlCalendar\nCreate an IntlCalendar from a DateTime object or string',
'intlcal_get': '(IntlCalendar $calendar, int $field): int|false\nGet the value for a field',
'intlcal_get_actual_maximum': '(IntlCalendar $calendar, int $field): int|false\nThe maximum value for a field, considering the objectʼs current time',
'intlcal_get_actual_minimum': '(IntlCalendar $calendar, int $field): int|false\nThe minimum value for a field, considering the objectʼs current time',
'IntlCalendar::getAvailableLocales': '(): array\nGet array of locales for which there is data',
'intlcal_get_available_locales': '(): array\nGet array of locales for which there is data',
'intlcal_get_day_of_week_type': '(IntlCalendar $calendar, int $dayOfWeek): int|false\nTell whether a day is a weekday, weekend or a day that has a transition between the two',
'intlcal_get_error_code': '(IntlCalendar $calendar): int|false\nGet last error code on the object',
'intlcal_get_error_message': '(IntlCalendar $calendar): string|false\nGet last error message on the object',
'intlcal_get_first_day_of_week': '(IntlCalendar $calendar): int|false\nGet the first day of the week for the calendarʼs locale',
'intlcal_get_greatest_minimum': '(IntlCalendar $calendar, int $field): int|false\nGet the largest local minimum value for a field',
'IntlCalendar::getKeywordValuesForLocale': '(string $keyword, string $locale, bool $onlyCommon): IntlIterator|false\nGet set of locale keyword values',
'intlcal_get_keyword_values_for_locale': '(string $keyword, string $locale, bool $onlyCommon): IntlIterator|false\nGet set of locale keyword values',
'intlcal_get_least_maximum': '(IntlCalendar $calendar, int $field): int|false\nGet the smallest local maximum for a field',
'intlcal_get_locale': '(IntlCalendar $calendar, int $type): string|false\nGet the locale associated with the object',
'intlcal_get_maximum': '(IntlCalendar $calendar, int $field): int|false\nGet the global maximum value for a field',
'intlcal_get_minimal_days_in_first_week': '(IntlCalendar $calendar): int|false\nGet minimal number of days the first week in a year or month can have',
'intlcal_get_minimum': '(IntlCalendar $calendar, int $field): int|false\nGet the global minimum value for a field',
'IntlCalendar::getNow': '(): float\nGet number representing the current time',
'intlcal_get_now': '(): float\nGet number representing the current time',
'intlcal_get_repeated_wall_time_option': '(IntlCalendar $calendar): int\nGet behavior for handling repeating wall time',
'intlcal_get_skipped_wall_time_option': '(IntlCalendar $calendar): int\nGet behavior for handling skipped wall time',
'intlcal_get_time': '(IntlCalendar $calendar): float|false\nGet time currently represented by the object',
'intlcal_get_time_zone': '(IntlCalendar $calendar): IntlTimeZone|false\nGet the objectʼs timezone',
'intlcal_get_type': '(IntlCalendar $calendar): string\nGet the calendar type',
'intlcal_get_weekend_transition': '(IntlCalendar $calendar, int $dayOfWeek): int|false\nGet time of the day at which weekend begins or ends',
'intlcal_in_daylight_time': '(IntlCalendar $calendar): bool\nWhether the objectʼs time is in Daylight Savings Time',
'intlcal_is_equivalent_to': '(IntlCalendar $calendar, IntlCalendar $other): bool\nWhether another calendar is equal but for a different time',
'intlcal_is_lenient': '(IntlCalendar $calendar): bool\nWhether date/time interpretation is in lenient mode',
'intlcal_is_set': '(IntlCalendar $calendar, int $field): bool\nWhether a field is set',
'intlcal_is_weekend': '(IntlCalendar $calendar, ?float $timestamp = null): bool\nWhether a certain date/time is in the weekend',
'intlcal_roll': '(IntlCalendar $calendar, int $field, int|bool $value): bool\nAdd value to field without carrying into more significant fields',
'intlcal_set': '(IntlCalendar $cal, int $year, int $month, int $dayOfMonth = NULL, int $hour = NULL, int $minute = NULL, int $second = NULL): bool\nSet a time field or several common fields at once',
'intlcal_set_first_day_of_week': '(IntlCalendar $calendar, int $dayOfWeek): true\nSet the day on which the week is deemed to start',
'intlcal_set_lenient': '(IntlCalendar $calendar, bool $lenient): true\nSet whether date/time interpretation is to be lenient',
'intlcal_set_minimal_days_in_first_week': '(IntlCalendar $calendar, int $days): true\nSet minimal number of days the first week in a year or month can have',
'intlcal_set_repeated_wall_time_option': '(IntlCalendar $calendar, int $option): true\nSet behavior for handling repeating wall times at negative timezone offset transitions',
'intlcal_set_skipped_wall_time_option': '(IntlCalendar $calendar, int $option): true\nSet behavior for handling skipped wall times at positive timezone offset transitions',
'intlcal_set_time': '(IntlCalendar $calendar, float $timestamp): bool\nSet the calendar time in milliseconds since the epoch',
'intlcal_set_time_zone': '(IntlCalendar $calendar, IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSet the timezone used by this calendar',
'intlcal_to_date_time': '(IntlCalendar $calendar): DateTime|false\nConvert an IntlCalendar into a DateTime object',
'IntlChar::charAge': '(int|string $codepoint): ?array\nGet the "age" of the code point',
'IntlChar::charDigitValue': '(int|string $codepoint): ?int\nGet the decimal digit value of a decimal digit character',
'IntlChar::charDirection': '(int|string $codepoint): ?int\nGet bidirectional category value for a code point',
'IntlChar::charFromName': '(string $name, int $type = IntlChar::UNICODE_CHAR_NAME): ?int\nFind Unicode character by name and return its code point value',
'IntlChar::charMirror': '(int|string $codepoint): int|string|null\nGet the "mirror-image" character for a code point',
'IntlChar::charName': '(int|string $codepoint, int $type = IntlChar::UNICODE_CHAR_NAME): ?string\nRetrieve the name of a Unicode character',
'IntlChar::charType': '(int|string $codepoint): ?int\nGet the general category value for a code point',
'IntlChar::chr': '(int|string $codepoint): ?string\nReturn Unicode character by code point value',
'IntlChar::digit': '(int|string $codepoint, int $base = 10): int|false|null\nGet the decimal digit value of a code point for a given radix',
'IntlChar::enumCharNames': '(int|string $start, int|string $end, callable $callback, int $type = IntlChar::UNICODE_CHAR_NAME): bool\nEnumerate all assigned Unicode characters within a range',
'IntlChar::enumCharTypes': '(callable $callback): void\nEnumerate all code points with their Unicode general categories',
'IntlChar::foldCase': '(int|string $codepoint, int $options = IntlChar::FOLD_CASE_DEFAULT): int|string|null\nPerform case folding on a code point',
'IntlChar::forDigit': '(int $digit, int $base = 10): int\nGet character representation for a given digit and radix',
'IntlChar::getBidiPairedBracket': '(int|string $codepoint): int|string|null\nGet the paired bracket character for a code point',
'IntlChar::getBlockCode': '(int|string $codepoint): ?int\nGet the Unicode allocation block containing a code point',
'IntlChar::getCombiningClass': '(int|string $codepoint): ?int\nGet the combining class of a code point',
'IntlChar::getFC_NFKC_Closure': '(int|string $codepoint): string|false|null\nGet the FC_NFKC_Closure property for a code point',
'IntlChar::getIntPropertyMaxValue': '(int $property): int\nGet the max value for a Unicode property',
'IntlChar::getIntPropertyMinValue': '(int $property): int\nGet the min value for a Unicode property',
'IntlChar::getIntPropertyValue': '(int|string $codepoint, int $property): ?int\nGet the value for a Unicode property for a code point',
'IntlChar::getNumericValue': '(int|string $codepoint): ?float\nGet the numeric value for a Unicode code point',
'IntlChar::getPropertyEnum': '(string $alias): int\nGet the property constant value for a given property name',
'IntlChar::getPropertyName': '(int $property, int $type = IntlChar::LONG_PROPERTY_NAME): string|false\nGet the Unicode name for a property',
'IntlChar::getPropertyValueEnum': '(int $property, string $name): int\nGet the property value for a given value name',
'IntlChar::getPropertyValueName': '(int $property, int $value, int $type = IntlChar::LONG_PROPERTY_NAME): string|false\nGet the Unicode name for a property value',
'IntlChar::getUnicodeVersion': '(): array\nGet the Unicode version',
'IntlChar::hasBinaryProperty': '(int|string $codepoint, int $property): ?bool\nCheck a binary Unicode property for a code point',
'IntlChar::isalnum': '(int|string $codepoint): ?bool\nCheck if code point is an alphanumeric character',
'IntlChar::isalpha': '(int|string $codepoint): ?bool\nCheck if code point is a letter character',
'IntlChar::isbase': '(int|string $codepoint): ?bool\nCheck if code point is a base character',
'IntlChar::isblank': '(int|string $codepoint): ?bool\nCheck if code point is a "blank" or "horizontal space" character',
'IntlChar::iscntrl': '(int|string $codepoint): ?bool\nCheck if code point is a control character',
'IntlChar::isdefined': '(int|string $codepoint): ?bool\nCheck whether the code point is defined',
'IntlChar::isdigit': '(int|string $codepoint): ?bool\nCheck if code point is a digit character',
'IntlChar::isgraph': '(int|string $codepoint): ?bool\nCheck if code point is a graphic character',
'IntlChar::isIDIgnorable': '(int|string $codepoint): ?bool\nCheck if code point is an ignorable character',
'IntlChar::isIDPart': '(int|string $codepoint): ?bool\nCheck if code point is permissible in an identifier',
'IntlChar::isIDStart': '(int|string $codepoint): ?bool\nCheck if code point is permissible as the first character in an identifier',
'IntlChar::isISOControl': '(int|string $codepoint): ?bool\nCheck if code point is an ISO control code',
'IntlChar::isJavaIDPart': '(int|string $codepoint): ?bool\nCheck if code point is permissible in a Java identifier',
'IntlChar::isJavaIDStart': '(int|string $codepoint): ?bool\nCheck if code point is permissible as the first character in a Java identifier',
'IntlChar::isJavaSpaceChar': '(int|string $codepoint): ?bool\nCheck if code point is a space character according to Java',
'IntlChar::islower': '(int|string $codepoint): ?bool\nCheck if code point is a lowercase letter',
'IntlChar::isMirrored': '(int|string $codepoint): ?bool\nCheck if code point has the Bidi_Mirrored property',
'IntlChar::isprint': '(int|string $codepoint): ?bool\nCheck if code point is a printable character',
'IntlChar::ispunct': '(int|string $codepoint): ?bool\nCheck if code point is punctuation character',
'IntlChar::isspace': '(int|string $codepoint): ?bool\nCheck if code point is a space character',
'IntlChar::istitle': '(int|string $codepoint): ?bool\nCheck if code point is a titlecase letter',
'IntlChar::isUAlphabetic': '(int|string $codepoint): ?bool\nCheck if code point has the Alphabetic Unicode property',
'IntlChar::isULowercase': '(int|string $codepoint): ?bool\nCheck if code point has the Lowercase Unicode property',
'IntlChar::isupper': '(int|string $codepoint): ?bool\nCheck if code point has the general category "Lu" (uppercase letter)',
'IntlChar::isUUppercase': '(int|string $codepoint): ?bool\nCheck if code point has the Uppercase Unicode property',
'IntlChar::isUWhiteSpace': '(int|string $codepoint): ?bool\nCheck if code point has the White_Space Unicode property',
'IntlChar::isWhitespace': '(int|string $codepoint): ?bool\nCheck if code point is a whitespace character according to ICU',
'IntlChar::isxdigit': '(int|string $codepoint): ?bool\nCheck if code point is a hexadecimal digit',
'IntlChar::ord': '(int|string $character): ?int\nReturn Unicode code point value of character',
'IntlChar::tolower': '(int|string $codepoint): int|string|null\nMake Unicode character lowercase',
'IntlChar::totitle': '(int|string $codepoint): int|string|null\nMake Unicode character titlecase',
'IntlChar::toupper': '(int|string $codepoint): int|string|null\nMake Unicode character uppercase',
'IntlDatePatternGenerator::create': '(?string $locale = null): ?IntlDatePatternGenerator\nCreates a new IntlDatePatternGenerator instance',
'IntlGregorianCalendar::createFromDate': '(int $year, int $month, int $dayOfMonth): static\nCreate a new IntlGregorianCalendar instance from date',
'IntlGregorianCalendar::createFromDateTime': '(int $year, int $month, int $dayOfMonth, int $hour, int $minute, ?int $second = null): static\nCreate a new IntlGregorianCalendar instance from date and time',
'IntlTimeZone::countEquivalentIDs': '(string $timezoneId): int|false\nGet the number of IDs in the equivalency group that includes the given ID',
'intltz_count_equivalent_ids': '(string $timezoneId): int|false\nGet the number of IDs in the equivalency group that includes the given ID',
'IntlTimeZone::createDefault': '(): IntlTimeZone\nCreate a new copy of the default timezone for this host',
'intltz_create_default': '(): IntlTimeZone\nCreate a new copy of the default timezone for this host',
'IntlTimeZone::createEnumeration': '(string|int|null $countryOrRawOffset = null): IntlIterator|false\nGet an enumeration over time zone IDs associated with the given country or offset',
'intltz_create_enumeration': '(string|int|null $countryOrRawOffset = null): IntlIterator|false\nGet an enumeration over time zone IDs associated with the given country or offset',
'IntlTimeZone::createTimeZone': '(string $timezoneId): ?IntlTimeZone\nCreate a timezone object for the given ID',
'intltz_create_time_zone': '(string $timezoneId): ?IntlTimeZone\nCreate a timezone object for the given ID',
'IntlTimeZone::createTimeZoneIDEnumeration': '(int $type, ?string $region = null, ?int $rawOffset = null): IntlIterator|false\nGet an enumeration over system time zone IDs with the given filter conditions',
'intltz_create_time_zone_id_enumeration': '(int $type, ?string $region = null, ?int $rawOffset = null): IntlIterator|false\nGet an enumeration over system time zone IDs with the given filter conditions',
'IntlTimeZone::fromDateTimeZone': '(DateTimeZone $timezone): ?IntlTimeZone\nCreate a timezone object from DateTimeZone',
'intltz_from_date_time_zone': '(DateTimeZone $timezone): ?IntlTimeZone\nCreate a timezone object from DateTimeZone',
'IntlTimeZone::getCanonicalID': '(string $timezoneId, bool &$isSystemId = null): string|false\nGet the canonical system timezone ID or the normalized custom time zone ID for the given time zone ID',
'intltz_get_canonical_id': '(string $timezoneId, bool &$isSystemId = null): string|false\nGet the canonical system timezone ID or the normalized custom time zone ID for the given time zone ID',
'intltz_get_display_name': '(IntlTimeZone $timezone, bool $dst = false, int $style = IntlTimeZone::DISPLAY_LONG, ?string $locale = null): string|false\nGet a name of this time zone suitable for presentation to the user',
'intltz_get_dst_savings': '(IntlTimeZone $timezone): int\nGet the amount of time to be added to local standard time to get local wall clock time',
'IntlTimeZone::getEquivalentID': '(string $timezoneId, int $offset): string|false\nGet an ID in the equivalency group that includes the given ID',
'intltz_get_equivalent_id': '(string $timezoneId, int $offset): string|false\nGet an ID in the equivalency group that includes the given ID',
'intltz_get_error_code': '(IntlTimeZone $timezone): int|false\nGet last error code on the object',
'intltz_get_error_message': '(IntlTimeZone $timezone): string|false\nGet last error message on the object',
'IntlTimeZone::getGMT': '(): IntlTimeZone\nCreate GMT (UTC) timezone',
'intltz_get_gmt': '(): IntlTimeZone\nCreate GMT (UTC) timezone',
'IntlTimeZone::getIanaID': '(string $timezoneId): string|false\nTranslate a timezone identifier to its IANA equivalent',
'intltz_get_iana_id': '(string $timezoneId): string|false\nTranslate a timezone identifier to its IANA equivalent',
'intltz_get_id': '(IntlTimeZone $timezone): string|false\nGet timezone ID',
'IntlTimeZone::getIDForWindowsID': '(string $timezoneId, ?string $region = null): string|false\nTranslate a Windows timezone into a system timezone',
'intltz_get_id_for_windows_id': '(string $timezoneId, ?string $region = null): string|false\nTranslate a Windows timezone into a system timezone',
'intltz_get_offset': '(IntlTimeZone $timezone, float $timestamp, bool $local, int &$rawOffset, int &$dstOffset): bool\nGet the time zone raw and GMT offset for the given moment in time',
'intltz_get_raw_offset': '(IntlTimeZone $timezone): int\nGet the raw GMT offset (before taking daylight savings time into account',
'IntlTimeZone::getRegion': '(string $timezoneId): string|false\nGet the region code associated with the given system time zone ID',
'intltz_get_region': '(string $timezoneId): string|false\nGet the region code associated with the given system time zone ID',
'IntlTimeZone::getTZDataVersion': '(): string|false\nGet the timezone data version currently used by ICU',
'intltz_get_tz_data_version': '(): string|false\nGet the timezone data version currently used by ICU',
'IntlTimeZone::getUnknown': '(): IntlTimeZone\nGet the "unknown" time zone',
'intltz_get_unknown': '(): IntlTimeZone\nGet the "unknown" time zone',
'IntlTimeZone::getWindowsID': '(string $timezoneId): string|false\nTranslate a system timezone into a Windows timezone',
'intltz_get_windows_id': '(string $timezoneId): string|false\nTranslate a system timezone into a Windows timezone',
'intltz_has_same_rules': '(IntlTimeZone $timezone, IntlTimeZone $other): bool\nCheck if this zone has the same rules and offset as another zone',
'intltz_to_date_time_zone': '(IntlTimeZone $timezone): DateTimeZone|false\nConvert to DateTimeZone object',
'intltz_use_daylight_time': '(IntlTimeZone $timezone): bool\nCheck if this time zone uses daylight savings time',
'Locale::acceptFromHttp': '(string $header): string|false\nTries to find out best available locale based on HTTP "Accept-Language" header',
'locale_accept_from_http': '(string $header): string|false\nTries to find out best available locale based on HTTP "Accept-Language" header',
'Locale::canonicalize': '(string $locale): ?string\nCanonicalize the locale string',
'Locale::composeLocale': '(array $subtags): string|false\nReturns a correctly ordered and delimited locale ID',
'locale_compose': '(array $subtags): string|false\nReturns a correctly ordered and delimited locale ID',
'Locale::filterMatches': '(string $languageTag, string $locale, bool $canonicalize = false): ?bool\nChecks if a language tag filter matches with locale',
'locale_filter_matches': '(string $languageTag, string $locale, bool $canonicalize = false): ?bool\nChecks if a language tag filter matches with locale',
'Locale::getAllVariants': '(string $locale): ?array\nGets the variants for the input locale',
'locale_get_all_variants': '(string $locale): ?array\nGets the variants for the input locale',
'Locale::getDefault': '(): string\nGets the default locale value from the INTL global \'default_locale\'',
'locale_get_default': '(): string\nGets the default locale value from the INTL global \'default_locale\'',
'Locale::getDisplayLanguage': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for language of the inputlocale',
'locale_get_display_language': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for language of the inputlocale',
'Locale::getDisplayName': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for the input locale',
'locale_get_display_name': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for the input locale',
'Locale::getDisplayRegion': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for region of the input locale',
'locale_get_display_region': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for region of the input locale',
'Locale::getDisplayScript': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for script of the input locale',
'locale_get_display_script': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for script of the input locale',
'Locale::getDisplayVariant': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for variants of the input locale',
'locale_get_display_variant': '(string $locale, ?string $displayLocale = null): string|false\nReturns an appropriately localized display name for variants of the input locale',
'Locale::getKeywords': '(string $locale): array|false|null\nGets the keywords for the input locale',
'locale_get_keywords': '(string $locale): array|false|null\nGets the keywords for the input locale',
'Locale::getPrimaryLanguage': '(string $locale): ?string\nGets the primary language for the input locale',
'locale_get_primary_language': '(string $locale): ?string\nGets the primary language for the input locale',
'Locale::getRegion': '(string $locale): ?string\nGets the region for the input locale',
'locale_get_region': '(string $locale): ?string\nGets the region for the input locale',
'Locale::getScript': '(string $locale): ?string\nGets the script for the input locale',
'locale_get_script': '(string $locale): ?string\nGets the script for the input locale',
'Locale::isRightToLeft': '(string $locale = ""): bool\nCheck whether a locale uses a right-to-left writing system',
'locale_is_right_to_left': '(string $locale = ""): bool\nCheck whether a locale uses a right-to-left writing system',
'Locale::lookup': '(array $languageTag, string $locale, bool $canonicalize = false, ?string $defaultLocale = null): ?string\nSearches the language tag list for the best match to the language',
'locale_lookup': '(array $languageTag, string $locale, bool $canonicalize = false, ?string $defaultLocale = null): ?string\nSearches the language tag list for the best match to the language',
'Locale::parseLocale': '(string $locale): ?array\nReturns a key-value array of locale ID subtag elements',
'locale_parse': '(string $locale): ?array\nReturns a key-value array of locale ID subtag elements',
'Locale::setDefault': '(string $locale): true\nSets the default runtime locale',
'locale_set_default': '(string $locale): true\nSets the default runtime locale',
'MessageFormatter::create': '(string $locale, string $pattern): ?MessageFormatter\nConstructs a new Message Formatter',
'msgfmt_create': '(string $locale, string $pattern): ?MessageFormatter\nConstructs a new Message Formatter',
'MessageFormatter::formatMessage': '(string $locale, string $pattern, array $values): string|false\nQuick format message',
'msgfmt_format_message': '(string $locale, string $pattern, array $values): string|false\nQuick format message',
'msgfmt_format': '(MessageFormatter $formatter, array $values): string|false\nFormat the message',
'msgfmt_get_error_code': '(MessageFormatter $formatter): int\nGet the error code from last operation',
'msgfmt_get_error_message': '(MessageFormatter $formatter): string\nGet the error text from the last operation',
'msgfmt_get_locale': '(MessageFormatter $formatter): string\nGet the locale for which the formatter was created',
'msgfmt_get_pattern': '(MessageFormatter $formatter): string|false\nGet the pattern used by the formatter',
'MessageFormatter::parseMessage': '(string $locale, string $pattern, string $message): array|false\nQuick parse input string',
'msgfmt_parse_message': '(string $locale, string $pattern, string $message): array|false\nQuick parse input string',
'msgfmt_parse': '(MessageFormatter $formatter, string $string): array|false\nParse input string according to pattern',
'msgfmt_set_pattern': '(MessageFormatter $formatter, string $pattern): bool\nSet the pattern used by the formatter',
'Normalizer::getRawDecomposition': '(string $string, int $form = Normalizer::FORM_C): ?string\nGets the Decomposition_Mapping property for the given UTF-8 encoded code point',
'normalizer_get_raw_decomposition': '(string $string, int $form = Normalizer::FORM_C): ?string\nGets the Decomposition_Mapping property for the given UTF-8 encoded code point',
'Normalizer::isNormalized': '(string $string, int $form = Normalizer::FORM_C): bool\nChecks if the provided string is already in the specified normalization form',
'normalizer_is_normalized': '(string $string, int $form = Normalizer::FORM_C): bool\nChecks if the provided string is already in the specified normalization form',
'Normalizer::normalize': '(string $string, int $form = Normalizer::FORM_C): string|false\nNormalizes the input provided and returns the normalized string',
'normalizer_normalize': '(string $string, int $form = Normalizer::FORM_C): string|false\nNormalizes the input provided and returns the normalized string',
'NumberFormatter::create': '(string $locale, int $style, ?string $pattern = null): ?NumberFormatter\nCreate a number formatter',
'numfmt_create': '(string $locale, int $style, ?string $pattern = null): ?NumberFormatter\nCreate a number formatter',
'numfmt_format_currency': '(NumberFormatter $formatter, float $amount, string $currency): string|false\nFormat a currency value',
'numfmt_format': '(NumberFormatter $formatter, int|float $num, int $type = NumberFormatter::TYPE_DEFAULT): string|false\nFormat a number',
'numfmt_get_attribute': '(NumberFormatter $formatter, int $attribute): int|float|false\nGet an attribute',
'numfmt_get_error_code': '(NumberFormatter $formatter): int\nGet formatter\'s last error code',
'numfmt_get_error_message': '(NumberFormatter $formatter): string\nGet formatter\'s last error message',
'numfmt_get_locale': '(NumberFormatter $formatter, int $type = ULOC_ACTUAL_LOCALE): string|false\nGet formatter locale',
'numfmt_get_pattern': '(NumberFormatter $formatter): string|false\nGet formatter pattern',
'numfmt_get_symbol': '(NumberFormatter $formatter, int $symbol): string|false\nGet a symbol value',
'numfmt_get_text_attribute': '(NumberFormatter $formatter, int $attribute): string|false\nGet a text attribute',
'numfmt_parse_currency': '(NumberFormatter $formatter, string $string, string &$currency, int &$offset = null): float|false\nParse a currency number',
'numfmt_parse': '(NumberFormatter $formatter, string $string, int $type = NumberFormatter::TYPE_DOUBLE, int &$offset = null): int|float|false\nParse a number',
'numfmt_set_attribute': '(NumberFormatter $formatter, int $attribute, int|float $value): bool\nSet an attribute',
'numfmt_set_pattern': '(NumberFormatter $formatter, string $pattern): bool\nSet formatter pattern',
'numfmt_set_symbol': '(NumberFormatter $formatter, int $symbol, string $value): bool\nSet a symbol value',
'numfmt_set_text_attribute': '(NumberFormatter $formatter, int $attribute, string $value): bool\nSet a text attribute',
'resourcebundle_count': '(ResourceBundle $bundle): int\nGet number of elements in the bundle',
'ResourceBundle::create': '(?string $locale, ?string $bundle, bool $fallback = true): ?ResourceBundle\nCreate a resource bundle',
'resourcebundle_create': '(?string $locale, ?string $bundle, bool $fallback = true): ?ResourceBundle\nCreate a resource bundle',
'resourcebundle_get_error_code': '(ResourceBundle $bundle): int\nGet bundle\'s last error code',
'resourcebundle_get_error_message': '(ResourceBundle $bundle): string\nGet bundle\'s last error message',
'resourcebundle_get': '(ResourceBundle $bundle, string|int $index, bool $fallback = true): ResourceBundle|array|string|int|null\nGet data from the bundle',
'ResourceBundle::getLocales': '(string $bundle): array|false\nGet supported locales',
'resourcebundle_locales': '(string $bundle): array|false\nGet supported locales',
'Transliterator::create': '(string $id, int $direction = Transliterator::FORWARD): ?Transliterator\nCreate a transliterator',
'transliterator_create': '(string $id, int $direction = Transliterator::FORWARD): ?Transliterator\nCreate a transliterator',
'Transliterator::createFromRules': '(string $rules, int $direction = Transliterator::FORWARD): ?Transliterator\nCreate transliterator from rules',
'transliterator_create_from_rules': '(string $rules, int $direction = Transliterator::FORWARD): ?Transliterator\nCreate transliterator from rules',
'transliterator_create_inverse': '(Transliterator $transliterator): ?Transliterator\nCreate an inverse transliterator',
'transliterator_get_error_code': '(Transliterator $transliterator): int\nGet last error code',
'transliterator_get_error_message': '(Transliterator $transliterator): string\nGet last error message',
'Transliterator::listIDs': '(): array|false\nGet transliterator IDs',
'transliterator_list_ids': '(): array|false\nGet transliterator IDs',
'transliterator_transliterate': '(Transliterator|string $transliterator, string $string, int $start = ?, int $end = -1): string|false\nTransliterate a string',
'UConverter::getAliases': '(string $name): array|false|null\nGet the aliases of the given name',
'UConverter::getAvailable': '(): array\nGet the available canonical converter names',
'UConverter::getStandards': '(): ?array\nGet standards associated to converter names',
'UConverter::reasonText': '(int $reason): string\nGet string representation of the callback reason',
'UConverter::transcode': '(string $str, string $toEncoding, string $fromEncoding, ?array $options = null): string|false\nConvert a string from one character encoding to another',
'litespeed_finish_request': '(): bool\nFlushes all response data to the client',
'litespeed_request_headers': 'Alias of apache_request_headers',
'litespeed_response_headers': 'Alias of apache_response_headers',
'mb_check_encoding': '(array|string|null $value = null, ?string $encoding = null): bool\nCheck if strings are valid for the specified encoding',
'mb_chr': '(int $codepoint, ?string $encoding = null): string|false\nReturn character by Unicode code point value',
'mb_convert_case': '(string $string, int $mode, ?string $encoding = null): string\nPerform case folding on a string',
'mb_convert_encoding': '(array|string $string, string $to_encoding, array|string|null $from_encoding = null): array|string|false\nConvert a string from one character encoding to another',
'mb_convert_kana': '(string $string, string $mode = "KV", ?string $encoding = null): string\nConvert "kana" one from another ("zen-kaku", "han-kaku" and more)',
'mb_convert_variables': '(string $to_encoding, array|string $from_encoding, mixed &$var, mixed &...$vars): string|false\nConvert character code in variable(s)',
'mb_decode_mimeheader': '(string $string): string\nDecode string in MIME header field',
'mb_decode_numericentity': '(string $string, array $map, ?string $encoding = null): string\nDecode HTML numeric string reference to character',
'mb_detect_encoding': '(string $string, array|string|null $encodings = null, bool $strict = false): string|false\nDetect character encoding',
'mb_detect_order': '(array|string|null $encoding = null): array|bool\nSet/Get character encoding detection order',
'mb_encode_mimeheader': '(string $string, ?string $charset = null, ?string $transfer_encoding = null, string $newline = "\\r\\n", int $indent = ?): string\nEncode string for MIME header',
'mb_encode_numericentity': '(string $string, array $map, ?string $encoding = null, bool $hex = false): string\nEncode character to HTML numeric string reference',
'mb_encoding_aliases': '(string $encoding): array\nGet aliases of a known encoding type',
'mb_ereg_match': '(string $pattern, string $string, ?string $options = null): bool\nRegular expression match for multibyte string',
'mb_ereg_replace_callback': '(string $pattern, callable $callback, string $string, ?string $options = null): string|false|null\nPerform a regular expression search and replace with multibyte support using a callback',
'mb_ereg_replace': '(string $pattern, string $replacement, string $string, ?string $options = null): string|false|null\nReplace regular expression with multibyte support',
'mb_ereg_search_getpos': '(): int\nReturns start point for next regular expression match',
'mb_ereg_search_getregs': '(): array|false\nRetrieve the result from the last multibyte regular expression match',
'mb_ereg_search_init': '(string $string, ?string $pattern = null, ?string $options = null): bool\nSetup string and regular expression for a multibyte regular expression match',
'mb_ereg_search_pos': '(?string $pattern = null, ?string $options = null): array|false\nReturns position and length of a matched part of the multibyte regular expression for a predefined multibyte string',
'mb_ereg_search_regs': '(?string $pattern = null, ?string $options = null): array|false\nReturns the matched part of a multibyte regular expression',
'mb_ereg_search_setpos': '(int $offset): bool\nSet start point of next regular expression match',
'mb_ereg_search': '(?string $pattern = null, ?string $options = null): bool\nMultibyte regular expression match for predefined multibyte string',
'mb_ereg': '(string $pattern, string $string, array &$matches = null): bool\nRegular expression match with multibyte support',
'mb_eregi_replace': '(string $pattern, string $replacement, string $string, ?string $options = null): string|false|null\nReplace regular expression with multibyte support ignoring case',
'mb_eregi': '(string $pattern, string $string, array &$matches = null): bool\nRegular expression match ignoring case with multibyte support',
'mb_get_info': '(string $type = "all"): array|string|int|false|null\nGet internal settings of mbstring',
'mb_http_input': '(?string $type = null): array|string|false\nDetect HTTP input character encoding',
'mb_http_output': '(?string $encoding = null): string|bool\nSet/Get HTTP output character encoding',
'mb_internal_encoding': '(?string $encoding = null): string|bool\nSet/Get internal character encoding',
'mb_language': '(?string $language = null): string|bool\nSet/Get current language',
'mb_lcfirst': '(string $string, ?string $encoding = null): string\nMake a string\'s first character lowercase',
'mb_list_encodings': '(): array\nReturns an array of all supported encodings',
'mb_ltrim': '(string $string, ?string $characters = null, ?string $encoding = null): string\nStrip whitespace (or other characters) from the beginning of a string',
'mb_ord': '(string $string, ?string $encoding = null): int|false\nGet Unicode code point of character',
'mb_output_handler': '(string $string, int $status): string\nCallback function converts character encoding in output buffer',
'mb_parse_str': '(string $string, array &$result): bool\nParse GET/POST/COOKIE data and set global variable',
'mb_preferred_mime_name': '(string $encoding): string|false\nGet MIME charset string',
'mb_regex_encoding': '(?string $encoding = null): string|bool\nSet/Get character encoding for multibyte regex',
'mb_regex_set_options': '(?string $options = null): string\nSet/Get the default options for mbregex functions',
'mb_rtrim': '(string $string, ?string $characters = null, ?string $encoding = null): string\nStrip whitespace (or other characters) from the end of a string',
'mb_scrub': '(string $string, ?string $encoding = null): string\nReplace ill-formed byte sequences with the substitute character',
'mb_send_mail': '(string $to, string $subject, string $message, array|string $additional_headers = [], ?string $additional_params = null): bool\nSend encoded mail',
'mb_split': '(string $pattern, string $string, int $limit = -1): array|false\nSplit multibyte string using regular expression',
'mb_str_pad': '(string $string, int $length, string $pad_string = " ", int $pad_type = STR_PAD_RIGHT, ?string $encoding = null): string\nPad a multibyte string to a certain length with another multibyte string',
'mb_str_split': '(string $string, int $length = 1, ?string $encoding = null): array\nGiven a multibyte string, return an array of its characters',
'mb_strcut': '(string $string, int $start, ?int $length = null, ?string $encoding = null): string\nGet part of string',
'mb_strimwidth': '(string $string, int $start, int $width, string $trim_marker = "", ?string $encoding = null): string\nGet truncated string with specified width',
'mb_stripos': '(string $haystack, string $needle, int $offset = ?, ?string $encoding = null): int|false\nFinds position of first occurrence of a string within another, case insensitive',
'mb_stristr': '(string $haystack, string $needle, bool $before_needle = false, ?string $encoding = null): string|false\nFinds first occurrence of a string within another, case insensitive',
'mb_strlen': '(string $string, ?string $encoding = null): int\nGet string length',
'mb_strpos': '(string $haystack, string $needle, int $offset = ?, ?string $encoding = null): int|false\nFind position of first occurrence of string in a string',
'mb_strrchr': '(string $haystack, string $needle, bool $before_needle = false, ?string $encoding = null): string|false\nFinds the last occurrence of a character in a string within another',
'mb_strrichr': '(string $haystack, string $needle, bool $before_needle = false, ?string $encoding = null): string|false\nFinds the last occurrence of a character in a string within another, case insensitive',
'mb_strripos': '(string $haystack, string $needle, int $offset = ?, ?string $encoding = null): int|false\nFinds position of last occurrence of a string within another, case insensitive',
'mb_strrpos': '(string $haystack, string $needle, int $offset = ?, ?string $encoding = null): int|false\nFind position of last occurrence of a string in a string',
'mb_strstr': '(string $haystack, string $needle, bool $before_needle = false, ?string $encoding = null): string|false\nFinds first occurrence of a string within another',
'mb_strtolower': '(string $string, ?string $encoding = null): string\nMake a string lowercase',
'mb_strtoupper': '(string $string, ?string $encoding = null): string\nMake a string uppercase',
'mb_strwidth': '(string $string, ?string $encoding = null): int\nReturn width of string',
'mb_substitute_character': '(string|int|null $substitute_character = null): string|int|bool\nSet/Get substitution character',
'mb_substr_count': '(string $haystack, string $needle, ?string $encoding = null): int\nCount the number of substring occurrences',
'mb_substr': '(string $string, int $start, ?int $length = null, ?string $encoding = null): string\nGet part of string',
'mb_trim': '(string $string, ?string $characters = null, ?string $encoding = null): string\nStrip whitespace (or other characters) from the beginning and end of a string',
'mb_ucfirst': '(string $string, ?string $encoding = null): string\nMake a string\'s first character uppercase',
'mhash_count': '(): int\nGets the highest available hash ID',
'mhash_get_block_size': '(int $algo): int|false\nGets the block size of the specified hash',
'mhash_get_hash_name': '(int $algo): string|false\nGets the name of the specified hash',
'mhash_keygen_s2k': '(int $algo, string $password, string $salt, int $length): string|false\nGenerates a key',
'mhash': '(int $algo, string $data, ?string $key = null): string|false\nComputes hash',
'pcntl_alarm': '(int $seconds): int\nSet an alarm clock for delivery of a signal',
'pcntl_async_signals': '(?bool $enable = null): bool\nEnable/disable asynchronous signal handling or return the old setting',
'pcntl_errno': 'Alias of pcntl_get_last_error',
'pcntl_exec': '(string $path, array $args = [], array $env_vars = []): false\nExecutes specified program in current process space',
'pcntl_fork': '(): int\nForks the currently running process',
'pcntl_forkx': '(int $flags): int\nCreate a child process using forkx(2)',
'pcntl_get_last_error': '(): int\nRetrieve the error number set by the last pcntl function which failed',
'pcntl_getcpu': '(): int\nGet the CPU number on which the calling process last executed',
'pcntl_getcpuaffinity': '(?int $process_id = null): array|false\nGet the cpu affinity of a process',
'pcntl_getpriority': '(?int $process_id = null, int $mode = PRIO_PROCESS): int|false\nGet the priority of any process',
'pcntl_getqos_class': '(): Pcntl\\QosClass\nGet the QoS class of the current thread',
'pcntl_rfork': '(int $flags, int $signal = ?): int\nManipulates process resources',
'pcntl_setcpuaffinity': '(?int $process_id = null, array $cpu_ids = []): bool\nSet the cpu affinity of a process',
'pcntl_setns': '(?int $process_id = null, int $nstype = CLONE_NEWNET): bool\nReassociate the calling process with a namespace of another process',
'pcntl_setpriority': '(int $priority, ?int $process_id = null, int $mode = PRIO_PROCESS): bool\nChange the priority of any process',
'pcntl_setqos_class': '(Pcntl\\QosClass $qos_class = Pcntl\\QosClass::Default): void\nSet the QoS class of the current thread',
'pcntl_signal_dispatch': '(): bool\nCalls signal handlers for pending signals',
'pcntl_signal_get_handler': '(int $signal): callable|int\nGet the current handler for specified signal',
'pcntl_signal': '(int $signal, callable|int $handler, bool $restart_syscalls = true): bool\nInstalls a signal handler',
'pcntl_sigprocmask': '(int $mode, array $signals, array &$old_signals = null): bool\nSets and retrieves blocked signals',
'pcntl_sigtimedwait': '(array $signals, array &$info = [], int $seconds = ?, int $nanoseconds = ?): int|false\nWaits for signals, with a timeout',
'pcntl_sigwaitinfo': '(array $signals, array &$info = []): int|false\nWaits for signals',
'pcntl_strerror': '(int $error_code): string\nRetrieve the system error message associated with the given errno',
'pcntl_unshare': '(int $flags): bool\nDissociates parts of the process execution context',
'pcntl_wait': '(int &$status, int $flags = ?, array &$resource_usage = []): int\nWaits on or returns the status of a forked child',
'pcntl_waitid': '(int $idtype = P_ALL, ?int $id = null, array &$info = [], int $flags = WEXITED, array &$resource_usage = []): bool\nWaits for a child process to change state',
'pcntl_waitpid': '(int $process_id, int &$status, int $flags = ?, array &$resource_usage = []): int\nWaits on or returns the status of a forked child',
'pcntl_wexitstatus': '(int $status): int|false\nReturns the return code of a terminated child',
'pcntl_wifcontinued': '(int $status): bool\nChecks whether the child process has continued from a job control stop',
'pcntl_wifexited': '(int $status): bool\nChecks if status code represents a normal exit',
'pcntl_wifsignaled': '(int $status): bool\nChecks whether the status code represents a termination due to a signal',
'pcntl_wifstopped': '(int $status): bool\nChecks whether the child process is currently stopped',
'pcntl_wstopsig': '(int $status): int|false\nReturns the signal which caused the child to stop',
'pcntl_wtermsig': '(int $status): int|false\nReturns the signal which caused the child to terminate',
'PDO::connect': '(string $dsn, ?string $username = null, ?string $password = null, ?array $options = null): static\nConnect to a database and return a PDO subclass for drivers that support it',
'PDO::getAvailableDrivers': '(): array\nReturn an array of available PDO drivers',
'pdo_drivers': '(): array\nReturn an array of available PDO drivers',
'Phar::apiVersion': '(): string\nReturns the api version',
'Phar::canCompress': '(int $compression = ?): bool\nReturns whether phar extension supports compression using either zlib or bzip2',
'Phar::canWrite': '(): bool\nReturns whether phar extension supports writing and creating phars',
'Phar::createDefaultStub': '(?string $index = null, ?string $webIndex = null): string\nCreate a phar-file format specific stub',
'Phar::getSupportedCompression': '(): array\nReturn array of supported compression algorithms',
'Phar::getSupportedSignatures': '(): array\nReturn array of supported signature types',
'Phar::interceptFileFuncs': '(): void\nInstructs phar to intercept fopen, file_get_contents, opendir, and all of the stat-related functions',
'Phar::isValidPharFilename': '(string $filename, bool $executable = true): bool\nReturns whether the given filename is a valid phar filename',
'Phar::loadPhar': '(string $filename, ?string $alias = null): bool\nLoads any phar archive with an alias',
'Phar::mapPhar': '(?string $alias = null, int $offset = ?): bool\nReads the currently executed file (a phar) and registers its manifest',
'Phar::mount': '(string $pharPath, string $externalPath): void\nMount an external path or file to a virtual location within the phar archive',
'Phar::mungServer': '(array $variables): void\nDefines a list of up to 4 $_SERVER variables that should be modified for execution',
'Phar::running': '(bool $returnPhar = true): string\nReturns the full path on disk or full phar URL to the currently executing Phar archive',
'Phar::unlinkArchive': '(string $filename): true\nCompletely remove a phar archive from disk and from memory',
'Phar::webPhar': '(?string $alias = null, ?string $index = null, ?string $fileNotFoundScript = null, array $mimeTypes = [], ?callable $rewrite = null): void\nRoutes a request from a web browser to an internal file within the phar archive',
'phpdbg_break_file': '(string $file, int $line): void\nInserts a breakpoint at a line in a file',
'phpdbg_break_function': '(string $function): void\nInserts a breakpoint at entry to a function',
'phpdbg_break_method': '(string $class, string $method): void\nInserts a breakpoint at entry to a method',
'phpdbg_break_next': '(): void\nInserts a breakpoint at the next opcode',
'phpdbg_clear': '(): void\nClears all breakpoints',
'phpdbg_color': '(int $element, string $color): void\nSets the color of certain elements',
'phpdbg_end_oplog': '(array $options = []): ?array\nEnds an oplog',
'phpdbg_exec': '(string $context): string|bool\nAttempts to set the execution context',
'phpdbg_get_executable': '(array $options = []): array\nGets executable',
'phpdbg_prompt': '(string $string): void\nSets the command prompt',
'phpdbg_start_oplog': '(): void\nStarts an oplog',
'posix_access': '(string $filename, int $flags = ?): bool\nDetermine accessibility of a file',
'posix_ctermid': '(): string|false\nGet path name of controlling terminal',
'posix_eaccess': '(string $filename, int $flags = ?): bool\nDetermine accessibility of a file',
'posix_errno': 'Alias of posix_get_last_error',
'posix_fpathconf': '(resource|int $file_descriptor, int $name): int|false\nReturns the value of a configurable limit',
'posix_get_last_error': '(): int\nRetrieve the error number set by the last posix function that failed',
'posix_getcwd': '(): string|false\nPathname of current directory',
'posix_getegid': '(): int\nReturn the effective group ID of the current process',
'posix_geteuid': '(): int\nReturn the effective user ID of the current process',
'posix_getgid': '(): int\nReturn the real group ID of the current process',
'posix_getgrgid': '(int $group_id): array|false\nReturn info about a group by group id',
'posix_getgrnam': '(string $name): array|false\nReturn info about a group by name',
'posix_getgroups': '(): array|false\nReturn the group set of the current process',
'posix_getlogin': '(): string|false\nReturn login name',
'posix_getpgid': '(int $process_id): int|false\nGet process group id for job control',
'posix_getpgrp': '(): int\nReturn the current process group identifier',
'posix_getpid': '(): int\nReturn the current process identifier',
'posix_getppid': '(): int\nReturn the parent process identifier',
'posix_getpwnam': '(string $username): array|false\nReturn info about a user by username',
'posix_getpwuid': '(int $user_id): array|false\nReturn info about a user by user id',
'posix_getrlimit': '(?int $resource = null): array|false\nReturn info about system resource limits',
'posix_getsid': '(int $process_id): int|false\nGet the current sid of the process',
'posix_getuid': '(): int\nReturn the real user ID of the current process',
'posix_initgroups': '(string $username, int $group_id): bool\nCalculate the group access list',
'posix_isatty': '(resource|int $file_descriptor): bool\nDetermine if a file descriptor is an interactive terminal',
'posix_kill': '(int $process_id, int $signal): bool\nSend a signal to a process',
'posix_mkfifo': '(string $filename, int $permissions): bool\nCreate a fifo special file (a named pipe)',
'posix_mknod': '(string $filename, int $flags, int $major = ?, int $minor = ?): bool\nCreate a special or ordinary file (POSIX.1)',
'posix_pathconf': '(string $path, int $name): int|false\nReturns the value of a configurable limit',
'posix_setegid': '(int $group_id): bool\nSet the effective GID of the current process',
'posix_seteuid': '(int $user_id): bool\nSet the effective UID of the current process',
'posix_setgid': '(int $group_id): bool\nSet the GID of the current process',
'posix_setpgid': '(int $process_id, int $process_group_id): bool\nSet process group id for job control',
'posix_setrlimit': '(int $resource, int $soft_limit, int $hard_limit): bool\nSet system resource limits',
'posix_setsid': '(): int\nMake the current process a session leader',
'posix_setuid': '(int $user_id): bool\nSet the UID of the current process',
'posix_strerror': '(int $error_code): string\nRetrieve the system error message associated with the given errno',
'posix_sysconf': '(int $conf_id): int\nReturns system runtime information',
'posix_times': '(): array|false\nGet process times',
'posix_ttyname': '(resource|int $file_descriptor): string|false\nDetermine terminal device name',
'posix_uname': '(): array|false\nGet system name',
'ftok': '(string $filename, string $project_id): int\nConvert a pathname and a project identifier to a System V IPC key',
'msg_get_queue': '(int $key, int $permissions = 0666): SysvMessageQueue|false\nCreate or attach to a message queue',
'msg_queue_exists': '(int $key): bool\nCheck whether a message queue exists',
'msg_receive': '(SysvMessageQueue $queue, int $desired_message_type, int &$received_message_type, int $max_message_size, mixed &$message, bool $unserialize = true, int $flags = ?, int &$error_code = null): bool\nReceive a message from a message queue',
'msg_remove_queue': '(SysvMessageQueue $queue): bool\nDestroy a message queue',
'msg_send': '(SysvMessageQueue $queue, int $message_type, string|int|float|bool $message, bool $serialize = true, bool $blocking = true, int &$error_code = null): bool\nSend a message to a message queue',
'msg_set_queue': '(SysvMessageQueue $queue, array $data): bool\nSet information in the message queue data structure',
'msg_stat_queue': '(SysvMessageQueue $queue): array|false\nReturns information from the message queue data structure',
'sem_acquire': '(SysvSemaphore $semaphore, bool $non_blocking = false): bool\nAcquire a semaphore',
'sem_get': '(int $key, int $max_acquire = 1, int $permissions = 0666, bool $auto_release = true): SysvSemaphore|false\nGet a semaphore id',
'sem_release': '(SysvSemaphore $semaphore): bool\nRelease a semaphore',
'sem_remove': '(SysvSemaphore $semaphore): bool\nRemove a semaphore',
'shm_attach': '(int $key, ?int $size = null, int $permissions = 0666): SysvSharedMemory|false\nCreates or open a shared memory segment',
'shm_detach': '(SysvSharedMemory $shm): true\nDisconnects from shared memory segment',
'shm_get_var': '(SysvSharedMemory $shm, int $key): mixed\nReturns a variable from shared memory',
'shm_has_var': '(SysvSharedMemory $shm, int $key): bool\nCheck whether a specific entry exists',
'shm_put_var': '(SysvSharedMemory $shm, int $key, mixed $value): bool\nInserts or updates a variable in shared memory',
'shm_remove_var': '(SysvSharedMemory $shm, int $key): bool\nRemoves a variable from shared memory',
'shm_remove': '(SysvSharedMemory $shm): bool\nRemoves shared memory from Unix systems',
'session_abort': '(): bool\nDiscard session array changes and finish session',
'session_cache_expire': '(?int $value = null): int|false\nGet and/or set current cache expire',
'session_cache_limiter': '(?string $value = null): string|false\nGet and/or set the current cache limiter',
'session_commit': 'Alias of session_write_close',
'session_create_id': '(string $prefix = ""): string|false\nCreate new session id',
'session_decode': '(string $data): bool\nDecodes session data from a session encoded string',
'session_destroy': '(): bool\nDestroys all data registered to a session',
'session_encode': '(): string|false\nEncodes the current session data as a session encoded string',
'session_gc': '(): int|false\nPerform session data garbage collection',
'session_get_cookie_params': '(): array\nGet the session cookie parameters',
'session_id': '(?string $id = null): string|false\nGet and/or set the current session id',
'session_module_name': '(?string $module = null): string|false\nGet and/or set the current session module',
'session_name': '(?string $name = null): string|false\nGet and/or set the current session name',
'session_regenerate_id': '(bool $delete_old_session = false): bool\nUpdate the current session id with a newly generated one',
'session_register_shutdown': '(): void\nSession shutdown function',
'session_reset': '(): bool\nRe-initialize session array with original values',
'session_save_path': '(?string $path = null): string|false\nGet and/or set the current session save path',
'session_set_cookie_params': '(array $lifetime_or_options): bool\nSet the session cookie parameters',
'session_set_save_handler': '(object $sessionhandler, bool $register_shutdown = true): bool\nSets user-level session storage functions',
'session_start': '(array $options = []): bool\nStart new or resume existing session',
'session_status': '(): int\nReturns the current session status',
'session_unset': '(): bool\nFree all session variables',
'session_write_close': '(): bool\nWrite session data and end session',
'shmop_close': '(Shmop $shmop): void\nClose shared memory block',
'shmop_delete': '(Shmop $shmop): bool\nDelete shared memory block',
'shmop_open': '(int $key, string $mode, int $permissions, int $size): Shmop|false\nCreate or open shared memory block',
'shmop_read': '(Shmop $shmop, int $offset, int $size): string\nRead data from shared memory block',
'shmop_size': '(Shmop $shmop): int\nGet size of shared memory block',
'shmop_write': '(Shmop $shmop, string $data, int $offset): int\nWrite data into shared memory block',
'socket_accept': '(Socket $socket): Socket|false\nAccepts a connection on a socket',
'socket_addrinfo_bind': '(AddressInfo $address): Socket|false\nCreate and bind to a socket from a given addrinfo',
'socket_addrinfo_connect': '(AddressInfo $address): Socket|false\nCreate and connect to a socket from a given addrinfo',
'socket_addrinfo_explain': '(AddressInfo $address): array\nGet information about addrinfo',
'socket_addrinfo_lookup': '(string $host, ?string $service = null, array $hints = []): array|false\nGet array with contents of getaddrinfo about the given hostname',
'socket_atmark': '(Socket $socket): bool\nDetermines whether socket is at out-of-band mark',
'socket_bind': '(Socket $socket, string $address, int $port = ?): bool\nBinds a name to a socket',
'socket_clear_error': '(?Socket $socket = null): void\nClears the error on the socket or the last error code',
'socket_close': '(Socket $socket): void\nCloses a Socket instance',
'socket_cmsg_space': '(int $level, int $type, int $num = ?): ?int\nCalculate message buffer size',
'socket_connect': '(Socket $socket, string $address, ?int $port = null): bool\nInitiates a connection on a socket',
'socket_create_listen': '(int $port, int $backlog = SOMAXCONN): Socket|false\nOpens a socket on port to accept connections',
'socket_create_pair': '(int $domain, int $type, int $protocol, array &$pair): bool\nCreates a pair of indistinguishable sockets and stores them in an array',
'socket_create': '(int $domain, int $type, int $protocol): Socket|false\nCreate a socket (endpoint for communication)',
'socket_export_stream': '(Socket $socket): resource|false\nExport a socket into a stream that encapsulates a socket',
'socket_get_option': '(Socket $socket, int $level, int $option): array|int|false\nGets socket options for the socket',
'socket_getopt': 'Alias of socket_get_option',
'socket_getpeername': '(Socket $socket, string &$address, int &$port = null): bool\nQueries the remote side of the given socket',
'socket_getsockname': '(Socket $socket, string &$address, int &$port = null): bool\nQueries the local side of the given socket which may either result in host/port or in a Unix filesystem path, dependent on its type',
'socket_import_stream': '(resource $stream): Socket|false\nImport a stream',
'socket_last_error': '(?Socket $socket = null): int\nReturns the last error on the socket',
'socket_listen': '(Socket $socket, int $backlog = ?): bool\nListens for a connection on a socket',
'socket_read': '(Socket $socket, int $length, int $mode = PHP_BINARY_READ): string|false\nReads a maximum of length bytes from a socket',
'socket_recv': '(Socket $socket, ?string &$data, int $length, int $flags): int|false\nReceives data from a connected socket',
'socket_recvfrom': '(Socket $socket, string &$data, int $length, int $flags, string &$address, int &$port = null): int|false\nReceives data from a socket whether or not it is connection-oriented',
'socket_recvmsg': '(Socket $socket, array &$message, int $flags = ?): int|false\nRead a message',
'socket_select': '(?array &$read, ?array &$write, ?array &$except, ?int $seconds, int $microseconds = ?): int|false\nRuns the select() system call on the given arrays of sockets with a specified timeout',
'socket_send': '(Socket $socket, string $data, int $length, int $flags): int|false\nSends data to a connected socket',
'socket_sendmsg': '(Socket $socket, array $message, int $flags = ?): int|false\nSend a message',
'socket_sendto': '(Socket $socket, string $data, int $length, int $flags, string $address, ?int $port = null): int|false\nSends a message to a socket, whether it is connected or not',
'socket_set_block': '(Socket $socket): bool\nSets blocking mode on a socket',
'socket_set_nonblock': '(Socket $socket): bool\nSets nonblocking mode for file descriptor fd',
'socket_set_option': '(Socket $socket, int $level, int $option, array|string|int $value): bool\nSets socket options for the socket',
'socket_setopt': 'Alias of socket_set_option',
'socket_shutdown': '(Socket $socket, int $mode = 2): bool\nShuts down a socket for receiving, sending, or both',
'socket_strerror': '(int $error_code): string\nReturn a string describing a socket error',
'socket_write': '(Socket $socket, string $data, ?int $length = null): int|false\nWrite to a socket',
'socket_wsaprotocol_info_export': '(Socket $socket, int $process_id): string|false\nExports the WSAPROTOCOL_INFO Structure',
'socket_wsaprotocol_info_import': '(string $info_id): Socket|false\nImports a Socket from another Process',
'socket_wsaprotocol_info_release': '(string $info_id): bool\nReleases an exported WSAPROTOCOL_INFO Structure',
'SQLite3::escapeString': '(string $string): string\nReturns a string that has been properly escaped',
'SQLite3::version': '(): array\nReturns the SQLite3 library version as a string constant and as a number',
'token_get_all': '(string $code, int $flags = ?): array\nSplit given source into PHP tokens',
'token_name': '(int $id): string\nGet the symbolic name of a given PHP token',
'PhpToken::tokenize': '(string $code, int $flags = ?): array\nSplits given source into PHP tokens, represented by PhpToken objects.',
'deflate_add': '(DeflateContext $context, string $data, int $flush_mode = ZLIB_SYNC_FLUSH): string|false\nIncrementally deflate data',
'deflate_init': '(int $encoding, array|object $options = []): DeflateContext|false\nInitialize an incremental deflate context',
'gzclose': '(resource $stream): bool\nClose an open gz-file pointer',
'gzcompress': '(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_DEFLATE): string|false\nCompress a string',
'gzdecode': '(string $data, int $max_length = ?): string|false\nDecodes a gzip compressed string',
'gzdeflate': '(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_RAW): string|false\nDeflate a string',
'gzencode': '(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_GZIP): string|false\nCreate a gzip compressed string',
'gzeof': '(resource $stream): bool\nTest for EOF on a gz-file pointer',
'gzfile': '(string $filename, bool $use_include_path = false): array|false\nRead entire gz-file into an array',
'gzgetc': '(resource $stream): string|false\nGet character from gz-file pointer',
'gzgets': '(resource $stream, ?int $length = null): string|false\nGet line from file pointer',
'gzgetss': '(resource $zp, int $length, string $allowable_tags = ?): string\nGet line from gz-file pointer and strip HTML tags',
'gzinflate': '(string $data, int $max_length = ?): string|false\nInflate a deflated string',
'gzopen': '(string $filename, string $mode, bool $use_include_path = false): resource|false\nOpen gz-file',
'gzpassthru': '(resource $stream): int\nOutput all remaining data on a gz-file pointer',
'gzputs': 'Alias of gzwrite',
'gzread': '(resource $stream, int $length): string|false\nBinary-safe gz-file read',
'gzrewind': '(resource $stream): bool\nRewind the position of a gz-file pointer',
'gzseek': '(resource $stream, int $offset, int $whence = SEEK_SET): int\nSeek on a gz-file pointer',
'gztell': '(resource $stream): int|false\nTell gz-file pointer read/write position',
'gzuncompress': '(string $data, int $max_length = ?): string|false\nUncompress a compressed string',
'gzwrite': '(resource $stream, string $data, ?int $length = null): int|false\nBinary-safe gz-file write',
'inflate_get_read_len': '(InflateContext $context): int\nGet number of bytes read so far',
'inflate_get_status': '(InflateContext $context): int\nGet decompression status',
'inflate_add': '(InflateContext $context, string $data, int $flush_mode = ZLIB_SYNC_FLUSH): string|false\nIncrementally inflate encoded data',
'inflate_init': '(int $encoding, array|object $options = []): InflateContext|false\nInitialize an incremental inflate context',
'ob_gzhandler': '(string $data, int $flags): string|false\nob_start callback function to gzip output buffer',
'readgzfile': '(string $filename, bool $use_include_path = false): int|false\nOutput a gz-file',
'zlib_decode': '(string $data, int $max_length = ?): string|false\nUncompress any raw/gzip/zlib encoded data',
'zlib_encode': '(string $data, int $encoding, int $level = -1): string|false\nCompress data with the specified encoding',
'zlib_get_coding_type': '(): string|false\nReturns the coding type used for output compression',
'bzclose': '(resource $bz): bool\nClose a bzip2 file',
'bzcompress': '(string $data, int $block_size = 4, int $work_factor = ?): string|int\nCompress a string into bzip2 encoded data',
'bzdecompress': '(string $data, bool $use_less_memory = false): string|int|false\nDecompresses bzip2 encoded data',
'bzerrno': '(resource $bz): int\nReturns a bzip2 error number',
'bzerror': '(resource $bz): array\nReturns the bzip2 error number and error string in an array',
'bzerrstr': '(resource $bz): string\nReturns a bzip2 error string',
'bzflush': '(resource $bz): bool\nDo nothing',
'bzopen': '(string|resource $file, string $mode): resource|false\nOpens a bzip2 compressed file',
'bzread': '(resource $bz, int $length = 1024): string|false\nBinary safe bzip2 file read',
'bzwrite': '(resource $bz, string $data, ?int $length = null): int|false\nBinary safe bzip2 file write',
'curl_file_create': '(string $filename, ?string $mime_type = null, ?string $posted_filename = null): CURLFile\nCreate a CURLFile object',
'curl_close': '(CurlHandle $handle): void\nClose a cURL session',
'curl_copy_handle': '(CurlHandle $handle): CurlHandle|false\nCopy a cURL handle along with all of its preferences',
'curl_errno': '(CurlHandle $handle): int\nReturn the last error number',
'curl_error': '(CurlHandle $handle): string\nReturn a string containing the last error for the current session',
'curl_escape': '(CurlHandle $handle, string $string): string|false\nURL encodes the given string',
'curl_exec': '(CurlHandle $handle): string|bool\nPerform a cURL session',
'curl_getinfo': '(CurlHandle $handle, ?int $option = null): mixed\nGet information regarding a specific transfer',
'curl_init': '(?string $url = null): CurlHandle|false\nInitialize a cURL session',
'curl_multi_add_handle': '(CurlMultiHandle $multi_handle, CurlHandle $handle): int\nAdd a normal cURL handle to a cURL multi handle',
'curl_multi_close': '(CurlMultiHandle $multi_handle): void\nRemove all cURL handles from a multi handle',
'curl_multi_errno': '(CurlMultiHandle $multi_handle): int\nReturn the last multi curl error number',
'curl_multi_exec': '(CurlMultiHandle $multi_handle, int &$still_running): int\nRun the sub-connections of the current cURL handle',
'curl_multi_getcontent': '(CurlHandle $handle): ?string\nReturn the content of a cURL handle if CURLOPT_RETURNTRANSFER is set',
'curl_multi_info_read': '(CurlMultiHandle $multi_handle, int &$queued_messages = null): array|false\nGet information about the current transfers',
'curl_multi_init': '(): CurlMultiHandle\nReturns a new cURL multi handle',
'curl_multi_remove_handle': '(CurlMultiHandle $multi_handle, CurlHandle $handle): int\nRemove a handle from a set of cURL handles',
'curl_multi_select': '(CurlMultiHandle $multi_handle, float $timeout = 1.0): int\nWait until reading or writing is possible for any cURL multi handle connection',
'curl_multi_setopt': '(CurlMultiHandle $multi_handle, int $option, mixed $value): bool\nSet a cURL multi option',
'curl_multi_strerror': '(int $error_code): ?string\nReturn string describing error code',
'curl_pause': '(CurlHandle $handle, int $flags): int\nPause and unpause a connection',
'curl_reset': '(CurlHandle $handle): void\nReset all options of a libcurl session handle',
'curl_setopt_array': '(CurlHandle $handle, array $options): bool\nSet multiple options for a cURL transfer',
'curl_setopt': '(CurlHandle $handle, int $option, mixed $value): bool\nSet an option for a cURL transfer',
'curl_share_close': '(CurlShareHandle $share_handle): void\nClose a cURL share handle',
'curl_share_errno': '(CurlShareHandle $share_handle): int\nReturn the last share curl error number',
'curl_share_init_persistent': '(array $share_options): CurlSharePersistentHandle\nInitialize a persistent cURL share handle',
'curl_share_init': '(): CurlShareHandle\nInitialize a cURL share handle',
'curl_share_setopt': '(CurlShareHandle $share_handle, int $option, mixed $value): bool\nSet an option for a cURL share handle',
'curl_share_strerror': '(int $error_code): ?string\nReturn string describing the given error code',
'curl_strerror': '(int $error_code): ?string\nReturn string describing the given error code',
'curl_unescape': '(CurlHandle $handle, string $string): string|false\nDecodes the given URL encoded string',
'curl_upkeep': '(CurlHandle $handle): bool\nPerforms any connection upkeep checks',
'curl_version': '(): array|false\nGets cURL version information',
'Dom\\HTMLDocument::createEmpty': '(string $encoding = "UTF-8"): Dom\\HTMLDocument\nCreates an empty HTML document',
'Dom\\HTMLDocument::createFromFile': '(string $path, int $options = ?, ?string $overrideEncoding = null): Dom\\HTMLDocument\nParses an HTML document from a file',
'Dom\\HTMLDocument::createFromString': '(string $source, int $options = ?, ?string $overrideEncoding = null): Dom\\HTMLDocument\nParses an HTML document from a string',
'DOMXPath::quote': '(string $str): string\nQuotes a string for use in an XPath expression',
'dom_import_simplexml': '(object $node): DOMAttr|DOMElement\nGets a DOMAttr or DOMElement object from a SimpleXMLElement object',
'Dom\\import_simplexml': '(object $node): Dom\\Attr|Dom\\Element\nGets a Dom\\Attr or Dom\\Element object from a SimpleXMLElement object',
'enchant_broker_describe': '(EnchantBroker $broker): array\nEnumerates the Enchant providers',
'enchant_broker_dict_exists': '(EnchantBroker $broker, string $tag): bool\nWhether a dictionary exists or not',
'enchant_broker_free_dict': '(EnchantDictionary $dictionary): bool\nFree a dictionary resource',
'enchant_broker_free': '(EnchantBroker $broker): bool\nFree the broker resource and its dictionaries',
'enchant_broker_get_dict_path': '(EnchantBroker $broker, int $type): string|false\nGet the directory path for a given backend',
'enchant_broker_get_error': '(EnchantBroker $broker): string|false\nReturns the last error of the broker',
'enchant_broker_init': '(): EnchantBroker|false\nCreate a new broker object',
'enchant_broker_list_dicts': '(EnchantBroker $broker): array\nReturns a list of available dictionaries',
'enchant_broker_request_dict': '(EnchantBroker $broker, string $tag): EnchantDictionary|false\nCreate a new dictionary using a tag',
'enchant_broker_request_pwl_dict': '(EnchantBroker $broker, string $filename): EnchantDictionary|false\nCreates a dictionary using a PWL file',
'enchant_broker_set_dict_path': '(EnchantBroker $broker, int $type, string $path): bool\nSet the directory path for a given backend',
'enchant_broker_set_ordering': '(EnchantBroker $broker, string $tag, string $ordering): bool\nDeclares a preference of dictionaries to use for the language',
'enchant_dict_add_to_personal': 'Alias of enchant_dict_add',
'enchant_dict_add_to_session': '(EnchantDictionary $dictionary, string $word): void\nAdd \'word\' to this spell-checking session',
'enchant_dict_add': '(EnchantDictionary $dictionary, string $word): void\nAdd a word to personal word list',
'enchant_dict_check': '(EnchantDictionary $dictionary, string $word): bool\nCheck whether a word is correctly spelled or not',
'enchant_dict_describe': '(EnchantDictionary $dictionary): array\nDescribes an individual dictionary',
'enchant_dict_get_error': '(EnchantDictionary $dictionary): string|false\nReturns the last error of the current spelling-session',
'enchant_dict_is_added': '(EnchantDictionary $dictionary, string $word): bool\nWhether or not \'word\' exists in this spelling-session',
'enchant_dict_is_in_session': 'Alias of enchant_dict_is_added',
'enchant_dict_quick_check': '(EnchantDictionary $dictionary, string $word, array &$suggestions = null): bool\nCheck the word is correctly spelled and provide suggestions',
'enchant_dict_store_replacement': '(EnchantDictionary $dictionary, string $misspelled, string $correct): void\nAdd a correction for a word',
'enchant_dict_suggest': '(EnchantDictionary $dictionary, string $word): array\nSuggest spellings for a word',
'_': 'Alias of gettext',
'bind_textdomain_codeset': '(string $domain, ?string $codeset = null): string|false\nSpecify or get the character encoding in which the messages from the DOMAIN message catalog will be returned',
'bindtextdomain': '(string $domain, ?string $directory = null): string|false\nSets or gets the path for a domain',
'dcgettext': '(string $domain, string $message, int $category): string\nOverrides the domain for a single lookup',
'dcngettext': '(string $domain, string $singular, string $plural, int $count, int $category): string\nPlural version of dcgettext',
'dgettext': '(string $domain, string $message): string\nOverride the current domain',
'dngettext': '(string $domain, string $singular, string $plural, int $count): string\nPlural version of dgettext',
'gettext': '(string $message): string\nLookup a message in the current domain',
'ngettext': '(string $singular, string $plural, int $count): string\nPlural version of gettext',
'textdomain': '(?string $domain = null): string\nSets the default domain',
'gmp_abs': '(GMP|int|string $num): GMP\nAbsolute value',
'gmp_add': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nAdd numbers',
'gmp_and': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nBitwise AND',
'gmp_binomial': '(GMP|int|string $n, int $k): GMP\nCalculates binomial coefficient',
'gmp_clrbit': '(GMP $num, int $index): void\nClear bit',
'gmp_cmp': '(GMP|int|string $num1, GMP|int|string $num2): int\nCompare numbers',
'gmp_com': '(GMP|int|string $num): GMP\nCalculates one\'s complement',
'gmp_div_q': '(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): GMP\nDivide numbers',
'gmp_div_qr': '(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): array\nDivide numbers and get quotient and remainder',
'gmp_div_r': '(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): GMP\nRemainder of the division of numbers',
'gmp_div': 'Alias of gmp_div_q',
'gmp_divexact': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nExact division of numbers',
'gmp_export': '(GMP|int|string $num, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): string\nExport to a binary string',
'gmp_fact': '(GMP|int|string $num): GMP\nFactorial',
'gmp_gcd': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nCalculate GCD',
'gmp_gcdext': '(GMP|int|string $num1, GMP|int|string $num2): array\nCalculate GCD and multipliers',
'gmp_hamdist': '(GMP|int|string $num1, GMP|int|string $num2): int\nHamming distance',
'gmp_import': '(string $data, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): GMP\nImport from a binary string',
'gmp_init': '(int|string $num, int $base = ?): GMP\nCreate GMP number',
'gmp_intval': '(GMP|int|string $num): int\nConvert GMP number to integer',
'gmp_invert': '(GMP|int|string $num1, GMP|int|string $num2): GMP|false\nInverse by modulo',
'gmp_jacobi': '(GMP|int|string $num1, GMP|int|string $num2): int\nJacobi symbol',
'gmp_kronecker': '(GMP|int|string $num1, GMP|int|string $num2): int\nKronecker symbol',
'gmp_lcm': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nCalculate LCM',
'gmp_legendre': '(GMP|int|string $num1, GMP|int|string $num2): int\nLegendre symbol',
'gmp_mod': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nModulo operation',
'gmp_mul': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nMultiply numbers',
'gmp_neg': '(GMP|int|string $num): GMP\nNegate number',
'gmp_nextprime': '(GMP|int|string $num): GMP\nFind next prime number',
'gmp_or': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nBitwise OR',
'gmp_perfect_power': '(GMP|int|string $num): bool\nPerfect power check',
'gmp_perfect_square': '(GMP|int|string $num): bool\nPerfect square check',
'gmp_popcount': '(GMP|int|string $num): int\nPopulation count',
'gmp_pow': '(GMP|int|string $num, int $exponent): GMP\nRaise number into power',
'gmp_powm': '(GMP|int|string $num, GMP|int|string $exponent, GMP|int|string $modulus): GMP\nRaise number into power with modulo',
'gmp_prob_prime': '(GMP|int|string $num, int $repetitions = 10): int\nCheck if number is "probably prime"',
'gmp_random_bits': '(int $bits): GMP\nRandom number',
'gmp_random_range': '(GMP|int|string $min, GMP|int|string $max): GMP\nGet a uniformly selected integer',
'gmp_random_seed': '(GMP|int|string $seed): void\nSets the RNG seed',
'gmp_random': '(int $limiter = 20): GMP\nRandom number',
'gmp_root': '(GMP|int|string $num, int $nth): GMP\nTake the integer part of nth root',
'gmp_rootrem': '(GMP|int|string $num, int $nth): array\nTake the integer part and remainder of nth root',
'gmp_scan0': '(GMP|int|string $num1, int $start): int\nScan for 0',
'gmp_scan1': '(GMP|int|string $num1, int $start): int\nScan for 1',
'gmp_setbit': '(GMP $num, int $index, bool $value = true): void\nSet bit',
'gmp_sign': '(GMP|int|string $num): int\nSign of number',
'gmp_sqrt': '(GMP|int|string $num): GMP\nCalculate square root',
'gmp_sqrtrem': '(GMP|int|string $num): array\nSquare root with remainder',
'gmp_strval': '(GMP|int|string $num, int $base = 10): string\nConvert GMP number to string',
'gmp_sub': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nSubtract numbers',
'gmp_testbit': '(GMP|int|string $num, int $index): bool\nTests if a bit is set',
'gmp_xor': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nBitwise XOR',
'ldap_8859_to_t61': '(string $value): string|false\nTranslate 8859 characters to t61 characters',
'ldap_add_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, ?array $controls = null): LDAP\\Result|false\nAdd entries to LDAP directory',
'ldap_add': '(LDAP\\Connection $ldap, string $dn, array $entry, ?array $controls = null): bool\nAdd entries to LDAP directory',
'ldap_bind_ext': '(LDAP\\Connection $ldap, ?string $dn = null, ?string $password = null, ?array $controls = null): LDAP\\Result|false\nBind to LDAP directory',
'ldap_bind': '(LDAP\\Connection $ldap, ?string $dn = null, ?string $password = null): bool\nBind to LDAP directory',
'ldap_close': 'Alias of ldap_unbind',
'ldap_compare': '(LDAP\\Connection $ldap, string $dn, string $attribute, string $value, ?array $controls = null): bool|int\nCompare value of attribute found in entry specified with DN',
'ldap_connect_wallet': '(?string $uri = null, string $wallet, string $password, int $auth_mode = GSLC_SSL_NO_AUTH): LDAP\\Connection|false\nConnect to an LDAP server',
'ldap_connect': '(?string $host = null, int $port = 389): LDAP\\Connection|false\nConnect to an LDAP server',
'ldap_control_paged_result_response': '(resource $link, resource $result, string &$cookie = ?, int &$estimated = ?): bool\nRetrieve the LDAP pagination cookie',
'ldap_control_paged_result': '(resource $link, int $pagesize, bool $iscritical = false, string $cookie = ""): bool\nSend LDAP pagination control',
'ldap_count_entries': '(LDAP\\Connection $ldap, LDAP\\Result $result): int\nCount the number of entries in a search',
'ldap_count_references': '(LDAP\\Connection $ldap, LDAP\\Result $result): int\nCounts the number of references in a search result',
'ldap_delete_ext': '(LDAP\\Connection $ldap, string $dn, ?array $controls = null): LDAP\\Result|false\nDelete an entry from a directory',
'ldap_delete': '(LDAP\\Connection $ldap, string $dn, ?array $controls = null): bool\nDelete an entry from a directory',
'ldap_dn2ufn': '(string $dn): string|false\nConvert DN to User Friendly Naming format',
'ldap_err2str': '(int $errno): string\nConvert LDAP error number into string error message',
'ldap_errno': '(LDAP\\Connection $ldap): int\nReturn the LDAP error number of the last LDAP command',
'ldap_error': '(LDAP\\Connection $ldap): string\nReturn the LDAP error message of the last LDAP command',
'ldap_escape': '(string $value, string $ignore = "", int $flags = ?): string\nEscape a string for use in an LDAP filter or DN',
'ldap_exop_passwd': '(LDAP\\Connection $ldap, string $user = "", string $old_password = "", string $new_password = "", array &$controls = null): string|bool\nPASSWD extended operation helper',
'ldap_exop_refresh': '(LDAP\\Connection $ldap, string $dn, int $ttl): int|false\nRefresh extended operation helper',
'ldap_exop_sync': '(LDAP\\Connection $ldap, string $request_oid, ?string $request_data = null, ?array $controls = null, string &$response_data = null, string &$response_oid = null): LDAP\\Result|bool\nPerforms an extended operation',
'ldap_exop_whoami': '(LDAP\\Connection $ldap): string|false\nWHOAMI extended operation helper',
'ldap_exop': '(LDAP\\Connection $ldap, string $request_oid, ?string $request_data = null, ?array $controls = null, string &$response_data = ?, string &$response_oid = ?): LDAP\\Result|bool\nPerforms an extended operation',
'ldap_explode_dn': '(string $dn, int $with_attrib): array|false\nSplits DN into its component parts',
'ldap_first_attribute': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): string|false\nReturn first attribute',
'ldap_first_entry': '(LDAP\\Connection $ldap, LDAP\\Result $result): LDAP\\ResultEntry|false\nReturn first result id',
'ldap_first_reference': '(LDAP\\Connection $ldap, LDAP\\Result $result): LDAP\\ResultEntry|false\nReturn first reference',
'ldap_free_result': '(LDAP\\Result $result): bool\nFree result memory',
'ldap_get_attributes': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): array\nGet attributes from a search result entry',
'ldap_get_dn': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): string|false\nGet the DN of a result entry',
'ldap_get_entries': '(LDAP\\Connection $ldap, LDAP\\Result $result): array|false\nGet all result entries',
'ldap_get_option': '(?LDAP\\Connection $ldap, int $option, array|string|int &$value = null): bool\nGet the current value for given option',
'ldap_get_values_len': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry, string $attribute): array|false\nGet all binary values from a result entry',
'ldap_get_values': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry, string $attribute): array|false\nGet all values from a result entry',
'ldap_list': '(LDAP\\Connection|array $ldap, array|string $base, array|string $filter, array $attributes = [], int $attributes_only = ?, int $sizelimit = -1, int $timelimit = -1, int $deref = LDAP_DEREF_NEVER, ?array $controls = null): LDAP\\Result|array|false\nSingle-level search',
'ldap_mod_add_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, ?array $controls = null): LDAP\\Result|false\nAdd attribute values to current attributes',
'ldap_mod_add': '(LDAP\\Connection $ldap, string $dn, array $entry, ?array $controls = null): bool\nAdd attribute values to current attributes',
'ldap_mod_del_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, ?array $controls = null): LDAP\\Result|false\nDelete attribute values from current attributes',
'ldap_mod_del': '(LDAP\\Connection $ldap, string $dn, array $entry, ?array $controls = null): bool\nDelete attribute values from current attributes',
'ldap_mod_replace_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, ?array $controls = null): LDAP\\Result|false\nReplace attribute values with new ones',
'ldap_mod_replace': '(LDAP\\Connection $ldap, string $dn, array $entry, ?array $controls = null): bool\nReplace attribute values with new ones',
'ldap_modify_batch': '(LDAP\\Connection $ldap, string $dn, array $modifications_info, ?array $controls = null): bool\nBatch and execute modifications on an LDAP entry',
'ldap_modify': 'Alias of ldap_mod_replace',
'ldap_next_attribute': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): string|false\nGet the next attribute in result',
'ldap_next_entry': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): LDAP\\ResultEntry|false\nGet next result entry',
'ldap_next_reference': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): LDAP\\ResultEntry|false\nGet next reference',
'ldap_parse_exop': '(LDAP\\Connection $ldap, LDAP\\Result $result, string &$response_data = null, string &$response_oid = null): bool\nParse result object from an LDAP extended operation',
'ldap_parse_reference': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry, array &$referrals): bool\nExtract information from reference entry',
'ldap_parse_result': '(LDAP\\Connection $ldap, LDAP\\Result $result, int &$error_code, string &$matched_dn = null, string &$error_message = null, array &$referrals = null, array &$controls = null): bool\nExtract information from result',
'ldap_read': '(LDAP\\Connection|array $ldap, array|string $base, array|string $filter, array $attributes = [], int $attributes_only = ?, int $sizelimit = -1, int $timelimit = -1, int $deref = LDAP_DEREF_NEVER, ?array $controls = null): LDAP\\Result|array|false\nRead an entry',
'ldap_rename_ext': '(LDAP\\Connection $ldap, string $dn, string $new_rdn, string $new_parent, bool $delete_old_rdn, ?array $controls = null): LDAP\\Result|false\nModify the name of an entry',
'ldap_rename': '(LDAP\\Connection $ldap, string $dn, string $new_rdn, string $new_parent, bool $delete_old_rdn, ?array $controls = null): bool\nModify the name of an entry',
'ldap_sasl_bind': '(LDAP\\Connection $ldap, ?string $dn = null, ?string $password = null, ?string $mech = null, ?string $realm = null, ?string $authc_id = null, ?string $authz_id = null, ?string $props = null): bool\nBind to LDAP directory using SASL',
'ldap_search': '(LDAP\\Connection|array $ldap, array|string $base, array|string $filter, array $attributes = [], int $attributes_only = ?, int $sizelimit = -1, int $timelimit = -1, int $deref = LDAP_DEREF_NEVER, ?array $controls = null): LDAP\\Result|array|false\nSearch LDAP tree',
'ldap_set_option': '(?LDAP\\Connection $ldap, int $option, array|string|int|bool $value): bool\nSet the value of the given option',
'ldap_set_rebind_proc': '(LDAP\\Connection $ldap, ?callable $callback): bool\nSet a callback function to do re-binds on referral chasing',
'ldap_sort': '(resource $link, resource $result, string $sortfilter): bool\nSort LDAP result entries on the client side',
'ldap_start_tls': '(LDAP\\Connection $ldap): bool\nStart TLS',
'ldap_t61_to_8859': '(string $value): string|false\nTranslate t61 characters to 8859 characters',
'ldap_unbind': '(LDAP\\Connection $ldap): bool\nUnbind from LDAP directory',
'libxml_clear_errors': '(): void\nClear libxml error buffer',
'libxml_disable_entity_loader': '(bool $disable = true): bool\nDisable the ability to load external entities',
'libxml_get_errors': '(): array\nRetrieve array of errors',
'libxml_get_external_entity_loader': '(): ?callable\nGet the current external entity loader',
'libxml_get_last_error': '(): LibXMLError|false\nRetrieve last error from libxml',
'libxml_set_external_entity_loader': '(?callable $resolver_function): true\nChanges the default external entity loader',
'libxml_set_streams_context': '(resource $context): void\nSet the streams context for the next libxml document load or write',
'libxml_use_internal_errors': '(?bool $use_errors = null): bool\nDisable libxml errors and allow user to fetch error information as needed',
'mysqli_connect': '(?string $hostname = null, ?string $username = null, ?string $password = null, ?string $database = null, ?int $port = null, ?string $socket = null): mysqli|false\nOpen a new connection to the MySQL server',
'mysqli_execute': 'Alias of mysqli_stmt_execute',
'mysqli_get_client_stats': '(): array\nReturns client per-process statistics',
'mysqli_get_links_stats': '(): array\nReturn information about open and cached links',
'mysqli_report': '(int $flags): true\nSets mysqli error reporting mode',
'mysqli_affected_rows': '(mysqli $mysql): int|string\nGets the number of affected rows in a previous MySQL operation',
'mysqli_autocommit': '(mysqli $mysql, bool $enable): bool\nTurns on or off auto-committing database modifications',
'mysqli_begin_transaction': '(mysqli $mysql, int $flags = ?, ?string $name = null): bool\nStarts a transaction',
'mysqli_change_user': '(mysqli $mysql, string $username, string $password, ?string $database): bool\nChanges the user of the database connection',
'mysqli_character_set_name': '(mysqli $mysql): string\nReturns the current character set of the database connection',
'mysqli_close': '(mysqli $mysql): true\nCloses a previously opened database connection',
'mysqli_commit': '(mysqli $mysql, int $flags = ?, ?string $name = null): bool\nCommits the current transaction',
'mysqli_connect_errno': '(): int\nReturns the error code from last connect call',
'mysqli_connect_error': '(): ?string\nReturns a description of the last connection error',
'mysqli_debug': '(string $options): true\nPerforms debugging operations',
'mysqli_dump_debug_info': '(mysqli $mysql): bool\nDump debugging information into the log',
'mysqli_errno': '(mysqli $mysql): int\nReturns the error code for the most recent function call',
'mysqli_error_list': '(mysqli $mysql): array\nReturns a list of errors from the last command executed',
'mysqli_error': '(mysqli $mysql): string\nReturns a string description of the last error',
'mysqli_execute_query': '(mysqli $mysql, string $query, ?array $params = null): mysqli_result|bool\nPrepares, binds parameters, and executes SQL statement',
'mysqli_field_count': '(mysqli $mysql): int\nReturns the number of columns for the most recent query',
'mysqli_get_charset': '(mysqli $mysql): ?object\nReturns a character set object',
'mysqli_get_client_info': '(?mysqli $mysql = null): string\nGet MySQL client info',
'mysqli_get_client_version': '(): int\nReturns the MySQL client version as an integer',
'mysqli_get_connection_stats': '(mysqli $mysql): array\nReturns statistics about the client connection',
'mysqli_get_host_info': '(mysqli $mysql): string\nReturns a string representing the type of connection used',
'mysqli_get_proto_info': '(mysqli $mysql): int\nReturns the version of the MySQL protocol used',
'mysqli_get_server_info': '(mysqli $mysql): string\nReturns the version of the MySQL server',
'mysqli_get_server_version': '(mysqli $mysql): int\nReturns the version of the MySQL server as an integer',
'mysqli_get_warnings': '(mysqli $mysql): mysqli_warning|false\nGet result of SHOW WARNINGS',
'mysqli_info': '(mysqli $mysql): ?string\nRetrieves information about the most recently executed query',
'mysqli_init': '(): mysqli|false\nInitializes MySQLi and returns an object for use with mysqli_real_connect()',
'mysqli_insert_id': '(mysqli $mysql): int|string\nReturns the value generated for an AUTO_INCREMENT column by the last query',
'mysqli_kill': '(mysqli $mysql, int $process_id): bool\nAsks the server to kill a MySQL thread',
'mysqli_more_results': '(mysqli $mysql): bool\nCheck if there are any more query results from a multi query',
'mysqli_multi_query': '(mysqli $mysql, string $query): bool\nPerforms one or more queries on the database',
'mysqli_next_result': '(mysqli $mysql): bool\nPrepare next result from multi_query',
'mysqli_options': '(mysqli $mysql, int $option, string|int $value): bool\nSet options',
'mysqli_ping': '(mysqli $mysql): bool\nPings a server connection, or tries to reconnect if the connection has gone down',
'mysqli::poll': '(?array &$read, ?array &$error, array &$reject, int $seconds, int $microseconds = ?): int|false\nPoll connections',
'mysqli_poll': '(?array &$read, ?array &$error, array &$reject, int $seconds, int $microseconds = ?): int|false\nPoll connections',
'mysqli_prepare': '(mysqli $mysql, string $query): mysqli_stmt|false\nPrepares an SQL statement for execution',
'mysqli_query': '(mysqli $mysql, string $query, int $result_mode = MYSQLI_STORE_RESULT): mysqli_result|bool\nPerforms a query on the database',
'mysqli_real_connect': '(mysqli $mysql, ?string $hostname = null, ?string $username = null, ?string $password = null, ?string $database = null, ?int $port = null, ?string $socket = null, int $flags = ?): bool\nOpens a connection to the MySQL server',
'mysqli_real_escape_string': '(mysqli $mysql, string $string): string\nEscapes special characters in a string for use in an SQL statement, taking into account the current charset of the connection',
'mysqli_real_query': '(mysqli $mysql, string $query): bool\nExecute an SQL query',
'mysqli_reap_async_query': '(mysqli $mysql): mysqli_result|bool\nGet result from async query',
'mysqli_refresh': '(mysqli $mysql, int $flags): bool\nRefreshes',
'mysqli_release_savepoint': '(mysqli $mysql, string $name): bool\nRemoves the named savepoint from the set of savepoints of the current transaction',
'mysqli_rollback': '(mysqli $mysql, int $flags = ?, ?string $name = null): bool\nRolls back current transaction',
'mysqli_savepoint': '(mysqli $mysql, string $name): bool\nSet a named transaction savepoint',
'mysqli_select_db': '(mysqli $mysql, string $database): bool\nSelects the default database for database queries',
'mysqli_set_charset': '(mysqli $mysql, string $charset): bool\nSets the client character set',
'mysqli_sqlstate': '(mysqli $mysql): string\nReturns the SQLSTATE error from previous MySQL operation',
'mysqli_ssl_set': '(mysqli $mysql, ?string $key, ?string $certificate, ?string $ca_certificate, ?string $ca_path, ?string $cipher_algos): true\nUsed for establishing secure connections using SSL',
'mysqli_stat': '(mysqli $mysql): string|false\nGets the current system status',
'mysqli_stmt_init': '(mysqli $mysql): mysqli_stmt|false\nInitializes a statement and returns an object for use with mysqli_stmt_prepare',
'mysqli_store_result': '(mysqli $mysql, int $mode = ?): mysqli_result|false\nTransfers a result set from the last query',
'mysqli_thread_id': '(mysqli $mysql): int\nReturns the thread ID for the current connection',
'mysqli_thread_safe': '(): bool\nReturns whether thread safety is given or not',
'mysqli_use_result': '(mysqli $mysql): mysqli_result|false\nInitiate a result set retrieval',
'mysqli_warning_count': '(mysqli $mysql): int\nReturns the number of warnings generated by the most recently executed query',
'mysqli_embedded_server_end': '(): void\nStop embedded server',
'mysqli_embedded_server_start': '(int $start, array $arguments, array $groups): bool\nInitialize and start embedded server',
'mysqli_field_tell': '(mysqli_result $result): int\nGet current field offset of a result pointer',
'mysqli_data_seek': '(mysqli_result $result, int $offset): bool\nAdjusts the result pointer to an arbitrary row in the result',
'mysqli_fetch_all': '(mysqli_result $result, int $mode = MYSQLI_NUM): array\nFetch all result rows as an associative array, a numeric array, or both',
'mysqli_fetch_array': '(mysqli_result $result, int $mode = MYSQLI_BOTH): array|null|false\nFetch the next row of a result set as an associative, a numeric array, or both',
'mysqli_fetch_assoc': '(mysqli_result $result): array|null|false\nFetch the next row of a result set as an associative array',
'mysqli_fetch_column': '(mysqli_result $result, int $column = ?): null|int|float|string|false\nFetch a single column from the next row of a result set',
'mysqli_fetch_field_direct': '(mysqli_result $result, int $index): object|false\nFetch meta-data for a single field',
'mysqli_fetch_field': '(mysqli_result $result): object|false\nReturns the next field in the result set',
'mysqli_fetch_fields': '(mysqli_result $result): array\nReturns an array of objects representing the fields in a result set',
'mysqli_fetch_object': '(mysqli_result $result, string $class = "stdClass", array $constructor_args = []): object|null|false\nFetch the next row of a result set as an object',
'mysqli_fetch_row': '(mysqli_result $result): array|null|false\nFetch the next row of a result set as an enumerated array',
'mysqli_num_fields': '(mysqli_result $result): int\nGets the number of fields in the result set',
'mysqli_field_seek': '(mysqli_result $result, int $index): true\nSet result pointer to a specified field offset',
'mysqli_free_result': '(mysqli_result $result): void\nFrees the memory associated with a result',
'mysqli_fetch_lengths': '(mysqli_result $result): array|false\nReturns the lengths of the columns of the current row in the result set',
'mysqli_num_rows': '(mysqli_result $result): int|string\nGets the number of rows in the result set',
'mysqli_stmt_affected_rows': '(mysqli_stmt $statement): int|string\nReturns the total number of rows changed, deleted, inserted, or matched by the last statement executed',
'mysqli_stmt_attr_get': '(mysqli_stmt $statement, int $attribute): int\nUsed to get the current value of a statement attribute',
'mysqli_stmt_attr_set': '(mysqli_stmt $statement, int $attribute, int $value): bool\nUsed to modify the behavior of a prepared statement',
'mysqli_stmt_bind_param': '(mysqli_stmt $statement, string $types, mixed &$var, mixed &...$vars): bool\nBinds variables to a prepared statement as parameters',
'mysqli_stmt_bind_result': '(mysqli_stmt $statement, mixed &$var, mixed &...$vars): bool\nBinds variables to a prepared statement for result storage',
'mysqli_stmt_close': '(mysqli_stmt $statement): true\nCloses a prepared statement',
'mysqli_stmt_data_seek': '(mysqli_stmt $statement, int $offset): void\nAdjusts the result pointer to an arbitrary row in the buffered result',
'mysqli_stmt_errno': '(mysqli_stmt $statement): int\nReturns the error code for the most recent statement call',
'mysqli_stmt_error_list': '(mysqli_stmt $statement): array\nReturns a list of errors from the last statement executed',
'mysqli_stmt_error': '(mysqli_stmt $statement): string\nReturns a string description for last statement error',
'mysqli_stmt_execute': '(mysqli_stmt $statement, ?array $params = null): bool\nExecutes a prepared statement',
'mysqli_stmt_fetch': '(mysqli_stmt $statement): ?bool\nFetch results from a prepared statement into the bound variables',
'mysqli_stmt_field_count': '(mysqli_stmt $statement): int\nReturns the number of columns in the given statement',
'mysqli_stmt_free_result': '(mysqli_stmt $statement): void\nFrees stored result memory for the given statement handle',
'mysqli_stmt_get_result': '(mysqli_stmt $statement): mysqli_result|false\nGets a result set from a prepared statement as a mysqli_result object',
'mysqli_stmt_get_warnings': '(mysqli_stmt $statement): mysqli_warning|false\nGet result of SHOW WARNINGS',
'mysqli_stmt_insert_id': '(mysqli_stmt $statement): int|string\nGet the ID generated from the previous INSERT operation',
'mysqli_stmt_more_results': '(mysqli_stmt $statement): bool\nCheck if there are more query results from a multiple query',
'mysqli_stmt_next_result': '(mysqli_stmt $statement): bool\nReads the next result from a multiple query',
'mysqli_stmt_num_rows': '(mysqli_stmt $statement): int|string\nReturns the number of rows fetched from the server',
'mysqli_stmt_param_count': '(mysqli_stmt $statement): int\nReturns the number of parameters for the given statement',
'mysqli_stmt_prepare': '(mysqli_stmt $statement, string $query): bool\nPrepares an SQL statement for execution',
'mysqli_stmt_reset': '(mysqli_stmt $statement): bool\nResets a prepared statement',
'mysqli_stmt_result_metadata': '(mysqli_stmt $statement): mysqli_result|false\nReturns result set metadata from a prepared statement',
'mysqli_stmt_send_long_data': '(mysqli_stmt $statement, int $param_num, string $data): bool\nSend data in blocks',
'mysqli_stmt_sqlstate': '(mysqli_stmt $statement): string\nReturns SQLSTATE error from previous statement operation',
'mysqli_stmt_store_result': '(mysqli_stmt $statement): bool\nStores a result set in an internal buffer',
'openssl_cipher_iv_length': '(string $cipher_algo): int|false\nGets the cipher iv length',
'openssl_cipher_key_length': '(string $cipher_algo): int|false\nGets the cipher key length',
'openssl_cms_decrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string|null $private_key = null, int $encoding = OPENSSL_ENCODING_SMIME): bool\nDecrypt a CMS message',
'openssl_cms_encrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|array|string $certificate, ?array $headers, int $flags = ?, int $encoding = OPENSSL_ENCODING_SMIME, string|int $cipher_algo = OPENSSL_CIPHER_AES_128_CBC): bool\nEncrypt a CMS message',
'openssl_cms_read': '(string $input_filename, array &$certificates): bool\nExport the CMS file to an array of PEM certificates',
'openssl_cms_sign': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, ?array $headers, int $flags = ?, int $encoding = OPENSSL_ENCODING_SMIME, ?string $untrusted_certificates_filename = null): bool\nSign a file',
'openssl_cms_verify': '(string $input_filename, int $flags = ?, ?string $certificates = null, array $ca_info = [], ?string $untrusted_certificates_filename = null, ?string $content = null, ?string $pk7 = null, ?string $sigfile = null, int $encoding = OPENSSL_ENCODING_SMIME): bool\nVerify a CMS signature',
'openssl_csr_export_to_file': '(OpenSSLCertificateSigningRequest|string $csr, string $output_filename, bool $no_text = true): bool\nExports a CSR to a file',
'openssl_csr_export': '(OpenSSLCertificateSigningRequest|string $csr, string &$output, bool $no_text = true): bool\nExports a CSR as a string',
'openssl_csr_get_public_key': '(OpenSSLCertificateSigningRequest|string $csr, bool $short_names = true): OpenSSLAsymmetricKey|false\nReturns the public key of a CSR',
'openssl_csr_get_subject': '(OpenSSLCertificateSigningRequest|string $csr, bool $short_names = true): array|false\nReturns the subject of a CSR',
'openssl_csr_new': '(array $distinguished_names, ?OpenSSLAsymmetricKey &$private_key, ?array $options = null, ?array $extra_attributes = null): OpenSSLCertificateSigningRequest|bool\nGenerates a CSR',
'openssl_csr_sign': '(OpenSSLCertificateSigningRequest|string $csr, OpenSSLCertificate|string|null $ca_certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $days, ?array $options = null, int $serial = ?, ?string $serial_hex = null): OpenSSLCertificate|false\nSign a CSR with another certificate (or itself) and generate a certificate',
'openssl_decrypt': '(string $data, string $cipher_algo, string $passphrase, int $options = ?, string $iv = "", ?string $tag = null, string $aad = ""): string|false\nDecrypts data',
'openssl_dh_compute_key': '(string $public_key, OpenSSLAsymmetricKey $private_key): string|false\nComputes shared secret for public value of remote DH public key and local DH key',
'openssl_digest': '(string $data, string $digest_algo, bool $binary = false): string|false\nComputes a digest',
'openssl_encrypt': '(string $data, string $cipher_algo, string $passphrase, int $options = ?, string $iv = "", string &$tag = null, string $aad = "", int $tag_length = 16): string|false\nEncrypts data',
'openssl_error_string': '(): string|false\nReturn openSSL error message',
'openssl_free_key': '(OpenSSLAsymmetricKey $key): void\nFree key resource',
'openssl_get_cert_locations': '(): array\nRetrieve the available certificate locations',
'openssl_get_cipher_methods': '(bool $aliases = false): array\nGets available cipher methods',
'openssl_get_curve_names': '(): array|false\nGets list of available curve names for ECC',
'openssl_get_md_methods': '(bool $aliases = false): array\nGets available digest methods',
'openssl_get_privatekey': 'Alias of openssl_pkey_get_private',
'openssl_get_publickey': 'Alias of openssl_pkey_get_public',
'openssl_open': '(string $data, string &$output, string $encrypted_key, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string $cipher_algo, ?string $iv = null): bool\nOpen sealed data',
'openssl_password_hash': '(string $algo, string $password, array $options = []): string\nCreate a password hash using OpenSSL\'s Argon2 implementation',
'openssl_password_verify': '(string $algo, string $password, string $hash): bool\nVerify a password against a hash using OpenSSL\'s Argon2 implementation',
'openssl_pbkdf2': '(string $password, string $salt, int $key_length, int $iterations, string $digest_algo = "sha1"): string|false\nGenerates a PKCS5 v2 PBKDF2 string',
'openssl_pkcs12_export_to_file': '(OpenSSLCertificate|string $certificate, string $output_filename, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string $passphrase, array $options = []): bool\nExports a PKCS#12 Compatible Certificate Store File',
'openssl_pkcs12_export': '(OpenSSLCertificate|string $certificate, string &$output, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string $passphrase, array $options = []): bool\nExports a PKCS#12 Compatible Certificate Store File to variable',
'openssl_pkcs12_read': '(string $pkcs12, array &$certificates, string $passphrase): bool\nParse a PKCS#12 Certificate Store into an array',
'openssl_pkcs7_decrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string|null $private_key = null): bool\nDecrypts an S/MIME encrypted message',
'openssl_pkcs7_encrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|array|string $certificate, ?array $headers, int $flags = ?, int $cipher_algo = OPENSSL_CIPHER_AES_128_CBC): bool\nEncrypt an S/MIME message',
'openssl_pkcs7_read': '(string $data, array &$certificates): bool\nExport the PKCS7 file to an array of PEM certificates',
'openssl_pkcs7_sign': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, ?array $headers, int $flags = PKCS7_DETACHED, ?string $untrusted_certificates_filename = null): bool\nSign an S/MIME message',
'openssl_pkcs7_verify': '(string $input_filename, int $flags, ?string $signers_certificates_filename = null, array $ca_info = [], ?string $untrusted_certificates_filename = null, ?string $content = null, ?string $output_filename = null): bool|int\nVerifies the signature of an S/MIME signed message',
'openssl_pkey_derive': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $key_length = ?): string|false\nComputes shared secret for public value of remote and local DH or ECDH key',
'openssl_pkey_export_to_file': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key, string $output_filename, ?string $passphrase = null, ?array $options = null): bool\nGets an exportable representation of a key into a file',
'openssl_pkey_export': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key, string &$output, ?string $passphrase = null, ?array $options = null): bool\nGets an exportable representation of a key into a string',
'openssl_pkey_free': '(OpenSSLAsymmetricKey $key): void\nFrees a private key',
'openssl_pkey_get_details': '(OpenSSLAsymmetricKey $key): array|false\nReturns an array with the key details',
'openssl_pkey_get_private': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, ?string $passphrase = null): OpenSSLAsymmetricKey|false\nGet a private key',
'openssl_pkey_get_public': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key): OpenSSLAsymmetricKey|false\nExtract public key from certificate and prepare it for use',
'openssl_pkey_new': '(?array $options = null): OpenSSLAsymmetricKey|false\nGenerates a new private key',
'openssl_private_decrypt': '(string $data, string &$decrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $padding = OPENSSL_PKCS1_PADDING, ?string $digest_algo = null): bool\nDecrypts data with private key',
'openssl_private_encrypt': '(string $data, string &$encrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nEncrypts data with private key',
'openssl_public_decrypt': '(string $data, string &$decrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nDecrypts data with public key',
'openssl_public_encrypt': '(string $data, string &$encrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, int $padding = OPENSSL_PKCS1_PADDING, ?string $digest_algo = null): bool\nEncrypts data with public key',
'openssl_random_pseudo_bytes': '(int $length, bool &$strong_result = null): string\nGenerate a pseudo-random string of bytes',
'openssl_seal': '(string $data, string &$sealed_data, array &$encrypted_keys, array $public_key, string $cipher_algo, string &$iv = null): int|false\nSeal (encrypt) data',
'openssl_sign': '(string $data, string &$signature, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string|int $algorithm = OPENSSL_ALGO_SHA1, int $padding = ?): bool\nGenerate signature',
'openssl_spki_export_challenge': '(string $spki): string|false\nExports the challenge associated with a signed public key and challenge',
'openssl_spki_export': '(string $spki): string|false\nExports a valid PEM formatted public key signed public key and challenge',
'openssl_spki_new': '(OpenSSLAsymmetricKey $private_key, string $challenge, int $digest_algo = OPENSSL_ALGO_MD5): string|false\nGenerate a new signed public key and challenge',
'openssl_spki_verify': '(string $spki): bool\nVerifies a signed public key and challenge',
'openssl_verify': '(string $data, string $signature, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, string|int $algorithm = OPENSSL_ALGO_SHA1, int $padding = ?): int|false\nVerify signature',
'openssl_x509_check_private_key': '(OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key): bool\nChecks if a private key corresponds to a certificate',
'openssl_x509_checkpurpose': '(OpenSSLCertificate|string $certificate, int $purpose, array $ca_info = [], ?string $untrusted_certificates_file = null): bool|int\nVerifies if a certificate can be used for a particular purpose',
'openssl_x509_export_to_file': '(OpenSSLCertificate|string $certificate, string $output_filename, bool $no_text = true): bool\nExports a certificate to file',
'openssl_x509_export': '(OpenSSLCertificate|string $certificate, string &$output, bool $no_text = true): bool\nExports a certificate as a string',
'openssl_x509_fingerprint': '(OpenSSLCertificate|string $certificate, string $digest_algo = "sha1", bool $binary = false): string|false\nCalculates the fingerprint, or digest, of a given X.509 certificate',
'openssl_x509_free': '(OpenSSLCertificate $certificate): void\nFree certificate resource',
'openssl_x509_parse': '(OpenSSLCertificate|string $certificate, bool $short_names = true): array|false\nParse an X509 certificate and return the information as an array',
'openssl_x509_read': '(OpenSSLCertificate|string $certificate): OpenSSLCertificate|false\nParse an X.509 certificate and return an object for it',
'openssl_x509_verify': '(OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key): int\nVerifies digital signature of x509 certificate against a public key',
'Pdo\\Firebird::getApiVersion': '(): int\nGet the API version',
'pg_affected_rows': '(PgSql\\Result $result): int\nReturns number of affected records (tuples)',
'pg_cancel_query': '(PgSql\\Connection $connection): bool\nCancel an asynchronous query',
'pg_change_password': '(PgSql\\Connection $connection, string $user, string $password): bool\nChange a PostgreSQL user\'s password',
'pg_client_encoding': '(?PgSql\\Connection $connection = null): string\nGets the client encoding',
'pg_close': '(?PgSql\\Connection $connection = null): true\nCloses a PostgreSQL connection',
'pg_connect_poll': '(PgSql\\Connection $connection): int\nPoll the status of an in-progress asynchronous PostgreSQL connection attempt',
'pg_connect': '(string $connection_string, int $flags = ?): PgSql\\Connection|false\nOpen a PostgreSQL connection',
'pg_connection_busy': '(PgSql\\Connection $connection): bool\nGet connection is busy or not',
'pg_connection_reset': '(PgSql\\Connection $connection): bool\nReset connection (reconnect)',
'pg_connection_status': '(PgSql\\Connection $connection): int\nGet connection status',
'pg_consume_input': '(PgSql\\Connection $connection): bool\nReads input on the connection',
'pg_convert': '(PgSql\\Connection $connection, string $table_name, array $values, int $flags = ?): array|false\nConvert associative array values into forms suitable for SQL statements',
'pg_copy_from': '(PgSql\\Connection $connection, string $table_name, array|Traversable $rows, string $separator = "\\t", string $null_as = "\\\\\\\\N"): bool\nInsert records into a table from an array',
'pg_copy_to': '(PgSql\\Connection $connection, string $table_name, string $separator = "\\t", string $null_as = "\\\\\\\\N"): array|false\nCopy a table to an array',
'pg_dbname': '(?PgSql\\Connection $connection = null): string\nGet the database name',
'pg_delete': '(PgSql\\Connection $connection, string $table_name, array $conditions, int $flags = PGSQL_DML_EXEC): string|bool\nDeletes records',
'pg_end_copy': '(?PgSql\\Connection $connection = null): bool\nSync with PostgreSQL backend',
'pg_escape_bytea': '(PgSql\\Connection $connection = ?, string $string): string\nEscape a string for insertion into a bytea field',
'pg_escape_identifier': '(PgSql\\Connection $connection = ?, string $string): string|false\nEscape an identifier for insertion into a text field',
'pg_escape_literal': '(PgSql\\Connection $connection = ?, string $string): string|false\nEscape a literal for insertion into a text field',
'pg_escape_string': '(PgSql\\Connection $connection = ?, string $string): string\nEscape a string for query',
'pg_execute': '(PgSql\\Connection $connection = ?, string $statement_name, array $params): PgSql\\Result|false\nSends a request to execute a prepared statement with given parameters, and waits for the result',
'pg_fetch_all_columns': '(PgSql\\Result $result, int $field = ?): array\nFetches all rows in a particular result column as an array',
'pg_fetch_all': '(PgSql\\Result $result, int $mode = PGSQL_ASSOC): array\nFetches all rows from a result as an array',
'pg_fetch_array': '(PgSql\\Result $result, ?int $row = null, int $mode = PGSQL_BOTH): array|false\nFetch a row as an array',
'pg_fetch_assoc': '(PgSql\\Result $result, ?int $row = null): array|false\nFetch a row as an associative array',
'pg_fetch_object': '(PgSql\\Result $result, ?int $row = null, string $class = "stdClass", array $constructor_args = []): object|false\nFetch a row as an object',
'pg_fetch_result': '(PgSql\\Result $result, mixed $field): string|false|null\nReturns values from a result instance',
'pg_fetch_row': '(PgSql\\Result $result, ?int $row = null, int $mode = PGSQL_NUM): array|false\nGet a row as an enumerated array',
'pg_field_is_null': '(PgSql\\Result $result, mixed $field): int\nTest if a field is SQL NULL',
'pg_field_name': '(PgSql\\Result $result, int $field): string\nReturns the name of a field',
'pg_field_num': '(PgSql\\Result $result, string $field): int\nReturns the field number of the named field',
'pg_field_prtlen': '(PgSql\\Result $result, mixed $field_name_or_number): int\nReturns the printed length',
'pg_field_size': '(PgSql\\Result $result, int $field): int\nReturns the internal storage size of the named field',
'pg_field_table': '(PgSql\\Result $result, int $field, bool $oid_only = false): string|int|false\nReturns the name or oid of the tables field',
'pg_field_type_oid': '(PgSql\\Result $result, int $field): string|int\nReturns the type ID (OID) for the corresponding field number',
'pg_field_type': '(PgSql\\Result $result, int $field): string\nReturns the type name for the corresponding field number',
'pg_flush': '(PgSql\\Connection $connection): int|bool\nFlush outbound query data on the connection',
'pg_free_result': '(PgSql\\Result $result): bool\nFree result memory',
'pg_get_notify': '(PgSql\\Connection $connection, int $mode = PGSQL_ASSOC): array|false\nGets SQL NOTIFY message',
'pg_get_pid': '(PgSql\\Connection $connection): int\nGets the backend\'s process ID',
'pg_get_result': '(PgSql\\Connection $connection): PgSql\\Result|false\nGet asynchronous query result',
'pg_host': '(?PgSql\\Connection $connection = null): string\nReturns the host name associated with the connection',
'pg_insert': '(PgSql\\Connection $connection, string $table_name, array $values, int $flags = PGSQL_DML_EXEC): PgSql\\Result|string|bool\nInsert array into table',
'pg_jit': '(?PgSql\\Connection $connection = null): array\nReturns the JIT information of the server',
'pg_last_error': '(?PgSql\\Connection $connection = null): string\nGet the last error message string of a connection',
'pg_last_notice': '(PgSql\\Connection $connection, int $mode = PGSQL_NOTICE_LAST): array|string|bool\nReturns the last notice message from PostgreSQL server',
'pg_last_oid': '(PgSql\\Result $result): string|int|false\nReturns the last row\'s OID',
'pg_lo_close': '(PgSql\\Lob $lob): bool\nClose a large object',
'pg_lo_create': '(mixed $object_id): int\nCreate a large object',
'pg_lo_export': '(PgSql\\Connection $connection = ?, int $oid, string $filename): bool\nExport a large object to file',
'pg_lo_import': '(PgSql\\Connection $connection = ?, string $filename, int|string $oid = ?): int|string|false\nImport a large object from file',
'pg_lo_open': '(PgSql\\Connection $connection, int $oid, string $mode): PgSql\\Lob|false\nOpen a large object',
'pg_lo_read_all': '(PgSql\\Lob $lob): int\nReads an entire large object and send straight to browser',
'pg_lo_read': '(PgSql\\Lob $lob, int $length = 8192): string|false\nRead a large object',
'pg_lo_seek': '(PgSql\\Lob $lob, int $offset, int $whence = SEEK_CUR): bool\nSeeks position within a large object',
'pg_lo_tell': '(PgSql\\Lob $lob): int\nReturns current seek position a of large object',
'pg_lo_truncate': '(PgSql\\Lob $lob, int $size): bool\nTruncates a large object',
'pg_lo_unlink': '(PgSql\\Connection $connection, int $oid): bool\nDelete a large object',
'pg_lo_write': '(PgSql\\Lob $lob, string $data, ?int $length = null): int|false\nWrite to a large object',
'pg_meta_data': '(PgSql\\Connection $connection, string $table_name, bool $extended = false): array|false\nGet meta data for table',
'pg_num_fields': '(PgSql\\Result $result): int\nReturns the number of fields in a result',
'pg_num_rows': '(PgSql\\Result $result): int\nReturns the number of rows in a result',
'pg_options': '(?PgSql\\Connection $connection = null): string\nGet the options associated with the connection',
'pg_parameter_status': '(PgSql\\Connection $connection = ?, string $name): string|false\nLooks up a current parameter setting of the server',
'pg_pconnect': '(string $connection_string, int $flags = ?): PgSql\\Connection|false\nOpen a persistent PostgreSQL connection',
'pg_ping': '(?PgSql\\Connection $connection = null): bool\nPing database connection',
'pg_port': '(?PgSql\\Connection $connection = null): string\nReturn the port number associated with the connection',
'pg_prepare': '(PgSql\\Connection $connection = ?, string $statement_name, string $query): PgSql\\Result|false\nSubmits a request to the server to create a prepared statement with the given parameters, and waits for completion',
'pg_put_copy_data': '(PgSql\\Connection $connection, string $cmd): int\nSend data to the server during a COPY operation',
'pg_put_copy_end': '(PgSql\\Connection $connection, ?string $error = null): int\nSignal the completion of a COPY operation to the server',
'pg_put_line': '(PgSql\\Connection $connection = ?, string $query): bool\nSend a NULL-terminated string to PostgreSQL backend',
'pg_query_params': '(PgSql\\Connection $connection = ?, string $query, array $params): PgSql\\Result|false\nSubmits a command to the server and waits for the result, with the ability to pass parameters separately from the SQL command text',
'pg_query': '(PgSql\\Connection $connection = ?, string $query): PgSql\\Result|false\nExecute a query',
'pg_result_error_field': '(PgSql\\Result $result, int $field_code): string|false|null\nReturns an individual field of an error report',
'pg_result_error': '(PgSql\\Result $result): string|false\nGet error message associated with result',
'pg_result_memory_size': '(PgSql\\Result $result): int\nReturns the amount of memory allocated for a query result',
'pg_result_seek': '(PgSql\\Result $result, int $row): bool\nSet internal row offset in result instance',
'pg_result_status': '(PgSql\\Result $result, int $mode = PGSQL_STATUS_LONG): string|int\nGet status of query result',
'pg_select': '(PgSql\\Connection $connection, string $table_name, array $conditions = [], int $flags = PGSQL_DML_EXEC, int $mode = PGSQL_ASSOC): array|string|false\nSelect records',
'pg_send_execute': '(PgSql\\Connection $connection, string $statement_name, array $params): int|bool\nSends a request to execute a prepared statement with given parameters, without waiting for the result(s)',
'pg_send_prepare': '(PgSql\\Connection $connection, string $statement_name, string $query): int|bool\nSends a request to create a prepared statement with the given parameters, without waiting for completion',
'pg_send_query_params': '(PgSql\\Connection $connection, string $query, array $params): int|bool\nSubmits a command and separate parameters to the server without waiting for the result(s)',
'pg_send_query': '(PgSql\\Connection $connection, string $query): int|bool\nSends asynchronous query',
'pg_set_chunked_rows_size': '(PgSql\\Connection $connection, int $size): bool\nSet the query results to be retrieved in chunk mode',
'pg_set_client_encoding': '(PgSql\\Connection $connection = ?, string $encoding): int\nSet the client encoding',
'pg_set_error_context_visibility': '(PgSql\\Connection $connection, int $visibility): int\nDetermines the visibility of the context\'s error messages returned by pg_last_error and pg_result_error',
'pg_set_error_verbosity': '(PgSql\\Connection $connection = ?, int $verbosity): int|false\nDetermines the verbosity of messages returned by pg_last_error and pg_result_error',
'pg_socket_poll': '(resource $socket, int $read, int $write, int $timeout = -1): int\nPoll a PostgreSQL connection socket for read/write readiness',
'pg_socket': '(PgSql\\Connection $connection): resource|false\nGet a read only handle to the socket underlying a PostgreSQL connection',
'pg_trace': '(string $filename, string $mode = "w", ?PgSql\\Connection $connection = null, int $trace_mode = ?): bool\nEnable tracing a PostgreSQL connection',
'pg_transaction_status': '(PgSql\\Connection $connection): int\nReturns the current in-transaction status of the server',
'pg_tty': '(?PgSql\\Connection $connection = null): string\nReturn the TTY name associated with the connection',
'pg_unescape_bytea': '(string $string): string\nUnescape binary for bytea type',
'pg_untrace': '(?PgSql\\Connection $connection = null): true\nDisable tracing of a PostgreSQL connection',
'pg_update': '(PgSql\\Connection $connection, string $table_name, array $values, array $conditions, int $flags = PGSQL_DML_EXEC): string|bool\nUpdate table',
'pg_version': '(?PgSql\\Connection $connection = null): array\nReturns an array with client, protocol and server version (when available)',
'readline_add_history': '(string $prompt): true\nAdds a line to the history',
'readline_callback_handler_install': '(string $prompt, callable $callback): true\nInitializes the readline callback interface and terminal, prints the prompt and returns immediately',
'readline_callback_handler_remove': '(): bool\nRemoves a previously installed callback handler and restores terminal settings',
'readline_callback_read_char': '(): void\nReads a character and informs the readline callback interface when a line is received',
'readline_clear_history': '(): true\nClears the history',
'readline_completion_function': '(callable $callback): bool\nRegisters a completion function',
'readline_info': '(?string $var_name = null, int|string|bool|null $value = null): mixed\nGets/sets various internal readline variables',
'readline_list_history': '(): array\nLists the history',
'readline_on_new_line': '(): void\nInform readline that the cursor has moved to a new line',
'readline_read_history': '(?string $filename = null): bool\nReads the history',
'readline_redisplay': '(): void\nRedraws the display',
'readline_write_history': '(?string $filename = null): bool\nWrites the history',
'readline': '(?string $prompt = null): string|false\nReads a line',
'simplexml_import_dom': '(object $node, ?string $class_name = SimpleXMLElement::class): ?SimpleXMLElement\nGet a SimpleXMLElement object from an XML or HTML node',
'simplexml_load_file': '(string $filename, ?string $class_name = SimpleXMLElement::class, int $options = ?, string $namespace_or_prefix = "", bool $is_prefix = false): SimpleXMLElement|false\nInterprets an XML file into an object',
'simplexml_load_string': '(string $data, ?string $class_name = SimpleXMLElement::class, int $options = ?, string $namespace_or_prefix = "", bool $is_prefix = false): SimpleXMLElement|false\nInterprets a string of XML into an object',
'snmp_get_quick_print': '(): bool\nFetches the current value of the NET-SNMP library\'s quick_print setting',
'snmp_get_valueretrieval': '(): int\nReturn the method how the SNMP values will be returned',
'snmp_read_mib': '(string $filename): bool\nReads and parses a MIB file into the active MIB tree',
'snmp_set_enum_print': '(bool $enable): true\nReturn all values that are enums with their enum value instead of the raw integer',
'snmp_set_oid_numeric_print': 'Alias of snmp_set_oid_output_format',
'snmp_set_oid_output_format': '(int $format): true\nSet the OID output format',
'snmp_set_quick_print': '(bool $enable): true\nSet the value of $enable within the NET-SNMP library',
'snmp_set_valueretrieval': '(int $method): true\nSpecify the method how the SNMP values will be returned',
'snmp2_get': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch an SNMP object',
'snmp2_getnext': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch the SNMP object which follows the given object id',
'snmp2_real_walk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nReturn all objects including their respective object ID within the specified one',
'snmp2_set': '(string $hostname, string $community, array|string $object_id, array|string $type, array|string $value, int $timeout = -1, int $retries = -1): bool\nSet the value of an SNMP object',
'snmp2_walk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nFetch all the SNMP objects from an agent',
'snmp3_get': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch an SNMP object',
'snmp3_getnext': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch the SNMP object which follows the given object id',
'snmp3_real_walk': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nReturn all objects including their respective object ID within the specified one',
'snmp3_set': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, array|string $type, array|string $value, int $timeout = -1, int $retries = -1): bool\nSet the value of an SNMP object',
'snmp3_walk': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nFetch all the SNMP objects from an agent',
'snmpget': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch an SNMP object',
'snmpgetnext': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch the SNMP object which follows the given object id',
'snmprealwalk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nReturn all objects including their respective object ID within the specified one',
'snmpset': '(string $hostname, string $community, array|string $object_id, array|string $type, array|string $value, int $timeout = -1, int $retries = -1): bool\nSet the value of an SNMP object',
'snmpwalk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nFetch all the SNMP objects from an agent',
'snmpwalkoid': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nQuery for a tree of information about a network entity',
'is_soap_fault': '(mixed $object): bool\nChecks if a SOAP call has failed',
'use_soap_error_handler': '(bool $enable = true): bool\nSet whether to use the SOAP error handler',
'sodium_add': '(string &$string1, string $string2): void\nAdd large numbers',
'sodium_base642bin': '(string $string, int $id, string $ignore = ""): string\nDecodes a base64-encoded string into raw binary.',
'sodium_bin2base64': '(string $string, int $id): string\nEncodes a raw binary string with base64.',
'sodium_bin2hex': '(string $string): string\nEncode to hexadecimal',
'sodium_compare': '(string $string1, string $string2): int\nCompare large numbers',
'sodium_crypto_aead_aegis128l_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt a message with AEGIS-128L',
'sodium_crypto_aead_aegis128l_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate a message with AEGIS-128L',
'sodium_crypto_aead_aegis128l_keygen': '(): string\nGenerate a random AEGIS-128L key',
'sodium_crypto_aead_aegis256_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt a message with AEGIS-256',
'sodium_crypto_aead_aegis256_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate a message with AEGIS-256',
'sodium_crypto_aead_aegis256_keygen': '(): string\nGenerate a random AEGIS-256 key',
'sodium_crypto_aead_aes256gcm_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt a message with AES-256-GCM',
'sodium_crypto_aead_aes256gcm_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate with AES-256-GCM',
'sodium_crypto_aead_aes256gcm_is_available': '(): bool\nCheck if hardware supports AES256-GCM',
'sodium_crypto_aead_aes256gcm_keygen': '(): string\nGenerate a random AES-256-GCM key',
'sodium_crypto_aead_chacha20poly1305_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt with ChaCha20-Poly1305',
'sodium_crypto_aead_chacha20poly1305_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate with ChaCha20-Poly1305',
'sodium_crypto_aead_chacha20poly1305_ietf_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify that the ciphertext includes a valid tag',
'sodium_crypto_aead_chacha20poly1305_ietf_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt a message',
'sodium_crypto_aead_chacha20poly1305_ietf_keygen': '(): string\nGenerate a random ChaCha20-Poly1305 (IETF) key.',
'sodium_crypto_aead_chacha20poly1305_keygen': '(): string\nGenerate a random ChaCha20-Poly1305 key.',
'sodium_crypto_aead_xchacha20poly1305_ietf_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\n(Preferred) Verify then decrypt with XChaCha20-Poly1305',
'sodium_crypto_aead_xchacha20poly1305_ietf_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\n(Preferred) Encrypt then authenticate with XChaCha20-Poly1305',
'sodium_crypto_aead_xchacha20poly1305_ietf_keygen': '(): string\nGenerate a random XChaCha20-Poly1305 key.',
'sodium_crypto_auth_keygen': '(): string\nGenerate a random key for sodium_crypto_auth',
'sodium_crypto_auth_verify': '(string $mac, string $message, string $key): bool\nVerifies that the tag is valid for the message',
'sodium_crypto_auth': '(string $message, string $key): string\nCompute a tag for the message',
'sodium_crypto_box_keypair_from_secretkey_and_publickey': '(string $secret_key, string $public_key): string\nCreate a unified keypair string from a secret key and public key',
'sodium_crypto_box_keypair': '(): string\nRandomly generate a secret key and a corresponding public key',
'sodium_crypto_box_open': '(string $ciphertext, string $nonce, string $key_pair): string|false\nAuthenticated public-key decryption',
'sodium_crypto_box_publickey_from_secretkey': '(string $secret_key): string\nCalculate the public key from a secret key',
'sodium_crypto_box_publickey': '(string $key_pair): string\nExtract the public key from a crypto_box keypair',
'sodium_crypto_box_seal_open': '(string $ciphertext, string $key_pair): string|false\nAnonymous public-key decryption',
'sodium_crypto_box_seal': '(string $message, string $public_key): string\nAnonymous public-key encryption',
'sodium_crypto_box_secretkey': '(string $key_pair): string\nExtracts the secret key from a crypto_box keypair',
'sodium_crypto_box_seed_keypair': '(string $seed): string\nDeterministically derive the key pair from a single key',
'sodium_crypto_box': '(string $message, string $nonce, string $key_pair): string\nAuthenticated public-key encryption',
'sodium_crypto_core_ristretto255_add': '(string $p, string $q): string\nAdds an element',
'sodium_crypto_core_ristretto255_from_hash': '(string $s): string\nMaps a vector',
'sodium_crypto_core_ristretto255_is_valid_point': '(string $s): bool\nDetermines if a point on the ristretto255 curve',
'sodium_crypto_core_ristretto255_random': '(): string\nGenerates a random key',
'sodium_crypto_core_ristretto255_scalar_add': '(string $x, string $y): string\nAdds a scalar value',
'sodium_crypto_core_ristretto255_scalar_complement': '(string $s): string\nThe sodium_crypto_core_ristretto255_scalar_complement purpose',
'sodium_crypto_core_ristretto255_scalar_invert': '(string $s): string\nInverts a scalar value',
'sodium_crypto_core_ristretto255_scalar_mul': '(string $x, string $y): string\nMultiplies a scalar value',
'sodium_crypto_core_ristretto255_scalar_negate': '(string $s): string\nNegates a scalar value',
'sodium_crypto_core_ristretto255_scalar_random': '(): string\nGenerates a random key',
'sodium_crypto_core_ristretto255_scalar_reduce': '(string $s): string\nReduces a scalar value',
'sodium_crypto_core_ristretto255_scalar_sub': '(string $x, string $y): string\nSubtracts a scalar value',
'sodium_crypto_core_ristretto255_sub': '(string $p, string $q): string\nSubtracts an element',
'sodium_crypto_generichash_final': '(string &$state, int $length = SODIUM_CRYPTO_GENERICHASH_BYTES): string\nComplete the hash',
'sodium_crypto_generichash_init': '(string $key = "", int $length = SODIUM_CRYPTO_GENERICHASH_BYTES): string\nInitialize a hash for streaming',
'sodium_crypto_generichash_keygen': '(): string\nGenerate a random generichash key',
'sodium_crypto_generichash_update': '(string &$state, string $message): true\nAdd message to a hash',
'sodium_crypto_generichash': '(string $message, string $key = "", int $length = SODIUM_CRYPTO_GENERICHASH_BYTES): string\nGet a hash of the message',
'sodium_crypto_kdf_derive_from_key': '(int $subkey_length, int $subkey_id, string $context, string $key): string\nDerive a subkey',
'sodium_crypto_kdf_keygen': '(): string\nGenerate a random root key for the KDF interface',
'sodium_crypto_kx_client_session_keys': '(string $client_key_pair, string $server_key): array\nCalculate the client-side session keys.',
'sodium_crypto_kx_keypair': '(): string\nCreates a new sodium keypair',
'sodium_crypto_kx_publickey': '(string $key_pair): string\nExtract the public key from a crypto_kx keypair',
'sodium_crypto_kx_secretkey': '(string $key_pair): string\nExtract the secret key from a crypto_kx keypair.',
'sodium_crypto_kx_seed_keypair': '(string $seed): string\nDescription',
'sodium_crypto_kx_server_session_keys': '(string $server_key_pair, string $client_key): array\nCalculate the server-side session keys.',
'sodium_crypto_pwhash_scryptsalsa208sha256_str_verify': '(string $hash, string $password): bool\nVerify that the password is a valid password verification string',
'sodium_crypto_pwhash_scryptsalsa208sha256_str': '(string $password, int $opslimit, int $memlimit): string\nGet an ASCII encoded hash',
'sodium_crypto_pwhash_scryptsalsa208sha256': '(int $length, string $password, string $salt, int $opslimit, int $memlimit): string\nDerives a key from a password, using scrypt',
'sodium_crypto_pwhash_str_needs_rehash': '(string $password, int $opslimit, int $memlimit): bool\nDetermine whether or not to rehash a password',
'sodium_crypto_pwhash_str_verify': '(string $hash, string $password): bool\nVerifies that a password matches a hash',
'sodium_crypto_pwhash_str': '(string $password, int $opslimit, int $memlimit): string\nGet an ASCII-encoded hash',
'sodium_crypto_pwhash': '(int $length, string $password, string $salt, int $opslimit, int $memlimit, int $algo = SODIUM_CRYPTO_PWHASH_ALG_DEFAULT): string\nDerive a key from a password, using Argon2',
'sodium_crypto_scalarmult_base': 'Alias of sodium_crypto_box_publickey_from_secretkey',
'sodium_crypto_scalarmult_ristretto255_base': '(string $n): string\nCalculates the public key from a secret key',
'sodium_crypto_scalarmult_ristretto255': '(string $n, string $p): string\nComputes a shared secret',
'sodium_crypto_scalarmult': '(string $n, string $p): string\nCompute a shared secret given a user\'s secret key and another user\'s public key',
'sodium_crypto_secretbox_keygen': '(): string\nGenerate random key for sodium_crypto_secretbox',
'sodium_crypto_secretbox_open': '(string $ciphertext, string $nonce, string $key): string|false\nAuthenticated shared-key decryption',
'sodium_crypto_secretbox': '(string $message, string $nonce, string $key): string\nAuthenticated shared-key encryption',
'sodium_crypto_secretstream_xchacha20poly1305_init_pull': '(string $header, string $key): string\nInitialize a secretstream context for decryption',
'sodium_crypto_secretstream_xchacha20poly1305_init_push': '(string $key): array\nInitialize a secretstream context for encryption',
'sodium_crypto_secretstream_xchacha20poly1305_keygen': '(): string\nGenerate a random secretstream key.',
'sodium_crypto_secretstream_xchacha20poly1305_pull': '(string &$state, string $ciphertext, string $additional_data = ""): array|false\nDecrypt a chunk of data from an encrypted stream',
'sodium_crypto_secretstream_xchacha20poly1305_push': '(string &$state, string $message, string $additional_data = "", int $tag = SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_MESSAGE): string\nEncrypt a chunk of data so that it can safely be decrypted in a streaming API',
'sodium_crypto_secretstream_xchacha20poly1305_rekey': '(string &$state): void\nExplicitly rotate the key in the secretstream state',
'sodium_crypto_shorthash_keygen': '(): string\nGet random bytes for key',
'sodium_crypto_shorthash': '(string $message, string $key): string\nCompute a short hash of a message and key',
'sodium_crypto_sign_detached': '(string $message, string $secret_key): string\nSign the message',
'sodium_crypto_sign_ed25519_pk_to_curve25519': '(string $public_key): string\nConvert an Ed25519 public key to a Curve25519 public key',
'sodium_crypto_sign_ed25519_sk_to_curve25519': '(string $secret_key): string\nConvert an Ed25519 secret key to a Curve25519 secret key',
'sodium_crypto_sign_keypair_from_secretkey_and_publickey': '(string $secret_key, string $public_key): string\nJoin a secret key and public key together',
'sodium_crypto_sign_keypair': '(): string\nRandomly generate a secret key and a corresponding public key',
'sodium_crypto_sign_open': '(string $signed_message, string $public_key): string|false\nCheck that the signed message has a valid signature',
'sodium_crypto_sign_publickey_from_secretkey': '(string $secret_key): string\nExtract the Ed25519 public key from the secret key',
'sodium_crypto_sign_publickey': '(string $key_pair): string\nExtract the Ed25519 public key from a keypair',
'sodium_crypto_sign_secretkey': '(string $key_pair): string\nExtract the Ed25519 secret key from a keypair',
'sodium_crypto_sign_seed_keypair': '(string $seed): string\nDeterministically derive the key pair from a single key',
'sodium_crypto_sign_verify_detached': '(string $signature, string $message, string $public_key): bool\nVerify signature for the message',
'sodium_crypto_sign': '(string $message, string $secret_key): string\nSign a message',
'sodium_crypto_stream_keygen': '(): string\nGenerate a random sodium_crypto_stream key.',
'sodium_crypto_stream_xchacha20_keygen': '(): string\nReturns a secure random key',
'sodium_crypto_stream_xchacha20_xor_ic': '(string $message, string $nonce, int $counter, string $key): string\nEncrypts a message using a nonce and a secret key (no authentication)',
'sodium_crypto_stream_xchacha20_xor': '(string $message, string $nonce, string $key): string\nEncrypts a message using a nonce and a secret key (no authentication)',
'sodium_crypto_stream_xchacha20': '(int $length, string $nonce, string $key): string\nExpands the key and nonce into a keystream of pseudorandom bytes',
'sodium_crypto_stream_xor': '(string $message, string $nonce, string $key): string\nEncrypt a message without authentication',
'sodium_crypto_stream': '(int $length, string $nonce, string $key): string\nGenerate a deterministic sequence of bytes from a seed',
'sodium_hex2bin': '(string $string, string $ignore = ""): string\nDecodes a hexadecimally encoded binary string',
'sodium_increment': '(string &$string): void\nIncrement large number',
'sodium_memcmp': '(string $string1, string $string2): int\nTest for equality in constant-time',
'sodium_memzero': '(string &$string): void\nOverwrite a string with NUL characters',
'sodium_pad': '(string $string, int $block_size): string\nAdd padding data',
'sodium_unpad': '(string $string, int $block_size): string\nRemove padding data',
'ob_tidyhandler': '(string $input, int $mode = ?): string\nob_start callback function to repair the buffer',
'tidy_access_count': '(tidy $tidy): int\nReturns the Number of Tidy accessibility warnings encountered for specified document',
'tidy_config_count': '(tidy $tidy): int\nReturns the Number of Tidy configuration errors encountered for specified document',
'tidy_error_count': '(tidy $tidy): int\nReturns the Number of Tidy errors encountered for specified document',
'tidy_get_output': '(tidy $tidy): string\nReturn a string representing the parsed tidy markup',
'tidy_warning_count': '(tidy $tidy): int\nReturns the Number of Tidy warnings encountered for specified document',
'tidy_get_body': '(tidy $tidy): ?tidyNode\nReturns a tidyNode object starting from the tag of the tidy parse tree',
'tidy_clean_repair': '(tidy $tidy): bool\nExecute configured cleanup and repair operations on parsed markup',
'tidy_diagnose': '(tidy $tidy): bool\nRun configured diagnostics on parsed and repaired markup',
'tidy_get_error_buffer': '(tidy $tidy): string|false\nReturn warnings and errors which occurred parsing the specified document',
'tidy_get_config': '(tidy $tidy): array\nGet current Tidy configuration',
'tidy_get_html_ver': '(tidy $tidy): int\nGet the Detected HTML version for the specified document',
'tidy_getopt': '(tidy $tidy, string $option): string|int|bool\nReturns the value of the specified configuration option for the tidy document',
'tidy_get_opt_doc': '(tidy $tidy, string $option): string|false\nReturns the documentation for the given option name',
'tidy_get_release': '(): string\nGet release date (version) for Tidy library',
'tidy_get_status': '(tidy $tidy): int\nGet status of specified document',
'tidy_get_head': '(tidy $tidy): ?tidyNode\nReturns a tidyNode object starting from the tag of the tidy parse tree',
'tidy_get_html': '(tidy $tidy): ?tidyNode\nReturns a tidyNode object starting from the tag of the tidy parse tree',
'tidy_is_xhtml': '(tidy $tidy): bool\nIndicates if the document is a XHTML document',
'tidy_is_xml': '(tidy $tidy): bool\nIndicates if the document is a generic (non HTML/XHTML) XML document',
'tidy_parse_file': '(string $filename, array|string|null $config = null, ?string $encoding = null, bool $useIncludePath = false): tidy|false\nParse markup in file or URI',
'tidy_parse_string': '(string $string, array|string|null $config = null, ?string $encoding = null): tidy|false\nParse a document stored in a string',
'tidy::repairFile': '(string $filename, array|string|null $config = null, ?string $encoding = null, bool $useIncludePath = false): string|false\nRepair a file and return it as a string',
'tidy_repair_file': '(string $filename, array|string|null $config = null, ?string $encoding = null, bool $useIncludePath = false): string|false\nRepair a file and return it as a string',
'tidy::repairString': '(string $string, array|string|null $config = null, ?string $encoding = null): string|false\nRepair a string using an optionally provided configuration file',
'tidy_repair_string': '(string $string, array|string|null $config = null, ?string $encoding = null): string|false\nRepair a string using an optionally provided configuration file',
'tidy_get_root': '(tidy $tidy): ?tidyNode\nReturns a tidyNode object representing the root of the tidy parse tree',
'odbc_autocommit': '(Odbc\\Connection $odbc, ?bool $enable = null): int|bool\nToggle autocommit behaviour',
'odbc_binmode': '(Odbc\\Result $statement, int $mode): true\nHandling of binary column data',
'odbc_close_all': '(): void\nClose all ODBC connections',
'odbc_close': '(Odbc\\Connection $odbc): void\nClose an ODBC connection',
'odbc_columnprivileges': '(Odbc\\Connection $odbc, ?string $catalog, string $schema, string $table, string $column): Odbc\\Result|false\nLists columns and associated privileges for the given table',
'odbc_columns': '(Odbc\\Connection $odbc, ?string $catalog = null, ?string $schema = null, ?string $table = null, ?string $column = null): Odbc\\Result|false\nLists the column names in specified tables',
'odbc_commit': '(Odbc\\Connection $odbc): bool\nCommit an ODBC transaction',
'odbc_connect': '(string $dsn, ?string $user = null, ?string $password = null, int $cursor_option = SQL_CUR_USE_DRIVER): Odbc\\Connection|false\nConnect to a datasource',
'odbc_connection_string_is_quoted': '(string $str): bool\nDetermines if an ODBC connection string value is quoted',
'odbc_connection_string_quote': '(string $str): string\nQuotes an ODBC connection string value',
'odbc_connection_string_should_quote': '(string $str): bool\nDetermines if an ODBC connection string value should be quoted',
'odbc_cursor': '(Odbc\\Result $statement): string|false\nGet cursorname',
'odbc_data_source': '(Odbc\\Connection $odbc, int $fetch_type): array|null|false\nReturns information about available DSNs',
'odbc_do': 'Alias of odbc_exec',
'odbc_error': '(?Odbc\\Connection $odbc = null): string\nGet the last error code',
'odbc_errormsg': '(?Odbc\\Connection $odbc = null): string\nGet the last error message',
'odbc_exec': '(Odbc\\Connection $odbc, string $query): Odbc\\Result|false\nDirectly execute an SQL statement',
'odbc_execute': '(Odbc\\Result $statement, array $params = []): bool\nExecute a prepared statement',
'odbc_fetch_array': '(Odbc\\Result $statement, ?int $row = null): array|false\nFetch a result row as an associative array',
'odbc_fetch_into': '(Odbc\\Result $statement, array &$array, ?int $row = null): int|false\nFetch one result row into array',
'odbc_fetch_object': '(Odbc\\Result $statement, ?int $row = null): stdClass|false\nFetch a result row as an object',
'odbc_fetch_row': '(Odbc\\Result $statement, ?int $row = null): bool\nFetch a row',
'odbc_field_len': '(Odbc\\Result $statement, int $field): int|false\nGet the length (precision) of a field',
'odbc_field_name': '(Odbc\\Result $statement, int $field): string|false\nGet the columnname',
'odbc_field_num': '(Odbc\\Result $statement, string $field): int|false\nReturn column number',
'odbc_field_precision': 'Alias of odbc_field_len',
'odbc_field_scale': '(Odbc\\Result $statement, int $field): int|false\nGet the scale of a field',
'odbc_field_type': '(Odbc\\Result $statement, int $field): string|false\nDatatype of a field',
'odbc_foreignkeys': '(Odbc\\Connection $odbc, ?string $pk_catalog, string $pk_schema, string $pk_table, string $fk_catalog, string $fk_schema, string $fk_table): Odbc\\Result|false\nRetrieves a list of foreign keys',
'odbc_free_result': '(Odbc\\Result $statement): true\nFree objects associated with a result',
'odbc_gettypeinfo': '(Odbc\\Connection $odbc, int $data_type = ?): Odbc\\Result|false\nRetrieves information about data types supported by the data source',
'odbc_longreadlen': '(Odbc\\Result $statement, int $length): true\nHandling of LONG columns',
'odbc_next_result': '(Odbc\\Result $statement): bool\nChecks if multiple results are available',
'odbc_num_fields': '(Odbc\\Result $statement): int\nNumber of columns in a result',
'odbc_num_rows': '(Odbc\\Result $statement): int\nNumber of rows in a result',
'odbc_pconnect': '(string $dsn, ?string $user = null, ?string $password = null, int $cursor_option = SQL_CUR_USE_DRIVER): Odbc\\Connection|false\nOpen a persistent database connection',
'odbc_prepare': '(Odbc\\Connection $odbc, string $query): Odbc\\Result|false\nPrepares a statement for execution',
'odbc_primarykeys': '(Odbc\\Connection $odbc, ?string $catalog, string $schema, string $table): Odbc\\Result|false\nGets the primary keys for a table',
'odbc_procedurecolumns': '(Odbc\\Connection $odbc, ?string $catalog = null, ?string $schema = null, ?string $procedure = null, ?string $column = null): Odbc\\Result|false\nRetrieve information about parameters to procedures',
'odbc_procedures': '(Odbc\\Connection $odbc, ?string $catalog = null, ?string $schema = null, ?string $procedure = null): Odbc\\Result|false\nGet the list of procedures stored in a specific data source',
'odbc_result_all': '(Odbc\\Result $statement, string $format = ""): int|false\nPrint result as HTML table',
'odbc_result': '(Odbc\\Result $statement, string|int $field): string|bool|null\nGet result data',
'odbc_rollback': '(Odbc\\Connection $odbc): bool\nRollback a transaction',
'odbc_setoption': '(Odbc\\Connection|Odbc\\Result $odbc, int $which, int $option, int $value): bool\nAdjust ODBC settings',
'odbc_specialcolumns': '(Odbc\\Connection $odbc, int $type, ?string $catalog, string $schema, string $table, int $scope, int $nullable): Odbc\\Result|false\nRetrieves special columns',
'odbc_statistics': '(Odbc\\Connection $odbc, ?string $catalog, string $schema, string $table, int $unique, int $accuracy): Odbc\\Result|false\nRetrieve statistics about a table',
'odbc_tableprivileges': '(Odbc\\Connection $odbc, ?string $catalog, string $schema, string $table): Odbc\\Result|false\nLists tables and the privileges associated with each table',
'odbc_tables': '(Odbc\\Connection $odbc, ?string $catalog = null, ?string $schema = null, ?string $table = null, ?string $types = null): Odbc\\Result|false\nGet the list of table names stored in a specific data source',
'xml_error_string': '(int $error_code): ?string\nGet XML parser error string',
'xml_get_current_byte_index': '(XMLParser $parser): int\nGet current byte index for an XML parser',
'xml_get_current_column_number': '(XMLParser $parser): int\nGet current column number for an XML parser',
'xml_get_current_line_number': '(XMLParser $parser): int\nGet current line number for an XML parser',
'xml_get_error_code': '(XMLParser $parser): int\nGet XML parser error code',
'xml_parse_into_struct': '(XMLParser $parser, string $data, array &$values, array &$index = null): int|false\nParse XML data into an array structure',
'xml_parse': '(XMLParser $parser, string $data, bool $is_final = false): int\nStart parsing an XML document',
'xml_parser_create_ns': '(?string $encoding = null, string $separator = ":"): XMLParser\nCreate an XML parser with namespace support',
'xml_parser_create': '(?string $encoding = null): XMLParser\nCreate an XML parser',
'xml_parser_free': '(XMLParser $parser): bool\nFree an XML parser',
'xml_parser_get_option': '(XMLParser $parser, int $option): string|int|bool\nGet options from an XML parser',
'xml_parser_set_option': '(XMLParser $parser, int $option, string|int|bool $value): bool\nSet options in an XML parser',
'xml_set_character_data_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up character data handler',
'xml_set_default_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up default handler',
'xml_set_element_handler': '(XMLParser $parser, callable|string|null $start_handler, callable|string|null $end_handler): true\nSet up start and end element handlers',
'xml_set_end_namespace_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up end namespace declaration handler',
'xml_set_external_entity_ref_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up external entity reference handler',
'xml_set_notation_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up notation declaration handler',
'xml_set_object': '(XMLParser $parser, object $object): true\nUse XML Parser within an object',
'xml_set_processing_instruction_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up processing instruction (PI) handler',
'xml_set_start_namespace_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up start namespace declaration handler',
'xml_set_unparsed_entity_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up unparsed entity declaration handler',
'XMLReader::fromStream': '(resource $stream, ?string $encoding = null, int $flags = ?, ?string $documentUri = null): static\nCreates an XMLReader from a stream to read from',
'XMLReader::fromString': '(string $source, ?string $encoding = null, int $flags = ?): static\nCreates an XMLReader from an XML string',
'XMLReader::fromUri': '(string $uri, ?string $encoding = null, int $flags = ?): static\nCreates an XMLReader from a URI to read from',
'XMLReader::open': '(string $uri, ?string $encoding = null, int $flags = ?): XMLReader\nSet the URI containing the XML to parse',
'XMLReader::XML': '(string $source, ?string $encoding = null, int $flags = ?): XMLReader\nSet the data containing the XML to parse',
'xmlwriter_end_attribute': '(XMLWriter $writer): bool\nEnd attribute',
'xmlwriter_end_cdata': '(XMLWriter $writer): bool\nEnd current CDATA',
'xmlwriter_end_comment': '(XMLWriter $writer): bool\nCreate end comment',
'xmlwriter_end_document': '(XMLWriter $writer): bool\nEnd current document',
'xmlwriter_end_dtd': '(XMLWriter $writer): bool\nEnd current DTD',
'xmlwriter_end_dtd_attlist': '(XMLWriter $writer): bool\nEnd current DTD AttList',
'xmlwriter_end_dtd_element': '(XMLWriter $writer): bool\nEnd current DTD element',
'xmlwriter_end_dtd_entity': '(XMLWriter $writer): bool\nEnd current DTD Entity',
'xmlwriter_end_element': '(XMLWriter $writer): bool\nEnd current element',
'xmlwriter_end_pi': '(XMLWriter $writer): bool\nEnd current PI',
'xmlwriter_flush': '(XMLWriter $writer, bool $empty = true): string|int\nFlush current buffer',
'xmlwriter_full_end_element': '(XMLWriter $writer): bool\nEnd current element',
'xmlwriter_open_memory': '(): XMLWriter|false\nCreate new xmlwriter using memory for string output',
'xmlwriter_open_uri': '(string $uri): XMLWriter|false\nCreate new xmlwriter using source uri for output',
'xmlwriter_output_memory': '(XMLWriter $writer, bool $flush = true): string\nReturns current buffer',
'xmlwriter_set_indent': '(XMLWriter $writer, bool $enable): bool\nToggle indentation on/off',
'xmlwriter_set_indent_string': '(XMLWriter $writer, string $indentation): bool\nSet string used for indenting',
'xmlwriter_start_attribute': '(XMLWriter $writer, string $name): bool\nCreate start attribute',
'xmlwriter_start_attribute_ns': '(XMLWriter $writer, ?string $prefix, string $name, ?string $namespace): bool\nCreate start namespaced attribute',
'xmlwriter_start_cdata': '(XMLWriter $writer): bool\nCreate start CDATA tag',
'xmlwriter_start_comment': '(XMLWriter $writer): bool\nCreate start comment',
'xmlwriter_start_document': '(XMLWriter $writer, ?string $version = "1.0", ?string $encoding = null, ?string $standalone = null): bool\nCreate document tag',
'xmlwriter_start_dtd': '(XMLWriter $writer, string $qualifiedName, ?string $publicId = null, ?string $systemId = null): bool\nCreate start DTD tag',
'xmlwriter_start_dtd_attlist': '(XMLWriter $writer, string $name): bool\nCreate start DTD AttList',
'xmlwriter_start_dtd_element': '(XMLWriter $writer, string $qualifiedName): bool\nCreate start DTD element',
'xmlwriter_start_dtd_entity': '(XMLWriter $writer, string $name, bool $isParam): bool\nCreate start DTD Entity',
'xmlwriter_start_element': '(XMLWriter $writer, string $name): bool\nCreate start element tag',
'xmlwriter_start_element_ns': '(XMLWriter $writer, ?string $prefix, string $name, ?string $namespace): bool\nCreate start namespaced element tag',
'xmlwriter_start_pi': '(XMLWriter $writer, string $target): bool\nCreate start PI tag',
'xmlwriter_text': '(XMLWriter $writer, string $content): bool\nWrite text',
'XMLWriter::toMemory': '(): static\nCreate new XMLWriter using memory for string output',
'XMLWriter::toStream': '(resource $stream): static\nCreate new XMLWriter using a stream for output',
'XMLWriter::toUri': '(string $uri): static\nCreate new XMLWriter using a URI for output',
'xmlwriter_write_attribute': '(XMLWriter $writer, string $name, string $value): bool\nWrite full attribute',
'xmlwriter_write_attribute_ns': '(XMLWriter $writer, ?string $prefix, string $name, ?string $namespace, string $value): bool\nWrite full namespaced attribute',
'xmlwriter_write_cdata': '(XMLWriter $writer, string $content): bool\nWrite full CDATA tag',
'xmlwriter_write_comment': '(XMLWriter $writer, string $content): bool\nWrite full comment tag',
'xmlwriter_write_dtd': '(XMLWriter $writer, string $name, ?string $publicId = null, ?string $systemId = null, ?string $content = null): bool\nWrite full DTD tag',
'xmlwriter_write_dtd_attlist': '(XMLWriter $writer, string $name, string $content): bool\nWrite full DTD AttList tag',
'xmlwriter_write_dtd_element': '(XMLWriter $writer, string $name, string $content): bool\nWrite full DTD element tag',
'xmlwriter_write_dtd_entity': '(XMLWriter $writer, string $name, string $content, bool $isParam = false, ?string $publicId = null, ?string $systemId = null, ?string $notationData = null): bool\nWrite full DTD Entity tag',
'xmlwriter_write_element': '(XMLWriter $writer, string $name, ?string $content = null): bool\nWrite full element tag',
'xmlwriter_write_element_ns': '(XMLWriter $writer, ?string $prefix, string $name, ?string $namespace, ?string $content = null): bool\nWrite full namespaced element tag',
'xmlwriter_write_pi': '(XMLWriter $writer, string $target, string $content): bool\nWrites a PI',
'xmlwriter_write_raw': '(XMLWriter $writer, string $content): bool\nWrite a raw XML text',
'zip_close': '(resource $zip): void\nClose a ZIP file archive',
'zip_entry_close': '(resource $zip_entry): bool\nClose a directory entry',
'zip_entry_compressedsize': '(resource $zip_entry): int|false\nRetrieve the compressed size of a directory entry',
'zip_entry_compressionmethod': '(resource $zip_entry): string|false\nRetrieve the compression method of a directory entry',
'zip_entry_filesize': '(resource $zip_entry): int|false\nRetrieve the actual file size of a directory entry',
'zip_entry_name': '(resource $zip_entry): string|false\nRetrieve the name of a directory entry',
'zip_entry_open': '(resource $zip_dp, resource $zip_entry, string $mode = "rb"): bool\nOpen a directory entry for reading',
'zip_entry_read': '(resource $zip_entry, int $len = 1024): string|false\nRead from an open directory entry',
'zip_open': '(string $filename): resource|int|false\nOpen a ZIP file archive',
'zip_read': '(resource $zip): resource|false\nRead next entry in a ZIP file archive',
'ZipArchive::isCompressionMethodSupported': '(int $method, bool $enc = true): bool\nCheck if a compression method is supported by libzip',
'ZipArchive::isEncryptionMethodSupported': '(int $method, bool $enc = true): bool\nCheck if a encryption method is supported by libzip',
});
jush.api.php_fun = jush.api.lowercase_keys({
'__construct': '(mixed ...$values)\nObject constructor',
'__destruct': 'Object destructor',
'__call': '(string $name, array $arguments): mixed\nTriggered when invoking inaccessible methods in an object context',
'__callStatic': '(string $name, array $arguments): mixed\nTriggered when invoking inaccessible methods in a static context',
'__get': '(string $name): mixed\nUtilized for reading data from inaccessible properties',
'__set': '(string $name, mixed $value): void\nRun when writing data to inaccessible properties',
'__isset': '(string $name): bool\nTriggered by calling isset() or empty() on inaccessible properties',
'__unset': '(string $name): void\nInvoked when unset() is used on inaccessible properties',
'__sleep': '(): array\nCalled by serialize()',
'__wakeup': '(): void\nCalled by unserialize()',
'__serialize': '(): array\nCalled by serialize()',
'__unserialize': '(array $data): void\nCalled by unserialize()',
'__toString': '(): string\nDecide how to react when object is converted to a string',
'__invoke': '(mixed ...$values): mixed\nCalled when a script tries to call an object as a function',
'__set_state': '(array $properties): object\nCalled by var_export() result',
'__clone': '(): void\nCalled after cloning',
'__debugInfo': '(): array\nCalled by var_dump()',
'__autoload': '(string $class): void\nAttempt to load undefined class',
});
jush.api.php_new = jush.api.lowercase_keys({
'AllowDynamicProperties': 'Construct a new AllowDynamicProperties attribute instance',
'Attribute': '(int $flags = Attribute::TARGET_ALL)\nConstruct a new Attribute instance',
'Deprecated': '(?string $message = null, ?string $since = null)\nConstruct a new Deprecated attribute instance',
'NoDiscard': '(?string $message = null)\nConstruct a new NoDiscard attribute instance',
'Override': 'Construct a new Override attribute instance',
'Closure': 'Constructor that disallows instantiation',
'Error': '(string $message = "", int $code = ?, ?Throwable $previous = null)\nConstruct the error object',
'ErrorException': '(string $message = "", int $code = ?, int $severity = E_ERROR, ?string $filename = null, ?int $line = null, ?Throwable $previous = null)\nConstructs the exception',
'Exception': '(string $message = "", int $code = ?, ?Throwable $previous = null)\nConstruct the exception',
'Fiber': '(callable $callback)\nCreates a new Fiber instance',
'FiberError': 'Constructor to disallow direct instantiation',
'InternalIterator': 'Private constructor to disallow direct instantiation',
'ReturnTypeWillChange': 'Construct a new ReturnTypeWillChange attribute instance',
'SensitiveParameter': 'Construct a new SensitiveParameter attribute instance',
'SensitiveParameterValue': '(mixed $value)\nConstructs a new SensitiveParameterValue object',
'WeakReference': 'Constructor that disallows instantiation',
'ArgumentCountError': 'ArgumentCountError is thrown when too few arguments are passed to a user-defined function or method',
'ArithmeticError': 'ArithmeticError is thrown when an error occurs while performing mathematical operations',
'ArrayAccess': 'Interface to provide accessing objects as arrays',
'AssertionError': 'AssertionError is thrown when an assertion made via assert fails',
'BackedEnum': 'The BackedEnum interface is automatically applied to backed enumerations by the engine',
'ClosedGeneratorException': 'A ClosedGeneratorException is thrown when trying to retrieve a value from a closed Generator',
'CompileError': 'CompileError is thrown for some compilation errors, which formerly issued a fatal error',
'Countable': 'Classes implementing Countable can be used with the count function',
'DivisionByZeroError': 'DivisionByZeroError is thrown when an attempt is made to divide a number by zero',
'Generator': 'Generator objects are returned from generators',
'Iterator': 'Interface for external iterators or objects that can be iterated themselves internally',
'IteratorAggregate': 'Interface to create an external Iterator',
'ParseError': 'ParseError is thrown when an error occurs while parsing PHP code, such as when eval is called',
'__PHP_Incomplete_Class': 'Created by unserialize when trying to unserialize an undefined class or a class that is not listed in the allowed_classes of unserialize\'s $options array',
'RequestParseBodyException': 'A RequestParseBodyException is thrown in request_parse_body when the request body is invalid, according to the Content-Type header',
'Serializable': 'Interface for customized serializing',
'stdClass': 'A generic empty class with dynamic properties',
'Stringable': 'The Stringable interface denotes a class as having a __toString() method',
'Throwable': 'Throwable is the base interface for any object that can be thrown via a throw statement, including Error and Exception',
'Traversable': 'Abstract base interface that cannot be implemented alone',
'TypeError': 'A TypeError may be thrown when: The value being set for a class property does not match the property\'s corresponding declared type',
'UnhandledMatchError': 'An UnhandledMatchError is thrown when the subject passed to a match expression is not handled by any arm of the match expression',
'UnitEnum': 'The UnitEnum interface is automatically applied to all enumerations by the engine',
'ValueError': 'A ValueError is thrown when the type of an argument is correct but the value of it is incorrect',
'WeakMap': 'A WeakMap is map (or dictionary) that accepts objects as keys',
'DelayedTargetValidation': 'This attribute delays target validation errors for internal attributes from compile time to when the attribute is instantiated via the Reflection API',
'DateInterval': '(string $duration)\nCreates a new DateInterval object',
'DatePeriod': '(DateTimeInterface $start, DateInterval $interval, DateTimeInterface $end, int $options = ?)\nCreates a new DatePeriod object',
'DateTime': '(string $datetime = "now", ?DateTimeZone $timezone = null)\nReturns new DateTime object',
'DateError': 'Thrown when the timezone database is not found, or contains invalid data',
'DateException': 'Parent class of Date/Time exceptions, for issues that come to light due to user input, or free form text arguments that need to be parsed',
'DateInvalidOperationException': 'Thrown by DateTimeImmutable::sub and DateTime::sub when an unsupported operation is attempted',
'DateInvalidTimeZoneException': 'Thrown when an incorrect value is passed to DateTimeZone::__construct',
'DateMalformedIntervalStringException': 'Thrown when an invalid $duration argument is passed to DateInterval::__construct',
'DateMalformedPeriodStringException': 'Thrown when an invalid $isostr argument is passed to DatePeriod::__construct',
'DateMalformedStringException': 'Thrown when an invalid Date/Time string is detected',
'DateObjectError': 'Thrown when one of the Date/Time classes has not been correctly initialised',
'DateRangeError': 'Thrown by DateTime::getTimestamp, DateTimeImmutable::getTimestamp, and date_timestamp_get, on 32-bit platforms if the date object represents a date outside of the 32-bit signed range',
'DateTimeImmutable': 'Representation of date and time',
'DateTimeInterface': 'DateTimeInterface was created so that parameter, return, or property type declarations may accept either DateTimeImmutable or DateTime as a value',
'DateTimeZone': 'Representation of time zone',
'Directory': 'Instances of Directory are created by calling the dir function, not by the new operator',
'HashContext': 'Private constructor to disallow direct instantiation',
'JsonException': 'Exception thrown if JSON_THROW_ON_ERROR option is set for json_encode or json_decode',
'JsonSerializable': 'Objects implementing JsonSerializable can customize their JSON representation when encoded with json_encode',
'Random\\Engine\\Mt19937': '(?int $seed = null, int $mode = MT_RAND_MT19937)\nConstructs a new Mt19937 engine',
'Random\\Engine\\PcgOneseq128XslRr64': '(string|int|null $seed = null)\nConstructs a new PCG Oneseq 128 XSL RR 64 engine',
'Random\\Engine\\Xoshiro256StarStar': '(string|int|null $seed = null)\nConstructs a new xoshiro256** engine',
'Random\\Randomizer': '(?Random\\Engine $engine = null)\nConstructs a new Randomizer',
'Random\\BrokenRandomEngineError': 'Indicates that the used Random\\Engine is broken, e',
'Random\\CryptoSafeEngine': 'A marker interface indicating that the Random\\Engine returns cryptographically secure randomness',
'Random\\Engine\\Secure': 'Generates cryptographically secure randomness using the operating system’s CSPRNG',
'Random\\Engine': 'A Random\\Engine provides a low-level source of randomness by returning random bytes that are consumed by high-level APIs to perform their operations',
'Random\\RandomError': 'The base class for Errors that occur during generation or use of randomness',
'Random\\RandomException': 'The base class for Exceptions that occur during generation or use of randomness',
'ReflectionAttribute': 'Private constructor to disallow direct instantiation',
'ReflectionClass': '(object|string $objectOrClass)\nConstructs a ReflectionClass',
'ReflectionClassConstant': '(object|string $class, string $constant)\nConstructs a ReflectionClassConstant',
'ReflectionConstant': '(string $name)\nConstructs a ReflectionConstant',
'ReflectionEnum': '(object|string $objectOrClass)\nInstantiates a ReflectionEnum object',
'ReflectionEnumBackedCase': '(object|string $class, string $constant)\nInstantiates a ReflectionEnumBackedCase object',
'ReflectionEnumUnitCase': '(object|string $class, string $constant)\nInstantiates a ReflectionEnumUnitCase object',
'ReflectionExtension': '(string $name)\nConstructs a ReflectionExtension',
'ReflectionFiber': '(Fiber $fiber)\nConstructs a ReflectionFiber object',
'ReflectionFunction': '(Closure|string $function)\nConstructs a ReflectionFunction object',
'ReflectionGenerator': '(Generator $generator)\nConstructs a ReflectionGenerator object',
'ReflectionMethod': '(string $classMethod)\nConstructs a ReflectionMethod',
'ReflectionObject': '(object $object)\nConstructs a ReflectionObject',
'ReflectionParameter': '(string|array|object $function, int|string $param)\nConstruct',
'ReflectionProperty': '(object|string $class, string $property)\nConstruct a ReflectionProperty object',
'ReflectionReference': 'Private constructor to disallow direct instantiation',
'ReflectionZendExtension': '(string $name)\nConstructs a ReflectionZendExtension object',
'Reflection': 'The reflection class',
'ReflectionException': 'The ReflectionException class',
'ReflectionFunctionAbstract': 'A parent class to ReflectionFunction, read its description for details',
'ReflectionType': 'The ReflectionType class reports information about a function\'s parameter/return type or a class\'s property type',
'Reflector': 'Reflector is an interface implemented by all exportable Reflection classes',
'AppendIterator': 'Constructs an AppendIterator',
'ArrayIterator': '(array|object $array = [], int $flags = ?)\nConstruct an ArrayIterator',
'ArrayObject': '(array|object $array = [], int $flags = ?, string $iteratorClass = ArrayIterator::class)\nConstruct a new array object',
'CachingIterator': '(Iterator $iterator, int $flags = CachingIterator::CALL_TOSTRING)\nConstruct a new CachingIterator object for the iterator',
'CallbackFilterIterator': '(Iterator $iterator, callable $callback)\nCreate a filtered iterator from another iterator',
'DirectoryIterator': '(string $directory)\nConstructs a new directory iterator from a path',
'FilesystemIterator': '(string $directory, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO | FilesystemIterator::SKIP_DOTS)\nConstructs a new filesystem iterator',
'FilterIterator': '(Iterator $iterator)\nConstruct a filterIterator',
'GlobIterator': '(string $pattern, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO)\nConstruct a directory using glob',
'InfiniteIterator': '(Iterator $iterator)\nConstructs an InfiniteIterator',
'IteratorIterator': '(Traversable $iterator, ?string $class = null)\nCreate an iterator from anything that is traversable',
'LimitIterator': '(Iterator $iterator, int $offset = ?, int $limit = -1)\nConstruct a LimitIterator',
'MultipleIterator': '(int $flags = MultipleIterator::MIT_NEED_ALL | MultipleIterator::MIT_KEYS_NUMERIC)\nConstructs a new MultipleIterator',
'NoRewindIterator': '(Iterator $iterator)\nConstruct a NoRewindIterator',
'ParentIterator': '(RecursiveIterator $iterator)\nConstructs a ParentIterator',
'RecursiveCachingIterator': '(Iterator $iterator, int $flags = RecursiveCachingIterator::CALL_TOSTRING)\nConstruct',
'RecursiveCallbackFilterIterator': '(RecursiveIterator $iterator, callable $callback)\nCreate a RecursiveCallbackFilterIterator from a RecursiveIterator',
'RecursiveDirectoryIterator': '(string $directory, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO)\nConstructs a RecursiveDirectoryIterator',
'RecursiveFilterIterator': '(RecursiveIterator $iterator)\nCreate a RecursiveFilterIterator from a RecursiveIterator',
'RecursiveIteratorIterator': '(Traversable $iterator, int $mode = RecursiveIteratorIterator::LEAVES_ONLY, int $flags = ?)\nConstruct a RecursiveIteratorIterator',
'RecursiveRegexIterator': '(RecursiveIterator $iterator, string $pattern, int $mode = RecursiveRegexIterator::MATCH, int $flags = ?, int $pregFlags = ?)\nCreates a new RecursiveRegexIterator',
'RecursiveTreeIterator': '(RecursiveIterator|IteratorAggregate $iterator, int $flags = RecursiveTreeIterator::BYPASS_KEY, int $cachingIteratorFlags = CachingIterator::CATCH_GET_CHILD, int $mode = RecursiveTreeIterator::SELF_FIRST)\nConstruct a RecursiveTreeIterator',
'RegexIterator': '(Iterator $iterator, string $pattern, int $mode = RegexIterator::MATCH, int $flags = ?, int $pregFlags = ?)\nCreate a new RegexIterator',
'SplFileInfo': '(string $filename)\nConstruct a new SplFileInfo object',
'SplFileObject': '(string $filename, string $mode = "r", bool $useIncludePath = false, ?resource $context = null)\nConstruct a new file object',
'SplFixedArray': '(int $size = ?)\nConstructs a new fixed array',
'SplTempFileObject': '(int $maxMemory = 2 * 1024 * 1024)\nConstruct a new temporary file object',
'BadFunctionCallException': 'Exception thrown if a callback refers to an undefined function or if some arguments are missing',
'BadMethodCallException': 'Exception thrown if a callback refers to an undefined method or if some arguments are missing',
'DomainException': 'Exception thrown if a value does not adhere to a defined valid data domain',
'EmptyIterator': 'The EmptyIterator class for an empty iterator',
'InvalidArgumentException': 'Exception thrown if an argument is not of the expected type',
'LengthException': 'Exception thrown if a length is invalid',
'LogicException': 'Exception that represents error in the program logic',
'OuterIterator': 'Classes implementing OuterIterator can be used to iterate over iterators',
'OutOfBoundsException': 'Exception thrown if a value is not a valid key',
'OutOfRangeException': 'Exception thrown when an illegal index was requested',
'OverflowException': 'Exception thrown when adding an element to a full container',
'RangeException': 'Exception thrown to indicate range errors during program execution',
'RecursiveArrayIterator': 'This iterator allows for unsetting and modifying values and keys while iterating over arrays and objects, in the same way as the ArrayIterator',
'RecursiveIterator': 'Classes implementing RecursiveIterator can be used to iterate over iterators recursively',
'RuntimeException': 'Exception thrown if an error which can only be found on runtime occurs',
'SeekableIterator': 'The Seekable iterator',
'SplDoublyLinkedList': 'The SplDoublyLinkedList class provides the main functionalities of a doubly linked list',
'SplHeap': 'The SplHeap class provides the main functionalities of a Heap',
'SplMaxHeap': 'The SplMaxHeap class provides the main functionalities of a heap, keeping the maximum on the top',
'SplMinHeap': 'The SplMinHeap class provides the main functionalities of a heap, keeping the minimum on the top',
'SplObjectStorage': 'The SplObjectStorage class provides a map from objects to data or, by ignoring data, an object set',
'SplObserver': 'The SplObserver interface is used alongside SplSubject to implement the Observer Design Pattern',
'SplPriorityQueue': 'The SplPriorityQueue class provides the main functionalities of a prioritized queue, implemented using a max heap',
'SplQueue': 'The SplQueue class provides the main functionalities of a queue implemented using a doubly linked list by setting the iterator mode to SplDoublyLinkedList::IT_MODE_FIFO',
'SplStack': 'The SplStack class provides the main functionalities of a stack implemented using a doubly linked list by setting the iterator mode to SplDoublyLinkedList::IT_MODE_LIFO',
'SplSubject': 'The SplSubject interface is used alongside SplObserver to implement the Observer Design Pattern',
'UnderflowException': 'Exception thrown when performing an invalid operation on an empty container, such as removing an element',
'UnexpectedValueException': 'Exception thrown if a value does not match with a set of values',
'streamWrapper': 'Constructs a new stream wrapper',
'php_user_filter': 'Children of this class are passed to stream_filter_register',
'StreamBucket': 'A stream bucket is a chunk of a stream which can be extracted from bucket brigades',
'Uri\\Rfc3986\\Uri': '(string $uri, ?Uri\\Rfc3986\\Uri $baseUrl = null)\nConstruct the Uri object',
'Uri\\WhatWg\\InvalidUrlException': '(string $message = "", array $errors = [], int $code = ?, ?Throwable $previous = null)\nConstruct an InvalidUrlException object',
'Uri\\WhatWg\\Url': '(string $uri, ?Uri\\WhatWg\\Url $baseUrl = null, array &$softErrors = null)\nConstruct the Url object',
'Uri\\WhatWg\\UrlValidationError': '(string $context, Uri\\WhatWg\\UrlValidationErrorType $type, bool $failure)\nConstruct a UrlValidationError object',
'Uri\\InvalidUriException': 'Indicates that a given URI is invalid or that an operation would result in an invalid URI',
'Uri\\UriError': 'The base class for Errors that occur during processing of URIs',
'Uri\\UriException': 'The base class for Exceptions that occur during processing of URIs',
'BcMath\\Number': '(string|int $num)\nCreates a BcMath\\Number object',
'com': '(string $module_name, array|string|null $server_name = null, int $codepage = CP_ACP, string $typelib = "")\ncom class constructor',
'COMPersistHelper': '(?variant $variant = null)\nConstruct a COMPersistHelper object',
'dotnet': '(string $assembly_name, string $datatype_name, int $codepage = CP_ACP)\ndotnet class constructor',
'variant': '(mixed $value = null, int $type = VT_EMPTY, int $codepage = CP_ACP)\nvariant class constructor',
'com_safearray_proxy': 'com_safearray_proxy is an internal class used for resolving multi-dimensional array accesses on SafeArray types',
'Dba\\Connection': 'A fully opaque class which replaces a dba resource as of PHP 8',
'FFI': 'Objects of this class are created by the factory methods FFI::cdef, FFI::load or FFI::scope',
'FFI\\CData': 'FFI\\CData objects can be used in a number of ways as a regular PHP data: C data of scalar types can be read and assigned via the $cdata property, e',
'finfo': '(int $flags = FILEINFO_NONE, ?string $magic_database = null)\nAlias finfo_open',
'Filter\\FilterException': 'The base class for Exceptions thrown by the Filter extension',
'Filter\\FilterFailedException': 'Thrown when a validation filter fails and the FILTER_THROW_ON_FAILURE flag is set',
'FTP\\Connection': 'A fully opaque class which replaces a ftp resource as of PHP 8',
'GdFont': 'A fully opaque class which replaces gd font resources as of PHP 8',
'GdImage': 'A fully opaque class which replaces gd resources as of PHP 8',
'Collator': '(string $locale)\nCreate a collator',
'IntlBreakIterator': 'Private constructor for disallowing instantiation',
'IntlCalendar': 'Private constructor for disallowing instantiation',
'IntlGregorianCalendar': '(int $timeZoneOrYear, int $localeOrMonth, int $dayOfMonth, int $hour, int $minute, int $second = ?)\nCreate the Gregorian Calendar class',
'IntlRuleBasedBreakIterator': '(string $rules, bool $compiled = false)\nCreate iterator from ruleset',
'IntlTimeZone': 'Private constructor to disallow direct instantiation',
'Spoofchecker': 'Constructor',
'Transliterator': 'Private constructor to deny instantiation',
'UConverter': '(?string $destination_encoding = null, ?string $source_encoding = null)\nCreate UConverter object',
'IntlDateFormatter': 'Date Formatter is a concrete class that enables locale-dependent formatting/parsing of dates using pattern strings and/or canned patterns',
'IntlChar': 'IntlChar provides access to a number of utility methods that can be used to access information about Unicode characters',
'IntlCodePointBreakIterator': 'This break iterator identifies the boundaries between UTF-8 code points',
'IntlDatePatternGenerator': 'Generates localized date and/or time format pattern strings suitable for use in IntlDateFormatter',
'IntlException': 'This class is used for generating exceptions when errors occur inside intl functions',
'IntlIterator': 'This class represents iterator objects throughout the intl extension whenever the iterator cannot be identified with any other object provided by the extension',
'IntlPartsIterator': 'Objects of this class can be obtained from IntlBreakIterator objects',
'Locale': 'Examples of identifiers include: en-US (English, United States) zh-Hant-TW (Chinese, Traditional Script, Taiwan) fr-CA, fr-FR (French for Canada and France respectively)',
'MessageFormatter': 'MessageFormatter is a concrete class that enables users to produce concatenated, language-neutral messages',
'Normalizer': 'The Unicode Consortium has defined a number of normalization forms reflecting the various needs of applications: Normalization Form D (NFD) - Canonical Decomposition Normalization Form C (NFC) - Canonical Decomposition followed by Canonical Composition Normalization Form KD (NFKD) - Compatibility Decomposition Normalization Form KC (NFKC) - Compatibility Decomposition followed by Canonical Composition The different forms are defined in terms of a set of transformations on the text, transformations that are expressed by both an algorithm and a set of data files',
'NumberFormatter': 'For currencies you can use currency format type to create a formatter that returns a string with the formatted number and the appropriate currency sign',
'ResourceBundle': 'Localized software products often require sets of data that are to be customized depending on current locale, e',
'PDO': '(string $dsn, ?string $username = null, ?string $password = null, ?array $options = null)\nCreates a PDO instance representing a connection to a database',
'PDOException': 'Represents an error raised by PDO',
'PDORow': 'Represents a row from a result set returned by PDOStatement::fetch called with PDO::FETCH_LAZY fetch mode',
'PDOStatement': 'Represents a prepared statement and, after the statement is executed, an associated result set',
'Phar': '(string $filename, int $flags = FilesystemIterator::SKIP_DOTS | FilesystemIterator::UNIX_PATHS, ?string $alias = null)\nConstruct a Phar archive object',
'PharData': '(string $filename, int $flags = FilesystemIterator::SKIP_DOTS | FilesystemIterator::UNIX_PATHS, ?string $alias = null, int $format = ?)\nConstruct a non-executable tar or zip archive object',
'PharFileInfo': '(string $filename)\nConstruct a Phar entry object',
'PharException': 'The PharException class provides a phar-specific exception class for try/catch blocks',
'SysvMessageQueue': 'A fully opaque class which replaces a sysvmsg queue resource as of PHP 8',
'SysvSemaphore': 'A fully opaque class which replaces a sysvsem resource as of PHP 8',
'SysvSharedMemory': 'A fully opaque class which replaces a sysvshm resource as of PHP 8',
'SessionHandler': 'SessionHandler is a special class that can be used to expose the current internal PHP session save handler by inheritance',
'SessionHandlerInterface': 'SessionHandlerInterface is an interface which defines the minimal prototype for creating a custom session handler',
'SessionIdInterface': 'SessionIdInterface is an interface which defines optional methods for creating a custom session handler',
'SessionUpdateTimestampHandlerInterface': 'SessionUpdateTimestampHandlerInterface is an interface which defines optional methods for creating a custom session handler',
'Shmop': 'A fully opaque class which replaces shmop resources as of PHP 8',
'AddressInfo': 'A fully opaque class which replaces AddressInfo resources as of PHP 8',
'Socket': 'A fully opaque class which replaces Socket resources as of PHP 8',
'SQLite3': '(string $filename, int $flags = SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, string $encryptionKey = "")\nInstantiates an SQLite3 object and opens an SQLite 3 database',
'SQLite3Result': 'Constructs an SQLite3Result',
'SQLite3Stmt': '(SQLite3 $sqlite3, string $query)\nConstructs an SQLite3Stmt object',
'SQLite3Exception': 'Represents a SQLite3 specific exception',
'PhpToken': '(int $id, string $text, int $line = -1, int $pos = -1)\nReturns a new PhpToken object',
'DeflateContext': 'A fully opaque class which replaces zlib',
'InflateContext': 'A fully opaque class which replaces zlib',
'CURLStringFile': '(string $data, string $postname, string $mime = "application/octet-stream")\nCreate a CURLStringFile object',
'CURLFile': 'This class or CURLStringFile should be used to upload a file with CURLOPT_POSTFIELDS',
'CurlHandle': 'A fully opaque class which replaces curl resources as of PHP 8',
'CurlMultiHandle': 'A fully opaque class which replaces curl_multi resources as of PHP 8',
'CurlShareHandle': 'A fully opaque class which replaces curl_share resources as of PHP 8',
'CurlSharePersistentHandle': 'Represents a persistent cURL "share" handle',
'DOMAttr': '(string $name, string $value = "")\nCreates a new DOMAttr object',
'DOMCdataSection': '(string $data)\nConstructs a new DOMCdataSection object',
'DOMComment': '(string $data = "")\nCreates a new DOMComment object',
'DOMDocument': '(string $version = "1.0", string $encoding = "")\nCreates a new DOMDocument object',
'DOMDocumentFragment': 'Constructs a DOMDocumentFragment object',
'DOMElement': '(string $qualifiedName, ?string $value = null, string $namespace = "")\nCreates a new DOMElement object',
'DOMEntityReference': '(string $name)\nCreates a new DOMEntityReference object',
'DOMImplementation': 'Creates a new DOMImplementation object',
'DOMProcessingInstruction': '(string $name, string $value = "")\nCreates a new DOMProcessingInstruction object',
'DOMText': '(string $data = "")\nCreates a new DOMText object',
'DOMXPath': '(DOMDocument $document, bool $registerNodeNS = true)\nCreates a new DOMXPath object',
'DOMCharacterData': 'Represents nodes with character data',
'DOMDocumentType': 'Each DOMDocument has a doctype attribute whose value is either null or a DOMDocumentType object',
'DOMEntity': 'This interface represents a known entity, either parsed or unparsed, in an XML document',
'DOMException': 'See also',
'DOMNodeList': 'Represents a live list of nodes',
'Dom\\Attr': 'Dom\\Attr represents an attribute in the Dom\\Element object',
'Dom\\CDATASection': 'The Dom\\CDATASection class inherits from Dom\\Text for textual representation of CData constructs',
'Dom\\CharacterData': 'This is the modern, spec-compliant equivalent of DOMCharacterData',
'Dom\\ChildNode': 'This is the modern, spec-compliant equivalent of DOMChildNode',
'Dom\\Comment': 'This is the modern, spec-compliant equivalent of DOMComment',
'Dom\\Document': 'This is the modern, spec-compliant equivalent of DOMDocument',
'Dom\\DocumentFragment': 'This represents a document fragment, which can be used as a container for other nodes',
'Dom\\DocumentType': 'Each Dom\\Document has a doctype attribute whose value is either null or a Dom\\DocumentType object',
'Dom\\DtdNamedNodeMap': 'Represents a named node map for entities and notation nodes of the DTD',
'Dom\\Element': 'Represents an element',
'Dom\\Entity': 'This is the modern, spec-compliant equivalent of DOMEntity',
'Dom\\EntityReference': 'This is the modern, spec-compliant equivalent of DOMEntityReference',
'Dom\\HTMLCollection': 'Represents a static set of elements',
'Dom\\HTMLDocument': 'Represents an HTML document',
'Dom\\HTMLElement': 'Represents an element in the HTML namespace',
'Dom\\NamedNodeMap': 'Represents the set of attributes on an element',
'Dom\\NamespaceInfo': 'This represents immutable information about namespaces of an element',
'Dom\\Node': 'This is the modern, spec-compliant equivalent of DOMNode',
'Dom\\NodeList': 'This is the modern, spec-compliant equivalent of DOMNodeList',
'Dom\\ParentNode': 'This is the modern, spec-compliant equivalent of DOMParentNode',
'Dom\\ProcessingInstruction': 'This is the modern, spec-compliant equivalent of DOMProcessingInstruction',
'Dom\\Text': 'The Dom\\Text class inherits from Dom\\CharacterData and represents a text node',
'Dom\\TokenList': 'Represents a set of tokens in an attribute (e',
'Dom\\XMLDocument': 'Represents an XML document',
'Dom\\XPath': 'This is the modern, spec-compliant equivalent of DOMXPath',
'EnchantBroker': 'A fully opaque class which replaces enchant_broker resources as of PHP 8',
'EnchantDictionary': 'A fully opaque class which replaces enchant_dict resources as of PHP 8',
'GMP': '(int|string $num = ?, int $base = ?)\nCreate GMP number',
'LDAP\\Connection': 'A fully opaque class which replaces a ldap resource as of PHP 8',
'LDAP\\Result': 'A fully opaque class which replaces a ldap result resource as of PHP 8',
'LDAP\\ResultEntry': 'A fully opaque class which replaces a ldap result entry resource as of PHP 8',
'LibXMLError': 'Contains various information about errors thrown by libxml',
'mysqli_result': '(mysqli $mysql, int $result_mode = MYSQLI_STORE_RESULT)\nConstructs a mysqli_result object',
'mysqli_stmt': '(mysqli $mysql, ?string $query = null)\nConstructs a new mysqli_stmt object',
'mysqli_warning': 'Private constructor to disallow direct instantiation',
'mysqli': 'Represents a connection between PHP and a MySQL database',
'mysqli_driver': 'The mysqli_driver class is an instance of the monostate pattern, i',
'mysqli_sql_exception': 'The mysqli exception handling class',
'OpenSSLAsymmetricKey': 'A fully opaque class which replaces OpenSSL key resources as of PHP 8',
'OpenSSLCertificate': 'A fully opaque class which replaces OpenSSL X',
'OpenSSLCertificateSigningRequest': 'A fully opaque class which replaces OpenSSL X',
'Pdo\\Dblib': 'A PDO subclass representing a connection using the DBLib PDO driver',
'Pdo\\Firebird': 'A PDO subclass representing a connection using the Firebird PDO driver',
'Pdo\\Mysql': 'This driver supports a dedicated SQL query parser for the MySQL dialect',
'Pdo\\Odbc': 'A PDO subclass representing a connection using the ODBC PDO driver',
'Pdo\\Pgsql': 'This driver supports a dedicated SQL query parser for the PostgreSQL dialect',
'Pdo\\Sqlite': 'This driver supports a dedicated SQL query parser for the SQLite dialect',
'PgSql\\Connection': 'A fully opaque class which replaces a pgsql link resource as of PHP 8',
'PgSql\\Lob': 'A fully opaque class which replaces a pgsql large object resource as of PHP 8',
'PgSql\\Result': 'A fully opaque class which replaces a pgsql result resource as of PHP 8',
'SimpleXMLElement': '(string $data, int $options = ?, bool $dataIsURL = false, string $namespaceOrPrefix = "", bool $isPrefix = false)\nCreates a new SimpleXMLElement object',
'SimpleXMLIterator': 'The SimpleXMLIterator provides recursive iteration over all nodes of a SimpleXMLElement object',
'SNMP': '(int $version, string $hostname, string $community, int $timeout = -1, int $retries = -1)\nCreates SNMP instance representing session to remote SNMP agent',
'SNMPException': 'Represents an error raised by SNMP',
'SoapClient': '(?string $wsdl, array $options = [])\nSoapClient constructor',
'SoapFault': '(array|string|null $code, string $string, ?string $actor = null, mixed $details = null, ?string $name = null, mixed $headerFault = null, string $lang = "")\nSoapFault constructor',
'SoapHeader': '(string $namespace, string $name, mixed $data = ?, bool $mustunderstand = ?, string $actor = ?)\nSoapHeader constructor',
'SoapParam': '(mixed $data, string $name)\nSoapParam constructor',
'SoapServer': '(?string $wsdl, array $options = [])\nSoapServer constructor',
'SoapVar': '(mixed $data, ?int $encoding, ?string $typeName = null, ?string $typeNamespace = null, ?string $nodeName = null, ?string $nodeNamespace = null)\nSoapVar constructor',
'Soap\\Sdl': 'A fully opaque class which replaces a soap_sdl resource as of PHP 8',
'Soap\\Url': 'A fully opaque class which replaces a soap_url resource as of PHP 8',
'SodiumException': 'Exceptions thrown by the sodium functions',
'tidy': '(?string $filename = null, array|string|null $config = null, ?string $encoding = null, bool $useIncludePath = false)\nConstructs a new tidy object',
'tidyNode': 'Private constructor to disallow direct instantiation',
'Odbc\\Connection': 'A fully opaque class which replaces an odbc_connection resource as of PHP 8',
'Odbc\\Result': 'A fully opaque class which replaces an odbc_result resource as of PHP 8',
'XMLParser': 'A fully opaque class which replaces xml resources as of PHP 8',
'XMLReader': 'The XMLReader extension is an XML Pull parser',
'XSLTProcessor': 'Creates a new XSLTProcessor object',
'ZipArchive': 'A file archive, compressed with Zip',
});
vrana-jush-d490483/jush-dark.css 0000664 0000000 0000000 00000000560 15237625165 0016470 0 ustar 00root root 0000000 0000000 .jush {
--text-color: #ccc;
--bg-color: #111;
--border-color: #555;
--php-color: #cc9;
--string-color: #e6e;
--string-plain-color: #e6e;
--keyword-color: #acf;
--identifier-color: #f88;
--value-color: #e6e;
--number-color: #0c0;
--attribute-color: #3cc;
--js-bg-color: #036;
--css-bg-color: #404000;
--php-bg-color: #520;
--php-sql-bg-color: #404000;
}
vrana-jush-d490483/jush-help.js 0000664 0000000 0000000 00000005645 15237625165 0016334 0 ustar 00root root 0000000 0000000 /** JUSH help - open URL with help on specified position in file
* @link https://jush.sourceforge.io/
* @author Jakub Vrana, https://www.vrana.cz
* @license https://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
*/
/* SciTE:
file.patterns.jush=*.htm;*.html;*.php;*.sql;*.js;*.css;php.ini;*.conf;.htaccess;my.ini
command.1.$(file.patterns.jush)=node jush-help.js "$(FilePath)" $(SelectionStartLine) $(SelectionStartColumn) $(tabsize) "$(CurrentWord)"
command.name.1.$(file.patterns.jush)=JUSH help
command.quiet.1.$(file.patterns.jush)=1
command.save.before.1.$(file.patterns.jush)=1
*/
const fs = require('fs');
const path = require('path');
const { spawn } = require('child_process');
function loadJush() {
const dir = path.join(__dirname, 'modules');
const files = fs.readdirSync(dir).sort().filter(file => (/^jush-(?!textarea|autocomplete-.+).+\.js$/.test(file)));
const code = ['jush.js'].concat(files)
.map(file => fs.readFileSync(path.join(dir, file), 'utf8'))
.join('\n');
return new Function(code + '\nreturn jush;')();
}
function openUrl(url) {
const options = { detached: true, stdio: 'ignore', windowsHide: true };
let child;
if (process.platform == 'win32') {
child = spawn('cmd', ['/c', 'start', '""', '"' + url + '"'], Object.assign({ windowsVerbatimArguments: true }, options));
} else if (process.platform == 'darwin') {
child = spawn('open', [url], options);
} else {
child = spawn('xdg-open', [url], options);
}
child.unref();
}
const args = process.argv.slice(2);
if (args.length < 3) {
console.error('Usage: node jush-help.js filename line column [tabsize] [word]\nPurpose: Open URL with help on specified position in file');
process.exit(1);
}
const filename = args[0];
const line = +args[1];
const column = +args[2];
const basename = path.basename(filename);
let lang = 'htm';
const extension = /\.(js|sql|xml|css)$/.exec(basename);
if (extension) {
lang = extension[1];
} else if (basename == 'php.ini') {
lang = 'phpini';
} else if (basename == 'my.ini') {
lang = 'sqlset';
} else if (/\.conf$/.test(basename) || basename == '.htaccess') {
lang = 'cnf';
}
const file = fs.readFileSync(filename, 'utf8').replace(/\r/g, '').split('\n').slice(0, line).join('\n'); // highlight only first lines of file (performance)
let s = loadJush().highlight(lang, file).split('\n').pop(); // get last line of output
if (args.length > 3) {
s = s.replace(/\t/g, ' '.repeat(+args[3]));
}
s = s.replace(/&[^;]+;/g, '&');
let href = '';
let pos = 1;
let match;
const re = /|(<\/a>)|<[^>]+>|([^<]+)/g;
while ((match = re.exec(s))) {
if (match[1]) {
href = match[1];
} else if (match[2]) {
if (pos == column) { // last character of link
break;
}
href = '';
} else if (match[3]) {
pos += match[3].length;
if (pos > column) {
break;
}
}
}
openUrl(href ? href : 'https://www.google.com/search?q=' + encodeURIComponent(args.length > 4 ? args[4] : (match ? match[3] : '')));
vrana-jush-d490483/jush.css 0000664 0000000 0000000 00000006166 15237625165 0015561 0 ustar 00root root 0000000 0000000 .jush {
--text-color: #000;
--bg-color: #fff;
--border-color: #ccc;
--php-color: #003;
--string-color: green;
--string-plain-color: #009F00;
--keyword-color: navy;
--identifier-color: red;
--value-color: purple;
--number-color: #007F7F;
--attribute-color: teal;
--js-bg-color: #f0f0ff;
--css-bg-color: #ffffe0;
--php-bg-color: #fff0f0;
--php-sql-bg-color: #ffbbb0;
}
.jush { color: var(--text-color); white-space: pre; }
[contenteditable].jush { border: 1px solid var(--border-color); } /* the editable created by jush.textarea() */
.jush-htm_com, .jush-com, .jush-com_code, .jush-one, .jush-php_doc, .jush-php_com, .jush-php_one, .jush-js_one, .jush-js_doc { color: gray; }
.jush-php, .jush-php_new, .jush-php_fun { color: var(--php-color); background-color: var(--php-bg-color); }
.jush-php_quo, .jush-php_eot, .jush-js_bac { color: var(--string-color); }
.jush-php_apo, .jush-quo, .jush-quo_one, .jush-apo, .jush-sql_apo, .jush-sqlite_apo, .jush-sql_quo, .jush-sql_eot { color: var(--string-plain-color); }
.jush-php_quo_var, .jush-php_var, .jush-sql_var, .jush-js_bac .jush-js { font-style: italic; }
.jush-php_apo .jush-php_quo_var, .jush-php_apo .jush-php_var { font-style: normal; }
.jush-php_halt2 { background-color: var(--bg-color); color: var(--text-color); }
.jush-tag_css, .jush-att_css .jush-att_quo, .jush-att_css .jush-att_apo, .jush-att_css .jush-att_val { color: var(--text-color); background-color: var(--css-bg-color); }
.jush-tag_js, .jush-att_js .jush-att_quo, .jush-att_js .jush-att_apo, .jush-att_js .jush-att_val, .jush-css_js { color: var(--text-color); background-color: var(--js-bg-color); }
.jush-tag, .jush-xml_tag { color: var(--keyword-color); }
.jush-att, .jush-xml_att, .jush-att_js, .jush-att_css, .jush-att_http { color: var(--attribute-color); }
.jush-att_quo, .jush-att_apo, .jush-att_val { color: var(--value-color); }
.jush-ent { color: var(--value-color); }
.jush-js_key, .jush-js_key .jush-quo, .jush-js_key .jush-apo, .jush-json_key, .jush-json_key .jush-quo { color: var(--value-color); }
.jush-js_reg { color: var(--keyword-color); }
.jush-php_sql .jush-php_quo, .jush-php_sql .jush-php_apo,
.jush-php_sqlite .jush-php_quo, .jush-php_sqlite .jush-php_apo,
.jush-php_pgsql .jush-php_quo, .jush-php_pgsql .jush-php_apo,
.jush-php_mssql .jush-php_quo, .jush-php_mssql .jush-php_apo,
.jush-php_oracle .jush-php_quo, .jush-php_oracle .jush-php_apo { background-color: var(--php-sql-bg-color); }
.jush-bac, .jush-php_bac, .jush-bra, .jush-mssql_bra, .jush-sqlite_quo { color: var(--identifier-color); }
.jush-num, .jush-clr { color: var(--number-color); }
.jush a { color: var(--keyword-color); }
.jush a.jush-help { cursor: help; }
.jush-sql a, .jush-sql_code a, .jush-sqlite a, .jush-pgsql a, .jush-mssql a, .jush-oracle a, .jush-simpledb a, .jush-igdb a, .jush-redis a, .jush-elastic a { font-weight: bold; }
.jush-php_sql .jush-php_quo a, .jush-php_sql .jush-php_apo a { font-weight: normal; }
.jush-tag a, .jush-att a, .jush-apo a, .jush-quo a, .jush-php_apo a, .jush-php_quo a, .jush-php_eot2 a { color: inherit; }
a.jush-custom:link, a.jush-custom:visited { font-weight: normal; color: inherit; }
.jush p { margin: 0; }
vrana-jush-d490483/modules/ 0000775 0000000 0000000 00000000000 15237625165 0015535 5 ustar 00root root 0000000 0000000 vrana-jush-d490483/modules/jush-autocomplete-sql.js 0000664 0000000 0000000 00000015753 15237625165 0022353 0 ustar 00root root 0000000 0000000 /** Get callback for autocompletition
* @param {string} esc escaped empty identifier, e.g. `` for MySQL or [] for MS SQL
* @param {Object>} tablesColumns keys are table names, values are lists of columns
* @param {Array} [statements] statements offered at the beginning of a query, all by default
* @return {Function} see autocomplete()
*/
jush.autocompleteSql = function (esc, tablesColumns, statements) {
const mysql = (esc == '``'); // the escaping is the only hint about the database
/**
* key: regular expression; ' ' will be expanded to '\\s+', '\\w' to esc[0]+'?\\w'+esc[1]+'?', '$' will be appended
* value: list of autocomplete words; '?' means to not use the word if it's already in the current query
*/
const keywordsDefault = {
'^': statements || ['SELECT', 'INSERT INTO', 'UPDATE', 'DELETE FROM', 'TRUNCATE', 'EXPLAIN'],
'^EXPLAIN ': ['SELECT'],
'^INSERT ': (mysql ? ['IGNORE'] : []),
'^INSERT [^]+\\) ': ['?VALUES'].concat(mysql ? ['ON DUPLICATE KEY UPDATE'] : []),
'^UPDATE \\w+ ': ['SET'],
'^UPDATE \\w+ SET [^]+ ': ['?WHERE'],
'^DELETE FROM \\w+ ': ['WHERE'],
' JOIN \\w+(( AS)? (?!(ON|USING|AS) )\\w+)? ': ['ON', 'USING'],
'\\bSELECT ': ['*', 'DISTINCT'],
'\\bSELECT [^]*[^,] ': ['?FROM'],
'\\bSELECT (?![^]* (WHERE|GROUP BY|HAVING|ORDER BY|LIMIT) )[^]+ FROM [^]+ ': ['INNER JOIN', 'LEFT JOIN', '?WHERE'],
'\\bSELECT (?![^]* (HAVING|ORDER BY|LIMIT|OFFSET) )[^]+ FROM [^]+ ': ['?GROUP BY'],
'\\bSELECT (?![^]* (ORDER BY|LIMIT|OFFSET) )[^]+ FROM [^]+ ': ['?HAVING'],
'\\bSELECT (?![^]* (LIMIT|OFFSET) )[^]+ FROM [^]+ ': ['?ORDER BY'], // this matches prefixes without LIMIT|OFFSET and offers ORDER BY if it's not already used in prefix or suffix
'\\bSELECT (?![^]* (OFFSET) )[^]+ FROM [^]+ ': (esc != '[]' ? ['?LIMIT', '?OFFSET'] : []), // MS SQL uses TOP
' ORDER BY (?![^]* (LIMIT|OFFSET) )[^]+ ': ['DESC'],
};
// strings and comments must be found in a single pass, otherwise a delimiter inside the other construct would be honored
const literals = new RegExp(
'\'(?:[^\']|\'\')*\'?' // string, possibly unterminated
+ '|/\\*[^]*?(?:\\*/|$)' // block comment
+ '|(?:^|\\s)--' + (mysql ? ' ' : '') + '[^\\n]*' // line comment
+ (mysql ? '|#[^\\n]*' : '') // # is a comment only in MySQL
, 'g');
let forceEscape = false;
/** Replace a string by a placeholder and a comment by whitespace
* @param {string} literal
* @return {string}
*/
function replaceLiteral(literal) {
return (literal[0] == '\'' ? '0' : ' ');
}
/** Get list of strings for autocompletion
* @param {string} state
* @param {string} before
* @param {string} after
* @return {Object} keys are words, values are offsets
*/
function autocomplete(state, before, after) {
// bac, bra, mssql_bra and sqlite_quo are identifiers so they are completed
if (/^(one|com|com_nest|sql_apo|sqlite_apo|sql_quo)$/.test(state)) {
return {};
}
before = before
.replace(literals, replaceLiteral)
.replace(/[^]*;/, '') // strip previous query
.replace(/^\s+/, '')
;
after = after
.replace(literals, replaceLiteral)
.replace(/;[^]*/, '') // strip next query
;
const query = before + after;
const allTables = Object.keys(tablesColumns);
const usedTables = findTables(query); // tables used by the current query
const uniqueColumns = {};
for (const alias in usedTables) {
for (const column of tablesColumns[usedTables[alias]]) {
uniqueColumns[column] = 0;
}
}
const columns = Object.keys(uniqueColumns);
if (columns.length > 50) {
columns.length = 0;
}
if (Object.keys(usedTables).length > 1) {
for (const alias in usedTables) {
columns.push(alias + '.');
}
}
const preferred = {
'\\b(FROM|INTO|^UPDATE|JOIN|^TRUNCATE) ': allTables, // all tables including the current ones (self-join)
'\\b(^INSERT|USING) [^(]*\\(([^)]+, )?': columns, // offer columns right after '(' or after ','
'\\b(?!(IN|VALUES)\\()[a-z_]\\w*\\(([^)]+, )?': columns, // function call; IN() and VALUES() contain values
'(^UPDATE [^]+ SET| DUPLICATE KEY UPDATE| BY) ([^]+, )?': columns,
' (WHERE|HAVING|AND|OR|ON|=) (\\(\\s*)*': columns, // the condition can be parenthesized
};
keywordsDefault['\\bSELECT( DISTINCT)? (?![^]* FROM )([^]+, )?'] = columns; // this is not in preferred because we prefer '*'
const context = before.replace(escRe('[\\w`]+$'), ''); // in 'UPDATE tab.`co', context is 'UPDATE tab.'
before = before.replace(escRe('[^]*[^\\w`]'), ''); // in 'UPDATE tab.`co', before is '`co'
const thisColumns = []; // columns in the current table ('table.')
const match = context.match(escRe('`?(\\w+)`?\\.$'));
if (match) {
let table = match[1];
if (!tablesColumns[table]) {
table = usedTables[table];
}
if (tablesColumns[table]) {
thisColumns.push(...tablesColumns[table]);
preferred['\\.'] = thisColumns;
}
}
forceEscape = query.includes(esc[0]) && !/^\w/.test(before); // if there's any ` in the query, use ` everywhere unless the user starts typing letters
allTables.forEach(addEsc);
columns.forEach(addEsc);
thisColumns.forEach(addEsc);
const ac = {};
for (const keywords of [preferred, keywordsDefault]) {
for (const re in keywords) {
if (context.match(escRe(re.replace(/ /g, '\\s+').replace(/\\w\+/g, '`?\\w+`?') + '$', 'i'))) {
for (let keyword of keywords[re]) {
if (keyword[0] == '?') {
keyword = keyword.substring(1);
if (query.match(new RegExp('\\s+' + keyword.replace(/ /g, '\\s+') + '\\s+', 'i'))) {
continue;
}
}
if (keyword.length > before.length && keyword.toUpperCase().startsWith(before.toUpperCase())) {
const isCol = (keywords[re] == columns || keywords[re] == thisColumns);
ac[keyword + (isCol ? '' : ' ')] = before.length;
}
}
}
}
}
return ac;
}
function addEsc(val, key, array) {
if (forceEscape || !/^[a-z_]\w*\.?$/i.test(val)) {
array[key] = esc[0] + val.replace(/\.?$/, esc[1] + '$&');
}
}
/** Change odd ` to esc[0], even to esc[1] */
function escRe(re, flags) {
let i = 0;
return new RegExp(re.replace(/`/g, () => (esc[0] == '[' ? '\\' : '') + esc[i++ % 2]), flags);
}
/** @return {Object} key is alias, value is actual table */
function findTables(query) {
const re = escRe('\\b(FROM|JOIN|INTO|UPDATE)\\s+(\\w+|`.+?`)((\\s+AS)?\\s+((?!(LEFT|INNER|JOIN|ON|USING|WHERE|GROUP|HAVING|ORDER|LIMIT)\\b)\\w+|`.+?`))?', 'gi'); //! handle `abc``def`
const result = {};
let match;
while ((match = re.exec(query))) {
const table = match[2].replace(escRe('^`|`$', 'g'), '');
const alias = (match[5] ? match[5].replace(escRe('^`|`$', 'g'), '') : table);
if (tablesColumns[table]) {
result[alias] = table;
}
}
if (!Object.keys(result).length) {
for (const table in tablesColumns) {
result[table] = table;
}
}
return result;
}
// we open the autocomplete on word character, space, '(', '.' and '`'; textarea also triggers it on Backspace and Ctrl+Space
autocomplete.openBy = escRe('^[\\w`(. ]$'); //! ignore . in 1.23
return autocomplete;
};
vrana-jush-d490483/modules/jush-cnf.js 0000664 0000000 0000000 00000020465 15237625165 0017617 0 ustar 00root root 0000000 0000000 jush.tr.cnf = { quo_one: /"/, one: /#/, cnf_http: /((?:^|\n)\s*)(RequestHeader|Header|CacheIgnoreHeaders)([ \t]+|$)/i, cnf_php: /((?:^|\n)\s*)(PHPIniDir)([ \t]+|$)/i, cnf_phpini: /((?:^|\n)\s*)(php_value|php_flag|php_admin_value|php_admin_flag)([ \t]+|$)/i };
jush.tr.quo_one = { esc: /\\/, _1: /"|(?=\n)/ };
jush.tr.cnf_http = { apo: /'/, quo: /"/, _1: /(?=\n)/ };
jush.tr.cnf_php = { _1: /()/ };
jush.tr.cnf_phpini = { cnf_phpini_val: /[ \t]/ };
jush.tr.cnf_phpini_val = { apo: /'/, quo: /"/, _2: /(?=\n)/ };
jush.urls.cnf_http = 'https://httpd.apache.org/docs/current/mod/$key.html#$val';
jush.urls.cnf_php = 'https://www.php.net/$key';
jush.urls.cnf_phpini = 'https://www.php.net/configuration.changes#$key';
jush.slugs.cnf = name => name.toLowerCase();
jush.links.cnf_http = { 'mod_cache': /CacheIgnoreHeaders/i, 'mod_headers': /.+/ };
jush.links.cnf_php = { 'configuration.file': /.+/ };
jush.links.cnf_phpini = { 'configuration.changes.apache': /.+/ };
jush.build_links2('cnf', 'https://httpd.apache.org/docs/current/mod/$key.html#$1', /((?:^|\n)\s*(?:<)?)/, /(\b)/gi, {
'beos': /(MaxRequestsPerThread)/,
'core': /(AcceptFilter|AcceptPathInfo|AccessFileName|AddDefaultCharset|AddOutputFilterByType|AllowEncodedSlashes|AllowOverride|AuthName|AuthType|CGIMapExtension|ContentDigest|DefaultType|Directory|DirectoryMatch|DocumentRoot|EnableMMAP|EnableSendfile|ErrorDocument|ErrorLog|FileETag|Files|FilesMatch|ForceType|HostnameLookups|IfDefine|IfModule|Include|KeepAlive|KeepAliveTimeout|Limit|LimitExcept|LimitInternalRecursion|LimitRequestBody|LimitRequestFields|LimitRequestFieldSize|LimitRequestLine|LimitXMLRequestBody|Location|LocationMatch|LogLevel|MaxKeepAliveRequests|NameVirtualHost|Options|Require|RLimitCPU|RLimitMEM|RLimitNPROC|Satisfy|ScriptInterpreterSource|ServerAdmin|ServerAlias|ServerName|ServerPath|ServerRoot|ServerSignature|ServerTokens|SetHandler|SetInputFilter|SetOutputFilter|TimeOut|TraceEnable|UseCanonicalName|UseCanonicalPhysicalPort|VirtualHost)/,
'mod_actions': /(Action|Script)/,
'mod_alias': /(Alias|AliasMatch|Redirect|RedirectMatch|RedirectPermanent|RedirectTemp|ScriptAlias|ScriptAliasMatch)/,
'mod_auth_basic': /(AuthBasicAuthoritative|AuthBasicProvider)/,
'mod_auth_digest': /(AuthDigestAlgorithm|AuthDigestDomain|AuthDigestNcCheck|AuthDigestNonceFormat|AuthDigestNonceLifetime|AuthDigestProvider|AuthDigestQop|AuthDigestShmemSize)/,
'mod_authn_alias': /(AuthnProviderAlias)/,
'mod_authn_anon': /(Anonymous|Anonymous_LogEmail|Anonymous_MustGiveEmail|Anonymous_NoUserID|Anonymous_VerifyEmail)/,
'mod_authn_dbd': /(AuthDBDUserPWQuery|AuthDBDUserRealmQuery)/,
'mod_authn_dbm': /(AuthDBMType|AuthDBMUserFile)/,
'mod_authn_default': /(AuthDefaultAuthoritative)/,
'mod_authn_file': /(AuthUserFile)/,
'mod_authnz_ldap': /(AuthLDAPBindDN|AuthLDAPBindPassword|AuthLDAPCharsetConfig|AuthLDAPCompareDNOnServer|AuthLDAPDereferenceAliases|AuthLDAPGroupAttribute|AuthLDAPGroupAttributeIsDN|AuthLDAPRemoteUserAttribute|AuthLDAPRemoteUserIsDN|AuthLDAPUrl|AuthzLDAPAuthoritative)/,
'mod_authz_dbm': /(AuthDBMGroupFile|AuthzDBMAuthoritative|AuthzDBMType)/,
'mod_authz_default': /(AuthzDefaultAuthoritative)/,
'mod_authz_groupfile': /(AuthGroupFile|AuthzGroupFileAuthoritative)/,
'mod_authz_host': /(Allow|Deny|Order)/,
'mod_authz_owner': /(AuthzOwnerAuthoritative)/,
'mod_authz_user': /(AuthzUserAuthoritative)/,
'mod_autoindex': /(AddAlt|AddAltByEncoding|AddAltByType|AddDescription|AddIcon|AddIconByEncoding|AddIconByType|DefaultIcon|HeaderName|IndexHeadInsert|IndexIgnore|IndexOptions|IndexOrderDefault|IndexStyleSheet|ReadmeName)/,
'mod_cache': /(CacheDefaultExpire|CacheDisable|CacheEnable|CacheIgnoreCacheControl|CacheIgnoreNoLastMod|CacheIgnoreQueryString|CacheLastModifiedFactor|CacheMaxExpire|CacheStoreNoStore|CacheStorePrivate)/,
'mod_cern_meta': /(MetaDir|MetaFiles|MetaSuffix)/,
'mod_cgi': /(ScriptLog|ScriptLogBuffer|ScriptLogLength)/,
'mod_cgid': /(ScriptSock)/,
'mod_dav': /(Dav|DavDepthInfinity|DavMinTimeout)/,
'mod_dav_fs': /(DavLockDB)/,
'mod_dav_lock': /(DavGenericLockDB)/,
'mod_dbd': /(DBDExptime|DBDKeep|DBDMax|DBDMin|DBDParams|DBDPersist|DBDPrepareSQL|DBDriver)/,
'mod_deflate': /(DeflateBufferSize|DeflateCompressionLevel|DeflateFilterNote|DeflateMemLevel|DeflateWindowSize)/,
'mod_dir': /(DirectoryIndex|DirectorySlash)/,
'mod_disk_cache': /(CacheDirLength|CacheDirLevels|CacheMaxFileSize|CacheMinFileSize|CacheRoot)/,
'mod_dumpio': /(DumpIOInput|DumpIOLogLevel|DumpIOOutput)/,
'mod_echo': /(ProtocolEcho)/,
'mod_env': /(PassEnv|SetEnv|UnsetEnv)/,
'mod_example': /(Example)/,
'mod_expires': /(ExpiresActive|ExpiresByType|ExpiresDefault)/,
'mod_ext_filter': /(ExtFilterDefine|ExtFilterOptions)/,
'mod_file_cache': /(CacheFile|MMapFile)/,
'mod_filter': /(FilterChain|FilterDeclare|FilterProtocol|FilterProvider|FilterTrace)/,
'mod_charset_lite': /(CharsetDefault|CharsetOptions|CharsetSourceEnc)/,
'mod_ident': /(IdentityCheck|IdentityCheckTimeout)/,
'mod_imagemap': /(ImapBase|ImapDefault|ImapMenu)/,
'mod_include': /(SSIEnableAccess|SSIEndTag|SSIErrorMsg|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|XBitHack)/,
'mod_info': /(AddModuleInfo)/,
'mod_isapi': /(ISAPIAppendLogToErrors|ISAPIAppendLogToQuery|ISAPICacheFile|ISAPIFakeAsync|ISAPILogNotSupported|ISAPIReadAheadBuffer)/,
'mod_ldap': /(LDAPCacheEntries|LDAPCacheTTL|LDAPConnectionTimeout|LDAPOpCacheEntries|LDAPOpCacheTTL|LDAPSharedCacheFile|LDAPSharedCacheSize|LDAPTrustedClientCert|LDAPTrustedGlobalCert|LDAPTrustedMode|LDAPVerifyServerCert)/,
'mod_log_config': /(BufferedLogs|CookieLog|CustomLog|LogFormat|TransferLog)/,
'mod_log_forensic': /(ForensicLog)/,
'mod_mem_cache': /(MCacheMaxObjectCount|MCacheMaxObjectSize|MCacheMaxStreamingBuffer|MCacheMinObjectSize|MCacheRemovalAlgorithm|MCacheSize)/,
'mod_mime': /(AddCharset|AddEncoding|AddHandler|AddInputFilter|AddLanguage|AddOutputFilter|AddType|DefaultLanguage|ModMimeUsePathInfo|MultiviewsMatch|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|TypesConfig)/,
'mod_mime_magic': /(MimeMagicFile)/,
'mod_negotiation': /(CacheNegotiatedDocs|ForceLanguagePriority|LanguagePriority)/,
'mod_nw_ssl': /(NWSSLTrustedCerts|NWSSLUpgradeable|SecureListen)/,
'mod_proxy': /(AllowCONNECT|BalancerMember|NoProxy|Proxy|ProxyBadHeader|ProxyBlock|ProxyDomain|ProxyErrorOverride|ProxyFtpDirCharset|ProxyIOBufferSize|ProxyMatch|ProxyMaxForwards|ProxyPass|ProxyPassInterpolateEnv|ProxyPassMatch|ProxyPassReverse|ProxyPassReverseCookieDomain|ProxyPassReverseCookiePath|ProxyPreserveHost|ProxyReceiveBufferSize|ProxyRemote|ProxyRemoteMatch|ProxyRequests|ProxySet|ProxyStatus|ProxyTimeout|ProxyVia)/,
'mod_rewrite': /(RewriteBase|RewriteCond|RewriteEngine|RewriteLock|RewriteLog|RewriteLogLevel|RewriteMap|RewriteOptions|RewriteRule)/,
'mod_setenvif': /(BrowserMatch|BrowserMatchNoCase|SetEnvIf|SetEnvIfNoCase)/,
'mod_so': /(LoadFile|LoadModule)/,
'mod_speling': /(CheckCaseOnly|CheckSpelling)/,
'mod_ssl': /(SSLCACertificateFile|SSLCACertificatePath|SSLCADNRequestFile|SSLCADNRequestPath|SSLCARevocationFile|SSLCARevocationPath|SSLCertificateChainFile|SSLCertificateFile|SSLCertificateKeyFile|SSLCipherSuite|SSLCryptoDevice|SSLEngine|SSLHonorCipherOrder|SSLMutex|SSLOptions|SSLPassPhraseDialog|SSLProtocol|SSLProxyCACertificateFile|SSLProxyCACertificatePath|SSLProxyCARevocationFile|SSLProxyCARevocationPath|SSLProxyCipherSuite|SSLProxyEngine|SSLProxyMachineCertificateFile|SSLProxyMachineCertificatePath|SSLProxyProtocol|SSLProxyVerify|SSLProxyVerifyDepth|SSLRandomSeed|SSLRequire|SSLRequireSSL|SSLSessionCache|SSLSessionCacheTimeout|SSLUserName|SSLVerifyClient|SSLVerifyDepth)/,
'mod_status': /(ExtendedStatus|SeeRequestTail)/,
'mod_substitute': /(Substitute)/,
'mod_suexec': /(SuexecUserGroup)/,
'mod_userdir': /(UserDir)/,
'mod_usertrack': /(CookieDomain|CookieExpires|CookieName|CookieStyle|CookieTracking)/,
'mod_version': /(IfVersion)/,
'mod_vhost_alias': /(VirtualDocumentRoot|VirtualDocumentRootIP|VirtualScriptAlias|VirtualScriptAliasIP)/,
'mpm_common': /(AcceptMutex|ChrootDir|CoreDumpDirectory|EnableExceptionHook|GracefulShutdownTimeout|Group|Listen|ListenBackLog|LockFile|MaxClients|MaxMemFree|MaxRequestsPerChild|MaxSpareThreads|MinSpareThreads|PidFile|ReceiveBufferSize|ScoreBoardFile|SendBufferSize|ServerLimit|StartServers|StartThreads|ThreadLimit|ThreadsPerChild|ThreadStackSize|User)/,
'mpm_netware': /(MaxThreads)/,
'mpm_winnt': /(Win32DisableAcceptEx)/,
'prefork': /(MaxSpareServers|MinSpareServers)/,
});
vrana-jush-d490483/modules/jush-css.js 0000664 0000000 0000000 00000027666 15237625165 0017653 0 ustar 00root root 0000000 0000000 jush.tr.css = { php: jush.php, quo: /"/, apo: /'/, com: /\/\*/, css_at: /(@)([^;\s{]+)/, css_pro: /\{/, _2: /(<)(\/style)(>)/i };
jush.tr.css_at = { php: jush.php, quo: /"/, apo: /'/, com: /\/\*/, css_at2: /\{/, _1: /;/ };
jush.tr.css_at2 = { php: jush.php, quo: /"/, apo: /'/, com: /\/\*/, css_at: /@/, css_pro: /\{/, _2: /}/ };
jush.tr.css_pro = { php: jush.php, com: /\/\*/, css_val: /(\s*)([-\w]+)(\s*:)/, _1: /}/ }; //! misses e.g. margin/*-left*/:
jush.tr.css_val = { php: jush.php, quo: /"/, apo: /'/, css_js: /expression\s*\(/i, com: /\/\*/, clr: /#/, num: /[-+]?[0-9]*\.?[0-9]+(?:em|ex|px|in|cm|mm|pt|pc|%)?/, _2: /}/, _1: /;|$/ };
jush.tr.css_js = { php: jush.php, css_js: /\(/, _1: /\)/ };
jush.tr.clr = { _1: /(?=[^a-fA-F0-9])/ };
jush.urls.css_at = 'https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/$key';
jush.urls.css_val = 'https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/$key';
jush.links.css_at = {
'@$val': /^(charset|color-profile|container|counter-style|custom-media|document|font-face|font-feature-values|font-palette-values|function|import|keyframes|layer|media|namespace|page|position-try|property|scope|starting-style|supports|view-transition)$/i
};
jush.links.css_val = {
'$val': /^(-moz-float-edge|-moz-force-broken-image-icon|-moz-orient|-moz-user-focus|-moz-user-input|-webkit-border-before|-webkit-box-reflect|-webkit-mask-box-image|-webkit-mask-composite|-webkit-mask-position-x|-webkit-mask-position-y|-webkit-mask-repeat-x|-webkit-mask-repeat-y|-webkit-tap-highlight-color|-webkit-text-fill-color|-webkit-text-security|-webkit-text-stroke|-webkit-text-stroke-color|-webkit-text-stroke-width|-webkit-touch-callout|accent-color|align-content|align-items|align-self|alignment-baseline|all|anchor-name|anchor-scope|animation|animation-composition|animation-delay|animation-direction|animation-duration|animation-fill-mode|animation-iteration-count|animation-name|animation-play-state|animation-range|animation-range-end|animation-range-start|animation-timeline|animation-timing-function|appearance|aspect-ratio|backdrop-filter|backface-visibility|background|background-attachment|background-blend-mode|background-clip|background-color|background-image|background-origin|background-position|background-position-x|background-position-y|background-repeat|background-repeat-x|background-repeat-y|background-size|baseline-shift|baseline-source|block-size|border|border-block|border-block-color|border-block-end|border-block-end-color|border-block-end-style|border-block-end-width|border-block-start|border-block-start-color|border-block-start-style|border-block-start-width|border-block-style|border-block-width|border-bottom|border-bottom-color|border-bottom-left-radius|border-bottom-right-radius|border-bottom-style|border-bottom-width|border-collapse|border-color|border-end-end-radius|border-end-start-radius|border-image|border-image-outset|border-image-repeat|border-image-slice|border-image-source|border-image-width|border-inline|border-inline-color|border-inline-end|border-inline-end-color|border-inline-end-style|border-inline-end-width|border-inline-start|border-inline-start-color|border-inline-start-style|border-inline-start-width|border-inline-style|border-inline-width|border-left|border-left-color|border-left-style|border-left-width|border-radius|border-right|border-right-color|border-right-style|border-right-width|border-shape|border-spacing|border-start-end-radius|border-start-start-radius|border-style|border-top|border-top-color|border-top-left-radius|border-top-right-radius|border-top-style|border-top-width|border-width|bottom|box-align|box-decoration-break|box-direction|box-flex|box-flex-group|box-lines|box-ordinal-group|box-orient|box-pack|box-shadow|box-sizing|break-after|break-before|break-inside|caption-side|caret|caret-animation|caret-color|caret-shape|clear|clip|clip-path|clip-rule|color|color-interpolation|color-interpolation-filters|color-scheme|column-count|column-fill|column-gap|column-height|column-rule|column-rule-color|column-rule-style|column-rule-visibility-items|column-rule-width|column-span|column-width|column-wrap|columns|contain|contain-intrinsic-block-size|contain-intrinsic-height|contain-intrinsic-inline-size|contain-intrinsic-size|contain-intrinsic-width|container|container-name|container-type|content|content-visibility|corner-block-end-shape|corner-block-start-shape|corner-bottom-left-shape|corner-bottom-right-shape|corner-bottom-shape|corner-end-end-shape|corner-end-start-shape|corner-inline-end-shape|corner-inline-start-shape|corner-left-shape|corner-right-shape|corner-shape|corner-start-end-shape|corner-start-start-shape|corner-top-left-shape|corner-top-right-shape|corner-top-shape|counter-increment|counter-reset|counter-set|cursor|cx|cy|d|direction|display|dominant-baseline|dynamic-range-limit|empty-cells|field-sizing|fill|fill-opacity|fill-rule|filter|flex|flex-basis|flex-direction|flex-flow|flex-grow|flex-shrink|flex-wrap|float|flood-color|flood-opacity|font|font-family|font-feature-settings|font-kerning|font-language-override|font-optical-sizing|font-palette|font-size|font-size-adjust|font-smooth|font-stretch|font-style|font-synthesis|font-synthesis-position|font-synthesis-small-caps|font-synthesis-style|font-synthesis-weight|font-variant|font-variant-alternates|font-variant-caps|font-variant-east-asian|font-variant-emoji|font-variant-ligatures|font-variant-numeric|font-variant-position|font-variation-settings|font-weight|font-width|forced-color-adjust|frame-sizing|gap|grid|grid-area|grid-auto-columns|grid-auto-flow|grid-auto-rows|grid-column|grid-column-end|grid-column-start|grid-row|grid-row-end|grid-row-start|grid-template|grid-template-areas|grid-template-columns|grid-template-rows|hanging-punctuation|height|hyphenate-character|hyphenate-limit-chars|hyphens|image-orientation|image-rendering|image-resolution|initial-letter|inline-size|inset|inset-block|inset-block-end|inset-block-start|inset-inline|inset-inline-end|inset-inline-start|interactivity|interest-delay|interest-delay-end|interest-delay-start|interpolate-size|isolation|justify-content|justify-items|justify-self|left|letter-spacing|lighting-color|line-break|line-clamp|line-height|line-height-step|link-parameters|list-style|list-style-image|list-style-position|list-style-type|margin|margin-block|margin-block-end|margin-block-start|margin-bottom|margin-inline|margin-inline-end|margin-inline-start|margin-left|margin-right|margin-top|margin-trim|marker|marker-end|marker-mid|marker-start|mask|mask-border|mask-border-mode|mask-border-outset|mask-border-repeat|mask-border-slice|mask-border-source|mask-border-width|mask-clip|mask-composite|mask-image|mask-mode|mask-origin|mask-position|mask-repeat|mask-size|mask-type|math-depth|math-shift|math-style|max-block-size|max-height|max-inline-size|max-width|min-block-size|min-height|min-inline-size|min-width|mix-blend-mode|object-fit|object-position|object-view-box|offset|offset-anchor|offset-distance|offset-path|offset-position|offset-rotate|opacity|order|orphans|outline|outline-color|outline-offset|outline-style|outline-width|overflow|overflow-anchor|overflow-block|overflow-clip-margin|overflow-inline|overflow-wrap|overflow-x|overflow-y|overlay|overscroll-behavior|overscroll-behavior-block|overscroll-behavior-inline|overscroll-behavior-x|overscroll-behavior-y|padding|padding-block|padding-block-end|padding-block-start|padding-bottom|padding-inline|padding-inline-end|padding-inline-start|padding-left|padding-right|padding-top|page|page-break-after|page-break-before|page-break-inside|paint-order|path-length|perspective|perspective-origin|place-content|place-items|place-self|pointer-events|position|position-anchor|position-area|position-try|position-try-fallbacks|position-try-order|position-visibility|print-color-adjust|quotes|r|reading-flow|reading-order|resize|right|rotate|row-gap|row-rule|row-rule-color|row-rule-style|row-rule-visibility-items|row-rule-width|ruby-align|ruby-overhang|ruby-position|rule|rule-visibility-items|rx|ry|scale|scroll-behavior|scroll-initial-target|scroll-margin|scroll-margin-block|scroll-margin-block-end|scroll-margin-block-start|scroll-margin-bottom|scroll-margin-inline|scroll-margin-inline-end|scroll-margin-inline-start|scroll-margin-left|scroll-margin-right|scroll-margin-top|scroll-marker-group|scroll-padding|scroll-padding-block|scroll-padding-block-end|scroll-padding-block-start|scroll-padding-bottom|scroll-padding-inline|scroll-padding-inline-end|scroll-padding-inline-start|scroll-padding-left|scroll-padding-right|scroll-padding-top|scroll-snap-align|scroll-snap-stop|scroll-snap-type|scroll-target-group|scroll-timeline|scroll-timeline-axis|scroll-timeline-name|scrollbar-color|scrollbar-gutter|scrollbar-width|shape-image-threshold|shape-margin|shape-outside|shape-rendering|speak-as|stop-color|stop-opacity|stroke|stroke-dasharray|stroke-dashoffset|stroke-linecap|stroke-linejoin|stroke-miterlimit|stroke-opacity|stroke-width|tab-size|table-layout|text-align|text-align-last|text-anchor|text-autospace|text-box|text-box-edge|text-box-trim|text-combine-upright|text-decoration|text-decoration-color|text-decoration-inset|text-decoration-line|text-decoration-skip|text-decoration-skip-ink|text-decoration-style|text-decoration-thickness|text-emphasis|text-emphasis-color|text-emphasis-position|text-emphasis-style|text-indent|text-justify|text-orientation|text-overflow|text-rendering|text-shadow|text-size-adjust|text-spacing-trim|text-transform|text-underline-offset|text-underline-position|text-wrap|text-wrap-mode|text-wrap-style|timeline-scope|top|touch-action|transform|transform-box|transform-origin|transform-style|transition|transition-behavior|transition-delay|transition-duration|transition-property|transition-timing-function|translate|unicode-bidi|user-modify|user-select|vector-effect|vertical-align|view-timeline|view-timeline-axis|view-timeline-inset|view-timeline-name|view-transition-class|view-transition-name|view-transition-scope|visibility|white-space|white-space-collapse|widows|width|will-change|word-break|word-spacing|writing-mode|x|y|z-index|zoom)$/i
};
jush.build_links2('css', 'https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Selectors/$key', /(:)/, /((?![-\w]))/gi, {
':$1': /(-moz-broken|-moz-drag-over|-moz-first-node|-moz-handler-blocked|-moz-handler-crashed|-moz-handler-disabled|-moz-last-node|-moz-loading|-moz-only-whitespace|-moz-submit-invalid|-moz-suppressed|-moz-user-disabled|-moz-window-inactive|active|active-view-transition|active-view-transition-type|any-link|autofill|blank|buffering|checked|current|default|defined|dir|disabled|empty|enabled|first|first-child|first-of-type|focus|focus-visible|focus-within|fullscreen|future|has|has-slotted|heading|host|host-context|hover|in-range|indeterminate|interest-source|interest-target|invalid|is|lang|last-child|last-of-type|left|link|local-link|modal|muted|not|nth-child|nth-last-child|nth-last-of-type|nth-of-type|only-child|only-of-type|open|optional|out-of-range|past|paused|picture-in-picture|placeholder-shown|playing|popover-open|read-only|read-write|required|right|root|scope|seeking|stalled|state|target|target-after|target-before|target-current|user-invalid|user-valid|valid|visited|volume-locked|where|xr-overlay)/,
'::$1': /(:)(-moz-color-swatch|-moz-focus-inner|-moz-list-bullet|-moz-list-number|-moz-meter-bar|-moz-progress-bar|-moz-range-progress|-moz-range-thumb|-moz-range-track|-webkit-inner-spin-button|-webkit-meter-bar|-webkit-meter-even-less-good-value|-webkit-meter-inner-element|-webkit-meter-optimum-value|-webkit-meter-suboptimum-value|-webkit-progress-bar|-webkit-progress-inner-element|-webkit-progress-value|-webkit-scrollbar|-webkit-search-cancel-button|-webkit-search-results-button|-webkit-slider-runnable-track|-webkit-slider-thumb|after|backdrop|before|checkmark|column|cue|details-content|file-selector-button|first-letter|first-line|grammar-error|highlight|marker|part|picker|picker-icon|placeholder|scroll-button|scroll-marker|scroll-marker-group|search-text|selection|slotted|spelling-error|target-text|view-transition|view-transition-group|view-transition-image-pair|view-transition-new|view-transition-old)/,
});
vrana-jush-d490483/modules/jush-elastic.js 0000664 0000000 0000000 00000001200 15237625165 0020457 0 ustar 00root root 0000000 0000000 jush.tr.elastic = { json: /:(?= )/ }; // Adminer prints the queries as ": "
jush.build_links2('elastic', 'https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-$key', /(\b)/, /(\b)/g, {
'https://www.elastic.co/docs/api/doc/elasticsearch/': /(GET|POST|PUT|DELETE|HEAD)/, // no page explains the methods, the reference prints them by every operation
'search': /(_search)/,
'count': /(_count)/,
'index': /(_doc)/,
'update': /(_update)/,
'indices-put-mapping': /(_mapping)/,
'indices-update-aliases': /(_aliases)/, // must be before _alias
'indices-get-alias': /(_alias)/,
'indices-stats': /(_stats)/,
});
vrana-jush-d490483/modules/jush-htm.js 0000664 0000000 0000000 00000013147 15237625165 0017640 0 ustar 00root root 0000000 0000000 jush.tr.htm = { php: jush.php, tag_css: /(<)(style)\b/i, tag_js: /(<)(script)\b/i, htm_com: // };
jush.tr.ent = { php: jush.php, _1: /[;\s]/ };
jush.tr.tag = { php: jush.php, att_css: /(\s*)(style)(\s*=\s*|$)/i, att_js: /(\s*)(on[-\w]+)(\s*=\s*|$)/i, att_http: /(\s*)(http-equiv)(\s*=\s*|$)/i, att: /(\s*)([-\w]+)()/, _1: />/ };
jush.tr.tag_css = { php: jush.php, att: /(\s*)([-\w]+)()/, css: />/ };
jush.tr.tag_js = { php: jush.php, att: /(\s*)([-\w]+)()/, js: />/ };
jush.tr.att = { php: jush.php, att_quo: /\s*=\s*"/, att_apo: /\s*=\s*'/, att_val: /\s*=\s*/, _1: /()/ };
jush.tr.att_css = { php: jush.php, att_quo: /"/, att_apo: /'/, att_val: /\s*/ };
jush.tr.att_js = { php: jush.php, att_quo: /"/, att_apo: /'/, att_val: /\s*/ };
jush.tr.att_http = { php: jush.php, att_quo: /"/, att_apo: /'/, att_val: /\s*/ };
jush.tr.att_quo = { php: jush.php, _2: /"/ };
jush.tr.att_apo = { php: jush.php, _2: /'/ };
jush.tr.att_val = { php: jush.php, _2: /(?=>|\s)/ };
jush.tr.xml = { php: jush.php, htm_com: / &', '<a href="">HTML</a> <!-- comment --> &'],
['htm', '', '<a href="" onclick="alert(\'\');">'],
['htm', '', '<a href="" style="color: red;">'],
['htm', ' SCRIPT', '<script type="text/javascript">alert("");</script> SCRIPT'],
['htm', ' STYLE', '<style type="text/css">a { color: red; }</style> STYLE'],
['htm', '', '<a href=index.php title=\'Quoting\'>'],
['htm', '', '<meta http-equiv="Content-Type" content="text/html; charset=utf-8">'],
['tag', 'title=""', 'title=""'],
['xml', '', '<rss version="0.91">'],
['css', 'a { color: red } /* comment */ b { font-weight: bold; color: black; }', 'a { color: red } /* </style> comment */ b { font-weight: bold; color: black; }'],
['css', 'a:hover::after, p:first-child::first-line { color: red }', 'a:hover::after, p:first-child::first-line { color: red }'], // pseudo-classes and pseudo-elements are distinguished by the number of colons
['css', '@media print { a { color: red } }', '@media print { a { color: red } }'],
['js', 'if (/.+@.+/.test(email)) { /* */ alert(email); }', 'if (/.+@.+/.test(email)) { /* </script> */ alert(email); }'],
['js', '/[/\\]]/.test("/");', '/[/\\]]/.test("/");'],
['js', 'var s = `a ${x} b`; // comment', 'var s = `a ${x} b`; // comment'],
['js', 'x.name = a.at(1);', 'x.name = a.at(1);'], // a member is linked only after a dot, .name prefers the first DOM interface declaring it
['js', 'xhr.getResponseHeader("Content-Type");', 'xhr.getResponseHeader("Content-Type");'],
['js', '{ a: [ 1, { "b": "c" }, 3 ], \'d\': true, e: [null]}', '{ a: [ 1, { "b": "c" }, 3 ], \'d\': true, e: [null]}'],
['js', '/** @param {string} s */', '/** @param {string} s */'],
['js_doc', '@return {@link Foo}', '@return {@link Foo}'],
['json', '{"a": [1, {"b": "c"}, -2.5e3], "d": true, "e": null}', '{"a": [1, {"b": "c"}, -2.5e3], "d": true, "e": null}'],
['json', '{"esc": "a\\"b", "empty": {}, "arr": []}', '{"esc": "a\\"b", "empty": {}, "arr": []}'],
['json', '"param": {"a": 1}', '"param": {"a": 1}'],
['json', 'function({"a":1, "b":"c"})', 'function({"a":1, "b":"c"})'],
['json', '[}', '[}'], // invalid JSON must not loop
['htm', '";', '<?php echo "<a href=\'$href\'>";'],
['htm', '";log()?>', '<?="<a>";log()?><b>'],
['php', 'echo "Test" . $_SERVER["PHP_SELF"]; /* ?> comment */ mysql_free_result($result);', 'echo "Test" . $_SERVER["PHP_SELF"]; /* ?> comment */ mysql_free_result($result);'],
['php', 'mysql_query("SELECT 1");', 'mysql_query("SELECT 1");'],
['php', 'mssql_query("SELECT TOP 1 * FROM t");', 'mssql_query("SELECT TOP 1 * FROM t");'],
['php', '/** @return bool */ ini_set("display_errors", true);', '/** @return bool */ ini_set("display_errors", true);'],
['php', 'header("HTTP/1.1 404 Not Found");', 'header("HTTP/1.1 404 Not Found");'],
['php', 'header("Content-Type: text/html; charset=utf-8");', 'header("Content-Type: text/html; charset=utf-8");'],
['php', 'mail("", "", "", "From: info@example.com\\nMIME-Version: 1.0");', 'mail("", "", "", "From: info@example.com\\nMIME-Version: 1.0");'],
['php', 'echo <<echo <<<EOT\ntext $x\nEOT\n. <<<\'EOT\'\ntext $x\nEOT;\necho 1;'],
['php', 'echo \'apo\'; // line\n# hash\necho "a $var b";', 'echo \'apo\'; // line\n# hash\necho "a $var b";'],
['sql', 'SELECT 1, \'MySQL\'', 'SELECT 1, \'MySQL\''],
['sql', 'SELECT 1 -- comment\n# hash\n/* block */', 'SELECT 1 -- comment\n# hash\n/* block */'],
['sql', '/*!40101 SELECT 1 */', '/*!40101 SELECT 1 */'],
['sql', 'SELECT `col`, @var, \'It\'\'s\'', 'SELECT `col`, @var, \'It\'\'s\''],
['sql', 'SELECT * FROM tab JOIN `tab2`', 'SELECT * FROM tab JOIN `tab2`'],
['sql', 'AUTO_INCREMENT inet4 CLONE LIMIT', 'AUTO_INCREMENT inet4 CLONE LIMIT'],
['sql', 'SHOW ERRORS; SHOW CREATE TABLE t', 'SHOW ERRORS; SHOW CREATE TABLE t'], // a longer phrase wins over SHOW alone
['sql', 'WHILE x DO SET a = 1; END WHILE', 'WHILE x DO SET a = 1; END WHILE'], // DO leaves the state and is still linked
['sql', 'LOAD DATA INFILE \'f\'', 'LOAD DATA INFILE \'f\''], // MySQL documents only the beginning of the MariaDB phrase
['sqlite', 'SELECT 1, \'SQLite\'', 'SELECT 1, \'SQLite\''],
['sqlite', 'CREATE TABLE t (id INTEGER) STRICT, WITHOUT ROWID', 'CREATE TABLE t (id INTEGER) STRICT, WITHOUT ROWID'],
['sqlite', 'WITH RECURSIVE cte AS (SELECT 1) SELECT * FROM cte', 'WITH RECURSIVE cte AS (SELECT 1) SELECT * FROM cte'],
['sqlite', 'SELECT row_number() OVER (PARTITION BY x ORDER BY y) FROM t', 'SELECT row_number() OVER (PARTITION BY x ORDER BY y) FROM t'],
['sqlite', 'INSERT INTO t VALUES (1) ON CONFLICT DO UPDATE SET x = excluded.x RETURNING id', 'INSERT INTO t VALUES (1) ON CONFLICT DO UPDATE SET x = excluded.x RETURNING id'],
['sqlite', 'SELECT json_extract(data, \'$.x\') FROM t', 'SELECT json_extract(data, \'$.x\') FROM t'],
['sqlite', 'SELECT sqrt(4), unixepoch()', 'SELECT sqrt(4), unixepoch()'],
['pgsql', 'SELECT 1, $tag$ \'text\' $tag$, /* WHERE */ \'PostgreSQL\'', 'SELECT 1, $tag$ \'text\' $tag$, /* WHERE */ \'PostgreSQL\''],
['pgsql', 'DO $$ BEGIN SELECT 1; END $$', 'DO $$ BEGIN SELECT 1; END $$'],
['pgsql', 'CREATE FUNCTION f() RETURNS int AS $x$ SELECT \'a\' $x$ LANGUAGE sql', 'CREATE FUNCTION f() RETURNS int AS $x$ SELECT \'a\' $x$ LANGUAGE sql'],
['pgsql', 'DO $$ SELECT \'a\'', 'DO $$ SELECT \'a\''], // not terminated yet
['pgsql', 'DO $o$ SELECT $i$ raw $i$ $o$', 'DO $o$ SELECT $i$ raw $i$ $o$'],
['pgsql', 'ALTER DATABASE "x"; DROP OWNED BY CURRENT_USER', 'ALTER DATABASE "x"; DROP OWNED BY CURRENT_USER'],
['mssql', 'SELECT 1, \'MS SQL\'', 'SELECT 1, \'MS SQL\''],
['oracle', 'SELECT 1, \'Oracle\'', 'SELECT 1, \'Oracle\''],
['sql', 'SET foreign_key_checks = 0', 'SET foreign_key_checks = 0'],
['sqlstatus', 'Qcache_hits', 'Qcache_hits'],
['pgsqlset', 'autovacuum', 'autovacuum'],
['cnf', 'Listen 80\nphp_flag display_errors On', 'Listen 80\nphp_flag display_errors On'],
['http', 'HTTP/1.1 302 Found\nLocation: /', 'HTTP/1.1 302 Found\nLocation: /'],
['http', 'GET / HTTP/1.1\nHost: example.com', 'GET / HTTP/1.1\nHost: example.com'],
['phpini', 'display_errors = On\n; comment', 'display_errors = On\n; comment'],
['txt', 'plain text', 'plain <?php echo 1; ?> text'],
['simpledb', 'SELECT * FROM domain WHERE id = 1', 'SELECT * FROM domain WHERE id = 1'],
['igdb', 'POST games; fields *;', 'POST games; fields *;'],
['redis', 'GET user:1\nRESTORE-ASKING key 0 dump', 'GET user:1\nRESTORE-ASKING key 0 dump'],
['redis', 'CONFIG SET appendonly "yes"', 'CONFIG SET appendonly "yes"'],
['redis', "SET key 'a\\'b' GET", 'SET key \'a\\\'b\' GET'], // GET is not a command here but it is linked anyway
['elastic', 'logs/_search: {"size":50}', 'logs/_search: {"size":50}'],
['elastic', 'logs/_doc/1: {"a":true}', 'logs/_doc/1: {"a":true}'], // the endpoint is linked also in the middle of the path
['elastic', 'POST logs/_update/1?refresh=true: {"doc":{"a":1}}', 'POST logs/_update/1?refresh=true: {"doc":{"a":1}}'],
['elastic', 'DELETE logs', 'DELETE logs'], // a command without a body
];
tests.highlight_html = [
['htm', '<area href="">', '<area href="">']
];
const html = [];
for (const callback in tests) {
for (const test of tests[callback]) {
const highlighted = jush[callback](test[0], test[1]);
if (highlighted !== test[2]) {
console.log(highlighted.replace(/['\\]/g, '\\$&').replace(/\n/g, '\\n'));
html.push('error:');
}
html.push('' + test[0] + ' ' + highlighted + '
');
}
}
// MariaDB flavor - Adminer's syntaxHighlighting() replaces the base URL at runtime
const mariaTests = [
['sql', 'SELECT 1', 'SELECT 1'],
['sql', 'AUTO_INCREMENT inet4 CLONE LIMIT', 'AUTO_INCREMENT inet4 CLONE LIMIT'],
['sql', 'LOAD DATA INFILE \'f\'', 'LOAD DATA INFILE \'f\''],
['sqlset', 'foreign_key_checks', 'foreign_key_checks'],
['sqlstatus', 'Aborted_clients', 'Aborted_clients'],
];
for (const state of ['sql', 'sqlset', 'sqlstatus']) {
jush.urls[state][0] = jush.urls[state][0].replace('dev.mysql.com/doc/mysql', 'mariadb.com/kb');
}
for (const test of mariaTests) {
const highlighted = jush.highlight(test[0], test[1]);
if (highlighted !== test[2]) {
console.log(highlighted.replace(/['\\]/g, '\\$&').replace(/\n/g, '\\n'));
html.push('error:');
}
html.push('' + test[0] + ' (MariaDB) ' + highlighted + '
');
}
for (const state of ['sql', 'sqlset', 'sqlstatus']) {
jush.urls[state][0] = jush.urls[state][0].replace('mariadb.com/kb', 'dev.mysql.com/doc/mysql');
}
// SQL autocomplete
const tables = {
albums: ['id', 'interpret', 'title'],
songs: ['id', 'album', 'title'],
};
const quotedTables = { 'my albums': ['my id', 'title'], songs: ['id', 'album'] }; // names which are not identifiers are always quoted
const autocompleteEsc = { pgsql: '""', mssql: '[]' }; // escaped empty identifier, the other states use ``
const autocompleteTests = [ // state, text before and after the caret, expected words with the length of the typed prefix, tables with columns, statements offered at the beginning
['sql', 'SELECT * FROM ', '', '{"albums ":0,"songs ":0}', tables], // all tables are offered after FROM
['sql', 'SELECT id,\ntitle\nFROM albums\n', '', '{"INNER JOIN ":0,"LEFT JOIN ":0,"WHERE ":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // the query can span lines
['sql', 'SELECT * FROM albums ORDER\nBY id ', '', '{"LIMIT ":0,"OFFSET ":0,"DESC ":0}', tables], // a keyword split by a newline is recognized as already used
['sql', '/* WHERE\nin a comment */\nSELECT * FROM albums\n', '', '{"INNER JOIN ":0,"LEFT JOIN ":0,"WHERE ":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // a multi-line comment is ignored
['sql', 'SELECT * FROM albums -- c1\nWHERE id = 1 -- c2 GROUP BY x\n', '', '{"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // every comment is ignored, not just the first one
['sql', 'SELECT * FROM albums # ORDER BY x\n', '', '{"INNER JOIN ":0,"LEFT JOIN ":0,"WHERE ":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // # is a comment in MySQL
['pgsql', 'SELECT * FROM albums # ORDER BY x\n', '', '{"LIMIT ":0,"OFFSET ":0,"DESC ":0}', tables], // # is not a comment in PostgreSQL, the ORDER BY is a part of the query
['sql', 'SELECT * FROM albums WHERE a = \'x -- y\' AND ', '', '{"id":0,"interpret":0,"title":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // a comment inside a string doesn't start a comment
['sql', 'SELECT * FROM albums WHERE a = \'x\' AND b = \'y;z\' AND ', '', '{"id":0,"interpret":0,"title":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // a semicolon inside any string doesn't end the query
['sql', 'SELECT * FROM albums WHERE a = \'it\'\'s\' AND ', '', '{"id":0,"interpret":0,"title":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // a doubled apostrophe doesn't end the string
['sql', 'SELECT * FROM albums\nWHERE id = 1\n;\n', '', '{"SELECT ":0,"INSERT INTO ":0,"UPDATE ":0,"DELETE FROM ":0,"TRUNCATE ":0,"EXPLAIN ":0}', tables], // the previous query is stripped
['sql', 'SELECT * FROM albums\n', '\nWHERE id = 1;\nSELECT * FROM songs ORDER BY x ', '{"INNER JOIN ":0,"LEFT JOIN ":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // the next query is stripped, the rest of the current one is not
['sql', 'SELECT *\nFROM albums\nJOIN songs ON albums.id = songs.album\nWHERE ', '', '{"id":0,"interpret":0,"title":0,"album":0,"albums.":0,"songs.":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // columns of all joined tables
['sql', 'SELECT * FROM albums a\nWHERE a.', '', '{"id":0,"interpret":0,"title":0}', tables], // columns of an aliased table
['sql', 'SELECT * FROM albums WHERE (', '', '{"id":0,"interpret":0,"title":0}', tables], // the condition can be parenthesized
['sql', 'SELECT * FROM albums WHERE UPPER(', '', '{"id":0,"interpret":0,"title":0}', tables], // columns are offered in a function call
['sql', 'SELECT * FROM albums WHERE id IN (', '', '{}', tables], // IN contains values, not columns
['sql', 'SELECT * FROM albums\nWHERE ti', '', '{"title":2}', tables], // the value is the length of the typed prefix
['com', 'SELECT ', '', '{}', tables], // no autocomplete in a comment
['com_nest', 'SELECT ', '', '{}', tables], // no autocomplete in a PostgreSQL comment
['sql_quo', 'SELECT * FROM albums WHERE a = "x AND ', '', '{}', tables], // no autocomplete in a MySQL string quoted by "
['sql', 'SELECT * FROM ', '', '{"`my albums` ":0,"songs ":0}', quotedTables], // MySQL quotes a name which is not an identifier
['sql', 'SELECT * FROM `albums`\nWHERE ', '', '{"`id`":0,"`interpret`":0,"`title`":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0,"LIMIT ":0,"OFFSET ":0}', tables], // a backtick anywhere quotes everything, the table name is found inside it
['pgsql', 'SELECT * FROM ', '', '{"\\"my albums\\" ":0,"songs ":0}', quotedTables], // PostgreSQL quotes by ""
['mssql', 'SELECT * FROM [my albums]\nWHERE ', '', '{"[my id]":0,"[title]":0,"GROUP BY ":0,"HAVING ":0,"ORDER BY ":0}', quotedTables], // MS SQL quotes by [], the table name is found inside it; MS SQL has no LIMIT
['sql', 'INSERT ', '', '{"IGNORE ":0}', tables], // INSERT IGNORE is MySQL-specific
['pgsql', 'INSERT ', '', '{}', tables],
['sql', 'INSERT INTO albums (id) ', '', '{"VALUES ":0,"ON DUPLICATE KEY UPDATE ":0}', tables], // ON DUPLICATE KEY UPDATE is MySQL-specific
['pgsql', 'INSERT INTO albums (id) ', '', '{"VALUES ":0}', tables],
['sql', '', '', '{"INSERT INTO ":0,"UPDATE ":0,"DELETE FROM ":0}', tables, ['INSERT INTO', 'UPDATE', 'DELETE FROM']], // only the passed statements are offered, e.g. in a trigger
['sql', '', '', '{}', tables, []], // no statement is offered, e.g. in a check constraint
];
for (const test of autocompleteTests) {
const completed = JSON.stringify(jush.autocompleteSql(autocompleteEsc[test[0]] || '``', test[4], test[5])(test[0], test[1], test[2]));
if (completed !== test[3]) {
console.log(completed.replace(/['\\]/g, '\\$&'));
html.push('error:');
}
html.push('' + test[0] + ' (autocomplete) ' + jush.highlight(test[0], test[1] + '\u2038' + test[2]) + '\n' + jush.highlight('json', completed) + '
');
}
document.getElementById('result').innerHTML = html.join('\n');
vrana-jush-d490483/textarea.html 0000664 0000000 0000000 00000001527 15237625165 0016575 0 ustar 00root root 0000000 0000000
JUSH textarea
SQL
vrana-jush-d490483/update/ 0000775 0000000 0000000 00000000000 15237625165 0015347 5 ustar 00root root 0000000 0000000 vrana-jush-d490483/update/css.php 0000664 0000000 0000000 00000002741 15237625165 0016654 0 ustar 00root root 0000000 0000000 $tooltip) {
$lines .= "\n\t'$name': '$tooltip',";
}
return substr_replace($subject, $lines, $start, $end - $start);
}
vrana-jush-d490483/update/htm.php 0000664 0000000 0000000 00000003020 15237625165 0016643 0 ustar 00root root 0000000 0000000 attribute table ("| [`accept`](#accept) |")
preg_match_all('~^(?:- |\| )\[?`([-\w]+)`~m', $section, $matches);
$atts = array_merge($atts, $matches[1]);
}
$atts = array_diff(array_unique($atts), $globals); // global attributes are linked by the entry above them
sort($atts);
$jush = read_file($jush_file);
$jush = set_list($jush, "jush.links.tag = {\n\t'Elements/Heading_Elements': /^(h[1-6])\$/i,\n\t'Elements/\$val': /^(", ")\$/i", $tags, 'tags');
$jush = set_list($jush, "jush.links.att = {\n\t'Global_attributes/\$val': /^(", ")\$/i", $globals, 'global attributes');
$jush = set_list($jush, "'Elements/\$tag#\$val': /^(", ")\$/i", $atts, 'attributes');
file_put_contents($jush_file, $jush);
vrana-jush-d490483/update/http.php 0000664 0000000 0000000 00000001776 15237625165 0017052 0 ustar 00root root 0000000 0000000 ' || trim(preg_replace('~\{\{.*?\}\}~s', '', $paragraph)) == '') {
continue;
}
$text = preg_replace_callback('~\{\{.*?\}\}~s', function ($match) {
preg_match_all('~"([^"]*)"~', $match[0], $args); // {{jsxref("Statements/let", "let", "", 1)}} - the last non-empty argument is the label
$args = array_filter($args[1], 'strlen');
return ($args ? end($args) : '');
}, $paragraph);
$text = preg_replace('~\[([^\]]*)\]\([^)]*\)~', '$1', $text); // links
$text = str_replace(['**', '`'], '', $text);
$text = preg_replace('~(.*?)~', '^$1', $text); // HTML tags are not supported in titles
$text = trim(preg_replace('~\s+~', ' ', $text));
if ($text != '') {
return js_escape($text);
}
}
return '';
}
$objects = []; // proper-case names for the main list, e.g. parseInt, Array
$statics = []; // static members for the main list, e.g. Math\.abs
$instances = []; // object name => instance members, e.g. Array => [pop, push]
$api = []; // key => tooltip for the jush.api.js block
foreach (read_dirs("$reference/global_objects") as $dir) {
$md = read_file("$reference/global_objects/$dir/index.md");
$name = basename(front_matter($md, 'slug')); // dir names are lowercased, slugs keep case
if (!preg_match('~^\w+$~', $name)) {
continue;
}
$objects[] = $name;
add_api($api, $name, description($md));
foreach (glob("$reference/global_objects/$dir/*", GLOB_ONLYDIR) as $subdir) {
$sub_md = read_file("$subdir/index.md");
$member = basename(front_matter($sub_md, 'slug'));
$page_type = front_matter($sub_md, 'page-type');
if (!preg_match('~^\w+$~', $member)) { // e.g. Symbol.iterator
continue;
}
if (strpos($page_type, 'javascript-static-') === 0) {
$statics[] = "$name\\.$member";
add_api($api, "$name.$member", description($sub_md));
} elseif (strpos($page_type, 'javascript-instance-') === 0) {
$instances[$name][] = $member;
}
}
}
sort($objects);
sort($statics);
$statements = [];
foreach (read_dirs("$reference/statements") as $dir) {
// multi-keyword statements (do...while, if...else, try...catch) have static entries
if (preg_match('~^[a-z]+$~', $dir) && !in_array($dir, ['block', 'empty', 'label'])) { // pages not named after a keyword
$statements[] = $dir;
}
}
$xhr_methods = []; // XMLHttpRequest instance methods, e.g. send
$xhr_path = "$argv[1]/files/en-us/web/api/xmlhttprequest";
add_api($api, 'XMLHttpRequest', description(read_file("$xhr_path/index.md")));
foreach (read_dirs($xhr_path) as $dir) {
$md = read_file("$xhr_path/$dir/index.md");
$member = basename(front_matter($md, 'slug'));
// open collides with window.open
if (front_matter($md, 'page-type') == 'web-api-instance-method' && $member != 'open') {
$xhr_methods[] = $member;
}
}
sort($xhr_methods);
$jush = read_file($jush_file);
// static members first so that e.g. Math\.abs wins over Math
$jush = set_list($jush, "'Web/JavaScript/Reference/Global_Objects/\$1': /(", ")/,", array_merge($statics, $objects), 'globals');
$jush = set_list($jush, "'Web/JavaScript/Reference/Statements/\$1': /(", ")/,", $statements, 'statements');
$jush = set_list($jush, "'Web/API/XMLHttpRequest/\$1': /(\\.)(", ")/,", $xhr_methods, 'XMLHttpRequest methods');
preg_match_all("~'Web/JavaScript/Reference/Global_Objects/(\w+)/\\\$1'~", $jush, $matches);
foreach ($matches[1] as $object) {
sort($instances[$object]);
$jush = set_list($jush, "'Web/JavaScript/Reference/Global_Objects/$object/\$1': /(\\.)(", ")/,", $instances[$object], "$object members");
}
file_put_contents($jush_file, $jush);
ksort($api);
$jush_api = read_file($jush_api_file);
$jush_api = set_block($jush_api, 'jush.api.js = {', "\n};", $api);
file_put_contents($jush_api_file, $jush_api);
vrana-jush-d490483/update/js_doc.php 0000664 0000000 0000000 00000005535 15237625165 0017331 0 ustar 00root root 0000000 0000000 $names) {
$new = array_merge($new, $names);
$lines .= "\t'$page': /(" . implode('|', $names) . ")/,\n";
}
report_diff($label, $old, $new);
return substr_replace($subject, $lines, $start, $end - $start);
}
$tags = []; // block tags linked by the '$1' entry, e.g. param
$entries = []; // page => tags linked by their own entry, e.g. tags-param => ['@arg', '@argument']
foreach (glob("$content/tags-*.md") as $file) {
$md = read_file($file);
$name = front_matter($md, 'tag');
if (!preg_match('~^\w+$~', $name)) {
continue;
}
// check for the inline value, tags-callback.md has a typo in the block one ("blockTagss")
$inline = (front_matter($md, 'tags') == 'inlineTags');
$names = front_matter_list($md, 'synonyms');
if ($inline) {
array_unshift($names, $name); // inline tags are not in the '$1' entry, they need the "{@" prefix
} else {
$tags[] = $name;
}
foreach ($names as $synonym) {
if (preg_match('~^\w+$~', $synonym)) { // e.g. "memberof!"
$entries[basename($file, '.md')][] = ($inline ? '\\{@' : '@') . $synonym;
}
}
}
if (!$tags) {
fwrite(STDERR, "No tags found in $content\n");
exit(1);
}
sort($tags);
ksort($entries);
$jush = read_file($jush_file);
// tags first so that e.g. @returns wins over the @return synonym
$jush = set_list($jush, "'tags-\$1': /(@(?:", "))/,", $tags, 'tags');
$jush = set_entries($jush, "'tags-\$1': /(@(?:" . implode('|', $tags) . "))/,\n", '});', $entries, 'synonyms');
file_put_contents($jush_file, $jush);
vrana-jush-d490483/update/pgsql.php 0000664 0000000 0000000 00000017072 15237625165 0017215 0 ustar 00root root 0000000 0000000 ([^<]+)~', $ref, $matches);
foreach ($matches[1] as $name) {
if ($id == 'sql-' . strtolower(str_replace(' ', '', $name))) {
$phrases[] = $name;
} elseif ($id == 'sql-' . strtolower(str_replace(' ', '-', $name))) {
$hyphens[] = $name;
} elseif (strpos($name, ' ')) {
$explicit["$id.html"][] = $name; // abbreviated pages like sql-altertsconfig.html
}
// single-word aliases of another page (TABLE and WITH are described under sql-select) stay plain keywords
}
}
if (!$phrases || !$hyphens || !$explicit) {
fwrite(STDERR, "No statements found in $sgml/ref\n");
exit(1);
}
$lines = '';
ksort($explicit);
foreach ($explicit as $page => $names) {
$lines .= "\t'" . $page . "': /(" . phrases_regexp($names) . ")/,\n";
}
$lines .= "\t'sql\$1.html': /(" . phrases_regexp($hyphens) . ")/,\n";
$lines .= "\t'sql-\$1.html': /(" . phrases_regexp($phrases) . ")/,\n";
// Explicit entries go first so that e.g. ALTER\s+OPERATOR\s+CLASS wins over ALTER\s+OPERATOR
preg_match_all("~^\t'sql[^']*\.html': /\\((.*)\\)/,\n~m", $jush, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
if (!$matches) {
fwrite(STDERR, "Can't find statement entries\n");
exit(1);
}
$old = [];
$start = $matches[0][0][1];
foreach (array_reverse($matches) as $match) {
$old = array_merge($old, statement_names($match[1][0]));
$jush = substr_replace($jush, '', $match[0][1], strlen($match[0][0]));
}
$jush = substr_replace($jush, $lines, $start, 0);
$new = array_merge($phrases, $hyphens, ...array_values($explicit));
sort($old);
sort($new);
report_diff('statements', $old, $new);
// Function names appear as name ( in signature tables and synopses
function function_names($section) {
preg_match_all('~.*? |.*? ~s', $section, $matches);
$return = [];
foreach ($matches[0] as $block) {
preg_match_all('~(\w+) \s*\(~', $block, $names);
$return = array_merge($return, array_map('strtolower', $names[1]));
}
$return = array_unique($return);
sort($return);
return $return;
}
// Replace the function list in the (?:...)(?=\s*\(|$) group of a 'functions-*.html' entry,
// dropping names already linked by the keyword part of the entry (e.g. current_date)
function set_functions($jush, $page, array $names) {
$start = strpos($jush, "'$page': /(");
$end = strpos($jush, "\n", $start);
$entry = substr($jush, $start, $end - $start);
$keywords = explode('|', preg_replace('~\(\?:.*~s', '', $entry));
$names = array_values(array_diff($names, $keywords));
$entry = set_list($entry, '(?:', ')(?=', $names, "$page functions");
return substr_replace($jush, $entry, $start, $end - $start);
}
preg_match_all('~~s', read_file("$sgml/func.sgml"), $matches, PREG_SET_ORDER);
if (!$matches) {
fwrite(STDERR, "Can't find function sections in func.sgml\n");
exit(1);
}
$append = '';
foreach ($matches as $match) {
$page = "$match[1].html";
$names = function_names($match[2]);
if (!$names) {
continue; // keyword-only pages like functions-logical
}
if (strpos($jush, "'$page': /(") !== false) {
$jush = set_functions($jush, $page, $names);
} else {
$append .= "\t'$page': /((?:" . implode('|', $names) . ")(?=\\s*\\(|\$))/,\n";
fwrite(STDERR, "Added $page: " . implode(', ', $names) . "\n");
}
}
if ($append != '') {
// Append new pages last so that already linked names (e.g. length in functions-string) keep their entry
$start = strpos($jush, "\n});", strpos($jush, "jush.build_links2('pgsql',"));
$jush = substr_replace($jush, $append, $start + 1, 0);
}
// Only reserved and type/function-name keywords are highlighted, others can be used as identifiers
preg_match_all('~^PG_KEYWORD\("(\w+)", \w+, (?:RESERVED|TYPE_FUNC_NAME)_KEYWORD~m', read_file("$argv[1]/src/include/parser/kwlist.h"), $matches);
if (!$matches[1]) {
fwrite(STDERR, "Can't find keywords in kwlist.h\n");
exit(1);
}
$keywords = array_map('strtoupper', $matches[1]);
sort($keywords);
// The '' entry holds keywords with no doc page: subtract single words linked by other entries
// (e.g. SELECT or BETWEEN) but keep words linked only as part of a phrase (e.g. TO in SET\s+ROLE)
// and words linked only as function calls (e.g. LEFT is a keyword but left( links to functions-string)
if (!preg_match("~jush\\.build_links2\\('pgsql'.*?\n\\}\\);~s", $jush, $match)) {
fwrite(STDERR, "Can't find build_links2 block\n");
exit(1);
}
$covered = [];
preg_match_all("~^\t'([^']*)': /\\((.*)\\)/~m", $match[0], $matches, PREG_SET_ORDER);
foreach ($matches as $entry) {
if ($entry[1] != '') {
foreach (explode('|', preg_replace('~\(\?:.*~s', '', $entry[2])) as $alternative) {
if (preg_match('~^\w+$~', $alternative)) {
$covered[] = strtoupper($alternative);
}
}
}
}
$keywords = array_values(array_diff($keywords, $covered));
$jush = set_list($jush, "'': /(", ")/,", $keywords, 'keywords');
// Config variables are grouped by the runtime-config-* page; the ssl_ciphers value descriptions
// also have a guc- id but no xreflabel
preg_match_all('~~s', read_file("$sgml/config.sgml"), $matches, PREG_SET_ORDER);
$sections = [];
foreach ($matches as $match) {
preg_match_all('~ $names) {
$lines .= "\t'$key': /(" . implode('|', $names) . ")/,\n";
}
$jush = substr_replace($jush, $lines, $start, $end - $start);
file_put_contents($jush_file, $jush);
vrana-jush-d490483/update/php.php 0000664 0000000 0000000 00000006101 15237625165 0016645 0 ustar 00root root 0000000 0000000 tooltip for the jush-api.js blocks
$api_php_fun = [];
$api_php2 = [];
foreach (preg_split('~\r?\n~', $api) as $line) {
$line = rtrim($line);
if ($line == '') {
continue;
}
list($decl, $description) = array_pad(explode("\t", $line, 2), 2, '');
// static method: "Class::method(signature): return\tdescription"
if (preg_match('~^([\w\\\\]+)::(\w+)(\(.*)$~', $decl, $match)) {
if (substr($match[2], 0, 2) != '__') {
add_api($api_php2, js_escape("$match[1]::$match[2]"), tooltip($match[3], $description));
}
continue;
}
// class or function: "name(signature)\tdescription"
if (!preg_match('~^([\w\\\\]+)(\(.*)$~', $decl, $match)) {
continue; // keyword, method, $variable or constant, not a class or function
}
$name = $match[1];
$js_name = js_escape($name);
if (strpos($description, '(new)') === 0) { // class, interface or exception
$class_names[$js_name] = true;
add_api($api_php_new, $js_name, tooltip($match[2], trim(substr($description, strlen('(new)')))));
} elseif ($name == 'clone') { // language construct, linked as a keyword instead of a function
add_api($api_php2, $js_name, tooltip($match[2], $description));
} elseif (substr($name, 0, 2) != '__') { // function
$function_names[$js_name] = true;
add_api($api_php2, $js_name, tooltip($match[2], $description));
} elseif ($name != '__halt_compiler') { // magic method
add_api($api_php_fun, $js_name, tooltip($match[2], $description));
}
}
$jush = set_list($jush, 'const php_class = /(', ')/;', array_keys($class_names), 'classes');
$jush = set_list($jush, "'function.\$1': /(return|(?:include|require)(?:_once)?|(?:", ')(?=\s*\(|$))/,', array_keys($function_names), 'functions');
file_put_contents($jush_file, $jush);
$jush_api = set_block($jush_api, 'jush.api.php2 = jush.api.lowercase_keys({', "\n});", $api_php2);
$jush_api = set_block($jush_api, 'jush.api.php_fun = jush.api.lowercase_keys({', "\n});", $api_php_fun);
$jush_api = set_block($jush_api, 'jush.api.php_new = jush.api.lowercase_keys({', "\n});", $api_php_new);
file_put_contents($jush_api_file, $jush_api);
vrana-jush-d490483/update/redis.php 0000664 0000000 0000000 00000001751 15237625165 0017172 0 ustar 00root root 0000000 0000000 $command) {
$container = $command['container'] ?? '';
$names[] = ($container != '' ? "$container $name" : $name);
}
}
$names = array_unique($names);
$jush = read_file($jush_file);
$jush = set_list($jush, "'\$1': /(", ")/,", explode('|', phrases_regexp($names)), 'commands');
file_put_contents($jush_file, $jush);
vrana-jush-d490483/update/sql.php 0000664 0000000 0000000 00000064426 15237625165 0016673 0 ustar 00root root 0000000 0000000 'regexp source'] of the entries in a build_links2 block
function block_entries($block) {
preg_match_all("~^\t'([^']*)': /(.*)/,~m", $block, $matches, PREG_SET_ORDER);
$return = [];
foreach ($matches as $match) {
$return[$match[1]] = $match[2];
}
return $return;
}
// Get the body of a build_links2 block with its start and end offsets
function find_block($jush, $key) {
$start = strpos($jush, "jush.build_links2('$key'");
$start = ($start === false ? false : strpos($jush, "{\n", $start));
$end = ($start === false ? false : strpos($jush, "\n});", $start));
if ($end === false) {
fwrite(STDERR, "Can't find the build_links2('$key') block\n");
exit(1);
}
$start += 2;
return [substr($jush, $start, $end - $start), $start, $end];
}
// Test whether some of the given entries already matches $s as a whole phrase,
// as a keyword followed by something else or as a function call
function is_covered(array $regexps, $s, $mode = 'phrase') {
$subjects = ['phrase' => $s, 'keyword' => "$s x", 'call' => "$s("];
$suffixes = ['phrase' => '$', 'keyword' => '\s', 'call' => '\($'];
foreach ($regexps as $regexp) {
if (preg_match('~^(?:' . $regexp . ')' . $suffixes[$mode] . '~i', $subjects[$mode])) {
return true;
}
}
return false;
}
// Expand (?:A|B) and (?:A|B)? groups of a phrase alternation into plain phrases (for diff reporting)
function expand_phrases($alternation) {
$s = str_replace('\\s+', ' ', $alternation);
if (preg_match('~^(.*?)\(\?:([^()]*)\)(\??)(.*)$~s', $s, $match)) {
$return = [];
$options = explode('|', $match[2]);
if ($match[3]) {
$options[] = '';
}
foreach ($options as $option) {
foreach (expand_phrases($match[1] . $option . $match[4]) as $phrase) {
$return[] = preg_replace('~\s+~', ' ', trim($phrase));
}
}
return array_unique($return);
}
return explode('|', $s);
}
// Turn DATABASE back into the (?:DATABASE|SCHEMA) alternation the runtime maps to one page
function schema_regexp($phrases_regexp) {
return preg_replace('~DATABASE(S?)~', '(?:DATABASE|SCHEMA)$1', $phrases_regexp);
}
// Replace the mechanical form embedded in an exceptional key part by $1 so that
// e.g. st_area and st_binary merge into one st_$1 entry
function embed_name($exception, $mechanical) {
$pos = strrpos($exception, $mechanical);
return ($pos === false ? $exception : substr_replace($exception, '$1', $pos, strlen($mechanical)));
}
// A phrase the vendor doesn't document may still be made of its keywords (e.g. GROUP BY):
// an empty key part keeps it highlighted there while '-' leaves it as plain text
function unknown_key($phrase, array $keywords) {
return (array_diff(explode(' ', $phrase), $keywords) ? '-' : '');
}
// Get the top-level alternatives of the leading capturing subpattern and the rest of the source
function entry_alternatives($source) {
$alternatives = [];
$depth = 0;
$last = 0;
for ($i = 0; $i < strlen($source); $i++) {
$c = $source[$i];
if ($c == '\\') {
$i++;
} elseif ($c == '(') {
if (!$depth++) {
$last = $i + 1;
}
} elseif ($c == ')') {
if (!--$depth) {
$alternatives[] = substr($source, $last, $i - $last);
return [$alternatives, substr($source, $i + 1)];
}
} elseif ($c == '|' && $depth == 1) {
$alternatives[] = substr($source, $last, $i - $last);
$last = $i + 1;
}
}
fwrite(STDERR, "Can't parse the entry /$source/\n");
exit(1);
}
// Whether a phrase of the first list is a prefix of a phrase of the second one
function prefix_of(array $phrases, array $others) {
foreach ($phrases as $phrase) {
foreach ($others as $other) {
if (strpos($other, "$phrase ") === 0) {
return true;
}
}
}
return false;
}
// links2 is a single alternation matching the first alternative, not the longest one, so a phrase must
// not precede a longer phrase starting with it; phrases_regexp() sorts them inside one entry,
// this orders the entries so that it holds across them too
function order_entries(array $entries) { // [line, phrases]
$return = [];
while ($entries) {
foreach ($entries as $i => $entry) {
foreach ($entries as $j => $other) {
if ($i != $j && prefix_of($entry[1], $other[1])) {
continue 2; // a longer phrase is still waiting
}
}
$return[] = $entry;
unset($entries[$i]);
continue 2;
}
fwrite(STDERR, "Statement entries shadow each other in a cycle: " . implode(', ', array_map(function ($entry) {
return implode('|', $entry[1]);
}, $entries)) . "\n");
return array_merge($return, $entries);
}
return $return;
}
// The entries which can't be ordered - a hand-maintained phrase after the generated region - get
// a lookahead rejecting the rest of the longer phrases instead
function set_shadow_lookaheads($jush, $block_key) {
list($block, $start, $end) = find_block($jush, $block_key);
$lines = explode("\n", $block);
$alternatives = []; // [line, position in the entry, phrase or '' when it can't take a lookahead]
$last_phrase = []; // phrase => index of its last alternative
foreach ($lines as $line => $source) {
if (!preg_match("~^\t'[^']*': /(.*)/,$~", $source, $match)) {
continue;
}
foreach (entry_alternatives($match[1])[0] as $position => $alternative) {
$alternative = preg_replace('~\(\?!\\\\s\+\(\?:[^)]*\)\)~', '', $alternative); // drop the lookahead of the previous run
// only a plain phrase optionally followed by lookaheads can take one more
$phrase = (preg_match('~^([A-Z][A-Z0-9_]*(?:\\\\s\+[A-Z][A-Z0-9_]*)*)(|\(\?[=!].*)$~s', $alternative, $match2)
? str_replace('\\s+', ' ', $match2[1])
: '');
foreach (($phrase != '' ? [$phrase] : expand_phrases(preg_replace('~\(\?[=!].*~s', '', $alternative))) as $name) {
if (preg_match('~^[A-Z][A-Z0-9_ ]*$~', $name)) {
$last_phrase[$name] = count($alternatives);
}
}
$alternatives[] = [$line, $position, $phrase];
}
}
$lookaheads = [];
foreach ($alternatives as $index => list($line, $position, $phrase)) {
$rests = [];
foreach ($last_phrase as $name => $last) {
if ($phrase != '' && $last > $index && strpos($name, "$phrase ") === 0) {
// the whole rest, not just the next word - PARTITION must stay linked in PARTITION BY x
$rests[str_replace(' ', '\\s+', substr($name, strlen($phrase) + 1))] = true;
}
}
if ($rests) {
$rests = array_keys($rests);
sort($rests);
$lookaheads[$line][$position] = '(?!\\s+(?:' . implode('|', $rests) . '))';
fwrite(STDERR, "Shadowed: $phrase before " . implode(', ', str_replace('\\s+', ' ', $rests)) . "\n");
}
}
foreach ($lines as $line => $source) {
if (!preg_match("~^(\t'[^']*': /)(.*)(/,)$~", $source, $match)) {
continue;
}
list($entry, $rest) = entry_alternatives($match[2]);
foreach ($entry as $position => $alternative) {
$alternative = preg_replace('~\(\?!\\\\s\+\(\?:[^)]*\)\)~', '', $alternative);
$lookahead = ($lookaheads[$line][$position] ?? '');
$entry[$position] = ($lookahead == '' ? $alternative : preg_replace(
'~^([A-Z][A-Z0-9_]*(?:\\\\s\+[A-Z][A-Z0-9_]*)*)~',
'$1' . str_replace('\\', '\\\\', $lookahead),
$alternative
));
}
$lines[$line] = $match[1] . '(' . implode('|', $entry) . ')' . $rest . $match[3];
}
return substr_replace($jush, implode("\n", $lines), $start, $end - $start);
}
// MariaDB inventory
// functions: the reference table links every function to its page (the file name is the KB slug)
$maria_functions = [];
preg_match_all('~^\| \[([^\]]+)\]\(([^)#]+)\.md[^)]*\)~m', read_file("$maria_ref/sql-functions/function-and-operator-reference.md"), $matches, PREG_SET_ORDER);
foreach ($matches as $match) {
$name = str_replace(['\\', '()'], '', trim($match[1]));
// Spider UDFs are documented under storage-engines
if (preg_match('~^\w+$~', $name) && strpos($match[2], 'storage-engines/') === false) {
$maria_functions[strtolower($name)] = strtolower(basename($match[2]));
}
}
if (!$maria_functions) {
fwrite(STDERR, "No functions found in function-and-operator-reference.md\n");
exit(1);
}
// statements: one file per statement, the all-caps H1 is the phrase;
// some statement docs live outside the sql-statements reference
$maria_statements = [];
$maria_usage = dirname($maria_ref) . '/server-usage';
foreach (
["$maria_ref/sql-statements", "$maria_ref/sql-structure/sequences", "$maria_usage/stored-routines", "$maria_usage/triggers-events", "$maria_usage/views"] as $dir
) {
foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir)) as $file) {
// geometry-constructors holds geometry function docs, not statements
if (preg_match('~(?(\w+)(?:\(\))?~', mysql_page('built-in-function-reference'), $matches, PREG_SET_ORDER);
foreach ($matches as $match) {
if (strpos($match[1], 'group-replication-functions') !== 0) {
$mysql_functions[strtolower($match[3])] = [$match[1], $match[2]];
}
}
if (!$mysql_functions) {
fwrite(STDERR, "No functions found in built-in-function-reference.html\n");
exit(1);
}
// statements: chapter TOC titles like "15.1.2 ALTER DATABASE Statement"
$mysql_statements = [];
preg_match_all('~href="([\w-]+\.html)">(?:[\d.]+ )?([A-Z][A-Z0-9_ ]*?) (?:Statements?|Clause)<~', mysql_page('sql-statements'), $matches, PREG_SET_ORDER);
foreach ($matches as $match) {
$phrase = preg_replace('~\s+~', ' ', $match[2]);
if (!isset($mysql_statements[$phrase])) {
$mysql_statements[$phrase] = $match[1];
}
}
if (!$mysql_statements) {
fwrite(STDERR, "No statements found in sql-statements.html\n");
exit(1);
}
// reserved keywords are marked with (R)
preg_match_all('~([A-Z_0-9]+) \(R\)~', mysql_page('keywords'), $matches);
$mysql_keywords = array_unique($matches[1]);
if (!$mysql_keywords) {
fwrite(STDERR, "No keywords found in keywords.html\n");
exit(1);
}
// system variables (the option reference adds nothing settable in SET);
// some variables are documented only as options with dashed #option_mysqld_ anchors -
// their names get a [-_] alternation and jush.js finds the right form by probing links2
$mysql_sysvars = [];
preg_match_all('~href="([\w-]+\.html)#(sysvar|option_mysqld)_([\w-]+)">(\w+)<~', mysql_page('server-system-variable-reference'), $matches, PREG_SET_ORDER);
foreach ($matches as $match) {
if ((!isset($mysql_sysvars[$match[4]]) || $match[2] == 'sysvar') && !in_array($match[1], $skip_pages)) {
$mysql_sysvars[$match[4]] = [$match[1], $match[3], $match[2]];
}
}
if (!$mysql_sysvars) {
fwrite(STDERR, "No variables found in server-system-variable-reference.html\n");
exit(1);
}
// status variables
$mysql_status = [];
preg_match_all('~href="([\w-]+\.html)#statvar_([\w.-]+)">(\w+)<~', mysql_page('server-status-variable-reference'), $matches, PREG_SET_ORDER);
foreach ($matches as $match) {
if (!in_array($match[1], $skip_pages)) {
$mysql_status[$match[3]] = [$match[1], $match[2]];
}
}
if (!$mysql_status) {
fwrite(STDERR, "No variables found in server-status-variable-reference.html\n");
exit(1);
}
// Update the function groups of the hand-maintained 'page.html#function_$1' entries in place
list($block) = find_block($jush, 'sql');
list($hand) = set_region($block, 'statements', '');
list($hand) = set_region($hand, 'functions', '');
foreach (block_entries($hand) as $key => $regexp) {
if (preg_match('~^([\w-]+\.html)#function_\$1( |$)~', $key, $match)) {
$page = $match[1];
$names = [];
foreach ($mysql_functions as $name => $function) {
if ($function[0] == $page && $function[1] == str_replace('_', '-', $name)) {
$names[] = $name;
}
}
if (!$names) {
fwrite(STDERR, "Stale function page $page: not in the MySQL function reference\n");
continue;
}
$keywords = array_map('strtolower', explode('|', ltrim(preg_replace('~\(\?:.*~s', '', $regexp), '(')));
$names = array_values(array_diff($names, $keywords));
sort($names);
$start = strpos($jush, "'$key': /");
$end = strpos($jush, "\n", $start);
$entry = set_list(substr($jush, $start, $end - $start), '|(?:', ')(?=', $names, "$page functions");
$jush = substr_replace($jush, $entry, $start, $end - $start);
}
}
// Hand-maintained entries decide what the generated regions must not duplicate
list($block) = find_block($jush, 'sql');
list($hand) = set_region($block, 'statements', '');
list($hand) = set_region($hand, 'functions', '');
$hand_regexps = [];
foreach (block_entries($hand) as $key => $regexp) {
if ($key != '') {
$hand_regexps[] = $regexp;
}
}
// Partition functions: shared names link to both manuals, the rest to one
$function_groups = []; // entry key => names
$maria_only_functions = []; // names with a mechanical KB slug
foreach ($mysql_functions as $name => $function) {
if (is_covered($hand_regexps, $name, 'call')) {
continue;
}
list($page, $anchor) = $function;
$mysql_key = "$page#function_" . ($anchor == str_replace('_', '-', $name) ? '$1' : embed_name($anchor, str_replace('_', '-', $name)));
$maria_slug = ($maria_functions[$name] ?? '');
$maria_key = ($maria_slug == '' ? '-' : ($maria_slug == $name ? '$1' : embed_name($maria_slug, $name)) . '/');
$function_groups["$mysql_key $maria_key"][] = $name;
}
foreach ($maria_functions as $name => $slug) {
if (!isset($mysql_functions[$name]) && !is_covered($hand_regexps, $name, 'call')) {
if ($slug == $name) {
$maria_only_functions[] = $name;
} else {
$function_groups['- ' . embed_name($slug, $name) . '/'][] = $name;
}
}
}
// Partition statements; DATABASE pages also match SCHEMA (jush.js maps it back)
$shared_statements = [];
$mysql_only_statements = [];
$maria_only_statements = [];
$statement_exceptions = []; // entry key => phrases
foreach (array_keys($mysql_statements + $maria_statements) as $phrase) {
if (is_covered($hand_regexps, $phrase)) {
continue;
}
$mechanical = strtolower(str_replace(' ', '-', $phrase));
$mysql_key = (isset($mysql_statements[$phrase]) ? ($mysql_statements[$phrase] == "$mechanical.html" ? '$1.html' : embed_name($mysql_statements[$phrase], $mechanical)) : unknown_key($phrase, $mysql_keywords));
$maria_key = (isset($maria_statements[$phrase]) ? ($maria_statements[$phrase] == $mechanical ? '$1' : embed_name($maria_statements[$phrase], $mechanical)) . '/' : unknown_key($phrase, $maria_keywords));
if ($mysql_key == '$1.html' && $maria_key == '$1/') {
$shared_statements[] = $phrase;
} elseif ($mysql_key == '$1.html' && $maria_key == '-') {
$mysql_only_statements[] = $phrase;
} elseif ($mysql_key == '-' && $maria_key == '$1/') {
$maria_only_statements[] = $phrase;
} else {
$statement_exceptions["$mysql_key $maria_key"][] = $phrase;
}
}
// Rewrite the statements region: the exceptions, MariaDB-only statements and functions,
// MySQL-only statements and the shared list, ordered so that a longer phrase wins over its prefix
$entries = []; // [line, phrases]
ksort($statement_exceptions);
foreach ($statement_exceptions as $key => $phrases) {
$entries[] = ["\t'$key': /(" . schema_regexp(phrases_regexp($phrases)) . ")(?!\\()/,\n", $phrases];
}
$maria_only = ($maria_only_statements ? schema_regexp(phrases_regexp($maria_only_statements)) . '(?!\\()' : '');
if ($maria_only_functions) {
sort($maria_only_functions);
$maria_only .= ($maria_only ? '|' : '') . '(?:' . implode('|', $maria_only_functions) . ')(?=\\s*\\(|$)';
}
if ($maria_only != '') {
$entries[] = ["\t'- \$1/': /($maria_only)/,\n", $maria_only_statements];
}
if ($mysql_only_statements) {
$entries[] = ["\t'\$1.html -': /(" . schema_regexp(phrases_regexp($mysql_only_statements)) . ")(?!\\()/,\n", $mysql_only_statements];
}
$entries[] = ["\t'\$1.html': /(" . schema_regexp(phrases_regexp($shared_statements)) . ")(?!\\()/,\n", $shared_statements];
$lines = implode('', array_column(order_entries($entries), 0));
list($jush, $old_region) = set_region($jush, 'statements', $lines);
$old_statements = [];
foreach (block_entries($old_region) as $regexp) {
$regexp = str_replace('(?!\()', '', $regexp);
if (preg_match('~^\((.*)\)$~s', $regexp, $match)) {
$regexp = $match[1];
}
$old_statements = array_merge($old_statements, array_filter(expand_phrases($regexp), function ($phrase) {
// the SCHEMA variants only exist in the regexps, the doc pages use DATABASE
return preg_match('~^[A-Z0-9_ ]+$~', $phrase) && !preg_match('~\bSCHEMAS?\b~', $phrase);
}));
}
// the region also holds the MariaDB-only functions
preg_match_all('~\(\?:([\w|]+)\)\(\?=~', $old_region, $matches);
$old_maria_functions = ($matches[1] ? explode('|', implode('|', $matches[1])) : []);
$new_statements = array_merge($shared_statements, $mysql_only_statements, $maria_only_statements, ...array_values($statement_exceptions ?: [[]]));
sort($old_statements);
sort($new_statements);
report_diff('statements', array_unique($old_statements), $new_statements);
// Rewrite the functions region
$lines = '';
ksort($function_groups);
foreach ($function_groups as $key => $names) {
sort($names);
$lines .= "\t'$key': /(" . implode('|', $names) . ")(?=\\s*\\(|\$)/,\n";
}
list($jush, $old_region) = set_region($jush, 'functions', $lines);
$old_functions = $old_maria_functions;
foreach (block_entries($old_region) as $regexp) {
preg_match_all('~\w+~', str_replace(['(?:', '(?=\\s*\\(|$)'], '', $regexp), $matches);
$old_functions = array_merge($old_functions, $matches[0]);
}
$new_functions = array_merge($maria_only_functions, ...array_values($function_groups ?: [[]]));
sort($old_functions);
sort($new_functions);
report_diff('functions', array_unique($old_functions), $new_functions);
// The '' entry holds keywords with no doc page: subtract words linked by other entries
// but keep words linked only as function calls (their lookahead rejects a bare keyword)
$keywords = array_unique(array_map('strtoupper', array_merge($mysql_keywords, $maria_keywords)));
sort($keywords);
list($block) = find_block($jush, 'sql');
$linked = [];
foreach (block_entries($block) as $key => $regexp) {
if ($key != '') {
$linked[] = $regexp;
}
}
$keywords = array_values(array_filter($keywords, function ($keyword) use ($linked) {
return !is_covered($linked, $keyword, 'keyword');
}));
$jush = set_list($jush, "'': /(", ")(?!\\()/,", $keywords, 'keywords');
// Rewrite the sqlset block: system variables grouped by their page pair
$groups = [];
foreach (array_keys($mysql_sysvars + $maria_sysvars) as $name) {
$mysql_key = '-';
$regexp_name = $name;
if (isset($mysql_sysvars[$name])) {
list($page, $anchor, $kind) = $mysql_sysvars[$name];
$mechanical = ($kind == 'sysvar' ? $name : str_replace('_', '-', $name));
$mysql_key = "$page#{$kind}_" . ($anchor == $mechanical ? '$1' : embed_name($anchor, $mechanical));
if ($kind == 'option_mysqld') {
$regexp_name = str_replace('_', '[-_]', $name);
}
}
$maria_key = '-';
if (isset($maria_sysvars[$name])) {
list($page, $anchor) = $maria_sysvars[$name];
$maria_key = "$page/#" . ($anchor == strtolower($name) ? '$1' : embed_name($anchor, strtolower($name)));
}
$groups["$mysql_key $maria_key"][] = $regexp_name;
}
ksort($groups);
$lines = '';
foreach ($groups as $key => $names) {
sort($names);
$lines .= "\t'$key': /(" . implode('|', $names) . ")/,\n";
}
list($block, $start, $end) = find_block($jush, 'sqlset');
$old_sysvars = [];
foreach (block_entries($block) as $regexp) {
foreach (explode('|', $regexp) as $alternative) {
$old_sysvars[] = trim(str_replace('[-_]', '_', $alternative), '()');
}
}
report_diff('system variables', array_unique($old_sysvars), array_keys($mysql_sysvars + $maria_sysvars));
$jush = substr_replace($jush, rtrim($lines, "\n"), $start, $end - $start);
// Rewrite the sqlstatus block: whole pages are matched by a name prefix, the rest links
// to the big server-status-variables pages (MariaDB anchors are lowercased by jush.js)
$maria_pages = [];
foreach ($maria_status as $name => $status) {
$maria_pages[$status[0]][] = $name;
}
ksort($maria_pages);
$com_page = 'server-status-variables';
$lines = "\t'server-status-variables.html#statvar_Com_xxx $com_page/#\$1': /(Com_.+)/,\n";
foreach ($maria_pages as $page => $names) {
if ($page == 'server-status-variables') {
continue;
}
$prefix = array_reduce($names, function ($carry, $name) {
while ($carry !== null && strncasecmp($name, $carry, strlen($carry))) {
$carry = substr($carry, 0, -1);
}
return ($carry === null ? $name : $carry);
});
$prefix = preg_replace('~(_[^_]*|[^_]+)$~', '_', $prefix);
$mysql_key = '-';
foreach ($mysql_status as $name => $status) {
if ($prefix != '' ? !strncasecmp($name, $prefix, strlen($prefix)) : isset($maria_status[$name]) && $maria_status[$name][0] == $page) {
$mysql_key = "$status[0]#statvar_\$1";
break;
}
}
// a whole page is matched by the common name prefix, mixed pages list all their names
sort($names);
$lines .= "\t'$mysql_key $page/#\$1': /(" . (strlen($prefix) < 4 ? implode('|', $names) : "$prefix.+") . ")/,\n";
}
$lines .= "\t'server-status-variables.html#statvar_\$1 server-status-variables/#\$1': /(.+)/,\n";
list($block, $start, $end) = find_block($jush, 'sqlstatus');
$old_pages = [];
foreach (array_keys(block_entries($block)) as $key) {
if (preg_match('~(?:^|\s)([\w-]+)/#~', $key, $match)) {
$old_pages[] = $match[1];
}
}
report_diff('status pages', array_unique($old_pages), array_keys($maria_pages));
$jush = substr_replace($jush, rtrim($lines, "\n"), $start, $end - $start);
$jush = set_shadow_lookaheads($jush, 'sql');
file_put_contents($jush_file, $jush);
fwrite(STDERR, sprintf(
"MySQL: %d functions, %d statements, %d keywords, %d system variables, %d status variables\n",
count($mysql_functions), count($mysql_statements), count($mysql_keywords), count($mysql_sysvars), count($mysql_status)
));
fwrite(STDERR, sprintf(
"MariaDB: %d functions, %d statements, %d keywords, %d system variables, %d status variables\n",
count($maria_functions), count($maria_statements), count($maria_keywords), count($maria_sysvars), count($maria_status)
));
vrana-jush-d490483/update/sqlite.php 0000664 0000000 0000000 00000010065 15237625165 0017363 0 ustar 00root root 0000000 0000000 hd_fragment \w+ \{(\w+)\(\) SQL function}~m', read_file("$pages/lang_datefunc.in"), $matches);
$date = array_unique($matches[1]);
sort($date);
// JSON functions use tabentry (tabentryop defines the -> and ->> operators)
preg_match_all('~^tabentry \{([^}]*)\}~m', read_file("$pages/json1.in"), $matches);
$json = [];
foreach ($matches[1] as $syntax) {
preg_match_all('~(\w+)\(~', $syntax, $names);
$json = array_merge($json, $names[1]);
}
$json = array_unique($json);
sort($json);
// Built-in window functions are a list after the biwinfunc fragment
$window_page = read_file("$pages/windowfunctions.in");
preg_match_all('~(\w+)\(~', substr($window_page, strpos($window_page, 'hd_fragment biwinfunc')), $matches);
$window = array_unique($matches[1]);
sort($window);
// Pragmas are defined by Pragma, LegacyPragma, TestPragma, DebugPragma and DangerousPragma
preg_match_all('~^\w*Pragma\s+\{?(\w+)~m', read_file("$pages/pragma.in"), $matches);
$pragmas = array_unique($matches[1]);
sort($pragmas);
preg_match('~set keyword_list \[lsort \{(.*?)\}~s', read_file("$pages/lang_keywords.in"), $match);
if (!$match) {
fwrite(STDERR, "Can't find keyword_list in lang_keywords.in\n");
exit(1);
}
preg_match_all('~[A-Z][A-Z_0-9]*~', $match[1], $matches);
$keywords = array_merge($matches[0], ['EXCLUDED', 'FALSE', 'TRUE']); // not official keywords but the upsert alias and literals are highlighted too
sort($keywords);
$jush = read_file($jush_file);
$jush = set_list($jush, "'windowfunctions.html#\$1': /(", ")(?=", $window, 'window functions');
$jush = set_list($jush, "'lang_corefunc.html#\$1': /(", ")(?=", $core, 'core functions');
$jush = set_list($jush, "'lang_mathfunc.html#\$1': /(", ")(?=", $math, 'math functions');
$jush = set_list($jush, "'lang_datefunc.html#\$1': /(", ")(?=", $date, 'date functions');
$jush = set_list($jush, "'lang_aggfunc.html#\$1': /(", ")(?=", $aggregate, 'aggregate functions');
$jush = set_list($jush, "'json1.html#\$1': /(", ")(?=", $json, 'JSON functions');
// The '' entry holds keywords with no doc page: subtract single words linked by other entries
// (e.g. STRICT, not) but keep words linked only as part of a phrase (e.g. BY in PARTITION\s+BY)
// and words linked only as function calls (e.g. IF is a keyword but if( links to lang_corefunc)
if (!preg_match("~jush\\.build_links2\\('sqlite'.*?\n\\}\\);~s", $jush, $match)) {
fwrite(STDERR, "Can't find build_links2 block\n");
exit(1);
}
$covered = [];
preg_match_all("~^\t'([^']*)': /\\((.*)\\)/~m", $match[0], $matches, PREG_SET_ORDER);
foreach ($matches as $entry) {
if ($entry[1] != '' && strpos($entry[2], '(?=') === false) {
foreach (explode('|', $entry[2]) as $alternative) {
if (preg_match('~^\w+$~', $alternative)) {
$covered[] = strtoupper($alternative);
}
}
}
}
$keywords = array_values(array_diff($keywords, $covered));
$jush = set_list($jush, "'': /(", ")/,", $keywords, 'keywords');
$jush = set_list($jush, "jush.links2.sqliteset = /(\\b)(", ")(\\b)/gi", $pragmas, 'pragmas');
file_put_contents($jush_file, $jush);