jcc-express-mvc 1.8.7 → 1.8.21

package/lib/Templating-engine/index.js

@@ -4,60 +4,196 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compile = exports.jsBladeEngine = void 0;
+exports.compileString = compileString;
+exports.clearCache = clearCache;
 const Config_1 = require("../Config/Config");
 const engineHelper_1 = require("./engineHelper");
+const errors_1 = require("./errors");
+const plugins_1 = require("./plugins");
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const colors_1 = __importDefault(require("colors"));
+const app_root_path_1 = __importDefault(require("app-root-path"));
+/** Cache for extends result (layout merge) - avoids re-reading layout on every request */
+const extendsCache = new Map();
+const CACHE_ENABLED = Config_1.config.get("APP_ENV") === "production";
 class TemplatingEngine extends engineHelper_1.EngineHelpers {
     constructor() {
         super(...arguments);
         this.option = {};
+        this.parseDepth = 0;
+    }
+    /** Directive dispatch - ordered by specificity (longest prefix first). */
+    getDirectiveHandler(matched) {
+        const D = [
+            ["@includeUnless", this.includeUnless],
+            ["@includeWhen", this.includeWhen],
+            ["@includeIf", this.includeIf],
+            ["@include", this.includes],
+            ["@push", this.handlePush],
+            ["@prepend", this.handlePrepend],
+            ["@stack", this.handleStack],
+            ["@production", this.handleProduction],
+            ["@env", this.handleEnv],
+            ["@forelse", this.handleForelse],
+            ["@foreach", this.handleLoop],
+            ["@for", this.handleFor],
+            ["@while", this.handleWhile],
+            ["@switch", this.handleSwitch],
+            ["@unless", this.handleUnless],
+            ["@isset", this.handleIsset],
+            ["@empty", this.handleEmpty],
+            ["@auth", this.auth],
+            ["@guest", this.guest],
+            ["@if", this.handleCondition],
+            ["@ternary", this.ternary],
+            ["{{--", this.handleBladeComment],
+            ["{!!", this.handleVariable],
+            ["{{", this.handleVariable],
+            ["@json", this.handleJson],
+            ["@script(", this.handleScriptPath],
+            ["@script", this.handleScript],
+            ["@js", this.handleJs],
+            ["@inertia", this.inertia],
+            ["@viteReact", this.viteReactRefresh],
+            ["@vite([", this.vite],
+            ["@verbatim", this.handleVerbatim],
+            ["@method", this.handleMethod],
+            ["@csrf", this.handleCsrf],
+        ];
+        for (let i = 0; i < D.length; i++) {
+            if (matched.startsWith(D[i][0]))
+                return D[i][1];
+        }
+        return null;
+    }
+    /** Find leftmost directive match (avoids duplicate named groups from combined regex). */
+    findFirstMatch(content) {
+        let best = null;
+        let bestIndex = Infinity;
+        const dirs = this.directives;
+        for (let i = 0; i < TemplatingEngine.PREFIX_TO_KEY.length; i++) {
+            const [, key] = TemplatingEngine.PREFIX_TO_KEY[i];
+            const regex = dirs[key];
+            if (!regex)
+                continue;
+            const m = content.match(regex);
+            if (m && m.index !== undefined && m.index < bestIndex) {
+                bestIndex = m.index;
+                best = m;
+                if (bestIndex === 0)
+                    return best;
+            }
+        }
+        const customPatterns = (0, plugins_1.getCustomPatterns)();
+        for (let i = 0; i < customPatterns.length; i++) {
+            const re = new RegExp(customPatterns[i]);
+            const m = content.match(re);
+            if (m && m.index !== undefined && m.index < bestIndex) {
+                bestIndex = m.index;
+                best = m;
+                if (bestIndex === 0)
+                    return best;
+            }
+        }
+        return best;
     }
     /**
-     * Handles variable directives in the template content.
-     * @param {string} content - Template content.
-     * @param {Object} match - Match object from the regular expression.
-     * @param {Object} param - Local variables for rendering.
-     * @returns {string} - Rendered content.
+     * Handles Blade comments {{-- --}} - strips entirely from output.
+     */
+    handleBladeComment(content, match, param) {
+        const { beforMatch, afterMatch } = this.content(content, match);
+        return this.parser(beforMatch + afterMatch, param);
+    }
+    /**
+     * Handles variable directives - {{ }} escaped (Laravel-style), {!! !!} raw.
+     * Supports JS methods: join, split, trim, toUpperCase, etc. e.g. {{ items.join(', ') }}
      */
     handleVariable(content, match, param) {
-        const variableName = match.groups.param || "";
-        if (variableName.trim().startsWith("assets")) {
+        const variableName = (match.groups?.param || "").trim();
+        const isRaw = match[0].startsWith("{!!");
+        if (variableName.startsWith("assets")) {
             const assets = this.getAssets(variableName);
-            const newContent = content.replace(/{{\s*([^}]+)\s*}}/, assets);
+            const newContent = content.slice(0, match.index) +
+                assets +
+                content.slice(match.index + match[0].length);
             return this.parser(newContent, param);
         }
-        const variableValue = this.accessNestedProperty(param, variableName);
-        const newContent = content.replace(/{{\s*([^}]+)\s*}}/, variableValue);
+        const variableValue = this.resolveVariableExpression(variableName, param);
+        const output = isRaw || variableValue === ""
+            ? String(variableValue ?? "")
+            : this.htmlspecialchars(variableValue);
+        const newContent = content.slice(0, match.index) +
+            output +
+            content.slice(match.index + match[0].length);
         return this.parser(newContent, param);
     }
     /**
-     * Handles the @foreach directive in the template content.
-     * @param {string} content - Template content.
-     * @param {Object} match - Match object from the regular expression.
-     * @param {Object} param - Local variables for rendering.
-     * @returns {string} - Rendered content.
+     * Handles the @foreach directive (Laravel-style with $loop variable).
      */
     handleLoop(content, match, param) {
         let result = "";
-        const loopData = this.accessNestedProperty(param, match?.groups.loopData);
-        if (Array.isArray(loopData)) {
+        const loopData = this.accessNestedProperty(param, match?.groups?.loopData?.trim());
+        const loopVar = match?.groups?.loopvariable?.trim();
+        if (Array.isArray(loopData) && loopVar) {
             const loopBody = match.groups.loopBody;
-            result = loopData
-                .map((item, index) => {
-                const loopContext = {
-                    ...param,
-                    [match.groups.loopvariable]: item,
-                };
-                loopContext[match.groups.loopvariable]["loopIndex"] = index;
-                return this.parser(loopBody + "@endforeach", loopContext);
-            })
-                .join("");
+            const count = loopData.length;
+            const parts = [];
+            for (let index = 0; index < count; index++) {
+                const item = loopData[index];
+                const loopContext = Object.assign({}, param, {
+                    [loopVar]: item,
+                    loop: {
+                        index,
+                        first: index === 0,
+                        last: index === count - 1,
+                        count,
+                        even: index % 2 === 1,
+                        odd: index % 2 === 0,
+                    },
+                });
+                Object.defineProperty(loopContext[loopVar], "loopIndex", {
+                    value: index,
+                    enumerable: true,
+                });
+                parts.push(this.parser(loopBody + "@endforeach", loopContext));
+            }
+            result = parts.join("");
         }
         const { afterMatch, beforMatch } = this.content(content, match);
         const afterListResult = this.parser(afterMatch, param);
-        const finalResult = beforMatch + result + afterListResult;
-        return finalResult.replace(/@endforeach/gm, "");
+        return (beforMatch + result + afterListResult).replace(/@endforeach/gm, "");
+    }
+    /**
+     * Handles @forelse - foreach with @empty fallback (Laravel-style).
+     */
+    handleForelse(content, match, param) {
+        const loopData = this.accessNestedProperty(param, match?.groups?.loopData?.trim());
+        const loopVar = match?.groups?.loopvariable?.trim();
+        const { afterMatch, beforMatch } = this.content(content, match);
+        if (Array.isArray(loopData) && loopData.length > 0 && loopVar) {
+            const loopBody = match.groups.loopBody;
+            const count = loopData.length;
+            const parts = [];
+            for (let index = 0; index < count; index++) {
+                const item = loopData[index];
+                const loopContext = Object.assign({}, param, {
+                    [loopVar]: item,
+                    loop: {
+                        index,
+                        first: index === 0,
+                        last: index === count - 1,
+                        count,
+                        even: index % 2 === 1,
+                        odd: index % 2 === 0,
+                    },
+                });
+                parts.push(this.parser(loopBody, loopContext));
+            }
+            return this.parser(beforMatch + parts.join("") + afterMatch, param);
+        }
+        const emptyBody = match.groups?.emptyBody || "";
+        return this.parser(beforMatch + emptyBody + afterMatch, param);
     }
     /**
      * Handles the @if directive in the template content.
@@ -66,16 +202,41 @@ class TemplatingEngine extends engineHelper_1.EngineHelpers {
      * @param {Object} param - Local variables for rendering.
      * @returns {string} - Rendered content.
      */
+    /**
+     * Handles @if with @elseif and @else (Laravel-style).
+     */
     handleCondition(content, match, param) {
+        const ifData = (match?.groups?.ifData || "").trim();
+        const fullBody = match?.groups?.ifBody || "";
         let result = "";
-        const ifData = match?.groups.ifData;
-        const value = this.evaluateCondition(ifData, param);
-        if (value) {
-            result = this.parser(match.groups?.ifBody, param);
+        const parts = [];
+        let pos = 0;
+        const re = /@elseif\s*\(([^)]+)\)\s*|@else\s*/g;
+        let m;
+        parts.push({ type: "if", cond: ifData, body: "" });
+        while ((m = re.exec(fullBody)) !== null) {
+            parts[parts.length - 1].body = fullBody.slice(pos, m.index).trim();
+            if (m[0].startsWith("@elseif")) {
+                parts.push({ type: "elseif", cond: m[1].trim(), body: "" });
+                pos = m.index + m[0].length;
+            }
+            else {
+                parts.push({
+                    type: "else",
+                    body: fullBody.slice(m.index + m[0].length).trim(),
+                });
+                break;
+            }
         }
-        else {
-            if (match?.groups?.elseBody) {
-                result = this.parser(match.groups?.elseBody, param);
+        if (parts[parts.length - 1].body === "" &&
+            parts[parts.length - 1].type !== "else") {
+            parts[parts.length - 1].body = fullBody.slice(pos).trim();
+        }
+        for (const part of parts) {
+            if (part.type === "else" ||
+                (part.cond && this.evaluateCondition(part.cond, param))) {
+                result = this.parser(part.body, param);
+                break;
             }
         }
         const { beforMatch, afterMatch } = this.content(content, match);
@@ -89,14 +250,11 @@ class TemplatingEngine extends engineHelper_1.EngineHelpers {
      * @returns {string} - Rendered content.
      */
     ternary(content, match, param) {
-        let result = "";
-        const value = this.evaluateCondition(content, param);
-        if (value) {
-            result = this.parser(match.groups?.trueData, param);
-        }
-        else {
-            result = this.parser(match.groups?.falseData, param);
-        }
+        const condition = (match?.groups?.condition || "").trim();
+        const value = this.evaluateCondition(condition, param);
+        const result = value
+            ? this.parser(match.groups?.trueData ?? "", param)
+            : this.parser(match.groups?.falseData ?? "", param);
         const { beforMatch, afterMatch } = this.content(content, match);
         return beforMatch + result + this.parser(afterMatch, param);
     }
@@ -130,11 +288,232 @@ class TemplatingEngine extends engineHelper_1.EngineHelpers {
         if (includePath) {
             const includeContent = this.readFile(`views/${includePath}`);
             const { afterMatch, beforMatch } = this.content(content, match);
+            const extraData = this.parseIncludeData(match?.groups?.includeData, param);
+            const mergedParam = extraData ? { ...param, ...extraData } : param;
             const remainStr = this.parser(afterMatch, param);
-            return this.parser(beforMatch + includeContent + remainStr, param);
+            return this.parser(beforMatch + includeContent + remainStr, mergedParam);
         }
         return content;
     }
+    /**
+     * Parses the inline data object from @include("path", { key: value }).
+     * Supports string literals, numbers, booleans, and variable references (including dot notation).
+     * String concatenation with + is supported (e.g. "/path/" + job.id).
+     */
+    parseIncludeData(dataStr, param) {
+        if (!dataStr)
+            return null;
+        const inner = dataStr.trim().slice(1, -1).trim();
+        if (!inner)
+            return null;
+        const result = {};
+        const pairs = this.splitIncludeArgs(inner);
+        for (const pair of pairs) {
+            const colonIdx = pair.indexOf(":");
+            if (colonIdx === -1)
+                continue;
+            const key = pair.slice(0, colonIdx).trim();
+            const rawValue = pair.slice(colonIdx + 1).trim();
+            result[key] = this.resolveIncludeValue(rawValue, param);
+        }
+        return Object.keys(result).length > 0 ? result : null;
+    }
+    /** Split key:value pairs by comma, respecting quoted strings. */
+    splitIncludeArgs(str) {
+        const parts = [];
+        let current = "";
+        let depth = 0;
+        let inQuote = "";
+        for (let i = 0; i < str.length; i++) {
+            const c = str[i];
+            if (inQuote) {
+                current += c;
+                if (c === inQuote && str[i - 1] !== "\\")
+                    inQuote = "";
+            }
+            else if (c === '"' || c === "'") {
+                current += c;
+                inQuote = c;
+            }
+            else if (c === "{") {
+                current += c;
+                depth++;
+            }
+            else if (c === "}") {
+                current += c;
+                depth--;
+            }
+            else if (c === "," && depth === 0) {
+                parts.push(current.trim());
+                current = "";
+            }
+            else {
+                current += c;
+            }
+        }
+        if (current.trim())
+            parts.push(current.trim());
+        return parts;
+    }
+    /** Resolve a value expression: quoted string, number, boolean, concatenation, or variable. */
+    resolveIncludeValue(raw, param) {
+        if (/^\d+(\.\d+)?$/.test(raw))
+            return Number(raw);
+        if (raw === "true")
+            return true;
+        if (raw === "false")
+            return false;
+        if (raw === "null")
+            return null;
+        if (raw.includes("+")) {
+            const segments = raw.split("+").map((s) => s.trim());
+            return segments
+                .map((seg) => this.resolveIncludeValue(seg, param))
+                .join("");
+        }
+        const qm = raw.match(/^(['"])(.*)\1$/);
+        if (qm)
+            return qm[2];
+        return this.accessNestedProperty(param, raw);
+    }
+    includeIf(content, match, param) {
+        const viewPath = this.removeQuotes(match?.groups?.incIfPath || "").trim();
+        if (!viewPath || !this.viewExists(`views/${viewPath}`)) {
+            const { afterMatch, beforMatch } = this.content(content, match);
+            return this.parser(beforMatch + afterMatch, param);
+        }
+        const includeContent = this.readFile(`views/${viewPath}`);
+        const { afterMatch, beforMatch } = this.content(content, match);
+        return this.parser(beforMatch + includeContent + afterMatch, param);
+    }
+    includeWhen(content, match, param) {
+        const cond = (match?.groups?.incWhenCond || "").trim();
+        const path = this.removeQuotes(match?.groups?.incWhenPath || "").trim();
+        const { afterMatch, beforMatch } = this.content(content, match);
+        if (!this.evaluateCondition(cond, param)) {
+            return this.parser(beforMatch + afterMatch, param);
+        }
+        const includeContent = this.readFile(`views/${path}`);
+        return this.parser(beforMatch + includeContent + afterMatch, param);
+    }
+    includeUnless(content, match, param) {
+        const cond = (match?.groups?.incUnlessCond || "").trim();
+        const path = this.removeQuotes(match?.groups?.incUnlessPath || "").trim();
+        const { afterMatch, beforMatch } = this.content(content, match);
+        if (this.evaluateCondition(cond, param)) {
+            return this.parser(beforMatch + afterMatch, param);
+        }
+        const includeContent = this.readFile(`views/${path}`);
+        return this.parser(beforMatch + includeContent + afterMatch, param);
+    }
+    handleFor(content, match, param) {
+        const varName = match?.groups?.forVar?.trim();
+        const start = parseInt(match?.groups?.forStart ?? "0", 10);
+        const end = parseInt(match?.groups?.forEnd ?? "0", 10);
+        const step = parseInt(match?.groups?.forStep ?? "1", 10);
+        const body = match?.groups?.forBody ?? "";
+        let result = "";
+        for (let i = start; step > 0 ? i < end : i > end; i += step) {
+            const ctx = { ...param, [varName]: i };
+            result += this.parser(body, ctx);
+        }
+        const { afterMatch, beforMatch } = this.content(content, match);
+        return this.parser(beforMatch + result + afterMatch, param);
+    }
+    handleWhile(content, match, param) {
+        const cond = (match?.groups?.whileCond || "").trim();
+        const body = match?.groups?.whileBody ?? "";
+        let result = "";
+        let iterations = 0;
+        const maxIterations = 10000;
+        while (this.evaluateCondition(cond, param) &&
+            iterations++ < maxIterations) {
+            result += this.parser(body, param);
+        }
+        const { afterMatch, beforMatch } = this.content(content, match);
+        return this.parser(beforMatch + result + afterMatch, param);
+    }
+    handleSwitch(content, match, param) {
+        const switchVar = (match?.groups?.switchVar || "").trim();
+        const body = match?.groups?.switchBody ?? "";
+        const switchVal = this.accessNestedProperty(param, switchVar);
+        const caseRe = /@case\s*\(([^)]+)\)|@default\b/g;
+        const cases = [];
+        let pos = 0;
+        let m;
+        while ((m = caseRe.exec(body)) !== null) {
+            if (cases.length)
+                cases[cases.length - 1].body = body
+                    .slice(pos, m.index)
+                    .replace(/@break\b/g, "");
+            if (m[0].startsWith("@case")) {
+                cases.push({
+                    type: "case",
+                    value: this.removeQuotes(m[1]).trim(),
+                    body: "",
+                });
+            }
+            else {
+                cases.push({ type: "default", body: "" });
+            }
+            pos = m.index + m[0].length;
+        }
+        if (cases.length)
+            cases[cases.length - 1].body = body.slice(pos).replace(/@break\b/g, "");
+        let result = "";
+        for (const c of cases) {
+            if (c.type === "default" ||
+                String(this.removeQuotes(c.value)) === String(switchVal)) {
+                result = this.parser(c.body, param);
+                break;
+            }
+        }
+        const { afterMatch, beforMatch } = this.content(content, match);
+        return this.parser(beforMatch + result + afterMatch, param);
+    }
+    handleProduction(content, match, param) {
+        const body = match?.groups?.prodBody ?? "";
+        const { afterMatch, beforMatch } = this.content(content, match);
+        const result = Config_1.config.get("APP_ENV") === "production" ? this.parser(body, param) : "";
+        return this.parser(beforMatch + result + afterMatch, param);
+    }
+    handleEnv(content, match, param) {
+        const envNames = (match?.groups?.envNames || "")
+            .split(",")
+            .map((s) => this.removeQuotes(s.trim()));
+        const body = match?.groups?.envBody ?? "";
+        const currentEnv = Config_1.config.get("APP_ENV") || "";
+        const matchEnv = envNames.some((e) => e === currentEnv);
+        const { afterMatch, beforMatch } = this.content(content, match);
+        const result = matchEnv ? this.parser(body, param) : "";
+        return this.parser(beforMatch + result + afterMatch, param);
+    }
+    handlePush(content, match, param) {
+        const name = this.removeQuotes(match?.groups?.pushName || "").trim();
+        const body = match?.groups?.pushBody ?? "";
+        if (!param.__bladeStacks)
+            param.__bladeStacks = {};
+        param.__bladeStacks[name] =
+            (param.__bladeStacks[name] || "") + this.parser(body, param);
+        const { afterMatch, beforMatch } = this.content(content, match);
+        return this.parser(beforMatch + afterMatch, param);
+    }
+    handlePrepend(content, match, param) {
+        const name = this.removeQuotes(match?.groups?.prependName || "").trim();
+        const body = match?.groups?.prependBody ?? "";
+        if (!param.__bladeStacks)
+            param.__bladeStacks = {};
+        param.__bladeStacks[name] =
+            this.parser(body, param) + (param.__bladeStacks[name] || "");
+        const { afterMatch, beforMatch } = this.content(content, match);
+        return this.parser(beforMatch + afterMatch, param);
+    }
+    handleStack(content, match, param) {
+        const name = this.removeQuotes(match?.groups?.stackName || "").trim();
+        const stackContent = param?.__bladeStacks?.[name] || "";
+        const { afterMatch, beforMatch } = this.content(content, match);
+        return this.parser(beforMatch + stackContent + afterMatch, param);
+    }
     /**
      * Handles the @auth directive in the template content.
      * @param {string} content - Template content.
@@ -144,15 +523,15 @@ class TemplatingEngine extends engineHelper_1.EngineHelpers {
      */
     auth(content, match, param) {
         let result = "";
-        if (Object.values(param?.Auth || {}).length > 1) {
-            const authData = match?.groups?.authData?.replace(/(\'|\")/g, "");
-            if ((authData && param?.Auth?.role === authData) ||
+        const auth = param?.Auth;
+        const isAuthenticated = auth && typeof auth === "object" && Object.keys(auth).length > 0;
+        if (isAuthenticated) {
+            const authData = match?.groups?.authData?.replace(/(\'|\")/g, "").trim();
+            if (!authData ||
+                param?.Auth?.role === authData ||
                 param?.Auth?.roleType === authData ||
                 param?.Auth?.isAdmin) {
-                result = match?.groups?.authBody;
-            }
-            if (!authData) {
-                result = match?.groups?.authBody;
+                result = match?.groups?.authBody ?? "";
             }
         }
         const { beforMatch, afterMatch } = this.content(content, match);
@@ -196,77 +575,303 @@ class TemplatingEngine extends engineHelper_1.EngineHelpers {
         const { beforMatch, afterMatch } = this.content(content, match);
         let viteClientRefresh = "";
         if (Config_1.config.get("APP_ENV") != "production") {
-            viteClientRefresh = this.injectReactRefefresh();
+            viteClientRefresh = this.injectReactRefresh();
         }
         return this.parser(beforMatch + viteClientRefresh + afterMatch);
     }
     /**
      * Parses the template content based on the defined directives.
-     * @param {string} content - Template content.
-     * @param {Object} param - Local variables for rendering.
-     * @returns {string} - Rendered content.
+     * Uses pre-compiled regex for performance.
      */
     parser(content, param = this.option) {
-        const match = content.match(new RegExp(Object.values(this.directives)
-            .map((regex) => `(${regex.source})`)
-            .join("|")));
-        if (!match)
-            return content;
-        switch (true) {
-            case match[0].startsWith("@include"):
-                return this.includes(content, match, param);
-            case match[0].startsWith("@foreach"):
-                return this.handleLoop(content, match, param);
-            case match[0].startsWith("@auth"):
-                return this.auth(content, match, param);
-            case match[0].startsWith("@guest"):
-                return this.guest(content, match, param);
-            case match[0].startsWith("@if"):
-                return this.handleCondition(content, match, param);
-            case match[0].startsWith("@ternary"):
-                return this.ternary(content, match, param);
-            case match[0].startsWith("{{"):
-                return this.handleVariable(content, match, param);
-            case match[0].startsWith("@inertia"):
-                return this.inertia(content, match, param);
-            case match[0].startsWith("@viteReact"):
-                return this.viteReactRefresh(content, match, param);
-            case match[0].startsWith("@vite(["):
-                return this.vite(content, match, param);
-            default:
+        if (++this.parseDepth > TemplatingEngine.MAX_PARSE_DEPTH) {
+            this.parseDepth = 0;
+            throw new errors_1.TemplateError("Maximum parse depth exceeded - possible circular include or infinite recursion");
+        }
+        try {
+            const match = this.findFirstMatch(content);
+            if (!match)
                 return content;
+            const matched = match[0];
+            const custom = (0, plugins_1.findCustomDirective)(matched, match);
+            if (custom) {
+                return custom.handler(content, match, param, (c, p) => this.parser(c, p));
+            }
+            const handler = this.getDirectiveHandler(matched);
+            if (handler)
+                return handler.call(this, content, match, param);
+            return content;
+        }
+        finally {
+            this.parseDepth--;
+        }
+    }
+    handleVerbatim(content, match, param) {
+        const verbatimBody = match?.groups?.verbatimBody ?? "";
+        const { beforMatch, afterMatch } = this.content(content, match);
+        return beforMatch + verbatimBody + this.parser(afterMatch, param);
+    }
+    handleUnless(content, match, param) {
+        const cond = (match?.groups?.unlessData || "").trim();
+        const body = match?.groups?.unlessBody ?? "";
+        const { beforMatch, afterMatch } = this.content(content, match);
+        const result = this.evaluateCondition(cond, param)
+            ? ""
+            : this.parser(body, param);
+        return this.parser(beforMatch + result + afterMatch, param);
+    }
+    handleIsset(content, match, param) {
+        const key = (match?.groups?.issetData || "").trim();
+        const body = match?.groups?.issetBody ?? "";
+        const isSet = this.hasNestedProperty(param, key);
+        const { beforMatch, afterMatch } = this.content(content, match);
+        const result = isSet ? this.parser(body, param) : "";
+        return this.parser(beforMatch + result + afterMatch, param);
+    }
+    handleEmpty(content, match, param) {
+        const key = (match?.groups?.emptyData || "").trim();
+        const body = match?.groups?.emptyBody ?? "";
+        const val = this.accessNestedProperty(param, key);
+        const isEmpty = val === "" ||
+            val === undefined ||
+            val === null ||
+            val === false ||
+            val === 0 ||
+            val === "0" ||
+            (Array.isArray(val) && val.length === 0) ||
+            (typeof val === "object" &&
+                val !== null &&
+                Object.keys(val).length === 0);
+        const { beforMatch, afterMatch } = this.content(content, match);
+        const result = isEmpty ? this.parser(body, param) : "";
+        return this.parser(beforMatch + result + afterMatch, param);
+    }
+    handleJson(content, match, param) {
+        const key = (match?.groups?.jsonParam || "").trim();
+        const val = this.accessNestedProperty(param, key);
+        const json = JSON.stringify(val ?? null);
+        const { beforMatch, afterMatch } = this.content(content, match);
+        return this.parser(beforMatch + this.escapeJsonForHtml(json) + afterMatch, param);
+    }
+    /**
+     * Handles @csrf - outputs a hidden input with the CSRF token from res.locals._token.
+     */
+    handleCsrf(content, match, param) {
+        const token = param?._token ?? "";
+        const hidden = `<input type="hidden" name="_token" value="${token}">`;
+        const { beforMatch, afterMatch } = this.content(content, match);
+        return this.parser(beforMatch + hidden + afterMatch, param);
+    }
+    /**
+     * Handles @method('PUT') or @method(variable) - outputs a hidden input for HTTP method spoofing.
+     */
+    handleMethod(content, match, param) {
+        const raw = (match?.groups?.methodValue ?? "").trim();
+        const qm = raw.match(/^(['"])(.*)\1$/);
+        const method = (qm ? qm[2] : String(this.accessNestedProperty(param, raw))).toUpperCase();
+        const hidden = `<input type="hidden" name="_method" value="${method}">`;
+        const { beforMatch, afterMatch } = this.content(content, match);
+        return this.parser(beforMatch + hidden + afterMatch, param);
+    }
+    /**
+     * Handles @js ... @endjs - executes JavaScript on the server only.
+     * Variables and functions declared (const/let/var) are merged into template scope for use in {{ }}.
+     * Strip const/let/var so assignments go to sandbox (param) - var/undeclared assign to global.
+     */
+    handleJs(content, match, param) {
+        const jsBody = (match?.groups?.jsBody ?? "").trim();
+        try {
+            const vm = require("node:vm");
+            const sandbox = { ...param };
+            let stripped = jsBody.replace(/\b(const|let|var)\s+/g, " ");
+            stripped = stripped.replace(/([;}\d"'`])\s*(\w+\s*=)/g, "$1; $2");
+            vm.runInNewContext(stripped, sandbox);
+            Object.assign(param, sandbox);
+        }
+        catch (err) {
+            console.error("[TemplatingEngine] @js execution error:", err?.message);
         }
+        const { beforMatch, afterMatch } = this.content(content, match);
+        return this.parser(beforMatch + afterMatch, param);
+    }
+    /**
+     * Handles @script ... @endscript - outputs content as a script block for client-side.
+     * Body is parsed for {{ }} so you can inject template variables.
+     */
+    handleScript(content, match, param) {
+        const scriptBody = (match?.groups?.scriptBody ?? "").trim();
+        const parsed = this.parser(scriptBody, param);
+        const { beforMatch, afterMatch } = this.content(content, match);
+        return this.parser(beforMatch + "<script>" + parsed + "</script>" + afterMatch, param);
+    }
+    /**
+     * Handles @script('path') - includes a script from resources/js.
+     * Path is the filename (e.g. 'main' -> resources/js/main.jsx)
+     */
+    handleScriptPath(content, match, param) {
+        const scriptPath = (match?.groups?.scriptPath ?? "").trim();
+        const ext = scriptPath.includes(".") ? "" : ".jsx";
+        const resolvePath = `resources/js/${scriptPath.replace(/\./g, "/")}${ext}`;
+        const { beforMatch, afterMatch } = this.content(content, match);
+        return this.parser(this.getAssetPath(resolvePath, beforMatch, afterMatch), param);
     }
     /**
      * Compiles the template content by processing directives and extending layouts.
-     * @param {string} content - Template content.
-     * @returns {Promise<string>} - Compiled content.
+     * Caches extends result in production for performance.
      */
-    async compiler(content) {
-        const newContent = await this.extends(content);
-        const finalContent = this.parser(newContent);
-        return finalContent
-            .replace(/(\{\{\-\-)/gm, "<!--")
-            .replace(/(\-\-\}\})/gm, "-->");
+    async compiler(content, cacheKey) {
+        let newContent;
+        if (CACHE_ENABLED && cacheKey) {
+            const cached = extendsCache.get(cacheKey);
+            if (cached !== undefined) {
+                newContent = cached;
+            }
+            else {
+                newContent = await this.extends(content);
+                extendsCache.set(cacheKey, newContent);
+            }
+        }
+        else {
+            newContent = await this.extends(content);
+        }
+        newContent = this.collectBladeStacks(newContent, this.option);
+        return this.parser(newContent);
+    }
+    getExtendsCacheKey(content, resolvedPath) {
+        if (!CACHE_ENABLED)
+            return null;
+        const stat = fs_1.default.statSync(resolvedPath);
+        let key = `${resolvedPath}:${stat.mtimeMs}`;
+        const extendsMatch = content.match(this.directives.extends);
+        if (extendsMatch?.groups?.extendPath) {
+            const layoutDotPath = this.removeQuotes(extendsMatch.groups.extendPath).replace(/\./g, "/");
+            const layoutPath = path_1.default.join(app_root_path_1.default.path, "resources", "views", layoutDotPath + ".blade.html");
+            if (fs_1.default.existsSync(layoutPath)) {
+                key += `:${layoutPath}:${fs_1.default.statSync(layoutPath).mtimeMs}`;
+            }
+        }
+        return key;
+    }
+    /** Pre-collects @push/@prepend so @stack works (layout typically has @stack before @push in doc order). */
+    collectBladeStacks(content, param) {
+        if (!param.__bladeStacks)
+            param.__bladeStacks = {};
+        const expandIncludes = (str, depth = 0) => {
+            if (depth > 20)
+                return str;
+            const incMatch = str.match(/@include\((?<path>['"][^'"]+['"])\)/);
+            if (!incMatch)
+                return str;
+            const p = this.removeQuotes(incMatch.groups?.path || "").trim();
+            const included = this.readFile(`views/${p}`);
+            const { beforMatch, afterMatch } = this.content(str, incMatch);
+            return expandIncludes(beforMatch + included + afterMatch, depth + 1);
+        };
+        let expanded = expandIncludes(content);
+        const pushRe = /@push\s*\((?<name>['"][^'"]+['"])\)(?<body>[\s\S]*?)@endpush/g;
+        const prependRe = /@prepend\s*\((?<name>['"][^'"]+['"])\)(?<body>[\s\S]*?)@endprepend/g;
+        expanded = expanded.replace(pushRe, (match) => {
+            const m = match.match(/@push\s*\((?<name>['"][^'"]+['"])\)(?<body>[\s\S]*?)@endpush/);
+            if (m?.groups) {
+                const name = this.removeQuotes(m.groups.name).trim();
+                param.__bladeStacks[name] =
+                    (param.__bladeStacks[name] || "") + this.parser(m.groups.body, param);
+            }
+            return "";
+        });
+        expanded = expanded.replace(prependRe, (match) => {
+            const m = match.match(/@prepend\s*\((?<name>['"][^'"]+['"])\)(?<body>[\s\S]*?)@endprepend/);
+            if (m?.groups) {
+                const name = this.removeQuotes(m.groups.name).trim();
+                param.__bladeStacks[name] =
+                    this.parser(m.groups.body, param) + (param.__bladeStacks[name] || "");
+            }
+            return "";
+        });
+        return expanded;
     }
     async render(filePath, locals, callback) {
         try {
-            const content = fs_1.default.readFileSync(filePath, "utf-8");
-            this.option = locals;
-            const renderedContent = await this.compiler(content);
+            locals.url = request().url;
+            locals.fullUrl = request().fullUrl();
+            const resolvedPath = path_1.default.isAbsolute(filePath)
+                ? filePath
+                : path_1.default.join(app_root_path_1.default.path, filePath);
+            const content = fs_1.default.readFileSync(resolvedPath, "utf-8");
+            this.option = { __bladeStacks: {}, ...locals };
+            const cacheKey = this.getExtendsCacheKey(content, resolvedPath);
+            const renderedContent = await this.compiler(content, cacheKey);
             return callback(null, renderedContent);
         }
         catch (error) {
-            return console.log(colors_1.default.red(error.message));
-            // throw new AppError(error?.message, DEFAULT_ENGINE_ERROR);
+            const err = error instanceof errors_1.TemplateError
+                ? error
+                : new errors_1.TemplateError(error?.message ?? "Unknown error", undefined, undefined, filePath);
+            console.log(colors_1.default.red(err.toString()));
+            return callback(error, null);
         }
     }
     Content(path, option) {
         return this.parser(`${this.readFile(path)}`, option);
     }
+    /** Compile template string with data (public for compileString, benchmarks). */
+    compileTemplate(template, data = {}) {
+        const param = { __bladeStacks: {}, ...data };
+        return this.parser(template, param);
+    }
+    /** No-op for API compatibility (call after registerDirective/clearCustomDirectives). */
+    clearCombinedRegex() { }
 }
+/** Prefix -> directive key for regex lookup (avoids duplicate named groups in combined regex). */
+TemplatingEngine.PREFIX_TO_KEY = [
+    ["@includeUnless", "includeUnless"],
+    ["@includeWhen", "includeWhen"],
+    ["@includeIf", "includeIf"],
+    ["@include", "include"],
+    ["@push", "push"],
+    ["@prepend", "prepend"],
+    ["@stack", "stack"],
+    ["@production", "production"],
+    ["@env", "env"],
+    ["@forelse", "forelse"],
+    ["@foreach", "foreach"],
+    ["@for", "for"],
+    ["@while", "while"],
+    ["@switch", "switch"],
+    ["@unless", "unless"],
+    ["@isset", "isset"],
+    ["@empty", "empty"],
+    ["@auth", "auth"],
+    ["@guest", "guest"],
+    ["@if", "if"],
+    ["@ternary", "ternary"],
+    ["{{--", "bladeComment"],
+    ["{!!", "rawVariable"],
+    ["{{", "variable"],
+    ["@json", "json"],
+    ["@script(", "scriptPath"],
+    ["@script", "script"],
+    ["@js", "js"],
+    ["@inertia", "inertia"],
+    ["@viteReact", "viteReactRefresh"],
+    ["@vite([", "vite"],
+    ["@verbatim", "verbatim"],
+    ["@method", "methodField"],
+    ["@csrf", "csrf"],
+];
+TemplatingEngine.MAX_PARSE_DEPTH = 500;
 const engine = new TemplatingEngine();
+/** Clear the extends cache and path cache (e.g. after file changes or plugin changes in dev). */
+function clearCache() {
+    extendsCache.clear();
+    engine.clearCombinedRegex();
+    engine.clearPathCache();
+}
 const compile = engine.Content.bind(engine);
 exports.compile = compile;
+/** Compile a template string with data (for benchmarking, tests). */
+function compileString(template, data = {}) {
+    return engine.compileTemplate(template, data);
+}
 const jsBladeEngine = engine;
 exports.jsBladeEngine = jsBladeEngine;