jsonConvertToArray with JSON_INVALID_UTF8_IGNORE does not work

json_decode JSON_INVALID_UTF8_IGNORE is not honoring any of those flags at the moment

.eslintrc.js

@@ -1,43 +0,0 @@
-module.exports = {
-	'env': {
-		'browser': true,
-		'es6': true,
-		'commonjs': true,
-		'jquery': true
-	},
-	'extends': 'eslint:recommended',
-	'parserOptions': {
-		'ecmaVersion': 6
-	},
-	'rules': {
-		'indent': [
-			'error',
-			'tab',
-			{
-				'SwitchCase': 1
-			}
-		],
-		'linebreak-style': [
-			'error',
-			'unix'
-		],
-		'quotes': [
-			'error',
-			'single'
-		],
-		'semi': [
-			'error',
-			'always'
-		],
-		'no-console': 'off',
-		'no-unused-vars': [
-			'error', {
-				'vars': 'all',
-				'args': 'after-used',
-				'ignoreRestSiblings': false
-			}
-		],
-		// Requires eslint >= v8.14.0
-		'no-constant-binary-expression': 'error'
-	}
-};

.gitignore

@@ -5,3 +5,6 @@ vendor/
 tools/
 www/composer.lock
 www/vendor
+**/.env
+**/.target
+package-lock.json

.phan/config.php

@@ -26,8 +26,8 @@
 use Phan\Config;
 
 return [
-	// "target_php_version" => "8.2",
-	"minimum_target_php_version" => "8.2",
+	// "target_php_version" => "8.3",
+	"minimum_target_php_version" => "8.3",
 	// turn color on (-C)
 	"color_issue_messages_if_supported" => true,
 	// If true, missing properties will be created when

.phive/phars.xml

@@ -1,12 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phive xmlns="https://phar.io/phive">
-  <phar name="phpunit" version="^9.6" installed="9.6.21" location="./tools/phpunit" copy="false"/>
-  <phar name="phpcbf" version="^3.7.2" installed="3.10.3" location="./tools/phpcbf" copy="false"/>
-  <phar name="phpcs" version="^3.7.2" installed="3.10.3" location="./tools/phpcs" copy="false"/>
-  <phar name="phpstan" version="^1.10.37" installed="1.12.4" location="./tools/phpstan" copy="false"/>
-  <phar name="phan" version="^5.4.2" installed="5.4.3" location="./tools/phan" copy="false"/>
-  <phar name="psalm" version="^5.15.0" installed="5.24.0" location="./tools/psalm" copy="false"/>
+  <phar name="phpunit" version="~9.6" installed="9.6.31" location="./tools/phpunit" copy="false"/>
+  <phar name="phpcbf" version="4" installed="4.0.1" location="./tools/phpcbf" copy="false"/>
+  <phar name="phpcs" version="4" installed="4.0.1" location="./tools/phpcs" copy="false"/>
+  <phar name="phpstan" version="^2.0" installed="2.1.33" location="./tools/phpstan" copy="false"/>
+  <phar name="phan" version="^5.4.3" installed="5.5.2" location="./tools/phan" copy="false"/>
+  <phar name="psalm" version="^5.26.1" installed="5.26.1" location="./tools/psalm" copy="false"/>
   <phar name="phpdox" version="^0.12.0" installed="0.12.0" location="./tools/phpdox" copy="false"/>
-  <phar name="phpdocumentor" version="^3.4.2" installed="3.4.3" location="./tools/phpDocumentor" copy="false"/>
-  <phar name="php-cs-fixer" version="^3.34.1" installed="3.57.2" location="./tools/php-cs-fixer" copy="false"/>
+  <phar name="phpdocumentor" version="^3.4.2" installed="3.9.1" location="./tools/phpDocumentor" copy="false"/>
+  <phar name="php-cs-fixer" version="^3.34.1" installed="3.92.4" location="./tools/php-cs-fixer" copy="false"/>
 </phive>

4dev/checking/phan.sh

@@ -1,5 +1,100 @@
-base="/storage/var/www/html/developers/clemens/core_data/php_libraries/trunk/";
+#!/bin/env bash
+
+function error() {
+	if [ -t 1 ]; then echo "[MAK] ERROR: $*" >&2; fi; exit 0;
+}
+
+usage() {
+	cat <<EOF
+Usage: $(basename "${BASH_SOURCE[0]}") [-h | --help] [-p | --php VERSION] [-c | --composer]
+
+Runs phan static analyzer.
+
+If -p is not set, the default intalled PHP is used.
+
+Available options:
+
+-h, --help        Print this help and exit
+-p, --php VERSION Chose PHP version in the form of "N.N", if not found will exit
+-c, --composer    Use composer version and not the default phives bundle
+EOF
+	exit
+}
+
+BASE_PATH=$(pwd)"/";
+PHP_BIN_PATH=$(which php);
+if [ -z "${PHP_BIN_PATH}" ]; then
+	echo "Cannot find php binary";
+	exit;
+fi;
+DEFAULT_PHP_VERSION=$(${PHP_BIN_PATH} -r "echo PHP_MAJOR_VERSION.'.'.PHP_MINOR_VERSION;");
+if [ -z "${DEFAULT_PHP_VERSION}" ]; then
+	echo "Cannot set default PHP version";
+	exit;
+fi;
+php_version="";
+no_php_version=0;
+use_composer=0;
+while [ -n "${1-}" ]; do
+	case "${1}" in
+		-p | --php)
+			php_version="${2-}";
+			shift
+			;;
+		-c | --composer)
+			use_composer=1;
+			shift
+			;;
+		-h | --help)
+			usage
+			;;
+		# invalid option
+		-?*)
+			error "[!] Unknown option: '$1'."
+			;;
+	esac
+	shift;
+done;
+if [ -z "${php_version}" ]; then
+	php_version="${DEFAULT_PHP_VERSION}";
+	no_php_version=1;
+fi;
+php_bin="${PHP_BIN_PATH}${php_version}";
+echo "Use PHP Version: ${php_version}";
+if [ "${use_composer}" -eq 1 ]; then
+	echo "Use composer installed";
+else
+	echo "Use phive installed";
+fi;
+
+if [ ! -f "${php_bin}" ]; then
+	echo "Set php ${php_bin} does not exist";
+	exit;
+fi;
+
 # must be run in ${base}
-cd $base;
-${base}tools/phan --progress-bar -C --analyze-twice;
-cd ~;
+cd "$BASE_PATH" || exit;
+export PHAN_DISABLE_XDEBUG_WARN=1;
+PHAN_CALL=(
+	"${php_bin}"
+);
+if [ "${use_composer}" -eq 1 ]; then
+	PHAN_CALL+=("${BASE_PATH}vendor/bin/phan");
+else
+	PHAN_CALL+=("${BASE_PATH}tools/phan");
+fi;
+PHAN_CALL+=(
+	"--progress-bar"
+	"-C"
+	"--analyze-twice"
+)
+"${PHAN_CALL[@]}";
+if [ "${no_php_version}" -eq 0 ]; then
+	echo "*** CALLED WITH PHP ${php_bin} ***";
+	${php_bin} --version;
+else
+	echo "Default PHP used: $(php --version)";
+fi;
+cd ~ || exit;
+
+# __END__

4dev/checking/phpstan.sh

@@ -1,5 +1,92 @@
-base="/storage/var/www/html/developers/clemens/core_data/php_libraries/trunk/";
-# must be run in ${base}
-cd $base;
-${base}tools/phpstan;
-cd ~;
+#!/bin/env bash
+
+function error() {
+	if [ -t 1 ]; then echo "[MAK] ERROR: $*" >&2; fi; exit 0;
+}
+
+usage() {
+	cat <<EOF
+Usage: $(basename "${BASH_SOURCE[0]}") [-h] [-h | --help] [-p | --php VERSION] [-c | --composer]
+
+Runs phan static analyzer.
+
+If -p is not set, the default intalled PHP is used.
+
+Available options:
+
+-h, --help        Print this help and exit
+-p, --php VERSION Chose PHP version in the form of "N.N", if not found will exit
+-c, --composer    Use composer version and not the default phives bundle
+EOF
+	exit
+}
+
+BASE_PATH=$(pwd)"/";
+PHP_BIN_PATH=$(which php);
+if [ -z "${PHP_BIN_PATH}" ]; then
+	echo "Cannot find php binary";
+	exit;
+fi;
+DEFAULT_PHP_VERSION=$(${PHP_BIN_PATH} -r "echo PHP_MAJOR_VERSION.'.'.PHP_MINOR_VERSION;");
+if [ -z "${DEFAULT_PHP_VERSION}" ]; then
+	echo "Cannot set default PHP version";
+	exit;
+fi;
+php_version="";
+no_php_version=0;
+use_composer=0;
+while [ -n "${1-}" ]; do
+	case "${1}" in
+		-p | --php)
+			php_version="${2-}";
+			shift
+			;;
+		-c | --composer)
+			use_composer=1;
+			shift
+			;;
+		-h | --help)
+			usage
+			;;
+		# invalid option
+		-?*)
+			error "[!] Unknown option: '$1'."
+			;;
+	esac
+	shift;
+done;
+if [ -z "${php_version}" ]; then
+	php_version="${DEFAULT_PHP_VERSION}";
+	no_php_version=1;
+fi;
+php_bin="${PHP_BIN_PATH}${php_version}";
+echo "Use PHP Version: ${php_version}";
+if [ "${use_composer}" -eq 1 ]; then
+	echo "Use composer installed";
+else
+	echo "Use phive installed";
+fi;
+
+if [ ! -f "${php_bin}" ]; then
+	echo "Set php ${php_bin} does not exist";
+	exit;
+fi;
+
+BASE_PATH=$(pwd)"/";
+cd "$BASE_PATH" || exit;
+PHPSTAN_CALL=(
+	"${php_bin}"
+);
+if [ "${use_composer}" -eq 1 ]; then
+	PHPSTAN_CALL+=("${BASE_PATH}vendor/bin/phpstan");
+else
+	PHPSTAN_CALL+=("${BASE_PATH}tools/phpstan");
+fi;
+"${PHPSTAN_CALL[@]}";
+if [ "${no_php_version}" -eq 0 ]; then
+	echo "*** CALLED WITH PHP ${php_bin} ***";
+	${php_bin} --version;
+else
+	echo "Default PHP used: $(php --version)";
+fi;
+cd ~ || exit;

4dev/checking/phpunit.sh

@@ -1,49 +1,119 @@
 #!/bin/env bash
 
-base="/storage/var/www/html/developers/clemens/core_data/php_libraries/trunk/";
+function error() {
+	if [ -t 1 ]; then echo "[MAK] ERROR: $*" >&2; fi; exit 0;
+}
+
+usage() {
+	cat <<EOF
+Usage: $(basename "${BASH_SOURCE[0]}") [-h | --help] [-p | --php VERSION] [-c | --composer] [-t | --testdox] [-v | --verbose]
+
+Runs all the PHP unit tests.
+
+If -p is not set, the default intalled PHP is used.
+
+Available options:
+
+-h, --help        Print this help and exit
+-t, --testdox     Enable testdox output for PHPunit
+-v, --verbose     Enable verbose output for PHPunit
+-c, --composer    Use composer version and not the default phives bundle
+-p, --php VERSION Chose PHP version in the form of "N.N", if not found will exit
+EOF
+	exit
+}
+
+# set base variables
+BASE_PATH=$(pwd)"/";
+PHPUNIT_CONFIG="${BASE_PATH}phpunit.xml";
+PHP_BIN_PATH=$(which php);
+if [ -z "${PHP_BIN_PATH}" ]; then
+	echo "Cannot find php binary";
+	exit;
+fi;
+DEFAULT_PHP_VERSION=$(${PHP_BIN_PATH} -r "echo PHP_MAJOR_VERSION.'.'.PHP_MINOR_VERSION;");
+if [ -z "${DEFAULT_PHP_VERSION}" ]; then
+	echo "Cannot set default PHP version";
+	exit;
+fi;
 # -c phpunit.xml
 # --testdox
-# call with "t" to give verbose testdox output
+# call with "-tt" to give verbose testdox output
 # SUPPORTED: https://www.php.net/supported-versions.php
-# call with php version number to force a certain php version
+# call with -p <php version number> to force a certain php version
 
 opt_testdox="";
-if [ "${1}" = "t" ] || [ "${2}" = "t" ]; then
-	opt_testdox="--testdox";
-fi;
-php_bin="";
-if [ -n "${1}" ]; then
+opt_verbose="";
+php_version="";
+no_php_version=0;
+use_composer=0;
+while [ -n "${1-}" ]; do
 	case "${1}" in
-		# "7.3") php_bin="/usr/bin/php7.3 "; ;;
-		# "7.4") php_bin="/usr/bin/php7.4 "; ;;
-		# "8.0") php_bin="/usr/bin/php8.0 "; ;;
-		# "8.1") php_bin="/usr/bin/php8.1 "; ;;
-		"8.2") php_bin="/usr/bin/php8.2 "; ;;
-		"8.3") php_bin="/usr/bin/php8.4 "; ;;
-		*) echo "Not support PHP: ${1}"; exit; ;;
-	esac;
+		-t | --testdox)
+			opt_testdox="--testdox";
+			;;
+		-v | --verbose)
+			opt_verbose="--verbose";
+			;;
+		-c | --composer)
+			use_composer=1;
+			shift
+			;;
+		-p | --php)
+			php_version="${2-}";
+			shift
+			;;
+		-h | --help)
+			usage
+			;;
+		# invalid option
+		-?*)
+			error "[!] Unknown option: '$1'."
+			;;
+	esac
+	shift;
+done;
+
+if [ -z "${php_version}" ]; then
+	php_version="${DEFAULT_PHP_VERSION}";
+	no_php_version=1;
 fi;
-if [ -n "${2}" ] && [ -z "${php_bin}" ]; then
-	case "${2}" in
-		# "7.3") php_bin="/usr/bin/php7.3 "; ;;
-		# "7.4") php_bin="/usr/bin/php7.4 "; ;;
-		# "8.0") php_bin="/usr/bin/php8.0 "; ;;
-		# "8.1") php_bin="/usr/bin/php8.1 "; ;;
-		"8.2") php_bin="/usr/bin/php8.2 "; ;;
-		"8.3") php_bin="/usr/bin/php8.3 "; ;;
-		*) echo "Not support PHP: ${1}"; exit; ;;
-	esac;
+php_bin="${PHP_BIN_PATH}${php_version}";
+echo "Use PHP Version: ${php_version}";
+if [ "${use_composer}" -eq 1 ]; then
+	echo "Use composer installed";
+else
+	echo "Use phive installed";
+fi;
+
+if [ ! -f "${php_bin}" ]; then
+	echo "Set php ${php_bin} does not exist";
+	exit;
 fi;
 
 # Note 4dev/tests/bootstrap.php has to be set as bootstrap file in phpunit.xml
-phpunit_call="${php_bin}${base}vendor/bin/phpunit ${opt_testdox} -c ${base}phpunit.xml ${base}4dev/tests/";
-
-${phpunit_call};
-
-if [ ! -z "${php_bin}" ]; then
-	echo "CALLED WITH PHP: ${php_bin}"$(${php_bin} --version);
+PHPUNIT_CALL=(
+	"${php_bin}"
+);
+if [ "${use_composer}" -eq 1 ]; then
+	PHPUNIT_CALL+=("${BASE_PATH}vendor/bin/phpunit");
 else
-	echo "Default PHP used: "$(php --version);
+	PHPUNIT_CALL+=("${BASE_PATH}tools/phpunit");
+fi;
+PHPUNIT_CALL+=(
+	"${opt_testdox}"
+	"${opt_verbose}"
+	"-c" "${PHPUNIT_CONFIG}"
+	"${BASE_PATH}4dev/tests/"
+);
+"${PHPUNIT_CALL[@]}" || exit;
+
+echo -e "\nPHPUnit Config: ${PHPUNIT_CONFIG}";
+if [ "${no_php_version}" -eq 0 ]; then
+	echo "*** CALLED WITH PHP ${php_bin} ***";
+	${php_bin} --version;
+else
+	echo "Default PHP used: $(php --version)";
 fi;
 
 # __END__

4dev/database/table/edit_log.sql

@@ -10,8 +10,8 @@ CREATE TABLE edit_log (
     edit_log_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
     euid INT, -- this is a foreign key, but I don't nedd to reference to it
     FOREIGN KEY (euid) REFERENCES edit_user (edit_user_id) MATCH FULL ON UPDATE CASCADE ON DELETE SET NULL,
-    ecuid VARCHAR,
-    ecuuid UUID, -- this is the one we want to use, full UUIDv4 from the edit user table
+    eucuid VARCHAR,
+    eucuuid UUID, -- this is the one we want to use, full UUIDv4 from the edit user table
     -- date_created equal, but can be overridden
     event_date TIMESTAMP WITHOUT TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     -- session ID if set

4dev/database/table/generic.sql

@@ -9,5 +9,6 @@
 CREATE TABLE generic (
     date_created TIMESTAMP WITHOUT TIME ZONE DEFAULT clock_timestamp(),
     date_updated TIMESTAMP WITHOUT TIME ZONE,
+    uuid UUID DEFAULT gen_random_uuid(),
     uid VARCHAR
 );

4dev/tests/AAASetupData/requests/http_requests.php

@@ -48,7 +48,7 @@ header("Content-Type: application/json; charset=UTF-8");
 if (!empty($http_headers['HTTP_AUTHORIZATION']) && !empty($http_headers['HTTP_RUNAUTHTEST'])) {
 	header("HTTP/1.1 401 Unauthorized");
 	print buildContent($http_headers, '{"code": 401, "content": {"Error": "Not Authorized"}}');
-	exit;
+	exit(1);
 }
 
 // if server request type is get set file_get to null -> no body
@@ -57,7 +57,7 @@ if ($_SERVER['REQUEST_METHOD'] == "GET") {
 } elseif (($file_get = file_get_contents('php://input')) === false) {
 	header("HTTP/1.1 404 Not Found");
 	print buildContent($http_headers, '{"code": 404, "content": {"Error": "file_get_contents failed"}}');
-	exit;
+	exit(1);
 }
 
 print buildContent($http_headers, $file_get);

4dev/tests/ACL/CoreLibsACLLoginTest.php

@@ -12,6 +12,8 @@ Not yet covered tests:
 - loginGetLocale
 - loginGetHeaderColor
 - loginGetPages
+- loginGetPageLookupList
+- loginPageAccessAllowed
 - loginGetEuid
 */
 
@@ -152,7 +154,6 @@ final class CoreLibsACLLoginTest extends TestCase
 		// TARGET
 		define('TARGET', 'test');
 		// LOGIN DB SCHEMA
-		// define('LOGIN_DB_SCHEMA', '');
 
 		// SHOULD SET
 		// DEFAULT_ACL_LEVEL (d80)
@@ -1531,6 +1532,12 @@ final class CoreLibsACLLoginTest extends TestCase
 				$login_mock->loginGetEditAccessCuidFromUid($mock_settings['edit_access_uid']),
 				'Assert check access uid to cuid valid'
 			);
+			// - loginGetEditAccessCuidFromId
+			$this->assertEquals(
+				$expected['check_access_cuid'],
+				$login_mock->loginGetEditAccessCuidFromUid($mock_settings['edit_access_id']),
+				'Assert check access id to cuid valid'
+			);
 			// Deprecated
 			// - loginCheckEditAccess
 			$this->assertEquals(

4dev/tests/ACL/database/CoreLibsACLLogin_database_create_data.sql

@@ -652,8 +652,8 @@ CREATE TABLE edit_log (
     edit_log_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
     euid INT, -- this is a foreign key, but I don't nedd to reference to it
     FOREIGN KEY (euid) REFERENCES edit_user (edit_user_id) MATCH FULL ON UPDATE CASCADE ON DELETE SET NULL,
-    ecuid VARCHAR,
-    ecuuid UUID, -- this is the one we want to use, full UUIDv4 from the edit user table
+    eucuid VARCHAR,
+    eucuuid UUID, -- this is the one we want to use, full UUIDv4 from the edit user table
     -- date_created equal, but can be overridden
     event_date TIMESTAMP WITHOUT TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     -- session ID if set

4dev/tests/Check/CoreLibsCheckEmailTest.php

@@ -24,12 +24,12 @@ final class CoreLibsCheckEmailTest extends TestCase
 			'get email regex invalid -1, will be 0' => [
 				-1,
 				"^[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}@"
-					. "[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]{1,})*\.([a-zA-Z]{2,}){1}$"
+					. "(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[a-zA-Z]{2,6}$"
 			],
 			'get email regex invalid 10, will be 0' => [
 				10,
 				"^[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}@"
-					. "[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]{1,})*\.([a-zA-Z]{2,}){1}$"
+					. "(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[a-zA-Z]{2,6}$"
 			],
 			'get email regex valid 1, will be 1' => [
 				1,
@@ -157,7 +157,7 @@ final class CoreLibsCheckEmailTest extends TestCase
 					'error' => 0,
 					'message' => 'Invalid email address',
 					'regex' => "^[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}@"
-						. "[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]{1,})*\.([a-zA-Z]{2,}){1}$"
+						. "(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[a-zA-Z]{2,6}$"
 				]
 			],
 			'error 1 will return double @ error' => [
@@ -181,7 +181,7 @@ final class CoreLibsCheckEmailTest extends TestCase
 				[
 					'error' => 3,
 					'message' => 'Invalid domain part after @ sign',
-					'regex' => "@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]{1,})*\.([a-zA-Z]{2,}){1}$"
+					'regex' => "@(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[a-zA-Z]{2,6}$"
 				]
 			],
 			'error 4 will be invalid domain' => [
@@ -189,7 +189,7 @@ final class CoreLibsCheckEmailTest extends TestCase
 				[
 					'error' => 4,
 					'message' => 'Invalid domain name part',
-					'regex' => "@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]{1,})*\."
+					'regex' => "@(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\."
 				]
 			],
 			'error 5 will be invalid domain top level only' => [
@@ -197,7 +197,7 @@ final class CoreLibsCheckEmailTest extends TestCase
 				[
 					'error' => 5,
 					'message' => 'Wrong domain top level part',
-					'regex' => "\.([a-zA-Z]{2,6}){1}$"
+					'regex' => "\.[a-zA-Z]{2,6}$"
 				]
 			],
 			'error 6 will be domain double dot' => [

4dev/tests/Combined/CoreLibsCombinedArrayHandlerFindArraysMissingKeyTest.php

@@ -0,0 +1,404 @@
+<?php
+
+// This code was created by Claude Sonnet 4
+
+declare(strict_types=1);
+
+namespace tests;
+
+use PHPUnit\Framework\TestCase;
+use CoreLibs\Combined\ArrayHandler;
+
+class CoreLibsCombinedArrayHandlerFindArraysMissingKeyTest extends TestCase
+{
+	private const DATA_SEPARATOR = ':'; // Updated to match your class's separator
+
+	/**
+	 * Test finding missing single key when searching by value without specific key
+	 */
+	public function testFindMissingSingleKeyWithValueSearch()
+	{
+		$array = [
+			'item1' => [
+				'name' => 'John',
+				'age' => 25
+				// missing 'email' key
+			],
+			'item2' => [
+				'name' => 'Jane',
+				'age' => 30,
+				'email' => 'jane@example.com'
+			],
+			'item3' => [
+				'name' => 'John', // same value as item1
+				'age' => 35,
+				'email' => 'john2@example.com'
+			]
+		];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 'John', 'email');
+
+		$this->assertCount(1, $result);
+		$this->assertEquals($array['item1'], $result[0]['content']);
+		$this->assertEquals('item1', $result[0]['path']);
+		$this->assertEquals(['email'], $result[0]['missing_key']);
+	}
+
+	/**
+	 * Test finding missing single key when searching by specific key-value pair
+	 */
+	public function testFindMissingSingleKeyWithKeyValueSearch()
+	{
+		$array = [
+			'user1' => [
+				'id' => 1,
+				'name' => 'Alice'
+				// missing 'status' key
+			],
+			'user2' => [
+				'id' => 2,
+				'name' => 'Bob',
+				'status' => 'active'
+			],
+			'user3' => [
+				'id' => 1, // same id as user1
+				'name' => 'Charlie',
+				'status' => 'inactive'
+			]
+		];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 1, 'status', 'id');
+
+		$this->assertCount(1, $result);
+		$this->assertEquals($array['user1'], $result[0]['content']);
+		$this->assertEquals('user1', $result[0]['path']);
+		$this->assertEquals(['status'], $result[0]['missing_key']);
+	}
+
+	/**
+	 * Test finding missing multiple keys
+	 */
+	public function testFindMissingMultipleKeys()
+	{
+		$array = [
+			'record1' => [
+				'name' => 'Test',
+				'value' => 100
+				// missing both 'date' and 'status' keys
+			],
+			'record2' => [
+				'name' => 'Test',
+				'value' => 200,
+				'date' => '2023-01-01'
+				// missing 'status' key
+			],
+			'record3' => [
+				'name' => 'Test',
+				'value' => 300,
+				'date' => '2023-01-02',
+				'status' => 'complete'
+			]
+		];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 'Test', ['date', 'status']);
+
+		$this->assertCount(2, $result);
+
+		// First result should be record1 missing both keys
+		$this->assertEquals($array['record1'], $result[0]['content']);
+		$this->assertEquals('record1', $result[0]['path']);
+		$this->assertContains('date', $result[0]['missing_key']);
+		$this->assertContains('status', $result[0]['missing_key']);
+		$this->assertCount(2, $result[0]['missing_key']);
+
+		// Second result should be record2 missing status key
+		$this->assertEquals($array['record2'], $result[1]['content']);
+		$this->assertEquals('record2', $result[1]['path']);
+		$this->assertEquals(['status'], $result[1]['missing_key']);
+	}
+
+	/**
+	 * Test with nested arrays
+	 */
+	public function testFindMissingKeyInNestedArrays()
+	{
+		$array = [
+			'section1' => [
+				'items' => [
+					'item1' => [
+						'name' => 'Product A',
+						'price' => 99.99
+						// missing 'category' key
+					],
+					'item2' => [
+						'name' => 'Product B',
+						'price' => 149.99,
+						'category' => 'electronics'
+					]
+				]
+			],
+			'section2' => [
+				'data' => [
+					'name' => 'Product A', // same name as nested item
+					'category' => 'books'
+				]
+			]
+		];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 'Product A', 'category');
+
+		$this->assertCount(1, $result);
+		$this->assertEquals($array['section1']['items']['item1'], $result[0]['content']);
+		$this->assertEquals('section1:items:item1', $result[0]['path']);
+		$this->assertEquals(['category'], $result[0]['missing_key']);
+	}
+
+	/**
+	 * Test when no arrays are missing the required key
+	 */
+	public function testNoMissingKeys()
+	{
+		$array = [
+			'item1' => [
+				'name' => 'John',
+				'email' => 'john@example.com'
+			],
+			'item2' => [
+				'name' => 'Jane',
+				'email' => 'jane@example.com'
+			]
+		];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 'John', 'email');
+
+		$this->assertEmpty($result);
+	}
+
+	/**
+	 * Test when search value is not found in any array
+	 */
+	public function testSearchValueNotFound()
+	{
+		$array = [
+			'item1' => [
+				'name' => 'John',
+				'age' => 25
+			],
+			'item2' => [
+				'name' => 'Jane',
+				'age' => 30
+			]
+		];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 'Bob', 'email');
+
+		$this->assertEmpty($result);
+	}
+
+	/**
+	 * Test with different data types for search value
+	 */
+	public function testDifferentSearchValueTypes()
+	{
+		$array = [
+			'item1' => [
+				'active' => true,
+				'count' => 5
+				// missing 'label' key
+			],
+			'item2' => [
+				'active' => false,
+				'count' => 10,
+				'label' => 'test'
+			],
+			'item3' => [
+				'active' => true, // same boolean as item1
+				'count' => 15,
+				'label' => 'another'
+			]
+		];
+
+		// Test with boolean
+		$result = ArrayHandler::findArraysMissingKey($array, true, 'label', 'active');
+		$this->assertCount(1, $result);
+		$this->assertEquals('item1', $result[0]['path']);
+
+		// Test with integer
+		$result = ArrayHandler::findArraysMissingKey($array, 5, 'label', 'count');
+		$this->assertCount(1, $result);
+		$this->assertEquals('item1', $result[0]['path']);
+	}
+
+	/**
+	 * Test with empty array
+	 */
+	public function testEmptyArray()
+	{
+		$array = [];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 'test', 'key');
+
+		$this->assertEmpty($result);
+	}
+
+	/**
+	 * Test with array containing non-array values
+	 */
+	public function testMixedArrayTypes()
+	{
+		$array = [
+			'string_value' => 'hello',
+			'numeric_value' => 123,
+			'array_value' => [
+				'name' => 'test',
+				// missing 'type' key
+			],
+			'another_array' => [
+				'name' => 'test',
+				'type' => 'example'
+			]
+		];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 'test', 'type');
+
+		$this->assertCount(1, $result);
+		$this->assertEquals($array['array_value'], $result[0]['content']);
+		$this->assertEquals('array_value', $result[0]['path']);
+		$this->assertEquals(['type'], $result[0]['missing_key']);
+	}
+
+	/**
+	 * Test path building with deeper nesting
+	 */
+	public function testDeepNestingPathBuilding()
+	{
+		$array = [
+			'level1' => [
+				'level2' => [
+					'level3' => [
+						'items' => [
+							'target_item' => [
+								'name' => 'deep_test',
+								// missing 'required_field'
+							]
+						]
+					]
+				]
+			]
+		];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 'deep_test', 'required_field');
+
+		$this->assertCount(1, $result);
+		$this->assertEquals('level1:level2:level3:items:target_item', $result[0]['path']);
+	}
+
+	/**
+	 * Test with custom path separator
+	 */
+	public function testCustomPathSeparator()
+	{
+		$array = [
+			'level1' => [
+				'level2' => [
+					'item' => [
+						'name' => 'test',
+						// missing 'type' key
+					]
+				]
+			]
+		];
+
+		$result = ArrayHandler::findArraysMissingKey($array, 'test', 'type', null, '/');
+
+		$this->assertCount(1, $result);
+		$this->assertEquals('level1/level2/item', $result[0]['path']);
+	}
+
+	/**
+	 * Test default path separator behavior
+	 */
+	public function testDefaultPathSeparator()
+	{
+		$array = [
+			'parent' => [
+				'child' => [
+					'name' => 'test',
+					// missing 'value' key
+				]
+			]
+		];
+
+		// Using default separator (should be ':')
+		$result = ArrayHandler::findArraysMissingKey($array, 'test', 'value');
+
+		$this->assertCount(1, $result);
+		$this->assertEquals('parent:child', $result[0]['path']);
+	}
+
+	/**
+	 * Test different path separators don't affect search logic
+	 */
+	public function testPathSeparatorDoesNotAffectSearchLogic()
+	{
+		$array = [
+			'section' => [
+				'data' => [
+					'id' => 123,
+					'name' => 'item'
+					// missing 'status'
+				]
+			]
+		];
+
+		// Test with different separators - results should be identical except for path
+		$result1 = ArrayHandler::findArraysMissingKey($array, 123, 'status', 'id', ':');
+		$result2 = ArrayHandler::findArraysMissingKey($array, 123, 'status', 'id', '.');
+		$result3 = ArrayHandler::findArraysMissingKey($array, 123, 'status', 'id', '/');
+
+		$this->assertCount(1, $result1);
+		$this->assertCount(1, $result2);
+		$this->assertCount(1, $result3);
+
+		// Content and missing_key should be the same
+		$this->assertEquals($result1[0]['content'], $result2[0]['content']);
+		$this->assertEquals($result1[0]['content'], $result3[0]['content']);
+		$this->assertEquals($result1[0]['missing_key'], $result2[0]['missing_key']);
+		$this->assertEquals($result1[0]['missing_key'], $result3[0]['missing_key']);
+
+		// Paths should be different based on separator
+		$this->assertEquals('section:data', $result1[0]['path']);
+		$this->assertEquals('section.data', $result2[0]['path']);
+		$this->assertEquals('section/data', $result3[0]['path']);
+	}
+
+	/**
+	 * test type checking
+	 */
+	public function testStrictTypeChecking()
+	{
+		$array = [
+			'item1' => [
+				'id' => '123', // string
+				'name' => 'test'
+				// missing 'status'
+			],
+			'item2' => [
+				'id' => 123, // integer
+				'name' => 'test2',
+				'status' => 'active'
+			]
+		];
+
+		// Search for integer 123 - should only match item2
+		$result = ArrayHandler::findArraysMissingKey($array, 123, 'status', 'id');
+		$this->assertEmpty($result); // item2 has the status key
+
+		// Search for string '123' - should only match item1
+		$result = ArrayHandler::findArraysMissingKey($array, '123', 'status', 'id');
+		$this->assertCount(1, $result);
+		$this->assertEquals('item1', $result[0]['path']);
+	}
+}
+
+// __END__

4dev/tests/Combined/CoreLibsCombinedArrayHandlerKsortArrayTest.php

@@ -0,0 +1,333 @@
+<?php
+
+// This code was created by Claude Sonnet 4
+// modification for value checks with assertEqualsCanonicalizing
+
+declare(strict_types=1);
+
+namespace tests;
+
+use PHPUnit\Framework\TestCase;
+use CoreLibs\Combined\ArrayHandler;
+
+class CoreLibsCombinedArrayHandlerKsortArrayTest extends TestCase
+{
+	/**
+	 * Test basic ascending sort (default behavior)
+	 */
+	public function testKsortArrayBasicAscending(): void
+	{
+		$input = [
+			'zebra' => 'value1',
+			'apple' => 'value2',
+			'banana' => 'value3',
+			'cherry' => 'value4'
+		];
+
+		$expected = [
+			'apple' => 'value2',
+			'banana' => 'value3',
+			'cherry' => 'value4',
+			'zebra' => 'value1'
+		];
+
+		$result = ArrayHandler::ksortArray($input);
+		$this->assertEquals($expected, $result);
+		$this->assertEquals(array_keys($expected), array_keys($result));
+	}
+
+	/**
+	 * Test descending sort with reverse=true
+	 */
+	public function testKsortArrayDescending(): void
+	{
+		$input = [
+			'zebra' => 'value1',
+			'apple' => 'value2',
+			'banana' => 'value3',
+			'cherry' => 'value4'
+		];
+
+		$expected = [
+			'zebra' => 'value1',
+			'cherry' => 'value4',
+			'banana' => 'value3',
+			'apple' => 'value2'
+		];
+
+		$result = ArrayHandler::ksortArray($input, false, true);
+		$this->assertEquals($expected, $result);
+		$this->assertEquals(array_keys($expected), array_keys($result));
+	}
+
+	/**
+	 * Test case-insensitive ascending sort
+	 */
+	public function testKsortArrayCaseInsensitiveAscending(): void
+	{
+		$input = [
+			'Zebra' => 'value1',
+			'apple' => 'value2',
+			'Banana' => 'value3',
+			'cherry' => 'value4'
+		];
+
+		$expected = [
+			'apple' => 'value2',
+			'Banana' => 'value3',
+			'cherry' => 'value4',
+			'Zebra' => 'value1'
+		];
+
+		$result = ArrayHandler::ksortArray($input, true);
+		$this->assertEquals($expected, $result);
+		$this->assertEquals(array_keys($expected), array_keys($result));
+	}
+
+	/**
+	 * Test case-insensitive descending sort
+	 */
+	public function testKsortArrayCaseInsensitiveDescending(): void
+	{
+		$input = [
+			'Zebra' => 'value1',
+			'apple' => 'value2',
+			'Banana' => 'value3',
+			'cherry' => 'value4'
+		];
+
+		$expected = [
+			'Zebra' => 'value1',
+			'cherry' => 'value4',
+			'Banana' => 'value3',
+			'apple' => 'value2'
+		];
+
+		$result = ArrayHandler::ksortArray($input, true, true);
+		$this->assertEquals($expected, $result);
+		$this->assertEquals(array_keys($expected), array_keys($result));
+	}
+
+	/**
+	 * Test with mixed case keys to verify case sensitivity behavior
+	 */
+	public function testKsortArrayCaseSensitivityComparison(): void
+	{
+		$input = [
+			'B' => 'value1',
+			'a' => 'value2',
+			'C' => 'value3',
+			'b' => 'value4'
+		];
+
+		// Case-sensitive sort (uppercase comes before lowercase in ASCII)
+		$expectedCaseSensitive = [
+			'B' => 'value1',
+			'C' => 'value3',
+			'a' => 'value2',
+			'b' => 'value4'
+		];
+
+		// Case-insensitive sort
+		$expectedCaseInsensitive = [
+			'a' => 'value2',
+			'B' => 'value1',
+			'b' => 'value4',
+			'C' => 'value3'
+		];
+
+		$resultCaseSensitive = ArrayHandler::ksortArray($input, false);
+		$resultCaseInsensitive = ArrayHandler::ksortArray($input, true);
+
+		$this->assertEquals($expectedCaseSensitive, $resultCaseSensitive);
+		$this->assertEquals($expectedCaseInsensitive, $resultCaseInsensitive);
+	}
+
+	/**
+	 * Test with numeric string keys
+	 */
+	public function testKsortArrayNumericStringKeys(): void
+	{
+		$input = [
+			'10' => 'value1',
+			'2' => 'value2',
+			'1' => 'value3',
+			'20' => 'value4'
+		];
+
+		// String comparison, not numeric
+		$expected = [
+			'1' => 'value3',
+			'10' => 'value1',
+			'2' => 'value2',
+			'20' => 'value4'
+		];
+
+		$result = ArrayHandler::ksortArray($input);
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test with special characters in keys
+	 */
+	public function testKsortArraySpecialCharacters(): void
+	{
+		$input = [
+			'key_with_underscore' => 'value1',
+			'key-with-dash' => 'value2',
+			'key.with.dot' => 'value3',
+			'key with space' => 'value4',
+			'keyWithCamelCase' => 'value5'
+		];
+
+		$result = ArrayHandler::ksortArray($input);
+
+		// Verify it doesn't throw an error and maintains all keys
+		$this->assertCount(5, $result);
+		$this->assertArrayHasKey('key_with_underscore', $result);
+		$this->assertArrayHasKey('key-with-dash', $result);
+		$this->assertArrayHasKey('key.with.dot', $result);
+		$this->assertArrayHasKey('key with space', $result);
+		$this->assertArrayHasKey('keyWithCamelCase', $result);
+	}
+
+	/**
+	 * Test with empty array
+	 */
+	public function testKsortArrayEmpty(): void
+	{
+		$input = [];
+		$result = ArrayHandler::ksortArray($input);
+		$this->assertEquals([], $result);
+		$this->assertIsArray($result);
+	}
+
+	/**
+	 * Test with single element array
+	 */
+	public function testKsortArraySingleElement(): void
+	{
+		$input = ['onlykey' => 'onlyvalue'];
+		$result = ArrayHandler::ksortArray($input);
+		$this->assertEquals($input, $result);
+	}
+
+	/**
+	 * Test that original array is not modified (function returns new array)
+	 */
+	public function testKsortArrayDoesNotModifyOriginal(): void
+	{
+		$original = [
+			'zebra' => 'value1',
+			'apple' => 'value2',
+			'banana' => 'value3'
+		];
+
+		$originalCopy = $original; // Keep a copy for comparison
+		$result = ArrayHandler::ksortArray($original);
+
+		// Original array should remain unchanged
+		$this->assertEquals($originalCopy, $original);
+		$this->assertNotEquals(array_keys($original), array_keys($result));
+	}
+
+	/**
+	 * Test with complex mixed data types as values
+	 */
+	public function testKsortArrayMixedValueTypes(): void
+	{
+		$input = [
+			'string_key' => 'string_value',
+			'array_key' => ['nested', 'array'],
+			'int_key' => 42,
+			'bool_key' => true,
+			'null_key' => null
+		];
+
+		$result = ArrayHandler::ksortArray($input);
+
+		// Check that all keys are preserved and sorted
+		$expectedKeys = ['array_key', 'bool_key', 'int_key', 'null_key', 'string_key'];
+		$this->assertEquals($expectedKeys, array_keys($result));
+
+		// Check that values are preserved correctly
+		$this->assertEquals('string_value', $result['string_key']);
+		$this->assertEquals(['nested', 'array'], $result['array_key']);
+		$this->assertEquals(42, $result['int_key']);
+		$this->assertTrue($result['bool_key']);
+		$this->assertNull($result['null_key']);
+	}
+
+	/**
+	 * Test all parameter combinations
+	 */
+	public function testKsortArrayAllParameterCombinations(): void
+	{
+		$input = [
+			'Delta' => 'value1',
+			'alpha' => 'value2',
+			'Charlie' => 'value3',
+			'bravo' => 'value4'
+		];
+
+		// Test all 4 combinations
+		$result1 = ArrayHandler::ksortArray($input, false, false); // default
+		$result2 = ArrayHandler::ksortArray($input, false, true);  // reverse only
+		$result3 = ArrayHandler::ksortArray($input, true, false);  // lowercase only
+		$result4 = ArrayHandler::ksortArray($input, true, true);   // both
+
+		// Each should produce different ordering
+		$this->assertNotEquals(array_keys($result1), array_keys($result2));
+		$this->assertNotEquals(array_keys($result1), array_keys($result3));
+		$this->assertNotEquals(array_keys($result1), array_keys($result4));
+		$this->assertNotEquals(array_keys($result2), array_keys($result3));
+		$this->assertNotEquals(array_keys($result2), array_keys($result4));
+		$this->assertNotEquals(array_keys($result3), array_keys($result4));
+
+		// But all should have same keys and values, just different order
+		$this->assertEqualsCanonicalizing(array_values($input), array_values($result1));
+		$this->assertEqualsCanonicalizing(array_values($input), array_values($result2));
+		$this->assertEqualsCanonicalizing(array_values($input), array_values($result3));
+		$this->assertEqualsCanonicalizing(array_values($input), array_values($result4));
+	}
+
+	/**
+	 * Data provider for comprehensive testing
+	 */
+	public function sortingParametersProvider(): array
+	{
+		return [
+			'default' => [false, false],
+			'reverse' => [false, true],
+			'lowercase' => [true, false],
+			'lowercase_reverse' => [true, true],
+		];
+	}
+
+	/**
+	 * Test that function works with all parameter combinations using data provider
+	 *
+	 * @dataProvider sortingParametersProvider
+	 */
+	public function testKsortArrayWithDataProvider(bool $lowerCase, bool $reverse): void
+	{
+		$input = [
+			'Zebra' => 'animal1',
+			'apple' => 'fruit1',
+			'Banana' => 'fruit2',
+			'cat' => 'animal2'
+		];
+
+		$result = ArrayHandler::ksortArray($input, $lowerCase, $reverse);
+
+		// Basic assertions that apply to all combinations
+		$this->assertIsArray($result);
+		$this->assertCount(4, $result);
+		$this->assertArrayHasKey('Zebra', $result);
+		$this->assertArrayHasKey('apple', $result);
+		$this->assertArrayHasKey('Banana', $result);
+		$this->assertArrayHasKey('cat', $result);
+	}
+}
+
+// __END__

4dev/tests/Combined/CoreLibsCombinedArrayHandlerSelectArrayFromOptionTest.php

@@ -0,0 +1,383 @@
+<?php
+
+// created by Claude Sonnet 4
+
+// testRecursiveSearchWithFlatResult had wrong retunr count
+
+declare(strict_types=1);
+
+namespace tests;
+
+use PHPUnit\Framework\TestCase;
+use CoreLibs\Combined\ArrayHandler;
+
+class CoreLibsCombinedArrayHandlerSelectArrayFromOptionTest extends TestCase
+{
+	private array $testData;
+	private array $nestedTestData;
+
+	protected function setUp(): void
+	{
+		$this->testData = [
+			'item1' => [
+				'name' => 'John',
+				'age' => 25,
+				'status' => 'active',
+				'score' => 85.5
+			],
+			'item2' => [
+				'name' => 'jane',
+				'age' => 30,
+				'status' => 'inactive',
+				'score' => 92.0
+			],
+			'item3' => [
+				'name' => 'Bob',
+				'age' => 25,
+				'status' => 'active',
+				'score' => 78.3
+			],
+			'item4' => [
+				'name' => 'Alice',
+				'age' => 35,
+				'status' => 'pending',
+				'score' => 88.7
+			]
+		];
+
+		$this->nestedTestData = [
+			'level1_a' => [
+				'name' => 'Level1A',
+				'type' => 'parent',
+				'children' => [
+					'child1' => [
+						'name' => 'Child1',
+						'type' => 'child',
+						'active' => true
+					],
+					'child2' => [
+						'name' => 'Child2',
+						'type' => 'child',
+						'active' => false
+					]
+				]
+			],
+			'level1_b' => [
+				'name' => 'Level1B',
+				'type' => 'parent',
+				'children' => [
+					'child3' => [
+						'name' => 'Child3',
+						'type' => 'child',
+						'active' => true,
+						'nested' => [
+							'deep1' => [
+								'name' => 'Deep1',
+								'type' => 'deep',
+								'active' => true
+							]
+						]
+					]
+				]
+			],
+			'item5' => [
+				'name' => 'Direct',
+				'type' => 'child',
+				'active' => false
+			]
+		];
+	}
+
+	public function testEmptyArrayReturnsEmpty(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption([], 'name', 'John');
+		$this->assertEmpty($result);
+	}
+
+	public function testBasicStringSearch(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption($this->testData, 'name', 'John');
+
+		$this->assertCount(1, $result);
+		$this->assertArrayHasKey('item1', $result);
+		$this->assertEquals('John', $result['item1']['name']);
+	}
+
+	public function testBasicIntegerSearch(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption($this->testData, 'age', 25);
+
+		$this->assertCount(2, $result);
+		$this->assertArrayHasKey('item1', $result);
+		$this->assertArrayHasKey('item3', $result);
+	}
+
+	public function testBasicFloatSearch(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption($this->testData, 'score', 85.5);
+
+		$this->assertCount(1, $result);
+		$this->assertArrayHasKey('item1', $result);
+		$this->assertEquals(85.5, $result['item1']['score']);
+	}
+
+	public function testBasicBooleanSearch(): void
+	{
+		$data = [
+			'item1' => ['enabled' => true, 'name' => 'Test1'],
+			'item2' => ['enabled' => false, 'name' => 'Test2'],
+			'item3' => ['enabled' => true, 'name' => 'Test3']
+		];
+
+		$result = ArrayHandler::selectArrayFromOption($data, 'enabled', true);
+
+		$this->assertCount(2, $result);
+		$this->assertArrayHasKey('item1', $result);
+		$this->assertArrayHasKey('item3', $result);
+	}
+
+	public function testStrictComparison(): void
+	{
+		$data = [
+			'item1' => ['value' => '25', 'name' => 'String25'],
+			'item2' => ['value' => 25, 'name' => 'Int25'],
+			'item3' => ['value' => 25.0, 'name' => 'Float25']
+		];
+
+		// Non-strict should match all
+		$nonStrictResult = ArrayHandler::selectArrayFromOption($data, 'value', 25, false);
+		$this->assertCount(3, $nonStrictResult);
+
+		// Strict should only match exact type
+		$strictResult = ArrayHandler::selectArrayFromOption($data, 'value', 25, true);
+		$this->assertCount(1, $strictResult);
+		$this->assertArrayHasKey('item2', $strictResult);
+	}
+
+	public function testCaseInsensitiveSearch(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption($this->testData, 'name', 'JANE', false, true);
+
+		$this->assertCount(1, $result);
+		$this->assertArrayHasKey('item2', $result);
+		$this->assertEquals('jane', $result['item2']['name']);
+	}
+
+	public function testCaseSensitiveSearch(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption($this->testData, 'name', 'JANE', false, false);
+
+		$this->assertEmpty($result);
+	}
+
+	public function testRecursiveSearchWithFlatResult(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption(
+			$this->nestedTestData,
+			'type',
+			'child',
+			false,
+			false,
+			true,
+			true,
+			':*'
+		);
+
+		$this->assertCount(4, $result);
+		$this->assertArrayHasKey('level1_a:*children:*child1', $result);
+		$this->assertArrayHasKey('level1_a:*children:*child2', $result);
+		$this->assertArrayHasKey('level1_b:*children:*child3', $result);
+		$this->assertArrayHasKey('item5', $result);
+	}
+
+	public function testRecursiveSearchWithNestedResult(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption(
+			$this->nestedTestData,
+			'type',
+			'child',
+			false,
+			false,
+			true,
+			false
+		);
+
+		$this->assertCount(3, $result);
+		$this->assertArrayHasKey('level1_a', $result);
+		$this->assertArrayHasKey('level1_b', $result);
+		$this->assertArrayHasKey('item5', $result);
+
+		// Check nested structure is preserved
+		$this->assertArrayHasKey('children', $result['level1_a']);
+		$this->assertArrayHasKey('child1', $result['level1_a']['children']);
+		$this->assertArrayHasKey('child2', $result['level1_a']['children']);
+	}
+
+	public function testRecursiveSearchDeepNesting(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption(
+			$this->nestedTestData,
+			'type',
+			'deep',
+			false,
+			false,
+			true,
+			true,
+			':*'
+		);
+
+		$this->assertCount(1, $result);
+		$this->assertArrayHasKey('level1_b:*children:*child3:*nested:*deep1', $result);
+		$this->assertEquals('Deep1', $result['level1_b:*children:*child3:*nested:*deep1']['name']);
+	}
+
+	public function testCustomFlatSeparator(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption(
+			$this->nestedTestData,
+			'type',
+			'child',
+			false,
+			false,
+			true,
+			true,
+			'|'
+		);
+
+		$this->assertArrayHasKey('level1_a|children|child1', $result);
+		$this->assertArrayHasKey('level1_a|children|child2', $result);
+		$this->assertArrayHasKey('level1_b|children|child3', $result);
+	}
+
+	public function testNonRecursiveSearch(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption(
+			$this->nestedTestData,
+			'type',
+			'child',
+			false,
+			false,
+			false
+		);
+
+		// Should only find direct matches, not nested ones
+		$this->assertCount(1, $result);
+		$this->assertArrayHasKey('item5', $result);
+	}
+
+	public function testNoMatchesFound(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption($this->testData, 'name', 'NonExistent');
+
+		$this->assertEmpty($result);
+	}
+
+	public function testMissingLookupKey(): void
+	{
+		$result = ArrayHandler::selectArrayFromOption($this->testData, 'nonexistent_key', 'value');
+
+		$this->assertEmpty($result);
+	}
+
+	public function testCombinedStrictAndCaseInsensitive(): void
+	{
+		$data = [
+			'item1' => ['name' => 'Test', 'id' => '123'],
+			'item2' => ['name' => 'test', 'id' => 123],
+			'item3' => ['name' => 'TEST', 'id' => '123']
+		];
+
+		// Case insensitive but strict type matching
+		$result = ArrayHandler::selectArrayFromOption($data, 'id', '123', true, true);
+
+		$this->assertCount(2, $result);
+		$this->assertArrayHasKey('item1', $result);
+		$this->assertArrayHasKey('item3', $result);
+	}
+
+	public function testBooleanWithCaseInsensitive(): void
+	{
+		$data = [
+			'item1' => ['active' => true, 'name' => 'Test1'],
+			'item2' => ['active' => false, 'name' => 'Test2']
+		];
+
+		// Case insensitive flag should not affect boolean comparison
+		$result = ArrayHandler::selectArrayFromOption($data, 'active', true, false, true);
+
+		$this->assertCount(1, $result);
+		$this->assertArrayHasKey('item1', $result);
+	}
+
+	public function testArrayWithNumericKeys(): void
+	{
+		$data = [
+			0 => ['name' => 'First', 'type' => 'test'],
+			1 => ['name' => 'Second', 'type' => 'test'],
+			2 => ['name' => 'Third', 'type' => 'other']
+		];
+
+		$result = ArrayHandler::selectArrayFromOption($data, 'type', 'test');
+
+		$this->assertCount(2, $result);
+		$this->assertArrayHasKey(0, $result);
+		$this->assertArrayHasKey(1, $result);
+	}
+
+	public function testRecursiveWithMixedKeyTypes(): void
+	{
+		$data = [
+			'string_key' => [
+				'name' => 'Parent',
+				'type' => 'parent',
+				0 => [
+					'name' => 'Child0',
+					'type' => 'child'
+				],
+				'child_key' => [
+					'name' => 'ChildKey',
+					'type' => 'child'
+				]
+			]
+		];
+
+		$result = ArrayHandler::selectArrayFromOption($data, 'type', 'child', false, false, true, true, ':*');
+
+		$this->assertCount(2, $result);
+		$this->assertArrayHasKey('string_key:*0', $result);
+		$this->assertArrayHasKey('string_key:*child_key', $result);
+	}
+
+	public function testAllParametersCombined(): void
+	{
+		$data = [
+			'parent1' => [
+				'name' => 'Parent1',
+				'status' => 'ACTIVE',
+				'children' => [
+					'child1' => [
+						'name' => 'Child1',
+						'status' => 'active'
+					]
+				]
+			]
+		];
+
+		$result = ArrayHandler::selectArrayFromOption(
+			$data,
+			'status',
+			'active',
+			false,      // not strict
+			true,       // case insensitive
+			true,       // recursive
+			true,       // flat result
+			'|'         // custom separator
+		);
+
+		$this->assertCount(2, $result);
+		$this->assertArrayHasKey('parent1', $result);
+		$this->assertArrayHasKey('parent1|children|child1', $result);
+	}
+}
+
+// __END__

4dev/tests/Combined/CoreLibsCombinedArrayHandlerSortArrayTest.php

@@ -0,0 +1,328 @@
+<?php
+
+// This code was created by Claude Sonnet 4
+
+declare(strict_types=1);
+
+namespace tests;
+
+use PHPUnit\Framework\TestCase;
+use CoreLibs\Combined\ArrayHandler;
+
+class CoreLibsCombinedArrayHandlerSortArrayTest extends TestCase
+{
+	/**
+	 * Test basic ascending sort without maintaining keys
+	 */
+	public function testBasicAscendingSort()
+	{
+		$input = [3, 1, 4, 1, 5, 9];
+		$expected = [1, 1, 3, 4, 5, 9];
+
+		$result = ArrayHandler::sortArray($input);
+
+		$this->assertEquals($expected, $result);
+		$this->assertEquals(array_keys($expected), array_keys($result));
+	}
+
+	/**
+	 * Test basic descending sort without maintaining keys
+	 */
+	public function testBasicDescendingSort()
+	{
+		$input = [3, 1, 4, 1, 5, 9];
+		$expected = [9, 5, 4, 3, 1, 1];
+
+		$result = ArrayHandler::sortArray($input, false, true);
+
+		$this->assertEquals($expected, $result);
+		$this->assertEquals(array_keys($expected), array_keys($result));
+	}
+
+	/**
+	 * Test ascending sort with key maintenance
+	 */
+	public function testAscendingSortWithKeyMaintenance()
+	{
+		$input = ['c' => 3, 'a' => 1, 'd' => 4, 'b' => 1, 'e' => 5];
+		$expected = ['a' => 1, 'b' => 1, 'c' => 3, 'd' => 4, 'e' => 5];
+
+		$result = ArrayHandler::sortArray($input, false, false, true);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test descending sort with key maintenance
+	 */
+	public function testDescendingSortWithKeyMaintenance()
+	{
+		$input = ['c' => 3, 'a' => 1, 'd' => 4, 'b' => 1, 'e' => 5];
+		$expected = ['e' => 5, 'd' => 4, 'c' => 3, 'a' => 1, 'b' => 1];
+
+		$result = ArrayHandler::sortArray($input, false, true, true);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test string sorting with lowercase conversion
+	 */
+	public function testStringLowerCaseSort()
+	{
+		$input = ['Banana', 'apple', 'Cherry', 'date'];
+		$expected = ['apple', 'Banana', 'Cherry', 'date'];
+
+		$result = ArrayHandler::sortArray($input, true);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test string sorting with lowercase conversion in reverse
+	 */
+	public function testStringLowerCaseSortReverse()
+	{
+		$input = ['Banana', 'apple', 'Cherry', 'date'];
+		$expected = ['date', 'Cherry', 'Banana', 'apple'];
+
+		$result = ArrayHandler::sortArray($input, true, true);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test string sorting with lowercase conversion and key maintenance
+	 */
+	public function testStringLowerCaseSortWithKeys()
+	{
+		$input = ['b' => 'Banana', 'a' => 'apple', 'c' => 'Cherry', 'd' => 'date'];
+		$expected = ['a' => 'apple', 'b' => 'Banana', 'c' => 'Cherry', 'd' => 'date'];
+
+		$result = ArrayHandler::sortArray($input, true, false, true);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test string sorting with lowercase conversion, reverse, and key maintenance
+	 */
+	public function testStringLowerCaseSortReverseWithKeys()
+	{
+		$input = ['b' => 'Banana', 'a' => 'apple', 'c' => 'Cherry', 'd' => 'date'];
+		$expected = ['d' => 'date', 'c' => 'Cherry', 'b' => 'Banana', 'a' => 'apple'];
+
+		$result = ArrayHandler::sortArray($input, true, true, true);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test numeric string sorting with SORT_NUMERIC flag
+	 */
+	public function testNumericStringSorting()
+	{
+		$input = ['10', '2', '1', '20'];
+		$expected = ['1', '2', '10', '20'];
+
+		$result = ArrayHandler::sortArray($input, false, false, false, SORT_NUMERIC);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test natural string sorting with SORT_NATURAL flag
+	 */
+	public function testNaturalStringSorting()
+	{
+		$input = ['img1.png', 'img10.png', 'img2.png', 'img20.png'];
+		$expected = ['img1.png', 'img2.png', 'img10.png', 'img20.png'];
+
+		$result = ArrayHandler::sortArray($input, false, false, false, SORT_NATURAL);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test with empty array
+	 */
+	public function testEmptyArray()
+	{
+		$input = [];
+		$expected = [];
+
+		$result = ArrayHandler::sortArray($input);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test with single element array
+	 */
+	public function testSingleElementArray()
+	{
+		$input = [42];
+		$expected = [42];
+
+		$result = ArrayHandler::sortArray($input);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test with array containing null values
+	 */
+	public function testArrayWithNullValues()
+	{
+		$input = [3, null, 1, null, 2];
+		$expected = [null, null, 1, 2, 3];
+
+		$result = ArrayHandler::sortArray($input);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test with mixed data types
+	 */
+	public function testMixedDataTypes()
+	{
+		$input = [3, '1', 4.5, '2', 1];
+
+		$result = ArrayHandler::sortArray($input);
+
+		// Should sort according to PHP's natural comparison rules
+		$this->assertIsArray($result);
+		$this->assertCount(5, $result);
+	}
+
+	/**
+	 * Test that original array is not modified (immutability)
+	 */
+	public function testOriginalArrayNotModified()
+	{
+		$original = [3, 1, 4, 1, 5, 9];
+		$input = $original;
+
+		$result = ArrayHandler::sortArray($input);
+
+		$this->assertEquals($original, $input);
+		$this->assertNotEquals($input, $result);
+	}
+
+	/**
+	 * Test case sensitivity without lowercase flag
+	 */
+	public function testCaseSensitivityWithoutLowercase()
+	{
+		$input = ['Banana', 'apple', 'Cherry'];
+
+		$result = ArrayHandler::sortArray($input);
+
+		// Capital letters should come before lowercase in ASCII sort
+		$this->assertEquals('Banana', $result[0]);
+		$this->assertEquals('Cherry', $result[1]);
+		$this->assertEquals('apple', $result[2]);
+	}
+
+	/**
+	 * Test all parameters combination
+	 */
+	public function testAllParametersCombination()
+	{
+		$input = ['z' => 'Zebra', 'a' => 'apple', 'b' => 'Banana'];
+
+		$result = ArrayHandler::sortArray($input, true, true, true, SORT_REGULAR);
+
+		// Should be sorted by lowercase, reversed, with keys maintained
+		$keys = array_keys($result);
+		$values = array_values($result);
+
+		$this->assertEquals(['z', 'b', 'a'], $keys);
+		$this->assertEquals(['Zebra', 'Banana', 'apple'], $values);
+	}
+
+	/**
+	 * Test floating point numbers
+	 */
+	public function testFloatingPointNumbers()
+	{
+		$input = [3.14, 2.71, 1.41, 1.73];
+		$expected = [1.41, 1.73, 2.71, 3.14];
+
+		$result = ArrayHandler::sortArray($input);
+
+		$this->assertEquals($expected, $result);
+	}
+
+	/**
+	 * Test with duplicate values and key maintenance
+	 */
+	public function testDuplicateValuesWithKeyMaintenance()
+	{
+		$input = ['first' => 1, 'second' => 2, 'third' => 1, 'fourth' => 2];
+
+		$result = ArrayHandler::sortArray($input, false, false, true);
+
+		$this->assertCount(4, $result);
+		$this->assertEquals([1, 1, 2, 2], array_values($result));
+		// Keys should be preserved
+		$this->assertArrayHasKey('first', $result);
+		$this->assertArrayHasKey('second', $result);
+		$this->assertArrayHasKey('third', $result);
+		$this->assertArrayHasKey('fourth', $result);
+	}
+
+	/**
+	 * Data provider for comprehensive parameter testing
+	 */
+	public function sortParameterProvider(): array
+	{
+		return [
+			'basic_ascending' => [
+				[3, 1, 4, 2],
+				false, false, false, SORT_REGULAR,
+				[1, 2, 3, 4]
+			],
+			'basic_descending' => [
+				[3, 1, 4, 2],
+				false, true, false, SORT_REGULAR,
+				[4, 3, 2, 1]
+			],
+			'lowercase_ascending' => [
+				['Banana', 'apple', 'Cherry'],
+				true, false, false, SORT_REGULAR,
+				['apple', 'Banana', 'Cherry']
+			],
+			'lowercase_descending' => [
+				['Banana', 'apple', 'Cherry'],
+				true, true, false, SORT_REGULAR,
+				['Cherry', 'Banana', 'apple']
+			]
+		];
+	}
+
+	/**
+	 * Test various parameter combinations using data provider
+	 *
+	 * @dataProvider sortParameterProvider
+	 */
+	public function testSortParameterCombinations(
+		array $input,
+		bool $lowercase,
+		bool $reverse,
+		bool $maintainKeys,
+		int $params,
+		array $expected
+	) {
+		$result = ArrayHandler::sortArray($input, $lowercase, $reverse, $maintainKeys, $params);
+
+		if (!$maintainKeys) {
+			$this->assertEquals($expected, $result);
+		} else {
+			$this->assertEquals($expected, array_values($result));
+		}
+	}
+}
+
+// __END__

4dev/tests/Combined/CoreLibsCombinedDateTimeTest.php

@@ -490,11 +490,11 @@ final class CoreLibsCombinedDateTimeTest extends TestCase
 			],
 			'micro interval with microtime' => [
 				'18999d 0h 38m 10s 1235ms',
-				1641515890.1235,
+				1641515891.235,
 			],
 			'micro interval with microtime' => [
 				'18999d 0h 38m 10s 1234567890ms',
-				1641515890.1234567,
+				1642750457.89,
 			],
 			'negative interval no microtime' => [
 				'-18999d 0h 38m 10s',
@@ -503,23 +503,246 @@ final class CoreLibsCombinedDateTimeTest extends TestCase
 			// short for mini tests
 			'microtime only' => [
 				'0s 1235ms',
-				0.1235,
+				1.235,
 			],
 			'seconds only' => [
 				'30s 1235ms',
-				30.1235,
+				31.235,
 			],
 			'minutes only' => [
 				'1m 30s 1235ms',
-				90.1235,
+				91.235,
 			],
 			'hours only' => [
 				'1h 1m 30s 1235ms',
-				3690.1235,
+				3691.235,
 			],
 			'days only' => [
 				'1d 1h 1m 30s 1235ms',
-				90090.1235,
+				90091.235,
+			],
+			'days only with long name' => [
+				'1day 1hour 1min 30second 1235millisecond',
+				90091.235,
+			],
+			// Test day variations
+			'day singular' => [
+				'5day',
+				432000,
+			],
+			'days plural' => [
+				'3days',
+				259200,
+			],
+			'days with space' => [
+				'2days 5h',
+				190800,
+			],
+			'day without space' => [
+				'1day1h',
+				90000,
+			],
+			// Test hour variations
+			'hour singular' => [
+				'2hour',
+				7200,
+			],
+			'hours plural' => [
+				'4hours',
+				14400,
+			],
+			'hours with space' => [
+				'3hours 30m',
+				12600,
+			],
+			'hour without space' => [
+				'1hour30m',
+				5400,
+			],
+			// Test minute variations
+			'min short' => [
+				'45min',
+				2700,
+			],
+			'minute singular' => [
+				'1minute',
+				60,
+			],
+			'minutes plural' => [
+				'10minutes',
+				600,
+			],
+			'minutes with space' => [
+				'5minutes 20s',
+				320,
+			],
+			'min without space' => [
+				'2min30s',
+				150,
+			],
+			// Test second variations
+			'sec short' => [
+				'30sec',
+				30,
+			],
+			'second singular' => [
+				'1second',
+				1,
+			],
+			'seconds plural' => [
+				'45seconds',
+				45,
+			],
+			'seconds with space' => [
+				'15seconds 500ms',
+				15.5,
+			],
+			'sec without space' => [
+				'10sec250ms',
+				10.25,
+			],
+			// Test millisecond variations
+			'ms short' => [
+				'500ms',
+				0.5,
+			],
+			'millis short' => [
+				'250millis',
+				0.25,
+			],
+			'millisec medium singular' => [
+				'250millisec',
+				0.25,
+			],
+			'millisecs medium plural' => [
+				'250millisecs',
+				0.25,
+			],
+			'misec medium singular' => [
+				'250millisec',
+				0.25,
+			],
+			'msecs medium plural' => [
+				'250millisecs',
+				0.25,
+			],
+			'millisecond long singular' => [
+				'1millisecond',
+				0.001,
+			],
+			'milliseconds long plural' => [
+				'999milliseconds',
+				0.999,
+			],
+			// Test negative values
+			'negative days' => [
+				'-5d',
+				-432000,
+			],
+			'negative hours' => [
+				'-3h',
+				-10800,
+			],
+			'negative minutes' => [
+				'-45m',
+				-2700,
+			],
+			'negative seconds' => [
+				'-30s',
+				-30,
+			],
+			'negative milliseconds' => [
+				'-500ms',
+				-0.5,
+			],
+			'negative complex' => [
+				'-2days 3hours 15minutes 30seconds 250milliseconds',
+				-184530.25,
+			],
+			// Test combined formats
+			'all components short' => [
+				'1d 2h 3m 4s 5ms',
+				93784.005,
+			],
+			'all components long' => [
+				'2days 3hours 4minutes 5seconds 678milliseconds',
+				183845.678,
+			],
+			'mixed short and long' => [
+				'1day 2h 3minutes 4sec 100ms',
+				93784.1,
+			],
+			'no spaces between components' => [
+				'1d2h3m4s5ms',
+				93784.005,
+			],
+			'only days and milliseconds' => [
+				'5d 123ms',
+				432000.123,
+			],
+			'only hours and seconds' => [
+				'2h 45s',
+				7245,
+			],
+			'only minutes and milliseconds' => [
+				'30m 500ms',
+				1800.5,
+			],
+			// Test zero values
+			'zero seconds' => [
+				'0s',
+				0,
+			],
+			'zero with milliseconds' => [
+				'0s 123ms',
+				0.123,
+			],
+			// Test large values
+			'large days' => [
+				'365days',
+				31536000,
+			],
+			'large hours' => [
+				'48hours',
+				172800,
+			],
+			'large minutes' => [
+				'1440minutes',
+				86400,
+			],
+			'large seconds' => [
+				'86400seconds',
+				86400,
+			],
+			// Test edge cases with spaces
+			'extra spaces' => [
+				'1d 2h 3m 4s 5ms',
+				93784.005,
+			],
+			'mixed spaces and no spaces' => [
+				'1d 2h3m 4s5ms',
+				93784.005,
+			],
+			// Test single component each
+			'only days short' => [
+				'7d',
+				604800,
+			],
+			'only hours short' => [
+				'12h',
+				43200,
+			],
+			'only minutes short' => [
+				'90m',
+				5400,
+			],
+			'only seconds short' => [
+				'120s',
+				120,
+			],
+			'only milliseconds short' => [
+				'1500ms',
+				1.5,
 			],
 			'already set' => [
 				1641515890,
@@ -529,10 +752,18 @@ final class CoreLibsCombinedDateTimeTest extends TestCase
 				'xyz',
 				'xyz',
 			],
+			'empty data' => [
+				' ',
+				' ',
+			],
 			'out of bound data' => [
 				'99999999999999999999d',
 				8.64E+24
 			],
+			'spaces inbetween' => [
+				'  -       9 d 2h 58minutes 35    seconds     123     ms          ',
+				-788315.123,
+			]
 		];
 	}
 
@@ -555,6 +786,36 @@ final class CoreLibsCombinedDateTimeTest extends TestCase
 		);
 	}
 
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::stringToTime
+	 * @testdox stringToTime invalid input will throw exception if requested
+	 *
+	 * @return void
+	 */
+	public function testStringToTimeException(): void
+	{
+		$this->expectException(\InvalidArgumentException::class);
+		$this->expectExceptionMessageMatches("/^Invalid time string format, cannot parse: /");
+		\CoreLibs\Combined\DateTime::stringToTime('1x 2y 3z', true);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::stringToTime
+	 * @testdox stringToTime empty input will throw exception if requested
+	 *
+	 * @return void
+	 */
+	public function testStringToTimeExceptionEmpty(): void
+	{
+		$this->expectException(\InvalidArgumentException::class);
+		$this->expectExceptionMessageMatches("/^Invalid time string format, no interval value found: /");
+		\CoreLibs\Combined\DateTime::stringToTime(' ', true);
+	}
+
 	/**
 	 * Undocumented function
 	 *
@@ -926,48 +1187,114 @@ final class CoreLibsCombinedDateTimeTest extends TestCase
 	public function daysIntervalProvider(): array
 	{
 		return [
-			'valid interval /, not named array' => [
-				'2020/1/1',
-				'2020/1/30',
-				false,
-				[29, 22, 8],
+			// normal and format tests
+			'valid interval / not named array' => [
+				'input_a' => '2020/1/1',
+				'input_b' => '2020/1/30',
+				'return_named' => false, // return_named
+				'include_end_date' => true, // include_end_date
+				'exclude_start_date' => false, // exclude_start_date
+				'expected' => [30, 22, 8, false],
 			],
-			'valid interval /, named array' => [
-				'2020/1/1',
-				'2020/1/30',
-				true,
-				['overall' => 29, 'weekday' => 22, 'weekend' => 8],
+			'valid interval / named array' => [
+				'input_a' => '2020/1/1',
+				'input_b' => '2020/1/30',
+				'return_named' => true,
+				'include_end_date' => true,
+				'exclude_start_date' => false,
+				'expected' => ['overall' => 30, 'weekday' => 22, 'weekend' => 8, 'reverse' => false],
 			],
-			'valid interval -' => [
-				'2020-1-1',
-				'2020-1-30',
-				false,
-				[29, 22, 8],
-			],
-			'valid interval switched' => [
-				'2020/1/30',
-				'2020/1/1',
-				false,
-				[28, 0, 0],
+			'valid interval with "-"' => [
+				'input_a' => '2020-1-1',
+				'input_b' => '2020-1-30',
+				'return_named' => false,
+				'include_end_date' => true,
+				'exclude_start_date' => false,
+				'expected' => [30, 22, 8, false],
 			],
 			'valid interval with time' => [
-				'2020/1/1 12:12:12',
-				'2020/1/30 13:13:13',
-				false,
-				[28, 21, 8],
+				'input_a' => '2020/1/1 12:12:12',
+				'input_b' => '2020/1/30 13:13:13',
+				'return_named' => false,
+				'include_end_date' => true,
+				'exclude_start_date' => false,
+				'expected' => [30, 22, 8, false],
 			],
+			// invalid
 			'invalid dates' => [
-				'abc',
-				'xyz',
-				false,
-				[0, 0, 0]
+				'input_a' => 'abc',
+				'input_b' => 'xyz',
+				'return_named' => false,
+				'include_end_date' => true,
+				'exclude_start_date' => false,
+				'expected' => [0, 0, 0, false]
 			],
-			// this test will take a long imte
+			// this test will take a long time
 			'out of bound dates' => [
-				'1900-1-1',
-				'9999-12-31',
-				false,
-				[2958463,2113189,845274],
+				'input_a' => '1900-1-1',
+				'input_b' => '9999-12-31',
+				'return_named' => false,
+				'include_end_date' => true,
+				'exclude_start_date' => false,
+				'expected' => [2958463, 2113189, 845274, false],
+			],
+			// tests for include/exclude
+			'exclude end date' => [
+				'input_b' => '2020/1/1',
+				'input_a' => '2020/1/30',
+				'return_named' => false,
+				'include_end_date' => false,
+				'exclude_start_date' => false,
+				'expected' => [29, 21, 8, false],
+			],
+			'exclude start date' => [
+				'input_b' => '2020/1/1',
+				'input_a' => '2020/1/30',
+				'return_named' => false,
+				'include_end_date' => true,
+				'exclude_start_date' => true,
+				'expected' => [29, 21, 8, false],
+			],
+			'exclude start and end date' => [
+				'input_b' => '2020/1/1',
+				'input_a' => '2020/1/30',
+				'return_named' => false,
+				'include_end_date' => false,
+				'exclude_start_date' => true,
+				'expected' => [28, 20, 8, false],
+			],
+			// reverse
+			'reverse: valid interval' => [
+				'input_a' => '2020/1/30',
+				'input_b' => '2020/1/1',
+				'return_named' => false,
+				'include_end_date' => true,
+				'exclude_start_date' => false,
+				'expected' => [30, 22, 8, true],
+			],
+			'reverse: exclude end date' => [
+				'input_a' => '2020/1/30',
+				'input_b' => '2020/1/1',
+				'return_named' => false,
+				'include_end_date' => false,
+				'exclude_start_date' => false,
+				'expected' => [29, 21, 8, true],
+			],
+			'reverse: exclude start date' => [
+				'input_a' => '2020/1/30',
+				'input_b' => '2020/1/1',
+				'return_named' => false,
+				'include_end_date' => true,
+				'exclude_start_date' => true,
+				'expected' => [29, 21, 8, true],
+			],
+			'reverse: exclude start and end date' => [
+				'input_a' => '2020/1/30',
+				'input_b' => '2020/1/1',
+				'return_named' => false,
+				'include_end_date' => false,
+				'exclude_start_date' => true,
+				'expected' => [28, 20, 8, true],
 			],
 		];
 	}
@@ -982,20 +1309,52 @@ final class CoreLibsCombinedDateTimeTest extends TestCase
 	 *
 	 * @param string $input_a
 	 * @param string $input_b
-	 * @param bool   $flag
-	 * @param array $expected
+	 * @param bool   $return_named
+	 * @param array  $expected
 	 * @return void
 	 */
 	public function testCalcDaysInterval(
 		string $input_a,
 		string $input_b,
-		bool $flag,
+		bool $return_named,
+		bool $include_end_date,
+		bool $exclude_start_date,
 		$expected
 	): void {
 		$this->assertEquals(
 			$expected,
-			\CoreLibs\Combined\DateTime::calcDaysInterval($input_a, $input_b, $flag)
+			\CoreLibs\Combined\DateTime::calcDaysInterval(
+				$input_a,
+				$input_b,
+				return_named:$return_named,
+				include_end_date:$include_end_date,
+				exclude_start_date:$exclude_start_date
+			),
+			'call calcDaysInterval'
 		);
+		if ($return_named) {
+			$this->assertEquals(
+				$expected,
+				\CoreLibs\Combined\DateTime::calcDaysIntervalNamedIndex(
+					$input_a,
+					$input_b,
+					include_end_date:$include_end_date,
+					exclude_start_date:$exclude_start_date
+				),
+				'call calcDaysIntervalNamedIndex'
+			);
+		} else {
+			$this->assertEquals(
+				$expected,
+				\CoreLibs\Combined\DateTime::calcDaysIntervalNumIndex(
+					$input_a,
+					$input_b,
+					include_end_date:$include_end_date,
+					exclude_start_date:$exclude_start_date
+				),
+				'call calcDaysIntervalNamedIndex'
+			);
+		}
 	}
 
 	/**
@@ -1187,7 +1546,38 @@ final class CoreLibsCombinedDateTimeTest extends TestCase
 				'2023-07-03',
 				'2023-07-27',
 				true
-			]
+			],
+			// reverse
+			'reverse: no weekend' => [
+				'2023-07-04',
+				'2023-07-03',
+				false
+			],
+			'reverse: start weekend sat' => [
+				'2023-07-04',
+				'2023-07-01',
+				true
+			],
+			'reverse: start weekend sun' => [
+				'2023-07-04',
+				'2023-07-02',
+				true
+			],
+			'reverse: end weekend sat' => [
+				'2023-07-08',
+				'2023-07-03',
+				true
+			],
+			'reverse: end weekend sun' => [
+				'2023-07-09',
+				'2023-07-03',
+				true
+			],
+			'reverse: long period > 6 days' => [
+				'2023-07-27',
+				'2023-07-03',
+				true
+			],
 		];
 	}
 

4dev/tests/Convert/CoreLibsConvertByteTest.php

@@ -40,7 +40,7 @@ final class CoreLibsConvertByteTest extends TestCase
 				4 => '1.00 KB',
 				5 => '1.02KiB',
 			],
-			'invalud string number' => [
+			'invalid string number' => [
 				0 => '1024 MB',
 				1 => '1024 MB',
 				2 => '1024 MB',
@@ -123,47 +123,6 @@ final class CoreLibsConvertByteTest extends TestCase
 		];
 	}
 
-	/**
-	 * Undocumented function
-	 *
-	 * @return array
-	 */
-	public function byteStringProvider(): array
-	{
-		return [
-			'negative number' => [
-				0 => '-117.42 MB',
-				1 => -123123794,
-				2 => -117420000,
-			],
-			'megabyte' => [
-				0 => '242.98 MB',
-				1 => 254782996,
-				2 => 242980000
-			],
-			'megabyte si' => [
-				0 => '254.78 MiB',
-				1 => 267156193,
-				2 => 254780000
-			],
-			'petabyte' => [
-				0 => '1 EiB',
-				1 => 1152921504606846976,
-				2 => 1000000000000000000,
-			],
-			'max int' => [
-				0 => '8 EB',
-				1 => -9223372036854775807 - 1,
-				2 => 8000000000000000000,
-			],
-			'exabyte, overflow' => [
-				0 => '867.36EB',
-				1 => 3873816255479021568,
-				2 => 363028535651074048,
-			]
-		];
-	}
-
 	/**
 	 * Undocumented function
 	 *
@@ -180,7 +139,7 @@ final class CoreLibsConvertByteTest extends TestCase
 	 * @return void
 	 */
 	public function testHumanReadableByteFormat(
-		$input,
+		string|int|float $input,
 		string $expected,
 		string $expected_si,
 		string $expected_no_space,
@@ -217,6 +176,73 @@ final class CoreLibsConvertByteTest extends TestCase
 		);
 	}
 
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function byteStringProvider(): array
+	{
+		return [
+			'negative number' => [
+				0 => '-117.42 MB',
+				1 => -123123794,
+				2 => -117420000,
+				3 => "-123123793",
+				4 => "-117420000",
+				5 => null,
+			],
+			'megabyte' => [
+				0 => '242.98 MB',
+				1 => 254782996,
+				2 => 242980000,
+				3 => "254782996",
+				4 => "242980000",
+				5 => null,
+			],
+			'megabyte si' => [
+				0 => '254.78 MiB',
+				1 => 267156193,
+				2 => 254780000,
+				3 => "267156193",
+				4 => "254780000",
+				5 => null,
+			],
+			'petabyte' => [
+				0 => '1 EiB',
+				1 => 1152921504606846976,
+				2 => 1000000000000000000,
+				3 => "1152921504606846976",
+				4 => "1000000000000000000",
+				5 => null,
+			],
+			'max int' => [
+				0 => '8 EB',
+				1 => 0,
+				2 => 0,
+				3 => "9223372036854775808",
+				4 => "8000000000000000000",
+				5 => \LengthException::class,
+			],
+			'exabyte, overflow' => [
+				0 => '867.36EB',
+				1 => 0,
+				2 => 0,
+				3 => "999997996235794808832",
+				4 => "867360000000000000000",
+				5 => \LengthException::class,
+			],
+			'huge exabyte, overflow' => [
+				0 => '1000EB',
+				1 => 0,
+				2 => 0,
+				3 => "1152921504606846976000",
+				4 => "1000000000000000000000",
+				5 => \LengthException::class,
+			],
+		];
+	}
+
 	/**
 	 * Undocumented function
 	 *
@@ -227,10 +253,22 @@ final class CoreLibsConvertByteTest extends TestCase
 	 * @param string|int|float $input
 	 * @param string|int|float $expected
 	 * @param string|int|float $expected_si
+	 * @param string|int|float $expected_string
+	 * @param string|int|float $expected_string_si
+	 * @param ?string          $exception
 	 * @return void
 	 */
-	public function testStringByteFormat($input, $expected, $expected_si): void
-	{
+	public function testStringByteFormat(
+		string|int|float $input,
+		string|int|float $expected,
+		string|int|float $expected_si,
+		string|int|float $expected_string,
+		string|int|float $expected_string_si,
+		?string $exception
+	): void {
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
 		$this->assertEquals(
 			$expected,
 			\CoreLibs\Convert\Byte::stringByteFormat($input)
@@ -239,6 +277,17 @@ final class CoreLibsConvertByteTest extends TestCase
 			$expected_si,
 			\CoreLibs\Convert\Byte::stringByteFormat($input, \CoreLibs\Convert\Byte::BYTE_FORMAT_SI)
 		);
+		$this->assertEquals(
+			$expected_string,
+			\CoreLibs\Convert\Byte::stringByteFormat($input, \CoreLibs\Convert\Byte::RETURN_AS_STRING)
+		);
+		$this->assertEquals(
+			$expected_string_si,
+			\CoreLibs\Convert\Byte::stringByteFormat(
+				$input,
+				\CoreLibs\Convert\Byte::BYTE_FORMAT_SI | \CoreLibs\Convert\Byte::RETURN_AS_STRING
+			)
+		);
 	}
 
 	/**

4dev/tests/Convert/CoreLibsConvertJsonTest.php

@@ -164,6 +164,51 @@ final class CoreLibsConvertJsonTest extends TestCase
 		);
 	}
 
+	/**
+	 * test with flags
+	 *
+	 * @covers ::jsonConvertToArray
+	 * @testdox jsonConvertToArray flag test, if flag is used
+	 *
+	 * @return void
+	 */
+	public function testJsonConvertToArrayWithFlags(): void
+	{
+		$input = '{"valid":"json","invalid":"\xB1\x31"}';
+		/* $expected_without_flag = [
+			'valid' => 'json'
+		];
+		$expected_with_flag = [
+			'valid' => 'json',
+			'invalid' => "\xB1\x31"
+		]; */
+		// no idea why in both it throws an erro
+		$expected_without_flag = [];
+		$expected_with_flag = [];
+		$this->assertEquals(
+			$expected_without_flag,
+			\CoreLibs\Convert\Json::jsonConvertToArray($input)
+		);
+		$this->assertEquals(
+			$expected_with_flag,
+			\CoreLibs\Convert\Json::jsonConvertToArray($input, flags:JSON_INVALID_UTF8_IGNORE)
+		);
+	}
+
+	public function testJsonConvertToArrayRemoveThrowFlag(): void
+	{
+		$input = '{"valid":"json","invalid":"\xB1\x31"}';
+		// show NOT throw an exception
+		try {
+			$this->assertEquals(
+				[],
+				\CoreLibs\Convert\Json::jsonConvertToArray($input, flags:JSON_THROW_ON_ERROR)
+			);
+		} catch (\Exception $e) {
+			$this->fail('Exception was thrown despite flag removal');
+		}
+	}
+
 	/**
 	 * test json error states
 	 *
@@ -189,6 +234,49 @@ final class CoreLibsConvertJsonTest extends TestCase
 		);
 	}
 
+	/**
+	 * test json error states
+	 *
+	 * @covers ::jsonValidate
+	 * @dataProvider jsonErrorProvider
+	 * @testdox jsonValidate $input will be $expected_i/$expected_s [$_dataName]
+	 *
+	 * @param string|null $input
+	 * @param int $expected_i
+	 * @param string $expected_s
+	 * @return void
+	 */
+	public function testJsonValidateGetLastError(?string $input, int $expected_i, string $expected_s): void
+	{
+		\CoreLibs\Convert\Json::jsonValidate($input);
+		$this->assertEquals(
+			$expected_i,
+			\CoreLibs\Convert\Json::jsonGetLastError()
+		);
+		$this->assertEquals(
+			$expected_s,
+			\CoreLibs\Convert\Json::jsonGetLastError(true)
+		);
+	}
+
+	/**
+	 * test json validation
+	 *
+	 * @covers ::jsonValidate
+	 * @testdox jsonValidate test valid and invalid json
+	 *
+	 * @return void
+	 */
+	public function testJsonValidate(): void
+	{
+		$this->assertTrue(
+			\CoreLibs\Convert\Json::jsonValidate('{"valid": "json"}')
+		);
+		$this->assertFalse(
+			\CoreLibs\Convert\Json::jsonValidate('not valid json')
+		);
+	}
+
 	/**
 	 * Undocumented function
 	 *

4dev/tests/Convert/CoreLibsConvertMathTest.php

@@ -122,9 +122,9 @@ final class CoreLibsConvertMathTest extends TestCase
 	public function providerCbrt(): array
 	{
 		return [
-			'cube root of 2' => [2, 1.25992, 5],
-			'cube root of 3' => [3, 1.44225, 5],
-			'cube root of -1' => [-1, 'NAN', 0],
+			'cube root of 2' => [2, 1.25992, 5, null],
+			'cube root of 3' => [3, 1.44225, 5, null],
+			'cube root of -1' => [-1, 'NAN', 0, \InvalidArgumentException::class],
 		];
 	}
 
@@ -138,10 +138,14 @@ final class CoreLibsConvertMathTest extends TestCase
 	 * @param  float|int $number
 	 * @param  float     $expected
 	 * @param  int       $round_to
+	 * @param  ?string   $exception
 	 * @return void
 	 */
-	public function testCbrt(float|int $number, float|string $expected, int $round_to): void
+	public function testCbrt(float|int $number, float|string $expected, int $round_to, ?string $exception): void
 	{
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
 		$this->assertEquals(
 			$expected,
 			round(\CoreLibs\Convert\Math::cbrt($number), $round_to)

4dev/tests/Convert/CoreLibsConvertStringsRegexValidateTest.php

@@ -0,0 +1,283 @@
+<?php
+
+// This code was created by Claude Sonnet 4
+// FIX:
+// '/test{/',          // Unmatched brace -> this is valid
+// '/test{1,}/',       // Invalid quantifier -> this is valid
+
+declare(strict_types=1);
+
+namespace tests;
+
+use PHPUnit\Framework\TestCase;
+use CoreLibs\Convert\Strings;
+
+/**
+ * Test class for CoreLibs\Convert\Strings regex validation methods
+ */
+class CoreLibsConvertStringsRegexValidateTest extends TestCase
+{
+	/**
+	 * Test isValidRegex with valid regex patterns
+	 */
+	public function testIsValidRegexWithValidPatterns(): void
+	{
+		$validPatterns = [
+			'/^[a-zA-Z0-9]+$/',
+			'/test/',
+			'/\d+/',
+			'/^hello.*world$/',
+			'/[0-9]{3}-[0-9]{3}-[0-9]{4}/',
+			'#^https?://.*#i',
+			'~^[a-z]+~',
+			'|test|',
+			'/^$/m',
+			'/\w+/u',
+		];
+
+		foreach ($validPatterns as $pattern) {
+			$this->assertTrue(
+				Strings::isValidRegex($pattern),
+				"Pattern '{$pattern}' should be valid"
+			);
+		}
+	}
+
+	/**
+	 * Test isValidRegex with invalid regex patterns
+	 */
+	public function testIsValidRegexWithInvalidPatterns(): void
+	{
+		$invalidPatterns = [
+			'/[/',              // Unmatched bracket
+			'/test[/',          // Unmatched bracket
+			'/(?P<name>/',      // Unmatched parenthesis
+			'/(?P<>test)/',     // Invalid named group
+			'/test\\/',         // Invalid escape at end
+			'/(test/',          // Unmatched parenthesis
+			'/test)/',          // Unmatched parenthesis
+			// '/test{/',          // Unmatched brace -> this is valid
+			// '/test{1,}/',       // Invalid quantifier -> this is valid
+			'/[z-a]/',          // Invalid character range
+			'invalid',          // No delimiters
+			'',                 // Empty string
+			'/(?P<123>test)/',  // Invalid named group name
+		];
+
+		foreach ($invalidPatterns as $pattern) {
+			$this->assertFalse(
+				Strings::isValidRegex($pattern),
+				"Pattern '{$pattern}' should be invalid"
+			);
+		}
+	}
+
+	/**
+	 * Test getLastRegexErrorString returns correct error messages
+	 */
+	public function testGetLastRegexErrorStringReturnsCorrectMessages(): void
+	{
+		// Test with a valid regex first to ensure clean state
+		Strings::isValidRegex('/valid/');
+		$this->assertEquals('No error', Strings::getLastRegexErrorString());
+
+		// Test with invalid regex to trigger an error
+		Strings::isValidRegex('/[/');
+		$errorMessage = Strings::getLastRegexErrorString();
+
+		// The error message should be one of the defined messages
+		$this->assertContains($errorMessage, array_values(Strings::PREG_ERROR_MESSAGES));
+		$this->assertNotEquals('Unknown error', $errorMessage);
+	}
+
+	/**
+	 * Test getLastRegexErrorString with unknown error
+	 */
+	public function testGetLastRegexErrorStringWithUnknownError(): void
+	{
+		// This is harder to test directly since we can't easily mock preg_last_error()
+		// but we can test the fallback behavior by reflection or assume it works
+
+		// At minimum, ensure it returns a string
+		$result = Strings::getLastRegexErrorString();
+		$this->assertIsString($result);
+		$this->assertNotEmpty($result);
+	}
+
+	/**
+	 * Test validateRegex with valid patterns
+	 */
+	public function testValidateRegexWithValidPatterns(): void
+	{
+		$validPatterns = [
+			'/^test$/',
+			'/\d+/',
+			'/[a-z]+/i',
+		];
+
+		foreach ($validPatterns as $pattern) {
+			$result = Strings::validateRegex($pattern);
+
+			$this->assertIsArray($result);
+			$this->assertArrayHasKey('valid', $result);
+			$this->assertArrayHasKey('preg_error', $result);
+			$this->assertArrayHasKey('error', $result);
+
+			$this->assertTrue($result['valid'], "Pattern '{$pattern}' should be valid");
+			$this->assertEquals(PREG_NO_ERROR, $result['preg_error']);
+			$this->assertNull($result['error']);
+		}
+	}
+
+	/**
+	 * Test validateRegex with invalid patterns
+	 */
+	public function testValidateRegexWithInvalidPatterns(): void
+	{
+		$invalidPatterns = [
+			'/[/',              // Unmatched bracket
+			'/(?P<name>/',      // Unmatched parenthesis
+			'/test\\/',         // Invalid escape at end
+			'/(test/',          // Unmatched parenthesis
+		];
+
+		foreach ($invalidPatterns as $pattern) {
+			$result = Strings::validateRegex($pattern);
+
+			$this->assertIsArray($result);
+			$this->assertArrayHasKey('valid', $result);
+			$this->assertArrayHasKey('preg_error', $result);
+			$this->assertArrayHasKey('error', $result);
+			$this->assertArrayHasKey('pcre_error', $result);
+
+			$this->assertFalse($result['valid'], "Pattern '{$pattern}' should be invalid");
+			$this->assertNotEquals(PREG_NO_ERROR, $result['preg_error']);
+			$this->assertIsString($result['error']);
+			$this->assertNotNull($result['error']);
+			$this->assertNotEmpty($result['error']);
+
+			// Verify error message is from our defined messages or 'Unknown error'
+			$this->assertTrue(
+				in_array($result['error'], array_values(Strings::PREG_ERROR_MESSAGES)) ||
+				$result['error'] === 'Unknown error'
+			);
+		}
+	}
+
+	/**
+	 * Test validateRegex array structure
+	 */
+	public function testValidateRegexArrayStructure(): void
+	{
+		$result = Strings::validateRegex('/test/');
+
+		// Test array structure for valid regex
+		$this->assertIsArray($result);
+		$this->assertCount(4, $result);
+		$this->assertArrayHasKey('valid', $result);
+		$this->assertArrayHasKey('preg_error', $result);
+		$this->assertArrayHasKey('error', $result);
+
+		$result = Strings::validateRegex('/[/');
+
+		// Test array structure for invalid regex
+		$this->assertIsArray($result);
+		$this->assertCount(4, $result);
+		$this->assertArrayHasKey('valid', $result);
+		$this->assertArrayHasKey('preg_error', $result);
+		$this->assertArrayHasKey('error', $result);
+		$this->assertArrayHasKey('pcre_error', $result);
+	}
+
+	/**
+	 * Test that methods handle edge cases properly
+	 */
+	public function testEdgeCases(): void
+	{
+		// Empty string
+		$this->assertFalse(Strings::isValidRegex(''));
+
+		$result = Strings::validateRegex('');
+		$this->assertFalse($result['valid']);
+
+		// Very long pattern
+		$longPattern = '/' . str_repeat('a', 1000) . '/';
+		$this->assertTrue(Strings::isValidRegex($longPattern));
+
+		// Unicode patterns
+		$this->assertTrue(Strings::isValidRegex('/\p{L}+/u'));
+		$this->assertTrue(Strings::isValidRegex('/[α-ω]+/u'));
+	}
+
+	/**
+	 * Test PREG_ERROR_MESSAGES constant accessibility
+	 */
+	public function testPregErrorMessagesConstant(): void
+	{
+		$this->assertIsArray(Strings::PREG_ERROR_MESSAGES);
+		$this->assertNotEmpty(Strings::PREG_ERROR_MESSAGES);
+
+		// Check that all expected PREG constants are defined
+		$expectedKeys = [
+			PREG_NO_ERROR,
+			PREG_INTERNAL_ERROR,
+			PREG_BACKTRACK_LIMIT_ERROR,
+			PREG_RECURSION_LIMIT_ERROR,
+			PREG_BAD_UTF8_ERROR,
+			PREG_BAD_UTF8_OFFSET_ERROR,
+			PREG_JIT_STACKLIMIT_ERROR,
+		];
+
+		foreach ($expectedKeys as $key) {
+			$this->assertArrayHasKey($key, Strings::PREG_ERROR_MESSAGES);
+			$this->assertIsString(Strings::PREG_ERROR_MESSAGES[$key]);
+			$this->assertNotEmpty(Strings::PREG_ERROR_MESSAGES[$key]);
+		}
+	}
+
+	/**
+	 * Test error state isolation between method calls
+	 */
+	public function testErrorStateIsolation(): void
+	{
+		// Start with invalid regex
+		Strings::isValidRegex('/[/');
+		$firstError = Strings::getLastRegexErrorString();
+		$this->assertNotEquals('No error', $firstError);
+
+		// Use valid regex
+		Strings::isValidRegex('/valid/');
+		$secondError = Strings::getLastRegexErrorString();
+		$this->assertEquals('No error', $secondError);
+
+		// Verify validateRegex clears previous errors
+		$result = Strings::validateRegex('/valid/');
+		$this->assertTrue($result['valid']);
+		$this->assertEquals(PREG_NO_ERROR, $result['preg_error']);
+	}
+
+	/**
+	 * Test various regex delimiters
+	 */
+	public function testDifferentDelimiters(): void
+	{
+		$patterns = [
+			'/test/',      // forward slash
+			'#test#',      // hash
+			'~test~',      // tilde
+			'|test|',      // pipe
+			'@test@',      // at symbol
+			'!test!',      // exclamation
+			'%test%',      // percent
+		];
+
+		foreach ($patterns as $pattern) {
+			$this->assertTrue(
+				Strings::isValidRegex($pattern),
+				"Pattern with delimiter '{$pattern}' should be valid"
+			);
+		}
+	}
+}
+
+// __END__

4dev/tests/Convert/CoreLibsConvertStringsTest.php

@@ -24,117 +24,83 @@ final class CoreLibsConvertStringsTest extends TestCase
 	{
 		// 0: input
 		// 1: format
-		// 2: split characters as string, null for default
 		// 3: expected
 		return [
 			'all empty string' => [
 				'',
 				'',
-				null,
 				''
 			],
 			'empty input string' => [
 				'',
 				'2-2',
-				null,
 				''
 			],
 			'empty format string string' => [
 				'1234',
 				'',
-				null,
 				'1234'
 			],
 			'string format match' => [
 				'1234',
 				'2-2',
-				null,
 				'12-34'
 			],
 			'string format trailing match' => [
 				'1234',
 				'2-2-',
-				null,
 				'12-34'
 			],
 			'string format leading match' => [
 				'1234',
 				'-2-2',
-				null,
 				'12-34'
 			],
 			'string format double inside match' => [
 				'1234',
 				'2--2',
-				null,
 				'12--34',
 			],
 			'string format short first' => [
 				'1',
 				'2-2',
-				null,
 				'1'
 			],
 			'string format match first' => [
 				'12',
 				'2-2',
-				null,
 				'12'
 			],
 			'string format short second' => [
 				'123',
 				'2-2',
-				null,
 				'12-3'
 			],
 			'string format too long' => [
 				'1234567',
 				'2-2',
-				null,
 				'12-34-567'
 			],
-			'string format invalid format string' => [
-				'1234',
-				'2_2',
-				null,
-				'1234'
-			],
 			'different split character' => [
 				'1234',
 				'2_2',
-				'_',
 				'12_34'
 			],
 			'mixed split characters' => [
 				'123456',
 				'2-2_2',
-				'-_',
 				'12-34_56'
 			],
 			'length mixed' => [
 				'ABCD12345568ABC13',
 				'2-4_5-2#4',
-				'-_#',
 				'AB-CD12_34556-8A#BC13'
 			],
 			'split with split chars in string' => [
 				'12-34',
 				'2-2',
-				null,
 				'12--3-4'
 			],
-			'mutltibyte string' => [
-				'あいうえ',
-				'2-2',
-				null,
-				'あいうえ'
-			],
-			'mutltibyte split string' => [
-				'1234',
-				'２-２',
-				null,
-				'1234'
-			],
 		];
 	}
 
@@ -143,29 +109,137 @@ final class CoreLibsConvertStringsTest extends TestCase
 	 *
 	 * @covers ::splitFormatString
 	 * @dataProvider splitFormatStringProvider
-	 * @testdox splitFormatString $input with format $format and splitters $split_characters will be $expected [$_dataName]
+	 * @testdox splitFormatString $input with format $format will be $expected [$_dataName]
 	 *
 	 * @param  string      $input
 	 * @param  string      $format
-	 * @param  string|null $split_characters
 	 * @param  string      $expected
 	 * @return void
 	 */
 	public function testSplitFormatString(
 		string $input,
 		string $format,
+		string $expected
+	): void {
+		$output = \CoreLibs\Convert\Strings::splitFormatString(
+			$input,
+			$format,
+		);
+		$this->assertEquals(
+			$expected,
+			$output
+		);
+	}
+
+	/** check exceptions */
+	public function splitFormatStringExceptionProvider(): array
+	{
+		return [
+			'string format with no splitter match' => [
+				'1234',
+				'22',
+				'12-34'
+			],
+			'invalid format string' => [
+				'1234',
+				'2あ2',
+			],
+			'mutltibyte string' => [
+				'あいうえ',
+				'2-2',
+			],
+			'mutltibyte split string' => [
+				'1234',
+				'２-２',
+			],
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::splitFormatStringFixed
+	 * @dataProvider splitFormatStringExceptionProvider
+	 * @testdox splitFormatString Exception catch checks for $input with $format[$_dataName]
+	 *
+	 * @return void
+	 */
+	public function testSplitFormatStringExceptions(string $input, string $format): void
+	{
+		// catch exception
+		$this->expectException(\InvalidArgumentException::class);
+		\CoreLibs\Convert\Strings::splitFormatString($input, $format);
+	}
+
+	/**
+	 * test for split Format string fixed length
+	 *
+	 * @return array
+	 */
+	public function splitFormatStringFixedProvider(): array
+	{
+		return [
+			'normal split, default split char' => [
+				'abcdefg',
+				4,
+				null,
+				'abcd-efg'
+			],
+			'noraml split, other single split char' => [
+				'abcdefg',
+				4,
+				"=",
+				'abcd=efg'
+			],
+			'noraml split, other multiple split char' => [
+				'abcdefg',
+				4,
+				"-=-",
+				'abcd-=-efg'
+			],
+			'non ascii characters' => [
+				'あいうえお',
+				2,
+				"-",
+				'あい-うえ-お'
+			],
+			'empty string' => [
+				'',
+				4,
+				"-",
+				''
+			]
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::splitFormatStringFixed
+	 * @dataProvider splitFormatStringFixedProvider
+	 * @testdox splitFormatStringFixed $input with length $split_length and split chars $split_characters will be $expected [$_dataName]
+	 *
+	 * @param  string      $input
+	 * @param  int         $split_length
+	 * @param  string|null $split_characters
+	 * @param  string      $expected
+	 * @return void
+	 */
+	public function testSplitFormatStringFixed(
+		string $input,
+		int $split_length,
 		?string $split_characters,
 		string $expected
 	): void {
 		if ($split_characters === null) {
-			$output = \CoreLibs\Convert\Strings::splitFormatString(
+			$output = \CoreLibs\Convert\Strings::splitFormatStringFixed(
 				$input,
-				$format
+				$split_length
 			);
 		} else {
-			$output = \CoreLibs\Convert\Strings::splitFormatString(
+			$output = \CoreLibs\Convert\Strings::splitFormatStringFixed(
 				$input,
-				$format,
+				$split_length,
 				$split_characters
 			);
 		}
@@ -175,6 +249,36 @@ final class CoreLibsConvertStringsTest extends TestCase
 		);
 	}
 
+	public function splitFormatStringFixedExceptionProvider(): array
+	{
+		return [
+			'split length too short' => [
+				'abcdefg',
+				-1,
+			],
+			'split length longer than string' => [
+				'abcdefg',
+				20,
+			],
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::splitFormatStringFixed
+	 * @dataProvider splitFormatStringFixedExceptionProvider
+	 * @testdox splitFormatStringFixed Exception catch checks for $input with $length [$_dataName]
+	 *
+	 * @return void
+	 */
+	public function testSplitFormatStringFixedExceptions(string $input, int $length): void
+	{
+		// catch exception
+		$this->expectException(\InvalidArgumentException::class);
+		\CoreLibs\Convert\Strings::splitFormatStringFixed($input, $length);
+	}
+
 	/**
 	 * Undocumented function
 	 *
@@ -378,6 +482,305 @@ final class CoreLibsConvertStringsTest extends TestCase
 			\CoreLibs\Convert\Strings::stripUTF8BomBytes($file)
 		);
 	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function allCharsInSetProvider(): array
+	{
+		return [
+			'find' => [
+				'abc',
+				'abcdef',
+				true
+			],
+			'not found' => [
+				'abcz',
+				'abcdef',
+				false
+			]
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::allCharsInSet
+	 * @dataProvider allCharsInSetProvider
+	 * @testdox allCharsInSet $input in $haystack with expected $expected [$_dataName]
+	 *
+	 * @param  string $needle
+	 * @param  string $haystack
+	 * @param  bool   $expected
+	 * @return void
+	 */
+	public function testAllCharsInSet(string $needle, string $haystack, bool $expected): void
+	{
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Convert\Strings::allCharsInSet($needle, $haystack)
+		);
+	}
+
+	public function buildCharStringFromListsProvider(): array
+	{
+		return [
+			'test a' => [
+				'abc',
+				['a', 'b', 'c'],
+			],
+			'test b' => [
+				'abc123',
+				['a', 'b', 'c'],
+				['1', '2', '3'],
+			],
+			'test c: no params' => [
+				'',
+			],
+			'test c: empty 1' => [
+				'',
+				[]
+			],
+			'test nested' => [
+				'abc',
+				[['a'], ['b'], ['c']],
+			],
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::buildCharStringFromLists
+	 * @dataProvider buildCharStringFromListsProvider
+	 * @testdox buildCharStringFromLists all $input convert to $expected [$_dataName]
+	 *
+	 * @param  string $expected
+	 * @param  array  ...$input
+	 * @return void
+	 */
+	public function testBuildCharStringFromLists(string $expected, array ...$input): void
+	{
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Convert\Strings::buildCharStringFromLists(...$input)
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function removeDuplicatesProvider(): array
+	{
+		return [
+			'test no change' => [
+				'ABCDEFG',
+				'ABCDEFG',
+			],
+			'test simple' => [
+				'aa',
+				'a'
+			],
+			'test keep lower and uppwer case' => [
+				'AaBbCc',
+				'AaBbCc'
+			],
+			'test unqiue' => [
+				'aabbcc',
+				'abc'
+			],
+			'test multibyte no change' => [
+				'あいうえお',
+				'あいうえお',
+			],
+			'test multibyte' => [
+				'ああいいううええおお',
+				'あいうえお',
+			],
+			'test multibyte special' => [
+				'あぁいぃうぅえぇおぉ',
+				'あぁいぃうぅえぇおぉ',
+			]
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::removeDuplicates
+	 * @dataProvider removeDuplicatesProvider
+	 * @testdox removeDuplicates make $input unqiue to $expected [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $expected
+	 * @return void
+	 */
+	public function testRemoveDuplicates(string $input, string $expected): void
+	{
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Convert\Strings::removeDuplicates($input)
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function isValidRegexSimpleProvider(): array
+	{
+		return [
+			'valid regex' => [
+				'/^[A-z]$/',
+				true,
+				[
+					'valid' => true,
+					'preg_error' => 0,
+					'error' => null,
+					'pcre_error' => null
+				],
+			],
+			'invalid regex A' => [
+				'/^[A-z]$',
+				false,
+				[
+					'valid' => false,
+					'preg_error' => 1,
+					'error' => 'Internal PCRE error',
+					'pcre_error' => 'Internal error'
+				],
+			],
+			'invalid regex B' => [
+				'/^[A-z$',
+				false,
+				[
+					'valid' => false,
+					'preg_error' => 1,
+					'error' => 'Internal PCRE error',
+					'pcre_error' => 'Internal error'
+				],
+			],
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::isValidRegexSimple
+	 * @dataProvider isValidRegexSimpleProvider
+	 * @testdox isValidRegexSimple make $input unqiue to $expected [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  bool $expected
+	 * @return void
+	 */
+	public function testIsValidRegexSimple(string $input, bool $expected, array $expected_extended): void
+	{
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Convert\Strings::isValidRegex($input),
+			'Regex is not valid'
+		);
+		$this->assertEquals(
+			$expected_extended,
+			\CoreLibs\Convert\Strings::validateRegex($input),
+			'Validation of regex failed'
+		);
+		$this->assertEquals(
+			// for true null is set, so we get here No Error
+			$expected_extended['error'] ?? \CoreLibs\Convert\Strings::PREG_ERROR_MESSAGES[0],
+			\CoreLibs\Convert\Strings::getLastRegexErrorString(),
+			'Cannot match last preg error string'
+		);
+	}
+
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function parseCharacterRangesProvider(): array
+	{
+		return [
+			'simple a-z' => [
+				['a-z'],
+				implode('', range('a', 'z')),
+				null,
+			],
+			'simple A-Z' => [
+				['A-Z'],
+				implode('', range('A', 'Z')),
+				null,
+			],
+			'simple 0-9' => [
+				['0-9'],
+				implode('', range('0', '9')),
+				null,
+			],
+			'mixed ranges' => [
+				['a-c', 'X-Z', '3-5'],
+				'abcXYZ345',
+				null,
+			],
+			'reverse ranges' => [
+				['z-a'],
+				'abcdefghijklmnopqrstuvwxyz',
+				null,
+			],
+			'overlapping ranges' => [
+				['a-f', 'd-j'],
+				'abcdefghij',
+				null,
+			],
+			'mixed valid and overlap ranges' => [
+				['a-f', 'z-a', '0-3'],
+				'abcdefghijklmnopqrstuvwxyz0123',
+				null,
+			],
+			'range without dashes' => [
+				['abcddfff'],
+				'abcdf',
+				null,
+			],
+			'invalid ranges' => [
+				['a-あ', 'A-あ', '0-あ'],
+				'',
+				\InvalidArgumentException::class,
+			],
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::parseCharacterRanges
+	 * @dataProvider parseCharacterRangesProvider
+	 * @testdox parseCharacterRanges $input to $expected [$_dataName]
+	 *
+	 * @param  array       $input
+	 * @param  string      $expected
+	 * @param  string|null $expected_exception
+	 * @return void
+	 */
+	public function testParseCharacterRanges(
+		array $input,
+		string $expected,
+		?string $expected_exception
+	): void {
+		if ($expected_exception !== null) {
+			$this->expectException($expected_exception);
+		}
+		$this->assertEquals(
+			$expected,
+			implode('', \CoreLibs\Convert\Strings::parseCharacterRanges(implode('', $input)))
+		);
+	}
 }
 
 // __END__

4dev/tests/Create/CoreLibsCreateHashTest.php

@@ -21,8 +21,10 @@ final class CoreLibsCreateHashTest extends TestCase
 	public function hashData(): array
 	{
 		return [
-			'any string' => [
+			'hash tests' => [
+				// this is the string
 				'text' => 'Some String Text',
+				// hash list special
 				'crc32b_reverse' => 'c5c21d91', // crc32b (in revere)
 				'sha1Short' => '4d2bc9ba0', // sha1Short
 				// via hash
@@ -31,6 +33,8 @@ final class CoreLibsCreateHashTest extends TestCase
 				'fnv132' => '9df444f9', // hash: fnv132
 				'fnv1a32' => '2c5f91b9', // hash: fnv1a32
 				'joaat' => '50dab846', // hash: joaat
+				'ripemd160' => 'aeae3f041b20136451519edd9361570909300342', // hash: ripemd160,
+				'sha256' => '9055080e022f224fa835929b80582b3c71c672206fa3a49a87412c25d9d42ceb', // hash: sha256
 			]
 		];
 	}
@@ -81,7 +85,7 @@ final class CoreLibsCreateHashTest extends TestCase
 	{
 		$list = [];
 		foreach ($this->hashData() as $name => $values) {
-			foreach ([null, 'crc32b', 'adler32', 'fnv132', 'fnv1a32', 'joaat'] as $_hash_type) {
+			foreach ([null, 'crc32b', 'adler32', 'fnv132', 'fnv1a32', 'joaat', 'ripemd160', 'sha256'] as $_hash_type) {
 				// default value test
 				if ($_hash_type === null) {
 					$hash_type = \CoreLibs\Create\Hash::STANDARD_HASH_SHORT;
@@ -114,6 +118,22 @@ final class CoreLibsCreateHashTest extends TestCase
 		];
 	}
 
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function hashStandardProvider(): array
+	{
+		$hash_source = 'Some String Text';
+		return [
+			'Long Hash check: ' . \CoreLibs\Create\Hash::STANDARD_HASH => [
+				$hash_source,
+				hash(\CoreLibs\Create\Hash::STANDARD_HASH, $hash_source)
+			],
+		];
+	}
+
 	/**
 	 * Undocumented function
 	 *
@@ -136,9 +156,13 @@ final class CoreLibsCreateHashTest extends TestCase
 	/**
 	 * Undocumented function
 	 *
+	 * phpcs:disable Generic.Files.LineLength
 	 * @covers ::__sha1Short
+	 * @covers ::__crc32b
+	 * @covers ::sha1Short
 	 * @dataProvider sha1ShortProvider
-	 * @testdox __sha1Short $input will be $expected (crc32b) and $expected_sha1 (sha1 short) [$_dataName]
+	 * @testdox __sha1Short/__crc32b/sha1short $input will be $expected (crc32b) and $expected_sha1 (sha1 short) [$_dataName]
+	 * phpcs:enable Generic.Files.LineLength
 	 *
 	 * @param string $input
 	 * @param string $expected
@@ -149,16 +173,29 @@ final class CoreLibsCreateHashTest extends TestCase
 		// uses crc32b
 		$this->assertEquals(
 			$expected,
-			\CoreLibs\Create\Hash::__sha1Short($input)
+			\CoreLibs\Create\Hash::__sha1Short($input),
+			'__sha1Short depreacted'
 		);
 		$this->assertEquals(
 			$expected,
-			\CoreLibs\Create\Hash::__sha1Short($input, false)
+			\CoreLibs\Create\Hash::__sha1Short($input, false),
+			'__sha1Short (false) depreacted'
+		);
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Create\Hash::__crc32b($input),
+			'__crc32b'
 		);
 		// sha1 type
 		$this->assertEquals(
 			$expected_sha1,
-			\CoreLibs\Create\Hash::__sha1Short($input, true)
+			\CoreLibs\Create\Hash::__sha1Short($input, true),
+			'__sha1Short (true) depreacted'
+		);
+		$this->assertEquals(
+			$expected_sha1,
+			\CoreLibs\Create\Hash::sha1Short($input),
+			'sha1Short'
 		);
 	}
 
@@ -166,8 +203,10 @@ final class CoreLibsCreateHashTest extends TestCase
 	 * Undocumented function
 	 *
 	 * @covers ::__hash
+	 * @covers ::hashShort
+	 * @covers ::hashShort
 	 * @dataProvider hashProvider
-	 * @testdox __hash $input with $hash_type will be $expected [$_dataName]
+	 * @testdox __hash/hashShort/hash $input with $hash_type will be $expected [$_dataName]
 	 *
 	 * @param string $input
 	 * @param string|null $hash_type
@@ -179,12 +218,24 @@ final class CoreLibsCreateHashTest extends TestCase
 		if ($hash_type === null) {
 			$this->assertEquals(
 				$expected,
-				\CoreLibs\Create\Hash::__hash($input)
+				\CoreLibs\Create\Hash::__hash($input),
+				'__hash'
+			);
+			$this->assertEquals(
+				$expected,
+				\CoreLibs\Create\Hash::hashShort($input),
+				'hashShort'
 			);
 		} else {
 			$this->assertEquals(
 				$expected,
-				\CoreLibs\Create\Hash::__hash($input, $hash_type)
+				\CoreLibs\Create\Hash::__hash($input, $hash_type),
+				'__hash with hash type'
+			);
+			$this->assertEquals(
+				$expected,
+				\CoreLibs\Create\Hash::hash($input, $hash_type),
+				'hash with hash type'
 			);
 		}
 	}
@@ -193,8 +244,9 @@ final class CoreLibsCreateHashTest extends TestCase
 	 * Undocumented function
 	 *
 	 * @covers ::__hashLong
+	 * @covers ::hashLong
 	 * @dataProvider hashLongProvider
-	 * @testdox __hashLong $input will be $expected [$_dataName]
+	 * @testdox __hashLong/hashLong $input will be $expected [$_dataName]
 	 *
 	 * @param string $input
 	 * @param string $expected
@@ -206,6 +258,168 @@ final class CoreLibsCreateHashTest extends TestCase
 			$expected,
 			\CoreLibs\Create\Hash::__hashLong($input)
 		);
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Create\Hash::hashLong($input)
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::hash
+	 * @covers ::hashStd
+	 * @dataProvider hashStandardProvider
+	 * @testdox hash/hashStd $input will be $expected [$_dataName]
+	 *
+	 * @param string $input
+	 * @param string $expected
+	 * @return void
+	 */
+	public function testHashStandard(string $input, string $expected): void
+	{
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Create\Hash::hashStd($input)
+		);
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Create\Hash::hash($input)
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::hash
+	 * @testdox hash with invalid type
+	 *
+	 * @return void
+	 */
+	public function testInvalidHashType(): void
+	{
+		$hash_source = 'Some String Text';
+		$expected = hash(\CoreLibs\Create\Hash::STANDARD_HASH, $hash_source);
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Create\Hash::hash($hash_source, 'DOES_NOT_EXIST')
+		);
+	}
+
+	/**
+	 * Note: this only tests default sha256
+	 *
+	 * @covers ::hashHmac
+	 * @testdox hash hmac test
+	 *
+	 * @return void
+	 */
+	public function testHashMac(): void
+	{
+		$hash_key = 'FIX KEY';
+		$hash_source = 'Some String Text';
+		$expected = '16479b3ef6fa44e1cdd8b2dcfaadf314d1a7763635e8738f1e7996d714d9b6bf';
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Create\Hash::hashHmac($hash_source, $hash_key)
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::hashHmac
+	 * @testdox hash hmac with invalid type
+	 *
+	 * @return void
+	 */
+	public function testInvalidHashMacType(): void
+	{
+		$hash_key = 'FIX KEY';
+		$hash_source = 'Some String Text';
+		$expected = hash_hmac(\CoreLibs\Create\Hash::STANDARD_HASH, $hash_source, $hash_key);
+		$this->assertEquals(
+			$expected,
+			\CoreLibs\Create\Hash::hashHmac($hash_source, $hash_key, 'DOES_NOT_EXIST')
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array<mixed>
+	 */
+	public function providerHashTypes(): array
+	{
+		return [
+			'Hash crc32b' => [
+				'crc32b',
+				true,
+				false,
+			],
+			'Hash adler32' => [
+				'adler32',
+				true,
+				false,
+			],
+			'HAsh fnv132' => [
+				'fnv132',
+				true,
+				false,
+			],
+			'Hash fnv1a32' => [
+				'fnv1a32',
+				true,
+				false,
+			],
+			'Hash: joaat' => [
+				'joaat',
+				true,
+				false,
+			],
+			'Hash: ripemd160' => [
+				'ripemd160',
+				true,
+				true,
+			],
+			'Hash: sha256' => [
+				'sha256',
+				true,
+				true,
+			],
+			'Hash: invalid' => [
+				'invalid',
+				false,
+				false
+			]
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::isValidHashType
+	 * @covers ::isValidHashHmacType
+	 * @dataProvider providerHashTypes
+	 * @testdox check if $hash_type is valid for hash $hash_ok and hash hmac $hash_hmac_ok [$_dataName]
+	 *
+	 * @param  string $hash_type
+	 * @param  bool   $hash_ok
+	 * @param  bool   $hash_hmac_ok
+	 * @return void
+	 */
+	public function testIsValidHashAndHashHmacTypes(string $hash_type, bool $hash_ok, bool $hash_hmac_ok): void
+	{
+		$this->assertEquals(
+			$hash_ok,
+			\CoreLibs\Create\Hash::isValidHashType($hash_type),
+			'hash valid'
+		);
+		$this->assertEquals(
+			$hash_hmac_ok,
+			\CoreLibs\Create\Hash::isValidHashHmacType($hash_type),
+			'hash hmac valid'
+		);
 	}
 }
 

4dev/tests/Create/CoreLibsCreateRandomKeyTest.php

@@ -13,32 +13,6 @@ use PHPUnit\Framework\TestCase;
  */
 final class CoreLibsCreateRandomKeyTest extends TestCase
 {
-	/**
-	 * Undocumented function
-	 *
-	 * @return array
-	 */
-	public function keyLenghtProvider(): array
-	{
-		return [
-			'valid key length' => [
-				0 => 6,
-				1 => true,
-				2 => 6,
-			],
-			'negative key length' => [
-				0 => -1,
-				1 => false,
-				2 => 4,
-			],
-			'tpp big key length' => [
-				0 => 300,
-				1 => false,
-				2 => 4,
-			],
-		];
-	}
-
 	/**
 	 * Undocumented function
 	 *
@@ -47,109 +21,67 @@ final class CoreLibsCreateRandomKeyTest extends TestCase
 	public function randomKeyGenProvider(): array
 	{
 		return [
-			'default key length' => [
+			// just key length
+			'default key length, default char set' => [
 				0 => null,
-				1 => 4
+				1 => \CoreLibs\Create\RandomKey::KEY_LENGTH_DEFAULT
 			],
-			'set -1 key length default' => [
+			'set -1 key length, default char set' => [
 				0 => -1,
-				1 => 4,
+				1 => \CoreLibs\Create\RandomKey::KEY_LENGTH_DEFAULT,
 			],
-			'set too large key length' => [
+			'set 0 key length, default char set' => [
+				0 => -1,
+				1 => \CoreLibs\Create\RandomKey::KEY_LENGTH_DEFAULT,
+			],
+			'set too large key length, default char set' => [
 				0 => 300,
-				1 => 4,
+				1 => \CoreLibs\Create\RandomKey::KEY_LENGTH_DEFAULT,
 			],
-			'set override key lenght' => [
+			'set override key lenght, default char set' => [
 				0 => 6,
 				1 => 6,
 			],
+			// just character set
+			'default key length, different char set A' => [
+				0 => \CoreLibs\Create\RandomKey::KEY_LENGTH_DEFAULT,
+				1 => \CoreLibs\Create\RandomKey::KEY_LENGTH_DEFAULT,
+				2 => [
+					'A', 'B', 'C'
+				],
+			],
+			'different key length, different char set B' => [
+				0 => 16,
+				1 => 16,
+				2 => [
+					'A', 'B', 'C'
+				],
+				3 => [
+					'1', '2', '3'
+				]
+			],
 		];
 	}
 
+	// Alternative more efficient version using strpos
 	/**
-	 * 1
+	 * check if all characters are in set
 	 *
-	 * @return array
+	 * @param  string $input
+	 * @param  string $allowed_chars
+	 * @return bool
 	 */
-	public function keepKeyLengthProvider(): array
+	private function allCharsInSet(string $input, string $allowed_chars): bool
 	{
-		return [
-			'set too large' => [
-				0 => 6,
-				1 => 300,
-				2 => 6,
-			],
-			'set too small' => [
-				0 => 8,
-				1 => -2,
-				2 => 8,
-			],
-			'change valid' => [
-				0 => 10,
-				1 => 6,
-				2 => 6,
-			]
-		];
-	}
+		$inputLength = strlen($input);
 
-	/**
-	 * run before each test and reset to default 4
-	 *
-	 * @before
-	 *
-	 * @return void
-	 */
-	public function resetKeyLength(): void
-	{
-		\CoreLibs\Create\RandomKey::setRandomKeyLength(4);
-	}
-
-	/**
-	 * check that first length is 4
-	 *
-	 * @covers ::getRandomKeyLength
-	 * @testWith [4]
-	 * @testdox getRandomKeyLength on init will be $expected [$_dataName]
-	 *
-	 * @param integer $expected
-	 * @return void
-	 */
-	public function testGetRandomKeyLengthInit(int $expected): void
-	{
-		$this->assertEquals(
-			$expected,
-			\CoreLibs\Create\RandomKey::getRandomKeyLength()
-		);
-	}
-
-	/**
-	 * Undocumented function
-	 *
-	 * @covers ::setRandomKeyLength
-	 * @covers ::getRandomKeyLength
-	 * @dataProvider keyLenghtProvider
-	 * @testdox setRandomKeyLength $input will be $expected, compare to $compare [$_dataName]
-	 *
-	 * @param integer $input
-	 * @param boolean $expected
-	 * @param integer $compare
-	 * @return void
-	 */
-	public function testSetRandomKeyLength(int $input, bool $expected, int $compare): void
-	{
-		// set
-		$this->assertEquals(
-			$expected,
-			\CoreLibs\Create\RandomKey::setRandomKeyLength($input)
-		);
-		// read test, if false, use compare check
-		if ($expected === false) {
-			$input = $compare;
+		for ($i = 0; $i < $inputLength; $i++) {
+			if (strpos($allowed_chars, $input[$i]) === false) {
+				return false;
+			}
 		}
-		$this->assertEquals(
-			$input,
-			\CoreLibs\Create\RandomKey::getRandomKeyLength()
-		);
+
+		return true;
 	}
 
 	/**
@@ -163,43 +95,41 @@ final class CoreLibsCreateRandomKeyTest extends TestCase
 	 * @param integer $expected
 	 * @return void
 	 */
-	public function testRandomKeyGen(?int $input, int $expected): void
+	public function testRandomKeyGen(?int $input, int $expected, array ...$key_range): void
 	{
+		$__key_data = \CoreLibs\Create\RandomKey::KEY_CHARACTER_RANGE_DEFAULT;
+		if (count($key_range)) {
+			$__key_data = join('', array_unique(array_merge(...$key_range)));
+		}
 		if ($input === null) {
 			$this->assertEquals(
 				$expected,
 				strlen(\CoreLibs\Create\RandomKey::randomKeyGen())
 			);
-		} else {
+		} elseif ($input !== null && !count($key_range)) {
+			$random_key = \CoreLibs\Create\RandomKey::randomKeyGen($input);
+			$this->assertTrue(
+				$this->allCharsInSet($random_key, $__key_data),
+				'Characters not valid'
+			);
 			$this->assertEquals(
 				$expected,
-				strlen(\CoreLibs\Create\RandomKey::randomKeyGen($input))
+				strlen($random_key),
+				'String length not matching'
+			);
+		} elseif (count($key_range)) {
+			$random_key = \CoreLibs\Create\RandomKey::randomKeyGen($input, ...$key_range);
+			$this->assertTrue(
+				$this->allCharsInSet($random_key, $__key_data),
+				'Characters not valid'
+			);
+			$this->assertEquals(
+				$expected,
+				strlen($random_key),
+				'String length not matching'
 			);
 		}
 	}
-
-	/**
-	 * Check that if set to n and then invalid, it keeps the previous one
-	 * or if second change valid, second will be shown
-	 *
-	 * @covers ::setRandomKeyLength
-	 * @dataProvider keepKeyLengthProvider
-	 * @testdox keep setRandomKeyLength set with $input_valid and then $input_invalid will be $expected [$_dataName]
-	 *
-	 * @param integer $input_valid
-	 * @param integer $input_invalid
-	 * @param integer $expected
-	 * @return void
-	 */
-	public function testKeepKeyLength(int $input_valid, int $input_invalid, int $expected): void
-	{
-		\CoreLibs\Create\RandomKey::setRandomKeyLength($input_valid);
-		\CoreLibs\Create\RandomKey::setRandomKeyLength($input_invalid);
-		$this->assertEquals(
-			$expected,
-			\CoreLibs\Create\RandomKey::getRandomKeyLength()
-		);
-	}
 }
 
 // __END__

4dev/tests/DB/CoreLibsDBIOTest.php

@@ -135,6 +135,7 @@ final class CoreLibsDBIOTest extends TestCase
 		}
 		// check if they already exist, drop them
 		if ($db->dbShowTableMetaData('table_with_primary_key') !== false) {
+			$db->dbExec("CREATE EXTENSION IF NOT EXISTS pgcrypto");
 			$db->dbExec("DROP TABLE table_with_primary_key");
 			$db->dbExec("DROP TABLE table_without_primary_key");
 			$db->dbExec("DROP TABLE test_meta");
@@ -3692,7 +3693,7 @@ final class CoreLibsDBIOTest extends TestCase
 	 *
 	 * @return array
 	 */
-	public function preparedProviderValue(): array
+	public function providerDbGetPrepareCursorValue(): array
 	{
 		// 1: query (can be empty for do not set)
 		// 2: stm name
@@ -3736,7 +3737,7 @@ final class CoreLibsDBIOTest extends TestCase
 	 * test return prepare cursor errors
 	 *
 	 * @covers ::dbGetPrepareCursorValue
-	 * @dataProvider preparedProviderValue
+	 * @dataProvider providerDbGetPrepareCursorValue
 	 * @testdox prepared query $stm_name with $key expect error id $error_id [$_dataName]
 	 *
 	 * @param string $query
@@ -3769,6 +3770,94 @@ final class CoreLibsDBIOTest extends TestCase
 		);
 	}
 
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function providerDbPreparedCursorStatus(): array
+	{
+		return [
+			'empty statement pararm' => [
+				'query' => 'SELECT row_int, uid FROM table_with_primary_key',
+				'stm_name' => 'test_stm_a',
+				'check_stm_name' => '',
+				'check_query' => '',
+				'expected' => false
+			],
+			'different stm_name' => [
+				'query' => 'SELECT row_int, uid FROM table_with_primary_key',
+				'stm_name' => 'test_stm_b',
+				'check_stm_name' => 'other_name',
+				'check_query' => '',
+				'expected' => 0
+			],
+			'same stm_name' => [
+				'query' => 'SELECT row_int, uid FROM table_with_primary_key',
+				'stm_name' => 'test_stm_c',
+				'check_stm_name' => 'test_stm_c',
+				'check_query' => '',
+				'expected' => 1
+			],
+			'same stm_name and query' => [
+				'query' => 'SELECT row_int, uid FROM table_with_primary_key',
+				'stm_name' => 'test_stm_d',
+				'check_stm_name' => 'test_stm_d',
+				'check_query' => 'SELECT row_int, uid FROM table_with_primary_key',
+				'expected' => 2
+			],
+			'same stm_name and different query' => [
+				'query' => 'SELECT row_int, uid FROM table_with_primary_key',
+				'stm_name' => 'test_stm_e',
+				'check_stm_name' => 'test_stm_e',
+				'check_query' => 'SELECT row_int, uid, row_int FROM table_with_primary_key',
+				'expected' => 1
+			],
+			'insert query test' => [
+				'query' => 'INSERT INTO table_with_primary_key (row_int, uid) VALUES ($1, $2)',
+				'stm_name' => 'test_stm_f',
+				'check_stm_name' => 'test_stm_f',
+				'check_query' => 'INSERT INTO table_with_primary_key (row_int, uid) VALUES ($1, $2)',
+				'expected' => 2
+			]
+		];
+	}
+
+	/**
+	 * test cursor status for prepared statement
+	 *
+	 * @covers ::dbPreparedCursorStatus
+	 * @dataProvider providerDbPreparedCursorStatus
+	 * @testdox Check prepared $stm_name ($check_stm_name) status is $expected [$_dataName]
+	 *
+	 * @param  string   $query
+	 * @param  string   $stm_name
+	 * @param  string   $check_stm_name
+	 * @param  string   $check_query
+	 * @param  bool|int $expected
+	 * @return void
+	 */
+	public function testDbPreparedCursorStatus(
+		string $query,
+		string $stm_name,
+		string $check_stm_name,
+		string $check_query,
+		bool|int $expected
+	): void {
+		$db = new \CoreLibs\DB\IO(
+			self::$db_config['valid'],
+			self::$log
+		);
+		$db->dbPrepare($stm_name, $query);
+		// $db->dbExecute($stm_name);
+		$this->assertEquals(
+			$expected,
+			$db->dbPreparedCursorStatus($check_stm_name, $check_query),
+			'check prepared stement cursor status'
+		);
+		unset($db);
+	}
+
 	// - schema set/get tests
 	//   dbGetSchema, dbSetSchema
 
@@ -4656,7 +4745,7 @@ final class CoreLibsDBIOTest extends TestCase
 		$res = $db->dbReturnRowParams($query_select, ['CONVERT_TYPE_TEST']);
 		// all hast to be string
 		foreach ($res as $key => $value) {
-			$this->assertIsString($value, 'Aseert string for column: ' . $key);
+			$this->assertIsString($value, 'Assert string for column: ' . $key);
 		}
 		// convert base only
 		$db->dbSetConvertFlag(Convert::on);
@@ -4669,10 +4758,10 @@ final class CoreLibsDBIOTest extends TestCase
 			}
 			switch ($type_layout[$name]) {
 				case 'int':
-					$this->assertIsInt($value, 'Aseert int for column: ' . $key . '/' . $name);
+					$this->assertIsInt($value, 'Assert int for column: ' . $key . '/' . $name);
 					break;
 				default:
-					$this->assertIsString($value, 'Aseert string for column: ' . $key  . '/' . $name);
+					$this->assertIsString($value, 'Assert string for column: ' . $key  . '/' . $name);
 					break;
 			}
 		}
@@ -4686,13 +4775,13 @@ final class CoreLibsDBIOTest extends TestCase
 			}
 			switch ($type_layout[$name]) {
 				case 'int':
-					$this->assertIsInt($value, 'Aseert int for column: ' . $key . '/' . $name);
+					$this->assertIsInt($value, 'Assert int for column: ' . $key . '/' . $name);
 					break;
 				case 'float':
-					$this->assertIsFloat($value, 'Aseert float for column: ' . $key . '/' . $name);
+					$this->assertIsFloat($value, 'Assert float for column: ' . $key . '/' . $name);
 					break;
 				default:
-					$this->assertIsString($value, 'Aseert string for column: ' . $key  . '/' . $name);
+					$this->assertIsString($value, 'Assert string for column: ' . $key  . '/' . $name);
 					break;
 			}
 		}
@@ -4706,17 +4795,17 @@ final class CoreLibsDBIOTest extends TestCase
 			}
 			switch ($type_layout[$name]) {
 				case 'int':
-					$this->assertIsInt($value, 'Aseert int for column: ' . $key . '/' . $name);
+					$this->assertIsInt($value, 'Assert int for column: ' . $key . '/' . $name);
 					break;
 				case 'float':
-					$this->assertIsFloat($value, 'Aseert float for column: ' . $key . '/' . $name);
+					$this->assertIsFloat($value, 'Assert float for column: ' . $key . '/' . $name);
 					break;
 				case 'json':
 				case 'jsonb':
-					$this->assertIsArray($value, 'Aseert array for column: ' . $key . '/' . $name);
+					$this->assertIsArray($value, 'Assert array for column: ' . $key . '/' . $name);
 					break;
 				default:
-					$this->assertIsString($value, 'Aseert string for column: ' . $key  . '/' . $name);
+					$this->assertIsString($value, 'Assert string for column: ' . $key  . '/' . $name);
 					break;
 			}
 		}
@@ -4730,25 +4819,25 @@ final class CoreLibsDBIOTest extends TestCase
 			}
 			switch ($type_layout[$name]) {
 				case 'int':
-					$this->assertIsInt($value, 'Aseert int for column: ' . $key . '/' . $name);
+					$this->assertIsInt($value, 'Assert int for column: ' . $key . '/' . $name);
 					break;
 				case 'float':
-					$this->assertIsFloat($value, 'Aseert float for column: ' . $key . '/' . $name);
+					$this->assertIsFloat($value, 'Assert float for column: ' . $key . '/' . $name);
 					break;
 				case 'json':
 				case 'jsonb':
-					$this->assertIsArray($value, 'Aseert array for column: ' . $key . '/' . $name);
+					$this->assertIsArray($value, 'Assert array for column: ' . $key . '/' . $name);
 					break;
 				case 'bytea':
 					// for hex types it must not start with \x
 					$this->assertStringStartsNotWith(
 						'\x',
 						$value,
-						'Aseert bytes not starts with \x for column: ' . $key . '/' . $name
+						'Assert bytes not starts with \x for column: ' . $key . '/' . $name
 					);
 					break;
 				default:
-					$this->assertIsString($value, 'Aseert string for column: ' . $key  . '/' . $name);
+					$this->assertIsString($value, 'Assert string for column: ' . $key  . '/' . $name);
 					break;
 			}
 		}
@@ -4920,8 +5009,8 @@ final class CoreLibsDBIOTest extends TestCase
 				)
 			),
 			($params === null ?
-				$db->dbGetQueryHash($query) :
-				$db->dbGetQueryHash($query, $params)
+				$db->dbBuildQueryHash($query) :
+				$db->dbBuildQueryHash($query, $params)
 			),
 			'Failed assertdbGetQueryHash '
 		);
@@ -5147,6 +5236,9 @@ final class CoreLibsDBIOTest extends TestCase
 					$3
 					-- comment 3
 					, $4
+					-- ignore $5, $6
+					-- $7, $8
+					-- digest($9, 10)
 				)
 				SQL,
 				'count' => 4,
@@ -5196,8 +5288,78 @@ final class CoreLibsDBIOTest extends TestCase
 				SQL,
 				'count' => 1,
 				'convert' => false,
+			],
+			'update with case' => [
+				'query' => <<<SQL
+				UPDATE table_with_primary_key SET
+					row_int = $1::INT,
+					row_varchar = CASE WHEN row_int = 1 THEN $2 ELSE 'bar'::VARCHAR END
+				WHERE
+					row_varchar = $3
+				SQL,
+				'count' => 3,
+				'convert' => false,
+			],
+			'select with case' => [
+				'query' => <<<SQL
+				SELECT row_int
+				FROM table_with_primary_key
+				WHERE
+					row_varchar = CASE WHEN row_int = 1 THEN $1 ELSE $2 END
+				SQL,
+				'count' => 2,
+				'convert' => false,
+			],
+			// special $$ string case
+			'text string, with $ placehoders that could be seen as $$ string' => [
+				'query' => <<<SQL
+				SELECT row_int
+				FROM table_with_primary_key
+				WHERE
+					row_bytea = digest($3::VARCHAR, $4) OR
+					row_varchar = encode(digest($3, $4), 'hex') OR
+					row_bytea = hmac($3, $5, $4) OR
+					row_varchar = encode(hmac($3, $5, $4), 'hex') OR
+					row_bytea = pgp_sym_encrypt($3, $6) OR
+					row_varchar = encode(pgp_sym_encrypt($1, $6), 'hex') OR
+					row_varchar = CASE WHEN row_int = 1 THEN $1 ELSE $2 END
+				SQL,
+				'count' => 6,
+				'convert' => false,
+			],
+			// NOTE, in SQL heredoc we cannot write $$ strings parts
+			'text string, with $ placehoders are in $$ strings' => [
+				'query' => '
+				SELECT row_int
+				FROM table_with_primary_key
+				WHERE
+					row_varchar = $$some string$$ OR
+					row_varchar = $tag$some string$tag$ OR
+					row_varchar = $btag$some $1 string$btag$ OR
+					row_varchar = $btag$some $1 $subtag$ something $subtag$string$btag$ OR
+					row_varchar = $1
+				',
+				'count' => 1,
+				'convert' => false,
+			],
+			// a text string with escaped quite
+			'text string, with escaped quote' => [
+				'query' => <<<SQL
+				SELECT row_int
+				FROM table_with_primary_key
+				WHERE
+					row_varchar = 'foo bar bar baz $5' OR
+					row_varchar = 'foo bar '' barbar $6' OR
+					row_varchar = E'foo bar \' barbar $7' OR
+					row_varchar = CASE WHEN row_int = 1 THEN $1 ELSE $2 END
+				SQL,
+				'count' => 2,
+				'convert' => false,
 			]
 		];
+		$string = <<<SQL
+		'''
+		SQL;
 	}
 
 	/**

4dev/tests/Logging/CoreLibsLoggingErrorMessagesTest.php

@@ -105,11 +105,15 @@ final class CoreLibsLoggingErrorMessagesTest extends TestCase
 			'log_folder' => self::LOG_FOLDER,
 			'log_level' => Level::Error,
 		]);
+		$errorLogTmpfile = tmpfile();
+		$errorLogLocationBackup = ini_set('error_log', stream_get_meta_data($errorLogTmpfile)['uri']);
 		$em = new \CoreLibs\Logging\ErrorMessage($log);
 		$em->setMessage(
 			$level,
 			$str
 		);
+		// for exceptions if log level is set to catch them
+		$error_log_content = stream_get_contents($errorLogTmpfile);
 		$this->assertEquals(
 			[
 				'level' => $expected,
@@ -377,6 +381,8 @@ final class CoreLibsLoggingErrorMessagesTest extends TestCase
 		?bool $log_warning,
 		string $expected
 	): void {
+		$errorLogTmpfile = tmpfile();
+		$errorLogLocationBackup = ini_set('error_log', stream_get_meta_data($errorLogTmpfile)['uri']);
 		$log = new \CoreLibs\Logging\Logging([
 			'log_file_id' => 'testErrorMessagesLogError',
 			'log_folder' => self::LOG_FOLDER,
@@ -392,6 +398,9 @@ final class CoreLibsLoggingErrorMessagesTest extends TestCase
 			log_error: $log_error,
 			log_warning: $log_warning
 		);
+		ini_set('error_log', $errorLogLocationBackup);
+		// for exceptions if log level is set to catch them
+		$error_log_content = stream_get_contents($errorLogTmpfile);
 		$file_content = '';
 		if (is_file($log->getLogFolder() . $log->getLogFile())) {
 			$file_content = file_get_contents(
@@ -447,6 +456,8 @@ final class CoreLibsLoggingErrorMessagesTest extends TestCase
 			'log_level' => Level::Debug,
 			'log_per_run' => true
 		]);
+		$errorLogTmpfile = tmpfile();
+		$errorLogLocationBackup = ini_set('error_log', stream_get_meta_data($errorLogTmpfile)['uri']);
 		$em = new \CoreLibs\Logging\ErrorMessage($log);
 		$em->setErrorMsg(
 			$id,
@@ -456,6 +467,9 @@ final class CoreLibsLoggingErrorMessagesTest extends TestCase
 			log_error: $log_error,
 			log_warning: $log_warning
 		);
+		ini_set('error_log', $errorLogLocationBackup);
+		// for exceptions if log level is set to catch them
+		$error_log_content = stream_get_contents($errorLogTmpfile);
 		$file_content = '';
 		if (is_file($log->getLogFolder() . $log->getLogFile())) {
 			$file_content = file_get_contents(

4dev/tests/Logging/CoreLibsLoggingLoggingTest.php

@@ -18,7 +18,7 @@ use CoreLibs\Logging\Logger\Flag;
 final class CoreLibsLoggingLoggingTest extends TestCase
 {
 	private const LOG_FOLDER = __DIR__ . DIRECTORY_SEPARATOR . 'log' . DIRECTORY_SEPARATOR;
-	private const REGEX_BASE = "\[[\d\-\s\.:]+\]\s{1}" // date
+	private const REGEX_BASE = "\[[\d\-\s\.:+T]+\]\s{1}" // date, just basic checks
 		. "\[[\w\.]+(:\d+)?\]\s{1}" // host:port
 		. "\[(phar:\/\/)?[\w\-\.\/]+:\d+\]\s{1}" // folder/file [note phar:// is for phpunit]
 		. "\[\w+\]\s{1}" // run id
@@ -249,7 +249,7 @@ final class CoreLibsLoggingLoggingTest extends TestCase
 		$this->assertFalse(
 			$log->loggingLevelIsDebug()
 		);
-		// not set, should be debug]
+		// not set, should be debug
 		$log = new \CoreLibs\Logging\Logging([
 			'log_file_id' => 'testSetLoggingLevel',
 			'log_folder' => self::LOG_FOLDER,
@@ -297,6 +297,71 @@ final class CoreLibsLoggingLoggingTest extends TestCase
 		$log->setLoggingLevel('NotGood');
 	}
 
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::setErrorLogWriteLevel
+	 * @covers ::getErrorLogWriteLevel
+	 * @testdox setErrorLogWriteLevel set/get checks
+	 *
+	 * @return void
+	 */
+	public function testSetErrorLogWriteLevel(): void
+	{
+		// valid that is not Debug
+		$log = new \CoreLibs\Logging\Logging([
+			'log_file_id' => 'testSetErrorLogWriteLevel',
+			'log_folder' => self::LOG_FOLDER,
+			'error_log_write_level' => Level::Error
+		]);
+		$this->assertEquals(
+			Level::Error,
+			$log->getErrorLogWriteLevel()
+		);
+		// not set on init
+		$log = new \CoreLibs\Logging\Logging([
+			'log_file_id' => 'testSetErrorLogWriteLevel',
+			'log_folder' => self::LOG_FOLDER,
+		]);
+		$this->assertEquals(
+			Level::Emergency,
+			$log->getErrorLogWriteLevel()
+		);
+		// invalid, should be Emergency, will throw excpetion too
+		$this->expectException(\InvalidArgumentException::class);
+		$this->expectExceptionMessage(
+			'Option: "error_log_write_level" is not of instance \CoreLibs\Logging\Logger\Level'
+		);
+		$log = new \CoreLibs\Logging\Logging([
+			'log_file_id' => 'testSetLoggingLevel',
+			'log_folder' => self::LOG_FOLDER,
+			'error_log_write_level' => 'I'
+		]);
+		$this->assertEquals(
+			Level::Emergency,
+			$log->getErrorLogWriteLevel()
+		);
+		// set valid then change
+		$log = new \CoreLibs\Logging\Logging([
+			'log_file_id' => 'testSetErrorLogWriteLevel',
+			'log_folder' => self::LOG_FOLDER,
+			'error_log_write_level' => Level::Error
+		]);
+		$this->assertEquals(
+			Level::Error,
+			$log->getErrorLogWriteLevel()
+		);
+		$log->setErrorLogWriteLevel(Level::Notice);
+		$this->assertEquals(
+			Level::Notice,
+			$log->getErrorLogWriteLevel()
+		);
+		// illegal logging level
+		$this->expectException(\Psr\Log\InvalidArgumentException::class);
+		$this->expectExceptionMessageMatches("/^Level \"NotGood\" is not defined, use one of: /");
+		$log->setErrorLogWriteLevel('NotGood');
+	}
+
 	// setLogFileId
 	// getLogFileId
 
@@ -395,7 +460,7 @@ final class CoreLibsLoggingLoggingTest extends TestCase
 		}
 		$per_run_id = $log->getLogUniqueId();
 		$this->assertMatchesRegularExpression(
-			"/^\d{4}-\d{2}-\d{2}_\d{6}_U_[a-z0-9]{8}$/",
+			"/^\d{4}-\d{2}-\d{2}_\d{6}\.U_[a-z0-9]{8}$/",
 			$per_run_id,
 			'assert per log run id 1st'
 		);
@@ -403,7 +468,7 @@ final class CoreLibsLoggingLoggingTest extends TestCase
 			$log->setLogUniqueId(true);
 			$per_run_id_2nd = $log->getLogUniqueId();
 			$this->assertMatchesRegularExpression(
-				"/^\d{4}-\d{2}-\d{2}_\d{6}_U_[a-z0-9]{8}$/",
+				"/^\d{4}-\d{2}-\d{2}_\d{6}\.U_[a-z0-9]{8}$/",
 				$per_run_id_2nd,
 				'assert per log run id 2nd'
 			);
@@ -824,13 +889,13 @@ final class CoreLibsLoggingLoggingTest extends TestCase
 		$this->assertTrue($log_ok, 'assert ::log (debug) OK');
 		$this->assertEquals(
 			$log->getLogFile(),
-			$log->getLogFileId() . '_DEBUG.log'
+			$log->getLogFileId() . '.DEBUG.log'
 		);
 		$log_ok = $log->log(Level::Info, 'INFO', group_id: 'GROUP_ID', prefix: 'PREFIX:');
 		$this->assertTrue($log_ok, 'assert ::log (info) OK');
 		$this->assertEquals(
 			$log->getLogFile(),
-			$log->getLogFileId() . '_INFO.log'
+			$log->getLogFileId() . '.INFO.log'
 		);
 	}
 

4dev/tests/Security/CoreLibsSecurityAsymmetricAnonymousEncryptionTest.php

@@ -0,0 +1,838 @@
+<?php
+
+declare(strict_types=1);
+
+namespace tests;
+
+use PHPUnit\Framework\TestCase;
+use CoreLibs\Security\CreateKey;
+use CoreLibs\Security\AsymmetricAnonymousEncryption;
+
+/**
+ * Test class for Security\AsymmetricAnonymousEncryption and Security\CreateKey
+ * @coversDefaultClass \CoreLibs\Security\AsymmetricAnonymousEncryption
+ * @testdox \CoreLibs\Security\AsymmetricAnonymousEncryption method tests
+ */
+final class CoreLibsSecurityAsymmetricAnonymousEncryptionTest extends TestCase
+{
+	// MARK: key set and compare
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::getKeyPair
+	 * @covers ::compareKeyPair
+	 * @covers ::getPublicKey
+	 * @covers ::comparePublicKey
+	 * @testdox Check if init class set key pair matches to created key pair and public key
+	 *
+	 * @return void
+	 */
+	public function testKeyPairInitGetCompare(): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$crypt = new AsymmetricAnonymousEncryption($key_pair);
+		$this->assertTrue(
+			$crypt->compareKeyPair($key_pair),
+			'set key pair not equal to original key pair'
+		);
+		$this->assertTrue(
+			$crypt->comparePublicKey($public_key),
+			'automatic set public key not equal to original public key'
+		);
+		$this->assertEquals(
+			$key_pair,
+			$crypt->getKeyPair(),
+			'set key pair returned not equal to original key pair'
+		);
+		$this->assertEquals(
+			$public_key,
+			$crypt->getPublicKey(),
+			'automatic set public key returned not equal to original public key'
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::getKeyPair
+	 * @covers ::compareKeyPair
+	 * @covers ::getPublicKey
+	 * @covers ::comparePublicKey
+	 * @testdox Check if init class set key pair and public key matches to created key pair and public key
+	 *
+	 * @return void
+	 */
+	public function testKeyPairPublicKeyInitGetCompare(): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$crypt = new AsymmetricAnonymousEncryption($key_pair, $public_key);
+		$this->assertTrue(
+			$crypt->compareKeyPair($key_pair),
+			'set key pair not equal to original key pair'
+		);
+		$this->assertTrue(
+			$crypt->comparePublicKey($public_key),
+			'set public key not equal to original public key'
+		);
+		$this->assertEquals(
+			$key_pair,
+			$crypt->getKeyPair(),
+			'set key pair returned not equal to original key pair'
+		);
+		$this->assertEquals(
+			$public_key,
+			$crypt->getPublicKey(),
+			'set public key returned not equal to original public key'
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::getKeyPair
+	 * @covers ::getPublicKey
+	 * @covers ::comparePublicKey
+	 * @testdox Check if init class set public key matches to created public key
+	 *
+	 * @return void
+	 */
+	public function testPublicKeyInitGetCompare(): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$crypt = new AsymmetricAnonymousEncryption(public_key:$public_key);
+		$this->assertTrue(
+			$crypt->comparePublicKey($public_key),
+			'set public key not equal to original public key'
+		);
+		$this->assertEquals(
+			null,
+			$crypt->getKeyPair(),
+			'unset set key pair returned not equal to original key pair'
+		);
+		$this->assertEquals(
+			$public_key,
+			$crypt->getPublicKey(),
+			'set public key returned not equal to original public key'
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::setKeyPair
+	 * @covers ::getKeyPair
+	 * @covers ::compareKeyPair
+	 * @covers ::getPublicKey
+	 * @covers ::comparePublicKey
+	 * @testdox Check if set key pair after class init matches to created key pair and public key
+	 *
+	 * @return void
+	 */
+	public function testKeyPairSetGetCompare(): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$crypt = new AsymmetricAnonymousEncryption();
+		$crypt->setKeyPair($key_pair);
+		$this->assertTrue(
+			$crypt->compareKeyPair($key_pair),
+			'post class init set key pair not equal to original key pair'
+		);
+		$this->assertTrue(
+			$crypt->comparePublicKey($public_key),
+			'post class init automatic set public key not equal to original public key'
+		);
+		$this->assertEquals(
+			$key_pair,
+			$crypt->getKeyPair(),
+			'post class init set key pair returned not equal to original key pair'
+		);
+		$this->assertEquals(
+			$public_key,
+			$crypt->getPublicKey(),
+			'post class init automatic set public key returned not equal to original public key'
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::setKeyPair
+	 * @covers ::setPublicKey
+	 * @covers ::getKeyPair
+	 * @covers ::compareKeyPair
+	 * @covers ::getPublicKey
+	 * @covers ::comparePublicKey
+	 * @testdox Check if set key pair after class init matches to created key pair and public key
+	 *
+	 * @return void
+	 */
+	public function testKeyPairPublicKeySetGetCompare(): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$crypt = new AsymmetricAnonymousEncryption();
+		$crypt->setKeyPair($key_pair);
+		$crypt->setPublicKey($public_key);
+		$this->assertTrue(
+			$crypt->compareKeyPair($key_pair),
+			'post class init set key pair not equal to original key pair'
+		);
+		$this->assertTrue(
+			$crypt->comparePublicKey($public_key),
+			'post class init set public key not equal to original public key'
+		);
+		$this->assertEquals(
+			$key_pair,
+			$crypt->getKeyPair(),
+			'post class init set key pair returned not equal to original key pair'
+		);
+		$this->assertEquals(
+			$public_key,
+			$crypt->getPublicKey(),
+			'post class init set public key returned not equal to original public key'
+		);
+	}
+
+		/**
+	 * Undocumented function
+	 *
+	 * @covers ::setPublicKey
+	 * @covers ::getKeyPair
+	 * @covers ::compareKeyPair
+	 * @covers ::getPublicKey
+	 * @covers ::comparePublicKey
+	 * @testdox Check if set key pair after class init matches to created key pair and public key
+	 *
+	 * @return void
+	 */
+	public function testPublicKeySetGetCompare(): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$crypt = new AsymmetricAnonymousEncryption();
+		$crypt->setPublicKey($public_key);
+		$this->assertTrue(
+			$crypt->comparePublicKey($public_key),
+			'post class init set public key not equal to original public key'
+		);
+		$this->assertEquals(
+			null,
+			$crypt->getKeyPair(),
+			'post class init unset key pair returned not equal to original key pair'
+		);
+		$this->assertEquals(
+			$public_key,
+			$crypt->getPublicKey(),
+			'post class init set public key returned not equal to original public key'
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @testdox Check different key pair and public key set
+	 *
+	 * @return void
+	 */
+	public function testDifferentSetKeyPairPublicKey()
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$key_pair_2 = CreateKey::createKeyPair();
+		$public_key_2 = CreateKey::getPublicKey($key_pair_2);
+		$crypt = new AsymmetricAnonymousEncryption($key_pair, $public_key_2);
+		$this->assertTrue(
+			$crypt->compareKeyPair($key_pair),
+			'key pair set matches key pair created'
+		);
+		$this->assertTrue(
+			$crypt->comparePublicKey($public_key_2),
+			'alternate public key set matches alternate public key created'
+		);
+		$this->assertFalse(
+			$crypt->comparePublicKey($public_key),
+			'alternate public key set does not match key pair public key'
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @testdox Check if new set privat key does not overwrite set public key
+	 *
+	 * @return void
+	 */
+	public function testUpdateKeyPairNotUpdatePublicKey(): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$crypt = new AsymmetricAnonymousEncryption($key_pair);
+		$this->assertTrue(
+			$crypt->compareKeyPair($key_pair),
+			'set key pair not equal to original key pair'
+		);
+		$this->assertTrue(
+			$crypt->comparePublicKey($public_key),
+			'set public key not equal to original public key'
+		);
+		$key_pair_2 = CreateKey::createKeyPair();
+		$public_key_2 = CreateKey::getPublicKey($key_pair_2);
+		$crypt->setKeyPair($key_pair_2);
+		$this->assertTrue(
+			$crypt->compareKeyPair($key_pair_2),
+			'new set key pair not equal to original new key pair'
+		);
+		$this->assertTrue(
+			$crypt->comparePublicKey($public_key),
+			'original set public key not equal to original public key'
+		);
+		$this->assertFalse(
+			$crypt->comparePublicKey($public_key_2),
+			'new public key equal to original public key'
+		);
+	}
+
+	// MARK: empty encrytped string
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::decryptKey
+	 * @covers ::decrypt
+	 * @testdox Test empty encrypted string to decrypt
+	 *
+	 * @return void
+	 */
+	public function testEmptyDecryptionString(): void
+	{
+		$this->expectExceptionMessage('Encrypted string cannot be empty');
+		AsymmetricAnonymousEncryption::decryptKey('', CreateKey::generateRandomKey());
+	}
+
+	// MARK: encrypt/decrypt
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function providerEncryptDecryptSuccess(): array
+	{
+		return [
+			'valid string' => [
+				'input' => 'I am a secret',
+				'expected' => 'I am a secret',
+			],
+		];
+	}
+
+	/**
+	 * test encrypt/decrypt produce correct output
+	 *
+	 * @covers ::generateRandomKey
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerEncryptDecryptSuccess
+	 * @testdox encrypt/decrypt $input must be $expected [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $expected
+	 * @return void
+	 */
+	public function testEncryptDecryptSuccess(string $input, string $expected): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		// test class
+		$crypt = new AsymmetricAnonymousEncryption($key_pair);
+		$encrypted = $crypt->encrypt($input);
+		$decrypted = $crypt->decrypt($encrypted);
+		$this->assertEquals(
+			$expected,
+			$decrypted,
+			'Class call',
+		);
+		$crypt = new AsymmetricAnonymousEncryption($key_pair, $public_key);
+		$encrypted = $crypt->encrypt($input);
+		$decrypted = $crypt->decrypt($encrypted);
+		$this->assertEquals(
+			$expected,
+			$decrypted,
+			'Class call botjh set',
+		);
+	}
+
+	/**
+	 * test encrypt/decrypt produce correct output
+	 *
+	 * @covers ::generateRandomKey
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerEncryptDecryptSuccess
+	 * @testdox encrypt/decrypt indirect $input must be $expected [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $expected
+	 * @return void
+	 */
+	public function testEncryptDecryptSuccessIndirect(string $input, string $expected): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		// test indirect
+		$encrypted = AsymmetricAnonymousEncryption::getInstance(public_key:$public_key)->encrypt($input);
+		$decrypted = AsymmetricAnonymousEncryption::getInstance($key_pair)->decrypt($encrypted);
+		$this->assertEquals(
+			$expected,
+			$decrypted,
+			'Class Instance call',
+		);
+	}
+
+	/**
+	 * test encrypt/decrypt produce correct output
+	 *
+	 * @covers ::generateRandomKey
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerEncryptDecryptSuccess
+	 * @testdox encrypt/decrypt indirect with public key $input must be $expected [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $expected
+	 * @return void
+	 */
+	public function testEncryptDecryptSuccessIndirectPublicKey(string $input, string $expected): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		// test indirect
+		$encrypted = AsymmetricAnonymousEncryption::getInstance(public_key:$public_key)->encrypt($input);
+		$decrypted = AsymmetricAnonymousEncryption::getInstance($key_pair)->decrypt($encrypted);
+		$this->assertEquals(
+			$expected,
+			$decrypted,
+			'Class Instance call public key',
+		);
+	}
+
+	/**
+	 * test encrypt/decrypt produce correct output
+	 *
+	 * @covers ::generateRandomKey
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerEncryptDecryptSuccess
+	 * @testdox encrypt/decrypt static $input must be $expected [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $expected
+	 * @return void
+	 */
+	public function testEncryptDecryptSuccessStatic(string $input, string $expected): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		// test static
+		$encrypted = AsymmetricAnonymousEncryption::encryptKey($input, $public_key);
+		$decrypted = AsymmetricAnonymousEncryption::decryptKey($encrypted, $key_pair);
+
+		$this->assertEquals(
+			$expected,
+			$decrypted,
+			'Static call',
+		);
+	}
+
+	// MARK: invalid decrypt key
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function providerEncryptFailed(): array
+	{
+		return [
+			'wrong decryption key' => [
+				'input' => 'I am a secret',
+				'excpetion_message' => 'Invalid key pair'
+			],
+		];
+	}
+
+	/**
+	 * Test decryption with wrong key
+	 *
+	 * @covers ::generateRandomKey
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerEncryptFailed
+	 * @testdox decrypt with wrong key $input throws $exception_message [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testEncryptFailed(string $input, string $exception_message): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$wrong_key_pair = CreateKey::createKeyPair();
+
+		// wrong key in class call
+		$crypt = new AsymmetricAnonymousEncryption(public_key:$public_key);
+		$encrypted = $crypt->encrypt($input);
+		$this->expectExceptionMessage($exception_message);
+		$crypt->setKeyPair($wrong_key_pair);
+		$crypt->decrypt($encrypted);
+	}
+
+	/**
+	 * Test decryption with wrong key
+	 *
+	 * @covers ::generateRandomKey
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerEncryptFailed
+	 * @testdox decrypt indirect with wrong key $input throws $exception_message [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testEncryptFailedIndirect(string $input, string $exception_message): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$wrong_key_pair = CreateKey::createKeyPair();
+
+		// class instance
+		$encrypted = AsymmetricAnonymousEncryption::getInstance(public_key:$public_key)->encrypt($input);
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::getInstance($wrong_key_pair)->decrypt($encrypted);
+	}
+
+	/**
+	 * Test decryption with wrong key
+	 *
+	 * @covers ::generateRandomKey
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerEncryptFailed
+	 * @testdox decrypt static with wrong key $input throws $exception_message [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testEncryptFailedStatic(string $input, string $exception_message): void
+	{
+		$key_pair = CreateKey::createKeyPair();
+		$public_key = CreateKey::getPublicKey($key_pair);
+		$wrong_key_pair = CreateKey::createKeyPair();
+
+		// class static
+		$encrypted = AsymmetricAnonymousEncryption::encryptKey($input, $public_key);
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::decryptKey($encrypted, $wrong_key_pair);
+	}
+
+	// MARK: invalid key pair
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function providerWrongKeyPair(): array
+	{
+		return [
+			'not hex key pair' => [
+				'key_pair' => 'not_a_hex_key_pair',
+				'exception_message' => 'Invalid hex key pair'
+			],
+			'too short hex key pair' => [
+				'key_pair' => '1cabd5cba9e042f12522f4ff2de5c31d233b',
+				'excpetion_message' => 'Key pair is not the correct size (must be '
+			],
+			'empty key pair' => [
+				'key_pair' => '',
+				'excpetion_message' => 'Key pair cannot be empty'
+			]
+		];
+	}
+
+	/**
+	 * test invalid key provided to decrypt or encrypt
+	 *
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerWrongKeyPair
+	 * @testdox wrong key pair $key_pair throws $exception_message [$_dataName]
+	 *
+	 * @param  string $key_pair
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testWrongKeyPair(string $key_pair, string $exception_message): void
+	{
+		$enc_key_pair = CreateKey::createKeyPair();
+
+		// class
+		$this->expectExceptionMessage($exception_message);
+		$crypt = new AsymmetricAnonymousEncryption($key_pair);
+		$this->expectExceptionMessage($exception_message);
+		$crypt->encrypt('test');
+		$crypt->setKeyPair($enc_key_pair);
+		$encrypted = $crypt->encrypt('test');
+		$this->expectExceptionMessage($exception_message);
+		$crypt->setKeyPair($key_pair);
+		$crypt->decrypt($encrypted);
+	}
+
+	/**
+	 * test invalid key provided to decrypt or encrypt
+	 *
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerWrongKeyPair
+	 * @testdox wrong key pair indirect $key_pair throws $exception_message [$_dataName]
+	 *
+	 * @param  string $key_pair
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testWrongKeyPairIndirect(string $key_pair, string $exception_message): void
+	{
+		$enc_key_pair = CreateKey::createKeyPair();
+
+		// set valid encryption
+		$encrypted = AsymmetricAnonymousEncryption::getInstance($enc_key_pair)->encrypt('test');
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::getInstance($key_pair)->decrypt($encrypted);
+	}
+
+	/**
+	 * test invalid key provided to decrypt or encrypt
+	 *
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerWrongKeyPair
+	 * @testdox wrong key pair static $key_pair throws $exception_message [$_dataName]
+	 *
+	 * @param  string $key_pair
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testWrongKeyPairStatic(string $key_pair, string $exception_message): void
+	{
+		$enc_key_pair = CreateKey::createKeyPair();
+
+		// set valid encryption
+		$encrypted = AsymmetricAnonymousEncryption::encryptKey('test', CreateKey::getPublicKey($enc_key_pair));
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::decryptKey($encrypted, $key_pair);
+	}
+
+	// MARK: invalid public key
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function providerWrongPublicKey(): array
+	{
+		return [
+			'not hex public key' => [
+				'public_key' => 'not_a_hex_public_key',
+				'exception_message' => 'Invalid hex public key'
+			],
+			'too short hex public key' => [
+				'public_key' => '1cabd5cba9e042f12522f4ff2de5c31d233b',
+				'excpetion_message' => 'Public key is not the correct size (must be '
+			],
+			'empty public key' => [
+				'public_key' => '',
+				'excpetion_message' => 'Public key cannot be empty'
+			]
+		];
+	}
+
+	/**
+	 * test invalid key provided to decrypt or encrypt
+	 *
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerWrongPublicKey
+	 * @testdox wrong public key $public_key throws $exception_message [$_dataName]
+	 *
+	 * @param  string $public_key
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testWrongPublicKey(string $public_key, string $exception_message): void
+	{
+		$enc_key_pair = CreateKey::createKeyPair();
+		// $enc_public_key = CreateKey::getPublicKey($enc_key_pair);
+
+		// class
+		$this->expectExceptionMessage($exception_message);
+		$crypt = new AsymmetricAnonymousEncryption(public_key:$public_key);
+		$this->expectExceptionMessage($exception_message);
+		$crypt->decrypt('test');
+		$crypt->setKeyPair($enc_key_pair);
+		$encrypted = $crypt->encrypt('test');
+		$this->expectExceptionMessage($exception_message);
+		$crypt->setPublicKey($public_key);
+		$crypt->decrypt($encrypted);
+	}
+
+	/**
+	 * test invalid key provided to decrypt or encrypt
+	 *
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerWrongPublicKey
+	 * @testdox wrong public key indirect $key throws $exception_message [$_dataName]
+	 *
+	 * @param  string $key
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testWrongPublicKeyIndirect(string $key, string $exception_message): void
+	{
+		$enc_key = CreateKey::createKeyPair();
+
+		// class instance
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::getInstance(public_key:$key)->encrypt('test');
+		// we must encrypt valid thing first so we can fail with the wrong key
+		$encrypted = AsymmetricAnonymousEncryption::getInstance($enc_key)->encrypt('test');
+		// $this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::getInstance($key)->decrypt($encrypted);
+	}
+
+	/**
+	 * test invalid key provided to decrypt or encrypt
+	 *
+	 * @covers ::encrypt
+	 * @covers ::decrypt
+	 * @dataProvider providerWrongPublicKey
+	 * @testdox wrong public key static $key throws $exception_message [$_dataName]
+	 *
+	 * @param  string $key
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testWrongPublicKeyStatic(string $key, string $exception_message): void
+	{
+		$enc_key = CreateKey::createKeyPair();
+
+		// class static
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::encryptKey('test', $key);
+		// we must encrypt valid thing first so we can fail with the wrong key
+		$encrypted = AsymmetricAnonymousEncryption::encryptKey('test', $enc_key);
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::decryptKey($encrypted, $key);
+	}
+
+	// MARK: wrong cipher text
+
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
+	public function providerWrongCiphertext(): array
+	{
+		return [
+			'invalid cipher text' => [
+				'input' => 'short',
+				'exception_message' => 'base642bin failed: '
+			],
+			'cannot decrypt' => [
+				// phpcs:disable Generic.Files.LineLength
+				'input' => 'Um8tBGiVfFAOg2YoUgA5fTqK1wXPB1S7uxhPNE1lqDxgntkEhYJDOmjXa0DMpBlYHjab6sC4mgzwZSzGCUnXDAgsHckwYwfAzs/r',
+				// phpcs:enable Generic.Files.LineLength
+				'exception_message' => 'Invalid key pair'
+			],
+			'invalid text' => [
+				'input' => 'U29tZSB0ZXh0IGhlcmU=',
+				'exception_message' => 'Invalid key pair'
+			]
+		];
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::decrypt
+	 * @dataProvider providerWrongCiphertext
+	 * @testdox too short ciphertext $input throws $exception_message [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testWrongCiphertext(string $input, string $exception_message): void
+	{
+		$key = CreateKey::createKeyPair();
+		// class
+		$crypt = new AsymmetricAnonymousEncryption($key);
+		$this->expectExceptionMessage($exception_message);
+		$crypt->decrypt($input);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::decryptKey
+	 * @dataProvider providerWrongCiphertext
+	 * @testdox too short ciphertext indirect $input throws $exception_message [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testWrongCiphertextIndirect(string $input, string $exception_message): void
+	{
+		$key = CreateKey::createKeyPair();
+
+		// class instance
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::getInstance($key)->decrypt($input);
+
+		// class static
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::decryptKey($input, $key);
+	}
+
+		/**
+	 * Undocumented function
+	 *
+	 * @covers ::decryptKey
+	 * @dataProvider providerWrongCiphertext
+	 * @testdox too short ciphertext static $input throws $exception_message [$_dataName]
+	 *
+	 * @param  string $input
+	 * @param  string $exception_message
+	 * @return void
+	 */
+	public function testWrongCiphertextStatic(string $input, string $exception_message): void
+	{
+		$key = CreateKey::createKeyPair();
+		// class static
+		$this->expectExceptionMessage($exception_message);
+		AsymmetricAnonymousEncryption::decryptKey($input, $key);
+	}
+}
+
+// __END__

4dev/tests/Security/CoreLibsSecurityPasswordTest.php

@@ -13,6 +13,11 @@ use PHPUnit\Framework\TestCase;
  */
 final class CoreLibsSecurityPasswordTest extends TestCase
 {
+	/**
+	 * Undocumented function
+	 *
+	 * @return array
+	 */
 	public function passwordProvider(): array
 	{
 		return [
@@ -21,6 +26,11 @@ final class CoreLibsSecurityPasswordTest extends TestCase
 		];
 	}
 
+	/**
+	 * Note: we need different hash types for PHP versions
+	 *
+	 * @return array
+	 */
 	public function passwordRehashProvider(): array
 	{
 		return [
@@ -63,6 +73,10 @@ final class CoreLibsSecurityPasswordTest extends TestCase
 	 */
 	public function testPasswordRehashCheck(string $input, bool $expected): void
 	{
+		// in PHP 8.4 the length is $12
+		if (PHP_VERSION_ID > 80400) {
+			$input = str_replace('$2y$10$', '$2y$12$', $input);
+		}
 		$this->assertEquals(
 			$expected,
 			\CoreLibs\Security\Password::passwordRehashCheck($input)

4dev/tests/Security/CoreLibsSecuritySymmetricEncryptionTest.php

@@ -15,6 +15,77 @@ use CoreLibs\Security\SymmetricEncryption;
  */
 final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 {
+	// MARK: key set compare
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::compareKey
+	 * @covers ::getKey
+	 * @testdox Check if init class set key matches to created key
+	 *
+	 * @return void
+	 */
+	public function testKeyInitGetCompare(): void
+	{
+		$key = CreateKey::generateRandomKey();
+		$crypt = new SymmetricEncryption($key);
+		$this->assertTrue(
+			$crypt->compareKey($key),
+			'set key not equal to original key'
+		);
+		$this->assertEquals(
+			$key,
+			$crypt->getKey(),
+			'set key returned not equal to original key'
+		);
+	}
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::setKey
+	 * @covers ::compareKey
+	 * @covers ::getKey
+	 * @testdox Check if set key after class init matches to created key
+	 *
+	 * @return void
+	 */
+	public function testKeySetGetCompare(): void
+	{
+		$key = CreateKey::generateRandomKey();
+		$crypt = new SymmetricEncryption();
+		$crypt->setKey($key);
+		$this->assertTrue(
+			$crypt->compareKey($key),
+			'set key not equal to original key'
+		);
+		$this->assertEquals(
+			$key,
+			$crypt->getKey(),
+			'set key returned not equal to original key'
+		);
+	}
+
+	// MARK: empty encrypted string
+
+	/**
+	 * Undocumented function
+	 *
+	 * @covers ::decryptKey
+	 * @covers ::decrypt
+	 * @testdox Test empty encrypted string to decrypt
+	 *
+	 * @return void
+	 */
+	public function testEmptyDecryptionString(): void
+	{
+		$this->expectExceptionMessage('Encrypted string cannot be empty');
+		SymmetricEncryption::decryptKey('', CreateKey::generateRandomKey());
+	}
+
+	// MARK: encrypt/decrypt compare
+
 	/**
 	 * Undocumented function
 	 *
@@ -88,8 +159,8 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 	 * test encrypt/decrypt produce correct output
 	 *
 	 * @covers ::generateRandomKey
-	 * @covers ::encrypt
-	 * @covers ::decrypt
+	 * @covers ::encryptKey
+	 * @covers ::decryptKey
 	 * @dataProvider providerEncryptDecryptSuccess
 	 * @testdox encrypt/decrypt static $input must be $expected [$_dataName]
 	 *
@@ -111,6 +182,8 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 		);
 	}
 
+	// MARK: invalid key
+
 	/**
 	 * Undocumented function
 	 *
@@ -180,8 +253,8 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 	 * Test decryption with wrong key
 	 *
 	 * @covers ::generateRandomKey
-	 * @covers ::encrypt
-	 * @covers ::decrypt
+	 * @covers ::encryptKey
+	 * @covers ::decryptKey
 	 * @dataProvider providerEncryptFailed
 	 * @testdox decrypt static with wrong key $input throws $exception_message [$_dataName]
 	 *
@@ -200,6 +273,8 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 		SymmetricEncryption::decryptKey($encrypted, $wrong_key);
 	}
 
+	// MARK: wrong key
+
 	/**
 	 * Undocumented function
 	 *
@@ -216,6 +291,10 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 				'key' => '1cabd5cba9e042f12522f4ff2de5c31d233b',
 				'excpetion_message' => 'Key is not the correct size (must be '
 			],
+			'empty key' => [
+				'key' => '',
+				'excpetion_message' => 'Key cannot be empty'
+			]
 		];
 	}
 
@@ -236,6 +315,7 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 		$enc_key = CreateKey::generateRandomKey();
 
 		// class
+		$this->expectExceptionMessage($exception_message);
 		$crypt = new SymmetricEncryption($key);
 		$this->expectExceptionMessage($exception_message);
 		$crypt->encrypt('test');
@@ -244,22 +324,6 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 		$this->expectExceptionMessage($exception_message);
 		$crypt->setKey($key);
 		$crypt->decrypt($encrypted);
-
-		// class instance
-		$this->expectExceptionMessage($exception_message);
-		SymmetricEncryption::getInstance($key)->encrypt('test');
-		// we must encrypt valid thing first so we can fail with the wrong key
-		$encrypted = SymmetricEncryption::getInstance($enc_key)->encrypt('test');
-		$this->expectExceptionMessage($exception_message);
-		SymmetricEncryption::getInstance($key)->decrypt($encrypted);
-
-		// class static
-		$this->expectExceptionMessage($exception_message);
-		SymmetricEncryption::encryptKey('test', $key);
-		// we must encrypt valid thing first so we can fail with the wrong key
-		$encrypted = SymmetricEncryption::encryptKey('test', $enc_key);
-		$this->expectExceptionMessage($exception_message);
-		SymmetricEncryption::decryptKey($encrypted, $key);
 	}
 
 	/**
@@ -290,8 +354,8 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 		/**
 	 * test invalid key provided to decrypt or encrypt
 	 *
-	 * @covers ::encrypt
-	 * @covers ::decrypt
+	 * @covers ::encryptKey
+	 * @covers ::decryptKey
 	 * @dataProvider providerWrongKey
 	 * @testdox wrong key static $key throws $exception_message [$_dataName]
 	 *
@@ -312,6 +376,8 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 		SymmetricEncryption::decryptKey($encrypted, $key);
 	}
 
+	// MARK: wrong input
+
 	/**
 	 * Undocumented function
 	 *
@@ -358,7 +424,7 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 	/**
 	 * Undocumented function
 	 *
-	 * @covers ::decrypt
+	 * @covers ::decryptKey
 	 * @dataProvider providerWrongCiphertext
 	 * @testdox too short ciphertext indirect $input throws $exception_message [$_dataName]
 	 *
@@ -382,7 +448,7 @@ final class CoreLibsSecuritySymmetricEncryptionTest extends TestCase
 		/**
 	 * Undocumented function
 	 *
-	 * @covers ::decrypt
+	 * @covers ::decryptKey
 	 * @dataProvider providerWrongCiphertext
 	 * @testdox too short ciphertext static $input throws $exception_message [$_dataName]
 	 *

4dev/tests/UrlRequests/CoreLibsUrlRequestsCurlTest.php

@@ -59,8 +59,6 @@ final class CoreLibsUrlRequestsCurlTest extends TestCase
 				continue;
 			}
 			$this->url_basic = $url;
-			// split out the last / part for url set test
-			curl_close($handle);
 			// print "Open: $url\n";
 			break;
 		}
@@ -969,13 +967,23 @@ final class CoreLibsUrlRequestsCurlTest extends TestCase
 			"query" => ["foo-get" => "bar"]
 		]);
 		$this->assertEquals("200", $response["code"], "multi call: get response code not matching");
+		$request_expected = json_decode(
+			<<<JSON
+			{
+				"HEADERS":{
+					"HTTP_USER_AGENT":"CoreLibsUrlRequestCurl\/1",
+					"HTTP_FIRST_CALL":"get","HTTP_ACCEPT":"*\/*",
+					"HTTP_HOST":"soba.egplusww.jp"
+				},
+				"REQUEST_TYPE":"GET",
+				"PARAMS":{"foo-get":"bar"},"BODY":null
+			}
+			JSON,
+			true
+		);
 		$this->assertEquals(
-			'{"HEADERS":{"HTTP_USER_AGENT":"CoreLibsUrlRequestCurl\/1",'
-			. '"HTTP_FIRST_CALL":"get","HTTP_ACCEPT":"*\/*",'
-			. '"HTTP_HOST":"soba.egplusww.jp"},'
-			. '"REQUEST_TYPE":"GET",'
-			. '"PARAMS":{"foo-get":"bar"},"BODY":null}',
-			$response['content'],
+			$request_expected,
+			json_decode($response['content'], true),
 			'multi call: get content not matching'
 		);
 		// post
@@ -984,13 +992,25 @@ final class CoreLibsUrlRequestsCurlTest extends TestCase
 			"body" => ["foo-post" => "baz"]
 		]);
 		$this->assertEquals("200", $response["code"], "multi call: post response code not matching");
+		$request_expected = json_decode(
+			<<<JSON
+			{
+				"HEADERS":{
+					"HTTP_HOST":"soba.egplusww.jp",
+					"HTTP_USER_AGENT":"CoreLibsUrlRequestCurl\/1",
+					"HTTP_SECOND_CALL":"post",
+					"HTTP_ACCEPT":"*\/*"
+				},
+				"REQUEST_TYPE":"POST",
+				"PARAMS":[],
+				"BODY":{"foo-post":"baz"}
+			}
+			JSON,
+			true
+		);
 		$this->assertEquals(
-			'{"HEADERS":{"HTTP_USER_AGENT":"CoreLibsUrlRequestCurl\/1",'
-			. '"HTTP_SECOND_CALL":"post","HTTP_ACCEPT":"*\/*",'
-			. '"HTTP_HOST":"soba.egplusww.jp"},'
-			. '"REQUEST_TYPE":"POST",'
-			. '"PARAMS":[],"BODY":{"foo-post":"baz"}}',
-			$response['content'],
+			$request_expected,
+			json_decode($response['content'], true),
 			'multi call: post content not matching'
 		);
 		// delete
@@ -998,13 +1018,24 @@ final class CoreLibsUrlRequestsCurlTest extends TestCase
 			"headers" => ["third-call" => "delete"],
 		]);
 		$this->assertEquals("200", $response["code"], "multi call: delete response code not matching");
+		$request_expected = json_decode(
+			<<<JSON
+			{
+				"HEADERS":{
+					"HTTP_HOST":"soba.egplusww.jp",
+					"HTTP_USER_AGENT":"CoreLibsUrlRequestCurl\/1",
+					"HTTP_THIRD_CALL":"delete","HTTP_ACCEPT":"*\/*"
+				},
+				"REQUEST_TYPE":"DELETE",
+				"PARAMS":[],
+				"BODY":[]
+			}
+			JSON,
+			true
+		);
 		$this->assertEquals(
-			'{"HEADERS":{"HTTP_USER_AGENT":"CoreLibsUrlRequestCurl\/1",'
-			. '"HTTP_THIRD_CALL":"delete","HTTP_ACCEPT":"*\/*",'
-			. '"HTTP_HOST":"soba.egplusww.jp"},'
-			. '"REQUEST_TYPE":"DELETE",'
-			. '"PARAMS":[],"BODY":[]}',
-			$response['content'],
+			$request_expected,
+			json_decode($response['content'], true),
 			'multi call: delete content not matching'
 		);
 	}

4dev/update/20241203_update_edit_tables/edit_tables_cuid_cuuid_update_add.sql

@@ -1,7 +1,7 @@
 -- 20241203: update edit tables
 ALTER TABLE edit_generic ADD cuuid UUID DEFAULT gen_random_uuid();
-ALTER TABLE edit_log ADD ecuid VARCHAR;
-ALTER TABLE edit_log ADD ecuuid VARCHAR;
+ALTER TABLE edit_log ADD eucuid VARCHAR;
+ALTER TABLE edit_log ADD eucuuid VARCHAR;
 ALTER TABLE edit_log ADD action_sub_id VARCHAR;
 ALTER TABLE edit_log ADD http_data JSONB;
 ALTER TABLE edit_log ADD ip_address JSONB;
@@ -32,3 +32,5 @@ BEGIN
 END;
 $$
 LANGUAGE 'plpgsql';
+
+-- END --

README.md

@@ -114,3 +114,13 @@ Add `.libs` to the master .gitingore
 ### Update phpunit
 
 On a version update the old phpunit folder in .libs has to be removed and the new version extracted again
+
+## Javascript
+
+The original edit.js javascript functions are now in utils.js or utils.min.js.
+
+The development for those files is located in a different repository
+
+General: <https://[service]/CodeBlocks/JavaScript.utils>
+
+Org: <https://[serverice]/[org]/Code-Blocks.JavaScript.utils>

SECURITY.md

@@ -0,0 +1,11 @@
+# Security Policy
+
+This software follows the [Semver 2.0 scheme](https://semver.org/).
+
+## Supported Versions
+
+Only the latest version is supported
+
+## Reporting a Vulnerability
+
+Open a ticket to report a secuirty problem

eslint.config.mjs

@@ -0,0 +1,59 @@
+import globals from 'globals';
+import pluginJs from '@eslint/js';
+
+/*
+module.exports = {
+	// in globals block
+	'extends': 'eslint:recommended',
+	'parserOptions': {
+		'ecmaVersion': 6
+	},
+	// rules copied
+};
+*/
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+	{languageOptions: {
+		globals: {
+			...globals.browser,
+			...globals.jquery
+		}
+	}},
+	pluginJs.configs.recommended,
+	{
+		'rules': {
+			'indent': [
+				'error',
+				'tab',
+				{
+					'SwitchCase': 1
+				}
+			],
+			'linebreak-style': [
+				'error',
+				'unix'
+			],
+			// 'quotes': [
+			// 	'error',
+			// 	'single'
+			// ],
+			'semi': [
+				'error',
+				'always'
+			],
+			'no-console': 'off',
+			'no-unused-vars': [
+				'error', {
+					'vars': 'all',
+					'args': 'after-used',
+					'ignoreRestSiblings': false
+				}
+			],
+			// Requires eslint >= v8.14.0
+			'no-constant-binary-expression': 'error'
+		}
+	}
+];
+
+// __END__

jsconfig.json

@@ -1,9 +1,11 @@
+// https://www.typescriptlang.org/tsconfig/#compilerOptions
 {
 	"compilerOptions": {
 		"module": "ESNext",
 		"moduleResolution": "Node",
 		"target": "ES2020",
 		"jsx": "react",
+		"checkJs": true,
 		"allowImportingTsExtensions": true,
 		"strictNullChecks": true,
 		"strictFunctionTypes": true

package.json

@@ -0,0 +1,17 @@
+{
+	"name": "core-libraries",
+	"version": "9.26.8",
+	"main": "",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1"
+	},
+	"author": "Clemens Schwaighofer",
+	"license": "",
+	"description": "Core Libraries",
+	"devDependencies": {
+		"@eslint/js": "^9.20.0",
+		"esbuild": "^0.25.0",
+		"eslint": "^9.20.1",
+		"globals": "^15.15.0"
+	}
+}

phpstan-bootstrap.php

@@ -10,5 +10,6 @@ $_SERVER['HTTP_HOST'] = 'soba.tokyo.tequila.jp';
 define('BASE_NAME', '');
 define('SITE_DOMAIN', '');
 define('HOST_NAME', 'soba.tokyo.tequila.jp');
+define('DEFAULT_ENCODING', 'en_US.UTF-8');
 
 // __END__

phpstan.neon

@@ -9,7 +9,7 @@ parameters:
 	#friendly:
 	#	lineBefore: 3
 	#	lineAfter: 3
-	level: 8 # max is now 9
+	level: 8 # max is now 10
 	# strictRules:
 	# 	allRules: false
 	checkMissingCallableSignature: true

phpunit.xml

@@ -1,7 +1,7 @@
 <phpunit
 	cacheResultFile="/tmp/phpunit-corelibs.result.cache"
 	colors="true"
-	verbose="true"
+	verbose="false"
 	convertDeprecationsToExceptions="true"
 	bootstrap="4dev/tests/bootstrap.php"
 >

www/admin/UrlRequests.target.php

@@ -52,7 +52,7 @@ header("Content-Type: application/json; charset=UTF-8");
 if (!empty($http_headers['HTTP_AUTHORIZATION']) && !empty($http_headers['HTTP_RUNAUTHTEST'])) {
 	header("HTTP/1.1 401 Unauthorized");
 	print buildContent($http_headers, '{"code": 401, "content": {"Error": "Not Authorized"}}');
-	exit;
+	exit(1);
 }
 
 // if server request type is get set file_get to null -> no body
@@ -61,7 +61,7 @@ if ($_SERVER['REQUEST_METHOD'] == "GET") {
 } elseif (($file_get = file_get_contents('php://input')) === false) {
 	header("HTTP/1.1 404 Not Found");
 	print buildContent($http_headers, '{"code": 404, "content": {"Error": "file_get_contents failed"}}');
-	exit;
+	exit(1);
 }
 // str_replace('\"', '"', trim($file_get, '"'));
 

www/admin/class_test.admin.backend.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.array.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -51,6 +51,9 @@ $test_array = [
 		'element_c' => [
 			'type' => 'email'
 		],
+		'element_d' => [
+			'type' => 'butter'
+		],
 	],
 ];
 
@@ -60,6 +63,8 @@ echo "ARRAYSEARCHRECURSIVE(email, [array], type): "
 	. DgS::printAr(ArrayHandler::arraySearchRecursive('email', $test_array, 'type')) . "<br>";
 echo "ARRAYSEARCHRECURSIVE(email, [array]['input'], type): "
 	. DgS::printAr(ArrayHandler::arraySearchRecursive('email', $test_array['input'], 'type')) . "<br>";
+echo "ARRAYSEARCHRECURSIVE(email, [array]['input'], wrong): "
+	. DgS::printAr(ArrayHandler::arraySearchRecursive('email', $test_array['input'], 'wrong')) . "<br>";
 // all return
 echo "ARRAYSEARCHRECURSIVEALL(email, [array], type): "
 	. Dgs::printAr((array)ArrayHandler::arraySearchRecursiveAll('email', $test_array, 'type')) . "<br>";
@@ -68,7 +73,15 @@ echo "ARRAYSEARCHRECURSIVEALL(email, [array], type): "
 
 // simple search
 echo "ARRAYSEARCHSIMPLE([array], type, email): "
-	. (string)ArrayHandler::arraySearchSimple($test_array, 'type', 'email') . "<br>";
+	. Dgs::prBl(ArrayHandler::arraySearchSimple($test_array, 'type', 'email')) . "<br>";
+echo "ARRAYSEARCHSIMPLE([array], type, not): "
+	. Dgs::prBl(ArrayHandler::arraySearchSimple($test_array, 'type', 'not')) . "<br>";
+echo "ARRAYSEARCHSIMPLE([array], type, [email,butter]): "
+	. Dgs::prBl(ArrayHandler::arraySearchSimple($test_array, 'type', ['email', 'butter'])) . "<br>";
+echo "ARRAYSEARCHSIMPLE([array], type, [email,not]): "
+	. Dgs::prBl(ArrayHandler::arraySearchSimple($test_array, 'type', ['email', 'not'])) . "<br>";
+echo "ARRAYSEARCHSIMPLE([array], type, [never,not]): "
+	. Dgs::prBl(ArrayHandler::arraySearchSimple($test_array, 'type', ['never', 'not'])) . "<br>";
 
 $array_1 = [
 	'foo' => 'bar'
@@ -168,6 +181,31 @@ $data = [
 $search = ['image', 'result_image', 'nothing', 'EMPTY'];
 $result = ArrayHandler::arraySearchKey($data, $search);
 print "ARRAYSEARCHKEY: Search: " . DgS::printAr($search) . ", Found: " . DgS::printAr($result) . "<br>";
+$result = ArrayHandler::arraySearchKey($data, $search, true);
+print "ARRAYSEARCHKEY: FLAT: Search: " . DgS::printAr($search) . ", Found: " . DgS::printAr($result) . "<br>";
+$result = ArrayHandler::arraySearchKey($data, $search, true, true);
+print "ARRAYSEARCHKEY: FLAT:PREFIX: Search: " . DgS::printAr($search) . ", Found: " . DgS::printAr($result) . "<br>";
+$result = ArrayHandler::arraySearchKey($data, ["EMPTY"], true);
+print "ARRAYSEARCHKEY: FLAT:PREFIX: Search: " . DgS::printAr(["EMPTY"]) . ", Found: " . DgS::printAr($result) . "<br>";
+
+// $data = [
+// 	[
+// 		[name] => qrc_apcd,
+// 		[value] => 5834367225,
+// 	],
+// 	[
+// 		[name] => qrc_other,
+// 		[value] => test,
+// 	],
+// 	[
+// 		[name] => qrc_car_type,
+// 		[value] => T33P17,
+// 	],
+// 	[
+// 		[name] => qrc_deaer_store,
+// 		[value] => 9990:001,
+// 	]
+// ]
 
 // $test = [
 // 	'A' => [
@@ -263,6 +301,233 @@ $out = array_intersect_key(
 );
 print "array intersect key: " . DgS::printAr($keys) . ": " . DgS::printAr($out) . "<br>";
 
+print "array + suffix: " . DgS::printAr(ArrayHandler::arrayModifyKey($array, key_mod_suffix:'_attached')) . "<br>";
+
+print "<hr>";
+$unsorted = [9, 5, 'A', 4, 'B', 6, 'c', 'C', 'a'];
+$unsorted_keys = [
+	'A' => 9, 'B' => 5, 'C' => 'A', 'D' => 4, 'E' => 'B', 'F' => 6, 'G' => 'c',
+	'H1' => 'D', 'B1' => 'd', 'H' => 'C', 'I' => 'a'
+];
+print "Unsorted: " . DgS::printAr($unsorted) . "<br>";
+print "(sort): " . DgS::printAr(ArrayHandler::sortArray($unsorted)) . "<br>";
+print "(sort, lower): " . DgS::printAr(ArrayHandler::sortArray($unsorted, case_insensitive:true)) . "<br>";
+print "(sort, reverse): " . DgS::printAr(ArrayHandler::sortArray($unsorted, reverse:true)) . "<br>";
+print "(sort, lower, reverse): "
+	. DgS::printAr(ArrayHandler::sortArray($unsorted, case_insensitive:true, reverse:true)) . "<br>";
+print "(sort, keys): " . DgS::printAr(ArrayHandler::sortArray($unsorted_keys, maintain_keys:true)) . "<br>";
+print "(sort, keys, lower): "
+	. DgS::printAr(ArrayHandler::sortArray($unsorted_keys, maintain_keys:true, case_insensitive:true)) . "<br>";
+
+print "<hr>";
+$unsorted = [9 => 'A', 5 => 'B', 'A' => 'C', 4 => 'D', 'B' => 'E', 6 => 'F', 'c' => 'G', 'C' => 'H', 'a' => 'I'];
+print "Unsorted Keys: " . DgS::printAr($unsorted) . "<br>";
+print "(sort): " . DgS::printAr(ArrayHandler::sortArray($unsorted)) . "<br>";
+print "(sort, keys): " . DgS::printAr(ArrayHandler::sortArray($unsorted, maintain_keys:true)) . "<br>";
+print "(kosrt): " . DgS::printAr(ArrayHandler::ksortArray($unsorted)) . "<br>";
+print "(kosrt, reverse): " . DgS::printAr(ArrayHandler::ksortArray($unsorted, reverse:true)) . "<br>";
+print "(kosrt, lower case, reverse): "
+	. DgS::printAr(ArrayHandler::ksortArray($unsorted, case_insensitive:true, reverse:true)) . "<br>";
+
+
+print "<hr>";
+$nested = [
+	'B' => 'foo', 'a', '0', 9, /** @phpstan-ignore-line This is a test for wrong index */
+	'1' => ['z', 'b', 'a'],
+	'd' => ['zaip', 'bar', 'baz']
+];
+print "Nested: " . DgS::printAr($nested) . "<br>";
+print "(sort): " . DgS::printAr(ArrayHandler::sortArray($nested)) . "<br>";
+print "(ksort): " . DgS::printAr(ArrayHandler::ksortArray($nested)) . "<br>";
+
+print "<hr>";
+
+$search_array = [
+	'table_lookup' => [
+		'match' => [
+			['param' => 'access_d_cd', 'data' => 'a_cd', 'time_validation' => 'on_load',],
+			['param' => 'other_block', 'data' => 'b_cd'],
+			['pflaume' => 'other_block', 'data' => 'c_cd'],
+			['param' => 'third_block', 'data' => 'd_cd', 'time_validation' => 'cool'],
+			['special' => 'other_block', 'data' => 'e_cd', 'time_validation' => 'other'],
+		]
+	]
+];
+print "Search: " . DgS::printAr($search_array) . "<br>";
+print "Result (all): " . Dgs::printAr(ArrayHandler::findArraysMissingKey(
+	$search_array,
+	'other_block',
+	'time_validation'
+)) . "<br>";
+print "Result (key): " . Dgs::printAr(ArrayHandler::findArraysMissingKey(
+	$search_array,
+	'other_block',
+	'time_validation',
+	'pflaume'
+)) . "<br>";
+print "Result (key): " . Dgs::printAr(ArrayHandler::findArraysMissingKey(
+	$search_array,
+	'other_block',
+	['data', 'time_validation'],
+	'pflaume'
+)) . "<br>";
+
+print "<hr>";
+
+$search_array = [
+	'a' => [
+		'lookup' => 1,
+		'value' => 'Foo',
+		'other' => 'Bar',
+	],
+	'b' => [
+		'lookup' => 1,
+		'value' => 'AAA',
+		'other' => 'Other',
+	],
+	'c' => [
+		'lookup' => 0,
+		'value' => 'CCC',
+		'other' => 'OTHER',
+	],
+	'd' => [
+		'd-1' => [
+			'lookup' => 1,
+			'value' => 'D SUB 1',
+			'other' => 'Other B',
+		],
+		'd-2' => [
+			'lookup' => 0,
+			'value' => 'D SUB 2',
+			'other' => 'Other C',
+		],
+		'more' => [
+			'lookup' => 1,
+			'd-more-1' => [
+				'lookup' => 1,
+				'value' => 'D MORE SUB 1',
+				'other' => 'Other C',
+			],
+			'd-more-2' => [
+				'lookup' => 0,
+				'value' => 'D MORE SUB 0',
+				'other' => 'Other C',
+			],
+		]
+	]
+];
+
+print "Search: " . DgS::printAr($search_array) . "<br>";
+print "Result: " . DgS::printAr(ArrayHandler::selectArrayFromOption(
+	$search_array,
+	'lookup',
+	1,
+)) . "<br>";
+print "Result: " . DgS::printAr(ArrayHandler::selectArrayFromOption(
+	$search_array,
+	'lookup',
+	1,
+	recursive:true
+)) . "<br>";
+print "Result: " . DgS::printAr(ArrayHandler::selectArrayFromOption(
+	$search_array,
+	'lookup',
+	1,
+	recursive:true,
+	flat_separator:'-=-'
+)) . "<br>";
+print "Result: " . DgS::printAr(ArrayHandler::selectArrayFromOption(
+	$search_array,
+	'lookup',
+	1,
+	recursive:true,
+	flat_result:false
+)) . "<br>";
+print "Result: " . DgS::printAr(ArrayHandler::selectArrayFromOption(
+	$search_array,
+	'other',
+	'Other',
+	case_insensitive:false,
+)) . "<br>";
+
+$nestedTestData = [
+	'level1_a' => [
+		'name' => 'Level1A',
+		'type' => 'parent',
+		'children' => [
+			'child1' => [
+				'name' => 'Child1',
+				'type' => 'child',
+				'active' => true
+			],
+			'child2' => [
+				'name' => 'Child2',
+				'type' => 'child',
+				'active' => false
+			]
+		]
+	],
+	'level1_b' => [
+		'name' => 'Level1B',
+		'type' => 'parent',
+		'children' => [
+			'child3' => [
+				'name' => 'Child3',
+				'type' => 'child',
+				'active' => true,
+				'nested' => [
+					'deep1' => [
+						'name' => 'Deep1',
+						'type' => 'deep',
+						'active' => true
+					]
+				]
+			]
+		]
+	],
+	'item5' => [
+		'name' => 'Direct',
+		'type' => 'child',
+		'active' => false
+	]
+];
+
+$result = ArrayHandler::selectArrayFromOption(
+	$nestedTestData,
+	'type',
+	'child',
+	false,
+	false,
+	true,
+	true,
+	':*'
+);
+print "*1*Result: " . DgS::printAr($result) . "<br>";
+$data = [
+	'parent1' => [
+		'name' => 'Parent1',
+		'status' => 'ACTIVE',
+		'children' => [
+			'child1' => [
+				'name' => 'Child1',
+				'status' => 'active'
+			]
+		]
+	]
+];
+
+$result = ArrayHandler::selectArrayFromOption(
+	$data,
+	'status',
+	'active',
+	false,      // not strict
+	true,       // case insensitive
+	true,       // recursive
+	true,       // flat result
+	'|'         // custom separator
+);
+print "*2*Result: " . DgS::printAr($result) . "<br>";
+
 print "</body></html>";
 
 // __END__

www/admin/class_test.autoloader.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 // basic class test file

www/admin/class_test.byte.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -74,9 +74,21 @@ foreach ($bytes as $byte) {
 	print '<div style="width: 35%; text-align: right; padding-right: 2px;">';
 	print "(" . number_format($byte) . "/" . $byte . ") bytes :";
 	$_bytes = Byte::humanReadableByteFormat($byte);
-	print '</div><div style="width: 10%;">' . $_bytes;
-	print '</div><div style="width: 10%;">';
-	print Byte::stringByteFormat($_bytes);
+	print '</div>';
+	print '<div style="width: 10%;">' . $_bytes . '</div>';
+	print '<div style="width: 40%;">';
+	try {
+		print Byte::stringByteFormat($_bytes);
+	} catch (\LengthException $e) {
+		print "LengthException 1: " . $e->getMessage();
+		try {
+			print "<br>S: " . Byte::stringByteFormat($_bytes, Byte::RETURN_AS_STRING);
+		} catch (\LengthException $e) {
+			print "LengthException 2: " . $e->getMessage();
+		} catch (\RuntimeException $e) {
+			print "RuntimeException 1: " . $e->getMessage();
+		}
+	}
 	print "</div>";
 	//
 	print "</div>";
@@ -87,13 +99,85 @@ foreach ($bytes as $byte) {
 	print "bytes [si]:";
 	$_bytes = Byte::humanReadableByteFormat($byte, Byte::BYTE_FORMAT_SI);
 	print '</div><div style="width: 10%;">' . $_bytes;
-	print '</div><div style="width: 10%;">';
-	print Byte::stringByteFormat($_bytes);
+	print '</div><div style="width: 40%;">';
+	try {
+		print Byte::stringByteFormat($_bytes);
+	} catch (\LengthException $e) {
+		print "LengthException A: " . $e->getMessage();
+		try {
+			print "<br>Ssi: " . Byte::stringByteFormat($_bytes, Byte::RETURN_AS_STRING | Byte::BYTE_FORMAT_SI);
+		} catch (\LengthException $e) {
+			print "LengthException B: " . $e->getMessage();
+		} catch (\RuntimeException $e) {
+			print "RuntimeException A: " . $e->getMessage();
+		}
+	}
 	print "</div>";
 	//
 	print "</div>";
 }
 
+$string_bytes = [
+	'-117.42 MB',
+	'242.98 MB',
+	'254.78 MiB',
+	'1 EiB',
+	'8 EB',
+	'867.36EB',
+	'1000EB',
+	'10000EB',
+];
+print "<b>BYTE STRING TO BYTES TESTS</b><br>";
+foreach ($string_bytes as $string) {
+	print '<div style="display: flex; border-bottom: 1px dashed gray;">';
+	//
+	print '<div style="width: 35%; text-align: right; padding-right: 2px;">';
+	print "string byte ($string) to bytes :";
+	try {
+		$_bytes = Byte::stringByteFormat($string);
+	} catch (\LengthException $e) {
+		print "<br>LengthException A: " . $e->getMessage();
+		$_bytes = 0;
+	}
+	try {
+		$_bytes_string = Byte::stringByteFormat($string, Byte::RETURN_AS_STRING);
+	} catch (\LengthException $e) {
+		print "<br>LengthException B: " . $e->getMessage();
+		$_bytes_string = '';
+	} catch (\RuntimeException $e) {
+		print "<br>RuntimeException: " . $e->getMessage();
+		$_bytes_string = '';
+	}
+	try {
+		$_bytes_si = Byte::stringByteFormat($string, Byte::BYTE_FORMAT_SI);
+	} catch (\LengthException $e) {
+		print "<br>LengthException A: " . $e->getMessage();
+		$_bytes_si = 0;
+	}
+	try {
+		$_bytes_string_si = Byte::stringByteFormat($string, Byte::RETURN_AS_STRING | Byte::BYTE_FORMAT_SI);
+	} catch (\LengthException $e) {
+		print "<br>LengthException B: " . $e->getMessage();
+		$_bytes_string_si = '';
+	} catch (\RuntimeException $e) {
+		print "<br>RuntimeException: " . $e->getMessage();
+		$_bytes_string_si = '';
+	}
+	print '</div>';
+	print '<div style="width: 20%;">'
+		. "F:" . number_format((int)$_bytes)
+		. '<br>B: ' . $_bytes
+		. '<br>S: ' . $_bytes_string
+		. "<br>Fsi:" . number_format((int)$_bytes_si)
+		. '<br>Bsi: ' . $_bytes_si
+		. '<br>Ssi: ' . $_bytes_string_si;
+	print '</div>';
+	print '<div style="width: 10%;">';
+	print "B: " . Byte::humanReadableByteFormat($_bytes) . "<br>";
+	print "Bsi: " . Byte::humanReadableByteFormat($_bytes_si, Byte::BYTE_FORMAT_SI);
+	print "</div>";
+	print "</div>";
+}
 print "</body></html>";
 
 // __END__

www/admin/class_test.check.colors.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.class-calls.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.config.direct.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.config.link.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.convert.colors.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.create_email.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.datetime.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -225,6 +225,36 @@ foreach ($intervals as $interval) {
 	print "STRINGTOTIME: $reverse_interval: " . DateTime::stringToTime($reverse_interval) . "<br>";
 }
 print "<hr>";
+$interval_strings = [
+	'10d 5h 30m 15s 123456ms',
+	'18999d 0h 38m 10s 1235ms',
+	'18999 d 0 h 38 m 10s 1235ms',
+	'-2h 15m 5s',
+	'45s 500ms',
+	'0s',
+	'0ms',
+	'1s 5ms',
+	'1s 50ms',
+	'1s 500ms',
+	'1s 5000ms',
+	'10day 5hour 30min 15sec 123456millis',
+	'10day 5hour 30min 15sec 123456millisec',
+	'10day 5hour 30min 15sec 123456msec',
+	'-2days 3hours 15minutes 30seconds 250milliseconds',
+	'',
+	' ',
+	'invalid',
+];
+foreach ($interval_strings as $interval_string) {
+	print "STRINGTOTIME: $interval_string: " . DateTime::stringToTime($interval_string) . "<br>";
+	try {
+		// test exception
+		DateTime::stringToTime($interval_string, throw_exception:true);
+	} catch (\InvalidArgumentException $e) {
+		print "ERROR: " . $e->getMessage() . "<br><pre>" . $e . "</pre><br>";
+	}
+}
+print "<hr>";
 $check_dates = [
 	'2021-05-01',
 	'2021-05-40'
@@ -268,7 +298,9 @@ foreach ($compare_datetimes as $compare_datetime) {
 	print "COMPAREDATE: $compare_datetime[0] = $compare_datetime[1]: "
 		. (string)DateTime::compareDateTime($compare_datetime[0], $compare_datetime[1]) . "<br>";
 }
+
 print "<hr>";
+print "<h2>calcDaysInterval</h2>";
 $compare_dates = [
 	[ '2021-05-01', '2021-05-10', ],
 	[ '2021-05-10', '2021-05-01', ],
@@ -279,9 +311,21 @@ foreach ($compare_dates as $compare_date) {
 	print "CALCDAYSINTERVAL: $compare_date[0] = $compare_date[1]: "
 		. DgS::printAr(DateTime::calcDaysInterval($compare_date[0], $compare_date[1])) . "<br>";
 	print "CALCDAYSINTERVAL(named): $compare_date[0] = $compare_date[1]: "
-		. DgS::printAr(DateTime::calcDaysInterval($compare_date[0], $compare_date[1], true)) . "<br>";
+		. DgS::printAr(DateTime::calcDaysInterval($compare_date[0], $compare_date[1], return_named:true)) . "<br>";
+	print "CALCDAYSINTERVAL(EXCLUDE END): $compare_date[0] = $compare_date[1]: "
+		. Dgs::printAr(DateTime::calcDaysInterval($compare_date[0], $compare_date[1], include_end_date:false));
+	print "CALCDAYSINTERVAL(EXCLUDE START): $compare_date[0] = $compare_date[1]: "
+		. Dgs::printAr(DateTime::calcDaysInterval($compare_date[0], $compare_date[1], exclude_start_date:true));
+	print "CALCDAYSINTERVAL(EXCLUDE END, EXCLUDE START): $compare_date[0] = $compare_date[1]: "
+		. Dgs::printAr(DateTime::calcDaysInterval(
+			$compare_date[0],
+			$compare_date[1],
+			include_end_date:false,
+			exclude_start_date:true
+		));
 }
 print "<hr>";
+print "<h2>setWeekdayNameFromIsoDow</h2>";
 // test date conversion
 $dow = 2;
 print "DOW[$dow]: " . DateTime::setWeekdayNameFromIsoDow($dow) . "<br>";
@@ -297,26 +341,25 @@ $date = '2022-70-242';
 print "DATE-dow[$date];invalid: " . DateTime::setWeekdayNameFromDate($date) . "<br>";
 print "DATE-dow[$date],long;invalid: " . DateTime::setWeekdayNameFromDate($date, true) . "<br>";
 print "DOW-date[$date];invalid: " . DateTime::setWeekdayNumberFromDate($date) . "<br>";
-print "<hr>";
-// check date range includes a weekend
-// does not:
-$start_date = '2023-07-03';
-$end_date = '2023-07-05';
-print "Has Weekend: " . $start_date . " ~ " . $end_date . ": "
-	. Dgs::prBl(DateTime::dateRangeHasWeekend($start_date, $end_date)) . "<br>";
-$start_date = '2023-07-03';
-$end_date = '2023-07-10';
-print "Has Weekend: " . $start_date . " ~ " . $end_date . ": "
-	. Dgs::prBl(DateTime::dateRangeHasWeekend($start_date, $end_date)) . "<br>";
-$start_date = '2023-07-03';
-$end_date = '2023-07-31';
-print "Has Weekend: " . $start_date . " ~ " . $end_date . ": "
-	. Dgs::prBl(DateTime::dateRangeHasWeekend($start_date, $end_date)) . "<br>";
-$start_date = '2023-07-01';
-$end_date = '2023-07-03';
-print "Has Weekend: " . $start_date . " ~ " . $end_date . ": "
-	. Dgs::prBl(DateTime::dateRangeHasWeekend($start_date, $end_date)) . "<br>";
 
+print "<hr>";
+print "<h2>dateRangeHasWeekend</h2>";
+// check date range includes a weekend
+$has_weekend_list = [
+	['2023-07-03', '2023-07-05'],
+	['2023-07-03', '2023-07-10'],
+	['2023-07-03', '2023-07-31'],
+	['2023-07-01', '2023-07-03'],
+	['2023-07-01', '2023-07-01'],
+	['2023-07-01', '2023-07-02'],
+	['2023-06-30', '2023-07-01'],
+	['2023-06-30', '2023-06-30'],
+	['2023-07-01', '2023-06-30'],
+];
+foreach ($has_weekend_list as $days) {
+	print "Has Weekend: " . $days[0] . " ~ " . $days[1] . ": "
+		. Dgs::prBl(DateTime::dateRangeHasWeekend($days[0], $days[1])) . "<br>";
+}
 
 print "</body></html>";
 
@@ -460,7 +503,10 @@ function intervalStringFormatDeprecated(
 		// print "-> V: $value | $part, $time_name | I: " . is_int($value) . " | F: " . is_float($value)
 		// 	. " | " . ($value != 0 ? 'Not zero' : 'ZERO') . "<br>";
 		// var_dump($skip_last_zero);
-		if ($value != 0 || $skip_zero === false || $skip_last_zero === false) {
+		if (
+			is_numeric($value) &&
+			($value != 0 || $skip_zero === false || $skip_last_zero === false)
+		) {
 			if ($part == 'f') {
 				if ($truncate_nanoseconds === true) {
 					$value = round($value, 3);

www/admin/class_test.db.convert-placeholder.php

@@ -7,7 +7,7 @@
 declare(strict_types=1);
 
 // turn on all error reporting
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -21,6 +21,7 @@ ob_end_flush();
 
 use CoreLibs\Debug\Support;
 use CoreLibs\DB\Support\ConvertPlaceholder;
+use CoreLibs\Convert\Html;
 
 $log = new CoreLibs\Logging\Logging([
 	'log_folder' => BASE . LOG,
@@ -38,10 +39,12 @@ print '<div><h1>' . $PAGE_NAME . '</h1></div>';
 print "LOGFILE NAME: " . $log->getLogFile() . "<br>";
 print "LOGFILE ID: " . $log->getLogFileId() . "<br>";
 
-print "Lookup Regex: <pre>" . ConvertPlaceholder::REGEX_LOOKUP_PLACEHOLDERS . "</pre>";
-print "Replace Named Regex: <pre>" . ConvertPlaceholder::REGEX_REPLACE_NAMED . "</pre>";
-print "Replace Named Regex: <pre>" . ConvertPlaceholder::REGEX_REPLACE_QUESTION_MARK . "</pre>";
-print "Replace Named Regex: <pre>" . ConvertPlaceholder::REGEX_REPLACE_NUMBERED . "</pre>";
+print "Lookup Regex: <pre>" . Html::htmlent(ConvertPlaceholder::REGEX_LOOKUP_PLACEHOLDERS) . "</pre>";
+print "Lookup Numbered Regex: <pre>" . Html::htmlent(ConvertPlaceholder::REGEX_LOOKUP_NUMBERED) . "</pre>";
+print "Replace Named Regex: <pre>" . Html::htmlent(ConvertPlaceholder::REGEX_REPLACE_NAMED) . "</pre>";
+print "Replace Question Mark Regex: <pre>"
+	. Html::htmlent(ConvertPlaceholder::REGEX_REPLACE_QUESTION_MARK) . "</pre>";
+print "Replace Numbered Regex: <pre>" . Html::htmlent(ConvertPlaceholder::REGEX_REPLACE_NUMBERED) . "</pre>";
 
 $uniqid = \CoreLibs\Create\Uids::uniqIdShort();
 // $binary_data = $db->dbEscapeBytea(file_get_contents('class_test.db.php') ?: '');
@@ -91,40 +94,63 @@ RETURNING
 	some_binary
 SQL;
 
-print "[ALL] Convert: "
+print "<b>[ALL] Convert</b>: "
 	. Support::printAr(ConvertPlaceholder::convertPlaceholderInQuery($query, $params))
 	. "<br>";
 echo "<hr>";
 
 $query = "SELECT foo FROM bar WHERE baz = :baz AND buz = :baz AND biz = :biz AND boz = :bez";
 $params = [':baz' => 'SETBAZ', ':bez' => 'SETBEZ', ':biz' => 'SETBIZ'];
-print "[NO PARAMS] Convert: "
+print "<b>[NO PARAMS] Convert</b>: "
 	. Support::printAr(ConvertPlaceholder::convertPlaceholderInQuery($query, $params))
 	. "<br>";
 echo "<hr>";
 
 $query = "SELECT foo FROM bar WHERE baz = :baz AND buz = :baz AND biz = :biz AND boz = :bez";
 $params = null;
-print "[NO PARAMS] Convert: "
+print "<b>[NO PARAMS] Convert</b>: "
 	. Support::printAr(ConvertPlaceholder::convertPlaceholderInQuery($query, $params))
 	. "<br>";
 echo "<hr>";
 
 $query = "SELECT row_varchar FROM table_with_primary_key WHERE row_varchar <> :row_varchar";
 $params = null;
-print "[NO PARAMS] Convert: "
+print "<b>[NO PARAMS] Convert</b>: "
 	. Support::printAr(ConvertPlaceholder::convertPlaceholderInQuery($query, $params))
 	. "<br>";
 echo "<hr>";
 
 $query = "SELECT row_varchar, row_varchar_literal, row_int, row_date FROM table_with_primary_key";
 $params = null;
-print "[NO PARAMS] TEST: "
+print "<b>[NO PARAMS] TEST</b>: "
 	. Support::printAr(ConvertPlaceholder::convertPlaceholderInQuery($query, $params))
 	. "<br>";
 echo "<hr>";
 
-print "[P-CONV]: "
+$query = <<<SQL
+UPDATE table_with_primary_key SET
+	row_int = $1::INT, row_numeric = $1::NUMERIC, row_varchar = $1
+WHERE
+	row_varchar = $1
+SQL;
+$params = [1];
+print "<b>[All the same params] TEST</b>: "
+	. Support::printAr(ConvertPlaceholder::convertPlaceholderInQuery($query, $params))
+	. "<br>";
+echo "<hr>";
+
+$query = <<<SQL
+SELECT row_varchar, row_varchar_literal, row_int, row_date
+FROM table_with_primary_key
+WHERE row_varchar = :row_varchar
+SQL;
+$params = [':row_varchar' => 1];
+print "<b>[: param] TEST</b>: "
+	. Support::printAr(ConvertPlaceholder::convertPlaceholderInQuery($query, $params))
+	. "<br>";
+echo "<hr>";
+
+print "<b>[P-CONV]</b>: "
 	. Support::printAr(
 		ConvertPlaceholder::updateParamList([
 			'original' => [
@@ -186,6 +212,13 @@ SQL,
 		'params' => [\CoreLibs\Create\Uids::uniqIdShort(), 'string A-1', 1234],
 		'direction' => 'pg',
 	],
+	'b?' => [
+		'query' => <<<SQL
+SELECT test FROM test_foo = ?
+SQL,
+		'params' => [1234],
+		'direction' => 'pg',
+	],
 	'b:' => [
 		'query' => <<<SQL
 INSERT INTO test_foo (
@@ -220,7 +253,7 @@ foreach ($test_queries as $info => $data) {
 	$query = $data['query'];
 	$params = $data['params'];
 	$direction = $data['direction'];
-	print "[$info] Convert: "
+	print "<b>[$info] Convert</b>: "
 		. Support::printAr(ConvertPlaceholder::convertPlaceholderInQuery($query, $params, $direction))
 		. "<br>";
 	echo "<hr>";

www/admin/class_test.db.dbReturn.php

@@ -7,7 +7,7 @@
 declare(strict_types=1);
 
 // turn on all error reporting
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.db.encryption.php

@@ -0,0 +1,166 @@
+<?php // phpcs:ignore warning
+
+/**
+ * @phan-file-suppress PhanTypeSuspiciousStringExpression
+ */
+
+declare(strict_types=1);
+
+// turn on all error reporting
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+
+ob_start();
+
+// basic class test file
+define('USE_DATABASE', true);
+// sample config
+require 'config.php';
+// for testing encryption compare
+use OpenPGP\OpenPGP;
+// define log file id
+$LOG_FILE_ID = 'classTest-db-query-encryption';
+ob_end_flush();
+
+// use CoreLibs\Debug\Support;
+use CoreLibs\Security\SymmetricEncryption;
+use CoreLibs\Security\CreateKey;
+use CoreLibs\Create\Hash;
+use CoreLibs\Debug\Support;
+
+$log = new CoreLibs\Logging\Logging([
+	'log_folder' => BASE . LOG,
+	'log_file_id' => $LOG_FILE_ID,
+	'log_per_date' => true,
+]);
+// db connection and attach logger
+$db = new CoreLibs\DB\IO(DB_CONFIG, $log);
+$db->log->debug('START', '=============================>');
+
+$PAGE_NAME = 'TEST CLASS: DB QUERY ENCRYPTION';
+print "<!DOCTYPE html>";
+print "<html><head><title>" . $PAGE_NAME . "</title></head>";
+print "<body>";
+print '<div><a href="class_test.php">Class Test Master</a></div>';
+print '<div><h1>' . $PAGE_NAME . '</h1></div>';
+
+// encryption key
+$key_new = CreateKey::generateRandomKey();
+print "Secret Key NEW: " . $key_new . "<br>";
+// for reproducable test results
+$key = 'e475c19b9a3c8363feb06b51f5b73f1dc9b6f20757d4ab89509bf5cc70ed30ec';
+print "Secret Key: " . $key . "<br>";
+
+// test text
+$text_string = "I a some deep secret";
+$text_string = "I a some deep secret ABC";
+//
+$crypt = new SymmetricEncryption($key);
+$encrypted = $crypt->encrypt($text_string);
+$string_hashed = Hash::hashStd($text_string);
+$string_hmac = Hash::hashHmac($text_string, $key);
+$decrypted = $crypt->decrypt($encrypted);
+
+print "String: " . $text_string . "<br>";
+print "Encrypted: " . $encrypted . "<br>";
+print "Hashed: " . $string_hashed . "<br>";
+print "Hmac: " . $string_hmac . "<br>";
+
+$db->dbExecParams(
+	<<<SQL
+	INSERT INTO test_encryption (
+		-- for compare
+		plain_text,
+		-- via php encryption
+		hash_text, hmac_text, crypt_text,
+		-- -- in DB encryption
+		pg_digest_bytea, pg_digest_text,
+		pg_hmac_bytea, pg_hmac_text,
+		pg_crypt_bytea, pg_crypt_text
+	) VALUES (
+		$1,
+		$2, $3, $4,
+		digest($1::VARCHAR, $5),
+		encode(digest($1, $5), 'hex'),
+		hmac($1, $6, $5),
+		encode(hmac($1, $6, $5), 'hex'),
+		pgp_sym_encrypt($1, $7),
+		encode(pgp_sym_encrypt($1, $7), 'hex')
+	) RETURNING cuuid
+	SQL,
+	[
+		// 1: original string
+		$text_string,
+		// 2: hashed, 3: hmac, 4: encrypted
+		$string_hashed, $string_hmac, $encrypted,
+		// 5: hash type, 6: hmac secret, 7: pgp secret
+		'sha256', $key, $key
+	]
+);
+$cuuid = $db->dbGetReturningExt('cuuid');
+print "INSERTED: " . print_r($cuuid, true) . "<br>";
+print "LAST ERROR: " . $db->dbGetLastError(true) . "<br>";
+
+// read back
+$res = $db->dbReturnRowParams(
+	<<<SQL
+	SELECT
+		-- for compare
+		plain_text,
+		-- via php encryption
+		hash_text, hmac_text, crypt_text,
+		-- in DB encryption
+		pg_digest_bytea, pg_digest_text,
+		pg_hmac_bytea, pg_hmac_text,
+		pg_crypt_bytea, pg_crypt_text,
+		encode(pg_crypt_bytea, 'hex') AS pg_crypt_bytea_hex,
+		pgp_sym_decrypt(pg_crypt_bytea, $2) AS from_pg_crypt_bytea,
+		pgp_sym_decrypt(decode(pg_crypt_text, 'hex'), $2) AS from_pg_crypt_text
+	FROM
+		test_encryption
+	WHERE
+		cuuid = $1
+	SQL,
+	[
+		$cuuid, $key
+	]
+);
+
+print "RES: <pre>" . Support::prAr($res) . "</pre><br>";
+
+if ($res === false) {
+	echo "Failed to run query<br>";
+} else {
+	if (hash_equals($string_hashed, $res['pg_digest_text'])) {
+		print "libsodium and pgcrypto hash match<br>";
+	}
+	if (hash_equals($string_hmac, $res['pg_hmac_text'])) {
+		print "libsodium and pgcrypto hash hmac match<br>";
+	}
+	// do compare for PHP and pgcrypto settings
+	$encryptedMessage_template = <<<TEXT
+	-----BEGIN PGP MESSAGE-----
+
+	{BASE64}
+	-----END PGP MESSAGE-----
+	TEXT;
+	$base64_string = base64_encode(hex2bin($res['pg_crypt_text']) ?: '');
+	$encryptedMessage = str_replace(
+		'{BASE64}',
+		$base64_string,
+		$encryptedMessage_template
+	);
+	try {
+		$literalMessage = OpenPGP::decryptMessage($encryptedMessage, passwords: [$key]);
+		$decrypted = $literalMessage->getLiteralData()->getData();
+		print "Pg decrypted PHP: " . $decrypted . "<br>";
+		if ($decrypted == $text_string) {
+			print "Decryption worked<br>";
+		}
+	} catch (\Exception $e) {
+		print "Error decrypting message: " . $e->getMessage() . "<br>";
+	}
+}
+
+print "</body></html>";
+
+// __END__

www/admin/class_test.db.php

@@ -7,7 +7,7 @@
 declare(strict_types=1);
 
 // turn on all error reporting
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -76,41 +76,41 @@ $db->dbResetEncoding();
 
 // empty calls, none of the below should fail
 //
-$db->dbGetCursor();
+$foo = $db->dbGetCursor();
 //
-$db->dbGetCursorExt();
+$foo = $db->dbGetCursorExt();
 //
-$db->dbGetCursorPos('SELECT foo', ['bar']);
+$foo = $db->dbGetCursorPos('SELECT foo', ['bar']);
 //
-$db->dbGetCursorNumRows('SELECT foo', ['bar']);
+$foo = $db->dbGetCursorNumRows('SELECT foo', ['bar']);
 //
-$db->dbGetInsertPKName();
+$foo = $db->dbGetInsertPKName();
 //
-$db->dbGetInsertPK();
+$foo = $db->dbGetInsertPK();
 //
-$db->dbGetReturningExt();
-$db->dbGetReturningExt('foo');
-$db->dbGetReturningExt('foo', 0);
-$db->dbGetReturningExt(pos:0);
+$foo = $db->dbGetReturningExt();
+$foo = $db->dbGetReturningExt('foo');
+$foo = $db->dbGetReturningExt('foo', 0);
+$foo = $db->dbGetReturningExt(pos:0);
 //
-$db->dbGetReturningArray();
+$foo = $db->dbGetReturningArray();
 //
-$db->dbGetNumRows();
+$foo = $db->dbGetNumRows();
 //
-$db->dbGetNumFields();
+$foo = $db->dbGetNumFields();
 //
-$db->dbGetFieldNames();
+$foo = $db->dbGetFieldNames();
 //
-$db->dbGetFieldTypes();
+$foo = $db->dbGetFieldTypes();
 //
-$db->dbGetFieldNameTypes();
+$foo = $db->dbGetFieldNameTypes();
 //
-$db->dbGetFieldName(0);
+$foo = $db->dbGetFieldName(0);
 //
-$db->dbGetFieldType(0);
-$db->dbGetFieldType('foo');
+$foo = $db->dbGetFieldType(0);
+$foo = $db->dbGetFieldType('foo');
 //
-$db->dbGetPrepareCursorValue('foo', 'bar');
+$foo = $db->dbGetPrepareCursorValue('foo', 'bar');
 
 // TEST CACHE READS
 
@@ -273,8 +273,8 @@ $query_insert = <<<SQL
 INSERT INTO
 	test_foo
 (
-	test, some_bool, string_a, number_a, number_a_numeric,
-	some_time, some_timestamp, json_string
+	test, some_bool, string_a, number_a, numeric_a,
+	some_internval, some_timestamp, json_string
 ) VALUES (
 	$1, $2, $3, $4, $5,
 	$6, $7, $8
@@ -283,8 +283,8 @@ RETURNING test
 SQL;
 $query_select = <<<SQL
 SELECT
-	test, some_bool, string_a, number_a, number_a_numeric,
-	some_time, some_time, some_timestamp, json_string
+	test, some_bool, string_a, number_a, numeric_a,
+	some_time, some_internval, some_timestamp, json_string
 FROM
 	test_foo
 WHERE
@@ -554,7 +554,7 @@ print "<b>PREPARE QUERIES</b><br>";
 // READ PREPARE
 $q_prep = <<<SQL
 SELECT test_foo_id, test, some_bool, string_a, number_a,
-number_a_numeric, some_time
+numeric_a, some_time
 FROM test_foo
 WHERE test = $1
 ORDER BY test_foo_id DESC LIMIT 5
@@ -582,7 +582,7 @@ if ($db->dbPrepare('sel_test_foo', $q_prep) === false) {
 
 // sel test with ANY () type
 $q_prep = "SELECT test_foo_id, test, some_bool, string_a, number_a, "
-	. "number_a_numeric, some_time "
+	. "numeric_a, some_time "
 	. "FROM test_foo "
 	. "WHERE test = ANY($1) "
 	. "ORDER BY test_foo_id DESC LIMIT 5";
@@ -618,7 +618,7 @@ $test_bar = $db->dbEscapeLiteral('SOMETHING DIFFERENT');
 $q = <<<SQL
 SELECT test_foo_id, test, some_bool, string_a, number_a,
 -- comment
-number_a_numeric, some_time
+numeric_a, some_time
 FROM test_foo
 WHERE test = $test_bar
 ORDER BY test_foo_id DESC LIMIT 5
@@ -631,7 +631,7 @@ print "DB RETURN PARAMS<br>";
 $q = <<<SQL
 SELECT test_foo_id, test, some_bool, string_a, number_a,
 -- comment
-number_a_numeric, some_time
+numeric_a, some_time
 FROM test_foo
 WHERE test = $1
 ORDER BY test_foo_id DESC LIMIT 5
@@ -646,7 +646,7 @@ echo "<hr>";
 print "DB RETURN PARAMS LIKE<br>";
 $q = <<<SQL
 SELECT
-	test_foo_id, test, some_bool, string_a, number_a, number_a_numeric
+	test_foo_id, test, some_bool, string_a, number_a, numeric_a
 FROM test_foo
 WHERE string_a LIKE $1;
 SQL;
@@ -660,7 +660,7 @@ echo "<hr>";
 print "DB RETURN PARAMS ANY<br>";
 $q = <<<SQL
 SELECT
-	test_foo_id, test, some_bool, string_a, number_a, number_a_numeric
+	test_foo_id, test, some_bool, string_a, number_a, numeric_a
 FROM test_foo
 WHERE string_a = ANY($1);
 SQL;
@@ -707,6 +707,17 @@ if (
 } else {
 	print "[PGB] [3] pgb_sel_test_foo prepare OK<br>";
 }
+$stm_status = $db->dbPreparedCursorStatus('');
+print "[PGB] Empty statement name: " . $log->prAr($stm_status) . "<br>";
+$stm_status = $db->dbPreparedCursorStatus('pgb_sel_test_foobar');
+print "[PGB] Prepared name not match status: $stm_status<br>";
+$stm_status = $db->dbPreparedCursorStatus('pgb_sel_test_foo');
+print "[PGB] Prepared name match status: $stm_status<br>";
+$stm_status = $db->dbPreparedCursorStatus('pgb_sel_test_foo', $q_prep);
+print "[PGB] prepared exists and query match status: $stm_status<br>";
+$stm_status = $db->dbPreparedCursorStatus('pgb_sel_test_foo', "SELECT * FROM test_foo");
+print "[PGB] prepared exists and query not match status: $stm_status<br>";
+
 $db_pgb->dbClose();
 
 # db write class test

www/admin/class_test.db.query-placeholder.php

@@ -7,7 +7,7 @@
 declare(strict_types=1);
 
 // turn on all error reporting
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -54,7 +54,7 @@ if (($dbh = $db->dbGetDbh()) instanceof \PgSql\Connection) {
 	print "NO DB HANDLER<br>";
 }
 // REGEX for placeholder count
-print "Placeholder regex: <pre>" . CoreLibs\DB\Support\ConvertPlaceholder::REGEX_LOOKUP_PLACEHOLDERS . "</pre>";
+print "Placeholder lookup regex: <pre>" . CoreLibs\DB\Support\ConvertPlaceholder::REGEX_LOOKUP_NUMBERED . "</pre>";
 
 // turn on debug replace for placeholders
 $db->dbSetDebugReplacePlaceholder(true);
@@ -148,6 +148,7 @@ RETURNING
 	bigint_a, number_real, number_double, numeric_3,
 	uuid_var
 SQL;
+print "Placeholders: <pre>" . print_r($db->dbGetQueryParamPlaceholders($query_insert), true) . "<pre>";
 $status = $db->dbExecParams($query_insert, $query_params);
 echo "<b>*</b><br>";
 echo "INSERT ALL COLUMN TYPES: "
@@ -174,6 +175,26 @@ while (is_array($res = $db->dbReturnParams($query, [$query_value]))) {
 
 echo "<hr>";
 
+echo "<b>CASE part</b><br>";
+$query = <<<SQL
+UPDATE
+test_foo
+SET
+some_timestamp = NOW(),
+	-- if not 1 set, else keep at one
+	smallint_a = (CASE
+			WHEN smallint_a <> 1 THEN $1
+			ELSE 1::INT
+	END)::INT
+WHERE
+	string_a = $2
+SQL;
+echo "QUERY: <pre>" . $query . "</pre>";
+$res = $db->dbExecParams($query, [1, 'foobar']);
+print "ERROR: " . $db->dbGetLastError(true) . "<br>";
+
+echo "<hr>";
+
 // test connectors: = , <> () for query detection
 
 // convert placeholder tests
@@ -237,7 +258,7 @@ SQL,
 		SQL,
 		'params' => [1, 2, 3, 4, 5, 6],
 		'direction' => 'pg'
-	]
+	],
 ];
 
 $db->dbSetConvertPlaceholder(true);
@@ -306,6 +327,7 @@ SQL,
 ) {
 	print "RES: " . Support::prAr($res) . "<br>";
 }
+print "PL: " . Support::PrAr($db->dbGetPlaceholderConverted()) . "<br>";
 print "ERROR: " . $db->dbGetLastError(true) . "<br>";
 
 print "</body></html>";

www/admin/class_test.db.single.php

@@ -7,7 +7,7 @@
 declare(strict_types=1);
 
 // turn on all error reporting
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.db.types.php

@@ -7,7 +7,7 @@
 declare(strict_types=1);
 
 // turn on all error reporting
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -57,6 +57,43 @@ if (($dbh = $db->dbGetDbh()) instanceof \PgSql\Connection) {
 print "<b>TRUNCATE test_foo</b><br>";
 $db->dbExec("TRUNCATE test_foo");
 
+/*
+BELOW IS THE FULL TABLE WITH ALL PostgreSQL Types
+=> \d test_foo
+												Table "public.test_foo"
+Column            |            Type             | Nullable |                     Default
+------------------+-----------------------------+----------+-----------------------------------------------
+test              | character varying           |          |
+some_bool         | boolean                     |          |
+string_a          | character varying           |          |
+number_a          | integer                     |          |
+numeric_a         | numeric                     |          |
+some_internval    | interval                    |          |
+test_foo_id       | integer                     | not null | generated always as identity
+json_string       | jsonb                       |          |
+some_timestamp    | timestamp without time zone |          |
+some_binary       | bytea                       |          |
+null_var          | character varying           |          |
+smallint_a        | smallint                    |          |
+number_real       | real                        |          |
+number_double     | double precision            |          |
+number_serial     | integer                     | not null | nextval('test_foo_number_serial_seq'::regclass)
+array_char_1      | character varying[]         |          |
+array_char_2      | character varying[]         |          |
+array_int_1       | integer[]                   |          |
+array_int_2       | integer[]                   |          |
+composite_item    | inventory_item              |          |
+array_composite   | inventory_item[]            |          |
+numeric_3         | numeric(3,0)                |          |
+identity_always   | bigint                      | not null | generated always as identity
+identitiy_default | bigint                      | not null | generated by default as identity
+uuid_var          | uuid                        |          | gen_random_uuid()
+some_date         | date                        |          |
+some_time         | time without time zone      |          |
+bigint_a          | bigint                      |          |
+default_uuid      | uuid                        |          | gen_random_uuid()
+*/
+
 /* $q = <<<SQL
 INSERT INTO test_foo (test, array_composite) VALUES ('C', '{"(a,1,1.5)","(b,2,2.5)"}')
 SQL;
@@ -90,7 +127,7 @@ $query_params = [
 
 $query_insert = <<<SQL
 INSERT INTO test_foo (
-	test, some_bool, string_a, number_a, number_a_numeric, smallint_a,
+	test, some_bool, string_a, number_a, numeric_a, smallint_a,
 	some_time, some_timestamp, json_string, null_var,
 	array_char_1, array_int_1,
 	array_composite,
@@ -106,7 +143,7 @@ INSERT INTO test_foo (
 )
 RETURNING
 	test_foo_id,
-	test, some_bool, string_a, number_a, number_a_numeric, smallint_a,
+	test, some_bool, string_a, number_a, numeric_a, smallint_a,
 	some_time, some_timestamp, json_string, null_var,
 	array_char_1, array_int_1,
 	array_composite,
@@ -127,8 +164,8 @@ echo "<hr>";
 $query_select = <<<SQL
 SELECT
 	test_foo_id,
-	test, some_bool, string_a, number_a, number_a_numeric, smallint_a,
-	number_real, number_double, number_numeric_3, number_serial,
+	test, some_bool, string_a, number_a, numeric_a, smallint_a,
+	number_real, number_double, numeric_3, number_serial,
 	some_time, some_timestamp, json_string, null_var,
 	array_char_1, array_char_2, array_int_1, array_int_2, array_composite,
 	composite_item, (composite_item).*,

www/admin/class_test.debug.php

@@ -12,7 +12,7 @@ $PRINT_ALL = false;
 $ECHO_ALL = true;
 $DB_DEBUG = true;
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -68,6 +68,14 @@ function test2(): array
 	return DebugSupport::getCallerMethodList(1);
 }
 
+// date stueff
+print "printTime(-1): " . DebugSupport::printTime() . "<br>";
+print "printTime(2): " . DebugSupport::printTime(2) . "<br>";
+print "printTime(3): " . DebugSupport::printTime(3) . "<br>";
+print "printTime(5): " . DebugSupport::printTime(5) . "<br>";
+print "printIsoTime(): " . DebugSupport::printIsoTime() . "<br>";
+print "printIsoTime(false): " . DebugSupport::printIsoTime(false) . "<br>";
+
 print "S::GETCALLERMETHOD: " . DebugSupport::getCallerMethod(0) . "<br>";
 print "S::GETCALLERMETHOD: " . test() . "<br>";
 print "S::GETCALLERMETHODLIST: <pre>" . print_r(test2(), true) . "</pre><br>";
@@ -146,7 +154,7 @@ print "LOG LEVEL: " .  DebugSupport::printAr(\CoreLibs\Convert\SetVarType::setAr
 	$new_log->getLogLevel('debug', 'on')
 )) . "<br>";
 
-echo "<b>CLASS DEBUG CALL</b><br>";
+echo "<b>CLASS DEBUG CALL LEGACY</b><br>";
 
 // @codingStandardsIgnoreLine
 class TestL

www/admin/class_test.deprecated.helper.php

@@ -0,0 +1,110 @@
+<?php // phpcs:ignore warning
+
+/**
+ * @phan-file-suppress PhanTypeSuspiciousStringExpression
+ */
+
+declare(strict_types=1);
+
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+
+ob_start();
+
+// basic class test file
+define('USE_DATABASE', false);
+// sample config
+require 'config.php';
+// define log file id
+$LOG_FILE_ID = 'classTest-phpv';
+ob_end_flush();
+
+$log = new CoreLibs\Logging\Logging([
+	'log_folder' => BASE . LOG,
+	'log_file_id' => $LOG_FILE_ID,
+	'log_per_date' => true,
+]);
+$_phpv = new CoreLibs\Check\PhpVersion();
+$phpv_class = 'CoreLibs\Check\PhpVersion';
+
+$PAGE_NAME = 'TEST CLASS: PHP VERSION';
+print "<!DOCTYPE html>";
+print "<html><head><title>" . $PAGE_NAME . "</title></head>";
+print "<body>";
+print '<div><a href="class_test.php">Class Test Master</a></div>';
+print '<div><h1>' . $PAGE_NAME . '</h1></div>';
+
+// fputcsv
+print "<h3>\CoreLibs\DeprecatedHelper\Deprecated84::fputcsv()</h3>";
+$test_csv = BASE . TMP . 'DeprecatedHelper.test.csv';
+print "File: $test_csv<br>";
+
+$fp = fopen($test_csv, "w");
+if (!is_resource($fp)) {
+	die("Cannot open file: $test_csv");
+}
+\CoreLibs\DeprecatedHelper\Deprecated84::fputcsv($fp, ["A", "B", "C"]);
+fclose($fp);
+
+$fp = fopen($test_csv, "r");
+if (!is_resource($fp)) {
+	die("Cannot open file: $test_csv");
+}
+while ($entry = \CoreLibs\DeprecatedHelper\Deprecated84::fgetcsv($fp)) {
+	print "fgetcsv: <pre>" . print_r($entry, true) . "</pre>";
+}
+fclose($fp);
+
+$out = \CoreLibs\DeprecatedHelper\Deprecated84::str_getcsv("A,B,C");
+print "str_getcsv: <pre>" . print_r($out, true) . "</pre>";
+
+/**
+ * temporary different CSV function, because fgetcsv seems to be broken on some systems
+ * (does not read out japanese text)
+ *
+ * @param  string $string    full line for csv split
+ * @param  string $encoding  optional, if given, converts string to the internal encoding
+ *                           before we do anything
+ * @param  string $delimiter sepperate character, default ','
+ * @param  string $enclosure string line marker, default '"'
+ * @param  string $flag      INTERN | EXTERN. if INTERN uses the PHP function, else uses explode
+ * @return array<int,string|null> array with split data from input line
+ */
+function mtParseCSV(
+	string $string,
+	string $encoding = '',
+	string $delimiter = ',',
+	string $enclosure = '"',
+	string $flag = 'INTERN'
+): array {
+	$lines = [];
+	if ($encoding) {
+		$string = \CoreLibs\Convert\Encoding::convertEncoding(
+			$string,
+			'UTF-8',
+			$encoding
+		);
+		if ($string === false) {
+			return $lines;
+		}
+	}
+	if ($flag == 'INTERN') {
+		// split with PHP function
+		$lines = str_getcsv($string, $delimiter, $enclosure);
+	} else {
+		// split up with delimiter
+		$lines = explode(',', $string) ?: [];
+	}
+	// strip " from beginning and end of line
+	for ($i = 0; $i < count($lines); $i++) {
+		// remove line breaks
+		$lines[$i] = preg_replace("/\r\n?/", '', (string)$lines[$i]) ?? '';
+		// lingering " at the beginning and end of the line
+		$lines[$i] = preg_replace("/^\"/", '', (string)$lines[$i]) ?? '';
+		$lines[$i] = preg_replace("/\"$/", '', (string)$lines[$i]) ?? '';
+	}
+	return $lines;
+}
+
+print "</body></html>";
+
+// __END__

www/admin/class_test.email.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.encoding.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.encryption.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -18,6 +18,7 @@ require 'config.php';
 $LOG_FILE_ID = 'classTest-encryption';
 ob_end_flush();
 
+use CoreLibs\Security\AsymmetricAnonymousEncryption;
 use CoreLibs\Security\SymmetricEncryption;
 use CoreLibs\Security\CreateKey;
 
@@ -36,6 +37,8 @@ print "<body>";
 print '<div><a href="class_test.php">Class Test Master</a></div>';
 print '<div><h1>' . $PAGE_NAME . '</h1></div>';
 
+print "<h2>Symmetric Encryption</h2>";
+
 $key = CreateKey::generateRandomKey();
 print "Secret Key: " . $key . "<br>";
 
@@ -105,6 +108,49 @@ try {
 // $encrypted = $se->encrypt($string);
 // $decrypted = $se->decrypt($encrypted);
 
+echo "<hr>";
+print "<h2>Asymmetric Encryption</h2>";
+
+$key_pair = CreateKey::createKeyPair();
+$public_key = CreateKey::getPublicKey($key_pair);
+
+$string = "I am some asymmetric secret";
+print "Message: " . $string . "<br>";
+$encrypted = sodium_crypto_box_seal($string, CreateKey::hex2bin($public_key));
+$message = sodium_bin2base64($encrypted, SODIUM_BASE64_VARIANT_ORIGINAL);
+print "Encrypted PL: " . $message . "<br>";
+$result = sodium_base642bin($message, SODIUM_BASE64_VARIANT_ORIGINAL);
+$decrypted = sodium_crypto_box_seal_open($result, CreateKey::hex2bin($key_pair));
+print "Decrypted PL: " . $decrypted . "<br>";
+
+$encrypted = AsymmetricAnonymousEncryption::encryptKey($string, $public_key);
+print "Encrypted ST: " . $encrypted . "<br>";
+$decrypted = AsymmetricAnonymousEncryption::decryptKey($encrypted, $key_pair);
+print "Decrypted ST: " . $decrypted . "<br>";
+
+$aa_crypt = new AsymmetricAnonymousEncryption($key_pair, $public_key);
+$encrypted = $aa_crypt->encrypt($string);
+print "Encrypted: " . $encrypted . "<br>";
+$decrypted = $aa_crypt->decrypt($encrypted);
+print "Decrypted: " . $decrypted . "<br>";
+
+print "Base64 encode: " . base64_encode('Some text here') . "<Br>";
+
+/// this has to fail
+$crypt = new AsymmetricAnonymousEncryption();
+$crypt->setPublicKey(CreateKey::getPublicKey(CreateKey::createKeyPair()));
+print "Public Key: " . $crypt->getPublicKey() . "<br>";
+try {
+	$crypt->setPublicKey(CreateKey::createKeyPair());
+} catch (RangeException $e) {
+	print "Invalid range: <pre>$e</pre>";
+}
+try {
+	$crypt->setKeyPair(CreateKey::getPublicKey(CreateKey::createKeyPair()));
+} catch (RangeException $e) {
+	print "Invalid range: <pre>$e</pre>";
+}
+
 print "</body></html>";
 
 // __END__

www/admin/class_test.error_msg.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -40,6 +40,8 @@ print "Log ERROR: " . $log->prAr($em->getFlagLogError()) . "<br>";
 print "FN: " . ml::fromName('Affe')->name . "<br>";
 print "NU: " . ml::fromValue(100)->name . "<br>";
 print "NU: " . ml::fromValue(1000)->name . "<br>";
+print "OK.: " . ml::ok->name . "<br>";
+print "OK^: " . ml::fromName('OK')->name . "<br>";
 
 $em->setErrorMsg('123', 'error', 'msg this is bad, auto logged if debug');
 $em->setErrorMsg('123', 'error', 'msg this is bad, auto logged if debug', 'target-id', 'other-style');
@@ -56,6 +58,14 @@ $em->setErrorMsg('100-2', 'error', 'Input wring', jump_target:['target' => 'foo-
 $em->setMessage('error', 'I have no id set', jump_target:['target' => 'bar-123', 'info' => 'Jump Bar']);
 $em->setMessage('error', 'Jump empty', jump_target:['target' => 'bar-empty']);
 
+function inLine(\CoreLibs\Logging\ErrorMessage $em): void
+{
+	$em->log->error('Direct log before from ', context:['function' => __FUNCTION__]);
+	$em->setMessage('error', 'Inline call', context:['test' => 'inLine Function']);
+	$em->log->error('Direct log from ', context:['function' => __FUNCTION__]);
+}
+inLine($em);
+
 print "ErrorsLast: <pre>" . $log->prAr($em->getLastErrorMsg()) . "</pre>";
 print "ErrorsIds: <pre>" . $log->prAr($em->getErrorIds()) . "</pre>";
 print "Errors: <pre>" . $log->prAr($em->getErrorMsg()) . "</pre>";

www/admin/class_test.file.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.hash.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -19,6 +19,7 @@ $LOG_FILE_ID = 'classTest-hash';
 ob_end_flush();
 
 use CoreLibs\Create\Hash;
+use CoreLibs\Security\CreateKey;
 
 $log = new CoreLibs\Logging\Logging([
 	'log_folder' => BASE . LOG,
@@ -38,28 +39,66 @@ print '<div><h1>' . $PAGE_NAME . '</h1></div>';
 
 $to_crc = 'Some text block';
 // static
-print "S::__CRC32B: $to_crc: " . $hash_class::__crc32b($to_crc) . "<br>";
-print "S::__SHA1SHORT(off): $to_crc: " . $hash_class::__sha1short($to_crc) . "<br>";
-print "S::__SHA1SHORT(on): $to_crc: " . $hash_class::__sha1short($to_crc, true) . "<br>";
-print "S::__hash(d): " . $to_crc . "/"
-	. Hash::STANDARD_HASH_SHORT . ": " . $hash_class::__hash($to_crc) . "<br>";
-foreach (['adler32', 'fnv132', 'fnv1a32', 'joaat', 'sha512'] as $__hash_c) {
-	print "S::__hash($__hash_c): $to_crc: " . $hash_class::__hash($to_crc, $__hash_c) . "<br>";
+print "S::__CRC32B: $to_crc: " . Hash::__crc32b($to_crc) . "<br>";
+// print "S::__SHA1SHORT(off): $to_crc: " . Hash::__sha1short($to_crc) . "<br>";
+print "S::hashShort(__sha1Short replace): $to_crc: " . Hash::hashShort($to_crc) . "<br>";
+// print "S::__SHA1SHORT(on): $to_crc: " . Hash::__sha1short($to_crc, true) . "<br>";
+print "S::sha1Short(__sha1Short replace): $to_crc: " . Hash::sha1Short($to_crc) . "<br>";
+// print "S::__hash(d): " . $to_crc . "/"
+// 	. Hash::STANDARD_HASH_SHORT . ": " . $hash_class::__hash($to_crc) . "<br>";
+$to_crc_list = [
+	'Some text block',
+	'Some String Text',
+	'any string',
+];
+foreach ($to_crc_list as $__to_crc) {
+	foreach (['adler32', 'fnv132', 'fnv1a32', 'joaat', 'ripemd160', 'sha256', 'sha512'] as $__hash_c) {
+		print "Hash::hash($__hash_c): $__to_crc: " . Hash::hash($to_crc, $__hash_c) . "<br>";
+	}
 }
 // static use
 print "U-S::__CRC32B: $to_crc: " . Hash::__crc32b($to_crc) . "<br>";
 
 echo "<hr>";
 $text = 'Some String Text';
+// $text = 'any string';
 $type = 'crc32b';
 print "Hash: " . $type . ": " . hash($type, $text) . "<br>";
-print "Class: " . $type . ": " . Hash::__hash($text, $type) . "<br>";
+// print "Class (old): " . $type . ": " . Hash::__hash($text, $type) . "<br>";
+print "Class (new): " . $type . ": " . Hash::hash($text, $type) . "<br>";
 
 echo "<hr>";
-print "<br>CURRENT STANDARD_HASH_SHORT: " . Hash::STANDARD_HASH_SHORT . "<br>";
-print "<br>CURRENT STANDARD_HASH_LONG: " . Hash::STANDARD_HASH_LONG . "<br>";
-print "HASH SHORT: " . $to_crc . ": " . Hash::__hash($to_crc) . "<br>";
-print "HASH LONG: " . $to_crc . ": " . Hash::__hashLong($to_crc) . "<br>";
+print "CURRENT STANDARD_HASH_SHORT: " . Hash::STANDARD_HASH_SHORT . "<br>";
+print "CURRENT STANDARD_HASH_LONG: " . Hash::STANDARD_HASH_LONG . "<br>";
+print "CURRENT STANDARD_HASH: " . Hash::STANDARD_HASH . "<br>";
+print "HASH SHORT: " . $to_crc . ": " . Hash::hashShort($to_crc) . "<br>";
+print "HASH LONG: " . $to_crc . ": " . Hash::hashLong($to_crc) . "<br>";
+print "HASH DEFAULT: " . $to_crc . ": " . Hash::hashStd($to_crc) . "<br>";
+
+echo "<hr>";
+$key = CreateKey::generateRandomKey();
+$key = "FIX KEY";
+print "Secret Key: " . $key . "<br>";
+print "HASHMAC DEFAULT (fix): " . $to_crc . ": " . Hash::hashHmac($to_crc, $key) . "<br>";
+$key = CreateKey::generateRandomKey();
+print "Secret Key: " . $key . "<br>";
+print "HASHMAC DEFAULT (random): " . $to_crc . ": " . Hash::hashHmac($to_crc, $key) . "<br>";
+
+echo "<hr>";
+$hash_types = ['crc32b', 'sha256', 'invalid'];
+foreach ($hash_types as $hash_type) {
+	echo "<b>Checking $hash_type:</b><br>";
+	if (Hash::isValidHashType($hash_type)) {
+		echo "hash type: $hash_type is valid<br>";
+	} else {
+		echo "hash type: $hash_type is INVALID<br>";
+	}
+	if (Hash::isValidHashHmacType($hash_type)) {
+		echo "hash hmac type: $hash_type is valid<br>";
+	} else {
+		echo "hash hmac type: $hash_type is INVALID<br>";
+	}
+}
 
 // print "UNIQU ID SHORT : " . Hash::__uniqId() . "<br>";
 // print "UNIQU ID LONG : " . Hash::__uniqIdLong() . "<br>";

www/admin/class_test.html.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.html_build.block.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.html_build.element.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.html_build.replace.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.image.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.json.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -46,6 +46,7 @@ $json = '["f: {b"""ar}]';
 $output = Json::jsonConvertToArray($json);
 print "S::E-JSON: $json: " . DgS::printAr($output) . "<br>";
 print "S::E-JSON ERROR: " . Json::jsonGetLastError() . ": " . Json::jsonGetLastError(true) . "<br>";
+print "S::E Validate: " . Json::jsonValidate($json) . ": " . Json::jsonGetLastError(true) . "<br>";
 
 // direct
 $json = '{"direct": "static function call"}';
@@ -58,6 +59,22 @@ $output = $json_class::jsonConvertToArray($json);
 print "J/S::E-JSON: $json: " . DgS::printAr($output) . "<br>";
 print "J/S::E-JSON ERROR: " . $json_class::jsonGetLastError() . ": " . $json_class::jsonGetLastError(true) . "<br>";
 
+$json = '{"valid":"json","invalid":"\xB1\x31"}';
+$json = '{"valid":"json","invalid":"abc\x80def"}';
+$output_no_flag = Json::jsonConvertToArray($json);
+print "No Flag JSON: $json: " . DgS::printAr($output_no_flag) . "<br>";
+print "No Flag JSON ERROR: " . Json::jsonGetLastError() . ": " . Json::jsonGetLastError(true) . "<br>";
+$output_flag = Json::jsonConvertToArray($json, flags:JSON_INVALID_UTF8_IGNORE);
+print "No Flag JSON: $json: " . DgS::printAr($output_flag) . "<br>";
+print "No Flag JSON ERROR: " . Json::jsonGetLastError() . ": " . Json::jsonGetLastError(true) . "<br>";
+$output_raw = json_decode($json, true, flags:JSON_INVALID_UTF8_IGNORE);
+print "No Flag JSON RAW (F-1): $json: " . DgS::printAr($output_raw) . "<br>";
+$output_raw = json_decode($json, true, flags:JSON_INVALID_UTF8_SUBSTITUTE);
+print "No Flag JSON RAW (F-2): $json: " . DgS::printAr($output_raw) . "<br>";
+$output_raw = json_decode($json, true);
+print "No Flag JSON RAW: $json: " . DgS::printAr($output_raw) . "<br>";
+
+
 // $json = '{"foo": "bar"}';
 // $output = Jason::jsonConvertToArray($json);
 // print "S::JSON: $json: " . DgS::printAr($output) . "<br>";
@@ -67,6 +84,8 @@ print "J/S::E-JSON ERROR: " . $json_class::jsonGetLastError() . ": " . $json_cla
 $array = ['foo' => 'bar'];
 $output = Json::jsonConvertArrayTo($array);
 print "S::JSON: " . DgS::printAr($array) . " => " . $output . "<br>";
+$array = ['foo' => 'bar', 'sub' => ['other' => 'this', 'foo' => 'bar', 'set' => [12, 34, true]]];
+print "Pretty: <pre>" . Json::jsonPrettyPrint($array) . "</pre><br>";
 
 print "</body></html>";
 

www/admin/class_test.lang.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.logging.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -82,6 +82,7 @@ $log->error('Cannot process data', ['error' => 'log']);
 $log->critical('Critical message', ['critical' => 'log']);
 $log->alert('Alert message', ['Alert' => 'log']);
 $log->emergency('Emergency message', ['Emergency' => 'log']);
+error_log('TRIGGER ERROR LOG MANUAL: Emergency');
 print "Log File: " . $log->getLogFile() . "<br>";
 
 $log->setLogFlag(Flag::per_run);
@@ -120,6 +121,12 @@ Class TestP
 	public function test(): void
 	{
 		$this->log->info('TestL::test call');
+		$this->subCall();
+	}
+
+	public function subCall(): void
+	{
+		$this->log->info('TestL::sub_call call');
 	}
 }
 

www/admin/class_test.login.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -31,6 +31,7 @@ $log = new CoreLibs\Logging\Logging([
 	'log_per_date' => true,
 ]);
 $db = new CoreLibs\DB\IO(DB_CONFIG, $log);
+$log->setLogFileId('classTest-login-override');
 $login = new CoreLibs\ACL\Login(
 	$db,
 	$log,
@@ -45,6 +46,7 @@ $login = new CoreLibs\ACL\Login(
 		'locale_path' => BASE . INCLUDES . LOCALE,
 	]
 );
+$log->setLogFileId($LOG_FILE_ID);
 ob_end_flush();
 $login->loginMainCall();
 
@@ -117,7 +119,7 @@ if (isset($login->loginGetAcl()['unit'])) {
 	if ($login->loginCheckEditAccessCuid($edit_access_cuid)) {
 		print "Set new:" . $edit_access_cuid . "<br>";
 	} else {
-		print "Load default unit id: " . $login->loginGetAcl()['unit_id'] . "<br>";
+		print "Load default unit id: " . $login->loginGetAcl()['unit_cuid'] . "<br>";
 	}
 } else {
 	print "Something went wrong with the login<br>";
@@ -127,6 +129,12 @@ if (isset($login->loginGetAcl()['unit'])) {
 // IP check: 'REMOTE_ADDR', 'HTTP_X_FORWARDED_FOR', 'CLIENT_IP' in _SERVER
 // Agent check: 'HTTP_USER_AGENT'
 
+print "<hr>";
+print "PAGE lookup:<br>";
+$file_name = 'test_edit_base.php';
+print "Access to '$file_name': " . $log->prAr($login->loginPageAccessAllowed($file_name)) . "<br>";
+$file_name = 'i_do_not_exists.php';
+print "Access to '$file_name': " . $log->prAr($login->loginPageAccessAllowed($file_name)) . "<br>";
 
 echo "<hr>";
 print "SESSION: " . Support::printAr($_SESSION) . "<br>";
@@ -140,4 +148,18 @@ $login->writeLog(
 	write_type:'JSON'
 );
 
+echo "<hr>";
+print "<h3>Legacy Lookups</h3>";
+
+$edit_access_id = 1;
+$edit_access_cuid = $login->loginGetEditAccessCuidFromId($edit_access_id);
+$edit_access_id_rev = null;
+if (is_string($edit_access_cuid)) {
+	$edit_access_id_rev = $login->loginGetEditAccessIdFromCuid($edit_access_cuid);
+}
+print "EA ID: " . $edit_access_id . "<br>";
+print "EA CUID: " . $log->prAr($edit_access_cuid) . "<br>";
+print "REV EA CUID: " . $log->prAr($edit_access_id_rev) . "<br>";
+$log->info('This is a test');
+
 print "</body></html>";

www/admin/class_test.math.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.memoryusage.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.mime.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.output.form.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -29,15 +29,17 @@ $table_arrays = [];
 $table_arrays[\CoreLibs\Get\System::getPageName(1)] = [
 	// form fields mtaching up with db fields
 	'table_array' => [
+		'foo',
+		'bar'
 	],
 	// laod query
-	'load_query' => '',
+	'load_query' => 'SELECT uuid_nr, foo, bar FROM test',
 	// database table to load from
-	'table_name' => '',
+	'table_name' => 'test',
 	// for load dro pdown, format output
 	'show_fields' => [
 		[
-			'name' => 'name'
+			'name' => 'foo'
 		],
 		[
 			'name' => 'enabled',

www/admin/class_test.password.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -37,6 +37,8 @@ print "<body>";
 print '<div><a href="class_test.php">Class Test Master</a></div>';
 print '<div><h1>' . $PAGE_NAME . '</h1></div>';
 
+print "PHP Version: " . PHP_VERSION . "<br>";
+
 $password = 'something1234';
 $enc_password = $_password->passwordSet($password);
 print "PASSWORD: $password: " . $enc_password . "<br>";
@@ -51,6 +53,20 @@ print "PASSWORD REHASH: " . (string)$password_class::passwordRehashCheck($enc_pa
 // direct static
 print "S::PASSWORD VERFIY: " . (string)PwdChk::passwordVerify($password, $enc_password) . "<br>";
 
+if (PHP_VERSION_ID < 80400) {
+	$rehash_test = '$2y$10$EgWJ2WE73DWi.hIyFRCdpejLXTvHbmTK3LEOclO1tAvXAXUNuUS4W';
+	$rehash_test_throw = '$2y$12$EgWJ2WE73DWi.hIyFRCdpejLXTvHbmTK3LEOclO1tAvXAXUNuUS4W';
+} else {
+	$rehash_test = '$2y$12$EgWJ2WE73DWi.hIyFRCdpejLXTvHbmTK3LEOclO1tAvXAXUNuUS4W';
+	$rehash_test_throw = '$2y$10$EgWJ2WE73DWi.hIyFRCdpejLXTvHbmTK3LEOclO1tAvXAXUNuUS4W';
+}
+if (PwdChk::passwordRehashCheck($rehash_test)) {
+	print "Bad password [BAD]<br>";
+}
+if (PwdChk::passwordRehashCheck($rehash_test_throw)) {
+	print "Bad password [OK]<br>";
+}
+
 print "</body></html>";
 
 // __END__

www/admin/class_test.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -95,6 +95,7 @@ $test_files = [
 	'class_test.db.dbReturn.php' => 'Class Test: DB dbReturn',
 	'class_test.db.single.php' => 'Class Test: DB single query tests',
 	'class_test.db.convert-placeholder.php' => 'Class Test: DB convert placeholder',
+	'class_test.db.encryption.php' => 'Class Test: DB pgcrypto',
 	'class_test.convert.colors.php' => 'Class Test: CONVERT COLORS',
 	'class_test.check.colors.php' => 'Class Test: CHECK COLORS',
 	'class_test.mime.php' => 'Class Test: MIME',
@@ -141,6 +142,7 @@ $test_files = [
 	'class_test.error_msg.php' => 'Class Test: ERROR MSG',
 	'class_test.url-requests.curl.php' => 'Class Test: URL REQUESTS: CURL',
 	'subfolder/class_test.config.direct.php' => 'Class Test: CONFIG DIRECT SUB',
+	'class_test.deprecated.helper.php' => 'Class Test: DEPRECATED HELPERS',
 ];
 
 asort($test_files);

www/admin/class_test.phpv.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -28,8 +28,6 @@ $log = new CoreLibs\Logging\Logging([
 $_phpv = new CoreLibs\Check\PhpVersion();
 $phpv_class = 'CoreLibs\Check\PhpVersion';
 
-// define a list of from to color sets for conversion test
-
 $PAGE_NAME = 'TEST CLASS: PHP VERSION';
 print "<!DOCTYPE html>";
 print "<html><head><title>" . $PAGE_NAME . "</title></head>";

www/admin/class_test.randomkey.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -34,17 +34,40 @@ print "<body>";
 print '<div><a href="class_test.php">Class Test Master</a></div>';
 print '<div><h1>' . $PAGE_NAME . '</h1></div>';
 
+$output = RandomKey::randomKeyGen(
+	12,
+	[
+		0 => 'A', 1 => 'B', 2 => 'C', 3 => 'D', 4 => 'E', 5 => 'F', 6 => 'G', 7 => 'H', 8 => 'I', 9 => 'J', 10 => 'K',
+		11 => 'L', 12 => 'M', 13 => 'N', 14 => 'O', 15 => 'P', 16 => 'Q', 17 => 'R', 18 => 'S', 19 => 'T', 20 => 'U',
+		21 => 'V', 22 => 'W', 23 => 'X', 24 => 'Y', 25 => 'Z', 26 => 'a', 27 => 'b', 28 => 'c', 29 => 'd', 30 => 'e',
+		31 => 'f', 32 => 'g', 33 => 'h', 34 => 'i', 35 => 'j', 36 => 'k', 37 => 'l', 38 => 'm', 39 => 'n', 40 => 'o',
+		41 => 'p', 42 => 'q', 43 => 'r', 44 => 's', 45 => 't', 46 => 'u', 47 => 'v', 48 => 'w', 49 => 'x', 50 => 'y',
+		51 => 'z', 52 => '0', 53 => '1', 54 => '2', 55 => '3', 56 => '4', 57 => '5', 58 => '6', 59 => '7', 60 => '8',
+		61 => '9'
+	]
+);
+print "CUSTOM OUTPUT: " . $output . "<br>";
+
 $key_length = 10;
 $key_length_b = 5;
 $key_lenght_long = 64;
 print "S::RANDOMKEYGEN(auto): " . RandomKey::randomKeyGen() . "<br>";
-print "S::SETRANDOMKEYLENGTH($key_length): " . RandomKey::setRandomKeyLength($key_length) . "<br>";
-print "S::RANDOMKEYGEN($key_length): " . RandomKey::randomKeyGen() . "<br>";
+// print "S::SETRANDOMKEYLENGTH($key_length): " . RandomKey::setRandomKeyLength($key_length) . "<br>";
+print "S::RANDOMKEYGEN($key_length): " . RandomKey::randomKeyGen($key_length) . "<br>";
 print "S::RANDOMKEYGEN($key_length_b): " . RandomKey::randomKeyGen($key_length_b) . "<br>";
-print "S::RANDOMKEYGEN($key_length): " . RandomKey::randomKeyGen() . "<br>";
+print "S::RANDOMKEYGEN($key_length): " . RandomKey::randomKeyGen($key_length) . "<br>";
 print "S::RANDOMKEYGEN($key_lenght_long): " . RandomKey::randomKeyGen($key_lenght_long) . "<br>";
+print "S::RANDOMKEYGEN($key_lenght_long, list data): "
+	. RandomKey::randomKeyGen($key_lenght_long, ['A', 'B', 'C'], ['7', '8', '9']) . "<br>";
+print "S::RANDOMKEYGEN(auto): " . RandomKey::randomKeyGen() . "<br>";
+print "===<Br>";
 $_array = new CoreLibs\Create\RandomKey();
-print "C->RANDOMKEYGEN(auto): " . $_array->randomKeyGen() . "<br>";
+print "C->RANDOMKEYGEN(default): " . $_array->randomKeyGen() . "<br>";
+print "===<Br>";
+// CHANGE key characters
+$_array = new CoreLibs\Create\RandomKey(['A', 'F', 'B'], ['1', '5', '9']);
+print "C->RANDOMKEYGEN(pre set): " . $_array->randomKeyGen() . "<br>";
+
 
 print "</body></html>";
 

www/admin/class_test.readenvfile.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.runningtime.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.session.php

@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 /**
  * Undocumented function
@@ -86,8 +86,10 @@ if (!isset($_SESSION['counter'])) {
 $_SESSION['counter']++;
 print "[READ] A " . $var . ": " . ($_SESSION[$var] ?? '{UNSET}') . "<br>";
 $_SESSION[$var] = $value;
+/** @phpstan-ignore-next-line nullCoalesce.offset */
 print "[READ] B " . $var . ": " . ($_SESSION[$var] ?? '{UNSET}') . "<br>";
 print "[READ] Confirm " . $var . " is " . $value . ": "
+/** @phpstan-ignore-next-line equal.alwaysTrue, nullCoalesce.offset */
 	. (($_SESSION[$var] ?? '') == $value ? 'Matching' : 'Not matching') . "<br>";
 
 // test set wrappers methods

www/admin/class_test.session.read.php

@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 /**
  * Undocumented function

www/admin/class_test.smarty.php

@@ -4,9 +4,11 @@
  * @phan-file-suppress PhanTypeSuspiciousStringExpression
  */
 
+// FIXME: Smarty Class must be updated for PHP 8.4
+
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -33,6 +35,7 @@ $l10n = new \CoreLibs\Language\L10n(
 );
 $smarty = new CoreLibs\Template\SmartyExtend(
 	$l10n,
+	$log,
 	CACHE_ID,
 	COMPILE_ID,
 );
@@ -45,6 +48,7 @@ $adm = new CoreLibs\Admin\Backend(
 );
 $adm->DATA['adm_set'] = 'SET from admin class';
 
+
 $PAGE_NAME = 'TEST CLASS: SMARTY';
 print "<!DOCTYPE html>";
 print "<html><head><title>" . $PAGE_NAME . "</title></head>";

www/admin/class_test.strings.php

@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -14,6 +14,9 @@ require 'config.php';
 $LOG_FILE_ID = 'classTest-string';
 ob_end_flush();
 
+use CoreLibs\Convert\Strings;
+use CoreLibs\Debug\Support as DgS;
+
 $log = new CoreLibs\Logging\Logging([
 	'log_folder' => BASE . LOG,
 	'log_file_id' => $LOG_FILE_ID,
@@ -29,6 +32,7 @@ print '<div><a href="class_test.php">Class Test Master</a></div>';
 print '<div><h1>' . $PAGE_NAME . '</h1></div>';
 
 $split = '4-4-4';
+$split_length = 4;
 $test_strings = [
 	'13',
 	'1234',
@@ -40,20 +44,59 @@ $test_strings = [
 ];
 
 foreach ($test_strings as $string) {
-	print "Convert: $string with $split to: "
-		. \CoreLibs\Convert\Strings::splitFormatString($string, $split)
+	print "A) Convert: $string with $split to: "
+		. Strings::splitFormatString($string, $split)
 		. "<br>";
+	try {
+		print "B) Convert: $string with $split_length to: "
+			. Strings::splitFormatStringFixed($string, $split_length)
+			. "<br>";
+	} catch (Exception $e) {
+		print "Split not possible: " . $e->getMessage() . "<br>";
+	}
 }
 
 $split = '2_2';
+$split_length = 2;
 $string = '1234';
-print "Convert: $string with $split to: "
-	. \CoreLibs\Convert\Strings::splitFormatString($string, $split)
+print "A) Convert: $string with $split to: "
+	. Strings::splitFormatString($string, $split)
+	. "<br>";
+print "B) Convert: $string with $split_length to: "
+	. Strings::splitFormatStringFixed($string, $split_length, "_")
 	. "<br>";
 $split = '2-2';
 $string = 'あいうえ';
-print "Convert: $string with $split to: "
-	. \CoreLibs\Convert\Strings::splitFormatString($string, $split)
+try {
+	print "Convert: $string with $split to: "
+		. Strings::splitFormatString($string, $split)
+		. "<br>";
+} catch (\Exception $e) {
+	print "Cannot split string: " . $e->getMessage() . "<br>";
+}
+print "B) Convert: $string with $split_length to: "
+	. Strings::splitFormatStringFixed($string, $split_length, "-")
+	. "<br>";
+
+$string = 'ABCD12345568ABC13';
+$format = '2-4_5-2#4';
+$output = 'AB-CD12_34556-8A#BC13';
+print "A) Convert: $string with $format to: "
+	. Strings::splitFormatString($string, $format)
+	. "<br>";
+
+// try other split calls
+$string = "ABCDE";
+$split_length = 2;
+$split_char = "-=-";
+print "Convert: $string with $split_length / $split_char to: "
+	. Strings::splitFormatStringFixed($string, $split_length, $split_char)
+	. "<br>";
+$string = "あいうえお";
+$split_length = 2;
+$split_char = "-=-";
+print "Convert: $string with $split_length / $split_char to: "
+	. Strings::splitFormatStringFixed($string, $split_length, $split_char)
 	. "<br>";
 
 $test_splits = [
@@ -63,7 +106,70 @@ $test_splits = [
 	'2-3-4',
 ];
 foreach ($test_splits as $split) {
-	print "$split with count: " . \CoreLibs\Convert\Strings::countSplitParts($split) . "<br>";
+	print "$split with count: " . Strings::countSplitParts($split) . "<br>";
+}
+
+// check char list in list
+$needle = "abc";
+$haystack = "abcdefg";
+print "Needle: " . $needle . ", Haysteck: " . $haystack . ": "
+	. DgS::prBl(Strings::allCharsInSet($needle, $haystack)) . "<br>";
+$needle = "abcz";
+print "Needle: " . $needle . ", Haysteck: " . $haystack . ": "
+	. DgS::prBl(Strings::allCharsInSet($needle, $haystack)) . "<br>";
+
+print "Combined strings A: "
+	. Strings::buildCharStringFromLists(['A', 'B', 'C'], ['0', '1', '2']) . "<br>";
+print "Combined strings B: "
+	. Strings::buildCharStringFromLists([['F'], ['G'], 'H'], [['5', ['6']], ['0'], '1', '2']) . "<br>";
+print "Combined strings C: "
+	. Strings::buildCharStringFromLists([
+		0 => 'A', 1 => 'B', 2 => 'C', 3 => 'D', 4 => 'E', 5 => 'F', 6 => 'G', 7 => 'H', 8 => 'I', 9 => 'J', 10 => 'K',
+		11 => 'L', 12 => 'M', 13 => 'N', 14 => 'O', 15 => 'P', 16 => 'Q', 17 => 'R', 18 => 'S', 19 => 'T', 20 => 'U',
+		21 => 'V', 22 => 'W', 23 => 'X', 24 => 'Y', 25 => 'Z', 26 => 'a', 27 => 'b', 28 => 'c', 29 => 'd', 30 => 'e',
+		31 => 'f', 32 => 'g', 33 => 'h', 34 => 'i', 35 => 'j', 36 => 'k', 37 => 'l', 38 => 'm', 39 => 'n', 40 => 'o',
+		41 => 'p', 42 => 'q', 43 => 'r', 44 => 's', 45 => 't', 46 => 'u', 47 => 'v', 48 => 'w', 49 => 'x', 50 => 'y',
+		51 => 'z', 52 => '0', 53 => '1', 54 => '2', 55 => '3', 56 => '4', 57 => '5', 58 => '6', 59 => '7', 60 => '8',
+		61 => '9'
+	]) . "<br>";
+
+$input_string = "AaBbCc";
+print "Unique: " . Strings::removeDuplicates($input_string) . "<br>";
+print "Unique: " . Strings::removeDuplicates(strtolower($input_string)) . "<br>";
+
+$regex_string = "/^[A-z]$/";
+print "Regex is: " . $regex_string . ": " . DgS::prBl(Strings::isValidRegex($regex_string)) . "<br>";
+$regex_string = "'//test{//'";
+print "Regex is: " . $regex_string . ": " . DgS::prBl(Strings::isValidRegex($regex_string)) . "<br>";
+print "Regex is: " . $regex_string . ": " . DgS::printAr(Strings::validateRegex($regex_string)) . "<br>";
+$regex_string = "/^[A-z";
+print "Regex is: " . $regex_string . ": " . DgS::prBl(Strings::isValidRegex($regex_string)) . "<br>";
+print "[A] LAST PREGE ERROR: " . preg_last_error() . " -> "
+	. (Strings::PREG_ERROR_MESSAGES[preg_last_error()] ?? '-') . "<br>";
+$preg_error = Strings::isValidRegex($regex_string);
+print "[B] LAST PREGE ERROR: " . preg_last_error() . " -> "
+	. Strings::getLastRegexErrorString() . " -> " . preg_last_error_msg() . "<br>";
+
+$base_strings = [
+	'abcddfff',
+	'A-Z',
+	'a-z',
+	'A-Za-z',
+	'A-Df-g',
+	'A-D0-9',
+	'D-A7-0',
+	'A-FB-G',
+	'0-9',
+	'あ-お',
+	'ア-オ',
+];
+foreach ($base_strings as $string) {
+	try {
+		$parsed = Strings::parseCharacterRanges($string);
+		print "Parsed ranges for '$string': " . DgS::printAr($parsed) . "<br>";
+	} catch (\InvalidArgumentException $e) {
+		print "Error parsing ranges for '$string': " . $e->getMessage() . "<br>";
+	}
 }
 
 print "</body></html>";

www/admin/class_test.system.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.token.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.uids.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 
@@ -56,6 +56,8 @@ print "UNIQU ID LONG : " . Uids::uniqIdLong() . "<br>";
 $uuidv4 = Uids::uuidv4();
 if (!Uids::validateUuuidv4($uuidv4)) {
 	print "Invalid UUIDv4: " . $uuidv4 . "<br>";
+} else {
+	print "Valid UUIDv4: " . $uuidv4 . "<br>";
 }
 if (!Uids::validateUuuidv4("foobar")) {
 	print "Invalid UUIDv4: hard coded<Br>";

www/admin/class_test.url-requests.curl.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/class_test.varistype.php

@@ -6,7 +6,7 @@
 
 declare(strict_types=1);
 
-error_reporting(E_ALL | E_STRICT | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
+error_reporting(E_ALL | E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
 
 ob_start();
 

www/admin/layout/javascript/edit.jq.js

@@ -1,7 +1,9 @@
-/* general edit javascript */
-/* jquery version */
+/*
+general edit javascript
+jquery version
+*/
 
-/* jshint esversion: 11 */
+/** @deprecated Do not use this anymore, use utils.js or utils.min.js */
 
 /* global i18n */
 
@@ -18,11 +20,28 @@ if (!DEBUG) {
 var GL_OB_S = 100;
 var GL_OB_BASE = 100;
 
+/**
+ * Gets html element or throws an error
+ * @param {string} el_id Element ID to get
+ * @returns {HTMLElement}
+ * @throws Error
+ * @deprecated use utils.js
+ */
+function loadEl(el_id)
+{
+	let el = document.getElementById(el_id);
+	if (el === null) {
+		throw new Error('Cannot find: ' + el_id);
+	}
+	return el;
+}
+
 /**
  * opens a popup window with winName and given features (string)
  * @param {String} theURL   the url
  * @param {String} winName  window name
  * @param {Object} features popup features
+ * @deprecated use utils.js
  */
 function pop(theURL, winName, features) // eslint-disable-line no-unused-vars
 {
@@ -33,6 +52,7 @@ function pop(theURL, winName, features) // eslint-disable-line no-unused-vars
 /**
  * automatically resize a text area based on the amount of lines in it
  * @param {string} ta_id element id
+ * @deprecated use utils.js
  */
 function expandTA(ta_id) // eslint-disable-line no-unused-vars
 {
@@ -58,6 +78,7 @@ function expandTA(ta_id) // eslint-disable-line no-unused-vars
 /**
  * wrapper to get the real window size for the current browser window
  * @return {Object} object with width/height
+ * @deprecated use utils.js
  */
 function getWindowSize()
 {
@@ -73,6 +94,7 @@ function getWindowSize()
 /**
  * wrapper to get the correct scroll offset
  * @return {Object} object with x/y px
+ * @deprecated use utils.js
  */
 function getScrollOffset()
 {
@@ -88,6 +110,7 @@ function getScrollOffset()
 /**
  * wrapper to get the correct scroll offset for opener page (from popup)
  * @return {Object} object with x/y px
+ * @deprecated use utils.js
  */
 function getScrollOffsetOpener() // eslint-disable-line no-unused-vars
 {
@@ -105,13 +128,14 @@ function getScrollOffsetOpener() // eslint-disable-line no-unused-vars
  * @param {String}  id   element to center
  * @param {Boolean} left if true centers to the middle from the left
  * @param {Boolean} top  if true centers to the middle from the top
+ * @deprecated use utils.js
  */
 function setCenter(id, left, top)
 {
 	// get size of id
 	var dimensions = {
-		height: $('#' + id).height(),
-		width: $('#' + id).width()
+		height: $('#' + id).height() ?? 0,
+		width: $('#' + id).width() ?? 0
 	};
 	var type = $('#' + id).css('position');
 	var viewport = getWindowSize();
@@ -122,14 +146,14 @@ function setCenter(id, left, top)
 	// console.log('Left: %s, Top: %s (%s)', parseInt((viewport.width / 2) - (dimensions.width / 2) + offset.left), parseInt((viewport.height / 2) - (dimensions.height / 2) + offset.top), parseInt((viewport.height / 2) - (dimensions.height / 2)));
 	if (left) {
 		$('#' + id).css({
-			left: parseInt((viewport.width / 2) - (dimensions.width / 2) + offset.left) + 'px'
+			left: ((viewport.width / 2) - (dimensions.width / 2) + offset.left) + 'px'
 		});
 	}
 	if (top) {
 		// if we have fixed, we do not add the offset, else it moves out of the screen
 		var top_pos = type == 'fixed' ?
-			parseInt((viewport.height / 2) - (dimensions.height / 2)) :
-			parseInt((viewport.height / 2) - (dimensions.height / 2) + offset.top);
+			(viewport.height / 2) - (dimensions.height / 2) :
+			(viewport.height / 2) - (dimensions.height / 2) + offset.top;
 		$('#' + id).css({
 			top: top_pos + 'px'
 		});
@@ -142,6 +166,7 @@ function setCenter(id, left, top)
  * @param {Number} [offset=0]         offset from top, default is 0 (px)
  * @param {Number} [duration=500]     animation time, default 500ms
  * @param {String} [base='body,html'] base element for offset scroll
+ * @deprecated use utils.js
  */
 function goToPos(element, offset = 0, duration = 500, base = 'body,html') // eslint-disable-line no-unused-vars
 {
@@ -156,11 +181,25 @@ function goToPos(element, offset = 0, duration = 500, base = 'body,html') // esl
 	}
 }
 
+/**
+ * go to element, scroll
+ * non jquery
+ * @param {string} target
+ * @deprecated use utils.js
+*/
+function goTo(target) // eslint-disable-line no-unused-vars
+{
+	loadEl(target).scrollIntoView({
+		behavior: 'smooth'
+	});
+}
+
 /**
  * uses the i18n object created in the translation template
  * that is filled from gettext in PHP
  * @param  {String} string text to translate
  * @return {String}        translated text (based on PHP selected language)
+ * @deprecated use utils.js
  */
 function __(string)
 {
@@ -177,37 +216,70 @@ function __(string)
  * First, checks if it isn't implemented yet.
  * @param  {String} String.prototype.format string with elements to be replaced
  * @return {String}                         Formated string
+ * @deprecated use utils.js
  */
 if (!String.prototype.format) {
 	String.prototype.format = function()
 	{
-		var args = arguments;
-		return this.replace(/{(\d+)}/g, function(match, number)
-		{
-			return typeof args[number] != 'undefined' ?
-				args[number] :
-				match
-			;
-		});
+		console.error('[DEPRECATED] use formatString');
+		return formatString(this, arguments);
+	};
+}
+
+/**
+ * simple sprintf formater for replace
+ * usage: "{0} is cool, {1} is not".format("Alpha", "Beta");
+ * First, checks if it isn't implemented yet.
+ * @param  {String} string String with {..} entries
+ * @param  {...any} args   List of replacement
+ * @returns {String}       Escaped string
+ * @deprecated use utils.js
+ */
+function formatString(string, ...args)
+{
+	return string.replace(/{(\d+)}/g, function(match, number)
+	{
+		return typeof args[number] != 'undefined' ?
+			args[number] :
+			match
+		;
+	});
+}
+
+/**
+ * round to digits (float)
+ * @param  {Number}  Number.prototype.round Float type number to round
+ * @param  {Number} prec                   Precision to round to
+ * @return {Float}                         Rounded number
+ * @deprecated use utils.js
+ */
+if (Number.prototype.round) {
+	Number.prototype.round = function (prec) {
+		console.error('[DEPRECATED] use roundPrecision');
+		return roundPrecision(this, prec);
 	};
 }
 
 /**
  * round to digits (float)
- * @param  {Float}  Number.prototype.round Float type number to round
- * @param  {Number} prec                   Precision to round to
- * @return {Float}                         Rounded number
+ * @param  {Number} number    Float type number to round
+ * @param  {Number} precision Precision to round to
+ * @return {Number}           Rounded number
+ * @deprecated use utils.js
  */
-if (Number.prototype.round) {
-	Number.prototype.round = function (prec) {
-		return Math.round(this * Math.pow(10, prec)) / Math.pow(10, prec);
-	};
+function roundPrecision(number, precision)
+{
+	if (!isNaN(number) || !isNaN(precision)) {
+		return number;
+	}
+	return Math.round(number * Math.pow(10, precision)) / Math.pow(10, precision);
 }
 
 /**
  * formats flat number 123456 to 123,456
  * @param  {Number} x number to be formated
  * @return {String}   formatted with , in thousands
+ * @deprecated use utils.js
  */
 function numberWithCommas(x) // eslint-disable-line no-unused-vars
 {
@@ -220,6 +292,7 @@ function numberWithCommas(x) // eslint-disable-line no-unused-vars
  * converts line breaks to br
  * @param  {String} string any string
  * @return {String}        string with <br>
+ * @deprecated use utils.js
  */
 function convertLBtoBR(string) // eslint-disable-line no-unused-vars
 {
@@ -228,51 +301,78 @@ function convertLBtoBR(string) // eslint-disable-line no-unused-vars
 
 /**
  * escape HTML string
- * @param  {String} !String.prototype.escapeHTML HTML data string to be escaped
- * @return {String}                              escaped string
+ * @param  {String} String.prototype.escapeHTML HTML data string to be escaped
+ * @return {String}                             escaped string
+ * @deprecated use utils.js
  */
 if (!String.prototype.escapeHTML) {
 	String.prototype.escapeHTML = function() {
-		return this.replace(/[&<>"'/]/g, function (s) {
-			var entityMap = {
-				'&': '&amp;',
-				'<': '&lt;',
-				'>': '&gt;',
-				'"': '&quot;',
-				'\'': '&#39;',
-				'/': '&#x2F;'
-			};
-
-			return entityMap[s];
-		});
+		console.error('[DEPRECATED] use escapeHtml');
+		return escapeHtml(this);
 	};
 }
 
 /**
  * unescape a HTML encoded string
- * @param  {String} !String.prototype.unescapeHTML data with escaped entries
- * @return {String}                                HTML formated string
+ * @param  {String} String.prototype.unescapeHTML data with escaped entries
+ * @return {String}                               HTML formated string
+ * @deprecated use utils.js
  */
 if (!String.prototype.unescapeHTML) {
 	String.prototype.unescapeHTML = function() {
-		return this.replace(/&[#\w]+;/g, function (s) {
-			var entityMap = {
-				'&amp;': '&',
-				'&lt;': '<',
-				'&gt;': '>',
-				'&quot;': '"',
-				'&#39;': '\'',
-				'&#x2F;': '/'
-			};
-
-			return entityMap[s];
-		});
+		console.error('[DEPRECATED] use unescapeHtml');
+		return unescapeHtml(this);
 	};
 }
 
+/**
+ * Escapes HTML in string
+ * @param {String} string Text to escape HTML in
+ * @returns {String}
+ * @deprecated use utils.js
+ */
+function escapeHtml(string)
+{
+	return string.replace(/[&<>"'/]/g, function (s) {
+		var entityMap = {
+			'&': '&amp;',
+			'<': '&lt;',
+			'>': '&gt;',
+			'"': '&quot;',
+			'\'': '&#39;',
+			'/': '&#x2F;'
+		};
+
+		return entityMap[s];
+	});
+}
+
+/**
+ * Unescape a HTML encoded string
+ * @param {String} string Text to unescape HTML in
+ * @returns {String}
+ * @deprecated use utils.js
+ */
+function unescapeHtml(string)
+{
+	return string.replace(/&[#\w]+;/g, function (s) {
+		var entityMap = {
+			'&amp;': '&',
+			'&lt;': '<',
+			'&gt;': '>',
+			'&quot;': '"',
+			'&#39;': '\'',
+			'&#x2F;': '/'
+		};
+
+		return entityMap[s];
+	});
+}
+
 /**
  * returns current timestamp (unix timestamp)
  * @return {Number} timestamp (in milliseconds)
+ * @deprecated use utils.js
  */
 function getTimestamp() // eslint-disable-line no-unused-vars
 {
@@ -285,6 +385,7 @@ function getTimestamp() // eslint-disable-line no-unused-vars
  * i.e. 0-255 -> '00'-'ff'
  * @param  {Number} dec decimal string
  * @return {String}     hex encdoded number
+ * @deprecated use utils.js
  */
 function dec2hex(dec)
 {
@@ -296,6 +397,7 @@ function dec2hex(dec)
  * only works on mondern browsers
  * @param  {Number} len length of unique id string
  * @return {String}     random string in length of len
+ * @deprecated use utils.js
  */
 function generateId(len) // eslint-disable-line no-unused-vars
 {
@@ -309,6 +411,7 @@ function generateId(len) // eslint-disable-line no-unused-vars
  * works on all browsers
  * after many runs it will create duplicates
  * @return {String} not true random string
+ * @deprecated use utils.js
  */
 function randomIdF() // eslint-disable-line no-unused-vars
 {
@@ -322,6 +425,7 @@ function randomIdF() // eslint-disable-line no-unused-vars
  * @param  {Number} min minimum int number inclusive
  * @param  {Number} max maximumg int number inclusive
  * @return {Number}     Random number
+ * @deprecated use utils.js
  */
 function getRandomIntInclusive(min, max) // eslint-disable-line no-unused-vars
 {
@@ -335,6 +439,7 @@ function getRandomIntInclusive(min, max) // eslint-disable-line no-unused-vars
  * check if name is a function
  * @param  {string}  name Name of function to check if exists
  * @return {Boolean}      true/false
+ * @deprecated use utils.js
  */
 function isFunction(name) // eslint-disable-line no-unused-vars
 {
@@ -354,6 +459,7 @@ function isFunction(name) // eslint-disable-line no-unused-vars
  * @param  {mixed}  context      context (window or first namespace)
  *                               hidden next are all the arguments
  * @return {mixed}               Return values from functon
+ * @deprecated use utils.js
  */
 function executeFunctionByName(functionName, context /*, args */) // eslint-disable-line no-unused-vars
 {
@@ -370,6 +476,7 @@ function executeFunctionByName(functionName, context /*, args */) // eslint-disa
  * checks if a variable is an object
  * @param  {Mixed}   val possible object
  * @return {Boolean}     true/false if it is an object or not
+ * @deprecated use utils.js
  */
 function isObject(val)
 {
@@ -383,6 +490,7 @@ function isObject(val)
  * get the length of an object (entries)
  * @param  {Object} object object to check
  * @return {Number} number of entry
+ * @deprecated use utils.js
  */
 function getObjectCount(object)
 {
@@ -394,6 +502,7 @@ function getObjectCount(object)
  * @param  {String}  key    key name
  * @param  {Object}  object object to search key in
  * @return {Boolean}        true/false if key exists in object
+ * @deprecated use utils.js
  */
 function keyInObject(key, object)
 {
@@ -402,9 +511,10 @@ function keyInObject(key, object)
 
 /**
  * returns matching key of value
- * @param  {Object} obj   object to search value in
- * @param  {Mixed}  value any value (String, Number, etc)
- * @return {String}       the key found for the first matching value
+ * @param  {Object} object object to search value in
+ * @param  {Mixed}  value  any value (String, Number, etc)
+ * @return {String}        the key found for the first matching value
+ * @deprecated use utils.js
  */
 function getKeyByValue(object, value) // eslint-disable-line no-unused-vars
 {
@@ -416,9 +526,10 @@ function getKeyByValue(object, value) // eslint-disable-line no-unused-vars
 
 /**
  * returns true if value is found in object with a key
- * @param  {Object}  obj   object to search value in
- * @param  {Mixed}   value any value (String, Number, etc)
- * @return {Boolean}       true on value found, false on not found
+ * @param  {Object}  object object to search value in
+ * @param  {Mixed}   value  any value (String, Number, etc)
+ * @return {Boolean}        true on value found, false on not found
+ * @deprecated use utils.js
  */
 function valueInObject(object, value) // eslint-disable-line no-unused-vars
 {
@@ -434,6 +545,7 @@ function valueInObject(object, value) // eslint-disable-line no-unused-vars
  * or if JSON.parse(JSON.stringify(obj)) is failing
  * @param  {Object} inObject Object to copy
  * @return {Object}          Copied Object
+ * @deprecated use utils.js
  */
 function deepCopyFunction(inObject)
 {
@@ -457,6 +569,7 @@ function deepCopyFunction(inObject)
  * checks if a DOM element actually exists
  * @param  {String}  id Element id to check for
  * @return {Boolean}    true if element exists, false on failure
+ * @deprecated use utils.js
  */
 function exists(id)
 {
@@ -468,6 +581,7 @@ function exists(id)
  * currently precision is fixed, if dynamic needs check for max/min precision
  * @param  {Number} bytes bytes in int
  * @return {String}       string in GB/MB/KB
+ * @deprecated use utils.js
  */
 function formatBytes(bytes) // eslint-disable-line no-unused-vars
 {
@@ -484,6 +598,7 @@ function formatBytes(bytes) // eslint-disable-line no-unused-vars
  * like formatBytes, but returns bytes for <1KB and not 0.n KB
  * @param  {Number} bytes bytes in int
  * @return {String}       string in GB/MB/KB
+ * @deprecated use utils.js
  */
 function formatBytesLong(bytes) // eslint-disable-line no-unused-vars
 {
@@ -496,6 +611,7 @@ function formatBytesLong(bytes) // eslint-disable-line no-unused-vars
  * Convert a string with B/K/M/etc into a byte number
  * @param  {String|Number} bytes Any string with B/K/M/etc
  * @return {String|Number}       A byte number, or original string as is
+ * @deprecated use utils.js
  */
 function stringByteFormat(bytes) // eslint-disable-line no-unused-vars
 {
@@ -526,6 +642,7 @@ function stringByteFormat(bytes) // eslint-disable-line no-unused-vars
 /**
  * prints out error messages based on data available from the browser
  * @param {Object} err error from try/catch block
+ * @deprecated use utils.js
  */
 function errorCatch(err)
 {
@@ -533,22 +650,20 @@ function errorCatch(err)
 	if (err.stack) {
 		// only FF
 		if (err.lineNumber) {
-			console.log('ERROR[%s:%s] %s', err.name, err.lineNumber, err.message);
+			console.error('ERROR[%s:%s] ', err.name, err.lineNumber, err);
 		} else if (err.line) {
 			// only Safari
-			console.log('ERROR[%s:%s] %s', err.name, err.line, err.message);
+			console.error('ERROR[%s:%s] ', err.name, err.line, err);
 		} else {
-			console.log('ERROR[%s] %s', err.name, err.message);
+			console.error('ERROR[%s] ', err.name, err);
 		}
-		// stack trace
-		console.log('ERROR[stack] %s', err.stack);
 	} else if (err.number) {
 		// IE
-		console.log('ERROR[%s:%s] %s', err.name, err.number, err.message);
-		console.log('ERROR[description] %s', err.description);
+		console.error('ERROR[%s:%s] %s', err.name, err.number, err.message);
+		console.error('ERROR[description] %s', err.description);
 	} else {
 		// the rest
-		console.log('ERROR[%s] %s', err.name, err.message);
+		console.error('ERROR[%s] %s', err.name, err.message);
 	}
 }
 
@@ -571,6 +686,7 @@ function errorCatch(err)
  * @param {String}  loc            location name for action indicator
  *                                 default empty. for console.log
  * @param {Boolean} [overlay=true] override the auto hide/show over the overlay div block
+ * @deprecated use utils.js
  */
 function actionIndicator(loc, overlay = true) // eslint-disable-line no-unused-vars
 {
@@ -587,6 +703,7 @@ function actionIndicator(loc, overlay = true) // eslint-disable-line no-unused-v
  * @param {String}  loc            location name for action indicator
  *                                 default empty. for console.log
  * @param {Boolean} [overlay=true] override the auto hide/show over the overlay div block
+ * @deprecated use utils.js
  */
 function actionIndicatorShow(loc, overlay = true)
 {
@@ -609,6 +726,7 @@ function actionIndicatorShow(loc, overlay = true)
  * @param {String}  loc            location name for action indicator
  *                                 default empty. for console.log
  * @param {Boolean} [overlay=true] override the auto hide/show over the overlay div block
+ * @deprecated use utils.js
  */
 function actionIndicatorHide(loc, overlay = true)
 {
@@ -621,6 +739,7 @@ function actionIndicatorHide(loc, overlay = true)
 
 /**
  * shows the overlay box or if already visible, bumps the zIndex to 100
+ * @deprecated use utils.js
  */
 function overlayBoxShow()
 {
@@ -635,6 +754,7 @@ function overlayBoxShow()
 
 /**
  * hides the overlay box or if zIndex is 100 bumps it down to previous level
+ * @deprecated use utils.js
  */
 function overlayBoxHide()
 {
@@ -648,6 +768,7 @@ function overlayBoxHide()
 
 /**
  * position the overlay block box and shows it
+ * @deprecated use utils.js
  */
 function setOverlayBox() // eslint-disable-line no-unused-vars
 {
@@ -658,6 +779,7 @@ function setOverlayBox() // eslint-disable-line no-unused-vars
 
 /**
  * opposite of set, always hides overlay box
+ * @deprecated use utils.js
  */
 function hideOverlayBox() // eslint-disable-line no-unused-vars
 {
@@ -668,6 +790,7 @@ function hideOverlayBox() // eslint-disable-line no-unused-vars
 
 /**
  * the abort call, clears the action box and hides it and the overlay box
+ * @deprecated use utils.js
  */
 function ClearCall() // eslint-disable-line no-unused-vars
 {
@@ -689,6 +812,7 @@ function ClearCall() // eslint-disable-line no-unused-vars
  *   zIndex of 1000
  * - indicator is page centered
  * @param {String} loc ID string, only used for console log
+ * @deprecated use utils.js
  */
 function showActionIndicator(loc) // eslint-disable-line no-unused-vars
 {
@@ -727,6 +851,7 @@ function showActionIndicator(loc) // eslint-disable-line no-unused-vars
  * the overlayBox is not hidden but the zIndex
  * is set to this value
  * @param {String} loc ID string, only used for console log
+ * @deprecated use utils.js
  */
 function hideActionIndicator(loc) // eslint-disable-line no-unused-vars
 {
@@ -750,6 +875,7 @@ function hideActionIndicator(loc) // eslint-disable-line no-unused-vars
 /**
  * checks if overlayBox exists, if not it is
  * added as hidden item at the body end
+ * @deprecated use utils.js
  */
 function checkOverlayExists()
 {
@@ -767,6 +893,7 @@ function checkOverlayExists()
  * if not visible show and set zIndex to 10 (GL_OB_BASE)
  * if visible, add +1 to the GL_OB_S variable and
  * up zIndex by this value
+ * @deprecated use utils.js
  */
 function showOverlayBoxLayers(el_id) // eslint-disable-line no-unused-vars
 {
@@ -799,8 +926,9 @@ function showOverlayBoxLayers(el_id) // eslint-disable-line no-unused-vars
  * and set zIndex and GL_OB_S to 0
  * else just set zIndex to the new GL_OB_S value
  * @param {String} el_id Target to hide layer
+ * @deprecated use utils.js
  */
-function hideOverlayBoxLayers(el_id)
+function hideOverlayBoxLayers(el_id='')
 {
 	// console.log('HIDE overlaybox: %s', GL_OB_S);
 	// remove on layer
@@ -824,6 +952,7 @@ function hideOverlayBoxLayers(el_id)
 
 /**
  * only for single action box
+ * @deprecated use utils.js
  */
 function clearCallActionBox() // eslint-disable-line no-unused-vars
 {
@@ -841,6 +970,7 @@ function clearCallActionBox() // eslint-disable-line no-unused-vars
  * @param  {Array}  [css=[]]     array for css tags
  * @param  {Object} [options={}] anything else (value, placeholder, OnClick, style)
  * @return {Object}              created element as an object
+ * @deprecated use utils.js
  */
 function cel(tag, id = '', content = '', css = [], options = {})
 {
@@ -861,6 +991,7 @@ function cel(tag, id = '', content = '', css = [], options = {})
  * @param  {Object} attach  the object to be attached
  * @param  {String} [id=''] optional id, if given search in base for this id and attach there
  * @return {Object}         "none", technically there is no return needed as it is global attach
+ * @deprecated use utils.js
  */
 function ael(base, attach, id = '')
 {
@@ -891,6 +1022,7 @@ function ael(base, attach, id = '')
  * @param  {Object}    base   object to where we attach the elements
  * @param  {...Object} attach attach 1..n: attach directly to the base element those attachments
  * @return {Object}           "none", technically there is no return needed, global attach
+ * @deprecated use utils.js
  */
 function aelx(base, ...attach)
 {
@@ -907,6 +1039,7 @@ function aelx(base, ...attach)
  * @param  {Object} base   object to where we attach the elements
  * @param  {Array}  attach array of objects to attach
  * @return {Object}        "none", technically there is no return needed, global attach
+ * @deprecated use utils.js
  */
 function aelxar(base, attach) // eslint-disable-line no-unused-vars
 {
@@ -921,6 +1054,7 @@ function aelxar(base, attach) // eslint-disable-line no-unused-vars
  * resets the sub elements of the base element given
  * @param  {Object} base cel created element
  * @return {Object}      returns reset base element
+ * @deprecated use utils.js
  */
 function rel(base) // eslint-disable-line no-unused-vars
 {
@@ -933,6 +1067,7 @@ function rel(base) // eslint-disable-line no-unused-vars
  * @param  {Object} _element element to work one
  * @param  {String} css      style sheet to remove (name)
  * @return {Object}          returns full element
+ * @deprecated use utils.js
  */
 function rcssel(_element, css)
 {
@@ -948,6 +1083,7 @@ function rcssel(_element, css)
  * @param  {Object} _element element to work on
  * @param  {String} css      style sheet to add (name)
  * @return {Object}         returns full element
+ * @deprecated use utils.js
  */
 function acssel(_element, css)
 {
@@ -965,6 +1101,7 @@ function acssel(_element, css)
  * @param  {String} rcss     style to remove (name)
  * @param  {String} acss     style to add (name)
  * @return {Object}          returns full element
+ * @deprecated use utils.js
  */
 function scssel(_element, rcss, acss) // eslint-disable-line no-unused-vars
 {
@@ -977,6 +1114,7 @@ function scssel(_element, rcss, acss) // eslint-disable-line no-unused-vars
  * that can be inserted into the page
  * @param  {Object} tree object tree with dom element declarations
  * @return {String}      HTML string that can be used as innerHTML
+ * @deprecated use utils.js
  */
 function phfo(tree)
 {
@@ -1083,6 +1221,7 @@ function phfo(tree)
  * Is like tree.sub call
  * @param  {Array}  list Array of cel created objects
  * @return {String}      HTML String
+ * @deprecated use utils.js
  */
 function phfa(list) // eslint-disable-line no-unused-vars
 {
@@ -1109,11 +1248,14 @@ function phfa(list) // eslint-disable-line no-unused-vars
  * @param  {String}  [sort='']             if empty as is, else allowed 'keys',
  *                                         'values' all others are ignored
  * @return {String}                        html with build options block
+ * @deprecated use utils.js
  */
 function html_options(name, data, selected = '', options_only = false, return_string = false, sort = '') // eslint-disable-line no-unused-vars
 {
 	// wrapper to new call
-	return html_options_block(name, data, selected, false, options_only, return_string, sort);
+	return html_options_block(
+		name, data, selected, 0, options_only, return_string, sort
+	);
 }
 
 /**
@@ -1134,9 +1276,11 @@ function html_options(name, data, selected = '', options_only = false, return_st
  *                                         'values' all others are ignored
  * @param  {String}  [onchange='']         onchange trigger call, default unset
  * @return {String}                        html with build options block
+ * @deprecated use utils.js
  */
-function html_options_block(name, data, selected = '', multiple = 0, options_only = false, return_string = false, sort = '', onchange = '')
-{
+function html_options_block(
+	name, data, selected = '', multiple = 0, options_only = false, return_string = false, sort = '', onchange = ''
+) {
 	var content = [];
 	var element_select;
 	var select_options = {};
@@ -1173,7 +1317,8 @@ function html_options_block(name, data, selected = '', multiple = 0, options_onl
 		// basic options init
 		options = {
 			'label': value,
-			'value': key
+			'value': key,
+			'selected': ''
 		};
 		// add selected if matching
 		if (multiple == 0 && !Array.isArray(selected) && selected == key) {
@@ -1184,7 +1329,7 @@ function html_options_block(name, data, selected = '', multiple = 0, options_onl
 			options.selected = '';
 		}
 		// create the element option
-		element_option = cel('option', '', value, '', options);
+		element_option = cel('option', '', value, [], options);
 		// attach it to the select element
 		ael(element_select, element_option);
 	}
@@ -1214,6 +1359,7 @@ function html_options_block(name, data, selected = '', multiple = 0, options_onl
  * @param {String} name      name/id
  * @param {Object} data      array of options
  * @param {String} [sort=''] if empty as is, else allowed 'keys', 'values'
+ * @deprecated use utils.js
  *                            all others are ignored
  */
 function html_options_refill(name, data, sort = '') // eslint-disable-line no-unused-vars
@@ -1236,7 +1382,7 @@ function html_options_refill(name, data, sort = '') // eslint-disable-line no-un
 		[].forEach.call(document.querySelectorAll('#' + name + ' :checked'), function(elm) {
 			option_selected = elm.value;
 		});
-		document.getElementById(name).innerHTML = '';
+		loadEl(name).innerHTML = '';
 		for (const key of data_list) {
 			value = data[key];
 			// console.log('add [%s]  options: key: %s, value: %s', name, key, value);
@@ -1247,7 +1393,7 @@ function html_options_refill(name, data, sort = '') // eslint-disable-line no-un
 			if (key == option_selected) {
 				element_option.selected = true;
 			}
-			document.getElementById(name).appendChild(element_option);
+			loadEl(name).appendChild(element_option);
 		}
 	}
 }
@@ -1262,6 +1408,7 @@ function html_options_refill(name, data, sort = '') // eslint-disable-line no-un
  * @param  {String}        [return_key=''] if set only returns this key entry
  *                                         or empty for none
  * @return {Object|String}                 parameter entry list
+ * @deprecated use utils.js
  */
 function parseQueryString(query = '', return_key = '') // eslint-disable-line no-unused-vars
 {
@@ -1311,11 +1458,12 @@ function parseQueryString(query = '', return_key = '') // eslint-disable-line no
  *                                        all parameters are returned
  * @param  {String}        [query='']     different query string to parse, if not
  *                                        set (default) the current window href is used
- * @param  {Bool}          [single=false] if set to true then only the first found
+ * @param  {Boolean}       [single=false] if set to true then only the first found
  *                                        will be returned
  * @return {Object|Array|String}          if search is empty, object, if search is set
  *                                        and only one entry, then string, else array
  *                                        unless single is true
+ * @deprecated use utils.js
  */
 function getQueryStringParam(search = '', query = '', single = false) // eslint-disable-line no-unused-vars
 {
@@ -1323,7 +1471,7 @@ function getQueryStringParam(search = '', query = '', single = false) // eslint-
 		query = window.location.href;
 	}
 	const url = new URL(query);
-	let param = '';
+	let param = null;
 	if (search) {
 		let _params = url.searchParams.getAll(search);
 		if (_params.length == 1 || single === true) {
@@ -1353,6 +1501,7 @@ function getQueryStringParam(search = '', query = '', single = false) // eslint-
 // *** MASTER logout call
 /**
  * submits basic data for form logout
+ * @deprecated use utils.js
  */
 function loginLogout() // eslint-disable-line no-unused-vars
 {
@@ -1373,6 +1522,7 @@ function loginLogout() // eslint-disable-line no-unused-vars
  * @param {String} [header_id='mainHeader'] the target for the main element block
  *                                          if not set mainHeader is assumed
  *                                          this is the target div for the "loginRow"
+ * @deprecated use utils.js
  */
 function createLoginRow(login_string, header_id = 'mainHeader') // eslint-disable-line no-unused-vars
 {
@@ -1408,6 +1558,7 @@ function createLoginRow(login_string, header_id = 'mainHeader') // eslint-disabl
  * @param {String} [header_id='mainHeader'] the target for the main element block
  *                                          if not set mainHeader is assumed
  *                                          this is the target div for the "menuRow"
+ * @deprecated use utils.js
  */
 function createNavMenu(nav_menu, header_id = 'mainHeader') // eslint-disable-line no-unused-vars
 {

www/admin/layout/javascript/edit.pt.js

@@ -1,5 +1,11 @@
-/* general edit javascript */
-/* prototype version */
+/*
+general edit javascript
+prototype version
+*/
+
+/** @deprecated Do not use this anymore, use utils.js */
+
+throw new Error("Prototype Support is deprected, please switch to jquery and utils.js/utils.min.js");
 
 /* jshint esversion: 6 */
 
@@ -25,7 +31,7 @@ function pop(theURL, winName, features) {
 
 /**
  * automatically resize a text area based on the amount of lines in it
- * @param {[string} ta_id element id
+ * @param {string} ta_id element id
  */
 function expandTA(ta_id) {
 	var ta;