mcp-image 0.1.0 → 0.2.0

package/dist/business/templateNormalizer.js

@@ -0,0 +1,659 @@
+"use strict";
+/**
+ * Template engine implementation with embedded best practice templates
+ * Provides static template loading and advanced processing capabilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateNormalizer = exports.BestPracticesTemplateNormalizer = void 0;
+exports.createTemplateNormalizer = createTemplateNormalizer;
+const mcp_1 = require("../types/mcp");
+/**
+ * Static template engine with embedded best practice templates
+ * Templates are code-based for performance (no file I/O)
+ * Enhanced with pattern indexing for O(1) template lookup
+ */
+class StaticTemplateEngine {
+    constructor() {
+        this.cachedTemplates = null;
+        this.templateIndex = new Map();
+        this.patternCache = new Map();
+    }
+    /**
+     * Build all 7 embedded templates for prompt normalization
+     * Each template targets specific prompt improvement patterns
+     * Templates are cached after first build for performance
+     * Creates pattern index for faster matching
+     */
+    buildStaticTemplates() {
+        if (this.cachedTemplates !== null) {
+            return this.cachedTemplates;
+        }
+        const templates = [
+            {
+                id: 'fantasy-armor-enhancement',
+                name: 'Fantasy Armor Enhancement',
+                category: mcp_1.BestPracticeCategory.STYLE_ENHANCEMENT,
+                pattern: /fantasy\s+armor|armor\s+fantasy|medieval\s+armor|knight.*armor/i,
+                enhancement: 'ornate elven plate armor with intricate engravings, polished metalwork, leather straps and buckles, weathered battle-worn details',
+                priority: 85,
+                metadata: {
+                    tags: ['fantasy', 'armor', 'medieval', 'hyper-specific'],
+                    author: 'StaticTemplateEngine',
+                    version: '1.0.0',
+                },
+            },
+            {
+                id: 'beautiful-landscape-enhancement',
+                name: 'Beautiful Landscape Enhancement',
+                category: mcp_1.BestPracticeCategory.COMPOSITION_GUIDE,
+                pattern: /beautiful\s+landscape|scenic\s+view|nature\s+scene|landscape\s+photography/i,
+                enhancement: 'sweeping vista with dramatic lighting, rule of thirds composition, foreground elements creating depth, golden hour lighting, rich color palette',
+                priority: 80,
+                metadata: {
+                    tags: ['landscape', 'nature', 'composition', 'hyper-specific'],
+                    author: 'StaticTemplateEngine',
+                    version: '1.0.0',
+                },
+            },
+            {
+                id: 'minimalist-logo-enhancement',
+                name: 'Minimalist Logo Enhancement',
+                category: mcp_1.BestPracticeCategory.TECHNICAL_DETAIL,
+                pattern: /minimalist\s+logo|simple\s+logo|clean\s+logo|logo\s+design/i,
+                enhancement: 'context: corporate branding, intent: memorable brand identity, clean geometric shapes, limited color palette, scalable vector design, negative space utilization',
+                priority: 75,
+                metadata: {
+                    tags: ['logo', 'minimalist', 'branding', 'context-and-intent'],
+                    author: 'StaticTemplateEngine',
+                    version: '1.0.0',
+                },
+            },
+            {
+                id: 'character-consistency-person',
+                name: 'Character Consistency Person',
+                category: mcp_1.BestPracticeCategory.TECHNICAL_DETAIL,
+                pattern: /person|character|individual|human.*figure|portrait/i,
+                enhancement: 'consistent facial features, same eye color and shape, identical hair texture and style, matching skin tone, consistent body proportions',
+                priority: 70,
+                metadata: {
+                    tags: ['character', 'consistency', 'person', 'portrait'],
+                    author: 'StaticTemplateEngine',
+                    version: '1.0.0',
+                },
+            },
+            {
+                id: 'no-cars-positive',
+                name: 'No Cars Positive Guidance',
+                category: mcp_1.BestPracticeCategory.COMPOSITION_GUIDE,
+                pattern: /no\s+cars|without\s+cars|car.*free|avoid.*cars/i,
+                enhancement: 'pedestrian-friendly environment, walking paths and bike lanes, public transportation, green spaces with trees and benches, outdoor café seating',
+                priority: 65,
+                metadata: {
+                    tags: ['semantic-negatives', 'urban', 'pedestrian', 'alternative'],
+                    author: 'StaticTemplateEngine',
+                    version: '1.0.0',
+                },
+            },
+            {
+                id: 'default-camera-enhancement',
+                name: 'Default Camera Enhancement',
+                category: mcp_1.BestPracticeCategory.TECHNICAL_DETAIL,
+                pattern: /photo|photograph|image|shot|camera/i,
+                enhancement: 'professional camera settings, optimal lighting conditions, sharp focus with appropriate depth of field, balanced exposure, high resolution detail',
+                priority: 60,
+                metadata: {
+                    tags: ['camera', 'photography', 'technical', 'default'],
+                    author: 'StaticTemplateEngine',
+                    version: '1.0.0',
+                },
+            },
+            {
+                id: 'artistic-style-enhancement',
+                name: 'Artistic Style Enhancement',
+                category: mcp_1.BestPracticeCategory.STYLE_ENHANCEMENT,
+                pattern: /artistic|art\s+style|creative|abstract.*art/i,
+                enhancement: 'distinctive artistic technique, expressive brushwork or digital artistry, cohesive color scheme, creative composition with visual impact',
+                priority: 55,
+                metadata: {
+                    tags: ['artistic', 'style', 'creative', 'expression'],
+                    author: 'StaticTemplateEngine',
+                    version: '1.0.0',
+                },
+            },
+            {
+                id: 'animal-character-enhancement',
+                name: 'Animal Character Enhancement',
+                category: mcp_1.BestPracticeCategory.STYLE_ENHANCEMENT,
+                pattern: /\b(cat|dog|bird|horse|lion|tiger|elephant|bear|fox|wolf|rabbit|deer)\b/i,
+                enhancement: 'sweeping vista background with natural habitat, detailed fur/feather texture, expressive eyes, dynamic pose, professional wildlife photography lighting',
+                priority: 65,
+                metadata: {
+                    tags: ['animal', 'wildlife', 'character', 'texture'],
+                    author: 'StaticTemplateEngine',
+                    version: '1.0.0',
+                },
+            },
+        ];
+        // Cache templates for performance on subsequent calls
+        this.cachedTemplates = templates;
+        // Build pattern index for O(1) template lookup
+        this.buildTemplateIndex(templates);
+        return templates;
+    }
+    /**
+     * Build indexed templates by extracting key terms from patterns
+     * Enables fast template lookup using word-based indexing
+     */
+    buildTemplateIndex(templates) {
+        this.templateIndex.clear();
+        for (const template of templates) {
+            // Extract key terms from regex pattern
+            const keyTerms = this.extractKeyTermsFromPattern(template.pattern);
+            for (const term of keyTerms) {
+                if (!this.templateIndex.has(term)) {
+                    this.templateIndex.set(term, []);
+                }
+                this.templateIndex.get(term).push(template);
+            }
+        }
+    }
+    /**
+     * Extract searchable key terms from regex pattern
+     * Converts regex patterns to searchable keywords for indexing
+     */
+    extractKeyTermsFromPattern(pattern) {
+        const source = pattern.source.toLowerCase();
+        const terms = [];
+        // Extract literal words from regex (simple extraction)
+        const wordMatches = source.match(/[a-z]+/g);
+        if (wordMatches) {
+            terms.push(...wordMatches.filter((word) => word.length > 2)); // Only words longer than 2 chars
+        }
+        // Add some common pattern variations
+        if (source.includes('fantasy'))
+            terms.push('fantasy', 'medieval', 'knight');
+        if (source.includes('landscape'))
+            terms.push('landscape', 'nature', 'scenic');
+        if (source.includes('logo'))
+            terms.push('logo', 'brand', 'design');
+        if (source.includes('person'))
+            terms.push('person', 'character', 'human', 'portrait');
+        if (source.includes('car'))
+            terms.push('car', 'vehicle', 'automotive');
+        if (source.includes('photo'))
+            terms.push('photo', 'photograph', 'camera', 'image');
+        if (source.includes('artistic'))
+            terms.push('artistic', 'art', 'creative');
+        if (source.includes('cat|dog|bird'))
+            terms.push('cat', 'dog', 'bird', 'animal', 'pet');
+        return [...new Set(terms)]; // Remove duplicates
+    }
+    /**
+     * Find candidate templates using index-based lookup for improved performance
+     * Uses word-based indexing to reduce the number of regex evaluations needed
+     */
+    findCandidateTemplates(prompt) {
+        if (!prompt || typeof prompt !== 'string') {
+            return [];
+        }
+        const promptLower = prompt.toLowerCase();
+        const candidateTemplates = new Set();
+        // Extract words from prompt for index lookup
+        const words = promptLower.match(/[a-z]+/g) || [];
+        // Find templates using index
+        for (const word of words) {
+            const templates = this.templateIndex.get(word);
+            if (templates) {
+                for (const template of templates) {
+                    candidateTemplates.add(template);
+                }
+            }
+        }
+        // If no candidates found via index, fall back to all templates
+        if (candidateTemplates.size === 0) {
+            return this.buildStaticTemplates();
+        }
+        return Array.from(candidateTemplates);
+    }
+    /**
+     * Check if a template pattern matches the given prompt
+     * Enhanced with caching for frequently tested patterns
+     */
+    matchPattern(prompt, template) {
+        if (!prompt || typeof prompt !== 'string') {
+            return false;
+        }
+        if (!template || !template.pattern || !(template.pattern instanceof RegExp)) {
+            return false;
+        }
+        // Create cache key for this prompt-template combination
+        const cacheKey = `${prompt.slice(0, 50)}:${template.id}`;
+        // Check pattern cache first
+        if (this.patternCache.has(cacheKey)) {
+            return this.patternCache.get(cacheKey);
+        }
+        try {
+            const result = template.pattern.test(prompt);
+            // Cache the result (limit cache size to prevent memory bloat)
+            if (this.patternCache.size < 1000) {
+                this.patternCache.set(cacheKey, result);
+            }
+            else {
+                // Clear cache when it gets too large
+                this.patternCache.clear();
+                this.patternCache.set(cacheKey, result);
+            }
+            return result;
+        }
+        catch (error) {
+            // Log error without exposing sensitive information
+            console.error('Template pattern matching failed:', {
+                templateId: template.id,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+            return false;
+        }
+    }
+    /**
+     * Apply template transformation to a prompt
+     * Enhanced with indexed template lookup for improved performance
+     * Includes comprehensive error handling and validation
+     */
+    applyTemplate(prompt) {
+        // Input validation
+        if (!prompt || typeof prompt !== 'string') {
+            return {
+                originalPrompt: prompt || '',
+                normalizedPrompt: prompt || '',
+                confidence: 0,
+                appliedRules: [],
+            };
+        }
+        try {
+            // Use optimized candidate template lookup instead of checking all templates
+            const candidateTemplates = this.findCandidateTemplates(prompt);
+            const matchingTemplates = candidateTemplates.filter((template) => this.matchPattern(prompt, template));
+            if (matchingTemplates.length === 0) {
+                return {
+                    originalPrompt: prompt,
+                    normalizedPrompt: prompt,
+                    confidence: 0,
+                    appliedRules: [],
+                };
+            }
+            // Use the highest priority template
+            const bestTemplate = matchingTemplates.reduce((best, current) => current.priority > best.priority ? current : best);
+            // Validate template has required properties
+            if (!bestTemplate.enhancement || !bestTemplate.id) {
+                return {
+                    originalPrompt: prompt,
+                    normalizedPrompt: prompt,
+                    confidence: 0,
+                    appliedRules: [],
+                };
+            }
+            const enhancedPrompt = `${prompt}, ${bestTemplate.enhancement}`;
+            return {
+                originalPrompt: prompt,
+                normalizedPrompt: enhancedPrompt,
+                confidence: 0.8, // Fixed confidence for now, will be improved in advanced processor
+                appliedRules: [bestTemplate.id],
+            };
+        }
+        catch (error) {
+            console.error('Template application failed:', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                prompt: prompt.substring(0, 50), // Only log first 50 chars for privacy
+            });
+            return {
+                originalPrompt: prompt,
+                normalizedPrompt: prompt,
+                confidence: 0,
+                appliedRules: [],
+            };
+        }
+    }
+}
+/**
+ * Advanced template processor with conflict resolution and confidence calculation
+ */
+class AdvancedTemplateProcessor {
+    /**
+     * Resolve conflicts between competing templates based on priority
+     * Returns the highest priority templates only
+     * Includes comprehensive error handling and validation
+     */
+    resolveConflicts(templates, prompt) {
+        // Input validation
+        if (!Array.isArray(templates)) {
+            console.error('Templates must be an array');
+            return [];
+        }
+        if (templates.length <= 1) {
+            return templates;
+        }
+        if (typeof prompt !== 'string') {
+            console.error('Prompt must be a string');
+            return templates;
+        }
+        try {
+            // Filter out invalid templates
+            const validTemplates = templates.filter((template) => template && typeof template.priority === 'number' && !Number.isNaN(template.priority));
+            if (validTemplates.length === 0) {
+                return [];
+            }
+            // Sort by priority (highest first) and return only the highest priority ones
+            const sortedTemplates = validTemplates.sort((a, b) => b.priority - a.priority);
+            const highestPriority = sortedTemplates[0]?.priority;
+            if (highestPriority === undefined) {
+                return [];
+            }
+            return sortedTemplates.filter((template) => template.priority === highestPriority);
+        }
+        catch (error) {
+            console.error('Conflict resolution failed:', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                templateCount: templates.length,
+            });
+            return templates;
+        }
+    }
+    /**
+     * Calculate overall confidence based on multiple template matches
+     * Uses weighted average based on individual match confidences
+     * Includes comprehensive error handling and validation
+     */
+    calculateOverallConfidence(templateMatches) {
+        // Input validation
+        if (!Array.isArray(templateMatches)) {
+            console.error('Template matches must be an array');
+            return 0;
+        }
+        if (templateMatches.length === 0) {
+            return 0;
+        }
+        try {
+            // Filter out invalid matches
+            const validMatches = templateMatches.filter((match) => match &&
+                typeof match.confidence === 'number' &&
+                !Number.isNaN(match.confidence) &&
+                match.confidence >= 0 &&
+                match.confidence <= 1);
+            if (validMatches.length === 0) {
+                return 0;
+            }
+            if (validMatches.length === 1) {
+                return validMatches[0]?.confidence ?? 0;
+            }
+            // Calculate weighted average confidence
+            const totalWeight = validMatches.reduce((sum, match) => sum + match.confidence, 0);
+            if (totalWeight === 0) {
+                return 0;
+            }
+            const weightedSum = validMatches.reduce((sum, match) => sum + match.confidence * match.confidence, 0);
+            return Math.min(weightedSum / totalWeight, 1.0);
+        }
+        catch (error) {
+            console.error('Confidence calculation failed:', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                matchCount: templateMatches.length,
+            });
+            return 0;
+        }
+    }
+}
+/**
+ * BestPracticesTemplateNormalizer - orchestrates all 7 best practice templates
+ * Provides comprehensive prompt normalization with multiple rule application
+ */
+class BestPracticesTemplateNormalizer {
+    constructor() {
+        this.engine = new StaticTemplateEngine();
+        this.processor = new AdvancedTemplateProcessor();
+    }
+    /**
+     * Normalize prompt by applying all matching best practice templates
+     * Applies templates sequentially based on priority and handles conflicts
+     */
+    normalize(prompt) {
+        if (!prompt || typeof prompt !== 'string') {
+            return {
+                originalPrompt: prompt || '',
+                normalizedPrompt: prompt || '',
+                confidence: 0,
+                appliedRules: [],
+            };
+        }
+        try {
+            // Step 1: Convert negative expressions to positive alternatives
+            const positivePrompt = this.convertNegativeToPositive(prompt);
+            // Step 2: Get candidate templates using optimized lookup
+            const candidateTemplates = this.engine.findCandidateTemplates(positivePrompt);
+            // Step 3: Find all matching templates using both original and positive prompts
+            const matchingTemplates = candidateTemplates.filter((template) => this.engine.matchPattern(prompt, template) ||
+                this.engine.matchPattern(positivePrompt, template));
+            if (matchingTemplates.length === 0) {
+                return {
+                    originalPrompt: prompt,
+                    normalizedPrompt: positivePrompt,
+                    confidence: 0.1, // Small confidence for negative conversion
+                    appliedRules: [],
+                };
+            }
+            // Step 4: Sort all matching templates by priority (no conflict resolution for comprehensive application)
+            const sortedTemplates = matchingTemplates.sort((a, b) => b.priority - a.priority);
+            // Step 5: Apply all matching templates sequentially
+            let normalizedPrompt = positivePrompt;
+            const appliedRules = [];
+            for (const template of sortedTemplates) {
+                if (template.enhancement && template.id) {
+                    normalizedPrompt = `${normalizedPrompt}, ${template.enhancement}`;
+                    appliedRules.push(template.id);
+                }
+            }
+            // Step 6: Automatically inject camera controls for photo-related prompts
+            const cameraEnhancedResult = this.injectCameraControls(normalizedPrompt, appliedRules);
+            // Step 7: Calculate overall confidence based on quality metrics
+            const templateMatches = sortedTemplates.map((template) => ({
+                template,
+                confidence: this.calculateTemplateConfidence(template, prompt),
+                matchedText: template.pattern.source,
+                position: { start: 0, end: normalizedPrompt.length },
+            }));
+            const confidence = Math.min(this.processor.calculateOverallConfidence(templateMatches), 1.0);
+            return {
+                originalPrompt: prompt,
+                normalizedPrompt: cameraEnhancedResult.prompt,
+                confidence: Math.max(confidence, 0.1),
+                appliedRules: cameraEnhancedResult.rules,
+            };
+        }
+        catch (error) {
+            console.error('BestPracticesTemplateNormalizer.normalize failed:', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                promptLength: prompt?.length || 0,
+                promptPreview: prompt?.substring(0, 50) || 'null/undefined',
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            // Return safe fallback result
+            return {
+                originalPrompt: prompt || '',
+                normalizedPrompt: prompt || '',
+                confidence: 0,
+                appliedRules: [],
+            };
+        }
+    }
+    /**
+     * Convert negative expressions to positive alternatives
+     * Transforms semantic negatives into constructive alternatives
+     */
+    convertNegativeToPositive(prompt) {
+        if (!prompt || typeof prompt !== 'string') {
+            return prompt;
+        }
+        let positivePrompt = prompt;
+        // Define negative to positive transformations
+        const transformations = [
+            { negative: /no\s+cars?/gi, positive: 'pedestrian-friendly environment' },
+            { negative: /avoid\s+people/gi, positive: 'peaceful solitary setting' },
+            { negative: /not\s+dark/gi, positive: 'well-lit bright atmosphere' },
+            { negative: /without\s+cars?/gi, positive: 'car-free zone with walking paths' },
+            { negative: /car.*free/gi, positive: 'pedestrian and cyclist friendly area' },
+            { negative: /avoid.*cars?/gi, positive: 'public transportation and walking infrastructure' },
+        ];
+        // Apply transformations
+        for (const { negative, positive } of transformations) {
+            if (negative.test(positivePrompt)) {
+                positivePrompt = positivePrompt.replace(negative, positive);
+            }
+        }
+        return positivePrompt;
+    }
+    /**
+     * Calculate confidence score for individual template matches
+     * Uses template priority and pattern specificity for scoring
+     */
+    calculateTemplateConfidence(template, prompt) {
+        try {
+            if (!template || !prompt) {
+                return 0;
+            }
+            // Base confidence from priority (0-100 normalized to 0-1)
+            const priorityScore = template.priority / 100;
+            // Pattern specificity bonus for more specific patterns
+            const patternLength = template.pattern.source.length;
+            const specificityBonus = Math.min(patternLength / 50, 0.2); // Max 0.2 bonus
+            // Calculate final confidence with bounds checking
+            const confidence = Math.min(priorityScore + specificityBonus, 1.0);
+            return Math.max(confidence, 0.1); // Minimum confidence for matched templates
+        }
+        catch (error) {
+            console.warn('Template confidence calculation failed:', {
+                templateId: template?.id || 'unknown',
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+            return 0.5; // Fallback confidence
+        }
+    }
+    /**
+     * Automatically inject camera controls for photo-related prompts
+     * Ensures professional camera settings are included when appropriate
+     */
+    injectCameraControls(prompt, currentRules) {
+        try {
+            // Check if prompt is photo-related and camera enhancement not already applied
+            const photoKeywords = /photo|photograph|image|shot|camera|portrait/i;
+            const hasCameraRule = currentRules.includes('default-camera-enhancement');
+            if (photoKeywords.test(prompt) && !hasCameraRule) {
+                const cameraEnhancement = 'professional camera settings, optimal lighting conditions, sharp focus with appropriate depth of field, balanced exposure, high resolution detail';
+                return {
+                    prompt: `${prompt}, ${cameraEnhancement}`,
+                    rules: [...currentRules, 'default-camera-enhancement'],
+                };
+            }
+            return { prompt, rules: currentRules };
+        }
+        catch (error) {
+            console.error('Camera control injection failed:', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                ruleCount: currentRules?.length || 0,
+            });
+            return { prompt, rules: currentRules };
+        }
+    }
+}
+exports.BestPracticesTemplateNormalizer = BestPracticesTemplateNormalizer;
+/**
+ * Unified TemplateNormalizer interface with Result pattern for safe error handling
+ * Provides comprehensive normalization with fallback capabilities
+ */
+class TemplateNormalizer {
+    constructor() {
+        this.bestPracticesNormalizer = new BestPracticesTemplateNormalizer();
+        this.staticEngine = new StaticTemplateEngine();
+        this.processor = new AdvancedTemplateProcessor();
+    }
+    /**
+     * Normalize prompt using best practices with automatic fallback
+     * Uses Result pattern for safe error handling
+     */
+    normalize(prompt) {
+        try {
+            // Primary normalization using best practices
+            const result = this.bestPracticesNormalizer.normalize(prompt);
+            // Validate result quality
+            if (result.confidence > 0 && result.normalizedPrompt) {
+                return result;
+            }
+            // Fallback to static template engine if best practices fail
+            console.warn('Best practices normalization failed, falling back to static templates', {
+                originalPrompt: prompt?.substring(0, 50),
+                confidence: result.confidence,
+            });
+            return this.staticEngine.applyTemplate(prompt);
+        }
+        catch (error) {
+            console.error('All normalization methods failed, returning original prompt', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                prompt: prompt?.substring(0, 50),
+            });
+            // Ultimate fallback - return original prompt
+            return {
+                originalPrompt: prompt || '',
+                normalizedPrompt: prompt || '',
+                confidence: 0,
+                appliedRules: [],
+            };
+        }
+    }
+    /**
+     * Get all available templates
+     */
+    getAvailableTemplates() {
+        return this.staticEngine.buildStaticTemplates();
+    }
+    /**
+     * Calculate confidence score for template matches
+     */
+    calculateConfidence(matches) {
+        return this.processor.calculateOverallConfidence(matches);
+    }
+    /**
+     * Convert negative expressions to positive alternatives
+     * Exposes the convertNegativeToPositive functionality
+     */
+    convertNegativeToPositive(prompt) {
+        return this.bestPracticesNormalizer.convertNegativeToPositive(prompt);
+    }
+}
+exports.TemplateNormalizer = TemplateNormalizer;
+/**
+ * Factory function to create a template normalizer with default configuration
+ * Provides a clean interface for prompt normalization using embedded templates
+ */
+function createTemplateNormalizer() {
+    const engine = new StaticTemplateEngine();
+    const processor = new AdvancedTemplateProcessor();
+    return {
+        /**
+         * Normalize a prompt by applying the best matching template
+         */
+        normalizePrompt(prompt) {
+            return engine.applyTemplate(prompt);
+        },
+        /**
+         * Get all available templates
+         */
+        getAvailableTemplates() {
+            return engine.buildStaticTemplates();
+        },
+        /**
+         * Calculate confidence score for template matches
+         */
+        calculateConfidence(matches) {
+            return processor.calculateOverallConfidence(matches);
+        },
+    };
+}
+//# sourceMappingURL=templateNormalizer.js.map