i18ntk 3.3.0 → 4.1.0

package/runtime/index.js

@@ -11,13 +11,32 @@ const { envManager } = require('../utils/env-manager');
 let configManager = null;
 try { configManager = require('../utils/config-manager'); } catch (_) { /* optional */ }
 
-const state = {
+function createState(options = {}) {
+  return {
+    baseDir: resolveBaseDir(options.baseDir),
+    language: options.language || 'en',
+    fallbackLanguage: options.fallbackLanguage || 'en',
+    keySeparator: options.keySeparator || '.',
+    cache: new Map(),
+    lazy: options.lazy === true,
+    keyManifest: new Map(),
+    loadedFiles: new Set(),
+    eagerLoadedLanguages: new Set(),
+  };
+}
+
+const singletonState = {
   baseDir: null,                // absolute path to locales dir (e.g., ./locales)
   language: 'en',
   fallbackLanguage: 'en',
-  keySeparator: '.',
-  cache: new Map(),             // lang -> merged translations object
-};
+  keySeparator: '.',
+  cache: new Map(),             // lang -> merged translations object
+  lazy: false,
+  keyManifest: new Map(),       // lang -> Map: keyName -> filePath
+  loadedFiles: new Set(),       // tracks loaded files in lazy mode
+  eagerLoadedLanguages: new Set(),
+};
+let singletonInitialized = false;
 
 // --- Utilities ---
 function stripBOMAndComments(s) {
@@ -98,12 +117,12 @@ function resolveBaseDir(explicitBaseDir) {
   }
 }
 
-function listJsonFilesRecursively(dir) {
+function listJsonFilesRecursively(dir, baseDir = dir) {
   const results = [];
   const stack = [dir];
   while (stack.length) {
     const d = stack.pop();
-    if (!SecurityUtils.safeExistsSync(d)) continue;
+    if (!SecurityUtils.safeExistsSync(d, baseDir)) continue;
     try {
       for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
         const full = path.join(d, entry.name);
@@ -120,6 +139,87 @@ function listJsonFilesRecursively(dir) {
   return results;
 }
 
+function loadKeyManifestFromDir(baseDir) {
+  if (!baseDir || typeof baseDir !== 'string') return new Map();
+  const validatedBase = SecurityUtils.validatePath(baseDir, path.dirname(baseDir));
+  const baseStat = SecurityUtils.safeStatSync(validatedBase, path.dirname(validatedBase));
+  const baseRoot = baseStat && baseStat.isFile() ? path.dirname(validatedBase) : validatedBase;
+  const files = baseStat && baseStat.isFile() ? [validatedBase] : listJsonFilesRecursively(validatedBase, validatedBase);
+  const manifest = new Map();
+  const MAX_SIZE = 100 * 1024;
+  let currentSize = 0;
+
+  for (const file of files) {
+    let validated;
+    try { validated = SecurityUtils.validatePath(file, baseRoot); } catch (_) { continue; }
+    const rel = path.relative(baseRoot, validated);
+    if (rel.startsWith('..') || path.isAbsolute(rel)) continue;
+
+    try {
+      const data = readJsonSafe(validated);
+      if (!data || typeof data !== 'object') continue;
+
+      for (const key of Object.keys(data)) {
+        if (manifest.has(key)) continue;
+
+        const entrySize = JSON.stringify(key).length + JSON.stringify(validated).length + 5;
+        if (currentSize + entrySize > MAX_SIZE) break;
+
+        manifest.set(key, validated);
+        currentSize += entrySize;
+      }
+    } catch (_) { continue; }
+
+    if (currentSize >= MAX_SIZE) break;
+  }
+
+  return manifest;
+}
+
+function getLanguagePath(baseDir, lang) {
+  const langDir = path.join(baseDir, lang);
+  const langFile = path.join(baseDir, `${lang}.json`);
+  const langDirStat = SecurityUtils.safeStatSync(langDir, path.dirname(langDir));
+  if (langDirStat && langDirStat.isDirectory()) return langDir;
+  const langFileStat = SecurityUtils.safeStatSync(langFile, path.dirname(langFile));
+  if (langFileStat && langFileStat.isFile()) return langFile;
+  return null;
+}
+
+function getManifestForLanguage(runtimeState, lang) {
+  if (!runtimeState.keyManifest) runtimeState.keyManifest = new Map();
+  if (runtimeState.keyManifest.has(lang)) return runtimeState.keyManifest.get(lang);
+
+  const languagePath = getLanguagePath(runtimeState.baseDir, lang);
+  const manifest = languagePath ? loadKeyManifestFromDir(languagePath) : new Map();
+  runtimeState.keyManifest.set(lang, manifest);
+  return manifest;
+}
+
+function loadFileLazy(runtimeState, filePath, lang) {
+  const baseDir = runtimeState.baseDir;
+  if (!baseDir) throw new Error('baseDir not initialized');
+
+  let validatedPath;
+  try { validatedPath = SecurityUtils.validatePath(filePath, baseDir); } catch (e) {
+    throw new Error(`Invalid file path for lazy load: ${e.message}`);
+  }
+
+  const rel = path.relative(baseDir, validatedPath);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) {
+    throw new Error(`File outside base directory: ${filePath}`);
+  }
+
+  const data = readJsonSafe(validatedPath);
+  if (data && typeof data === 'object') {
+    let cacheEntry = runtimeState.cache.get(lang);
+    if (!cacheEntry) cacheEntry = {};
+    deepMerge(cacheEntry, data);
+    runtimeState.cache.set(lang, cacheEntry);
+  }
+  return data;
+}
+
 function readLanguageFromBase(baseDir, lang) {
   const merged = {};
   const langFile = path.join(baseDir, `${lang}.json`);
@@ -128,7 +228,7 @@ function readLanguageFromBase(baseDir, lang) {
   // Prefer folder if exists, otherwise single file
   const langDirStat = SecurityUtils.safeStatSync(langDir, path.dirname(langDir));
   if (langDirStat && langDirStat.isDirectory()) {
-    const files = listJsonFilesRecursively(langDir);
+    const files = listJsonFilesRecursively(langDir, langDir);
     for (const file of files) {
       try {
         const data = readJsonSafe(file);
@@ -150,10 +250,19 @@ function readLanguageFromBase(baseDir, lang) {
   return merged;
 }
 
-function getTranslations(lang) {
-  if (state.cache.has(lang)) return state.cache.get(lang);
-  const data = readLanguageFromBase(state.baseDir, lang);
-  state.cache.set(lang, data);
+function getTranslationsForState(runtimeState, lang) {
+  if (!runtimeState.baseDir) runtimeState.baseDir = resolveBaseDir();
+
+  if (runtimeState.lazy) {
+    if (runtimeState.cache.has(lang)) return runtimeState.cache.get(lang);
+    runtimeState.cache.set(lang, {});
+    getManifestForLanguage(runtimeState, lang);
+    return runtimeState.cache.get(lang);
+  }
+
+  if (runtimeState.cache.has(lang)) return runtimeState.cache.get(lang);
+  const data = readLanguageFromBase(runtimeState.baseDir, lang);
+  runtimeState.cache.set(lang, data);
   return data;
 }
 
@@ -165,15 +274,42 @@ function interpolate(template, params) {
 }
 
 // Resolve a dotted key path from an object
-function resolveKey(obj, key, sep = '.') {
-  if (!obj || typeof obj !== 'object') return undefined;
-  if (!key || typeof key !== 'string') return undefined;
+function resolveKey(obj, key, sep = '.', runtimeState = null, lang = null) {
+  if (!obj || typeof obj !== 'object') return undefined;
+  if (!key || typeof key !== 'string') return undefined;
   const parts = key.split(sep);
   let cur = obj;
   for (const p of parts) {
     if (cur && Object.prototype.hasOwnProperty.call(cur, p)) {
       cur = cur[p];
     } else {
+      if (runtimeState && lang && runtimeState.lazy) {
+        const manifest = getManifestForLanguage(runtimeState, lang);
+        for (let i = parts.length; i > 0; i--) {
+          const prefix = parts.slice(0, i).join(sep);
+          const filePath = manifest.get(prefix);
+          const loadedFileKey = `${lang}\0${filePath}`;
+          if (filePath && !runtimeState.loadedFiles.has(loadedFileKey)) {
+            runtimeState.loadedFiles.add(loadedFileKey);
+            try {
+              loadFileLazy(runtimeState, filePath, lang);
+            } catch (_) {
+              // stale manifest entry — already marked as loaded to prevent retry
+            }
+            const langData = runtimeState.cache.get(lang);
+            return resolveKey(langData, key, sep, runtimeState, lang);
+          }
+        }
+        if (!runtimeState.eagerLoadedLanguages.has(lang)) {
+          const fullData = readLanguageFromBase(runtimeState.baseDir, lang);
+          const langData = runtimeState.cache.get(lang) || {};
+          deepMerge(langData, fullData);
+          runtimeState.cache.set(lang, langData);
+          runtimeState.eagerLoadedLanguages.add(lang);
+          return resolveKey(langData, key, sep, runtimeState, lang);
+        }
+        return undefined;
+      }
       return undefined;
     }
   }
@@ -182,62 +318,110 @@ function resolveKey(obj, key, sep = '.') {
 
 // --- Public API ---
 function initRuntime(options = {}) {
-  state.baseDir = resolveBaseDir(options.baseDir);
-  state.language = options.language || state.language || 'en';
-  state.fallbackLanguage = options.fallbackLanguage || state.fallbackLanguage || 'en';
-  state.keySeparator = options.keySeparator || state.keySeparator || '.';
-  // Optional prewarm caches
-  state.cache.clear();
-  if (options.preload === true) {
-    getTranslations(state.language);
-    if (state.fallbackLanguage && state.fallbackLanguage !== state.language) {
-      getTranslations(state.fallbackLanguage);
+  const runtimeState = createState(options);
+  preload(runtimeState, options.preload);
+
+  if (!singletonInitialized) {
+    singletonState.baseDir = runtimeState.baseDir;
+    singletonState.language = runtimeState.language;
+    singletonState.fallbackLanguage = runtimeState.fallbackLanguage;
+    singletonState.keySeparator = runtimeState.keySeparator;
+    singletonState.lazy = runtimeState.lazy;
+    singletonState.keyManifest = new Map();
+    singletonState.loadedFiles = new Set();
+    singletonState.eagerLoadedLanguages = new Set();
+    singletonState.cache.clear();
+    preload(singletonState, options.preload);
+    singletonInitialized = true;
+  }
+
+  return createRuntime(runtimeState);
+}
+
+function preload(runtimeState, shouldPreload) {
+  if (shouldPreload === true) {
+    if (runtimeState.lazy) {
+      getManifestForLanguage(runtimeState, runtimeState.language);
+      if (!runtimeState.cache.has(runtimeState.language)) {
+        runtimeState.cache.set(runtimeState.language, {});
+      }
+      if (runtimeState.fallbackLanguage && runtimeState.fallbackLanguage !== runtimeState.language) {
+        getManifestForLanguage(runtimeState, runtimeState.fallbackLanguage);
+        if (!runtimeState.cache.has(runtimeState.fallbackLanguage)) {
+          runtimeState.cache.set(runtimeState.fallbackLanguage, {});
+        }
+      }
+    } else {
+      getTranslationsForState(runtimeState, runtimeState.language);
+      if (runtimeState.fallbackLanguage && runtimeState.fallbackLanguage !== runtimeState.language) {
+        getTranslationsForState(runtimeState, runtimeState.fallbackLanguage);
+      }
     }
   }
+}
+
+function createRuntime(runtimeState) {
+  const runtimeTranslate = (key, params) => translateWithState(runtimeState, key, params);
   return {
-    t: translate,
-    translate,
-    setLanguage,
-    getLanguage,
-    getAvailableLanguages,
-    refresh,
+    t: runtimeTranslate,
+    translate: runtimeTranslate,
+    setLanguage: (lang) => setLanguageForState(runtimeState, lang),
+    getLanguage: () => getLanguageForState(runtimeState),
+    getAvailableLanguages: () => getAvailableLanguagesForState(runtimeState),
+    refresh: (lang) => refreshForState(runtimeState, lang),
   };
 }
 
 function translate(key, params = {}) {
-  const langData = getTranslations(state.language);
-  let value = resolveKey(langData, key, state.keySeparator);
+  return translateWithState(singletonState, key, params);
+}
 
-  if (typeof value === 'undefined' && state.fallbackLanguage) {
-    const fbData = getTranslations(state.fallbackLanguage);
-    value = resolveKey(fbData, key, state.keySeparator);
-  }
+function translateWithState(runtimeState, key, params = {}) {
+  const langData = getTranslationsForState(runtimeState, runtimeState.language);
+  let value = resolveKey(langData, key, runtimeState.keySeparator, runtimeState, runtimeState.language);
+
+  if (typeof value === 'undefined' && runtimeState.fallbackLanguage) {
+    const fbData = getTranslationsForState(runtimeState, runtimeState.fallbackLanguage);
+    value = resolveKey(fbData, key, runtimeState.keySeparator, runtimeState, runtimeState.fallbackLanguage);
+  }
 
   if (typeof value === 'string') return interpolate(value, params);
   return typeof value === 'undefined' ? key : value;
 }
 
 function setLanguage(lang) {
+  setLanguageForState(singletonState, lang);
+}
+
+function setLanguageForState(runtimeState, lang) {
   if (!lang || typeof lang !== 'string') return;
-  state.language = lang;
+  runtimeState.language = lang;
 }
 
 function getLanguage() {
-  return state.language;
+  return getLanguageForState(singletonState);
+}
+
+function getLanguageForState(runtimeState) {
+  return runtimeState.language;
 }
 
 function getAvailableLanguages() {
+  return getAvailableLanguagesForState(singletonState);
+}
+
+function getAvailableLanguagesForState(runtimeState) {
   const langs = new Set();
-  if (!state.baseDir) state.baseDir = resolveBaseDir();
-  if (!SecurityUtils.safeExistsSync(state.baseDir)) return ['en'];
+  if (!runtimeState.baseDir) runtimeState.baseDir = resolveBaseDir();
+  if (!SecurityUtils.safeExistsSync(runtimeState.baseDir, path.dirname(runtimeState.baseDir))) return ['en'];
   try {
-    for (const entry of fs.readdirSync(state.baseDir, { withFileTypes: true })) {
+    for (const entry of fs.readdirSync(runtimeState.baseDir, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.toLowerCase().endsWith('.json')) {
         langs.add(entry.name.replace(/\.json$/i, ''));
       } else if (entry.isDirectory()) {
         const lang = entry.name;
-        const idx = path.join(state.baseDir, lang, `${lang}.json`);
-        if (SecurityUtils.safeExistsSync(idx)) langs.add(lang);
+        const idx = path.join(runtimeState.baseDir, lang, `${lang}.json`);
+        if (SecurityUtils.safeExistsSync(idx, path.dirname(idx))) langs.add(lang);
         else langs.add(lang); // be permissive
       }
     }
@@ -248,13 +432,24 @@ function getAvailableLanguages() {
   return Array.from(langs.size ? langs : new Set(['en']));
 }
 
-function refresh(lang = state.language) {
-  if (state.cache.has(lang)) state.cache.delete(lang);
-  if (lang !== state.fallbackLanguage && state.cache.has(state.fallbackLanguage)) {
-    // do nothing; keep or clear on demand
-  }
+function refresh(lang) {
+  refreshForState(singletonState, lang);
 }
 
+function refreshForState(runtimeState, lang = runtimeState.language) {
+  if (runtimeState.cache.has(lang)) runtimeState.cache.delete(lang);
+  if (runtimeState.eagerLoadedLanguages) runtimeState.eagerLoadedLanguages.delete(lang);
+  if (runtimeState.keyManifest) runtimeState.keyManifest.delete(lang);
+  if (runtimeState.loadedFiles) {
+    for (const fileKey of Array.from(runtimeState.loadedFiles)) {
+      if (fileKey.startsWith(`${lang}\0`)) runtimeState.loadedFiles.delete(fileKey);
+    }
+  }
+  if (lang !== runtimeState.fallbackLanguage && runtimeState.cache.has(runtimeState.fallbackLanguage)) {
+    // do nothing; keep or clear on demand
+  }
+}
+
 module.exports = {
   initRuntime,
   translate,
@@ -262,5 +457,6 @@ module.exports = {
   setLanguage,
   getLanguage,
   getAvailableLanguages,
-  refresh,
-};
+  refresh,
+  loadKeyManifest: (baseDir) => loadKeyManifestFromDir(baseDir || singletonState.baseDir),
+};

package/ui-locales/en.json

@@ -1209,7 +1209,7 @@
   },
   "operations": {
     "completed": "✅ Operation completed successfully!",
-    "deleteReportsTitle": "🗑️ Delete Reports & Logs",
+    "deleteReportsTitle": "🗑️ Delete Reports, Logs & Cache",
     "scanningForFiles": "🔍 Scanning for files to delete...",
     "noFilesFoundToDelete": "✅ No files found to delete.",
     "availableDirectories": "📁 Available directories:",

package/utils/translate/protection.js

@@ -3,6 +3,8 @@ const SecurityUtils = require('../security');
 
 const DEFAULT_PROTECTION_FILE = 'i18ntk-auto-translate.json';
 const TOKEN_PREFIX = '__I18NTK_KEEP_';
+const MAX_CONTEXT_RULES = 100;
+const MAX_CONTEXT_INPUT_LENGTH = 200;
 
 function defaultProtectionConfig() {
   return {
@@ -49,12 +51,90 @@ function compilePatterns(patterns) {
   return compiled;
 }
 
+function parseContextString(context) {
+  if (typeof context !== 'string') return null;
+  if (context.length > MAX_CONTEXT_INPUT_LENGTH) return null;
+
+  const trimmed = context.trim();
+
+  if (trimmed === 'standalone') {
+    return { mode: 'standalone' };
+  }
+
+  const afterMatch = trimmed.match(/^after:(.+)$/i);
+  if (afterMatch) {
+    const words = afterMatch[1].split('|').map(w => w.trim()).filter(Boolean);
+    if (words.length === 0) return null;
+    return { mode: 'after', words };
+  }
+
+  const beforeMatch = trimmed.match(/^before:(.+)$/i);
+  if (beforeMatch) {
+    const words = beforeMatch[1].split('|').map(w => w.trim()).filter(Boolean);
+    if (words.length === 0) return null;
+    return { mode: 'before', words };
+  }
+
+  const prefix = trimmed.substring(0, 'surrounded:'.length);
+  if (prefix.toLowerCase() === 'surrounded:') {
+    const rest = trimmed.substring('surrounded:'.length);
+    const idx = rest.indexOf(',');
+    if (idx === -1) return null;
+    const left = rest.slice(0, idx).trim();
+    const right = rest.slice(idx + 1).trim();
+    const leftWords = left.split('|').map(w => w.trim()).filter(Boolean);
+    const rightWords = right.split('|').map(w => w.trim()).filter(Boolean);
+    if (leftWords.length === 0 || rightWords.length === 0) return null;
+    return { mode: 'surrounded', left: leftWords, right: rightWords };
+  }
+
+  return null;
+}
+
+function parseContextRule(rule) {
+  if (typeof rule === 'string') {
+    const trimmed = rule.trim();
+    if (!trimmed || trimmed.length > MAX_CONTEXT_INPUT_LENGTH) return null;
+    return { value: trimmed, type: 'global' };
+  }
+
+  if (
+    typeof rule === 'object' &&
+    rule !== null &&
+    typeof rule.value === 'string' &&
+    typeof rule.context === 'string'
+  ) {
+    const value = rule.value.trim();
+    const rawContext = rule.context;
+
+    if (!value || value.length > MAX_CONTEXT_INPUT_LENGTH) return null;
+    if (!rawContext || rawContext.length > MAX_CONTEXT_INPUT_LENGTH) return null;
+
+    const parsed = parseContextString(rawContext);
+    if (!parsed) return null;
+
+    return { value, type: 'context', context: parsed };
+  }
+
+  return null;
+}
+
 function normalizeProtectionConfig(config = {}, filePath = null) {
   const terms = normalizeList(config.terms);
   const keys = normalizeList(config.keys);
   const values = normalizeList(config.values);
   const patterns = normalizeList(config.patterns);
 
+  const rawTerms = Array.isArray(config.terms) ? config.terms : [];
+  const normalizedTerms = [];
+  for (const term of rawTerms) {
+    const normalized = parseContextRule(term);
+    if (normalized) {
+      normalizedTerms.push(normalized);
+    }
+  }
+  const cappedTerms = normalizedTerms.slice(0, MAX_CONTEXT_RULES);
+
   return {
     enabled: true,
     filePath,
@@ -62,7 +142,8 @@ function normalizeProtectionConfig(config = {}, filePath = null) {
     keys,
     values,
     patterns,
-    compiledPatterns: compilePatterns(patterns)
+    compiledPatterns: compilePatterns(patterns),
+    normalizedTerms: cappedTerms
   };
 }
 
@@ -98,10 +179,20 @@ function saveProtectionFile(filePath, config, options = {}) {
   if (!SecurityUtils.safeExistsSync(dir, path.dirname(dir))) {
     SecurityUtils.safeMkdirSync(dir, path.dirname(dir), { recursive: true });
   }
+
+  const rawTerms = Array.isArray(config?.terms) ? config.terms : [];
+  const sanitizedTerms = [];
+  for (const term of rawTerms) {
+    const normalized = parseContextRule(term);
+    if (normalized) {
+      sanitizedTerms.push(term);
+    }
+  }
+
   const nextConfig = {
     ...defaultProtectionConfig(),
     ...(config || {}),
-    terms: normalizeList(config?.terms),
+    terms: sanitizedTerms.slice(0, MAX_CONTEXT_RULES),
     keys: normalizeList(config?.keys),
     values: normalizeList(config?.values),
     patterns: normalizeList(config?.patterns)
@@ -156,7 +247,8 @@ function shouldPreserveWholeValue(keyPath, value, protection) {
   if (!protection || protection.enabled === false) return false;
   if (protection.keys.some(rule => keyMatchesRule(keyPath, rule))) return true;
   const valueText = String(value);
-  return protection.values.includes(valueText) || protection.terms.includes(valueText);
+  return protection.values.includes(valueText) ||
+    (protection.normalizedTerms || []).some(rule => rule.type === 'global' && rule.value === valueText);
 }
 
 function addReplacement(replacements, original) {
@@ -165,13 +257,65 @@ function addReplacement(replacements, original) {
   replacements.push({ original });
 }
 
+function shouldProtectInContext(value, rule, index, fullText) {
+  if (rule.type === 'global') return true;
+
+  const { context } = rule;
+  const before = fullText.substring(0, index);
+  const after = fullText.substring(index + value.length);
+
+  if (context.mode === 'after') {
+    const alternation = context.words.map(escapeRegExp).join('|');
+    const regex = new RegExp(`(^|[\\s\\p{P}])(${alternation})\\s+$`, 'iu');
+    return regex.test(before);
+  }
+
+  if (context.mode === 'before') {
+    const alternation = context.words.map(escapeRegExp).join('|');
+    const regex = new RegExp(`^\\s+(${alternation})([\\s\\p{P}]|$)`, 'iu');
+    return regex.test(after);
+  }
+
+  if (context.mode === 'standalone') {
+    const isBoundaryBefore = before === '' || /(?:\s|\(|\[|\{|"|'|\-|–|—|。|、|」)$/.test(before);
+    const isBoundaryAfter = after === '' || /^[\s.,!?;:)\]}<>"'\-–—。、」]/.test(after);
+    return isBoundaryBefore && isBoundaryAfter;
+  }
+
+  if (context.mode === 'surrounded') {
+    const leftAlternation = context.left.map(escapeRegExp).join('|');
+    const rightAlternation = context.right.map(escapeRegExp).join('|');
+    const leftRegex = new RegExp(`(^|[\\s\\p{P}])(${leftAlternation})\\s+$`, 'iu');
+    const rightRegex = new RegExp(`^\\s+(${rightAlternation})([\\s\\p{P}]|$)`, 'iu');
+    return leftRegex.test(before) && rightRegex.test(after);
+  }
+
+  return false;
+}
+
 function collectReplacements(value, protection) {
   const text = String(value);
   const replacements = [];
 
-  for (const term of protection.terms || []) {
-    if (text.includes(term)) {
-      addReplacement(replacements, term);
+  const rules = protection.normalizedTerms || (protection.terms || [])
+    .map(parseContextRule)
+    .filter(Boolean);
+  for (const rule of rules) {
+    if (rule.type === 'global') {
+      if (text.includes(rule.value)) {
+        addReplacement(replacements, rule.value);
+      }
+    } else {
+      if (!rule.value) continue;
+      const escaped = escapeRegExp(rule.value);
+      const regex = new RegExp(escaped, 'gi');
+      let match;
+      while ((match = regex.exec(text)) !== null) {
+        if (shouldProtectInContext(rule.value, rule, match.index, text)) {
+          addReplacement(replacements, match[0]);
+        }
+        if (match[0] === '') regex.lastIndex++;
+      }
     }
   }
 
@@ -221,7 +365,8 @@ function hasProtectionRules(protection) {
   return Boolean(
     protection &&
     (
-      protection.terms.length ||
+      (protection.normalizedTerms && protection.normalizedTerms.length) ||
+      (protection.terms && protection.terms.length) ||
       protection.keys.length ||
       protection.values.length ||
       protection.patterns.length
@@ -235,6 +380,7 @@ module.exports = {
   defaultProtectionConfig,
   hasProtectionRules,
   loadProtectionConfig,
+  parseContextRule,
   protectText,
   readProtectionFile,
   restoreText,