locai 2.1.0

package/dist/utils/quality/length-checker.js

@@ -0,0 +1,140 @@
+/**
+ * Length Validation Checker.
+ * Checks if translated text length is within acceptable bounds relative to source text.
+ */
+class LengthChecker {
+    defaultConfig;
+    constructor() {
+        this.defaultConfig = {
+            mode: "strict",
+            maxDeviation: 0.1,
+            minDeviation: -0.1,
+        };
+    }
+    /**
+     * Check if translated text length is acceptable.
+     */
+    checkLength(source, translated, options = {}) {
+        try {
+            const sourceLength = this.calculateLength(source);
+            const translatedLength = this.calculateLength(translated);
+            const ratio = sourceLength > 0 ? translatedLength / sourceLength : 1;
+            const config = this.getConfig(options);
+            const { minRatio, maxRatio } = this.calculateAllowedRange(config);
+            if (ratio < minRatio || ratio > maxRatio) {
+                return [
+                    {
+                        type: "length",
+                        severity: this.determineSeverity(ratio, minRatio, maxRatio),
+                        message: this.generateErrorMessage(ratio, config),
+                        details: {
+                            mode: config.mode,
+                            context: config.context,
+                            targetLang: config.targetLang,
+                            sourceLength,
+                            translatedLength,
+                            ratio: parseFloat(ratio.toFixed(3)),
+                            allowedRange: {
+                                min: parseFloat(minRatio.toFixed(2)),
+                                max: parseFloat(maxRatio.toFixed(2)),
+                            },
+                            deviation: parseFloat((ratio - 1).toFixed(3)),
+                        },
+                    },
+                ];
+            }
+            return [];
+        }
+        catch (error) {
+            console.error("Length check failed:", error);
+            return [
+                {
+                    type: "length",
+                    severity: "error",
+                    message: "Length validation failed due to technical error",
+                    details: { error: error.message },
+                },
+            ];
+        }
+    }
+    /**
+     * Calculate length of text ignoring whitespace.
+     */
+    calculateLength(text) {
+        if (!text)
+            return 0;
+        return text.replace(/\s+/g, "").length;
+    }
+    /**
+     * Get configuration for length check.
+     */
+    getConfig(options) {
+        const lengthControl = options.lengthControl || {};
+        const mode = lengthControl.mode || this.defaultConfig.mode;
+        const targetLang = options.targetLang || "en";
+        const context = options.detectedContext?.category || "general";
+        if (mode === "smart") {
+            return this.getSmartModeConfig(lengthControl, targetLang, context);
+        }
+        return this.getStandardModeConfig(lengthControl, mode, targetLang, context);
+    }
+    /**
+     * Get configuration for smart mode.
+     */
+    getSmartModeConfig(lengthControl, targetLang, context) {
+        const smartRules = lengthControl.rules?.smart || {};
+        const langRules = smartRules.byLanguage?.[targetLang] || {};
+        const contextRules = smartRules.byContext?.[context] || {};
+        const defaultValue = smartRules.default || 0.15;
+        return {
+            mode: "smart",
+            targetLang,
+            context,
+            maxDeviation: Math.min(langRules.max ?? defaultValue, contextRules.max ?? defaultValue),
+            minDeviation: Math.max(langRules.min ?? -defaultValue, contextRules.min ?? -defaultValue),
+        };
+    }
+    /**
+     * Get configuration for standard mode.
+     */
+    getStandardModeConfig(lengthControl, mode, targetLang, context) {
+        const deviation = lengthControl.rules?.[mode] || this.defaultConfig.maxDeviation;
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mode: mode,
+            targetLang,
+            context,
+            maxDeviation: deviation,
+            minDeviation: -deviation,
+        };
+    }
+    /**
+     * Calculate allowed length ratio range.
+     */
+    calculateAllowedRange(config) {
+        return {
+            minRatio: 1 + config.minDeviation,
+            maxRatio: 1 + config.maxDeviation,
+        };
+    }
+    /**
+     * Determine severity of length mismatch.
+     */
+    determineSeverity(ratio, minRatio, maxRatio) {
+        const deviation = Math.abs(ratio - 1);
+        if (deviation > Math.max(Math.abs(minRatio - 1), Math.abs(maxRatio - 1)) * 1.5) {
+            return "critical";
+        }
+        return "warning";
+    }
+    /**
+     * Generate error message for length mismatch.
+     */
+    generateErrorMessage(ratio, config) {
+        const percentage = Math.abs((ratio - 1) * 100).toFixed(1);
+        const direction = ratio > 1 ? "longer" : "shorter";
+        return (`Translation is ${percentage}% ${direction} than source text ` +
+            `[${(config.targetLang || "").toUpperCase()}, ${config.context}]`);
+    }
+}
+export default LengthChecker;

package/dist/utils/quality/markdown-checker.js

@@ -0,0 +1,220 @@
+/**
+ * Markdown Preservation Checker.
+ * Ensures markdown formatting is preserved during translation.
+ */
+class MarkdownChecker {
+    markdownPatterns;
+    constructor() {
+        this.markdownPatterns = {
+            // Headers
+            headers: /^#{1,6}\s+/gm,
+            // Bold
+            bold: /\*\*(.+?)\*\*/g,
+            // Italic
+            italic: /\*(.+?)\*|_(.+?)_/g,
+            // Links
+            links: /\[([^\]]+)\]\(([^)]+)\)/g,
+            // Images
+            images: /!\[([^\]]*)\]\(([^)]+)\)/g,
+            // Code inline
+            inlineCode: /`([^`]+)`/g,
+            // Lists
+            unorderedLists: /^[*+-]\s+/gm,
+            orderedLists: /^\d+\.\s+/gm,
+            // Blockquotes
+            blockquotes: /^>\s+/gm,
+            // Horizontal rules
+            horizontalRules: /^(---|\*\*\*|___)$/gm,
+        };
+    }
+    /**
+     * Check if markdown is preserved between source and translation.
+     */
+    checkMarkdownPreservation(sourceText, translatedText) {
+        const issues = [];
+        // Check each markdown pattern
+        for (const [patternName, pattern] of Object.entries(this.markdownPatterns)) {
+            const sourceMatches = (sourceText.match(pattern) || []).length;
+            const translatedMatches = (translatedText.match(pattern) || []).length;
+            if (sourceMatches !== translatedMatches) {
+                issues.push({
+                    type: "markdown-preservation",
+                    severity: "error",
+                    pattern: patternName,
+                    message: `Markdown ${patternName} count mismatch: source has ${sourceMatches}, translation has ${translatedMatches}`,
+                    details: {
+                        sourceCount: sourceMatches,
+                        translatedCount: translatedMatches,
+                    },
+                });
+            }
+        }
+        // Check for broken markdown links
+        const brokenLinks = this.checkBrokenMarkdownLinks(translatedText);
+        issues.push(...brokenLinks);
+        return issues;
+    }
+    /**
+     * Check for broken markdown links.
+     */
+    checkBrokenMarkdownLinks(text) {
+        const issues = [];
+        const linkPattern = /\[([^\]]+)\]\(([^)]+)\)/g;
+        const matches = text.matchAll(linkPattern);
+        for (const match of matches) {
+            const [fullMatch, linkText, url] = match;
+            // Check for common issues
+            if (!linkText.trim()) {
+                issues.push({
+                    type: "markdown-link",
+                    severity: "warning",
+                    message: `Empty link text in: "${fullMatch}"`,
+                });
+            }
+            if (!url.trim()) {
+                issues.push({
+                    type: "markdown-link",
+                    severity: "error",
+                    message: `Empty URL in: "${fullMatch}"`,
+                });
+            }
+            // Check for spaces in URL (common translation error)
+            if (url.includes(" ")) {
+                issues.push({
+                    type: "markdown-link",
+                    severity: "warning",
+                    message: `URL contains spaces: "${url}"`,
+                });
+            }
+        }
+        return issues;
+    }
+    /**
+     * Fix markdown preservation issues.
+     */
+    fixMarkdownPreservation(sourceText, translatedText) {
+        let fixedText = translatedText;
+        const foundIssues = [];
+        const appliedFixes = [];
+        // Extract markdown elements from source
+        const sourceMarkdown = this.extractMarkdownElements(sourceText);
+        // Try to restore missing markdown
+        for (const [type, elements] of Object.entries(sourceMarkdown)) {
+            if (elements.length > 0) {
+                const result = this.restoreMarkdownElements(fixedText, elements, type);
+                fixedText = result.text;
+                foundIssues.push(...result.foundIssues);
+                // fixes are not really applied in restoreMarkdownElements for now
+            }
+        }
+        // Fix broken links
+        const linkResult = this.fixBrokenLinks(fixedText);
+        fixedText = linkResult.text;
+        foundIssues.push(...linkResult.foundIssues);
+        appliedFixes.push(...linkResult.appliedFixes);
+        return { text: fixedText, foundIssues, appliedFixes };
+    }
+    /**
+     * Extract markdown elements from text.
+     */
+    extractMarkdownElements(text) {
+        const elements = {
+            headers: [],
+            bold: [],
+            italic: [],
+            links: [],
+            images: [],
+            inlineCode: [],
+            lists: [],
+        };
+        // Extract headers
+        const headerMatches = text.matchAll(this.markdownPatterns.headers);
+        for (const match of headerMatches) {
+            elements.headers.push(match[0]);
+        }
+        // Extract bold text
+        const boldMatches = text.matchAll(this.markdownPatterns.bold);
+        for (const match of boldMatches) {
+            elements.bold.push(match[0]);
+        }
+        // Extract links
+        const linkMatches = text.matchAll(this.markdownPatterns.links);
+        for (const match of linkMatches) {
+            elements.links.push({
+                full: match[0],
+                text: match[1],
+                url: match[2],
+            });
+        }
+        // Extract inline code
+        const codeMatches = text.matchAll(this.markdownPatterns.inlineCode);
+        for (const match of codeMatches) {
+            elements.inlineCode.push(match[0]);
+        }
+        return elements;
+    }
+    /**
+     * Restore markdown elements that were lost in translation.
+     */
+    restoreMarkdownElements(text, elements, type) {
+        const foundIssues = [];
+        const appliedFixes = [];
+        const fixedText = text;
+        // For now, we'll just report issues
+        // Full restoration would require more context about where to place elements
+        if (elements.length > 0) {
+            const currentCount = (fixedText.match(this.markdownPatterns[type]) || []).length;
+            if (currentCount < elements.length) {
+                foundIssues.push({
+                    type: "markdown-missing",
+                    severity: "warning", // Added severity
+                    message: `Missing ${elements.length - currentCount} ${type} elements`,
+                });
+                // Note: Full restoration is complex and context-dependent
+            }
+        }
+        return { text: fixedText, foundIssues, appliedFixes };
+    }
+    /**
+     * Fix broken markdown links.
+     */
+    fixBrokenLinks(text) {
+        const foundIssues = [];
+        const appliedFixes = [];
+        let fixedText = text;
+        // Fix spaces in URLs
+        const linkPattern = /\[([^\]]+)\]\(([^)]+)\)/g;
+        fixedText = fixedText.replace(linkPattern, (match, linkText, url) => {
+            let fixedUrl = url;
+            let modified = false;
+            // Remove spaces from URL
+            if (url.includes(" ")) {
+                fixedUrl = url.replace(/\s+/g, "-");
+                modified = true;
+                foundIssues.push({
+                    type: "markdown-link",
+                    severity: "warning", // Added severity
+                    message: `URL had spaces: "${url}"`,
+                });
+                appliedFixes.push({
+                    type: "markdown-link",
+                    message: `Fixed URL spaces: "${url}" → "${fixedUrl}"`,
+                });
+            }
+            return modified ? `[${linkText}](${fixedUrl})` : match;
+        });
+        return { text: fixedText, foundIssues, appliedFixes };
+    }
+    /**
+     * Check if text contains markdown.
+     */
+    hasMarkdown(text) {
+        for (const pattern of Object.values(this.markdownPatterns)) {
+            if (pattern.test(text)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+export default MarkdownChecker;

package/dist/utils/quality/placeholder-checker.js

@@ -0,0 +1,142 @@
+/**
+ * Placeholder Consistency Checker.
+ * Ensures placeholders like {name}, ${value}, %s are preserved correctly.
+ */
+class PlaceholderChecker {
+    /**
+     * Check for placeholder mismatches or corruptions.
+     */
+    checkPlaceholders(source, translated) {
+        const placeholderRegex = /\{[^}]+\}|\$\{[^}]+\}|%[sd]/g;
+        const sourcePlaceholders = source.match(placeholderRegex) || [];
+        const translatedPlaceholders = translated.match(placeholderRegex) || [];
+        const issues = [];
+        // Check for missing or extra placeholders
+        if (sourcePlaceholders.length !== translatedPlaceholders.length) {
+            issues.push({
+                type: "placeholder",
+                message: "Placeholder count mismatch",
+                source: sourcePlaceholders,
+                translated: translatedPlaceholders,
+            });
+        }
+        // Check for corrupted placeholders (placeholders that were translated/modified)
+        for (const sourcePlaceholder of sourcePlaceholders) {
+            if (!translated.includes(sourcePlaceholder)) {
+                // Look for potential corrupted versions
+                const corruptedPattern = this.findCorruptedPlaceholder(translated, sourcePlaceholder);
+                if (corruptedPattern) {
+                    issues.push({
+                        type: "placeholder",
+                        message: `Corrupted placeholder detected: expected '${sourcePlaceholder}' but found '${corruptedPattern}'`,
+                        source: sourcePlaceholder,
+                        corrupted: corruptedPattern,
+                    });
+                }
+                else {
+                    issues.push({
+                        type: "placeholder",
+                        message: `Missing placeholder: ${sourcePlaceholder}`,
+                        source: sourcePlaceholder,
+                    });
+                }
+            }
+        }
+        return issues;
+    }
+    /**
+     * Fix corrupted or missing placeholders in translated text.
+     */
+    fixPlaceholders(source, translated) {
+        const placeholderRegex = /\{[^}]+\}|\$\{[^}]+\}|%[sd]/g;
+        const sourcePlaceholders = source.match(placeholderRegex) || [];
+        let fixedText = translated;
+        const foundIssues = [];
+        const appliedFixes = [];
+        // First, fix corrupted placeholders
+        for (const sourcePlaceholder of sourcePlaceholders) {
+            if (!fixedText.includes(sourcePlaceholder)) {
+                // Try to find and fix corrupted versions
+                const corruptedPattern = this.findCorruptedPlaceholder(fixedText, sourcePlaceholder);
+                if (corruptedPattern) {
+                    foundIssues.push({
+                        type: "placeholder",
+                        message: `Corrupted placeholder: ${corruptedPattern} → ${sourcePlaceholder}`,
+                    });
+                    // Replace the corrupted version with the correct one
+                    fixedText = fixedText.replace(corruptedPattern, sourcePlaceholder);
+                    appliedFixes.push({
+                        type: "placeholder",
+                        message: `Fixed corrupted placeholder: ${corruptedPattern} → ${sourcePlaceholder}`,
+                    });
+                }
+                else {
+                    // Placeholder is completely missing, try to add it
+                    foundIssues.push({
+                        type: "placeholder",
+                        message: `Missing placeholder: ${sourcePlaceholder}`,
+                    });
+                    const possiblePosition = this.findBestPlaceholderPosition(fixedText, source, sourcePlaceholder);
+                    if (possiblePosition !== -1) {
+                        fixedText = this.insertPlaceholder(fixedText, sourcePlaceholder, possiblePosition);
+                        appliedFixes.push({
+                            type: "placeholder",
+                            message: `Added missing placeholder: ${sourcePlaceholder}`,
+                        });
+                    }
+                }
+            }
+        }
+        return { text: fixedText, foundIssues, appliedFixes };
+    }
+    /**
+     * Find a corrupted version of a placeholder in translated text.
+     */
+    findCorruptedPlaceholder(translated, sourcePlaceholder) {
+        // Extract the placeholder name (e.g., "message" from "{message}")
+        const placeholderName = sourcePlaceholder.slice(1, -1); // Remove { and }
+        // Look for common corruption patterns
+        const corruptionPatterns = [
+            // Pattern: {mesaj}{message} or {mensaje}{message} (translated + original)
+            new RegExp(`\\{[^}]*\\}\\{${placeholderName}\\}`, "g"),
+            // Pattern: {mesaj} or {mensaje} (just translated)
+            new RegExp(`\\{[^}]*${placeholderName.slice(0, -2)}[^}]*\\}`, "g"),
+            // Pattern: Bạn{message} or text{message} (text prefixed to placeholder)
+            new RegExp(`[^\\s]{2,}\\{${placeholderName}\\}`, "g"),
+            // Pattern: {message}được or {message}text (text suffixed to placeholder)
+            new RegExp(`\\{${placeholderName}\\}[^\\s]{2,}`, "g"),
+            // Pattern: Any placeholder with similar length but different content
+            new RegExp(`\\{[^}]{${Math.max(1, placeholderName.length - 2)},${placeholderName.length + 3}}\\}`, "g"),
+        ];
+        for (const pattern of corruptionPatterns) {
+            const matches = translated.match(pattern);
+            if (matches && matches.length > 0) {
+                // Return the first match that's not the original placeholder
+                for (const match of matches) {
+                    if (match !== sourcePlaceholder) {
+                        return match;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Find best position to insert a missing placeholder.
+     */
+    findBestPlaceholderPosition(translated, source, placeholder) {
+        const sourcePosition = source.indexOf(placeholder);
+        const sourceWords = source.slice(0, sourcePosition).split(" ").length;
+        const translatedWords = translated.split(" ");
+        return sourceWords >= translatedWords.length
+            ? translated.length
+            : translatedWords.slice(0, sourceWords).join(" ").length;
+    }
+    /**
+     * Insert placeholder into text at specified position.
+     */
+    insertPlaceholder(text, placeholder, position) {
+        return text.slice(0, position) + placeholder + text.slice(position);
+    }
+}
+export default PlaceholderChecker;

package/dist/utils/quality/punctuation-checker.js

@@ -0,0 +1,50 @@
+/**
+ * Punctuation Consistency Checker.
+ * Ensures end punctuation marks are preserved in translation.
+ */
+class PunctuationChecker {
+    /**
+     * Check for punctuation mismatches.
+     */
+    checkPunctuation(source, translated) {
+        const issues = [];
+        const endPunctuation = /[.!?]$/;
+        if (source.match(endPunctuation) && !translated.match(endPunctuation)) {
+            issues.push({
+                type: "punctuation",
+                message: "Missing punctuation mark",
+            });
+        }
+        return issues;
+    }
+    /**
+     * Fix missing punctuation marks.
+     */
+    fixPunctuation(source, translated) {
+        const endPunctuation = /[.!?]$/;
+        let fixedText = translated;
+        const foundIssues = [];
+        const appliedFixes = [];
+        const sourceEndsWithPunctuation = source.match(endPunctuation);
+        const translatedEndsWithPunctuation = translated.match(endPunctuation);
+        if (sourceEndsWithPunctuation && !translatedEndsWithPunctuation) {
+            foundIssues.push({
+                type: "punctuation",
+                message: "Missing punctuation mark",
+            });
+            fixedText = this.addPunctuation(fixedText, sourceEndsWithPunctuation[0]);
+            appliedFixes.push({
+                type: "punctuation",
+                message: `Added punctuation mark: ${sourceEndsWithPunctuation[0]}`,
+            });
+        }
+        return { text: fixedText, foundIssues, appliedFixes };
+    }
+    /**
+     * Add punctuation to the end of text.
+     */
+    addPunctuation(text, punctuation) {
+        return text.trim() + punctuation;
+    }
+}
+export default PunctuationChecker;

package/dist/utils/quality/quote-balance-checker.js

@@ -0,0 +1,143 @@
+/**
+ * Quote Balance Checker.
+ * Ensures quotes (single, double, guillemets, etc.) are balanced in translation.
+ */
+class QuoteBalanceChecker {
+    /**
+     * Check for unbalanced quotes.
+     */
+    checkQuoteBalance(text) {
+        const issues = [];
+        // Check single quotes
+        const singleQuotes = this._countQuotes(text, "'");
+        if (singleQuotes.unbalanced) {
+            issues.push({
+                type: "unbalanced-quotes",
+                severity: "error",
+                message: `Unbalanced single quotes: ${singleQuotes.count} found`,
+                char: "'",
+            });
+        }
+        // Check double quotes
+        const doubleQuotes = this._countQuotes(text, '"');
+        if (doubleQuotes.unbalanced) {
+            issues.push({
+                type: "unbalanced-quotes",
+                severity: "error",
+                message: `Unbalanced double quotes: ${doubleQuotes.count} found`,
+                char: '"',
+            });
+        }
+        // Check guillemets (French quotes)
+        const guillemetsOpen = (text.match(/«/g) || []).length;
+        const guillemetsClose = (text.match(/»/g) || []).length;
+        if (guillemetsOpen !== guillemetsClose) {
+            issues.push({
+                type: "unbalanced-quotes",
+                severity: "error",
+                message: `Unbalanced guillemets: ${guillemetsOpen} « vs ${guillemetsClose} »`,
+                char: "«»",
+            });
+        }
+        // Check German quotes
+        const germanQuotesOpen = (text.match(/„/g) || []).length;
+        const germanQuotesClose = (text.match(/"/g) || []).length;
+        if (germanQuotesOpen !== germanQuotesClose) {
+            issues.push({
+                type: "unbalanced-quotes",
+                severity: "warning",
+                message: `Unbalanced German quotes: ${germanQuotesOpen} „ vs ${germanQuotesClose} "`,
+                char: '„"', // Escaped quote
+            });
+        }
+        return issues;
+    }
+    /**
+     * Count occurrences of a quote character.
+     */
+    _countQuotes(text, quoteChar) {
+        const count = (text.match(new RegExp(`\\${quoteChar}`, "g")) || []).length;
+        return {
+            count,
+            unbalanced: count % 2 !== 0,
+        };
+    }
+    /**
+     * Fix unbalanced quotes.
+     */
+    fixQuoteBalance(text) {
+        let fixedText = text;
+        const foundIssues = [];
+        const appliedFixes = [];
+        // Fix single quotes
+        const singleQuoteCheck = this._countQuotes(fixedText, "'");
+        if (singleQuoteCheck.unbalanced) {
+            foundIssues.push({
+                type: "unbalanced-quotes",
+                severity: "error", // Added severity
+                message: `Found ${singleQuoteCheck.count} single quotes (odd number)`,
+            });
+            // Try to fix by adding missing closing quote at the end
+            if (fixedText.includes("'")) {
+                fixedText = fixedText + "'";
+                appliedFixes.push({
+                    type: "quote-balance",
+                    message: "Added missing closing single quote at the end",
+                });
+            }
+        }
+        // Fix double quotes
+        const doubleQuoteCheck = this._countQuotes(fixedText, '"');
+        if (doubleQuoteCheck.unbalanced) {
+            foundIssues.push({
+                type: "unbalanced-quotes",
+                severity: "error", // Added severity
+                message: `Found ${doubleQuoteCheck.count} double quotes (odd number)`,
+            });
+            // Try to fix by adding missing closing quote at the end
+            if (fixedText.includes('"')) {
+                fixedText = fixedText + '"';
+                appliedFixes.push({
+                    type: "quote-balance",
+                    message: "Added missing closing double quote at the end",
+                });
+            }
+        }
+        // Fix guillemets
+        const guillemetsOpen = (fixedText.match(/«/g) || []).length;
+        const guillemetsClose = (fixedText.match(/»/g) || []).length;
+        if (guillemetsOpen > guillemetsClose) {
+            fixedText = fixedText + "»";
+            foundIssues.push({
+                type: "unbalanced-quotes",
+                severity: "error", // Added severity
+                message: "Found unbalanced guillemets",
+            });
+            appliedFixes.push({
+                type: "quote-balance",
+                message: "Added missing closing guillemet",
+            });
+        }
+        return { text: fixedText, foundIssues, appliedFixes };
+    }
+    /**
+     * Validate that quotes in source and translation match in pattern.
+     */
+    validateQuoteConsistency(source, translated) {
+        const issues = [];
+        // Check if source has quotes but translation doesn't (or vice versa)
+        const sourceHasSingleQuotes = source.includes("'");
+        const translatedHasSingleQuotes = translated.includes("'");
+        const translatedHasDoubleQuotes = translated.includes('"');
+        // If source has quotes, translation should maintain similar quoting
+        if (sourceHasSingleQuotes && !translatedHasSingleQuotes && !translatedHasDoubleQuotes) {
+            issues.push({
+                type: "quote-consistency",
+                severity: "warning",
+                message: "Source has quotes but translation doesn't",
+            });
+        }
+        return issues;
+    }
+}
+export default QuoteBalanceChecker;