@babelize/engine 0.1.0 → 0.1.3

package/dist/utils/placeholder-protection.js

@@ -37,51 +37,93 @@ const PROTECTED_PATTERNS = [
     { kind: 'template', source: String.raw `\$\{[^{}]*\}` },
     // i18next nesting: $t(key) / $t(key, {...})
     { kind: 'nesting', source: String.raw `\$t\([^()]*\)` },
-    // Python named printf: %(name)s
-    { kind: 'printf', source: String.raw `%\(\w+\)[sdifr]` },
+    // Python named printf: %(name)s, %(count)d, %(price).2f
+    { kind: 'printf', source: String.raw `%\(\w+\)[-#0 +]*\d*(?:\.\d+)?[sdifr]` },
+    // Escaped percent in printf-style (gettext) strings: "50%% off"
+    { kind: 'printf', source: '%%' },
     // printf: %s %d %1$s %.2f %@ — not "%" followed by a word ("50%done")
     { kind: 'printf', source: String.raw `%(?:\d+\$)?[-+0#]*\d*(?:\.\d+)?[sdifu@xXc](?![A-Za-z])` },
     // ICU simple / formatted args and positional args: {name} {0} {price, number} {d, date, short}
     { kind: 'argument', source: String.raw `\{\s*[\w.]+\s*(?:,\s*(?:number|date|time)\s*(?:,\s*[^{}]+)?)?\}` },
+    // Python str.format positional field: "Only {} left"
+    { kind: 'argument', source: String.raw `\{\}` },
+    // HTML character references in markup-bearing text: —   ’
+    { kind: 'entity', source: String.raw `&(?:[a-zA-Z][a-zA-Z0-9]{1,31}|#\d{1,7}|#x[0-9a-fA-F]{1,6});` },
     // Markup / react-i18next Trans tags: <0>, </0>, <1/>, <b>, </strong>, <br />, <Link href="...">
     { kind: 'tag', source: String.raw `<\/?\d+\s*\/?>|<\/?[A-Za-z][\w.:-]*(?:\s+[^<>]*?)?\s*\/?>` },
 ];
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/** A term as a whole term in any script (same rule as modules/glossary termPattern). */
+function wholeTerm(term) {
+    return `(?<![\\p{L}\\p{N}_])${escapeRegex(term)}(?![\\p{L}\\p{N}_])`;
+}
 /** In ICU messages braces are structure, so only these kinds are tokenized. */
-const ICU_SAFE_KINDS = new Set(['url', 'email', 'code', 'tag']);
-function buildPattern(neverTranslateTerms, icu) {
+const ICU_SAFE_KINDS = new Set(['url', 'email', 'code', 'tag', 'entity']);
+/**
+ * Placeholders, tags, URLs etc. come first, so a term never matches inside
+ * one ("{dashboard}", "https://\u2026/settings"). Terms match longest first; a
+ * never-translate term wins over a fixed term spelled the same (ignoring
+ * case). Fixed terms are the named groups `f<i>` (index into `fixed`).
+ */
+function buildPattern(neverTranslateTerms, icu, fixedTerms) {
     const sources = PROTECTED_PATTERNS.filter((p) => !icu || ICU_SAFE_KINDS.has(p.kind)).map((p) => p.source);
-    const terms = [...new Set(neverTranslateTerms.filter((t) => t.trim().length > 0))]
-        .sort((a, b) => b.length - a.length)
-        .map((t) => `(?<![\\w])${escapeRegex(t)}(?![\\w])`);
+    const never = [...new Set(neverTranslateTerms.filter((t) => t.trim().length > 0))];
+    const neverLower = new Set(never.map((t) => t.toLowerCase()));
+    const seen = new Set();
+    const fixed = fixedTerms.filter((f) => {
+        const k = f.term.toLowerCase();
+        if (!f.term.trim() || !f.translation || neverLower.has(k) || seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+    const terms = [
+        ...never.map((t) => ({ term: t, source: wholeTerm(t) })),
+        ...fixed.map((f, i) => ({ term: f.term, source: `(?<f${i}>${wholeTerm(f.term)})` })),
+    ].sort((a, b) => b.term.length - a.term.length);
     if (terms.length > 0)
-        sources.push(terms.join('|'));
-    return new RegExp(sources.map((s) => `(?:${s})`).join('|'), 'gi');
+        sources.push(terms.map((t) => t.source).join('|'));
+    return { pattern: new RegExp(sources.map((s) => `(?:${s})`).join('|'), 'giu'), fixed };
 }
 /**
  * Replace every protected span (and every never-translate term) with a token.
  * With `icu: true`, braces are left alone (they are ICU structure) and only
  * URLs, emails, code, tags and terms are tokenized.
+ * `fixedTerms` ("always translate as") are tokenized too, and `restore` maps
+ * their tokens to the fixed translation: a plain-text translator never sees
+ * the term, so it can't ignore the rule.
  * Literal `[#VAR_n#]` text already present in the source is protected too, so
  * it can never be confused with an issued token.
  */
 function protectText(text, neverTranslateTerms = [], options = {}) {
     const tokens = [];
-    const pattern = buildPattern(neverTranslateTerms, options.icu ?? false);
+    const restore = [];
+    const { pattern, fixed } = buildPattern(neverTranslateTerms, options.icu ?? false, options.fixedTerms ?? []);
     // Guard pre-existing token-shaped text first.
     const guarded = text.replace(TOKEN_PATTERN, (m) => {
         tokens.push(m);
+        restore.push(m);
         return `\uE000${tokens.length - 1}\uE000`;
     });
     const protectedText = guarded
-        .replace(pattern, (match) => {
+        .replace(pattern, (...args) => {
+        const match = args[0];
+        const groups = args[args.length - 1];
+        let replacement = match;
+        if (fixed.length > 0 && groups && typeof groups === 'object') {
+            const g = groups;
+            const i = fixed.findIndex((_, idx) => g[`f${idx}`] !== undefined);
+            if (i >= 0)
+                replacement = fixed[i].translation;
+        }
         tokens.push(match);
+        restore.push(replacement);
         return tokenFor(tokens.length - 1);
     })
         .replace(/\uE000(\d+)\uE000/g, (_, i) => tokenFor(Number(i)));
-    return { text: protectedText, tokens };
+    return { text: protectedText, tokens, restore };
 }
 /** Every issued token must appear exactly once, and no other token may appear. */
 function checkTokens(translated, tokenCount) {
@@ -102,7 +144,10 @@ function checkTokens(translated, tokenCount) {
     const unexpected = [...counts.keys()].filter((i) => i >= tokenCount);
     return { ok: missing.length === 0 && duplicated.length === 0 && unexpected.length === 0, missing, duplicated, unexpected };
 }
-/** Swap tokens back for their original text. Call only after checkTokens passed. */
+/**
+ * Swap tokens back. Pass protectText's `restore` (fixed glossary terms become
+ * their translation) or `tokens` (original text). Call only after checkTokens passed.
+ */
 function restoreText(translated, tokens) {
     return translated.replace(TOKEN_PATTERN, (m, i) => tokens[Number(i)] ?? m);
 }

package/dist/utils/translation-sanitizer.d.ts

@@ -6,5 +6,6 @@
  */
 export declare function sanitizeTranslation(text: string, options?: {
     nllb?: boolean;
+    source?: string;
 }): string;
 export declare function validateRawTokens(aiOutput: string, expectedCount: number): boolean;

package/dist/utils/translation-sanitizer.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanitizeTranslation = sanitizeTranslation;
 exports.validateRawTokens = validateRawTokens;
-const NLLB_ARTIFACT_PATTERN = new RegExp('\\b(?:__)?[a-z]{3}_[A-Z][a-z]{3,4}(?:__)?\\b', 'g');
+const NLLB_ARTIFACT_PATTERN = new RegExp(
+// Sentence-initial echoes come back capitalized ("Eng_Latn Produktkatalog").
+'\\b(?:__)?[A-Za-z][a-z]{2}_[A-Z][a-z]{3,4}(?:__)?\\b', 'g');
 /**
  * Collapse phrase-level stutter ("Il a Il a" -> "Il a"). NLLB occasionally
  * repeats a short fragment twice after language tokens are stripped. Only
@@ -11,14 +13,19 @@ const NLLB_ARTIFACT_PATTERN = new RegExp('\\b(?:__)?[a-z]{3}_[A-Z][a-z]{3,4}(?:_
  */
 function collapsePhraseStutter(text) {
     const words = text.split(/\s+/);
-    if (words.length >= 4 && words.length % 2 === 0) {
-        const half = words.length / 2;
-        const first = words.slice(0, half);
-        const second = words.slice(half);
-        if (first.length >= 2 &&
-            first.every((w, i) => w.toLowerCase() === second[i].toLowerCase())) {
-            return first.join(' ');
+    // The whole output is one phrase of >=2 words repeated 2+ times ("Il a Il a",
+    // "Product catalog Product catalog Product catalog").
+    for (let size = 2; size <= words.length / 2; size++) {
+        if (words.length % size !== 0)
+            continue;
+        const first = words.slice(0, size).map((w) => w.toLowerCase());
+        let repeated = true;
+        for (let i = size; i < words.length && repeated; i++) {
+            if (words[i].toLowerCase() !== first[i % size])
+                repeated = false;
         }
+        if (repeated)
+            return words.slice(0, size).join(' ');
     }
     return text;
 }
@@ -45,7 +52,14 @@ function sanitizeTranslation(text, options = {}) {
     // legitimate translated text.
     clean = clean.replace(/\u2047/g, '');
     clean = clean.replace(/  +/g, ' ').trim();
-    return collapsePhraseStutter(clean);
+    clean = collapsePhraseStutter(clean);
+    // A one-word source doubled in the output ("Product" → "Produkt Produkt").
+    if (options.source && !/\s/.test(options.source.trim())) {
+        const words = clean.split(/\s+/);
+        if (words.length > 1 && words.every((w) => w.toLowerCase() === words[0].toLowerCase()))
+            clean = words[0];
+    }
+    return clean;
 }
 function validateRawTokens(aiOutput, expectedCount) {
     for (let i = 0; i < expectedCount; i++) {

package/dist/utils/translator-load-balancer.js

@@ -27,7 +27,7 @@ class TranslatorLoadBalancer {
         this.config = { ...DEFAULT_CONFIG };
         this.initializeEndpoints();
         if (this.config.endpoints.length > 0) {
-            setTimeout(() => this.startHealthChecks(), 0);
+            setTimeout(() => this.startHealthChecks(), 0).unref?.();
         }
     }
     /**
@@ -214,6 +214,7 @@ class TranslatorLoadBalancer {
             try {
                 const controller = new AbortController();
                 timeout = setTimeout(() => controller.abort(), this.config.healthCheckTimeout);
+                timeout.unref?.();
                 const response = await fetch(`${endpoint.url}/health`, {
                     method: 'GET',
                     signal: controller.signal,
@@ -250,6 +251,9 @@ class TranslatorLoadBalancer {
         if (this.healthCheckInterval)
             return;
         this.healthCheckInterval = setInterval(() => this.healthCheck(), this.config.healthCheckInterval);
+        // Background monitoring must not keep the process alive: short-lived
+        // hosts (scripts, the local runner) would otherwise never exit.
+        this.healthCheckInterval.unref?.();
         // Initial health check
         this.healthCheck();
     }

package/dist/utils/untranslated.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Detects source text that came back from translation unchanged.
+ *
+ * Into a Latin-script language an unchanged short string can be a real
+ * translation ("Hotel", "Email"). Into a non-Latin-script language, English
+ * letters returned verbatim were not translated. Such values must be rejected
+ * when the translator returns them AND when a cache or TM lookup does: once
+ * stored, a bad value would otherwise be replayed on every run and never retried.
+ */
+/** Is the locale written in Latin script (where an unchanged word can be a real translation)? */
+export declare function isLatinScript(locale: string): boolean;
+/** Letters left once placeholders, tags and entities are removed. */
+export declare function hasWords(text: string | undefined): boolean;
+/** `translated` is the untouched source, into a language where that cannot be a translation. */
+export declare function isUntranslatedInto(source: string, translated: string, targetLocale: string): boolean;

package/dist/utils/untranslated.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Detects source text that came back from translation unchanged.
+ *
+ * Into a Latin-script language an unchanged short string can be a real
+ * translation ("Hotel", "Email"). Into a non-Latin-script language, English
+ * letters returned verbatim were not translated. Such values must be rejected
+ * when the translator returns them AND when a cache or TM lookup does: once
+ * stored, a bad value would otherwise be replayed on every run and never retried.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLatinScript = isLatinScript;
+exports.hasWords = hasWords;
+exports.isUntranslatedInto = isUntranslatedInto;
+/** Is the locale written in Latin script (where an unchanged word can be a real translation)? */
+function isLatinScript(locale) {
+    try {
+        return new Intl.Locale(locale).maximize().script === 'Latn';
+    }
+    catch {
+        return true;
+    }
+}
+/** Letters left once placeholders, tags and entities are removed. */
+function hasWords(text) {
+    if (!text)
+        return false;
+    const stripped = text.replace(/%\(\w+\)[-#0 +]*\d*(?:\.\d+)?[a-zA-Z]|%[sdif%]|\{[^{}]*\}|<[^>]*>|&[#\w]+;|\[\s*#\s*VAR_\d+\s*#\s*\]/gi, ' ');
+    return /\p{L}{2,}/u.test(stripped);
+}
+/** `translated` is the untouched source, into a language where that cannot be a translation. */
+function isUntranslatedInto(source, translated, targetLocale) {
+    return !isLatinScript(targetLocale) && translated.trim() === source.trim() && hasWords(source);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babelize/engine",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Babelize translation pipeline (extract, keygen, translate, inject). Infrastructure is injected through provider/store interfaces.",
   "keywords": [
     "babelize",
@@ -11,10 +11,6 @@
   ],
   "license": "Apache-2.0",
   "homepage": "https://babelize.co",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/babelize/babelize-dashboard.git"
-  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -36,7 +32,7 @@
     "@babel/parser": "^7.28.5",
     "@babel/traverse": "^7.28.5",
     "@babel/types": "^7.29.8",
-    "@babelize/types": "^0.1.1",
+    "@babelize/types": "^0.1.2",
     "@vue/compiler-dom": "^3.5",
     "@vue/compiler-sfc": "^3.5",
     "diff": "^8.0.4",

package/dist/injection/django/django-template-injector.d.ts

@@ -1,29 +0,0 @@
-import type { FileInjection } from '../../runtime/types';
-export interface DjangoInjectorOptions {
-    /** The masked HTML content after standard HTML injection has run */
-    maskedContent: string;
-    /** The restore function from dtl-mask to undo masking */
-    restore: (masked: string) => string;
-    /** Path of the file being processed */
-    filePath: string;
-    /** Mapping from extraction ID to translation key */
-    keyMapping: Map<string, string>;
-    /** Original unmodified source content for comparison */
-    sourceContent: string;
-}
-/**
- * Convert data-i18n attributes to Django {% trans %} tags.
- *
- * For pure text elements:
- *   <p data-i18n="hello">Hello</p>  →  <p>{% trans "hello" %}</p>
- *
- * For mixed content (elements with both text and child elements):
- *   <p data-i18n="hello">Hello <em>world</em></p>  →
- *   <p>{% blocktrans %}Hello <em>world</em>{% endblocktrans %}</p>
- *   (blocktrans wraps the raw inner HTML)
- *
- * For attribute translations:
- *   <input data-i18n-placeholder="ph_key" placeholder="Search...">  →
- *   <input placeholder="{% trans "ph_key" %}">
- */
-export declare function injectDjangoTemplates(options: DjangoInjectorOptions): Promise<FileInjection>;

package/dist/injection/django/django-template-injector.js

@@ -1,216 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.injectDjangoTemplates = injectDjangoTemplates;
-function asElement(node) {
-    return node.nodeType === 1 ? node : null;
-}
-/**
- * Convert data-i18n attributes to Django {% trans %} tags.
- *
- * For pure text elements:
- *   <p data-i18n="hello">Hello</p>  →  <p>{% trans "hello" %}</p>
- *
- * For mixed content (elements with both text and child elements):
- *   <p data-i18n="hello">Hello <em>world</em></p>  →
- *   <p>{% blocktrans %}Hello <em>world</em>{% endblocktrans %}</p>
- *   (blocktrans wraps the raw inner HTML)
- *
- * For attribute translations:
- *   <input data-i18n-placeholder="ph_key" placeholder="Search...">  →
- *   <input placeholder="{% trans "ph_key" %}">
- */
-async function injectDjangoTemplates(options) {
-    const { maskedContent, restore, filePath, keyMapping } = options;
-    const { parse } = await Promise.resolve().then(() => __importStar(require('node-html-parser')));
-    const injections = [];
-    const importAdded = false;
-    const hookAdded = false;
-    // Parse the masked + injected HTML
-    const root = parse(maskedContent, {
-        comment: false,
-        blockTextElements: { script: true, style: true, noscript: true, pre: true },
-    });
-    const htmlEl = root.querySelector('html');
-    if (!htmlEl) {
-        return {
-            file: filePath,
-            originalContent: options.sourceContent,
-            modifiedContent: restore(maskedContent),
-            injections,
-            importAdded,
-            hookAdded,
-        };
-    }
-    walkAndInject(htmlEl, filePath, options.sourceContent, keyMapping, injections);
-    let modifiedContent = root.toString();
-    // Remove the i18n.js script tag injected by HTML pipeline — Django uses {% trans %} not client JS
-    modifiedContent = modifiedContent.replace(/<script[^>]*src\s*=\s*["']i18n\.js["'][^>]*>\s*<\/script>\s*\n?/g, '');
-    // Add {% load i18n %} after any {% extends %} tag (DTL requires extends first)
-    modifiedContent = ensureI18nLoad(modifiedContent);
-    // Restore template tags
-    modifiedContent = restore(modifiedContent);
-    return {
-        file: filePath,
-        originalContent: options.sourceContent,
-        modifiedContent,
-        injections,
-        importAdded,
-        hookAdded,
-    };
-}
-function walkAndInject(node, filePath, sourceContent, keyMapping, injections) {
-    const element = asElement(node);
-    if (!element)
-        return;
-    const rawTagName = element.rawTagName?.toLowerCase();
-    if (!rawTagName)
-        return;
-    if (['script', 'style', 'noscript', 'code', 'pre', 'svg'].includes(rawTagName))
-        return;
-    // Handle data-i18n on this element
-    const i18nKey = element.getAttribute('data-i18n');
-    if (i18nKey) {
-        convertDataI18nToTransTag(element, i18nKey, filePath, sourceContent, injections);
-    }
-    // Handle data-i18n-{attr} for attribute translations
-    convertDataI18nAttrTags(element, filePath, sourceContent, injections);
-    // Recurse into children
-    for (const child of node.childNodes || []) {
-        if (child.nodeType === 1) {
-            walkAndInject(child, filePath, sourceContent, keyMapping, injections);
-        }
-    }
-}
-function convertDataI18nToTransTag(element, key, filePath, sourceContent, injections) {
-    const line = element.range
-        ? (sourceContent.slice(0, element.range[0]).match(/\n/g) || []).length + 1
-        : 0;
-    // Remove the data-i18n attribute
-    element.removeAttribute('data-i18n');
-    const children = element.childNodes || [];
-    const hasElementChildren = children.some((c) => c.nodeType === 1);
-    if (hasElementChildren) {
-        // Mixed content: use blocktrans / endblocktrans
-        // Preserve inner HTML and wrap with blocktrans
-        const innerHtml = children
-            .map((c) => (c.nodeType === 1 ? c.toString() : c.toString()))
-            .join('');
-        // Replace children with raw blocktrans content
-        element.childNodes = [];
-        // node-html-parser doesn't support raw HTML children directly,
-        // so we set innerHTML which parses and inserts
-        element.innerHTML = `{% blocktrans %}${innerHtml}{% endblocktrans %}`;
-        injections.push({
-            file: filePath,
-            line,
-            column: 0,
-            original: innerHtml.trim(),
-            replacement: `{% blocktrans %}${innerHtml}{% endblocktrans %}`,
-            key,
-            confidence: 100,
-        });
-    }
-    else {
-        // Pure text content: use {% trans "key" %}
-        const text = children
-            .map((c) => c.toString())
-            .join('')
-            .trim();
-        element.childNodes = [];
-        element.innerHTML = `{% trans "${key}" %}`;
-        injections.push({
-            file: filePath,
-            line,
-            column: 0,
-            original: text,
-            replacement: `{% trans "${key}" %}`,
-            key,
-            confidence: 100,
-        });
-    }
-}
-function convertDataI18nAttrTags(element, filePath, sourceContent, injections) {
-    const i18nAttrs = [
-        'data-i18n-title',
-        'data-i18n-placeholder',
-        'data-i18n-alt',
-        'data-i18n-aria-label',
-        'data-i18n-aria-description',
-    ];
-    for (const dataAttr of i18nAttrs) {
-        const key = element.getAttribute(dataAttr);
-        if (!key)
-            continue;
-        // Extract the target attribute name: "data-i18n-placeholder" → "placeholder"
-        const attrSuffix = dataAttr.replace('data-i18n-', '');
-        const originalValue = element.getAttribute(attrSuffix) || '';
-        element.removeAttribute(dataAttr);
-        const line = element.range
-            ? (sourceContent.slice(0, element.range[0]).match(/\n/g) || []).length + 1
-            : 0;
-        // Replace attribute value with {% trans "key" %}
-        element.setAttribute(attrSuffix, `{% trans "${key}" %}`);
-        injections.push({
-            file: filePath,
-            line,
-            column: 0,
-            original: originalValue,
-            replacement: `{% trans "${key}" %}`,
-            key,
-            confidence: 100,
-        });
-    }
-}
-/**
- * Ensure {% load i18n %} is present in the template.
- * DTL requires it after any {% extends %} tag (at the top of the template
- * but after extends).
- */
-function ensureI18nLoad(content) {
-    if (/{%\s*load\s+i18n\s*%}/i.test(content)) {
-        return content;
-    }
-    // If there's an extends tag, insert load right after the last extends
-    const extendsMatch = content.match(/({%\s*extends\s+.*?%\})\s*\n?/s);
-    if (extendsMatch) {
-        const lastExtendsEnd = content.indexOf(extendsMatch[0]) + extendsMatch[0].length;
-        return (content.slice(0, lastExtendsEnd) +
-            '\n{% load i18n %}\n' +
-            content.slice(lastExtendsEnd));
-    }
-    // No extends: insert at the very top
-    return '{% load i18n %}\n' + content;
-}

package/dist/modules/glossary/glossary.d.ts

@@ -1,9 +0,0 @@
-import type { AlwaysTranslateAsEntry } from './types';
-/**
- * Post-translation processor for "always translate as" glossary entries.
- *
- * After the HF model returns a translation, this function scans the result
- * for each always-translate-as term and replaces it with the fixed
- * translation for the target locale.
- */
-export declare function applyAlwaysTranslateAs(translatedText: string, entries: AlwaysTranslateAsEntry[], targetLocale: string): string;

package/dist/modules/glossary/glossary.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyAlwaysTranslateAs = applyAlwaysTranslateAs;
-const string_utils_1 = require("../../utils/string-utils");
-/**
- * Post-translation processor for "always translate as" glossary entries.
- *
- * After the HF model returns a translation, this function scans the result
- * for each always-translate-as term and replaces it with the fixed
- * translation for the target locale.
- */
-function applyAlwaysTranslateAs(translatedText, entries, targetLocale) {
-    if (!entries.length || !translatedText)
-        return translatedText;
-    let result = translatedText;
-    // Sort longest-first to avoid partial replacements
-    const sorted = [...entries].sort((a, b) => b.term.length - a.term.length);
-    for (const entry of sorted) {
-        const fixedTranslation = entry.translations[targetLocale];
-        if (!fixedTranslation)
-            continue;
-        // Replace all occurrences of the term (case-insensitive, word-boundary)
-        const regex = new RegExp(`\\b${(0, string_utils_1.escapeRegex)(entry.term)}\\b`, 'gi');
-        result = result.replace(regex, fixedTranslation);
-    }
-    return result;
-}

package/dist/modules/glossary/masker.d.ts

@@ -1,23 +0,0 @@
-export interface MaskedString {
-    masked: string;
-    terms: MaskedTerm[];
-}
-export interface MaskedTerm {
-    term: string;
-    matches: string[];
-}
-/**
- * Replace never-translate terms with placeholders (__TERM_0__, __TERM_1__, ...)
- * so NLLB does not attempt to translate them.
- *
- * Rules:
- * - Whole-word matching only (word-boundary anchors)
- * - Case-insensitive matching
- * - Longest terms matched first to prevent partial overlaps
- * - All occurrences of each term are masked
- */
-export declare function applyGlossaryMask(text: string, terms: string[]): MaskedString;
-/**
- * Restore __TERM_N__ placeholders back to their original terms.
- */
-export declare function restoreGlossaryMask(text: string, terms: MaskedTerm[]): string;

package/dist/modules/glossary/masker.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyGlossaryMask = applyGlossaryMask;
-exports.restoreGlossaryMask = restoreGlossaryMask;
-const string_utils_1 = require("../../utils/string-utils");
-/**
- * Replace never-translate terms with placeholders (__TERM_0__, __TERM_1__, ...)
- * so NLLB does not attempt to translate them.
- *
- * Rules:
- * - Whole-word matching only (word-boundary anchors)
- * - Case-insensitive matching
- * - Longest terms matched first to prevent partial overlaps
- * - All occurrences of each term are masked
- */
-function applyGlossaryMask(text, terms) {
-    if (!terms.length || !text) {
-        return { masked: text, terms: [] };
-    }
-    // Sort terms longest-first to avoid smaller terms eating larger ones.
-    const sorted = [...terms].sort((a, b) => b.length - a.length);
-    let masked = text;
-    const usedTerms = [];
-    sorted.forEach((term) => {
-        let placeholderIndex = usedTerms.findIndex((entry) => entry.term === term);
-        if (placeholderIndex === -1) {
-            placeholderIndex = usedTerms.push({ term, matches: [] }) - 1;
-        }
-        const placeholder = `__TERM_${placeholderIndex}__`;
-        // Word-boundary + case-insensitive matching
-        const regex = new RegExp(`(?:^|(?<=\\W))${(0, string_utils_1.escapeRegex)(term)}(?:$|(?=\\W))`, 'gi');
-        masked = masked.replace(regex, (matched) => {
-            usedTerms[placeholderIndex].matches.push(matched);
-            return placeholder;
-        });
-    });
-    return { masked, terms: usedTerms };
-}
-/**
- * Restore __TERM_N__ placeholders back to their original terms.
- */
-function restoreGlossaryMask(text, terms) {
-    if (!terms.length || !text)
-        return text;
-    let restored = text;
-    terms.forEach((maskedTerm, index) => {
-        const placeholderRegex = new RegExp(`__TERM_${index}__`, 'g');
-        let replacementIndex = 0;
-        restored = restored.replace(placeholderRegex, () => {
-            const replacement = maskedTerm.matches[replacementIndex] ?? maskedTerm.term;
-            replacementIndex++;
-            return replacement;
-        });
-    });
-    return restored;
-}