bctranslate 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bctranslate",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "CLI to transform source files into i18n-ready code with automatic translation via argostranslate",
   "type": "module",
   "bin": {

package/src/generators/setup.js

@@ -1,4 +1,4 @@
-import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, writeFileSync, mkdirSync, readFileSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
 import { getLocaleDir } from './locales.js';
@@ -150,39 +150,102 @@ async function ensureVanillaI18n(cwd, from, to, localeDir) {
     locales[lang] = await resp.json();
   }
 
-  function t(key, params) {
-    const msg = (locales[currentLocale] && locales[currentLocale][key]) || key;
-    if (!params) return msg;
-    return msg.replace(/\\{(\\w+)\\}/g, function (_, k) {
-      return params[k] !== undefined ? params[k] : '{' + k + '}';
-    });
-  }
+  function t(key, params) {
+    // Support both flat keys ("home.submit") and nested objects ({ home: { submit: ... } })
+    const dict = locales[currentLocale] || {};
+    const direct = Object.prototype.hasOwnProperty.call(dict, key) ? dict[key] : null;
+    const msg =
+      direct !== null && direct !== undefined
+        ? direct
+        : key.split('.').reduce((obj, i) => (obj ? obj[i] : null), dict) || key;
+
+    if (!params) return msg;
+    return String(msg).replace(/\\{(\\w+)\\}/g, (match, k) =>
+      params[k] !== undefined ? params[k] : match
+    );
+  }
 
   async function setLocale(lang) {
     await loadLocale(lang);
     currentLocale = lang;
     // Re-translate all elements with data-i18n attribute
-    document.querySelectorAll('[data-i18n]').forEach(function (el) {
-      const key = el.getAttribute('data-i18n');
-      el.textContent = t(key);
-    });
+    document.querySelectorAll('[data-i18n]').forEach(function (el) {
+      const key = el.getAttribute('data-i18n');
+      const translated = t(key);
+      // Preserve markup translations (e.g. "Hello <strong>world</strong>")
+      if (el.children.length > 0 || /<[^>]+>/.test(String(translated))) {
+        el.innerHTML = translated;
+      } else {
+        el.textContent = translated;
+      }
+    });
     document.querySelectorAll('[data-i18n-placeholder]').forEach(function (el) {
       el.placeholder = t(el.getAttribute('data-i18n-placeholder'));
     });
-    document.querySelectorAll('[data-i18n-title]').forEach(function (el) {
-      el.title = t(el.getAttribute('data-i18n-title'));
-    });
-  }
-
-  // Auto-init
-  loadLocale('${from}');
-  loadLocale('${to}');
+    document.querySelectorAll('[data-i18n-title]').forEach(function (el) {
+      const translated = t(el.getAttribute('data-i18n-title'));
+      if (el.tagName === 'TITLE') {
+        document.title = translated;
+      } else {
+        el.title = translated;
+      }
+    });
+  }
+
+  // Auto-init
+  loadLocale('${from}');
+  setLocale('${to}');
 
   window.i18n = { t: t, setLocale: setLocale, loadLocale: loadLocale };
 })();
 `;
 
-  writeFileSync(i18nFile, content, 'utf-8');
-  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
-  console.log(chalk.yellow(`  ⚠ Add <script src="i18n.js"></script> to your HTML`));
-}
+  writeFileSync(i18nFile, content, 'utf-8');
+  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
+
+  const injected = injectVanillaI18nEntrypoint(cwd);
+  if (!injected) {
+    console.log(chalk.yellow(`  ⚠ Add <script src="i18n.js"></script> to your HTML`));
+  }
+}
+
+function injectVanillaI18nEntrypoint(cwd) {
+  // Prefer HTML entrypoint if present
+  const htmlPath = join(cwd, 'index.html');
+  if (existsSync(htmlPath)) {
+    const html = readFileSync(htmlPath, 'utf-8');
+    if (!/\bi18n\.js\b/.test(html)) {
+      const scriptTag = `  <script src="./i18n.js"></script>\n`;
+      let updated = html;
+
+      const firstScript = updated.match(/<script\b/i);
+      if (firstScript) {
+        updated = updated.replace(firstScript[0], scriptTag + firstScript[0]);
+      } else if (updated.includes('</body>')) {
+        updated = updated.replace('</body>', scriptTag + '</body>');
+      } else if (updated.includes('</head>')) {
+        updated = updated.replace('</head>', scriptTag + '</head>');
+      } else {
+        updated += '\n' + scriptTag;
+      }
+
+      writeFileSync(htmlPath, updated, 'utf-8');
+      console.log(chalk.green(`  ✓ Updated ${htmlPath} (added i18n.js script)`));
+    }
+    return true;
+  }
+
+  // Fallback: ESM entrypoint
+  const jsPath = join(cwd, 'index.js');
+  if (existsSync(jsPath)) {
+    const js = readFileSync(jsPath, 'utf-8');
+    const alreadyImports = js.includes("./i18n.js") || js.includes("'./i18n.js'") || js.includes("\"./i18n.js\"");
+    if (!alreadyImports && /\b(import|export)\b/.test(js)) {
+      writeFileSync(jsPath, `import './i18n.js';\n` + js, 'utf-8');
+      console.log(chalk.green(`  ✓ Updated ${jsPath} (imported i18n.js)`));
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/index.js

@@ -128,7 +128,7 @@ export async function writeFileResult(parseResult, translations, opts) {
 export async function translateAllFiles(files, opts) {
   const { from, to, cwd, project, verbose, localesDir } = opts;
 
-  const resolvedLocaleDir = localesDir || getLocaleDir(cwd, project);
+  const resolvedLocaleDir = opts.outdir ? join(opts.outdir, 'locales') : (localesDir || getLocaleDir(cwd, project));
   const existingTarget    = loadLocale(resolvedLocaleDir, to);
 
   // Phase 1 — parse

package/src/parsers/html.js

@@ -1,5 +1,6 @@
 import MagicString from 'magic-string';
 import { parse, NodeTypes } from '@vue/compiler-dom';
+import { parseJs } from './js.js';
 import { contextKey, isTranslatable } from '../utils.js';
 
 const ATTR_WHITELIST = new Set([
@@ -30,7 +31,7 @@ const CONTENT_TAGS = new Set([
   'td',
 ]);
 
-const SKIP_TAGS = new Set(['script', 'style', 'noscript']);
+const SKIP_TAGS = new Set(['style', 'noscript']);
 
 function stripTags(html) {
   return html.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
@@ -71,6 +72,27 @@ export function parseHtml(source, filePath, project) {
 
     const openTagText = source.slice(node.loc.start.offset, openTagEnd);
 
+    // Special case: inline <script> blocks inside HTML
+    if (tag === 'script' && !node.isSelfClosing) {
+      const hasSrc = (node.props || []).some(
+        (p) => p.type === NodeTypes.ATTRIBUTE && p.name === 'src'
+      );
+      if (hasSrc) return;
+
+      const closeRel = node.loc.source.lastIndexOf('</');
+      if (closeRel > -1) {
+        const closeTagStart = node.loc.start.offset + closeRel;
+        const scriptJs = source.slice(openTagEnd + 1, closeTagStart);
+        const jsResult = parseJs(scriptJs, filePath, project);
+        if (jsResult.modified) {
+          s.overwrite(openTagEnd + 1, closeTagStart, jsResult.source);
+          extracted.push(...jsResult.extracted);
+        }
+      }
+
+      return;
+    }
+
     // 1) Extract translatable attributes
     for (const prop of node.props || []) {
       if (prop.type !== NodeTypes.ATTRIBUTE) continue;

package/src/parsers/js.js

@@ -1,8 +1,8 @@
-import * as babelParser from '@babel/parser';
-import _traverse from '@babel/traverse';
-import * as t from '@babel/types';
-import MagicString from 'magic-string';
-import { contextKey, isTranslatable } from '../utils.js';
+import * as babelParser from '@babel/parser';
+import _traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import MagicString from 'magic-string';
+import { contextKey, isTranslatable } from '../utils.js';
 
 const traverse = _traverse.default || _traverse;
 
@@ -10,14 +10,37 @@ const traverse = _traverse.default || _traverse;
  * Parse a .js/.ts file and extract translatable strings.
  * These are strings in common UI patterns: alert(), confirm(), DOM manipulation, etc.
  */
-export function parseJs(source, filePath, project) {
-  const extracted = [];
-  const isTS = filePath.endsWith('.ts');
-
-  let ast;
-  try {
-    ast = babelParser.parse(source, {
-      sourceType: 'module',
+export function parseJs(source, filePath, project) {
+  const extracted = [];
+  const isTS = filePath.endsWith('.ts');
+
+  const tFuncFor = (key) => {
+    if (project.type === 'vanilla') return `i18n.t('${key}')`;
+    if (project.type === 'vue') return `this.$t('${key}')`;
+    return `t('${key}')`;
+  };
+
+  const translatableVarNames = new Set([
+    'title', 'pageTitle', 'heading', 'subheading', 'header', 'subtitle',
+    'label', 'placeholder', 'message', 'text', 'description', 'tooltip', 'hint', 'caption',
+    'error', 'errorMessage', 'success', 'successMessage',
+    'buttonText', 'linkText',
+  ]);
+
+  const translatableAttrNames = new Set([
+    'title',
+    'placeholder',
+    'label',
+    'alt',
+    'aria-label',
+    'aria-placeholder',
+    'aria-description',
+  ]);
+
+  let ast;
+  try {
+    ast = babelParser.parse(source, {
+      sourceType: 'module',
       plugins: [
         isTS ? 'typescript' : null,
         'classProperties',
@@ -33,12 +56,32 @@ export function parseJs(source, filePath, project) {
 
   const s = new MagicString(source);
 
-  // Track which string literals to translate
-  traverse(ast, {
-    // Object property values with translatable keys
-    ObjectProperty(path) {
-      const keyNode = path.node.key;
-      const valueNode = path.node.value;
+  // Track which string literals to translate
+  traverse(ast, {
+    VariableDeclarator(path) {
+      const { id, init } = path.node;
+      if (!init) return;
+      if (id.type !== 'Identifier') return;
+      if (!translatableVarNames.has(id.name)) return;
+
+      let value = null;
+      if (init.type === 'StringLiteral') value = init.value;
+      else if (init.type === 'TemplateLiteral' && init.expressions.length === 0) {
+        value = init.quasis[0]?.value?.cooked ?? '';
+      }
+
+      if (typeof value !== 'string' || !isTranslatable(value)) return;
+
+      const key = contextKey(value, filePath);
+      const tFunc = tFuncFor(key);
+      s.overwrite(init.start, init.end, tFunc);
+      extracted.push({ key, text: value, context: `js-var-${id.name}` });
+    },
+
+    // Object property values with translatable keys
+    ObjectProperty(path) {
+      const keyNode = path.node.key;
+      const valueNode = path.node.value;
 
       if (valueNode.type !== 'StringLiteral') return;
       if (!isTranslatable(valueNode.value)) return;
@@ -53,19 +96,19 @@ export function parseJs(source, filePath, project) {
         'name', 'displayName',
       ]);
 
-      if (!translatableKeys.has(keyName)) return;
+      if (!translatableKeys.has(keyName)) return;
+
+      const key = contextKey(valueNode.value, filePath);
+      const tFunc = tFuncFor(key);
+
+      s.overwrite(valueNode.start, valueNode.end, tFunc);
+      extracted.push({ key, text: valueNode.value, context: `js-prop-${keyName}` });
+    },
 
-      const key = contextKey(valueNode.value, filePath);
-      const tFunc = project.type === 'vue' ? `this.$t('${key}')` : `t('${key}')`;
-
-      s.overwrite(valueNode.start, valueNode.end, tFunc);
-      extracted.push({ key, text: valueNode.value, context: `js-prop-${keyName}` });
-    },
-
-    // Function calls: alert('text'), console messages excluded
-    CallExpression(path) {
-      const callee = path.node.callee;
-      let calleeName = '';
+    // Function calls: alert('text'), console messages excluded
+    CallExpression(path) {
+      const callee = path.node.callee;
+      let calleeName = '';
 
       if (callee.type === 'Identifier') {
         calleeName = callee.name;
@@ -76,19 +119,35 @@ export function parseJs(source, filePath, project) {
       // Skip console.*, require(), import()
       if (calleeName.startsWith('console.') || calleeName === 'require') return;
 
-      // Translate alert/confirm/prompt first arg
-      if (['alert', 'confirm', 'prompt'].includes(calleeName)) {
-        const arg = path.node.arguments[0];
-        if (arg && arg.type === 'StringLiteral' && isTranslatable(arg.value)) {
-          const key = contextKey(arg.value, filePath);
-          const tFunc = project.type === 'vue' ? `this.$t('${key}')` : `t('${key}')`;
-          s.overwrite(arg.start, arg.end, tFunc);
-          extracted.push({ key, text: arg.value, context: 'js-call' });
-        }
-      }
-
-      // .textContent = 'text', .innerText = 'text', .title = 'text'
-    },
+      // Translate alert/confirm/prompt first arg
+      if (['alert', 'confirm', 'prompt'].includes(calleeName)) {
+        const arg = path.node.arguments[0];
+        if (arg && arg.type === 'StringLiteral' && isTranslatable(arg.value)) {
+          const key = contextKey(arg.value, filePath);
+          const tFunc = tFuncFor(key);
+          s.overwrite(arg.start, arg.end, tFunc);
+          extracted.push({ key, text: arg.value, context: 'js-call' });
+        }
+      }
+
+      // element.setAttribute('title', '...')
+      if (callee.type === 'MemberExpression' && callee.property?.name === 'setAttribute') {
+        const [nameArg, valueArg] = path.node.arguments;
+        if (
+          nameArg?.type === 'StringLiteral' &&
+          valueArg?.type === 'StringLiteral' &&
+          translatableAttrNames.has(nameArg.value) &&
+          isTranslatable(valueArg.value)
+        ) {
+          const key = contextKey(valueArg.value, filePath);
+          const tFunc = tFuncFor(key);
+          s.overwrite(valueArg.start, valueArg.end, tFunc);
+          extracted.push({ key, text: valueArg.value, context: `js-attr-${nameArg.value}` });
+        }
+      }
+
+      // .textContent = 'text', .innerText = 'text', .title = 'text'
+    },
 
     // Assignment: element.textContent = 'text'
     AssignmentExpression(path) {
@@ -105,18 +164,14 @@ export function parseJs(source, filePath, project) {
           'alt', 'innerHTML',
         ]);
 
-        if (domProps.has(propName)) {
-          const key = contextKey(right.value, filePath);
-          const tFunc = project.type === 'vanilla'
-            ? `i18n.t('${key}')`
-            : project.type === 'vue'
-              ? `this.$t('${key}')`
-              : `t('${key}')`;
-
-          s.overwrite(right.start, right.end, tFunc);
-          extracted.push({ key, text: right.value, context: `js-dom-${propName}` });
-        }
-      }
+        if (domProps.has(propName)) {
+          const key = contextKey(right.value, filePath);
+          const tFunc = tFuncFor(key);
+
+          s.overwrite(right.start, right.end, tFunc);
+          extracted.push({ key, text: right.value, context: `js-dom-${propName}` });
+        }
+      }
     },
   });
 
@@ -125,4 +180,4 @@ export function parseJs(source, filePath, project) {
     extracted,
     modified: extracted.length > 0,
   };
-}
+}

package/src/parsers/vue.js

@@ -1,4 +1,7 @@
 import * as compiler from '@vue/compiler-dom';
+import { parse as babelParse } from '@babel/parser';
+import _traverse from '@babel/traverse';
+const traverse = _traverse.default;
 import MagicString from 'magic-string';
 import { contextKey, isTranslatable } from '../utils.js';
 
@@ -30,14 +33,6 @@ const ATTR_WHITELIST = new Set([
  *  - Options API (no setup)
  *    → use  $t('key')         (global plugin property)
  */
-function detectTStyle(source) {
-  const isSetup = /<script\b[^>]*\bsetup\b/i.test(source);
-
-  // Already has:  const { t } = ...   or   const { t, ... } = ...
-  const hasT = /const\s*\{[^}]*\bt\b[^}]*\}\s*=/.test(source);
-
-  return { isSetup, hasT };
-}
 
 /**
  * Parse a .vue file and extract translatable strings.
@@ -46,12 +41,9 @@ export function parseVue(source, filePath) {
   const extracted = [];
   const s = new MagicString(source);
 
-  const { isSetup, hasT } = detectTStyle(source);
-
-  // In templates: use t() for Composition API, $t() for Options API
-  const tpl = (key) => (isSetup || hasT) ? `t('${key}')` : `$t('${key}')`;
-  // In scripts: use t() for setup, this.$t() for options
-  const scr = (key) => isSetup ? `t('${key}')` : `this.$t('${key}')`;
+  // Always use t() for consistency, as promised in the README.
+  const tpl = (key) => `t('${key}')`;
+  const scr = (key) => `t('${key}')`;
 
   // ── Template ────────────────────────────────────────────────────────────────
   const templateMatch = source.match(/<template\b[^>]*>([\s\S]*?)<\/template>/);
@@ -77,12 +69,13 @@ export function parseVue(source, filePath) {
     extractScriptStrings(scriptContent, s, scriptOffset, extracted, filePath, scr);
   }
 
-  // ── Inject `const { t } = useI18n()` if setup but t not yet declared ────────
-  if (extracted.length > 0 && isSetup && !hasT) {
+  // ── Inject `const { t } = useI18n()` if not yet declared ────────
+  if (extracted.length > 0) {
     const scriptSetupMatch = source.match(/(<script\b[^>]*\bsetup\b[^>]*>)([\s\S]*?)<\/script>/i);
-    if (scriptSetupMatch) {
-      const insertAt =
-        source.indexOf(scriptSetupMatch[0]) + scriptSetupMatch[1].length;
+    const hasT = /const\s*\{[^}]*\bt\b[^}]*\}\s*=/.test(source);
+    
+    if (scriptSetupMatch && !hasT) {
+      const insertAt = source.indexOf(scriptSetupMatch[0]) + scriptSetupMatch[1].length;
       const needsImport = !source.includes('useI18n');
       const importLine = needsImport ? `import { useI18n } from 'vue-i18n';\n` : '';
       s.appendRight(insertAt, `\n${importLine}const { t } = useI18n();\n`);
@@ -155,64 +148,87 @@ function walkTemplate(nodes, s, baseOffset, extracted, filePath, tpl) {
 // ── Script string extractor ───────────────────────────────────────────────────
 
 function extractScriptStrings(scriptContent, s, baseOffset, extracted, filePath, scr) {
-  // Pattern A: alert/confirm/toast/notify calls  →  match[2]=quote, match[3]=text
-  // Pattern B: UI object property string values  →  match[2]=quote, match[3]=text
-  const patternsAB = [
+  try {
+    const ast = babelParse(scriptContent, {
+      sourceType: 'module',
+      plugins: ['typescript', 'jsx'], // Enable TS and JSX support
+    });
+
+    const replacements = [];
+
+    traverse(ast, {
+      enter(path) {
+        let text;
+
+        if (path.isStringLiteral()) {
+          text = path.node.value;
+        } else if (path.isTemplateLiteral()) {
+          if (path.node.expressions.length > 0 || path.node.quasis.length !== 1) {
+            return;
+          }
+          text = path.node.quasis[0].value.cooked;
+        } else {
+          return;
+        }
+        
+        if (!isTranslatable(text)) return;
+
+        // --- Parent checks to avoid replacing the wrong strings ---
+        if (path.parent.type === 'CallExpression' && path.parent.callee.name === 't') return;
+        if (['ImportDeclaration', 'ExportNamedDeclaration', 'ExportAllDeclaration'].includes(path.parent.type)) return;
+        if (path.parent.type === 'ObjectProperty' && path.parent.key === path.node) return;
+        if (path.parent.type === 'Property' && ['name'].includes(path.parent.key.name)) return;
+
+        // --- Passed all checks, schedule replacement ---
+        const key = contextKey(text, filePath);
+        const start = baseOffset + path.node.start;
+        const end = baseOffset + path.node.end;
+        replacements.push({ start, end, key });
+        extracted.push({ key, text, context: 'script' });
+      }
+    });
+
+    // Apply replacements in reverse order to avoid offset issues
+    for (let i = replacements.length - 1; i >= 0; i--) {
+      const { start, end, key } = replacements[i];
+      s.overwrite(start, end, scr(key));
+    }
+
+  } catch (e) {
+    console.error('Babel parsing failed:', e);
+    // If babel parsing fails, fallback to regex.
+    extractScriptStringsRegex(scriptContent, s, baseOffset, extracted, filePath, scr);
+  }
+}
+
+
+function extractScriptStringsRegex(scriptContent, s, baseOffset, extracted, filePath, scr) {
+  // This is the old regex-based implementation, kept as a fallback.
+  const patterns = [
     /\b(alert|confirm|toast|notify|message\.(?:success|error|warning|info))\s*\(\s*(['"`])((?:(?!\2).)+)\2\s*\)/g,
     /\b(title|label|placeholder|message|text|description|tooltip|hint|caption|header|subtitle|errorMessage|successMessage|emptyText|noData|loadingText|buttonText|confirmText|cancelText|successText|failText|warningText|helperText|hintText)\s*:\s*(['"`])((?:(?!\2).)+)\2/g,
+    /\bref\s*\(\s*(['"`])((?:(?!\1)[^\\]|\\.)+)\1\s*\)/g,
+    /\bcomputed\s*\(\s*\(\s*\)\s*=>\s*(['"`])((?:(?!\1)[^\\]|\\.)+)\1\s*\)/g,
   ];
 
-  for (const pattern of patternsAB) {
+  for (const pattern of patterns) {
     let match;
     while ((match = pattern.exec(scriptContent)) !== null) {
-      const text = match[3];
+      const text = match[3] || match[2];
       if (!isTranslatable(text) || text.length <= 1) continue;
-      const quoteChar = match[2];
-      const relPos = match.index + match[0].indexOf(quoteChar + text);
-      if (isAlreadyWrappedScript(scriptContent, relPos)) continue;
-      const key      = contextKey(text, filePath);
-      const textStart = baseOffset + relPos;
-      const textEnd   = textStart + text.length + 2;
-      s.overwrite(textStart, textEnd, scr(key));
-      extracted.push({ key, text, context: 'script' });
-    }
-  }
+      
+      const quoteChar = match[2] || match[1];
+      const innerStr = quoteChar + text + quoteChar;
+      const relPos = match.index + match[0].lastIndexOf(innerStr);
 
-  // Pattern C: ref('string') / ref("string")  →  match[1]=quote, match[2]=text
-  const refPattern = /\bref\s*\(\s*(['"`])((?:(?!\1)[^\\]|\\.)+)\1\s*\)/g;
-  {
-    let match;
-    while ((match = refPattern.exec(scriptContent)) !== null) {
-      const text = match[2];
-      if (!isTranslatable(text) || text.length <= 1) continue;
-      const quoteChar = match[1];
-      const innerStr  = quoteChar + text + quoteChar;
-      const relPos    = match.index + match[0].indexOf(innerStr);
       if (isAlreadyWrappedScript(scriptContent, relPos)) continue;
-      const key      = contextKey(text, filePath);
-      const textStart = baseOffset + relPos;
-      const textEnd   = textStart + innerStr.length;
-      s.overwrite(textStart, textEnd, scr(key));
-      extracted.push({ key, text, context: 'script-ref' });
-    }
-  }
 
-  // Pattern D: computed(() => 'string')  →  match[1]=quote, match[2]=text
-  const computedPattern = /\bcomputed\s*\(\s*\(\s*\)\s*=>\s*(['"`])((?:(?!\1)[^\\]|\\.)+)\1\s*\)/g;
-  {
-    let match;
-    while ((match = computedPattern.exec(scriptContent)) !== null) {
-      const text = match[2];
-      if (!isTranslatable(text) || text.length <= 1) continue;
-      const quoteChar = match[1];
-      const innerStr  = quoteChar + text + quoteChar;
-      const relPos    = match.index + match[0].indexOf(innerStr);
-      if (isAlreadyWrappedScript(scriptContent, relPos)) continue;
-      const key      = contextKey(text, filePath);
+      const key = contextKey(text, filePath);
       const textStart = baseOffset + relPos;
-      const textEnd   = textStart + innerStr.length;
+      const textEnd = textStart + innerStr.length;
+
       s.overwrite(textStart, textEnd, scr(key));
-      extracted.push({ key, text, context: 'script-computed' });
+      extracted.push({ key, text, context: 'script-regex' });
     }
   }
 }
@@ -222,12 +238,14 @@ function isAlreadyWrappedScript(scriptContent, pos) {
   return /\$?t\s*\(\s*$/.test(before);
 }
 
+
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function isAlreadyWrapped(source, start, end) {
-  // Look back 25 chars for an open t( or $t( call — node is inside an interpolation
+  // Look back 25 chars for an open t( call — node is inside an interpolation
   const before = source.slice(Math.max(0, start - 25), start);
-  return /\$?t\s*\(\s*['"]/.test(before);
+  // Note: We only check for `t` now, not `$t`.
+  return /t\s*\(\s*['"]/.test(before);
 }
 
 function extractTemplateRegex(source, s, extracted, filePath, tpl) {

package/python/t2.py

@@ -1,76 +0,0 @@
-import sys
-import json
-import os
-
-# Suppress TensorFlow logs
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
-
-try:
-    import argostranslate.package
-    import argostranslate.translate
-except ImportError:
-    print(json.dumps({"error": "argostranslate not found. Please run: pip install argostranslate"}), file=sys.stderr)
-    sys.exit(1)
-
-def main():
-    if len(sys.argv) != 3:
-        print(json.dumps({"error": "Usage: python translator.py <from_code> <to_code>"}), file=sys.stderr)
-        sys.exit(1)
-
-    from_code = sys.argv[1]
-    to_code = sys.argv[2]
-
-    try:
-        input_data = sys.stdin.read()
-        batch = json.loads(input_data)
-    except json.JSONDecodeError:
-        print(json.dumps({"error": "Invalid JSON input"}), file=sys.stderr)
-        sys.exit(1)
-
-    try:
-        # 1. Find the installed languages
-        installed_languages = argostranslate.translate.get_installed_languages()
-        from_lang = next((lang for lang in installed_languages if lang.code == from_code), None)
-        to_lang = next((lang for lang in installed_languages if lang.code == to_code), None)
-
-        if not from_lang or not to_lang:
-            # This should ideally be handled by the check in the Node.js bridge,
-            # but as a fallback, we report it here too.
-            available_codes = [l.code for l in installed_languages]
-            print(json.dumps({
-                "error": f"Language pair not installed: {from_code}->{to_code}. Installed: {available_codes}"
-            }), file=sys.stderr)
-            sys.exit(1)
-
-        # 2. Get the translation object
-        translation = from_lang.get_translation(to_lang)
-        if not translation:
-             # This may happen if the translation direction is not supported (e.g., en->en)
-            if from_code == to_code:
-                # If source and target are the same, just return the original text
-                print(json.dumps(batch))
-                sys.exit(0)
-            else:
-                print(json.dumps({"error": f"Translation from {from_code} to {to_code} is not supported by the installed model."}), file=sys.stderr)
-                sys.exit(1)
-
-
-        # 3. Translate texts
-        translated_batch = []
-        for item in batch:
-            original_text = item.get('text', '')
-            translated_text = translation.translate(original_text)
-            translated_batch.append({
-                "key": item.get('key'),
-                "text": translated_text
-            })
-
-        # 4. Output the result as a JSON array
-        print(json.dumps(translated_batch, ensure_ascii=False))
-
-    except Exception as e:
-        print(json.dumps({"error": f"An unexpected error occurred: {str(e)}"}), file=sys.stderr)
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()