path: root/src/Smarty.php

<?php

namespace Smarty;

use FilesystemIterator;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use Smarty\Cacheresource\File;
use Smarty\Extension\Base;
use Smarty\Extension\BCPluginsAdapter;
use Smarty\Extension\CallbackWrapper;
use Smarty\Extension\CoreExtension;
use Smarty\Extension\DefaultExtension;
use Smarty\Extension\ExtensionInterface;
use Smarty\Filter\Output\TrimWhitespace;
use Smarty\Runtime\CaptureRuntime;
use Smarty\Runtime\DefaultPluginHandlerRuntime;
use Smarty\Runtime\ForeachRuntime;
use Smarty\Runtime\InheritanceRuntime;
use Smarty\Runtime\TplFunctionRuntime;


/**
 * Project:     Smarty: the PHP compiling template engine
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3.0 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * For questions, help, comments, discussion, etc., please join the
 * Smarty mailing list. Send a blank e-mail to
 * smarty-discussion-subscribe@googlegroups.com
 *
 * @author    Monte Ohrt <monte at ohrt dot com>
 * @author    Uwe Tews   <uwe dot tews at gmail dot com>
 * @author    Rodney Rehm
 * @author    Simon Wisselink
 */

/**
 * This is the main Smarty class
 */
class Smarty extends \Smarty\TemplateBase {

	/**
	 * smarty version
	 */
	const SMARTY_VERSION = '5.4.4';

	/**
	 * define caching modes
	 */
	const CACHING_OFF = 0;
	const CACHING_LIFETIME_CURRENT = 1;
	const CACHING_LIFETIME_SAVED = 2;
	/**
	 * define constant for clearing cache files be saved expiration dates
	 */
	const CLEAR_EXPIRED = -1;
	/**
	 * define compile check modes
	 */
	const COMPILECHECK_OFF = 0;
	const COMPILECHECK_ON = 1;
	/**
	 * filter types
	 */
	const FILTER_POST = 'post';
	const FILTER_PRE = 'pre';
	const FILTER_OUTPUT = 'output';
	const FILTER_VARIABLE = 'variable';
	/**
	 * plugin types
	 */
	const PLUGIN_FUNCTION = 'function';
	const PLUGIN_BLOCK = 'block';
	const PLUGIN_COMPILER = 'compiler';
	const PLUGIN_MODIFIER = 'modifier';
	const PLUGIN_MODIFIERCOMPILER = 'modifiercompiler';

	/**
	 * The character set to adhere to (defaults to "UTF-8")
	 */
	public static $_CHARSET = 'UTF-8';

	/**
	 * The date format to be used internally
	 * (accepts date() and strftime())
	 */
	public static $_DATE_FORMAT = '%b %e, %Y';

	/**
	 * Flag denoting if PCRE should run in UTF-8 mode
	 */
	public static $_UTF8_MODIFIER = 'u';

	/**
	 * Flag denoting if operating system is windows
	 */
	public static $_IS_WINDOWS = false;

	/**
	 * auto literal on delimiters with whitespace
	 *
	 * @var boolean
	 */
	public $auto_literal = true;

	/**
	 * display error on not assigned variables
	 *
	 * @var boolean
	 */
	public $error_unassigned = false;

	/**
	 * flag if template_dir is normalized
	 *
	 * @var bool
	 */
	public $_templateDirNormalized = false;

	/**
	 * joined template directory string used in cache keys
	 *
	 * @var string
	 */
	public $_joined_template_dir = null;

	/**
	 * flag if config_dir is normalized
	 *
	 * @var bool
	 */
	public $_configDirNormalized = false;

	/**
	 * joined config directory string used in cache keys
	 *
	 * @var string
	 */
	public $_joined_config_dir = null;

	/**
	 * default template handler
	 *
	 * @var callable
	 */
	public $default_template_handler_func = null;

	/**
	 * default config handler
	 *
	 * @var callable
	 */
	public $default_config_handler_func = null;

	/**
	 * default plugin handler
	 *
	 * @var callable
	 */
	private $default_plugin_handler_func = null;

	/**
	 * flag if template_dir is normalized
	 *
	 * @var bool
	 */
	public $_compileDirNormalized = false;

	/**
	 * flag if template_dir is normalized
	 *
	 * @var bool
	 */
	public $_cacheDirNormalized = false;

	/**
	 * force template compiling?
	 *
	 * @var boolean
	 */
	public $force_compile = false;

	/**
	 * use sub dirs for compiled/cached files?
	 *
	 * @var boolean
	 */
	public $use_sub_dirs = false;

	/**
	 * merge compiled includes
	 *
	 * @var boolean
	 */
	public $merge_compiled_includes = false;

	/**
	 * force cache file creation
	 *
	 * @var boolean
	 */
	public $force_cache = false;

	/**
	 * template left-delimiter
	 *
	 * @var string
	 */
	private $left_delimiter = "{";

	/**
	 * template right-delimiter
	 *
	 * @var string
	 */
	private $right_delimiter = "}";

	/**
	 * array of strings which shall be treated as literal by compiler
	 *
	 * @var array string
	 */
	public $literals = [];

	/**
	 * class name
	 * This should be instance of \Smarty\Security.
	 *
	 * @var string
	 * @see \Smarty\Security
	 */
	public $security_class = \Smarty\Security::class;

	/**
	 * implementation of security class
	 *
	 * @var \Smarty\Security
	 */
	public $security_policy = null;

	/**
	 * debug mode
	 * Setting this to true enables the debug-console. Setting it to 2 enables individual Debug Console window by
	 * template name.
	 *
	 * @var boolean|int
	 */
	public $debugging = false;

	/**
	 * This determines if debugging is enable-able from the browser.
	 * <ul>
	 *  <li>NONE => no debugging control allowed</li>
	 *  <li>URL => enable debugging when SMARTY_DEBUG is found in the URL.</li>
	 * </ul>
	 *
	 * @var string
	 */
	public $debugging_ctrl = 'NONE';

	/**
	 * Name of debugging URL-param.
	 * Only used when $debugging_ctrl is set to 'URL'.
	 * The name of the URL-parameter that activates debugging.
	 *
	 * @var string
	 */
	public $smarty_debug_id = 'SMARTY_DEBUG';

	/**
	 * Path of debug template.
	 *
	 * @var string
	 */
	public $debug_tpl = null;

	/**
	 * When set, smarty uses this value as error_reporting-level.
	 *
	 * @var int
	 */
	public $error_reporting = null;

	/**
	 * Controls whether variables with the same name overwrite each other.
	 *
	 * @var boolean
	 */
	public $config_overwrite = true;

	/**
	 * Controls whether config values of on/true/yes and off/false/no get converted to boolean.
	 *
	 * @var boolean
	 */
	public $config_booleanize = true;

	/**
	 * Controls whether hidden config sections/vars are read from the file.
	 *
	 * @var boolean
	 */
	public $config_read_hidden = false;

	/**
	 * locking concurrent compiles
	 *
	 * @var boolean
	 */
	public $compile_locking = true;

	/**
	 * Controls whether cache resources should use locking mechanism
	 *
	 * @var boolean
	 */
	public $cache_locking = false;

	/**
	 * seconds to wait for acquiring a lock before ignoring the write lock
	 *
	 * @var float
	 */
	public $locking_timeout = 10;

	/**
	 * resource type used if none given
	 * Must be a valid key of $registered_resources.
	 *
	 * @var string
	 */
	public $default_resource_type = 'file';

	/**
	 * cache resource
	 * Must be a subclass of \Smarty\Cacheresource\Base
	 *
	 * @var \Smarty\Cacheresource\Base
	 */
	private $cacheResource;

	/**
	 * config type
	 *
	 * @var string
	 */
	public $default_config_type = 'file';

	/**
	 * check If-Modified-Since headers
	 *
	 * @var boolean
	 */
	public $cache_modified_check = false;

	/**
	 * registered plugins
	 *
	 * @var array
	 */
	public $registered_plugins = [];

	/**
	 * registered objects
	 *
	 * @var array
	 */
	public $registered_objects = [];

	/**
	 * registered classes
	 *
	 * @var array
	 */
	public $registered_classes = [];

	/**
	 * registered resources
	 *
	 * @var array
	 */
	public $registered_resources = [];

	/**
	 * registered cache resources
	 *
	 * @var array
	 * @deprecated since 5.0
	 */
	private $registered_cache_resources = [];

	/**
	 * default modifier
	 *
	 * @var array
	 */
	public $default_modifiers = [];

	/**
	 * autoescape variable output
	 *
	 * @var boolean
	 */
	public $escape_html = false;

	/**
	 * start time for execution time calculation
	 *
	 * @var int
	 */
	public $start_time = 0;

	/**
	 * internal flag to enable parser debugging
	 *
	 * @var bool
	 */
	public $_parserdebug = false;

	/**
	 * Debug object
	 *
	 * @var \Smarty\Debug
	 */
	public $_debug = null;

	/**
	 * template directory
	 *
	 * @var array
	 */
	protected $template_dir = ['./templates/'];

	/**
	 * flags for normalized template directory entries
	 *
	 * @var array
	 */
	protected $_processedTemplateDir = [];

	/**
	 * config directory
	 *
	 * @var array
	 */
	protected $config_dir = ['./configs/'];

	/**
	 * flags for normalized template directory entries
	 *
	 * @var array
	 */
	protected $_processedConfigDir = [];

	/**
	 * compile directory
	 *
	 * @var string
	 */
	protected $compile_dir = './templates_c/';

	/**
	 * cache directory
	 *
	 * @var string
	 */
	protected $cache_dir = './cache/';

	/**
	 * PHP7 Compatibility mode
	 *
	 * @var bool
	 */
	private $isMutingUndefinedOrNullWarnings = false;

	/**
	 * Cache of loaded resource handlers.
	 *
	 * @var array
	 */
	public $_resource_handlers = [];

	/**
	 * Cache of loaded cacheresource handlers.
	 *
	 * @var array
	 */
	public $_cacheresource_handlers = [];

	/**
	 * List of extensions
	 *
	 * @var ExtensionInterface[]
	 */
	private $extensions = [];
	/**
	 * @var BCPluginsAdapter
	 */
	private $BCPluginsAdapter;

	/**
	 * Initialize new Smarty object
	 */
	public function __construct() {

		$this->start_time = microtime(true);
		// Check if we're running on Windows
		\Smarty\Smarty::$_IS_WINDOWS = strtoupper(substr(PHP_OS, 0, 3)) === 'WIN';
		// let PCRE (preg_*) treat strings as ISO-8859-1 if we're not dealing with UTF-8
		if (\Smarty\Smarty::$_CHARSET !== 'UTF-8') {
			\Smarty\Smarty::$_UTF8_MODIFIER = '';
		}

		$this->BCPluginsAdapter = new BCPluginsAdapter($this);

		$this->extensions[] = new CoreExtension();
		$this->extensions[] = new DefaultExtension();
		$this->extensions[] = $this->BCPluginsAdapter;

		$this->cacheResource = new File();
	}

	/**
	 * Load an additional extension.
	 *
	 * @return void
	 */
	public function addExtension(ExtensionInterface $extension) {
		$this->extensions[] = $extension;
	}

	/**
	 * Returns all loaded extensions
	 *
	 * @return array|ExtensionInterface[]
	 */
	public function getExtensions(): array {
		return $this->extensions;
	}

	/**
	 * Replace the entire list extensions, allowing you to determine the exact order of the extensions.
	 *
	 * @param ExtensionInterface[] $extensions
	 *
	 * @return void
	 */
	public function setExtensions(array $extensions): void {
		$this->extensions = $extensions;
	}

	/**
	 * Check if a template resource exists
	 *
	 * @param string $resource_name template name
	 *
	 * @return bool status
	 * @throws \Smarty\Exception
	 */
	public function templateExists($resource_name) {
		// create source object
		$source = Template\Source::load(null, $this, $resource_name);
		return $source->exists;
	}

	/**
	 * Loads security class and enables security
	 *
	 * @param string|\Smarty\Security $security_class if a string is used, it must be class-name
	 *
	 * @return static                 current Smarty instance for chaining
	 * @throws \Smarty\Exception
	 */
	public function enableSecurity($security_class = null) {
		\Smarty\Security::enableSecurity($this, $security_class);
		return $this;
	}

	/**
	 * Disable security
	 *
	 * @return static current Smarty instance for chaining
	 */
	public function disableSecurity() {
		$this->security_policy = null;
		return $this;
	}

	/**
	 * Add template directory(s)
	 *
	 * @param string|array $template_dir directory(s) of template sources
	 * @param string $key of the array element to assign the template dir to
	 * @param bool $isConfig true for config_dir
	 *
	 * @return static current Smarty instance for chaining
	 */
	public function addTemplateDir($template_dir, $key = null, $isConfig = false) {
		if ($isConfig) {
			$processed = &$this->_processedConfigDir;
			$dir = &$this->config_dir;
			$this->_configDirNormalized = false;
		} else {
			$processed = &$this->_processedTemplateDir;
			$dir = &$this->template_dir;
			$this->_templateDirNormalized = false;
		}
		if (is_array($template_dir)) {
			foreach ($template_dir as $k => $v) {
				if (is_int($k)) {
					// indexes are not merged but appended
					$dir[] = $v;
				} else {
					// string indexes are overridden
					$dir[$k] = $v;
					unset($processed[$key]);
				}
			}
		} else {
			if ($key !== null) {
				// override directory at specified index
				$dir[$key] = $template_dir;
				unset($processed[$key]);
			} else {
				// append new directory
				$dir[] = $template_dir;
			}
		}
		return $this;
	}

	/**
	 * Get template directories
	 *
	 * @param mixed $index index of directory to get, null to get all
	 * @param bool $isConfig true for config_dir
	 *
	 * @return array|string list of template directories, or directory of $index
	 */
	public function getTemplateDir($index = null, $isConfig = false) {
		if ($isConfig) {
			$dir = &$this->config_dir;
		} else {
			$dir = &$this->template_dir;
		}
		if ($isConfig ? !$this->_configDirNormalized : !$this->_templateDirNormalized) {
			$this->_normalizeTemplateConfig($isConfig);
		}
		if ($index !== null) {
			return isset($dir[$index]) ? $dir[$index] : null;
		}
		return $dir;
	}

	/**
	 * Set template directory
	 *
	 * @param string|array $template_dir directory(s) of template sources
	 * @param bool $isConfig true for config_dir
	 *
	 * @return static current Smarty instance for chaining
	 */
	public function setTemplateDir($template_dir, $isConfig = false) {
		if ($isConfig) {
			$this->config_dir = [];
			$this->_processedConfigDir = [];
		} else {
			$this->template_dir = [];
			$this->_processedTemplateDir = [];
		}
		$this->addTemplateDir($template_dir, null, $isConfig);
		return $this;
	}

	/**
	 * Adds a template directory before any existing directoires
	 *
	 * @param string $new_template_dir directory of template sources
	 * @param bool $is_config true for config_dir
	 *
	 * @return static current Smarty instance for chaining
	 */
	public function prependTemplateDir($new_template_dir, $is_config = false) {
		$current_template_dirs = $is_config ? $this->config_dir : $this->template_dir;
		array_unshift($current_template_dirs, $new_template_dir);
		$this->setTemplateDir($current_template_dirs, $is_config);
		return $this;
	}

	/**
	 * Add config directory(s)
	 *
	 * @param string|array $config_dir directory(s) of config sources
	 * @param mixed $key key of the array element to assign the config dir to
	 *
	 * @return static current Smarty instance for chaining
	 */
	public function addConfigDir($config_dir, $key = null) {
		return $this->addTemplateDir($config_dir, $key, true);
	}

	/**
	 * Get config directory
	 *
	 * @param mixed $index index of directory to get, null to get all
	 *
	 * @return array configuration directory
	 */
	public function getConfigDir($index = null) {
		return $this->getTemplateDir($index, true);
	}

	/**
	 * Set config directory
	 *
	 * @param $config_dir
	 *
	 * @return static current Smarty instance for chaining
	 */
	public function setConfigDir($config_dir) {
		return $this->setTemplateDir($config_dir, true);
	}

	/**
	 * Registers plugin to be used in templates
	 *
	 * @param string $type plugin type
	 * @param string $name name of template tag
	 * @param callable $callback PHP callback to register
	 * @param bool $cacheable if true (default) this function is cache able
	 *
	 * @return $this
	 * @throws \Smarty\Exception
	 *
	 * @api  Smarty::registerPlugin()
	 */
	public function registerPlugin($type, $name, $callback, $cacheable = true) {
		if (isset($this->registered_plugins[$type][$name])) {
			throw new Exception("Plugin tag '{$name}' already registered");
		} elseif (!is_callable($callback) && !class_exists($callback)) {
			throw new Exception("Plugin '{$name}' not callable");
		} else {
			$this->registered_plugins[$type][$name] = [$callback, (bool)$cacheable];
		}
		return $this;
	}

	/**
	 * Returns plugin previously registered using ::registerPlugin as a numerical array as follows or null if not found:
	 * [
	 *  0 => the callback
	 *  1 => (bool) $cacheable
	 *  2 => (array) $cache_attr
	 * ]
	 *
	 * @param string $type plugin type
	 * @param string $name name of template tag
	 *
	 * @return array|null
	 *
	 * @api  Smarty::unregisterPlugin()
	 */
	public function getRegisteredPlugin($type, $name): ?array {
		if (isset($this->registered_plugins[$type][$name])) {
			return $this->registered_plugins[$type][$name];
		}
		return null;
	}

	/**
	 * Unregisters plugin previously registered using ::registerPlugin
	 *
	 * @param string $type plugin type
	 * @param string $name name of template tag
	 *
	 * @return $this
	 *
	 * @api  Smarty::unregisterPlugin()
	 */
	public function unregisterPlugin($type, $name) {
		if (isset($this->registered_plugins[$type][$name])) {
			unset($this->registered_plugins[$type][$name]);
		}
		return $this;
	}

	/**
	 * Adds directory of plugin files
	 *
	 * @param null|array|string $plugins_dir
	 *
	 * @return static current Smarty instance for chaining
	 * @deprecated since 5.0
	 */
	public function addPluginsDir($plugins_dir) {
		trigger_error('Using Smarty::addPluginsDir() to load plugins is deprecated and will be ' .
			'removed in a future release. Use Smarty::addExtension() to add an extension or Smarty::registerPlugin to ' .
			'quickly register a plugin using a callback function.', E_USER_DEPRECATED);

		foreach ((array)$plugins_dir as $v) {
			$path = $this->_realpath(rtrim($v ?? '', '/\\') . DIRECTORY_SEPARATOR, true);
			$this->BCPluginsAdapter->loadPluginsFromDir($path);
		}

		return $this;
	}

	/**
	 * Get plugin directories
	 *
	 * @return array list of plugin directories
	 * @deprecated since 5.0
	 */
	public function getPluginsDir() {
		trigger_error('Using Smarty::getPluginsDir() is deprecated and will be ' .
			'removed in a future release. It will always return an empty array.', E_USER_DEPRECATED);
		return [];
	}

	/**
	 * Set plugins directory
	 *
	 * @param string|array $plugins_dir directory(s) of plugins
	 *
	 * @return static current Smarty instance for chaining
	 * @deprecated since 5.0
	 */
	public function setPluginsDir($plugins_dir) {
		trigger_error('Using Smarty::getPluginsDir() is deprecated and will be ' .
			'removed in a future release. For now, it will remove the DefaultExtension from the extensions list and ' .
			'proceed to call Smartyy::addPluginsDir..', E_USER_DEPRECATED);

		$this->extensions = array_filter(
			$this->extensions,
			function ($extension) {
				return !($extension instanceof DefaultExtension);
			}
		);

		return $this->addPluginsDir($plugins_dir);
	}

	/**
	 * Registers a default plugin handler
	 *
	 * @param callable $callback class/method name
	 *
	 * @return $this
	 * @throws Exception              if $callback is not callable
	 *
	 * @api  Smarty::registerDefaultPluginHandler()
	 *
	 * @deprecated since 5.0
	 */
	public function registerDefaultPluginHandler($callback) {

		trigger_error('Using Smarty::registerDefaultPluginHandler() is deprecated and will be ' .
			'removed in a future release. Please rewrite your plugin handler as an extension.',
			E_USER_DEPRECATED);

		if (is_callable($callback)) {
			$this->default_plugin_handler_func = $callback;
		} else {
			throw new Exception("Default plugin handler '$callback' not callable");
		}
		return $this;
	}

	/**
	 * Get compiled directory
	 *
	 * @return string path to compiled templates
	 */
	public function getCompileDir() {
		if (!$this->_compileDirNormalized) {
			$this->_normalizeDir('compile_dir', $this->compile_dir);
			$this->_compileDirNormalized = true;
		}
		return $this->compile_dir;
	}

	/**
	 *
	 * @param string $compile_dir directory to store compiled templates in
	 *
	 * @return static current Smarty instance for chaining
	 */
	public function setCompileDir($compile_dir) {
		$this->_normalizeDir('compile_dir', $compile_dir);
		$this->_compileDirNormalized = true;
		return $this;
	}

	/**
	 * Get cache directory
	 *
	 * @return string path of cache directory
	 */
	public function getCacheDir() {
		if (!$this->_cacheDirNormalized) {
			$this->_normalizeDir('cache_dir', $this->cache_dir);
			$this->_cacheDirNormalized = true;
		}
		return $this->cache_dir;
	}

	/**
	 * Set cache directory
	 *
	 * @param string $cache_dir directory to store cached templates in
	 *
	 * @return static current Smarty instance for chaining
	 */
	public function setCacheDir($cache_dir) {
		$this->_normalizeDir('cache_dir', $cache_dir);
		$this->_cacheDirNormalized = true;
		return $this;
	}

	private $templates = [];

	/**
	 * Creates a template object
	 *
	 * @param string $template_name
	 * @param mixed $cache_id cache id to be used with this template
	 * @param mixed $compile_id compile id to be used with this template
	 * @param null $parent next higher level of Smarty variables
	 *
	 * @return Template template object
	 * @throws Exception
	 */
	public function createTemplate($template_name, $cache_id = null, $compile_id = null, $parent = null): Template {

		$data = [];

		// Shuffle params for backward compatibility: if 2nd param is an object, it's the parent
		if (is_object($cache_id)) {
			$parent = $cache_id;
			$cache_id = null;
		}

		// Shuffle params for backward compatibility: if 2nd param is an array, it's data
		if (is_array($cache_id)) {
			$data = $cache_id;
			$cache_id = null;
		}

		return $this->doCreateTemplate($template_name, $cache_id, $compile_id, $parent, null, null, false, $data);
	}

	/**
	 * Get unique template id
	 *
	 * @param string $resource_name
	 * @param null|mixed $cache_id
	 * @param null|mixed $compile_id
	 * @param null $caching
	 *
	 * @return string
	 */
	private function generateUniqueTemplateId(
		$resource_name,
		$cache_id = null,
		$compile_id = null,
		$caching = null
	): string {
		// defaults for optional params
		$cache_id = $cache_id ?? $this->cache_id;
		$compile_id = $compile_id ?? $this->compile_id;
		$caching = (int)$caching ?? $this->caching;

		// Add default resource type to resource name if it is missing
		if (strpos($resource_name, ':') === false) {
			$resource_name = "{$this->default_resource_type}:{$resource_name}";
		}

		$_templateId = $resource_name . '#' . $cache_id . '#' . $compile_id . '#' . $caching;

		// hash very long IDs to prevent problems with filename length
		// do not hash shorter IDs, so they remain recognizable
		if (strlen($_templateId) > 150) {
			$_templateId = sha1($_templateId);
		}

		return $_templateId;
	}

	/**
	 * Normalize path
	 *  - remove /./ and /../
	 *  - make it absolute if required
	 *
	 * @param string $path file path
	 * @param bool $realpath if true - convert to absolute
	 *                         false - convert to relative
	 *                         null - keep as it is but
	 *                         remove /./ /../
	 *
	 * @return string
	 */
	public function _realpath($path, $realpath = null) {
		$nds = ['/' => '\\', '\\' => '/'];
		preg_match(
			'%^(?<root>(?:[[:alpha:]]:[\\\\/]|/|[\\\\]{2}[[:alpha:]]+|[[:print:]]{2,}:[/]{2}|[\\\\])?)(?<path>(.*))$%u',
			$path,
			$parts
		);
		$path = $parts['path'];
		if ($parts['root'] === '\\') {
			$parts['root'] = substr(getcwd(), 0, 2) . $parts['root'];
		} else {
			if ($realpath !== null && !$parts['root']) {
				$path = getcwd() . DIRECTORY_SEPARATOR . $path;
			}
		}
		// normalize DIRECTORY_SEPARATOR
		$path = str_replace($nds[DIRECTORY_SEPARATOR], DIRECTORY_SEPARATOR, $path);
		$parts['root'] = str_replace($nds[DIRECTORY_SEPARATOR], DIRECTORY_SEPARATOR, $parts['root']);
		do {
			$path = preg_replace(
				['#[\\\\/]{2}#', '#[\\\\/][.][\\\\/]#', '#[\\\\/]([^\\\\/.]+)[\\\\/][.][.][\\\\/]#'],
				DIRECTORY_SEPARATOR,
				$path,
				-1,
				$count
			);
		} while ($count > 0);
		return $realpath !== false ? $parts['root'] . $path : str_ireplace(getcwd(), '.', $parts['root'] . $path);
	}

	/**
	 * @param boolean $use_sub_dirs
	 */
	public function setUseSubDirs($use_sub_dirs) {
		$this->use_sub_dirs = $use_sub_dirs;
	}

	/**
	 * @param int $error_reporting
	 */
	public function setErrorReporting($error_reporting) {
		$this->error_reporting = $error_reporting;
	}

	/**
	 * @param boolean $escape_html
	 */
	public function setEscapeHtml($escape_html) {
		$this->escape_html = $escape_html;
	}

	/**
	 * Return auto_literal flag
	 *
	 * @return boolean
	 */
	public function getAutoLiteral() {
		return $this->auto_literal;
	}

	/**
	 * Set auto_literal flag
	 *
	 * @param boolean $auto_literal
	 */
	public function setAutoLiteral($auto_literal = true) {
		$this->auto_literal = $auto_literal;
	}

	/**
	 * @param boolean $force_compile
	 */
	public function setForceCompile($force_compile) {
		$this->force_compile = $force_compile;
	}

	/**
	 * @param boolean $merge_compiled_includes
	 */
	public function setMergeCompiledIncludes($merge_compiled_includes) {
		$this->merge_compiled_includes = $merge_compiled_includes;
	}

	/**
	 * Get left delimiter
	 *
	 * @return string
	 */
	public function getLeftDelimiter() {
		return $this->left_delimiter;
	}

	/**
	 * Set left delimiter
	 *
	 * @param string $left_delimiter
	 */
	public function setLeftDelimiter($left_delimiter) {
		$this->left_delimiter = $left_delimiter;
	}

	/**
	 * Get right delimiter
	 *
	 * @return string $right_delimiter
	 */
	public function getRightDelimiter() {
		return $this->right_delimiter;
	}

	/**
	 * Set right delimiter
	 *
	 * @param string
	 */
	public function setRightDelimiter($right_delimiter) {
		$this->right_delimiter = $right_delimiter;
	}

	/**
	 * @param boolean $debugging
	 */
	public function setDebugging($debugging) {
		$this->debugging = $debugging;
	}

	/**
	 * @param boolean $config_overwrite
	 */
	public function setConfigOverwrite($config_overwrite) {
		$this->config_overwrite = $config_overwrite;
	}

	/**
	 * @param boolean $config_booleanize
	 */
	public function setConfigBooleanize($config_booleanize) {
		$this->config_booleanize = $config_booleanize;
	}

	/**
	 * @param boolean $config_read_hidden
	 */
	public function setConfigReadHidden($config_read_hidden) {
		$this->config_read_hidden = $config_read_hidden;
	}

	/**
	 * @param boolean $compile_locking
	 */
	public function setCompileLocking($compile_locking) {
		$this->compile_locking = $compile_locking;
	}

	/**
	 * @param string $default_resource_type
	 */
	public function setDefaultResourceType($default_resource_type) {
		$this->default_resource_type = $default_resource_type;
	}

	/**
	 * Test install
	 *
	 * @param null $errors
	 */
	public function testInstall(&$errors = null) {
		\Smarty\TestInstall::testInstall($this, $errors);
	}

	/**
	 * Get Smarty object
	 *
	 * @return static
	 */
	public function getSmarty() {
		return $this;
	}

	/**
	 * Normalize and set directory string
	 *
	 * @param string $dirName cache_dir or compile_dir
	 * @param string $dir filepath of folder
	 */
	private function _normalizeDir($dirName, $dir) {
		$this->{$dirName} = $this->_realpath(rtrim($dir ?? '', "/\\") . DIRECTORY_SEPARATOR, true);
	}

	/**
	 * Normalize template_dir or config_dir
	 *
	 * @param bool $isConfig true for config_dir
	 */
	private function _normalizeTemplateConfig($isConfig) {
		if ($isConfig) {
			$processed = &$this->_processedConfigDir;
			$dir = &$this->config_dir;
		} else {
			$processed = &$this->_processedTemplateDir;
			$dir = &$this->template_dir;
		}
		if (!is_array($dir)) {
			$dir = (array)$dir;
		}
		foreach ($dir as $k => $v) {
			if (!isset($processed[$k])) {
				$dir[$k] = $this->_realpath(rtrim($v ?? '', "/\\") . DIRECTORY_SEPARATOR, true);
				$processed[$k] = true;
			}
		}

		if ($isConfig) {
			$this->_configDirNormalized = true;
			$this->_joined_config_dir = join('#', $this->config_dir);
		} else {
			$this->_templateDirNormalized = true;
			$this->_joined_template_dir = join('#', $this->template_dir);
		}

	}

	/**
	 * Mutes errors for "undefined index", "undefined array key" and "trying to read property of null".
	 *
	 * @void
	 */
	public function muteUndefinedOrNullWarnings(): void {
		$this->isMutingUndefinedOrNullWarnings = true;
	}

	/**
	 * Indicates if Smarty will mute errors for "undefined index", "undefined array key" and "trying to read property of null".
	 *
	 * @return bool
	 */
	public function isMutingUndefinedOrNullWarnings(): bool {
		return $this->isMutingUndefinedOrNullWarnings;
	}

	/**
	 * Empty cache for a specific template
	 *
	 * @param string $template_name template name
	 * @param string $cache_id cache id
	 * @param string $compile_id compile id
	 * @param integer $exp_time expiration time
	 * @param string $type resource type
	 *
	 * @return int number of cache files deleted
	 * @throws \Smarty\Exception
	 *
	 * @api  Smarty::clearCache()
	 */
	public function clearCache(
		$template_name,
		$cache_id = null,
		$compile_id = null,
		$exp_time = null
	) {
		return $this->getCacheResource()->clear($this, $template_name, $cache_id, $compile_id, $exp_time);
	}

	/**
	 * Empty cache folder
	 *
	 * @param integer $exp_time expiration time
	 * @param string $type resource type
	 *
	 * @return int number of cache files deleted
	 *
	 * @api  Smarty::clearAllCache()
	 */
	public function clearAllCache($exp_time = null) {
		return $this->getCacheResource()->clearAll($this, $exp_time);
	}

	/**
	 * Delete compiled template file
	 *
	 * @param string $resource_name template name
	 * @param string $compile_id compile id
	 * @param integer $exp_time expiration time
	 *
	 * @return int number of template files deleted
	 * @throws \Smarty\Exception
	 *
	 * @api  Smarty::clearCompiledTemplate()
	 */
	public function clearCompiledTemplate($resource_name = null, $compile_id = null, $exp_time = null) {
		$_compile_dir = $this->getCompileDir();
		if ($_compile_dir === '/') { //We should never want to delete this!
			return 0;
		}
		$_compile_id = isset($compile_id) ? preg_replace('![^\w]+!', '_', $compile_id) : null;
		$_dir_sep = $this->use_sub_dirs ? DIRECTORY_SEPARATOR : '^';
		if (isset($resource_name)) {
			$_save_stat = $this->caching;
			$this->caching = \Smarty\Smarty::CACHING_OFF;
			/* @var Template $tpl */
			$tpl = $this->doCreateTemplate($resource_name);
			$this->caching = $_save_stat;
			if (!$tpl->getSource()->handler->recompiled && $tpl->getSource()->exists) {
				$_resource_part_1 = basename(str_replace('^', DIRECTORY_SEPARATOR, $tpl->getCompiled()->filepath));
				$_resource_part_1_length = strlen($_resource_part_1);
			} else {
				return 0;
			}
			$_resource_part_2 = str_replace('.php', '.cache.php', $_resource_part_1);
			$_resource_part_2_length = strlen($_resource_part_2);
		}
		$_dir = $_compile_dir;
		if ($this->use_sub_dirs && isset($_compile_id)) {
			$_dir .= $_compile_id . $_dir_sep;
		}
		if (isset($_compile_id)) {
			$_compile_id_part = $_compile_dir . $_compile_id . $_dir_sep;
			$_compile_id_part_length = strlen($_compile_id_part);
		}
		$_count = 0;
		try {
			$_compileDirs = new RecursiveDirectoryIterator($_dir);
		} catch (\UnexpectedValueException $e) {
			// path not found / not a dir
			return 0;
		}
		$_compile = new RecursiveIteratorIterator($_compileDirs, RecursiveIteratorIterator::CHILD_FIRST);
		foreach ($_compile as $_file) {
			if (substr(basename($_file->getPathname()), 0, 1) === '.') {
				continue;
			}
			$_filepath = (string)$_file;
			if ($_file->isDir()) {
				if (!$_compile->isDot()) {
					// delete folder if empty
					@rmdir($_file->getPathname());
				}
			} else {
				// delete only php files
				if (substr($_filepath, -4) !== '.php') {
					continue;
				}
				$unlink = false;
				if ((!isset($_compile_id) ||
						(isset($_filepath[$_compile_id_part_length]) &&
							$a = !strncmp($_filepath, $_compile_id_part, $_compile_id_part_length)))
					&& (!isset($resource_name) || (isset($_filepath[$_resource_part_1_length])
							&& substr_compare(
								$_filepath,
								$_resource_part_1,
								-$_resource_part_1_length,
								$_resource_part_1_length
							) === 0) || (isset($_filepath[$_resource_part_2_length])
							&& substr_compare(
								$_filepath,
								$_resource_part_2,
								-$_resource_part_2_length,
								$_resource_part_2_length
							) === 0))
				) {
					if (isset($exp_time)) {
						if (is_file($_filepath) && time() - filemtime($_filepath) >= $exp_time) {
							$unlink = true;
						}
					} else {
						$unlink = true;
					}
				}
				if ($unlink && is_file($_filepath) && @unlink($_filepath)) {
					$_count++;
					if (function_exists('opcache_invalidate')
						&& (!function_exists('ini_get') || strlen(ini_get('opcache.restrict_api')) < 1)
					) {
						opcache_invalidate($_filepath, true);
					} elseif (function_exists('apc_delete_file')) {
						apc_delete_file($_filepath);
					}
				}
			}
		}
		return $_count;
	}

	/**
	 * Compile all template files
	 *
	 * @param string $extension file extension
	 * @param bool $force_compile force all to recompile
	 * @param int $time_limit
	 * @param int $max_errors
	 *
	 * @return integer number of template files recompiled
	 * @api Smarty::compileAllTemplates()
	 *
	 */
	public function compileAllTemplates(
		$extension = '.tpl',
		$force_compile = false,
		$time_limit = 0,
		$max_errors = null
	) {
		return $this->compileAll($extension, $force_compile, $time_limit, $max_errors);
	}

	/**
	 * Compile all config files
	 *
	 * @param string $extension file extension
	 * @param bool $force_compile force all to recompile
	 * @param int $time_limit
	 * @param int $max_errors
	 *
	 * @return int number of template files recompiled
	 * @api Smarty::compileAllConfig()
	 *
	 */
	public function compileAllConfig(
		$extension = '.conf',
		$force_compile = false,
		$time_limit = 0,
		$max_errors = null
	) {
		return $this->compileAll($extension, $force_compile, $time_limit, $max_errors, true);
	}

	/**
	 * Compile all template or config files
	 *
	 * @param string $extension template file name extension
	 * @param bool $force_compile force all to recompile
	 * @param int $time_limit set maximum execution time
	 * @param int $max_errors set maximum allowed errors
	 * @param bool $isConfig flag true if called for config files
	 *
	 * @return int number of template files compiled
	 */
	protected function compileAll(
		$extension,
		$force_compile,
		$time_limit,
		$max_errors,
		$isConfig = false
	) {
		// switch off time limit
		if (function_exists('set_time_limit')) {
			@set_time_limit($time_limit);
		}
		$_count = 0;
		$_error_count = 0;
		$sourceDir = $isConfig ? $this->getConfigDir() : $this->getTemplateDir();
		// loop over array of source directories
		foreach ($sourceDir as $_dir) {
			$_dir_1 = new RecursiveDirectoryIterator(
				$_dir,
				defined('FilesystemIterator::FOLLOW_SYMLINKS') ?
					FilesystemIterator::FOLLOW_SYMLINKS : 0
			);
			$_dir_2 = new RecursiveIteratorIterator($_dir_1);
			foreach ($_dir_2 as $_fileinfo) {
				$_file = $_fileinfo->getFilename();
				if (substr(basename($_fileinfo->getPathname()), 0, 1) === '.' || strpos($_file, '.svn') !== false) {
					continue;
				}
				if (substr_compare($_file, $extension, -strlen($extension)) !== 0) {
					continue;
				}
				if ($_fileinfo->getPath() !== substr($_dir, 0, -1)) {
					$_file = substr($_fileinfo->getPath(), strlen($_dir)) . DIRECTORY_SEPARATOR . $_file;
				}
				echo "\n", $_dir, '---', $_file;
				flush();
				$_start_time = microtime(true);
				$_smarty = clone $this;
				//
				$_smarty->force_compile = $force_compile;
				try {
					$_tpl = $this->doCreateTemplate($_file);
					$_tpl->caching = self::CACHING_OFF;
					$_tpl->setSource(
						$isConfig ? \Smarty\Template\Config::load($_tpl) : \Smarty\Template\Source::load($_tpl)
					);
					if ($_tpl->mustCompile()) {
						$_tpl->compileTemplateSource();
						$_count++;
						echo ' compiled in  ', microtime(true) - $_start_time, ' seconds';
						flush();
					} else {
						echo ' is up to date';
						flush();
					}
				} catch (\Exception $e) {
					echo "\n        ------>Error: ", $e->getMessage(), "\n";
					$_error_count++;
				}
				// free memory
				unset($_tpl);
				if ($max_errors !== null && $_error_count === $max_errors) {
					echo "\ntoo many errors\n";
					exit(1);
				}
			}
		}
		echo "\n";
		return $_count;
	}

	/**
	 * check client side cache
	 *
	 * @param \Smarty\Template\Cached $cached
	 * @param Template $_template
	 * @param string $content
	 *
	 * @throws \Exception
	 * @throws \Smarty\Exception
	 */
	public function cacheModifiedCheck(Template\Cached $cached, Template $_template, $content) {
		$_isCached = $_template->isCached() && !$_template->getCompiled()->getNocacheCode();
		$_last_modified_date =
			@substr($_SERVER['HTTP_IF_MODIFIED_SINCE'], 0, strpos($_SERVER['HTTP_IF_MODIFIED_SINCE'], 'GMT') + 3);
		if ($_isCached && $cached->timestamp <= strtotime($_last_modified_date)) {
			switch (PHP_SAPI) {
				case 'cgi': // php-cgi < 5.3
				case 'cgi-fcgi': // php-cgi >= 5.3
				case 'fpm-fcgi': // php-fpm >= 5.3.3
					header('Status: 304 Not Modified');
					break;
				case 'cli':
					if (/* ^phpunit */
					!empty($_SERVER['SMARTY_PHPUNIT_DISABLE_HEADERS']) /* phpunit$ */
					) {
						$_SERVER['SMARTY_PHPUNIT_HEADERS'][] = '304 Not Modified';
					}
					break;
				default:
					if (/* ^phpunit */
					!empty($_SERVER['SMARTY_PHPUNIT_DISABLE_HEADERS']) /* phpunit$ */
					) {
						$_SERVER['SMARTY_PHPUNIT_HEADERS'][] = '304 Not Modified';
					} else {
						header($_SERVER['SERVER_PROTOCOL'] . ' 304 Not Modified');
					}
					break;
			}
		} else {
			switch (PHP_SAPI) {
				case 'cli':
					if (/* ^phpunit */
					!empty($_SERVER['SMARTY_PHPUNIT_DISABLE_HEADERS']) /* phpunit$ */
					) {
						$_SERVER['SMARTY_PHPUNIT_HEADERS'][] =
							'Last-Modified: ' . gmdate('D, d M Y H:i:s', $cached->timestamp) . ' GMT';
					}
					break;
				default:
					header('Last-Modified: ' . gmdate('D, d M Y H:i:s', $cached->timestamp) . ' GMT');
					break;
			}
			echo $content;
		}
	}

	public function getModifierCallback(string $modifierName) {
		foreach ($this->getExtensions() as $extension) {
			if ($callback = $extension->getModifierCallback($modifierName)) {
				return [new CallbackWrapper($modifierName, $callback), 'handle'];
			}
		}
		return null;
	}

	public function getFunctionHandler(string $functionName): ?\Smarty\FunctionHandler\FunctionHandlerInterface {
		foreach ($this->getExtensions() as $extension) {
			if ($handler = $extension->getFunctionHandler($functionName)) {
				return $handler;
			}
		}
		return null;
	}

	public function getBlockHandler(string $blockTagName): ?\Smarty\BlockHandler\BlockHandlerInterface {
		foreach ($this->getExtensions() as $extension) {
			if ($handler = $extension->getBlockHandler($blockTagName)) {
				return $handler;
			}
		}
		return null;
	}

	public function getModifierCompiler(string $modifier): ?\Smarty\Compile\Modifier\ModifierCompilerInterface {
		foreach ($this->getExtensions() as $extension) {
			if ($handler = $extension->getModifierCompiler($modifier)) {
				return $handler;
			}
		}
		return null;
	}

	/**
	 * Run pre-filters over template source
	 *
	 * @param string $source the content which shall be processed by the filters
	 * @param Template $template template object
	 *
	 * @return string                   the filtered source
	 */
	public function runPreFilters($source, Template $template) {

		foreach ($this->getExtensions() as $extension) {
			/** @var \Smarty\Filter\FilterInterface $filter */
			foreach ($extension->getPreFilters() as $filter) {
				$source = $filter->filter($source, $template);
			}
		}

		// return filtered output
		return $source;
	}

	/**
	 * Run post-filters over template's compiled code
	 *
	 * @param string $code the content which shall be processed by the filters
	 * @param Template $template template object
	 *
	 * @return string                   the filtered code
	 */
	public function runPostFilters($code, Template $template) {

		foreach ($this->getExtensions() as $extension) {
			/** @var \Smarty\Filter\FilterInterface $filter */
			foreach ($extension->getPostFilters() as $filter) {
				$code = $filter->filter($code, $template);
			}
		}

		// return filtered output
		return $code;
	}

	/**
	 * Run filters over template output
	 *
	 * @param string $content the content which shall be processed by the filters
	 * @param Template $template template object
	 *
	 * @return string                   the filtered (modified) output
	 */
	public function runOutputFilters($content, Template $template) {

		foreach ($this->getExtensions() as $extension) {
			/** @var \Smarty\Filter\FilterInterface $filter */
			foreach ($extension->getOutputFilters() as $filter) {
				$content = $filter->filter($content, $template);
			}
		}

		// return filtered output
		return $content;
	}

	/**
	 * Writes file in a safe way to disk
	 *
	 * @param string $_filepath complete filepath
	 * @param string $_contents file content
	 *
	 * @return boolean true
	 * @throws Exception
	 */
	public function writeFile($_filepath, $_contents) {
		$_error_reporting = error_reporting();
		error_reporting($_error_reporting & ~E_NOTICE & ~E_WARNING);
		$_dirpath = dirname($_filepath);
		// if subdirs, create dir structure
		if ($_dirpath !== '.') {
			$i = 0;
			// loop if concurrency problem occurs
			// see https://bugs.php.net/bug.php?id=35326
			while (!is_dir($_dirpath)) {
				if (@mkdir($_dirpath, 0777, true)) {
					break;
				}
				clearstatcache();
				if (++$i === 3) {
					error_reporting($_error_reporting);
					throw new Exception("unable to create directory {$_dirpath}");
				}
				sleep(1);
			}
		}
		// write to tmp file, then move to overt file lock race condition
		$_tmp_file = $_dirpath . DIRECTORY_SEPARATOR . str_replace(['.', ','], '_', uniqid('wrt', true));
		if (!file_put_contents($_tmp_file, $_contents)) {
			error_reporting($_error_reporting);
			throw new Exception("unable to write file {$_tmp_file}");
		}
		/*
		 * Windows' rename() fails if the destination exists,
		 * Linux' rename() properly handles the overwrite.
		 * Simply unlink()ing a file might cause other processes
		 * currently reading that file to fail, but linux' rename()
		 * seems to be smart enough to handle that for us.
		 */
		if (\Smarty\Smarty::$_IS_WINDOWS) {
			// remove original file
			if (is_file($_filepath)) {
				@unlink($_filepath);
			}
			// rename tmp file
			$success = @rename($_tmp_file, $_filepath);
		} else {
			// rename tmp file
			$success = @rename($_tmp_file, $_filepath);
			if (!$success) {
				// remove original file
				if (is_file($_filepath)) {
					@unlink($_filepath);
				}
				// rename tmp file
				$success = @rename($_tmp_file, $_filepath);
			}
		}
		if (!$success) {
			error_reporting($_error_reporting);
			throw new Exception("unable to write file {$_filepath}");
		}
		// set file permissions
		@chmod($_filepath, 0666 & ~umask());
		error_reporting($_error_reporting);
		return true;
	}

	private $runtimes = [];

	/**
	 * Loads and returns a runtime extension or null if not found
	 *
	 * @param string $type
	 *
	 * @return object|null
	 */
	public function getRuntime(string $type) {

		if (isset($this->runtimes[$type])) {
			return $this->runtimes[$type];
		}

		// Lazy load runtimes when/if needed
		switch ($type) {
			case 'Capture':
				return $this->runtimes[$type] = new CaptureRuntime();
			case 'Foreach':
				return $this->runtimes[$type] = new ForeachRuntime();
			case 'Inheritance':
				return $this->runtimes[$type] = new InheritanceRuntime();
			case 'TplFunction':
				return $this->runtimes[$type] = new TplFunctionRuntime();
			case 'DefaultPluginHandler':
				return $this->runtimes[$type] = new DefaultPluginHandlerRuntime(
					$this->getDefaultPluginHandlerFunc()
				);
		}

		throw new \Smarty\Exception('Trying to load invalid runtime ' . $type);
	}

	/**
	 * Indicates if a runtime is available.
	 *
	 * @param string $type
	 *
	 * @return bool
	 */
	public function hasRuntime(string $type): bool {
		try {
			$this->getRuntime($type);
			return true;
		} catch (\Smarty\Exception $e) {
			return false;
		}
	}

	/**
	 * @return callable|null
	 */
	public function getDefaultPluginHandlerFunc(): ?callable {
		return $this->default_plugin_handler_func;
	}

	/**
	 * load a filter of specified type and name
	 *
	 * @param string $type filter type
	 * @param string $name filter name
	 *
	 * @return bool
	 * @throws \Smarty\Exception
	 * @api  Smarty::loadFilter()
	 *
	 * @deprecated since 5.0
	 */
	public function loadFilter($type, $name) {

		if ($type == \Smarty\Smarty::FILTER_VARIABLE) {
			foreach ($this->getExtensions() as $extension) {
				if ($extension->getModifierCallback($name)) {

					trigger_error('Using Smarty::loadFilter() to load variable filters is deprecated and will ' .
						'be removed in a future release. Use Smarty::addDefaultModifiers() to add a modifier.',
						E_USER_DEPRECATED);

					$this->addDefaultModifiers([$name]);
					return true;
				}
			}
		}

		trigger_error('Using Smarty::loadFilter() to load filters is deprecated and will be ' .
			'removed in a future release. Use Smarty::addExtension() to add an extension or Smarty::registerFilter to ' .
			'quickly register a filter using a callback function.', E_USER_DEPRECATED);

		if ($type == \Smarty\Smarty::FILTER_OUTPUT && $name == 'trimwhitespace') {
			$this->BCPluginsAdapter->addOutputFilter(new TrimWhitespace());
			return true;
		}

		$_plugin = "smarty_{$type}filter_{$name}";
		if (!is_callable($_plugin) && class_exists($_plugin, false)) {
			$_plugin = [$_plugin, 'execute'];
		}

		if (is_callable($_plugin)) {
			$this->registerFilter($type, $_plugin, $name);
			return true;
		}

		throw new Exception("{$type}filter '{$name}' not found or callable");
	}

	/**
	 * load a filter of specified type and name
	 *
	 * @param string $type filter type
	 * @param string $name filter name
	 *
	 * @return static
	 * @throws \Smarty\Exception
	 * @api  Smarty::unloadFilter()
	 *
	 *
	 * @deprecated since 5.0
	 */
	public function unloadFilter($type, $name) {
		trigger_error('Using Smarty::unloadFilter() to unload filters is deprecated and will be ' .
			'removed in a future release. Use Smarty::addExtension() to add an extension or Smarty::(un)registerFilter to ' .
			'quickly (un)register a filter using a callback function.', E_USER_DEPRECATED);

		return $this->unregisterFilter($type, $name);
	}

	private $_caching_type = 'file';

	/**
	 * @param $type
	 *
	 * @return void
	 * @deprecated since 5.0
	 */
	public function setCachingType($type) {
		trigger_error('Using Smarty::setCachingType() is deprecated and will be ' .
			'removed in a future release. Use Smarty::setCacheResource() instead.', E_USER_DEPRECATED);
		$this->_caching_type = $type;
		$this->activateBCCacheResource();
	}

	/**
	 * @return string
	 * @deprecated since 5.0
	 */
	public function getCachingType(): string {
		trigger_error('Using Smarty::getCachingType() is deprecated and will be ' .
			'removed in a future release.', E_USER_DEPRECATED);
		return $this->_caching_type;
	}

	/**
	 * Registers a resource to fetch a template
	 *
	 * @param string $name name of resource type
	 * @param Base $resource_handler
	 *
	 * @return static
	 *
	 * @api  Smarty::registerCacheResource()
	 *
	 * @deprecated since 5.0
	 */
	public function registerCacheResource($name, \Smarty\Cacheresource\Base $resource_handler) {

		trigger_error('Using Smarty::registerCacheResource() is deprecated and will be ' .
			'removed in a future release. Use Smarty::setCacheResource() instead.', E_USER_DEPRECATED);

		$this->registered_cache_resources[$name] = $resource_handler;
		$this->activateBCCacheResource();
		return $this;
	}

	/**
	 * Unregisters a resource to fetch a template
	 *
	 * @param                                                                 $name
	 *
	 * @return static
	 * @api  Smarty::unregisterCacheResource()
	 *
	 * @deprecated since 5.0
	 *
	 */
	public function unregisterCacheResource($name) {

		trigger_error('Using Smarty::unregisterCacheResource() is deprecated and will be ' .
			'removed in a future release.', E_USER_DEPRECATED);

		if (isset($this->registered_cache_resources[$name])) {
			unset($this->registered_cache_resources[$name]);
		}
		return $this;
	}

	private function activateBCCacheResource() {
		if ($this->_caching_type == 'file') {
			$this->setCacheResource(new File());
		}
		if (isset($this->registered_cache_resources[$this->_caching_type])) {
			$this->setCacheResource($this->registered_cache_resources[$this->_caching_type]);
		}
	}

	/**
	 * Registers a filter function
	 *
	 * @param string $type filter type
	 * @param callable $callback
	 * @param string|null $name optional filter name
	 *
	 * @return static
	 * @throws \Smarty\Exception
	 *
	 * @api  Smarty::registerFilter()
	 */
	public function registerFilter($type, $callback, $name = null) {
		$name = $name ?? $this->_getFilterName($callback);
		if (!is_callable($callback)) {
			throw new Exception("{$type}filter '{$name}' not callable");
		}
		switch ($type) {
			case 'variable':
				$this->registerPlugin(self::PLUGIN_MODIFIER, $name, $callback);
				trigger_error('Using Smarty::registerFilter() to register variable filters is deprecated and ' .
					'will be removed in a future release. Use Smarty::addDefaultModifiers() to add a modifier.',
					E_USER_DEPRECATED);

				$this->addDefaultModifiers([$name]);
				break;
			case 'output':
				$this->BCPluginsAdapter->addCallableAsOutputFilter($callback, $name);
				break;
			case 'pre':
				$this->BCPluginsAdapter->addCallableAsPreFilter($callback, $name);
				break;
			case 'post':
				$this->BCPluginsAdapter->addCallableAsPostFilter($callback, $name);
				break;
			default:
				throw new Exception("Illegal filter type '{$type}'");
		}

		return $this;
	}

	/**
	 * Return internal filter name
	 *
	 * @param callback $callable
	 *
	 * @return string|null   internal filter name or null if callable cannot be serialized
	 */
	private function _getFilterName($callable) {
		if (is_array($callable)) {
			$_class_name = is_object($callable[0]) ? get_class($callable[0]) : $callable[0];
			return $_class_name . '_' . $callable[1];
		} elseif (is_string($callable)) {
			return $callable;
		}
		return null;
	}

	/**
	 * Unregisters a filter function. Smarty cannot unregister closures/anonymous functions if
	 * no name was given in ::registerFilter.
	 *
	 * @param string $type filter type
	 * @param callback|string $name the name previously used in ::registerFilter
	 *
	 * @return static
	 * @throws \Smarty\Exception
	 * @api  Smarty::unregisterFilter()
	 *
	 *
	 */
	public function unregisterFilter($type, $name) {

		if (!is_string($name)) {
			$name = $this->_getFilterName($name);
		}

		if ($name) {
			switch ($type) {
				case 'output':
					$this->BCPluginsAdapter->removeOutputFilter($name);
					break;
				case 'pre':
					$this->BCPluginsAdapter->removePreFilter($name);
					break;
				case 'post':
					$this->BCPluginsAdapter->removePostFilter($name);
					break;
				default:
					throw new Exception("Illegal filter type '{$type}'");
			}
		}

		return $this;
	}

	/**
	 * Add default modifiers
	 *
	 * @param array|string $modifiers modifier or list of modifiers
	 *                                                                                   to add
	 *
	 * @return static
	 * @api Smarty::addDefaultModifiers()
	 *
	 */
	public function addDefaultModifiers($modifiers) {
		if (is_array($modifiers)) {
			$this->default_modifiers = array_merge($this->default_modifiers, $modifiers);
		} else {
			$this->default_modifiers[] = $modifiers;
		}
		return $this;
	}

	/**
	 * Get default modifiers
	 *
	 * @return array list of default modifiers
	 * @api Smarty::getDefaultModifiers()
	 *
	 */
	public function getDefaultModifiers() {
		return $this->default_modifiers;
	}

	/**
	 * Set default modifiers
	 *
	 * @param array|string $modifiers modifier or list of modifiers
	 *                                                                                   to set
	 *
	 * @return static
	 * @api Smarty::setDefaultModifiers()
	 *
	 */
	public function setDefaultModifiers($modifiers) {
		$this->default_modifiers = (array)$modifiers;
		return $this;
	}

	/**
	 * @return Cacheresource\Base
	 */
	public function getCacheResource(): Cacheresource\Base {
		return $this->cacheResource;
	}

	/**
	 * @param Cacheresource\Base $cacheResource
	 */
	public function setCacheResource(Cacheresource\Base $cacheResource): void {
		$this->cacheResource = $cacheResource;
	}

	/**
	 * fetches a rendered Smarty template
	 *
	 * @param string $template the resource handle of the template file or template object
	 * @param mixed $cache_id cache id to be used with this template
	 * @param mixed $compile_id compile id to be used with this template
	 *
	 * @return string rendered template output
	 * @throws Exception
	 * @throws Exception
	 */
	public function fetch($template = null, $cache_id = null, $compile_id = null) {
		return $this->returnOrCreateTemplate($template, $cache_id, $compile_id)->fetch();
	}

	/**
	 * displays a Smarty template
	 *
	 * @param string $template the resource handle of the template file or template object
	 * @param mixed $cache_id cache id to be used with this template
	 * @param mixed $compile_id compile id to be used with this template
	 *
	 * @throws \Exception
	 * @throws \Smarty\Exception
	 */
	public function display($template = null, $cache_id = null, $compile_id = null) {
		$this->returnOrCreateTemplate($template, $cache_id, $compile_id)->display();
	}

	/**
	 * @param $resource_name
	 * @param $cache_id
	 * @param $compile_id
	 * @param $parent
	 * @param $caching
	 * @param $cache_lifetime
	 * @param bool $isConfig
	 * @param array $data
	 *
	 * @return Template
	 * @throws Exception
	 */
	public function doCreateTemplate(
		$resource_name,
		$cache_id = null,
		$compile_id = null,
		$parent = null,
		$caching = null,
		$cache_lifetime = null,
		bool $isConfig = false,
		array $data = []): Template {

		if (!$this->_templateDirNormalized) {
			$this->_normalizeTemplateConfig(false);
		}

		$_templateId = $this->generateUniqueTemplateId($resource_name, $cache_id, $compile_id, $caching);

		if (!isset($this->templates[$_templateId])) {
			$newTemplate = new Template($resource_name, $this, $parent ?: $this, $cache_id, $compile_id, $caching, $isConfig);
			$newTemplate->templateId = $_templateId; // @TODO this could go in constructor ^?
			$this->templates[$_templateId] = $newTemplate;
		}

		$tpl = clone $this->templates[$_templateId];

		$tpl->setParent($parent ?: $this);

		if ($cache_lifetime) {
			$tpl->setCacheLifetime($cache_lifetime);
		}

		// fill data if present
		foreach ($data as $_key => $_val) {
			$tpl->assign($_key, $_val);
		}

		$tpl->tplFunctions = array_merge($parent->tplFunctions ?? [], $tpl->tplFunctions ?? []);

		if (!$this->debugging && $this->debugging_ctrl === 'URL') {
			$tpl->getSmarty()->getDebug()->debugUrl($tpl->getSmarty());
		}
		return $tpl;
	}

	/**
	 * test if cache is valid
	 *
	 * @param null|string|Template $template the resource handle of the template file or template
	 *                                                          object
	 * @param mixed $cache_id cache id to be used with this template
	 * @param mixed $compile_id compile id to be used with this template
	 *
	 * @return bool cache status
	 * @throws \Exception
	 * @throws \Smarty\Exception
	 *
	 * @api  Smarty::isCached()
	 */
	public function isCached($template = null, $cache_id = null, $compile_id = null) {
		return $this->returnOrCreateTemplate($template, $cache_id, $compile_id)->isCached();
	}

	/**
	 * @param $template
	 * @param $cache_id
	 * @param $compile_id
	 * @param $parent
	 *
	 * @return Template
	 * @throws Exception
	 */
	private function returnOrCreateTemplate($template, $cache_id = null, $compile_id = null) {
		if (!($template instanceof Template)) {
			$template = $this->createTemplate($template, $cache_id, $compile_id, $this);
			$template->caching = $this->caching;
		}
		return $template;
	}

	/**
	 * Sets if Smarty should check If-Modified-Since headers to determine cache validity.
	 * @param bool $cache_modified_check
	 * @return void
	 */
	public function setCacheModifiedCheck($cache_modified_check): void {
		$this->cache_modified_check = (bool) $cache_modified_check;
	}

}