phpmyadmin working

11 files changed, 1815 insertions, 0 deletions

diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/KBDocumentation.php b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/KBDocumentation.php
new file mode 100644
index 0000000..958f1ad
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/KBDocumentation.php
@@ -0,0 +1,75 @@
+<?php
+declare(strict_types = 1);
+namespace Williamdes\MariaDBMySQLKBS;
+
+use \stdClass;
+use \JsonSerializable;
+
+class KBDocumentation extends stdClass implements JsonSerializable
+{
+
+    /**
+     * The URL
+     *
+     * @var string
+     */
+    private $url;
+
+    /**
+     * The anchor
+     *
+     * @var string
+     */
+    private $anchor = null;
+
+    /**
+     * Create a KBEntry object
+     *
+     * @param string      $url    The url
+     * @param string|null $anchor The anchor
+     */
+    public function __construct(string $url, ?string $anchor = null)
+    {
+        $this->url = $url;
+        if ($anchor !== null) {
+            $this->anchor = $anchor;
+        }
+    }
+
+    /**
+     * Get the url
+     *
+     * @return string
+     */
+    public function getUrl(): string
+    {
+        return $this->url;
+    }
+
+    /**
+     * Get the anchor
+     *
+     * @return string|null
+     */
+    public function getAnchor(): ?string
+    {
+        return $this->anchor;
+    }
+
+    /**
+     * Used for json_encode function
+     * This can seem useless, do not remove it.
+     *
+     * @return array
+     */
+    public function jsonSerialize(): array
+    {
+        $outObj        = array();
+        $outObj['url'] = $this->url;
+        if ($this->anchor !== null) {
+            $outObj['anchor'] = $this->anchor;
+        }
+        return $outObj;
+    }
+
+}
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/KBEntry.php b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/KBEntry.php
new file mode 100644
index 0000000..7ff7e9c
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/KBEntry.php
@@ -0,0 +1,151 @@
+<?php
+declare(strict_types = 1);
+namespace Williamdes\MariaDBMySQLKBS;
+
+use \stdClass;
+use \JsonSerializable;
+
+class KBEntry extends stdClass implements JsonSerializable
+{
+
+    /**
+     * The name of the variable
+     *
+     * @var string
+     */
+    private $name;
+
+    /**
+     * Type of variable
+     *
+     * @var string
+     */
+    private $type = null;
+
+    /**
+     * Is dynamic ?
+     *
+     * @var bool
+     */
+    private $dynamic = null;
+
+    /**
+     * Documentations
+     *
+     * @var KBDocumentation[]
+     */
+    private $docs = null;
+
+    /**
+     * Create a KBEntry object
+     *
+     * @param string      $name    The name of the variable
+     * @param string|null $type    Type of variable
+     * @param bool|null   $dynamic Is dynamic ?
+     */
+    public function __construct(string $name, ?string $type, ?bool $dynamic)
+    {
+        $this->name = $name;
+        if ($type !== null) {
+            $this->type = $type;
+        }
+        if ($dynamic !== null) {
+            $this->dynamic = $dynamic;
+        }
+    }
+
+    /**
+     * Get the variable name
+     *
+     * @return string
+     */
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    /**
+     * Is the variable dynamic
+     *
+     * @return bool|null
+     */
+    public function isDynamic(): ?bool
+    {
+        return $this->dynamic;
+    }
+
+    /**
+     * Get the variable type
+     *
+     * @return string|null
+     */
+    public function getType(): ?string
+    {
+        return $this->type;
+    }
+
+    /**
+     * Variable has documentations
+     *
+     * @return bool
+     */
+    public function hasDocumentations(): bool
+    {
+        if ($this->docs === null) {
+            return false;
+        } else {
+            return count($this->docs) > 0;
+        }
+    }
+
+    /**
+     * Get all documentations
+     *
+     * @return KBDocumentation[]
+     */
+    public function getDocumentations(): array
+    {
+        return $this->docs;
+    }
+
+    /**
+     * Add documentation link
+     *
+     * @param string      $url    The URL
+     * @param string|null $anchor The anchor
+     * @return KBDocumentation
+     */
+    public function addDocumentation(string $url, ?string $anchor = null ): KBDocumentation
+    {
+        $this->url = $url;
+        if ($this->docs === null) {
+            $this->docs = array();
+        }
+        $kbd          = new KBDocumentation($url, $anchor);
+        $this->docs[] = $kbd;
+        return $kbd;
+    }
+
+    /**
+     * Used for json_encode function
+     * This can seem useless, do not remove it.
+     *
+     * @return array
+     */
+    public function jsonSerialize(): array
+    {
+        $outObj         = array();
+        $outObj['name'] = $this->name;
+        if ($this->type !== null) {
+            $outObj['type'] = $this->type;
+        }
+        if ($this->dynamic !== null) {
+            $outObj['dynamic'] = $this->dynamic;
+        }
+        if ($this->docs !== null) {
+            $outObj['docs'] = $this->docs;
+        }
+        return $outObj;
+    }
+
+}
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/KBException.php b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/KBException.php
new file mode 100644
index 0000000..05eea91
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/KBException.php
@@ -0,0 +1,12 @@
+<?php
+declare(strict_types = 1);
+namespace Williamdes\MariaDBMySQLKBS;
+
+use \Exception;
+
+/**
+ * KBException class
+ */
+class KBException extends Exception
+{
+}
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/MariaDB.js b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/MariaDB.js
new file mode 100644
index 0000000..a6f3c01
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/MariaDB.js
@@ -0,0 +1,271 @@
+'use strict';
+
+const common = require(__dirname + '/common');
+const cleaner = require(__dirname + '/cleaner');
+
+/**
+ * Create a doc element
+ * @param {Element} element The root element
+ * @returns object The doc object
+ */
+const createDoc = function($, element) {
+    let doc = {
+        id: $(element).attr('id'),
+        name: $(element)
+            .text()
+            .trim(),
+    };
+    try {
+        /* jshint -W083 */
+        // Parse ul > li
+        const ulElementList = $(element)
+            .nextAll()
+            .not('p')
+            .first();
+        if (ulElementList.find('li > strong').length === 0) {
+            return { id: null };
+        }
+        ulElementList.find('li').each((i, elementDescr) => {
+            const valueKey = $(elementDescr);
+            const key = valueKey
+                .find('strong')
+                .text()
+                .toLowerCase()
+                .trim();
+            const value = $(elementDescr)
+                .text()
+                .replace(valueKey.find('strong').text(), '')
+                .trim();
+            switch (key) {
+                case 'dynamic:':
+                    doc.dynamic = value.toLowerCase() === 'yes';
+                    break;
+                case 'scope:':
+                    doc.scope = value
+                        .toLowerCase()
+                        .split(',')
+                        .map(item => {
+                            if (item.match(/session/)) {
+                                return 'session';
+                            } else if (item.match(/global/)) {
+                                return 'global';
+                            } else {
+                                return item.trim();
+                            }
+                        });
+                    doc.scope = doc.scope.filter(function(e) {
+                        return e === 0 || e;
+                    });
+                    break;
+                case 'type:':
+                    doc.type = cleaner.cleanType(value.toLowerCase());
+                    break;
+                case 'data type:':
+                    /*
+                     * Default method, <li> has a <code> child
+                     * Example: <li><strong>Data Type:</strong> <code>numeric</code></li>
+                     */
+                    let dataType = valueKey.find('code');
+                    if (dataType.length > 0) {
+                        doc.type = cleaner.cleanType(
+                            dataType
+                                .first()
+                                .text()
+                                .toLowerCase()
+                                .trim()
+                        );
+                    } else {
+                        /*
+                         * Fallback method, <li> has text
+                         * Example: <li><strong>Data Type:</strong> boolean</li>
+                         */
+                        let dataType = value.replace(/undefined/gi, '');
+                        dataType = dataType.toLowerCase().trim();
+                        if (dataType !== '') {
+                            doc.type = cleaner.cleanType(dataType);
+                        } else if (dataType === '') {
+                            console.log('Empty datatype found for : ' + doc.id);
+                        } else {
+                            console.log('No datatype found for : ' + doc.id);
+                        }
+                    }
+                    break;
+                case 'description:':
+                    doc.type = cleaner.cleanType(value.toLowerCase());
+                    break;
+                case 'default value:':
+                case 'default:':
+                    doc.default = cleaner.cleanDefault(
+                        valueKey
+                            .text()
+                            .replace(valueKey.find('strong').text(), '')
+                            .trim()
+                    );
+                    break;
+                case 'valid values:':
+                    doc.validValues = valueKey
+                        .find('code')
+                        .get()
+                        .map(el => $(el).text());
+                    break;
+                case 'range:':
+                    doc.range = valueKey
+                        .find('code')
+                        .get()
+                        .map(el => $(el).text());
+                    if (doc.range.length === 1) {
+                        // try x-y
+                        doc.range = doc.range[0].split('-').map(item => item.trim());
+                    }
+                    if (doc.range.length === 1) {
+                        // try x to y
+                        doc.range = doc.range[0].split('to').map(item => item.trim());
+                    }
+                    if (doc.range[1] !== undefined) {
+                        doc.range[1] = parseFloat(doc.range[1]);
+                    }
+                    if (doc.range.length === 1) {
+                        // try x upwards
+                        if (value.includes('upwards')) {
+                            doc.range[1] = value;
+                        }
+                    }
+                    // Could be oneday a float
+                    doc.range = {
+                        from: parseFloat(doc.range[0]),
+                        to: doc.range[1],
+                    };
+                    doc.range = cleaner.cleanRange(doc.range);
+
+                    break;
+                case 'commandline:':
+                    if (
+                        typeof value === 'string' &&
+                        (value.toLowerCase() !== 'no' &&
+                            value.toLowerCase() !== 'none' &&
+                            value.toLowerCase() !== 'n/a' &&
+                            value.toLowerCase() !== 'no commandline option')
+                    ) {
+                        doc.cli = cleaner.cleanCli(value, true);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        });
+        /* jshint +W083 */
+    } catch (e) {
+        console.error(e);
+        console.log('Error at : #' + doc.id);
+    }
+    if (doc.type !== undefined) {
+        if (doc.type === 'numeric') {
+            doc.type = 'integer';
+        }
+    }
+    return doc;
+};
+
+function parsePage($, cbSuccess) {
+    var anchors = [];
+    $('.anchored_heading').each(function(i, el) {
+        let doc = createDoc($, el);
+        if (doc.id && typeof doc.id === 'string') {
+            anchors.push(doc);
+        }
+    });
+    cbSuccess(anchors);
+}
+
+const KB_URL = 'https://mariadb.com/kb/en/library/documentation/';
+
+const storageEngines = ['aria', 'myrocks', 'cassandra', 'galera-cluster', 'mroonga', 'myisam', 'tokudb', 'connect'];
+
+const systemVariables = ['xtradbinnodb-server', 'mariadb-audit-plugin', 'ssltls', 'performance-schema'];
+
+const custom = [
+    {
+        url: 'columns-storage-engines-and-plugins/storage-engines/spider/spider-server-system-variables/',
+        name: 'spider-server-system-variables',
+    },
+    {
+        url: 'semisynchronous-replication/',
+        name: 'semisynchronous-replication-system-variables',
+    },
+    {
+        url: 'replication-and-binary-log-server-system-variables/',
+        name: 'replication-and-binary-log-server-system-variables',
+    },
+    {
+        url: 'gtid/',
+        name: 'gtid-system-variables',
+    },
+    {
+        url: 'replication/optimization-and-tuning/system-variables/server-system-variables/',
+        name: 'server-system-variables',
+    },
+    {
+        url: 'system-versioned-tables/',
+        name: 'versioned-tables-system-variables',
+    },
+];
+
+const status = [
+    'server',
+    'galera-cluster',
+    'aria-server',
+    'cassandra',
+    'mroonga',
+    'spider-server',
+    'sphinx',
+    'tokudb',
+    'xtradbinnodb-server',
+    'replication-and-binary-log',
+    'oqgraph-system-and',
+    'thread-pool-system-and',
+    'ssltls',
+    'mariadb-audit-plugin',
+    'semisynchronous-replication-plugin',
+];
+
+const pages = [];
+
+storageEngines.forEach(se => {
+    pages.push({
+        url: KB_URL + 'columns-storage-engines-and-plugins/storage-engines/' + se + '/' + se + '-system-variables/',
+        name: se + '-system-variables',
+    });
+});
+
+custom.forEach(cu => {
+    pages.push({
+        url: KB_URL + cu.url,
+        name: cu.name,
+    });
+});
+
+status.forEach(statusName => {
+    pages.push({
+        url: KB_URL + statusName + '-status-variables/',
+        name: statusName + '-status-variables',
+    });
+});
+
+systemVariables.forEach(systemVariableName => {
+    pages.push({
+        url: KB_URL + systemVariableName + '-system-variables/',
+        name: systemVariableName + '-system-variables',
+    });
+});
+
+module.exports = {
+    run: () => {
+        /*var pages = [
+            {
+                url: 'http://7.2.local/Global%20Transaction%20ID%20-%20MariaDB%20Knowledge%20Base.html',
+                name: 'gtid-system-variables'
+            }
+        ]*/
+        return common.processDataExtraction(pages, 'mariadb-', parsePage);
+    },
+};
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/MySQL.js b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/MySQL.js
new file mode 100644
index 0000000..99f4561
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/MySQL.js
@@ -0,0 +1,251 @@
+'use strict';
+
+const common = require(__dirname + '/common');
+const cleaner = require(__dirname + '/cleaner');
+
+/**
+ * Complete a doc element with info found in table
+ * @param {HTMLTableRowElement[]} rows The table rows
+ * @param {Object} doc The doc object
+ */
+function completeDoc($, rows, doc) {
+    $(rows).each((i, elem) => {
+        let tds = $(elem).find('td'); // first is key and last is value
+        var name = tds
+            .first()
+            .text()
+            .toLowerCase()
+            .trim();
+        var value = tds.last();
+        switch (name) {
+            case 'dynamic':
+                doc.dynamic =
+                    value
+                        .text()
+                        .toLowerCase()
+                        .trim() === 'yes';
+                break;
+            case 'name':
+                doc.name = value.text().trim();
+                break;
+            case 'system variable':
+                // Do not overwrite the name
+                if (typeof doc.name === 'undefined') {
+                    doc.name = value
+                        .text()
+                        .toLowerCase()
+                        .trim();
+                }
+                break;
+            case 'scope':
+                let scope = value.text().toLowerCase();
+                if (scope === 'both') {
+                    // found on mysql-cluster-options-variables.html
+                    doc.scope = ['global', 'session'];
+                } else if (scope != '') {
+                    doc.scope = scope.split(',').map(item => {
+                        if (item.match(/session/)) {
+                            return 'session';
+                        } else if (item.match(/global/)) {
+                            return 'global';
+                        } else {
+                            return item.trim();
+                        }
+                    });
+                }
+                if (doc.scope !== undefined) {
+                    doc.scope = doc.scope.filter(function(e) {
+                        return e === 0 || e;
+                    });
+                }
+                break;
+            case 'type':
+                let type = value
+                    .text()
+                    .toLowerCase()
+                    .trim();
+                if (type != '') {
+                    doc.type = cleaner.cleanType(type);
+                }
+                break;
+            case 'default value':
+            case 'default, range':
+                doc.default = cleaner.cleanDefault(value.text().trim());
+                break;
+            case 'valid values':
+                doc.validValues = $(value)
+                    .find('code')
+                    .get()
+                    .map(el => $(el).text());
+                break;
+            case 'minimum value':
+                if (doc.range == undefined) {
+                    doc.range = {};
+                }
+                doc.range.from = parseFloat(value.text().trim());
+                break;
+            case 'maximum value':
+                if (doc.range == undefined) {
+                    doc.range = {};
+                }
+                doc.range.to = parseFloat(value.text().trim());
+                break;
+            case 'command-line format':
+                doc.cli = cleaner.cleanCli(value.text().trim());
+                break;
+            case 'command line':
+                if (typeof doc.cli !== 'string') {
+                    doc.cli =
+                        value
+                            .text()
+                            .toLowerCase()
+                            .trim() === 'yes';
+                }
+                break;
+        }
+    });
+}
+
+/**
+ * Create a doc element
+ * @param {Element} element The root element
+ * @returns object The doc object
+ */
+function createDoc($, element, doc) {
+    completeDoc($, $(element).find('tbody > tr'), doc);
+    if (doc.range !== undefined) {
+        doc.range = cleaner.cleanRange(doc.range);
+    }
+
+    if (doc.name && doc.name.match(cleaner.regexCli)) {
+        delete doc.name;
+    }
+
+    return doc;
+}
+
+function parsePage($, cbSuccess) {
+    var anchors = [];
+    $('.informaltable, .table')
+        .filter(function(i, elem) {
+            return (
+                $(elem)
+                    .find('th')
+                    .first()
+                    .text() === 'Property'
+            );
+        })
+        .each(function(i, elem) {
+            let doc = {
+                id: $(elem)
+                    .prevAll()
+                    .find('a')
+                    .filter(function(i, el) {
+                        return typeof $(el).attr('name') === 'string' && typeof $(el).attr('class') === 'undefined';
+                    })
+                    .first()
+                    .attr('name'),
+            };
+            if (typeof doc.id !== 'string') {
+                doc.id = $(elem)
+                    .prevAll()
+                    .find('.link')
+                    .first()
+                    .attr('href')
+                    .split('#')[1];
+            }
+            createDoc($, elem, doc);
+            if (typeof doc.cli === 'boolean') {
+                doc.cli = $(elem)
+                    .prevAll()
+                    .find('.option')
+                    .first()
+                    .text();
+                if (doc.cli === '') {
+                    delete doc.cli;
+                }
+            }
+            if (!doc.name && doc.cli) {
+                var matches = doc.cli.match(cleaner.regexCli);
+                doc.name = matches[2].replace(/-/g, '_');
+            }
+            anchors.push(doc);
+        });
+
+    cbSuccess(anchors);
+}
+
+const KB_URL = 'https://dev.mysql.com/doc/refman/8.0/en/';
+const KB_URL57 = 'https://dev.mysql.com/doc/refman/5.7/en/';
+
+const pages = [
+    {
+        url: KB_URL + 'server-system-variables.html',
+        name: 'server-system-variables',
+    },
+    {
+        url: KB_URL + 'innodb-parameters.html',
+        name: 'innodb-parameters',
+    },
+    {
+        url: KB_URL + 'performance-schema-system-variables.html',
+        name: 'performance-schema-system-variables',
+    },
+    {
+        url: KB_URL + 'x-plugin-options-system-variables.html',
+        name: 'x-plugin-options-system-variables',
+    },
+    {
+        url: KB_URL + 'replication-options-binary-log.html',
+        name: 'replication-options-binary-log',
+    },
+    {
+        url: KB_URL57 + 'replication-options-binary-log.html',
+        name: 'replication-options-binary-log_5.7',
+    },
+    {
+        url: KB_URL + 'pluggable-authentication-system-variables.html',
+        name: 'pluggable-authentication-system-variables',
+    },
+    {
+        url: KB_URL + 'audit-log-reference.html',
+        name: 'audit-log-reference',
+    },
+    {
+        url: KB_URL + 'replication-options-gtids.html',
+        name: 'replication-options-gtids',
+    },
+    {
+        url: KB_URL + 'replication-options-slave.html',
+        name: 'replication-options-slave',
+    },
+    {
+        url: KB_URL + 'replication-options-master.html',
+        name: 'replication-options-master',
+    },
+    {
+        url: KB_URL + 'replication-options.html',
+        name: 'replication-options',
+    },
+    {
+        url: KB_URL57 + 'mysql-cluster-options-variables.html',
+        name: 'mysql-cluster-options-variables',
+    },
+    {
+        url: KB_URL + 'server-options.html',
+        name: 'server-options',
+    },
+    {
+        url: KB_URL + 'version-tokens-reference.html',
+        name: 'version-tokens-reference',
+    },
+];
+
+module.exports = {
+    parsePage: parsePage,
+    createDoc: createDoc,
+    completeDoc: completeDoc,
+    run: () => {
+        return common.processDataExtraction(pages, 'mysql-', parsePage);
+    },
+};
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/Search.php b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/Search.php
new file mode 100644
index 0000000..12f8ded
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/Search.php
@@ -0,0 +1,167 @@
+<?php
+declare(strict_types = 1);
+namespace Williamdes\MariaDBMySQLKBS;
+
+use \stdClass;
+
+class Search
+{
+
+    /**
+     * Loaded data
+     *
+     * @var mixed
+     */
+    public static $data;
+
+    /**
+     * Data is loaded
+     *
+     * @var bool
+     */
+    public static $loaded = false;
+
+    public const ANY        = -1;
+    public const MYSQL      = 1;
+    public const MARIADB    = 2;
+    public const DS         = DIRECTORY_SEPARATOR;
+    public static $DATA_DIR = __DIR__.self::DS."..".self::DS."dist".self::DS;
+
+    /**
+     * Load data from disk
+     *
+     * @return void
+     * @throws KBException
+     */
+    public static function loadData(): void
+    {
+        if (Search::$loaded === false) {
+            $filePath = Search::$DATA_DIR."merged-ultraslim.json";
+            $contents = @file_get_contents($filePath);
+            if ($contents === false) {
+                throw new KBException("$filePath does not exist !");
+            }
+            Search::$data   = json_decode($contents);
+            Search::$loaded = true;
+        }
+    }
+
+    /**
+     * Load test data
+     *
+     * @param SlimData $slimData The SlimData object
+     * @return void
+     */
+    public static function loadTestData(SlimData $slimData): void
+    {
+        Search::$data   = json_decode((string) json_encode($slimData));
+        Search::$loaded = true;
+    }
+
+    /**
+     * get the first link to doc available
+     *
+     * @param string $name Name of variable
+     * @param int    $type (optional) Type of link Search::MYSQL/Search::MARIADB/Search::ANY
+     * @return string
+     * @throws KBException
+     */
+    public static function getByName(string $name, int $type = Search::ANY): string
+    {
+        self::loadData();
+        $kbEntrys = self::getVariable($name);
+        if (isset($kbEntrys->a)) {
+            foreach ($kbEntrys->a as $kbEntry) {
+                if ($type === Search::ANY) {
+                    return Search::$data->urls[$kbEntry->u]."#".$kbEntry->a;
+                } elseif ($type === Search::MYSQL) {
+                    if ($kbEntry->t === Search::MYSQL) {
+                        return Search::$data->urls[$kbEntry->u]."#".$kbEntry->a;
+                    }
+                } elseif ($type === Search::MARIADB) {
+                    if ($kbEntry->t === Search::MARIADB) {
+                        return Search::$data->urls[$kbEntry->u]."#".$kbEntry->a;
+                    }
+                }
+            }
+        }
+
+        throw new KBException("$name does not exist for this type of documentation !");
+    }
+
+    /**
+     * Get a variable
+     *
+     * @param string $name Name of variable
+     * @return stdClass
+     * @throws KBException
+     */
+    public static function getVariable(string $name): stdClass
+    {
+        self::loadData();
+        if (isset(Search::$data->vars->{$name})) {
+            return Search::$data->vars->{$name};
+        } else {
+            throw new KBException("$name does not exist !");
+        }
+    }
+
+    /**
+     * get the type of the variable
+     *
+     * @param string $name Name of variable
+     * @return string
+     * @throws KBException
+     */
+    public static function getVariableType(string $name): string
+    {
+        self::loadData();
+        $kbEntry = self::getVariable($name);
+        if (isset($kbEntry->t)) {
+            return Search::$data->varTypes->{$kbEntry->t};
+        } else {
+            throw new KBException("$name does have a known type !");
+        }
+    }
+
+    /**
+     * Return the list of static variables
+     *
+     * @return array
+     */
+    public static function getStaticVariables(): array
+    {
+        return self::getVariablesWithDynamic(false);
+    }
+
+    /**
+     * Return the list of dynamic variables
+     *
+     * @return array
+     */
+    public static function getDynamicVariables(): array
+    {
+        return self::getVariablesWithDynamic(true);
+    }
+
+    /**
+     * Return the list of variables having dynamic = $dynamic
+     *
+     * @param bool $dynamic dynamic=true/dynamic=false
+     * @return array
+     */
+    public static function getVariablesWithDynamic(bool $dynamic): array
+    {
+        self::loadData();
+        $staticVars = array();
+        foreach (Search::$data->vars as $name => $var) {
+            if (isset($var->d)) {
+                if ($var->d === $dynamic) {
+                    $staticVars[] = $name;
+                }
+            }
+        }
+        return $staticVars;
+    }
+
+}
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/SlimData.php b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/SlimData.php
new file mode 100644
index 0000000..fc7cd42
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/SlimData.php
@@ -0,0 +1,162 @@
+<?php
+declare(strict_types = 1);
+namespace Williamdes\MariaDBMySQLKBS;
+
+use \stdClass;
+use \JsonSerializable;
+
+class SlimData extends stdClass implements JsonSerializable
+{
+
+    /**
+     * Variables
+     *
+     * @var KBEntry[]
+     */
+    private $vars = array();
+
+    /**
+     * File revision
+     *
+     * @var float
+     */
+    private $version = 1;
+
+    /**
+     * Urls
+     *
+     * @var string[]
+     */
+    private $urls = array();
+
+    /**
+     * Types of documentation
+     *
+     * @var array<string, string|int>
+     */
+    private $types = array("MYSQL" => 1, "MARIADB" => 2);
+
+    /**
+     * Types of variables
+     *
+     * @var array<string, string|int>
+     */
+    private $varTypes = array(
+        "string" => 1,
+        "boolean" => 2,
+        "integer" => 3,
+        "numeric" => 4,
+        "enumeration" => 5,
+        "set" => 6,
+        "directory name" => 7,
+        "file name" => 8,
+        "byte" => 9
+    );
+
+    /**
+     * Create a slimData object
+     *
+     * @param float|null                 $version  The version
+     * @param array<string, string>|null $types    The types of documentations
+     * @param array<string, string>|null $varTypes The types of variables
+     */
+    public function __construct(
+        ?float $version = null,
+        ?array $types = null,
+        ?array $varTypes = null
+    ) {
+        if ($version !== null) {
+            $this->version = $version;
+        }
+
+        if ($types !== null) {
+            $this->types = $types;
+        }
+
+        if ($varTypes !== null) {
+            $this->varTypes = $varTypes;
+        }
+    }
+
+    /**
+     * Add a variable
+     *
+     * @param string      $name    The name
+     * @param string|null $type    The type
+     * @param bool|null   $dynamic Is dynamic
+     * @return KBEntry The newly created KBEntry
+     */
+    public function addVariable(string $name, ?string $type, ?bool $dynamic): KBEntry
+    {
+        $kbe          = new KBEntry($name, $type, $dynamic);
+        $this->vars[] = $kbe;
+        return $kbe;
+    }
+
+    /**
+     * Used for json_encode function
+     * This can seem useless, do not remove it.
+     *
+     * @return array
+     */
+    public function jsonSerialize(): array
+    {
+        $outObj = array();
+        if (count($this->vars) > 0) {
+            $vars = new stdClass();
+            foreach ($this->vars as $var) {
+                $variable    = new stdClass();
+                $variable->d = $var->isDynamic();
+                if ($variable->d === null) {
+                    unset($variable->d);
+                }
+
+                if ($var->getType() !== null) {
+                    if (isset($this->varTypes[$var->getType()]) === false) {
+                        $this->varTypes[$var->getType()] = "".(count($this->varTypes) + 1);
+                    }
+
+                    $variable->t = $this->varTypes[$var->getType()];
+                }
+
+                if ($var->hasDocumentations()) {
+                    $variable->a = array();
+                    foreach ($var->getDocumentations() as $kbd) {
+                        $entry    = new stdClass();
+                        $entry->a = $kbd->getAnchor();
+                        if ($entry->a === null) {
+                            unset($entry->a);
+                        }
+                        if (preg_match("!^(https|http)://mariadb.com!", $kbd->getUrl())) {
+                            $entry->t = $this->types["MARIADB"];
+                        } elseif (preg_match("!^(https|http)://dev.mysql.com!", $kbd->getUrl())) {
+                            $entry->t = $this->types["MYSQL"];
+                        }
+                        if (isset($entry->t)) {// If has no valid type, skip.
+                            //Do not allow other urls.
+                            $keyIndex = array_search($kbd->getUrl(), $this->urls);
+                            if ($keyIndex === false) {
+                                $this->urls[] = $kbd->getUrl();
+                            }
+                            $keyIndex = array_search($kbd->getUrl(), $this->urls);
+                            $entry->u = $keyIndex;
+
+                            $variable->a[] = $entry;
+                        }
+                    }
+                }
+
+                $vars->{$var->getName()} = $variable;
+            }
+            $outObj['vars'] = $vars;
+        }
+        $outObj['version'] = $this->version;
+        if (count($this->vars) > 0) {
+            $outObj['types']    = array_flip($this->types);
+            $outObj['varTypes'] = array_flip($this->varTypes);
+            $outObj['urls']     = $this->urls;
+        }
+        return $outObj;
+    }
+
+}
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/cleaner.js b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/cleaner.js
new file mode 100644
index 0000000..c15d51a
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/cleaner.js
@@ -0,0 +1,128 @@
+'use strict';
+
+const realTypes = [
+    'string',
+    'boolean',
+    'integer',
+    'numeric',
+    'enumeration',
+    'set',
+    'directory name',
+    'file name',
+    'byte',
+];
+
+/**
+ * Clean type using real types
+ * @param {String} type The type
+ * @return {String|undefined} The cleaned type
+ */
+const cleanType = function(type) {
+    if (realTypes.includes(type) === false && typeof type === 'string') {
+        if (type.match(/in bytes/i) || type.match(/number of bytes/i) || type.match(/size in mb/i)) {
+            type = 'byte';
+        } else if (
+            type.match(/number of/i) ||
+            type.match(/size of/i) ||
+            type.match(/in microseconds/i) ||
+            type.match(/in seconds/i)
+        ) {
+            type = 'integer';
+        } else if (
+            type.match(/numeric (64-bit unsigned integer)/i) ||
+            type.match(/numeric (32-bit unsigned integer)/i)
+        ) {
+            type = 'numeric';
+        } else {
+            type = undefined;
+        }
+    }
+    return type;
+};
+
+const regexCli = /([-]{2})([0-9a-z-_]+)/i;
+
+/**
+ * Clean cli argument
+ * @param {String} cli The command line string
+ * @param {boolean} skipRegex Skip regex check
+ * @returns {String} The cleaned cli
+ */
+const cleanCli = function(cli, skipRegex = false) {
+    if (typeof cli === 'string') {
+        if (cli.match(/<code\>/i) || cli.match(/<\/code\>/i)) {
+            cli = cli.replace(/<code\>/gi, '');
+            cli = cli.replace(/<\/code\>/gi, '');
+            cli = cli.replace(/\>/gi, '');
+            cli = cli.replace(/</gi, '');
+        }
+        if (!cli.match(regexCli) && skipRegex === false) {
+            cli = undefined;
+        }
+    }
+    return cli;
+};
+
+/**
+ * Clean the range object
+ * @param {Object} range The range object
+ * @returns {Object} The cleaned range object
+ */
+const cleanRange = function(range) {
+    if (range !== undefined) {
+        // clean range
+        if (typeof range.from !== 'number' || isNaN(range.from)) {
+            delete range.from;
+        }
+        if (typeof range.to === 'string' && range.to.match(/upwards/i)) {
+            range.to = 'upwards';
+        } else if (typeof range.to !== 'number' || isNaN(range.to)) {
+            delete range.to;
+        }
+    }
+    return range;
+};
+
+/**
+ * Clean a default value
+ * @param {String} defaultValue The default value
+ * @returns {String} The same or an alternative formated text
+ */
+const cleanDefault = function(defaultValue) {
+    return defaultValue
+        .split('\n')
+        .map(el => cleanTextDefault(el.trim()))
+        .join(', ');
+};
+
+/**
+ * Clean text of a default value
+ * @param {String} defaultTextValue The default text value
+ * @returns {String} The same or an alternative text
+ */
+const cleanTextDefault = function(defaultTextValue) {
+    if (defaultTextValue === 'Autosized (see description)') {
+        defaultTextValue = '(autosized)';
+    }
+    if (defaultTextValue.indexOf('Based on the number of processors') !== -1) {
+        defaultTextValue = '(based on the number of processors)';
+    }
+    if (defaultTextValue === 'The MariaDB data directory') {
+        defaultTextValue = '(the MariaDB data directory)';
+    }
+    if (defaultTextValue.match(/-1 \(signifies (autoscaling); do not assign this literal value\)/g)) {
+        defaultTextValue = '(-1 signifies autoscaling; do not use -1)';
+    }
+    if (defaultTextValue.match(/-1 \(signifies (autosizing); do not assign this literal value\)/g)) {
+        defaultTextValue = '(-1 signifies autosizing; do not use -1)';
+    }
+    return defaultTextValue;
+};
+
+module.exports = {
+    regexCli: regexCli,
+    cleanType: cleanType,
+    cleanCli: cleanCli,
+    cleanRange: cleanRange,
+    cleanDefault: cleanDefault,
+};
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/common.js b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/common.js
new file mode 100644
index 0000000..d9274dc
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/common.js
@@ -0,0 +1,113 @@
+'use strict';
+
+const fs = require('fs');
+const Crawler = require('crawler');
+const path = require('path');
+
+/**
+ * Sort the object keys
+ * @see https://stackoverflow.com/a/48112249/5155484
+ * @param {Object} obj The object
+ * @param {Function} arraySorter The sorter callback
+ */
+const sortObject = function(obj, arraySorter) {
+    if (typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        if (arraySorter) {
+            obj.sort(arraySorter);
+        }
+        for (var i = 0; i < obj.length; i++) {
+            obj[i] = sortObject(obj[i], arraySorter);
+        }
+        return obj;
+    }
+    var temp = {};
+    var keys = [];
+    for (var key in obj) {
+        keys.push(key);
+    }
+    keys.sort();
+    for (var index in keys) {
+        temp[keys[index]] = sortObject(obj[keys[index]], arraySorter);
+    }
+    return temp;
+};
+
+const writeJSON = function(filename, data, cbSuccess = null) {
+    fs.writeFile(filename, JSON.stringify(sortObject(data), null, 2) + '\n', function(err) {
+        if (err) {
+            return console.log(err);
+        } else {
+            if (cbSuccess !== null) {
+                cbSuccess();
+            }
+        }
+    });
+};
+
+const readJSON = function(filename, callbackSuccess) {
+    fs.readFile(filename, 'utf8', function(err, data) {
+        if (err) {
+            return console.log(err);
+        }
+        callbackSuccess(JSON.parse(data), filename);
+    });
+};
+
+const listDirectory = function(dirname, callbackSuccess) {
+    fs.readdir(dirname, (err, files) => {
+        if (err) {
+            return console.log(err);
+        }
+        callbackSuccess(files, dirname);
+    });
+};
+
+const writePage = function(filePrefix, name, url, data, onWriteSuccess) {
+    let pageKB = {
+        url: url,
+        name: name,
+        data: data,
+    };
+    writeJSON(path.join(__dirname, '../', 'data', filePrefix + pageKB.name + '.json'), pageKB, onWriteSuccess);
+};
+
+const processDataExtraction = function(pages, filePrefix, parsePage) {
+    return new Promise(resolve => {
+        var nbrPagesProcessed = 0;
+        var crawler = new Crawler({
+            maxConnections: 1,
+            // This will be called for each crawled page
+            callback: function(error, res, done) {
+                if (error) {
+                    console.log(error);
+                } else {
+                    console.log('URL : ' + res.options.url);
+                    parsePage(res.$, anchors => {
+                        writePage(filePrefix, res.options.name, res.options.url, anchors, () => {
+                            nbrPagesProcessed++;
+                            if (nbrPagesProcessed === pages.length) {
+                                resolve();
+                            }
+                        });
+                    });
+                }
+                done();
+            },
+        });
+        crawler.queue(
+            pages.map(page => {
+                return { uri: page.url, name: page.name, url: page.url };
+            })
+        );
+    });
+};
+
+module.exports = {
+    processDataExtraction: processDataExtraction,
+    listDirectory: listDirectory,
+    readJSON: readJSON,
+    writeJSON: writeJSON,
+};
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/index.js b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/index.js
new file mode 100644
index 0000000..e0308f1
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/index.js
@@ -0,0 +1,13 @@
+'use strict';
+const MariaDB = require('./MariaDB.js');
+const MySQL = require('./MySQL.js');
+
+console.log('Run build...');
+
+Promise.all([MariaDB.run(), MySQL.run()])
+    .then(() => {
+        console.log('All done.');
+    })
+    .then(() => {
+        console.log('End !');
+    });
diff --git a/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/merge.php b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/merge.php
new file mode 100644
index 0000000..471cab1
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/williamdes/mariadb-mysql-kbs/src/merge.php
@@ -0,0 +1,472 @@
+<?php
+declare(strict_types = 1);
+$dataDir = __DIR__."/../data/";
+$files   = glob("$dataDir*.json");
+
+/**
+ * Compare 2 variables
+ *
+ * @param mixed $var1 First
+ * @param mixed $var2 Second
+ * @return bool
+ */
+function JSONcompare($var1, $var2): bool
+{
+    return json_encode($var1) === json_encode($var2);
+}
+
+/**
+ * Fix key=range
+ *
+ * @param stdClass $current Current value
+ * @param stdClass $cache   Cache value
+ * @return void
+ */
+function fixRange(stdClass &$current, stdClass &$cache): void
+{
+        global $newData, $key, $nbrConflictsSolved;
+    $currentHasFrom = isset($current->from);
+    $cacheHasFrom   = isset($cache->from);
+    $currentHasTo   = isset($current->to);
+    $cacheHasTo     = isset($cache->to);
+    if ($currentHasFrom === false && $cacheHasFrom === true) {
+        $current->from = $cache->from;
+        if (JSONcompare($cache, $current)) {
+            $newData->$key = $current;
+            if (JSONcompare($current, $cache)) {
+                $nbrConflictsSolved++;
+            } else {
+                fixRange($current, $cache);
+            }
+        }
+    } elseif ($currentHasFrom === true && $cacheHasFrom === false) {
+        $cache->from = $current->from;
+        if (JSONcompare($cache, $current)) {
+            $newData->$key = $cache;
+            if (JSONcompare($current, $cache)) {
+                $nbrConflictsSolved++;
+            } else {
+                fixRange($current, $cache);
+            }
+        }
+    } elseif ($currentHasTo === false && $cacheHasTo === true) {
+        $current->to = $cache->to;
+        if (JSONcompare($cache, $current)) {
+            $newData->$key = $current;
+            if (JSONcompare($current, $cache)) {
+                $nbrConflictsSolved++;
+            } else {
+                fixRange($current, $cache);
+            }
+        }
+    } elseif ($currentHasTo === true && $cacheHasTo === false) {
+        $cache->to = $current->to;
+        if (JSONcompare($cache, $current)) {
+            $newData->$key = $cache;
+            if (JSONcompare($current, $cache)) {
+                $nbrConflictsSolved++;
+            } else {
+                fixRange($current, $cache);
+            }
+        }
+    } elseif (( $currentHasFrom === true && $currentHasFrom === true )
+        && ( $cache->from === $current->from )
+    ) {
+        $onlyFrom       = new stdClass();
+        $onlyFrom->from = $current->from;
+        $newData->$key  = $onlyFrom;
+        $nbrConflictsSolved++;
+        echo '[WARN] conflict range to - '.json_encode($cache).' - '.json_encode($current).PHP_EOL;
+    } else {
+        echo '[ERROR] conflict range - '.json_encode($cache).' - '.json_encode($current).PHP_EOL;
+    }
+}
+
+$variables = array();
+
+$nbr                = 0;
+$nbrConflicts       = 0;
+$nbrConflictsSolved = 0;
+foreach ($files as $file) {
+    $fileData = json_decode(file_get_contents($file));
+    if (isset($fileData->data) === false) {
+        continue;
+    } else {
+        $data = $fileData->data;
+    }
+
+    foreach ($data as $doc) {
+        $identifier = $doc->name;
+        if (isset($identifier)) {
+            if (isset($variables[$identifier]) === false) {
+                if (isset($doc->ids) === false) {
+                    $doc->ids = array();
+                }
+                $variables[$identifier] = $doc;
+                $kbEntry                = new stdClass();
+                $kbEntry->anchor        = $doc->id;
+                $kbEntry->url           = $fileData->url;
+                $doc->ids[]             = $kbEntry;
+                unset($doc->id);
+            } else {
+                if (isset($doc->ids) === false) {
+                    $doc->ids = array();
+                }
+                $kbEntry         = new stdClass();
+                $kbEntry->anchor = $doc->id;
+                $kbEntry->url    = $fileData->url;
+                $doc->ids[]      = $kbEntry;
+                unset($doc->id);
+                //echo $identifier." duplicate ! in ".str_replace($dataDir, "", $file).PHP_EOL;
+                $newData = new stdClass();
+                foreach ((array) $doc as $key => $val) {
+                    if (isset($variables[$identifier]->$key)) {
+                        $cacheValue = $variables[$identifier]->$key;
+                        $docValue   = $doc->$key;
+                        if ((                            strtoupper(json_encode($cacheValue)) === strtoupper(json_encode($docValue)))
+                            && (                            json_encode($cacheValue) !== json_encode($docValue))
+                        ) {
+                            $nbrConflicts++;
+                            $nbrConflictsSolved++;
+                            //echo 'upper conflict '.$key.' - '.json_encode($cacheValue).' - '.json_encode($docValue).PHP_EOL;
+                            $docValue = strtoupper(json_encode($docValue));
+                        } elseif (json_encode($cacheValue) !== json_encode($docValue)) {
+                            $nbrConflicts++;
+                            if ($key === "type") {
+                                $realTypes = array(
+                                    "string",
+                                    "boolean",
+                                    "integer",
+                                    "numeric",
+                                    "enumeration",
+                                    "set",
+                                    "directory name",
+                                    "file name",
+                                    "byte"
+                                );
+                                if (in_array($cacheValue, $realTypes)// original
+                                    && in_array($docValue, $realTypes) === false// dupe
+                                ) {//original type valid
+                                    echo 'original type valid : '.$cacheValue.PHP_EOL;
+                                } elseif (in_array($cacheValue, $realTypes) === false// original
+                                    && in_array($docValue, $realTypes)// dupe
+                                ) {// dupe type valid
+                                    $newData->$key = $docValue;
+                                    //echo 'dupe type valid : '.$docValue.PHP_EOL;
+                                    $nbrConflictsSolved++;
+                                } else {
+                                    if ((                                        json_encode($cacheValue) === '"numeric"'
+                                        && json_encode($docValue) === '"integer"')
+                                        || (                                        json_encode($cacheValue) === '"integer"'
+                                        && json_encode($docValue) === '"numeric"')
+                                    ) {// numeric vs integer
+                                        //echo "integer wins !".PHP_EOL;
+                                        $newData->$key = "integer";
+                                        $nbrConflictsSolved++;
+                                    } else {
+                                        echo 'type conflict : '.json_encode($cacheValue).' - '.json_encode($docValue).PHP_EOL;
+                                    }
+                                }
+                            } elseif ($key === "ids") {
+                                /*if (isset($newData->ids) === false) {
+                                    $newData->ids = array();
+                                }*/
+                                $newData->ids = array_merge($cacheValue, $docValue);
+                                /*$source = array("_", "option-mysqld-", "sysvar-", );
+                                $destination = array("-", "","");
+                                if (// Replace prefix to see if same id
+                                    str_replace($source, $destination, $docValue)
+                                    ===
+                                    str_replace($source, $destination, $cacheValue)
+                                ) {
+                                    $newData->$key = str_replace($source, $destination, $docValue);
+                                    $nbrConflictsSolved++;// TODO: check if good idea
+                                } else {
+                                    echo '[ERROR] conflict id : '
+                                    .json_encode($cacheValue)
+                                    .' - '
+                                    .json_encode($docValue)
+                                    .' - '
+                                    .str_replace($source, $destination, $docValue)
+                                    .' - '
+                                    .str_replace($source, $destination, $cacheValue)
+                                    .PHP_EOL;
+                                }*/
+                            } elseif ($key === "default") {
+                                $originalValues    = array("on", "off", "ON", "OFF", "true", "false", "TRUE", "FALSE");
+                                $destinationValues = array("1", "0", "1", "0", "1", "0", "1", "0");
+                                $docValue          = str_replace($originalValues, $destinationValues, $docValue);
+                                $cacheValue        = str_replace($originalValues, $destinationValues, $cacheValue);
+                                if ($docValue === $cacheValue) {
+                                    $newData->$key = $docValue;
+                                    $nbrConflictsSolved++;
+                                } else {
+                                    if (is_array($cacheValue) === false
+                                        && is_array($docValue) === false
+                                    ) {
+                                        if (floatval($cacheValue) === floatval($docValue)) {
+                                            $newData->$key = $docValue;
+                                            $nbrConflictsSolved++;
+                                        } else {
+                                            echo '[ERROR] conflict default, not array : '.json_encode($cacheValue).' - '.json_encode($docValue).PHP_EOL;
+                                        }
+                                    } else {
+                                        echo '[ERROR] conflict default : '.json_encode($cacheValue).' - '.json_encode($docValue).PHP_EOL;
+                                    }
+                                }
+                            } elseif ($key === "validValues") {
+                                if (is_array($cacheValue) === false) {
+                                    $cacheValue = array($cacheValue);
+                                }
+                                if (is_array($docValue) === false) {
+                                    $docValue = array($docValue);
+                                }
+                                $intersecValidValues = array_intersect($docValue, $cacheValue);
+                                if (count($intersecValidValues) === count($docValue)
+                                    && count($intersecValidValues) === count($cacheValue)
+                                ) {// No variables were lost in process
+                                    $newData->$key = $intersecValidValues;
+                                    $nbrConflictsSolved++;
+                                } elseif (array_values(array_diff($docValue, $cacheValue)) === array("32768","65536")
+                                ) {// Missing translation (in bytes) for 32k and 64k
+                                    $intersecValidValues[] = "32768";
+                                    $intersecValidValues[] = "65536";
+                                    $newData->$key         = array_values($intersecValidValues);
+                                    $nbrConflictsSolved++;
+                                } elseif (strtoupper(json_encode(ksort($docValue))) === strtoupper(json_encode(ksort($cacheValue)))
+                                ) {// uppercase / lowercase
+                                    ksort($cacheValue);
+                                    $newData->$key = json_decode(json_encode($cacheValue));
+                                    $nbrConflictsSolved++;
+                                } else {
+                                    echo '[ERROR] conflict validValues : '
+                                    .json_encode($cacheValue)
+                                    .' - '
+                                    .json_encode($docValue)
+                                    .' - '
+                                    .json_encode($intersecValidValues)
+                                    .' - '
+                                    .json_encode(array_values(array_diff($docValue, $cacheValue))).PHP_EOL;
+                                }
+                            } elseif ($key === "cli") {
+                                $replaceSource      = array("file", "dir_name", "-- ", "_");
+                                $replaceDest        = array("path", "path", "--", "-");
+                                $replacedDocValue   = str_replace($replaceSource, $replaceDest, $docValue);
+                                $replacedCacheValue = str_replace($replaceSource, $replaceDest, $cacheValue);
+                                if (str_replace($replaceSource, $replaceDest, $docValue) === str_replace($replaceSource, $replaceDest, $cacheValue)
+                                ) {//Try replacements
+                                    $newData->$key = str_replace($replaceSource, $replaceDest, $docValue);
+                                    $nbrConflictsSolved++;
+                                } elseif (str_replace("--", "", $docValue) === str_replace("--", "", $cacheValue)
+                                ) {// Doc not well formated, missing -- before cli command
+                                    $newData->$key = "--".str_replace("--", "", $docValue);
+                                    $nbrConflictsSolved++;
+                                } elseif (strlen(str_replace(str_replace("#", "", $docValue), "", $cacheValue)) !== strlen($cacheValue)
+                                ) {// More precise doc, value hint, eg: --blablabla={0|1}
+                                    $newData->$key = $cacheValue;
+                                    $nbrConflictsSolved++;
+                                } elseif (strlen(
+                                    str_replace(
+                                        str_replace(
+                                            array("#"),
+                                            array(""),
+                                            $replacedDocValue
+                                        ), "", $replacedCacheValue
+                                    )
+                                ) !== strlen($replacedCacheValue)
+                                ) {// More precise doc, value hint, eg: --blablabla={0|1} using replaced values
+                                    $newData->$key = $replacedCacheValue;
+                                    $nbrConflictsSolved++;
+                                } elseif (strlen(
+                                    str_replace(
+                                        str_replace(
+                                            array("#"),
+                                            array(""),
+                                            $replacedCacheValue
+                                        ), "", $replacedDocValue
+                                    )
+                                ) !== strlen($replacedDocValue)
+                                ) {// More precise doc, value hint, eg: --blablabla={0|1} using replaced values, reversed: cache/doc
+                                    $newData->$key = $replacedDocValue;
+                                    $nbrConflictsSolved++;
+                                } elseif (strlen(str_replace(str_replace(array("#"), array(""), $docValue), "", $cacheValue)) !== strlen($cacheValue)
+                                ) {// More precise doc, value hint, eg: --blablabla={0|1}
+                                    $newData->$key = $cacheValue;
+                                    $nbrConflictsSolved++;
+                                } elseif (strlen(str_replace($cacheValue, "", $docValue)) !== strlen($docValue)
+                                ) {// contained in cache
+                                    $newData->$key = $docValue;
+                                    $nbrConflictsSolved++;
+                                } elseif (strlen(str_replace($docValue, "", $cacheValue)) !== strlen($cacheValue)
+                                ) {// contained in conflict
+                                    $newData->$key = $cacheValue;
+                                    $nbrConflictsSolved++;
+                                } else {
+                                    echo '[ERROR] conflict cli : cacheValue: '
+                                    .json_encode($cacheValue)
+                                    .' - docValue: '
+                                    .json_encode($docValue)
+                                    .' - docValue: '
+                                    .str_replace($replaceSource, $replaceDest, $docValue)
+                                    .' - cacheValue: '
+                                    .str_replace($replaceSource, $replaceDest, $cacheValue)
+                                    .PHP_EOL;
+                                }
+                            } elseif ($key === "range") {
+                                $current = $docValue;
+                                $cache   = $cacheValue;
+                                fixRange($current, $cache);
+                            } else {
+                                echo '[ERROR] conflict '.$key.' + '.$identifier.' - '.json_encode($cacheValue).' - '.json_encode($docValue).PHP_EOL;
+                            }
+                        } else {
+                            $newData->$key = $val;
+                        }
+                    } else {
+                        $newData->$key = $val;
+                    }
+                }
+                //print_r($newData);
+                $variables[$identifier] = $newData;
+            }
+        }
+    }
+    $nbr += count($data);
+}
+echo "NBR: ".$nbr.PHP_EOL;
+echo "NBR_UNIQUE: ".count($variables).PHP_EOL;
+echo "NBR_CONFLICTS: ".$nbrConflicts.PHP_EOL;
+echo "NBR_CONFLICTS_SOLVED: ".$nbrConflictsSolved.PHP_EOL;
+echo "NBR_CONFLICTS_REMAINING: ".($nbrConflicts - $nbrConflictsSolved).PHP_EOL;
+
+$fileOut          = new stdClass();
+$fileOut->vars    = json_decode(json_encode($variables));
+$fileOut->version = 1.0;
+
+$md = "# Variables and options".PHP_EOL;
+foreach ($fileOut->vars as $id => $doc) {
+    //$md .= "## ".$doc->url.PHP_EOL;
+    $md .= "## ".$doc->name.PHP_EOL;
+    $md .= "|name|value|".PHP_EOL;
+    $md .= "|----|-----|".PHP_EOL;
+    if (isset($doc->name)) {
+        $md .= "|Name|`$doc->name`|".PHP_EOL;
+    }
+    if (isset($doc->cli)) {
+        $md .= "|Command line|`$doc->cli`|".PHP_EOL;
+    }
+    if (isset($doc->type)) {
+        $md .= "|Type of variable|`$doc->type`|".PHP_EOL;
+    }
+    if (isset($doc->scope)) {
+        $md .= "|Scope|`".implode("`, `", $doc->scope)."`|".PHP_EOL;
+    }
+    if (isset($doc->default)) {
+        $md .= "|Default value|`$doc->default`|".PHP_EOL;
+    }
+    if (isset($doc->dynamic)) {
+        $md .= "|Dynamic|`".( ($doc->dynamic) ? 'true' : 'false')."`|".PHP_EOL;
+    }
+    if (empty($doc->validValues) === false) {
+        $md .= "|Valid value(s)|`".implode("`, `", $doc->validValues)."`|".PHP_EOL;
+    }
+    if (isset($doc->range)) {
+        $r = '';
+        if (isset($doc->range->from)) {
+            $r .= "from: `".$doc->range->from."`";
+        }
+
+        if (isset($doc->range->to)) {
+            if (isset($doc->range->from)) {
+                $r .= " ";
+            }
+            $r .= "to: `".$doc->range->to."`";
+        }
+        $md .= "|Range|$r|".PHP_EOL;
+    }
+    $md .= PHP_EOL;
+    $md .= "### Documentation(s)".PHP_EOL;
+    $md .= "|source|anchor name|".PHP_EOL;
+    $md .= "|------|----|".PHP_EOL;
+    foreach ($doc->ids as &$kbEntry) {
+        $matchs = array();
+        preg_match("/:\/\/([a-z.]+)/i", $kbEntry->url, $matchs);
+        $md .= "|$matchs[1]|[$kbEntry->anchor]($kbEntry->url#$kbEntry->anchor)|".PHP_EOL;
+    }
+    $md .= PHP_EOL;
+}
+
+file_put_contents(__DIR__."/../dist/merged-raw.md", $md.PHP_EOL);
+
+file_put_contents(__DIR__."/../dist/merged-raw.json", json_encode($fileOut, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES).PHP_EOL);
+
+$fileOut->urls = array();
+
+foreach ($fileOut->vars as $id => $doc) {
+    foreach ($doc->ids as &$kbEntry) {
+        $urlId = array_search($kbEntry->url, $fileOut->urls, true);
+        if ($urlId === false) {
+            $urlId = array_push($fileOut->urls, $kbEntry->url);
+        }
+        $kbEntry->url = $urlId;
+        $kbEntry      = "$urlId#$kbEntry->anchor";
+    }
+}
+$fileOut->version = 1.0;
+file_put_contents(__DIR__."/../dist/merged-slim.json", json_encode($fileOut, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES).PHP_EOL);
+
+$fileOut->vars     = json_decode(json_encode($variables));
+$fileOut->types    = array( "MYSQL" => 1, "MARIADB" => 2 );
+$fileOut->varTypes = array(
+    "string" => 1,
+    "boolean" => 2,
+    "integer" => 3,
+    "numeric" => 4,
+    "enumeration" => 5,
+    "set" => 6,
+    "directory name" => 7,
+    "file name" => 8,
+    "byte" => 9
+);
+foreach ($fileOut->vars as $id => &$doc) {
+    $data = new stdClass();
+    if (isset($doc->dynamic)) {
+        $data->d = $doc->dynamic;
+    }
+    if (isset($doc->type)) {
+        $data->t = $fileOut->varTypes[$doc->type];
+    }
+    $data->a = array();
+    foreach ($doc->ids as &$kbEntry) {
+        $urlId = array_search($kbEntry->url, $fileOut->urls, true);
+        if ($urlId === false) {
+            $urlId = array_push($fileOut->urls, $kbEntry->url);
+        }
+        $kbEntryMin    = new stdClass();
+        $kbEntryMin->a = $kbEntry->anchor;
+
+        $kbEntryMin->u = $urlId;
+        if (preg_match("/mysql\.com/", $kbEntry->url)) {
+            $kbEntryMin->t = $fileOut->types["MYSQL"];
+        } elseif (preg_match("/mariadb\.com/", $kbEntry->url)) {
+            $kbEntryMin->t = $fileOut->types["MARIADB"];
+        }
+        $data->a[] = $kbEntryMin;
+    }
+    $doc = $data;
+}
+$fileOut->types    = array_flip($fileOut->types);
+$fileOut->varTypes = array_flip($fileOut->varTypes);
+$fileOut->version  = 1.0;
+file_put_contents(__DIR__."/../dist/merged-ultraslim.json", json_encode($fileOut, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES).PHP_EOL);
+
+$content = '<?php'.PHP_EOL.'$data = '.json_encode($fileOut, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES).';'.PHP_EOL;
+
+$content = str_replace(
+    array("{", "}", ":"),
+    array("[", "]", "=>"),
+    $content
+);
+
+file_put_contents(__DIR__."/../dist/merged-ultraslim.php", $content);
+echo "Files merged !".PHP_EOL;