Moved minify to powers. Improved the mapper class.

README.md

@@ -140,14 +140,14 @@ TODO
 + *Author*: [Llewellyn van der Merwe](mailto:joomla@vdm.io)
 + *Name*: [Component Builder](https://git.vdm.dev/joomla/Component-Builder)
 + *First Build*: 30th April, 2015
-+ *Last Build*: 1st January, 2023
++ *Last Build*: 8th January, 2023
 + *Version*: 3.1.13
 + *Copyright*: Copyright (C) 2015 Vast Development Method. All rights reserved.
 + *License*: GNU General Public License version 2 or later; see LICENSE.txt
-+ *Line count*: **342047**
++ *Line count*: **344993**
 + *Field count*: **2009**
-+ *File count*: **2225**
++ *File count*: **2240**
-+ *Folder count*: **391**
++ *Folder count*: **399**
 
 > This **component** was build with a [Joomla](https://extensions.joomla.org/extension/component-builder/) [Automated Component Builder](https://www.joomlacomponentbuilder.com).
 > Developed by [Llewellyn van der Merwe](mailto:llewellyn@joomlacomponentbuilder.com)

admin/README.txt

@@ -140,14 +140,14 @@ TODO
 + *Author*: [Llewellyn van der Merwe](mailto:joomla@vdm.io)
 + *Name*: [Component Builder](https://git.vdm.dev/joomla/Component-Builder)
 + *First Build*: 30th April, 2015
-+ *Last Build*: 1st January, 2023
++ *Last Build*: 8th January, 2023
 + *Version*: 3.1.13
 + *Copyright*: Copyright (C) 2015 Vast Development Method. All rights reserved.
 + *License*: GNU General Public License version 2 or later; see LICENSE.txt
-+ *Line count*: **342047**
++ *Line count*: **344993**
 + *Field count*: **2009**
-+ *File count*: **2225**
++ *File count*: **2240**
-+ *Folder count*: **391**
++ *Folder count*: **399**
 
 > This **component** was build with a [Joomla](https://extensions.joomla.org/extension/component-builder/) [Automated Component Builder](https://www.joomlacomponentbuilder.com).
 > Developed by [Llewellyn van der Merwe](mailto:llewellyn@joomlacomponentbuilder.com)

admin/helpers/compiler/a_Get.php

@@ -1557,7 +1557,7 @@ class Get
 			// build the site_views settings
 			$component->site_views = array_map(
 				function ($array) {
-					// has become a lacacy issue, can't remove this
+					// has become a legacy issue, can't remove this
 					$array['view']     = $array['siteview'];
 					$array['settings'] = $this->getCustomViewData(
 						$array['view']
@@ -1596,7 +1596,7 @@ class Get
 			// build the custom_admin_views settings
 			$component->custom_admin_views = array_map(
 				function ($array) {
-					// has become a lacacy issue, can't remove this
+					// has become a legacy issue, can't remove this
 					$array['view']     = $array['customadminview'];
 					$array['settings'] = $this->getCustomViewData(
 						$array['view'], 'custom_admin_view'

admin/helpers/compiler/e_Interpretation.php

@@ -25,6 +25,7 @@ use VDM\Joomla\Componentbuilder\Compiler\Factory as CFactory;
 use VDM\Joomla\Componentbuilder\Compiler\Utilities\Placefix;
 use VDM\Joomla\Componentbuilder\Compiler\Utilities\Indent;
 use VDM\Joomla\Componentbuilder\Compiler\Utilities\Line;
+use VDM\Joomla\Componentbuilder\Compiler\Utilities\Minify;
 
 /**
  * Compiler class
@@ -16680,32 +16681,26 @@ class Interpretation extends Fields
 			$list_fileScript = '';
 			CFactory::_('Content')->set_($nameListCode, 'ADMIN_ADD_JAVASCRIPT_FILE', '');
 		}
-		// minfy the script
+		// minify the script
 		if (CFactory::_('Config')->get('minify', 0) && isset($list_fileScript)
 			&& StringHelper::check($list_fileScript))
 		{
-			// minify the fielScript javscript
+			// minify the fileScript javascript
-			$minifier = new JS;
+			$list_fileScript = Minify::js($list_fileScript);
-			$minifier->add($list_fileScript);
-			$list_fileScript = $minifier->minify();
 		}
-		// minfy the script
+		// minify the script
 		if (CFactory::_('Config')->get('minify', 0) && isset($fileScript)
 			&& StringHelper::check($fileScript))
 		{
-			// minify the fielScript javscript
+			// minify the fileScript javascript
-			$minifier = new JS;
+			$fileScript = Minify::js($fileScript);
-			$minifier->add($fileScript);
-			$fileScript = $minifier->minify();
 		}
-		// minfy the script
+		// minify the script
 		if (CFactory::_('Config')->get('minify', 0) && isset($footerScript)
 			&& StringHelper::check($footerScript))
 		{
-			// minify the footerScript javscript
+			// minify the footerScript javascript
-			$minifier = new JS;
+			$footerScript = Minify::js($footerScript);
-			$minifier->add($footerScript);
-			$footerScript = $minifier->minify();
 		}
 		// make sure there is script to add
 		if (isset($list_fileScript)

admin/helpers/compiler/f_Infusion.php

@@ -23,6 +23,7 @@ use VDM\Joomla\Componentbuilder\Compiler\Factory as CFactory;
 use VDM\Joomla\Componentbuilder\Compiler\Utilities\Placefix;
 use VDM\Joomla\Componentbuilder\Compiler\Utilities\Indent;
 use VDM\Joomla\Componentbuilder\Compiler\Utilities\Line;
+use VDM\Joomla\Componentbuilder\Compiler\Utilities\Minify;
 
 /**
  * Infusion class
@@ -837,12 +838,8 @@ class Infusion extends Interpretation
 						if (CFactory::_('Config')->get('minify', 0)
 							&& strpos((string) $footerScript, '<?php') === false)
 						{
-							// minfy the script
+							// minify the script
-							$minifier = new JS;
+							$footerScript = Minify::js($footerScript);
-							$minifier->add($footerScript);
-							$footerScript = $minifier->minify();
-							// clear some memory
-							unset($minifier);
 						}
 						CFactory::_('Content')->set_($nameListCode, 'VIEWS_FOOTER_SCRIPT', PHP_EOL . '<script type="text/javascript">'
 							. $footerScript . "</script>");

admin/helpers/componentbuilder.php

@@ -24,7 +24,9 @@ spl_autoload_register(function ($class) {
 	// project-specific base directories and namespace prefix
 	$search = [
 		'libraries/jcb_powers/VDM.Joomla' => 'VDM\\Joomla',
-		'libraries/jcb_powers/VDM.Gitea' => 'VDM\\Gitea'
+		'libraries/jcb_powers/VDM.Minify' => 'VDM\\Minify',
+		'libraries/jcb_powers/VDM.Gitea' => 'VDM\\Gitea',
+		'libraries/jcb_powers/VDM.Psr' => 'VDM\\Psr'
 	];
 	// Start the search and load if found
 	$found = false;
@@ -1078,8 +1080,6 @@ abstract class ComponentbuilderHelper
 		{
 			// import the Joomla librarys
 			jimport('joomla.application.component.modellist');
-			// include class to minify js
-			require_once JPATH_ADMINISTRATOR.'/components/com_componentbuilder/helpers/js.php';
 		}
 		// load only if smart
 		if ('smart' === $type)

admin/helpers/keywords_after.txt

@@ -1,7 +0,0 @@
-in
-public
-extends
-private
-protected
-implements
-instanceof

admin/helpers/keywords_before.txt

@@ -1,28 +0,0 @@
-do
-in
-let
-new
-var
-case
-else
-enum
-void
-with
-class
-const
-yield
-delete
-export
-import
-public
-return
-static
-typeof
-extends
-package
-private
-continue
-function
-protected
-implements
-instanceof

admin/helpers/keywords_reserved.txt

@@ -1,47 +0,0 @@
-do
-if
-in
-for
-let
-new
-try
-var
-case
-else
-enum
-eval
-null
-this
-true
-void
-with
-break
-catch
-class
-const
-false
-super
-throw
-while
-yield
-delete
-export
-import
-public
-return
-static
-switch
-typeof
-default
-extends
-finally
-package
-private
-continue
-debugger
-function
-arguments
-interface
-protected
-implements
-instanceof

admin/helpers/minify.php

@@ -1,381 +0,0 @@
-<?php
-/*--------------------------------------------------------------------------------------------------------|  www.vdm.io  |------/
-    __      __       _     _____                 _                                  _     __  __      _   _               _
-    \ \    / /      | |   |  __ \               | |                                | |   |  \/  |    | | | |             | |
-     \ \  / /_ _ ___| |_  | |  | | _____   _____| | ___  _ __  _ __ ___   ___ _ __ | |_  | \  / | ___| |_| |__   ___   __| |
-      \ \/ / _` / __| __| | |  | |/ _ \ \ / / _ \ |/ _ \| '_ \| '_ ` _ \ / _ \ '_ \| __| | |\/| |/ _ \ __| '_ \ / _ \ / _` |
-       \  / (_| \__ \ |_  | |__| |  __/\ V /  __/ | (_) | |_) | | | | | |  __/ | | | |_  | |  | |  __/ |_| | | | (_) | (_| |
-        \/ \__,_|___/\__| |_____/ \___| \_/ \___|_|\___/| .__/|_| |_| |_|\___|_| |_|\__| |_|  |_|\___|\__|_| |_|\___/ \__,_|
-                                                        | |                                                                 
-                                                        |_| 				
-/-------------------------------------------------------------------------------------------------------------------------------/
-
-	@version		2.6.x
-	@created		30th April, 2015
-	@package		Component Builder
-	@subpackage		minify.php
-	@author			Llewellyn van der Merwe <http://joomlacomponentbuilder.com>	
-	@github			Joomla Component Builder <https://github.com/vdm-io/Joomla-Component-Builder>
-	@copyright		Copyright (C) 2015. All Rights Reserved
-	@license		GNU/GPL Version 2 or later - http://www.gnu.org/licenses/gpl-2.0.html 
-	
-	Builds Complex Joomla Components 
-                                                             
-/-----------------------------------------------------------------------------------------------------------------------------*/
-
-// No direct access to this file
-defined('_JEXEC') or die('Restricted access');
-
-/**
- * Abstract minifier class.
- *
- * Please report bugs on https://github.com/matthiasmullie/minify/issues
- *
- * @author Matthias Mullie <minify@mullie.eu>
- *
- * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved.
- * @license MIT License
- */
-abstract class Minify
-{
-    /**
-     * The data to be minified
-     *
-     * @var string[]
-     */
-    protected $data = array();
-
-    /**
-     * Array of patterns to match.
-     *
-     * @var string[]
-     */
-    protected $patterns = array();
-
-    /**
-     * This array will hold content of strings and regular expressions that have
-     * been extracted from the JS source code, so we can reliably match "code",
-     * without having to worry about potential "code-like" characters inside.
-     *
-     * @var string[]
-     */
-    public $extracted = array();
-
-    /**
-     * Init the minify class - optionally, code may be passed along already.
-     */
-    public function __construct(/* $data = null, ... */)
-    {
-        // it's possible to add the source through the constructor as well ;)
-        if (func_num_args()) {
-            call_user_func_array(array($this, 'add'), func_get_args());
-        }
-    }
-
-    /**
-     * Add a file or straight-up code to be minified.
-     *
-     * @param string $data
-     */
-    public function add($data /* $data = null, ... */)
-    {
-        // bogus "usage" of parameter $data: scrutinizer warns this variable is
-        // not used (we're using func_get_args instead to support overloading),
-        // but it still needs to be defined because it makes no sense to have
-        // this function without argument :)
-        $args = array($data) + func_get_args();
-
-        // this method can be overloaded
-        foreach ($args as $data) {
-            // redefine var
-            $data = (string) $data;
-
-            // load data
-            $value = $this->load($data);
-            $key = ($data != $value) ? $data : count($this->data);
-
-            // store data
-            $this->data[$key] = $value;
-        }
-    }
-
-    /**
-     * Load data.
-     *
-     * @param  string $data Either a path to a file or the content itself.
-     * @return string
-     */
-    protected function load($data)
-    {
-        // check if the data is a file
-        if (@file_exists($data) && is_file($data)) {
-            $data = @file_get_contents($data);
-
-            // strip BOM, if any
-            if (substr($data, 0, 3) == "\xef\xbb\xbf") {
-                $data = substr($data, 3);
-            }
-        }
-
-        return $data;
-    }
-
-    /**
-     * Save to file
-     *
-     * @param  string    $content The minified data.
-     * @param  string    $path    The path to save the minified data to.
-     * @throws Exception
-     */
-    protected function save($content, $path)
-    {
-        // create file & open for writing
-        if (($handler = @fopen($path, 'w')) === false) {
-            throw new Exception('The file "'.$path.'" could not be opened. Check if PHP has enough permissions.');
-        }
-
-        // write to file
-        if (@fwrite($handler, $content) === false) {
-            throw new Exception('The file "'.$path.'" could not be written to. Check if PHP has enough permissions.');
-        }
-
-        // close the file
-        @fclose($handler);
-    }
-
-    /**
-     * Minify the data & (optionally) saves it to a file.
-     *
-     * @param  string[optional] $path Path to write the data to.
-     * @return string           The minified data.
-     */
-    public function minify($path = null)
-    {
-        $content = $this->execute($path);
-
-        // save to path
-        if ($path !== null) {
-            $this->save($content, $path);
-        }
-
-        return $content;
-    }
-
-    /**
-     * Minify & gzip the data & (optionally) saves it to a file.
-     *
-     * @param  string[optional] $path Path to write the data to.
-     * @param  int[optional]    $level Compression level, from 0 to 9.
-     * @return string           The minified & gzipped data.
-     */
-    public function gzip($path = null, $level = 9)
-    {
-        $content = $this->execute($path);
-        $content = gzencode($content, $level, FORCE_GZIP);
-
-        // save to path
-        if ($path !== null) {
-            $this->save($content, $path);
-        }
-
-        return $content;
-    }
-
-    /**
-     * Minify the data.
-     *
-     * @param  string[optional] $path Path to write the data to.
-     * @return string           The minified data.
-     */
-    abstract protected function execute($path = null);
-
-    /**
-     * Register a pattern to execute against the source content.
-     *
-     * @param  string          $pattern     PCRE pattern.
-     * @param  string|callable $replacement Replacement value for matched pattern.
-     * @throws Exception
-     */
-    protected function registerPattern($pattern, $replacement = '')
-    {
-        // study the pattern, we'll execute it more than once
-        $pattern .= 'S';
-
-        $this->patterns[] = array($pattern, $replacement);
-    }
-
-    /**
-     * We can't "just" run some regular expressions against JavaScript: it's a
-     * complex language. E.g. having an occurrence of // xyz would be a comment,
-     * unless it's used within a string. Of you could have something that looks
-     * like a 'string', but inside a comment.
-     * The only way to accurately replace these pieces is to traverse the JS one
-     * character at a time and try to find whatever starts first.
-     *
-     * @param  string $content The content to replace patterns in.
-     * @return string The (manipulated) content.
-     */
-    protected function replace($content)
-    {
-        $processed = '';
-        $positions = array_fill(0, count($this->patterns), -1);
-        $matches = array();
-
-        while ($content) {
-            // find first match for all patterns
-            foreach ($this->patterns as $i => $pattern) {
-                list($pattern, $replacement) = $pattern;
-
-                // no need to re-run matches that are still in the part of the
-                // content that hasn't been processed
-                if ($positions[$i] >= 0) {
-                    continue;
-                }
-
-                $match = null;
-                if (preg_match($pattern, $content, $match)) {
-                    $matches[$i] = $match;
-
-                    // we'll store the match position as well; that way, we
-                    // don't have to redo all preg_matches after changing only
-                    // the first (we'll still know where those others are)
-                    $positions[$i] = strpos($content, $match[0]);
-                } else {
-                    // if the pattern couldn't be matched, there's no point in
-                    // executing it again in later runs on this same content;
-                    // ignore this one until we reach end of content
-                    unset($matches[$i]);
-                    $positions[$i] = strlen($content);
-                }
-            }
-
-            // no more matches to find: everything's been processed, break out
-            if (!$matches) {
-                $processed .= $content;
-                break;
-            }
-
-            // see which of the patterns actually found the first thing (we'll
-            // only want to execute that one, since we're unsure if what the
-            // other found was not inside what the first found)
-            $discardLength = min($positions);
-            $firstPattern = array_search($discardLength, $positions);
-            $match = $matches[$firstPattern][0];
-
-            // execute the pattern that matches earliest in the content string
-            list($pattern, $replacement) = $this->patterns[$firstPattern];
-            $replacement = $this->replacePattern($pattern, $replacement, $content);
-
-            // figure out which part of the string was unmatched; that's the
-            // part we'll execute the patterns on again next
-            $content = substr($content, $discardLength);
-            $unmatched = (string) substr($content, strpos($content, $match) + strlen($match));
-
-            // move the replaced part to $processed and prepare $content to
-            // again match batch of patterns against
-            $processed .= substr($replacement, 0, strlen($replacement) - strlen($unmatched));
-            $content = $unmatched;
-
-            // first match has been replaced & that content is to be left alone,
-            // the next matches will start after this replacement, so we should
-            // fix their offsets
-            foreach ($positions as $i => $position) {
-                $positions[$i] -= $discardLength + strlen($match);
-            }
-        }
-
-        return $processed;
-    }
-
-    /**
-     * This is where a pattern is matched against $content and the matches
-     * are replaced by their respective value.
-     * This function will be called plenty of times, where $content will always
-     * move up 1 character.
-     *
-     * @param  string          $pattern     Pattern to match.
-     * @param  string|callable $replacement Replacement value.
-     * @param  string          $content     Content to match pattern against.
-     * @return string
-     */
-    protected function replacePattern($pattern, $replacement, $content)
-    {
-        if (is_callable($replacement)) {
-            return preg_replace_callback($pattern, $replacement, $content, 1, $count);
-        } else {
-            return preg_replace($pattern, $replacement, $content, 1, $count);
-        }
-    }
-
-    /**
-     * Strings are a pattern we need to match, in order to ignore potential
-     * code-like content inside them, but we just want all of the string
-     * content to remain untouched.
-     *
-     * This method will replace all string content with simple STRING#
-     * placeholder text, so we've rid all strings from characters that may be
-     * misinterpreted. Original string content will be saved in $this->extracted
-     * and after doing all other minifying, we can restore the original content
-     * via restoreStrings()
-     *
-     * @param string[optional] $chars
-     */
-    protected function extractStrings($chars = '\'"')
-    {
-        // PHP only supports $this inside anonymous functions since 5.4
-        $minifier = $this;
-        $callback = function ($match) use ($minifier) {
-            if (!$match[1]) {
-                /*
-                 * Empty strings need no placeholder; they can't be confused for
-                 * anything else anyway.
-                 * But we still needed to match them, for the extraction routine
-                 * to skip over this particular string.
-                 */
-                return $match[0];
-            }
-
-            $count = count($minifier->extracted);
-            $placeholder = $match[1].$count.$match[1];
-            $minifier->extracted[$placeholder] = $match[1].$match[2].$match[1];
-
-            return $placeholder;
-        };
-
-        /*
-         * The \\ messiness explained:
-         * * Don't count ' or " as end-of-string if it's escaped (has backslash
-         * in front of it)
-         * * Unless... that backslash itself is escaped (another leading slash),
-         * in which case it's no longer escaping the ' or "
-         * * So there can be either no backslash, or an even number
-         * * multiply all of that times 4, to account for the escaping that has
-         * to be done to pass the backslash into the PHP string without it being
-         * considered as escape-char (times 2) and to get it in the regex,
-         * escaped (times 2)
-         */
-        $this->registerPattern('/(['.$chars.'])(.*?((?<!\\\\)|\\\\\\\\+))\\1/s', $callback);
-    }
-
-    /**
-     * This method will restore all extracted data (strings, regexes) that were
-     * replaced with placeholder text in extract*(). The original content was
-     * saved in $this->extracted.
-     *
-     * @param  string $content
-     * @return string
-     */
-    protected function restoreExtractedData($content)
-    {
-        if (!$this->extracted) {
-            // nothing was extracted, nothing to restore
-            return $content;
-        }
-
-        $content = strtr($content, $this->extracted);
-
-        $this->extracted = array();
-
-        return $content;
-    }
-}

admin/helpers/operators_after.txt

@@ -1,45 +0,0 @@
-+
--
-*
-/
-%
-=
-+=
--=
-*=
-/=
-%=
-<<=
->>=
->>>=
-&=
-^=
-|=
-&
-|
-^
-~
-<<
->>
->>>
-==
-===
-!=
-!==
->
-<
->=
-<=
-&&
-||
-.
-[
-]
-?
-:
-,
-;
-(
-)
-{
-}

admin/helpers/operators_before.txt

@@ -1,43 +0,0 @@
-+
--
-*
-/
-%
-=
-+=
--=
-*=
-/=
-%=
-<<=
->>=
->>>=
-&=
-^=
-|=
-&
-|
-^
-~
-<<
->>
->>>
-==
-===
-!=
-!==
->
-<
->=
-<=
-&&
-||
-!
-.
-[
-?
-:
-,
-;
-(
-{

componentbuilder.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <extension type="component" version="4" method="upgrade">
 	<name>COM_COMPONENTBUILDER</name>
-	<creationDate>1st January, 2023</creationDate>
+	<creationDate>8th January, 2023</creationDate>
 	<author>Llewellyn van der Merwe</author>
 	<authorEmail>joomla@vdm.io</authorEmail>
 	<authorUrl>https://dev.vdm.io</authorUrl>

libraries/jcb_powers/VDM.Joomla/src/Componentbuilder/Abstraction/Mapper.php

@@ -0,0 +1,259 @@
+<?php
+/**
+ * @package    Joomla.Component.Builder
+ *
+ * @created    4th September, 2022
+ * @author     Llewellyn van der Merwe <https://dev.vdm.io>
+ * @git        Joomla Component Builder <https://git.vdm.dev/joomla/Component-Builder>
+ * @copyright  Copyright (C) 2015 Vast Development Method. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE.txt
+ */
+
+namespace VDM\Joomla\Componentbuilder\Abstraction;
+
+
+use VDM\Joomla\Componentbuilder\Interfaces\Mapperdoubleinterface;
+use VDM\Joomla\Componentbuilder\Interfaces\Mappersingleinterface;
+
+
+/**
+ * Compiler Mapper
+ * 
+ * @since 3.2.0
+ */
+abstract class Mapper implements Mapperdoubleinterface, Mappersingleinterface
+{
+
+	/**
+	 * The Content
+	 *
+	 * @var    array
+	 * @since 3.2.0
+	 **/
+	public array $active = [];
+
+	/**
+	 * Set content
+	 *
+	 * @param   string  $key    The main string key
+	 * @param   mixed   $value  The values to set
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function set(string $key, $value)
+	{
+		$this->active[$this->key($key)] = $value;
+	}
+
+	/**
+	 * Get content
+	 *
+	 * @param   string  $key    The main string key
+	 * @param   mixed   $value  The values to set
+	 *
+	 * @return  mixed
+	 * @since 3.2.0
+	 */
+	public function get(string $key)
+	{
+		return $this->active[$this->key($key)] ?? null;
+	}
+
+	/**
+	 * Does key exist
+	 *
+	 * @param   string  $key    The main string key
+	 *
+	 * @return  bool
+	 * @since 3.2.0
+	 */
+	public function exist(string $key): bool
+	{
+		if (isset($this->active[$this->key($key)]))
+		{
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Add content
+	 *
+	 * @param   string  $key    The main string key
+	 * @param   mixed   $value  The values to set
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function add(string $key, $value)
+	{
+		if (isset($this->active[$this->key($key)]))
+		{
+			$this->active[$this->key($key)] .= $value;
+		}
+		else
+		{
+			$this->active[$this->key($key)] = $value;
+		}
+	}
+
+	/**
+	 * Remove content
+	 *
+	 * @param   string     $key     The main string key
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function remove(string $key)
+	{
+		unset($this->active[$this->key($key)]);
+	}
+
+	/**
+	 * Model the key
+	 *
+	 * @param   string   $key  The key to model
+	 *
+	 * @return  string
+	 * @since 3.2.0
+	 */
+	abstract protected function key(string $key): string;
+
+	/**
+	 * The Dynamic Content
+	 *
+	 * @var    array
+	 * @since 3.2.0
+	 **/
+	public array $_active = [];
+
+	/**
+	 * Set dynamic content
+	 *
+	 * @param   string    $firstKey    The first key
+	 * @param   string    $secondKey   The second key
+	 * @param   mixed     $value       The values to set
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function set_(string $firstKey, string $secondKey, $value)
+	{
+		$this->_active[$this->firstKey($firstKey)]
+			[$this->secondKey($secondKey)] = $value;
+	}
+
+	/**
+	 * Get dynamic content
+	 *
+	 * @param   string    $firstKey     The first key
+	 * @param   string    $secondKey    The second key
+	 *
+	 * @return  mixed
+	 * @since 3.2.0
+	 */
+	public function get_(string $firstKey, ?string $secondKey = null)
+	{
+		if (is_string($secondKey))
+		{
+			return $this->_active[$this->firstKey($firstKey)]
+				[$this->secondKey($secondKey)]  ?? null;
+		}
+		return $this->_active[$this->firstKey($firstKey)] ?? null;
+	}
+
+	/**
+	 * Does keys exist
+	 *
+	 * @param   string        $firstKey     The first key
+	 * @param   string|null   $secondKey    The second key
+	 *
+	 * @return  bool
+	 * @since 3.2.0
+	 */
+	public function exist_(string $firstKey, ?string $secondKey = null): bool
+	{
+		if (is_string($secondKey) && isset($this->_active[$this->firstKey($firstKey)]) &&
+			isset($this->_active[$this->firstKey($firstKey)]
+				[$this->secondKey($secondKey)]))
+		{
+			return true;
+		}
+		elseif (is_null($secondKey) && isset($this->_active[$this->firstKey($firstKey)]))
+		{
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Add dynamic content
+	 *
+	 * @param   string    $firstKey     The first key
+	 * @param   string    $secondKey    The second key
+	 * @param   mixed     $value        The values to set
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function add_(string $firstKey, string $secondKey, $value)
+	{
+		if (isset($this->_active[$this->firstKey($firstKey)]) &&
+			isset($this->_active[$this->firstKey($firstKey)]
+				[$this->secondKey($secondKey)]))
+		{
+			$this->_active[$this->firstKey($firstKey)]
+				[$this->secondKey($secondKey)] .= $value;
+		}
+		else
+		{
+			$this->_active[$this->firstKey($firstKey)]
+				[$this->secondKey($secondKey)] = $value;
+		}
+	}
+
+	/**
+	 * Remove dynamic content
+	 *
+	 * @param   string         $firstKey     The first key
+	 * @param   string|null    $secondKey    The second key
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function remove_(string $firstKey, ?string $secondKey = null)
+	{
+		if (is_string($secondKey))
+		{
+			unset($this->_active[$this->firstKey($firstKey)]
+				[$this->secondKey($secondKey)]);
+		}
+		else
+		{
+			unset($this->_active[$this->firstKey($firstKey)]);
+		}
+	}
+
+	/**
+	 * Model the first key
+	 *
+	 * @param   string   $key  The first key to model
+	 *
+	 * @return  string
+	 * @since 3.2.0
+	 */
+	abstract protected function firstKey(string $key): string;
+
+	/**
+	 * Model the second key
+	 *
+	 * @param   string   $key  The second key to model
+	 *
+	 * @return  string
+	 * @since 3.2.0
+	 */
+	abstract protected function secondKey(string $key): string;
+}
+

libraries/jcb_powers/VDM.Joomla/src/Componentbuilder/Compiler/Content.php

@@ -13,6 +13,9 @@ namespace VDM\Joomla\Componentbuilder\Compiler;
 
 
 use VDM\Joomla\Componentbuilder\Compiler\Utilities\Placefix;
+use VDM\Joomla\Componentbuilder\Interfaces\Mapperdoubleinterface;
+use VDM\Joomla\Componentbuilder\Interfaces\Mappersingleinterface;
+use VDM\Joomla\Componentbuilder\Abstraction\Mapper;
 
 
 /**
@@ -20,202 +23,45 @@ use VDM\Joomla\Componentbuilder\Compiler\Utilities\Placefix;
  * 
  * @since 3.2.0
  */
-class Content
+class Content extends Mapper implements Mapperdoubleinterface, Mappersingleinterface
 {
 	/**
-	 * The Content
+	 * Model the key
 	 *
-	 * @var    array
+	 * @param   string   $key  The key to model
-	 * @since 3.2.0
-	 **/
-	public array $active = [];
-
-	/**
-	 * The Dynamic Content
 	 *
-	 * @var    array
+	 * @return  string
-	 * @since 3.2.0
-	 **/
-	public array $_active = [];
-
-	/**
-	 * Set content
-	 *
-	 * @param   string  $key    The main string key
-	 * @param   mixed   $value  The values to set
-	 *
-	 * @return  void
 	 * @since 3.2.0
 	 */
-	public function set(string $key, $value)
+	protected function key(string $key): string
 	{
-		$this->active[Placefix::_h($key)] = $value;
+		return Placefix::_h($key);
 	}
 
 	/**
-	 * Get content
+	 * Model the first key
 	 *
-	 * @param   string  $key    The main string key
+	 * @param   string   $key  The first key to model
-	 * @param   mixed   $value  The values to set
 	 *
-	 * @return  mixed
+	 * @return  string
 	 * @since 3.2.0
 	 */
-	public function get(string $key)
+	protected function firstKey(string $key): string
 	{
-		return $this->active[Placefix::_h($key)] ?? null;
+		return $key;
 	}
 
 	/**
-	 * Does key exist
+	 * Model the second key
 	 *
-	 * @param   string  $key    The main string key
+	 * @param   string   $key  The second key to model
 	 *
-	 * @return  bool
+	 * @return  string
 	 * @since 3.2.0
 	 */
-	public function exist(string $key): bool
+	protected function secondKey(string $key): string
 	{
-		if (isset($this->active[Placefix::_h($key)]))
+		return Placefix::_h($key);
-		{
-			return true;
-		}
-		return false;
 	}
-
-	/**
-	 * Add content
-	 *
-	 * @param   string  $key    The main string key
-	 * @param   mixed   $value  The values to set
-	 *
-	 * @return  void
-	 * @since 3.2.0
-	 */
-	public function add(string $key, $value)
-	{
-		if (isset($this->active[Placefix::_h($key)]))
-		{
-			$this->active[Placefix::_h($key)] .= $value;
-		}
-		else
-		{
-			$this->active[Placefix::_h($key)] = $value;
-		}
-	}
-
-	/**
-	 * Remove content
-	 *
-	 * @param   string     $key     The main string key
-	 *
-	 * @return  void
-	 * @since 3.2.0
-	 */
-	public function remove(string $key)
-	{
-		unset($this->active[Placefix::_h($key)]);
-	}
-
-	/**
-	 * Set dynamic content
-	 *
-	 * @param   string    $view    The view key
-	 * @param   string    $key     The main string key
-	 * @param   mixed     $value   The values to set
-	 *
-	 * @return  void
-	 * @since 3.2.0
-	 */
-	public function set_(string $view, string $key, $value)
-	{
-		$this->_active[$view][Placefix::_h($key)] = $value;
-	}
-
-	/**
-	 * Get dynamic content
-	 *
-	 * @param   string         $view  The view key
-	 * @param   string|null    $key   The main string key
-	 *
-	 * @return  mixed
-	 * @since 3.2.0
-	 */
-	public function get_(string $view, ?string $key = null)
-	{
-		if (is_string($key))
-		{
-			return $this->_active[$view][Placefix::_h($key)] ?? null;
-		}
-		return $this->_active[$view] ?? null;
-	}
-
-	/**
-	 * Does view key exist
-	 *
-	 * @param   string         $view    The view key
-	 * @param   string|null    $key     The main string key
-	 *
-	 * @return  bool
-	 * @since 3.2.0
-	 */
-	public function exist_(string $view, ?string $key = null): bool
-	{
-		if (is_string($key) && isset($this->_active[$view]) &&
-			isset($this->_active[$view][Placefix::_h($key)]))
-		{
-			return true;
-		}
-		elseif (is_null($key) && isset($this->_active[$view]))
-		{
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Add dynamic content
-	 *
-	 * @param   string    $view    The view key
-	 * @param   string    $key     The main string key
-	 * @param   mixed     $value   The values to set
-	 *
-	 * @return  void
-	 * @since 3.2.0
-	 */
-	public function add_(string $view, string $key, $value)
-	{
-		if (isset($this->_active[$view]) &&
-			isset($this->_active[$view][Placefix::_h($key)]))
-		{
-			$this->_active[$view][Placefix::_h($key)] .= $value;
-		}
-		else
-		{
-			$this->_active[$view][Placefix::_h($key)] = $value;
-		}
-	}
-
-	/**
-	 * Remove dynamic content
-	 *
-	 * @param   string         $view    The view key
-	 * @param   string|null    $key     The main string key
-	 *
-	 * @return  void
-	 * @since 3.2.0
-	 */
-	public function remove_(string $view, ?string $key = null)
-	{
-		if (is_string($key))
-		{
-			unset($this->_active[$view][Placefix::_h($key)]);
-		}
-		else
-		{
-			unset($this->_active[$view]);
-		}
-	}
-
 }
 

libraries/jcb_powers/VDM.Joomla/src/Componentbuilder/Compiler/Factory.php

@@ -17,6 +17,7 @@ use VDM\Joomla\Componentbuilder\Service\Crypt;
 use VDM\Joomla\Componentbuilder\Service\Server;
 use VDM\Joomla\Componentbuilder\Compiler\Service\Database;
 use VDM\Joomla\Componentbuilder\Compiler\Service\Model;
+use VDM\Joomla\Componentbuilder\Compiler\Service\Mapper;
 use VDM\Joomla\Componentbuilder\Compiler\Service\Compiler;
 use VDM\Joomla\Componentbuilder\Compiler\Service\Event;
 use VDM\Joomla\Componentbuilder\Compiler\Service\History;
@@ -113,6 +114,7 @@ abstract class Factory implements FactoryInterface
 			->registerServiceProvider(new Server())
 			->registerServiceProvider(new Database())
 			->registerServiceProvider(new Model())
+			->registerServiceProvider(new Mapper())
 			->registerServiceProvider(new Compiler())
 			->registerServiceProvider(new Event())
 			->registerServiceProvider(new History())

libraries/jcb_powers/VDM.Joomla/src/Componentbuilder/Compiler/Service/Compiler.php

@@ -16,7 +16,6 @@ use Joomla\DI\Container;
 use Joomla\DI\ServiceProviderInterface;
 use VDM\Joomla\Componentbuilder\Compiler\Config;
 use VDM\Joomla\Componentbuilder\Compiler\Registry;
-use VDM\Joomla\Componentbuilder\Compiler\Content;
 
 
 /**
@@ -41,9 +40,6 @@ class Compiler implements ServiceProviderInterface
 
 		$container->alias(Registry::class, 'Registry')
 			->share('Registry', [$this, 'getRegistry'], true);
-
-		$container->alias(Content::class, 'Content')
-			->share('Content', [$this, 'getContent'], true);
 	}
 
 	/**
@@ -72,18 +68,5 @@ class Compiler implements ServiceProviderInterface
 		return new Registry();
 	}
 
-	/**
-	 * Get the Compiler Content
-	 *
-	 * @param   Container  $container  The DI container.
-	 *
-	 * @return  Content
-	 * @since 3.2.0
-	 */
-	public function getContent(Container $container): Content
-	{
-		return new Content();
-	}
-
 }
 

libraries/jcb_powers/VDM.Joomla/src/Componentbuilder/Compiler/Service/Mapper.php

@@ -0,0 +1,55 @@
+<?php
+/**
+ * @package    Joomla.Component.Builder
+ *
+ * @created    4th September, 2022
+ * @author     Llewellyn van der Merwe <https://dev.vdm.io>
+ * @git        Joomla Component Builder <https://git.vdm.dev/joomla/Component-Builder>
+ * @copyright  Copyright (C) 2015 Vast Development Method. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE.txt
+ */
+
+namespace VDM\Joomla\Componentbuilder\Compiler\Service;
+
+
+use Joomla\DI\Container;
+use Joomla\DI\ServiceProviderInterface;
+use VDM\Joomla\Componentbuilder\Compiler\Content;
+
+
+/**
+ * Mapper Service Provider
+ * 
+ * @since 3.2.0
+ */
+class Mapper implements ServiceProviderInterface
+{
+	/**
+	 * Registers the service provider with a DI container.
+	 *
+	 * @param   Container  $container  The DI container.
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function register(Container $container)
+	{
+		$container->alias(Content::class, 'Content')
+			->share('Content', [$this, 'getContent'], true);
+	}
+
+	/**
+	 * Get the Compiler Content
+	 *
+	 * @param   Container  $container  The DI container.
+	 *
+	 * @return  Content
+	 * @since 3.2.0
+	 */
+	public function getContent(Container $container): Content
+	{
+		return new Content();
+	}
+
+}
+

libraries/jcb_powers/VDM.Joomla/src/Componentbuilder/Compiler/Utilities/Minify.php

@@ -0,0 +1,91 @@
+<?php
+/**
+ * @package    Joomla.Component.Builder
+ *
+ * @created    4th September, 2022
+ * @author     Llewellyn van der Merwe <https://dev.vdm.io>
+ * @git        Joomla Component Builder <https://git.vdm.dev/joomla/Component-Builder>
+ * @copyright  Copyright (C) 2015 Vast Development Method. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE.txt
+ */
+
+namespace VDM\Joomla\Componentbuilder\Compiler\Utilities;
+
+
+use VDM\Minify\Css;
+use VDM\Minify\JavaScript;
+
+
+/**
+ * Compiler Minifier
+ * 
+ * @since 3.2.0
+ */
+abstract class Minify
+{
+	/**
+	 * Minify JavaScript Class
+	 *
+	 * @var JavaScript
+	 * @since 3.2.0
+	 */
+	public static JavaScript $js;
+
+	/**
+	 * Minify Css Class
+	 *
+	 * @var Css
+	 * @since 3.2.0
+	 */
+	public static Css $css;
+
+	/**
+	 * Minify JavaScript
+	 * 
+	 * @param   string  $data
+	 *
+	 * @return  string
+	 * @since 3.2.0
+	 */
+	public static function js(string $data): string
+	{
+		// check if instance already set
+		if (empty(self::$js))
+		{
+			// set instanceof on JavaScript
+			self::$js = new JavaScript;
+		}
+
+		// add the data
+		self::$js->add($data);
+
+		// return minified
+		return self::$js->minify();
+	}
+
+	/**
+	 * Minify Css
+	 * 
+	 * @param   string  $data
+	 *
+	 * @return  string
+	 * @since 3.2.0
+	 */
+	public static function css(string $data): string
+	{
+		// check if instance already set
+		if (empty(self::$css))
+		{
+			// set instanceof on Css
+			self::$css = new Css;
+		}
+
+		// add the data
+		self::$css->add($data);
+
+		// return minified
+		return self::$css->minify();
+	}
+
+}
+

libraries/jcb_powers/VDM.Joomla/src/Componentbuilder/Interfaces/Mapperdoubleinterface.php

@@ -0,0 +1,78 @@
+<?php
+/**
+ * @package    Joomla.Component.Builder
+ *
+ * @created    4th September, 2022
+ * @author     Llewellyn van der Merwe <https://dev.vdm.io>
+ * @git        Joomla Component Builder <https://git.vdm.dev/joomla/Component-Builder>
+ * @copyright  Copyright (C) 2015 Vast Development Method. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE.txt
+ */
+
+namespace VDM\Joomla\Componentbuilder\Interfaces;
+
+
+/**
+ * The Double Mapper Interface
+ */
+interface Mapperdoubleinterface
+{
+	/**
+	 * Set dynamic content
+	 *
+	 * @param   string    $firstKey    The first key
+	 * @param   string    $secondKey   The second key
+	 * @param   mixed     $value       The values to set
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function set_(string $firstKey, string $secondKey, $value);
+
+	/**
+	 * Get dynamic content
+	 *
+	 * @param   string    $firstKey     The first key
+	 * @param   string    $secondKey    The second key
+	 *
+	 * @return  mixed
+	 * @since 3.2.0
+	 */
+	public function get_(string $firstKey, ?string $secondKey = null);
+
+	/**
+	 * Does keys exist
+	 *
+	 * @param   string        $firstKey     The first key
+	 * @param   string|null   $secondKey    The second key
+	 *
+	 * @return  bool
+	 * @since 3.2.0
+	 */
+	public function exist_(string $firstKey, ?string $secondKey = null): bool;
+
+	/**
+	 * Add dynamic content
+	 *
+	 * @param   string    $firstKey     The first key
+	 * @param   string    $secondKey    The second key
+	 * @param   mixed     $value        The values to set
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function add_(string $firstKey, string $secondKey, $value);
+
+	/**
+	 * Remove dynamic content
+	 *
+	 * @param   string         $firstKey     The first key
+	 * @param   string|null    $secondKey    The second key
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function remove_(string $firstKey, ?string $secondKey = null);
+
+}
+

libraries/jcb_powers/VDM.Joomla/src/Componentbuilder/Interfaces/Mappersingleinterface.php

@@ -0,0 +1,74 @@
+<?php
+/**
+ * @package    Joomla.Component.Builder
+ *
+ * @created    4th September, 2022
+ * @author     Llewellyn van der Merwe <https://dev.vdm.io>
+ * @git        Joomla Component Builder <https://git.vdm.dev/joomla/Component-Builder>
+ * @copyright  Copyright (C) 2015 Vast Development Method. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE.txt
+ */
+
+namespace VDM\Joomla\Componentbuilder\Interfaces;
+
+
+/**
+ * The Single Mapper Interface
+ */
+interface Mappersingleinterface
+{
+	/**
+	 * Set content
+	 *
+	 * @param   string  $key    The main string key
+	 * @param   mixed   $value  The values to set
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function set(string $key, $value);
+
+	/**
+	 * Get content
+	 *
+	 * @param   string  $key    The main string key
+	 * @param   mixed   $value  The values to set
+	 *
+	 * @return  mixed
+	 * @since 3.2.0
+	 */
+	public function get(string $key);
+
+	/**
+	 * Does key exist
+	 *
+	 * @param   string  $key    The main string key
+	 *
+	 * @return  bool
+	 * @since 3.2.0
+	 */
+	public function exist(string $key): bool;
+
+	/**
+	 * Add content
+	 *
+	 * @param   string  $key    The main string key
+	 * @param   mixed   $value  The values to set
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function add(string $key, $value);
+
+	/**
+	 * Remove content
+	 *
+	 * @param   string     $key     The main string key
+	 *
+	 * @return  void
+	 * @since 3.2.0
+	 */
+	public function remove(string $key);
+
+}
+

libraries/jcb_powers/VDM.Joomla/src/Componentbuilder/Server/Model/Load.php

@@ -101,6 +101,7 @@ class Load extends Model implements ModelInterface
 				break;
 			}
 		}
+
 		return $value;
 	}
 

libraries/jcb_powers/VDM.Joomla/src/Utilities/ArrayHelper.php

@@ -24,9 +24,9 @@ abstract class ArrayHelper
 	 *
 	 * @input	array   The array to check
 	 *
-	 * @returns bool/int  number of items in array on success
+	 * @returns int|false  number of items in array on success
 	 * 
-	 * @since  3.0.9
+	 * @since  3.2.0
 	 */
 	public static function check($array, $removeEmptyString = false)
 	{
@@ -35,17 +35,19 @@ abstract class ArrayHelper
 			// also make sure the empty strings are removed
 			if ($removeEmptyString)
 			{
-				foreach ($array as $key => $string)
+				$array = array_filter($array);
+
+				if (empty($array))
 				{
-					if (empty($string))
+					return false;
-					{
-						unset($array[$key]);
-					}
 				}
-				return self::check($array, false);
+
+				return count($array);
 			}
+
 			return $nr;
 		}
+
 		return false;
 	}
 
@@ -54,25 +56,25 @@ abstract class ArrayHelper
 	 *
 	 * @input	array   The arrays you would like to merge
 	 *
-	 * @returns array on success
+	 * @returns array|null  merged array on success
 	 * 
 	 * @since  3.0.9
 	 */
-	public static function merge($arrays)
+	public static function merge($arrays): ?array
 	{
 		if(self::check($arrays))
 		{
-			$arrayBuket = array();
+			$merged = [];
 			foreach ($arrays as $array)
 			{
 				if (self::check($array))
 				{
-					$arrayBuket = array_merge($arrayBuket, $array);
+					$merged = array_merge($merged, $array);
 				}
 			}
-			return $arrayBuket;
+			return $merged;
 		}
-		return false;
+		return null;
 	}
 
 	/**

libraries/jcb_powers/VDM.Minify/index.html

@@ -0,0 +1 @@
+<html><body bgcolor="#FFFFFF"></body></html>

libraries/jcb_powers/VDM.Minify/src/Abstraction/BasicException.php

@@ -0,0 +1,26 @@
+<?php
+/**
+ * Basic exception.
+ *
+ * Please report bugs on https://github.com/matthiasmullie/minify/issues
+ *
+ * @author Matthias Mullie <minify@mullie.eu>
+ * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+namespace VDM\Minify\Abstraction;
+
+
+/**
+ * Basic exception.
+ *
+ * Please report bugs on https://github.com/matthiasmullie/minify/issues
+ *
+ * @author Matthias Mullie 
+ * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+abstract class BasicException extends \Exception
+{
+}
+

libraries/jcb_powers/VDM.Minify/src/Abstraction/Minify.php

@@ -0,0 +1,513 @@
+<?php
+/**
+ * Abstract minifier class.
+ *
+ * Please report bugs on https://github.com/matthiasmullie/minify/issues
+ *
+ * @author Matthias Mullie <minify@mullie.eu>
+ * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+
+namespace VDM\Minify\Abstraction;
+
+
+use VDM\Minify\Exceptions\IOException;
+use VDM\Psr\Cache\CacheItemInterface;
+
+
+/**
+ * Abstract minifier class.
+ *
+ * Please report bugs on https://github.com/matthiasmullie/minify/issues
+ *
+ * @author Matthias Mullie 
+ * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+abstract class Minify
+{
+    /**
+     * The data to be minified.
+     *
+     * @var string[]
+     */
+    protected $data = array();
+
+    /**
+     * Array of patterns to match.
+     *
+     * @var string[]
+     */
+    protected $patterns = array();
+
+    /**
+     * This array will hold content of strings and regular expressions that have
+     * been extracted from the JS source code, so we can reliably match "code",
+     * without having to worry about potential "code-like" characters inside.
+     *
+     * @internal
+     *
+     * @var string[]
+     */
+    public $extracted = array();
+
+    /**
+     * Init the minify class - optionally, code may be passed along already.
+     */
+    public function __construct(/* $data = null, ... */)
+    {
+        // it's possible to add the source through the constructor as well ;)
+        if (func_num_args()) {
+            call_user_func_array(array($this, 'add'), func_get_args());
+        }
+    }
+
+    /**
+     * Add a file or straight-up code to be minified.
+     *
+     * @param string|string[] $data
+     *
+     * @return static
+     */
+    public function add($data /* $data = null, ... */)
+    {
+        // bogus "usage" of parameter $data: scrutinizer warns this variable is
+        // not used (we're using func_get_args instead to support overloading),
+        // but it still needs to be defined because it makes no sense to have
+        // this function without argument :)
+        $args = array($data) + func_get_args();
+
+        // this method can be overloaded
+        foreach ($args as $data) {
+            if (is_array($data)) {
+                call_user_func_array(array($this, 'add'), $data);
+                continue;
+            }
+
+            // redefine var
+            $data = (string) $data;
+
+            // load data
+            $value = $this->load($data);
+            $key = ($data != $value) ? $data : count($this->data);
+
+            // replace CR linefeeds etc.
+            // @see https://github.com/matthiasmullie/minify/pull/139
+            $value = str_replace(array("\r\n", "\r"), "\n", $value);
+
+            // store data
+            $this->data[$key] = $value;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Add a file to be minified.
+     *
+     * @param string|string[] $data
+     *
+     * @return static
+     *
+     * @throws IOException
+     */
+    public function addFile($data /* $data = null, ... */)
+    {
+        // bogus "usage" of parameter $data: scrutinizer warns this variable is
+        // not used (we're using func_get_args instead to support overloading),
+        // but it still needs to be defined because it makes no sense to have
+        // this function without argument :)
+        $args = array($data) + func_get_args();
+
+        // this method can be overloaded
+        foreach ($args as $path) {
+            if (is_array($path)) {
+                call_user_func_array(array($this, 'addFile'), $path);
+                continue;
+            }
+
+            // redefine var
+            $path = (string) $path;
+
+            // check if we can read the file
+            if (!$this->canImportFile($path)) {
+                throw new IOException('The file "' . $path . '" could not be opened for reading. Check if PHP has enough permissions.');
+            }
+
+            $this->add($path);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Minify the data & (optionally) saves it to a file.
+     *
+     * @param string[optional] $path Path to write the data to
+     *
+     * @return string The minified data
+     */
+    public function minify($path = null)
+    {
+        $content = $this->execute($path);
+
+        // save to path
+        if ($path !== null) {
+            $this->save($content, $path);
+        }
+
+        return $content;
+    }
+
+    /**
+     * Minify & gzip the data & (optionally) saves it to a file.
+     *
+     * @param string[optional] $path  Path to write the data to
+     * @param int[optional]    $level Compression level, from 0 to 9
+     *
+     * @return string The minified & gzipped data
+     */
+    public function gzip($path = null, $level = 9)
+    {
+        $content = $this->execute($path);
+        $content = gzencode($content, $level, FORCE_GZIP);
+
+        // save to path
+        if ($path !== null) {
+            $this->save($content, $path);
+        }
+
+        return $content;
+    }
+
+    /**
+     * Minify the data & write it to a CacheItemInterface object.
+     *
+     * @param CacheItemInterface $item Cache item to write the data to
+     *
+     * @return CacheItemInterface Cache item with the minifier data
+     */
+    public function cache(CacheItemInterface $item)
+    {
+        $content = $this->execute();
+        $item->set($content);
+
+        return $item;
+    }
+
+    /**
+     * Minify the data.
+     *
+     * @param string[optional] $path Path to write the data to
+     *
+     * @return string The minified data
+     */
+    abstract public function execute($path = null);
+
+    /**
+     * Load data.
+     *
+     * @param string $data Either a path to a file or the content itself
+     *
+     * @return string
+     */
+    protected function load($data)
+    {
+        // check if the data is a file
+        if ($this->canImportFile($data)) {
+            $data = file_get_contents($data);
+
+            // strip BOM, if any
+            if (substr($data, 0, 3) == "\xef\xbb\xbf") {
+                $data = substr($data, 3);
+            }
+        }
+
+        return $data;
+    }
+
+    /**
+     * Save to file.
+     *
+     * @param string $content The minified data
+     * @param string $path    The path to save the minified data to
+     *
+     * @throws IOException
+     */
+    protected function save($content, $path)
+    {
+        $handler = $this->openFileForWriting($path);
+
+        $this->writeToFile($handler, $content);
+
+        @fclose($handler);
+    }
+
+    /**
+     * Register a pattern to execute against the source content.
+     *
+     * If $replacement is a string, it must be plain text. Placeholders like $1 or \2 don't work.
+     * If you need that functionality, use a callback instead.
+     *
+     * @param string          $pattern     PCRE pattern
+     * @param string|callable $replacement Replacement value for matched pattern
+     */
+    protected function registerPattern($pattern, $replacement = '')
+    {
+        // study the pattern, we'll execute it more than once
+        $pattern .= 'S';
+
+        $this->patterns[] = array($pattern, $replacement);
+    }
+
+    /**
+     * We can't "just" run some regular expressions against JavaScript: it's a
+     * complex language. E.g. having an occurrence of // xyz would be a comment,
+     * unless it's used within a string. Of you could have something that looks
+     * like a 'string', but inside a comment.
+     * The only way to accurately replace these pieces is to traverse the JS one
+     * character at a time and try to find whatever starts first.
+     *
+     * @param string $content The content to replace patterns in
+     *
+     * @return string The (manipulated) content
+     */
+    protected function replace($content)
+    {
+        $contentLength = strlen($content);
+        $output = '';
+        $processedOffset = 0;
+        $positions = array_fill(0, count($this->patterns), -1);
+        $matches = array();
+
+        while ($processedOffset < $contentLength) {
+            // find first match for all patterns
+            foreach ($this->patterns as $i => $pattern) {
+                list($pattern, $replacement) = $pattern;
+
+                // we can safely ignore patterns for positions we've unset earlier,
+                // because we know these won't show up anymore
+                if (array_key_exists($i, $positions) == false) {
+                    continue;
+                }
+
+                // no need to re-run matches that are still in the part of the
+                // content that hasn't been processed
+                if ($positions[$i] >= $processedOffset) {
+                    continue;
+                }
+
+                $match = null;
+                if (preg_match($pattern, $content, $match, PREG_OFFSET_CAPTURE, $processedOffset)) {
+                    $matches[$i] = $match;
+
+                    // we'll store the match position as well; that way, we
+                    // don't have to redo all preg_matches after changing only
+                    // the first (we'll still know where those others are)
+                    $positions[$i] = $match[0][1];
+                } else {
+                    // if the pattern couldn't be matched, there's no point in
+                    // executing it again in later runs on this same content;
+                    // ignore this one until we reach end of content
+                    unset($matches[$i], $positions[$i]);
+                }
+            }
+
+            // no more matches to find: everything's been processed, break out
+            if (!$matches) {
+                // output the remaining content
+                $output .= substr($content, $processedOffset);
+                break;
+            }
+
+            // see which of the patterns actually found the first thing (we'll
+            // only want to execute that one, since we're unsure if what the
+            // other found was not inside what the first found)
+            $matchOffset = min($positions);
+            $firstPattern = array_search($matchOffset, $positions);
+            $match = $matches[$firstPattern];
+
+            // execute the pattern that matches earliest in the content string
+            list(, $replacement) = $this->patterns[$firstPattern];
+
+            // add the part of the input between $processedOffset and the first match;
+            // that content wasn't matched by anything
+            $output .= substr($content, $processedOffset, $matchOffset - $processedOffset);
+            // add the replacement for the match
+            $output .= $this->executeReplacement($replacement, $match);
+            // advance $processedOffset past the match
+            $processedOffset = $matchOffset + strlen($match[0][0]);
+        }
+
+        return $output;
+    }
+
+    /**
+     * If $replacement is a callback, execute it, passing in the match data.
+     * If it's a string, just pass it through.
+     *
+     * @param string|callable $replacement Replacement value
+     * @param array           $match       Match data, in PREG_OFFSET_CAPTURE form
+     *
+     * @return string
+     */
+    protected function executeReplacement($replacement, $match)
+    {
+        if (!is_callable($replacement)) {
+            return $replacement;
+        }
+        // convert $match from the PREG_OFFSET_CAPTURE form to the form the callback expects
+        foreach ($match as &$matchItem) {
+            $matchItem = $matchItem[0];
+        }
+
+        return $replacement($match);
+    }
+
+    /**
+     * Strings are a pattern we need to match, in order to ignore potential
+     * code-like content inside them, but we just want all of the string
+     * content to remain untouched.
+     *
+     * This method will replace all string content with simple STRING#
+     * placeholder text, so we've rid all strings from characters that may be
+     * misinterpreted. Original string content will be saved in $this->extracted
+     * and after doing all other minifying, we can restore the original content
+     * via restoreStrings().
+     *
+     * @param string[optional] $chars
+     * @param string[optional] $placeholderPrefix
+     */
+    protected function extractStrings($chars = '\'"', $placeholderPrefix = '')
+    {
+        // PHP only supports $this inside anonymous functions since 5.4
+        $minifier = $this;
+        $callback = function ($match) use ($minifier, $placeholderPrefix) {
+            // check the second index here, because the first always contains a quote
+            if ($match[2] === '') {
+                /*
+                 * Empty strings need no placeholder; they can't be confused for
+                 * anything else anyway.
+                 * But we still needed to match them, for the extraction routine
+                 * to skip over this particular string.
+                 */
+                return $match[0];
+            }
+
+            $count = count($minifier->extracted);
+            $placeholder = $match[1] . $placeholderPrefix . $count . $match[1];
+            $minifier->extracted[$placeholder] = $match[1] . $match[2] . $match[1];
+
+            return $placeholder;
+        };
+
+        /*
+         * The \\ messiness explained:
+         * * Don't count ' or " as end-of-string if it's escaped (has backslash
+         * in front of it)
+         * * Unless... that backslash itself is escaped (another leading slash),
+         * in which case it's no longer escaping the ' or "
+         * * So there can be either no backslash, or an even number
+         * * multiply all of that times 4, to account for the escaping that has
+         * to be done to pass the backslash into the PHP string without it being
+         * considered as escape-char (times 2) and to get it in the regex,
+         * escaped (times 2)
+         */
+        $this->registerPattern('/([' . $chars . '])(.*?(?<!\\\\)(\\\\\\\\)*+)\\1/s', $callback);
+    }
+
+    /**
+     * This method will restore all extracted data (strings, regexes) that were
+     * replaced with placeholder text in extract*(). The original content was
+     * saved in $this->extracted.
+     *
+     * @param string $content
+     *
+     * @return string
+     */
+    protected function restoreExtractedData($content)
+    {
+        if (!$this->extracted) {
+            // nothing was extracted, nothing to restore
+            return $content;
+        }
+
+        $content = strtr($content, $this->extracted);
+
+        $this->extracted = array();
+
+        return $content;
+    }
+
+    /**
+     * Check if the path is a regular file and can be read.
+     *
+     * @param string $path
+     *
+     * @return bool
+     */
+    protected function canImportFile($path)
+    {
+        $parsed = parse_url($path);
+        if (
+            // file is elsewhere
+            isset($parsed['host']) ||
+            // file responds to queries (may change, or need to bypass cache)
+            isset($parsed['query'])
+        ) {
+            return false;
+        }
+
+        return strlen($path) < PHP_MAXPATHLEN && @is_file($path) && is_readable($path);
+    }
+
+    /**
+     * Attempts to open file specified by $path for writing.
+     *
+     * @param string $path The path to the file
+     *
+     * @return resource Specifier for the target file
+     *
+     * @throws IOException
+     */
+    protected function openFileForWriting($path)
+    {
+        if ($path === '' || ($handler = @fopen($path, 'w')) === false) {
+            throw new IOException('The file "' . $path . '" could not be opened for writing. Check if PHP has enough permissions.');
+        }
+
+        return $handler;
+    }
+
+    /**
+     * Attempts to write $content to the file specified by $handler. $path is used for printing exceptions.
+     *
+     * @param resource $handler The resource to write to
+     * @param string   $content The content to write
+     * @param string   $path    The path to the file (for exception printing only)
+     *
+     * @throws IOException
+     */
+    protected function writeToFile($handler, $content, $path = '')
+    {
+        if (
+            !is_resource($handler) ||
+            ($result = @fwrite($handler, $content)) === false ||
+            ($result < strlen($content))
+        ) {
+            throw new IOException('The file "' . $path . '" could not be written to. Check your disk space and file permissions.');
+        }
+    }
+
+    protected static function str_replace_first($search, $replace, $subject)
+    {
+        $pos = strpos($subject, $search);
+        if ($pos !== false) {
+            return substr_replace($subject, $replace, $pos, strlen($search));
+        }
+
+        return $subject;
+    }
+}
+

libraries/jcb_powers/VDM.Minify/src/Abstraction/index.html

@@ -0,0 +1 @@
+<html><body bgcolor="#FFFFFF"></body></html>

libraries/jcb_powers/VDM.Minify/src/Css.php

@@ -0,0 +1,758 @@
+<?php
+/**
+ * CSS Minifier.
+ *
+ * Please report bugs on https://github.com/matthiasmullie/minify/issues
+ *
+ * @author Matthias Mullie <minify@mullie.eu>
+ * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+namespace VDM\Minify;
+
+
+use VDM\Minify\Exceptions\FileImportException;
+use VDM\Minify\Path\Converter;
+use VDM\Minify\Path\Interfaces\ConverterInterface;
+use VDM\Minify\Abstraction\Minify;
+
+
+/**
+ * CSS minifier.
+ *
+ * Please report bugs on https://github.com/matthiasmullie/minify/issues
+ *
+ * @author Matthias Mullie 
+ * @author Tijs Verkoyen 
+ * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+class Css extends Minify
+{
+    /**
+     * @var int maximum inport size in kB
+     */
+    protected $maxImportSize = 5;
+
+    /**
+     * @var string[] valid import extensions
+     */
+    protected $importExtensions = array(
+        'gif' => 'data:image/gif',
+        'png' => 'data:image/png',
+        'jpe' => 'data:image/jpeg',
+        'jpg' => 'data:image/jpeg',
+        'jpeg' => 'data:image/jpeg',
+        'svg' => 'data:image/svg+xml',
+        'woff' => 'data:application/x-font-woff',
+        'woff2' => 'data:application/x-font-woff2',
+        'avif' => 'data:image/avif',
+        'apng' => 'data:image/apng',
+        'webp' => 'data:image/webp',
+        'tif' => 'image/tiff',
+        'tiff' => 'image/tiff',
+        'xbm' => 'image/x-xbitmap',
+    );
+
+    /**
+     * Set the maximum size if files to be imported.
+     *
+     * Files larger than this size (in kB) will not be imported into the CSS.
+     * Importing files into the CSS as data-uri will save you some connections,
+     * but we should only import relatively small decorative images so that our
+     * CSS file doesn't get too bulky.
+     *
+     * @param int $size Size in kB
+     */
+    public function setMaxImportSize($size)
+    {
+        $this->maxImportSize = $size;
+    }
+
+    /**
+     * Set the type of extensions to be imported into the CSS (to save network
+     * connections).
+     * Keys of the array should be the file extensions & respective values
+     * should be the data type.
+     *
+     * @param string[] $extensions Array of file extensions
+     */
+    public function setImportExtensions(array $extensions)
+    {
+        $this->importExtensions = $extensions;
+    }
+
+    /**
+     * Move any import statements to the top.
+     *
+     * @param string $content Nearly finished CSS content
+     *
+     * @return string
+     */
+    protected function moveImportsToTop($content)
+    {
+        if (preg_match_all('/(;?)(@import (?<url>url\()?(?P<quotes>["\']?).+?(?P=quotes)(?(url)\)));?/', $content, $matches)) {
+            // remove from content
+            foreach ($matches[0] as $import) {
+                $content = str_replace($import, '', $content);
+            }
+
+            // add to top
+            $content = implode(';', $matches[2]) . ';' . trim($content, ';');
+        }
+
+        return $content;
+    }
+
+    /**
+     * Combine CSS from import statements.
+     *
+     * Import statements will be loaded and their content merged into the original
+     * file, to save HTTP requests.
+     *
+     * @param string   $source  The file to combine imports for
+     * @param string   $content The CSS content to combine imports for
+     * @param string[] $parents Parent paths, for circular reference checks
+     *
+     * @return string
+     *
+     * @throws FileImportException
+     */
+    protected function combineImports($source, $content, $parents)
+    {
+        $importRegexes = array(
+            // @import url(xxx)
+            '/
+            # import statement
+            @import
+            # whitespace
+            \s+
+                # open url()
+                url\(
+                    # (optional) open path enclosure
+                    (?P<quotes>["\']?)
+                        # fetch path
+                        (?P<path>.+?)
+                    # (optional) close path enclosure
+                    (?P=quotes)
+                # close url()
+                \)
+                # (optional) trailing whitespace
+                \s*
+                # (optional) media statement(s)
+                (?P<media>[^;]*)
+                # (optional) trailing whitespace
+                \s*
+            # (optional) closing semi-colon
+            ;?
+            /ix',
+
+            // @import 'xxx'
+            '/
+            # import statement
+            @import
+            # whitespace
+            \s+
+                # open path enclosure
+                (?P<quotes>["\'])
+                    # fetch path
+                    (?P<path>.+?)
+                # close path enclosure
+                (?P=quotes)
+                # (optional) trailing whitespace
+                \s*
+                # (optional) media statement(s)
+                (?P<media>[^;]*)
+                # (optional) trailing whitespace
+                \s*
+            # (optional) closing semi-colon
+            ;?
+            /ix',
+        );
+
+        // find all relative imports in css
+        $matches = array();
+        foreach ($importRegexes as $importRegex) {
+            if (preg_match_all($importRegex, $content, $regexMatches, PREG_SET_ORDER)) {
+                $matches = array_merge($matches, $regexMatches);
+            }
+        }
+
+        $search = array();
+        $replace = array();
+
+        // loop the matches
+        foreach ($matches as $match) {
+            // get the path for the file that will be imported
+            $importPath = dirname($source) . '/' . $match['path'];
+
+            // only replace the import with the content if we can grab the
+            // content of the file
+            if (!$this->canImportByPath($match['path']) || !$this->canImportFile($importPath)) {
+                continue;
+            }
+
+            // check if current file was not imported previously in the same
+            // import chain.
+            if (in_array($importPath, $parents)) {
+                throw new FileImportException('Failed to import file "' . $importPath . '": circular reference detected.');
+            }
+
+            // grab referenced file & minify it (which may include importing
+            // yet other @import statements recursively)
+            $minifier = new self($importPath);
+            $minifier->setMaxImportSize($this->maxImportSize);
+            $minifier->setImportExtensions($this->importExtensions);
+            $importContent = $minifier->execute($source, $parents);
+
+            // check if this is only valid for certain media
+            if (!empty($match['media'])) {
+                $importContent = '@media ' . $match['media'] . '{' . $importContent . '}';
+            }
+
+            // add to replacement array
+            $search[] = $match[0];
+            $replace[] = $importContent;
+        }
+
+        // replace the import statements
+        return str_replace($search, $replace, $content);
+    }
+
+    /**
+     * Import files into the CSS, base64-ized.
+     *
+     * @url(image.jpg) images will be loaded and their content merged into the
+     * original file, to save HTTP requests.
+     *
+     * @param string $source  The file to import files for
+     * @param string $content The CSS content to import files for
+     *
+     * @return string
+     */
+    protected function importFiles($source, $content)
+    {
+        $regex = '/url\((["\']?)(.+?)\\1\)/i';
+        if ($this->importExtensions && preg_match_all($regex, $content, $matches, PREG_SET_ORDER)) {
+            $search = array();
+            $replace = array();
+
+            // loop the matches
+            foreach ($matches as $match) {
+                $extension = substr(strrchr($match[2], '.'), 1);
+                if ($extension && !array_key_exists($extension, $this->importExtensions)) {
+                    continue;
+                }
+
+                // get the path for the file that will be imported
+                $path = $match[2];
+                $path = dirname($source) . '/' . $path;
+
+                // only replace the import with the content if we're able to get
+                // the content of the file, and it's relatively small
+                if ($this->canImportFile($path) && $this->canImportBySize($path)) {
+                    // grab content && base64-ize
+                    $importContent = $this->load($path);
+                    $importContent = base64_encode($importContent);
+
+                    // build replacement
+                    $search[] = $match[0];
+                    $replace[] = 'url(' . $this->importExtensions[$extension] . ';base64,' . $importContent . ')';
+                }
+            }
+
+            // replace the import statements
+            $content = str_replace($search, $replace, $content);
+        }
+
+        return $content;
+    }
+
+    /**
+     * Minify the data.
+     * Perform CSS optimizations.
+     *
+     * @param string[optional] $path    Path to write the data to
+     * @param string[] $parents Parent paths, for circular reference checks
+     *
+     * @return string The minified data
+     */
+    public function execute($path = null, $parents = array())
+    {
+        $content = '';
+
+        // loop CSS data (raw data and files)
+        foreach ($this->data as $source => $css) {
+            /*
+             * Let's first take out strings & comments, since we can't just
+             * remove whitespace anywhere. If whitespace occurs inside a string,
+             * we should leave it alone. E.g.:
+             * p { content: "a   test" }
+             */
+            $this->extractStrings();
+            $this->stripComments();
+            $this->extractMath();
+            $this->extractCustomProperties();
+            $css = $this->replace($css);
+
+            $css = $this->stripWhitespace($css);
+            $css = $this->shortenColors($css);
+            $css = $this->shortenZeroes($css);
+            $css = $this->shortenFontWeights($css);
+            $css = $this->stripEmptyTags($css);
+
+            // restore the string we've extracted earlier
+            $css = $this->restoreExtractedData($css);
+
+            $source = is_int($source) ? '' : $source;
+            $parents = $source ? array_merge($parents, array($source)) : $parents;
+            $css = $this->combineImports($source, $css, $parents);
+            $css = $this->importFiles($source, $css);
+
+            /*
+             * If we'll save to a new path, we'll have to fix the relative paths
+             * to be relative no longer to the source file, but to the new path.
+             * If we don't write to a file, fall back to same path so no
+             * conversion happens (because we still want it to go through most
+             * of the move code, which also addresses url() & @import syntax...)
+             */
+            $converter = $this->getPathConverter($source, $path ?: $source);
+            $css = $this->move($converter, $css);
+
+            // combine css
+            $content .= $css;
+        }
+
+        $content = $this->moveImportsToTop($content);
+
+        return $content;
+    }
+
+    /**
+     * Moving a css file should update all relative urls.
+     * Relative references (e.g. ../images/image.gif) in a certain css file,
+     * will have to be updated when a file is being saved at another location
+     * (e.g. ../../images/image.gif, if the new CSS file is 1 folder deeper).
+     *
+     * @param ConverterInterface $converter Relative path converter
+     * @param string             $content   The CSS content to update relative urls for
+     *
+     * @return string
+     */
+    protected function move(ConverterInterface $converter, $content)
+    {
+        /*
+         * Relative path references will usually be enclosed by url(). @import
+         * is an exception, where url() is not necessary around the path (but is
+         * allowed).
+         * This *could* be 1 regular expression, where both regular expressions
+         * in this array are on different sides of a |. But we're using named
+         * patterns in both regexes, the same name on both regexes. This is only
+         * possible with a (?J) modifier, but that only works after a fairly
+         * recent PCRE version. That's why I'm doing 2 separate regular
+         * expressions & combining the matches after executing of both.
+         */
+        $relativeRegexes = array(
+            // url(xxx)
+            '/
+            # open url()
+            url\(
+                \s*
+                # open path enclosure
+                (?P<quotes>["\'])?
+                    # fetch path
+                    (?P<path>.+?)
+                # close path enclosure
+                (?(quotes)(?P=quotes))
+                \s*
+            # close url()
+            \)
+            /ix',
+
+            // @import "xxx"
+            '/
+            # import statement
+            @import
+            # whitespace
+            \s+
+                # we don\'t have to check for @import url(), because the
+                # condition above will already catch these
+                # open path enclosure
+                (?P<quotes>["\'])
+                    # fetch path
+                    (?P<path>.+?)
+                # close path enclosure
+                (?P=quotes)
+            /ix',
+        );
+
+        // find all relative urls in css
+        $matches = array();
+        foreach ($relativeRegexes as $relativeRegex) {
+            if (preg_match_all($relativeRegex, $content, $regexMatches, PREG_SET_ORDER)) {
+                $matches = array_merge($matches, $regexMatches);
+            }
+        }
+
+        $search = array();
+        $replace = array();
+
+        // loop all urls
+        foreach ($matches as $match) {
+            // determine if it's a url() or an @import match
+            $type = (strpos($match[0], '@import') === 0 ? 'import' : 'url');
+
+            $url = $match['path'];
+            if ($this->canImportByPath($url)) {
+                // attempting to interpret GET-params makes no sense, so let's discard them for awhile
+                $params = strrchr($url, '?');
+                $url = $params ? substr($url, 0, -strlen($params)) : $url;
+
+                // fix relative url
+                $url = $converter->convert($url);
+
+                // now that the path has been converted, re-apply GET-params
+                $url .= $params;
+            }
+
+            /*
+             * Urls with control characters above 0x7e should be quoted.
+             * According to Mozilla's parser, whitespace is only allowed at the
+             * end of unquoted urls.
+             * Urls with `)` (as could happen with data: uris) should also be
+             * quoted to avoid being confused for the url() closing parentheses.
+             * And urls with a # have also been reported to cause issues.
+             * Urls with quotes inside should also remain escaped.
+             *
+             * @see https://developer.mozilla.org/nl/docs/Web/CSS/url#The_url()_functional_notation
+             * @see https://hg.mozilla.org/mozilla-central/rev/14abca4e7378
+             * @see https://github.com/matthiasmullie/minify/issues/193
+             */
+            $url = trim($url);
+            if (preg_match('/[\s\)\'"#\x{7f}-\x{9f}]/u', $url)) {
+                $url = $match['quotes'] . $url . $match['quotes'];
+            }
+
+            // build replacement
+            $search[] = $match[0];
+            if ($type === 'url') {
+                $replace[] = 'url(' . $url . ')';
+            } elseif ($type === 'import') {
+                $replace[] = '@import "' . $url . '"';
+            }
+        }
+
+        // replace urls
+        return str_replace($search, $replace, $content);
+    }
+
+    /**
+     * Shorthand hex color codes.
+     * #FF0000 -> #F00.
+     *
+     * @param string $content The CSS content to shorten the hex color codes for
+     *
+     * @return string
+     */
+    protected function shortenColors($content)
+    {
+        $content = preg_replace('/(?<=[: ])#([0-9a-z])\\1([0-9a-z])\\2([0-9a-z])\\3(?:([0-9a-z])\\4)?(?=[; }])/i', '#$1$2$3$4', $content);
+
+        // remove alpha channel if it's pointless...
+        $content = preg_replace('/(?<=[: ])#([0-9a-z]{6})ff?(?=[; }])/i', '#$1', $content);
+        $content = preg_replace('/(?<=[: ])#([0-9a-z]{3})f?(?=[; }])/i', '#$1', $content);
+
+        $colors = array(
+            // we can shorten some even more by replacing them with their color name
+            '#F0FFFF' => 'azure',
+            '#F5F5DC' => 'beige',
+            '#A52A2A' => 'brown',
+            '#FF7F50' => 'coral',
+            '#FFD700' => 'gold',
+            '#808080' => 'gray',
+            '#008000' => 'green',
+            '#4B0082' => 'indigo',
+            '#FFFFF0' => 'ivory',
+            '#F0E68C' => 'khaki',
+            '#FAF0E6' => 'linen',
+            '#800000' => 'maroon',
+            '#000080' => 'navy',
+            '#808000' => 'olive',
+            '#CD853F' => 'peru',
+            '#FFC0CB' => 'pink',
+            '#DDA0DD' => 'plum',
+            '#800080' => 'purple',
+            '#F00' => 'red',
+            '#FA8072' => 'salmon',
+            '#A0522D' => 'sienna',
+            '#C0C0C0' => 'silver',
+            '#FFFAFA' => 'snow',
+            '#D2B48C' => 'tan',
+            '#FF6347' => 'tomato',
+            '#EE82EE' => 'violet',
+            '#F5DEB3' => 'wheat',
+            // or the other way around
+            'WHITE' => '#fff',
+            'BLACK' => '#000',
+        );
+
+        return preg_replace_callback(
+            '/(?<=[: ])(' . implode('|', array_keys($colors)) . ')(?=[; }])/i',
+            function ($match) use ($colors) {
+                return $colors[strtoupper($match[0])];
+            },
+            $content
+        );
+    }
+
+    /**
+     * Shorten CSS font weights.
+     *
+     * @param string $content The CSS content to shorten the font weights for
+     *
+     * @return string
+     */
+    protected function shortenFontWeights($content)
+    {
+        $weights = array(
+            'normal' => 400,
+            'bold' => 700,
+        );
+
+        $callback = function ($match) use ($weights) {
+            return $match[1] . $weights[$match[2]];
+        };
+
+        return preg_replace_callback('/(font-weight\s*:\s*)(' . implode('|', array_keys($weights)) . ')(?=[;}])/', $callback, $content);
+    }
+
+    /**
+     * Shorthand 0 values to plain 0, instead of e.g. -0em.
+     *
+     * @param string $content The CSS content to shorten the zero values for
+     *
+     * @return string
+     */
+    protected function shortenZeroes($content)
+    {
+        // we don't want to strip units in `calc()` expressions:
+        // `5px - 0px` is valid, but `5px - 0` is not
+        // `10px * 0` is valid (equates to 0), and so is `10 * 0px`, but
+        // `10 * 0` is invalid
+        // we've extracted calcs earlier, so we don't need to worry about this
+
+        // reusable bits of code throughout these regexes:
+        // before & after are used to make sure we don't match lose unintended
+        // 0-like values (e.g. in #000, or in http://url/1.0)
+        // units can be stripped from 0 values, or used to recognize non 0
+        // values (where wa may be able to strip a .0 suffix)
+        $before = '(?<=[:(, ])';
+        $after = '(?=[ ,);}])';
+        $units = '(em|ex|%|px|cm|mm|in|pt|pc|ch|rem|vh|vw|vmin|vmax|vm)';
+
+        // strip units after zeroes (0px -> 0)
+        // NOTE: it should be safe to remove all units for a 0 value, but in
+        // practice, Webkit (especially Safari) seems to stumble over at least
+        // 0%, potentially other units as well. Only stripping 'px' for now.
+        // @see https://github.com/matthiasmullie/minify/issues/60
+        $content = preg_replace('/' . $before . '(-?0*(\.0+)?)(?<=0)px' . $after . '/', '\\1', $content);
+
+        // strip 0-digits (.0 -> 0)
+        $content = preg_replace('/' . $before . '\.0+' . $units . '?' . $after . '/', '0\\1', $content);
+        // strip trailing 0: 50.10 -> 50.1, 50.10px -> 50.1px
+        $content = preg_replace('/' . $before . '(-?[0-9]+\.[0-9]+)0+' . $units . '?' . $after . '/', '\\1\\2', $content);
+        // strip trailing 0: 50.00 -> 50, 50.00px -> 50px
+        $content = preg_replace('/' . $before . '(-?[0-9]+)\.0+' . $units . '?' . $after . '/', '\\1\\2', $content);
+        // strip leading 0: 0.1 -> .1, 01.1 -> 1.1
+        $content = preg_replace('/' . $before . '(-?)0+([0-9]*\.[0-9]+)' . $units . '?' . $after . '/', '\\1\\2\\3', $content);
+
+        // strip negative zeroes (-0 -> 0) & truncate zeroes (00 -> 0)
+        $content = preg_replace('/' . $before . '-?0+' . $units . '?' . $after . '/', '0\\1', $content);
+
+        // IE doesn't seem to understand a unitless flex-basis value (correct -
+        // it goes against the spec), so let's add it in again (make it `%`,
+        // which is only 1 char: 0%, 0px, 0 anything, it's all just the same)
+        // @see https://developer.mozilla.org/nl/docs/Web/CSS/flex
+        $content = preg_replace('/flex:([0-9]+\s[0-9]+\s)0([;\}])/', 'flex:${1}0%${2}', $content);
+        $content = preg_replace('/flex-basis:0([;\}])/', 'flex-basis:0%${1}', $content);
+
+        return $content;
+    }
+
+    /**
+     * Strip empty tags from source code.
+     *
+     * @param string $content
+     *
+     * @return string
+     */
+    protected function stripEmptyTags($content)
+    {
+        $content = preg_replace('/(?<=^)[^\{\};]+\{\s*\}/', '', $content);
+        $content = preg_replace('/(?<=(\}|;))[^\{\};]+\{\s*\}/', '', $content);
+
+        return $content;
+    }
+
+    /**
+     * Strip comments from source code.
+     */
+    protected function stripComments()
+    {
+        // PHP only supports $this inside anonymous functions since 5.4
+        $minifier = $this;
+        $callback = function ($match) use ($minifier) {
+            $count = count($minifier->extracted);
+            $placeholder = '/*' . $count . '*/';
+            $minifier->extracted[$placeholder] = $match[0];
+
+            return $placeholder;
+        };
+        $this->registerPattern('/\n?\/\*(!|.*?@license|.*?@preserve).*?\*\/\n?/s', $callback);
+
+        $this->registerPattern('/\/\*.*?\*\//s', '');
+    }
+
+    /**
+     * Strip whitespace.
+     *
+     * @param string $content The CSS content to strip the whitespace for
+     *
+     * @return string
+     */
+    protected function stripWhitespace($content)
+    {
+        // remove leading & trailing whitespace
+        $content = preg_replace('/^\s*/m', '', $content);
+        $content = preg_replace('/\s*$/m', '', $content);
+
+        // replace newlines with a single space
+        $content = preg_replace('/\s+/', ' ', $content);
+
+        // remove whitespace around meta characters
+        // inspired by stackoverflow.com/questions/15195750/minify-compress-css-with-regex
+        $content = preg_replace('/\s*([\*$~^|]?+=|[{};,>~]|!important\b)\s*/', '$1', $content);
+        $content = preg_replace('/([\[(:>\+])\s+/', '$1', $content);
+        $content = preg_replace('/\s+([\]\)>\+])/', '$1', $content);
+        $content = preg_replace('/\s+(:)(?![^\}]*\{)/', '$1', $content);
+
+        // whitespace around + and - can only be stripped inside some pseudo-
+        // classes, like `:nth-child(3+2n)`
+        // not in things like `calc(3px + 2px)`, shorthands like `3px -2px`, or
+        // selectors like `div.weird- p`
+        $pseudos = array('nth-child', 'nth-last-child', 'nth-last-of-type', 'nth-of-type');
+        $content = preg_replace('/:(' . implode('|', $pseudos) . ')\(\s*([+-]?)\s*(.+?)\s*([+-]?)\s*(.*?)\s*\)/', ':$1($2$3$4$5)', $content);
+
+        // remove semicolon/whitespace followed by closing bracket
+        $content = str_replace(';}', '}', $content);
+
+        return trim($content);
+    }
+
+    /**
+     * Replace all occurrences of functions that may contain math, where
+     * whitespace around operators needs to be preserved (e.g. calc, clamp).
+     */
+    protected function extractMath()
+    {
+        $functions = array('calc', 'clamp', 'min', 'max');
+        $pattern = '/\b(' . implode('|', $functions) . ')(\(.+?)(?=$|;|})/m';
+
+        // PHP only supports $this inside anonymous functions since 5.4
+        $minifier = $this;
+        $callback = function ($match) use ($minifier, $pattern, &$callback) {
+            $function = $match[1];
+            $length = strlen($match[2]);
+            $expr = '';
+            $opened = 0;
+
+            // the regular expression for extracting math has 1 significant problem:
+            // it can't determine the correct closing parenthesis...
+            // instead, it'll match a larger portion of code to where it's certain that
+            // the calc() musts have ended, and we'll figure out which is the correct
+            // closing parenthesis here, by counting how many have opened
+            for ($i = 0; $i < $length; ++$i) {
+                $char = $match[2][$i];
+                $expr .= $char;
+                if ($char === '(') {
+                    ++$opened;
+                } elseif ($char === ')' && --$opened === 0) {
+                    break;
+                }
+            }
+
+            // now that we've figured out where the calc() starts and ends, extract it
+            $count = count($minifier->extracted);
+            $placeholder = 'math(' . $count . ')';
+            $minifier->extracted[$placeholder] = $function . '(' . trim(substr($expr, 1, -1)) . ')';
+
+            // and since we've captured more code than required, we may have some leftover
+            // calc() in here too - go recursive on the remaining but of code to go figure
+            // that out and extract what is needed
+            $rest = $minifier->str_replace_first($function . $expr, '', $match[0]);
+            $rest = preg_replace_callback($pattern, $callback, $rest);
+
+            return $placeholder . $rest;
+        };
+
+        $this->registerPattern($pattern, $callback);
+    }
+
+    /**
+     * Replace custom properties, whose values may be used in scenarios where
+     * we wouldn't want them to be minified (e.g. inside calc).
+     */
+    protected function extractCustomProperties()
+    {
+        // PHP only supports $this inside anonymous functions since 5.4
+        $minifier = $this;
+        $this->registerPattern(
+            '/(?<=^|[;}{])\s*(--[^:;{}"\'\s]+)\s*:([^;{}]+)/m',
+            function ($match) use ($minifier) {
+                $placeholder = '--custom-' . count($minifier->extracted) . ':0';
+                $minifier->extracted[$placeholder] = $match[1] . ':' . trim($match[2]);
+
+                return $placeholder;
+            }
+        );
+    }
+
+    /**
+     * Check if file is small enough to be imported.
+     *
+     * @param string $path The path to the file
+     *
+     * @return bool
+     */
+    protected function canImportBySize($path)
+    {
+        return ($size = @filesize($path)) && $size <= $this->maxImportSize * 1024;
+    }
+
+    /**
+     * Check if file a file can be imported, going by the path.
+     *
+     * @param string $path
+     *
+     * @return bool
+     */
+    protected function canImportByPath($path)
+    {
+        return preg_match('/^(data:|https?:|\\/)/', $path) === 0;
+    }
+
+    /**
+     * Return a converter to update relative paths to be relative to the new
+     * destination.
+     *
+     * @param string $source
+     * @param string $target
+     *
+     * @return ConverterInterface
+     */
+    protected function getPathConverter($source, $target)
+    {
+        return new Converter($source, $target);
+    }
+}
+

libraries/jcb_powers/VDM.Minify/src/Exceptions/FileImportException.php

@@ -0,0 +1,25 @@
+<?php
+/**
+ * File Import Exception.
+ *
+ * Please report bugs on https://github.com/matthiasmullie/minify/issues
+ *
+ * @author Matthias Mullie <minify@mullie.eu>
+ * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+namespace VDM\Minify\Exceptions;
+
+
+use VDM\Minify\Abstraction\BasicException;
+
+
+/**
+ * File Import Exception Class.
+ *
+ * @author Matthias Mullie 
+ */
+class FileImportException extends BasicException
+{
+}
+

libraries/jcb_powers/VDM.Minify/src/Exceptions/IOException.php

@@ -0,0 +1,25 @@
+<?php
+/**
+ * IO Exception.
+ *
+ * Please report bugs on https://github.com/matthiasmullie/minify/issues
+ *
+ * @author Matthias Mullie <minify@mullie.eu>
+ * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+namespace VDM\Minify\Exceptions;
+
+
+use VDM\Minify\Abstraction\BasicException;
+
+
+/**
+ * IO Exception Class.
+ *
+ * @author Matthias Mullie 
+ */
+class IOException extends BasicException
+{
+}
+

libraries/jcb_powers/VDM.Minify/src/Exceptions/index.html

@@ -0,0 +1 @@
+<html><body bgcolor="#FFFFFF"></body></html>

libraries/jcb_powers/VDM.Minify/src/Path/Converter.php

@@ -0,0 +1,207 @@
+<?php
+/**
+ * Convert paths relative from 1 file to another.
+ *
+ * E.g.
+ *     ../../images/icon.jpg relative to /css/imports/icons.css
+ * becomes
+ *     ../images/icon.jpg relative to /css/minified.css
+ *
+ * Please report bugs on https://github.com/matthiasmullie/path-converter/issues
+ *
+ * @author Matthias Mullie <pathconverter@mullie.eu>
+ * @copyright Copyright (c) 2015, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+namespace VDM\Minify\Path;
+
+
+use VDM\Minify\Path\Interfaces\ConverterInterface;
+
+class Converter implements ConverterInterface
+{
+    /**
+     * @var string
+     */
+    protected $from;
+
+    /**
+     * @var string
+     */
+    protected $to;
+
+    /**
+     * @param string $from The original base path (directory, not file!)
+     * @param string $to   The new base path (directory, not file!)
+     * @param string $root Root directory (defaults to `getcwd`)
+     */
+    public function __construct($from, $to, $root = '')
+    {
+        $shared = $this->shared($from, $to);
+        if ($shared === '') {
+            // when both paths have nothing in common, one of them is probably
+            // absolute while the other is relative
+            $root = $root ?: getcwd();
+            $from = strpos($from, $root) === 0 ? $from : preg_replace('/\/+/', '/', $root . '/' . $from);
+            $to = strpos($to, $root) === 0 ? $to : preg_replace('/\/+/', '/', $root . '/' . $to);
+
+            // or traveling the tree via `..`
+            // attempt to resolve path, or assume it's fine if it doesn't exist
+            $from = @realpath($from) ?: $from;
+            $to = @realpath($to) ?: $to;
+        }
+
+        $from = $this->dirname($from);
+        $to = $this->dirname($to);
+
+        $from = $this->normalize($from);
+        $to = $this->normalize($to);
+
+        $this->from = $from;
+        $this->to = $to;
+    }
+
+    /**
+     * Normalize path.
+     *
+     * @param string $path
+     *
+     * @return string
+     */
+    protected function normalize($path)
+    {
+        // deal with different operating systems' directory structure
+        $path = rtrim(str_replace(DIRECTORY_SEPARATOR, '/', $path), '/');
+
+        // remove leading current directory.
+        if (substr($path, 0, 2) === './') {
+            $path = substr($path, 2);
+        }
+
+        // remove references to current directory in the path.
+        $path = str_replace('/./', '/', $path);
+
+        /*
+         * Example:
+         *     /home/forkcms/frontend/cache/compiled_templates/../../core/layout/css/../images/img.gif
+         * to
+         *     /home/forkcms/frontend/core/layout/images/img.gif
+         */
+        do {
+            $path = preg_replace('/[^\/]+(?<!\.\.)\/\.\.\//', '', $path, -1, $count);
+        } while ($count);
+
+        return $path;
+    }
+
+    /**
+     * Figure out the shared path of 2 locations.
+     *
+     * Example:
+     *     /home/forkcms/frontend/core/layout/images/img.gif
+     * and
+     *     /home/forkcms/frontend/cache/minified_css
+     * share
+     *     /home/forkcms/frontend
+     *
+     * @param string $path1
+     * @param string $path2
+     *
+     * @return string
+     */
+    protected function shared($path1, $path2)
+    {
+        // $path could theoretically be empty (e.g. no path is given), in which
+        // case it shouldn't expand to array(''), which would compare to one's
+        // root /
+        $path1 = $path1 ? explode('/', $path1) : array();
+        $path2 = $path2 ? explode('/', $path2) : array();
+
+        $shared = array();
+
+        // compare paths & strip identical ancestors
+        foreach ($path1 as $i => $chunk) {
+            if (isset($path2[$i]) && $path1[$i] == $path2[$i]) {
+                $shared[] = $chunk;
+            } else {
+                break;
+            }
+        }
+
+        return implode('/', $shared);
+    }
+
+    /**
+     * Convert paths relative from 1 file to another.
+     *
+     * E.g.
+     *     ../images/img.gif relative to /home/forkcms/frontend/core/layout/css
+     * should become:
+     *     ../../core/layout/images/img.gif relative to
+     *     /home/forkcms/frontend/cache/minified_css
+     *
+     * @param string $path The relative path that needs to be converted
+     *
+     * @return string The new relative path
+     */
+    public function convert($path)
+    {
+        // quit early if conversion makes no sense
+        if ($this->from === $this->to) {
+            return $path;
+        }
+
+        $path = $this->normalize($path);
+        // if we're not dealing with a relative path, just return absolute
+        if (strpos($path, '/') === 0) {
+            return $path;
+        }
+
+        // normalize paths
+        $path = $this->normalize($this->from . '/' . $path);
+
+        // strip shared ancestor paths
+        $shared = $this->shared($path, $this->to);
+        $path = mb_substr($path, mb_strlen($shared));
+        $to = mb_substr($this->to, mb_strlen($shared));
+
+        // add .. for every directory that needs to be traversed to new path
+        $to = str_repeat('../', count(array_filter(explode('/', $to))));
+
+        return $to . ltrim($path, '/');
+    }
+
+    /**
+     * Attempt to get the directory name from a path.
+     *
+     * @param string $path
+     *
+     * @return string
+     */
+    protected function dirname($path)
+    {
+        if (@is_file($path)) {
+            return dirname($path);
+        }
+
+        if (@is_dir($path)) {
+            return rtrim($path, '/');
+        }
+
+        // no known file/dir, start making assumptions
+
+        // ends in / = dir
+        if (mb_substr($path, -1) === '/') {
+            return rtrim($path, '/');
+        }
+
+        // has a dot in the name, likely a file
+        if (preg_match('/.*\..*$/', basename($path)) !== 0) {
+            return dirname($path);
+        }
+
+        // you're on your own here!
+        return $path;
+    }
+}
+

libraries/jcb_powers/VDM.Minify/src/Path/Interfaces/ConverterInterface.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * Convert file paths.
+ *
+ * Please report bugs on https://github.com/matthiasmullie/path-converter/issues
+ *
+ * @author Matthias Mullie <pathconverter@mullie.eu>
+ * @copyright Copyright (c) 2015, Matthias Mullie. All rights reserved
+ * @license MIT License
+ */
+namespace VDM\Minify\Path\Interfaces;
+
+interface ConverterInterface
+{
+    /**
+     * Convert file paths.
+     *
+     * @param string $path The path to be converted
+     *
+     * @return string The new path
+     */
+    public function convert($path);
+}
+

libraries/jcb_powers/VDM.Minify/src/Path/Interfaces/index.html

@@ -0,0 +1 @@
+<html><body bgcolor="#FFFFFF"></body></html>

libraries/jcb_powers/VDM.Minify/src/Path/index.html

@@ -0,0 +1 @@
+<html><body bgcolor="#FFFFFF"></body></html>

libraries/jcb_powers/VDM.Minify/src/index.html

@@ -0,0 +1 @@
+<html><body bgcolor="#FFFFFF"></body></html>

libraries/jcb_powers/VDM.Psr/index.html

@@ -0,0 +1 @@
+<html><body bgcolor="#FFFFFF"></body></html>

libraries/jcb_powers/VDM.Psr/src/Cache/CacheItemInterface.php

@@ -0,0 +1,114 @@
+<?php
+/**
+ * @package    Common interface for caching libraries
+ *
+ * @created    Feb 9, 2021
+ * @author     PHP-FIG <https://www.php-fig.org/>
+ * @git        Caching Interface <https://github.com/php-fig/cache>
+ * @license    MIT
+ */
+namespace VDM\Psr\Cache;
+
+
+/**
+ * CacheItemInterface defines an interface for interacting with objects inside a cache.
+ *
+ * Each Item object MUST be associated with a specific key, which can be set
+ * according to the implementing system and is typically passed by the
+ * Cache\CacheItemPoolInterface object.
+ *
+ * The Cache\CacheItemInterface object encapsulates the storage and retrieval of
+ * cache items. Each Cache\CacheItemInterface is generated by a
+ * Cache\CacheItemPoolInterface object, which is responsible for any required
+ * setup as well as associating the object with a unique Key.
+ * Cache\CacheItemInterface objects MUST be able to store and retrieve any type
+ * of PHP value defined in the Data section of the specification.
+ *
+ * Calling Libraries MUST NOT instantiate Item objects themselves. They may only
+ * be requested from a Pool object via the getItem() method.  Calling Libraries
+ * SHOULD NOT assume that an Item created by one Implementing Library is
+ * compatible with a Pool from another Implementing Library.
+ */
+interface CacheItemInterface
+{
+    /**
+     * Returns the key for the current cache item.
+     *
+     * The key is loaded by the Implementing Library, but should be available to
+     * the higher level callers when needed.
+     *
+     * @return string
+     *   The key string for this cache item.
+     */
+    public function getKey(): string;
+
+    /**
+     * Retrieves the value of the item from the cache associated with this object's key.
+     *
+     * The value returned must be identical to the value originally stored by set().
+     *
+     * If isHit() returns false, this method MUST return null. Note that null
+     * is a legitimate cached value, so the isHit() method SHOULD be used to
+     * differentiate between "null value was found" and "no value was found."
+     *
+     * @return mixed
+     *   The value corresponding to this cache item's key, or null if not found.
+     */
+    public function get(): mixed;
+
+    /**
+     * Confirms if the cache item lookup resulted in a cache hit.
+     *
+     * Note: This method MUST NOT have a race condition between calling isHit()
+     * and calling get().
+     *
+     * @return bool
+     *   True if the request resulted in a cache hit. False otherwise.
+     */
+    public function isHit(): bool;
+
+    /**
+     * Sets the value represented by this cache item.
+     *
+     * The $value argument may be any item that can be serialized by PHP,
+     * although the method of serialization is left up to the Implementing
+     * Library.
+     *
+     * @param mixed $value
+     *   The serializable value to be stored.
+     *
+     * @return static
+     *   The invoked object.
+     */
+    public function set(mixed $value): static;
+
+    /**
+     * Sets the expiration time for this cache item.
+     *
+     * @param ?\DateTimeInterface $expiration
+     *   The point in time after which the item MUST be considered expired.
+     *   If null is passed explicitly, a default value MAY be used. If none is set,
+     *   the value should be stored permanently or for as long as the
+     *   implementation allows.
+     *
+     * @return static
+     *   The called object.
+     */
+    public function expiresAt(?\DateTimeInterface $expiration): static;
+
+    /**
+     * Sets the expiration time for this cache item.
+     *
+     * @param int|\DateInterval|null $time
+     *   The period of time from the present after which the item MUST be considered
+     *   expired. An integer parameter is understood to be the time in seconds until
+     *   expiration. If null is passed explicitly, a default value MAY be used.
+     *   If none is set, the value should be stored permanently or for as long as the
+     *   implementation allows.
+     *
+     * @return static
+     *   The called object.
+     */
+    public function expiresAfter(int|\DateInterval|null $time): static;
+}
+

libraries/jcb_powers/VDM.Psr/src/Cache/index.html

@@ -0,0 +1 @@
+<html><body bgcolor="#FFFFFF"></body></html>

site/helpers/componentbuilder.php

@@ -24,7 +24,9 @@ spl_autoload_register(function ($class) {
 	// project-specific base directories and namespace prefix
 	$search = [
 		'libraries/jcb_powers/VDM.Joomla' => 'VDM\\Joomla',
-		'libraries/jcb_powers/VDM.Gitea' => 'VDM\\Gitea'
+		'libraries/jcb_powers/VDM.Minify' => 'VDM\\Minify',
+		'libraries/jcb_powers/VDM.Gitea' => 'VDM\\Gitea',
+		'libraries/jcb_powers/VDM.Psr' => 'VDM\\Psr'
 	];
 	// Start the search and load if found
 	$found = false;
@@ -1075,8 +1077,6 @@ abstract class ComponentbuilderHelper
 		{
 			// import the Joomla librarys
 			jimport('joomla.application.component.modellist');
-			// include class to minify js
-			require_once JPATH_ADMINISTRATOR.'/components/com_componentbuilder/helpers/js.php';
 		}
 		// load only if smart
 		if ('smart' === $type)