@lokascript/i18n 2.11.1 → 3.1.0

package/dist/index.cjs

@@ -4525,7 +4525,11 @@ var bengaliDictionary = {
     random: "\u098F\u09B2\u09CB\u09AE\u09C7\u09B2\u09CB",
     length: "\u09A6\u09C8\u09B0\u09CD\u0998\u09CD\u09AF",
     index: "\u09B8\u09C2\u099A\u0995",
-    empty: "\u0996\u09BE\u09B2\u09BF-\u0995\u09B0\u09C1\u09A8",
+    // The EXPRESSION `empty` is the state predicate (`if my value is empty`),
+    // not the command: `খালি-করুন` is the imperative "empty it!" and belongs to
+    // the `empty` COMMAND, which keeps it. Kept in step with the semantic
+    // lexicon by `lexicon-parity.test.ts`.
+    empty: "\u0996\u09BE\u09B2\u09BF",
     "starts with": "\u09A6\u09BF\u09AF\u09BC\u09C7_\u09B6\u09C1\u09B0\u09C1",
     "ends with": "\u09A6\u09BF\u09AF\u09BC\u09C7_\u09B6\u09C7\u09B7",
     "ignoring case": "\u0995\u09C7\u09B8_\u0989\u09AA\u09C7\u0995\u09CD\u09B7\u09BE",
@@ -7437,25 +7441,25 @@ var HyperscriptTranslator = class {
   }
   translateWithDetails(text, options) {
     const fromLocale = options.from || this.detectLanguage(text);
-    const toLocale2 = options.to;
-    if (fromLocale === toLocale2) {
+    const toLocale = options.to;
+    if (fromLocale === toLocale) {
       return {
         translated: text,
         original: text,
         tokens: [],
-        locale: { from: fromLocale, to: toLocale2 }
+        locale: { from: fromLocale, to: toLocale }
       };
     }
     const fromDict = this.getDictionary(fromLocale);
-    const toDict = this.getDictionary(toLocale2);
+    const toDict = this.getDictionary(toLocale);
     if (!fromDict || !toDict) {
-      throw new Error(`Missing dictionary for locale: ${!fromDict ? fromLocale : toLocale2}`);
+      throw new Error(`Missing dictionary for locale: ${!fromDict ? fromLocale : toLocale}`);
     }
     const tokens = tokenize(text, fromLocale);
-    const translatedTokens = this.translateTokens(tokens, fromLocale, toLocale2);
+    const translatedTokens = this.translateTokens(tokens, fromLocale, toLocale);
     const translated = this.reconstructText(translatedTokens);
     if (options.validate && toDict) {
-      const validation = validate(toDict, toLocale2);
+      const validation = validate(toDict, toLocale);
       if (!validation.valid) {
         console.warn("Translation validation warnings:", validation.warnings);
       }
@@ -7463,7 +7467,7 @@ var HyperscriptTranslator = class {
     const result = {
       translated,
       tokens: translatedTokens,
-      locale: { from: fromLocale, to: toLocale2 },
+      locale: { from: fromLocale, to: toLocale },
       warnings: []
     };
     if (options.preserveOriginal) {
@@ -7471,9 +7475,9 @@ var HyperscriptTranslator = class {
     }
     return result;
   }
-  translateTokens(tokens, fromLocale, toLocale2) {
+  translateTokens(tokens, fromLocale, toLocale) {
     const fromDict = this.getDictionary(fromLocale);
-    const toDict = this.getDictionary(toLocale2);
+    const toDict = this.getDictionary(toLocale);
     const reverseFromDict = this.getReverseDictionary(fromLocale);
     const emptyDict = {
       commands: {},
@@ -7488,7 +7492,7 @@ var HyperscriptTranslator = class {
     return tokens.map((token) => {
       let translated = token.value;
       if (this.isTranslatableToken(token)) {
-        if (fromLocale !== "en" && toLocale2 !== "en") {
+        if (fromLocale !== "en" && toLocale !== "en") {
           const english = this.findTranslation(token.value, fromDict || emptyDict, reverseFromDict);
           if (english) {
             translated = this.findTranslation(english, toDict || emptyDict, /* @__PURE__ */ new Map()) || token.value;
@@ -7619,39 +7623,6 @@ var HyperscriptTranslator = class {
 new HyperscriptTranslator({ locale: "en" });
 
 // src/constants.ts
-var ENGLISH_MODIFIER_ROLES = {
-  to: "destination",
-  into: "destination",
-  from: "source",
-  with: "style",
-  by: "quantity",
-  as: "method",
-  on: "event",
-  over: "duration",
-  for: "duration"
-};
-var COMMAND_PRIMARY_ROLES = {
-  set: "destination",
-  on: "event",
-  trigger: "event",
-  send: "event",
-  wait: "duration",
-  fetch: "source",
-  get: "source",
-  if: "condition",
-  unless: "condition",
-  while: "condition",
-  repeat: "loopType",
-  go: "destination",
-  scroll: "destination",
-  tell: "destination",
-  default: "destination",
-  swap: "destination",
-  // morph deliberately absent: its schema primaryRole is `patient` (the
-  // element being morphed — aligned with the transformer's patient marking
-  // in the session-9 role-layout swap), and patient is the default.
-  bind: "destination"
-};
 var ENGLISH_MODIFIERS = /* @__PURE__ */ new Set([
   "to",
   "from",
@@ -7884,69 +7855,6 @@ var ENGLISH_EXPRESSION_KEYWORDS = /* @__PURE__ */ new Set([
   "starts with",
   "ends with"
 ]);
-var CONDITIONAL_KEYWORDS = /* @__PURE__ */ new Set([
-  // English
-  "if",
-  "unless",
-  "when",
-  "where",
-  // Japanese
-  "\u3082\u3057",
-  "\u6642\u306B",
-  "\u3068\u304D\u306B",
-  "\u3069\u3053\u3067",
-  // Chinese
-  "\u5982\u679C",
-  "\u5F53",
-  // Arabic
-  "\u0625\u0630\u0627",
-  "\u0639\u0646\u062F\u0645\u0627",
-  "\u062D\u064A\u062B",
-  // Spanish
-  "si",
-  "cuando",
-  "donde",
-  // German
-  "wenn",
-  "wann",
-  "wo",
-  // French
-  "quand",
-  "lorsque",
-  "o\xF9",
-  // Portuguese
-  "quando",
-  "onde",
-  // Turkish
-  "e\u011Fer",
-  "zaman",
-  "nerede",
-  // Indonesian
-  "ketika",
-  "saat",
-  "dimana",
-  // Korean
-  "\uB54C",
-  "\uC5B4\uB514\uC11C",
-  // Quechua
-  "maypi",
-  // Swahili
-  "wakati",
-  "wapi"
-]);
-var THEN_KEYWORDS = /* @__PURE__ */ new Set([
-  "then",
-  "\u305D\u308C\u304B\u3089",
-  "\u90A3\u4E48",
-  "\u062B\u0645",
-  "entonces",
-  "alors",
-  "dann",
-  "sonra",
-  "lalu",
-  "chayqa",
-  "kisha"
-]);
 
 // src/parser/create-provider.ts
 function createKeywordProvider(dictionary, locale, options = {}) {
@@ -14179,1770 +14087,6 @@ async function createEnhancedI18n(locale, options) {
 }
 var enhancedI18nImplementation = new TypedI18nContextImplementation();
 
-// src/grammar/direct-mappings.ts
-function reverseMapping(mapping) {
-  const reversedWords = {};
-  for (const [source, target] of Object.entries(mapping.words)) {
-    reversedWords[target] = source;
-  }
-  const reversedCategories = {};
-  if (mapping.categories) {
-    for (const [category, words] of Object.entries(mapping.categories)) {
-      reversedCategories[category] = {};
-      for (const [source, target] of Object.entries(words)) {
-        reversedCategories[category][target] = source;
-      }
-    }
-  }
-  const result = {
-    source: mapping.target,
-    target: mapping.source,
-    words: reversedWords
-  };
-  if (Object.keys(reversedCategories).length > 0) {
-    result.categories = reversedCategories;
-  }
-  return result;
-}
-function buildMappingFromDictionaries(sourceDict, targetDict, sourceCode, targetCode) {
-  const words = {};
-  const categories = {};
-  for (const category of [
-    "commands",
-    "modifiers",
-    "events",
-    "logical",
-    "temporal",
-    "values",
-    "attributes"
-  ]) {
-    const sourceCategory = sourceDict[category];
-    const targetCategory = targetDict[category];
-    if (sourceCategory && targetCategory) {
-      categories[category] = {};
-      for (const [englishKey, sourceWord] of Object.entries(sourceCategory)) {
-        const targetWord = targetCategory[englishKey];
-        if (targetWord && sourceWord !== targetWord) {
-          words[sourceWord] = targetWord;
-          categories[category][sourceWord] = targetWord;
-        }
-      }
-    }
-  }
-  return {
-    source: sourceCode,
-    target: targetCode,
-    words,
-    categories
-  };
-}
-var jaZhMapping = buildMappingFromDictionaries(ja, zh, "ja", "zh");
-var zhJaMapping = reverseMapping(jaZhMapping);
-var koJaMapping = buildMappingFromDictionaries(ko, ja, "ko", "ja");
-var jaKoMapping = reverseMapping(koJaMapping);
-var esPtMapping = {
-  source: "es",
-  target: "pt",
-  words: {
-    // Commands - many are cognates
-    en: "em",
-    // on (event)
-    decir: "dizer",
-    // tell
-    disparar: "disparar",
-    // trigger
-    enviar: "enviar",
-    // send
-    tomar: "pegar",
-    // take
-    poner: "colocar",
-    // put
-    establecer: "definir",
-    // set
-    obtener: "obter",
-    // get
-    agregar: "adicionar",
-    // add
-    quitar: "remover",
-    // remove
-    alternar: "alternar",
-    // toggle
-    ocultar: "esconder",
-    // hide
-    mostrar: "mostrar",
-    // show
-    si: "se",
-    // if
-    menos: "a menos",
-    // unless
-    repetir: "repetir",
-    // repeat
-    para: "para",
-    // for
-    mientras: "enquanto",
-    // while
-    hasta: "at\xE9",
-    // until
-    continuar: "continuar",
-    // continue
-    romper: "parar",
-    // break
-    detener: "parar",
-    // halt
-    esperar: "esperar",
-    // wait
-    buscar: "buscar",
-    // fetch
-    llamar: "chamar",
-    // call
-    retornar: "retornar",
-    // return
-    hacer: "fazer",
-    // make
-    registrar: "registrar",
-    // log
-    lanzar: "lan\xE7ar",
-    // throw
-    atrapar: "capturar",
-    // catch
-    medir: "medir",
-    // measure
-    transici\u00F3n: "transi\xE7\xE3o",
-    // transition
-    incrementar: "incrementar",
-    // increment
-    decrementar: "decrementar",
-    // decrement
-    predeterminar: "padr\xE3o",
-    // default
-    ir: "ir",
-    // go
-    copiar: "copiar",
-    // copy
-    escoger: "escolher",
-    // pick
-    intercambiar: "trocar",
-    // swap
-    transformar: "transformar",
-    // morph
-    a\u00F1adir: "anexar",
-    // append
-    salir: "sair",
-    // exit
-    // Modifiers
-    a: "para",
-    // to
-    de: "de",
-    // from
-    dentro: "em",
-    // into
-    con: "com",
-    // with
-    como: "como",
-    // as
-    por: "por",
-    // by
-    // Events
-    clic: "clique",
-    // click
-    cambio: "mudan\xE7a",
-    // change
-    entrada: "entrada",
-    // input
-    env\u00EDo: "envio",
-    // submit
-    carga: "carregar",
-    // load
-    enfoque: "foco",
-    // focus
-    desenfoque: "desfoque",
-    // blur
-    // Logical
-    verdadero: "verdadeiro",
-    // true
-    falso: "falso",
-    // false
-    y: "e",
-    // and
-    o: "ou",
-    // or
-    no: "n\xE3o",
-    // not
-    es: "\xE9",
-    // is
-    // Temporal
-    segundos: "segundos",
-    // seconds
-    milisegundos: "milissegundos",
-    // milliseconds
-    // Values
-    nulo: "nulo",
-    // null
-    indefinido: "indefinido",
-    // undefined
-    vac\u00EDo: "vazio"
-    // empty
-  },
-  categories: {
-    commands: {
-      en: "em",
-      decir: "dizer",
-      tomar: "pegar",
-      poner: "colocar",
-      establecer: "definir",
-      obtener: "obter",
-      agregar: "adicionar",
-      quitar: "remover",
-      ocultar: "esconder",
-      si: "se",
-      mientras: "enquanto",
-      hasta: "at\xE9",
-      romper: "parar",
-      detener: "parar",
-      llamar: "chamar",
-      hacer: "fazer",
-      lanzar: "lan\xE7ar",
-      atrapar: "capturar",
-      escoger: "escolher",
-      intercambiar: "trocar",
-      a\u00F1adir: "anexar",
-      salir: "sair"
-    },
-    events: {
-      clic: "clique",
-      cambio: "mudan\xE7a",
-      carga: "carregar",
-      enfoque: "foco",
-      desenfoque: "desfoque"
-    },
-    logical: {
-      verdadero: "verdadeiro",
-      y: "e",
-      o: "ou",
-      no: "n\xE3o",
-      es: "\xE9"
-    }
-  }
-};
-var ptEsMapping = reverseMapping(esPtMapping);
-var directMappings = /* @__PURE__ */ new Map([
-  // Japanese ↔ Chinese
-  ["ja->zh", jaZhMapping],
-  ["zh->ja", zhJaMapping],
-  // Korean ↔ Japanese
-  ["ko->ja", koJaMapping],
-  ["ja->ko", jaKoMapping],
-  // Spanish ↔ Portuguese
-  ["es->pt", esPtMapping],
-  ["pt->es", ptEsMapping]
-]);
-function hasDirectMapping(source, target) {
-  return directMappings.has(`${source}->${target}`);
-}
-function getDirectMapping(source, target) {
-  return directMappings.get(`${source}->${target}`);
-}
-
-// src/grammar/transformer.ts
-function getCommandKeywordsForLocale(locale) {
-  const keywords = new Set(ENGLISH_COMMANDS);
-  const dict = dictionaries[locale];
-  if (dict?.commands) {
-    Object.values(dict.commands).forEach((cmd) => {
-      if (typeof cmd === "string") {
-        keywords.add(cmd.toLowerCase());
-      }
-    });
-  }
-  return keywords;
-}
-var EN_COPULAS = ["is", "are", "was", "were", "am", "be"];
-function getCopulasForLocale(locale) {
-  const copulas = new Set(EN_COPULAS);
-  if (locale !== "en") {
-    for (const form of EN_COPULAS) {
-      copulas.add(translateWord(form, "en", locale).toLowerCase());
-    }
-  }
-  return copulas;
-}
-function isPredicateAdjectivePosition(tokens, i, copulas) {
-  const prev = tokens[i - 1]?.toLowerCase();
-  return !!prev && copulas.has(prev);
-}
-function getForLoopWordsForLocale(locale) {
-  const forWords = /* @__PURE__ */ new Set(["for"]);
-  const inWords = /* @__PURE__ */ new Set(["in"]);
-  if (locale !== "en") {
-    forWords.add(translateWord("for", "en", locale).toLowerCase());
-    inWords.add(translateWord("in", "en", locale).toLowerCase());
-  }
-  return { forWords, inWords };
-}
-function isLoopHeadFor(tokens, i, inWords, commandKeywords) {
-  for (let j = i + 1; j < tokens.length; j++) {
-    const lt = tokens[j].toLowerCase();
-    if (inWords.has(lt)) return true;
-    if (commandKeywords.has(lt)) return false;
-  }
-  return false;
-}
-function repairHebrewFrontedAccusative(text) {
-  const ACC = "\u05D0\u05EA";
-  const verbs = getCommandKeywordsForLocale("he");
-  const tokens = text.split(/\s+/);
-  let changed = false;
-  for (let i = 0; i + 1 < tokens.length; i++) {
-    if (tokens[i] === ACC && verbs.has(tokens[i + 1].toLowerCase())) {
-      [tokens[i], tokens[i + 1]] = [tokens[i + 1], tokens[i]];
-      changed = true;
-      i++;
-    }
-  }
-  return changed ? tokens.join(" ") : text;
-}
-function extractBlockStructure(input, sourceLocale) {
-  const tokens = input.split(/\s+/);
-  const head = tokens[0]?.toLowerCase();
-  if (!head || !BLOCK_HEAD_KEYWORDS.has(head)) return null;
-  let depth = 1;
-  let endIdx = -1;
-  for (let i = 1; i < tokens.length; i++) {
-    const t = tokens[i].toLowerCase();
-    if (BLOCK_HEAD_KEYWORDS.has(t)) depth++;
-    else if (t === "end") {
-      depth--;
-      if (depth === 0) {
-        endIdx = i;
-        break;
-      }
-    }
-  }
-  if (endIdx !== -1 && endIdx !== tokens.length - 1) return null;
-  const inner = endIdx !== -1 ? tokens.slice(1, endIdx) : tokens.slice(1);
-  const base = { headKeyword: tokens[0], body: "" };
-  if (endIdx !== -1) base.tailKeyword = tokens[endIdx];
-  if (head === "live") {
-    return { ...base, body: inner.join(" ") };
-  }
-  if (head === "when") {
-    const idx = inner.findIndex((t) => t.toLowerCase() === "changes");
-    if (idx >= 0) {
-      return {
-        ...base,
-        prefixExpr: inner.slice(0, idx).join(" "),
-        connector: inner[idx],
-        body: inner.slice(idx + 1).join(" ")
-      };
-    }
-    return null;
-  }
-  const commands = getCommandKeywordsForLocale(sourceLocale);
-  const copulas = getCopulasForLocale(sourceLocale);
-  let bodyStart = -1;
-  for (let i = 0; i < inner.length; i++) {
-    if (commands.has(inner[i].toLowerCase()) && !isPredicateAdjectivePosition(inner, i, copulas)) {
-      bodyStart = i;
-      break;
-    }
-  }
-  if (bodyStart <= 0) return null;
-  return {
-    ...base,
-    prefixExpr: inner.slice(0, bodyStart).join(" "),
-    body: inner.slice(bodyStart).join(" ")
-  };
-}
-function splitCompoundStatement(input, sourceLocale) {
-  const lines = input.split(/\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-  const parts = [];
-  for (const line of lines) {
-    const lineParts = splitOnThen(line, sourceLocale);
-    for (const part of lineParts) {
-      const commandParts = splitOnCommandBoundaries(part, sourceLocale);
-      parts.push(...commandParts);
-    }
-  }
-  return parts;
-}
-function splitCompoundStatementWithMetadata(input, sourceLocale) {
-  const rawLines = input.split("\n");
-  const lineMetadata = [];
-  const parts = [];
-  const partToLineIndex = [];
-  for (let lineIndex = 0; lineIndex < rawLines.length; lineIndex++) {
-    const rawLine = rawLines[lineIndex];
-    const indentMatch = rawLine.match(/^(\s*)/);
-    const originalIndent = indentMatch ? indentMatch[1] : "";
-    const trimmed = rawLine.trim();
-    lineMetadata.push({
-      content: trimmed,
-      originalIndent,
-      isBlank: trimmed.length === 0
-    });
-    if (trimmed.length > 0) {
-      const lineParts = splitOnThen(trimmed, sourceLocale);
-      for (const part of lineParts) {
-        const commandParts = splitOnCommandBoundaries(part, sourceLocale);
-        for (const cmdPart of commandParts) {
-          parts.push(cmdPart);
-          partToLineIndex.push(lineIndex);
-        }
-      }
-    }
-  }
-  return { parts, lineMetadata, partToLineIndex };
-}
-function normalizeIndentation(lineMetadata) {
-  const indentedLines = lineMetadata.filter((m) => !m.isBlank && m.originalIndent.length > 0);
-  if (indentedLines.length === 0) {
-    return lineMetadata.map(() => "");
-  }
-  const indentLengths = indentedLines.map((m) => {
-    const normalized = m.originalIndent.replace(/\t/g, "    ");
-    return normalized.length;
-  });
-  const minIndent = Math.min(...indentLengths);
-  const baseUnit = minIndent > 0 ? minIndent : 4;
-  return lineMetadata.map((meta) => {
-    if (meta.isBlank) {
-      return "";
-    }
-    if (meta.originalIndent.length === 0) {
-      return "";
-    }
-    const normalized = meta.originalIndent.replace(/\t/g, "    ");
-    const level = Math.round(normalized.length / baseUnit);
-    return "    ".repeat(level);
-  });
-}
-function reconstructWithLineStructure(transformedParts, lineMetadata, partToLineIndex, targetThen) {
-  const nonBlankCount = lineMetadata.filter((m) => !m.isBlank).length;
-  if (nonBlankCount <= 1 && transformedParts.length <= 1) {
-    const normalizedIndents2 = normalizeIndentation(lineMetadata);
-    const result2 = [];
-    for (let i = 0; i < lineMetadata.length; i++) {
-      if (lineMetadata[i].isBlank) {
-        result2.push("");
-      } else if (transformedParts.length > 0) {
-        result2.push(normalizedIndents2[i] + transformedParts[0]);
-      }
-    }
-    return result2.join("\n");
-  }
-  const normalizedIndents = normalizeIndentation(lineMetadata);
-  const partsPerLine = /* @__PURE__ */ new Map();
-  for (let i = 0; i < transformedParts.length; i++) {
-    const lineIdx = partToLineIndex[i];
-    if (!partsPerLine.has(lineIdx)) {
-      partsPerLine.set(lineIdx, []);
-    }
-    partsPerLine.get(lineIdx).push(transformedParts[i]);
-  }
-  const result = [];
-  for (let i = 0; i < lineMetadata.length; i++) {
-    const meta = lineMetadata[i];
-    const indent = normalizedIndents[i];
-    if (meta.isBlank) {
-      result.push("");
-    } else {
-      const lineParts = partsPerLine.get(i) || [];
-      if (lineParts.length > 0) {
-        const lineContent = lineParts.join(` ${targetThen} `);
-        result.push(indent + lineContent);
-      }
-    }
-  }
-  return result.join("\n");
-}
-var BOUNDARY_MODIFIERS = /* @__PURE__ */ new Set([
-  "to",
-  "into",
-  "from",
-  "with",
-  "by",
-  "as",
-  "at",
-  "in",
-  "on",
-  "of",
-  "over"
-]);
-var boundaryModifiersCache = /* @__PURE__ */ new Map();
-function getBoundaryModifiersForLocale(locale) {
-  const cached = boundaryModifiersCache.get(locale);
-  if (cached) return cached;
-  const modifiers = new Set(BOUNDARY_MODIFIERS);
-  const profile = getProfile(locale);
-  profile?.markers.forEach((marker) => {
-    const form = marker.form.replace(/^-|-$/g, "").toLowerCase();
-    if (form) modifiers.add(form);
-    marker.alternatives?.forEach((alt) => {
-      const altForm = alt.replace(/^-|-$/g, "").toLowerCase();
-      if (altForm) modifiers.add(altForm);
-    });
-  });
-  boundaryModifiersCache.set(locale, modifiers);
-  return modifiers;
-}
-var ON_TARGET_COMMANDS = /* @__PURE__ */ new Set(["toggle", "add", "remove", "trigger", "send"]);
-function commandVerbOf(tokens, commandKeywords) {
-  for (const token of tokens) {
-    const lt = token.toLowerCase();
-    if (commandKeywords.has(lt) && !BOUNDARY_MODIFIERS.has(lt) && !EVENT_KEYWORDS.has(lt)) {
-      return lt;
-    }
-  }
-  return null;
-}
-var BLOCK_HEAD_KEYWORDS = /* @__PURE__ */ new Set(["live", "when", "unless"]);
-var BLOCK_BODY_KEYWORDS = /* @__PURE__ */ new Set(["if", "repeat", "unless", "while", "for"]);
-var UNLESS_GUARD_OBJECT_MARKING_LOCALES = /* @__PURE__ */ new Set(["he", "zh"]);
-function splitOnCommandBoundaries(input, sourceLocale) {
-  const commandKeywords = getCommandKeywordsForLocale(sourceLocale);
-  const boundaryModifiers = getBoundaryModifiersForLocale(sourceLocale);
-  const { forWords, inWords } = getForLoopWordsForLocale(sourceLocale);
-  const tokens = input.split(/\s+/);
-  if (tokens.length === 0) return [input];
-  const parts = [];
-  let currentPart = [];
-  const firstTokenLower = tokens[0]?.toLowerCase();
-  const isEventHandler = EVENT_KEYWORDS.has(firstTokenLower);
-  let seenFirstCommand = !isEventHandler;
-  let blockDepth = 0;
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    const lowerToken = token.toLowerCase();
-    if (BLOCK_HEAD_KEYWORDS.has(lowerToken)) {
-      blockDepth++;
-    } else if (lowerToken === "end" && blockDepth > 0) {
-      blockDepth--;
-    }
-    if (commandKeywords.has(lowerToken) && currentPart.length > 0) {
-      const prevToken = currentPart[currentPart.length - 1];
-      const prevLower = prevToken.toLowerCase();
-      if (!seenFirstCommand) {
-        seenFirstCommand = true;
-        currentPart.push(token);
-        continue;
-      }
-      if (blockDepth > 0) {
-        currentPart.push(token);
-        continue;
-      }
-      if (forWords.has(lowerToken) && !isLoopHeadFor(tokens, i, inWords, commandKeywords)) {
-        currentPart.push(token);
-        continue;
-      }
-      if (BOUNDARY_MODIFIERS.has(lowerToken)) {
-        const verb = commandVerbOf(currentPart, commandKeywords);
-        if (verb && ON_TARGET_COMMANDS.has(verb)) {
-          currentPart.push(token);
-          continue;
-        }
-        if (lowerToken === "on" && verb === "set") {
-          const nextTok = tokens[i + 1];
-          const nextLower = nextTok?.toLowerCase();
-          const scopeLike = !!nextTok && (/^[#.<@[]/.test(nextTok) || nextLower === "me" || nextLower === "it" || nextLower === "you");
-          if (scopeLike) {
-            currentPart.push(token);
-            continue;
-          }
-        }
-      }
-      if (!boundaryModifiers.has(prevLower) && !commandKeywords.has(prevLower)) {
-        parts.push(currentPart.join(" "));
-        currentPart = [token];
-        continue;
-      }
-    }
-    currentPart.push(token);
-  }
-  if (currentPart.length > 0) {
-    parts.push(currentPart.join(" "));
-  }
-  return parts.filter((p) => p.length > 0);
-}
-function splitOnThen(input, sourceLocale) {
-  const thenKeywords = Array.from(THEN_KEYWORDS);
-  const sourceDict = sourceLocale === "en" ? null : dictionaries[sourceLocale];
-  if (sourceDict?.modifiers?.then) {
-    thenKeywords.push(sourceDict.modifiers.then);
-  }
-  if (sourceDict?.logical?.then) {
-    thenKeywords.push((sourceDict?.logical).then);
-  }
-  const escapedKeywords = thenKeywords.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-  const pattern = new RegExp(`\\s+(${escapedKeywords.join("|")})\\s+`, "gi");
-  const parts = input.split(pattern).filter((part) => {
-    const lowerPart = part.toLowerCase().trim();
-    return lowerPart && !thenKeywords.some((k) => k.toLowerCase() === lowerPart);
-  });
-  return parts.map((p) => p.trim()).filter((p) => p.length > 0);
-}
-function getTargetThenKeyword(targetLocale) {
-  if (targetLocale === "en") return "then";
-  const targetDict = dictionaries[targetLocale];
-  if (!targetDict) return "then";
-  return targetDict.modifiers?.then || targetDict.logical?.then || "then";
-}
-function deriveEventKeywordsFromProfiles() {
-  const keywords = /* @__PURE__ */ new Set();
-  keywords.add("on");
-  for (const profile of Object.values(profiles)) {
-    for (const marker of profile.markers) {
-      if (marker.role === "event") {
-        const form = marker.form.replace(/^-|-$/g, "").toLowerCase();
-        if (form) keywords.add(form);
-        marker.alternatives?.forEach((alt) => {
-          const altForm = alt.replace(/^-|-$/g, "").toLowerCase();
-          if (altForm) keywords.add(altForm);
-        });
-      }
-    }
-  }
-  return keywords;
-}
-var EVENT_KEYWORDS = deriveEventKeywordsFromProfiles();
-var EVENT_CONJUNCTIONS = /* @__PURE__ */ new Set(["or"]);
-var BODY_MODIFIER_KEYWORDS = /* @__PURE__ */ new Set([
-  "async",
-  "once",
-  "debounced",
-  "debounce",
-  "throttled",
-  "throttle"
-]);
-function generateModifierMap(profile) {
-  const map = {};
-  profile.markers.forEach((marker) => {
-    const form = marker.form.replace(/^-|-$/g, "").toLowerCase();
-    if (form) {
-      map[form] = marker.role;
-    }
-    marker.alternatives?.forEach((alt) => {
-      const altForm = alt.replace(/^-|-$/g, "").toLowerCase();
-      if (altForm) {
-        map[altForm] = marker.role;
-      }
-    });
-  });
-  for (const [key, role] of Object.entries(ENGLISH_MODIFIER_ROLES)) {
-    if (!(key in map)) {
-      map[key] = role;
-    }
-  }
-  return map;
-}
-function buildArgumentModifierMap(profile, actionVerb) {
-  const map = generateModifierMap(profile);
-  const verb = actionVerb?.toLowerCase();
-  if (profile.wordOrder !== "SVO" || !verb || !ON_TARGET_COMMANDS.has(verb)) {
-    return map;
-  }
-  const remapped = {};
-  for (const [form, role] of Object.entries(map)) {
-    remapped[form] = role === "event" ? "destination" : role;
-  }
-  return remapped;
-}
-function parseStatement(input, sourceLocale = "en") {
-  const profile = getProfile(sourceLocale);
-  if (!profile) return null;
-  const tokens = tokenize2(input, profile);
-  const statementType = identifyStatementType(tokens, profile);
-  switch (statementType) {
-    case "event-handler":
-      return parseEventHandler(tokens, profile);
-    case "command":
-      return parseCommand(tokens, profile);
-    case "conditional":
-      return parseConditional(tokens);
-    default:
-      return null;
-  }
-}
-var ATTACHED_SUFFIXES = {
-  // Chinese: 时 (time/when) often attaches to events like 点击时 (when clicking)
-  zh: ["\u65F6", "\u7684", "\u5730", "\u5F97"],
-  // Japanese: Some particles may attach in casual writing
-  ja: [],
-  // Korean: Particles sometimes written without spaces
-  ko: []
-};
-var ATTACHED_PREFIXES = {
-  // Chinese: 当 (when) sometimes written attached
-  zh: ["\u5F53"],
-  // Arabic: Prepositions that attach
-  ar: ["\u0628\u0640", "\u0643\u0640", "\u0648"]
-};
-function splitAttachedAffixes(tokens, locale) {
-  const suffixes = ATTACHED_SUFFIXES[locale] || [];
-  const prefixes = ATTACHED_PREFIXES[locale] || [];
-  if (suffixes.length === 0 && prefixes.length === 0) {
-    return tokens;
-  }
-  const result = [];
-  for (const token of tokens) {
-    if (/^[#.<@]/.test(token) || /^\d+/.test(token)) {
-      result.push(token);
-      continue;
-    }
-    let processed = token;
-    let prefix = "";
-    let suffix = "";
-    for (const p of prefixes) {
-      if (processed.startsWith(p) && processed.length > p.length) {
-        prefix = p;
-        processed = processed.slice(p.length);
-        break;
-      }
-    }
-    for (const s of suffixes) {
-      if (processed.endsWith(s) && processed.length > s.length) {
-        suffix = s;
-        processed = processed.slice(0, -s.length);
-        break;
-      }
-    }
-    if (prefix) result.push(prefix);
-    if (processed) result.push(processed);
-    if (suffix) result.push(suffix);
-  }
-  return result;
-}
-function tokenize2(input, profile) {
-  const tokens = [];
-  let current = "";
-  let inSelector = false;
-  let selectorDepth = 0;
-  let bracketDepth = 0;
-  let parenDepth = 0;
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    if (char === "<") {
-      inSelector = true;
-      selectorDepth++;
-    } else if (char === ">" && inSelector) {
-      selectorDepth--;
-      if (selectorDepth === 0) inSelector = false;
-    }
-    if (char === "[") {
-      bracketDepth++;
-    } else if (char === "]" && bracketDepth > 0) {
-      bracketDepth--;
-    }
-    if (char === "(") {
-      parenDepth++;
-    } else if (char === ")" && parenDepth > 0) {
-      parenDepth--;
-    }
-    if (/\s/.test(char) && !inSelector && bracketDepth === 0 && parenDepth === 0) {
-      if (current) {
-        tokens.push(current);
-        current = "";
-      }
-    } else {
-      current += char;
-    }
-  }
-  if (current) {
-    tokens.push(current);
-  }
-  return splitAttachedAffixes(tokens, profile.code);
-}
-function identifyStatementType(tokens, profile) {
-  if (tokens.length === 0) return "unknown";
-  const firstToken = tokens[0].toLowerCase();
-  const eventMarker = profile.markers.find((m) => m.role === "event" && m.position === "preposition");
-  if (eventMarker && firstToken === eventMarker.form.toLowerCase()) {
-    return "event-handler";
-  }
-  if (EVENT_KEYWORDS.has(firstToken)) {
-    return "event-handler";
-  }
-  if (CONDITIONAL_KEYWORDS.has(firstToken)) {
-    return "conditional";
-  }
-  return "command";
-}
-function parseEventHandler(tokens, profile) {
-  const roles = /* @__PURE__ */ new Map();
-  let startIndex = EVENT_KEYWORDS.has(tokens[0]?.toLowerCase()) ? 1 : 0;
-  if (tokens[startIndex]) {
-    const eventTokens = [tokens[startIndex]];
-    startIndex++;
-    while (tokens[startIndex] && EVENT_CONJUNCTIONS.has(tokens[startIndex].toLowerCase()) && tokens[startIndex + 1]) {
-      eventTokens.push(tokens[startIndex], tokens[startIndex + 1]);
-      startIndex += 2;
-    }
-    roles.set("event", {
-      role: "event",
-      value: eventTokens.join(" ")
-    });
-  }
-  if (tokens[startIndex] && tokens[startIndex].toLowerCase() === "from" && tokens[startIndex + 1]) {
-    startIndex++;
-    const sourceValue = [];
-    while (tokens[startIndex]) {
-      if (ENGLISH_COMMANDS.has(tokens[startIndex].toLowerCase())) break;
-      sourceValue.push(tokens[startIndex]);
-      startIndex++;
-    }
-    if (sourceValue.length > 0) {
-      const value = sourceValue.join(" ");
-      roles.set("source", {
-        role: "source",
-        value,
-        isSelector: /^[#.<@]/.test(value)
-      });
-    }
-  }
-  if (tokens[startIndex]) {
-    roles.set("action", {
-      role: "action",
-      value: tokens[startIndex]
-    });
-    startIndex++;
-  }
-  if (tokens[startIndex]) {
-    const modifierMap = buildArgumentModifierMap(profile, roles.get("action")?.value);
-    let currentRole = "patient";
-    let currentValue = [];
-    for (let i = startIndex; i < tokens.length; i++) {
-      const token = tokens[i];
-      const mappedRole = modifierMap[token.toLowerCase()];
-      if (mappedRole) {
-        if (currentValue.length > 0) {
-          const value = currentValue.join(" ");
-          roles.set(currentRole, {
-            role: currentRole,
-            value,
-            isSelector: /^[#.<@]/.test(value)
-          });
-        }
-        currentRole = mappedRole;
-        currentValue = [];
-      } else {
-        currentValue.push(token);
-      }
-    }
-    if (currentValue.length > 0) {
-      const value = currentValue.join(" ");
-      roles.set(currentRole, {
-        role: currentRole,
-        value,
-        isSelector: /^[#.<@]/.test(value)
-      });
-    }
-  }
-  return {
-    type: "event-handler",
-    roles,
-    original: tokens.join(" ")
-  };
-}
-function parseCommand(tokens, profile) {
-  const roles = /* @__PURE__ */ new Map();
-  if (tokens.length === 0) {
-    return { type: "command", roles, original: "" };
-  }
-  roles.set("action", {
-    role: "action",
-    value: tokens[0]
-  });
-  const modifierMap = buildArgumentModifierMap(profile, tokens[0]);
-  let currentRole = "patient";
-  let currentValue = [];
-  for (let i = 1; i < tokens.length; i++) {
-    const token = tokens[i];
-    const mappedRole = modifierMap[token.toLowerCase()];
-    if (mappedRole) {
-      if (currentValue.length > 0) {
-        const value = currentValue.join(" ");
-        roles.set(currentRole, {
-          role: currentRole,
-          value,
-          isSelector: /^[#.<@]/.test(value)
-        });
-      }
-      currentRole = mappedRole;
-      currentValue = [];
-    } else {
-      currentValue.push(token);
-    }
-  }
-  if (currentValue.length > 0) {
-    const value = currentValue.join(" ");
-    roles.set(currentRole, {
-      role: currentRole,
-      value,
-      isSelector: /^[#.<@]/.test(value)
-    });
-  }
-  return {
-    type: "command",
-    roles,
-    original: tokens.join(" ")
-  };
-}
-var LITERAL_PRIMARY_ROLES = /* @__PURE__ */ new Set([
-  "duration",
-  "quantity"
-]);
-function applyPrimaryRole(parsed, targetProfile) {
-  if (parsed.type !== "command") return;
-  const action = parsed.roles.get("action")?.value;
-  if (!action) return;
-  const primaryRole = COMMAND_PRIMARY_ROLES[action.toLowerCase()];
-  if (!primaryRole || !LITERAL_PRIMARY_ROLES.has(primaryRole)) return;
-  const patientEl = parsed.roles.get("patient");
-  if (!patientEl || parsed.roles.has(primaryRole)) return;
-  if (targetProfile.markers.some((m) => m.role === primaryRole)) return;
-  parsed.roles.delete("patient");
-  parsed.roles.set(primaryRole, { ...patientEl, role: primaryRole });
-}
-function parseConditional(tokens, _profile) {
-  const roles = /* @__PURE__ */ new Map();
-  roles.set("action", {
-    role: "action",
-    value: tokens[0]
-  });
-  const thenIndex = tokens.findIndex((t) => THEN_KEYWORDS.has(t.toLowerCase()));
-  if (thenIndex > 1) {
-    const conditionValue = tokens.slice(1, thenIndex).join(" ");
-    roles.set("condition", {
-      role: "condition",
-      value: conditionValue
-    });
-  } else if (thenIndex === -1 && tokens.length > 1) {
-    roles.set("condition", {
-      role: "condition",
-      value: tokens.slice(1).join(" ")
-    });
-  }
-  return {
-    type: "conditional",
-    roles,
-    original: tokens.join(" ")
-  };
-}
-function translateWord(word, sourceLocale, targetLocale) {
-  if (/^[#.<@]/.test(word)) {
-    return word;
-  }
-  if (/^\d+/.test(word)) {
-    return word;
-  }
-  if (/\s/.test(word) && word.startsWith("(")) {
-    return word.split(/\s+/).map((w) => translateWord(w, sourceLocale, targetLocale)).join(" ");
-  }
-  if (word.length > 1 && (word.startsWith("(") || word.endsWith(")"))) {
-    const m = word.match(/^(\(*)([^()]+)(\)*)$/);
-    if (m && (m[1] || m[3])) {
-      return m[1] + translateWord(m[2], sourceLocale, targetLocale) + m[3];
-    }
-  }
-  const sourceDict = sourceLocale === "en" ? null : dictionaries[sourceLocale];
-  const targetDict = dictionaries[targetLocale];
-  if (!targetDict) return word;
-  let englishWord = word;
-  if (sourceDict) {
-    const found = findInDictionary(sourceDict, word);
-    if (found) {
-      englishWord = found.englishKey;
-    }
-  }
-  const translated = translateFromEnglish(targetDict, englishWord);
-  return translated ?? word;
-}
-var POSSESSIVE_MARKERS = {
-  en: { type: "suffix", marker: "'s" },
-  es: { type: "preposition", marker: "de" },
-  pt: { type: "preposition", marker: "de" },
-  fr: { type: "preposition", marker: "de" },
-  de: { type: "preposition", marker: "von" },
-  ja: { type: "suffix", marker: "\u306E" },
-  ko: { type: "suffix", marker: "\uC758" },
-  zh: { type: "suffix", marker: "\u7684" },
-  ar: { type: "preposition", marker: "\u0644\u0640" },
-  // Spaced genitive particle (not the glued `'ın`), so the tokenizer can split
-  // it off the selector — consistent with Turkish's other spaced case markers.
-  tr: { type: "particle", marker: "\u0131n" },
-  id: { type: "preposition", marker: "dari" },
-  // Latin-script genitive: must be a *spaced* particle (`#picker pa`), since a
-  // glued `#pickerpa` can't be split from the selector by the tokenizer the
-  // way a non-Latin suffix (の/의/র) can.
-  qu: { type: "particle", marker: "pa" },
-  // Bengali SOV postposition genitive, like ja/ko — a spaced suffix the
-  // tokenizer splits off as a particle. Previously absent, so it fell back to
-  // the English `'s` marker and its possessive property paths never parsed.
-  // (Hindi `का` is intentionally omitted: its `bind` lacks a verb-final
-  // grammar rule, so fixing its possessive alone yields a wrong `on` parse —
-  // tracked as separate follow-up.)
-  bn: { type: "suffix", marker: "\u09B0" },
-  sw: { type: "preposition", marker: "ya" }
-};
-function translatePossessive(token, sourceLocale, targetLocale) {
-  const possessiveMatch = token.match(/^(.+)'s$/i);
-  if (!possessiveMatch) {
-    return token;
-  }
-  const owner = possessiveMatch[1];
-  const targetMarker = POSSESSIVE_MARKERS[targetLocale] || POSSESSIVE_MARKERS.en;
-  const pronounPossessives = {
-    me: "my",
-    it: "its",
-    you: "your"
-  };
-  const lowerOwner = owner.toLowerCase();
-  if (pronounPossessives[lowerOwner]) {
-    const possessiveForm = pronounPossessives[lowerOwner];
-    return translateWord(possessiveForm, "en", targetLocale);
-  }
-  const translatedOwner = translateWord(owner, sourceLocale, targetLocale);
-  switch (targetMarker.type) {
-    case "suffix":
-      return `${translatedOwner}${targetMarker.marker}`;
-    case "particle":
-      return `${translatedOwner} ${targetMarker.marker}`;
-    case "preposition":
-      return `__POSS__${targetMarker.marker}__${translatedOwner}__POSS__`;
-    default:
-      return `${translatedOwner}'s`;
-  }
-}
-var POSSESSIVE_DOT_REGEX = /^(my|its|your|me|it|you)(\??\..+)$/i;
-var POSSESSIVE_DOT_PRONOUNS = {
-  me: "my",
-  it: "its",
-  you: "your",
-  my: "my",
-  its: "its",
-  your: "your"
-};
-function translatePossessiveDotNotation(value, sourceLocale, targetLocale) {
-  const match = value.match(POSSESSIVE_DOT_REGEX);
-  if (!match) return null;
-  const possessiveWord = match[1].toLowerCase();
-  const propertySuffix = match[2];
-  const possessiveKey = POSSESSIVE_DOT_PRONOUNS[possessiveWord] || possessiveWord;
-  const translated = translateWord(possessiveKey, sourceLocale, targetLocale);
-  if (translated.includes(" ")) return null;
-  if (translated !== possessiveKey) {
-    return translated + propertySuffix;
-  }
-  if (possessiveWord !== possessiveKey) {
-    const alt = translateWord(possessiveWord, sourceLocale, targetLocale);
-    if (alt !== possessiveWord && !alt.includes(" ")) {
-      return alt + propertySuffix;
-    }
-  }
-  return null;
-}
-function translateMultiWordValue(value, sourceLocale, targetLocale) {
-  if (value.includes("[")) {
-    const guards = [];
-    const masked = value.replace(/\[[^\]]*\]/g, (match) => {
-      guards.push(match);
-      return `\uE000${guards.length - 1}\uE001`;
-    });
-    if (guards.length > 0) {
-      const translated2 = translateMultiWordValue(masked, sourceLocale, targetLocale);
-      return translated2.replace(/(\d+)/g, (_, n) => guards[Number(n)]);
-    }
-  }
-  if (!value.includes(" ")) {
-    if (value.includes("'s")) {
-      return translatePossessive(value, sourceLocale, targetLocale);
-    }
-    const dotResult = translatePossessiveDotNotation(value, sourceLocale, targetLocale);
-    if (dotResult !== null) return dotResult;
-    return translateWord(value, sourceLocale, targetLocale);
-  }
-  const words = value.split(/\s+/);
-  const translated = [];
-  let i = 0;
-  while (i < words.length) {
-    const word = words[i];
-    if (word.includes("'s")) {
-      const possessiveResult = translatePossessive(word, sourceLocale, targetLocale);
-      const prepMatch = possessiveResult.match(/^__POSS__(.+)__(.+)__POSS__$/);
-      if (prepMatch && i + 1 < words.length) {
-        const marker = prepMatch[1];
-        const owner = prepMatch[2];
-        const property = words[i + 1];
-        const translatedProperty = translateWord(property, sourceLocale, targetLocale);
-        translated.push(`${translatedProperty} ${marker} ${owner}`);
-        i += 2;
-        continue;
-      } else if (prepMatch) {
-        const marker = prepMatch[1];
-        const owner = prepMatch[2];
-        translated.push(`${marker} ${owner}`);
-        i++;
-        continue;
-      }
-      translated.push(possessiveResult);
-      i++;
-      continue;
-    }
-    if (/^[#.<@]/.test(word) || /^\d+/.test(word)) {
-      translated.push(word);
-      i++;
-      continue;
-    }
-    if (/^["'].*["']$/.test(word)) {
-      translated.push(word);
-      i++;
-      continue;
-    }
-    const dotResult = translatePossessiveDotNotation(word, sourceLocale, targetLocale);
-    if (dotResult !== null) {
-      translated.push(dotResult);
-      i++;
-      continue;
-    }
-    translated.push(translateWord(word, sourceLocale, targetLocale));
-    i++;
-  }
-  return translated.join(" ");
-}
-function translateElements(parsed, sourceLocale, targetLocale) {
-  for (const [_role, element] of parsed.roles) {
-    if (element.value.includes("'s")) {
-      element.translated = translateMultiWordValue(element.value, sourceLocale, targetLocale);
-    } else if (!element.isSelector && !element.isLiteral) {
-      element.translated = translateMultiWordValue(element.value, sourceLocale, targetLocale);
-    } else {
-      element.translated = element.value;
-    }
-  }
-}
-var CARET_SCOPE_OPEN = "\uE000";
-var CARET_SCOPE_CLOSE = "\uE001";
-var CARET_SCOPE_RE = /(\^[A-Za-z_][\w-]*)(\s+on\s+(?:[#.][\w-]+|<[^>]*\/>|\[[^\]]+\]))/g;
-function maskCaretScopes(input) {
-  const scopes = [];
-  const masked = input.replace(CARET_SCOPE_RE, (_m, varTok, scope) => {
-    const idx = scopes.length;
-    scopes.push(scope);
-    return `${varTok}${CARET_SCOPE_OPEN}${idx}${CARET_SCOPE_CLOSE}`;
-  });
-  return scopes.length > 0 ? { masked, scopes } : null;
-}
-function restoreCaretScopes(input, scopes) {
-  return input.replace(
-    new RegExp(`${CARET_SCOPE_OPEN}(\\d+)${CARET_SCOPE_CLOSE}`, "g"),
-    (_m, n) => scopes[Number(n)] ?? ""
-  );
-}
-var VIEW_TAIL_OPEN = "\uE002";
-var VIEW_TAIL_CLOSE = "\uE003";
-var VIEW_TAIL_RE = /\busing\s+view\b(?:\s+(?!then\b)[A-Za-z][\w-]*)?/gi;
-var VIEW_TAIL_TOKEN_RE = new RegExp(`^${VIEW_TAIL_OPEN}(\\d+)${VIEW_TAIL_CLOSE}$`);
-function maskViewTransitionTails(input) {
-  const tails = [];
-  const masked = input.replace(VIEW_TAIL_RE, (match) => {
-    const idx = tails.length;
-    tails.push(match);
-    return `${VIEW_TAIL_OPEN}${idx}${VIEW_TAIL_CLOSE}`;
-  });
-  return tails.length > 0 ? { masked, tails } : null;
-}
-function restoreViewTransitionTails(input, tails) {
-  return input.replace(
-    new RegExp(`${VIEW_TAIL_OPEN}(\\d+)${VIEW_TAIL_CLOSE}`, "g"),
-    (_m, n) => tails[Number(n)] ?? ""
-  );
-}
-var GrammarTransformer = class {
-  constructor(sourceLocale = "en", targetLocale) {
-    const source = getProfile(sourceLocale);
-    const target = getProfile(targetLocale);
-    if (!source) throw new Error(`Unknown source locale: ${sourceLocale}`);
-    if (!target) throw new Error(`Unknown target locale: ${targetLocale}`);
-    this.sourceProfile = source;
-    this.targetProfile = target;
-  }
-  /**
-   * Transform a hyperscript statement from source to target language.
-   * Handles compound statements with "then" by splitting, transforming each part,
-   * and rejoining with the target language's "then" keyword.
-   *
-   * For multi-line input, preserves line structure (indentation, blank lines).
-   */
-  transform(input) {
-    const out = this.transformInternal(input);
-    return this.targetProfile.code === "he" ? repairHebrewFrontedAccusative(out) : out;
-  }
-  transformInternal(input) {
-    const viewTails = maskViewTransitionTails(input);
-    if (viewTails) {
-      return restoreViewTransitionTails(this.transformInternal(viewTails.masked), viewTails.tails);
-    }
-    const caret = maskCaretScopes(input);
-    if (caret) {
-      return restoreCaretScopes(this.transform(caret.masked), caret.scopes);
-    }
-    const targetThen = getTargetThenKeyword(this.targetProfile.code);
-    if (!input.includes("\n")) {
-      const jsBlock = this.tryTransformJsBlock(input);
-      if (jsBlock !== null) return jsBlock;
-      const eventModifier = this.tryTransformEventWithModifierBody(input);
-      if (eventModifier !== null) return eventModifier;
-      const eventBlock = this.tryTransformEventWithBlockBody(input);
-      if (eventBlock !== null) return eventBlock;
-      const eventGuard = this.tryTransformEventWithUnlessGuard(input);
-      if (eventGuard !== null) return eventGuard;
-    }
-    const hasMultiLineStructure = input.includes("\n");
-    if (hasMultiLineStructure) {
-      const { parts: parts2, lineMetadata, partToLineIndex } = splitCompoundStatementWithMetadata(
-        input,
-        this.sourceProfile.code
-      );
-      const transformedParts = parts2.map((part) => this.transformSingle(part));
-      return reconstructWithLineStructure(
-        transformedParts,
-        lineMetadata,
-        partToLineIndex,
-        targetThen
-      );
-    }
-    const parts = splitCompoundStatement(input, this.sourceProfile.code);
-    if (parts.length > 1) {
-      const transformedParts = parts.map((part) => this.transformSingle(part));
-      return transformedParts.join(` ${targetThen} `);
-    }
-    return this.transformSingle(input);
-  }
-  /**
-   * Transform a single hyperscript statement (no compound "then" chains).
-   */
-  transformSingle(input) {
-    const block = extractBlockStructure(input, this.sourceProfile.code);
-    if (block) {
-      return this.transformBlock(block);
-    }
-    const strippedEnd = this.transformWithTrailingEnd(input);
-    if (strippedEnd !== null) {
-      return strippedEnd;
-    }
-    const setScope = this.transformSetWithScope(input);
-    if (setScope !== null) {
-      return setScope;
-    }
-    const viewTail = this.transformWithViewTransitionTail(input);
-    if (viewTail !== null) {
-      return viewTail;
-    }
-    const parsed = parseStatement(input, this.sourceProfile.code);
-    if (!parsed) {
-      return input;
-    }
-    applyPrimaryRole(parsed, this.targetProfile);
-    translateElements(parsed, this.sourceProfile.code, this.targetProfile.code);
-    const rule = this.findRule(parsed);
-    if (rule?.transform.custom) {
-      return rule.transform.custom(parsed, this.targetProfile);
-    }
-    const roleOrder = rule?.transform.roleOrder || this.targetProfile.canonicalOrder;
-    const reordered = reorderRoles(parsed.roles, roleOrder);
-    const shouldInsertMarkers = rule?.transform.insertMarkers ?? true;
-    if (shouldInsertMarkers) {
-      const result = insertMarkers(
-        reordered,
-        this.targetProfile.markers,
-        this.targetProfile.adpositionType
-      );
-      return joinTokens(result);
-    }
-    return joinTokens(reordered.map((e) => e.translated || e.value));
-  }
-  /**
-   * Clause carrying a masked `using view transition` tail: strip the opaque
-   * token, transform the clause alone, and re-append the token at the very end.
-   *
-   * The tail is a clause-final modifier in every word order the corpus emits:
-   * the semantic side matches it as the literal `using view` marker plus a value
-   * word, and the SOV/VSO event-handler patterns admit it as an optional
-   * TRAILING group (after the with-marked operand). So the target position is
-   * "end of the transformed clause" for all 24 languages — no per-profile
-   * placement decision, which is what makes this a passthrough rather than a
-   * role.
-   *
-   * Returns null when the clause carries no masked tail, or when the token is
-   * not clause-final (nothing to reposition — leaving it in place still restores
-   * verbatim English).
-   */
-  transformWithViewTransitionTail(input) {
-    const trimmed = input.trim();
-    const tokens = trimmed.split(/\s+/);
-    if (tokens.length < 2) {
-      return null;
-    }
-    if (!VIEW_TAIL_TOKEN_RE.test(tokens[tokens.length - 1])) {
-      return null;
-    }
-    const tail = tokens[tokens.length - 1];
-    const head = tokens.slice(0, -1).join(" ");
-    return `${this.transformSingle(head)} ${tail}`;
-  }
-  /**
-   * `<command …> end` fragments: transform the command without its stranded
-   * terminator, then re-append the translated terminator as a standalone
-   * trailing token. Fragments that open a block of their own (`if … end`,
-   * `repeat … end`, `js … end`) bail — their terminator belongs to them and
-   * their dedicated paths handle it.
-   */
-  transformWithTrailingEnd(input) {
-    const src = this.sourceProfile.code;
-    const tokens = input.trim().split(/\s+/);
-    if (tokens.length < 2) {
-      return null;
-    }
-    const sourceEnd = translateWord("end", "en", src).toLowerCase();
-    if (tokens[tokens.length - 1].toLowerCase() !== sourceEnd) {
-      return null;
-    }
-    const openers = new Set(
-      ["if", "repeat", "unless", "while", "when", "live", "js"].map(
-        (k) => translateWord(k, "en", src).toLowerCase()
-      )
-    );
-    if (tokens.slice(0, -1).some((t) => openers.has(t.toLowerCase()))) {
-      return null;
-    }
-    const inner = this.transformSingle(tokens.slice(0, -1).join(" "));
-    const endT = translateWord(tokens[tokens.length - 1], src, this.targetProfile.code);
-    return `${inner} ${endT}`;
-  }
-  /**
-   * Detect and transform an inline JS block (`[on <event>] js <raw js> end`).
-   *
-   * The `js ... end` body is raw JavaScript: it must not be tokenized,
-   * translated, or word-order reordered. We mask the whole block with a single
-   * opaque placeholder, run the surrounding statement (the event-handler head,
-   * if any) through the normal reorder pipeline so the placeholder lands in the
-   * correct action position, then substitute the translated `js`/`end` keywords
-   * around the verbatim body.
-   *
-   * Returns `null` (fall through to the normal path) when there is no js block,
-   * no matching `end`, or trailing content after `end` (kept tight on purpose).
-   */
-  tryTransformJsBlock(input) {
-    const src = this.sourceProfile.code;
-    const dst = this.targetProfile.code;
-    const sourceJs = translateWord("js", "en", src);
-    const sourceEnd = translateWord("end", "en", src).toLowerCase();
-    const tokens = input.split(/\s+/).filter((t) => t.length > 0);
-    const escapedJs = sourceJs.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const jsRe = new RegExp(`^${escapedJs}(\\(.*\\))?$`, "i");
-    const jsIdx = tokens.findIndex((t) => jsRe.test(t));
-    if (jsIdx === -1) return null;
-    let endIdx = -1;
-    for (let i = jsIdx + 1; i < tokens.length; i++) {
-      if (tokens[i].toLowerCase() === sourceEnd) {
-        endIdx = i;
-        break;
-      }
-    }
-    if (endIdx === -1) return null;
-    if (endIdx !== tokens.length - 1) return null;
-    const jsToken = tokens[jsIdx];
-    const jsParen = jsToken.match(jsRe)?.[1] ?? "";
-    const jsKeywordRaw = jsParen ? jsToken.slice(0, jsToken.length - jsParen.length) : jsToken;
-    const body = tokens.slice(jsIdx + 1, endIdx).join(" ");
-    const targetJs = translateWord(jsKeywordRaw, src, dst) + jsParen;
-    const targetEnd = translateWord(tokens[endIdx], src, dst);
-    const replacement = [targetJs, body, targetEnd].filter((s) => s.length > 0).join(" ");
-    const before = tokens.slice(0, jsIdx);
-    if (before.length === 0) return replacement;
-    const placeholder = "JSBLOCKPLACEHOLDER";
-    const reordered = this.transformSingle([...before, placeholder].join(" "));
-    if (!reordered.includes(placeholder)) return null;
-    return reordered.replace(placeholder, replacement);
-  }
-  /**
-   * Transform an event handler whose body is a block command
-   * (`on <event> [from <src>] {if|repeat|unless|while|for} … end`).
-   *
-   * `parseEventHandler` would treat the block keyword as the action and sweep the
-   * condition/body into role values, then reorder them — shredding the block
-   * (`if event.shiftKey call submitAndContinue() end` → scattered tokens). Instead
-   * we mask the whole block as an opaque action placeholder, reorder the event
-   * head normally, transform the block as a self-contained unit, and restitch.
-   *
-   * Returns `null` (fall through) when the input isn't an event handler, has no
-   * block-keyword body, or has no closing `end`.
-   */
-  tryTransformEventWithBlockBody(input) {
-    const tokens = tokenize2(input, this.sourceProfile);
-    if (tokens.length === 0) return null;
-    if (!EVENT_KEYWORDS.has(tokens[0]?.toLowerCase())) return null;
-    let blockIdx = -1;
-    for (let i = 1; i < tokens.length; i++) {
-      if (BLOCK_BODY_KEYWORDS.has(tokens[i].toLowerCase())) {
-        blockIdx = i;
-        break;
-      }
-    }
-    if (blockIdx <= 0) return null;
-    if (tokens[tokens.length - 1].toLowerCase() !== "end") return null;
-    const eventHead = tokens.slice(0, blockIdx);
-    const blockTokens = tokens.slice(blockIdx);
-    if (this.targetProfile.wordOrder === "VSO" && eventHead.some((t) => t.toLowerCase() === "from")) {
-      return null;
-    }
-    const placeholder = "EVENTBLOCKPLACEHOLDER";
-    const headOut = this.transformSingle([...eventHead, placeholder].join(" "));
-    if (!headOut.includes(placeholder)) return null;
-    const blockOut = this.transformBlockBody(blockTokens);
-    const eventClause = headOut.replace(placeholder, "").replace(/\s+/g, " ").trim();
-    return [eventClause, blockOut].filter((s) => s.length > 0).join(" ");
-  }
-  /**
-   * Transform an event handler whose body is an inline `unless` guard with NO
-   * `end` (`on <event> unless <cond> <body>` — the `unless-condition` shape).
-   *
-   * Object-marking SVO targets (he, zh). `parseEventHandler` reads `unless` as the
-   * action and sweeps the whole `<cond> <body>` tail into a single `patient` blob;
-   * the target then prefixes that blob with its object marker — Hebrew's accusative
-   * את (`… אלא את I match .disabled מתג .selected`) or Chinese's BA particle 把
-   * (`… 除非 把 I match .disabled 切换 .selected`) — and the inner toggle loses its
-   * own marker. The semantic parser can't recover the guard from that: the marker
-   * ahead of the condition blocks the `unless` pattern AND the now-markerless body
-   * command fails its object-marked toggle pattern, so the body collapses (`unless`
-   * dropped). Marker-less languages (de/it/ar/pl) tolerate the same role-blob and
-   * stay faithful, so this is an object-marker artifact, not a general parse gap.
-   *
-   * The standalone `unless <cond> <body>` path already produces the correct shape
-   * (`extractBlockStructure` → `transformBlock`: condition kept marker-free, body
-   * command keeps its marker — he `אלא I match .disabled מתג את .selected`, zh
-   * `除非 I match .disabled 切换 把 .selected`). So we split the event head off,
-   * transform the guard through that path, and emit the event clause first (he and
-   * zh are both SVO — event leads). Returns `null` (fall through) when the input
-   * isn't an object-marking event handler with an un-terminated inline `unless`
-   * guard.
-   */
-  tryTransformEventWithUnlessGuard(input) {
-    if (!UNLESS_GUARD_OBJECT_MARKING_LOCALES.has(this.targetProfile.code)) return null;
-    const tokens = tokenize2(input, this.sourceProfile);
-    if (tokens.length === 0) return null;
-    if (!EVENT_KEYWORDS.has(tokens[0]?.toLowerCase())) return null;
-    let guardIdx = -1;
-    for (let i = 1; i < tokens.length; i++) {
-      if (tokens[i].toLowerCase() === "unless") {
-        guardIdx = i;
-        break;
-      }
-    }
-    if (guardIdx <= 0) return null;
-    if (tokens[tokens.length - 1].toLowerCase() === "end") return null;
-    const eventHead = tokens.slice(0, guardIdx);
-    const guard = tokens.slice(guardIdx).join(" ");
-    const guardOut = this.transform(guard);
-    if (!guardOut) return null;
-    const placeholder = "EVENTGUARDPLACEHOLDER";
-    const headOut = this.transformSingle([...eventHead, placeholder].join(" "));
-    if (!headOut.includes(placeholder)) return null;
-    const eventClause = headOut.replace(placeholder, "").replace(/\s+/g, " ").trim();
-    return [eventClause, guardOut].filter((s) => s.length > 0).join(" ");
-  }
-  /**
-   * Transform an event handler whose body leads with a command-modifier
-   * (`on <event> [from <src>] {async|once|debounced [at N]|throttled [at N]} <body>`).
-   *
-   * `parseEventHandler` reads the first token after the event as the **action**, so
-   * a leading modifier is mistaken for the verb and the real verb (`fetch`/`add`) is
-   * swept into the patient. For SOV targets the reorder then surfaces that verb
-   * **first** (`取得 /api/data を クリック …`), and the semantic parser matches the
-   * leading `<verb> <patient>` with the low-priority `*-generated-verb-first`
-   * command pattern — returning a bare command and discarding the event + the rest
-   * of the body (degenerate parse).
-   *
-   * Instead, lift the modifier out, transform the modifier-free handler through the
-   * normal path (which keeps the body in canonical patient-first SOV order so the
-   * event sits mid-stream and the existing SOV event-extraction recovers it), then
-   * re-emit the modifier as a **leading English literal**. The semantic parser
-   * strips a leading `once`/`debounced`/`throttled` (`extractStandaloneModifiers`)
-   * and an `async` anywhere (`stripAsyncModifier`) before parsing, so the modifier
-   * is consumed as handler metadata rather than shadowing the body.
-   *
-   * Returns `null` (fall through) when the input isn't an event handler or the body
-   * doesn't lead with a modifier — leaving simple/Mode-B handlers byte-identical.
-   */
-  tryTransformEventWithModifierBody(input) {
-    if (this.targetProfile.wordOrder !== "SOV") return null;
-    const tokens = tokenize2(input, this.sourceProfile);
-    if (tokens.length === 0) return null;
-    if (!EVENT_KEYWORDS.has(tokens[0]?.toLowerCase())) return null;
-    let i = 1;
-    if (!tokens[i]) return null;
-    i++;
-    while (tokens[i] && EVENT_CONJUNCTIONS.has(tokens[i].toLowerCase()) && tokens[i + 1]) {
-      i += 2;
-    }
-    if (tokens[i]?.toLowerCase() === "from" && tokens[i + 1]) {
-      i++;
-      while (tokens[i] && !ENGLISH_COMMANDS.has(tokens[i].toLowerCase()) && !BODY_MODIFIER_KEYWORDS.has(tokens[i].toLowerCase())) {
-        i++;
-      }
-    }
-    const modWord = tokens[i]?.toLowerCase();
-    if (!modWord || !BODY_MODIFIER_KEYWORDS.has(modWord)) return null;
-    const modStart = i;
-    let modEnd = i + 1;
-    if (modWord !== "async" && modWord !== "once") {
-      if (tokens[modEnd]?.toLowerCase() === "at") modEnd++;
-      if (tokens[modEnd] && /^\d+(ms|s|m)?$/.test(tokens[modEnd])) modEnd++;
-    }
-    const modifierPhrase = tokens.slice(modStart, modEnd).join(" ");
-    const rebuilt = [...tokens.slice(0, modStart), ...tokens.slice(modEnd)].join(" ");
-    if (tokens.length - (modEnd - modStart) <= 2) return null;
-    const bodyOut = this.transform(rebuilt);
-    return [modifierPhrase, bodyOut].filter((s) => s.length > 0).join(" ");
-  }
-  /**
-   * Transform a `set <stuff> on <scope>` clause (S1 tabs-aria). The trailing
-   * `on <scope>` is the element(s) the attribute is set on — kept attached by
-   * splitOnCommandBoundaries. The semantic parser captures it as a `scope` role
-   * via the passthrough literal `on` (setSchema's scope markerOverride is `on`
-   * in every language), so `on` is emitted verbatim and only the scope *value*
-   * is translated (selectors pass through; `me`/`it`/`you` translate to the
-   * native reference, which the parser also accepts).
-   *
-   * Positioning matches where the set patterns expect the scope: at the clause
-   * end for verb-first orders (SVO/VSO), and immediately before the clause-final
-   * verb for SOV (the generated SOV pattern is `{dest} {patient} on {scope}
-   * {verb}`). Returns null (fall through) when there is no trailing `on <scope>`.
-   *
-   * Source is English in the sync-translations pipeline, so the `set` verb and
-   * `on` marker are matched as English literals.
-   */
-  transformSetWithScope(input) {
-    const src = this.sourceProfile.code;
-    const dst = this.targetProfile.code;
-    const m = input.match(/^(.*\bset\b.*\S)\s+on\s+([#.<@[]\S*|me|it|you)\s*$/i);
-    if (!m) return null;
-    const head = m[1];
-    const scopeRaw = m[2];
-    const headOut = this.transformSingle(head);
-    const scopeT = /^[#.<@[]/.test(scopeRaw) ? scopeRaw : translateWord(scopeRaw, src, dst);
-    if (this.targetProfile.wordOrder === "SOV") {
-      const verb = translateWord("set", "en", dst);
-      const firstTok = input.trim().split(/\s+/)[0]?.toLowerCase();
-      const isEventHandler = !!firstTok && EVENT_KEYWORDS.has(firstTok);
-      const toks = headOut.split(/\s+/).filter(Boolean);
-      if (!isEventHandler) {
-        const vIdx = toks.indexOf(verb);
-        if (vIdx >= 0) {
-          toks.splice(vIdx, 1);
-          toks.push("on", scopeT, verb);
-          return toks.join(" ");
-        }
-      } else if (toks.length > 0 && toks[toks.length - 1] === verb) {
-        toks.splice(toks.length - 1, 0, "on", scopeT);
-        return toks.join(" ");
-      }
-      return `${headOut} on ${scopeT}`;
-    }
-    return `${headOut} on ${scopeT}`;
-  }
-  /**
-   * Transform a self-contained block command (`{head} {clause?} {body} {end}`),
-   * where head ∈ {if, repeat, unless, …}. The clause (condition / `until event …`)
-   * runs up to the first command verb and is translated word-by-word; the body is
-   * recursively transformed (so its inner commands reorder for the target); the
-   * head/tail keywords are translated. The block is never word-order reordered as
-   * a whole — delimiters stay at the edges regardless of target word order.
-   */
-  transformBlockBody(blockTokens) {
-    const src = this.sourceProfile.code;
-    const dst = this.targetProfile.code;
-    const head = blockTokens[0];
-    const hasEnd = blockTokens[blockTokens.length - 1]?.toLowerCase() === "end";
-    const tail = hasEnd ? blockTokens[blockTokens.length - 1] : "";
-    const inner = blockTokens.slice(1, hasEnd ? -1 : void 0);
-    const commands = getCommandKeywordsForLocale(src);
-    const copulas = getCopulasForLocale(src);
-    let bodyStart = inner.findIndex(
-      (t, i) => commands.has(t.toLowerCase()) && !isPredicateAdjectivePosition(inner, i, copulas)
-    );
-    if (bodyStart < 0) bodyStart = inner.length;
-    const clause = inner.slice(0, bodyStart).join(" ");
-    const bodyTokens = inner.slice(bodyStart);
-    const headT = translateWord(head, src, dst);
-    const tailT = tail ? translateWord(tail, src, dst) : "";
-    const clauseT = clause ? translateMultiWordValue(clause, src, dst) : "";
-    const bodyT = this.transformConditionalBody(bodyTokens);
-    const POSITIONAL_BRANCH_HEADS = /* @__PURE__ */ new Set(["first", "last", "next", "previous", "closest"]);
-    const thenT = this.targetProfile.wordOrder === "SOV" && clauseT && POSITIONAL_BRANCH_HEADS.has(bodyTokens[1]?.toLowerCase()) && inner[bodyStart - 1]?.toLowerCase() !== "then" ? translateWord("then", src, dst) : "";
-    return [headT, clauseT, thenT, bodyT, tailT].filter((s) => s.length > 0).join(" ");
-  }
-  /**
-   * Transform an `if`/`unless` block body, splitting it at a top-level `else` into
-   * a then-branch and an else-branch so each is reordered as a self-contained unit
-   * and the `else` keyword itself is translated. Without this, the body is reordered
-   * as one stream: `else` rides along glued to the preceding clause (and, when that
-   * clause begins with a selector, is marked a selector and left *untranslated*),
-   * and a spurious `then` is inserted around it — both of which break the target
-   * text and the downstream parse. The split is depth-aware so an `else` belonging
-   * to a nested block is not mistaken for this block's separator. Bodies without an
-   * `else` transform exactly as before.
-   */
-  transformConditionalBody(bodyTokens) {
-    const src = this.sourceProfile.code;
-    const dst = this.targetProfile.code;
-    const sourceElse = translateWord("else", "en", src).toLowerCase();
-    let depth = 0;
-    let elseIdx = -1;
-    for (let i = 0; i < bodyTokens.length; i++) {
-      const t = bodyTokens[i].toLowerCase();
-      if (BLOCK_BODY_KEYWORDS.has(t)) depth++;
-      else if (t === "end" && depth > 0) depth--;
-      else if (t === sourceElse && depth === 0) {
-        elseIdx = i;
-        break;
-      }
-    }
-    if (elseIdx === -1) {
-      const body = bodyTokens.join(" ");
-      return body ? this.transform(body) : "";
-    }
-    const thenBranch = bodyTokens.slice(0, elseIdx).join(" ");
-    const elseBranch = bodyTokens.slice(elseIdx + 1).join(" ");
-    const elseT = translateWord(bodyTokens[elseIdx], src, dst);
-    return [
-      thenBranch ? this.transform(thenBranch) : "",
-      elseT,
-      elseBranch ? this.transform(elseBranch) : ""
-    ].filter((s) => s.length > 0).join(" ");
-  }
-  /**
-   * Translate a reactive block by translating the head/tail/connector
-   * via the dictionary, recursively transforming the body through the
-   * regular pipeline, and rejoining in source-language position order.
-   * Block-syntactic tokens are never reordered: they're delimiters, not
-   * arguments, and authors expect them at start/end positions
-   * regardless of target word order.
-   */
-  transformBlock(block) {
-    const src = this.sourceProfile.code;
-    const dst = this.targetProfile.code;
-    const head = translateWord(block.headKeyword, src, dst);
-    const tail = block.tailKeyword ? translateWord(block.tailKeyword, src, dst) : "";
-    const connector = block.connector ? translateWord(block.connector, src, dst) : "";
-    const prefix = block.prefixExpr ? translateMultiWordValue(block.prefixExpr, src, dst) : "";
-    const body = this.transform(block.body);
-    return [head, prefix, connector, body, tail].filter((s) => s.length > 0).join(" ");
-  }
-  /**
-   * Find the best matching rule for this statement
-   */
-  findRule(parsed) {
-    if (!this.targetProfile.rules) return void 0;
-    const matchingRules = this.targetProfile.rules.filter((rule) => this.matchesRule(parsed, rule)).sort((a, b) => b.priority - a.priority);
-    return matchingRules[0];
-  }
-  /**
-   * Check if a parsed statement matches a rule
-   */
-  matchesRule(parsed, rule) {
-    const { match } = rule;
-    for (const role of match.requiredRoles) {
-      if (!parsed.roles.has(role)) {
-        return false;
-      }
-    }
-    if (match.commands && match.commands.length > 0) {
-      const action = parsed.roles.get("action");
-      if (!action) return false;
-      const actionValue = action.value.toLowerCase();
-      if (!match.commands.some((cmd) => cmd.toLowerCase() === actionValue)) {
-        return false;
-      }
-    }
-    if (match.predicate && !match.predicate(parsed)) {
-      return false;
-    }
-    return true;
-  }
-};
-function toLocale(input, targetLocale) {
-  const transformer = new GrammarTransformer("en", targetLocale);
-  return transformer.transform(input);
-}
-function toEnglish(input, sourceLocale) {
-  const transformer = new GrammarTransformer(sourceLocale, "en");
-  return transformer.transform(input);
-}
-function translate(input, sourceLocale, targetLocale) {
-  if (sourceLocale === targetLocale) return input;
-  if (sourceLocale === "en") return toLocale(input, targetLocale);
-  if (targetLocale === "en") return toEnglish(input, sourceLocale);
-  if (hasDirectMapping(sourceLocale, targetLocale)) {
-    return translateDirect(input, sourceLocale, targetLocale);
-  }
-  const english = toEnglish(input, sourceLocale);
-  return toLocale(english, targetLocale);
-}
-function translateDirect(input, sourceLocale, targetLocale) {
-  const mapping = getDirectMapping(sourceLocale, targetLocale);
-  if (!mapping) {
-    return toLocale(toEnglish(input, sourceLocale), targetLocale);
-  }
-  const tokens = input.split(/\s+/);
-  const translated = tokens.map((token) => {
-    if (token.startsWith("#") || token.startsWith(".") || token.startsWith("@")) {
-      return token;
-    }
-    if (token.startsWith('"') || token.startsWith("'")) {
-      return token;
-    }
-    const directTranslation = mapping.words[token];
-    if (directTranslation) {
-      return directTranslation;
-    }
-    const suffixMatch = token.match(/^(.+?)(-.+)$/);
-    if (suffixMatch) {
-      const [, base, suffix] = suffixMatch;
-      const translatedBase = mapping.words[base] || base;
-      return translatedBase + suffix;
-    }
-    return token;
-  });
-  return translated.join(" ");
-}
-var examples = {
-  english: {
-    eventHandler: "on click increment #count",
-    putInto: "put my value into #output",
-    toggle: "toggle .active",
-    wait: "wait 2 seconds"
-  },
-  // Expected outputs (approximate, for reference)
-  japanese: {
-    eventHandler: "#count \u3092 \u30AF\u30EA\u30C3\u30AF \u3067 \u5897\u52A0",
-    putInto: "\u79C1\u306E \u5024 \u3092 #output \u306B \u7F6E\u304F",
-    toggle: ".active \u3092 \u5207\u308A\u66FF\u3048",
-    wait: "2\u79D2 \u5F85\u3064"
-  },
-  chinese: {
-    eventHandler: "\u5F53 \u70B9\u51FB \u65F6 \u589E\u52A0 #count",
-    putInto: "\u628A \u6211\u7684\u503C \u653E \u5230 #output",
-    toggle: "\u5207\u6362 .active",
-    wait: "\u7B49\u5F85 2\u79D2"
-  },
-  arabic: {
-    eventHandler: "\u0632\u0650\u062F #count \u0639\u0646\u062F \u0627\u0644\u0646\u0642\u0631",
-    putInto: "\u0636\u0639 \u0642\u064A\u0645\u062A\u064A \u0641\u064A #output",
-    toggle: "\u0628\u062F\u0651\u0644 .active",
-    wait: "\u0627\u0646\u062A\u0638\u0631 \u062B\u0627\u0646\u064A\u062A\u064A\u0646"
-  }
-};
-
 // src/index.ts
 var defaultTranslator = new HyperscriptTranslator({ locale: "en" });
 var defaultRuntime = new RuntimeI18nManager({ locale: "en" });
@@ -15953,7 +14097,6 @@ exports.ENGLISH_COMMANDS = ENGLISH_COMMANDS;
 exports.ENGLISH_KEYWORDS = ENGLISH_KEYWORDS;
 exports.EnhancedI18nInputSchema = EnhancedI18nInputSchema;
 exports.EnhancedI18nOutputSchema = EnhancedI18nOutputSchema;
-exports.GrammarTransformer = GrammarTransformer;
 exports.HyperscriptI18nWebpackPlugin = HyperscriptI18nWebpackPlugin;
 exports.HyperscriptTranslator = HyperscriptTranslator;
 exports.LANGUAGE_FAMILY_DEFAULTS = LANGUAGE_FAMILY_DEFAULTS;
@@ -16007,7 +14150,6 @@ exports.getI18n = getI18n;
 exports.getPlural = getPlural;
 exports.getProfile = getProfile;
 exports.getSupportedLocales = getSupportedLocales;
-exports.grammarExamples = examples;
 exports.hi = hi;
 exports.hiDictionary = hindiDictionary;
 exports.hiKeywords = hiKeywords;
@@ -16036,7 +14178,6 @@ exports.malayProfile = malayProfile;
 exports.ms = ms2;
 exports.msDictionary = ms;
 exports.msKeywords = msKeywords;
-exports.parseStatement = parseStatement;
 exports.pl = pl2;
 exports.plDictionary = pl;
 exports.plKeywords = plKeywords;
@@ -16066,14 +14207,11 @@ exports.thKeywords = thKeywords;
 exports.tl = tl2;
 exports.tlDictionary = tl;
 exports.tlKeywords = tlKeywords;
-exports.toEnglish = toEnglish;
-exports.toLocale = toLocale;
 exports.tokenize = tokenize;
 exports.tr = tr2;
 exports.trDictionary = tr;
 exports.trKeywords = trKeywords;
 exports.transformStatement = transformStatement;
-exports.translate = translate;
 exports.translateFromEnglish = translateFromEnglish;
 exports.turkishProfile = turkishProfile;
 exports.uk = uk;