@lokascript/i18n 2.11.1 → 3.0.0

package/dist/index.js

@@ -4523,7 +4523,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",
@@ -7435,25 +7439,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);
       }
@@ -7461,7 +7465,7 @@ var HyperscriptTranslator = class {
     const result = {
       translated,
       tokens: translatedTokens,
-      locale: { from: fromLocale, to: toLocale2 },
+      locale: { from: fromLocale, to: toLocale },
       warnings: []
     };
     if (options.preserveOriginal) {
@@ -7469,9 +7473,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: {},
@@ -7486,7 +7490,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;
@@ -7617,39 +7621,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",
@@ -7882,69 +7853,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 = {}) {
@@ -14177,1774 +14085,10 @@ 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" });
 
-export { DICTIONARY_CATEGORIES, DateFormatter, ENGLISH_COMMANDS, ENGLISH_KEYWORDS, EnhancedI18nInputSchema, EnhancedI18nOutputSchema, GrammarTransformer, HyperscriptI18nWebpackPlugin, HyperscriptTranslator, LANGUAGE_FAMILY_DEFAULTS, LocaleFormatter, LocaleManager, NumberFormatter, PluralAwareTranslator, RuntimeI18nManager, SSRLocaleManager, TypedI18nContextImplementation, UNIVERSAL_ENGLISH_KEYWORDS, UNIVERSAL_PATTERNS, ar2 as ar, ar as arDictionary, arKeywords, arabicProfile, bn2 as bn, bn as bnDictionary, bnKeywords, chineseProfile, createEnglishProvider, createEnhancedI18n, createExpressI18nMiddleware, createI18nContext, createKeywordProvider, de2 as de, de as deDictionary, deKeywords, defaultRuntime, defaultTranslator, detectBrowserLocale, detectLocale, dictionaries, en2 as en, englishProfile, enhancedI18nImplementation, es2 as es, es as esDictionary, esKeywords, findInDictionary, forEachCategory, formatForLocale, fr2 as fr, fr as frDictionary, frKeywords, getBrowserLocales, getDictionary, getDictionaryCategory, getFormatter, getI18n, getPlural, getProfile, getSupportedLocales, examples as grammarExamples, hi, hindiDictionary as hiDictionary, hiKeywords, hyperscriptI18nVitePlugin, id2 as id, id as idDictionary, idKeywords, indonesianProfile, initializeI18n, insertMarkers, isDictionaryCategory, isLocaleSupported, isRTL, it2 as it, it as itDictionary, itKeywords, ja2 as ja, ja as jaDictionary, jaKeywords, japaneseProfile, ko2 as ko, ko as koDictionary, koKeywords, koreanProfile, malayProfile, ms2 as ms, ms as msDictionary, msKeywords, parseStatement, pl2 as pl, pl as plDictionary, plKeywords, pluralRules, pluralTimeExpressions, profiles, pt2 as pt, pt as ptDictionary, ptKeywords, qu2 as qu, qu as quDictionary, quKeywords, quechuaProfile, reorderRoles, ru, russianDictionary as ruDictionary, ruKeywords, runtimeI18n, spanishProfile, supportedLocales, sw2 as sw, sw as swDictionary, swKeywords, swahiliProfile, th2 as th, th as thDictionary, thKeywords, tl2 as tl, tl as tlDictionary, tlKeywords, toEnglish, toLocale, tokenize, tr2 as tr, tr as trDictionary, trKeywords, transformStatement, translate, translateFromEnglish, turkishProfile, uk, ukrainianDictionary as ukDictionary, ukKeywords, validate, vi2 as vi, vi as viDictionary, viKeywords, withI18n, zh2 as zh, zh as zhDictionary, zhKeywords };
+export { DICTIONARY_CATEGORIES, DateFormatter, ENGLISH_COMMANDS, ENGLISH_KEYWORDS, EnhancedI18nInputSchema, EnhancedI18nOutputSchema, HyperscriptI18nWebpackPlugin, HyperscriptTranslator, LANGUAGE_FAMILY_DEFAULTS, LocaleFormatter, LocaleManager, NumberFormatter, PluralAwareTranslator, RuntimeI18nManager, SSRLocaleManager, TypedI18nContextImplementation, UNIVERSAL_ENGLISH_KEYWORDS, UNIVERSAL_PATTERNS, ar2 as ar, ar as arDictionary, arKeywords, arabicProfile, bn2 as bn, bn as bnDictionary, bnKeywords, chineseProfile, createEnglishProvider, createEnhancedI18n, createExpressI18nMiddleware, createI18nContext, createKeywordProvider, de2 as de, de as deDictionary, deKeywords, defaultRuntime, defaultTranslator, detectBrowserLocale, detectLocale, dictionaries, en2 as en, englishProfile, enhancedI18nImplementation, es2 as es, es as esDictionary, esKeywords, findInDictionary, forEachCategory, formatForLocale, fr2 as fr, fr as frDictionary, frKeywords, getBrowserLocales, getDictionary, getDictionaryCategory, getFormatter, getI18n, getPlural, getProfile, getSupportedLocales, hi, hindiDictionary as hiDictionary, hiKeywords, hyperscriptI18nVitePlugin, id2 as id, id as idDictionary, idKeywords, indonesianProfile, initializeI18n, insertMarkers, isDictionaryCategory, isLocaleSupported, isRTL, it2 as it, it as itDictionary, itKeywords, ja2 as ja, ja as jaDictionary, jaKeywords, japaneseProfile, ko2 as ko, ko as koDictionary, koKeywords, koreanProfile, malayProfile, ms2 as ms, ms as msDictionary, msKeywords, pl2 as pl, pl as plDictionary, plKeywords, pluralRules, pluralTimeExpressions, profiles, pt2 as pt, pt as ptDictionary, ptKeywords, qu2 as qu, qu as quDictionary, quKeywords, quechuaProfile, reorderRoles, ru, russianDictionary as ruDictionary, ruKeywords, runtimeI18n, spanishProfile, supportedLocales, sw2 as sw, sw as swDictionary, swKeywords, swahiliProfile, th2 as th, th as thDictionary, thKeywords, tl2 as tl, tl as tlDictionary, tlKeywords, tokenize, tr2 as tr, tr as trDictionary, trKeywords, transformStatement, translateFromEnglish, turkishProfile, uk, ukrainianDictionary as ukDictionary, ukKeywords, validate, vi2 as vi, vi as viDictionary, viKeywords, withI18n, zh2 as zh, zh as zhDictionary, zhKeywords };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map