Merge branch 'master' into 420upd

PHP8.2 compatibility (#775 )
* PHP8.2 compatibility * PHP8.2 compatibility : Fixed unit tests * PHP8.2 compatibility : Replace ENT_COMPAT by ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401 * PHP8.2 compatibility : Remove deprecated utf8_decode * PHP8.2 compatibility : Remove HTML-ENTITIES parameter * Removed some unused code for clarity, updated the changelog. * More concise escape implementation and unit test to cover both modifierplugin and modifiercompiler. * Fix htmlall unescape of quotes without mbstring too Co-authored-by: Simon Wisselink <s.wisselink@iwink.nl>
2026-08-04 12:34:33 +02:00 · 2022-11-22 21:31:35 +01:00 · 2022-11-22 21:22:57 +01:00 · 2022-10-22 22:08:38 +02:00 · 2022-09-29 09:24:42 +02:00 · 2022-09-27 12:24:08 +02:00
316 changed files with 2290 additions and 1701 deletions
@@ -7,8 +7,10 @@

 # exclude from git export
 /tests export-ignore
-/utilities/ export-ignore
-
+/utilities export-ignore
+/docker-compose.yml export-ignore
+/.github export-ignore
+/run_tests_for_all_php_versions.sh export-ignore
 /.gitattributes export-ignore
 /.gitignore export-ignore
 /make-release.sh export-ignore
@@ -1,8 +1,10 @@
 # https://help.github.com/en/categories/automating-your-workflow-with-github-actions

 on:
-  - pull_request
-  - push
+  pull_request:
+  push:
+    branches:
+      - 'master'

 name: CI

@@ -28,6 +30,8 @@ jobs:
          - "7.3"
          - "7.4"
          - "8.0"
+          - "8.1"
+          - "8.2"

        compiler:
          - default
@@ -36,6 +40,12 @@ jobs:
          - os: ubuntu-latest
            php-version: "8.0"
            compiler: jit
+          - os: ubuntu-latest
+            php-version: "8.1"
+            compiler: jit
+          - os: ubuntu-latest
+            php-version: "8.2"
+            compiler: jit

    steps:
    - name: Checkout
@@ -65,9 +75,5 @@ jobs:
        restore-keys: |
          ${{ runner.os }}-php-${{ matrix.php-version }}-

-    - name: Install dependencies
-      if: steps.composer-cache.outputs.cache-hit != 'true'
-      run: composer install --prefer-dist --no-progress --no-suggest
-
    - name: Run tests with phpunit
-      run: ./phpunit.sh
+      run: ./run-tests.sh
@@ -5,7 +5,6 @@
 lexer/*.php
 lexer/*.php.bak
 lexer/*.out
-utilies/*.php

 # Dev
 phpunit*
@@ -6,6 +6,82 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+### Added
+- PHP8.2 compatibility [#775](https://github.com/smarty-php/smarty/pull/775)
+
+### Changed
+- Include docs and demo in the releases [#799](https://github.com/smarty-php/smarty/issues/799)
+- Using PHP functions as modifiers now triggers a deprecation notice because we will drop support for this in the next major release [#813](https://github.com/smarty-php/smarty/issues/813) 
+-  Dropped remaining references to removed PHP-support in Smarty 4 from docs, lexer and security class. [#816](https://github.com/smarty-php/smarty/issues/816)
+
+### Fixed
+- Output buffer is now cleaned for internal PHP errors as well, not just for Exceptions [#514](https://github.com/smarty-php/smarty/issues/514)
+- Fixed recursion and out of memory errors when caching in complicated template set-ups using inheritance and includes [#801](https://github.com/smarty-php/smarty/pull/801)
+- Fixed PHP8.1 deprecation errors in strip_tags 
+- Fix Variable Usage in Exception message when unable to load subtemplate [#808](https://github.com/smarty-php/smarty/pull/808)
+- Fixed PHP8.1 deprecation notices for strftime [#672](https://github.com/smarty-php/smarty/issues/672)
+- Fixed PHP8.1 deprecation errors passing null to parameter in trim [#807](https://github.com/smarty-php/smarty/pull/807)
+- Adapt Smarty upper/lower functions to be codesafe (e.g. for Turkish locale) [#586](https://github.com/smarty-php/smarty/pull/586)
+- Bug fix for underscore and limited length in template name in custom resources [#581](https://github.com/smarty-php/smarty/pull/581)
+
+## [4.2.1] - 2022-09-14
+
+### Security
+- Applied appropriate javascript and html escaping in mailto plugin to counter injection attacks [#454](https://github.com/smarty-php/smarty/issues/454)
+
+### Fixed
+- Fixed PHP8.1 deprecation notices in modifiers (upper, explode, number_format and replace) [#755](https://github.com/smarty-php/smarty/pull/755) and [#788](https://github.com/smarty-php/smarty/pull/788)
+- Fixed PHP8.1 deprecation notices in capitalize modifier [#789](https://github.com/smarty-php/smarty/issues/789)
+- Fixed use of `rand()` without a parameter in math function [#794](https://github.com/smarty-php/smarty/issues/794)
+- Fixed unselected year/month/day not working in html_select_date [#395](https://github.com/smarty-php/smarty/issues/395)
+
+## [4.2.0] - 2022-08-01
+
+### Fixed
+- Fixed problems with smarty_mb_str_replace [#549](https://github.com/smarty-php/smarty/issues/549)
+- Fixed second parameter of unescape modifier not working [#777](https://github.com/smarty-php/smarty/issues/777)
+
+### Changed
+- Updated HTML of the debug template [#599](https://github.com/smarty-php/smarty/pull/599)
+
+## [4.1.1] - 2022-05-17
+
+### Security
+- Prevent PHP injection through malicious block name or include file name. This addresses CVE-2022-29221
+
+### Fixed
+- Exclude docs and demo from export and composer [#751](https://github.com/smarty-php/smarty/pull/751)
+- PHP 8.1 deprecation notices in demo/plugins/cacheresource.pdo.php [#706](https://github.com/smarty-php/smarty/issues/706)
+- PHP 8.1 deprecation notices in truncate modifier [#699](https://github.com/smarty-php/smarty/issues/699)
+- Math equation `max(x, y)` didn't work anymore [#721](https://github.com/smarty-php/smarty/issues/721)
+- Fix PHP 8.1 deprecated warning when calling rtrim [#743](https://github.com/smarty-php/smarty/pull/743)
+- PHP 8.1: fix deprecation in escape modifier [#727](https://github.com/smarty-php/smarty/pull/727)
+
+## [4.1.0] - 2022-02-06
+
+### Added
+- PHP8.1 compatibility [#713](https://github.com/smarty-php/smarty/pull/713)
+
+## [4.0.4] - 2022-01-18
+
+### Fixed
+- Fixed illegal characters bug in math function security check [#702](https://github.com/smarty-php/smarty/issues/702)
+
+## [4.0.3] - 2022-01-10
+
+### Security
+- Prevent evasion of the `static_classes` security policy. This addresses CVE-2021-21408
+
+## [4.0.2] - 2022-01-10
+
+### Security
+- Prevent arbitrary PHP code execution through maliciously crafted expression for the math function. This addresses CVE-2021-29454
+
+## [4.0.1] - 2022-01-09
+
+### Security
+- Rewrote the mailto function to not use `eval` when encoding with javascript
+
 ## [4.0.0] - 2021-11-25

 ## [4.0.0-rc.0] - 2021-10-13
@@ -7,7 +7,7 @@ Smarty is a template engine for PHP, facilitating the separation of presentation
 Read the [documentation](https://smarty-php.github.io/smarty/) to find out how to use it. 

 ## Requirements
-Smarty can be run with PHP 7.1 to PHP 8.0.
+Smarty can be run with PHP 7.1 to PHP 8.2.

 ## Installation
 Smarty versions 3.1.11 or later can be installed with [Composer](https://getcomposer.org/).
@@ -17,12 +17,4 @@ To get the latest stable version of Smarty use:
 composer require smarty/smarty
 ````

-To get the latest, unreleased version, use:
-```bash
-composer require smarty/smarty:dev-master
-````
-
-To get the previous stable version of Smarty, Smarty 3, use:
-```bash
-composer require smarty/smarty:^3
-````
+More in the [Getting Started](./docs/getting-started.md) section of the docs.
@@ -2,7 +2,7 @@

 ## Supported Versions

-Smarty currently supports the latest minor version of Smarty 3 and Smarty 4. (Smarty 4 has not been released yet.)
+Smarty currently supports the latest minor version of Smarty 3 and Smarty 4.

 | Version | Supported          |
 | ------- | ------------------ |
@@ -5,7 +5,7 @@
    "keywords": [
        "templating"
    ],
-    "homepage": "https://www.smarty.net",
+    "homepage": "https://smarty-php.github.io/smarty/",
    "license": "LGPL-3.0",
    "authors": [
        {
@@ -27,7 +27,7 @@
    ],
    "support": {
        "issues": "https://github.com/smarty-php/smarty/issues",
-        "forum": "https://www.smarty.net/forums/"
+        "forum": "https://github.com/smarty-php/smarty/discussions"
    },
    "require": {
        "php": "^7.1 || ^8.0"
@@ -196,7 +196,7 @@ class Smarty_CacheResource_Pdo extends Smarty_CacheResource_Custom
     * @return void
     * @access protected
     */
-    protected function fetch($id, $name, $cache_id = null, $compile_id = null, &$content, &$mtime)
+    protected function fetch($id, $name, $cache_id, $compile_id, &$content, &$mtime)
    {
        $stmt = $this->getFetchStatement($this->fetchColumns, $id, $cache_id, $compile_id);
        $stmt->execute();
@@ -244,7 +244,7 @@ class Smarty_CacheResource_Pdo extends Smarty_CacheResource_Custom
     * @return boolean success
     * @access protected
     */
-    protected function save($id, $name, $cache_id = null, $compile_id = null, $exp_time, $content)
+    protected function save($id, $name, $cache_id, $compile_id, $exp_time, $content)
    {
        $stmt = $this->pdo->prepare($this->insertStatement);
        $stmt->bindValue('id', $id);
@@ -0,0 +1,45 @@
+version: "2"
+services:
+  base:
+    build:
+      context: .
+      dockerfile: ./utilities/testrunners/php71/Dockerfile
+    volumes:
+      - .:/app
+    working_dir: /app
+    entrypoint: sh ./run-tests.sh
+  php71:
+    extends:
+      service: base
+    build:
+      dockerfile: ./utilities/testrunners/php71/Dockerfile
+  php72:
+    extends:
+      service: base
+    build:
+      dockerfile: ./utilities/testrunners/php72/Dockerfile
+  php73:
+    extends:
+      service: base
+    build:
+      dockerfile: ./utilities/testrunners/php73/Dockerfile
+  php74:
+    extends:
+      service: base
+    build:
+      dockerfile: ./utilities/testrunners/php74/Dockerfile
+  php80:
+    extends:
+      service: base
+    build:
+      dockerfile: ./utilities/testrunners/php80/Dockerfile
+  php81:
+    extends:
+      service: base
+    build:
+      dockerfile: ./utilities/testrunners/php81/Dockerfile
+  php82:
+    extends:
+      service: base
+    build:
+      dockerfile: ./utilities/testrunners/php82/Dockerfile
@@ -1,5 +0,0 @@
-BUGS
-====
-
-Check the `BUGS` file that comes with the latest distribution of Smarty,
-or check the website.
@@ -1,15 +0,0 @@
-Resources {#inforesources}
-=========
-
-Smarty\'s homepage is located at [URL.SMARTY](&url.smarty;)
-
-   You can join the mailing list by sending an e-mail to ``. An archive
-    of the mailing list can be viewed at [here](&url.ml.archive;)
-
-   Forums are at [URL.FORUMS](&url.forums;)
-
-   The wiki is located at [URL.WIKI](&url.wiki;)
-
-   Join the chat at [irc.freenode.net\#smarty](&url.wiki;)
-
-   FAQ\'s are [here](&url.faq_1;) and [here](&url.faq_2;)
@@ -188,67 +188,6 @@ See also [`{html_select_date}`](#language.function.html.select.date),
 [`date_format`](#language.modifier.date.format) and
 [`$smarty.now`](#language.variables.smarty.now),

-WAP/WML {#tips.wap}
-=======
-
-WAP/WML templates require a php [Content-Type
-header](&url.php-manual;header) to be passed along with the template.
-The easist way to do this would be to write a custom function that
-prints the header. If you are using [caching](#caching), that won\'t
-work so we\'ll do it using the [`{insert}`](#language.function.insert)
-tag; remember `{insert}` tags are not cached! Be sure that there is
-nothing output to the browser before the template, or else the header
-may fail.
-
-
-    <?php
-
-    // be sure apache is configure for the .wml extensions!
-    // put this function somewhere in your application, or in Smarty.addons.php
-    function insert_header($params)
-    {
-       // this function expects $content argument
-       if (empty($params['content'])) {
-           return;
-       }
-       header($params['content']);
-       return;
-    }
-
-    ?>
-
-        
-
-your Smarty template *must* begin with the insert tag :
-
-
-    {insert name=header content="Content-Type: text/vnd.wap.wml"}
-
-    <?xml version="1.0"?>
-    <!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml">
-
-    <!-- begin new wml deck -->
-    <wml>
-     <!-- begin first card -->
-     <card>
-      <do type="accept">
-       <go href="#two"/>
-      </do>
-      <p>
-       Welcome to WAP with Smarty!
-       Press OK to continue...
-      </p>
-     </card>
-     <!-- begin second card -->
-     <card id="two">
-      <p>
-       Pretty easy isn't it?
-      </p>
-     </card>
-    </wml>
-
-        
-
 Componentized Templates {#tips.componentized.templates}
 =======================

@@ -259,7 +198,7 @@ Smarty object, [`assign()`](#api.assign) the variables and
 [`display()`](#api.display) the template. So lets say for example we
 have a stock ticker on our template. We would collect the stock data in
 our application, then assign these variables in the template and display
-it. Now wouldn\'t it be nice if you could add this stock ticker to any
+it. Now wouldn't it be nice if you could add this stock ticker to any
 application by merely including the template, and not worry about
 fetching the data up front?

@@ -301,9 +240,7 @@ assigning it to a template variable.

        

-See also [`{include_php}`](#language.function.include.php),
-[`{include}`](#language.function.include) and
-[`{php}`](#language.function.php).
+See also: [`{include}`](#language.function.include).

 Obfuscating E-mail Addresses {#tips.obfuscating.email}
 ============================
@@ -109,7 +109,7 @@ the corresponding error is in the template.

       

-   This means that your application registered a custom error hander
+-   This means that your application registered a custom error handler
    (using [set\_error\_handler()](&url.php-manual;set_error_handler))
    which is not respecting the given `$errno` as it should. If, for
    whatever reason, this is the desired behaviour of your custom error
@@ -1,6 +1,18 @@
 Basic Syntax
 ============

+A simple Smarty template could look like this:
+```html
+<h1>{$title|escape}</h1>
+<ul>
+    {foreach $cities as $city}
+        <li>{$city.name|escape} ({$city.population})</li>
+    {foreachelse}
+        <li>no cities found</li>        
+    {/foreach}
+</ul>
+```
+
 All Smarty template tags are enclosed within delimiters. By default
 these are `{` and `}`, but they can be
 [changed](../programmers/api-variables/variable-left-delimiter.md).
@@ -11,6 +23,7 @@ displayed as static content, or unchanged. When Smarty encounters
 template tags, it attempts to interpret them, and displays the
 appropriate output in their place.

+The basis components of the Smarty syntax are:
 - [Comments](./language-basic-syntax/language-syntax-comments.md)
 - [Variables](./language-basic-syntax/language-syntax-variables.md)
 - [Functions](./language-basic-syntax/language-syntax-functions.md)
@@ -3,7 +3,7 @@ Attributes {#language.syntax.attributes}

 Most of the [functions](#language.syntax.functions) take attributes that
 specify or modify their behavior. Attributes to Smarty functions are
-much like HTML attributes. Static values don\'t have to be enclosed in
+much like HTML attributes. Static values don't have to be enclosed in
 quotes, but it is required for literal strings. Variables with or
 without modifiers may also be used, and should not be in quotes. You can
 even use PHP function results, plugin results and complex expressions.
@@ -16,12 +16,10 @@ Built-in Functions {#language.builtin.functions}
 - [{function}](./language-builtin-functions/language-function-function.md)
 - [{if},{elseif},{else}](./language-builtin-functions/language-function-if.md)
 - [{include}](./language-builtin-functions/language-function-include.md)
- [{include_php}](./language-builtin-functions/language-function-include.php)
 - [{insert}](./language-builtin-functions/language-function-insert.md)
 - [{ldelim},{rdelim}](./language-builtin-functions/language-function-ldelim.md)
 - [{literal}](./language-builtin-functions/language-function-literal.md)
 - [{nocache}](./language-builtin-functions/language-function-nocache.md)
- [{php}](./language-builtin-functions/language-function-php.md)
 - [{section},{sectionelse}](./language-builtin-functions/language-function-section.md)
 - [{setfilter}](./language-builtin-functions/language-function-setfilter.md)
 - [{strip}](./language-builtin-functions/language-function-strip.md)
@@ -135,7 +135,6 @@ The following functions can also *optionally* assign template variables.

 [`{capture}`](#language.function.capture),
 [`{include}`](#language.function.include),
-[`{include_php}`](#language.function.include.php),
 [`{insert}`](#language.function.insert),
 [`{counter}`](#language.function.counter),
 [`{cycle}`](#language.function.cycle),
@@ -3,14 +3,14 @@

 `{block}` is used to define a named area of template source for template
 inheritance. For details see section of [Template
-Interitance](#advanced.features.template.inheritance).
+Inheritance](#advanced.features.template.inheritance).

 The `{block}` template source area of a child template will replace the
-correponding areas in the parent template(s).
+corresponding areas in the parent template(s).

 Optionally `{block}` areas of child and parent templates can be merged
 into each other. You can append or prepend the parent `{block}` content
-by using the `append` or `prepend` option flag with the childs `{block}`
+by using the `append` or `prepend` option flag with the child's `{block}`
 definition. With the {\$smarty.block.parent} the `{block}` content of
 the parent template can be inserted at any location of the child
 `{block}` content. {\$smarty.block.child} inserts the `{block}` content
@@ -3,7 +3,7 @@

 `{extends}` tags are used in child templates in template inheritance for
 extending parent templates. For details see section of [Template
-Interitance](#advanced.features.template.inheritance).
+Inheritance](#advanced.features.template.inheritance).

 -   The `{extends}` tag must be on the first line of the template.

@@ -33,5 +33,5 @@ Interitance](#advanced.features.template.inheritance).

      

-See also [Template Interitance](#advanced.features.template.inheritance)
+See also [Template Inheritance](#advanced.features.template.inheritance)
 and [`{block}`](#language.function.block).
@@ -2,7 +2,7 @@
 =====

 The `{for}{forelse}` tag is used to create simple loops. The following
-different formarts are supported:
+different formats are supported:

 -   `{for $var=$start to $end}` simple loop with step size of 1.

@@ -1,74 +0,0 @@
-{include\_php} {#language.function.include.php}
-==============
-
-> **Note**
->
-> `{include_php}` is deprecated from Smarty, use registered plugins to
-> properly insulate presentation from the application code. As of Smarty
-> 3.1 the `{include_php}` tags are only available from [SmartyBC](#bc).
-
-   Attribute Name    Type     Required   Default  Description
-  ---------------- --------- ---------- --------- ----------------------------------------------------------------------------------
-        file        string      Yes       *n/a*   The name of the php file to include as absolute path
-        once        boolean      No      *TRUE*   whether or not to include the php file more than once if included multiple times
-       assign       string       No       *n/a*   The name of the variable that the output of include\_php will be assigned to
-
-**Option Flags:**
-
-    Name    Description
-  --------- ----------------------------------------
-   nocache  Disables caching of inluded PHP script
-
-`{include_php}` tags are used to include a php script in your template.
-The path of the attribute `file` can be either absolute, or relative to
-[`$trusted_dir`](#variable.trusted.dir). If security is enabled, then
-the script must be located in the `$trusted_dir` path of the securty
-policy. See the [Security](#advanced.features.security) section for
-details.
-
-By default, php files are only included once even if called multiple
-times in the template. You can specify that it should be included every
-time with the `once` attribute. Setting once to FALSE will include the
-php script each time it is included in the template.
-
-You can optionally pass the `assign` attribute, which will specify a
-template variable name that the output of `{include_php}` will be
-assigned to instead of displayed.
-
-The smarty object is available as `$_smarty_tpl->smarty` within the PHP
-script that you include.
-
-The `load_nav.php` file:
-
-
-    <?php
-
-    // load in variables from a mysql db and assign them to the template
-    require_once('database.class.php');
-    $db = new Db();
-    $db->query('select url, name from navigation order by name');
-    $this->assign('navigation', $db->getRows());
-
-    ?>
-
-      
-
-where the template is:
-
-
-    {* absolute path, or relative to $trusted_dir *}
-    {include_php file='/path/to/load_nav.php'}
-    {include_php '/path/to/load_nav.php'}             {* short-hand *}
-
-    {foreach item='nav' from=$navigation}
-      <a href="{$nav.url}">{$nav.name}</a><br />
-    {/foreach}
-
-      
-
-See also [`{include}`](#language.function.include),
-[`$trusted_dir`](#variable.trusted.dir),
-[`{php}`](#language.function.php),
-[`{capture}`](#language.function.capture), [template
-resources](#resources) and [componentized
-templates](#tips.componentized.templates)
@@ -131,7 +131,7 @@ cache lifetime of 500 seconds.
      

 In this example included template will be cached independent of the
-global cahing setting.
+global caching setting.


    {include 'sub_template.tpl' caching}
@@ -188,7 +188,5 @@ current template.

      

-See also [`{include_php}`](#language.function.include.php),
-[`{insert}`](#language.function.insert),
-[`{php}`](#language.function.php), [template resources](#resources) and
+See also [`{insert}`](#language.function.insert), [template resources](#resources) and
 [componentized templates](#tips.componentized.templates).
@@ -65,7 +65,7 @@ and display the returned results in place of the {insert} tag.
    The path can be either absolute, or relative to
    [`$trusted_dir`](#variable.trusted.dir). If security is enabled,
    then the script must be located in the `$trusted_dir` path of the
-    securty policy. See the [Security](#advanced.features.security)
+    security policy. See the [Security](#advanced.features.security)
    section for details.

 The Smarty object is passed as the second argument. This way you can
@@ -1,45 +0,0 @@
-{php} {#language.function.php}
-=====
-
-> **Note**
->
-> `{php}` tags are deprecated from Smarty, and should not be used. Put
-> your PHP logic in PHP scripts or plugin functions instead.
-
-> **Note**
->
-> As of Smarty 3.1 the `{php}` tags are only available from
-> [SmartyBC](#bc).
-
-The `{php}` tags allow PHP code to be embedded directly into the
-template. They will not be escaped, regardless of the
-[`$php_handling`](#variable.php.handling) setting.
-
-
-    {php}
-       // including a php script directly from the template.
-       include('/path/to/display_weather.php');
-    {/php}
-
-      
-
-
-    {* this template includes a {php} block that assign's the variable $varX *}
-    {php}
-       global $foo, $bar;
-       if($foo == $bar){
-         echo 'This will be sent to browser';
-       }
-      // assign a variable to Smarty
-      $this->assign('varX','Toffee');
-    {/php}
-    {* output the variable *}
-    <strong>{$varX}</strong> is my fav ice cream :-)
-
-      
-
-See also [`$php_handling`](#variable.php.handling),
-[`{include_php}`](#language.function.include.php),
-[`{include}`](#language.function.include),
-[`{insert}`](#language.function.insert) and [componentized
-templates](#tips.componentized.templates).
@@ -251,8 +251,8 @@ The above example will output:

 {section}\'s can be nested as deep as you like. With nested
 {section}\'s, you can access complex data structures, such as
-multi-dimensional arrays. This is an example `.php` script thats
-assign\'s the arrays.
+multi-dimensional arrays. This is an example `.php` script that
+assigns the arrays.


    <?php
@@ -10,7 +10,7 @@ The filter can be:

 -   A variable filter plugin specified by it\'s name.

-   A modidier specified by it\'s name and optional additional
+-   A modifier specified by it\'s name and optional additional
    parameter.

 `{setfilter}...{/setfilter}` blocks can be nested. The filter definition
@@ -22,7 +22,7 @@ ftp and display the contents.
    >
    > If security is enabled and you are fetching a file from the local
    > file system, `{fetch}` will only allow files from within the
-    > `$secure_dir` path of the securty policy. See the
+    > `$secure_dir` path of the security policy. See the
    > [Security](#advanced.features.security) section for details.

 -   If the `assign` attribute is set, the output of the `{fetch}`
@@ -19,7 +19,7 @@ automatically calculated from the image file if they are not supplied.
    from. If not given, the web server\'s document root
    `$_ENV['DOCUMENT_ROOT']` is used as the base. If security is
    enabled, then the image must be located in the `$secure_dir` path of
-    the securty policy. See the [Security](#advanced.features.security)
+    the security policy. See the [Security](#advanced.features.security)
    section for details.

 -   `href` is the href value to link the image to. If link is supplied,
@@ -115,7 +115,7 @@ These parameters follow the modifier name and are separated by a `:`

    -   Secondly - if security is enabled, all php-functions that are to
        be used as modifiers have to be declared trusted in the
-        `$modifiers` property of the securty policy. See the
+        `$modifiers` property of the security policy. See the
        [Security](../programmers/advanced-features/advanced-features-security.md) section for details.

 See also [`registerPlugin()`](../programmers/api-functions/api-register-plugin.md), [combining
@@ -15,5 +15,5 @@ modifier](#language.modifier.to_charset).
 > modifier should only be used in cases where the application cannot
 > anticipate that a certain string is required in another encoding.

-See also [Charset Enconding](#charset), [from\_charset
+See also [Charset Encoding](#charset), [from\_charset
 modifier](#language.modifier.from_charset).
@@ -15,5 +15,5 @@ modifier](#language.modifier.from_charset).
 > modifier should only be used in cases where the application cannot
 > anticipate that a certain string is required in another encoding.

-See also [Charset Enconding](#charset), [from\_charset
+See also [Charset Encoding](#charset), [from\_charset
 modifier](#language.modifier.from_charset).
@@ -157,13 +157,13 @@ Returns the version of Smarty the template was compiled with.
 ----------------------

 Returns block text from child template. See [Template
-interitance](#advanced.features.template.inheritance).
+inheritance](#advanced.features.template.inheritance).

 {\$smarty.block.parent} {#language.variables.smarty.block.parent}
 -----------------------

 Returns block text from parent template. See [Template
-interitance](#advanced.features.template.inheritance)
+inheritance](#advanced.features.template.inheritance)

 {\$smarty.ldelim}, {\$smarty.rdelim} {#language.variables.smarty.ldelim}
 ------------------------------------
@@ -0,0 +1,152 @@
+Features
+=======
+
+Some of Smarty's features:
+-   It is extremely fast.
+-   It is efficient since the PHP parser does the dirty work.
+-   No template parsing overhead, only compiles once.
+-   It is smart about [recompiling](#variable.compile.check) only the
+    template files that have changed.
+-   You can easily create your own custom
+    [functions](#language.custom.functions) and [variable
+    modifiers](#language.modifiers), so the template language is
+    extremely extensible.
+-   Configurable template [{delimiter}](#variable.left.delimiter) tag
+    syntax, so you can use `{$foo}`, `{{$foo}}`, `<!--{$foo}-->`, etc.
+-   The [`{if}..{elseif}..{else}..{/if}`](#language.function.if)
+    constructs are passed to the PHP parser, so the `{if...}` expression
+    syntax can be as simple or as complex an evaluation as you like.
+-   Allows unlimited nesting of
+    [`sections`](#language.function.section), `if's` etc.
+-   Built-in [caching](#caching) support
+-   Arbitrary [template](#resources) sources
+-   [Template Inheritance](#advanced.features.template.inheritance) for
+    easy management of template content.
+-   [Plugin](#plugins) architecture
+
+## Separation of presentation from application code
+-   This means templates can certainly contain logic under the condition
+    that it is for presentation only. Things such as
+    [including](./designers/language-builtin-functions/language-function-include.md) other templates,
+    [alternating](./designers/language-custom-functions/language-function-cycle.md) table row colors,
+    [upper-casing](./designers/language-modifiers/language-modifier-upper.md) a variable,
+    [looping](./designers/language-builtin-functions/language-function-foreach.md) over an array of data and
+    rendering it are examples of presentation logic.
+-   This does not mean however that Smarty forces a separation of
+    business and presentation logic. Smarty has no knowledge of which is
+    which, so placing business logic in the template is your own doing.
+-   Also, if you desire *no* logic in your templates you certainly can
+    do so by boiling the content down to text and variables only.
+
+## How does it work?
+
+Under the hood, Smarty "compiles" (basically copies and converts) the
+templates into PHP scripts. This happens once when each template is
+first invoked, and then the compiled versions are used from that point
+forward. Smarty takes care of this for you, so the template designer
+just edits the Smarty templates and never has to manage the compiled
+versions. This approach keeps the templates easy to maintain, and yet
+keeps execution times extremely fast since the compiled code is just
+PHP. And of course, all PHP scripts take advantage of PHP op-code caches
+such as APC.
+
+## Template Inheritance
+
+Template inheritance was introduced in Smarty 3. Before template
+inheritance, we managed our templates in
+pieces such as header and footer templates. This organization lends
+itself to many problems that require some hoop-jumping, such as managing
+content within the header/footer on a per-page basis. With template
+inheritance, instead of including other templates we maintain our
+templates as single pages. We can then manipulate blocks of content
+within by inheriting them. This makes templates intuitive, efficient and
+easy to manage. See
+[Template Inheritance](./programmers/advanced-features/advanced-features-template-inheritance.md)
+for more info.
+
+## Why not use XML/XSLT syntax?
+There are a couple of good reasons. First, Smarty can be used for more
+than just XML/HTML based templates, such as generating emails,
+javascript, CSV, and PDF documents. Second, XML/XSLT syntax is even more
+verbose and fragile than PHP code! It is perfect for computers, but
+horrible for humans. Smarty is about being easy to read, understand and
+maintain.
+
+## Template Security
+Although Smarty insulates you from PHP, you still have the option to use
+it in certain ways if you wish. Template security forces the restriction
+of PHP (and select Smarty functions.) This is useful if you have third
+parties editing templates, and you don't want to unleash the full power
+of PHP or Smarty to them.
+
+## Integration
+Sometimes Smarty gets compared to Model-View-Controller (MVC)
+frameworks. Smarty is not an MVC, it is just the presentation layer,
+much like the View (V) part of an MVC. As a matter of fact, Smarty can
+easily be integrated as the view layer of an MVC. Many of the more
+popular ones have integration instructions for Smarty, or you may find
+some help here in the forums and documentation.
+
+## Other Template Engines
+Smarty is not the only engine following the *"Separate Programming Code
+from Presentation"* philosophy. For instance, Python has template
+engines built around the same principles such as Django Templates and
+CheetahTemplate. *Note: Languages such as Python do not mix with HTML
+natively, which give them the advantage of proper programming code
+separation from the outset. There are libraries available to mix Python
+with HTML, but they are typically avoided.*
+
+## What Smarty is Not
+
+Smarty is not an application development framework. Smarty is not an
+MVC. Smarty is not an alternative to Laravel, Symfony, CodeIgniter,
+or any of the other application development frameworks for PHP.
+
+Smarty is a template engine, and works as the (V)iew component of your
+application. Smarty can easily be coupled to any of the engines listed
+above as the view component. No different than any other software,
+Smarty has a learning curve. Smarty does not guarantee good application
+design or proper separation of presentation, this still needs to be
+addressed by a competent developer and web designer.
+
+## Is Smarty Right for Me?
+
+Smarty is not meant to be a tool for every job. The important thing is
+to identify if Smarty fits your needs. There are some important
+questions to ask yourself:
+
+### Template Syntax
+Are you content with PHP tags mixed with HTML? Are your
+web designers comfortable with PHP? Would your web designers prefer a
+tag-based syntax designed for presentation? Some experience working with
+both Smarty and PHP helps answer these questions.
+
+### The Business Case
+Is there a requirement to insulate the templates from
+PHP? Do you have untrusted parties editing templates that you do not
+wish to unleash the power of PHP to? Do you need to programmatically
+control what is and is not available within the templates? Smarty
+supplies these capabilities by design.
+
+## Feature set
+Does Smarty's features such as caching, template
+inheritance and plugin architecture save development cycles writing code
+that would be needed otherwise? Does the codebase or framework you plan
+on using have the features you need for the presentation component?
+
+## Sites using Smarty
+Many well-known PHP projects make use of Smarty such as XOOPS CMS, CMS Made Simple, Tiki
+CMS/Groupware and X-Cart to name a few.
+
+## Summary
+Whether you are using Smarty for a small website or massive enterprise
+solution, it can accommodate your needs. There are numerous features
+that make Smarty a great choice:
+
+-   separation of PHP from HTML/CSS just makes sense
+-   readability for organization and management
+-   security for 3rd party template access
+-   feature completeness, and easily extendable to your own needs
+-   massive user base, Smarty is here to stay
+-   LGPL license for commercial use
+-   100% free to use, open source project
@@ -1,267 +1,56 @@
 What is Smarty?
-===============
-
-Smarty is a template engine for PHP. More specifically, it facilitates a
-manageable way to separate application logic and content from its
-presentation. This is best described in a situation where the
-application programmer and the template designer play different roles,
-or in most cases are not the same person.
-
-For example, let\'s say you are creating a web page that is displaying a
-newspaper article.
-
-   The article `$headline`, `$tagline`, `$author` and `$body` are
-    content elements, they contain no information about how they will be
-    presented. They are [passed](#api.assign) into Smarty by the
-    application.
-
-   Then the template designer edits the templates and uses a
-    combination of HTML tags and [template tags](#language.basic.syntax)
-    to format the presentation of these
-    [variables](#language.syntax.variables) with elements such as
-    tables, div\'s, background colors, font sizes, style sheets, svg
-    etc.
-
-   One day the programmer needs to change the way the article content
-    is retrieved, ie a change in application logic. This change does not
-    affect the template designer, the content will still arrive in the
-    template exactly the same.
-
-   Likewise, if the template designer wants to completely redesign the
-    templates, this would require no change to the application logic.
-
-   Therefore, the programmer can make changes to the application logic
-    without the need to restructure templates, and the template designer
-    can make changes to templates without breaking application logic.
-
-One design goal of Smarty is the separation of business logic and
-presentation logic.
-
-   This means templates can certainly contain logic under the condition
-    that it is for presentation only. Things such as
-    [including](#language.function.include) other templates,
-    [alternating](#language.function.cycle) table row colors,
-    [upper-casing](#language.modifier.upper) a variable,
-    [looping](#language.function.foreach) over an array of data and
-    [displaying](#api.display) it are examples of presentation logic.
-
-   This does not mean however that Smarty forces a separation of
-    business and presentation logic. Smarty has no knowledge of which is
-    which, so placing business logic in the template is your own doing.
-
-   Also, if you desire *no* logic in your templates you certainly can
-    do so by boiling the content down to text and variables only.
-
-**Some of Smarty\'s features:**
-
-   It is extremely fast.
-
-   It is efficient since the PHP parser does the dirty work.
-
-   No template parsing overhead, only compiles once.
-
-   It is smart about [recompiling](#variable.compile.check) only the
-    template files that have changed.
-
-   You can easily create your own custom
-    [functions](#language.custom.functions) and [variable
-    modifiers](#language.modifiers), so the template language is
-    extremely extensible.
-
-   Configurable template [{delimiter}](#variable.left.delimiter) tag
-    syntax, so you can use `{$foo}`, `{{$foo}}`, `<!--{$foo}-->`, etc.
-
-   The [`{if}..{elseif}..{else}..{/if}`](#language.function.if)
-    constructs are passed to the PHP parser, so the `{if...}` expression
-    syntax can be as simple or as complex an evaluation as you like.
-
-   Allows unlimited nesting of
-    [`sections`](#language.function.section), `if's` etc.
-
-   Built-in [caching](#caching) support
-
-   Arbitrary [template](#resources) sources
-
-   [Template Inheritance](#advanced.features.template.inheritance) for
-    easy management of template content.
-
-   [Plugin](#plugins) architecture
-
-Installation
-============
-
-Requirements {#installation.requirements}
-============
-
-Smarty requires a web server running PHP 5.2 or greater.
-
-Basic Installation {#installing.smarty.basic}
-==================
-
-Install the Smarty library files which are in the `/libs/` sub directory
-of the distribution. These are `.php` files that you SHOULD NOT edit.
-They are shared among all applications and only get changed when you
-upgrade to a new version of Smarty.
-
-In the examples below the Smarty tarball has been unpacked to:
-
-   `/usr/local/lib/Smarty-v.e.r/` for \*nix machines
-
-   and `c:\webroot\libs\Smarty-v.e.r\` for the windows environment.
-
-<!-- -->
-
-
-    Smarty-v.e.r/
-       libs/
-          Smarty.class.php
-          debug.tpl
-          sysplugins/* (everything)
-          plugins/*    (everything)
-
-        
-
-Smarty uses a PHP [constant](&url.php-manual;define) named
-[`SMARTY_DIR`](#constant.smarty.dir) which is the **full system file
-path** to the Smarty `libs/` directory. Basically, if your application
-can find the `Smarty.class.php` file, you do not need to set the
-[`SMARTY_DIR`](#constant.smarty.dir) as Smarty will figure it out on its
-own. Therefore, if `Smarty.class.php` is not in your
-[include\_path](&url.php-manual;ini.core.php#ini.include-path), or you
-do not supply an absolute path to it in your application, then you must
-define `SMARTY_DIR` manually. `SMARTY_DIR` **must include a trailing
-slash/**.
-
-::: {.informalexample}
-Here\'s how you create an instance of Smarty in your PHP scripts:
-
-
-    <?php
-    // NOTE: Smarty has a capital 'S'
-    require_once('Smarty.class.php');
-    $smarty = new Smarty();
-    ?>
-
-        
-:::
-
-Try running the above script. If you get an error saying the
-`Smarty.class.php` file could not be found, you need to do one of the
-following:
-
-
-    <?php
-    // *nix style (note capital 'S')
-    define('SMARTY_DIR', '/usr/local/lib/Smarty-v.e.r/libs/');
-
-    // windows style
-    define('SMARTY_DIR', 'c:/webroot/libs/Smarty-v.e.r/libs/');
-
-    // hack version example that works on both *nix and windows
-    // Smarty is assumend to be in 'includes/' dir under current script
-    define('SMARTY_DIR',str_replace("\\","/",getcwd()).'/includes/Smarty-v.e.r/libs/');
-
-    require_once(SMARTY_DIR . 'Smarty.class.php');
-    $smarty = new Smarty();
-    ?>
-
-        
-
-
-    <?php
-    // *nix style (note capital 'S')
-    require_once('/usr/local/lib/Smarty-v.e.r/libs/Smarty.class.php');
-
-    // windows style
-    require_once('c:/webroot/libs/Smarty-v.e.r/libs/Smarty.class.php');
-
-    $smarty = new Smarty();
-    ?>
-
-        
-
-
-    ;;;;;;;;;;;;;;;;;;;;;;;;;
-    ; Paths and Directories ;
-    ;;;;;;;;;;;;;;;;;;;;;;;;;
-
-    ; *nix: "/path1:/path2"
-    include_path = ".:/usr/share/php:/usr/local/lib/Smarty-v.e.r/libs/"
-
-    ; Windows: "\path1;\path2"
-    include_path = ".;c:\php\includes;c:\webroot\libs\Smarty-v.e.r\libs\"
-
-
-    <?php
-    // *nix
-    ini_set('include_path', ini_get('include_path').PATH_SEPARATOR.'/usr/local/lib/Smarty-v.e.r/libs/');
-
-    // windows
-    ini_set('include_path', ini_get('include_path').PATH_SEPARATOR.'c:/webroot/lib/Smarty-v.e.r/libs/');
-    ?>
-
-        
-
-Now that the library files are in place, it\'s time to setup the Smarty
-directories for your application:
-
-   Smarty requires four directories which are by default named
-    `templates/`, `templates_c/`, `configs/` and `cache/`
-
-   Each of these are definable by the Smarty class properties
-    [`$template_dir`](#variable.template.dir),
-    [`$compile_dir`](#variable.compile.dir),
-    [`$config_dir`](#variable.config.dir), and
-    [`$cache_dir`](#variable.cache.dir) respectively
-
-   It is highly recommended that you setup a separate set of these
-    directories for each application that will use Smarty
-
-   You can verify if your system has the correct access rights for
-    these directories with [`testInstall()`](#api.test.install).
-
-For our installation example, we will be setting up the Smarty
-environment for a guest book application. We picked an application only
-for the purpose of a directory naming convention. You can use the same
-environment for any application, just replace `guestbook/` with the name
-of your application.
-
-
-    /usr/local/lib/Smarty-v.e.r/libs/
-            Smarty.class.php
-            debug.tpl
-            sysplugins/*
-            plugins/*
-
-    /web/www.example.com/
-            guestbook/
-            templates/
-                index.tpl
-            templates_c/
-            configs/
-            cache/
-            htdocs/
-                index.php
-
-        
-
-Be sure that you know the location of your web server\'s document root
-as a file path. In the following examples, the document root is
-`/web/www.example.com/guestbook/htdocs/`. The Smarty directories are
-only accessed by the Smarty library and never accessed directly by the
-web browser. Therefore to avoid any security concerns, it is recommended
-(but not mandatory) to place these directories *outside* of the web
-server\'s document root.
-
-You will need as least one file under your document root, and that is
-the script accessed by the web browser. We will name our script
-`index.php`, and place it in a subdirectory under the document root
-`/htdocs/`.
-
-Smarty will need **write access** (windows users please ignore) to the
-[`$compile_dir`](#variable.compile.dir) and
-[`$cache_dir`](#variable.cache.dir) directories (`templates_c/` and
-`cache/`), so be sure the web server user account can write to them.
+==============
+
+## Requirements
+Smarty can be run with PHP 7.1 to PHP 8.2.
+
+## Installation
+Smarty versions 3.1.11 or later can be installed with [Composer](https://getcomposer.org/).
+
+To get the latest stable version of Smarty use:
+```bash
+composer require smarty/smarty
+````
+
+To get the latest, unreleased version, use:
+```bash
+composer require smarty/smarty:dev-master
+````
+
+To get the previous stable version of Smarty, Smarty 3, use:
+```bash
+composer require smarty/smarty:^3
+````
+
+Here's how you create an instance of Smarty in your PHP scripts:
+```php
+<?php
+
+require 'vendor/autoload.php';
+$smarty = new Smarty();
+```
+
+Now that the library files are in place, it's time to setup the Smarty
+directories for your application.
+
+Smarty requires four directories which are by default named
+    [`templates`](./programmers/api-variables/variable-template-dir.md),
+    [`configs`](./programmers/api-variables/variable-config-dir.md),
+    [`templates_c`](./programmers/api-variables/variable-compile-dir.md)
+     and 
+    [`cache`](./programmers/api-variables/variable-cache-dir.md) 
+    relative to the current working directory.
+
+The defaults can be changed as follows:
+```php
+$smarty = new Smarty();
+$smarty->setTemplateDir('/some/template/dir');
+$smarty->setConfigDir('/some/config/dir');
+$smarty->setCompileDir('/some/compile/dir');
+$smarty->setCacheDir('/some/cache/dir');
+```
+
+The compile dir and cache dir need to be writable for the user running the PHP script.

 > **Note**
 >
@@ -270,66 +59,62 @@ Smarty will need **write access** (windows users please ignore) to the
 > can look in your `httpd.conf` file to see what user and group are
 > being used.

+```bash
+chown nobody:nobody /web/www.example.com/guestbook/templates_c/
+chmod 770 /web/www.example.com/guestbook/templates_c/

-    chown nobody:nobody /web/www.example.com/guestbook/templates_c/
-    chmod 770 /web/www.example.com/guestbook/templates_c/
+chown nobody:nobody /web/www.example.com/guestbook/cache/
+chmod 770 /web/www.example.com/guestbook/cache/
+```

-    chown nobody:nobody /web/www.example.com/guestbook/cache/
-    chmod 770 /web/www.example.com/guestbook/cache/
+You can verify if your system has the correct access rights for
+    these directories with [`testInstall()`](./programmers/api-functions/api-test-install.md):

-        
+```php
+$smarty = new Smarty();
+$smarty->setTemplateDir('/some/template/dir');
+$smarty->setConfigDir('/some/config/dir');
+$smarty->setCompileDir('/some/compile/dir');
+$smarty->setCacheDir('/some/cache/dir');
+$smarty->testInstall();
+```
+
+Now, let's create the `index.tpl` file that Smarty will display. This
+needs to be located in the [`$template_dir`](./programmers/api-variables/variable-template-dir.md).
+
+```html
+{* Smarty *}
+Hello {$name}, welcome to Smarty!
+```

 > **Note**
 >
-> `chmod 770` will be fairly tight security, it only allows user
-> "nobody" and group "nobody" read/write access to the directories. If
-> you would like to open up read access to anyone (mostly for your own
-> convenience of viewing these files), you can use `775` instead.
-
-We need to create the `index.tpl` file that Smarty will display. This
-needs to be located in the [`$template_dir`](#variable.template.dir).
-
-
-    {* Smarty *}
-
-    Hello {$name}, welcome to Smarty!
-
-        
-
-> **Note**
->
-> `{* Smarty *}` is a template [comment](#language.syntax.comments). It
+> `{* Smarty *}` is a template [comment](./designers/language-basic-syntax/language-syntax-comments.md). It
 > is not required, but it is good practice to start all your template
 > files with this comment. It makes the file easy to recognize
 > regardless of the file extension. For example, text editors could
 > recognize the file and turn on special syntax highlighting.

-Now lets edit `index.php`. We\'ll create an instance of Smarty,
-[`assign()`](#api.assign) a template variable and
-[`display()`](#api.display) the `index.tpl` file.
+Now lets edit our php file. We'll create an instance of Smarty,
+[`assign()`](./programmers/api-functions/api-assign.md) a template variable and
+[`display()`](./programmers/api-functions/api-display.md) the `index.tpl` file.

+```php
+<?php

-    <?php
+require 'vendor/autoload.php';

-    require_once(SMARTY_DIR . 'Smarty.class.php');
+$smarty = new Smarty();

-    $smarty = new Smarty();
+$smarty->setTemplateDir('/web/www.example.com/guestbook/templates/');
+$smarty->setCompileDir('/web/www.example.com/guestbook/templates_c/');
+$smarty->setConfigDir('/web/www.example.com/guestbook/configs/');
+$smarty->setCacheDir('/web/www.example.com/guestbook/cache/');

-    $smarty->setTemplateDir('/web/www.example.com/guestbook/templates/');
-    $smarty->setCompileDir('/web/www.example.com/guestbook/templates_c/');
-    $smarty->setConfigDir('/web/www.example.com/guestbook/configs/');
-    $smarty->setCacheDir('/web/www.example.com/guestbook/cache/');
+$smarty->assign('name', 'Ned');
+$smarty->display('index.tpl');

-    $smarty->assign('name','Ned');
-
-    //** un-comment the following line to show the debug console
-    //$smarty->debugging = true;
-
-    $smarty->display('index.tpl');
-
-    ?>
-
-        
+```

 > **Note**
 >
@@ -340,78 +125,45 @@ Now lets edit `index.php`. We\'ll create an instance of Smarty,
 > absolute paths. This ensures that Smarty is getting files from the
 > directories you intended.

-Now navigate to the `index.php` file with the web browser. You should
-see *\"Hello Ned, welcome to Smarty!\"*
+Now, run your PHP file. You should see *\"Hello Ned, welcome to Smarty!\"*

 You have completed the basic setup for Smarty!

-Extended Setup {#installing.smarty.extended}
+## Extended Setup {#installing.smarty.extended}
 ==============

 This is a continuation of the [basic
 installation](#installing.smarty.basic), please read that first!

-A slightly more flexible way to setup Smarty is to [extend the
-class](&url.php-manual;ref.classobj) and initialize your Smarty
+A slightly more flexible way to setup Smarty is to extend the Smarty
+class and initialize your Smarty
 environment. So instead of repeatedly setting directory paths, assigning
 the same vars, etc., we can do that in one place.

-Lets create a new directory `/php/includes/guestbook/` and make a new
-file called `setup.php`. In our example environment, `/php/includes` is
-in our `include_path`. Be sure you set this up too, or use absolute file
-paths.
+```php
+<?php

+class Smarty_GuestBook extends Smarty {

-    <?php
+   public function __construct()
+   {
+        parent::__construct();

-    // load Smarty library
-    require('Smarty.class.php');
+        $this->setTemplateDir('/web/www.example.com/guestbook/templates/');
+        $this->setCompileDir('/web/www.example.com/guestbook/templates_c/');
+        $this->setConfigDir('/web/www.example.com/guestbook/configs/');
+        $this->setCacheDir('/web/www.example.com/guestbook/cache/');

-    // The setup.php file is a good place to load
-    // required application library files, and you
-    // can do that right here. An example:
-    // require('guestbook/guestbook.lib.php');
+        $this->caching = Smarty::CACHING_LIFETIME_CURRENT;
+        $this->assign('app_name', 'Guest Book');
+   }

-    class Smarty_GuestBook extends Smarty {
+}
+```

-       function __construct()
-       {
-
-            // Class Constructor.
-            // These automatically get set with each new instance.
-
-            parent::__construct();
-
-            $this->setTemplateDir('/web/www.example.com/guestbook/templates/');
-            $this->setCompileDir('/web/www.example.com/guestbook/templates_c/');
-            $this->setConfigDir('/web/www.example.com/guestbook/configs/');
-            $this->setCacheDir('/web/www.example.com/guestbook/cache/');
-
-            $this->caching = Smarty::CACHING_LIFETIME_CURRENT;
-            $this->assign('app_name', 'Guest Book');
-       }
-
-    }
-    ?>
-
-        
-
-Now lets alter the `index.php` file to use `setup.php`:
-
-
-    <?php
-
-    require('guestbook/setup.php');
-
-    $smarty = new Smarty_GuestBook();
-
-    $smarty->assign('name','Ned');
-
-    $smarty->display('index.tpl');
-    ?>
-
-       
-
-Now you see it is quite simple to bring up an instance of Smarty, just
-use `Smarty_GuestBook()` which automatically initializes everything for
-our application.
+Now, we can use `Smarty_GuestBook` instead of `Smarty` in our scripts:
+```php
+$smarty = new Smarty_GuestBook();
+$smarty->assign('name','Ned');
+$smarty->display('index.tpl');
+```
@@ -1,12 +1,31 @@
 # Smarty 4 Documentation
-
 Smarty is a template engine for PHP, facilitating the separation of presentation (HTML/CSS) from application logic. 

+It allows you to write **templates**, using **variables**, **modifiers**, **functions** and **comments**, like this:
+```html
+<h1>{$title|escape}</h1>
+
+<p>
+    The number of pixels is: {math equation="x * y" x=$height y=$width}.
+</p>
+```
+
+When this template is rendered, with the value "Hello world" for the variable $title, 640 for $width, 
+and 480 for $height, the result is:
+```html
+<h1>Hello world</h1>
+
+<p>
+    The number of pixels is: 307200.
+</p>
+```
+
 ## Introduction
- [Preface](./preface.md)
+- [Philosophy](./philosophy.md) - or "Why do I need a template engine?"
+- [Features](./features.md) - or "Why do I want Smarty?"
 - [Getting Started](./getting-started.md)

-## Smarty for template developers
+## Smarty for template designers
 - [Basic Syntax](./designers/language-basic-syntax.md)
 - [Variables](./designers/language-variables.md)
 - [Variable Modifiers](./designers/language-modifiers.md)
@@ -24,4 +43,8 @@ Smarty is a template engine for PHP, facilitating the separation of presentation
 - [Caching](./programmers/caching.md)
 - [Resources](./programmers/resources.md)
 - [Advanced Features](./programmers/advanced-features.md)
- [Extending Smarty With Plugins](./programmers/plugins.md)
+- [Extending Smarty With Plugins](./programmers/plugins.md)
+
+## Other
+- [Some random tips & tricks](./appendixes/tips.md)
+- [Troubleshooting](./appendixes/troubleshooting.md)
@@ -0,0 +1,108 @@
+Philosophy
+=======
+
+## What is Smarty?
+
+Smarty is a template engine for PHP. More specifically, it facilitates a
+manageable way to separate application logic and content from its
+presentation. This is best described in a situation where the
+application programmer and the template designer play different roles,
+or in most cases are not the same person.
+
+For example, let\'s say you are creating a web page that is displaying a
+newspaper article.
+
+-   The article `$headline`, `$tagline`, `$author` and `$body` are
+    content elements, they contain no information about how they will be
+    presented. They are [passed](#api.assign) into Smarty by the
+    application.
+
+-   Then the template designer edits the templates and uses a
+    combination of HTML tags and [template tags](#language.basic.syntax)
+    to format the presentation of these
+    [variables](#language.syntax.variables) with elements such as
+    tables, div\'s, background colors, font sizes, style sheets, svg
+    etc.
+
+-   One day the programmer needs to change the way the article content
+    is retrieved, ie a change in application logic. This change does not
+    affect the template designer, the content will still arrive in the
+    template exactly the same.
+
+-   Likewise, if the template designer wants to completely redesign the
+    templates, this would require no change to the application logic.
+
+-   Therefore, the programmer can make changes to the application logic
+    without the need to restructure templates, and the template designer
+    can make changes to templates without breaking application logic.
+
+## Goals
+
+The Smarty design was largely driven by these goals:
+-   clean separation of presentation from application code
+-   PHP backend, Smarty template frontend
+-   complement PHP, not replace it
+-   fast development/deployment for programmers and designers
+-   quick and easy to maintain
+-   syntax easy to understand, no PHP knowledge necessary
+-   flexibility for custom development
+-   security: insulation from PHP
+-   free, open source
+
+
+
+## Two camps of thought
+
+When it comes to templating in PHP, there are basically two camps of
+thought. The first camp exclaims that \"PHP is a template engine\". This
+approach simply mixes PHP code with HTML. Although this approach is
+fastest from a pure script-execution point of view, many would argue
+that the PHP syntax is messy and complicated when mixed with tagged
+markup such as HTML.
+
+The second camp exclaims that presentation should be void of all
+programming code, and instead use simple tags to indicate where
+application content is revealed. This approach is common with other
+template engines (even in other programming languages), and is also the
+approach that Smarty takes. The idea is to keep the templates focused
+squarely on presentation, void of application code, and with as little
+overhead as possible.
+
+## Why is separating PHP from templates important?
+
+Two major benefits:
+
+-   SYNTAX: Templates typically consist of semantic markup such as HTML.
+    PHP syntax works well for application code, but quickly degenerates
+    when mixed with HTML. Smarty\'s simple {tag} syntax is designed
+    specifically to express presentation. Smarty focuses your templates
+    on presentation and less on \"code\". This lends to quicker template
+    deployment and easier maintenance. Smarty syntax requires no working
+    knowledge of PHP, and is intuitive for programmers and
+    non-programmers alike.
+
+-   INSULATION: When PHP is mixed with templates, there are no
+    restrictions on what type of logic can be injected into a template.
+    Smarty insulates the templates from PHP, creating a controlled
+    separation of presentation from business logic. Smarty also has
+    security features that can further enforce restrictions on
+    templates.
+
+## Web designers and PHP
+
+A common question: "Web designers have to learn a syntax anyway, why
+not PHP?" Of course web designers can learn PHP, and they may already
+be familiar with it. The issue isn't their ability to learn PHP, it is
+about the consequences of mixing PHP with HTML. If designers use PHP, it
+is too easy to add code into templates that doesn't belong there (you
+just handed them a swiss-army knife when they just needed a knife.) You
+can teach them the rules of application design, but this is probably
+something they don't really need to learn (now they are developers!)
+The PHP manual is also an overwhelming pile of information to sift
+through. It is like handing the owner of a car the factory assembly
+manual when all they need is the owners manual. Smarty gives web
+designers exactly the tools they need, and gives developers fine-grained
+control over those tools. The simplicity of the tag-based syntax is also
+a huge welcome for designers, it helps them streamline the organization
+and management of templates.
+
@@ -1,212 +0,0 @@
-Preface
-=======
-
-**The Philosophy**
-
-The Smarty design was largely driven by these goals:
-
-   clean separation of presentation from application code
-   PHP backend, Smarty template frontend
-   complement PHP, not replace it
-   fast development/deployment for programmers and designers
-   quick and easy to maintain
-   syntax easy to understand, no PHP knowledge necessary
-   flexibility for custom development
-   security: insulation from PHP
-   free, open source
-
-**What is Smarty?**
-
-Smarty is a template engine for PHP, facilitating the separation of
-presentation (HTML/CSS) from application logic. This implies that *PHP
-code is application logic*, and is separated from the presentation.
-
-**Two camps of thought**
-
-When it comes to templating in PHP, there are basically two camps of
-thought. The first camp exclaims that \"PHP is a template engine\". This
-approach simply mixes PHP code with HTML. Although this approach is
-fastest from a pure script-execution point of view, many would argue
-that the PHP syntax is messy and complicated when mixed with tagged
-markup such as HTML.
-
-The second camp exclaims that presentation should be void of all
-programming code, and instead use simple tags to indicate where
-application content is revealed. This approach is common with other
-template engines (even in other programming languages), and is also the
-approach that Smarty takes. The idea is to keep the templates focused
-squarely on presentation, void of application code, and with as little
-overhead as possible.
-
-**Why is separating PHP from templates important?**
-
-Two major benefits:
-
-   SYNTAX: Templates typically consist of semantic markup such as HTML.
-    PHP syntax works well for application code, but quickly degenerates
-    when mixed with HTML. Smarty\'s simple {tag} syntax is designed
-    specifically to express presentation. Smarty focuses your templates
-    on presentation and less on \"code\". This lends to quicker template
-    deployment and easier maintenance. Smarty syntax requires no working
-    knowledge of PHP, and is intuitive for programmers and
-    non-programmers alike.
-
-   INSULATION: When PHP is mixed with templates, there are no
-    restrictions on what type of logic can be injected into a template.
-    Smarty insulates the templates from PHP, creating a controlled
-    separation of presentation from business logic. Smarty also has
-    security features that can further enforce restrictions on
-    templates.
-
-**Web designers and PHP**
-
-A common question: \"Web designers have to learn a syntax anyways, why
-not PHP?\" Of course web designers can learn PHP, and they may already
-be familiar with it. The issue isn\'t their ability to learn PHP, it is
-about the consequences of mixing PHP with HTML. If designers use PHP, it
-is too easy to add code into templates that doesn\'t belong there (you
-just handed them a swiss-army knife when they just needed a knife.) You
-can teach them the rules of application design, but this is probably
-something they don\'t really need to learn (now they are developers!)
-The PHP manual is also an overwhelming pile of information to sift
-through. It is like handing the owner of a car the factory assembly
-manual when all they need is the owners manual. Smarty gives web
-designers exactly the tools they need, and gives developers fine-grained
-control over those tools. The simplicity of the tag-based syntax is also
-a huge welcome for designers, it helps them streamline the organization
-and management of templates.
-
-**Implementation is Important**
-
-Although Smarty gives you the tools to make a clean separation of
-presentation from application code, it also gives you plenty of room to
-bend those rules. A poor implementation (i.e. injecting PHP in
-templates) will cause more problems than the presentation separation was
-meant to resolve. The documentation does a good job of indicating what
-things to watch out for. Also see the Best Practices section of the
-Smarty website.
-
-**How does it work?**
-
-Under the hood, Smarty \"compiles\" (basically copies and converts) the
-templates into PHP scripts. This happens once when each template is
-first invoked, and then the compiled versions are used from that point
-forward. Smarty takes care of this for you, so the template designer
-just edits the Smarty templates and never has to manage the compiled
-versions. This approach keeps the templates easy to maintain, and yet
-keeps execution times extremely fast since the compiled code is just
-PHP. And of course, all PHP scripts take advantage of PHP op-code caches
-such as APC.
-
-**Template Inheritance**
-
-Template inheritance is new to Smarty 3, and it\'s one of many great new
-features. Before template inheritance, we managed our templates in
-pieces such as header and footer templates. This organization lends
-itself to many problems that require some hoop-jumping, such as managing
-content within the header/footer on a per-page basis. With template
-inheritance, instead of including other templates we maintain our
-templates as single pages. We can then manipulate blocks of content
-within by inheriting them. This makes templates intuitive, efficient and
-easy to manage. See the Template Inheritance section of th Smarty
-website for more info.
-
-**Why not use XML/XSLT syntax?**
-
-There are a couple of good reasons. First, Smarty can be used for more
-than just XML/HTML based templates, such as generating emails,
-javascript, CSV, and PDF documents. Second, XML/XSLT syntax is even more
-verbose and fragile than PHP code! It is perfect for computers, but
-horrible for humans. Smarty is about being easy to read, understand and
-maintain.
-
-**Template Security**
-
-Although Smarty insulates you from PHP, you still have the option to use
-it in certain ways if you wish. Template security forces the restriction
-of PHP (and select Smarty functions.) This is useful if you have third
-parties editing templates, and you don\'t want to unleash the full power
-of PHP or Smarty to them.
-
-**Integration**
-
-Sometimes Smarty gets compared to Model-View-Controller (MVC)
-frameworks. Smarty is not an MVC, it is just the presentation layer,
-much like the View (V) part of an MVC. As a matter of fact, Smarty can
-easily be integrated as the view layer of an MVC. Many of the more
-popular ones have integration instructions for Smarty, or you may find
-some help here in the forums and documentation.
-
-**Other Template Engines**
-
-Smarty is not the only engine following the *\"Separate Programming Code
-from Presentation\"* philosophy. For instance, Python has template
-engines built around the same principles such as Django Templates and
-CheetahTemplate. *Note: Languages such as Python do not mix with HTML
-natively, which give them the advantage of proper programming code
-separation from the outset. There are libraries available to mix Python
-with HTML, but they are typically avoided.*
-
-**What Smarty is Not**
-
-Smarty is not an application development framework. Smarty is not an
-MVC. Smarty is not an alternative to Zend Framework, CodeIgniter,
-PHPCake, or any of the other application development frameworks for PHP.
-
-Smarty is a template engine, and works as the (V)iew component of your
-application. Smarty can easily be coupled to any of the engines listed
-above as the view component. No different than any other software,
-Smarty has a learning curve. Smarty does not guarantee good application
-design or proper separation of presentation, this still needs to be
-addressed by a competent developer and web designer.
-
-**Is Smarty Right for Me?**
-
-Smarty is not meant to be a tool for every job. The important thing is
-to identify if Smarty fits your needs. There are some important
-questions to ask yourself:
-
-TEMPLATE SYNTAX. Are you content with PHP tags mixed with HTML? Are your
-web designers comfortable with PHP? Would your web designers prefer a
-tag-based syntax designed for presentation? Some experience working with
-both Smarty and PHP helps answer these questions.
-
-THE BUSINESS CASE: Is there a requirement to insulate the templates from
-PHP? Do you have untrusted parties editing templates that you do not
-wish to unleash the power of PHP to? Do you need to programmatically
-control what is and is not available within the templates? Smarty
-supplies these capabilities by design.
-
-FEATURE SET: Does Smarty\'s features such as caching, template
-inheritance and plugin architecture save development cycles writing code
-that would be needed otherwise? Does the codebase or framework you plan
-on using have the features you need for the presentation component?
-
-Templating in PHP is a hot topic, and opinions widely vary. It is
-important that you understand Smarty, understand your own requirements,
-and make an informed decision for yourself. You are welcome to ask
-specific questions in the forums or the IRC channel.
-
-See also the section about \"Use Cases and Work Flow\" on the Smarty
-website.
-
-**Sites using Smarty**
-
-There are tens of thousands of unique visitors on the Smarty website
-daily, mostly developers reading documentation. Many well-known PHP
-projects make use of Smarty such as XOOPS CMS, CMS Made Simple, Tiki
-CMS/Groupware and X-Cart to name a few.
-
-**Summary**
-
-Whether you are using Smarty for a small website or massive enterprise
-solution, it can accommodate your needs. There are numerous features
-that make Smarty a great choice:
-
-   separation of PHP from HTML/CSS just makes sense
-   readability for organization and management
-   security for 3rd party template access
-   feature completeness, and easily extendable to your own needs
-   massive user base, Smarty is here to stay
-   LGPL license for commercial use
-   100% free to use, open source project
@@ -29,7 +29,7 @@ determined by your needs, but use the first method whenever possible to
 keep template syntax to a minimum.

 If security is enabled, no private methods or functions can be accessed
-(beginningwith \'\_\'). If a method and property of the same name exist,
+(beginning with \'\_\'). If a method and property of the same name exist,
 the method will be used.

 You can restrict the methods and properties that can be accessed by
@@ -2,36 +2,20 @@ Security {#advanced.features.security}
 ========

 Security is good for situations when you have untrusted parties editing
-the templates eg via ftp, and you want to reduce the risk of system
+the templates e.g. via ftp, and you want to reduce the risk of system
 security compromises through the template language.

 The settings of the security policy are defined by properties of an
 instance of the Smarty\_Security class. These are the possible settings:

-   `$php_handling` determines how Smarty to handle PHP code embedded in
-    templates. Possible values are:
-
-    -   Smarty::PHP\_PASSTHRU -\> echo PHP tags as they are
-
-    -   Smarty::PHP\_QUOTE -\> escape tags as entities
-
-    -   Smarty::PHP\_REMOVE -\> remove php tags
-
-    -   Smarty::PHP\_ALLOW -\> execute php tags
-
-    The default value is Smarty::PHP\_PASSTHRU.
-
-    If security is enabled the [`$php_handling`](#variable.php.handling)
-    setting of the Smarty object is not checked for security.
-
 -   `$secure_dir` is an array of template directories that are
    considered secure. [`$template_dir`](#variable.template.dir)
-    concidered secure implicitly. The default is an empty array.
+    considered secure implicitly. The default is an empty array.

 -   `$trusted_dir` is an array of all directories that are considered
    trusted. Trusted directories are where you keep php scripts that are
    executed directly from the templates with
-    [`{include_php}`](#language.function.include.php). The default is an
+    [`{insert}`](#language.function.insert.php). The default is an
    empty array.

 -   `$trusted_uri` is an array of regular expressions matching URIs that
@@ -43,7 +27,7 @@ instance of the Smarty\_Security class. These are the possible settings:
    like authentication-tokens).

    The expression `'#https?://.*smarty.net$#i'` would allow accessing
-    the follwing URIs:
+    the following URIs:

    -   `http://smarty.net/foo`

@@ -110,12 +94,8 @@ instance of the Smarty\_Security class. These are the possible settings:
    super globals can be accessed by the template. The default is
    \"true\".

-   `$allow_php_tag` is a boolean flag which controls if {php} and
-    {include\_php} tags can be used by the template. The default is
-    \"false\".
-
 If security is enabled, no private methods, functions or properties of
-static classes or assigned objects can be accessed (beginningwith
+static classes or assigned objects can be accessed (beginning with
 \'\_\') by the template.

 To customize the security policy settings you can extend the
@@ -128,8 +108,6 @@ Smarty\_Security class or create an instance of it.
    class My_Security_Policy extends Smarty_Security {
      // disable all PHP functions
      public $php_functions = null;
-      // remove PHP tags
-      public $php_handling = Smarty::PHP_REMOVE;
      // allow everthing as modifier
      public $php_modifiers = array();
    }
@@ -145,8 +123,6 @@ Smarty\_Security class or create an instance of it.
    $my_security_policy = new Smarty_Security($smarty);
    // disable all PHP functions
    $my_security_policy->php_functions = null;
-    // remove PHP tags
-    $my_security_policy->php_handling = Smarty::PHP_REMOVE;
    // allow everthing as modifier
    $my_security_policy->php_modifiers = array();
    // enable security
@@ -164,5 +140,5 @@ Smarty\_Security class or create an instance of it.
 > **Note**
 >
 > Most security policy settings are only checked when the template gets
-> compiled. For that reasion you should delete all cached and compiled
+> compiled. For that reason you should delete all cached and compiled
 > template files when you change your security settings.
@@ -33,7 +33,7 @@ can override all or some of the parent named block areas.
    you can define the whole template inheritance tree in the PHP script
    when you are calling [`fetch()`](#api.fetch) or
    [`display()`](#api.display) with the `extends:` template resource
-    type. The later provides even more flexibillity.
+    type. The later provides even more flexibility.

 > **Note**
 >
@@ -8,7 +8,7 @@ Modifications done to the Smarty object will be global for all
 templates.

 However the Smarty class variables and functions can be accessed or
-called by induvidual template objects. Modification done to a template
+called by individual template objects. Modification done to a template
 object will apply only for that template and its included subtemplates.


@@ -26,7 +26,7 @@ the following parameters:
    variables assigned to any of the objects in it\'s parent chain.

 Data objects are used to create scopes for assigned variables. They can
-be used to have controll which variables are seen by which templates.
+be used to control which variables are seen by which templates.


    <?php
@@ -9,7 +9,7 @@ string

 disableSecurity

-This disables securty checking on templates.
+This disables security checking on templates.

 See also [`enableSecurity()`](#api.enable.security), and
 [Security](#advanced.features.security).
@@ -25,7 +25,7 @@ string

 enableSecurity

-This enables securty checking on templates. It uses the following
+This enables security checking on templates. It uses the following
 parameters:

 -   `securityclass` is an optional parameter. It\'s the name of the
@@ -16,6 +16,6 @@ given error was produced deliberately and must be ignored, or should be
 passed on to the next error handler.

 `Smarty::unmuteExpectedErrors()` removes the current error handler.
-Please note, that if you\'ve registerd any custom error handlers after
+Please note, that if you\'ve registered any custom error handlers after
 the muteExpectedErrors() call, the unmute will not remove Smarty\'s
 muting error handler, but the one registered last.
@@ -18,7 +18,7 @@ not find a definition for a tag otherwise. It uses the following
 parameters:

 If during compilation Smarty encounters tag which is not defined
-internal, registered or loacted in the plugins folder it tries to
+internal, registered or located in the plugins folder it tries to
 resolve it by calling the registered default plugin handler. The handler
 may be called several times for same undefined tag looping over valid
 plugin types.
@@ -10,7 +10,7 @@ void
 testInstall

 This function verifies that all required working folders of the Smarty
-installation can be accessed. It does output a corresponding protocoll.
+installation can be accessed. It does output a corresponding protocol.


    <?php
@@ -39,7 +39,6 @@ them directly, or use the corresponding setter/getter methods.
 - [$left_delimiter](./api-variables/variable-left-delimiter.md)
 - [$locking_timeout](./api-variables/variable-locking-timeout.md)
 - [$merge_compiled_includes](./api-variables/variable-merge-compiled-includes.md)
- [$php_handling](./api-variables/variable-php-handling.md)
 - [$plugins_dir](./api-variables/variable-plugins-dir.md)
 - [$right_delimiter](./api-variables/variable-right-delimiter.md)
 - [$smarty_debug_id](./api-variables/variable-smarty-debug-id.md)
@@ -1,7 +1,7 @@
 \$compile\_id {#variable.compile.id}
 =============

-Persistant compile identifier. As an alternative to passing the same
+Persistent compile identifier. As an alternative to passing the same
 `$compile_id` to each and every function call, you can set this
 `$compile_id` and it will be used implicitly thereafter.

@@ -10,7 +10,7 @@ post-filters](#plugins.prefilters.postfilters) you must use a unique
 `$compile_id` to keep the compiled template files separated.

 For example a [prefilter](#plugins.prefilters.postfilters) that
-localizes your templates (that is: translates language dependend parts)
+localizes your templates (that is: translates language dependent parts)
 at compile time, then you could use the current language as
 `$compile_id` and you will get a set of compiled templates for each
 language you use.
@@ -3,7 +3,7 @@

 Setting `$escape_html` to TRUE will escape all template variable output
 by wrapping it in
-`htmlspecialchars({$output}, ENT_QUOTES, SMARTY_RESOURCE_CHAR_SET);`,
+`htmlspecialchars({$output}, ENT_QUOTES, $char_set);`,
 which is the same as `{$variable|escape:"html"}`.

 Template designers can choose to selectively disable this feature by
@@ -2,6 +2,6 @@
 ==================

 This is maximum time in seconds a cache lock is valid to avoid dead
-locks. The deafult value is 10 seconds.
+locks. The default value is 10 seconds.

 See also [`$cache_locking`](#variable.cache.locking)
@@ -1,21 +0,0 @@
-\$php\_handling {#variable.php.handling}
-===============
-
-This tells Smarty how to handle PHP code embedded in the templates.
-There are four possible settings, the default being
-`Smarty::PHP_PASSTHRU`. Note that this does NOT affect php code within
-[`{php}{/php}`](#language.function.php) tags in the template.
-
-   `Smarty::PHP_PASSTHRU` - Smarty echos tags as-is.
-
-   `Smarty::PHP_QUOTE` - Smarty quotes the tags as html entities.
-
-   `Smarty::PHP_REMOVE` - Smarty removes the tags from the templates.
-
-   `Smarty::PHP_ALLOW` - Smarty will execute the tags as PHP code.
-
-> **Note**
->
-> Embedding PHP code into templates is highly discouraged. Use [custom
-> functions](#plugins.functions) or [modifiers](#plugins.modifiers)
-> instead.
@@ -5,4 +5,4 @@
 array of all directories that are considered trusted. Trusted
 directories are where you keep php scripts that are executed directly
 from the templates with
-[`{include_php}`](#language.function.include.php).
+[`{insert}`](#language.function.insert.php).
@@ -10,7 +10,7 @@ environments do not allow PHP processes to create directories, so this
 must be disabled which is the default.

 Sub directories are more efficient, so use them if you can.
-Theoretically you get much better perfomance on a filesystem with 10
+Theoretically you get much better performance on a filesystem with 10
 directories each having 100 files, than with 1 directory having 1000
 files. This was certainly the case with Solaris 7 (UFS)\... with newer
 filesystems such as ext3 and especially reiserfs, the difference is
@@ -25,10 +25,10 @@ like.
 -   You CANNOT remove a specified template name under multiple cache
    groups such as `'/a/b/*/foo.tpl'`, the cache grouping works
    left-to-right ONLY. You will need to group your templates under a
-    single cache group heirarchy to be able to clear them as a group.
+    single cache group hierarchy to be able to clear them as a group.

 Cache grouping should not be confused with your template directory
-heirarchy, the cache grouping has no knowledge of how your templates are
+hierarchy, the cache grouping has no knowledge of how your templates are
 structured. So for example, if you have a template structure like
 `themes/blue/index.tpl` and you want to be able to clear all the cache
 files for the "blue" theme, you will need to create a cache group
@@ -5,17 +5,17 @@ Charset Encoding {#charset.encoding}
 ================

 There are a variety of encodings for textual data, ISO-8859-1 (Latin1)
-and UTF-8 being the most popular. Unless specified otherwise with the
-`SMARTY_RESOURCE_CHAR_SET` constant, Smarty recognizes `UTF-8` as the
-internal charset if [Multibyte String](https://www.php.net/mbstring) is
-available, `ISO-8859-1` if not.
+and UTF-8 being the most popular. Unless you change `Smarty::$_CHARSET`, 
+Smarty recognizes `UTF-8` as the internal charset if 
+[Multibyte String](https://www.php.net/mbstring) is available, 
+`ISO-8859-1` if not.

 > **Note**
 >
 > `ISO-8859-1` has been PHP\'s default internal charset since the
 > beginning. Unicode has been evolving since 1991. Since then it has
 > become the one charset to conquer them all, as it is capable of
-> encoding most of the known characters even accross different character
+> encoding most of the known characters even across different character
 > systems (latin, cyrillic, japanese, ...). `UTF-8` is unicode\'s most
 > used encoding, as it allows referencing the thousands of character
 > with the smallest size overhead possible.
@@ -36,8 +36,9 @@ available, `ISO-8859-1` if not.
    if (function_exists('mb_internal_charset')) {
      mb_internal_charset('EUC-JP');
    }
-    define('SMARTY_RESOURCE_CHAR_SET', 'EUC-JP');
+
    require_once 'libs/Smarty.class.php';
+    Smarty::$_CHARSET = 'EUC-JP';
    $smarty = new Smarty();
      
     
@@ -3,20 +3,20 @@ Extends Template Resources {#resources.extends}

 The `extends:` resource is used to define child/parent relationships for
 template inheritance from the PHP script. For details see section of
-[Template Interitance](#advanced.features.template.inheritance).
+[Template Inheritance](#advanced.features.template.inheritance).

 As of Smarty 3.1 the `extends:` resource may use any available [template
 resource](#resources), including `string:` and `eval:`. When [templates
 from strings](#resources.string) are used, make sure they are properly
 (url or base64) encoded. Is an `eval:` resource found within an
 inheritance chain, its \"don\'t save a compile file\" property is
-superseeded by the `extends:` resource. The templates within an
+superseded by the `extends:` resource. The templates within an
 inheritance chain are not compiled separately, though. Only a single
 compiled template will be generated.

 > **Note**
 >
-> Use this when inheritance is required programatically. When inheriting
+> Use this when inheritance is required programmatically. When inheriting
 > within PHP, it is not obvious from the child template what inheritance
 > took place. If you have a choice, it is normally more flexible and
 > intuitive to handle inheritance chains from within the templates.
@@ -47,7 +47,7 @@ Templates from a specific \$template\_dir {#templates.from.specified.template.di
 Smarty 3.1 introduced the bracket-syntax for specifying an element from
 [`$template_dir`](#variable.template.dir). This allows websites
 employing multiple sets of templates better control over which template
-to acces.
+to access.

 The bracket-syntax can be used from anywhere you can specify the `file:`
 resource type.
@@ -23,5 +23,4 @@ to determine the appropriate value automatically. If defined, the path

         

-See also [`$smarty.const`](../designers/language-variables/language-variables-smarty.md) and
-[`$php_handling constants`](./api-variables/variable-php-handling.md)
+See also [`$smarty.const`](../designers/language-variables/language-variables-smarty.md).
@@ -161,7 +161,6 @@ class Smarty_Internal_Templatelexer
                                               'COMMENT'     => 'comment',
                                               'AS'          => 'as',
                                               'TO'          => 'to',
-                                               'PHP'         => '"<?php", "<%", "{php}" tag',
                                               'LOGOP'       => '"<", "==" ... logical operator',
                                               'TLOGOP'      => '"lt", "eq" ... logical operator; "is div by" ... if condition',
                                               'SCOND'       => '"is even" ... if condition',
@@ -747,6 +747,9 @@ value(res)       ::= doublequoted_with_quotes(s). {


 value(res)    ::= varindexed(vi) DOUBLECOLON static_class_access(r). {
+    if ($this->security && $this->security->static_classes !== array()) {
+        $this->compiler->trigger_template_error('dynamic static class not allowed by security setting');
+    }
    $prefixVar = $this->compiler->getNewPrefixVariable();
    if (vi['var'] === '\'smarty\'') {
        $this->compiler->appendPrefixCode("<?php {$prefixVar} = ". $this->compiler->compileTag('private_special_variable',array(),vi['smarty_internal_index']).';?>');
@@ -5,6 +5,11 @@
 * @package Smarty
 */

+
+if (!defined('SMARTY_HELPER_FUNCTIONS_LOADED')) {
+	include __DIR__ . '/functions.php';
+}
+
 /**
 * Smarty Autoloader
 *
@@ -41,31 +46,6 @@ class Smarty_Autoloader
     */
    public static $rootClasses = array('smarty' => 'Smarty.class.php');

-    /**
-     * Registers Smarty_Autoloader backward compatible to older installations.
-     *
-     * @param bool $prepend Whether to prepend the autoloader or not.
-     */
-    public static function registerBC($prepend = false)
-    {
-        /**
-         * register the class autoloader
-         */
-        if (!defined('SMARTY_SPL_AUTOLOAD')) {
-            define('SMARTY_SPL_AUTOLOAD', 0);
-        }
-        if (SMARTY_SPL_AUTOLOAD
-            && set_include_path(get_include_path() . PATH_SEPARATOR . SMARTY_SYSPLUGINS_DIR) !== false
-        ) {
-            $registeredAutoLoadFunctions = spl_autoload_functions();
-            if (!isset($registeredAutoLoadFunctions[ 'spl_autoload' ])) {
-                spl_autoload_register();
-            }
-        } else {
-            self::register($prepend);
-        }
-    }
-
    /**
     * Registers Smarty_Autoloader as an SPL autoloader.
     *
@@ -73,7 +53,7 @@ class Smarty_Autoloader
     */
    public static function register($prepend = false)
    {
-        self::$SMARTY_DIR = defined('SMARTY_DIR') ? SMARTY_DIR : dirname(__FILE__) . DIRECTORY_SEPARATOR;
+        self::$SMARTY_DIR = defined('SMARTY_DIR') ? SMARTY_DIR : __DIR__ . DIRECTORY_SEPARATOR;
        self::$SMARTY_SYSPLUGINS_DIR = defined('SMARTY_SYSPLUGINS_DIR') ? SMARTY_SYSPLUGINS_DIR :
            self::$SMARTY_DIR . 'sysplugins' . DIRECTORY_SEPARATOR;
        spl_autoload_register(array(__CLASS__, 'autoload'), true, $prepend);
@@ -89,7 +69,7 @@ class Smarty_Autoloader
        if ($class[ 0 ] !== 'S' || strpos($class, 'Smarty') !== 0) {
            return;
        }
-        $_class = strtolower($class);
+        $_class = smarty_strtolower_ascii($class);
        if (isset(self::$rootClasses[ $_class ])) {
            $file = self::$SMARTY_DIR . self::$rootClasses[ $_class ];
            if (is_file($file)) {
@@ -36,7 +36,7 @@ if (!defined('SMARTY_DIR')) {
    /**
     *
     */
-    define('SMARTY_DIR', dirname(__FILE__) . DIRECTORY_SEPARATOR);
+    define('SMARTY_DIR', __DIR__ . DIRECTORY_SEPARATOR);
 }
 /**
 * set SMARTY_SYSPLUGINS_DIR to absolute path to Smarty internal plugins.
@@ -60,12 +60,21 @@ if (!defined('SMARTY_MBSTRING')) {
     */
    define('SMARTY_MBSTRING', function_exists('mb_get_info'));
 }
+
+/**
+ * Load helper functions
+ */
+if (!defined('SMARTY_HELPER_FUNCTIONS_LOADED')) {
+    include __DIR__ . '/functions.php';
+}
+
 /**
 * Load Smarty_Autoloader
 */
 if (!class_exists('Smarty_Autoloader')) {
-    include dirname(__FILE__) . '/bootstrap.php';
+    include __DIR__ . '/bootstrap.php';
 }
+
 /**
 * Load always needed external class files
 */
@@ -98,7 +107,7 @@ class Smarty extends Smarty_Internal_TemplateBase
    /**
     * smarty version
     */
-    const SMARTY_VERSION = '4.0.0';
+    const SMARTY_VERSION = '4.2.1';
    /**
     * define variable scopes
     */
@@ -130,7 +139,6 @@ class Smarty extends Smarty_Internal_TemplateBase
    const DEBUG_OFF        = 0;
    const DEBUG_ON         = 1;
    const DEBUG_INDIVIDUAL = 2;
-
    /**
     * filter types
     */
@@ -771,7 +779,7 @@ class Smarty extends Smarty_Internal_TemplateBase
            $this->_normalizeTemplateConfig($isConfig);
        }
        if ($index !== null) {
-            return isset($dir[ $index ]) ? $dir[ $index ] : null;
+            return ($dir[ $index ] ?? null);
        }
        return $dir;
    }
@@ -867,7 +875,7 @@ class Smarty extends Smarty_Internal_TemplateBase
                $this->plugins_dir = (array)$this->plugins_dir;
            }
            foreach ($this->plugins_dir as $k => $v) {
-                $this->plugins_dir[ $k ] = $this->_realpath(rtrim($v, '/\\') . DIRECTORY_SEPARATOR, true);
+                $this->plugins_dir[ $k ] = $this->_realpath(rtrim($v ?? '', '/\\') . DIRECTORY_SEPARATOR, true);
            }
            $this->_cache[ 'plugin_files' ] = array();
            $this->_pluginsDirNormalized = true;
@@ -1345,7 +1353,7 @@ class Smarty extends Smarty_Internal_TemplateBase
     */
    private function _normalizeDir($dirName, $dir)
    {
-        $this->{$dirName} = $this->_realpath(rtrim($dir, "/\\") . DIRECTORY_SEPARATOR, true);
+        $this->{$dirName} = $this->_realpath(rtrim($dir ?? '', "/\\") . DIRECTORY_SEPARATOR, true);
    }

    /**
@@ -1367,7 +1375,7 @@ class Smarty extends Smarty_Internal_TemplateBase
        }
        foreach ($dir as $k => $v) {
            if (!isset($processed[ $k ])) {
-                $dir[ $k ] = $v = $this->_realpath(rtrim($v, "/\\") . DIRECTORY_SEPARATOR, true);
+                $dir[ $k ] = $v = $this->_realpath(rtrim($v ?? '', "/\\") . DIRECTORY_SEPARATOR, true);
                $processed[ $k ] = true;
            }
        }
@@ -11,6 +11,6 @@
 * Load and register Smarty Autoloader
 */
 if (!class_exists('Smarty_Autoloader')) {
-    include dirname(__FILE__) . '/Autoloader.php';
+    include __DIR__ . '/Autoloader.php';
 }
 Smarty_Autoloader::register(true);
@@ -1,9 +1,9 @@
 {capture name='_smarty_debug' assign=debug_output}
-    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
-    <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+    <!DOCTYPE html>
+    <html lang="en">
    <head>
        <title>Smarty Debug Console</title>
-        <style type="text/css">
+        <style>
            {literal}
            body, h1, h2, h3, td, th, p {
                font-family: sans-serif;
@@ -12,7 +12,6 @@
                margin: 1px;
                padding: 0;
            }
-
            h1 {
                margin: 0;
                text-align: left;
@@ -22,7 +21,6 @@
                font-weight: bold;
                font-size: 1.2em;
            }
-
            h2 {
                background-color: #9B410E;
                color: white;
@@ -38,48 +36,38 @@
                font-size: 0.7em;
                padding: 2px;
            }
-
            body {
                background: black;
            }
-
            p, table, div {
                background: #f0ead8;
            }
-
            p {
                margin: 0;
                font-style: italic;
                text-align: center;
            }
-
            table {
                width: 100%;
            }
-
            th, td {
                font-family: monospace;
                vertical-align: top;
                text-align: left;
            }
-
            td {
                color: green;
            }
-
-            .odd {
+            tr:nth-child(odd) {
                background-color: #eeeeee;
            }
-
-            .even {
+            tr:nth-child(even) {
                background-color: #fafafa;
            }
-
            .exectime {
                font-size: 0.8em;
                font-style: italic;
            }
-
            #bold div {
                color: black;
                font-weight: bold;
@@ -95,12 +83,11 @@
                color: blue;
                font-weight: bold;
            }
-
            #table_config_vars th {
                color: maroon;
            }
-
            {/literal}
+
        </style>
    </head>
    <body>
@@ -112,12 +99,13 @@
        <h2>included templates &amp; config files (load time in seconds)</h2>
        <div>
            {foreach $template_data as $template}
-                <font color=brown>{$template.name}</font>
-                <br />&nbsp;&nbsp;<span class="exectime">
+                <span style="color: brown;">{$template.name}</span>
+                <br>&nbsp;&nbsp;<span class="exectime">
                (compile {$template['compile_time']|string_format:"%.5f"}) (render {$template['render_time']|string_format:"%.5f"}) (cache {$template['cache_time']|string_format:"%.5f"})
                 </span>
-                <br />
+                <br>
            {/foreach}
+
        </div>
    {/if}

@@ -125,29 +113,46 @@

    <table id="table_assigned_vars">
        {foreach $assigned_vars as $vars}
-            <tr class="{if $vars@iteration % 2 eq 0}odd{else}even{/if}">
-                <td><h3><font color=blue>${$vars@key}</font></h3>
-                    {if isset($vars['nocache'])}<b>Nocache</b><br />{/if}
-                    {if isset($vars['scope'])}<b>Origin:</b> {$vars['scope']|debug_print_var nofilter}{/if}
+            <tr>
+                <td>
+                    <h3 style="color: blue;">${$vars@key}</h3>
+                    {if isset($vars['nocache'])}<strong>Nocache</strong><br>{/if}
+                    {if isset($vars['scope'])}<strong>Origin:</strong> {$vars['scope']|debug_print_var nofilter}{/if}
                </td>
-                <td><h3>Value</h3>{$vars['value']|debug_print_var:10:80 nofilter}</td>
-                <td>{if isset($vars['attributes'])}<h3>Attributes</h3>{$vars['attributes']|debug_print_var nofilter} {/if}</td>
+                <td>
+                    <h3>Value</h3>
+                    {$vars['value']|debug_print_var:10:80 nofilter}
+                </td>
+                <td>
+                    {if isset($vars['attributes'])}
+                        <h3>Attributes</h3>
+                        {$vars['attributes']|debug_print_var nofilter}
+                    {/if}
+                </td>
+            </tr>
         {/foreach}
+
    </table>

    <h2>assigned config file variables</h2>

+    {if NOT empty($config_vars)}
    <table id="table_config_vars">
        {foreach $config_vars as $vars}
-            <tr class="{if $vars@iteration % 2 eq 0}odd{else}even{/if}">
-                <td><h3><font color=blue>#{$vars@key}#</font></h3>
-                    {if isset($vars['scope'])}<b>Origin:</b> {$vars['scope']|debug_print_var nofilter}{/if}
+            <tr>
+                <td>
+                    <h3 style="color: blue;">#{$vars@key}#</h3>
+                    {if isset($vars['scope'])}<strong>Origin:</strong> {$vars['scope']|debug_print_var nofilter}{/if}
+                </td>
+                <td>
+                    {$vars['value']|debug_print_var:10:80 nofilter}
                </td>
-                <td>{$vars['value']|debug_print_var:10:80 nofilter}</td>
            </tr>
        {/foreach}

    </table>
+    {/if}
+
    </body>
    </html>
 {/capture}
@@ -0,0 +1,51 @@
+<?php
+/**
+ * This file is part of the Smarty package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * Registers some helper/polyfill functions.
+ */
+
+const SMARTY_HELPER_FUNCTIONS_LOADED = true;
+
+/**
+ * Converts the first characters in $string to uppercase (A-Z) if it is an ASCII lowercase character (a-z).
+ *
+ * May not be required when running PHP8.2+: https://wiki.php.net/rfc/strtolower-ascii
+ *
+ * @param $string
+ *
+ * @return string
+ */
+function smarty_ucfirst_ascii($string): string {
+    return smarty_strtoupper_ascii(substr($string, 0, 1)) . substr($string, 1);
+}
+
+/**
+ * Converts all uppercase ASCII characters (A-Z) in $string to lowercase (a-z).
+ *
+ * May not be required when running PHP8.2+: https://wiki.php.net/rfc/strtolower-ascii
+ *
+ * @param $string
+ *
+ * @return string
+ */
+function smarty_strtolower_ascii($string): string {
+    return strtr($string, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz');
+}
+
+/**
+ * Converts all lowercase ASCII characters (a-z) in $string to uppercase (A-Z).
+ *
+ * May not be required when running PHP8.2+: https://wiki.php.net/rfc/strtolower-ascii
+ *
+ * @param $string
+ *
+ * @return string
+ */
+function smarty_strtoupper_ascii($string): string {
+    return strtr($string, 'abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
+}
@@ -20,7 +20,7 @@
 * - indent_char   - string (" ")
 * - wrap_boundary - boolean (true)
 *
- * @link   https://www.smarty.net/manual/en/language.function.textformat.php {textformat}
+ * @link   https://www.smarty.net/docs/en/language.function.textformat.php {textformat}
 *         (Smarty online manual)
 *
 * @param array                    $params   parameters
@@ -12,7 +12,7 @@
 * Purpose:  print out a counter value
 *
 * @author Monte Ohrt <monte at ohrt dot com>
- * @link   https://www.smarty.net/manual/en/language.function.counter.php {counter}
+ * @link   https://www.smarty.net/docs/en/language.function.counter.php {counter}
 *         (Smarty online manual)
 *
 * @param array                    $params   parameters
@@ -23,7 +23,7 @@
 function smarty_function_counter($params, $template)
 {
    static $counters = array();
-    $name = (isset($params[ 'name' ])) ? $params[ 'name' ] : 'default';
+    $name = $params[ 'name' ] ?? 'default';
    if (!isset($counters[ $name ])) {
        $counters[ $name ] = array('start' => 1, 'skip' => 1, 'direction' => 'up', 'count' => 1);
    }
@@ -28,7 +28,7 @@
 * {cycle name=row values="one,two,three" reset=true}
 * {cycle name=row}
 *
- * @link    https://www.smarty.net/manual/en/language.function.cycle.php {cycle}
+ * @link    https://www.smarty.net/docs/en/language.function.cycle.php {cycle}
 *           (Smarty online manual)
 * @author  Monte Ohrt <monte at ohrt dot com>
 * @author  credit to Mark Priatel <mpriatel@rogers.com>
@@ -11,7 +11,7 @@
 * Name:     fetch
 * Purpose:  fetch file, web or ftp data and display results
 *
- * @link   https://www.smarty.net/manual/en/language.function.fetch.php {fetch}
+ * @link   https://www.smarty.net/docs/en/language.function.fetch.php {fetch}
 *         (Smarty online manual)
 * @author Monte Ohrt <monte at ohrt dot com>
 *
@@ -29,7 +29,7 @@
 * - assign     (optional) - assign the output as an array to this variable
 * - escape     (optional) - escape the content (not value), defaults to true
 *
- * @link    https://www.smarty.net/manual/en/language.function.html.checkboxes.php {html_checkboxes}
+ * @link    https://www.smarty.net/docs/en/language.function.html.checkboxes.php {html_checkboxes}
 *             (Smarty online manual)
 * @author  Christopher Kvarme <christopher.kvarme@flashjab.com>
 * @author  credits to Monte Ohrt <monte at ohrt dot com>
@@ -21,7 +21,7 @@
 * - basedir     - (optional) - base directory for absolute paths, default is environment variable DOCUMENT_ROOT
 * - path_prefix - prefix for path output (optional, default empty)
 *
- * @link    https://www.smarty.net/manual/en/language.function.html.image.php {html_image}
+ * @link    https://www.smarty.net/docs/en/language.function.html.image.php {html_image}
 *          (Smarty online manual)
 * @author  Monte Ohrt <monte at ohrt dot com>
 * @author  credits to Duda <duda@big.hu>
@@ -21,7 +21,7 @@
 * - id         (optional) - string default not set
 * - class      (optional) - string default not set
 *
- * @link   https://www.smarty.net/manual/en/language.function.html.options.php {html_image}
+ * @link   https://www.smarty.net/docs/en/language.function.html.options.php {html_image}
 *           (Smarty online manual)
 * @author Monte Ohrt <monte at ohrt dot com>
 * @author Ralf Strehle (minor optimization) <ralf dot strehle at yahoo dot de>
@@ -29,7 +29,7 @@
 * {html_radios values=$ids name='box' separator='<br>' output=$names}
 * {html_radios values=$ids checked=$checked separator='<br>' output=$names}
 *
- * @link    https://www.smarty.net/manual/en/language.function.html.radios.php {html_radios}
+ * @link    https://www.smarty.net/docs/en/language.function.html.radios.php {html_radios}
 *          (Smarty online manual)
 * @author  Christopher Kvarme <christopher.kvarme@flashjab.com>
 * @author  credits to Monte Ohrt <monte at ohrt dot com>
@@ -156,7 +156,7 @@ function smarty_function_html_radios($params, Smarty_Internal_Template $template
        }
    } else {
        foreach ($values as $_i => $_key) {
-            $_val = isset($output[ $_i ]) ? $output[ $_i ] : '';
+            $_val = $output[ $_i ] ?? '';
            $_html_result[] =
                smarty_function_html_radios_output(
                    $name,
@@ -28,7 +28,7 @@
 *            - 2.0 complete rewrite for performance,
 *              added attributes month_names, *_id
 *
- * @link    https://www.smarty.net/manual/en/language.function.html.select.date.php {html_select_date}
+ * @link    https://www.smarty.net/docs/en/language.function.html.select.date.php {html_select_date}
 *           (Smarty online manual)
 * @version 2.0
 * @author  Andrei Zmievski
@@ -101,6 +101,7 @@ function smarty_function_html_select_date($params, Smarty_Internal_Template $tem
    $field_separator = "\n";
    $option_separator = "\n";
    $time = null;
+
    // $all_empty = null;
    // $day_empty = null;
    // $month_empty = null;
@@ -113,17 +114,7 @@ function smarty_function_html_select_date($params, Smarty_Internal_Template $tem
    foreach ($params as $_key => $_value) {
        switch ($_key) {
            case 'time':
-                if (!is_array($_value) && $_value !== null) {
-                    $template->_checkPlugins(
-                        array(
-                            array(
-                                'function' => 'smarty_make_timestamp',
-                                'file'     => SMARTY_PLUGINS_DIR . 'shared.make_timestamp.php'
-                            )
-                        )
-                    );
-                    $time = smarty_make_timestamp($_value);
-                }
+                $$_key = $_value; // we'll handle conversion below
                break;
            case 'month_names':
                if (is_array($_value) && count($_value) === 12) {
@@ -178,43 +169,57 @@ function smarty_function_html_select_date($params, Smarty_Internal_Template $tem
    }
    // Note: date() is faster than strftime()
    // Note: explode(date()) is faster than date() date() date()
-    if (isset($params[ 'time' ]) && is_array($params[ 'time' ])) {
-        if (isset($params[ 'time' ][ $prefix . 'Year' ])) {
+
+    if (isset($time) && is_array($time)) {
+        if (isset($time[$prefix . 'Year'])) {
            // $_REQUEST[$field_array] given
-            foreach (array(
-                'Y' => 'Year',
-                'm' => 'Month',
-                'd' => 'Day'
-            ) as $_elementKey => $_elementName) {
+            foreach ([
+                         'Y' => 'Year',
+                         'm' => 'Month',
+                         'd' => 'Day'
+                     ] as $_elementKey => $_elementName) {
                $_variableName = '_' . strtolower($_elementName);
-                $$_variableName =
-                    isset($params[ 'time' ][ $prefix . $_elementName ]) ? $params[ 'time' ][ $prefix . $_elementName ] :
-                        date($_elementKey);
+                $$_variableName = $params[ 'time' ][ $prefix . $_elementName ] ?? date($_elementKey);
            }
-        } elseif (isset($params[ 'time' ][ $field_array ][ $prefix . 'Year' ])) {
+        } elseif (isset($time[$field_array][$prefix . 'Year'])) {
            // $_REQUEST given
-            foreach (array(
-                'Y' => 'Year',
-                'm' => 'Month',
-                'd' => 'Day'
-            ) as $_elementKey => $_elementName) {
+            foreach ([
+                         'Y' => 'Year',
+                         'm' => 'Month',
+                         'd' => 'Day'
+                     ] as $_elementKey => $_elementName) {
                $_variableName = '_' . strtolower($_elementName);
-                $$_variableName = isset($params[ 'time' ][ $field_array ][ $prefix . $_elementName ]) ?
-                    $params[ 'time' ][ $field_array ][ $prefix . $_elementName ] : date($_elementKey);
+                $$_variableName = isset($time[$field_array][$prefix . $_elementName]) ?
+                    $time[$field_array][$prefix . $_elementName] : date($_elementKey);
            }
        } else {
            // no date found, use NOW
-            list($_year, $_month, $_day) = $time = explode('-', date('Y-m-d'));
+            [$_year, $_month, $_day] = explode('-', date('Y-m-d'));
        }
+    } elseif (isset($time) && preg_match("/(\d*)-(\d*)-(\d*)/", $time, $matches)) {
+        $_year = $_month = $_day = null;
+        if ($matches[1] > '') $_year = (int) $matches[1];
+        if ($matches[2] > '') $_month = (int) $matches[2];
+        if ($matches[3] > '') $_day = (int) $matches[3];
    } elseif ($time === null) {
        if (array_key_exists('time', $params)) {
-            $_year = $_month = $_day = $time = null;
+            $_year = $_month = $_day = null;
        } else {
-            list($_year, $_month, $_day) = $time = explode('-', date('Y-m-d'));
+            [$_year, $_month, $_day] = explode('-', date('Y-m-d'));
        }
    } else {
-        list($_year, $_month, $_day) = $time = explode('-', date('Y-m-d', $time));
+        $template->_checkPlugins(
+            array(
+                array(
+                    'function' => 'smarty_make_timestamp',
+                    'file'     => SMARTY_PLUGINS_DIR . 'shared.make_timestamp.php'
+                )
+            )
+        );
+        $time = smarty_make_timestamp($time);
+        [$_year, $_month, $_day] = explode('-', date('Y-m-d', $time));
    }
+
    // make syntax "+N" or "-N" work with $start_year and $end_year
    // Note preg_match('!^(\+|\-)\s*(\d+)$!', $end_year, $match) is slower than trim+substr
    foreach (array(
@@ -258,9 +263,8 @@ function smarty_function_html_select_date($params, Smarty_Internal_Template $tem
            if ($year_id !== null || $all_id !== null) {
                $_html_years .= ' id="' . smarty_function_escape_special_chars(
                        $year_id !== null ?
-                            ($year_id ? $year_id : $_name) :
-                            ($all_id ? ($all_id . $_name) :
-                                $_name)
+                            ($year_id ?? $_name) :
+                            ($all_id ? ($all_id . $_name) : $_name)
                    ) . '"';
            }
            if ($year_size) {
@@ -268,7 +272,7 @@ function smarty_function_html_select_date($params, Smarty_Internal_Template $tem
            }
            $_html_years .= $_extra . $extra_attrs . '>' . $option_separator;
            if (isset($year_empty) || isset($all_empty)) {
-                $_html_years .= '<option value="">' . (isset($year_empty) ? $year_empty : $all_empty) . '</option>' .
+                $_html_years .= '<option value="">' . ($year_empty ?? $all_empty) . '</option>' .
                                $option_separator;
            }
            $op = $start_year > $end_year ? -1 : 1;
@@ -293,9 +297,8 @@ function smarty_function_html_select_date($params, Smarty_Internal_Template $tem
        if ($month_id !== null || $all_id !== null) {
            $_html_months .= ' id="' . smarty_function_escape_special_chars(
                    $month_id !== null ?
-                        ($month_id ? $month_id : $_name) :
-                        ($all_id ? ($all_id . $_name) :
-                            $_name)
+                        ($month_id ?? $_name) :
+                        ($all_id ? ($all_id . $_name) : $_name)
                ) . '"';
        }
        if ($month_size) {
@@ -303,14 +306,14 @@ function smarty_function_html_select_date($params, Smarty_Internal_Template $tem
        }
        $_html_months .= $_extra . $extra_attrs . '>' . $option_separator;
        if (isset($month_empty) || isset($all_empty)) {
-            $_html_months .= '<option value="">' . (isset($month_empty) ? $month_empty : $all_empty) . '</option>' .
+            $_html_months .= '<option value="">' . ($month_empty ?? $all_empty) . '</option>' .
                             $option_separator;
        }
        for ($i = 1; $i <= 12; $i++) {
            $_val = sprintf('%02d', $i);
            $_text = isset($month_names) ? smarty_function_escape_special_chars($month_names[ $i ]) :
-                ($month_format === '%m' ? $_val : strftime($month_format, $_month_timestamps[ $i ]));
-            $_value = $month_value_format === '%m' ? $_val : strftime($month_value_format, $_month_timestamps[ $i ]);
+                ($month_format === '%m' ? $_val : @strftime($month_format, $_month_timestamps[ $i ]));
+            $_value = $month_value_format === '%m' ? $_val : @strftime($month_value_format, $_month_timestamps[ $i ]);
            $_html_months .= '<option value="' . $_value . '"' . ($_val == $_month ? ' selected="selected"' : '') .
                             '>' . $_text . '</option>' . $option_separator;
        }
@@ -339,7 +342,7 @@ function smarty_function_html_select_date($params, Smarty_Internal_Template $tem
        }
        $_html_days .= $_extra . $extra_attrs . '>' . $option_separator;
        if (isset($day_empty) || isset($all_empty)) {
-            $_html_days .= '<option value="">' . (isset($day_empty) ? $day_empty : $all_empty) . '</option>' .
+            $_html_days .= '<option value="">' . ($day_empty ?? $all_empty) . '</option>' .
                           $option_separator;
        }
        for ($i = 1; $i <= 31; $i++) {
@@ -11,7 +11,7 @@
 * Name:     html_select_time
 * Purpose:  Prints the dropdowns for time selection
 *
- * @link   https://www.smarty.net/manual/en/language.function.html.select.time.php {html_select_time}
+ * @link   https://www.smarty.net/docs/en/language.function.html.select.time.php {html_select_time}
 *           (Smarty online manual)
 * @author Roberto Berto <roberto@berto.net>
 * @author Monte Ohrt <monte AT ohrt DOT com>
@@ -147,9 +147,7 @@ function smarty_function_html_select_time($params, Smarty_Internal_Template $tem
                's' => 'Second'
            ) as $_elementKey => $_elementName) {
                $_variableName = '_' . strtolower($_elementName);
-                $$_variableName =
-                    isset($params[ 'time' ][ $prefix . $_elementName ]) ? $params[ 'time' ][ $prefix . $_elementName ] :
-                        date($_elementKey);
+                $$_variableName = $params[ 'time' ][ $prefix . $_elementName ] ?? date($_elementKey);
            }
            $_meridian =
                isset($params[ 'time' ][ $prefix . 'Meridian' ]) ? (' ' . $params[ 'time' ][ $prefix . 'Meridian' ]) :
@@ -199,7 +197,7 @@ function smarty_function_html_select_time($params, Smarty_Internal_Template $tem
        if ($hour_id !== null || $all_id !== null) {
            $_html_hours .= ' id="' .
                            smarty_function_escape_special_chars(
-                                $hour_id !== null ? ($hour_id ? $hour_id : $_name) :
+                                $hour_id !== null ? ($hour_id ?? $_name) :
                                    ($all_id ? ($all_id . $_name) : $_name)
                            ) . '"';
        }
@@ -208,7 +206,7 @@ function smarty_function_html_select_time($params, Smarty_Internal_Template $tem
        }
        $_html_hours .= $_extra . $extra_attrs . '>' . $option_separator;
        if (isset($hour_empty) || isset($all_empty)) {
-            $_html_hours .= '<option value="">' . (isset($hour_empty) ? $hour_empty : $all_empty) . '</option>' .
+            $_html_hours .= '<option value="">' . ($hour_empty ?? $all_empty) . '</option>' .
                            $option_separator;
        }
        $start = $use_24_hours ? 0 : 1;
@@ -241,9 +239,8 @@ function smarty_function_html_select_time($params, Smarty_Internal_Template $tem
        if ($minute_id !== null || $all_id !== null) {
            $_html_minutes .= ' id="' . smarty_function_escape_special_chars(
                    $minute_id !== null ?
-                        ($minute_id ? $minute_id : $_name) :
-                        ($all_id ? ($all_id . $_name) :
-                            $_name)
+                        ($minute_id ?? $_name) :
+                        ($all_id ? ($all_id . $_name) : $_name)
                ) . '"';
        }
        if ($minute_size) {
@@ -251,7 +248,7 @@ function smarty_function_html_select_time($params, Smarty_Internal_Template $tem
        }
        $_html_minutes .= $_extra . $extra_attrs . '>' . $option_separator;
        if (isset($minute_empty) || isset($all_empty)) {
-            $_html_minutes .= '<option value="">' . (isset($minute_empty) ? $minute_empty : $all_empty) . '</option>' .
+            $_html_minutes .= '<option value="">' . ($minute_empty ?? $all_empty) . '</option>' .
                              $option_separator;
        }
        $selected = $_minute !== null ? ($_minute - $_minute % $minute_interval) : null;
@@ -279,9 +276,8 @@ function smarty_function_html_select_time($params, Smarty_Internal_Template $tem
        if ($second_id !== null || $all_id !== null) {
            $_html_seconds .= ' id="' . smarty_function_escape_special_chars(
                    $second_id !== null ?
-                        ($second_id ? $second_id : $_name) :
-                        ($all_id ? ($all_id . $_name) :
-                            $_name)
+                        ($second_id ?? $_name) :
+                        ($all_id ? ($all_id . $_name) : $_name)
                ) . '"';
        }
        if ($second_size) {
@@ -289,7 +285,7 @@ function smarty_function_html_select_time($params, Smarty_Internal_Template $tem
        }
        $_html_seconds .= $_extra . $extra_attrs . '>' . $option_separator;
        if (isset($second_empty) || isset($all_empty)) {
-            $_html_seconds .= '<option value="">' . (isset($second_empty) ? $second_empty : $all_empty) . '</option>' .
+            $_html_seconds .= '<option value="">' . ($second_empty ?? $all_empty) . '</option>' .
                              $option_separator;
        }
        $selected = $_second !== null ? ($_second - $_second % $second_interval) : null;
@@ -317,10 +313,8 @@ function smarty_function_html_select_time($params, Smarty_Internal_Template $tem
        if ($meridian_id !== null || $all_id !== null) {
            $_html_meridian .= ' id="' . smarty_function_escape_special_chars(
                    $meridian_id !== null ?
-                        ($meridian_id ? $meridian_id :
-                            $_name) :
-                        ($all_id ? ($all_id . $_name) :
-                            $_name)
+                        ($meridian_id ?? $_name) :
+                        ($all_id ? ($all_id . $_name) : $_name)
                ) . '"';
        }
        if ($meridian_size) {
@@ -328,7 +322,7 @@ function smarty_function_html_select_time($params, Smarty_Internal_Template $tem
        }
        $_html_meridian .= $_extra . $extra_attrs . '>' . $option_separator;
        if (isset($meridian_empty) || isset($all_empty)) {
-            $_html_meridian .= '<option value="">' . (isset($meridian_empty) ? $meridian_empty : $all_empty) .
+            $_html_meridian .= '<option value="">' . ($meridian_empty ?? $all_empty) .
                               '</option>' . $option_separator;
        }
        $_html_meridian .= '<option value="am"' . ($_hour > 0 && $_hour < 12 ? ' selected="selected"' : '') .
@@ -38,7 +38,7 @@
 * @author  credit to Messju Mohr <messju at lammfellpuschen dot de>
 * @author  credit to boots <boots dot smarty at yahoo dot com>
 * @version 1.1
- * @link    https://www.smarty.net/manual/en/language.function.html.table.php {html_table}
+ * @link    https://www.smarty.net/docs/en/language.function.html.table.php {html_table}
 *           (Smarty online manual)
 *
 * @param array $params parameters
@@ -36,7 +36,7 @@
 * {mailto address="me@domain.com" cc="you@domain.com,they@domain.com"}
 * {mailto address="me@domain.com" extra='class="mailto"'}
 *
- * @link    https://www.smarty.net/manual/en/language.function.mailto.php {mailto}
+ * @link    https://www.smarty.net/docs/en/language.function.mailto.php {mailto}
 *           (Smarty online manual)
 * @version 1.2
 * @author  Monte Ohrt <monte at ohrt dot com>
@@ -48,8 +48,13 @@
 */
 function smarty_function_mailto($params)
 {
-    static $_allowed_encoding =
-        array('javascript' => true, 'javascript_charcode' => true, 'hex' => true, 'none' => true);
+    static $_allowed_encoding = [
+        'javascript' => true,
+        'javascript_charcode' => true,
+        'hex' => true,
+        'none' => true
+    ];
+
    $extra = '';
    if (empty($params[ 'address' ])) {
        trigger_error("mailto: missing 'address' parameter", E_USER_WARNING);
@@ -57,19 +62,19 @@ function smarty_function_mailto($params)
    } else {
        $address = $params[ 'address' ];
    }
+
    $text = $address;
+
    // netscape and mozilla do not decode %40 (@) in BCC field (bug?)
    // so, don't encode it.
-    $search = array('%40', '%2C');
-    $replace = array('@', ',');
-    $mail_parms = array();
+    $mail_parms = [];
    foreach ($params as $var => $value) {
        switch ($var) {
            case 'cc':
            case 'bcc':
            case 'followupto':
                if (!empty($value)) {
-                    $mail_parms[] = $var . '=' . str_replace($search, $replace, rawurlencode($value));
+                    $mail_parms[] = $var . '=' . str_replace(['%40', '%2C'], ['@', ','], rawurlencode($value));
                }
                break;
            case 'subject':
@@ -83,6 +88,7 @@ function smarty_function_mailto($params)
            default:
        }
    }
+
    if ($mail_parms) {
        $address .= '?' . join('&', $mail_parms);
    }
@@ -94,22 +100,21 @@ function smarty_function_mailto($params)
        );
        return;
    }
-    // FIXME: (rodneyrehm) document.write() excues me what? 1998 has passed!
+
+    $string = '<a href="mailto:' . htmlspecialchars($address, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, Smarty::$_CHARSET) .
+        '" ' . $extra . '>' . htmlspecialchars($text, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, Smarty::$_CHARSET) . '</a>';
+
    if ($encode === 'javascript') {
-        $string = 'document.write(\'<a href="mailto:' . $address . '" ' . $extra . '>' . $text . '</a>\');';
        $js_encode = '';
        for ($x = 0, $_length = strlen($string); $x < $_length; $x++) {
            $js_encode .= '%' . bin2hex($string[ $x ]);
        }
-        return '<script type="text/javascript">eval(unescape(\'' . $js_encode . '\'))</script>';
+        return '<script type="text/javascript">document.write(unescape(\'' . $js_encode . '\'))</script>';
    } elseif ($encode === 'javascript_charcode') {
-        $string = '<a href="mailto:' . $address . '" ' . $extra . '>' . $text . '</a>';
-        for ($x = 0, $y = strlen($string); $x < $y; $x++) {
+        for ($x = 0, $_length = strlen($string); $x < $_length; $x++) {
            $ord[] = ord($string[ $x ]);
        }
-        $_ret = "<script type=\"text/javascript\" language=\"javascript\">\n" . "{document.write(String.fromCharCode(" .
-                implode(',', $ord) . "))" . "}\n" . "</script>\n";
-        return $_ret;
+        return '<script type="text/javascript">document.write(String.fromCharCode(' . implode(',', $ord) . '))</script>';
    } elseif ($encode === 'hex') {
        preg_match('!^(.*)(\?.*)$!', $address, $match);
        if (!empty($match[ 2 ])) {
@@ -132,6 +137,6 @@ function smarty_function_mailto($params)
        return '<a href="' . $mailto . $address_encode . '" ' . $extra . '>' . $text_encode . '</a>';
    } else {
        // no encoding
-        return '<a href="mailto:' . $address . '" ' . $extra . '>' . $text . '</a>';
+        return $string;
    }
 }
@@ -12,7 +12,7 @@
 * Name:     math
 * Purpose:  handle math computations in template
 *
- * @link   https://www.smarty.net/manual/en/language.function.math.php {math}
+ * @link   https://www.smarty.net/docs/en/language.function.math.php {math}
 *           (Smarty online manual)
 * @author Monte Ohrt <monte at ohrt dot com>
 *
@@ -25,41 +25,70 @@ function smarty_function_math($params, $template)
 {
    static $_allowed_funcs =
        array(
-            'int'   => true,
-            'abs'   => true,
-            'ceil'  => true,
-            'cos'   => true,
-            'exp'   => true,
-            'floor' => true,
-            'log'   => true,
-            'log10' => true,
-            'max'   => true,
-            'min'   => true,
-            'pi'    => true,
-            'pow'   => true,
-            'rand'  => true,
-            'round' => true,
-            'sin'   => true,
-            'sqrt'  => true,
-            'srand' => true,
-            'tan'   => true
+            'int'     => true,
+            'abs'     => true,
+            'ceil'    => true,
+            'acos'    => true,
+            'acosh'   => true,
+            'cos'     => true,
+            'cosh'    => true,
+            'deg2rad' => true,
+            'rad2deg' => true,
+            'exp'     => true,
+            'floor'   => true,
+            'log'     => true,
+            'log10'   => true,
+            'max'     => true,
+            'min'     => true,
+            'pi'      => true,
+            'pow'     => true,
+            'rand'    => true,
+            'round'   => true,
+            'asin'    => true,
+            'asinh'   => true,
+            'sin'     => true,
+            'sinh'    => true,
+            'sqrt'    => true,
+            'srand'   => true,
+            'atan'    => true,
+            'atanh'   => true,
+            'tan'     => true,
+            'tanh'    => true
        );
+
    // be sure equation parameter is present
    if (empty($params[ 'equation' ])) {
        trigger_error("math: missing equation parameter", E_USER_WARNING);
        return;
    }
    $equation = $params[ 'equation' ];
+
+    // Remove whitespaces
+    $equation = preg_replace('/\s+/', '', $equation);
+
+    // Adapted from https://www.php.net/manual/en/function.eval.php#107377
+    $number = '(?:\d+(?:[,.]\d+)?|pi|π)'; // What is a number
+    $functionsOrVars = '((?:0x[a-fA-F0-9]+)|([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*))';
+    $operators = '[,+\/*\^%-]'; // Allowed math operators
+    $regexp = '/^(('.$number.'|'.$functionsOrVars.'|('.$functionsOrVars.'\s*\((?1)*\)|\((?1)*\)))(?:'.$operators.'(?1))?)+$/';
+
+    if (!preg_match($regexp, $equation)) {
+        trigger_error("math: illegal characters", E_USER_WARNING);
+        return;
+    }
+
    // make sure parenthesis are balanced
    if (substr_count($equation, '(') !== substr_count($equation, ')')) {
        trigger_error("math: unbalanced parenthesis", E_USER_WARNING);
        return;
    }
+
    // disallow backticks
    if (strpos($equation, '`') !== false) {
        trigger_error("math: backtick character not allowed in equation", E_USER_WARNING);
        return;
    }
+
    // also disallow dollar signs
    if (strpos($equation, '$') !== false) {
        trigger_error("math: dollar signs not allowed in equation", E_USER_WARNING);
@@ -96,6 +125,7 @@ function smarty_function_math($params, $template)
    }
    $smarty_math_result = null;
    eval("\$smarty_math_result = " . $equation . ";");
+
    if (empty($params[ 'format' ])) {
        if (empty($params[ 'assign' ])) {
            return $smarty_math_result;
@@ -22,6 +22,8 @@
 */
 function smarty_modifier_capitalize($string, $uc_digits = false, $lc_rest = false)
 {
+    $string = (string) $string;
+
    if (Smarty::$_MBSTRING) {
        if ($lc_rest) {
            // uppercase (including hyphenated words)
@@ -0,0 +1,36 @@
+<?php
+/**
+ * Smarty plugin
+ *
+ * @package    Smarty
+ * @subpackage PluginsModifier
+ */
+/**
+ * Smarty count modifier plugin
+ * Type:     modifier
+ * Name:     count
+ * Purpose:  counts all elements in an array or in a Countable object
+ * Input:
+ *          - Countable|array: array or object to count
+ *          - mode: int defaults to 0 for normal count mode, if set to 1 counts recursive
+  *
+ * @param mixed $arrayOrObject  input array/object
+ * @param int $mode       count mode
+ *
+ * @return int
+ */
+function smarty_modifier_count($arrayOrObject, $mode = 0)
+{
+    /*
+     * @see https://www.php.net/count
+     * > Prior to PHP 8.0.0, if the parameter was neither an array nor an object that implements the Countable interface,
+     * > 1 would be returned, unless value was null, in which case 0 would be returned.
+     */
+
+    if ($arrayOrObject instanceof Countable || is_array($arrayOrObject)) {
+        return count($arrayOrObject, (int) $mode);
+    } elseif ($arrayOrObject === null) {
+        return 0;
+    }
+    return 1;
+}
@@ -15,7 +15,8 @@
 *          - format: strftime format for output
 *          - default_date: default date if $string is empty
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.date.format.php date_format (Smarty online manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.date.format.php date_format
+ *         (Smarty online manual)
 * @author Monte Ohrt <monte at ohrt dot com>
 *
 * @param string $string       input date string
@@ -78,7 +79,8 @@ function smarty_modifier_date_format($string, $format = null, $default_date = ''
            }
            $format = str_replace($_win_from, $_win_to, $format);
        }
-        return strftime($format, $timestamp);
+        // @ to suppress deprecation errors when running in PHP8.1 or higher.
+        return @strftime($format, $timestamp);
    } else {
        return date($format, $timestamp);
    }
@@ -17,101 +17,31 @@
 * @param string  $string        input string
 * @param string  $esc_type      escape type
 * @param string  $char_set      character set, used for htmlspecialchars() or htmlentities()
- * @param boolean $double_encode encode already encoded entitites again, used for htmlspecialchars() or htmlentities()
+ * @param boolean $double_encode encode already encoded entities again, used for htmlspecialchars() or htmlentities()
 *
 * @return string escaped input string
 */
 function smarty_modifier_escape($string, $esc_type = 'html', $char_set = null, $double_encode = true)
 {
-    static $_double_encode = true;
    static $is_loaded_1 = false;
    static $is_loaded_2 = false;
+
    if (!$char_set) {
        $char_set = Smarty::$_CHARSET;
    }
+    $string = (string)$string;
+
    switch ($esc_type) {
        case 'html':
-            if ($_double_encode) {
-                // php >=5.3.2 - go native
-                return htmlspecialchars($string, ENT_QUOTES, $char_set, $double_encode);
-            } else {
-                if ($double_encode) {
-                    // php <5.2.3 - only handle double encoding
-                    return htmlspecialchars($string, ENT_QUOTES, $char_set);
-                } else {
-                    // php <5.2.3 - prevent double encoding
-                    $string = preg_replace('!&(#?\w+);!', '%%%SMARTY_START%%%\\1%%%SMARTY_END%%%', $string);
-                    $string = htmlspecialchars($string, ENT_QUOTES, $char_set);
-                    $string = str_replace(
-                        array(
-                            '%%%SMARTY_START%%%',
-                            '%%%SMARTY_END%%%'
-                        ),
-                        array(
-                            '&',
-                            ';'
-                        ),
-                        $string
-                    );
-                    return $string;
-                }
-            }
+            return htmlspecialchars($string, ENT_QUOTES, $char_set, $double_encode);
        // no break
        case 'htmlall':
            if (Smarty::$_MBSTRING) {
-                // mb_convert_encoding ignores htmlspecialchars()
-                if ($_double_encode) {
-                    // php >=5.3.2 - go native
-                    $string = htmlspecialchars($string, ENT_QUOTES, $char_set, $double_encode);
-                } else {
-                    if ($double_encode) {
-                        // php <5.2.3 - only handle double encoding
-                        $string = htmlspecialchars($string, ENT_QUOTES, $char_set);
-                    } else {
-                        // php <5.2.3 - prevent double encoding
-                        $string = preg_replace('!&(#?\w+);!', '%%%SMARTY_START%%%\\1%%%SMARTY_END%%%', $string);
-                        $string = htmlspecialchars($string, ENT_QUOTES, $char_set);
-                        $string =
-                            str_replace(
-                                array(
-                                    '%%%SMARTY_START%%%',
-                                    '%%%SMARTY_END%%%'
-                                ),
-                                array(
-                                    '&',
-                                    ';'
-                                ),
-                                $string
-                            );
-                        return $string;
-                    }
-                }
-                // htmlentities() won't convert everything, so use mb_convert_encoding
-                return mb_convert_encoding($string, 'HTML-ENTITIES', $char_set);
+                $string = mb_convert_encoding($string, 'UTF-8', $char_set);
+                return htmlentities($string, ENT_QUOTES, 'UTF-8', $double_encode);
            }
            // no MBString fallback
-            if ($_double_encode) {
-                return htmlentities($string, ENT_QUOTES, $char_set, $double_encode);
-            } else {
-                if ($double_encode) {
-                    return htmlentities($string, ENT_QUOTES, $char_set);
-                } else {
-                    $string = preg_replace('!&(#?\w+);!', '%%%SMARTY_START%%%\\1%%%SMARTY_END%%%', $string);
-                    $string = htmlentities($string, ENT_QUOTES, $char_set);
-                    $string = str_replace(
-                        array(
-                            '%%%SMARTY_START%%%',
-                            '%%%SMARTY_END%%%'
-                        ),
-                        array(
-                            '&',
-                            ';'
-                        ),
-                        $string
-                    );
-                    return $string;
-                }
-            }
+            return htmlentities($string, ENT_QUOTES, $char_set, $double_encode);
        // no break
        case 'url':
            return rawurlencode($string);
@@ -0,0 +1,25 @@
+<?php
+/**
+ * Smarty plugin
+ *
+ * @package    Smarty
+ * @subpackage PluginsModifier
+ */
+
+/**
+ * Smarty explode modifier plugin
+ * Type:     modifier
+ * Name:     explode
+ * Purpose:  split a string by a string
+ *
+ * @param string   $separator
+ * @param string   $string
+ * @param int|null $limit
+ *
+ * @return array
+ */
+function smarty_modifier_explode($separator, $string, ?int $limit = null)
+{
+    // provide $string default to prevent deprecation errors in PHP >=8.1
+    return explode($separator, $string ?? '', $limit ?? PHP_INT_MAX);
+}
@@ -0,0 +1,26 @@
+<?php
+/**
+ * Smarty plugin
+ *
+ * @package    Smarty
+ * @subpackage PluginsModifier
+ */
+
+/**
+ * Smarty number_format modifier plugin
+ * Type:     modifier
+ * Name:     number_format
+ * Purpose:  Format a number with grouped thousands
+ *
+ * @param float|null  $num
+ * @param int         $decimals
+ * @param string|null $decimal_separator
+ * @param string|null $thousands_separator
+ *
+ * @return string
+ */
+function smarty_modifier_number_format(?float $num, int $decimals = 0, ?string $decimal_separator = ".", ?string $thousands_separator = ",")
+{
+    // provide $num default to prevent deprecation errors in PHP >=8.1
+    return number_format($num ?? 0.0, $decimals, $decimal_separator, $thousands_separator);
+}
@@ -11,7 +11,7 @@
 * Name:     regex_replace
 * Purpose:  regular expression search/replace
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.regex.replace.php
+ * @link   https://www.smarty.net/docs/en/language.modifier.regex.replace.php
 *          regex_replace (Smarty online manual)
 * @author Monte Ohrt <monte at ohrt dot com>
 *
@@ -11,7 +11,8 @@
 * Name:     replace
 * Purpose:  simple search/replace
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.replace.php replace (Smarty online manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.replace.php replace
+ *         (Smarty online manual)
 * @author Monte Ohrt <monte at ohrt dot com>
 * @author Uwe Tews
 *
@@ -11,7 +11,8 @@
 * Name:     spacify
 * Purpose:  add spaces between characters in a string
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.spacify.php spacify (Smarty online manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.spacify.php spacify
+ *         (Smarty online manual)
 * @author Monte Ohrt <monte at ohrt dot com>
 *
 * @param string $string       input string
@@ -13,7 +13,8 @@
 *               optionally splitting in the middle of a word, and
 *               appending the $etc string or inserting $etc into the middle.
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.truncate.php truncate (Smarty online manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.truncate.php truncate
+ *         (Smarty online manual)
 * @author Monte Ohrt <monte at ohrt dot com>
 *
 * @param string  $string      input string
@@ -42,8 +43,8 @@ function smarty_modifier_truncate($string, $length = 80, $etc = '...', $break_wo
            if (!$middle) {
                return mb_substr($string, 0, $length, Smarty::$_CHARSET) . $etc;
            }
-            return mb_substr($string, 0, $length / 2, Smarty::$_CHARSET) . $etc .
-                   mb_substr($string, -$length / 2, $length, Smarty::$_CHARSET);
+            return mb_substr($string, 0, intval($length / 2), Smarty::$_CHARSET) . $etc .
+                   mb_substr($string, -intval($length / 2), $length, Smarty::$_CHARSET);
        }
        return $string;
    }
@@ -56,7 +57,7 @@ function smarty_modifier_truncate($string, $length = 80, $etc = '...', $break_wo
        if (!$middle) {
            return substr($string, 0, $length) . $etc;
        }
-        return substr($string, 0, $length / 2) . $etc . substr($string, -$length / 2);
+        return substr($string, 0, intval($length / 2)) . $etc . substr($string, -intval($length / 2));
    }
    return $string;
 }
@@ -14,7 +14,7 @@
 * Input:    string to catenate
 * Example:  {$var|cat:"foo"}
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.cat.php cat
+ * @link   https://www.smarty.net/docs/en/language.modifier.cat.php cat
 *           (Smarty online manual)
 * @author Uwe Tews
 *
@@ -11,8 +11,8 @@
 * Name:     count_characters
 * Purpose:  count the number of characters in a text
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.count.characters.php count_characters (Smarty online
- *         manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.count.characters.php count_characters
+ *           (Smarty online manual)
 * @author Uwe Tews
 *
 * @param array $params parameters
@@ -11,7 +11,7 @@
 * Name:     count_paragraphs
 * Purpose:  count the number of paragraphs in a text
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.count.paragraphs.php
+ * @link   https://www.smarty.net/docs/en/language.modifier.count.paragraphs.php
 *          count_paragraphs (Smarty online manual)
 * @author Uwe Tews
 *
@@ -11,7 +11,7 @@
 * Name:     count_sentences
 * Purpose:  count the number of sentences in a text
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.count.paragraphs.php
+ * @link   https://www.smarty.net/docs/en/language.modifier.count.paragraphs.php
 *          count_sentences (Smarty online manual)
 * @author Uwe Tews
 *
@@ -11,7 +11,8 @@
 * Name:     count_words
 * Purpose:  count the number of words in a text
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.count.words.php count_words (Smarty online manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.count.words.php count_words
+ *           (Smarty online manual)
 * @author Uwe Tews
 *
 * @param array $params parameters
@@ -11,7 +11,8 @@
 * Name:     default
 * Purpose:  designate default value for empty variables
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.default.php default (Smarty online manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.default default
+ *           (Smarty online manual)
 * @author Uwe Tews
 *
 * @param array $params parameters
@@ -11,19 +11,18 @@
 * Name:     escape
 * Purpose:  escape string for output
 *
- * @link   https://www.smarty.net/docsv2/en/language.modifier.escape count_characters (Smarty online manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.escape count_characters
+ *         (Smarty online manual)
 * @author Rodney Rehm
 *
 * @param array                                $params parameters
 * @param Smarty_Internal_TemplateCompilerBase $compiler
 *
 * @return string with compiled code
- * @throws \SmartyException
+ * @throws SmartyException
 */
 function smarty_modifiercompiler_escape($params, Smarty_Internal_TemplateCompilerBase $compiler)
 {
-    static $_double_encode = true;
-    static $is_loaded = false;
    $compiler->template->_checkPlugins(
        array(
            array(
@@ -41,53 +40,28 @@ function smarty_modifiercompiler_escape($params, Smarty_Internal_TemplateCompile
        }
        switch ($esc_type) {
            case 'html':
-                if ($_double_encode) {
-                    return 'htmlspecialchars(' . $params[ 0 ] . ', ENT_QUOTES, ' . var_export($char_set, true) . ', ' .
-                           var_export($double_encode, true) . ')';
-                } elseif ($double_encode) {
-                    return 'htmlspecialchars(' . $params[ 0 ] . ', ENT_QUOTES, ' . var_export($char_set, true) . ')';
-                } else {
-                    // fall back to modifier.escape.php
-                }
-            // no break
+                return 'htmlspecialchars((string)' . $params[ 0 ] . ', ENT_QUOTES, ' . var_export($char_set, true) . ', ' .
+                    var_export($double_encode, true) . ')';
            case 'htmlall':
                if (Smarty::$_MBSTRING) {
-                    if ($_double_encode) {
-                        // php >=5.2.3 - go native
-                        return 'mb_convert_encoding(htmlspecialchars(' . $params[ 0 ] . ', ENT_QUOTES, ' .
-                               var_export($char_set, true) . ', ' . var_export($double_encode, true) .
-                               '), "HTML-ENTITIES", ' . var_export($char_set, true) . ')';
-                    } elseif ($double_encode) {
-                        // php <5.2.3 - only handle double encoding
-                        return 'mb_convert_encoding(htmlspecialchars(' . $params[ 0 ] . ', ENT_QUOTES, ' .
-                               var_export($char_set, true) . '), "HTML-ENTITIES", ' . var_export($char_set, true) . ')';
-                    } else {
-                        // fall back to modifier.escape.php
-                    }
+                    return 'htmlentities(mb_convert_encoding((string)' . $params[ 0 ] . ', \'UTF-8\', ' .
+                        var_export($char_set, true) . '), ENT_QUOTES, \'UTF-8\', ' .
+                        var_export($double_encode, true) . ')';
                }
                // no MBString fallback
-                if ($_double_encode) {
-                    // php >=5.2.3 - go native
-                    return 'htmlentities(' . $params[ 0 ] . ', ENT_QUOTES, ' . var_export($char_set, true) . ', ' .
-                           var_export($double_encode, true) . ')';
-                } elseif ($double_encode) {
-                    // php <5.2.3 - only handle double encoding
-                    return 'htmlentities(' . $params[ 0 ] . ', ENT_QUOTES, ' . var_export($char_set, true) . ')';
-                } else {
-                    // fall back to modifier.escape.php
-                }
-            // no break
+                return 'htmlentities((string)' . $params[ 0 ] . ', ENT_QUOTES, ' . var_export($char_set, true) . ', ' .
+                    var_export($double_encode, true) . ')';
            case 'url':
-                return 'rawurlencode(' . $params[ 0 ] . ')';
+                return 'rawurlencode((string)' . $params[ 0 ] . ')';
            case 'urlpathinfo':
-                return 'str_replace("%2F", "/", rawurlencode(' . $params[ 0 ] . '))';
+                return 'str_replace("%2F", "/", rawurlencode((string)' . $params[ 0 ] . '))';
            case 'quotes':
                // escape unescaped single quotes
-                return 'preg_replace("%(?<!\\\\\\\\)\'%", "\\\'",' . $params[ 0 ] . ')';
+                return 'preg_replace("%(?<!\\\\\\\\)\'%", "\\\'", (string)' . $params[ 0 ] . ')';
            case 'javascript':
                // escape quotes and backslashes, newlines, etc.
                // see https://html.spec.whatwg.org/multipage/scripting.html#restrictions-for-contents-of-script-elements
-                return 'strtr(' .
+                return 'strtr((string)' .
                       $params[ 0 ] .
                       ', array("\\\\" => "\\\\\\\\", "\'" => "\\\\\'", "\"" => "\\\\\"", "\\r" => "\\\\r", "\\n" => "\\\n", "</" => "<\/", "<!--" => "<\!--", "<s" => "<\s", "<S" => "<\S" ))';
        }
@@ -11,7 +11,8 @@
 * Name:     indent
 * Purpose:  indent lines of text
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.indent.php indent (Smarty online manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.indent.php indent
+ *           (Smarty online manual)
 * @author Uwe Tews
 *
 * @param array $params parameters
@@ -11,7 +11,8 @@
 * Name:     lower
 * Purpose:  convert string to lowercase
 *
- * @link   https://www.smarty.net/manual/en/language.modifier.lower.php lower (Smarty online manual)
+ * @link   https://www.smarty.net/docs/en/language.modifier.lower.php lower
+ *           (Smarty online manual)
 * @author Monte Ohrt <monte at ohrt dot com>
 * @author Uwe Tews
 *
@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * Smarty plugin
+ *
+ * @package    Smarty
+ * @subpackage PluginsModifierCompiler
+ */
+/**
+ * Smarty nl2br modifier plugin
+ * Type:     modifier
+ * Name:     nl2br
+ * Purpose:  insert HTML line breaks before all newlines in a string
+ *
+ * @link   https://www.smarty.net/docs/en/language.modifier.nl2br.tpl nl2br (Smarty online manual)
+  *
+ * @param array $params parameters
+ *
+ * @return string with compiled code
+ */
+function smarty_modifiercompiler_nl2br($params) {
+    return 'nl2br((string) ' . $params[0] . ', (bool) ' . ($params[1] ?? true) . ')';
+}
@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * Smarty plugin
+ *
+ * @package    Smarty
+ * @subpackage PluginsModifierCompiler
+ */
+/**
+ * Smarty round modifier plugin
+ * Type:     modifier
+ * Name:     round
+ * Purpose:  Returns the rounded value of num to specified precision (number of digits after the decimal point)
+ *
+ * @link   https://www.smarty.net/docs/en/language.modifier.round.tpl round (Smarty online manual)
+  *
+ * @param array $params parameters
+ *
+ * @return string with compiled code
+ */
+function smarty_modifiercompiler_round($params) {
+    return 'round((float) ' . $params[0] . ', (int) ' . ($params[1] ?? 0) . ', (int) ' . ($params[2] ?? PHP_ROUND_HALF_UP) . ')';
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Simon Wisselink	3251b1c32d	Merge branch 'master' into 420upd	2022-11-22 21:31:35 +01:00
Progi1984	c016895166	PHP8.2 compatibility (#775 ) * PHP8.2 compatibility * PHP8.2 compatibility : Fixed unit tests * PHP8.2 compatibility : Replace ENT_COMPAT by ENT_QUOTES \| ENT_SUBSTITUTE \| ENT_HTML401 * PHP8.2 compatibility : Remove deprecated utf8_decode * PHP8.2 compatibility : Remove HTML-ENTITIES parameter * Removed some unused code for clarity, updated the changelog. * More concise escape implementation and unit test to cover both modifierplugin and modifiercompiler. * Fix htmlall unescape of quotes without mbstring too Co-authored-by: Simon Wisselink <s.wisselink@iwink.nl>	2022-11-22 21:22:57 +01:00
Andrew Dawes	f81720941c	Fixed several typos and grammar errors (#821 )	2022-10-22 22:08:38 +02:00
Ian	e6ee257ca2	Merge branch 'master' into 420upd	2022-09-29 09:24:42 +02:00
Simon Wisselink	1ff79c6c38	Update changelog Closes #816	2022-09-27 12:24:08 +02:00
Simon Wisselink	254b5cabee	Dropped remaining references to removed PHP-support in Smarty 4 from docs, lexer and security class.	2022-09-27 12:21:01 +02:00
Raimondas Rimkevičius	1b556c7077	Use __DIR__ instead of dirname(__FILE__) (#817 )	2022-09-27 12:03:34 +02:00
Simon Wisselink	4550fc0339	Using PHP functions as modifiers now triggers a deprecation notice (#814 ) Fixes #813	2022-09-23 00:09:00 +02:00
Scott Newton	4fc39d59a5	Bug fix for underscore in template name (#581 ) * Corrected bug #578, where underscore characters were being stripped from template names when using a custom resource * Increased the maximum template name length to 127 characters when using a custom resource	2022-09-22 23:56:18 +02:00
Alec Smecher	0fb29024e7	#155 Adapt Smarty upper/lower functions to be codesafe (e.g. for Turkish locale) (#586 ) * Implemented locale safe strotoupper, strolower and ucfirst functions for translating user string to filenames etc. Fixes #155 Co-Authored-By: Alexkurd <7689609+Alexkurd@users.noreply.github.com>	2022-09-22 23:32:55 +02:00
Simon Wisselink	612bd3f657	Fixed PHP8.1 deprecation errors in strip_tags (#803 )	2022-09-22 14:55:20 +02:00
Simon Wisselink	9eea30ec1e	Removed now superfluous phpunit.sh	2022-09-22 14:44:45 +02:00
Simon Wisselink	ea95e8b047	Re-organize all testrunners to use the same script(s). (#812 )	2022-09-22 14:31:49 +02:00
Simon Wisselink	474138fd7e	Updated changelog	2022-09-22 14:31:01 +02:00
Mathias	b91c04bfcf	Fixed PHP8.1 deprecation errors passing null to parameter in trim (#807 ) Fixed a PHP 8.1 deprecation error: trim(): Passing null to parameter #1 ($string) of type string is deprecated in cacheresource_keyvaluestore.php on line 247 and in cacheresource_keyvaluestore.php on line 431	2022-09-22 14:29:51 +02:00
Simon Wisselink	c53342c9fc	Silence deprecation errors for strtime in PHP8.1 or higher Fixes #672 (#811)	2022-09-22 14:11:36 +02:00
Simon Wisselink	f8a958cd53	Update changelog	2022-09-21 21:56:39 +02:00
Jonathan Stoll	45345e75ec	Fix Variable Usage (#808 ) Fix Variable Usage in Exception message when unable to load subtemplate	2022-09-21 21:54:41 +02:00
Simon Wisselink	bf7d6b8bd8	Include docs en demo in the releases. Fixes #799	2022-09-20 22:45:16 +02:00
Simon Wisselink	32a11b34ea	Added changelog	2022-09-18 17:18:32 +02:00
Storyxx	db80246b58	fix compilation for caching templates (#801 )	2022-09-18 17:15:56 +02:00
Hypolite Petovan	d683641f90	Fix wrong indentation in libs/plugins/modifier.capitalize.php (#802 )	2022-09-18 11:14:59 +02:00
Ian	0d4939e135	Improve issue with certain ?? ternary in `159ed4ee02` for smarty class magic __get() method.	2022-09-15 12:15:37 +02:00
Simon Wisselink	e2e68b3622	clean output buffer for Throwable instead of just Exception (#797 ) Fixes #514	2022-09-14 13:47:36 +02:00
Simon Wisselink	ffa2b81a8e	Merge branch 'release/4.2.1'	2022-09-14 12:59:01 +02:00
Simon Wisselink	c693d81370	version bump	2022-09-14 12:58:59 +02:00
Simon Wisselink	813c83f7a3	Fixed unselected year/month/day not working in html_select_date Fixes #395	2022-09-14 12:44:37 +02:00
Simon Wisselink	55ea25d1f5	Applied appropriate javascript and html escaping in mailto plugin to counter injection attacks Fixes #454	2022-09-14 11:38:18 +02:00
Simon Wisselink	d304d349b4	Fixed PHP8.1 deprecation errors in capitalize modifier Fixes #789	2022-09-13 12:19:44 +02:00
Simon Wisselink	7494818434	prevent double CI workflows in PRs	2022-09-12 16:02:42 +02:00
Simon Wisselink	50d5890eac	Exclude unit test files from git export	2022-09-12 15:52:32 +02:00
Simon Wisselink	6872e78238	Utility script for running unit tests on all PHP versions locally	2022-09-12 15:50:09 +02:00
Simon Wisselink	5479e3362c	Fixed use of `rand()` without a parameter in math function (#795 ) * Fixed use of `rand()` without a parameter in math function Fixes #794	2022-09-12 12:13:42 +02:00
Simon Wisselink	f8f97b4e2d	Fixed PHP8.1 deprecation errors in upper modifier #788	2022-09-10 12:34:20 +02:00
Mark Fettig	1bc7c722a3	address PHP 8.1 'explode', 'number_format', and 'replace' deprecations (#755 )	2022-09-09 22:39:24 +02:00
Simon Wisselink	02968a82b5	Update SECURITY.md Removed comment that still indicated v4 wasn’t released yet.	2022-08-16 22:43:47 +02:00
Ian	fc06d246bf	Temporary fix strftime deprecation notes up from PHP 8.1+ Convert to DateTime Interface with intl before PHP 9.	2022-08-10 12:23:39 +02:00
Ian	292ad986cd	plugins: Extend b1f59d19b644774dfd1e4282c190a5e72915ac95	2022-08-10 11:39:42 +02:00
Ian	d024c3df4c	Fix end_template/end_render debug condition to check for set start time with PHP 8.1+	2022-08-10 11:38:36 +02:00
Ian	f98ba948c4	Remove space line for consistency	2022-08-10 11:38:22 +02:00
Ian	7468378e3b	plugins: math fix array item indents for readability	2022-08-10 11:37:54 +02:00
Ian	de1f382f0b	Fixup `dff1955cd5` debug template	2022-08-10 11:37:24 +02:00
Ian	a85296ab94	Remove line for consistency	2022-08-10 11:37:05 +02:00
Ian	40f40e549d	plugins: modifier.escape fix typo	2022-08-10 11:36:35 +02:00
Ian	64e50e00c9	plugins: shared.mb_str_replace add a space line	2022-08-10 11:36:18 +02:00
Ian	159ed4ee02	Use PHP 7 Null Coalescing Operator (??)	2022-08-10 11:36:02 +02:00
Ian	7f579fdc69	plugins: mailto fix tabs to spaces	2022-08-10 11:35:35 +02:00
Ian	c26151da1d	plugins: Update doc header link to current smarty docs	2022-08-10 11:35:14 +02:00
Ian	078e2dbc1b	plugins: Fix a SmartyException typo	2022-08-10 11:34:57 +02:00
Ian	36d157180a	autoloader: Remove registerBC method in follow of Smarty 4 cleanup	2022-08-10 11:34:31 +02:00
Ian	eec791d943	plugins: complete modifier escacpe and modifiercompiler escape for Smarty 5 PHP cleanup	2022-08-10 11:34:08 +02:00
Simon Wisselink	97aeb14c6f	Merge branch 'release/4.2.0'	2022-08-01 23:57:38 +02:00
Simon Wisselink	ed454551a3	version bump	2022-08-01 23:57:36 +02:00
Simon Wisselink	f4b26a3cbf	Fixed second param of unescape modifier (#778 ) Fixes #777	2022-08-01 23:49:19 +02:00
Simon Wisselink	20a8026ccd	Merge branch 'fix-issue-549-v3' of github.com:AnrDaemon/smarty into AnrDaemon-fix-issue-549-v3 (#771 )	2022-07-19 22:55:07 +02:00
Simon Wisselink	27910bf2c1	git push origin masterMerge branch 'JonisoftGermany-master'	2022-07-17 00:54:29 +02:00
Simon Wisselink	cb95216671	Changelog	2022-07-17 00:54:20 +02:00
Simon Wisselink	d6ac3297df	Merge branch 'master' of github.com:JonisoftGermany/smarty into JonisoftGermany-master	2022-07-17 00:53:25 +02:00
Simon Wisselink	560475a2f2	Do not use obsolete smarty properties '_dir_perms', '_file_perms', 'plugin_search_order' in our own code. (#772 )	2022-07-17 00:13:57 +02:00
Gunnar Kreitz	382d66305d	Fix PHP 8.1 htmlspecialchars deprecation (#766 )	2022-07-14 23:51:26 +02:00
Simon Wisselink	44bac8d58c	add local testrunners for all supported PHP versions using docker. (#770 )	2022-07-14 23:50:22 +02:00
Simon Wisselink	f8e1ba76f7	Replaced outdated references to SMARTY_RESOURCE_CHAR_SET in docs with Smarty::$_CHARSET.	2022-06-15 22:12:38 +02:00
Simon Wisselink	629504485f	Add CVE to changelog	2022-05-17 14:58:05 +02:00
Simon Wisselink	71036be8be	Merge branch 'release/4.1.1'	2022-05-17 14:56:28 +02:00
Simon Wisselink	78f0cf5f65	version bump	2022-05-17 14:56:26 +02:00
Simon Wisselink	64ad6442ca	Merge branch 'security/blockfunctioninjection'	2022-05-17 14:55:47 +02:00
Simon Wisselink	7eff7d6fb0	Changelog	2022-05-16 13:31:15 +02:00
Simon Wisselink	05f1a7deda	Replace '/' in user supplied input in C-style comments with ' /'.	2022-05-16 12:34:49 +02:00
Simon Wisselink	3f97b7352e	Changelog	2022-04-26 22:11:59 +02:00
Simon Wisselink	a6711b3833	Merge pull request #727 from liborm85/escape-modifier-fix PHP 8.1: fix deprecation in escape modifier	2022-04-26 22:11:33 +02:00
Simon Wisselink	52056ce65a	Changelog	2022-04-26 22:09:50 +02:00
Simon Wisselink	8b96efad45	Merge pull request #743 from xorti/fix-php81-rtrim-calls Fix PHP 8.1 deprecated warning when calling rtrim	2022-04-26 22:09:10 +02:00
Simon Wisselink	bfa02f3b91	Merge branch 'patch-1'	2022-04-26 22:06:29 +02:00
Simon Wisselink	89dc506638	Add changelog	2022-04-26 22:05:34 +02:00
Stephen Sigwart	e68065bc33	Exclude demo from export and composer	2022-04-01 22:48:14 -04:00
Stephen Sigwart	db2547287c	Exclude docs from export and composer	2022-04-01 22:46:50 -04:00
Jorge Sá Pereira	962f266483	Fix PHP 8.1 deprecated warning when calling rtrim Fixes - Deprecated: rtrim(): Passing null to parameter #1 ($string) of type string is deprecated	2022-03-10 02:06:00 +00:00
Simon Wisselink	8aeb5d6821	Merge pull request #726 from pH-7/patch-1 gitattributes: Ignore `.github` folder for distribution	2022-02-13 22:34:29 +01:00
Libor M	a2e1df1768	PHP 8.1: fix deprecation in escape modifier	2022-02-08 13:30:19 +01:00
♚ PH⑦ de Soria™♛	fe6d333c60	Ignore `.github` folder for distribution `.github` wasn't added here was it got created. However, we don't want `.github` for the distribution builds. Further info about this: https://www.pixelite.co.nz/article/using-git-attributes-exclude-files-your-release/	2022-02-08 06:32:27 +10:30
Simon Wisselink	50c4604857	Added issue 721 to changelog	2022-02-07 09:43:49 +01:00
Simon Wisselink	e5a6ff42f8	Merge pull request #725 from smarty-php/bugfix/699 prevent float to int cast deprecation warning in truncate modifier	2022-02-06 22:25:34 +01:00
Simon Wisselink	3cc56392c6	prevent float to int cast deprecation warning in truncate modifier Fixes #699	2022-02-06 22:20:05 +01:00
Simon Wisselink	17025423e1	Merge pull request #724 from smarty-php/bugfix/706 Fix PHP 8.1 deprecation notices in demo/plugins/cacheresource.pdo.php	2022-02-06 22:09:39 +01:00
Simon Wisselink	18d3e564da	Merge branch 'master' into bugfix/706	2022-02-06 22:05:01 +01:00
Simon Wisselink	0d2c38b482	fix PHP 8.1 deprecation notices in demo/plugins/cacheresource.pdo.php Fixes #706	2022-02-06 22:03:24 +01:00
Simon Wisselink	f90348971b	Merge pull request #722 from kochichi/bugfix/721 math equation return warning: max(x, y)	2022-02-06 21:54:54 +01:00
Simon Wisselink	9e0536de18	Merge branch 'release/4.1.0'	2022-02-06 21:34:27 +01:00
Simon Wisselink	265cf4f3bc	version bump	2022-02-06 21:34:26 +01:00
Simon Wisselink	47f95ad324	Merge pull request #717 from vemaeg/php81-doc Updating PHP 8.0 to 8.1 in the docs and add php8.1 test runner.	2022-02-06 21:30:52 +01:00
Pavel Kochman	02633ecaba	math equation return warning: math: illegal character for : {math equation="max(x, y)" x=$x y=$y}	2022-02-04 21:03:25 +01:00
Thomas A. Hirsch	6786623afb	Activating jit compiler for ubuntu-latest + php 8.1	2022-01-21 17:58:35 +01:00
Thomas	2d97169086	Merge branch 'smarty-php:master' into php81-doc	2022-01-21 17:57:27 +01:00
Thomas	0f098802c6	Create getting-started.md	2022-01-21 17:55:23 +01:00
Thomas	bbcd5817f6	Update README.md	2022-01-21 17:51:45 +01:00
Simon Wisselink	612094d763	Updated changelog	2022-01-21 10:21:00 +01:00
Simon Wisselink	0ef0dda825	Merge pull request #713 from vemaeg/php81 PHP 8.1 compatibility (without IntlDateFormatter)	2022-01-21 10:18:48 +01:00
Thomas BACCELLI	cef8951100	Add PHP 8.1 tests	2022-01-18 15:56:23 +01:00
Thomas BACCELLI	323aefa89f	Fix phpunit warning	2022-01-18 15:56:23 +01:00
Thomas A. Hirsch	277648b81c	Cherry-picked from `da76d927ed` Co-Authored-By: Thomas BACCELLI <tbaccelli@gmail.com>	2022-01-18 15:56:23 +01:00
Thomas A. Hirsch	8d3a7af308	Cherry-picked from `da76d927ed` Co-Authored-By: Thomas BACCELLI <tbaccelli@gmail.com>	2022-01-18 15:56:23 +01:00
Simon Wisselink	cdf0f2b164	Merge branch 'release/4.0.4'	2022-01-18 00:17:19 +01:00
Simon Wisselink	995b7eb36f	version bump	2022-01-18 00:17:17 +01:00
Claas Augner	059bea274c	Support multiple operators in math equations (#708 ) * fix(math): fix equation regexp Fixes #702.	2022-01-18 00:10:17 +01:00
Simon Wisselink	f707dadecb	Merge branch 'release/4.0.3'	2022-01-10 10:52:14 +01:00
Simon Wisselink	ace1c8e90f	version bump	2022-01-10 10:52:13 +01:00
Simon Wisselink	19ae410bf5	Merge pull request from GHSA-4h9c-v5vg-5m6m * Prevent evasion of the static_classes security policy. * Updated deprecated exception expectations.	2022-01-10 10:48:27 +01:00
Simon Wisselink	baad3115cd	Fixed PHPUnit expected Exceptions. (#701 )	2022-01-10 09:46:01 +01:00
Simon Wisselink	6f4f06db7e	Merge branch 'release/4.0.2'	2022-01-10 00:09:08 +01:00
Simon Wisselink	a535445dfd	version bump	2022-01-10 00:09:06 +01:00
Simon Wisselink	215d81a9fa	Merge pull request from GHSA-29gp-2c3m-3j6m * Temporary fix. Waiting for CVE * Add CVE	2022-01-10 00:01:43 +01:00
Simon Wisselink	efb416e5ef	Fixed unit tests	2022-01-09 23:29:43 +01:00
Simon Wisselink	29c0e5ac51	Merge branch 'release/4.0.1'	2022-01-09 23:20:45 +01:00
Simon Wisselink	23be620fc8	version bump	2022-01-09 23:20:44 +01:00
Simon Wisselink	e6ab34654b	Merge remote-tracking branch 'origin/master'	2022-01-09 23:15:44 +01:00
Simon Wisselink	c7576eb1a1	Rewrote the mailto function to not use `eval` when encoding with javascript	2022-01-09 23:15:25 +01:00
Marc Laporte	56aadc697f	Fix a typo in docs (#690 )	2021-12-22 23:01:19 +01:00
Darek Krzysztofiak	cd962280ce	Fix for php 8.0 (#687 ) * Fix PHP 8.0 $parts must be an array, because the argument for count() must be countable, mb_split() returns an array or a boolean.	2021-12-03 17:13:52 +01:00
Simon Wisselink	cb5efd04c3	Improve the documentation, bringing it up to date with PHP7/8 and Smarty 4 and providing a more logical introduction and getting started experience.	2021-12-03 16:51:08 +01:00
Simon Wisselink	3a91df797e	added links to appndixes, removed unuseful old appendixes	2021-12-03 12:18:46 +01:00
Simon Wisselink	6983788dfb	Merge branch 'master' of github.com:smarty-php/smarty	2021-12-03 12:15:04 +01:00
Simon Wisselink	09875a61f4	changed homepage links in composer.json	2021-12-03 12:04:13 +01:00
Simon Wisselink	428a701b18	Feature/add docs (#689 ) * Add converted docs repo * Set theme jekyll-theme-minimal * Removed BC docs, added TOC * Added TOCs, rewrote most important links in documentation. Linked README to new Github Pages site * some link fixes	2021-12-03 11:59:22 +01:00
Stoll, Jonathan	dff1955cd5	Update to HTML5-syntax in debug template * Replace deprecated tags * Use CSS3 selectors * Update html-frame * Remove deprecated syntax * Harmonize syntax in general	2020-06-19 21:20:46 +02:00