@genkaok/fenom-js 1.0.13

package/fenom-js.mjs

@@ -0,0 +1,1810 @@
+// --- ГРУППА: Переменные и присвоение ---
+const SET_PATTERNS = [
+    // 1. {set $var = {...} или [...]}
+    {
+        type: 'set',
+        regex: /^\{set\s+\$(\w+)\s*=\s*(\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}|\[[^\[\]]*(?:\[[^\[\]]*\][^\[\]]*)*\])\}/,
+        process(match) {
+            return {
+                variable: match[1], // без $
+                value: match[2].trim() // строка: "{a:1}" или "[1,2]"
+            };
+        }
+    },
+    // 2. {set $var = "строка" или 'строка'}
+    {
+        type: 'set',
+        regex: /^\{set\s+\$(\w+)\s*=\s*(['"])(.*?)\2\}/,
+        process(match) {
+            return {
+                variable: match[1],
+                value: match[3] // содержимое внутри кавычек
+            };
+        }
+    },
+    // 3. {set $var = 123 / true / $other / $a + 1}
+    {
+        type: 'set',
+        regex: /^\{set\s+\$(\w+)\s*=\s*([^{][^}]*)\}/,
+        process(match) {
+            return {
+                variable: match[1],
+                value: match[2].trim() // любое выражение: 100, $x, $count + 1 и т.д.
+            };
+        }
+    },
+    // 4. {add $var ++}
+    {
+        type: 'add',
+        regex: /^\{add\s+\$(\w+)\s*\+\+\}/,
+        process(match) {
+            return {
+                variable: match[1]
+            };
+        }
+    },
+    // 5. {var $var = "значение"} — аналог set, но может инициализировать
+    {
+        type: 'var',
+        regex: /^\{var\s+\$(\w+)\s*=\s*(['"])(.*?)\2\}/,
+        process(match) {
+            return {
+                variable: match[1],
+                value: match[3]
+            };
+        }
+    }
+];
+// --- ГРУППА: Условия ---
+const IF_PATTERNS = [
+    {
+        type: 'if',
+        regex: /^\{if\s+(.+?)\}/,
+        process(match) {
+            return { condition: match[1].trim() };
+        }
+    },
+    {
+        type: 'elseif',
+        regex: /^\{elseif\s+(.+?)\}/,
+        process(match) {
+            return { condition: match[1].trim() };
+        }
+    },
+    {
+        type: 'else',
+        regex: /^\{else\}/
+    },
+    {
+        type: 'endif',
+        regex: /^\{\/if\}/
+    }
+];
+// --- ГРУППА: Циклы ---
+const FOREACH_PATTERNS = [
+    // 1. for i..j
+    {
+        type: 'for_range',
+        regex: /^\{(for|foreach)\s+(\d+)\.\.(\d+)\s+as\s*\$(\w+)(?:\s*\|\s*reverse)?\s*\}/,
+        process(match) {
+            return {
+                start: parseInt(match[2], 10),
+                end: parseInt(match[3], 10),
+                item: match[4],
+                reverse: match[0].includes('| reverse')
+            };
+        }
+    },
+    // 2. {foreach $path.as.array as $item}
+    {
+        type: 'for',
+        regex: /^\{(for|foreach)\s*\$([^\s}]+?)\s+as\s*\$(\w+)(\s*\|\s*reverse)?\s*\}/,
+        process: (match) => ({
+            collection: `$${match[2]}`,
+            item: match[3],
+            key: null,
+            reverse: !!match[4]
+        })
+    },
+    // 3. {foreach $path as $key => $item}
+    {
+        type: 'for',
+        regex: /^\{(for|foreach)\s*\$([^\s}]+?)\s+as\s*\$(\w+)\s*=>\s*\$(\w+)(\s*\|\s*reverse)?\s*\}/,
+        process: (match) => ({
+            collection: `$${match[2]}`,
+            key: match[3],
+            item: match[4],
+            reverse: !!match[5]
+        })
+    },
+    // 3. {foreach $path as $key => $item}
+    {
+        type: 'for',
+        regex: /^\{(for|foreach)\s*\$([^\s}]+?)\s+as\s*\$(\w+)\s*=>\s*\$(\w+)(?:\s*\|\s*reverse)?\s*\}/,
+        process: (match) => ({
+            collection: `$${match[2]}`,
+            key: match[3],
+            item: match[4],
+            reverse: match[0].includes('| reverse')
+        })
+    },
+    // 4. endfor
+    {
+        type: 'endfor',
+        regex: /^\{\/(?:for|foreach)\}/
+    },
+    // 5. foreachelse
+    {
+        type: 'foreachelse',
+        regex: /^\{foreachelse\}/
+    },
+    // 6. break / continue
+    {
+        type: 'break',
+        regex: /^\{break\}/i
+    },
+    {
+        type: 'continue',
+        regex: /^\{continue\}/i
+    }
+];
+// --- ГРУППА: Switch ---
+const SWITCH_PATTERNS = [
+    {
+        type: 'switch',
+        regex: /^\{switch\s+(.+?)\}/,
+        process(match) {
+            return { value: match[1].trim() };
+        }
+    },
+    {
+        type: 'case',
+        regex: /^\{case\s+(.+?)\}/,
+        process(match) {
+            return { value: match[1].trim() };
+        }
+    },
+    {
+        type: 'default',
+        regex: /^\{default\}/
+    },
+    {
+        type: 'endswitch',
+        regex: /^\{\/switch\}/
+    }
+];
+// --- ГРУППА: Cycle ---
+const CYCLE_PATTERNS = [
+    {
+        type: 'cycle',
+        regex: /^\{cycle\s+(.+?)\}/,
+        process(match) {
+            return { values: match[1] }; // например: "'red','blue'"
+        }
+    }
+];
+// --- ГРУППА: Включение шаблонов ---
+const INCLUDE_PATTERNS = [
+    {
+        type: 'include',
+        // Поддерживает: {include 'file:...' key="value" key='value' key=$var key=word}
+        regex: /^\{include\s+['"]file:([^'"]+)['"](?:\s+((?:\s*\w+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s}]+))+))?\s*\}/,
+        process: (match) => {
+            const file = match[1];
+            const paramsPart = match[2]; // 'title="Тест" user=$currentUser'
+            const params = {};
+            if (paramsPart) {
+                // Извлекаем все `ключ=значение` через регулярку
+                const paramRegex = /(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s}]+))/g;
+                let paramMatch;
+                while ((paramMatch = paramRegex.exec(paramsPart)) !== null) {
+                    const key = paramMatch[1];
+                    const value = paramMatch[2] || paramMatch[3] || paramMatch[4] || '';
+                    params[key] = value;
+                }
+            }
+            return { file, params };
+        }
+    }
+];
+// --- ГРУППА: Наследование ---
+const EXTENDS_PATTERNS = [
+    // {extends 'file:...'}
+    {
+        type: 'extends',
+        regex: /^\{extends\s+['"]file:([^'"]+)['"]\s*\}/,
+        process: (match) => ({ file: match[1] }),
+    },
+    // {block "name"} → открывается
+    {
+        type: 'block_open',
+        regex: /^\{block\s+(['"])(.*?)\1\s*\}/,
+        process(match) {
+            return { name: match[2] };
+        }
+    },
+    // {/block} → закрывается
+    {
+        type: 'block_close',
+        regex: /^\{\/block\}/,
+    },
+    // {parent} — вставляет родительский контент блока
+    {
+        type: 'parent',
+        regex: /^\{parent\}/
+    },
+    // {paste "blockName"} — вставка другого блока (Fenom-фича)
+    {
+        type: 'paste',
+        regex: /^\{paste\s+(['"])(.*?)\1\}/,
+        process(match) {
+            return { name: match[2] };
+        }
+    },
+    // {use 'file:...'} — импорт макросов
+    {
+        type: 'use',
+        regex: /^\{use\s+(['"])(.*?)\1\}/,
+        process(match) {
+            return { file: match[2] };
+        }
+    }
+];
+// --- ГРУППА: Фильтры и экранирование ---
+const FILTER_PATTERNS = [
+    {
+        type: 'filter',
+        regex: /^\{filter\s+(.+?)\}/,
+        process(match) {
+            return { filter: match[1].trim() };
+        }
+    },
+    {
+        type: 'endfilter',
+        regex: /^\{\/filter\}/
+    },
+    {
+        type: 'raw',
+        regex: /^\{raw\}/
+    },
+    {
+        type: 'endraw',
+        regex: /^\{\/raw\}/
+    },
+    {
+        type: 'autoescape',
+        regex: /^\{autoescape\}/
+    },
+    {
+        type: 'endautoescape',
+        regex: /^\{\/autoescape\}/
+    }
+];
+// --- ГРУППА: Макросы и импорт ---
+const MACRO_PATTERNS = [
+    {
+        type: 'macro',
+        regex: /^\{macro\s+(\w+)(?:\s*\((.*?)\))?\}/,
+        process(match) {
+            const args = match[2] ? match[2].split(',').map(s => s.trim()) : [];
+            return { name: match[1], args };
+        }
+    },
+    {
+        type: 'endmacro',
+        regex: /^\{\/macro\}/
+    },
+    {
+        type: 'import',
+        regex: /^\{import\s+(['"])(.*?)\1\s+as\s+(\w+)\}/,
+        process(match) {
+            return { file: match[2], alias: match[3] };
+        }
+    }
+];
+// --- ГРУППА: Игнор ---
+const IGNORE_PATTERN = [
+    {
+        type: 'ignore_block',
+        regex: /^\{ignore\}([\s\S]*?)\{\/ignore\}/,
+        process: (match) => ({
+            content: match[1] // содержимое между {ignore} и {/ignore}
+        })
+    }
+];
+// --- ГРУППА: Прочее ---
+const MISC_PATTERNS = [
+    {
+        type: 'unset',
+        regex: /^\{unset\s+\$([^\s}]+)\}/,
+        process(match) {
+            return { variable: '$' + match[1] };
+        }
+    },
+    {
+        type: 'comment',
+        regex: /^\{\*\s*([\s\S]*?)\s*\*\}/,
+        // не нужно process — мы просто пропустим этот блок
+    }
+];
+// --- ГРУППА: Вывод переменных с модификаторами ---
+const OUTPUT_PATTERN = [
+    // 1. {output name="title"}
+    {
+        type: 'output',
+        regex: /^\{output\s+name\s*=\s*(['"])(.*?)\1\s*\}/,
+        process: (match) => ({
+            name: match[2],
+            filters: []
+        })
+    },
+    // 2. {output "$title"} или {output $title}
+    {
+        type: 'output',
+        regex: /^\{output\s+(['"])(.*?)\1\s*\}/,
+        process: (match) => ({
+            name: match[2],
+            filters: []
+        })
+    },
+    {
+        type: 'output',
+        regex: /^\{output\s+([^\s}]+)\s*\}/,
+        process: (match) => ({
+            name: match[1],
+            filters: []
+        })
+    },
+    // 3. Выражения: {output $user.age + 18}
+    {
+        type: 'output',
+        regex: /^\{output\s+(\$?[^}]+)\}/,
+        process: (match) => ({
+            name: match[1].trim(),
+            filters: []
+        })
+    },
+    // 🔥 4. ОСНОВНОЙ случай: {$var}, {$var|filter}, {$var|filter:"arg"}
+    {
+        type: 'output',
+        regex: /^\{\$(.+?)\}/, // ← нежадный — ловит всё внутри
+        process: (match) => {
+            const content = match[1].trim();
+            const parts = content.split('|').map(s => s.trim());
+            const variable = parts[0];
+            const filters = parts.slice(1);
+            return {
+                name: `$${variable}`, // → '$arr'
+                filters // → ['length']
+            };
+        }
+    },
+    // Любое выражение в { ... }, даже без $
+    {
+        type: 'output',
+        regex: /^\{([^$].+?)\}/,
+        process: (match) => {
+            const content = match[1].trim();
+            return {
+                name: content, // → '"Привет" ~ " " ~ "мир"'
+                filters: []
+            };
+        }
+    }
+];
+// Поддержка ++, --, +=, -=, *= и т.д.
+const OPERATOR_PATTERN = [
+    {
+        type: 'operator',
+        regex: /^\{\$([^\s}]+)\s*(\+\+|--|\+=|-=|\*=|\/=|\%=)\s*([^}]+)?\}/,
+        process: (match) => {
+            var _a;
+            const variable = match[1];
+            const operator = match[2];
+            const value = ((_a = match[3]) === null || _a === void 0 ? void 0 : _a.trim()) || '1';
+            return { variable: '$' + variable, operator, value };
+        }
+    }
+];
+
+// Объединяем все паттерны
+const ALL_PATTERNS = [
+    ...EXTENDS_PATTERNS,
+    ...INCLUDE_PATTERNS,
+    ...FOREACH_PATTERNS,
+    ...SWITCH_PATTERNS,
+    ...OPERATOR_PATTERN,
+    ...IF_PATTERNS,
+    ...IGNORE_PATTERN,
+    ...SET_PATTERNS,
+    ...MISC_PATTERNS,
+    ...CYCLE_PATTERNS,
+    ...FILTER_PATTERNS,
+    ...MACRO_PATTERNS,
+    ...OUTPUT_PATTERN,
+];
+function tokenize(input) {
+    const tokens = [];
+    let pos = 0;
+    while (pos < input.length) {
+        let matched = false;
+        if (input.slice(pos).startsWith('{ignore}')) {
+            let depth = 1;
+            let i = pos + 8; // длина '{ignore}'
+            while (i < input.length) {
+                if (input.length - i >= 8 && input.startsWith('{ignore}', i)) {
+                    depth++;
+                    i += 8;
+                    continue;
+                }
+                if (input.length - i >= 9 && input.startsWith('{/ignore}', i)) {
+                    depth--;
+                    i += 9;
+                    if (depth === 0) {
+                        const content = input.slice(pos + 8, i - 9);
+                        tokens.push({ type: 'ignore_block', content });
+                        pos = i;
+                        matched = true;
+                        break;
+                    }
+                    continue;
+                }
+                i++;
+            }
+            if (!matched) {
+                tokens.push({ type: 'text', value: '{ignore}' });
+                pos += 8;
+            }
+            continue;
+        }
+        if (input[pos] !== '{') {
+            const nextBrace = input.indexOf('{', pos);
+            if (nextBrace === -1) {
+                tokens.push({ type: 'text', value: input.slice(pos) });
+                break;
+            }
+            if (nextBrace > pos) {
+                tokens.push({ type: 'text', value: input.slice(pos, nextBrace) });
+            }
+            pos = nextBrace;
+        }
+        for (const pattern of ALL_PATTERNS) {
+            const substr = input.slice(pos);
+            const match = substr.match(pattern.regex);
+            if (match) {
+                if (pattern.type === 'comment') {
+                    tokens.push({ type: 'comment' });
+                    pos += match[0].length;
+                    matched = true;
+                    break;
+                }
+                const token = {
+                    type: pattern.type,
+                    value: match[0] // ← добавляем оригинальный текст токена
+                };
+                if (pattern.process) {
+                    Object.assign(token, pattern.process(match));
+                }
+                tokens.push(token);
+                pos += match[0].length;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            const context = input.slice(pos, pos + 30).replace(/\n/g, '↵');
+            console.warn(`Skip unknown tag at ${pos}: "${context}"`);
+            pos++;
+        }
+        // console.log('[TOKEN] matched:', tokens);
+    }
+    return tokens;
+}
+
+function parseIf(tokens, index) {
+    const ifToken = tokens[index];
+    const node = {
+        type: 'if',
+        condition: ifToken.condition,
+        body: [],
+        elseIfs: [],
+        elseBody: []
+    };
+    let i = index + 1;
+    let depth = 0;
+    // Собираем токены для каждой ветки
+    const bodyTokens = [];
+    const elseIfs = [];
+    const elseTokens = [];
+    let currentElseIf = null;
+    let inElseBranch = false;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        // Увеличиваем глубину для всех вложенных блоков
+        if (token.type === 'if') {
+            depth++;
+        }
+        if (token.type === 'for' || token.type === 'foreach' || token.type === 'for_range') {
+            depth++;
+        }
+        if (depth > 0) {
+            // Внутри вложенного блока — собираем токены и обновляем глубину
+            if (!currentElseIf && !inElseBranch) {
+                bodyTokens.push(token);
+            }
+            else if (currentElseIf) {
+                currentElseIf.tokens.push(token);
+            }
+            else if (inElseBranch) {
+                elseTokens.push(token);
+            }
+            // Уменьшаем глубину для закрывающих тегов
+            if (token.type === 'endif') {
+                depth--;
+            }
+            if (token.type === 'endfor' || token.type === 'endforeach') {
+                depth--;
+            }
+            i++;
+            continue;
+        }
+        // Обработка веток
+        if (token.type === 'elseif') {
+            if (!currentElseIf && !inElseBranch) {
+                currentElseIf = {
+                    condition: token.condition,
+                    tokens: []
+                };
+                elseIfs.push(currentElseIf);
+            }
+            else if (currentElseIf) {
+                currentElseIf.tokens.push(token);
+            }
+            else if (inElseBranch) {
+                elseTokens.push(token);
+            }
+            i++;
+            continue;
+        }
+        if (token.type === 'else') {
+            // 🔴 Завершаем текущий elseif
+            currentElseIf = null;
+            inElseBranch = true;
+            i++;
+            continue;
+        }
+        if (token.type === 'endif') {
+            break;
+        }
+        // Собираем токены
+        if (!currentElseIf && !inElseBranch) {
+            bodyTokens.push(token);
+        }
+        else if (currentElseIf) {
+            currentElseIf.tokens.push(token);
+        }
+        else if (inElseBranch) {
+            elseTokens.push(token);
+        }
+        i++;
+    }
+    // 🔥 ПАРСИМ собранные токены → в AST
+    node.body = parse(bodyTokens);
+    node.elseIfs = elseIfs.map(elif => ({
+        condition: elif.condition,
+        body: parse(elif.tokens)
+    }));
+    node.elseBody = parse(elseTokens);
+    // Возвращаем следующий индекс после {/if}
+    return {
+        node,
+        nextIndex: i + 1 // пропускаем {/if}
+    };
+}
+
+function parseFor(tokens, index) {
+    const token = tokens[index];
+    let node;
+    // 🔥 Обработка for_range
+    if (token.type === 'for_range') {
+        node = {
+            type: 'for_range',
+            start: token.start,
+            end: token.end,
+            item: token.item,
+            reverse: Boolean(token.reverse),
+            body: [],
+            elseBody: []
+        };
+    }
+    // Обычный for / foreach
+    else if (token.type === 'for' || token.type === 'foreach') {
+        node = {
+            type: 'for',
+            collection: token.collection,
+            item: token.item,
+            key: token.key || null,
+            reverse: Boolean(token.reverse),
+            body: [],
+            elseBody: []
+        };
+    }
+    // Неизвестный токен
+    else {
+        throw new Error(`Invalid for token at ${index}: ${token.type}`);
+    }
+    let i = index + 1;
+    let depth = 0;
+    let inElseBranch = false;
+    const bodyTokens = [];
+    const elseTokens = [];
+    while (i < tokens.length) {
+        const currentToken = tokens[i];
+        // Увеличиваем глубину для вложенных блоков (циклы и условия)
+        if (currentToken.type === 'for' || currentToken.type === 'foreach' || currentToken.type === 'for_range') {
+            depth++;
+        }
+        if (currentToken.type === 'if') {
+            depth++;
+        }
+        // Закрывающие теги
+        if (currentToken.type === 'endfor' || currentToken.type === 'endforeach') {
+            if (depth > 0) {
+                depth--;
+            }
+            else {
+                break; // выходим — нашли конец текущего цикла
+            }
+        }
+        if (currentToken.type === 'endif') {
+            if (depth > 0) {
+                depth--;
+            }
+        }
+        // Поддержка {foreachelse}
+        if (currentToken.type === 'foreachelse') {
+            if (depth === 0) {
+                inElseBranch = true;
+                i++;
+                continue;
+            }
+        }
+        // Собираем токены в нужную ветку
+        if (!inElseBranch) {
+            bodyTokens.push(currentToken);
+        }
+        else {
+            elseTokens.push(currentToken);
+        }
+        i++;
+    }
+    if (i >= tokens.length) {
+        throw new Error('Unclosed for loop: expected {/for}');
+    }
+    // Рекурсивно парсим
+    node.body = parse(bodyTokens);
+    if (elseTokens.length > 0) {
+        node.elseBody = parse(elseTokens);
+    }
+    return {
+        node,
+        nextIndex: i + 1 // пропускаем {/for}
+    };
+}
+
+function parseSwitch(tokens, index) {
+    const switchToken = tokens[index];
+    const node = {
+        type: 'switch',
+        value: switchToken.value,
+        cases: [],
+        defaultBody: []
+    };
+    let i = index + 1;
+    let depth = 0;
+    let currentCase = null;
+    let hasDefault = false;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        if (token.type === 'switch') {
+            depth++;
+        }
+        if (token.type === 'endswitch') {
+            if (depth > 0) {
+                depth--;
+                if (currentCase) {
+                    currentCase.body.push(token);
+                }
+                i++;
+                continue;
+            }
+            return {
+                node,
+                nextIndex: i + 1
+            };
+        }
+        if (depth > 0) {
+            if (currentCase) {
+                currentCase.body.push(token);
+            }
+            i++;
+            continue;
+        }
+        if (token.type === 'case') {
+            currentCase = {
+                value: token.value,
+                body: []
+            };
+            node.cases.push(currentCase);
+            i++;
+            continue;
+        }
+        if (token.type === 'default') {
+            if (hasDefault) {
+                throw new Error('Duplicate {default} in switch');
+            }
+            hasDefault = true;
+            currentCase = null; // после этого идёт defaultBody
+            i++;
+            continue;
+        }
+        // Добавляем токены в нужное место
+        if (currentCase) {
+            currentCase.body.push(token);
+        }
+        else if (hasDefault) {
+            node.defaultBody.push(token);
+        }
+        else {
+            // Пока нет default — все токены до него относятся к последнему case
+            if (node.cases.length > 0) {
+                node.cases[node.cases.length - 1].body.push(token);
+            }
+        }
+        i++;
+    }
+    throw new Error('Unclosed switch: expected {/switch}');
+}
+
+// parser/parser.ts
+function parse(tokens) {
+    const ast = [];
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        // --- Обработка block ---
+        if (token.type === 'block_open') {
+            const blockName = token.name;
+            i++; // пропускаем {block ...}
+            const blockTokens = [];
+            let depth = 0;
+            while (i < tokens.length) {
+                const current = tokens[i];
+                if (current.type === 'block_open') {
+                    depth++;
+                }
+                if (current.type === 'block_close') {
+                    if (depth === 0)
+                        break;
+                    depth--;
+                }
+                blockTokens.push(current);
+                i++;
+            }
+            const body = parse(blockTokens); // ← рекурсивно парсим содержимое
+            ast.push({
+                type: 'block',
+                name: blockName,
+                body,
+            });
+            i++; // пропускаем {/block}
+            continue;
+        }
+        // --- Обработка extends ---
+        if (token.type === 'extends') {
+            ast.push({ ...token });
+            i++;
+            continue;
+        }
+        // --- Обработка include ---
+        if (token.type === 'include') {
+            ast.push({ ...token });
+            i++;
+            continue;
+        }
+        // --- Остальные теги ---
+        if (['set', 'var', 'add'].includes(token.type)) {
+            ast.push({ ...token });
+            i++;
+            continue;
+        }
+        if (token.type === 'if') {
+            const { node, nextIndex } = parseIf(tokens, i);
+            ast.push(node);
+            i = nextIndex; // ← сначала обновляем
+            continue;
+        }
+        if (['for', 'foreach', 'for_range'].includes(token.type)) {
+            const { node, nextIndex } = parseFor(tokens, i);
+            ast.push(node);
+            i = nextIndex;
+            continue;
+        }
+        if (token.type === 'switch') {
+            const { node, nextIndex } = parseSwitch(tokens, i);
+            ast.push(node);
+            i = nextIndex;
+            continue;
+        }
+        if (token.type === 'output') {
+            const match = token.value.match(/^\{\$(.+)\}$/);
+            if (!match) {
+                ast.push({ type: 'text', value: token.value });
+                i++;
+                continue;
+            }
+            const content = match[1].trim();
+            const parts = content.split('|');
+            const variable = parts[0];
+            const filters = parts.slice(1);
+            ast.push({
+                type: 'output',
+                name: `$${variable}`,
+                filters
+            });
+            i++;
+            continue;
+        }
+        if (['elseif', 'else', 'endif', 'endfor', 'endforeach', 'endswitch'].includes(token.type)) {
+            i++;
+            continue;
+        }
+        // Простые токены
+        ast.push({ ...token });
+        i++;
+    }
+    return ast;
+}
+
+function tokenizeExpression(expr) {
+    const tokens = [];
+    const re = /(\s+|[$a-zA-Z_]\w*(?:\.\w+)*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\d+(?:\.\d+)?|[-+*/%=<>!&|?:(){}[\]~]+|[\w-]+:)/g;
+    let match;
+    const isOperator = (val) => {
+        return [
+            '+', '-', '*', '/', '%',
+            '==', '!=', '!==', '<', '<=', '>', '>=',
+            '&&', '||', '!', '(', ')', '?', ':',
+            '~' // ← добавили
+        ].includes(val);
+    };
+    while ((match = re.exec(expr)) !== null) {
+        const val = match[0].trim();
+        if (!val)
+            continue;
+        if (isOperator(val)) {
+            tokens.push({ type: 'op', value: val });
+        }
+        else if (val === '|') {
+            tokens.push({ type: 'filter', value: val });
+        }
+        else if (val.startsWith('$')) {
+            tokens.push({ type: 'var', value: val });
+        }
+        else if (/^["']/.test(val)) {
+            const str = val.slice(1, -1).replace(/\\(.)/g, '$1');
+            tokens.push({ type: 'str', value: str });
+        }
+        else if (!isNaN(+val)) {
+            tokens.push({ type: 'num', value: val });
+        }
+        else {
+            tokens.push({ type: 'str', value: val });
+        }
+    }
+    return tokens;
+}
+// Основная функция — только один раз
+function parseExpression(expr) {
+    const tokens = tokenizeExpression(expr);
+    let pos = 0;
+    function parseTernary() {
+        const test = parseLogical();
+        if (pos < tokens.length && tokens[pos].value === '?') {
+            pos++;
+            const consequent = parseExpressionInternal(); // ✅ Используем внутреннюю
+            if (pos < tokens.length && tokens[pos].value === ':')
+                pos++;
+            const alternate = parseTernary();
+            return { type: 'conditional', test, consequent, alternate };
+        }
+        return test;
+    }
+    function parseLogical() {
+        return parseBinary(() => parseEquality(), ['||', '&&']);
+    }
+    function parseEquality() {
+        return parseBinary(() => parseRelational(), ['==', '!=', '!==']);
+    }
+    function parseRelational() {
+        return parseBinary(() => parseAdditive(), ['<', '<=', '>', '>=']);
+    }
+    function parseAdditive() {
+        return parseBinary(() => parseMultiplicative(), ['+', '-', '~']);
+    }
+    function parseMultiplicative() {
+        return parseBinary(() => parseUnary(), ['*', '/', '%']);
+    }
+    function parseUnary() {
+        if (pos < tokens.length && ['!', '+', '-'].includes(tokens[pos].value)) {
+            const op = tokens[pos].value;
+            pos++;
+            return { type: 'unary', operator: op, argument: parseUnary() };
+        }
+        return parsePrimary();
+    }
+    function parsePrimary() {
+        const token = tokens[pos];
+        if (!token)
+            throw new Error('Unexpected end of expression');
+        if (token.type === 'num') {
+            pos++;
+            return { type: 'literal', value: +token.value };
+        }
+        if (token.type === 'str') {
+            pos++;
+            return { type: 'literal', value: token.value };
+        }
+        if (token.type === 'var') {
+            pos++;
+            return { type: 'variable', path: token.value.slice(1) };
+        }
+        if (token.value === '(') {
+            pos++;
+            const expr = parseTernary();
+            if (pos >= tokens.length || tokens[pos].value !== ')') {
+                throw new Error('Expected )');
+            }
+            pos++;
+            return expr;
+        }
+        throw new Error(`Unexpected token: ${token.value}`);
+    }
+    function parseBinary(parseLeft, operators) {
+        let left = parseLeft();
+        while (pos < tokens.length && operators.includes(tokens[pos].value)) {
+            const op = tokens[pos].value;
+            pos++;
+            const right = parseLeft();
+            left = { type: 'binary', operator: op, left, right };
+        }
+        return left;
+    }
+    function parseExpressionInternal() {
+        return parseTernary();
+    }
+    return parseTernary();
+}
+
+function parseValue(value) {
+    // Убираем пробелы
+    value = value.trim();
+    // Булевы
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null')
+        return null;
+    if (value === 'undefined')
+        return undefined;
+    // Число
+    if (!isNaN(+value) && !value.includes(' ')) {
+        return +value;
+    }
+    // Строка в кавычках
+    if (/^["'](.*)["']$/.test(value)) {
+        return value.slice(1, -1);
+    }
+    // Массив: ['a', 'b'] → только простые
+    if (value.startsWith('[') && value.endsWith(']')) {
+        try {
+            const items = value.slice(1, -1).split(',').map(s => s.trim());
+            return items.map(parseValue);
+        }
+        catch (_a) { }
+    }
+    // Объект: {a:1} → упрощённо
+    if (value.startsWith('{') && value.endsWith('}')) {
+        try {
+            return JSON.parse(value
+                .replace(/(\w+):/g, '"$1":')
+                .replace(/'/g, '"'));
+        }
+        catch (_b) { }
+    }
+    // Переменная? Нет — возвращаем как строку
+    // ❌ Не разрешаем $ здесь — это делает parseExpression
+    return value;
+}
+function warnFilter(name, expected, fn) {
+    return (...args) => {
+        const value = args[0];
+        let isValid = false;
+        switch (expected) {
+            case 'array':
+                isValid = Array.isArray(value) || typeof value === 'string';
+                break;
+            case 'string':
+                isValid = typeof value === 'string';
+                break;
+            case 'object':
+                isValid = value && typeof value === 'object' && !Array.isArray(value);
+                break;
+        }
+        if (!isValid) {
+            console.warn(`[Fenom] filter '${name}' should be used with ${expected}, but got ${typeof value}`);
+        }
+        return fn(...args);
+    };
+}
+function minifyHTML(html) {
+    return html
+        .replace(/>\s+</g, '><') // > < → ><
+        .replace(/\s{2,}/g, ' ') // множественные пробелы
+        .replace(/(<!--.*?-->)\s+/g, '$1') // пробелы после комментариев
+        .trim();
+}
+function getFromContext(path, context) {
+    if (!path || typeof path !== 'string')
+        return undefined;
+    const cleanPath = path.startsWith('$') ? path.slice(1) : path;
+    const tokens = [];
+    let current = '';
+    let inBracket = false;
+    for (const char of cleanPath) {
+        if (char === '.' && !inBracket) {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+        }
+        else if (char === '[') {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+            current = '[';
+            inBracket = true;
+        }
+        else if (char === ']') {
+            current += ']';
+            tokens.push(current);
+            current = '';
+            inBracket = false;
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    let value = context;
+    for (const token of tokens) {
+        if (token.startsWith('[')) {
+            const match = token.match(/^\[(?:'(.+)'|"(.+)"|(\d+))\]$/);
+            if (match) {
+                const key = match[1] || match[2] || parseInt(match[3], 10);
+                value = value === null || value === void 0 ? void 0 : value[key];
+            }
+        }
+        else {
+            value = value === null || value === void 0 ? void 0 : value[token];
+        }
+    }
+    return value;
+}
+function applyFilters(value, filterList, context, filters) {
+    let result = value;
+    for (const filter of filterList) {
+        const [name, ...args] = filter.split(':').map(s => s.trim());
+        const filterFn = filters[name];
+        if (typeof filterFn === 'function') {
+            const argValues = args.map(arg => {
+                var _a;
+                if (/^["'].*["']$/.test(arg))
+                    return arg.slice(1, -1);
+                if (!isNaN(+arg))
+                    return +arg;
+                if (arg.startsWith('$'))
+                    return (_a = getFromContext(arg.slice(1), context)) !== null && _a !== void 0 ? _a : '';
+                return arg;
+            });
+            try {
+                result = filterFn(result, ...argValues);
+            }
+            catch (e) {
+                result = '';
+            }
+        }
+    }
+    return result;
+}
+
+function evaluate(node, context, filters) {
+    var _a;
+    switch (node.type) {
+        case 'literal':
+            return node.value;
+        case 'variable':
+            return (_a = getFromContext(node.path, context)) !== null && _a !== void 0 ? _a : '';
+        case 'unary':
+            const arg = evaluate(node.argument, context, filters);
+            switch (node.operator) {
+                case '!': return !arg;
+                case '+': return +arg;
+                case '-': return -arg;
+            }
+            break;
+        case 'binary': {
+            const left = evaluate(node.left, context, filters);
+            const right = evaluate(node.right, context, filters);
+            switch (node.operator) {
+                case '+': return left + right;
+                case '-': return left - right;
+                case '*': return left * right;
+                case '/': return left / right;
+                case '%': return left % right;
+                case '==': return left == right;
+                case '!=': return left != right;
+                case '!==': return left !== right;
+                case '<': return left < right;
+                case '<=': return left <= right;
+                case '>': return left > right;
+                case '>=': return left >= right;
+                case '&&': return left && right;
+                case '||': return left || right;
+                case '~': return String(left) + String(right);
+            }
+            break;
+        }
+        case 'conditional':
+            const test = evaluate(node.test, context, filters);
+            return test
+                ? evaluate(node.consequent, context, filters)
+                : evaluate(node.alternate, context, filters);
+        case 'filter': {
+            const input = evaluate(node.expression, context, filters);
+            const args = node.args.map(arg => evaluate(arg, context, filters));
+            const filterFn = filters[node.filter];
+            if (typeof filterFn === 'function') {
+                return filterFn(input, ...args);
+            }
+            return input;
+        }
+    }
+    return '';
+}
+
+async function compileAST(ast, loader, context = {}, filters = {}) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    let result = '';
+    for (const node of ast) {
+        switch (node.type) {
+            case 'text':
+                result += node.value;
+                break;
+            case 'ignore_block':
+                result += node.content || '';
+                break;
+            case 'comment':
+                break;
+            case 'output': {
+                try {
+                    const exp = node.name.trim();
+                    let evaluated;
+                    if (/[+\-*/%<>!=&|?:~]/.test(exp)) {
+                        const ast = parseExpression(exp);
+                        evaluated = evaluate(ast, context, filters);
+                    }
+                    else {
+                        evaluated = (_a = getFromContext(exp, context)) !== null && _a !== void 0 ? _a : '';
+                    }
+                    const filtered = applyFilters(evaluated, node.filters, context, filters);
+                    result += String(filtered);
+                }
+                catch (e) {
+                    console.warn(`Eval error: ${node.name}`, e);
+                    result += '';
+                }
+                break;
+            }
+            case 'set': {
+                try {
+                    const valueStr = node.value.trim();
+                    if (/[+\-*/%~]/.test(valueStr)) {
+                        const ast = parseExpression(valueStr);
+                        context[node.variable] = evaluate(ast, context, filters);
+                    }
+                    else if (valueStr.startsWith('$')) {
+                        context[node.variable] = (_b = getFromContext(valueStr, context)) !== null && _b !== void 0 ? _b : '';
+                    }
+                    else {
+                        context[node.variable] = parseValue(valueStr);
+                    }
+                }
+                catch (e) {
+                    context[node.variable] = '';
+                }
+                break;
+            }
+            case 'var':
+                if (context[node.variable] === undefined) {
+                    context[node.variable] = parseValue(node.value);
+                }
+                break;
+            case 'add':
+                context[node.variable] = (context[node.variable] || 0) + 1;
+                break;
+            case 'if': {
+                let cond = false;
+                try {
+                    const ast = parseExpression(node.condition);
+                    cond = !!evaluate(ast, context, filters);
+                }
+                catch (e) {
+                    console.warn(`Condition error: ${node.condition}`, e);
+                }
+                const body = cond
+                    ? node.body
+                    : (((_d = (_c = node.elseIfs) === null || _c === void 0 ? void 0 : _c.find((elseIf) => {
+                        try {
+                            const ast = parseExpression(elseIf.condition);
+                            return !!evaluate(ast, context, filters);
+                        }
+                        catch (_a) {
+                            return false;
+                        }
+                    })) === null || _d === void 0 ? void 0 : _d.body) || node.elseBody || []);
+                result += await compileAST(body, loader, context, filters);
+                break;
+            }
+            case 'for_range': {
+                const { start, end, item, reverse, body, elseBody } = node;
+                const range = [];
+                for (let i = start; i <= end; i++) {
+                    range.push(i);
+                }
+                if (reverse)
+                    range.reverse();
+                let innerResult = '';
+                if (range.length === 0 && elseBody) {
+                    innerResult += await compileAST(elseBody, loader, context, filters);
+                }
+                else {
+                    for (const value of range) {
+                        const newContext = { ...context };
+                        newContext[item] = value;
+                        newContext.loop = {
+                            index: value - start + 1,
+                            first: value === (reverse ? end : start),
+                            last: value === (reverse ? start : end),
+                            key: value - start
+                        };
+                        innerResult += await compileAST(body, loader, newContext, filters);
+                    }
+                }
+                result += innerResult;
+                break;
+            }
+            case 'for': {
+                const collectionPath = node.collection.startsWith('$') ? node.collection.slice(1) : node.collection;
+                const collection = getFromContext(collectionPath, context);
+                let items = [];
+                if (Array.isArray(collection)) {
+                    items = Array.from(collection.entries());
+                }
+                else if (collection && typeof collection === 'object') {
+                    items = Object.entries(collection);
+                }
+                if (node.reverse)
+                    items = items.reverse();
+                if (items.length === 0 && node.elseBody) {
+                    result += await compileAST(node.elseBody, loader, context, filters);
+                }
+                else {
+                    for (const [index, itemValue] of items) {
+                        const newContext = { ...context };
+                        newContext[node.item] = itemValue;
+                        if (node.key)
+                            newContext[node.key] = index;
+                        newContext.loop = {
+                            index: index + 1,
+                            first: index === 0,
+                            last: index === items.length - 1,
+                            key: index,
+                        };
+                        result += await compileAST(node.body, loader, newContext, filters);
+                    }
+                }
+                break;
+            }
+            case 'switch': {
+                const rawValue = node.value.startsWith('$') ? node.value.slice(1) : node.value;
+                const value = (_e = getFromContext(rawValue, context)) !== null && _e !== void 0 ? _e : rawValue;
+                let matched = false;
+                for (const c of node.cases) {
+                    // Case values can be strings like "a" or variables
+                    const caseValue = c.value.startsWith('$')
+                        ? getFromContext(c.value.slice(1), context)
+                        : c.value.replace(/^["']|["']$/g, '');
+                    if (caseValue === value) {
+                        result += await compileAST(c.body, loader, context, filters);
+                        matched = true;
+                        break;
+                    }
+                }
+                if (!matched && node.defaultBody) {
+                    result += await compileAST(node.defaultBody, loader, context, filters);
+                }
+                break;
+            }
+            case 'operator': {
+                const { variable, operator, value } = node;
+                const varName = variable.startsWith('$') ? variable.slice(1) : variable;
+                let numValue = isNaN(+value) ? (_f = getFromContext(value, context)) !== null && _f !== void 0 ? _f : 0 : +value;
+                const currentValue = (_g = getFromContext(variable, context)) !== null && _g !== void 0 ? _g : 0;
+                switch (operator) {
+                    case '++':
+                        context[varName] = currentValue + 1;
+                        break;
+                    case '--':
+                        context[varName] = currentValue - 1;
+                        break;
+                    case '+=':
+                        context[varName] = currentValue + numValue;
+                        break;
+                    case '-=':
+                        context[varName] = currentValue - numValue;
+                        break;
+                    case '*=':
+                        context[varName] = currentValue * numValue;
+                        break;
+                    case '/=':
+                        context[varName] = currentValue / numValue;
+                        break;
+                    case '%=':
+                        context[varName] = currentValue % numValue;
+                        break;
+                }
+                break;
+            }
+            case 'block':
+                if (typeof context.block === 'function') {
+                    result += await context.block(node.name);
+                }
+                break;
+            case 'include': {
+                if (!loader) {
+                    console.warn(`{include '${node.file}'} ignored: no loader`);
+                    break;
+                }
+                try {
+                    const includedTemplate = await loader(node.file);
+                    const tokens = tokenize(includedTemplate);
+                    const includedAST = parse(tokens);
+                    const html = await compileAST(includedAST, loader, { ...context, ...node.params }, filters);
+                    result += html;
+                }
+                catch (err) {
+                    result += `<span style="color:red">[Include error: ${err.message}]</span>`;
+                }
+                break;
+            }
+            case 'extends':
+                break;
+            default:
+                console.warn(`Unknown node type: ${node.type}`);
+        }
+    }
+    return result;
+}
+
+function compile(ast, loader) {
+    const blocks = {};
+    let parentFile = null;
+    for (const node of ast) {
+        if (node.type === 'extends') {
+            parentFile = node.file;
+        }
+        else if (node.type === 'block') {
+            blocks[node.name] = node.body;
+        }
+    }
+    if (parentFile) {
+        return async function (context, filters) {
+            if (!loader) {
+                throw new Error(`Template uses {extends '${parentFile}'}, but no loader provided`);
+            }
+            try {
+                const template = await loader(parentFile);
+                const tokens = tokenize(template);
+                const parentAst = parse(tokens);
+                const parentBlocks = {};
+                for (const node of parentAst) {
+                    if (node.type === 'block') {
+                        parentBlocks[node.name] = node.body;
+                    }
+                }
+                const finalBlocks = { ...parentBlocks, ...blocks };
+                const blockContent = {};
+                context.block = async (name) => {
+                    if (blockContent[name] !== undefined)
+                        return blockContent[name];
+                    const blockAst = finalBlocks[name];
+                    if (!blockAst) {
+                        blockContent[name] = '';
+                        return '';
+                    }
+                    blockContent[name] = await compileAST(blockAst, loader, context, filters);
+                    return blockContent[name];
+                };
+                return await compileAST(parentAst, loader, context, filters);
+            }
+            catch (err) {
+                return `[Render error: ${err.message}]`;
+            }
+        };
+    }
+    else {
+        return async function (context, filters) {
+            return await compileAST(ast, loader, context, filters);
+        };
+    }
+}
+
+const filters = {
+    // ——— Строковые фильтры ————————————————————————
+    /**
+     * Преобразует строку в верхний регистр
+     */
+    upper: (s) => String(s).toUpperCase(),
+    /**
+     * Преобразует строку в нижний регистр
+     */
+    lower: (s) => String(s).toLowerCase(),
+    /**
+     * Делает первую букву строки заглавной, остальные — строчными
+     * 'аННА' → 'Анна'
+     */
+    capitalize: (s) => {
+        const str = String(s).trim();
+        if (str.length === 0)
+            return '';
+        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+    },
+    /**
+     * Аналог capitalize (для совместимости)
+     */
+    ucfirst: (s) => filters.capitalize(s),
+    /**
+     * Делает первую букву каждого слова заглавной
+     * 'hello world' → 'Hello World'
+     */
+    ucwords: (s) => {
+        const str = String(s).trim();
+        return str.replace(/\b\w/g, (match) => match.toUpperCase());
+    },
+    /**
+     * Делает первую букву строки строчной
+     * 'Hello' → 'hello'
+     */
+    lcfirst: (s) => {
+        const str = String(s).trim();
+        if (str.length === 0)
+            return '';
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    },
+    /**
+     * Удаляет пробелы с краёв строки
+     */
+    trim: (s) => String(s).trim(),
+    /**
+     * Удаляет пробелы слева
+     */
+    ltrim: (s) => String(s).replace(/^\s+/, ''),
+    /**
+     * Удаляет пробелы справа
+     */
+    rtrim: (s) => String(s).replace(/\s+$/, ''),
+    /**
+     * Преобразует \n → <br>
+     */
+    nl2br: (s) => String(s).replace(/\n/g, '<br>'),
+    /**
+     * Заменяет подстроку
+     * {$str|replace:'old':'new'}
+     */
+    replace: (s, search, replace) => {
+        const str = String(s);
+        return str.split(String(search)).join(String(replace));
+    },
+    /**
+     * Обрезает строку
+     * {$str|substr:0:5}
+     */
+    substr: warnFilter('substr', 'string', (s, start, length) => {
+        const str = String(s);
+        return length === undefined ? str.slice(start) : str.slice(start, start + length);
+    }),
+    /**
+     * Кодирует строку в URL
+     */
+    urlencode: (s) => encodeURIComponent(String(s)),
+    /**
+     * Декодирует URL
+     */
+    urldecode: (s) => decodeURIComponent(String(s)),
+    /**
+     * Экранирует HTML-символы
+     */
+    escape: warnFilter('escape', 'string', (s) => {
+        const str = String(s);
+        return str
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;');
+    }),
+    /**
+     * Синоним escape
+     */
+    e: (s) => filters.escape(s),
+    // ——— Работа с массивами ——————————————————————
+    /**
+     * Первый элемент массива/объекта
+     */
+    first: warnFilter('first', 'array', (arr) => {
+        if (Array.isArray(arr))
+            return arr[0];
+        if (arr && typeof arr === 'object')
+            return Object.values(arr)[0];
+        return '';
+    }),
+    /**
+     * Последний элемент массива/объекта
+     */
+    last: warnFilter('last', 'array', (arr) => {
+        if (Array.isArray(arr))
+            return arr[arr.length - 1];
+        if (arr && typeof arr === 'object') {
+            const values = Object.values(arr);
+            return values[values.length - 1];
+        }
+        return '';
+    }),
+    /**
+     * Объединяет массив в строку
+     * {$arr|join:', '}
+     */
+    join: warnFilter('join', 'array', (arr, separator = ',') => {
+        if (Array.isArray(arr))
+            return arr.join(separator);
+        if (arr && typeof arr === 'object')
+            return Object.values(arr).join(separator);
+        return String(arr);
+    }),
+    /**
+     * Переворачивает массив или строку
+     */
+    reverse: warnFilter('reverse', 'array', (arr) => {
+        return Array.isArray(arr) ? [...arr].reverse() : arr;
+    }),
+    /**
+     * Сортирует массив по значениям
+     */
+    sort: warnFilter('sort', 'array', (arr) => {
+        if (Array.isArray(arr))
+            return [...arr].sort();
+        return arr;
+    }),
+    /**
+     * Сортирует массив по ключам
+     */
+    ksort: warnFilter('ksort', 'object', (obj) => {
+        if (obj && typeof obj === 'object') {
+            const sorted = {};
+            Object.keys(obj).sort().forEach(key => {
+                sorted[key] = obj[key];
+            });
+            return sorted;
+        }
+        return obj;
+    }),
+    /**
+     * Возвращает только уникальные значения
+     */
+    unique: warnFilter('unique', 'array', (arr) => {
+        if (Array.isArray(arr))
+            return [...new Set(arr)];
+        return arr;
+    }),
+    /**
+     * Перемешивает массив
+     */
+    shuffle: warnFilter('shuffle', 'array', (arr) => {
+        if (!Array.isArray(arr))
+            return arr;
+        const newArr = [...arr];
+        for (let i = newArr.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [newArr[i], newArr[j]] = [newArr[j], newArr[i]];
+        }
+        return newArr;
+    }),
+    /**
+     * Возвращает срез массива/строки
+     * {$arr|slice:0:2}
+     */
+    slice: (arr, start, length) => {
+        if (Array.isArray(arr) || typeof arr === 'string') {
+            return length === undefined ? arr.slice(start) : arr.slice(start, start + length);
+        }
+        return arr;
+    },
+    /**
+     * Объединяет два массива
+     * {$arr1|merge:$arr2}
+     */
+    merge: (arr1, arr2) => {
+        if (Array.isArray(arr1) && Array.isArray(arr2)) {
+            return [...arr1, ...arr2];
+        }
+        return arr1;
+    },
+    /**
+     * Разбивает массив на группы
+     * {$items|batch:3}
+     */
+    batch: (arr, size) => {
+        if (!Array.isArray(arr))
+            return arr;
+        const result = [];
+        for (let i = 0; i < arr.length; i += size) {
+            result.push(arr.slice(i, i + size));
+        }
+        return result;
+    },
+    /**
+     * Возвращает ключи массива/объекта
+     */
+    keys: (obj) => {
+        return obj && typeof obj === 'object' ? Object.keys(obj) : [];
+    },
+    /**
+     * Возвращает значения массива/объекта
+     */
+    values: (obj) => (obj && typeof obj === 'object' ? Object.values(obj) : []),
+    /**
+     * Длина строки или количество элементов
+     */
+    length: (arr) => {
+        if (Array.isArray(arr))
+            return arr.length;
+        if (arr && typeof arr === 'object')
+            return Object.keys(arr).length;
+        return String(arr).length;
+    },
+    // ——— Форматирование и числа ——————————————————
+    /**
+     * Форматирует число
+     * {$price|number_format:2:'.':','}
+     */
+    number_format: (num, decimals = 0, decPoint = '.', thousandsSep = ',') => {
+        const n = Number(num);
+        if (isNaN(n))
+            return '';
+        return n.toLocaleString('en-US', {
+            minimumFractionDigits: decimals,
+            maximumFractionDigits: decimals,
+            useGrouping: true
+        }).replace(/,/g, thousandsSep).replace(/\./g, decPoint);
+    },
+    /**
+     * Абсолютное значение
+     */
+    abs: (n) => Math.abs(Number(n) || 0),
+    /**
+     * Округляет число
+     */
+    round: (n, precision = 0) => {
+        const factor = 10 ** precision;
+        return Math.round((Number(n) || 0) * factor) / factor;
+    },
+    // ——— JSON ————————————————————————————————
+    /**
+     * Кодирует в JSON
+     */
+    json_encode: (data) => JSON.stringify(data),
+    /**
+     * Декодирует из JSON
+     */
+    json_decode: (str) => {
+        try {
+            return JSON.parse(String(str));
+        }
+        catch (_a) {
+            return null;
+        }
+    },
+    // ——— Дата ————————————————————————————————
+    /**
+     * Форматирует timestamp
+     * Формат: d.m.Y H:i:s
+     */
+    date: (timestamp, format = 'd.m.Y') => {
+        const n = Number(timestamp);
+        const d = new Date(isNaN(n) ? timestamp : n * 1000);
+        if (isNaN(d.getTime())) {
+            console.warn(`[Fenom] filter 'date' received invalid timestamp: ${timestamp}`);
+            return '';
+        }
+        const pad = (n) => n.toString().padStart(2, '0');
+        return format
+            .replace(/d/g, pad(d.getDate()))
+            .replace(/m/g, pad(d.getMonth() + 1))
+            .replace(/Y/g, d.getFullYear().toString())
+            .replace(/H/g, pad(d.getHours()))
+            .replace(/i/g, pad(d.getMinutes()))
+            .replace(/s/g, pad(d.getSeconds()));
+    },
+    // ——— Прочее ——————————————————————————————
+    /**
+     * Возвращает значение по умолчанию, если пусто
+     */
+    default: (s, def) => {
+        return (s == null || s === '' || (typeof s === 'object' && Object.keys(s).length === 0))
+            ? def
+            : s;
+    },
+    /**
+     * Вывод без изменений
+     */
+    raw: (s) => s,
+    /**
+     * Отладка: вывод структуры
+     */
+    var_dump: (data) => {
+        return `<pre>${JSON.stringify(data, null, 2)}</pre>`;
+    },
+    /**
+     * Отладка: красивый вывод
+     */
+    print_r: (data) => {
+        return `<pre>${data instanceof Object ? JSON.stringify(data, null, 2) : String(data)}</pre>`;
+    }
+};
+
+async function FenomJs(template, options) {
+    const { context = {}, loader, minify = false, debug = false } = options || {};
+    try {
+        const tokens = tokenize(template);
+        if (debug)
+            console.log('tokens', tokens);
+        const ast = parse(tokens);
+        if (debug)
+            console.log('ast', ast);
+        const compiled = compile(ast, loader);
+        const html = await compiled(context, filters);
+        return minify ? minifyHTML(html) : html;
+    }
+    catch (err) {
+        console.error('Template error:', err);
+        return `<span style="color:red">[Ошибка шаблона: ${err.message}]</span>`;
+    }
+}
+
+export { FenomJs, compile, parse, tokenize };
+//# sourceMappingURL=fenom-js.mjs.map