@lokascript/i18n 2.11.1 → 3.1.0

package/dist/lokascript-i18n.mjs

@@ -6,60 +6,6 @@
  * Maps English modifier keywords to their semantic roles.
  * Used by both the grammar transformer and keyword provider.
  */
-const ENGLISH_MODIFIER_ROLES = {
-    to: 'destination',
-    into: 'destination',
-    from: 'source',
-    with: 'style',
-    by: 'quantity',
-    as: 'method',
-    on: 'event',
-    over: 'duration',
-    for: 'duration',
-};
-/**
- * Maps a command verb to its **primary** semantic role \u2014 the role of the
- * command's first/leading argument when no explicit modifier keyword marks it.
- *
- * The generic argument parser in the transformer defaults the first unmarked
- * argument to `patient`, which is correct for the majority of commands
- * (`toggle .x`, `add .x`, \u2026) but wrong for commands whose leading argument is a
- * non-patient \u2014 e.g. `wait <duration>`. Marking a duration as a patient emits a
- * spurious object-marker in the target language (Chinese `\u7b49\u5f85 \u628a 1s`, ungrammatical;
- * Japanese `1s \u3092 \u5f85\u3064`; Korean `1s \ub97c \ub300\uae30`), which the semantic parser then fails to
- * match \u2014 dropping the command.
- *
- * Only commands whose primary role is **not** `patient` are listed here (the
- * `patient` default already covers the rest). Mirrors the `primaryRole` field of
- * the semantic package's command schemas (`@lokascript/semantic`); kept in sync by
- * `schema-alignment.test.ts` so this local copy can't drift without the bundle
- * having to pull in the whole semantic graph.
- *
- * @see packages/i18n/src/schema-alignment.test.ts
- * @see docs-internal/ZH_BLOCK_BODY_SCOPE.md (#1 \u2014 transformer role model)
- */
-const 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 \u2014 aligned with the transformer's patient marking
-    // in the session-9 role-layout swap), and patient is the default.
-    bind: 'destination',
-};
 /**
  * English modifier keywords (derived from ENGLISH_MODIFIER_ROLES)
  */
@@ -323,79 +269,6 @@ const ENGLISH_EXPRESSION_KEYWORDS = new Set([
     'starts with',
     'ends with',
 ]);
-// =============================================================================
-// Conditional Keywords
-// =============================================================================
-/**
- * Conditional keywords across languages (for statement type identification).
- * Includes 'when'/'where' conditional modifiers and their translations.
- */
-const CONDITIONAL_KEYWORDS = 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\u00f9',
-    // Portuguese
-    'quando',
-    'onde',
-    // Turkish
-    'e\u011fer',
-    'zaman',
-    'nerede',
-    // Indonesian
-    'ketika',
-    'saat',
-    'dimana',
-    // Korean
-    '\ub54c',
-    '\uc5b4\ub514\uc11c',
-    // Quechua
-    'maypi',
-    // Swahili
-    'wakati',
-    'wapi',
-]);
-/**
- * "Then" keywords across languages (for conditional parsing).
- */
-const THEN_KEYWORDS = new Set([
-    'then',
-    '\u305d\u308c\u304b\u3089',
-    '\u90a3\u4e48',
-    '\u062b\u0645',
-    'entonces',
-    'alors',
-    'dann',
-    'sonra',
-    'lalu',
-    'chayqa',
-    'kisha',
-]);
 
 // packages/i18n/src/parser/create-provider.ts
 /**
@@ -623,7 +496,7 @@ function createEnglishProvider() {
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const es$1 = {
+const es = {
     commands: {
         on: 'en',
         tell: 'decir',
@@ -847,13 +720,13 @@ const es$1 = {
  * parser.parse('en clic alternar .active');
  * ```
  */
-const esKeywords = createKeywordProvider(es$1, 'es', {
+const esKeywords = createKeywordProvider(es, 'es', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const ja$1 = {
+const ja = {
     commands: {
         on: '\u3067',
         tell: '\u4f1d\u3048\u308b',
@@ -1091,13 +964,13 @@ const ja$1 = {
  * parser.parse('\u30af\u30ea\u30c3\u30af \u3067 \u5207\u308a\u66ff\u3048 .active');
  * ```
  */
-const jaKeywords = createKeywordProvider(ja$1, 'ja', {
+const jaKeywords = createKeywordProvider(ja, 'ja', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const fr$1 = {
+const fr = {
     commands: {
         on: 'sur',
         tell: 'dire',
@@ -1329,13 +1202,13 @@ const fr$1 = {
  * parser.parse('sur clic basculer .active');
  * ```
  */
-const frKeywords = createKeywordProvider(fr$1, 'fr', {
+const frKeywords = createKeywordProvider(fr, 'fr', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const de$1 = {
+const de = {
     commands: {
         on: 'bei',
         tell: 'sagen',
@@ -1588,13 +1461,13 @@ const de$1 = {
  * parser.parse('bei klick umschalten .active');
  * ```
  */
-const deKeywords = createKeywordProvider(de$1, 'de', {
+const deKeywords = createKeywordProvider(de, 'de', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const ar$1 = {
+const ar = {
     commands: {
         on: '\u0639\u0644\u0649',
         tell: '\u0623\u062e\u0628\u0631',
@@ -1832,13 +1705,13 @@ const ar$1 = {
  * parser.parse('\u0639\u0644\u0649 \u0646\u0642\u0631 \u0628\u062f\u0644 .active');
  * ```
  */
-const arKeywords = createKeywordProvider(ar$1, 'ar', {
+const arKeywords = createKeywordProvider(ar, 'ar', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const ko$1 = {
+const ko = {
     commands: {
         on: '\uc5d0',
         tell: '\ub9d0\ud558\ub2e4',
@@ -2073,13 +1946,13 @@ const ko$1 = {
  * parser.parse('\uc5d0 \ud074\ub9ad \ud1a0\uae00 .active');
  * ```
  */
-const koKeywords = createKeywordProvider(ko$1, 'ko', {
+const koKeywords = createKeywordProvider(ko, 'ko', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const zh$1 = {
+const zh = {
     commands: {
         on: '\u5f53',
         tell: '\u544a\u8bc9',
@@ -2328,13 +2201,13 @@ const zh$1 = {
  * parser.parse('\u5f53 \u70b9\u51fb \u5207\u6362 .active');
  * ```
  */
-const zhKeywords = createKeywordProvider(zh$1, 'zh', {
+const zhKeywords = createKeywordProvider(zh, 'zh', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const tr$1 = {
+const tr = {
     commands: {
         on: '\u00fczerinde',
         tell: 's\u00f6yle',
@@ -2581,13 +2454,13 @@ const tr$1 = {
  * parser.parse('\u00fczerinde t\u0131klama de\u011fi\u015ftir .active');
  * ```
  */
-const trKeywords = createKeywordProvider(tr$1, 'tr', {
+const trKeywords = createKeywordProvider(tr, 'tr', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const id$1 = {
+const id = {
     commands: {
         on: 'pada',
         tell: 'katakan',
@@ -2831,13 +2704,13 @@ const id$1 = {
  * parser.parse('pada klik ganti .active');
  * ```
  */
-const idKeywords = createKeywordProvider(id$1, 'id', {
+const idKeywords = createKeywordProvider(id, 'id', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const qu$1 = {
+const qu = {
     commands: {
         on: 'kaqpi',
         tell: 'niy',
@@ -3097,13 +2970,13 @@ const qu$1 = {
  * parser.parse('\u00f1itiy-pi yapay #count-ta');
  * ```
  */
-const quKeywords = createKeywordProvider(qu$1, 'qu', {
+const quKeywords = createKeywordProvider(qu, 'qu', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const sw$1 = {
+const sw = {
     commands: {
         on: 'kwenye',
         tell: 'ambia',
@@ -3370,13 +3243,13 @@ const sw$1 = {
  * parser.parse('kwenye bonyeza badilisha .active');
  * ```
  */
-const swKeywords = createKeywordProvider(sw$1, 'sw', {
+const swKeywords = createKeywordProvider(sw, 'sw', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const pt$1 = {
+const pt = {
     commands: {
         on: 'em',
         tell: 'dizer',
@@ -3615,13 +3488,13 @@ const pt$1 = {
  * parser.parse('em clique alternar .active');
  * ```
  */
-const ptKeywords = createKeywordProvider(pt$1, 'pt', {
+const ptKeywords = createKeywordProvider(pt, 'pt', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const it$1 = {
+const it = {
     commands: {
         on: 'su',
         tell: 'dire',
@@ -3830,13 +3703,13 @@ const it$1 = {
     },
 };
 
-const itKeywords = createKeywordProvider(it$1, 'it', {
+const itKeywords = createKeywordProvider(it, 'it', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const vi$1 = {
+const vi = {
     commands: {
         on: 'khi',
         tell: 'n\u00f3i v\u1edbi',
@@ -4043,13 +3916,13 @@ const vi$1 = {
     },
 };
 
-const viKeywords = createKeywordProvider(vi$1, 'vi', {
+const viKeywords = createKeywordProvider(vi, 'vi', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const pl$1 = {
+const pl = {
     commands: {
         on: 'gdy',
         tell: 'powiedz',
@@ -4264,7 +4137,7 @@ const pl$1 = {
     },
 };
 
-const plKeywords = createKeywordProvider(pl$1, 'pl', {
+const plKeywords = createKeywordProvider(pl, 'pl', {
     allowEnglishFallback: true,
 });
 
@@ -5161,7 +5034,11 @@ const 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: `\u0996\u09be\u09b2\u09bf-\u0995\u09b0\u09c1\u09a8` 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',
@@ -5171,9 +5048,9 @@ const bengaliDictionary = {
         'joined by': '\u09a6\u09cd\u09ac\u09be\u09b0\u09be_\u09af\u09c1\u0995\u09cd\u09a4',
     },
 };
-const bn$1 = bengaliDictionary;
+const bn = bengaliDictionary;
 
-const bnKeywords = createKeywordProvider(bn$1, 'bn', {
+const bnKeywords = createKeywordProvider(bn, 'bn', {
     allowEnglishFallback: true,
 });
 
@@ -5358,9 +5235,9 @@ const thaiDictionary = {
         'joined by': '\u0e23\u0e27\u0e21\u0e14\u0e49\u0e27\u0e22',
     },
 };
-const th$1 = thaiDictionary;
+const th = thaiDictionary;
 
-const thKeywords = createKeywordProvider(th$1, 'th', {
+const thKeywords = createKeywordProvider(th, 'th', {
     allowEnglishFallback: true,
 });
 
@@ -5596,9 +5473,9 @@ const malayDictionary = {
         index: 'indeks',
     },
 };
-const ms$1 = malayDictionary;
+const ms = malayDictionary;
 
-const msKeywords = createKeywordProvider(ms$1, 'ms', {
+const msKeywords = createKeywordProvider(ms, 'ms', {
     allowEnglishFallback: true,
 });
 
@@ -5840,15 +5717,15 @@ const tagalogDictionary = {
         index: 'indeks',
     },
 };
-const tl$1 = tagalogDictionary;
+const tl = tagalogDictionary;
 
-const tlKeywords = createKeywordProvider(tl$1, 'tl', {
+const tlKeywords = createKeywordProvider(tl, 'tl', {
     allowEnglishFallback: true,
 });
 
 // Generated/merged from semantic profiles \u2014 hand-written entries are preserved
 // To add derived entries, update the semantic profile and run: npm run generate:language-assets
-const he$1 = {
+const he = {
     commands: {
         add: '\u05d4\u05d5\u05e1\u05e3',
         append: '\u05e6\u05e8\u05e3',
@@ -5968,7 +5845,7 @@ const he$1 = {
  * parser.parse('\u05d1 \u05dc\u05d7\u05d9\u05e6\u05d4 \u05de\u05ea\u05d2 .active');
  * ```
  */
-const heKeywords = createKeywordProvider(he$1, 'he', {
+const heKeywords = createKeywordProvider(he, 'he', {
     allowEnglishFallback: true,
 });
 
@@ -6150,7 +6027,7 @@ function detectBrowserLocale() {
  * English dictionary - identity mapping since English is the canonical hyperscript language.
  * This exists primarily for symmetry in translation operations (e.g., en -> es).
  */
-const en$1 = {
+const en = {
     commands: {
         // Event handling
         on: 'on',
@@ -8250,7 +8127,7 @@ function buildMappingFromDictionaries(sourceDict, targetDict, sourceCode, target
  * These languages share many concepts through Kanji/Hanzi,
  * making direct translation more accurate than pivot translation.
  */
-const jaZhMapping = buildMappingFromDictionaries(ja$1, zh$1, 'ja', 'zh');
+const jaZhMapping = buildMappingFromDictionaries(ja, zh, 'ja', 'zh');
 /**
  * Chinese to Japanese mapping (reverse of jaZh)
  */
@@ -8264,7 +8141,7 @@ const zhJaMapping = reverseMapping(jaZhMapping);
  * Both are SOV languages with postposition particles,
  * sharing grammatical structure that enables more natural translation.
  */
-const koJaMapping = buildMappingFromDictionaries(ko$1, ja$1, 'ko', 'ja');
+const koJaMapping = buildMappingFromDictionaries(ko, ja, 'ko', 'ja');
 /**
  * Japanese to Korean mapping (reverse of koJa)
  */
@@ -8452,2513 +8329,5 @@ function getSupportedDirectPairs() {
     });
 }
 
-/**
- * Dictionary Index
- *
- * Exports dictionaries for all supported languages.
- * Each dictionary maps English canonical keywords to locale-specific translations
- * across 8 categories: commands, modifiers, events, logical, temporal, values,
- * attributes, and expressions.
- *
- * Derivation utilities (deriveFromProfile, createEnglishDictionary) are available
- * for generating dictionaries from semantic language profiles. See ./derive.ts.
- */
-// Import per-language dictionaries
-// =============================================================================
-// Dictionary Exports
-// =============================================================================
-/** English dictionary */
-const en = en$1;
-/** Spanish dictionary */
-const es = es$1;
-/** Japanese dictionary */
-const ja = ja$1;
-/** Korean dictionary */
-const ko = ko$1;
-/** Chinese dictionary */
-const zh = zh$1;
-/** French dictionary */
-const fr = fr$1;
-/** German dictionary */
-const de = de$1;
-/** Arabic dictionary */
-const ar = ar$1;
-/** Turkish dictionary */
-const tr = tr$1;
-/** Indonesian dictionary */
-const id = id$1;
-/** Portuguese dictionary */
-const pt = pt$1;
-/** Quechua dictionary */
-const qu = qu$1;
-/** Swahili dictionary */
-const sw = sw$1;
-/** Italian dictionary */
-const it = it$1;
-/** Vietnamese dictionary */
-const vi = vi$1;
-/** Polish dictionary */
-const pl = pl$1;
-/** Russian dictionary */
-const ru = russianDictionary;
-/** Ukrainian dictionary */
-const uk = ukrainianDictionary;
-/** Hindi dictionary */
-const hi = hindiDictionary;
-/** Bengali dictionary */
-const bn = bengaliDictionary;
-/** Thai dictionary */
-const th = thaiDictionary;
-/** Malay dictionary */
-const ms = malayDictionary;
-/** Tagalog dictionary */
-const tl = tagalogDictionary;
-/** Hebrew dictionary */
-const he = he$1;
-// =============================================================================
-// Dictionary Registry
-// =============================================================================
-/**
- * All available dictionaries indexed by locale code.
- */
-const dictionaries = {
-    en,
-    es,
-    ko,
-    zh,
-    fr,
-    de,
-    ja,
-    ar,
-    tr,
-    id,
-    qu,
-    sw,
-    pt,
-    it,
-    vi,
-    pl,
-    ru,
-    uk,
-    hi,
-    bn,
-    th,
-    ms,
-    tl,
-    he,
-};
-
-// packages/i18n/src/types.ts
-/**
- * All valid dictionary categories.
- */
-const DICTIONARY_CATEGORIES = [
-    'commands',
-    'modifiers',
-    'events',
-    'logical',
-    'temporal',
-    'values',
-    'attributes',
-    'expressions',
-];
-/**
- * Find a translation in any category of a dictionary.
- * Returns the English key if found, undefined otherwise.
- */
-function findInDictionary(dict, localizedWord) {
-    const normalized = localizedWord.toLowerCase();
-    for (const category of DICTIONARY_CATEGORIES) {
-        const entries = dict[category];
-        for (const [english, localized] of Object.entries(entries)) {
-            if (localized.toLowerCase() === normalized) {
-                return { category, englishKey: english };
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Find a translation for an English word in any category.
- * Returns the localized word if found, undefined otherwise.
- */
-function translateFromEnglish(dict, englishWord) {
-    const normalized = englishWord.toLowerCase();
-    for (const category of DICTIONARY_CATEGORIES) {
-        const entries = dict[category];
-        const translated = entries[normalized];
-        if (translated) {
-            return translated;
-        }
-    }
-    return undefined;
-}
-
-/**
- * Grammar-Aware Transformer
- *
- * Transforms hyperscript statements between languages using the
- * generalized grammar system. The key insight is that semantic
- * roles are universal - only their surface realization differs.
- */
-// =============================================================================
-// Compound Statement Handling
-// =============================================================================
-/**
- * Get all command keywords including translated ones for a locale.
- */
-function getCommandKeywordsForLocale(locale) {
-    const keywords = new Set(ENGLISH_COMMANDS);
-    // Add translated command keywords from dictionaries
-    const dict = dictionaries[locale];
-    if (dict?.commands) {
-        Object.values(dict.commands).forEach(cmd => {
-            if (typeof cmd === 'string') {
-                keywords.add(cmd.toLowerCase());
-            }
-        });
-    }
-    return keywords;
-}
-/**
- * English copula forms. A command keyword IMMEDIATELY after one of these is a
- * predicate adjective, not a command verb: in `if my value is empty add .error
- * to me` the `empty` belongs to the condition (`empty` is also a hyperscript
- * command, v0.9.90). Without this guard the condition/body scans cut the
- * condition at `is` and displace the adjective into the body's argument zone,
- * where it anchors a spurious `empty-{lang}-generated` parse AND steals a
- * neighboring role (the empty \u00d78 bn/hi/tr family). Source-locale copulas are
- * added via the dictionary in `isPredicateAdjectivePosition`.
- */
-const 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;
-}
-/**
- * True when tokens[i] sits right after a copula \u2014 a predicate-adjective
- * position that must never be read as the start of a body command.
- */
-function isPredicateAdjectivePosition(tokens, i, copulas) {
-    const prev = tokens[i - 1]?.toLowerCase();
-    return !!prev && copulas.has(prev);
-}
-/**
- * Source-locale surface forms of the `for` command keyword and the loop's
- * `in` preposition, for the loop-head test below.
- */
-function getForLoopWordsForLocale(locale) {
-    const forWords = new Set(['for']);
-    const inWords = new Set(['in']);
-    if (locale !== 'en') {
-        forWords.add(translateWord('for', 'en', locale).toLowerCase());
-        inWords.add(translateWord('in', 'en', locale).toLowerCase());
-    }
-    return { forWords, inWords };
-}
-/**
- * True when a `for` at tokens[i] heads a real loop. Hyperscript's only
- * statement-head `for` is `for <var> in <iterable>`, so a `for` with no `in`
- * among the tokens before the next command keyword is a ROLE PHRASE \u2014 take's
- * target (`take .active from .tab-button for me`) or a duration (`for 2s`) \u2014
- * and must never split the statement: the split shattered the phrase into a
- * dangling `then for me` clause, which six SOV languages then parsed as a
- * spurious `for` loop with patient "me" (the take-class \u00d76 family).
- */
-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;
-}
-/**
- * Repair a FRONTED Hebrew accusative marker in transformed output.
- *
- * When an event-handler body leads with a command-modifier (`on click once add \u2026`,
- * via {@link GrammarTransformer.tryTransformEventWithModifierBody}) or is a control
- * block (`on blur if \u2026 add \u2026 end`, via `tryTransformEventWithBlockBody`), the body
- * command's accusative marker \u05d0\u05ea can be emitted AHEAD of its verb \u2014 `add .error to me`
- * renders `\u2026 \u05d0\u05ea \u05d4\u05d5\u05e1\u05e3 .error \u2026` instead of the canonical `\u2026 \u05d4\u05d5\u05e1\u05e3 \u05d0\u05ea .error \u2026`. \u05d0\u05ea before
- * a verb is always ungrammatical Hebrew (it only ever marks a FOLLOWING definite
- * object), and the semantic parser drops the command in every parse path (fused-event,
- * multi-clause, conditional-body) when the marker is fronted but parses it when the
- * marker follows the verb. So an `<accusative-marker> <command-verb>` adjacency is a
- * pure transformer artifact: swap it back. Idempotent and safe \u2014 only touches `\u05d0\u05ea
- * <verb>`, never the ~40 generated `<verb> \u05d0\u05ea {patient}` patterns that embed \u05d0\u05ea legitimately.
- */
-function repairHebrewFrontedAccusative(text) {
-    const ACC = '\u05d0\u05ea'; // hebrewProfile.markers patient marker
-    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++; // skip the marker we just moved
-        }
-    }
-    return changed ? tokens.join(' ') : text;
-}
-/**
- * Detect a reactive block (`live ... end`, `when X changes Y [end]`,
- * `unless X Y [end]`) and decompose it. Returns `null` when the input
- * is not a reactive block, when there's content after the matched
- * `end`, or when the heuristic can't locate a body \u2014 all of which fall
- * through to the standard `parseStatement` path.
- */
-function extractBlockStructure(input, sourceLocale) {
-    const tokens = input.split(/\s+/);
-    const head = tokens[0]?.toLowerCase();
-    if (!head || !BLOCK_HEAD_KEYWORDS.has(head))
-        return null;
-    // Depth-aware match for the closing `end` so nested blocks
-    // (`live when X changes Y end end`) slice correctly.
-    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 there's trailing content after the matched `end`, bail out and
-    // let the existing splitter handle it. (`splitOnThen` normally
-    // separates trailing code before we get here.)
-    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') {
-        // Reactive: `when <expr> changes <body>`. Without `changes`, fall
-        // through to the standard event-wait path (parseConditional).
-        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;
-    }
-    // `unless <cond> <body>`: condition runs up to the first command
-    // keyword in `inner`. Heuristic \u2014 works because hyperscript bodies
-    // always start with a command verb, and `unless` conditions rarely
-    // contain bare command keywords as values. A candidate right after a
-    // copula (`\u2026 is empty`) is a predicate adjective inside the condition,
-    // not a body verb \u2014 skip it.
-    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) {
-    // First, split on newlines (preserving non-empty lines)
-    const lines = input
-        .split(/\n/)
-        .map(line => line.trim())
-        .filter(line => line.length > 0);
-    // If we have multiple lines, treat each as a separate part
-    // (but still need to handle "then" within each line)
-    const parts = [];
-    for (const line of lines) {
-        const lineParts = splitOnThen(line, sourceLocale);
-        // Further split each part on command boundaries
-        for (const part of lineParts) {
-            const commandParts = splitOnCommandBoundaries(part, sourceLocale);
-            parts.push(...commandParts);
-        }
-    }
-    return parts;
-}
-/**
- * Split a compound statement while preserving line structure metadata.
- * This tracks indentation and blank lines for reconstruction.
- */
-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];
-        // Capture leading whitespace
-        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) {
-            // Process non-empty lines for "then" and command boundaries
-            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 };
-}
-/**
- * Normalize indentation to consistent 4-space levels.
- * Preserves relative indentation structure while standardizing spacing.
- */
-function normalizeIndentation(lineMetadata) {
-    // Find non-blank lines with indentation
-    const indentedLines = lineMetadata.filter(m => !m.isBlank && m.originalIndent.length > 0);
-    if (indentedLines.length === 0) {
-        // No indented lines, return empty strings
-        return lineMetadata.map(() => '');
-    }
-    // Find minimum non-zero indent (the base unit)
-    const indentLengths = indentedLines.map(m => {
-        // Convert tabs to 4 spaces for consistent measurement
-        const normalized = m.originalIndent.replace(/\t/g, '    ');
-        return normalized.length;
-    });
-    const minIndent = Math.min(...indentLengths);
-    const baseUnit = minIndent > 0 ? minIndent : 4;
-    // Normalize each line's indentation
-    return lineMetadata.map(meta => {
-        if (meta.isBlank) {
-            return ''; // Blank lines get no indentation
-        }
-        if (meta.originalIndent.length === 0) {
-            return ''; // No original indent
-        }
-        // Convert tabs and calculate level
-        const normalized = meta.originalIndent.replace(/\t/g, '    ');
-        const level = Math.round(normalized.length / baseUnit);
-        return '    '.repeat(level); // 4 spaces per level
-    });
-}
-/**
- * Reconstruct output with preserved line structure.
- * Maps transformed parts back to their original lines with proper indentation.
- */
-function reconstructWithLineStructure(transformedParts, lineMetadata, partToLineIndex, targetThen) {
-    // If there's only one non-blank line, simple case
-    const nonBlankCount = lineMetadata.filter(m => !m.isBlank).length;
-    if (nonBlankCount <= 1 && transformedParts.length <= 1) {
-        const normalizedIndents = normalizeIndentation(lineMetadata);
-        const result = [];
-        for (let i = 0; i < lineMetadata.length; i++) {
-            if (lineMetadata[i].isBlank) {
-                result.push('');
-            }
-            else if (transformedParts.length > 0) {
-                result.push(normalizedIndents[i] + transformedParts[0]);
-            }
-        }
-        return result.join('\n');
-    }
-    // Normalize indentation
-    const normalizedIndents = normalizeIndentation(lineMetadata);
-    // Group transformed parts by their original line
-    const partsPerLine = 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]);
-    }
-    // Build result lines
-    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) {
-                // Join multiple parts on same line with "then"
-                const lineContent = lineParts.join(` ${targetThen} `);
-                result.push(indent + lineContent);
-            }
-        }
-    }
-    return result.join('\n');
-}
-/**
- * Split a statement on command keyword boundaries.
- * E.g., "wait 2s toggle .highlight" \u2192 ["wait 2s", "toggle .highlight"]
- *
- * Special cases:
- * - "on <event> <command>" stays together (event handler with first command)
- * - Modifiers like "to", "from" don't trigger splits
- */
-/**
- * English modifier keywords that should not trigger command boundary splits.
- * These are the base set; localized equivalents (e.g. Japanese `\u306b`, Spanish
- * `a`, Arabic `\u0625\u0644\u0649`) are layered on per source locale by
- * `getBoundaryModifiersForLocale`, so a preposition in a non-English source
- * is also recognized as a modifier rather than a spurious command boundary.
- */
-const BOUNDARY_MODIFIERS = new Set([
-    'to',
-    'into',
-    'from',
-    'with',
-    'by',
-    'as',
-    'at',
-    'in',
-    'on',
-    'of',
-    'over',
-]);
-/**
- * Boundary modifiers resolved for a given source locale: the English base set
- * (always kept, since input may mix English keywords) plus every grammatical
- * marker form declared by the locale's profile. Profile markers are the
- * surface realizations of semantic roles (destination, source, style, \u2026) \u2014
- * they always bind to a following value, so none should be treated as a
- * command boundary. Cached per locale because profiles are static.
- */
-const boundaryModifiersCache = 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;
-}
-/**
- * Commands for which a trailing `on <element>` is the TARGET the command acts
- * on (a destination), not a new event-handler clause. For these, the locative
- * `on` must neither split the statement (`splitOnCommandBoundaries`) nor be read
- * as a fresh `event` role (`buildArgumentModifierMap`) \u2014 see those call sites.
- *
- * Deliberately narrow. `on` is overloaded (event-handler head vs. locative
- * target), and the change has cross-language blast radius, so we only enable
- * the locative reading for the DOM class/attribute mutators where it's the
- * documented idiom (`toggle .open on #menu`, `toggle @hidden on #panel`).
- *
- * `trigger`/`send` \u2014 `trigger X on Y` / `send X on Y` fire an event on a target
- * element; the trailing `on Y` is that target (destination), not a new clause.
- * Previously excluded: keeping `on Y` attached produced `trigger X \u2192 #y` output
- * that was thought to destabilise the semantic parser's multi-line behaviour
- * fallback (behavior-sortable's `trigger sortable:start on me`). That concern is
- * stale \u2014 the recent semantic-parser body increments fold the surrounding block
- * cleanly, and splitting instead injected a spurious `then` (`disparar
- * sortable:start entonces en yo`) that glued the following `repeat until event`
- * loop into a then-chain and dropped it. Keeping `on Y` attached restores
- * behavior-sortable to faithful across the SVO languages.
- *
- * Excluded on purpose:
- *  - `set` \u2014 `set @attr to V on Y` carries BOTH `to` (value) and `on` (target);
- *    English marks both as `destination`, so remapping `on` would collide with
- *    and clobber the value. Needs distinct value/target roles first (deferred).
- *  - `put` \u2014 `put X on Y into Z` has the same dual-destination collision.
- *
- * `add`/`remove` use `to`/`from` for their target in practice (not `on`), so
- * their inclusion is a harmless no-op that documents intent.
- */
-const ON_TARGET_COMMANDS = new Set(['toggle', 'add', 'remove', 'trigger', 'send']);
-/**
- * Find the command verb of a partially-collected statement: the first command
- * keyword that is neither the event-handler head (`on`/\u305d\u306e\u4ed6 event markers) nor
- * an argument-introducing preposition. For `on click toggle .open` \u2192 `toggle`;
- * for `trigger sortable:start` \u2192 `trigger`.
- */
-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;
-}
-/**
- * Block-introducing keywords whose body should not be split at command
- * boundaries by `splitOnCommandBoundaries`. Inputs starting with one of
- * these are also routed around `parseStatement` entirely by
- * `extractBlockStructure` + `transformBlock` so block-syntactic tokens
- * never reach `parseCommand`/`parseConditional` (where they'd be
- * misinterpreted as command verbs or swept into role values).
- *
- * `if` deliberately stays out: `if X then Y end` already works via the
- * `splitOnThen` + `parseConditional` path.
- */
-const BLOCK_HEAD_KEYWORDS = new Set(['live', 'when', 'unless']);
-/**
- * Source-language block-introducing command keywords whose body is a clause plus a
- * branch/loop body (harness source is English, so these are English-keyed). Used to
- * locate a block body inside an event handler and to track block depth when finding
- * a top-level `else`.
- */
-const BLOCK_BODY_KEYWORDS = new Set(['if', 'repeat', 'unless', 'while', 'for']);
-/**
- * SVO targets that mark the object/patient with a particle (he \u05d0\u05ea, zh \u628a) and so
- * mangle an inline `on <event> unless <cond> <body>` guard \u2014 the unless tail is
- * swept into one patient blob and the marker lands ahead of the condition. These
- * route through `tryTransformEventWithUnlessGuard`. SOV/VSO object-markers
- * (ja/ko/tr/ar) are excluded: their event does not lead, so the SVO event-first
- * emission there would be wrong (and they don't exhibit the artifact today).
- */
-const UNLESS_GUARD_OBJECT_MARKING_LOCALES = 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 = [];
-    // Check if this starts with an event handler pattern (on/em/en/bei/\u3067 + event)
-    const firstTokenLower = tokens[0]?.toLowerCase();
-    const isEventHandler = EVENT_KEYWORDS.has(firstTokenLower);
-    // If it's an event handler, the first command after the event is part of the handler
-    // So we need to track whether we've seen the first command yet
-    let seenFirstCommand = !isEventHandler; // If not event handler, we're already past the "first command" phase
-    // Track block-scope depth (live/when/bind/if/unless/for/while/...). While
-    // inside a block, do not split on command boundaries \u2014 the body belongs
-    // to the block head and must transform as one unit. See comments on
-    // BLOCK_HEAD_KEYWORDS for the failure mode this prevents.
-    let blockDepth = 0;
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        const lowerToken = token.toLowerCase();
-        // Update block-scope depth before any split decision.
-        if (BLOCK_HEAD_KEYWORDS.has(lowerToken)) {
-            blockDepth++;
-        }
-        else if (lowerToken === 'end' && blockDepth > 0) {
-            blockDepth--;
-        }
-        // If this is a command keyword and we already have tokens in current part
-        if (commandKeywords.has(lowerToken) && currentPart.length > 0) {
-            // Check if the previous token looks like it could end a command
-            const prevToken = currentPart[currentPart.length - 1];
-            const prevLower = prevToken.toLowerCase();
-            // For event handlers: don't split before the first command
-            // E.g., "on click wait 1s" should stay together
-            if (!seenFirstCommand) {
-                // Mark that we've now seen the first command
-                seenFirstCommand = true;
-                currentPart.push(token);
-                continue;
-            }
-            // Don't split inside a block (live/when/bind/unless body, etc.).
-            // The block head and its body must transform as one statement.
-            if (blockDepth > 0) {
-                currentPart.push(token);
-                continue;
-            }
-            // A `for` that doesn't head a real loop (`for <var> in <iterable>`) is a
-            // role phrase of the current command \u2014 see isLoopHeadFor.
-            if (forWords.has(lowerToken) && !isLoopHeadFor(tokens, i, inWords, commandKeywords)) {
-                currentPart.push(token);
-                continue;
-            }
-            // Locative `on` for a DOM-target command (`toggle X on Y`) is the target
-            // element, NOT a new command. `on` lands in `commandKeywords` only
-            // incidentally \u2014 the EN dictionary registers `commands.on = 'on'` for the
-            // event-handler head \u2014 so without this guard the destination `on` split
-            // the statement, the join re-inserted a spurious `then` (\u062b\u0645/pagkatapos/\u2026),
-            // and the dangling `on Y` was misread as a second event handler. Keep it
-            // attached so the role parser can assign it to `destination`. Restricted
-            // to ON_TARGET_COMMANDS so `trigger X on me` etc. keep their prior split.
-            if (BOUNDARY_MODIFIERS.has(lowerToken)) {
-                const verb = commandVerbOf(currentPart, commandKeywords);
-                if (verb && ON_TARGET_COMMANDS.has(verb)) {
-                    currentPart.push(token);
-                    continue;
-                }
-                // `set @attr to V on <scope>` (S1 tabs-aria): the trailing `on <scope>`
-                // is the element(s) the attribute is set on, not a new command. `set` is
-                // deliberately NOT in ON_TARGET_COMMANDS (its role parser would clobber
-                // the value), so this is a dedicated guard \u2014 kept attached only when a
-                // selector/reference scope follows, then positioned by transformSingle's
-                // set-scope handler (transformSetWithScope). A `set` whose `on` is
-                // followed by a verb is left to split as before.
-                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)) {
-                // This looks like a command boundary - save current part and start new one
-                parts.push(currentPart.join(' '));
-                currentPart = [token];
-                continue;
-            }
-        }
-        currentPart.push(token);
-    }
-    // Add the last part
-    if (currentPart.length > 0) {
-        parts.push(currentPart.join(' '));
-    }
-    return parts.filter(p => p.length > 0);
-}
-/**
- * Split a single line on "then" keywords.
- */
-function splitOnThen(input, sourceLocale) {
-    // Build regex pattern from all known "then" keywords
-    const thenKeywords = Array.from(THEN_KEYWORDS);
-    // Add any dictionary-specific "then" keyword for the source locale
-    const sourceDict = sourceLocale === 'en' ? null : dictionaries[sourceLocale];
-    if (sourceDict?.modifiers?.then) {
-        thenKeywords.push(sourceDict.modifiers.then);
-    }
-    // Also check logical.then since some dictionaries put it there
-    if (sourceDict?.logical?.then) {
-        thenKeywords.push((sourceDict?.logical).then);
-    }
-    // Create a regex that matches any "then" keyword as a whole word
-    // Use word boundaries to avoid matching "then" inside other words
-    const escapedKeywords = thenKeywords.map(k => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
-    const pattern = new RegExp(`\\s+(${escapedKeywords.join('|')})\\s+`, 'gi');
-    // Split on "then" keywords
-    const parts = input.split(pattern).filter(part => {
-        // Filter out the "then" keywords themselves (captured by the group)
-        const lowerPart = part.toLowerCase().trim();
-        return lowerPart && !thenKeywords.some(k => k.toLowerCase() === lowerPart);
-    });
-    return parts.map(p => p.trim()).filter(p => p.length > 0);
-}
-/**
- * Get the "then" keyword in the target language.
- * Checks both modifiers and logical sections since dictionaries vary.
- */
-function getTargetThenKeyword(targetLocale) {
-    if (targetLocale === 'en')
-        return 'then';
-    const targetDict = dictionaries[targetLocale];
-    if (!targetDict)
-        return 'then';
-    // Check modifiers first, then logical (dictionaries vary)
-    return (targetDict.modifiers?.then || targetDict.logical?.then || 'then');
-}
-// =============================================================================
-// Derived Constants from Profiles
-// =============================================================================
-/**
- * Derive event keywords from all language profiles.
- * This replaces the hardcoded eventKeywords array.
- */
-function deriveEventKeywordsFromProfiles() {
-    const keywords = new Set();
-    // Add 'on' as the English default
-    keywords.add('on');
-    // Extract event markers from all profiles
-    for (const profile of Object.values(profiles)) {
-        for (const marker of profile.markers) {
-            if (marker.role === 'event') {
-                // Strip hyphen notation and add
-                const form = marker.form.replace(/^-|-$/g, '').toLowerCase();
-                if (form)
-                    keywords.add(form);
-                // Add alternatives
-                marker.alternatives?.forEach(alt => {
-                    const altForm = alt.replace(/^-|-$/g, '').toLowerCase();
-                    if (altForm)
-                        keywords.add(altForm);
-                });
-            }
-        }
-    }
-    return keywords;
-}
-/** Event keywords derived from language profiles */
-const EVENT_KEYWORDS = deriveEventKeywordsFromProfiles();
-/**
- * Conjunctions that join multiple events in an event handler head
- * (`on click or keypress ...`). Source hyperscript is English, so the
- * canonical form is `or`; localized equivalents are added defensively for
- * non-English sources.
- */
-const EVENT_CONJUNCTIONS = new Set(['or']);
-/**
- * Command-modifier keywords that may lead an event handler body
- * (`on click async fetch \u2026`, `on click once add \u2026`). They modify the handler /
- * following command rather than acting as the verb, so the transformer must lift
- * them out before role assignment instead of treating them as the action.
- * Source hyperscript is English, so these are the canonical English forms \u2014 the
- * semantic parser recognizes the same literals when stripping them pre-parse.
- */
-const BODY_MODIFIER_KEYWORDS = new Set([
-    'async',
-    'once',
-    'debounced',
-    'debounce',
-    'throttled',
-    'throttle',
-]);
-// =============================================================================
-// Helper: Dynamic Modifier Map
-// =============================================================================
-/**
- * Generates a lookup map for semantic roles based on the language profile.
- * Maps markers (e.g., 'to', '\u306b', 'into', '\u0625\u0644\u0649') to their semantic roles.
- * This enables parsing non-English input by using the profile's markers.
- */
-function generateModifierMap(profile) {
-    const map = {};
-    // Map markers to roles from the profile
-    profile.markers.forEach(marker => {
-        // Strip hyphen notation for suffix/prefix markers
-        const form = marker.form.replace(/^-|-$/g, '').toLowerCase();
-        if (form) {
-            map[form] = marker.role;
-        }
-        // Map alternatives if they exist (e.g., Korean vowel harmony variants)
-        marker.alternatives?.forEach(alt => {
-            const altForm = alt.replace(/^-|-$/g, '').toLowerCase();
-            if (altForm) {
-                map[altForm] = marker.role;
-            }
-        });
-    });
-    // Add English modifiers as fallback (don't override profile-specific markers)
-    for (const [key, role] of Object.entries(ENGLISH_MODIFIER_ROLES)) {
-        if (!(key in map)) {
-            map[key] = role;
-        }
-    }
-    return map;
-}
-/**
- * Modifier map for parsing the ARGUMENTS of a statement (everything after the
- * command verb), as opposed to the statement head.
- *
- * Why a separate map: a few languages reuse one word for both the event-handler
- * head marker and a locative/target preposition. English is the prime case \u2014
- * `on` is the event head (`on click \u2026`) AND the toggle/set target preposition
- * (`toggle .x on #y`). `generateModifierMap` maps `on \u2192 event` (from the EN
- * profile's event marker), so when the destination `on` was read in argument
- * position it overwrote the already-captured head event (the `click` got
- * dropped, e.g. `toggle @hidden on #panel` \u2192 `\u2026 \u0639\u0646\u062f #panel` with \u0646\u0642\u0631/click gone).
- *
- * The fix: in argument position, remap the event role to `destination`. This is
- * safe because a trigger event only ever appears at the statement head (which is
- * consumed before argument parsing begins). Any "event marker" reached while
- * scanning arguments is therefore being used as a locative \u2014 i.e. the element
- * the command acts ON \u2014 which is exactly the `destination` role (the semantic
- * parser also models `toggle .x on #y` as patient `.x` + destination `#y`).
- *
- * Restricted to (a) SVO source profiles and (b) ON_TARGET_COMMANDS:
- *  - SVO: in VSO/SOV languages the event marker can legitimately appear
- *    mid-statement (Arabic VSO renders an event handler as `\u0628\u062f\u0644 X \u0639\u0646\u062f \u0646\u0642\u0631`,
- *    classified as a command), so remapping there would mis-read a real event
- *    as a destination. English \u2014 and the en\u2192lang gate path \u2014 is SVO.
- *  - command: only the DOM class/attr mutators use a locative `on` target.
- *    For other commands (`trigger X on me`, `set X to V on Y`) the remap is
- *    either destabilising or collides with `to`/`into` \u2014 see ON_TARGET_COMMANDS.
- *
- * When neither applies the unmodified map is returned (event stays event).
- */
-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;
-}
-// =============================================================================
-// Statement Parser
-// =============================================================================
-/**
- * Parse a hyperscript statement into semantic roles
- * This is the core analysis step that identifies WHAT each part means
- */
-function parseStatement(input, sourceLocale = 'en') {
-    const profile = getProfile(sourceLocale);
-    if (!profile)
-        return null;
-    const tokens = tokenize(input, profile);
-    // Identify statement type and extract roles
-    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;
-    }
-}
-/**
- * Known suffixes that may attach to words without spaces.
- * These are split off during tokenization for proper parsing.
- */
-const ATTACHED_SUFFIXES = {
-    // Chinese: \u65f6 (time/when) often attaches to events like \u70b9\u51fb\u65f6 (when clicking)
-    zh: ['\u65f6', '\u7684', '\u5730', '\u5f97'],
-    // Japanese: Some particles may attach in casual writing
-    ja: [],
-    // Korean: Particles sometimes written without spaces
-    ko: [],
-};
-/**
- * Known prefixes that may attach to words without spaces.
- */
-const ATTACHED_PREFIXES = {
-    // Chinese: \u5f53 (when) sometimes written attached
-    zh: ['\u5f53'],
-    // Arabic: Prepositions that attach
-    ar: ['\u0628\u0640', '\u0643\u0640', '\u0648'],
-};
-/**
- * Post-process tokens to split attached suffixes/prefixes.
- * E.g., "\u70b9\u51fb\u65f6" \u2192 ["\u70b9\u51fb", "\u65f6"]
- */
-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) {
-        // Skip CSS selectors and numbers
-        if (/^[#.<@]/.test(token) || /^\d+/.test(token)) {
-            result.push(token);
-            continue;
-        }
-        let processed = token;
-        let prefix = '';
-        let suffix = '';
-        // Check for attached prefixes
-        for (const p of prefixes) {
-            if (processed.startsWith(p) && processed.length > p.length) {
-                prefix = p;
-                processed = processed.slice(p.length);
-                break;
-            }
-        }
-        // Check for attached suffixes
-        for (const s of suffixes) {
-            if (processed.endsWith(s) && processed.length > s.length) {
-                suffix = s;
-                processed = processed.slice(0, -s.length);
-                break;
-            }
-        }
-        // Add tokens in order: prefix, main, suffix
-        if (prefix)
-            result.push(prefix);
-        if (processed)
-            result.push(processed);
-        if (suffix)
-            result.push(suffix);
-    }
-    return result;
-}
-/**
- * Simple tokenizer that handles:
- * - Keywords (from dictionary)
- * - CSS selectors (#id, .class, <tag/>)
- * - String literals
- * - Numbers
- * - Attached suffixes/prefixes (language-specific)
- */
-function tokenize(input, profile) {
-    // Split on whitespace, preserving selectors and strings
-    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];
-        // Track CSS selector context
-        if (char === '<') {
-            inSelector = true;
-            selectorDepth++;
-        }
-        else if (char === '>' && inSelector) {
-            selectorDepth--;
-            if (selectorDepth === 0)
-                inSelector = false;
-        }
-        // Track event-guard / attribute brackets so `[key is 'Escape']` (which has
-        // internal spaces) stays a single token instead of splitting into
-        // `[key` / `is` / `'Escape']` \u2014 which mis-assigns `is` as the action verb.
-        if (char === '[') {
-            bracketDepth++;
-        }
-        else if (char === ']' && bracketDepth > 0) {
-            bracketDepth--;
-        }
-        // Track EVERY parenthesized group as a depth scope so it stays ONE token:
-        //
-        // - An ATTACHED `(` (a call or event destructure: `pointerdown(clientX,
-        //   clientY)`, `Resizable(a, b)`) must not split at the comma-space \u2014 the
-        //   event-handler-head reorder would separate the halves and drop the
-        //   whole handler (tl behavior-resizable degenerate).
-        // - A STANDALONE `(` opening an expression (`to (the value of #price as
-        //   Number) * (my value as Number)`) must be OPAQUE to role segmentation:
-        //   left loose, its interior `of`/`as`/`from` keywords hit the argument
-        //   modifier map, so the parser split the expression across roles \u2014 the
-        //   R1 cluster E mangle (computed-value: the transformer reordered INSIDE
-        //   the parens, embedded the event phrase mid-expression, and dropped the
-        //   whole second operand in every language). Interior keywords still
-        //   translate IN PLACE: role values are re-split on whitespace by
-        //   translateMultiWordValue, and translateWord strips paren punctuation
-        //   before its dictionary lookup (`($count or 0)` \u2192 `($count o 0)` in tl \u2014
-        //   the operator translates without the group being torn apart).
-        if (char === '(') {
-            parenDepth++;
-        }
-        else if (char === ')' && parenDepth > 0) {
-            parenDepth--;
-        }
-        // Split on whitespace unless inside a selector, a bracket guard, or an
-        // attached parenthesized argument list
-        if (/\s/.test(char) && !inSelector && bracketDepth === 0 && parenDepth === 0) {
-            if (current) {
-                tokens.push(current);
-                current = '';
-            }
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current) {
-        tokens.push(current);
-    }
-    // Post-process to split attached affixes for languages that need it
-    return splitAttachedAffixes(tokens, profile.code);
-}
-/**
- * Identify what type of statement this is
- */
-function identifyStatementType(tokens, profile) {
-    if (tokens.length === 0)
-        return 'unknown';
-    const firstToken = tokens[0].toLowerCase();
-    // Check for event handler
-    const eventMarker = profile.markers.find(m => m.role === 'event' && m.position === 'preposition');
-    if (eventMarker && firstToken === eventMarker.form.toLowerCase()) {
-        return 'event-handler';
-    }
-    // Check if first token is a known event keyword (derived from profiles)
-    if (EVENT_KEYWORDS.has(firstToken)) {
-        return 'event-handler';
-    }
-    // Check for conditional using shared constants
-    if (CONDITIONAL_KEYWORDS.has(firstToken)) {
-        return 'conditional';
-    }
-    return 'command';
-}
-/**
- * Parse an event handler statement
- * Pattern: on {event} {command} {target?} {modifiers?}
- *
- * Now handles modifiers like "by 3" in "on click increment #count by 3"
- */
-function parseEventHandler(tokens, profile) {
-    const roles = new Map();
-    // Skip the event keyword (e.g., 'on', '\u3067', '\u5f53', etc.) - derived from profiles
-    let startIndex = EVENT_KEYWORDS.has(tokens[0]?.toLowerCase()) ? 1 : 0;
-    // Next token is the event
-    if (tokens[startIndex]) {
-        const eventTokens = [tokens[startIndex]];
-        startIndex++;
-        // Fold "or"-conjoined events into the event value (e.g.
-        // "on click or keypress[...] toggle .active"). Without this, "or" would be
-        // read as the action verb and the second event swept into role values,
-        // hoisting "or <event2>" ahead of the command on reorder. Keeping the whole
-        // "<event1> or <event2>" string in the event role lets it translate and
-        // reorder as a single event clause. Only consumes "or" that immediately
-        // follows the event, before any source/action \u2014 so a later "or" in a guard
-        // or value is untouched.
-        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(' '),
-        });
-    }
-    // Check for event source modifier before the action (e.g., "from #source" in "on input from #firstName set ...")
-    // Only handle 'from' (event source) \u2014 other modifiers like circumfix markers (Chinese \u65f6) should not be consumed.
-    if (tokens[startIndex] && tokens[startIndex].toLowerCase() === 'from' && tokens[startIndex + 1]) {
-        startIndex++; // skip 'from'
-        // Collect source value tokens until a command keyword is found
-        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),
-            });
-        }
-    }
-    // Next token is the action (command verb)
-    if (tokens[startIndex]) {
-        roles.set('action', {
-            role: 'action',
-            value: tokens[startIndex],
-        });
-        startIndex++;
-    }
-    // Parse remaining tokens with modifier awareness (like parseCommand does)
-    // This handles "by 3" in "on click increment #count by 3".
-    // Argument map: for DOM-target commands the head event is already captured, so
-    // a locative `on` (`toggle @hidden on #panel`) maps to `destination` rather
-    // than overwriting the head `event`.
-    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) {
-                // Save previous role
-                if (currentValue.length > 0) {
-                    const value = currentValue.join(' ');
-                    roles.set(currentRole, {
-                        role: currentRole,
-                        value,
-                        isSelector: /^[#.<@]/.test(value),
-                    });
-                }
-                currentRole = mappedRole;
-                currentValue = [];
-            }
-            else {
-                currentValue.push(token);
-            }
-        }
-        // Save final role
-        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(' '),
-    };
-}
-/**
- * Parse a command statement
- * Pattern: {command} {args...}
- */
-function parseCommand(tokens, profile) {
-    const roles = new Map();
-    if (tokens.length === 0) {
-        return { type: 'command', roles, original: '' };
-    }
-    // First token is the command
-    roles.set('action', {
-        role: 'action',
-        value: tokens[0],
-    });
-    // Generate dynamic modifier map from language profile (argument position).
-    // This enables parsing non-English input (e.g., Japanese \u306b, Korean \uc5d0, Arabic \u0625\u0644\u0649).
-    // For a DOM-target command a locative `on` (`toggle .active on me`) maps to
-    // `destination` (SVO sources) rather than spawning a bogus `event` role.
-    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) {
-            // Save previous role
-            if (currentValue.length > 0) {
-                const value = currentValue.join(' ');
-                roles.set(currentRole, {
-                    role: currentRole,
-                    value,
-                    isSelector: /^[#.<@]/.test(value),
-                });
-            }
-            currentRole = mappedRole;
-            currentValue = [];
-        }
-        else {
-            currentValue.push(token);
-        }
-    }
-    // Save final role
-    if (currentValue.length > 0) {
-        const value = currentValue.join(' ');
-        roles.set(currentRole, {
-            role: currentRole,
-            value,
-            isSelector: /^[#.<@]/.test(value),
-        });
-    }
-    return {
-        type: 'command',
-        roles,
-        original: tokens.join(' '),
-    };
-}
-/**
- * Re-assign a command's mis-marked primary argument from the default `patient`
- * role to its true primary role (e.g. `wait`'s leading argument is a `duration`,
- * not a fronted object).
- *
- * The generic argument parser in `parseCommand` / `parseEventHandler` defaults the
- * first unmarked argument to `patient`. For most commands that is correct, but for a
- * command whose primary role is a non-patient *and which the target language does not
- * give a marker* (a duration, a measure \u2014 never a BA/object construction), the
- * `patient` assignment makes `insertMarkers` emit a spurious object-marker (Chinese
- * `\u628a`, Japanese `\u3092`, Korean `\ub97c`). The marked form is ungrammatical and the semantic
- * parser fails to match it, dropping the command.
- *
- * The fix is deliberately scoped to **literal/measure** primary roles
- * ({@link LITERAL_PRIMARY_ROLES}: `duration`, `quantity`) \u2014 values that are *never*
- * the object of an object-marking construction in any supported language, so moving
- * them off `patient` can only ever *remove* a spurious marker. Marker-bearing
- * primaries are intentionally left alone:
- *  - `set`\u2192destination `\u5230`, `fetch`\u2192source `\u4ece` carry a *correct* marker; touching
- *    them risks no benefit.
- *  - `send`/`trigger`\u2192event: in a language without an event marker (e.g. Korean has
- *    no event particle) un-marking the leading argument makes the semantic parser
- *    mis-read it as a bare event handler and emit a phantom `on` action \u2014 an
- *    over-generation that recall-based fidelity would not catch. So `event`-primary
- *    commands stay on the `patient` default.
- *
- * Roles are still reordered by the safety-net in `reorderRoles`, so no value is lost.
- * A belt-and-suspenders target-marker guard keeps the change inert should a profile
- * ever add a marker for one of these literal roles.
- *
- * Must run *before* `translateElements`, while the `action` value is still the
- * source-language (English) keyword, so the schema lookup resolves.
- *
- * @see docs-internal/ZH_BLOCK_BODY_SCOPE.md (#1 \u2014 transformer role model)
- */
-const LITERAL_PRIMARY_ROLES = new Set([
-    'duration',
-    'quantity',
-]);
-function applyPrimaryRole(parsed, targetProfile) {
-    // Only re-mark standalone command statements. In an event handler (`on click
-    // wait 2s \u2026`) a verb-final SOV language without an event particle (e.g. Korean)
-    // relies on the leading argument's patient marker as the structural cue that
-    // anchors the handler; un-marking it makes the semantic parser lose the event.
-    // The block-body / then-chain `wait` clauses this fix targets are each parsed as
-    // their own command statement, so they are still covered.
-    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;
-    // Only act on a leading argument the generic parser defaulted to `patient`,
-    // and only when the primary slot isn't already filled by an explicit marker.
-    const patientEl = parsed.roles.get('patient');
-    if (!patientEl || parsed.roles.has(primaryRole))
-        return;
-    // Guard: never introduce a marker that wasn't there. If the target language
-    // marks the primary role, leave the command as-is.
-    if (targetProfile.markers.some(m => m.role === primaryRole))
-        return;
-    parsed.roles.delete('patient');
-    parsed.roles.set(primaryRole, { ...patientEl, role: primaryRole });
-}
-/**
- * Parse a conditional statement
- */
-function parseConditional(tokens, _profile) {
-    const roles = new Map();
-    // First token is the 'if' keyword
-    roles.set('action', {
-        role: 'action',
-        value: tokens[0],
-    });
-    // Find 'then' to split condition from body - using shared constants
-    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) {
-        // Block-style `if <cond>` with the body on following lines (no inline
-        // `then`). Capture everything after `if` as the condition; otherwise the
-        // condition is silently dropped and the rendered block becomes a bare
-        // `if`/`\u05d0\u05dd`/`\u5982\u679c`, which the semantic block parser then rejects (null
-        // parse). This is the dominant failure for nested control-flow bodies in
-        // non-Latin languages (he, zh).
-        roles.set('condition', {
-            role: 'condition',
-            value: tokens.slice(1).join(' '),
-        });
-    }
-    return {
-        type: 'conditional',
-        roles,
-        original: tokens.join(' '),
-    };
-}
-// =============================================================================
-// Translation
-// =============================================================================
-/**
- * Translate words using dictionary with type-safe access.
- */
-function translateWord(word, sourceLocale, targetLocale) {
-    // Don't translate CSS selectors
-    if (/^[#.<@]/.test(word)) {
-        return word;
-    }
-    // Don't translate numbers
-    if (/^\d+/.test(word)) {
-        return word;
-    }
-    // A whole parenthesized group fused by the tokenizer (`(the value of #price
-    // as Number)`) reaching a single-token translate path: translate its
-    // interior word-by-word IN ORDER \u2014 never reordered, never re-segmented.
-    if (/\s/.test(word) && word.startsWith('(')) {
-        return word
-            .split(/\s+/)
-            .map(w => translateWord(w, sourceLocale, targetLocale))
-            .join(' ');
-    }
-    // A word carrying paren punctuation from a fused group after whitespace
-    // re-splitting (`(my` / `valor)` / `(($x`): strip the parens for the
-    // dictionary lookup and re-attach, so interior keywords still translate.
-    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;
-    // If source is not English, first map to English using type-safe lookup
-    let englishWord = word;
-    if (sourceDict) {
-        const found = findInDictionary(sourceDict, word);
-        if (found) {
-            englishWord = found.englishKey;
-        }
-    }
-    // Now map English to target locale using type-safe lookup
-    const translated = translateFromEnglish(targetDict, englishWord);
-    return translated ?? word;
-}
-/**
- * Possessive markers for each language.
- * Used to transform "X's Y" patterns to target language structure.
- */
-const 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 `'\u0131n`), so the tokenizer can split
-    // it off the selector \u2014 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 (\u306e/\uc758/\u09b0) can.
-    qu: { type: 'particle', marker: 'pa' },
-    // Bengali SOV postposition genitive, like ja/ko \u2014 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 `\u0915\u093e` is intentionally omitted: its `bind` lacks a verb-final
-    // grammar rule, so fixing its possessive alone yields a wrong `on` parse \u2014
-    // tracked as separate follow-up.)
-    bn: { type: 'suffix', marker: '\u09b0' },
-    sw: { type: 'preposition', marker: 'ya' },
-};
-/**
- * Transform possessive 's syntax to target language.
- *
- * Examples:
- *   me's value \u2192 mi valor (Spanish - pronoun becomes possessive adjective)
- *   #button's textContent \u2192 textContent de #button (Spanish - prepositional)
- *   me's value \u2192 \u79c1\u306e\u5024 (Japanese - \u306e particle)
- */
-function translatePossessive(token, sourceLocale, targetLocale) {
-    // Check for 's possessive pattern
-    const possessiveMatch = token.match(/^(.+)'s$/i);
-    if (!possessiveMatch) {
-        return token;
-    }
-    const owner = possessiveMatch[1];
-    const targetMarker = POSSESSIVE_MARKERS[targetLocale] || POSSESSIVE_MARKERS.en;
-    // Check if owner is a pronoun that has a possessive form
-    const pronounPossessives = {
-        me: 'my',
-        it: 'its',
-        you: 'your',
-    };
-    const lowerOwner = owner.toLowerCase();
-    if (pronounPossessives[lowerOwner]) {
-        // Convert "me's" to "my" then translate
-        const possessiveForm = pronounPossessives[lowerOwner];
-        return translateWord(possessiveForm, 'en', targetLocale);
-    }
-    // For selectors and other owners, translate owner and apply target possessive marker
-    const translatedOwner = translateWord(owner, sourceLocale, targetLocale);
-    switch (targetMarker.type) {
-        case 'suffix':
-            // Japanese/Korean/Chinese: owner + marker (e.g., #button\u306e, #button\uc758)
-            return `${translatedOwner}${targetMarker.marker}`;
-        case 'particle':
-            // Latin-script spaced genitive (Quechua `pa`): owner + space + marker
-            // so the tokenizer can separate it from the selector.
-            return `${translatedOwner} ${targetMarker.marker}`;
-        case 'preposition':
-            // Will be handled by caller - return marker + owner format
-            // Store as special format to be processed later
-            return `__POSS__${targetMarker.marker}__${translatedOwner}__POSS__`;
-        default:
-            return `${translatedOwner}'s`;
-    }
-}
-// =============================================================================
-// Possessive Dot Notation
-// =============================================================================
-/**
- * Regex to match possessive dot notation patterns.
- * Matches: my.prop, its.prop, your.prop, me.prop, it.prop, you.prop
- * Also matches optional chaining: my?.prop, me?.prop, etc.
- */
-const POSSESSIVE_DOT_REGEX = /^(my|its|your|me|it|you)(\??\..+)$/i;
-/**
- * Map pronoun forms to possessive adjective forms for dictionary lookup.
- */
-const POSSESSIVE_DOT_PRONOUNS = {
-    me: 'my',
-    it: 'its',
-    you: 'your',
-    my: 'my',
-    its: 'its',
-    your: 'your',
-};
-/**
- * Translate possessive dot notation like my.textContent \u2192 mi.textContent.
- * Handles both possessive adjective forms (my, its, your) and pronoun forms (me, it, you).
- * Also handles optional chaining (my?.prop).
- * Returns null if the value doesn't match or no translation is available.
- */
-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]; // ".textContent" or "?.textContent"
-    // Normalize to possessive adjective form for dictionary lookup
-    const possessiveKey = POSSESSIVE_DOT_PRONOUNS[possessiveWord] || possessiveWord;
-    const translated = translateWord(possessiveKey, sourceLocale, targetLocale);
-    // Skip if translation is multi-word (can't prefix dot notation)
-    if (translated.includes(' '))
-        return null;
-    if (translated !== possessiveKey) {
-        return translated + propertySuffix;
-    }
-    // Try original pronoun form if different from possessive key
-    if (possessiveWord !== possessiveKey) {
-        const alt = translateWord(possessiveWord, sourceLocale, targetLocale);
-        if (alt !== possessiveWord && !alt.includes(' ')) {
-            return alt + propertySuffix;
-        }
-    }
-    return null;
-}
-// =============================================================================
-// Multi-Word Value Translation
-// =============================================================================
-/**
- * Translate a multi-word value, translating each word individually.
- * Handles possessives like "my value" \u2192 "mi valor" in Spanish.
- * Also handles 's possessive syntax like "me's value" \u2192 "mi valor".
- * Also handles possessive dot notation like "my.textContent" \u2192 "mi.textContent".
- */
-function translateMultiWordValue(value, sourceLocale, targetLocale) {
-    // Mask event-guard / attribute brackets (`[key is 'Escape']`): their contents
-    // are expression syntax, not translatable keywords \u2014 translating `is` -> `ni`
-    // etc. inside them breaks the guard. Restore verbatim after translation.
-    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 translated = translateMultiWordValue(masked, sourceLocale, targetLocale);
-            return translated.replace(/\ue000(\d+)\ue001/g, (_, n) => guards[Number(n)]);
-        }
-    }
-    // If it's a single word, check for possessive then translate
-    if (!value.includes(' ')) {
-        // Check for possessive 's
-        if (value.includes("'s")) {
-            return translatePossessive(value, sourceLocale, targetLocale);
-        }
-        // Check for possessive dot notation (my.prop, its.prop, me.prop, etc.)
-        const dotResult = translatePossessiveDotNotation(value, sourceLocale, targetLocale);
-        if (dotResult !== null)
-            return dotResult;
-        return translateWord(value, sourceLocale, targetLocale);
-    }
-    // Split into words and translate each
-    const words = value.split(/\s+/);
-    const translated = [];
-    let i = 0;
-    while (i < words.length) {
-        const word = words[i];
-        // Check for possessive 's pattern FIRST (e.g., "me's value", "#button's textContent")
-        // This must come before selector check because "#button's" starts with #
-        if (word.includes("'s")) {
-            const possessiveResult = translatePossessive(word, sourceLocale, targetLocale);
-            // Check if it's a prepositional possessive that needs reordering
-            const prepMatch = possessiveResult.match(/^__POSS__(.+)__(.+)__POSS__$/);
-            if (prepMatch && i + 1 < words.length) {
-                // Prepositional: "X's Y" \u2192 "Y marker X" (e.g., "textContent de #button")
-                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; // Skip property since we consumed it
-                continue;
-            }
-            else if (prepMatch) {
-                // No property following - just output owner with marker prefix
-                const marker = prepMatch[1];
-                const owner = prepMatch[2];
-                translated.push(`${marker} ${owner}`);
-                i++;
-                continue;
-            }
-            // Suffix-style possessive (Japanese, Korean, etc.) or pronoun
-            translated.push(possessiveResult);
-            i++;
-            continue;
-        }
-        // Skip pure CSS selectors and numbers (but NOT possessives which were handled above)
-        if (/^[#.<@]/.test(word) || /^\d+/.test(word)) {
-            translated.push(word);
-            i++;
-            continue;
-        }
-        // Skip quoted strings
-        if (/^["'].*["']$/.test(word)) {
-            translated.push(word);
-            i++;
-            continue;
-        }
-        // Check for possessive dot notation (my.prop, its.prop, me.prop, etc.)
-        const dotResult = translatePossessiveDotNotation(word, sourceLocale, targetLocale);
-        if (dotResult !== null) {
-            translated.push(dotResult);
-            i++;
-            continue;
-        }
-        translated.push(translateWord(word, sourceLocale, targetLocale));
-        i++;
-    }
-    return translated.join(' ');
-}
-/**
- * Translate all elements in a parsed statement
- */
-function translateElements(parsed, sourceLocale, targetLocale) {
-    for (const [_role, element] of parsed.roles) {
-        // Always process possessive 's syntax, even for selectors
-        // E.g., "#button's textContent" should translate the possessive
-        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;
-        }
-    }
-}
-// =============================================================================
-// Caret-scope masking (`^name on <selector>`)
-// =============================================================================
-/** Private-use sentinels bracketing a masked caret-scope index. */
-const CARET_SCOPE_OPEN = '\uE000';
-const CARET_SCOPE_CLOSE = '\uE001';
-/**
- * Match `^name on <selector>` and the scope's selector form (#id, .class,
- * <tag/>, [attr]). The `^name` is kept; only the ` on <selector>` scope is masked.
- */
-const CARET_SCOPE_RE = /(\^[A-Za-z_][\w-]*)(\s+on\s+(?:[#.][\w-]+|<[^>]*\/>|\[[^\]]+\]))/g;
-/**
- * Mask the ` on <selector>` scope of every `^name on <selector>` read behind an
- * opaque token attached to `^name`, so the overloaded `on` doesn't reach the
- * splitter / event-handler parser. Returns null when there's nothing to mask.
- */
-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;
-}
-/** Restore masked caret-scope tokens to their verbatim ` on <selector>` form. */
-function restoreCaretScopes(input, scopes) {
-    return input.replace(new RegExp(`${CARET_SCOPE_OPEN}(\\d+)${CARET_SCOPE_CLOSE}`, 'g'), (_m, n) => scopes[Number(n)] ?? '');
-}
-// =============================================================================
-// View-transition tail masking (`using view transition`)
-// =============================================================================
-/** Private-use sentinels bracketing a masked view-transition-tail index. */
-const VIEW_TAIL_OPEN = '\uE002';
-const VIEW_TAIL_CLOSE = '\uE003';
-/**
- * Match `swap`/`process`'s trailing `using view transition` modifier.
- *
- * `using` is in no dictionary and in no role table, so it sweeps into whatever
- * role phrase is open; `transition` IS a translated command keyword in every
- * dictionary (es `transici\u00f3n`, de `\u00fcbergang`, ja `\u9077\u79fb`) and is in
- * `ENGLISH_COMMANDS`, so `splitOnCommandBoundaries` splits the clause there and
- * the rejoin plants a phantom translated `transition` COMMAND after the target's
- * `then`-connective (`intercambiar #a con #b using view entonces transici\u00f3n`).
- *
- * The phrase has no native form in any of the 24 languages \u2014 semantic's
- * `USING_VIEW_MARKER_ALL_LANGS` matches the literal English `using view` marker
- * everywhere \u2014 so it is a passthrough, matched on the English surface regardless
- * of source locale. The value word is optional so a bare `using view` still
- * masks rather than half-splitting; `then` is excluded so a clause boundary is
- * never swallowed into the tail.
- */
-const VIEW_TAIL_RE = /\busing\s+view\b(?:\s+(?!then\b)[A-Za-z][\w-]*)?/gi;
-/** Whether a token is a masked view-transition tail. */
-const VIEW_TAIL_TOKEN_RE = new RegExp(`^${VIEW_TAIL_OPEN}(\\d+)${VIEW_TAIL_CLOSE}$`);
-/**
- * Mask every `using view <value>` tail behind an opaque token, so the phrase
- * never reaches the splitter, the word translator, or the role parser. Returns
- * null when there's nothing to mask.
- */
-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;
-}
-/** Restore masked view-transition tokens to their verbatim English phrase. */
-function restoreViewTransitionTails(input, tails) {
-    return input.replace(new RegExp(`${VIEW_TAIL_OPEN}(\\d+)${VIEW_TAIL_CLOSE}`, 'g'), (_m, n) => tails[Number(n)] ?? '');
-}
-// =============================================================================
-// Main Transformer
-// =============================================================================
-class GrammarTransformer {
-    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);
-        // Hebrew: repair a fronted accusative marker the body-split heuristics can emit
-        // (`\u2026 \u05d0\u05ea \u05d4\u05d5\u05e1\u05e3 .x \u2026` \u2192 `\u2026 \u05d4\u05d5\u05e1\u05e3 \u05d0\u05ea .x \u2026`). Applied to the assembled output; idempotent
-        // across the internal recursion. See repairHebrewFrontedAccusative.
-        return this.targetProfile.code === 'he' ? repairHebrewFrontedAccusative(out) : out;
-    }
-    transformInternal(input) {
-        // `using view transition` is a passthrough phrase, not translatable content:
-        // `using` is in no dictionary and `transition` is a COMMAND keyword, so left
-        // in place the splitter tears the clause apart there and the tail renders as
-        // a phantom translated command. Mask it before any splitting/translation and
-        // restore it verbatim; transformSingle re-appends the opaque token at the
-        // clause tail so it lands after the reorder, not inside a role phrase.
-        const viewTails = maskViewTransitionTails(input);
-        if (viewTails) {
-            return restoreViewTransitionTails(this.transformInternal(viewTails.masked), viewTails.tails);
-        }
-        // Caret-scoped variable reads (`^name on <selector>`) carry a second,
-        // overloaded `on` that the splitter/event-parser would mistake for an event
-        // or command boundary \u2014 mangling `put ^count on #host into me`. Mask the
-        // ` on <selector>` scope behind an opaque token attached to `^name` so the
-        // command reorders as if the patient were a single value, then restore it.
-        // `on` is kept verbatim (the semantic caret-scope matcher accepts it by raw
-        // value across languages \u2014 passthrough-alignment).
-        const caret = maskCaretScopes(input);
-        if (caret) {
-            return restoreCaretScopes(this.transform(caret.masked), caret.scopes);
-        }
-        const targetThen = getTargetThenKeyword(this.targetProfile.code);
-        // Inline JS blocks (`... js <raw js> end`) must be masked BEFORE any
-        // splitting/reordering: the body is raw JavaScript, not hyperscript, so it
-        // must never be tokenized, translated, or word-order reordered. (Single-line
-        // only here; multi-line js bodies are handled with the behavior work.)
-        if (!input.includes('\n')) {
-            const jsBlock = this.tryTransformJsBlock(input);
-            if (jsBlock !== null)
-                return jsBlock;
-            // Event handler whose body leads with a command-modifier
-            // (`on click async fetch \u2026`, `on click once add \u2026`): lift the modifier out
-            // so the real verb isn't mistaken for the action and the SOV reorder keeps
-            // the body patient-first (recoverable by the parser's SOV event extraction).
-            const eventModifier = this.tryTransformEventWithModifierBody(input);
-            if (eventModifier !== null)
-                return eventModifier;
-            // Event handler whose body is a block (`on <event> if/repeat/unless \u2026 end`):
-            // the block body must be reordered as a self-contained unit, not shredded
-            // across the event handler's role soup.
-            const eventBlock = this.tryTransformEventWithBlockBody(input);
-            if (eventBlock !== null)
-                return eventBlock;
-            // Event handler whose body is an un-terminated inline `unless` guard
-            // (`on click unless I match .disabled toggle .selected`): route the guard
-            // through the standalone block path so Hebrew's accusative marker lands on
-            // the body command, not the condition. Hebrew-only; null elsewhere.
-            const eventGuard = this.tryTransformEventWithUnlessGuard(input);
-            if (eventGuard !== null)
-                return eventGuard;
-        }
-        // Check if input has multi-line structure worth preserving
-        const hasMultiLineStructure = input.includes('\n');
-        if (hasMultiLineStructure) {
-            // Multi-line case - preserve structure (indentation, blank lines)
-            const { parts, lineMetadata, partToLineIndex } = splitCompoundStatementWithMetadata(input, this.sourceProfile.code);
-            const transformedParts = parts.map(part => this.transformSingle(part));
-            return reconstructWithLineStructure(transformedParts, lineMetadata, partToLineIndex, targetThen);
-        }
-        // Single-line case - use existing logic
-        const parts = splitCompoundStatement(input, this.sourceProfile.code);
-        if (parts.length > 1) {
-            const transformedParts = parts.map(part => this.transformSingle(part));
-            return transformedParts.join(` ${targetThen} `);
-        }
-        // Single statement (no "then" splitting needed)
-        return this.transformSingle(input);
-    }
-    /**
-     * Transform a single hyperscript statement (no compound "then" chains).
-     */
-    transformSingle(input) {
-        // 0. Reactive block? Route around parseStatement entirely so
-        //    block-syntactic tokens (live/when/unless/end) aren't treated
-        //    as command verbs or swept into role values, and so SOV/VSO
-        //    reorder applies only inside the body.
-        const block = extractBlockStructure(input, this.sourceProfile.code);
-        if (block) {
-            return this.transformBlock(block);
-        }
-        // 0a. Fragment carrying a stranded trailing block terminator (`wait 200ms
-        //     end`, `set x to y end` \u2014 what the `then`-splitter leaves from
-        //     `if \u2026 then <cmd> end`). `end` is not a marker, so left in place it is
-        //     swept into the open role's VALUE and rendered inside that phrase
-        //     (bn `200ms \u09b6\u09c7\u09b7 \u0995\u09c7 \u0985\u09aa\u09c7\u0995\u09cd\u09b7\u09be`). Strip it, transform the clause alone, and
-        //     re-append the translated terminator after the verb \u2014 the same tail
-        //     position transformBlockBody emits for event-headed blocks.
-        const strippedEnd = this.transformWithTrailingEnd(input);
-        if (strippedEnd !== null) {
-            return strippedEnd;
-        }
-        // 0b. `set @attr to V on <scope>` (S1 tabs-aria): strip the trailing
-        //     `on <scope>`, transform the scope-less set normally, then re-insert
-        //     `on <scope>` where the semantic set patterns expect it.
-        const setScope = this.transformSetWithScope(input);
-        if (setScope !== null) {
-            return setScope;
-        }
-        // 0c. Masked `using view transition` tail (see maskViewTransitionTails):
-        //     strip the opaque token, transform the clause without it, and re-append
-        //     it at the clause tail. Left in the token stream it would be swept into
-        //     the open role's VALUE and rendered ahead of that role's marker
-        //     (ja `#b using view transition \u3067` instead of `#b \u3067 using view
-        //     transition`) \u2014 the same failure mode transformWithTrailingEnd fixes
-        //     for a stranded `end`.
-        const viewTail = this.transformWithViewTransitionTail(input);
-        if (viewTail !== null) {
-            return viewTail;
-        }
-        // 1. Parse into semantic roles
-        const parsed = parseStatement(input, this.sourceProfile.code);
-        if (!parsed) {
-            return input; // Return unchanged if parsing fails
-        }
-        // 1b. Re-assign a mis-marked primary argument (e.g. `wait`'s duration) off the
-        //     default `patient` role so the target doesn't emit a spurious object-marker.
-        //     Runs before translation while `action` is still the English keyword.
-        applyPrimaryRole(parsed, this.targetProfile);
-        // 2. Translate individual words
-        translateElements(parsed, this.sourceProfile.code, this.targetProfile.code);
-        // 3. Find applicable rule
-        const rule = this.findRule(parsed);
-        // 4. Apply transformation
-        if (rule?.transform.custom) {
-            return rule.transform.custom(parsed, this.targetProfile);
-        }
-        // 5. Reorder according to target language's canonical order
-        const roleOrder = rule?.transform.roleOrder || this.targetProfile.canonicalOrder;
-        const reordered = reorderRoles(parsed.roles, roleOrder);
-        // 6. Insert grammatical markers
-        const shouldInsertMarkers = rule?.transform.insertMarkers ?? true;
-        if (shouldInsertMarkers) {
-            const result = insertMarkers(reordered, this.targetProfile.markers, this.targetProfile.adpositionType);
-            // Use joinTokens for proper suffix/prefix attachment (Turkish -i, Quechua -ta, etc.)
-            return joinTokens(result);
-        }
-        // 7. Join without markers (still use joinTokens for consistency)
-        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 \u2014 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 \u2014 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 \u2026> 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 \u2026 end`,
-     * `repeat \u2026 end`, `js \u2026 end`) bail \u2014 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;
-        // The `js` / `end` keyword forms in the SOURCE language.
-        const sourceJs = translateWord('js', 'en', src);
-        const sourceEnd = translateWord('end', 'en', src).toLowerCase();
-        const tokens = input.split(/\s+/).filter(t => t.length > 0);
-        // The js command token, optionally with a `(locals)` suffix: `js`, `js(me)`.
-        const escapedJs = sourceJs.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const jsRe = new RegExp(`^${escapedJs}(\\(.*\\))?$`, 'i');
-        const jsIdx = tokens.findIndex(t => jsRe.test(t));
-        if (jsIdx === -1)
-            return null;
-        // First `end` after the js keyword closes the block (raw JS never contains a
-        // bare hyperscript `end` token).
-        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;
-        // Trailing content after `end` \u2014 leave for the normal path.
-        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);
-        // Bare `js ... end` with no leading event-handler head: emit directly.
-        if (before.length === 0)
-            return replacement;
-        // Mask the block as one opaque action token, reorder the surrounding
-        // statement, then restore the verbatim block.
-        const placeholder = 'JSBLOCKPLACEHOLDER';
-        const reordered = this.transformSingle([...before, placeholder].join(' '));
-        if (!reordered.includes(placeholder))
-            return null; // unexpected \u2014 fall through
-        return reordered.replace(placeholder, replacement);
-    }
-    /**
-     * Transform an event handler whose body is a block command
-     * (`on <event> [from <src>] {if|repeat|unless|while|for} \u2026 end`).
-     *
-     * `parseEventHandler` would treat the block keyword as the action and sweep the
-     * condition/body into role values, then reorder them \u2014 shredding the block
-     * (`if event.shiftKey call submitAndContinue() end` \u2192 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 = tokenize(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;
-        // Only handle the explicitly-terminated form; un-terminated bodies
-        // (`on click unless X toggle Y`) keep the existing path.
-        if (tokens[tokens.length - 1].toLowerCase() !== 'end')
-            return null;
-        const eventHead = tokens.slice(0, blockIdx);
-        const blockTokens = tokens.slice(blockIdx);
-        // Event heads carrying a `from <source>` modifier (`on keydown[...] from
-        // .modal if \u2026 end`): for SVO/SOV targets, route them through this block-body
-        // path too \u2014 masking the block and emitting the event clause (incl. the
-        // translated `from <source>`, which `transformSingle` \u2192 `parseEventHandler`
-        // already reorders) first, then the transformed block. This keeps the if-block
-        // body from being shredded across the event handler's roles and properly
-        // translates its inner keywords (`in`/`focus`/`first`/positional); the old
-        // exclusion left them English and mangled the order (this is what cleared
-        // `focus-trap` in tr). VSO targets (ar, tl) are kept on the existing path:
-        // there the event-first emission with a `from`-source reorders incorrectly and
-        // regresses `focus-trap`/`window-keydown`, while the existing path already
-        // parses them. So the `from`-source exclusion is scoped to VSO only.
-        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);
-        // Always emit the event clause first, then the block. An event handler's
-        // event is a leading delimiter, and the semantic parser only matches a
-        // block body when it follows the event \u2014 even in verb-first (VSO) languages
-        // whose normal command order would push the event to the end. So strip the
-        // placeholder out of the (possibly reordered) head and append the block,
-        // rather than substituting in place.
-        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>` \u2014 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 \u2014 Hebrew's accusative
-     * \u05d0\u05ea (`\u2026 \u05d0\u05dc\u05d0 \u05d0\u05ea I match .disabled \u05de\u05ea\u05d2 .selected`) or Chinese's BA particle \u628a
-     * (`\u2026 \u9664\u975e \u628a I match .disabled \u5207\u6362 .selected`) \u2014 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` \u2192 `transformBlock`: condition kept marker-free, body
-     * command keeps its marker \u2014 he `\u05d0\u05dc\u05d0 I match .disabled \u05de\u05ea\u05d2 \u05d0\u05ea .selected`, zh
-     * `\u9664\u975e I match .disabled \u5207\u6362 \u628a .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 \u2014 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) {
-        // SVO object-marking targets only \u2014 these front the unless tail with an object
-        // marker (he \u05d0\u05ea / zh \u628a) that breaks the parse. Event-leads emission below
-        // assumes SVO, so SOV/VSO object-markers (ja/ko/tr/ar) are intentionally out.
-        if (!UNLESS_GUARD_OBJECT_MARKING_LOCALES.has(this.targetProfile.code))
-            return null;
-        const tokens = tokenize(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;
-        // The terminated form (`\u2026 unless \u2026 end`) is handled by
-        // tryTransformEventWithBlockBody's masking path; only take the inline guard.
-        if (tokens[tokens.length - 1].toLowerCase() === 'end')
-            return null;
-        const eventHead = tokens.slice(0, guardIdx);
-        const guard = tokens.slice(guardIdx).join(' ');
-        // `unless` is a BLOCK_HEAD keyword, so transform() routes the guard through
-        // extractBlockStructure \u2192 transformBlock (the standalone shape that parses).
-        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** (`\u53d6\u5f97 /api/data \u3092 \u30af\u30ea\u30c3\u30af \u2026`), and the semantic parser matches the
-     * leading `<verb> <patient>` with the low-priority `*-generated-verb-first`
-     * command pattern \u2014 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 \u2014 leaving simple/Mode-B handlers byte-identical.
-     */
-    tryTransformEventWithModifierBody(input) {
-        // The verb-first degenerate parse this works around is specific to SOV
-        // reorder: only there does a leading modifier displace the patient-first
-        // order and surface the verb first. SVO/VSO/V2/other targets keep the body
-        // in an order the parser already handles, so leave them byte-identical.
-        if (this.targetProfile.wordOrder !== 'SOV')
-            return null;
-        const tokens = tokenize(input, this.sourceProfile);
-        if (tokens.length === 0)
-            return null;
-        if (!EVENT_KEYWORDS.has(tokens[0]?.toLowerCase()))
-            return null;
-        // Walk past the event clause head: event keyword, event token, any
-        // `or`-conjoined events, and an optional `from <source>` modifier \u2014 mirroring
-        // parseEventHandler's head parsing \u2014 to find where the body begins.
-        let i = 1; // past the event keyword
-        if (!tokens[i])
-            return null;
-        i++; // past the event token
-        while (tokens[i] && EVENT_CONJUNCTIONS.has(tokens[i].toLowerCase()) && tokens[i + 1]) {
-            i += 2;
-        }
-        if (tokens[i]?.toLowerCase() === 'from' && tokens[i + 1]) {
-            i++; // skip 'from'
-            // Collect source tokens until a command verb or a body modifier.
-            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;
-        // Consume the modifier phrase. `debounced`/`throttled` may carry an optional
-        // `at <duration>` (or a bare duration). `async`/`once` are single tokens.
-        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(' ');
-        // A handler with only a modifier and no body has nothing to keep patient-first.
-        if (tokens.length - (modEnd - modStart) <= 2)
-            return null;
-        // Re-run the full transform on the modifier-free handler so then-chains and
-        // juxtaposed bodies route through the existing (working) paths. The rebuilt
-        // input no longer leads with a modifier, so this never re-enters here.
-        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 \u2014 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];
-        // Transform the scope-less clause via the normal path; `head` no longer ends
-        // in `on <scope>`, so this never re-enters transformSetWithScope.
-        const headOut = this.transformSingle(head);
-        const scopeT = /^[#.<@[]/.test(scopeRaw) ? scopeRaw : translateWord(scopeRaw, src, dst);
-        // SOV needs the scope positioned per how the semantic set patterns match:
-        //  - Event-handler set (`on <event> set \u2026`): the dest-first SOV event-handler
-        //    pattern is verb-MEDIAL and carries an optional trailing `[on {scope}]`,
-        //    so append the scope at the clause end.
-        //  - Standalone then-clause set: SOV emits verb-MEDIAL (`{dest} {verb}
-        //    {patient}`), but the only command set pattern with scope is verb-LAST
-        //    (`{dest} {patient} on {scope} {verb}`). Move the medial verb to the end
-        //    and place `on {scope}` before it, so the generated command pattern matches.
-        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) {
-                // Standalone then-clause set: SOV emits verb-MEDIAL; move the verb to the
-                // end and place `on {scope}` before it so the verb-last command set
-                // pattern (scope before verb) matches.
-                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) {
-                // Event-handler set whose verb is clause-final (e.g. qu
-                // `{dest} ta {patient} man {event} pi {verb}`): the parser extracts the
-                // event and matches the body as a verb-last command, so the scope must
-                // sit before the verb. Verb-MEDIAL SOV event handlers (ja/ko/tr/bn/hi)
-                // fall through to the append branch, where their fused event-handler set
-                // pattern carries the trailing `[on {scope}]` group.
-                toks.splice(toks.length - 1, 0, 'on', scopeT);
-                return toks.join(' ');
-            }
-            return `${headOut} on ${scopeT}`;
-        }
-        // Verb-first (SVO/VSO/V2): append `on <scope>` at the clause end, which the
-        // trailing `[on {scope}]` group on the set patterns matches.
-        return `${headOut} on ${scopeT}`;
-    }
-    /**
-     * Transform a self-contained block command (`{head} {clause?} {body} {end}`),
-     * where head \u2208 {if, repeat, unless, \u2026}. The clause (condition / `until event \u2026`)
-     * 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 \u2014 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 : undefined);
-        // Skip predicate-adjective positions (`\u2026 is empty`): the adjective is
-        // part of the condition clause, not the body's first verb \u2014 cutting there
-        // displaced it into the next command's argument zone (empty \u00d78 bn/hi/tr).
-        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);
-        // SOV condition/branch boundary (R1 deferred-tail Family G): the SOV body
-        // renders its first command operand-first (`\u6700\u521d <button/> \u306e\u4e2d .modal \u3092
-        // \u30d5\u30a9\u30fc\u30ab\u30b9`), so nothing marks where the condition ends and the branch
-        // operand begins \u2014 the semantic fold's command-start detection needs a
-        // `{value}{particle}` run followed by a verb, which a POSITIONAL-headed
-        // operand (`first <button/> \u2026`) never forms, and the condition scan
-        // swallows the operand's head (focus-trap: ja focus.patient fell to the
-        // `me` default, ko/qu to the `.modal` tail). Emit the target's
-        // then-connective at the seam \u2014 the boundary the fold already respects
-        // (isThenKeyword) \u2014 gated to exactly the blind shape: SOV target, a
-        // positional keyword right after the branch's command verb, and no `then`
-        // already ending the condition.
-        const POSITIONAL_BRANCH_HEADS = 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 \u2014 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) : '';
-        // Recurse through `transform()` (not `transformSingle`) so the body
-        // gets `then`-splitting and nested-block handling for free.
-        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 undefined;
-        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;
-        // Check required roles
-        for (const role of match.requiredRoles) {
-            if (!parsed.roles.has(role)) {
-                return false;
-            }
-        }
-        // Check command match if specified
-        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;
-            }
-        }
-        // Check custom predicate
-        if (match.predicate && !match.predicate(parsed)) {
-            return false;
-        }
-        return true;
-    }
-}
-// =============================================================================
-// Convenience Functions
-// =============================================================================
-/**
- * Transform hyperscript from English to target language
- */
-function toLocale(input, targetLocale) {
-    const transformer = new GrammarTransformer('en', targetLocale);
-    return transformer.transform(input);
-}
-/**
- * Transform hyperscript from source language to English
- */
-function toEnglish(input, sourceLocale) {
-    const transformer = new GrammarTransformer(sourceLocale, 'en');
-    return transformer.transform(input);
-}
-/**
- * Transform between any two languages.
- *
- * Uses direct translation for supported language pairs (ja\u2194zh, es\u2194pt, ko\u2194ja),
- * falling back to English pivot for other pairs.
- */
-function translate(input, sourceLocale, targetLocale) {
-    if (sourceLocale === targetLocale)
-        return input;
-    if (sourceLocale === 'en')
-        return toLocale(input, targetLocale);
-    if (targetLocale === 'en')
-        return toEnglish(input, sourceLocale);
-    // Try direct translation for supported pairs
-    if (hasDirectMapping(sourceLocale, targetLocale)) {
-        return translateDirect(input, sourceLocale, targetLocale);
-    }
-    // Fallback: Via English pivot
-    const english = toEnglish(input, sourceLocale);
-    return toLocale(english, targetLocale);
-}
-/**
- * Direct translation between language pairs without English pivot.
- * More accurate for closely related languages (ja\u2194zh, es\u2194pt).
- */
-function translateDirect(input, sourceLocale, targetLocale) {
-    const mapping = getDirectMapping(sourceLocale, targetLocale);
-    if (!mapping) {
-        // Fallback to pivot translation
-        return toLocale(toEnglish(input, sourceLocale), targetLocale);
-    }
-    // Tokenize input
-    const tokens = input.split(/\s+/);
-    // Translate each token using direct mapping
-    const translated = tokens.map(token => {
-        // Preserve CSS selectors and literals
-        if (token.startsWith('#') || token.startsWith('.') || token.startsWith('@')) {
-            return token;
-        }
-        if (token.startsWith('"') || token.startsWith("'")) {
-            return token;
-        }
-        // Look up in direct mapping
-        const directTranslation = mapping.words[token];
-        if (directTranslation) {
-            return directTranslation;
-        }
-        // Check for suffix-attached tokens (e.g., "#count-ta" in Quechua)
-        const suffixMatch = token.match(/^(.+?)(-.+)$/);
-        if (suffixMatch) {
-            const [, base, suffix] = suffixMatch;
-            const translatedBase = mapping.words[base] || base;
-            return translatedBase + suffix;
-        }
-        // Return unchanged if no mapping found
-        return token;
-    });
-    return translated.join(' ');
-}
-// =============================================================================
-// Examples (for testing)
-// =============================================================================
-const 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',
-    },
-};
-
-export { ENGLISH_COMMANDS, ENGLISH_KEYWORDS, GrammarTransformer, LANGUAGE_FAMILY_DEFAULTS, LocaleManager, UNIVERSAL_ENGLISH_KEYWORDS, UNIVERSAL_PATTERNS, ar$1 as ar, ar$1 as arDictionary, arKeywords, arabicProfile, bn$1 as bn, bn$1 as bnDictionary, bnKeywords, chineseProfile, createEnglishProvider, createKeywordProvider, de$1 as de, de$1 as deDictionary, deKeywords, detectBrowserLocale, directMappings, en$1 as en, englishProfile, es$1 as es, es$1 as esDictionary, esKeywords, fr$1 as fr, fr$1 as frDictionary, frKeywords, frenchProfile, germanProfile, getDirectMapping, getProfile, getSupportedDirectPairs, getSupportedLocales, examples as grammarExamples, hasDirectMapping, he$1 as he, he$1 as heDictionary, heKeywords, hebrewProfile, hindiDictionary as hiDictionary, hiKeywords, hindiDictionary, id$1 as id, id$1 as idDictionary, idKeywords, indonesianProfile, insertMarkers, it$1 as it, it$1 as itDictionary, itKeywords, ja$1 as ja, ja$1 as jaDictionary, jaKeywords, japaneseProfile, joinTokens, ko$1 as ko, ko$1 as koDictionary, koKeywords, koreanProfile, malayProfile, ms$1 as ms, ms$1 as msDictionary, msKeywords, parseStatement, pl$1 as pl, pl$1 as plDictionary, plKeywords, portugueseProfile, profiles, pt$1 as pt, pt$1 as ptDictionary, ptKeywords, qu$1 as qu, qu$1 as quDictionary, quKeywords, quechuaProfile, reorderRoles, russianDictionary as ruDictionary, ruKeywords, russianDictionary, spanishProfile, sw$1 as sw, sw$1 as swDictionary, swKeywords, swahiliProfile, th$1 as th, th$1 as thDictionary, thKeywords, tl$1 as tl, tl$1 as tlDictionary, tlKeywords, toEnglish, toLocale, tr$1 as tr, tr$1 as trDictionary, trKeywords, transformStatement, translate, translateWordDirect, turkishProfile, ukrainianDictionary as ukDictionary, ukKeywords, ukrainianDictionary, vi$1 as vi, vi$1 as viDictionary, viKeywords, zh$1 as zh, zh$1 as zhDictionary, zhKeywords };
+export { ENGLISH_COMMANDS, ENGLISH_KEYWORDS, LANGUAGE_FAMILY_DEFAULTS, LocaleManager, UNIVERSAL_ENGLISH_KEYWORDS, UNIVERSAL_PATTERNS, ar, ar as arDictionary, arKeywords, arabicProfile, bn, bn as bnDictionary, bnKeywords, chineseProfile, createEnglishProvider, createKeywordProvider, de, de as deDictionary, deKeywords, detectBrowserLocale, directMappings, en, englishProfile, es, es as esDictionary, esKeywords, fr, fr as frDictionary, frKeywords, frenchProfile, germanProfile, getDirectMapping, getProfile, getSupportedDirectPairs, getSupportedLocales, hasDirectMapping, he, he as heDictionary, heKeywords, hebrewProfile, hindiDictionary as hiDictionary, hiKeywords, hindiDictionary, id, id as idDictionary, idKeywords, indonesianProfile, insertMarkers, it, it as itDictionary, itKeywords, ja, ja as jaDictionary, jaKeywords, japaneseProfile, joinTokens, ko, ko as koDictionary, koKeywords, koreanProfile, malayProfile, ms, ms as msDictionary, msKeywords, pl, pl as plDictionary, plKeywords, portugueseProfile, profiles, pt, pt as ptDictionary, ptKeywords, qu, qu as quDictionary, quKeywords, quechuaProfile, reorderRoles, russianDictionary as ruDictionary, ruKeywords, russianDictionary, spanishProfile, sw, sw as swDictionary, swKeywords, swahiliProfile, th, th as thDictionary, thKeywords, tl, tl as tlDictionary, tlKeywords, tr, tr as trDictionary, trKeywords, transformStatement, translateWordDirect, turkishProfile, ukrainianDictionary as ukDictionary, ukKeywords, ukrainianDictionary, vi, vi as viDictionary, viKeywords, zh, zh as zhDictionary, zhKeywords };
 //# sourceMappingURL=lokascript-i18n.mjs.map