Cena: {$price|money}
+ +{if isWeekend($now)} ... {/if} +``` + +Pro složitější logiku můžete konfigurovat přímo objekt `Latte\Engine`: + +```php +protected function beforeRender(): void +{ $latte = $this->template->getLatte(); - $latte->addFilterLoader(/* ... */); + $latte->setFeature(Latte\Feature::MigrationWarnings); +} +``` + +**Pomocí atributů** + +Elegantní způsob je definovat filtry a funkce jako metody přímo ve [třídě parametrů šablony|#Typově bezpečné šablony] presenteru nebo komponenty a označit je atributy: + +```php +class ArticleTemplate extends Nette\Bridges\ApplicationLatte\Template +{ + #[Latte\Attributes\TemplateFilter] + public function money(float $val): string + { + return round($val) . ' Kč'; + } + + #[Latte\Attributes\TemplateFunction] + public function isWeekend(DateTimeInterface $date): bool + { + return $date->format('N') >= 6; + } } ``` -Latte ve verzi 3 nabízí pokročilejší způsob a to vytvoření si [extension |latte:extending-latte#Latte Extension] pro každý webový projekt. Kusý příklad takové třídy: +Latte automaticky rozpozná a zaregistruje metody označené těmito atributy. Název filtru nebo funkce v šabloně odpovídá názvu metody. Tyto metody nesmí být privátní. + +**Globálně pomocí Extension** + +Předchozí způsoby jsou vhodné pro filtry a funkce, které potřebujete jen v konkrétním presenteru nebo komponentě, nikoliv v celé aplikaci. Pro celou aplikaci je nejvhodnější vytvořit si [extension |latte:extending-latte#Latte Extension]. Jde o třídu, která centralizuje všechna rozšíření Latte pro celý projekt. Kusý příklad: ```php namespace App\Presentation\Accessory; @@ -251,11 +315,16 @@ final class LatteExtension extends Latte\Extension ]; } + private function filterTimeAgoInWords(DateTimeInterface $time): string + { + // ... + } + // ... } ``` -Zaregistrujeme ji pomocí [konfigurace |configuration#Šablony Latte]: +Extension zaregistrujeme pomocí [konfigurace |configuration#Šablony Latte]: ```neon latte: @@ -263,6 +332,8 @@ latte: - App\Presentation\Accessory\LatteExtension ``` +Výhodou extension je, že lze využít dependency injection, mít přístup k modelové vrstvě aplikace a všechna rozšíření mít přehledně na jednom místě. Extension umožnuje definovat i vlastní značky, providery, průchody pro Latte kompilátor a další. + Překládání ---------- diff --git a/application/de/routing.texy b/application/de/routing.texy index 251247119d..ff2f7378e0 100644 --- a/application/de/routing.texy +++ b/application/de/routing.texy @@ -314,7 +314,7 @@ use Nette\Routing\Route; $router->addRoute('Price: {$price|money}
+ +{if isWeekend($now)} ... {/if} +``` + +For more complex logic, you can configure the `Latte\Engine` object directly: + +```php +protected function beforeRender(): void +{ $latte = $this->template->getLatte(); - $latte->addFilterLoader(/* ... */); + $latte->setFeature(Latte\Feature::MigrationWarnings); +} +``` + +**Using Attributes** + +A more elegant approach is defining filters and functions as methods directly in the presenter or component's [template parameter class|#Type-safe templates], marked with attributes: + +```php +class ArticleTemplate extends Nette\Bridges\ApplicationLatte\Template +{ + #[Latte\Attributes\TemplateFilter] + public function money(float $val): string + { + return '$' . number_format($val, 2); + } + + #[Latte\Attributes\TemplateFunction] + public function isWeekend(DateTimeInterface $date): bool + { + return $date->format('N') >= 6; + } } ``` -Latte version 3 offers a more advanced way by creating an [extension |latte:extending-latte#Latte Extension] for each web project. Here is a brief example of such a class: +Latte automatically discovers and registers methods marked with these attributes. The filter or function name in templates matches the method name. These methods must not be private. + +**Globally Using Extensions** + +The previous approaches suit filters and functions needed only in specific presenters or components, not application-wide. For the entire application, creating an [extension |latte:extending-latte#Latte Extension] works best. This class centralizes all Latte extensions for your project. A brief example: ```php namespace App\Presentation\Accessory; @@ -251,11 +315,16 @@ final class LatteExtension extends Latte\Extension ]; } + private function filterTimeAgoInWords(DateTimeInterface $time): string + { + // ... + } + // ... } ``` -We register it using [configuration |configuration#Latte Templates]: +Register the extension through [configuration |configuration#Latte Templates]: ```neon latte: @@ -263,6 +332,8 @@ latte: - App\Presentation\Accessory\LatteExtension ``` +Extensions offer several advantages: dependency injection support, access to your application's model layer, and centralized management of all extensions. They also support custom tags, providers, compiler passes, and more. + Translating ----------- diff --git a/application/es/routing.texy b/application/es/routing.texy index 829edb3c7d..d906f83f48 100644 --- a/application/es/routing.texy +++ b/application/es/routing.texy @@ -314,7 +314,7 @@ use Nette\Routing\Route; $router->addRoute('Резултати от търсенето за ' . $search . 'alert("Hacked!")`. Тъй като изходът не е обработен по никакъв начин, той става част от показаната страница: -```html +```latte
Резултати от търсенето за
``` @@ -59,7 +59,7 @@ echo '
```
@@ -91,7 +91,7 @@ echo '#текст
```
@@ -330,7 +330,7 @@ Latte вижда шаблона по същия начин като вас. Ра
Latte вижда шаблона по същия начин като вас. За разлика от Twig, разбира HTML и знае, че променливата се извежда като стойност на атрибут, който не е в кавички. Затова ги допълва. Когато нападателят вмъкне същото описание, резултатният код ще изглежда така:
-```html
+```latte
```
diff --git a/latte/bg/type-system.texy b/latte/bg/type-system.texy
index 8f052cf074..aa1be010a5 100644
--- a/latte/bg/type-system.texy
+++ b/latte/bg/type-system.texy
@@ -21,7 +21,7 @@
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-След това в началото на шаблона поставете тага `{templateType}` с пълното име на класа (включително namespace). Това дефинира, че в шаблона има променливи `$langs` и `$products`, включително съответните типове. Типовете на локалните променливи можете да посочите с помощта на таговете [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Дефиниции].
+След това в началото на шаблона поставете тага `{templateType}` с пълното име на класа (включително namespace). Това дефинира, че в шаблона има променливи `$lang` и `$products`, включително съответните типове. Типовете на локалните променливи можете да посочите с помощта на таговете [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Дефиниции].
От този момент IDE може да ви подсказва правилно.
diff --git a/latte/cs/@left-menu.texy b/latte/cs/@left-menu.texy
index 31a85bcaf7..4556b26913 100644
--- a/latte/cs/@left-menu.texy
+++ b/latte/cs/@left-menu.texy
@@ -5,6 +5,7 @@
- [Dědičnost šablon |Template Inheritance]
- [Typový systém |type-system]
- [Sandbox]
+ - [HTML attributy |html-attributes]
- Pro designéry 🎨
- [Syntaxe |syntax]
diff --git a/latte/cs/cookbook/@home.texy b/latte/cs/cookbook/@home.texy
index b4d54b0b7e..b6af15e673 100644
--- a/latte/cs/cookbook/@home.texy
+++ b/latte/cs/cookbook/@home.texy
@@ -8,6 +8,7 @@ Příklady kódů a receptů pro provádění běžných úkolů pomocí Latte.
- [Předávání proměnných napříč šablonami |passing-variables]
- [Všechno, co jste kdy chtěli vědět o seskupování |grouping]
- [Jak psát SQL queries v Latte? |how-to-write-sql-queries-in-latte]
+- [Migrace z Latte 3.0 |migration-from-latte-30]
- [Migrace z Latte 2 |migration-from-latte2]
- [Migrace z PHP |migration-from-php]
- [Migrace z Twigu |migration-from-twig]
diff --git a/latte/cs/cookbook/migration-from-latte-30.texy b/latte/cs/cookbook/migration-from-latte-30.texy
new file mode 100644
index 0000000000..03211a226d
--- /dev/null
+++ b/latte/cs/cookbook/migration-from-latte-30.texy
@@ -0,0 +1,109 @@
+Migrace z Latte 3.0
+*******************
+
+.[perex]
+Latte 3.1 přináší několik vylepšení a změn, díky kterým je psaní šablon bezpečnější a pohodlnější. Většina změn je zpětně kompatibilní, ale některé vyžadují pozornost při přechodu. Tento průvodce shrnuje BC breaky a jak je řešit.
+
+Latte 3.1 vyžaduje **PHP 8.2** nebo novější.
+
+
+Chytré atributy a migrace
+=========================
+
+Nejvýznamnější změnou v Latte 3.1 je nové chování [chytrých atributů |/html-attributes]. To ovlivňuje, jak se vykreslují hodnoty `null` a logické hodnoty v `data-` atributech.
+
+1. **Hodnoty `null`:** Dříve se `title={$null}` vykresloval jako `title=""`. Nyní se atribut zcela vynechá.
+2. **`data-` atributy:** Dříve se `data-foo={=true}` / `data-foo={=false}` vykreslovaly jako `data-foo="1"` / `data-foo=""`. Nyní se vykreslují jako `data-foo="true"` / `data-foo="false"`.
+
+Abychom vám pomohli identifikovat místa, kde se výstup ve vaší aplikaci změnil, Latte poskytuje migrační nástroj.
+
+
+Migrační varování
+-----------------
+
+Můžete zapnout [migrační varování |/develop#Migrační varování], která vás během vykreslování upozorní, pokud se výstup liší od Latte 3.0.
+
+```php
+$latte = new Latte\Engine;
+$latte->setFeature(Latte\Feature::MigrationWarnings);
+```
+
+Pokud jsou povolena, sledujte logy aplikace nebo Tracy bar pro `E_USER_WARNING`. Každé varování bude ukazovat na konkrétní řádek a sloupec v šabloně.
+
+**Jak varování vyřešit:**
+
+Pokud je nové chování správné (např. chcete, aby prázdný atribut zmizel), potvrďte jej použitím filtru `|accept` pro potlačení varování:
+
+```latte
+
+```
+
+Pokud chcete atribut zachovat jako prázdný (např. `title=""`) místo jeho vynechání, použijte null coalescing operátor:
+
+```latte
+
+```
+
+Nebo, pokud striktně vyžadujete staré chování (např. `"1"` pro `true`), explicitně přetypujte hodnotu na string:
+
+```latte
+
+```
+
+**Poté, co vyřešíte všechna varování:**
+
+Jakmile vyřešíte všechna varování, vypněte migrační varování a **odstraňte všechny** filtry `|accept` ze svých šablon, protože již nejsou potřeba.
+
+
+Strict Types
+============
+
+Latte 3.1 zapíná `declare(strict_types=1)` ve výchozím nastavení pro všechny kompilované šablony. To zlepšuje typovou bezpečnost, ale může způsobit typové chyby v PHP výrazech uvnitř šablon, pokud jste spoléhali na volné typování.
+
+Pokud typy nemůžete opravit okamžitě, můžete toto chování vypnout:
+
+```php
+$latte->setFeature(Latte\Feature::StrictTypes, false);
+```
+
+
+Globální konstanty
+==================
+
+Parser šablon byl vylepšen, aby lépe rozlišoval mezi jednoduchými řetězci a konstantami. V důsledku toho musí být globální konstanty nyní prefixovány zpětným lomítkem `\`.
+
+```latte
+{* Starý způsob (vyhodí varování, v budoucnu bude interpretováno jako string 'PHP_VERSION') *}
+{if PHP_VERSION > ...}
+
+{* Nový způsob (správně interpretováno jako konstanta) *}
+{if \PHP_VERSION > ...}
+```
+
+Tato změna předchází nejednoznačnostem a umožňuje volnější používání neuvodzovkovaných řetězců.
+
+
+Odstraněné funkce
+=================
+
+**Rezervované proměnné:** Proměnné začínající na `$__` (dvou podtržítko) a proměnná `$this` jsou nyní vyhrazeny pro vnitřní použití Latte. Nemůžete je používat v šablonách.
+
+**Undefined-safe operátor:** Operátor `??->`, což byla specifická funkce Latte vytvořená před PHP 8, byl odstraněn. Jde o historický relikt. Používejte prosím standardní PHP nullsafe operátor `?->`.
+
+**Filter Loader**
+Metoda `Engine::addFilterLoader()` byla označena jako zastaralá a odstraněna. Šlo o nekonzistentní koncept, který se jinde v Latte nevyskytoval.
+
+**Date Format**
+Statická vlastnost `Latte\Runtime\Filters::$dateFormat` byla odstraněna, aby se předešlo globálnímu stavu.
+
+
+Nové funkce
+===========
+
+Během migrace si můžete začít užívat nové funkce:
+
+- **Chytré HTML atributy:** Předávání polí do `class` a `style`, automatické vynechání `null` atributů.
+- **Nullsafe filtry:** Použijte `{$var?|filter}` pro přeskočení filtrování null hodnot.
+- **`n:elseif`:** Nyní můžete používat `n:elseif` společně s `n:if` a `n:else`.
+- **Zjednodušená syntaxe:** Pište `Výsledky vyhledávání pro ' . $search . '
'; Útočník může do vyhledávacího políčka a potažmo do proměnné `$search` zapsat libovolný řetězec, tedy i HTML kód jako ``. Protože výstup není nijak ošetřen, stane se součástí zobrazené stránky: -```html +```latteVýsledky vyhledávání pro
``` @@ -59,7 +59,7 @@ echo '
```
@@ -91,7 +91,7 @@ Kontextově sensitivní escapování
Co se přesně myslí slovem kontext? Jde o místo v dokumentu s vlastními pravidly pro ošetřování vypisovaných dat. Odvíjí se od typu dokumentu (HTML, XML, CSS, JavaScript, plain text, ...) a může se lišit v jeho konkrétních částech. Například v HTML dokumentu je takových míst (kontextů), kde platí velmi odlišná pravidla, celá řada. Možná budete překvapeni, kolik jich je. Tady máme první čtveřici:
-```html
+```latte
#text
```
@@ -330,7 +330,7 @@ Nyní se podíváme, jak si se stejnou šablonou poradí Latte:
Latte vidí šablonu stejně jako vy. Na rozdíl od Twigu chápe HTML a ví, že proměnná se vypisuje jako hodnota atributu, který není v uvozovkách. Proto je doplní. Když útočník vloží stejný popisek, výsledný kód bude vypadat takto:
-```html
+```latte
```
diff --git a/latte/cs/syntax.texy b/latte/cs/syntax.texy
index 0913d20fc7..39f1c621de 100644
--- a/latte/cs/syntax.texy
+++ b/latte/cs/syntax.texy
@@ -111,6 +111,34 @@ Což vypíše v závislosti na proměnné `$url`:
Avšak n:atributy nejsou jen zkratkou pro párové značky. Existují i ryzí n:atributy, jako třeba [n:href |application:creating-links#V šabloně presenteru] nebo velešikovný pomocník kodéra [n:class |tags#n:class].
+Kromě syntaxe s uvozovkami `{=' Hello world '|trim}
```
+Pokud může být hodnota `null` a chcete v takovém případě zabránit použití filtru, použijte [nullsafe filter |filters#Nullsafe Filters] `?|`:
+
+```latte
+{$heading?|upper}
+```
+
Dynamické HTML značky .{data-version:3.0.9}
===========================================
@@ -183,6 +218,41 @@ Uvnitř značek fungují PHP komentáře:
```
+Řízení bílých znaků
+===================
+
+Latte zachází s bílými znaky inteligentně. Kód můžete volně odsazovat pro čitelnost a výstup zůstane čistý. Když se tag objeví na řádku sám, celý řádek (odsazení i konec řádku) se z výstupu odstraní:
+
+```latte
+
+ {foreach $items as $item}
+ - {$item}
+ {/foreach}
+
+```
+
+Vypíše:
+
+```latte
+
+ - foo
+ - bar
+
+```
+
+A co když tag není na řádku sám, ale je tam i další obsah? Bílé znaky před tagem pak patří *dovnitř* tagu:
+
+```latte
+
+ {if $foo}hello{/if}
+
+```
+
+Odsazení je tedy fakticky uvnitř `{if}`: pokud je `$foo` false, nevypíše se nic – ani odsazení, ani prázdný řádek. Pokud je `$foo` true, výstup přirozeně obsahuje odsazení. Prostě pište přehledně odsazené šablony a výstup bude vždy čistý.
+
+Pro ještě čistší výstup lze aktivovat funkci [Dedent |develop#Dedent], která odstraní i odsazení vzniklé zanořením v párových značkách jako `{if}` nebo `{foreach}`.
+
+
Syntaktický cukr
================
@@ -204,7 +274,7 @@ Jednoduché řetězce jsou ty, které jsou tvořeny čistě z písmen, číslic,
Konstanty
---------
-Jelikož lze u jednoduchých řetězců vynechávat uvozovky, doporučujeme pro odlišení zapisovat globální konstanty s lomítkem na začátku:
+K rozlišení globálních konstant od jednoduchých řetězců použijte oddělovač globálního jmenného prostoru:
```latte
{if \PROJECT_ID === 1} ... {/if}
@@ -265,8 +335,6 @@ Historické okénko
Latte přišlo v průběhu své historie s celou řadou syntaktických cukříků, které se po pár letech objevily v samotném PHP. Například v Latte bylo možné psát pole jako `[1, 2, 3]` místo `array(1, 2, 3)` nebo používat nullsafe operátor `$obj?->foo` dávno předtím, než to bylo možné v samotném PHP. Latte také zavedlo operátor pro rozbalení pole `(expand) $arr`, který je ekvivalentem dnešního operátoru `...$arr` z PHP.
-Undefined-safe operator `??->`, což je obdoba nullsafe operatoru `?->`, který ale nevyvolá chybu, pokud proměnná neexistuje, vznikl z historických důvodů a dnes doporučujeme používat standardní PHP operátor `?->`.
-
Omezení PHP v Latte
===================
diff --git a/latte/cs/tags.texy b/latte/cs/tags.texy
index d302666d5a..cb8b03378a 100644
--- a/latte/cs/tags.texy
+++ b/latte/cs/tags.texy
@@ -16,7 +16,7 @@ Přehled a popis všech tagů (neboli značek či maker) šablonovacího systém
| `{ifset}` … `{elseifset}` … `{/ifset}` | [podmínka ifset |#ifset elseifset]
| `{ifchanged}` … `{/ifchanged}` | [test jestli došlo ke změně |#ifchanged]
| `{switch}` `{case}` `{default}` `{/switch}` | [podmínka switch |#switch case default]
-| `n:else` | [alternativní obsah pro podmínky |#n:else]
+| `n:else`, `n:elseif` | [alternativní obsah pro podmínky |#n:else]
.[table-latte-tags language-latte]
|## Cykly
@@ -137,7 +137,7 @@ Jako výraz můžete zapsat cokoliv, co znáte z PHP. Nemusíte se zkrátka uči
```latte
-{='0' . ($num ?? $num * 3) . ', ' . PHP_VERSION}
+{='0' . ($num ?? $num * 3) . ', ' . \PHP_VERSION}
```
Prosím, nehledejte v předchozím příkladu žádný smysl, ale kdybyste tam nějaký našli, napište nám :-)
@@ -252,14 +252,16 @@ Víte, že k n:atributům můžete připojit prefix `tag-`? Pak se bude podmínk
Boží.
-`n:else` .{data-version:3.0.11}
--------------------------------
+`n:else` `n:elseif` .{data-version:3.0.11}
+------------------------------------------
-Pokud podmínku `{if} ... {/if}` zapíšete v podobě [n:attributu |syntax#n:atributy], máte možnost uvést i alternativní větev pomocí `n:else`:
+Pokud podmínku `{if} ... {/if}` zapíšete v podobě [n:attributu |syntax#n:atributy], máte možnost uvést i alternativní větev pomocí `n:else` a `n:elseif` (od Latte 3.1):
```latte
Skladem {$count} kusů
+Neplatný počet
+
není dostupné
```
@@ -947,6 +949,9 @@ Pomocníci HTML kodéra
n:class
-------
+.[note]
+Od verze Latte 3.1 získal standardní HTML atribut `class` [stejnou funkcionalitu |html-attributes#třídy-classes]. Není tedy již nutné používat n:class.
+
Díky `n:class` velice snadno vygenerujete HTML atribut `class` přesně podle představ.
Příklad: potřebuji, aby aktivní prvek měl třídu `active`:
@@ -997,6 +1002,12 @@ V závislosti na vrácených hodnotách vypíše např.:
```
+Funkce inteligentních atributů v Latte 3.1, jako je vynechání hodnot `null` nebo předávání polí do `class` nebo `style`, fungují také v rámci `n:attr`:
+
+```latte
+
+```
+
n:tag
-----
diff --git a/latte/cs/type-system.texy b/latte/cs/type-system.texy
index 0454b2743d..7dcf6e8dce 100644
--- a/latte/cs/type-system.texy
+++ b/latte/cs/type-system.texy
@@ -21,7 +21,7 @@ Jak začít používat typy? Vytvořte si třídu šablony, např. `CatalogTempl
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-A dále na začátek šablony vložte značku `{templateType}` s plným názvem třídy (včetně namespace). To definuje, že v šabloně jsou proměnné `$langs` a `$products` včetně příslušných typů. Typy lokálních proměnných můžete uvést pomocí značek [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definice].
+A dále na začátek šablony vložte značku `{templateType}` s plným názvem třídy (včetně namespace). To definuje, že v šabloně jsou proměnné `$lang` a `$products` včetně příslušných typů. Typy lokálních proměnných můžete uvést pomocí značek [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definice].
Od té chvíle vám může IDE správně našeptávat.
diff --git a/latte/de/custom-tags.texy b/latte/de/custom-tags.texy
index 483b5f5820..89089b627d 100644
--- a/latte/de/custom-tags.texy
+++ b/latte/de/custom-tags.texy
@@ -923,7 +923,7 @@ Jetzt können Sie `n:confirm` auf Links, Schaltflächen oder Formularelementen v
Generiertes HTML:
-```html
+```latte
Löschen
```
diff --git a/latte/de/safety-first.texy b/latte/de/safety-first.texy
index 2f5b0697a1..bdc0cb85fa 100644
--- a/latte/de/safety-first.texy
+++ b/latte/de/safety-first.texy
@@ -33,7 +33,7 @@ echo '
{$heading?|upper}
+``` + Dynamické HTML značky .{data-version:3.0.9} =========================================== @@ -183,6 +218,41 @@ Uvnitř značek fungují PHP komentáře: ``` +Řízení bílých znaků +=================== + +Latte zachází s bílými znaky inteligentně. Kód můžete volně odsazovat pro čitelnost a výstup zůstane čistý. Když se tag objeví na řádku sám, celý řádek (odsazení i konec řádku) se z výstupu odstraní: + +```latte +-
+ {foreach $items as $item}
+
- {$item} + {/foreach} +
-
+
- foo +
- bar +
Suchergebnisse für ' . $search . '
'; Ein Angreifer kann in das Suchfeld und somit in die Variable `$search` eine beliebige Zeichenkette eingeben, also auch HTML-Code wie ``. Da die Ausgabe nicht bereinigt wird, wird sie Teil der angezeigten Seite: -```html +```latteSuchergebnisse für
``` @@ -59,7 +59,7 @@ echo '
```
@@ -91,7 +91,7 @@ Kontextsensitives Escaping
Was genau ist mit dem Wort Kontext gemeint? Es handelt sich um eine Stelle im Dokument mit eigenen Regeln für die Bereinigung ausgegebener Daten. Sie hängt vom Dokumenttyp ab (HTML, XML, CSS, JavaScript, Plain Text, ...) und kann sich in seinen spezifischen Teilen unterscheiden. Beispielsweise gibt es in einem HTML-Dokument eine ganze Reihe solcher Stellen (Kontexte), an denen sehr unterschiedliche Regeln gelten. Vielleicht werden Sie überrascht sein, wie viele es sind. Hier sind die ersten vier:
-```html
+```latte
#text
```
@@ -330,7 +330,7 @@ Sehen wir uns nun an, wie Latte mit demselben Template umgeht:
Latte sieht das Template genauso wie Sie. Im Gegensatz zu Twig versteht es HTML und weiß, dass die Variable als Wert eines Attributs ausgegeben wird, das nicht in Anführungszeichen steht. Deshalb ergänzt es sie. Wenn ein Angreifer dieselbe Beschreibung einfügt, sieht der resultierende Code so aus:
-```html
+```latte
```
diff --git a/latte/de/type-system.texy b/latte/de/type-system.texy
index 88beabecd4..f8994c6ef0 100644
--- a/latte/de/type-system.texy
+++ b/latte/de/type-system.texy
@@ -21,7 +21,7 @@ Wie beginnt man mit der Verwendung von Typen? Erstellen Sie eine Template-Klasse
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-Fügen Sie dann am Anfang des Templates das Tag `{templateType}` mit dem vollständigen Klassennamen (einschließlich Namespace) ein. Dies definiert, dass im Template die Variablen `$langs` und `$products` einschließlich der entsprechenden Typen vorhanden sind. Die Typen lokaler Variablen können Sie mit den Tags [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definition] angeben.
+Fügen Sie dann am Anfang des Templates das Tag `{templateType}` mit dem vollständigen Klassennamen (einschließlich Namespace) ein. Dies definiert, dass im Template die Variablen `$lang` und `$products` einschließlich der entsprechenden Typen vorhanden sind. Die Typen lokaler Variablen können Sie mit den Tags [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definition] angeben.
Von diesem Moment an kann Ihnen die IDE korrekt Vorschläge machen.
diff --git a/latte/el/custom-tags.texy b/latte/el/custom-tags.texy
index cf69c32588..3c041dd29d 100644
--- a/latte/el/custom-tags.texy
+++ b/latte/el/custom-tags.texy
@@ -923,7 +923,7 @@ class MyLatteExtension extends Extension
Παραγόμενο HTML:
-```html
+```latte
Διαγραφή
```
diff --git a/latte/el/safety-first.texy b/latte/el/safety-first.texy
index bb4b7c09d7..65985510ef 100644
--- a/latte/el/safety-first.texy
+++ b/latte/el/safety-first.texy
@@ -33,7 +33,7 @@ echo 'Αποτελέσματα αναζήτησης για ' . $search .
Ένας εισβολέας μπορεί να γράψει στο πεδίο αναζήτησης και κατ' επέκταση στη μεταβλητή `$search` οποιοδήποτε string, δηλαδή και κώδικα HTML όπως ``. Επειδή η έξοδος δεν επεξεργάζεται με κανέναν τρόπο, γίνεται μέρος της εμφανιζόμενης σελίδας:
-```html
+```latte
Αποτελέσματα αναζήτησης για #κείμενο Search results for ' . $search . ' Search results for #text Resultados de la búsqueda para ' . $search . ' Resultados de la búsqueda para #texto Résultats de la recherche pour ' . $search . ' Résultats de la recherche pour #texte Keresési eredmények erre: ' . $search . ' Keresési eredmények erre: #szöveg 検索結果: ' . $search . ' 検索結果: #テキスト Wyniki wyszukiwania dla ' . $search . ' Wyniki wyszukiwania dla #text Resultados da pesquisa para ' . $search . ' Resultados da pesquisa para #texto Rezultatele căutării pentru ' . $search . ' Rezultatele căutării pentru #text Результаты поиска для ' . $search . ' Результаты поиска для #текст Rezultati iskanja za ' . $search . ' Rezultati iskanja za #text ' . $search . ' için arama sonuçları için arama sonuçları #metin Результати пошуку для ' . $search . ' Результати пошуку для #text Hello world Hello world';
Αρκεί ο εισβολέας να εισάγει ως λεζάντα ένα έξυπνα κατασκευασμένο string `" onload="alert('Hacked!')` και αν η εκτύπωση δεν επεξεργαστεί, ο προκύπτων κώδικας θα μοιάζει ως εξής:
-```html
+```latte
```
@@ -91,7 +91,7 @@ Context-Aware Escaping
Τι ακριβώς εννοούμε με τη λέξη context; Πρόκειται για ένα μέρος στο έγγραφο με τους δικούς του κανόνες για την επεξεργασία των εκτυπωμένων δεδομένων. Εξαρτάται από τον τύπο του εγγράφου (HTML, XML, CSS, JavaScript, plain text, ...) και μπορεί να διαφέρει σε συγκεκριμένα μέρη του. Για παράδειγμα, σε ένα έγγραφο HTML, υπάρχουν πολλά τέτοια μέρη (contexts) όπου ισχύουν πολύ διαφορετικοί κανόνες. Ίσως εκπλαγείτε πόσα είναι. Εδώ έχουμε την πρώτη τετράδα:
-```html
+```latte
@@ -108,7 +108,7 @@ Context-Aware Escaping
Τα contexts μπορούν επίσης να στρωματοποιηθούν, κάτι που συμβαίνει όταν ενσωματώνουμε JavaScript ή CSS σε HTML. Αυτό μπορεί να γίνει με δύο διαφορετικούς τρόπους, με στοιχείο και με attribute:
-```html
+```latte
@@ -132,7 +132,7 @@ Context-Aware Escaping
Αν το εκτυπώσετε σε κείμενο HTML, σε αυτή τη συγκεκριμένη περίπτωση δεν χρειάζεται να κάνετε καμία αντικατάσταση, επειδή το string δεν περιέχει κανέναν χαρακτήρα με ειδική σημασία. Η κατάσταση αλλάζει αν το εκτυπώσετε μέσα σε ένα attribute HTML που περικλείεται σε απλά εισαγωγικά. Σε αυτή την περίπτωση, πρέπει να κάνετε escape τα εισαγωγικά σε οντότητες HTML:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Αν εισάγουμε αυτόν τον κώδικα σε ένα έγγραφο HTML χρησιμοποιώντας το `
```
Αν όμως θέλαμε να το εισάγουμε σε ένα attribute HTML, πρέπει ακόμα να κάνουμε escape τα εισαγωγικά σε οντότητες HTML:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
Και όταν εκτυπώνουμε αυτό το string σε ένα attribute, εφαρμόζουμε επιπλέον το escaping σύμφωνα με αυτό το context και αντικαθιστούμε το `&` με `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Latte εναντίον απλοϊκών συστημάτων
Ένας εισβολέας εισάγει ως λεζάντα της εικόνας ένα έξυπνα κατασκευασμένο string `foo onload=alert('Hacked!')`. Γνωρίζουμε ήδη ότι το Twig δεν μπορεί να αναγνωρίσει αν η μεταβλητή εκτυπώνεται στη ροή του κειμένου HTML, μέσα σε ένα attribute, σε ένα σχόλιο HTML κ.λπ., με λίγα λόγια δεν διακρίνει τα contexts. Και απλώς μετατρέπει μηχανικά τους χαρακτήρες `< > & ' "` σε οντότητες HTML. Έτσι, ο προκύπτων κώδικας θα μοιάζει ως εξής:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Latte εναντίον απλοϊκών συστημάτων
Το Latte βλέπει το πρότυπο όπως εσείς. Σε αντίθεση με το Twig, καταλαβαίνει HTML και ξέρει ότι η μεταβλητή εκτυπώνεται ως τιμή ενός attribute που δεν βρίσκεται σε εισαγωγικά. Γι' αυτό τα συμπληρώνει. Όταν ο εισβολέας εισάγει την ίδια λεζάντα, ο προκύπτων κώδικας θα μοιάζει ως εξής:
-```html
+```latte
```
diff --git a/latte/el/type-system.texy b/latte/el/type-system.texy
index 91b4f29239..26dff347f3 100644
--- a/latte/el/type-system.texy
+++ b/latte/el/type-system.texy
@@ -21,7 +21,7 @@
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-Και στη συνέχεια, στην αρχή του προτύπου, εισαγάγετε το tag `{templateType}` με το πλήρες όνομα της κλάσης (συμπεριλαμβανομένου του namespace). Αυτό ορίζει ότι στο πρότυπο υπάρχουν οι μεταβλητές `$langs` και `$products` συμπεριλαμβανομένων των αντίστοιχων τύπων τους. Μπορείτε να δηλώσετε τους τύπους των τοπικών μεταβλητών χρησιμοποιώντας τα tags [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Ορισμοί define].
+Και στη συνέχεια, στην αρχή του προτύπου, εισαγάγετε το tag `{templateType}` με το πλήρες όνομα της κλάσης (συμπεριλαμβανομένου του namespace). Αυτό ορίζει ότι στο πρότυπο υπάρχουν οι μεταβλητές `$lang` και `$products` συμπεριλαμβανομένων των αντίστοιχων τύπων τους. Μπορείτε να δηλώσετε τους τύπους των τοπικών μεταβλητών χρησιμοποιώντας τα tags [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Ορισμοί define].
Από εκείνη τη στιγμή, το IDE σας μπορεί να παρέχει σωστή αυτόματη συμπλήρωση.
diff --git a/latte/en/@left-menu.texy b/latte/en/@left-menu.texy
index eebab75253..88fc173a96 100644
--- a/latte/en/@left-menu.texy
+++ b/latte/en/@left-menu.texy
@@ -5,6 +5,7 @@
- [Template Inheritance]
- [Type System]
- [Sandbox]
+ - [HTML attributes]
- For Designers 🎨
- [Syntax]
diff --git a/latte/en/cookbook/@home.texy b/latte/en/cookbook/@home.texy
index 7c2738769a..58b23d4136 100644
--- a/latte/en/cookbook/@home.texy
+++ b/latte/en/cookbook/@home.texy
@@ -8,6 +8,7 @@ Example codes and recipes for accomplishing common tasks with Latte.
- [Passing variables across templates |passing-variables]
- [Everything you always wanted to know about grouping |grouping]
- [How to write SQL queries in Latte? |how-to-write-sql-queries-in-latte]
+- [Migration from Latte 3.0 |migration-from-latte-30]
- [Migration from Latte 2 |migration-from-latte2]
- [Migration from PHP |migration-from-php]
- [Migration from Twig |migration-from-twig]
diff --git a/latte/en/cookbook/migration-from-latte-30.texy b/latte/en/cookbook/migration-from-latte-30.texy
new file mode 100644
index 0000000000..0c73bfce8f
--- /dev/null
+++ b/latte/en/cookbook/migration-from-latte-30.texy
@@ -0,0 +1,110 @@
+Migration from Latte 3.0
+************************
+
+.[perex]
+Latte 3.1 brings several improvements and changes that make templates safer and more convenient to write. Most changes are backward compatible, but some require attention during migration. This guide summarizes the breaking changes and how to handle them.
+
+Latte 3.1 requires **PHP 8.2** or newer.
+
+
+Smart Attributes and Migration
+==============================
+
+The most significant change in Latte 3.1 is the new behavior of [Smart Attributes |/html-attributes]. This affects how `null` values and boolean values in `data-` attributes are rendered.
+
+1. **`null` values:** Previously, `title={$null}` rendered as `title=""`. Now, the attribute is completely dropped.
+2. **`data-` attributes:** Previously, `data-foo={=true}` / `data-foo={=false}` rendered as `data-foo="1"` / `data-foo=""`. Now, it renders as `data-foo="true"` / `data-foo="false"`.
+
+To help you identify places where the output has changed in your application, Latte provides a migration tool.
+
+
+Migration Warnings
+------------------
+
+You can enable [migration warnings |/develop#Migration Warnings], which will warn you during rendering if the output differs from Latte 3.0.
+
+```php
+$latte = new Latte\Engine;
+$latte->setFeature(Latte\Feature::MigrationWarnings);
+```
+
+When enabled, check your application logs or Tracy bar for `E_USER_WARNING`s. Each warning will point to the specific line, and column in template.
+
+**How to resolve warnings:**
+
+If the new behavior is correct (e.g. you want the empty attribute to disappear), confirm it using the `|accept` filter to suppress the warning:
+
+```latte
+
+```
+
+If you want to keep the attribute as empty (e.g. `title=""`) instead of dropping it, use the null coalescing operator:
+
+```latte
+
+```
+
+Or, if you strictly require the old behavior (e.g. `"1"` for `true`), explicitly cast the value to string:
+
+```latte
+
+```
+
+**After you resolve all warnings:**
+
+Once all warnings are resolved, disable migration warnings and **remove all** `|accept` filters from your templates, as they are no longer needed.
+
+
+Strict Types
+============
+
+Latte 3.1 enables `declare(strict_types=1)` by default for all compiled templates. This improves type safety but might cause type errors in PHP expressions inside your templates if you were relying on loose typing.
+
+If you cannot fix the types immediately, you can disable this behavior:
+
+```php
+$latte->setFeature(Latte\Feature::StrictTypes, false);
+```
+
+
+Global Constants
+================
+
+The template parser has been improved to better distinguish between simple strings and constants. As a result, global constants must now be prefixed with a backslash `\`.
+
+```latte
+{* Old way (throws a warning; in the future will be interpreted as the string 'PHP_VERSION') *}
+{if PHP_VERSION > ...}
+
+{* New way (correctly interpreted as constant) *}
+{if \PHP_VERSION > ...}
+```
+
+This change prevents ambiguity and allows you to use unquoted strings more freely.
+
+
+Removed Features
+================
+
+**Reserved Variables:** Variables starting with `$__` (double underscore) and the variable `$this` are now strictly reserved for Latte's internal use. You cannot use them in your templates.
+
+**Undefined-safe Operator:** The `??->` operator, which was a Latte-specific feature created before PHP 8, has been removed. It is a historical relic. Please use the standard PHP nullsafe operator `?->`.
+
+**Filter Loader**
+The `Engine::addFilterLoader()` method has been deprecated and removed. It was an inconsistent concept not found elsewhere in Latte.
+
+**Date Format**
+The static property `Latte\Runtime\Filters::$dateFormat` was removed to avoid global state.
+
+
+New Features
+============
+
+While migrating, you can start enjoying the new features:
+
+- **Smart HTML
+Attributes:** Pass arrays to `class` and `style`, auto-drop `null` attributes.
+- **Nullsafe filters:** Use `{$var?|filter}` to skip filtering null values.
+- **`n:elseif`:** You can now use `n:elseif` alongside `n:if` and `n:else`.
+- **Simplified syntax:** Write `';
An attacker simply needs to insert a cleverly crafted string `" onload="alert('Hacked!')` as the caption, and if the output is not sanitized, the resulting code will look like this:
-```html
+```latte
```
@@ -91,7 +91,7 @@ Context-Aware Escaping
What exactly is meant by the word context? It's a location within the document with its own rules for handling the data being printed. It depends on the document type (HTML, XML, CSS, JavaScript, plain text, ...) and can differ in specific parts. For example, in an HTML document, there are many places (contexts) where very different rules apply. You might be surprised how many there are. Here are the first four:
-```html
+```latte
@@ -108,7 +108,7 @@ It gets interesting inside HTML comments. Here, HTML entities are not used for e
Contexts can also be layered, which occurs when we embed JavaScript or CSS into HTML. This can be done in two different ways, using an element or an attribute:
-```html
+```latte
@@ -132,7 +132,7 @@ Let's take the string `Rock'n'Roll`.
If you print it in HTML text, in this particular case, no replacement is needed because the string does not contain any characters with special meaning. The situation changes if you print it inside an HTML attribute enclosed in single quotes. In that case, you need to escape the quotes into HTML entities:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
If we insert this code into an HTML document using `
```
However, if we wanted to insert it into an HTML attribute, we still need to escape the quotes into HTML entities:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
And when we print this string in an attribute, we still apply escaping according to this context and replace `&` with `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Notice that there are no quotes around the attribute values. The coder might hav
An attacker inserts a cleverly crafted string `foo onload=alert('Hacked!')` as the image caption. We already know that Twig cannot determine whether a variable is being printed in the HTML text flow, inside an attribute, an HTML comment, etc.; in short, it does not distinguish contexts. And it just mechanically converts the characters `< > & ' "` into HTML entities. So the resulting code will look like this:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Now let's see how Latte handles the same template:
Latte sees the template the same way you do. Unlike Twig, it understands HTML and knows that the variable is being printed as the value of an attribute that is not enclosed in quotes. Therefore, it adds them. When an attacker inserts the same caption, the resulting code will look like this:
-```html
+```latte
```
diff --git a/latte/en/syntax.texy b/latte/en/syntax.texy
index a65b056772..aa7e274f5f 100644
--- a/latte/en/syntax.texy
+++ b/latte/en/syntax.texy
@@ -111,6 +111,34 @@ Which outputs, depending on the variable `$url`:
However, n:attributes are not only a shortcut for pair tags, there are some pure n:attributes as well, for example the coder's best friend [n:class|tags#n:class] or the very handy [n:href |application:creating-links#In the Presenter Template].
+In addition to the syntax using quotes `{=' Hello world '|trim}
```
+If the value can be `null` and you want to avoid applying the filter in that case, use the [nullsafe filter |filters#Nullsafe Filters] `?|`:
+
+```latte
+
{$heading?|upper}
+```
+
Dynamic HTML Tags .{data-version:3.0.9}
=======================================
@@ -183,6 +218,41 @@ PHP comments work inside tags:
```
+Whitespace Control
+==================
+
+Latte handles whitespace intelligently. You can freely indent your code for readability, and the output stays clean. When a tag appears alone on a line, the entire line (indentation and newline) is removed from the output:
+
+```latte
+
+ {foreach $items as $item}
+
+```
+
+Outputs:
+
+```latte
+
+
+```
+
+What if a tag isn't alone on a line, but appears alongside other content? The whitespace before the tag then belongs *inside* the tag:
+
+```latte
+';
Al atacante le basta con insertar como descripción una cadena hábilmente construida `" onload="alert('Hacked!')` y si la impresión no está saneada, el código resultante se verá así:
-```html
+```latte
```
@@ -91,7 +91,7 @@ Escape sensible al contexto
¿Qué se entiende exactamente por la palabra contexto? Es un lugar en el documento con sus propias reglas para el saneamiento de los datos impresos. Depende del tipo de documento (HTML, XML, CSS, JavaScript, texto plano, ...) y puede diferir en sus partes específicas. Por ejemplo, en un documento HTML hay muchos lugares (contextos) donde se aplican reglas muy diferentes. Quizás se sorprenda de cuántos hay. Aquí tenemos los primeros cuatro:
-```html
+```latte
@@ -108,7 +108,7 @@ Es interesante dentro de los comentarios HTML. Aquí, el escape no se realiza ut
Los contextos también pueden anidarse, lo que ocurre cuando insertamos JavaScript o CSS en HTML. Esto se puede hacer de dos maneras diferentes, con un elemento y con un atributo:
-```html
+```latte
@@ -132,7 +132,7 @@ Tomemos la cadena `Rock'n'Roll`.
Si la imprime en texto HTML, en este caso particular no es necesario realizar ningún reemplazo, porque la cadena no contiene ningún carácter con significado especial. La situación cambia si la imprime dentro de un atributo HTML delimitado por comillas simples. En ese caso, es necesario escapar las comillas a entidades HTML:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Si insertamos este código en un documento HTML usando `
```
Sin embargo, si quisiéramos insertarlo en un atributo HTML, aún debemos escapar las comillas a entidades HTML:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
Y cuando imprimimos esta cadena en un atributo, aún aplicamos el escape según este contexto y reemplazamos `&` por `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Observe que no hay comillas alrededor de los valores de los atributos. El codifi
Un atacante inserta como descripción de la imagen una cadena hábilmente construida `foo onload=alert('Hacked!')`. Ya sabemos que Twig no puede saber si la variable se imprime en el flujo de texto HTML, dentro de un atributo, comentario HTML, etc., en resumen, no distingue contextos. Y solo convierte mecánicamente los caracteres `< > & ' "` en entidades HTML. Así que el código resultante se verá así:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Ahora veamos cómo Latte maneja la misma plantilla:
Latte ve la plantilla igual que usted. A diferencia de Twig, entiende HTML y sabe que la variable se imprime como el valor de un atributo que no está entre comillas. Por eso las añade. Cuando un atacante inserta la misma descripción, el código resultante se verá así:
-```html
+```latte
```
diff --git a/latte/es/type-system.texy b/latte/es/type-system.texy
index b3b4097727..d1cacbcb12 100644
--- a/latte/es/type-system.texy
+++ b/latte/es/type-system.texy
@@ -21,7 +21,7 @@ Los tipos declarados son informativos y Latte no los verifica en este momento.
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-Y luego, al principio de la plantilla, inserte la etiqueta `{templateType}` con el nombre completo de la clase (incluido el namespace). Esto define que en la plantilla existen las variables `$langs` y `$products` con sus tipos correspondientes. Puede indicar los tipos de las variables locales usando las etiquetas [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definiciones define].
+Y luego, al principio de la plantilla, inserte la etiqueta `{templateType}` con el nombre completo de la clase (incluido el namespace). Esto define que en la plantilla existen las variables `$lang` y `$products` con sus tipos correspondientes. Puede indicar los tipos de las variables locales usando las etiquetas [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definiciones define].
A partir de ese momento, su IDE puede sugerir correctamente.
diff --git a/latte/files/html-attributes.webp b/latte/files/html-attributes.webp
new file mode 100644
index 0000000000..56e729541b
Binary files /dev/null and b/latte/files/html-attributes.webp differ
diff --git a/latte/fr/custom-tags.texy b/latte/fr/custom-tags.texy
index 29c14a08a8..9983a44429 100644
--- a/latte/fr/custom-tags.texy
+++ b/latte/fr/custom-tags.texy
@@ -923,7 +923,7 @@ Vous pouvez maintenant utiliser `n:confirm` sur des liens, des boutons ou des é
HTML généré :
-```html
+```latte
Supprimer
```
diff --git a/latte/fr/safety-first.texy b/latte/fr/safety-first.texy
index e4b3f5a93a..d9476e4305 100644
--- a/latte/fr/safety-first.texy
+++ b/latte/fr/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
Il suffit à l'attaquant d'insérer comme légende une chaîne habilement construite `" onload="alert('Piraté !')` et si l'affichage n'est pas traité, le code résultant ressemblera à ceci :
-```html
+```latte
```
@@ -91,7 +91,7 @@ Cependant, XSS ne concerne pas seulement l'affichage des données dans les templ
Que signifie exactement le mot contexte ? C'est un endroit dans le document avec ses propres règles pour traiter les données affichées. Il dépend du type de document (HTML, XML, CSS, JavaScript, texte brut, ...) et peut varier dans ses parties spécifiques. Par exemple, dans un document HTML, il existe de nombreux endroits (contextes) où des règles très différentes s'appliquent. Vous serez peut-être surpris de leur nombre. Voici les quatre premiers :
-```html
+```latte
@@ -108,7 +108,7 @@ C'est intéressant à l'intérieur des commentaires HTML. Ici, l'échappement n'
Les contextes peuvent également être imbriqués, ce qui se produit lorsque nous insérons du JavaScript ou du CSS dans du HTML. Cela peut être fait de deux manières différentes, par élément et par attribut :
-```html
+```latte
@@ -132,7 +132,7 @@ Prenons la chaîne `Rock'n'Roll`.
Si vous l'affichez dans du texte HTML, dans ce cas précis, il n'est pas nécessaire de faire de remplacements, car la chaîne ne contient aucun caractère ayant une signification spéciale. La situation change si vous l'affichez à l'intérieur d'un attribut HTML entouré de guillemets simples. Dans ce cas, il faut échapper les guillemets en entités HTML :
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Si nous insérons ce code dans un document HTML à l'aide de `
```
Cependant, si nous voulions l'insérer dans un attribut HTML, nous devrions encore échapper les guillemets en entités HTML :
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
Et lorsque nous affichons cette chaîne dans un attribut, nous appliquons encore l'échappement selon ce contexte et remplaçons `&` par `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Notez qu'il n'y a pas de guillemets autour des valeurs des attributs. Le codeur
L'attaquant insère comme légende de l'image une chaîne habilement construite `foo onload=alert('Piraté !')`. Nous savons déjà que Twig ne peut pas savoir si la variable est affichée dans le flux de texte HTML, à l'intérieur d'un attribut, d'un commentaire HTML, etc., bref, il ne distingue pas les contextes. Et il ne fait que convertir mécaniquement les caractères `< > & ' "` en entités HTML. Le code résultant ressemblera donc à ceci :
-```html
+```latte
```
@@ -330,7 +330,7 @@ Voyons maintenant comment Latte gère le même template :
Latte voit le template de la même manière que vous. Contrairement à Twig, il comprend HTML et sait que la variable est affichée comme valeur d'un attribut qui n'est pas entre guillemets. C'est pourquoi il les ajoute. Lorsque l'attaquant insère la même légende, le code résultant ressemblera à ceci :
-```html
+```latte
```
diff --git a/latte/fr/type-system.texy b/latte/fr/type-system.texy
index 8419906504..0cac1c1ac0 100644
--- a/latte/fr/type-system.texy
+++ b/latte/fr/type-system.texy
@@ -21,7 +21,7 @@ Comment commencer à utiliser les types ? Créez une classe de template, par exe
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-Ensuite, au début du template, insérez la balise `{templateType}` avec le nom complet de la classe (y compris le namespace). Cela définit que les variables `$langs` et `$products` existent dans le template, y compris leurs types respectifs. Vous pouvez spécifier les types des variables locales à l'aide des balises [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Définitions].
+Ensuite, au début du template, insérez la balise `{templateType}` avec le nom complet de la classe (y compris le namespace). Cela définit que les variables `$lang` et `$products` existent dans le template, y compris leurs types respectifs. Vous pouvez spécifier les types des variables locales à l'aide des balises [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Définitions].
À partir de ce moment, l'IDE peut correctement vous faire des suggestions.
diff --git a/latte/hu/custom-tags.texy b/latte/hu/custom-tags.texy
index f8e2946305..6b7f70dbe5 100644
--- a/latte/hu/custom-tags.texy
+++ b/latte/hu/custom-tags.texy
@@ -923,7 +923,7 @@ Most már használhatja az `n:confirm`-ot linkeken, gombokon vagy űrlap elemeke
Generált HTML:
-```html
+```latte
Törlés
```
diff --git a/latte/hu/safety-first.texy b/latte/hu/safety-first.texy
index a07f648fe6..a1b2547fa0 100644
--- a/latte/hu/safety-first.texy
+++ b/latte/hu/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
A támadónak elég leírásként egy ügyesen összeállított `" onload="alert('Hacked!')` stringet beilleszteni, és ha a kiírás nincs kezelve, az eredményül kapott kód így fog kinézni:
-```html
+```latte
```
@@ -91,7 +91,7 @@ Kontextusérzékeny escapelés
Mit jelent pontosan a kontextus szó? Ez egy hely a dokumentumban, saját szabályokkal a kiírt adatok kezelésére. A dokumentum típusától (HTML, XML, CSS, JavaScript, plain text, ...) függ, és eltérhet annak konkrét részeiben. Például egy HTML dokumentumban számos ilyen hely (kontextus) van, ahol nagyon eltérő szabályok érvényesek. Talán meglepődik, mennyi van belőlük. Íme az első négy:
-```html
+```latte
@@ -108,7 +108,7 @@ Talán meglepő, de speciális szabályok érvényesek a `
@@ -108,7 +108,7 @@ Potresti essere sorpreso, ma regole speciali si applicano all'interno degli elem
I contesti possono anche essere annidati, cosa che accade quando inseriamo JavaScript o CSS in HTML. Questo può essere fatto in due modi diversi, con un elemento e con un attributo:
-```html
+```latte
@@ -132,7 +132,7 @@ Prendiamo la stringa `Rock'n'Roll`.
Se la stampi nel testo HTML, proprio in questo caso non è necessario effettuare alcuna sostituzione, perché la stringa non contiene alcun carattere con significato speciale. La situazione cambia se la stampi all'interno di un attributo HTML racchiuso tra apici singoli. In tal caso, è necessario eseguire l'escaping degli apici in entità HTML:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Se inseriamo questo codice nel documento HTML usando `
```
Se però volessimo inserirlo in un attributo HTML, dobbiamo ancora eseguire l'escaping degli apici in entità HTML:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
E quando stampiamo questa stringa in un attributo, applichiamo ancora l'escaping secondo questo contesto e sostituiamo `&` con `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Notate che non ci sono virgolette attorno ai valori degli attributi. Il codifica
Un aggressore inserisce come didascalia dell'immagine una stringa abilmente costruita `foo onload=alert('Hacked!')`. Sappiamo già che Twig non può riconoscere se la variabile viene stampata nel flusso del testo HTML, all'interno di un attributo, di un commento HTML, ecc., in breve non distingue i contesti. E converte meccanicamente solo i caratteri `< > & ' "` in entità HTML. Quindi il codice risultante sarà simile a questo:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Ora vediamo come Latte gestisce lo stesso template:
Latte vede il template come lo vedi tu. A differenza di Twig, capisce HTML e sa che la variabile viene stampata come valore di un attributo che non è tra virgolette. Pertanto le aggiunge. Quando l'aggressore inserisce la stessa didascalia, il codice risultante sarà simile a questo:
-```html
+```latte
```
diff --git a/latte/it/type-system.texy b/latte/it/type-system.texy
index ae98829c21..a5fb971b3c 100644
--- a/latte/it/type-system.texy
+++ b/latte/it/type-system.texy
@@ -21,7 +21,7 @@ Come iniziare a usare i tipi? Create una classe di template, ad es. `CatalogTemp
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-Quindi, all'inizio del template, inserite il tag `{templateType}` con il nome completo della classe (incluso il namespace). Questo definisce che nel template ci sono le variabili `$langs` e `$products` con i rispettivi tipi. Potete specificare i tipi delle variabili locali usando i tag [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definizioni define].
+Quindi, all'inizio del template, inserite il tag `{templateType}` con il nome completo della classe (incluso il namespace). Questo definisce che nel template ci sono le variabili `$lang` e `$products` con i rispettivi tipi. Potete specificare i tipi delle variabili locali usando i tag [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definizioni define].
Da quel momento, l'IDE può suggerire correttamente.
diff --git a/latte/ja/custom-tags.texy b/latte/ja/custom-tags.texy
index a3114b7964..347975a50b 100644
--- a/latte/ja/custom-tags.texy
+++ b/latte/ja/custom-tags.texy
@@ -923,7 +923,7 @@ class MyLatteExtension extends Extension
生成されたHTML：
-```html
+```latte
削除
```
diff --git a/latte/ja/safety-first.texy b/latte/ja/safety-first.texy
index 15f0190eb4..1e2c48e606 100644
--- a/latte/ja/safety-first.texy
+++ b/latte/ja/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
攻撃者は、説明として巧妙に作成された文字列 `" onload="alert('Hacked!')` を挿入するだけで、出力がサニタイズされていない場合、結果のコードは次のようになります：
-```html
+```latte
```
@@ -91,7 +91,7 @@ XSSからどのように防御しますか？
コンテキストという言葉で正確には何を意味しますか？それは、出力されるデータのサニタイズに関する独自のルールを持つドキュメント内の場所です。それはドキュメントのタイプ（HTML、XML、CSS、JavaScript、プレーンテキストなど）に依存し、その特定の場所によって異なる場合があります。 例えば、HTMLドキュメントには、非常に異なるルールが適用される多くの場所（コンテキスト）があります。いくつあるか驚くかもしれません。ここに最初の4つがあります：
-```html
+```latte
@@ -108,7 +108,7 @@ HTMLコメント内では興味深いです。ここでは、エスケープにH
コンテキストはネストすることもできます。これは、JavaScriptまたはCSSをHTMLに埋め込むときに発生します。これは2つの異なる方法、要素と属性で行うことができます：
-```html
+```latte
@@ -132,7 +132,7 @@ HTMLコメント内では興味深いです。ここでは、エスケープにH
HTMLテキストに出力する場合、この特定のケースでは、文字列に特別な意味を持つ文字が含まれていないため、置換を行う必要はありません。状況は、単一引用符で囲まれたHTML属性内に出力する場合に異なります。その場合、引用符をHTMLエンティティにエスケープする必要があります：
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
このコードを `
```
しかし、HTML属性に挿入したい場合は、さらに引用符をHTMLエンティティにエスケープする必要があります：
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
そして、この文字列を属性に出力するとき、このコンテキストに従ってエスケープを適用し、`&` を `&` に置き換えます：
-```html
+```latte
```
@@ -314,7 +314,7 @@ Latteはテンプレートをあなたと同じように見ます。HTML、XML
攻撃者は、画像の説明として巧妙に作成された文字列 `foo onload=alert('Hacked!')` を挿入します。Twigは、変数がHTMLテキストの流れの中、属性内、HTMLコメント内など、どこに出力されているかを判断できないこと、つまりコンテキストを区別しないことをすでに知っています。そして、文字 `< > & ' "` を機械的にHTMLエンティティに変換するだけです。 したがって、結果のコードは次のようになります：
-```html
+```latte
```
@@ -330,7 +330,7 @@ Latteはテンプレートをあなたと同じように見ます。HTML、XML
Latteはテンプレートをあなたと同じように見ます。Twigとは異なり、HTMLを理解し、変数が引用符で囲まれていない属性の値として出力されていることを知っています。したがって、それらを補完します。攻撃者が同じ説明を挿入すると、結果のコードは次のようになります：
-```html
+```latte
```
diff --git a/latte/ja/type-system.texy b/latte/ja/type-system.texy
index 74a8f15022..0f93ddc900 100644
--- a/latte/ja/type-system.texy
+++ b/latte/ja/type-system.texy
@@ -21,7 +21,7 @@
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-次に、テンプレートの先頭に、クラスの完全な名前（名前空間を含む）を持つ `{templateType}` タグを挿入します。これにより、テンプレート内に変数 `$langs` と `$products` が、対応する型とともに定義されます。ローカル変数の型は、[`{var}` |tags#var default]、`{varType}`、[`{define}` |template-inheritance#Definitions] タグを使用して指定できます。
+次に、テンプレートの先頭に、クラスの完全な名前（名前空間を含む）を持つ `{templateType}` タグを挿入します。これにより、テンプレート内に変数 `$lang` と `$products` が、対応する型とともに定義されます。ローカル変数の型は、[`{var}` |tags#var default]、`{varType}`、[`{define}` |template-inheritance#Definitions] タグを使用して指定できます。
その時点から、IDEは正しく補完できるようになります。
diff --git a/latte/pl/custom-tags.texy b/latte/pl/custom-tags.texy
index 50be9f0562..8dd42d7929 100644
--- a/latte/pl/custom-tags.texy
+++ b/latte/pl/custom-tags.texy
@@ -923,7 +923,7 @@ Teraz możesz użyć `n:confirm` na linkach, przyciskach lub elementach formular
Wygenerowany HTML:
-```html
+```latte
Usuń
```
diff --git a/latte/pl/safety-first.texy b/latte/pl/safety-first.texy
index dc1f49265c..d8a666e1d7 100644
--- a/latte/pl/safety-first.texy
+++ b/latte/pl/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
Atakującemu wystarczy jako opis wstawić sprytnie skonstruowany ciąg `" onload="alert('Hacked!')`, a jeśli wyświetlanie nie zostanie oczyszczone, wynikowy kod będzie wyglądał tak:
-```html
+```latte
```
@@ -91,7 +91,7 @@ Escapowanie kontekstowe
Co dokładnie oznacza słowo kontekst? Jest to miejsce w dokumencie z własnymi zasadami oczyszczania wyświetlanych danych. Zależy od typu dokumentu (HTML, XML, CSS, JavaScript, plain text, ...) i może się różnić w jego poszczególnych częściach. Na przykład w dokumencie HTML istnieje wiele takich miejsc (kontekstów), gdzie obowiązują bardzo różne zasady. Być może będziesz zaskoczony, ile ich jest. Oto pierwsza czwórka:
-```html
+```latte
@@ -108,7 +108,7 @@ Ciekawie jest wewnątrz komentarzy HTML. Tutaj bowiem do escapowania nie używa
Konteksty mogą się również nakładać, co ma miejsce, gdy wstawiamy JavaScript lub CSS do HTML. Można to zrobić na dwa różne sposoby, elementem i atrybutem:
-```html
+```latte
@@ -132,7 +132,7 @@ Miejmy ciąg `Rock'n'Roll`.
Jeśli będziesz go wyświetlać w tekście HTML, akurat w tym przypadku nie trzeba dokonywać żadnych zamian, ponieważ ciąg nie zawiera żadnego znaku o specjalnym znaczeniu. Inna sytuacja nastąpi, jeśli wyświetlisz go wewnątrz atrybutu HTML ujętego w pojedyncze cudzysłowy. W takim przypadku trzeba escapować cudzysłowy na encje HTML:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Jeśli ten kod wstawimy do dokumentu HTML za pomocą `
```
Jeśli jednak chcielibyśmy go wstawić do atrybutu HTML, musimy jeszcze escapować cudzysłowy na encje HTML:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
A kiedy ten ciąg wyświetlimy w atrybucie, jeszcze zastosujemy escapowanie zgodnie z tym kontekstem i zastąpimy `&` na `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Zwróć uwagę, że wokół wartości atrybutów nie ma cudzysłowów. Koder mó
Atakujący jako opis obrazka wstawia sprytnie skonstruowany ciąg `foo onload=alert('Hacked!')`. Już wiemy, że Twig nie może rozpoznać, czy zmienna jest wyświetlana w przepływie tekstu HTML, wewnątrz atrybutu, komentarza HTML itp., krótko mówiąc, nie rozróżnia kontekstów. I tylko mechanicznie konwertuje znaki `< > & ' "` na encje HTML. Więc wynikowy kod będzie wyglądał tak:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Teraz zobaczymy, jak z tym samym szablonem poradzi sobie Latte:
Latte widzi szablon tak samo jak Ty. W przeciwieństwie do Twiga rozumie HTML i wie, że zmienna jest wyświetlana jako wartość atrybutu, który nie jest w cudzysłowach. Dlatego je uzupełni. Kiedy atakujący wstawi ten sam opis, wynikowy kod będzie wyglądał tak:
-```html
+```latte
```
diff --git a/latte/pl/type-system.texy b/latte/pl/type-system.texy
index 3715e6a9d5..9f19e935d9 100644
--- a/latte/pl/type-system.texy
+++ b/latte/pl/type-system.texy
@@ -21,7 +21,7 @@ Jak zacząć używać typów? Utwórz klasę szablonu, np. `CatalogTemplateParam
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-A następnie na początku szablonu wstaw tag `{templateType}` z pełną nazwą klasy (włącznie z namespace). To definiuje, że w szablonie są zmienne `$langs` i `$products` wraz z odpowiednimi typami. Typy zmiennych lokalnych możesz podać za pomocą tagów [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definicje define].
+A następnie na początku szablonu wstaw tag `{templateType}` z pełną nazwą klasy (włącznie z namespace). To definiuje, że w szablonie są zmienne `$lang` i `$products` wraz z odpowiednimi typami. Typy zmiennych lokalnych możesz podać za pomocą tagów [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definicje define].
Od tego momentu IDE może poprawnie podpowiadać.
diff --git a/latte/pt/custom-tags.texy b/latte/pt/custom-tags.texy
index b080e9e20b..1e523ed866 100644
--- a/latte/pt/custom-tags.texy
+++ b/latte/pt/custom-tags.texy
@@ -923,7 +923,7 @@ Agora você pode usar `n:confirm` em links, botões ou elementos de formulário:
HTML gerado:
-```html
+```latte
Excluir
```
diff --git a/latte/pt/safety-first.texy b/latte/pt/safety-first.texy
index 049ff1ae25..5e0351605c 100644
--- a/latte/pt/safety-first.texy
+++ b/latte/pt/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
Basta ao atacante inserir como legenda uma string habilmente construída `" onload="alert('Hacked!')` e, se a exibição não for tratada, o código resultante será assim:
-```html
+```latte
```
@@ -91,7 +91,7 @@ Escaping sensível ao contexto
O que exatamente se entende pela palavra contexto? É um local no documento com as suas próprias regras para o tratamento dos dados exibidos. Depende do tipo de documento (HTML, XML, CSS, JavaScript, texto simples, ...) e pode diferir nas suas partes específicas. Por exemplo, num documento HTML, existem muitos desses locais (contextos), onde regras muito diferentes se aplicam. Pode surpreender-se com quantos existem. Aqui temos os quatro primeiros:
-```html
+```latte
@@ -108,7 +108,7 @@ Pode surpreender-se, mas regras especiais aplicam-se dentro dos elementos `
@@ -132,7 +132,7 @@ Tenha a string `Rock'n'Roll`.
Se a exibir em texto HTML, neste caso específico não é necessário fazer nenhuma substituição, pois a string não contém nenhum caractere com significado especial. A situação muda se a exibir dentro de um atributo HTML delimitado por aspas simples. Nesse caso, é necessário escapar as aspas para entidades HTML:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Se inserirmos este código num documento HTML usando `
```
No entanto, se quiséssemos inseri-lo num atributo HTML, ainda precisaríamos de escapar as aspas para entidades HTML:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
E quando exibimos esta string num atributo, ainda aplicamos o escaping de acordo com este contexto e substituímos `&` por `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Observe que não há aspas em torno dos valores dos atributos. O codificador pod
Um atacante insere como legenda da imagem uma string habilmente construída `foo onload=alert('Hacked!')`. Já sabemos que o Twig não pode saber se a variável está a ser exibida no fluxo de texto HTML, dentro de um atributo, comentário HTML, etc., em suma, não distingue contextos. E apenas converte mecanicamente os caracteres `< > & ' "` em entidades HTML. Então, o código resultante será assim:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Agora veremos como o Latte lida com o mesmo template:
O Latte vê o template da mesma forma que você. Ao contrário do Twig, ele entende HTML e sabe que a variável está a ser exibida como o valor de um atributo que não está entre aspas. Portanto, ele adiciona-as. Quando o atacante insere a mesma legenda, o código resultante será assim:
-```html
+```latte
```
diff --git a/latte/pt/type-system.texy b/latte/pt/type-system.texy
index 110047b4b4..9baf8bb9f8 100644
--- a/latte/pt/type-system.texy
+++ b/latte/pt/type-system.texy
@@ -21,7 +21,7 @@ Como começar a usar tipos? Crie uma classe de template, por exemplo, `CatalogTe
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-E, em seguida, no início do template, insira a tag `{templateType}` com o nome completo da classe (incluindo o namespace). Isso define que no template existem as variáveis `$langs` e `$products`, incluindo os tipos correspondentes. Você pode especificar os tipos de variáveis locais usando as tags [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definições].
+E, em seguida, no início do template, insira a tag `{templateType}` com o nome completo da classe (incluindo o namespace). Isso define que no template existem as variáveis `$lang` e `$products`, incluindo os tipos correspondentes. Você pode especificar os tipos de variáveis locais usando as tags [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definições].
A partir desse momento, o IDE pode sugerir corretamente.
diff --git a/latte/ro/custom-tags.texy b/latte/ro/custom-tags.texy
index bc12920a37..3c353caabb 100644
--- a/latte/ro/custom-tags.texy
+++ b/latte/ro/custom-tags.texy
@@ -923,7 +923,7 @@ Acum puteți utiliza `n:confirm` pe linkuri, butoane sau elemente de formular:
HTML generat:
-```html
+```latte
Șterge
```
diff --git a/latte/ro/safety-first.texy b/latte/ro/safety-first.texy
index 8140ba61d3..b4948a948d 100644
--- a/latte/ro/safety-first.texy
+++ b/latte/ro/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
Atacatorului îi este suficient să introducă ca descriere un șir inteligent construit `" onload="alert('Hacked!')` și dacă afișarea nu este tratată, codul rezultat va arăta astfel:
-```html
+```latte
```
@@ -91,7 +91,7 @@ Escapare contextuală sensibilă
Ce se înțelege exact prin cuvântul context? Este un loc în document cu propriile reguli pentru tratarea datelor afișate. Depinde de tipul documentului (HTML, XML, CSS, JavaScript, plain text, ...) și poate diferi în părțile sale specifice. De exemplu, într-un document HTML există o serie întreagă de astfel de locuri (contexte) unde se aplică reguli foarte diferite. Poate veți fi surprinși câte sunt. Iată primele patru:
-```html
+```latte
@@ -108,7 +108,7 @@ Interesant este în interiorul comentariilor HTML. Aici, escaparea nu se face fo
Contexturile se pot și stratifica, ceea ce se întâmplă când inserăm JavaScript sau CSS în HTML. Acest lucru se poate face în două moduri diferite, prin element și atribut:
-```html
+```latte
@@ -132,7 +132,7 @@ Să avem șirul `Rock'n'Roll`.
Dacă îl veți afișa în text HTML, în acest caz particular nu este nevoie de nicio înlocuire, deoarece șirul nu conține niciun caracter cu semnificație specială. Situația se schimbă dacă îl afișați în interiorul unui atribut HTML delimitat de apostrofuri simple. În acest caz, este necesar să escapați apostrofurile în entități HTML:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Dacă inserăm acest cod într-un document HTML folosind `
```
Dacă am dori însă să îl inserăm într-un atribut HTML, trebuie să mai escapăm ghilimelele în entități HTML:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
Și când afișăm acest șir într-un atribut, aplicăm și escaparea conform acestui context și înlocuim `&` cu `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Observați că în jurul valorilor atributelor nu există ghilimele. Coderul le-
Atacatorul introduce ca descriere a imaginii un șir inteligent construit `foo onload=alert('Hacked!')`. Știm deja că Twig nu poate recunoaște dacă variabila se afișează în fluxul textului HTML, în interiorul unui atribut, comentariu HTML etc., pe scurt, nu distinge contextele. Și doar convertesc mecanic caracterele `< > & ' "` în entități HTML. Deci, codul rezultat va arăta astfel:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Acum să vedem cum se descurcă Latte cu același șablon:
Latte vede șablonul la fel ca dvs. Spre deosebire de Twig, înțelege HTML și știe că variabila se afișează ca valoare a unui atribut care nu este între ghilimele. De aceea, le completează. Când atacatorul introduce aceeași descriere, codul rezultat va arăta astfel:
-```html
+```latte
```
diff --git a/latte/ro/type-system.texy b/latte/ro/type-system.texy
index fc64e5ef84..508abcd9ee 100644
--- a/latte/ro/type-system.texy
+++ b/latte/ro/type-system.texy
@@ -21,7 +21,7 @@ Cum să începeți să utilizați tipurile? Creați o clasă de șablon, de exem
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-Și apoi, la începutul șablonului, introduceți tag-ul `{templateType}` cu numele complet al clasei (inclusiv namespace). Acest lucru definește că în șablon există variabilele `$langs` și `$products` inclusiv tipurile corespunzătoare. Tipurile variabilelor locale pot fi specificate folosind tag-urile [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definiții define].
+Și apoi, la începutul șablonului, introduceți tag-ul `{templateType}` cu numele complet al clasei (inclusiv namespace). Acest lucru definește că în șablon există variabilele `$lang` și `$products` inclusiv tipurile corespunzătoare. Tipurile variabilelor locale pot fi specificate folosind tag-urile [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definiții define].
Din acel moment, IDE-ul vă poate oferi sugestii corecte.
diff --git a/latte/ru/custom-tags.texy b/latte/ru/custom-tags.texy
index dc35fdad01..3c0cd691eb 100644
--- a/latte/ru/custom-tags.texy
+++ b/latte/ru/custom-tags.texy
@@ -923,7 +923,7 @@ class MyLatteExtension extends Extension
Сгенерированный HTML:
-```html
+```latte
Удалить
```
diff --git a/latte/ru/safety-first.texy b/latte/ru/safety-first.texy
index 96b91313cc..ffd79d93c4 100644
--- a/latte/ru/safety-first.texy
+++ b/latte/ru/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
Злоумышленнику достаточно в качестве описания вставить хитро составленную строку `" onload="alert('Hacked!')`, и если вывод не будет обработан, результирующий код будет выглядеть так:
-```html
+```latte
```
@@ -91,7 +91,7 @@ echo '';
Что именно подразумевается под словом контекст? Это место в документе со своими правилами обработки выводимых данных. Зависит от типа документа (HTML, XML, CSS, JavaScript, plain text, ...) и может отличаться в его конкретных частях. Например, в HTML-документе таких мест (контекстов), где действуют очень разные правила, целое множество. Возможно, вы удивитесь, сколько их. Вот первая четверка:
-```html
+```latte
@@ -108,7 +108,7 @@ echo '
';
Контексты также могут вкладываться, что происходит, когда мы вставляем JavaScript или CSS в HTML. Это можно сделать двумя разными способами, элементом и атрибутом:
-```html
+```latte
@@ -132,7 +132,7 @@ echo '
';
Если вы будете выводить ее в HTML-тексте, то в данном случае не нужно делать никаких замен, потому что строка не содержит ни одного символа со специальным значением. Другая ситуация возникнет, если вы выведете ее внутри HTML-атрибута, заключенного в одинарные кавычки. В таком случае необходимо экранировать кавычки в HTML-сущности:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Если этот код вставить в HTML-документ с помощью `
```
Однако, если бы мы хотели вставить его в HTML-атрибут, нужно еще экранировать кавычки в HTML-сущности:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
А когда мы выводим эту строку в атрибуте, еще применяем экранирование в соответствии с этим контекстом и заменяем `&` на `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Latte видит шаблон так же, как и вы. Он понимает
Злоумышленник в качестве описания изображения вставляет хитро составленную строку `foo onload=alert('Hacked!')`. Мы уже знаем, что Twig не может определить, выводится ли переменная в потоке HTML-текста, внутри атрибута, HTML-комментария и т. д., короче говоря, не различает контексты. И просто механически преобразует символы `< > & ' "` в HTML-сущности. Так что результирующий код будет выглядеть так:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Latte видит шаблон так же, как и вы. Он понимает
Latte видит шаблон так же, как и вы. В отличие от Twig, он понимает HTML и знает, что переменная выводится как значение атрибута, который не заключен в кавычки. Поэтому он их добавит. Когда злоумышленник вставит то же описание, результирующий код будет выглядеть так:
-```html
+```latte
```
diff --git a/latte/ru/type-system.texy b/latte/ru/type-system.texy
index 875667cde2..ab6a5a5d6f 100644
--- a/latte/ru/type-system.texy
+++ b/latte/ru/type-system.texy
@@ -21,7 +21,7 @@
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-А затем в начало шаблона вставьте тег `{templateType}` с полным именем класса (включая пространство имен). Это определяет, что в шаблоне есть переменные `$langs` и `$products` с соответствующими типами. Типы локальных переменных можно указать с помощью тегов [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Определения].
+А затем в начало шаблона вставьте тег `{templateType}` с полным именем класса (включая пространство имен). Это определяет, что в шаблоне есть переменные `$lang` и `$products` с соответствующими типами. Типы локальных переменных можно указать с помощью тегов [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Определения].
С этого момента IDE сможет правильно подсказывать.
diff --git a/latte/sl/custom-tags.texy b/latte/sl/custom-tags.texy
index 1066b5eb86..1bb1570146 100644
--- a/latte/sl/custom-tags.texy
+++ b/latte/sl/custom-tags.texy
@@ -923,7 +923,7 @@ Zdaj lahko uporabite `n:confirm` na povezavah, gumbih ali elementih obrazca:
Generirana HTML koda:
-```html
+```latte
Izbriši
```
diff --git a/latte/sl/safety-first.texy b/latte/sl/safety-first.texy
index 509802d6c8..29adc447e2 100644
--- a/latte/sl/safety-first.texy
+++ b/latte/sl/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
Napadalcu zadostuje, da kot opis vstavi spretno sestavljen niz `" onload="alert('Hacked!')` in če izpis ne bo obdelan, bo rezultatna koda izgledala takole:
-```html
+```latte
```
@@ -91,7 +91,7 @@ Kontekstno občutljivo ubežanje
Kaj točno se misli z besedo kontekst? Gre za mesto v dokumentu z lastnimi pravili za obdelavo izpisanih podatkov. Odvisno je od vrste dokumenta (HTML, XML, CSS, JavaScript, navadno besedilo, ...) in se lahko razlikuje v njegovih konkretnih delih. Na primer, v dokumentu HTML je takih mest (kontekstov), kjer veljajo zelo različna pravila, cela vrsta. Morda boste presenečeni, koliko jih je. Tukaj imamo prvo četverico:
-```html
+```latte
@@ -108,7 +108,7 @@ Zanimivo je znotraj komentarjev HTML. Tukaj se namreč za ubežanje ne uporablja
Konteksti se lahko tudi plastijo, do česar pride, ko vstavimo JavaScript ali CSS v HTML. To je mogoče storiti na dva različna načina, z elementom in atributom:
-```html
+```latte
@@ -132,7 +132,7 @@ Imejmo niz `Rock'n'Roll`.
Če ga boste izpisovali v besedilu HTML, ravno v tem primeru ni treba delati nobenih zamenjav, ker niz ne vsebuje nobenega znaka s posebnim pomenom. Druga situacija nastane, če ga izpišete znotraj atributa HTML, omejenega z enojnimi narekovaji. V takem primeru je treba narekovaje ubežati v HTML entitete:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Če to kodo vstavimo v dokument HTML s pomočjo `
```
Če pa bi jo želeli vstaviti v atribut HTML, moramo še ubežati narekovaje v HTML entitete:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
In ko ta niz izpišemo v atributu, še uporabimo ubežanje po tem kontekstu in zamenjamo `&` za `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Opazite, da okoli vrednosti atributov ni narekovajev. Koder jih je lahko pozabil
Napadalec kot opis slike vstavi spretno sestavljen niz `foo onload=alert('Hacked!')`. Že vemo, da Twig ne more prepoznati, ali se spremenljivka izpisuje v toku besedila HTML, znotraj atributa, komentarja HTML, itd., skratka ne razlikuje kontekstov. In samo mehansko pretvarja znake `< > & ' "` v HTML entitete. Torej bo rezultatna koda izgledala takole:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Zdaj si poglejmo, kako se z enako predlogo spopade Latte:
Latte vidi predlogo enako kot vi. Za razliko od Twiga razume HTML in ve, da se spremenljivka izpisuje kot vrednost atributa, ki ni v narekovajih. Zato jih dopolni. Ko napadalec vstavi enak opis, bo rezultatna koda izgledala takole:
-```html
+```latte
```
diff --git a/latte/sl/type-system.texy b/latte/sl/type-system.texy
index 09f661778b..e814b63fd0 100644
--- a/latte/sl/type-system.texy
+++ b/latte/sl/type-system.texy
@@ -21,7 +21,7 @@ Kako začeti uporabljati tipe? Ustvarite si razred predloge, npr. `CatalogTempla
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-Nato na začetek predloge vstavite značko `{templateType}` s polnim imenom razreda (vključno z imenskim prostorom). To definira, da so v predlogi spremenljivke `$langs` in `$products` vključno z ustreznimi tipi. Tipe lokalnih spremenljivk lahko navedete s pomočjo značk [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definicije].
+Nato na začetek predloge vstavite značko `{templateType}` s polnim imenom razreda (vključno z imenskim prostorom). To definira, da so v predlogi spremenljivke `$lang` in `$products` vključno z ustreznimi tipi. Tipe lokalnih spremenljivk lahko navedete s pomočjo značk [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Definicije].
Od takrat vam lahko IDE pravilno predlaga.
diff --git a/latte/tr/custom-tags.texy b/latte/tr/custom-tags.texy
index 402e361e28..8f582915f0 100644
--- a/latte/tr/custom-tags.texy
+++ b/latte/tr/custom-tags.texy
@@ -923,7 +923,7 @@ class MyLatteExtension extends Extension
Oluşturulan HTML:
-```html
+```latte
Sil
```
diff --git a/latte/tr/safety-first.texy b/latte/tr/safety-first.texy
index a4943315fd..9e550024e2 100644
--- a/latte/tr/safety-first.texy
+++ b/latte/tr/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
Saldırganın açıklama olarak akıllıca oluşturulmuş bir karakter dizisi `" onload="alert('Hacklendiniz!')` eklemesi yeterlidir ve yazdırma işlenmezse, sonuç kodu şöyle görünecektir:
-```html
+```latte
```
@@ -91,7 +91,7 @@ Bağlama Duyarlı Kaçış
Bağlam kelimesiyle tam olarak ne kastediliyor? Belgenin içinde, yazdırılan verilerin işlenmesi için kendi kuralları olan bir yerdir. Belgenin türüne (HTML, XML, CSS, JavaScript, düz metin, ...) bağlıdır ve belirli bölümlerinde farklılık gösterebilir. Örneğin, bir HTML belgesinde, çok farklı kuralların geçerli olduğu birçok yer (bağlam) vardır. Kaç tane olduğuna şaşırabilirsiniz. İşte ilk dördü:
-```html
+```latte
@@ -108,7 +108,7 @@ HTML yorumlarının içi ilginçtir. Burada kaçış için HTML varlıkları kul
Bağlamlar ayrıca katmanlanabilir, bu da HTML'e JavaScript veya CSS eklediğimizde olur. Bu iki farklı şekilde yapılabilir, öğe ve nitelik ile:
-```html
+```latte
@@ -132,7 +132,7 @@ Bir Örnek İster misiniz?
Bunu HTML metninde yazdırırsanız, bu özel durumda herhangi bir değiştirme yapmaya gerek yoktur, çünkü dize özel anlamı olan hiçbir karakter içermez. Tek tırnak içine alınmış bir HTML niteliği içinde yazdırırsanız durum farklıdır. Bu durumda, tırnak işaretlerini HTML varlıklarına kaçış işlemine tabi tutmak gerekir:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Bu kodu `
```
Ancak bunu bir HTML niteliğine eklemek istersek, tırnak işaretlerini de HTML varlıklarına kaçış işlemine tabi tutmamız gerekir:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
Ve bu dizeyi bir nitelikte yazdırdığımızda, bu bağlama göre kaçış işlemini de uygular ve `&` yerine `&` yazarız:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Nitelik değerlerinin etrafında tırnak işareti olmadığına dikkat edin. Kod
Saldırgan, resim açıklaması olarak akıllıca oluşturulmuş bir karakter dizisi `foo onload=alert('Hacklendiniz!')` ekler. Twig'in değişkenin HTML metin akışında mı, bir nitelik içinde mi, HTML yorumunda mı vb. yazdırıldığını anlayamayacağını, kısacası bağlamları ayırt etmediğini zaten biliyoruz. Ve yalnızca `< > & ' "` karakterlerini mekanik olarak HTML varlıklarına dönüştürür. Yani sonuç kodu şöyle görünecektir:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Sahte `onload` niteliği sayfanın bir parçası haline geldi ve tarayıcı resm
Latte şablonu sizin gördüğünüz gibi görür. Twig'in aksine, HTML'i anlar ve değişkenin tırnak içinde olmayan bir niteliğin değeri olarak yazdırıldığını bilir. Bu yüzden onları ekler. Saldırgan aynı açıklamayı eklediğinde, sonuç kodu şöyle görünecektir:
-```html
+```latte
```
diff --git a/latte/tr/type-system.texy b/latte/tr/type-system.texy
index 005ce71f91..eaf4424ee5 100644
--- a/latte/tr/type-system.texy
+++ b/latte/tr/type-system.texy
@@ -21,7 +21,7 @@ Tipleri kullanmaya nasıl başlanır? İletilen parametreleri, tiplerini ve muht
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-Ve ardından şablonun başına `{templateType}` etiketini sınıfın tam adıyla (ad alanı dahil) ekleyin. Bu, şablonda `$langs` ve `$products` değişkenlerinin ilgili tipleriyle birlikte bulunduğunu tanımlar. Yerel değişkenlerin tiplerini [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Tanımlar] etiketlerini kullanarak belirtebilirsiniz.
+Ve ardından şablonun başına `{templateType}` etiketini sınıfın tam adıyla (ad alanı dahil) ekleyin. Bu, şablonda `$lang` ve `$products` değişkenlerinin ilgili tipleriyle birlikte bulunduğunu tanımlar. Yerel değişkenlerin tiplerini [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Tanımlar] etiketlerini kullanarak belirtebilirsiniz.
O andan itibaren IDE size doğru önerilerde bulunabilir.
diff --git a/latte/uk/custom-tags.texy b/latte/uk/custom-tags.texy
index 96af747f17..c2e63f4ab1 100644
--- a/latte/uk/custom-tags.texy
+++ b/latte/uk/custom-tags.texy
@@ -923,7 +923,7 @@ class MyLatteExtension extends Extension
Згенерований HTML:
-```html
+```latte
Видалити
```
diff --git a/latte/uk/safety-first.texy b/latte/uk/safety-first.texy
index 60ff086270..b5fd634f04 100644
--- a/latte/uk/safety-first.texy
+++ b/latte/uk/safety-first.texy
@@ -33,7 +33,7 @@ echo '';
Зловмиснику достатньо як опис вставити хитро складений рядок `" onload="alert('Hacked!')`, і якщо виведення не буде оброблено, кінцевий код виглядатиме так:
-```html
+```latte
```
@@ -91,7 +91,7 @@ echo '';
Що саме мається на увазі під словом контекст? Це місце в документі з власними правилами обробки виведених даних. Воно залежить від типу документа (HTML, XML, CSS, JavaScript, plain text, ...) і може відрізнятися в його конкретних частинах. Наприклад, в HTML-документі є ціла низка таких місць (контекстів), де діють дуже різні правила. Можливо, ви будете здивовані, скільки їх є. Ось перша четвірка:
-```html
+```latte
@@ -108,7 +108,7 @@ echo '
';
Контексти також можуть нашаровуватися, що відбувається, коли ми вставляємо JavaScript або CSS в HTML. Це можна зробити двома різними способами: елементом та атрибутом:
-```html
+```latte
@@ -132,7 +132,7 @@ echo '
';
Якщо ви будете виводити його в HTML-тексті, саме в цьому випадку не потрібно робити жодних замін, оскільки рядок не містить жодного символу зі спеціальним значенням. Інша ситуація виникне, якщо ви виведете його всередині HTML-атрибута, взятого в одинарні лапки. У такому випадку потрібно екранувати лапки на HTML-сутності:
-```html
+```latte
```
@@ -152,13 +152,13 @@ alert('Rock\'n\'Roll');
Якщо цей код вставити в HTML-документ за допомогою `
```
Однак, якби ми хотіли вставити його в HTML-атрибут, ми повинні ще екранувати лапки на HTML-сутності:
-```html
+```latte
```
@@ -170,7 +170,7 @@ https://example.org/?a=Jazz&b=Rock%27n%27Roll
І коли ми виводимо цей рядок в атрибуті, ще застосовуємо екранування відповідно до цього контексту і замінюємо `&` на `&`:
-```html
+```latte
```
@@ -314,7 +314,7 @@ Latte бачить шаблон так само, як і ви. Розуміє HT
Зловмисник як опис зображення вставляє хитро складений рядок `foo onload=alert('Hacked!')`. Ми вже знаємо, що Twig не може розпізнати, чи виводиться змінна в потоці HTML-тексту, всередині атрибута, HTML-коментаря тощо, коротше кажучи, не розрізняє контексти. І лише механічно перетворює символи `< > & ' "` на HTML-сутності. Отже, кінцевий код виглядатиме так:
-```html
+```latte
```
@@ -330,7 +330,7 @@ Latte бачить шаблон так само, як і ви. Розуміє HT
Latte бачить шаблон так само, як і ви. На відміну від Twig, він розуміє HTML і знає, що змінна виводиться як значення атрибута, який не взятий у лапки. Тому він їх доповнить. Коли зловмисник вставить той самий опис, кінцевий код виглядатиме так:
-```html
+```latte
```
diff --git a/latte/uk/type-system.texy b/latte/uk/type-system.texy
index 9d6c08535b..14ea265b99 100644
--- a/latte/uk/type-system.texy
+++ b/latte/uk/type-system.texy
@@ -21,7 +21,7 @@
class CatalogTemplateParameters
{
public function __construct(
- public string $langs,
+ public string $lang,
/** @var ProductEntity[] */
public array $products,
public Address $address,
@@ -35,7 +35,7 @@ $latte->render('template.latte', new CatalogTemplateParameters(
));
```
-А далі на початку шаблону вставте тег `{templateType}` з повною назвою класу (включаючи простір імен). Це визначає, що в шаблоні є змінні `$langs` та `$products` з відповідними типами. Типи локальних змінних можна вказати за допомогою тегів [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Визначення].
+А далі на початку шаблону вставте тег `{templateType}` з повною назвою класу (включаючи простір імен). Це визначає, що в шаблоні є змінні `$lang` та `$products` з відповідними типами. Типи локальних змінних можна вказати за допомогою тегів [`{var}` |tags#var default], `{varType}`, [`{define}` |template-inheritance#Визначення].
З цього моменту ваше IDE може правильно підказувати.
diff --git a/mail/cs/@home.texy b/mail/cs/@home.texy
index c2db2cff9a..3dde556165 100644
--- a/mail/cs/@home.texy
+++ b/mail/cs/@home.texy
@@ -176,6 +176,78 @@ V šabloně potom vytváříme odkazy tak, jak jsme zvyklí. Všechny odkazy vyt
```
+Inlinování CSS
+==============
+
+[api:Nette\Mail\CssInliner] převádí CSS pravidla na inline atributy `style`, aby se e-maily zobrazovaly správně ve všech klientech. Zároveň generuje HTML atributy pro kompatibilitu s Outlookem.
+
+.[note]
+Vyžaduje PHP 8.4 nebo novější a rozšíření `dom`.
+
+Většina e-mailových klientů má omezenou podporu značky `
+