@mdfriday/foundry 25.11.12 → 25.11.13

package/dist/internal/domain/template/vo/registry.js

@@ -1,2835 +0,0 @@
-"use strict";
-/**
- * Template functions registry
- * Centralized management of template functions following DDD principles
- * TypeScript equivalent of Go's valueobject/nsreg.go
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultTemplateRegistry = void 0;
-exports.newTemplateRegistry = newTemplateRegistry;
-exports.createCoreFuncMap = createCoreFuncMap;
-exports.createStandardFuncMap = createStandardFuncMap;
-exports.updateEngineDependentFunctions = updateEngineDependentFunctions;
-const log_1 = require("../../../../pkg/log");
-const crypto = __importStar(require("crypto"));
-// Create domain-specific logger for template operations
-const log = (0, log_1.getDomainLogger)('template', { component: 'registry' });
-const engineDependentFunctions = [];
-/**
- * Partial function implementation that depends on TemplateEngine
- */
-class PartialFunction {
-    engine = null;
-    getFunctionName() {
-        return 'partial';
-    }
-    updateEngine(engine) {
-        this.engine = engine;
-    }
-    execute = async (name, context) => {
-        if (!this.engine) {
-            log.error(`Partial function called but engine not set: ${name}`);
-            return `<!-- Partial function called but engine not ready: ${name} -->`;
-        }
-        try {
-            // Ensure name has partials/ prefix if not already present
-            const templateName = name.startsWith('partials/') ? name : `partials/${name}`;
-            // Execute partial synchronously using engine's internal components
-            return await this.executePartial(templateName, context);
-        }
-        catch (error) {
-            log.error(`Partial execution failed for "${name}":`, error);
-            return `<!-- Partial execution failed: ${name} - ${error.message} -->`;
-        }
-    };
-    /**
-     * Execute partial synchronously by directly accessing template engine internals
-     */
-    async executePartial(templateName, context) {
-        if (!this.engine) {
-            return `<!-- Template engine not available: ${templateName} -->`;
-        }
-        try {
-            // Use the new getPartial method which routes to PartialNamespace
-            const [templateObj, found, err] = await this.engine.getPartial(templateName);
-            if (err) {
-                log.error(`Error getting partial template:`, err);
-                return `<!-- Error getting partial template: ${templateName} - ${err.message} -->`;
-            }
-            if (!found || !templateObj) {
-                log.warn(`Template not found: ${templateName}`);
-                return `<!-- Template not found: ${templateName} -->`;
-            }
-            // Execute the template directly
-            const [result, execErr] = await templateObj.Execute(context);
-            if (execErr) {
-                log.error(`Template execution error:`, execErr);
-                return `<!-- Template execution error: ${templateName} - ${execErr.message} -->`;
-            }
-            return result;
-        }
-        catch (error) {
-            log.error(`Sync partial execution failed:`, error);
-            return `<!-- Partial sync execution failed: ${templateName} - ${error.message} -->`;
-        }
-    }
-}
-/**
- * Template functions registry implementation
- * Following DDD principles - encapsulates template function management logic
- */
-class DefaultTemplateRegistry {
-    /**
-     * Register core template functions that don't require external services
-     * Equivalent to Go's RegisterNamespaces()
-     */
-    registerCoreFunctions(funcMap) {
-        // Crypto functions
-        this.registerCryptoFunctions(funcMap);
-        // String manipulation functions
-        this.registerStringFunctions(funcMap);
-        // Math functions
-        this.registerMathFunctions(funcMap);
-        // Date/time functions
-        this.registerTimeFunctions(funcMap);
-        // Collection functions
-        this.registerCollectionFunctions(funcMap);
-        // Safe functions
-        this.registerSafeFunctions(funcMap);
-        // Reflect functions
-        this.registerReflectFunctions(funcMap);
-        // Format functions (printf, errorf, etc.)
-        this.registerFmtFunctions(funcMap);
-        // Path functions
-        this.registerPathFunctions(funcMap);
-        // Transform functions (unmarshal, etc.)
-        this.registerTransformFunctions(funcMap);
-    }
-    /**
-     * Register cryptographic hash functions
-     * Equivalent to Go's crypto packages
-     */
-    registerCryptoFunctions(funcMap) {
-        // MD5 hash function
-        funcMap.set('md5', (input) => {
-            if (!input)
-                return '';
-            return crypto.createHash('md5').update(input).digest('hex');
-        });
-        // AES-256-GCM encryption function
-        funcMap.set("encryptAESGCM", (password, content) => {
-            if (!password || !content)
-                return "";
-            const salt = crypto.randomBytes(16);
-            const iv = crypto.randomBytes(12);
-            // 派生 key：PBKDF2(SHA256)
-            const key = crypto.pbkdf2Sync(password, salt, 100000, 32, // 256-bit
-            "sha256");
-            // AES-GCM 加密
-            const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
-            const encrypted = Buffer.concat([
-                cipher.update(content, "utf8"),
-                cipher.final(),
-            ]);
-            const tag = cipher.getAuthTag();
-            // 输出格式：salt | iv | tag | ciphertext
-            const combined = Buffer.concat([salt, iv, tag, encrypted]);
-            return combined.toString("base64");
-        });
-    }
-    /**
-     * Register extended template functions that require external services
-     * Equivalent to Go's RegisterExtendedNamespaces()
-     */
-    registerExtendedFunctions(funcMap, services) {
-        // URL functions - require URL service
-        this.registerURLFunctions(funcMap, services);
-        // Site functions - require site service
-        this.registerSiteFunctions(funcMap, services);
-        this.registerResourcesFunctions(funcMap, services);
-        // Hugo functions - require hugo info service
-        this.registerHugoFunctions(funcMap, services);
-        // Language functions - require language service
-        this.registerLanguageFunctions(funcMap, services);
-    }
-    /**
-     * Register all available functions with services
-     * This is the main entry point for function registration
-     */
-    registerAllFunctions(funcMap, services) {
-        this.registerCoreFunctions(funcMap);
-        this.registerStringFunctions(funcMap);
-        this.registerMathFunctions(funcMap);
-        this.registerTimeFunctions(funcMap);
-        this.registerCollectionFunctions(funcMap);
-        // Register engine-dependent functions (with placeholder implementations)
-        this.registerEngineDependentFunctions(funcMap);
-        // Register service-based functions if services are provided
-        if (services) {
-            this.registerURLFunctions(funcMap, services);
-            this.registerExtendedFunctions(funcMap, services);
-        }
-    }
-    /**
-     * Register functions that depend on TemplateEngine
-     * These functions are registered with placeholder implementations initially
-     */
-    registerEngineDependentFunctions(funcMap) {
-        // Register partial function
-        const partialFunction = new PartialFunction();
-        engineDependentFunctions.push(partialFunction);
-        funcMap.set(partialFunction.getFunctionName(), partialFunction.execute);
-    }
-    /**
-     * Register URL template functions using URLService
-     * Equivalent to Go's registerUrls()
-     */
-    registerURLFunctions(funcMap, services) {
-        // URLs namespace functions
-        funcMap.set('urls', () => ({
-            // Parse parses raw URL string into a URL structure
-            Parse: (rawurl) => {
-                try {
-                    const u = new URL(rawurl);
-                    return {
-                        Host: u.host,
-                    };
-                }
-                catch {
-                    return {
-                        Host: '',
-                    };
-                }
-            },
-            // JoinPath joins path elements into a single path
-            JoinPath: (...elements) => {
-                // Remove empty elements and handle trailing slashes
-                const cleanElements = elements
-                    .filter(e => e !== '')
-                    .map(e => e.replace(/^\/+|\/+$/g, ''));
-                return cleanElements.join('/');
-            },
-            // URLize returns a URL-like string from the given text
-            URLize: (text) => services.urlize(text),
-            // Abs returns an absolute URL string
-            Abs: (url) => services.absURL(url),
-            // Rel returns a relative URL string
-            Rel: (url) => services.relURL(url),
-            // AbsLangURL returns an absolute URL modified with the language prefix
-            AbsLangURL: (url) => services.absURL(url), // TODO: Add language support
-            // RelLangURL returns a relative URL modified with the language prefix
-            RelLangURL: (url) => services.relURL(url), // TODO: Add language support
-            // Sanitize returns a sanitized string of the URL
-            Sanitize: (url) => {
-                try {
-                    const parsed = new URL(url);
-                    return parsed.toString();
-                }
-                catch {
-                    // If not a valid URL, at least remove dangerous characters
-                    return url.replace(/[<>"'%{}|\\^`]/g, '');
-                }
-            },
-            // PathEscape escapes special characters in a URL path
-            PathEscape: (path) => {
-                return encodeURIComponent(path)
-                    .replace(/%2F/g, '/') // Keep forward slashes
-                    .replace(/[!'()*]/g, c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
-            },
-            // QueryEscape escapes special characters in a URL query
-            QueryEscape: (query) => {
-                return encodeURIComponent(query);
-            },
-            // QueryUnescape unescapes special characters in a URL query
-            QueryUnescape: (query) => {
-                try {
-                    return decodeURIComponent(query);
-                }
-                catch {
-                    return query;
-                }
-            },
-            // IsAbs reports whether the URL is absolute
-            IsAbs: (urlStr) => {
-                try {
-                    const url = new URL(urlStr);
-                    return url.protocol !== '';
-                }
-                catch {
-                    return false;
-                }
-            },
-            // IsRelative reports whether the URL is relative
-            IsRelative: (urlStr) => {
-                try {
-                    new URL(urlStr);
-                    return false;
-                }
-                catch {
-                    return true;
-                }
-            }
-        }));
-        // Individual URL functions for backward compatibility
-        funcMap.set('absURL', (input) => services.absURL(input));
-        funcMap.set('relURL', (input) => services.relURL(input));
-        funcMap.set('urlize', (input) => services.urlize(input));
-        // Reference functions
-        funcMap.set('relref', (page, ref) => {
-            // If ref starts with http:// or https://, return as is
-            if (/^https?:\/\//.test(ref)) {
-                return ref;
-            }
-            // Remove anchor if present and store it
-            let anchor = '';
-            const hashIndex = ref.indexOf('#');
-            if (hashIndex !== -1) {
-                anchor = ref.slice(hashIndex);
-                ref = ref.slice(0, hashIndex);
-            }
-            // Remove leading and trailing slashes
-            ref = ref.replace(/^\/+|\/+$/g, '');
-            // If it's a relative path starting with ./ or ../, use relURL
-            if (ref.startsWith('./') || ref.startsWith('../')) {
-                return services.relURL(ref + anchor);
-            }
-            // Handle absolute paths
-            if (ref.startsWith('/')) {
-                return services.relURL(ref + anchor);
-            }
-            // For other cases, treat as relative path
-            return services.relURL('/' + ref + anchor);
-        });
-        funcMap.set('ref', (page, ref) => {
-            // Similar to relref but returns absolute URL
-            // If ref starts with http:// or https://, return as is
-            if (/^https?:\/\//.test(ref)) {
-                return ref;
-            }
-            // Remove anchor if present and store it
-            let anchor = '';
-            const hashIndex = ref.indexOf('#');
-            if (hashIndex !== -1) {
-                anchor = ref.slice(hashIndex);
-                ref = ref.slice(0, hashIndex);
-            }
-            // Remove leading and trailing slashes
-            ref = ref.replace(/^\/+|\/+$/g, '');
-            // If it's a relative path starting with ./ or ../, use absURL
-            if (ref.startsWith('./') || ref.startsWith('../')) {
-                return services.absURL(ref + anchor);
-            }
-            // Handle absolute paths
-            if (ref.startsWith('/')) {
-                return services.absURL(ref + anchor);
-            }
-            // For other cases, treat as relative path
-            return services.absURL('/' + ref + anchor);
-        });
-        // Language-aware URL functions
-        funcMap.set('absLangURL', (input) => {
-            // For now, delegate to absURL - can be enhanced for multi-language support
-            return services.absURL(input);
-        });
-        funcMap.set('relLangURL', (input) => {
-            // For now, delegate to relURL - can be enhanced for multi-language support
-            return services.relURL(input);
-        });
-    }
-    /**
-     * Register site template functions using SiteService
-     * Equivalent to Go's registerSite()
-     */
-    registerSiteFunctions(funcMap, services) {
-        // Site global object - register as a function that returns the site data
-        funcMap.set('Site', () => ({
-            Title: services.title(),
-            BaseURL: services.baseURL(),
-            Params: services.params(),
-            Menus: services.menus(),
-            IsMultiLingual: services.isMultiLanguage(),
-            LanguageCode: services.defaultLanguage()
-        }));
-    }
-    registerResourcesFunctions(funcMap, services) {
-        funcMap.set('resources', () => ({
-            Get: async (filename) => await services.Get(filename),
-            GetRemote: async (uri) => await services.GetRemote(uri),
-            Minify: async (resource) => await services.Minify(resource),
-            Fingerprint: async (resource) => await services.Fingerprint(resource),
-            ExecuteAsTemplate: async (targetPath, data, resource) => await services.ExecuteAsTemplate(targetPath, data, resource)
-        }));
-    }
-    /**
-     * Register Hugo template functions using HugoInfoService
-     * Equivalent to Go's registerHugo()
-     */
-    registerHugoFunctions(funcMap, services) {
-        funcMap.set('hugo', () => ({
-            Version: services.version(),
-            Environment: services.environment(),
-            Generator: services.generator()
-        }));
-    }
-    /**
-     * Register language template functions using LanguageService
-     * Equivalent to Go's registerLang()
-     */
-    registerLanguageFunctions(funcMap, services) {
-        // Import language service
-        const { lang } = require('../../../../pkg/lang');
-        // Language namespace functions
-        funcMap.set('lang', () => ({
-            // Get all language codes
-            getAllCodes: () => lang.getAllCodes(),
-            // Get all language names
-            getAllNames: () => lang.getAllNames(),
-            // Get language codes by direction
-            getCodesByDirection: (direction) => lang.getCodesByDirection(direction),
-            // Get language names by direction
-            getNamesByDirection: (direction) => lang.getNamesByDirection(direction),
-            // Get code-name mapping
-            getCodeNameMap: () => lang.getCodeNameMap(),
-            // Get code-name mapping by direction
-            getCodeNameMapByDirection: (direction) => lang.getCodeNameMapByDirection(direction),
-            // Get language name by code
-            getNameByCode: (code) => lang.getNameByCode(code),
-            // Get language info by code
-            getLanguageInfo: (code) => lang.getLanguageInfo(code),
-            // Check if language is supported
-            isSupported: (code) => lang.isSupported(code),
-            // Get language direction
-            getDirection: (code) => lang.getDirection(code),
-            // Check if language is LTR
-            isLTR: (code) => lang.isLTR(code),
-            // Check if language is RTL
-            isRTL: (code) => lang.isRTL(code)
-        }));
-        // Standalone functions for convenience
-        funcMap.set('langName', (code) => lang.getNameByCode(code) || code);
-        funcMap.set('langDirection', (code) => lang.getDirection(code) || 'ltr');
-        funcMap.set('isLTR', (code) => lang.isLTR(code));
-        funcMap.set('isRTL', (code) => lang.isRTL(code));
-        // i18n placeholder (can be extended later)
-        funcMap.set('i18n', (key) => {
-            return services.translate(key);
-        });
-    }
-    /**
-     * Register string manipulation functions
-     * Equivalent to Go's registerStrings()
-     */
-    registerStringFunctions(funcMap) {
-        // Humanize converts ID-style strings to human readable format
-        funcMap.set('humanize', (str) => {
-            if (!str)
-                return '';
-            // Convert from camelCase or PascalCase
-            str = str.replace(/([a-z])([A-Z])/g, '$1 $2');
-            // Convert from snake_case or kebab-case
-            str = str.replace(/[_-]+/g, ' ');
-            // Remove file extensions
-            str = str.replace(/\.[^/.]+$/, '');
-            // Capitalize first letter, rest lowercase
-            str = str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-            // Trim spaces
-            return str.trim();
-        });
-        funcMap.set('upper', (str) => str.toUpperCase());
-        funcMap.set('lower', (str) => str.toLowerCase());
-        funcMap.set('title', (str) => str.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()));
-        funcMap.set('trim', (str) => str.trim());
-        funcMap.set('replace', (...args) => {
-            if (args.length < 3) {
-                throw new Error('replace requires at least 3 arguments: string, old, new');
-            }
-            const str = String(args[0]);
-            const old = String(args[1]);
-            const newStr = String(args[2]);
-            // Handle optional limit parameter like Go's implementation
-            if (args.length >= 4) {
-                const limit = Number(args[3]);
-                if (isNaN(limit)) {
-                    throw new Error('replace limit must be a number');
-                }
-                // Implement limited replacement like Go's strings.Replace
-                let result = str;
-                let count = 0;
-                let startIndex = 0;
-                while (count < limit && startIndex < result.length) {
-                    const index = result.indexOf(old, startIndex);
-                    if (index === -1)
-                        break;
-                    result = result.substring(0, index) + newStr + result.substring(index + old.length);
-                    startIndex = index + newStr.length;
-                    count++;
-                }
-                return result;
-            }
-            // Default behavior: replace all occurrences (like Go's strings.ReplaceAll)
-            return str.split(old).join(newStr);
-        });
-        // ReplaceRE function - global alias following Go pattern
-        // Usage: {{ replaceRE "a+b" "X" "aabbaabbab" }} -> "XbXbX"
-        // Usage: {{ replaceRE "a+b" "X" "aabbaabbab" 1 }} -> "Xbaabbab"
-        funcMap.set('replaceRE', (...args) => {
-            if (args.length < 3) {
-                throw new Error('replaceRE requires at least 3 arguments: pattern, replacement, string');
-            }
-            const pattern = args[0];
-            const repl = args[1];
-            const s = args[2];
-            const n = args.length >= 4 ? args[3] : undefined;
-            // Use the strings namespace ReplaceRE implementation
-            const stringsNs = funcMap.get('strings')();
-            return stringsNs.ReplaceRE(pattern, repl, s, n);
-        });
-        // Split function - ensure first parameter is the string to split
-        funcMap.set('split', (str, sep) => {
-            // Handle null and undefined cases first
-            if (str === null || str === undefined) {
-                log.warn('split function: first argument is null or undefined');
-                return [];
-            }
-            if (typeof str !== 'string') {
-                log.warn('split function: first argument must be a string, got:', typeof str, 'value:', str);
-                // If it's an array, try to join it or return as is
-                if (Array.isArray(str)) {
-                    return str;
-                }
-                // Try to convert to string
-                const stringValue = String(str);
-                return stringValue.split(sep);
-            }
-            return str.split(sep);
-        });
-        // SplitRegex function - split string using regex pattern
-        funcMap.set('splitRegex', (str, regexPattern) => {
-            // Handle null and undefined cases first
-            if (str === null || str === undefined) {
-                log.warn('splitRegex function: first argument is null or undefined');
-                return [];
-            }
-            if (typeof str !== 'string') {
-                log.warn('splitRegex function: first argument must be a string, got:', typeof str, 'value:', str);
-                // If it's an array, try to join it or return as is
-                if (Array.isArray(str)) {
-                    return str;
-                }
-                // Try to convert to string
-                const stringValue = String(str);
-                try {
-                    const regex = new RegExp(regexPattern);
-                    return stringValue.split(regex);
-                }
-                catch (error) {
-                    log.warn('splitRegex function: invalid regex pattern:', regexPattern, 'error:', error);
-                    return [stringValue];
-                }
-            }
-            try {
-                const regex = new RegExp(regexPattern);
-                return str.split(regex);
-            }
-            catch (error) {
-                log.warn('splitRegex function: invalid regex pattern:', regexPattern, 'error:', error);
-                return [str];
-            }
-        });
-        // Join function
-        funcMap.set('delimit', (arr, sep) => {
-            if (Array.isArray(arr)) {
-                return arr.join(sep);
-            }
-            return String(arr);
-        });
-        // Contains function
-        funcMap.set('in', (matchValue, item) => {
-            if (Array.isArray(matchValue)) {
-                return matchValue.includes(item);
-            }
-            if (typeof matchValue === 'string' && typeof item === 'string') {
-                return matchValue.includes(item);
-            }
-            return false;
-        });
-        // HasPrefix function
-        funcMap.set('hasPrefix', (str, prefix) => str.startsWith(prefix));
-        // HasSuffix function
-        funcMap.set('hasSuffix', (str, suffix) => str.endsWith(suffix));
-        // Strings namespace - following Go's strings namespace pattern
-        funcMap.set('strings', () => ({
-            // Basic string operations
-            ToLower: (s) => String(s).toLowerCase(),
-            ToUpper: (s) => String(s).toUpperCase(),
-            Title: (s) => String(s).replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()),
-            // Trimming functions
-            Trim: (s, cutset) => String(s).split('').filter(c => !cutset.includes(c)).join(''),
-            TrimSpace: (s) => String(s).trim(),
-            TrimLeft: (cutset, s) => {
-                const str = String(s);
-                let i = 0;
-                while (i < str.length && cutset.includes(str[i])) {
-                    i++;
-                }
-                return str.slice(i);
-            },
-            TrimRight: (cutset, s) => {
-                const str = String(s);
-                let i = str.length - 1;
-                while (i >= 0 && cutset.includes(str[i])) {
-                    i--;
-                }
-                return str.slice(0, i + 1);
-            },
-            TrimPrefix: (prefix, s) => {
-                const str = String(s);
-                return str.startsWith(prefix) ? str.slice(prefix.length) : str;
-            },
-            TrimSuffix: (suffix, s) => {
-                const str = String(s);
-                return str.endsWith(suffix) ? str.slice(0, -suffix.length) : str;
-            },
-            // Testing functions
-            Contains: (s, substr) => String(s).includes(substr),
-            ContainsAny: (s, chars) => {
-                const str = String(s);
-                return chars.split('').some(char => str.includes(char));
-            },
-            HasPrefix: (s, prefix) => String(s).startsWith(prefix),
-            HasSuffix: (s, suffix) => String(s).endsWith(suffix),
-            // Replacement functions
-            Replace: (s, old, newStr, limit) => {
-                const str = String(s);
-                if (limit === undefined) {
-                    // Replace all occurrences (like Go's strings.ReplaceAll)
-                    return str.split(old).join(newStr);
-                }
-                // Implement limited replacement like Go's strings.Replace
-                let result = str;
-                let count = 0;
-                let startIndex = 0;
-                while (count < limit && startIndex < result.length) {
-                    const index = result.indexOf(old, startIndex);
-                    if (index === -1)
-                        break;
-                    result = result.substring(0, index) + newStr + result.substring(index + old.length);
-                    startIndex = index + newStr.length;
-                    count++;
-                }
-                return result;
-            },
-            // ReplaceRE returns a copy of s, replacing all matches of the regular
-            // expression pattern with the replacement text repl. The number of replacements
-            // can be limited with an optional fourth parameter.
-            // Follows Go's implementation strictly
-            ReplaceRE: (pattern, repl, s, n) => {
-                // Convert all parameters to strings (following Go's cast.ToStringE behavior)
-                const sp = String(pattern);
-                const sr = String(repl);
-                const ss = String(s);
-                // Handle optional limit parameter (following Go's cast.ToIntE behavior)
-                let nn = -1; // -1 means replace all (Go default)
-                if (n !== undefined) {
-                    const parsed = parseInt(String(n), 10);
-                    if (isNaN(parsed)) {
-                        throw new Error('limit argument must be integer');
-                    }
-                    nn = parsed;
-                }
-                let re;
-                try {
-                    // Create regex with global flag for multiple replacements
-                    re = new RegExp(sp, 'g');
-                }
-                catch (err) {
-                    throw new Error(`invalid regular expression: ${sp}`);
-                }
-                // Follow Go's ReplaceAllStringFunc implementation with counter
-                let replacementCount = 0;
-                return ss.replace(re, (match) => {
-                    // If we've reached the limit, return the original match
-                    if (nn >= 0 && replacementCount >= nn) {
-                        return match;
-                    }
-                    replacementCount++;
-                    return sr;
-                });
-            },
-            // Splitting and slicing
-            Split: (s, delimiter) => String(s).split(delimiter),
-            SliceString: (s, start, end) => {
-                const str = String(s);
-                return end !== undefined ? str.slice(start, end) : str.slice(start);
-            },
-            Substr: (s, start, length) => {
-                const str = String(s);
-                if (start < 0)
-                    start = str.length + start;
-                if (start < 0)
-                    start = 0;
-                if (start >= str.length)
-                    return '';
-                if (length === undefined)
-                    return str.slice(start);
-                if (length <= 0)
-                    return '';
-                return str.slice(start, start + length);
-            },
-            // Utility functions
-            Count: (substr, s) => {
-                const str = String(s);
-                if (!substr)
-                    return str.length + 1;
-                return (str.match(new RegExp(substr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
-            },
-            CountWords: (s) => {
-                const str = String(s).trim();
-                return str ? str.split(/\s+/).length : 0;
-            },
-            CountRunes: (s) => {
-                const str = String(s);
-                return str.replace(/\s/g, '').length;
-            },
-            RuneCount: (s) => String(s).length,
-            // Repeat function
-            Repeat: (n, s) => {
-                if (n < 0)
-                    throw new Error('strings: negative Repeat count');
-                return String(s).repeat(n);
-            },
-            // First letter upper
-            FirstUpper: (s) => {
-                const str = String(s);
-                return str.charAt(0).toUpperCase() + str.slice(1);
-            }
-        }));
-        // Substr extracts parts of a string, beginning at the character at the specified
-        // position, and returns the specified number of characters.
-        // It normally takes two parameters: start and length.
-        // It can also take one parameter: start, i.e. length is omitted, in which case
-        // the substring starting from start until the end of the string will be returned.
-        // To extract characters from the end of the string, use a negative start number.
-        // If length is given and is negative, then that many characters will be omitted from
-        // the end of string.
-        // Equivalent to Go's Substr function in strings namespace
-        // Usage: {{ substr "hello world" 0 5 }} -> "hello"
-        // Usage: {{ substr "hello world" 6 }} -> "world"
-        // Usage: {{ substr "hello world" -5 }} -> "world"
-        // Usage: {{ substr "hello world" 0 -6 }} -> "hello"
-        funcMap.set('substr', (a, ...nums) => {
-            // Convert input to string
-            const s = String(a);
-            // Convert string to array of characters to handle Unicode properly
-            const chars = Array.from(s);
-            const rlen = chars.length;
-            let start;
-            let length;
-            // Parse arguments
-            switch (nums.length) {
-                case 0:
-                    throw new Error('too few arguments');
-                case 1:
-                    // Only start parameter provided
-                    const startNum = Number(nums[0]);
-                    if (isNaN(startNum) || !Number.isInteger(startNum)) {
-                        throw new Error('start argument must be an integer');
-                    }
-                    start = startNum;
-                    length = rlen;
-                    break;
-                case 2:
-                    // Both start and length parameters provided
-                    const startNum2 = Number(nums[0]);
-                    const lengthNum = Number(nums[1]);
-                    if (isNaN(startNum2) || !Number.isInteger(startNum2)) {
-                        throw new Error('start argument must be an integer');
-                    }
-                    if (isNaN(lengthNum) || !Number.isInteger(lengthNum)) {
-                        throw new Error('length argument must be an integer');
-                    }
-                    start = startNum2;
-                    length = lengthNum;
-                    break;
-                default:
-                    throw new Error('too many arguments');
-            }
-            // Handle empty string
-            if (rlen === 0) {
-                return '';
-            }
-            // Handle negative start (count from end)
-            if (start < 0) {
-                start += rlen;
-            }
-            // If start was originally negative beyond rlen, set to 0
-            if (start < 0) {
-                start = 0;
-            }
-            // If start is beyond the string length, return empty
-            if (start > rlen - 1) {
-                return '';
-            }
-            let end = rlen;
-            // Handle different length cases
-            if (length === 0) {
-                return '';
-            }
-            else if (length < 0) {
-                // Negative length: omit that many characters from end
-                end += length;
-            }
-            else if (length > 0) {
-                // Positive length: take that many characters from start
-                end = start + length;
-            }
-            // Validate bounds
-            if (start >= end) {
-                return '';
-            }
-            if (end < 0) {
-                return '';
-            }
-            // Clamp end to string length
-            if (end > rlen) {
-                end = rlen;
-            }
-            // Extract substring
-            return chars.slice(start, end).join('');
-        });
-        // Truncate truncates the string to the specified length
-        // Equivalent to Go's Truncate function in strings namespace
-        // Usage: {{ truncate 10 "hello world" }} -> "hello …"
-        // Usage: {{ truncate 10 "..." "hello world" }} -> "hello..."
-        // Supports HTML-aware truncation
-        funcMap.set('truncate', (lengthParam, ...options) => {
-            // Parse length parameter
-            const length = Number(lengthParam);
-            if (isNaN(length) || !Number.isInteger(length)) {
-                throw new Error('truncate length must be an integer');
-            }
-            let textParam;
-            let ellipsis = ' …';
-            // Parse options
-            switch (options.length) {
-                case 0:
-                    throw new Error('truncate requires a length and a string');
-                case 1:
-                    textParam = options[0];
-                    ellipsis = ' …';
-                    break;
-                case 2:
-                    ellipsis = String(options[0]);
-                    textParam = options[1];
-                    break;
-                default:
-                    throw new Error('too many arguments passed to truncate');
-            }
-            // Convert text to string
-            const text = String(textParam);
-            // Check if input is HTML (simple heuristic: contains HTML tags)
-            const isHTML = /<[^>]+>/.test(text);
-            // Convert to array of characters for proper Unicode handling
-            const chars = Array.from(text);
-            // If text is already shorter than or equal to length, return as-is
-            if (chars.length <= length) {
-                if (isHTML) {
-                    return text; // Return as HTML
-                }
-                return this.escapeHTML(text);
-            }
-            if (isHTML) {
-                return this.truncateHTML(text, length, ellipsis);
-            }
-            else {
-                return this.truncateText(text, length, ellipsis);
-            }
-        });
-    }
-    /**
-     * HTML escape utility function
-     */
-    escapeHTML(text) {
-        return text
-            .replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;')
-            .replace(/'/g, '&#39;');
-    }
-    /**
-     * Truncate plain text, breaking at word boundaries when possible
-     */
-    truncateText(text, length, ellipsis) {
-        const chars = Array.from(text);
-        if (chars.length <= length) {
-            return this.escapeHTML(text);
-        }
-        let lastWordIndex = 0;
-        let currentLen = 0;
-        // Find the best truncation point (word boundary)
-        for (let i = 0; i < chars.length && currentLen < length; i++) {
-            const char = chars[i];
-            currentLen++;
-            if (/\s/.test(char)) {
-                lastWordIndex = i;
-            }
-            // For CJK characters, each character can be a word boundary
-            if (/[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/.test(char)) {
-                lastWordIndex = i;
-            }
-        }
-        // Determine truncation point
-        let endPos = currentLen >= length ? (lastWordIndex > 0 ? lastWordIndex : length) : chars.length;
-        const truncated = chars.slice(0, endPos).join('');
-        return this.escapeHTML(truncated) + ellipsis;
-    }
-    /**
-     * Truncate HTML text while preserving tag structure
-     */
-    truncateHTML(text, length, ellipsis) {
-        const tagRegex = /^<(\/)?([^ ]+?)(?:(\s*\/)| .*?)?>/;
-        const htmlSinglets = new Set(['br', 'col', 'link', 'base', 'img', 'param', 'area', 'hr', 'input']);
-        const tags = [];
-        let lastWordIndex = 0;
-        let lastNonSpace = 0;
-        let currentLen = 0;
-        let endTextPos = 0;
-        let i = 0;
-        const chars = Array.from(text);
-        while (i < chars.length) {
-            const currentChar = chars[i];
-            // Check for HTML tag
-            if (currentChar === '<') {
-                const remainingText = chars.slice(i).join('');
-                const match = remainingText.match(tagRegex);
-                if (match) {
-                    const fullMatch = match[0];
-                    const isClosing = match[1] === '/';
-                    const tagName = match[2].toLowerCase();
-                    const isSelfClosing = match[3] === '/';
-                    // Skip the entire tag
-                    i += fullMatch.length;
-                    lastWordIndex = lastNonSpace;
-                    // Track non-singlet tags for proper closing
-                    const isSinglet = htmlSinglets.has(tagName);
-                    if (!isSinglet && !isSelfClosing) {
-                        tags.push({
-                            name: tagName,
-                            pos: i - fullMatch.length,
-                            openTag: !isClosing
-                        });
-                    }
-                    continue;
-                }
-            }
-            // Count actual text characters
-            currentLen++;
-            if (/\s/.test(currentChar)) {
-                lastWordIndex = lastNonSpace;
-            }
-            else if (/[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/.test(currentChar)) {
-                // CJK characters can break at any character
-                lastWordIndex = i;
-            }
-            else {
-                lastNonSpace = i + 1;
-            }
-            if (currentLen > length) {
-                endTextPos = lastWordIndex > 0 ? lastWordIndex : i;
-                break;
-            }
-            i++;
-        }
-        if (currentLen <= length) {
-            return text; // No truncation needed
-        }
-        let output = chars.slice(0, endTextPos).join('') + ellipsis;
-        // Close any open HTML tags
-        let currentTag = null;
-        for (let j = tags.length - 1; j >= 0; j--) {
-            const tag = tags[j];
-            if (tag.pos >= endTextPos || currentTag !== null) {
-                if (currentTag !== null && currentTag.name === tag.name) {
-                    currentTag = null;
-                }
-                continue;
-            }
-            if (tag.openTag) {
-                output += `</${tag.name}>`;
-            }
-            else {
-                currentTag = tag;
-            }
-        }
-        return output;
-    }
-    /**
-     * Register math functions
-     * Equivalent to Go's registerMath()
-     */
-    registerMathFunctions(funcMap) {
-        // Basic arithmetic functions
-        funcMap.set('add', (a, b) => a + b);
-        funcMap.set('sub', (a, b) => a - b);
-        funcMap.set('mul', (a, b) => a * b);
-        funcMap.set('div', (a, b) => b !== 0 ? a / b : 0);
-        funcMap.set('mod', (a, b) => b !== 0 ? a % b : 0);
-        // Math namespace functions - following Go's math package
-        funcMap.set('math', () => ({
-            // Abs returns the absolute value of n
-            Abs: (n) => {
-                const num = Number(n);
-                if (isNaN(num)) {
-                    throw new Error('the math.Abs function requires a numeric argument');
-                }
-                return Math.abs(num);
-            },
-            // Add adds the multivalued addends
-            Add: (...inputs) => {
-                if (inputs.length < 2) {
-                    throw new Error('must provide at least two numbers');
-                }
-                return inputs.reduce((sum, val) => {
-                    const num = Number(val);
-                    if (isNaN(num)) {
-                        throw new Error('Add operator can\'t be used with non-numeric values');
-                    }
-                    return sum + num;
-                }, 0);
-            },
-            // Ceil returns the least integer value greater than or equal to n
-            Ceil: (n) => {
-                const num = Number(n);
-                if (isNaN(num)) {
-                    throw new Error('Ceil operator can\'t be used with non-numeric value');
-                }
-                return Math.ceil(num);
-            },
-            // Div divides n1 by n2
-            Div: (...inputs) => {
-                if (inputs.length < 2) {
-                    throw new Error('must provide at least two numbers');
-                }
-                const result = inputs.reduce((quotient, val, index) => {
-                    const num = Number(val);
-                    if (isNaN(num)) {
-                        throw new Error('Div operator can\'t be used with non-numeric values');
-                    }
-                    if (index === 0)
-                        return num;
-                    if (num === 0) {
-                        throw new Error('division by zero');
-                    }
-                    return quotient / num;
-                });
-                return result;
-            },
-            // Floor returns the greatest integer value less than or equal to n
-            Floor: (n) => {
-                const num = Number(n);
-                if (isNaN(num)) {
-                    throw new Error('Floor operator can\'t be used with non-numeric value');
-                }
-                return Math.floor(num);
-            },
-            // Log returns the natural logarithm of n
-            Log: (n) => {
-                const num = Number(n);
-                if (isNaN(num)) {
-                    throw new Error('Log operator can\'t be used with non-numeric value');
-                }
-                return Math.log(num);
-            },
-            // Max returns the greater of all numbers in inputs
-            Max: (...inputs) => {
-                if (inputs.length === 0) {
-                    throw new Error('must provide at least one number');
-                }
-                const numbers = inputs.flat().map(val => {
-                    const num = Number(val);
-                    if (isNaN(num)) {
-                        throw new Error('Max operator can\'t be used with non-numeric values');
-                    }
-                    return num;
-                });
-                return Math.max(...numbers);
-            },
-            // Min returns the smaller of all numbers in inputs
-            Min: (...inputs) => {
-                if (inputs.length === 0) {
-                    throw new Error('must provide at least one number');
-                }
-                const numbers = inputs.flat().map(val => {
-                    const num = Number(val);
-                    if (isNaN(num)) {
-                        throw new Error('Min operator can\'t be used with non-numeric values');
-                    }
-                    return num;
-                });
-                return Math.min(...numbers);
-            },
-            // Mod returns n1 % n2
-            Mod: (n1, n2) => {
-                const a = Number(n1);
-                const b = Number(n2);
-                if (isNaN(a) || isNaN(b)) {
-                    throw new Error('modulo operator can\'t be used with non-numeric value');
-                }
-                if (b === 0) {
-                    throw new Error('the number can\'t be divided by zero at modulo operation');
-                }
-                return a % b;
-            },
-            // ModBool returns the boolean of n1 % n2. If n1 % n2 == 0, return true
-            ModBool: (n1, n2) => {
-                const a = Number(n1);
-                const b = Number(n2);
-                if (isNaN(a) || isNaN(b)) {
-                    throw new Error('modulo operator can\'t be used with non-numeric value');
-                }
-                if (b === 0) {
-                    throw new Error('the number can\'t be divided by zero at modulo operation');
-                }
-                return (a % b) === 0;
-            },
-            // Mul multiplies the multivalued numbers
-            Mul: (...inputs) => {
-                if (inputs.length < 2) {
-                    throw new Error('must provide at least two numbers');
-                }
-                return inputs.reduce((product, val) => {
-                    const num = Number(val);
-                    if (isNaN(num)) {
-                        throw new Error('Mul operator can\'t be used with non-numeric values');
-                    }
-                    return product * num;
-                }, 1);
-            },
-            // Pow returns n1 raised to the power of n2
-            Pow: (n1, n2) => {
-                const a = Number(n1);
-                const b = Number(n2);
-                if (isNaN(a) || isNaN(b)) {
-                    throw new Error('Pow operator can\'t be used with non-numeric value');
-                }
-                return Math.pow(a, b);
-            },
-            // Rand returns a pseudo-random number in [0.0,1.0)
-            Rand: () => Math.random(),
-            // Round returns the integer nearest to n
-            Round: (n) => {
-                const num = Number(n);
-                if (isNaN(num)) {
-                    throw new Error('Round operator can\'t be used with non-numeric value');
-                }
-                return Math.round(num);
-            },
-            // Sqrt returns the square root of n
-            Sqrt: (n) => {
-                const num = Number(n);
-                if (isNaN(num)) {
-                    throw new Error('Sqrt operator can\'t be used with non-numeric value');
-                }
-                return Math.sqrt(num);
-            },
-            // Sub subtracts multivalued numbers
-            Sub: (...inputs) => {
-                if (inputs.length < 2) {
-                    throw new Error('must provide at least two numbers');
-                }
-                return inputs.reduce((difference, val, index) => {
-                    const num = Number(val);
-                    if (isNaN(num)) {
-                        throw new Error('Sub operator can\'t be used with non-numeric values');
-                    }
-                    if (index === 0)
-                        return num;
-                    return difference - num;
-                });
-            },
-            // Sum returns the sum of all numbers in inputs
-            Sum: (...inputs) => {
-                if (inputs.length === 0) {
-                    throw new Error('must provide at least one number');
-                }
-                const numbers = inputs.flat().map(val => {
-                    const num = Number(val);
-                    if (isNaN(num)) {
-                        throw new Error('Sum operator can\'t be used with non-numeric values');
-                    }
-                    return num;
-                });
-                return numbers.reduce((sum, num) => sum + num, 0);
-            },
-            // Product returns the product of all numbers in inputs
-            Product: (...inputs) => {
-                if (inputs.length === 0) {
-                    throw new Error('must provide at least one number');
-                }
-                const numbers = inputs.flat().map(val => {
-                    const num = Number(val);
-                    if (isNaN(num)) {
-                        throw new Error('Product operator can\'t be used with non-numeric values');
-                    }
-                    return num;
-                });
-                return numbers.reduce((product, num) => product * num, 1);
-            }
-        }));
-    }
-    /**
-     * Register time/date functions
-     * Equivalent to Go's registerTime()
-     */
-    registerTimeFunctions(funcMap) {
-        // Time namespace functions - following Go's time package
-        funcMap.set('time', () => ({
-            // AsTime converts a value to a time.Time
-            AsTime: (v) => {
-                if (!v)
-                    return null;
-                // If it's already a Date object
-                if (v instanceof Date)
-                    return v;
-                // If it's a string, try to parse it
-                if (typeof v === 'string') {
-                    const date = new Date(v);
-                    return isNaN(date.getTime()) ? null : date;
-                }
-                // If it's a number (unix timestamp)
-                if (typeof v === 'number') {
-                    // Check if it's in seconds (Unix timestamp) or milliseconds
-                    const date = new Date(v < 1e10 ? v * 1000 : v);
-                    return isNaN(date.getTime()) ? null : date;
-                }
-                return null;
-            },
-            // Format formats a time.Time
-            Format: (layout, value) => {
-                const date = value instanceof Date ? value : new Date(value);
-                if (isNaN(date.getTime())) {
-                    return '';
-                }
-                // Go time format parsing - based on reference time: Mon Jan 2 15:04:05 MST 2006
-                const year = date.getFullYear();
-                const month = date.getMonth() + 1; // JavaScript months are 0-based
-                const day = date.getDate();
-                const hour = date.getHours();
-                const minute = date.getMinutes();
-                const second = date.getSeconds();
-                const weekday = date.toLocaleString('en-US', { weekday: 'short' });
-                const monthName = date.toLocaleString('en-US', { month: 'short' });
-                // Go format patterns with unique placeholders to avoid conflicts
-                const patterns = [
-                    { pattern: '2006', placeholder: '{{YEAR_FULL}}', value: year.toString() },
-                    { pattern: 'January', placeholder: '{{MONTH_FULL}}', value: date.toLocaleString('en-US', { month: 'long' }) },
-                    { pattern: 'Monday', placeholder: '{{WEEKDAY_FULL}}', value: date.toLocaleString('en-US', { weekday: 'long' }) },
-                    { pattern: 'MST', placeholder: '{{TIMEZONE}}', value: date.toLocaleString('en-US', { timeZoneName: 'short' }) },
-                    { pattern: 'Jan', placeholder: '{{MONTH_SHORT}}', value: monthName },
-                    { pattern: 'Mon', placeholder: '{{WEEKDAY_SHORT}}', value: weekday },
-                    { pattern: '06', placeholder: '{{YEAR_SHORT}}', value: year.toString().slice(-2) },
-                    { pattern: '15', placeholder: '{{HOUR_24}}', value: hour.toString().padStart(2, '0') },
-                    { pattern: '01', placeholder: '{{MONTH_ZERO}}', value: month.toString().padStart(2, '0') },
-                    { pattern: '02', placeholder: '{{DAY_ZERO}}', value: day.toString().padStart(2, '0') },
-                    { pattern: '04', placeholder: '{{MINUTE_ZERO}}', value: minute.toString().padStart(2, '0') },
-                    { pattern: '05', placeholder: '{{SECOND_ZERO}}', value: second.toString().padStart(2, '0') },
-                    { pattern: 'PM', placeholder: '{{AMPM_UPPER}}', value: hour >= 12 ? 'PM' : 'AM' },
-                    { pattern: 'pm', placeholder: '{{AMPM_LOWER}}', value: hour >= 12 ? 'pm' : 'am' },
-                    { pattern: '3', placeholder: '{{HOUR_12}}', value: ((hour + 11) % 12 + 1).toString() },
-                    { pattern: '1', placeholder: '{{MONTH_NUM}}', value: month.toString() },
-                    { pattern: '2', placeholder: '{{DAY_NUM}}', value: day.toString() },
-                    { pattern: '4', placeholder: '{{MINUTE_NUM}}', value: minute.toString() },
-                    { pattern: '5', placeholder: '{{SECOND_NUM}}', value: second.toString() },
-                ];
-                let result = layout;
-                // Step 1: Replace patterns with unique placeholders
-                for (const { pattern, placeholder } of patterns) {
-                    const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                    result = result.replace(new RegExp(escapedPattern, 'g'), placeholder);
-                }
-                // Step 2: Replace placeholders with actual values
-                for (const { placeholder, value } of patterns) {
-                    result = result.replace(new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), value);
-                }
-                return result;
-            },
-            // Now returns the current time
-            Now: () => new Date(),
-            // Parse parses a formatted string and returns the time value it represents
-            Parse: (layout, value) => {
-                try {
-                    const date = new Date(value);
-                    return isNaN(date.getTime()) ? null : date;
-                }
-                catch {
-                    return null;
-                }
-            },
-            // Unix returns the Unix time in seconds
-            Unix: (value) => {
-                const date = value instanceof Date ? value : new Date(value);
-                return Math.floor(date.getTime() / 1000);
-            },
-            // UnixNano returns the Unix time in nanoseconds
-            UnixNano: (value) => {
-                const date = value instanceof Date ? value : new Date(value);
-                return date.getTime() * 1e6; // Convert milliseconds to nanoseconds
-            }
-        }));
-        // Now function that returns an object with Format method (Go-style)
-        funcMap.set('now', () => {
-            const date = new Date();
-            return {
-                Format: (layout) => {
-                    // Go time format parsing - based on reference time: Mon Jan 2 15:04:05 MST 2006
-                    // This represents Unix time 1136239445
-                    const year = date.getFullYear();
-                    const month = date.getMonth() + 1; // JavaScript months are 0-based
-                    const day = date.getDate();
-                    const hour = date.getHours();
-                    const minute = date.getMinutes();
-                    const second = date.getSeconds();
-                    // Go format patterns in order of precedence (longer patterns first to avoid conflicts)
-                    const patterns = [
-                        // Year patterns
-                        { pattern: '2006', value: year.toString() }, // 4-digit year
-                        { pattern: '06', value: year.toString().slice(-2) }, // 2-digit year
-                        // Month patterns  
-                        { pattern: '01', value: month.toString().padStart(2, '0') }, // 2-digit month
-                        { pattern: '1', value: month.toString() }, // 1-digit month
-                        // Day patterns
-                        { pattern: '02', value: day.toString().padStart(2, '0') }, // 2-digit day
-                        { pattern: '2', value: day.toString() }, // 1-digit day
-                        // Hour patterns (24-hour)
-                        { pattern: '15', value: hour.toString().padStart(2, '0') }, // 2-digit hour (24h)
-                        // Hour patterns (12-hour)
-                        { pattern: '3', value: ((hour % 12) || 12).toString() }, // 1-digit hour (12h)
-                        // Minute patterns
-                        { pattern: '04', value: minute.toString().padStart(2, '0') }, // 2-digit minute
-                        { pattern: '4', value: minute.toString() }, // 1-digit minute
-                        // Second patterns
-                        { pattern: '05', value: second.toString().padStart(2, '0') }, // 2-digit second
-                        { pattern: '5', value: second.toString() }, // 1-digit second
-                    ];
-                    let result = layout;
-                    // Apply patterns in order, using word boundaries to avoid partial matches
-                    for (const { pattern, value } of patterns) {
-                        // Use a more precise regex that considers word boundaries and context
-                        const regex = new RegExp(`\\b${pattern}\\b`, 'g');
-                        result = result.replace(regex, value);
-                    }
-                    // Handle some special cases that might not have word boundaries
-                    // For patterns that might be standalone or part of other formatting
-                    if (layout === '2006') {
-                        return year.toString(); // Pure year format
-                    }
-                    if (layout === '06') {
-                        return year.toString().slice(-2); // Pure 2-digit year format
-                    }
-                    if (layout === '01') {
-                        return month.toString().padStart(2, '0'); // Pure month format
-                    }
-                    if (layout === '02') {
-                        return day.toString().padStart(2, '0'); // Pure day format
-                    }
-                    if (layout === '15') {
-                        return hour.toString().padStart(2, '0'); // Pure hour format
-                    }
-                    if (layout === '04') {
-                        return minute.toString().padStart(2, '0'); // Pure minute format
-                    }
-                    if (layout === '05') {
-                        return second.toString().padStart(2, '0'); // Pure second format
-                    }
-                    return result;
-                },
-                // Also provide direct access to the Date object
-                getTime: () => date.getTime(),
-                toString: () => date.toString(),
-                toISOString: () => date.toISOString()
-            };
-        });
-        funcMap.set('dateFormat', (format, date) => {
-            // Simple date formatting - can be enhanced with proper library
-            return date.toLocaleDateString();
-        });
-    }
-    /**
-     * Register collection functions
-     * Equivalent to Go's registerCollections()
-     */
-    registerCollectionFunctions(funcMap) {
-        funcMap.set('len', (obj) => {
-            if (Array.isArray(obj))
-                return obj.length;
-            if (typeof obj === 'string')
-                return obj.length;
-            if (obj && typeof obj === 'object')
-                return Object.keys(obj).length;
-            return 0;
-        });
-        funcMap.set('first', (n, arr) => {
-            // Handle both cases: first(n, arr) and first(arr)
-            if (Array.isArray(n)) {
-                // Called as first(arr) - return first element
-                return n.slice(0, 1);
-            }
-            else if (Array.isArray(arr)) {
-                // Called as first(n, arr) - return first n elements
-                return arr.slice(0, n);
-            }
-            return [];
-        });
-        funcMap.set('last', (n, arr) => {
-            // Handle both cases: last(n, arr) and last(arr)
-            if (Array.isArray(n)) {
-                // Called as last(arr) - return last element
-                return n.slice(-1);
-            }
-            else if (Array.isArray(arr)) {
-                // Called as last(n, arr) - return last n elements
-                return arr.slice(-n);
-            }
-            return [];
-        });
-        // Merge function for combining objects/maps
-        funcMap.set('merge', (...args) => {
-            const result = {};
-            for (const arg of args) {
-                if (arg && typeof arg === 'object' && !Array.isArray(arg)) {
-                    Object.assign(result, arg);
-                }
-            }
-            return result;
-        });
-        // Index function to get item at index - supports nested indexing like Go's implementation
-        // Usage: {{ index array 0 }} or {{ index object "key" }} or {{ index nested "key1" "key2" 0 }}
-        funcMap.set('index', (item, ...indices) => {
-            try {
-                return this.doIndex(item, indices);
-            }
-            catch (error) {
-                log.error(`Index of type ${typeof item} with args [${indices.join(', ')}] failed:`, error);
-                return null;
-            }
-        });
-        // Reverse function
-        funcMap.set('reverse', (arr) => {
-            if (Array.isArray(arr)) {
-                return [...arr].reverse();
-            }
-            return arr;
-        });
-        // Append function
-        funcMap.set('append', (...args) => {
-            if (args.length < 2) {
-                return args[0] || [];
-            }
-            const result = Array.isArray(args[0]) ? [...args[0]] : [args[0]];
-            // For each remaining argument, spread it if it's an array, otherwise add as single element
-            for (let i = 1; i < args.length; i++) {
-                if (Array.isArray(args[i])) {
-                    result.push(...args[i]);
-                }
-                else {
-                    result.push(args[i]);
-                }
-            }
-            return result;
-        });
-        // Prepend function
-        funcMap.set('prepend', (arr, ...items) => {
-            if (Array.isArray(arr)) {
-                return [...items, ...arr];
-            }
-            return [...items, arr];
-        });
-        // Seq creates a sequence of integers from args. It's named and used as GNU's seq.
-        // Examples:
-        // 3 => 1, 2, 3
-        // 1 2 4 => 1, 3
-        // -3 => -1, -2, -3
-        // 1 4 => 1, 2, 3, 4
-        // 1 -2 => 1, 0, -1, -2
-        funcMap.set('seq', (...args) => {
-            if (args.length < 1 || args.length > 3) {
-                throw new Error('invalid number of arguments to Seq');
-            }
-            // Convert all arguments to integers
-            const intArgs = args.map(arg => {
-                const num = Number(arg);
-                if (isNaN(num)) {
-                    throw new Error('invalid arguments to Seq');
-                }
-                return Math.floor(num);
-            });
-            let inc = 1;
-            let last;
-            let first = intArgs[0];
-            if (intArgs.length === 1) {
-                last = first;
-                if (last === 0) {
-                    return [];
-                }
-                else if (last > 0) {
-                    first = 1;
-                }
-                else {
-                    first = -1;
-                    inc = -1;
-                }
-            }
-            else if (intArgs.length === 2) {
-                last = intArgs[1];
-                if (last < first) {
-                    inc = -1;
-                }
-            }
-            else {
-                inc = intArgs[1];
-                last = intArgs[2];
-                if (inc === 0) {
-                    throw new Error("'increment' must not be 0");
-                }
-                if (first < last && inc < 0) {
-                    throw new Error("'increment' must be > 0");
-                }
-                if (first > last && inc > 0) {
-                    throw new Error("'increment' must be < 0");
-                }
-            }
-            // Sanity check
-            if (last < -100000) {
-                throw new Error('size of result exceeds limit');
-            }
-            const size = Math.floor((last - first) / inc) + 1;
-            // Sanity check
-            if (size <= 0 || size > 2000) {
-                throw new Error('size of result exceeds limit');
-            }
-            const seq = new Array(size);
-            let val = first;
-            for (let i = 0; i < size; i++) {
-                seq[i] = val;
-                val += inc;
-                if ((inc < 0 && val < last) || (inc > 0 && val > last)) {
-                    break;
-                }
-            }
-            return seq;
-        });
-        // Sort returns a sorted copy of the list l
-        // Equivalent to Go's Sort function in collections namespace
-        // Usage: sort list [sortByField] [direction]
-        // Examples:
-        // {{ sort .Pages }} - sort by default comparison
-        // {{ sort .Pages "Title" }} - sort by Title field ascending  
-        // {{ sort .Pages "Date" "desc" }} - sort by Date field descending
-        funcMap.set('sort', (list, ...args) => {
-            if (list === null || list === undefined) {
-                throw new Error('sequence must be provided');
-            }
-            let arr;
-            // Handle different input types
-            if (Array.isArray(list)) {
-                arr = [...list]; // Create a copy to avoid mutating original
-            }
-            else if (typeof list === 'object' && list !== null) {
-                // Handle objects/maps - convert to array of values
-                arr = Object.values(list);
-            }
-            else {
-                throw new Error(`can't sort ${typeof list}`);
-            }
-            if (arr.length === 0) {
-                return arr;
-            }
-            // Parse arguments
-            let sortByField = '';
-            let sortAsc = true;
-            for (let i = 0; i < args.length; i++) {
-                const arg = args[i];
-                if (i === 0) {
-                    // First argument is the field to sort by
-                    if (typeof arg === 'string') {
-                        sortByField = arg;
-                    }
-                }
-                else if (i === 1) {
-                    // Second argument is the sort direction
-                    if (typeof arg === 'string' && arg.toLowerCase() === 'desc') {
-                        sortAsc = false;
-                    }
-                }
-            }
-            // Helper function to get nested property value
-            const getNestedValue = (obj, path) => {
-                if (!path || path === 'value') {
-                    return obj;
-                }
-                const keys = path.split('.');
-                let current = obj;
-                for (const key of keys) {
-                    if (current === null || current === undefined) {
-                        return undefined;
-                    }
-                    // Handle both object properties and method calls
-                    if (typeof current === 'object') {
-                        current = current[key];
-                    }
-                    else {
-                        return undefined;
-                    }
-                }
-                return current;
-            };
-            // Comparison function
-            const compare = (a, b) => {
-                let aVal = sortByField ? getNestedValue(a, sortByField) : a;
-                let bVal = sortByField ? getNestedValue(b, sortByField) : b;
-                // Handle undefined/null values
-                if (aVal === undefined || aVal === null) {
-                    if (bVal === undefined || bVal === null) {
-                        return 0;
-                    }
-                    return sortAsc ? -1 : 1;
-                }
-                if (bVal === undefined || bVal === null) {
-                    return sortAsc ? 1 : -1;
-                }
-                // Convert to comparable values
-                if (typeof aVal === 'string' && typeof bVal === 'string') {
-                    const result = aVal.localeCompare(bVal);
-                    return sortAsc ? result : -result;
-                }
-                if (typeof aVal === 'number' && typeof bVal === 'number') {
-                    const result = aVal - bVal;
-                    return sortAsc ? result : -result;
-                }
-                // For mixed types, convert to strings and compare
-                const aStr = String(aVal);
-                const bStr = String(bVal);
-                const result = aStr.localeCompare(bStr);
-                return sortAsc ? result : -result;
-            };
-            // Sort the array
-            return arr.sort(compare);
-        });
-        // where function - filters a collection based on conditions
-        // Usage: {{ where .Pages "Section" "blog" }}
-        // Usage: {{ where .Pages "Params.tags" "intersect" (slice "hugo" "go") }}
-        funcMap.set('where', (() => {
-            return (collection, key, ...args) => {
-                if (!collection) {
-                    return [];
-                }
-                // Parse arguments to get value and operator
-                let matchValue;
-                let operator = '=='; // default operator
-                if (args.length === 1) {
-                    matchValue = args[0];
-                }
-                else if (args.length === 2) {
-                    operator = args[0];
-                    matchValue = args[1];
-                }
-                else {
-                    throw new Error('where function requires 2-4 arguments');
-                }
-                const result = [];
-                // Handle different collection types
-                if (Array.isArray(collection)) {
-                    for (let i = 0; i < collection.length; i++) {
-                        const item = collection[i];
-                        const itemValue = this.getNestedValue(item, key);
-                        if (this.checkCondition(itemValue, matchValue, operator)) {
-                            result.push(item);
-                        }
-                    }
-                }
-                else if (typeof collection === 'object') {
-                    // Handle object/map
-                    for (const [mapKey, mapValue] of Object.entries(collection)) {
-                        if (Array.isArray(mapValue)) {
-                            const filtered = mapValue.filter(item => {
-                                const itemValue = this.getNestedValue(item, key);
-                                return this.checkCondition(itemValue, matchValue, operator);
-                            });
-                            if (filtered.length > 0) {
-                                result.push({ [mapKey]: filtered });
-                            }
-                        }
-                    }
-                }
-                return result;
-            };
-        })());
-        // intersect function - finds intersection of two arrays
-        funcMap.set('intersect', (set1, set2) => {
-            if (!Array.isArray(set1) || !Array.isArray(set2)) {
-                return [];
-            }
-            return set1.filter(item => set2.includes(item));
-        });
-        // querify function - converts key-value pairs to URL query string
-        // Usage: {{ querify "foo" 1 "bar" 2 "baz" "with spaces" }}
-        // Returns: bar=2&baz=with+spaces&foo=1
-        // Also supports array input: {{ slice "foo" 1 "bar" 2 | querify }}
-        funcMap.set('querify', (...args) => {
-            let params = [];
-            // Handle single array argument (from pipe)
-            if (args.length === 1 && Array.isArray(args[0])) {
-                params = args[0];
-            }
-            else {
-                params = args;
-            }
-            // Must have even number of parameters (key-value pairs)
-            if (params.length % 2 !== 0) {
-                throw new Error('querify requires an even number of arguments (key-value pairs)');
-            }
-            const queryParams = [];
-            // Process key-value pairs
-            for (let i = 0; i < params.length; i += 2) {
-                const key = String(params[i]);
-                const value = String(params[i + 1]);
-                queryParams.push([key, value]);
-            }
-            // Sort by key for consistent output (like Go's implementation)
-            queryParams.sort((a, b) => a[0].localeCompare(b[0]));
-            // Build query string
-            const queryString = queryParams
-                .map(([key, value]) => {
-                // URL encode key and value, replacing %20 with + for spaces (query string convention)
-                const encodedKey = encodeURIComponent(key).replace(/%20/g, '+');
-                const encodedValue = encodeURIComponent(value).replace(/%20/g, '+');
-                return `${encodedKey}=${encodedValue}`;
-            })
-                .join('&');
-            return queryString;
-        });
-        // IsSet returns whether a given array, slice, or map has the given key defined
-        // Equivalent to Go's IsSet function in collections namespace
-        // Usage: {{ isset .array 0 }} or {{ isset .object "key" }}
-        funcMap.set('isset', (c, key) => {
-            if (c === null || c === undefined) {
-                return false;
-            }
-            // Handle arrays and slices
-            if (Array.isArray(c)) {
-                // Convert key to integer for array indexing
-                const k = Number(key);
-                if (isNaN(k) || !Number.isInteger(k)) {
-                    console.warn(`isset unable to use key of type ${typeof key} as index`);
-                    return false;
-                }
-                // Check if index is valid (within bounds)
-                return c.length > k && k >= 0;
-            }
-            // Handle objects/maps
-            if (typeof c === 'object') {
-                // For objects, check if the key exists as a property
-                return key in c;
-            }
-            // Handle strings (similar to arrays, but for character indexing)
-            if (typeof c === 'string') {
-                const k = Number(key);
-                if (isNaN(k) || !Number.isInteger(k)) {
-                    console.warn(`isset unable to use key of type ${typeof key} as index`);
-                    return false;
-                }
-                return c.length > k && k >= 0;
-            }
-            // Unsupported types
-            console.warn(`calling isset with unsupported type "${typeof c}" (${c.constructor?.name || typeof c}) will always return false.`);
-            return false;
-        });
-    }
-    /**
-     * Core indexing implementation following Go's doIndex logic
-     * Supports nested indexing of arrays, objects, and maps
-     */
-    doIndex(item, indices) {
-        // Handle null/undefined item
-        if (item === null || item === undefined) {
-            return null;
-        }
-        // If no indices provided, return the item itself
-        if (indices.length === 0) {
-            return item;
-        }
-        let currentValue = item;
-        // Process each index in sequence (supports chained indexing like x[1][2][3])
-        for (const index of indices) {
-            // Handle null/undefined current value in chain
-            if (currentValue === null || currentValue === undefined) {
-                return null;
-            }
-            // Determine how to index based on the current value type
-            if (Array.isArray(currentValue)) {
-                // Handle array/slice indexing
-                currentValue = this.indexArray(currentValue, index);
-            }
-            else if (typeof currentValue === 'string') {
-                // Handle string indexing (strings are indexable like arrays)
-                currentValue = this.indexString(currentValue, index);
-            }
-            else if (typeof currentValue === 'object') {
-                // Handle object/map indexing (including TaxonomyList type)
-                currentValue = this.indexObject(currentValue, index);
-            }
-            else {
-                // Cannot index this type
-                throw new Error(`can't index item of type ${typeof currentValue}`);
-            }
-        }
-        return currentValue;
-    }
-    /**
-     * Index into an array or slice
-     */
-    indexArray(arr, index) {
-        // Convert index to integer
-        const i = this.toInteger(index);
-        if (i === null) {
-            throw new Error(`cannot index slice/array with type ${typeof index}`);
-        }
-        // Check bounds - Go version returns null for out of bounds instead of error
-        if (i < 0 || i >= arr.length) {
-            return null;
-        }
-        return arr[i];
-    }
-    /**
-     * Index into a string (treating it like a character array)
-     */
-    indexString(str, index) {
-        // Convert index to integer
-        const i = this.toInteger(index);
-        if (i === null) {
-            throw new Error(`cannot index string with type ${typeof index}`);
-        }
-        // Check bounds
-        if (i < 0 || i >= str.length) {
-            return null;
-        }
-        return str.charAt(i);
-    }
-    /**
-     * Index into an object/map (including TaxonomyList)
-     */
-    indexObject(obj, key) {
-        // Convert key to string for object property access
-        const keyStr = String(key);
-        // Check if property exists
-        if (obj.hasOwnProperty(keyStr)) {
-            return obj[keyStr];
-        }
-        // Try case-insensitive lookup (following Hugo's behavior)
-        const keys = Object.keys(obj);
-        const matchingKey = keys.find(k => k.toLowerCase() === keyStr.toLowerCase());
-        if (matchingKey) {
-            return obj[matchingKey];
-        }
-        // Map
-        if (obj instanceof Map) {
-            if (obj.has(keyStr)) {
-                return obj.get(keyStr);
-            }
-            // case-insensitive 查找
-            for (const k of obj.keys()) {
-                if (String(k).toLowerCase() === keyStr.toLowerCase()) {
-                    return obj.get(k);
-                }
-            }
-        }
-        // Property not found - return undefined/null like Go's zero value
-        return null;
-    }
-    /**
-     * Convert value to integer, similar to Go's index conversion
-     */
-    toInteger(value) {
-        if (typeof value === 'number') {
-            if (Number.isInteger(value)) {
-                return value;
-            }
-            // Convert float to int (truncate)
-            return Math.floor(value);
-        }
-        if (typeof value === 'string') {
-            const parsed = parseInt(value, 10);
-            if (!isNaN(parsed)) {
-                return parsed;
-            }
-        }
-        // Cannot convert to integer
-        return null;
-    }
-    /**
-     * Check condition between two values using the specified operator
-     * Following golang's checkCondition logic
-     */
-    checkCondition(value, matchValue, operator) {
-        // Normalize operator
-        const op = operator.toLowerCase().trim();
-        // Handle null/undefined cases
-        if (value == null && matchValue == null) {
-            return ['==', '=', 'eq', ''].includes(op);
-        }
-        if (value == null || matchValue == null) {
-            return ['!=', '<>', 'ne'].includes(op);
-        }
-        // Handle array membership (in operator)
-        if (op === 'in') {
-            if (Array.isArray(matchValue)) {
-                return matchValue.includes(value);
-            }
-            if (typeof matchValue === 'string' && typeof value === 'string') {
-                return matchValue.includes(value);
-            }
-            return false;
-        }
-        // Handle intersect operator for arrays
-        if (op === 'intersect') {
-            if (Array.isArray(value) && Array.isArray(matchValue)) {
-                return value.some(item => matchValue.includes(item));
-            }
-            return false;
-        }
-        // Type conversion for comparison
-        const [normalizedValue, normalizedMatch] = this.normalizeForComparison(value, matchValue);
-        switch (op) {
-            case '':
-            case '=':
-            case '==':
-            case 'eq':
-                return normalizedValue === normalizedMatch;
-            case '!=':
-            case '<>':
-            case 'ne':
-                return normalizedValue !== normalizedMatch;
-            case '<':
-            case 'lt':
-                return normalizedValue < normalizedMatch;
-            case '<=':
-            case 'le':
-                return normalizedValue <= normalizedMatch;
-            case '>':
-            case 'gt':
-                return normalizedValue > normalizedMatch;
-            case '>=':
-            case 'ge':
-                return normalizedValue >= normalizedMatch;
-            default:
-                return false;
-        }
-    }
-    /**
-     * Normalize values for comparison
-     */
-    normalizeForComparison(value, matchValue) {
-        // If both are numbers, compare as numbers
-        if (typeof value === 'number' && typeof matchValue === 'number') {
-            return [value, matchValue];
-        }
-        // If one is number and other is string number, convert both to numbers
-        if (typeof value === 'number' && typeof matchValue === 'string') {
-            const num = parseFloat(matchValue);
-            if (!isNaN(num)) {
-                return [value, num];
-            }
-        }
-        if (typeof value === 'string' && typeof matchValue === 'number') {
-            const num = parseFloat(value);
-            if (!isNaN(num)) {
-                return [num, matchValue];
-            }
-        }
-        // If both are strings, compare as strings
-        if (typeof value === 'string' && typeof matchValue === 'string') {
-            return [value, matchValue];
-        }
-        // If both are booleans, compare as booleans
-        if (typeof value === 'boolean' && typeof matchValue === 'boolean') {
-            return [value, matchValue];
-        }
-        // Default: convert both to strings for comparison
-        return [String(value), String(matchValue)];
-    }
-    /**
-     * Register safe functions
-     * Equivalent to Go's registerSafe()
-     */
-    registerSafeFunctions(funcMap) {
-        // Return function - implements early return like Go's template.Return
-        // Usage: {{ return VALUE }}
-        funcMap.set('return', (...args) => {
-            // If no arguments provided, return empty string
-            if (args.length === 0) {
-                return '';
-            }
-            // If single argument, return it directly
-            if (args.length === 1) {
-                return args[0];
-            }
-            // If multiple arguments, return them as an array
-            return args;
-        });
-        // Cond function - implements conditional branching like Go's template.Cond
-        // Usage: {{ cond CONDITION VALUE_IF_TRUE VALUE_IF_FALSE }}
-        funcMap.set('cond', (...args) => {
-            if (args.length < 2) {
-                throw new Error('cond requires at least 2 arguments');
-            }
-            const condition = args[0];
-            const trueValue = args[1];
-            const falseValue = args.length > 2 ? args[2] : '';
-            // Convert condition to boolean, following Go's truthiness rules
-            let isTrue = false;
-            if (condition === true || condition === 1) {
-                isTrue = true;
-            }
-            else if (typeof condition === 'string') {
-                isTrue = condition.length > 0 && condition !== "false" && condition !== "0";
-            }
-            else if (typeof condition === 'number') {
-                isTrue = condition !== 0;
-            }
-            else if (Array.isArray(condition)) {
-                isTrue = condition.length > 0;
-            }
-            else if (condition && typeof condition === 'object') {
-                isTrue = Object.keys(condition).length > 0;
-            }
-            return isTrue ? trueValue : falseValue;
-        });
-        funcMap.set('safeHTML', (str) => str);
-        funcMap.set('safeCSS', (str) => str);
-        funcMap.set('safeJS', (str) => str);
-        funcMap.set('safeURL', (str) => str);
-        // Dict function for creating key-value maps
-        funcMap.set('dict', (...args) => {
-            if (args.length % 2 !== 0) {
-                throw new Error('dict requires an even number of arguments');
-            }
-            const result = {};
-            for (let i = 0; i < args.length; i += 2) {
-                result[String(args[i])] = args[i + 1];
-            }
-            return result;
-        });
-        // Slice function for creating arrays
-        funcMap.set('slice', (...args) => {
-            return args;
-        });
-        // Default function for providing default values
-        // TypeScript equivalent of Go's default function
-        funcMap.set('default', (defaultValue, value) => {
-            // Return the value if it exists and is not empty/null/undefined, otherwise return default
-            if (value !== null && value !== undefined && value !== '' && value !== 0) {
-                return value;
-            }
-            return defaultValue;
-        });
-        // Jsonify function - encodes a given object to JSON
-        // Usage: {{ jsonify . }}
-        // Usage: {{ jsonify (dict "indent" "  ") . }}
-        funcMap.set('jsonify', (...args) => {
-            if (args.length === 0) {
-                return '';
-            }
-            let obj;
-            let opts = {};
-            if (args.length === 1) {
-                obj = args[0];
-            }
-            else if (args.length === 2) {
-                // First argument is options, second is the object to jsonify
-                const options = args[0];
-                obj = args[1];
-                if (options && typeof options === 'object') {
-                    opts.prefix = options.prefix || '';
-                    opts.indent = options.indent || '';
-                    opts.noHTMLEscape = options.noHTMLEscape || false;
-                }
-            }
-            else {
-                throw new Error('too many arguments to jsonify');
-            }
-            try {
-                let jsonString;
-                if (opts.indent) {
-                    // Pretty print with indentation
-                    jsonString = JSON.stringify(obj, null, opts.indent);
-                    // Add prefix to each line if specified
-                    if (opts.prefix) {
-                        jsonString = jsonString
-                            .split('\n')
-                            .map(line => opts.prefix + line)
-                            .join('\n');
-                    }
-                }
-                else {
-                    // Compact JSON
-                    jsonString = JSON.stringify(obj);
-                }
-                // Handle HTML escaping (by default, JSON.stringify doesn't escape HTML)
-                if (!opts.noHTMLEscape) {
-                    jsonString = jsonString
-                        .replace(/&/g, '\\u0026')
-                        .replace(/</g, '\\u003c')
-                        .replace(/>/g, '\\u003e');
-                }
-                return jsonString;
-            }
-            catch (error) {
-                throw new Error(`failed to jsonify object: ${error.message}`);
-            }
-        });
-    }
-    /**
-     * Register format functions (fmt namespace)
-     * Equivalent to Go's registerFmt()
-     */
-    registerFmtFunctions(funcMap) {
-        // Basic printf, print, println functions (for backward compatibility)
-        funcMap.set('printf', (format, ...args) => {
-            // Enhanced printf implementation supporting %v, %s, %d, %f, %t
-            let result = format;
-            let argIndex = 0;
-            // Replace format specifiers sequentially
-            result = result.replace(/%[vsdft%]/g, (match) => {
-                if (match === '%%') {
-                    return '%'; // Literal %
-                }
-                if (argIndex >= args.length) {
-                    return match; // Not enough arguments, keep the format specifier
-                }
-                const arg = args[argIndex++];
-                switch (match) {
-                    case '%v': // Go's general format specifier
-                    case '%s': // String
-                        return String(arg);
-                    case '%d': // Integer
-                        return String(Math.floor(Number(arg) || 0));
-                    case '%f': // Float
-                        return String(Number(arg) || 0);
-                    case '%t': // Boolean
-                        return String(Boolean(arg));
-                    default:
-                        return String(arg);
-                }
-            });
-            return result;
-        });
-        funcMap.set('print', (...args) => {
-            return args.map(arg => String(arg)).join(' ');
-        });
-        funcMap.set('println', (...args) => {
-            return args.map(arg => String(arg)).join(' ') + '\n';
-        });
-        // Standalone errorf and warnf functions for backward compatibility
-        funcMap.set('errorf', (format, ...args) => {
-            let message = format;
-            for (let i = 0; i < args.length; i++) {
-                message = message.replace(/%[sd%]/, String(args[i]));
-            }
-            log.error("Template Error:", message);
-            return ''; // errorf returns empty string but logs the error
-        });
-        funcMap.set('warnf', (format, ...args) => {
-            let message = format;
-            for (let i = 0; i < args.length; i++) {
-                message = message.replace(/%[sd%]/, String(args[i]));
-            }
-            log.warn("Template Warning:", message);
-            return ''; // warnf returns empty string but logs the warning
-        });
-        // Fmt namespace functions - following Go's fmt package
-        funcMap.set('fmt', () => ({
-            // Print returns a string representation of args
-            Print: (...args) => {
-                return args.map(arg => String(arg)).join(' ');
-            },
-            // Printf returns string representation of args formatted with the layout in format
-            Printf: (format, ...args) => {
-                let result = format;
-                for (let i = 0; i < args.length; i++) {
-                    result = result.replace(/%[sd%]/, String(args[i]));
-                }
-                return result;
-            },
-            // Println returns string representation of args ending with a newline
-            Println: (...args) => {
-                return args.map(arg => String(arg)).join(' ') + '\n';
-            },
-            // Errorf formats args according to a format specifier and logs an ERROR
-            // It returns an empty string
-            Errorf: (format, ...args) => {
-                let message = format;
-                for (let i = 0; i < args.length; i++) {
-                    message = message.replace(/%[sd%]/, String(args[i]));
-                }
-                log.error("Template Error:", message);
-                return '';
-            },
-            // Erroridf formats args according to a format specifier and logs an ERROR with ID
-            // It returns an empty string  
-            Erroridf: (id, format, ...args) => {
-                let message = format;
-                for (let i = 0; i < args.length; i++) {
-                    message = message.replace(/%[sd%]/, String(args[i]));
-                }
-                log.error("Template Error:", message);
-                return '';
-            },
-            // Warnf formats args according to a format specifier and logs a WARNING
-            // It returns an empty string
-            Warnf: (format, ...args) => {
-                let message = format;
-                for (let i = 0; i < args.length; i++) {
-                    message = message.replace(/%[sd%]/, String(args[i]));
-                }
-                log.error("Template Warning:", message);
-                return '';
-            },
-            // Warnidf formats args according to a format specifier and logs a WARNING with ID
-            // It returns an empty string
-            Warnidf: (id, format, ...args) => {
-                let message = format;
-                for (let i = 0; i < args.length; i++) {
-                    message = message.replace(/%[sd%]/, String(args[i]));
-                }
-                log.error("Template Warning:", message);
-                return '';
-            }
-        }));
-    }
-    /**
-     * Register reflect functions
-     * Equivalent to Go's registerReflect()
-     */
-    registerReflectFunctions(funcMap) {
-        // Reflect namespace functions - following Go's reflect package
-        funcMap.set('reflect', () => ({
-            // IsMap reports whether v is a map/object
-            // Following Go's implementation: only true maps, not structs/classes
-            IsMap: (v) => {
-                if (v === null || v === undefined) {
-                    return false;
-                }
-                // Must be an object
-                if (typeof v !== 'object' || Array.isArray(v)) {
-                    return false;
-                }
-                // In TypeScript/JavaScript context, we consider something a "map" only if:
-                // 1. It's a plain Object (constructor === Object)
-                // 2. OR it's a Map instance
-                // 3. OR it was explicitly created as a dict/map (has no prototype methods)
-                // Check for Map instance
-                if (v instanceof Map) {
-                    return true;
-                }
-                // Check for plain object (like golang's map)
-                if (v.constructor === Object) {
-                    return true;
-                }
-                // Check if it looks like a dict created by template functions
-                // (has no methods, only data properties)
-                const proto = Object.getPrototypeOf(v);
-                if (proto === Object.prototype || proto === null) {
-                    return true;
-                }
-                // Everything else (including class instances like Page) is not a map
-                return false;
-            },
-            // IsSlice reports whether v is a slice/array
-            IsSlice: (v) => {
-                return Array.isArray(v);
-            }
-        }));
-    }
-    /**
-     * Register path manipulation functions
-     * Equivalent to Go's path package functions
-     */
-    registerPathFunctions(funcMap) {
-        // Path namespace functions - following Go's path package
-        funcMap.set('path', () => ({
-            // Base returns the last element of path
-            Base: (path) => {
-                if (!path)
-                    return '.';
-                // 替换 Windows 分隔符 \ 为 /
-                path = path.replace(/\\/g, '/');
-                // Trim trailing slashes
-                path = path.replace(/\/+$/, '');
-                if (!path)
-                    return '/';
-                // Get the last part after the last slash
-                const parts = path.split('/');
-                return parts[parts.length - 1] || '/';
-            },
-            // Clean returns the shortest path name equivalent to path
-            Clean: (path) => {
-                if (!path)
-                    return '.';
-                // Convert backslashes to forward slashes
-                path = path.replace(/\\/g, '/');
-                // Handle absolute paths
-                const isAbs = path.startsWith('/');
-                // Split path into parts
-                const parts = path.split('/').filter(p => p && p !== '.');
-                // Handle .. parts
-                const stack = [];
-                for (const part of parts) {
-                    if (part === '..') {
-                        if (stack.length > 0 && stack[stack.length - 1] !== '..') {
-                            stack.pop();
-                        }
-                        else if (!isAbs) {
-                            stack.push('..');
-                        }
-                    }
-                    else {
-                        stack.push(part);
-                    }
-                }
-                // Join parts back together
-                path = stack.join('/');
-                if (isAbs)
-                    path = '/' + path;
-                return path || (isAbs ? '/' : '.');
-            },
-            // Dir returns all but the last element of path
-            Dir: (path) => {
-                if (!path)
-                    return '.';
-                // Trim trailing slashes
-                path = path.replace(/\/+$/, '');
-                if (!path)
-                    return '/';
-                // Get everything before the last slash
-                const parts = path.split('/');
-                parts.pop();
-                return parts.join('/') || '.';
-            },
-            // Ext returns the file name extension
-            Ext: (path) => {
-                const base = path.split('/').pop() || '';
-                const dot = base.lastIndexOf('.');
-                if (dot === -1 || dot === 0)
-                    return '';
-                return base.substring(dot);
-            },
-            // IsAbs reports whether the path is absolute
-            IsAbs: (path) => {
-                return path.startsWith('/');
-            },
-            // Join joins any number of path elements into a single path
-            Join: (...elements) => {
-                if (elements.length === 0)
-                    return '.';
-                // Filter out empty elements and handle trailing slashes
-                const parts = elements
-                    .filter(e => e)
-                    .map(e => e.replace(/^\/+|\/+$/g, ''));
-                // Join parts with single slashes
-                let path = parts.join('/');
-                // Handle absolute paths
-                if (elements[0] && elements[0].startsWith('/')) {
-                    path = '/' + path;
-                }
-                return path || '.';
-            },
-            // Split splits path immediately following the final slash
-            Split: (path) => {
-                if (!path)
-                    return ['.', ''];
-                // Find the last slash
-                const lastSlash = path.lastIndexOf('/');
-                if (lastSlash === -1) {
-                    return ['', path];
-                }
-                return [
-                    path.substring(0, lastSlash),
-                    path.substring(lastSlash + 1)
-                ];
-            }
-        }));
-    }
-    /**
-     * Register transform functions (unmarshal, etc.)
-     * Equivalent to Go's transform package functions
-     */
-    registerTransformFunctions(funcMap) {
-        // Transform namespace functions - following Go's transform package
-        funcMap.set('transform', () => ({
-            // Unmarshal unmarshals data from JSON, YAML, TOML, CSV formats
-            // Usage: {{ $data := "{"key": "value"}" | transform.Unmarshal }}
-            // Usage: {{ $data := (dict "format" "json") $jsonString | transform.Unmarshal }}
-            Unmarshal: (...args) => {
-                if (args.length < 1 || args.length > 2) {
-                    throw new Error('unmarshal takes 1 or 2 arguments');
-                }
-                let data;
-                let options = {};
-                if (args.length === 1) {
-                    data = args[0];
-                }
-                else {
-                    // First argument is options map
-                    const opts = args[0];
-                    if (!opts || typeof opts !== 'object') {
-                        throw new Error('first argument must be a map');
-                    }
-                    options = opts;
-                    data = args[1];
-                }
-                // Handle Resource objects (if data has Content method)
-                if (data && typeof data === 'object' && typeof data.Content === 'function') {
-                    try {
-                        const content = data.Content();
-                        return this.unmarshalContent(content, options);
-                    }
-                    catch (error) {
-                        throw new Error(`failed to get content from resource: ${error.message}`);
-                    }
-                }
-                // Handle string data
-                let dataStr;
-                if (typeof data === 'string') {
-                    dataStr = data;
-                }
-                else if (data && typeof data.toString === 'function') {
-                    dataStr = data.toString();
-                }
-                else {
-                    throw new Error(`type ${typeof data} not supported`);
-                }
-                if (!dataStr || dataStr.trim() === '') {
-                    return null;
-                }
-                return this.unmarshalContent(dataStr, options);
-            },
-            // Plainify returns a copy of s with all HTML tags removed
-            // Equivalent to Go's Plainify function in transform namespace
-            // Usage: {{ "Hello <strong>world</strong>!" | transform.Plainify }} -> "Hello world!"
-            // Usage: {{ transform.Plainify "<p>Text with <br> tags</p>" }} -> "Text with tags"
-            Plainify: (s) => {
-                const str = String(s);
-                return this.stripHTML(str);
-            }
-        }));
-        // Also register unmarshal as a standalone function for backward compatibility
-        funcMap.set('unmarshal', (...args) => {
-            const transform = funcMap.get('transform')();
-            return transform.Unmarshal(...args);
-        });
-        // Register plainify as a standalone function for convenience
-        funcMap.set('plainify', (s) => {
-            const str = String(s);
-            return this.stripHTML(str);
-        });
-    }
-    /**
-     * Strip HTML tags from a string
-     * Equivalent to Go's helpers.StripHTML function
-     * Preserves line breaks from block elements and normalizes whitespace
-     */
-    stripHTML(html) {
-        // Shortcut for strings with no HTML tags
-        if (!html.includes('<') && !html.includes('>')) {
-            return html;
-        }
-        // First pass: Replace block elements that should create line breaks
-        let result = html
-            .replace(/\n/g, ' ') // Convert newlines to spaces first
-            .replace(/<\/p>/gi, '\n') // </p> creates line break
-            .replace(/<br\s*\/?>/gi, '\n') // <br> and <br/> create line breaks
-            .replace(/<\/div>/gi, '\n') // </div> creates line break
-            .replace(/<\/h[1-6]>/gi, '\n') // Heading end tags create line breaks
-            .replace(/<\/li>/gi, '\n') // List items create line breaks
-            .replace(/<\/tr>/gi, '\n') // Table rows create line breaks
-            .replace(/<\/blockquote>/gi, '\n'); // Blockquotes create line breaks
-        // Second pass: Remove all HTML tags
-        result = result.replace(/<[^>]*>/g, '');
-        // Third pass: Normalize whitespace
-        // Convert multiple spaces to single spaces, but preserve intentional line breaks
-        const lines = result.split('\n');
-        const normalizedLines = lines.map(line => line.trim().replace(/\s+/g, ' '));
-        // Join lines back together, removing empty lines but preserving intentional breaks
-        result = normalizedLines
-            .filter(line => line.length > 0)
-            .join('\n')
-            .trim();
-        // Final cleanup: ensure we don't have multiple consecutive newlines
-        result = result.replace(/\n\s*\n/g, '\n');
-        return result;
-    }
-    /**
-     * Unmarshal content from string based on format
-     * Supports JSON, YAML, TOML, CSV formats
-     */
-    unmarshalContent(content, options = {}) {
-        const trimmedContent = content.trim();
-        if (!trimmedContent) {
-            return null;
-        }
-        // Determine format
-        let format = options.format;
-        if (!format) {
-            format = this.detectFormat(trimmedContent);
-        }
-        try {
-            switch (format.toLowerCase()) {
-                case 'json':
-                    return JSON.parse(trimmedContent);
-                case 'yaml':
-                case 'yml':
-                    return this.parseYAML(trimmedContent);
-                case 'toml':
-                    return this.parseTOML(trimmedContent);
-                case 'csv':
-                    return this.parseCSV(trimmedContent);
-                default:
-                    throw new Error(`format "${format}" not supported`);
-            }
-        }
-        catch (error) {
-            throw new Error(`failed to unmarshal ${format}: ${error.message}`);
-        }
-    }
-    /**
-     * Detect format from content
-     */
-    detectFormat(content) {
-        const trimmed = content.trim();
-        // JSON detection
-        if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
-            (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
-            try {
-                JSON.parse(trimmed);
-                return 'json';
-            }
-            catch {
-                // Not valid JSON, continue checking
-            }
-        }
-        // YAML detection (starts with --- or has key: value patterns)
-        if (trimmed.startsWith('---') || /^[a-zA-Z_][a-zA-Z0-9_]*\s*:\s*.+/m.test(trimmed)) {
-            return 'yaml';
-        }
-        // TOML detection (has [section] or key = value patterns)
-        if (/^\[.*\]$/m.test(trimmed) || /^[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*.+/m.test(trimmed)) {
-            return 'toml';
-        }
-        // CSV detection (has comma-separated values)
-        if (/^[^,\n]*,[^,\n]*/.test(trimmed)) {
-            return 'csv';
-        }
-        // Default to JSON if uncertain
-        return 'json';
-    }
-    /**
-     * Parse YAML content (basic implementation)
-     * For a full implementation, you'd want to use a proper YAML library
-     */
-    parseYAML(content) {
-        // This is a very basic YAML parser for simple key-value pairs
-        // For production use, consider integrating a proper YAML library like js-yaml
-        const lines = content.split('\n');
-        const result = {};
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            if (!trimmedLine || trimmedLine.startsWith('#') || trimmedLine === '---') {
-                continue;
-            }
-            const colonIndex = trimmedLine.indexOf(':');
-            if (colonIndex > 0) {
-                const key = trimmedLine.substring(0, colonIndex).trim();
-                let value = trimmedLine.substring(colonIndex + 1).trim();
-                // Remove quotes if present
-                if ((value.startsWith('"') && value.endsWith('"')) ||
-                    (value.startsWith("'") && value.endsWith("'"))) {
-                    value = value.slice(1, -1);
-                }
-                // Try to parse as number or boolean
-                if (value === 'true') {
-                    result[key] = true;
-                }
-                else if (value === 'false') {
-                    result[key] = false;
-                }
-                else if (/^\d+$/.test(value)) {
-                    result[key] = parseInt(value, 10);
-                }
-                else if (/^\d*\.\d+$/.test(value)) {
-                    result[key] = parseFloat(value);
-                }
-                else {
-                    result[key] = value;
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Parse TOML content (basic implementation)
-     * For a full implementation, you'd want to use a proper TOML library
-     */
-    parseTOML(content) {
-        // This is a very basic TOML parser for simple key-value pairs
-        // For production use, consider integrating a proper TOML library
-        const lines = content.split('\n');
-        const result = {};
-        let currentSection = '';
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            if (!trimmedLine || trimmedLine.startsWith('#')) {
-                continue;
-            }
-            // Section headers [section]
-            if (trimmedLine.startsWith('[') && trimmedLine.endsWith(']')) {
-                currentSection = trimmedLine.slice(1, -1);
-                if (!result[currentSection]) {
-                    result[currentSection] = {};
-                }
-                continue;
-            }
-            // Key-value pairs
-            const equalIndex = trimmedLine.indexOf('=');
-            if (equalIndex > 0) {
-                const key = trimmedLine.substring(0, equalIndex).trim();
-                let value = trimmedLine.substring(equalIndex + 1).trim();
-                // Remove quotes if present
-                if ((value.startsWith('"') && value.endsWith('"')) ||
-                    (value.startsWith("'") && value.endsWith("'"))) {
-                    value = value.slice(1, -1);
-                }
-                // Parse value
-                let parsedValue;
-                if (value === 'true') {
-                    parsedValue = true;
-                }
-                else if (value === 'false') {
-                    parsedValue = false;
-                }
-                else if (/^\d+$/.test(value)) {
-                    parsedValue = parseInt(value, 10);
-                }
-                else if (/^\d*\.\d+$/.test(value)) {
-                    parsedValue = parseFloat(value);
-                }
-                else {
-                    parsedValue = value;
-                }
-                if (currentSection) {
-                    result[currentSection][key] = parsedValue;
-                }
-                else {
-                    result[key] = parsedValue;
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Parse CSV content (basic implementation)
-     */
-    parseCSV(content) {
-        const lines = content.trim().split('\n');
-        if (lines.length === 0) {
-            return [];
-        }
-        // Parse header row
-        const headers = this.parseCSVLine(lines[0]);
-        const result = [];
-        // Parse data rows
-        for (let i = 1; i < lines.length; i++) {
-            const values = this.parseCSVLine(lines[i]);
-            const row = {};
-            for (let j = 0; j < headers.length; j++) {
-                const header = headers[j];
-                const value = j < values.length ? values[j] : '';
-                // Try to parse as number
-                if (/^\d+$/.test(value)) {
-                    row[header] = parseInt(value, 10);
-                }
-                else if (/^\d*\.\d+$/.test(value)) {
-                    row[header] = parseFloat(value);
-                }
-                else if (value === 'true') {
-                    row[header] = true;
-                }
-                else if (value === 'false') {
-                    row[header] = false;
-                }
-                else {
-                    row[header] = value;
-                }
-            }
-            result.push(row);
-        }
-        return result;
-    }
-    /**
-     * Parse a single CSV line, handling quoted values
-     */
-    parseCSVLine(line) {
-        const result = [];
-        let current = '';
-        let inQuotes = false;
-        for (let i = 0; i < line.length; i++) {
-            const char = line[i];
-            if (char === '"') {
-                if (inQuotes && line[i + 1] === '"') {
-                    // Escaped quote
-                    current += '"';
-                    i++; // Skip next quote
-                }
-                else {
-                    // Toggle quote state
-                    inQuotes = !inQuotes;
-                }
-            }
-            else if (char === ',' && !inQuotes) {
-                // Field separator
-                result.push(current.trim());
-                current = '';
-            }
-            else {
-                current += char;
-            }
-        }
-        // Add the last field
-        result.push(current.trim());
-        return result;
-    }
-    /**
-     * Get nested value from object using dot notation path
-     * Following golang's path resolution logic
-     */
-    getNestedValue(obj, path) {
-        if (!obj || !path) {
-            return undefined;
-        }
-        // Handle special case where path starts with a dot
-        const cleanPath = path.replace(/^\\.+/, '');
-        const parts = cleanPath.split('.');
-        let current = obj;
-        for (let i = 0; i < parts.length; i++) {
-            const part = parts[i];
-            if (current == null) {
-                return undefined;
-            }
-            // Handle array/object access
-            if (typeof current === 'object') {
-                // First try exact match (case-sensitive)
-                if (current.hasOwnProperty(part)) {
-                    current = current[part];
-                    continue;
-                }
-                // Then try case-insensitive property access (like Hugo)
-                const keys = Object.keys(current);
-                const matchingKey = keys.find(k => k.toLowerCase() === part.toLowerCase());
-                if (matchingKey) {
-                    current = current[matchingKey];
-                    continue;
-                }
-                // Special case: Try method call for common Hugo properties
-                // Kind -> kind(), Content -> content(), etc.
-                const methodName = part.toLowerCase();
-                if (typeof current[methodName] === 'function') {
-                    try {
-                        current = current[methodName]();
-                        continue;
-                    }
-                    catch (error) {
-                        return undefined;
-                    }
-                }
-                return undefined;
-            }
-            else {
-                return undefined;
-            }
-        }
-        return current;
-    }
-}
-exports.DefaultTemplateRegistry = DefaultTemplateRegistry;
-/**
- * Create default template registry
- */
-function newTemplateRegistry() {
-    return new DefaultTemplateRegistry();
-}
-/**
- * Convenience function to create and register core functions only
- */
-function createCoreFuncMap() {
-    const funcMap = new Map();
-    const registry = newTemplateRegistry();
-    registry.registerCoreFunctions(funcMap);
-    return funcMap;
-}
-/**
- * Convenience function to create and register all functions with services
- */
-function createStandardFuncMap(services) {
-    const funcMap = new Map();
-    const registry = newTemplateRegistry();
-    registry.registerAllFunctions(funcMap, services);
-    return funcMap;
-}
-/**
- * Update all engine-dependent functions with the template engine instance
- * This should be called after the template engine is created
- */
-function updateEngineDependentFunctions(engine) {
-    for (const func of engineDependentFunctions) {
-        try {
-            func.updateEngine(engine);
-        }
-        catch (error) {
-            log.error(`❌ Failed to update function ${func.getFunctionName()}:`, error);
-        }
-    }
-}
-//# sourceMappingURL=registry.js.map