tezx 2.0.11 → 3.0.0

package/cjs/jwt/node.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sign = sign;
+exports.verify = verify;
+const node_buffer_1 = require("node:buffer");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function base64url(input) {
+    return node_buffer_1.Buffer.from(input)
+        .toString("base64")
+        .replace(/=/g, "")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+}
+function parseExpiry(exp) {
+    const match = exp.match(/^(\d+)([smhd])$/);
+    if (!match)
+        return parseInt(exp, 10);
+    const [, val, unit] = match;
+    const num = parseInt(val, 10);
+    switch (unit) {
+        case "s":
+            return num;
+        case "m":
+            return num * 60;
+        case "h":
+            return num * 3600;
+        case "d":
+            return num * 86400;
+        default:
+            return num;
+    }
+}
+function base64urlDecode(input) {
+    input = input.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = input.length % 4;
+    if (pad)
+        input += "=".repeat(4 - pad);
+    return node_buffer_1.Buffer.from(input, "base64").toString("utf8");
+}
+function sign(payload, options) {
+    const header = {
+        alg: options?.algorithm || "HS256",
+        typ: "JWT",
+    };
+    const now = Math.floor(Date.now() / 1000);
+    const exp = typeof options?.expiresIn === "string"
+        ? now + parseExpiry(options.expiresIn)
+        : typeof options?.expiresIn === "number"
+            ? now + options.expiresIn
+            : now + 86400;
+    const fullPayload = { ...payload, iat: now, exp };
+    const encodedHeader = base64url(JSON.stringify(header));
+    const encodedPayload = base64url(JSON.stringify(fullPayload));
+    const data = `${encodedHeader}.${encodedPayload}`;
+    const secret = options?.secret || process.env.JWT_SECRET || "tezx_secret";
+    const signature = node_crypto_1.default
+        .createHmac(header.alg === "HS512" ? "sha512" : "sha256", secret)
+        .update(data)
+        .digest("base64")
+        .replace(/=/g, "")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+    return `${data}.${signature}`;
+}
+function verify(token, secret) {
+    try {
+        const [encodedHeader, encodedPayload, signature] = token.split(".");
+        const data = `${encodedHeader}.${encodedPayload}`;
+        const decodedHeader = JSON.parse(base64urlDecode(encodedHeader));
+        const expectedSig = node_crypto_1.default
+            .createHmac(decodedHeader.alg === "HS512" ? "sha512" : "sha256", secret || process.env.JWT_SECRET || "tezx_secret")
+            .update(data)
+            .digest("base64")
+            .replace(/=/g, "")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_");
+        if (expectedSig !== signature)
+            return null;
+        const payload = JSON.parse(base64urlDecode(encodedPayload));
+        if (payload.exp && Date.now() / 1000 > payload.exp)
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+exports.default = {
+    verify,
+    sign,
+};

package/cjs/jwt/web.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sign = sign;
+exports.verify = verify;
+function parseExpiry(exp) {
+    const match = exp.match(/^(\d+)([smhd])$/);
+    if (!match)
+        return parseInt(exp, 10);
+    const [, val, unit] = match;
+    const num = parseInt(val, 10);
+    switch (unit) {
+        case "s":
+            return num;
+        case "m":
+            return num * 60;
+        case "h":
+            return num * 3600;
+        case "d":
+            return num * 86400;
+        default:
+            return num;
+    }
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function uint8ToBase64(u8) {
+    let binary = "";
+    const len = u8.length;
+    for (let i = 0; i < len; i++)
+        binary += String.fromCharCode(u8[i]);
+    return typeof btoa !== "undefined" ? btoa(binary) : fallbackBtoa(binary);
+}
+function base64ToUint8(base64) {
+    const bin = typeof atob !== "undefined" ? atob(base64) : fallbackAtob(base64);
+    const len = bin.length;
+    const u8 = new Uint8Array(len);
+    for (let i = 0; i < len; i++)
+        u8[i] = bin.charCodeAt(i);
+    return u8;
+}
+function base64urlFromUint8(u8) {
+    return uint8ToBase64(u8)
+        .replace(/=/g, "")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+}
+function base64urlEncodeString(str) {
+    return base64urlFromUint8(encoder.encode(str));
+}
+function base64urlDecodeToString(input) {
+    let b64 = input.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = b64.length % 4;
+    if (pad)
+        b64 += "=".repeat(4 - pad);
+    const u8 = base64ToUint8(b64);
+    return decoder.decode(u8);
+}
+function constantTimeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let res = 0;
+    for (let i = 0; i < a.length; i++) {
+        res |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return res === 0;
+}
+function mapAlg(alg) {
+    if (alg === "HS256")
+        return { name: "HMAC", hash: "SHA-256" };
+    return { name: "HMAC", hash: "SHA-512" };
+}
+async function importKey(secret, alg) {
+    const keyData = encoder.encode(secret);
+    return crypto.subtle.importKey("raw", keyData, mapAlg(alg), false, [
+        "sign",
+        "verify",
+    ]);
+}
+async function hmacSign(key, data) {
+    const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(data));
+    return new Uint8Array(sig);
+}
+function fallbackBtoa(binaryStr) {
+    let base64 = "";
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let i = 0;
+    const len = binaryStr.length;
+    while (i < len) {
+        const c1 = binaryStr.charCodeAt(i++) & 0xff;
+        if (i === len) {
+            base64 += chars.charAt(c1 >> 2);
+            base64 += chars.charAt((c1 & 0x3) << 4);
+            base64 += "==";
+            break;
+        }
+        const c2 = binaryStr.charCodeAt(i++);
+        if (i === len) {
+            base64 += chars.charAt(c1 >> 2);
+            base64 += chars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xf0) >> 4));
+            base64 += chars.charAt((c2 & 0xf) << 2);
+            base64 += "=";
+            break;
+        }
+        const c3 = binaryStr.charCodeAt(i++);
+        base64 += chars.charAt(c1 >> 2);
+        base64 += chars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xf0) >> 4));
+        base64 += chars.charAt(((c2 & 0xf) << 2) | ((c3 & 0xc0) >> 6));
+        base64 += chars.charAt(c3 & 0x3f);
+    }
+    return base64;
+}
+function fallbackAtob(b64) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let output = "";
+    let i = 0;
+    b64 = b64.replace(/[^A-Za-z0-9\+\/]/g, "");
+    while (i < b64.length) {
+        const enc1 = chars.indexOf(b64.charAt(i++));
+        const enc2 = chars.indexOf(b64.charAt(i++));
+        const enc3 = chars.indexOf(b64.charAt(i++));
+        const enc4 = chars.indexOf(b64.charAt(i++));
+        const chr1 = (enc1 << 2) | (enc2 >> 4);
+        const chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+        const chr3 = ((enc3 & 3) << 6) | enc4;
+        output += String.fromCharCode(chr1);
+        if (enc3 !== 64 && enc3 !== -1)
+            output += String.fromCharCode(chr2);
+        if (enc4 !== 64 && enc4 !== -1)
+            output += String.fromCharCode(chr3);
+    }
+    return output;
+}
+async function sign(payload, opts) {
+    const alg = (opts?.algorithm || "HS256");
+    const secret = opts?.secret || globalThis.JWT_SECRET || "tezx_secret";
+    const header = { alg, typ: "JWT" };
+    const now = Math.floor(Date.now() / 1000);
+    const exp = typeof opts?.expiresIn === "string"
+        ? now + parseExpiry(opts.expiresIn)
+        : typeof opts?.expiresIn === "number"
+            ? now + opts.expiresIn
+            : now + 86400;
+    const fullPayload = { ...payload, iat: now, exp };
+    const encodedHeader = base64urlEncodeString(JSON.stringify(header));
+    const encodedPayload = base64urlEncodeString(JSON.stringify(fullPayload));
+    const data = `${encodedHeader}.${encodedPayload}`;
+    const key = await importKey(secret, alg);
+    const sigU8 = await hmacSign(key, data);
+    const signature = base64urlFromUint8(sigU8);
+    return `${data}.${signature}`;
+}
+async function verify(token, secret) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            return null;
+        const [eh, ep, sig] = parts;
+        const data = `${eh}.${ep}`;
+        const headerJson = base64urlDecodeToString(eh);
+        const header = JSON.parse(headerJson);
+        const alg = header?.alg === "HS512" ? "HS512" : "HS256";
+        const s = secret || globalThis.JWT_SECRET || "tezx_secret";
+        const key = await importKey(s, alg);
+        const expectedSigU8 = await hmacSign(key, data);
+        const expectedSig = base64urlFromUint8(expectedSigU8);
+        if (!constantTimeEqual(expectedSig, sig))
+            return null;
+        const payloadJson = base64urlDecodeToString(ep);
+        const payload = JSON.parse(payloadJson);
+        if (payload.exp && Date.now() / 1000 > payload.exp)
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+exports.default = { sign, verify };

package/cjs/middleware/basic-auth.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicAuth = void 0;
+const error_js_1 = require("../core/error.js");
+const buffer_js_1 = require("../utils/buffer.js");
+const basicAuth = (options) => {
+    const { validate, realm = "Restricted Area", onUnauthorized = (ctx, error) => {
+        ctx.setStatus = 401;
+        ctx.headers.set("WWW-Authenticate", `Basic realm="${realm}"`);
+        return ctx.json({ error: error?.message || "Unauthorized" });
+    }, } = options;
+    return async (ctx, next) => {
+        const auth = ctx.req.header("authorization");
+        if (!auth || !auth.startsWith("Basic ")) {
+            return onUnauthorized(ctx, new error_js_1.TezXError("Basic authentication required"));
+        }
+        const base64 = auth.slice(6).trim();
+        if (!base64) {
+            return onUnauthorized(ctx, new error_js_1.TezXError("Empty credentials"));
+        }
+        let username, password;
+        try {
+            const decoded = (0, buffer_js_1.base64Decode)(base64);
+            const idx = decoded.indexOf(":");
+            if (idx === -1)
+                throw new error_js_1.TezXError("Missing colon in credentials", 400);
+            username = decoded.slice(0, idx);
+            password = decoded.slice(idx + 1);
+            const valid = await validate(username, password, ctx);
+            if (!valid) {
+                return onUnauthorized(ctx, new error_js_1.TezXError("Invalid username or password", 403));
+            }
+            ctx.user = { username };
+            await next();
+        }
+        catch (err) {
+            return onUnauthorized(ctx, (0, error_js_1.TezXErrorParse)(err));
+        }
+    };
+};
+exports.basicAuth = basicAuth;
+exports.default = exports.basicAuth;

package/cjs/middleware/bearer-auth.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bearerAuth = void 0;
+const error_js_1 = require("../core/error.js");
+const bearerAuth = (options) => {
+    const { validate, realm = "API", onUnauthorized = (ctx, error) => {
+        ctx.setStatus = 401;
+        ctx.setHeader("WWW-Authenticate", `Bearer realm="${realm}"`);
+        return ctx.json({ error: error?.message || "Unauthorized" });
+    }, } = options;
+    return async (ctx, next) => {
+        const auth = ctx.req.header("authorization");
+        if (!auth || !auth.startsWith("Bearer ")) {
+            return onUnauthorized(ctx, new error_js_1.TezXError("Bearer token required"));
+        }
+        const token = auth.slice(7).trim();
+        if (!token) {
+            return onUnauthorized(ctx, new error_js_1.TezXError("Empty token"));
+        }
+        try {
+            const valid = await validate(token, ctx);
+            if (!valid) {
+                return onUnauthorized(ctx, new error_js_1.TezXError("Invalid or expired token"));
+            }
+            ctx.token = token;
+            await next();
+        }
+        catch (err) {
+            return onUnauthorized(ctx, (0, error_js_1.TezXErrorParse)(err));
+        }
+    };
+};
+exports.bearerAuth = bearerAuth;
+exports.default = exports.bearerAuth;

package/cjs/middleware/cache-control.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheControl = void 0;
+const error_js_1 = require("../core/error.js");
+const cacheControl = (opts) => {
+    const { defaultSettings, rules = [], onError = (err, ctx) => {
+        ctx.setStatus = 500;
+        ctx.body = { error: err.message ?? "Cache middleware failed" };
+    }, } = opts;
+    const len = rules.length | 0;
+    return async function cacheControlMiddleware(ctx, next) {
+        const method = ctx.method;
+        if (method !== "GET" && method !== "HEAD") {
+            return await next();
+        }
+        try {
+            await next();
+            let matched;
+            for (let i = 0; i < len; i++) {
+                const rule = rules[i];
+                if (rule.condition(ctx)) {
+                    matched = rule;
+                    break;
+                }
+            }
+            const settings = matched ?? defaultSettings;
+            const maxAge = settings.maxAge;
+            const scope = settings.scope;
+            const vary = settings.vary;
+            const cacheValue = `${scope}, max-age=${maxAge}`;
+            const expiresValue = new Date(Date.now() + maxAge * 1000).toUTCString();
+            const headers = ctx.headers;
+            headers.set("Cache-Control", cacheValue);
+            headers.set("Expires", expiresValue);
+            if (vary && vary.length > 0)
+                headers.set("Vary", vary.join(", "));
+        }
+        catch (err) {
+            return onError((0, error_js_1.TezXErrorParse)(err), ctx);
+        }
+    };
+};
+exports.cacheControl = cacheControl;
+exports.default = exports.cacheControl;

package/cjs/middleware/cors.js

@@ -1,36 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cors = cors;
+exports.default = cors;
 function cors(option = {}) {
-    const { methods, allowedHeaders, credentials, exposedHeaders, maxAge, origin, } = option;
+    const { credentials, maxAge, origin } = option;
+    let methods = (option.methods || ["GET", "POST", "PUT", "DELETE"]).join(", ");
+    let allowedHeaders = (option.allowedHeaders || ["Content-Type", "Authorization"]).join(", ");
+    let exposedHeaders = option?.exposedHeaders?.join(", ");
     return async function cors(ctx, next) {
-        const reqOrigin = ctx.req.headers.get("origin") || "";
+        const reqOrigin = ctx.req.header("origin") || "";
         let allowOrigin = "*";
         if (typeof origin === "string") {
             allowOrigin = origin;
         }
-        else if (origin instanceof RegExp) {
-            allowOrigin = origin.test(reqOrigin) ? reqOrigin : "";
-        }
         else if (Array.isArray(origin)) {
-            const isAllowed = origin.some((item) => {
-                if (typeof item === "string") {
-                    return item === reqOrigin;
-                }
-                else if (item instanceof RegExp) {
-                    return item.test(reqOrigin);
-                }
-            });
-            allowOrigin = isAllowed ? reqOrigin : "";
+            allowOrigin = origin.includes(reqOrigin) ? reqOrigin : "";
         }
         else if (typeof origin === "function") {
             allowOrigin = origin(reqOrigin) ? reqOrigin : "";
         }
         ctx.headers.set("Access-Control-Allow-Origin", allowOrigin);
-        ctx.headers.set("Access-Control-Allow-Methods", (methods || ["GET", "POST", "PUT", "DELETE"]).join(", "));
-        ctx.headers.set("Access-Control-Allow-Headers", (allowedHeaders || ["Content-Type", "Authorization"]).join(", "));
+        ctx.headers.set("Access-Control-Allow-Methods", methods);
+        ctx.headers.set("Access-Control-Allow-Headers", allowedHeaders);
         if (exposedHeaders) {
-            ctx.headers.set("Access-Control-Expose-Headers", exposedHeaders.join(", "));
+            ctx.headers.set("Access-Control-Expose-Headers", exposedHeaders);
         }
         if (credentials) {
             ctx.headers.set("Access-Control-Allow-Credentials", "true");
@@ -39,10 +32,7 @@ function cors(option = {}) {
             ctx.headers.set("Access-Control-Max-Age", maxAge.toString());
         }
         if (ctx.req.method === "OPTIONS") {
-            return new Response(null, {
-                status: 204,
-                headers: ctx.headers,
-            });
+            return new Response(null, { status: 204, headers: ctx.headers });
         }
         return await next();
     };

package/cjs/middleware/detect-bot.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectBot = void 0;
+const config_js_1 = require("../core/config.js");
+const rateLimit_js_1 = require("../utils/rateLimit.js");
+const runtime_js_1 = require("../utils/runtime.js");
+const detectBot = (opts = {}) => {
+    const botUAs = opts.botUserAgents || ["bot", "spider", "crawl", "slurp"];
+    let checkBot;
+    if (runtime_js_1.runtime === "bun") {
+        const botRegex = new RegExp(botUAs.join("|"), "i");
+        checkBot = (ua) => botRegex.test(ua);
+    }
+    else {
+        checkBot = (ua) => {
+            for (const b of botUAs)
+                if (ua.includes(b))
+                    return true;
+            return false;
+        };
+    }
+    const maxReq = opts.maxRequests || 30;
+    const winMs = opts.windowMs || 60000;
+    const enableRL = !!opts.enableRateLimiting;
+    const onBot = opts.onBotDetected ??
+        ((ctx, reason) => ctx.status(403).json({ error: `Bot detected: ${reason}` }));
+    let store = opts.storage;
+    if (enableRL && !store)
+        store = (0, rateLimit_js_1.createRateLimitDefaultStorage)();
+    return async (ctx, next) => {
+        const ua = ctx.headers.get("user-agent") || "";
+        if (checkBot(ua)) {
+            return onBot?.(ctx, "User-Agent");
+        }
+        if (await opts?.isBlacklisted?.(ctx)) {
+            return onBot?.(ctx, "Blacklisted IP");
+        }
+        if (enableRL) {
+            const addr = ctx.req.remoteAddress;
+            if (!addr) {
+                config_js_1.GlobalConfig.debugging.warn("[TezX detectBot] Missing remoteAddress. Use `getConnInfo(ctx)` to enable rate limiting.");
+            }
+            else {
+                const key = `${addr.address}:${addr.port || 0}`;
+                const { check, entry } = (0, rateLimit_js_1.isRateLimit)(key, store, maxReq, winMs);
+                if (check && addr.address) {
+                    return onBot?.(ctx, `Rate limit exceeded. Retry after ${Math.ceil((entry.resetTime - Date.now()) / 1000)} seconds.`);
+                }
+            }
+        }
+        if (await opts.customBotDetector?.(ctx)) {
+            return onBot?.(ctx, "Custom Detector");
+        }
+        return await next();
+    };
+};
+exports.detectBot = detectBot;

package/cjs/middleware/i18n.js

@@ -1,79 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.i18n = void 0;
-const config_js_1 = require("../core/config.js");
+exports.i18n = exports.default = void 0;
+const index_js_1 = require("../index.js");
 const i18n = (options) => {
-    const { loadTranslations, defaultCacheDuration = 3600000, isCacheValid = (cached) => cached.expiresAt > Date.now(), detectLanguage = (ctx) => ctx.req.query.lang ||
-        ctx.cookies?.get("lang") ||
-        ctx.req.headers.get("accept-language")?.split(",")[0] ||
-        options.defaultLanguage ||
-        "en", defaultLanguage = "en", fallbackChain = [], translationFunctionKey = "t", formatMessage = (message, options = {}) => {
-        return Object.entries(options).reduce((msg, [key, value]) => msg.replace(new RegExp(`{{${key}}}`, "g"), String(value)), message);
-    }, cacheTranslations = true, } = options;
-    const translationCache = {};
+    const { loadTranslations, defaultCacheDuration = 3600000, detectLanguage, defaultLanguage = "en", translationFunctionKey = "t", formatMessage = (msg, vars = {}) => {
+        if (vars && msg.indexOf("{{") !== -1) {
+            let out = "";
+            let i = 0;
+            while (i < msg.length) {
+                const startVar = msg.indexOf("{{", i);
+                if (startVar === -1) {
+                    out += msg.slice(i);
+                    break;
+                }
+                const endVar = msg.indexOf("}}", startVar + 2);
+                if (endVar === -1) {
+                    out += msg.slice(i);
+                    break;
+                }
+                out += msg.slice(i, startVar);
+                const keyVar = msg.slice(startVar + 2, endVar).trim();
+                out += vars[keyVar] !== undefined ? String(vars[keyVar]) : "";
+                i = endVar + 2;
+            }
+            return out;
+        }
+        return msg;
+    }, isCacheValid = (cached) => cached.expiresAt > Date.now(), cacheTranslations = false, cacheStorage: externalCache = null, } = options;
+    let localCache = null;
+    if (cacheTranslations && !externalCache)
+        localCache = new Map();
     return async function i18n(ctx, next) {
         try {
-            const detectedLanguage = detectLanguage(ctx);
-            const languageChain = [
-                detectedLanguage,
-                ...fallbackChain,
-                defaultLanguage,
-            ].filter(Boolean);
-            let translations = null;
-            let selectedLanguage = defaultLanguage;
-            for (const lang of languageChain) {
-                const normalizedLang = lang.split("-")[0].toLowerCase();
-                if (cacheTranslations && translationCache[normalizedLang]) {
-                    const cached = translationCache[normalizedLang];
-                    if (isCacheValid(cached, normalizedLang)) {
+            const lang = detectLanguage(ctx) ?? defaultLanguage;
+            let translations = undefined;
+            if (cacheTranslations) {
+                if (externalCache) {
+                    const cached = await externalCache.get(lang);
+                    if (cached && isCacheValid(cached, lang))
                         translations = cached.translations;
-                        selectedLanguage = lang;
-                        break;
-                    }
-                    delete translationCache[normalizedLang];
-                }
-                try {
-                    const { translations: loadedTranslations, expiresAt } = await loadTranslations(normalizedLang);
-                    let expirationTime = Date.now() + defaultCacheDuration;
-                    if (expiresAt instanceof Date) {
-                        expirationTime = expiresAt.getTime();
-                    }
-                    else if (typeof expiresAt === "number") {
-                        expirationTime = expiresAt;
-                    }
-                    translations = loadedTranslations;
-                    selectedLanguage = lang;
-                    if (cacheTranslations) {
-                        translationCache[normalizedLang] = {
-                            translations,
-                            expiresAt: expirationTime,
-                        };
-                    }
-                    break;
                 }
-                catch (error) {
-                    config_js_1.GlobalConfig.debugging.warn(`Translation load failed for ${lang}:`, error);
+                else if (localCache?.get(lang)) {
+                    const cached = localCache.get(lang);
+                    if (isCacheValid(cached, lang))
+                        translations = cached.translations;
+                    else
+                        localCache.delete(lang);
                 }
             }
             if (!translations) {
-                throw new Error("No translations available");
+                translations = await loadTranslations(lang);
+                const expiresAt = Date.now() + defaultCacheDuration;
+                if (cacheTranslations) {
+                    if (externalCache) {
+                        await externalCache.set(lang, { translations, expiresAt });
+                    }
+                    else {
+                        localCache?.set(lang, { translations, expiresAt });
+                    }
+                }
             }
-            ctx[translationFunctionKey] = (key, options) => {
-                const value = key.split(".").reduce((acc, k) => {
-                    return acc && typeof acc === "object" ? acc[k] : undefined;
-                }, translations);
-                const message = typeof value === "string" ? value : key;
-                return formatMessage(message, options);
+            ctx[translationFunctionKey] = function translate(key, vars) {
+                let acc = translations;
+                let start = 0;
+                for (let i = 0; i <= key.length; i++) {
+                    const c = key.charCodeAt(i);
+                    if (c === 46 || i === key.length) {
+                        const segment = key.slice(start, i);
+                        if (acc && typeof acc === "object") {
+                            acc = acc[segment];
+                        }
+                        else {
+                            acc = undefined;
+                            break;
+                        }
+                        start = i + 1;
+                    }
+                }
+                let msg = typeof acc === "string" ? acc : key;
+                return formatMessage(msg, vars);
             };
-            ctx.language = selectedLanguage;
-            ctx.languageChain = languageChain;
+            ctx.language = lang;
             return await next();
         }
         catch (error) {
-            config_js_1.GlobalConfig.debugging.error("i18n processing error:", error);
-            ctx.setStatus = 500;
-            throw error;
+            throw new index_js_1.TezXError(error?.message ?? "i18n failed", 500, error?.stack);
         }
     };
 };
+exports.default = i18n;
 exports.i18n = i18n;