@lokascript/i18n 2.5.1 → 2.6.0

package/dist/{transformer-BLv389qz.d.ts → transformer-BA8YX9u1.d.ts}

@@ -1,4 +1,4 @@
-import { a as Dictionary } from './types-BcALAO6h.js';
+import { D as Dictionary } from './types-BYtpqGq3.js';
 
 /**
  * KeywordProvider interface for locale-aware parsing.
@@ -869,6 +869,7 @@ declare const germanProfile: LanguageProfile;
 declare const frenchProfile: LanguageProfile;
 declare const portugueseProfile: LanguageProfile;
 declare const indonesianProfile: LanguageProfile;
+declare const malayProfile: LanguageProfile;
 declare const quechuaProfile: LanguageProfile;
 declare const swahiliProfile: LanguageProfile;
 declare const hebrewProfile: LanguageProfile;
@@ -901,10 +902,127 @@ declare class GrammarTransformer {
      * For multi-line input, preserves line structure (indentation, blank lines).
      */
     transform(input: string): string;
+    private transformInternal;
     /**
      * Transform a single hyperscript statement (no compound "then" chains).
      */
     private transformSingle;
+    /**
+     * 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).
+     */
+    private tryTransformJsBlock;
+    /**
+     * Transform an event handler whose body is a block command
+     * (`on <event> [from <src>] {if|repeat|unless|while|for} … end`).
+     *
+     * `parseEventHandler` would treat the block keyword as the action and sweep the
+     * condition/body into role values, then reorder them — shredding the block
+     * (`if event.shiftKey call submitAndContinue() end` → scattered tokens). Instead
+     * we mask the whole block as an opaque action placeholder, reorder the event
+     * head normally, transform the block as a self-contained unit, and restitch.
+     *
+     * Returns `null` (fall through) when the input isn't an event handler, has no
+     * block-keyword body, or has no closing `end`.
+     */
+    private tryTransformEventWithBlockBody;
+    /**
+     * Transform an event handler whose body is an inline `unless` guard with NO
+     * `end` (`on <event> unless <cond> <body>` — the `unless-condition` shape).
+     *
+     * Object-marking SVO targets (he, zh). `parseEventHandler` reads `unless` as the
+     * action and sweeps the whole `<cond> <body>` tail into a single `patient` blob;
+     * the target then prefixes that blob with its object marker — Hebrew's accusative
+     * את (`… אלא את I match .disabled מתג .selected`) or Chinese's BA particle 把
+     * (`… 除非 把 I match .disabled 切换 .selected`) — and the inner toggle loses its
+     * own marker. The semantic parser can't recover the guard from that: the marker
+     * ahead of the condition blocks the `unless` pattern AND the now-markerless body
+     * command fails its object-marked toggle pattern, so the body collapses (`unless`
+     * dropped). Marker-less languages (de/it/ar/pl) tolerate the same role-blob and
+     * stay faithful, so this is an object-marker artifact, not a general parse gap.
+     *
+     * The standalone `unless <cond> <body>` path already produces the correct shape
+     * (`extractBlockStructure` → `transformBlock`: condition kept marker-free, body
+     * command keeps its marker — he `אלא I match .disabled מתג את .selected`, zh
+     * `除非 I match .disabled 切换 把 .selected`). So we split the event head off,
+     * transform the guard through that path, and emit the event clause first (he and
+     * zh are both SVO — event leads). Returns `null` (fall through) when the input
+     * isn't an object-marking event handler with an un-terminated inline `unless`
+     * guard.
+     */
+    private tryTransformEventWithUnlessGuard;
+    /**
+     * Transform an event handler whose body leads with a command-modifier
+     * (`on <event> [from <src>] {async|once|debounced [at N]|throttled [at N]} <body>`).
+     *
+     * `parseEventHandler` reads the first token after the event as the **action**, so
+     * a leading modifier is mistaken for the verb and the real verb (`fetch`/`add`) is
+     * swept into the patient. For SOV targets the reorder then surfaces that verb
+     * **first** (`取得 /api/data を クリック …`), and the semantic parser matches the
+     * leading `<verb> <patient>` with the low-priority `*-generated-verb-first`
+     * command pattern — returning a bare command and discarding the event + the rest
+     * of the body (degenerate parse).
+     *
+     * Instead, lift the modifier out, transform the modifier-free handler through the
+     * normal path (which keeps the body in canonical patient-first SOV order so the
+     * event sits mid-stream and the existing SOV event-extraction recovers it), then
+     * re-emit the modifier as a **leading English literal**. The semantic parser
+     * strips a leading `once`/`debounced`/`throttled` (`extractStandaloneModifiers`)
+     * and an `async` anywhere (`stripAsyncModifier`) before parsing, so the modifier
+     * is consumed as handler metadata rather than shadowing the body.
+     *
+     * Returns `null` (fall through) when the input isn't an event handler or the body
+     * doesn't lead with a modifier — leaving simple/Mode-B handlers byte-identical.
+     */
+    private tryTransformEventWithModifierBody;
+    /**
+     * Transform a `set <stuff> on <scope>` clause (S1 tabs-aria). The trailing
+     * `on <scope>` is the element(s) the attribute is set on — kept attached by
+     * splitOnCommandBoundaries. The semantic parser captures it as a `scope` role
+     * via the passthrough literal `on` (setSchema's scope markerOverride is `on`
+     * in every language), so `on` is emitted verbatim and only the scope *value*
+     * is translated (selectors pass through; `me`/`it`/`you` translate to the
+     * native reference, which the parser also accepts).
+     *
+     * Positioning matches where the set patterns expect the scope: at the clause
+     * end for verb-first orders (SVO/VSO), and immediately before the clause-final
+     * verb for SOV (the generated SOV pattern is `{dest} {patient} on {scope}
+     * {verb}`). Returns null (fall through) when there is no trailing `on <scope>`.
+     *
+     * Source is English in the sync-translations pipeline, so the `set` verb and
+     * `on` marker are matched as English literals.
+     */
+    private transformSetWithScope;
+    /**
+     * Transform a self-contained block command (`{head} {clause?} {body} {end}`),
+     * where head ∈ {if, repeat, unless, …}. The clause (condition / `until event …`)
+     * runs up to the first command verb and is translated word-by-word; the body is
+     * recursively transformed (so its inner commands reorder for the target); the
+     * head/tail keywords are translated. The block is never word-order reordered as
+     * a whole — delimiters stay at the edges regardless of target word order.
+     */
+    private transformBlockBody;
+    /**
+     * Transform an `if`/`unless` block body, splitting it at a top-level `else` into
+     * a then-branch and an else-branch so each is reordered as a self-contained unit
+     * and the `else` keyword itself is translated. Without this, the body is reordered
+     * as one stream: `else` rides along glued to the preceding clause (and, when that
+     * clause begins with a selector, is marked a selector and left *untranslated*),
+     * and a spurious `then` is inserted around it — both of which break the target
+     * text and the downstream parse. The split is depth-aware so an `else` belonging
+     * to a nested block is not mistaken for this block's separator. Bodies without an
+     * `else` transform exactly as before.
+     */
+    private transformConditionalBody;
     /**
      * Translate a reactive block by translating the head/tail/connector
      * via the dictionary, recursively transforming the body through the
@@ -965,4 +1083,4 @@ declare const examples: {
     };
 };
 
-export { joinTokens as $, type AdpositionType as A, frKeywords as B, frenchProfile as C, germanProfile as D, ENGLISH_COMMANDS as E, getProfile as F, type GrammarRule as G, getSupportedLocales as H, hebrewProfile as I, hiKeywords as J, type KeywordProvider as K, LANGUAGE_FAMILY_DEFAULTS as L, type MorphologyType as M, hindiDictionary as N, id as O, type ParsedElement as P, idKeywords as Q, indonesianProfile as R, type SemanticRole as S, insertMarkers as T, UNIVERSAL_ENGLISH_KEYWORDS as U, it as V, type WordOrder as W, itKeywords as X, ja as Y, jaKeywords as Z, japaneseProfile as _, ENGLISH_KEYWORDS as a, ko as a0, koKeywords as a1, koreanProfile as a2, ms as a3, msKeywords as a4, parseStatement as a5, pl as a6, plKeywords as a7, portugueseProfile as a8, profiles as a9, viKeywords as aA, zh as aB, zhKeywords as aC, pt as aa, ptKeywords as ab, qu as ac, quKeywords as ad, quechuaProfile as ae, reorderRoles as af, ruKeywords as ag, russianDictionary as ah, spanishProfile as ai, sw as aj, swKeywords as ak, swahiliProfile as al, th as am, thKeywords as an, tl as ao, tlKeywords as ap, toEnglish as aq, toLocale as ar, tr as as, trKeywords as at, transformStatement as au, translate as av, turkishProfile as aw, ukKeywords as ax, ukrainianDictionary as ay, vi as az, GrammarTransformer as b, type GrammaticalMarker as c, type KeywordProviderOptions as d, type LanguageProfile as e, LocaleManager as f, type ParsedStatement as g, type PatternMatcher as h, type PatternTransform as i, UNIVERSAL_PATTERNS as j, ar as k, arKeywords as l, arabicProfile as m, bn as n, bnKeywords as o, chineseProfile as p, createEnglishProvider as q, createKeywordProvider as r, de as s, deKeywords as t, detectBrowserLocale as u, englishProfile as v, es as w, esKeywords as x, examples as y, fr as z };
+export { joinTokens as $, type AdpositionType as A, frenchProfile as B, germanProfile as C, getProfile as D, ENGLISH_COMMANDS as E, getSupportedLocales as F, type GrammarRule as G, examples as H, hebrewProfile as I, hindiDictionary as J, type KeywordProvider as K, LANGUAGE_FAMILY_DEFAULTS as L, type MorphologyType as M, hiKeywords as N, id as O, type ParsedElement as P, idKeywords as Q, indonesianProfile as R, type SemanticRole as S, insertMarkers as T, UNIVERSAL_ENGLISH_KEYWORDS as U, it as V, type WordOrder as W, itKeywords as X, ja as Y, jaKeywords as Z, japaneseProfile as _, ENGLISH_KEYWORDS as a, ko as a0, koKeywords as a1, koreanProfile as a2, malayProfile as a3, ms as a4, msKeywords as a5, parseStatement as a6, pl as a7, plKeywords as a8, portugueseProfile as a9, vi as aA, viKeywords as aB, zh as aC, zhKeywords as aD, profiles as aa, pt as ab, ptKeywords as ac, qu as ad, quKeywords as ae, quechuaProfile as af, reorderRoles as ag, russianDictionary as ah, ruKeywords as ai, spanishProfile as aj, sw as ak, swKeywords as al, swahiliProfile as am, th as an, thKeywords as ao, tl as ap, tlKeywords as aq, toEnglish as ar, toLocale as as, tr as at, trKeywords as au, transformStatement as av, translate as aw, turkishProfile as ax, ukrainianDictionary as ay, ukKeywords as az, GrammarTransformer as b, type GrammaticalMarker as c, type KeywordProviderOptions as d, type LanguageProfile as e, LocaleManager as f, type ParsedStatement as g, type PatternMatcher as h, type PatternTransform as i, UNIVERSAL_PATTERNS as j, ar as k, arKeywords as l, arabicProfile as m, bn as n, bnKeywords as o, chineseProfile as p, createEnglishProvider as q, createKeywordProvider as r, de as s, deKeywords as t, detectBrowserLocale as u, englishProfile as v, es as w, esKeywords as x, fr as y, frKeywords as z };

package/dist/{transformer-PFsYELrc.d.cts → transformer-DM7iplCU.d.cts}

@@ -1,4 +1,4 @@
-import { a as Dictionary } from './types-BcALAO6h.cjs';
+import { D as Dictionary } from './types-BYtpqGq3.cjs';
 
 /**
  * KeywordProvider interface for locale-aware parsing.
@@ -869,6 +869,7 @@ declare const germanProfile: LanguageProfile;
 declare const frenchProfile: LanguageProfile;
 declare const portugueseProfile: LanguageProfile;
 declare const indonesianProfile: LanguageProfile;
+declare const malayProfile: LanguageProfile;
 declare const quechuaProfile: LanguageProfile;
 declare const swahiliProfile: LanguageProfile;
 declare const hebrewProfile: LanguageProfile;
@@ -901,10 +902,127 @@ declare class GrammarTransformer {
      * For multi-line input, preserves line structure (indentation, blank lines).
      */
     transform(input: string): string;
+    private transformInternal;
     /**
      * Transform a single hyperscript statement (no compound "then" chains).
      */
     private transformSingle;
+    /**
+     * 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).
+     */
+    private tryTransformJsBlock;
+    /**
+     * Transform an event handler whose body is a block command
+     * (`on <event> [from <src>] {if|repeat|unless|while|for} … end`).
+     *
+     * `parseEventHandler` would treat the block keyword as the action and sweep the
+     * condition/body into role values, then reorder them — shredding the block
+     * (`if event.shiftKey call submitAndContinue() end` → scattered tokens). Instead
+     * we mask the whole block as an opaque action placeholder, reorder the event
+     * head normally, transform the block as a self-contained unit, and restitch.
+     *
+     * Returns `null` (fall through) when the input isn't an event handler, has no
+     * block-keyword body, or has no closing `end`.
+     */
+    private tryTransformEventWithBlockBody;
+    /**
+     * Transform an event handler whose body is an inline `unless` guard with NO
+     * `end` (`on <event> unless <cond> <body>` — the `unless-condition` shape).
+     *
+     * Object-marking SVO targets (he, zh). `parseEventHandler` reads `unless` as the
+     * action and sweeps the whole `<cond> <body>` tail into a single `patient` blob;
+     * the target then prefixes that blob with its object marker — Hebrew's accusative
+     * את (`… אלא את I match .disabled מתג .selected`) or Chinese's BA particle 把
+     * (`… 除非 把 I match .disabled 切换 .selected`) — and the inner toggle loses its
+     * own marker. The semantic parser can't recover the guard from that: the marker
+     * ahead of the condition blocks the `unless` pattern AND the now-markerless body
+     * command fails its object-marked toggle pattern, so the body collapses (`unless`
+     * dropped). Marker-less languages (de/it/ar/pl) tolerate the same role-blob and
+     * stay faithful, so this is an object-marker artifact, not a general parse gap.
+     *
+     * The standalone `unless <cond> <body>` path already produces the correct shape
+     * (`extractBlockStructure` → `transformBlock`: condition kept marker-free, body
+     * command keeps its marker — he `אלא I match .disabled מתג את .selected`, zh
+     * `除非 I match .disabled 切换 把 .selected`). So we split the event head off,
+     * transform the guard through that path, and emit the event clause first (he and
+     * zh are both SVO — event leads). Returns `null` (fall through) when the input
+     * isn't an object-marking event handler with an un-terminated inline `unless`
+     * guard.
+     */
+    private tryTransformEventWithUnlessGuard;
+    /**
+     * Transform an event handler whose body leads with a command-modifier
+     * (`on <event> [from <src>] {async|once|debounced [at N]|throttled [at N]} <body>`).
+     *
+     * `parseEventHandler` reads the first token after the event as the **action**, so
+     * a leading modifier is mistaken for the verb and the real verb (`fetch`/`add`) is
+     * swept into the patient. For SOV targets the reorder then surfaces that verb
+     * **first** (`取得 /api/data を クリック …`), and the semantic parser matches the
+     * leading `<verb> <patient>` with the low-priority `*-generated-verb-first`
+     * command pattern — returning a bare command and discarding the event + the rest
+     * of the body (degenerate parse).
+     *
+     * Instead, lift the modifier out, transform the modifier-free handler through the
+     * normal path (which keeps the body in canonical patient-first SOV order so the
+     * event sits mid-stream and the existing SOV event-extraction recovers it), then
+     * re-emit the modifier as a **leading English literal**. The semantic parser
+     * strips a leading `once`/`debounced`/`throttled` (`extractStandaloneModifiers`)
+     * and an `async` anywhere (`stripAsyncModifier`) before parsing, so the modifier
+     * is consumed as handler metadata rather than shadowing the body.
+     *
+     * Returns `null` (fall through) when the input isn't an event handler or the body
+     * doesn't lead with a modifier — leaving simple/Mode-B handlers byte-identical.
+     */
+    private tryTransformEventWithModifierBody;
+    /**
+     * Transform a `set <stuff> on <scope>` clause (S1 tabs-aria). The trailing
+     * `on <scope>` is the element(s) the attribute is set on — kept attached by
+     * splitOnCommandBoundaries. The semantic parser captures it as a `scope` role
+     * via the passthrough literal `on` (setSchema's scope markerOverride is `on`
+     * in every language), so `on` is emitted verbatim and only the scope *value*
+     * is translated (selectors pass through; `me`/`it`/`you` translate to the
+     * native reference, which the parser also accepts).
+     *
+     * Positioning matches where the set patterns expect the scope: at the clause
+     * end for verb-first orders (SVO/VSO), and immediately before the clause-final
+     * verb for SOV (the generated SOV pattern is `{dest} {patient} on {scope}
+     * {verb}`). Returns null (fall through) when there is no trailing `on <scope>`.
+     *
+     * Source is English in the sync-translations pipeline, so the `set` verb and
+     * `on` marker are matched as English literals.
+     */
+    private transformSetWithScope;
+    /**
+     * Transform a self-contained block command (`{head} {clause?} {body} {end}`),
+     * where head ∈ {if, repeat, unless, …}. The clause (condition / `until event …`)
+     * runs up to the first command verb and is translated word-by-word; the body is
+     * recursively transformed (so its inner commands reorder for the target); the
+     * head/tail keywords are translated. The block is never word-order reordered as
+     * a whole — delimiters stay at the edges regardless of target word order.
+     */
+    private transformBlockBody;
+    /**
+     * Transform an `if`/`unless` block body, splitting it at a top-level `else` into
+     * a then-branch and an else-branch so each is reordered as a self-contained unit
+     * and the `else` keyword itself is translated. Without this, the body is reordered
+     * as one stream: `else` rides along glued to the preceding clause (and, when that
+     * clause begins with a selector, is marked a selector and left *untranslated*),
+     * and a spurious `then` is inserted around it — both of which break the target
+     * text and the downstream parse. The split is depth-aware so an `else` belonging
+     * to a nested block is not mistaken for this block's separator. Bodies without an
+     * `else` transform exactly as before.
+     */
+    private transformConditionalBody;
     /**
      * Translate a reactive block by translating the head/tail/connector
      * via the dictionary, recursively transforming the body through the
@@ -965,4 +1083,4 @@ declare const examples: {
     };
 };
 
-export { joinTokens as $, type AdpositionType as A, frKeywords as B, frenchProfile as C, germanProfile as D, ENGLISH_COMMANDS as E, getProfile as F, type GrammarRule as G, getSupportedLocales as H, hebrewProfile as I, hiKeywords as J, type KeywordProvider as K, LANGUAGE_FAMILY_DEFAULTS as L, type MorphologyType as M, hindiDictionary as N, id as O, type ParsedElement as P, idKeywords as Q, indonesianProfile as R, type SemanticRole as S, insertMarkers as T, UNIVERSAL_ENGLISH_KEYWORDS as U, it as V, type WordOrder as W, itKeywords as X, ja as Y, jaKeywords as Z, japaneseProfile as _, ENGLISH_KEYWORDS as a, ko as a0, koKeywords as a1, koreanProfile as a2, ms as a3, msKeywords as a4, parseStatement as a5, pl as a6, plKeywords as a7, portugueseProfile as a8, profiles as a9, viKeywords as aA, zh as aB, zhKeywords as aC, pt as aa, ptKeywords as ab, qu as ac, quKeywords as ad, quechuaProfile as ae, reorderRoles as af, ruKeywords as ag, russianDictionary as ah, spanishProfile as ai, sw as aj, swKeywords as ak, swahiliProfile as al, th as am, thKeywords as an, tl as ao, tlKeywords as ap, toEnglish as aq, toLocale as ar, tr as as, trKeywords as at, transformStatement as au, translate as av, turkishProfile as aw, ukKeywords as ax, ukrainianDictionary as ay, vi as az, GrammarTransformer as b, type GrammaticalMarker as c, type KeywordProviderOptions as d, type LanguageProfile as e, LocaleManager as f, type ParsedStatement as g, type PatternMatcher as h, type PatternTransform as i, UNIVERSAL_PATTERNS as j, ar as k, arKeywords as l, arabicProfile as m, bn as n, bnKeywords as o, chineseProfile as p, createEnglishProvider as q, createKeywordProvider as r, de as s, deKeywords as t, detectBrowserLocale as u, englishProfile as v, es as w, esKeywords as x, examples as y, fr as z };
+export { joinTokens as $, type AdpositionType as A, frenchProfile as B, germanProfile as C, getProfile as D, ENGLISH_COMMANDS as E, getSupportedLocales as F, type GrammarRule as G, examples as H, hebrewProfile as I, hindiDictionary as J, type KeywordProvider as K, LANGUAGE_FAMILY_DEFAULTS as L, type MorphologyType as M, hiKeywords as N, id as O, type ParsedElement as P, idKeywords as Q, indonesianProfile as R, type SemanticRole as S, insertMarkers as T, UNIVERSAL_ENGLISH_KEYWORDS as U, it as V, type WordOrder as W, itKeywords as X, ja as Y, jaKeywords as Z, japaneseProfile as _, ENGLISH_KEYWORDS as a, ko as a0, koKeywords as a1, koreanProfile as a2, malayProfile as a3, ms as a4, msKeywords as a5, parseStatement as a6, pl as a7, plKeywords as a8, portugueseProfile as a9, vi as aA, viKeywords as aB, zh as aC, zhKeywords as aD, profiles as aa, pt as ab, ptKeywords as ac, qu as ad, quKeywords as ae, quechuaProfile as af, reorderRoles as ag, russianDictionary as ah, ruKeywords as ai, spanishProfile as aj, sw as ak, swKeywords as al, swahiliProfile as am, th as an, thKeywords as ao, tl as ap, tlKeywords as aq, toEnglish as ar, toLocale as as, tr as at, trKeywords as au, transformStatement as av, translate as aw, turkishProfile as ax, ukrainianDictionary as ay, ukKeywords as az, GrammarTransformer as b, type GrammaticalMarker as c, type KeywordProviderOptions as d, type LanguageProfile as e, LocaleManager as f, type ParsedStatement as g, type PatternMatcher as h, type PatternTransform as i, UNIVERSAL_PATTERNS as j, ar as k, arKeywords as l, arabicProfile as m, bn as n, bnKeywords as o, chineseProfile as p, createEnglishProvider as q, createKeywordProvider as r, de as s, deKeywords as t, detectBrowserLocale as u, englishProfile as v, es as w, esKeywords as x, fr as y, frKeywords as z };

package/dist/{types-BcALAO6h.d.cts → types-BYtpqGq3.d.cts}

@@ -119,4 +119,4 @@ interface TranslationResult {
     warnings?: string[];
 }
 
-export { DICTIONARY_CATEGORIES as D, type I18nConfig as I, type LocaleMetadata as L, type Token as T, type ValidationError as V, type Dictionary as a, type DictionaryCategory as b, type TokenType as c, type TranslationContext as d, type TranslationOptions as e, type TranslationResult as f, type ValidationResult as g, type ValidationWarning as h, findInDictionary as i, forEachCategory as j, getDictionaryCategory as k, isDictionaryCategory as l, translateFromEnglish as t };
+export { type Dictionary as D, type I18nConfig as I, type LocaleMetadata as L, type TranslationOptions as T, type ValidationResult as V, type TranslationResult as a, type Token as b, DICTIONARY_CATEGORIES as c, type DictionaryCategory as d, type TokenType as e, type TranslationContext as f, type ValidationError as g, type ValidationWarning as h, findInDictionary as i, forEachCategory as j, getDictionaryCategory as k, isDictionaryCategory as l, translateFromEnglish as t };

package/dist/{types-BcALAO6h.d.ts → types-BYtpqGq3.d.ts}

@@ -119,4 +119,4 @@ interface TranslationResult {
     warnings?: string[];
 }
 
-export { DICTIONARY_CATEGORIES as D, type I18nConfig as I, type LocaleMetadata as L, type Token as T, type ValidationError as V, type Dictionary as a, type DictionaryCategory as b, type TokenType as c, type TranslationContext as d, type TranslationOptions as e, type TranslationResult as f, type ValidationResult as g, type ValidationWarning as h, findInDictionary as i, forEachCategory as j, getDictionaryCategory as k, isDictionaryCategory as l, translateFromEnglish as t };
+export { type Dictionary as D, type I18nConfig as I, type LocaleMetadata as L, type TranslationOptions as T, type ValidationResult as V, type TranslationResult as a, type Token as b, DICTIONARY_CATEGORIES as c, type DictionaryCategory as d, type TokenType as e, type TranslationContext as f, type ValidationError as g, type ValidationWarning as h, findInDictionary as i, forEachCategory as j, getDictionaryCategory as k, isDictionaryCategory as l, translateFromEnglish as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lokascript/i18n",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "description": "Grammar transformation and keyword translation for hyperscript",
   "type": "module",
   "main": "dist/index.cjs",
@@ -37,9 +37,9 @@
     "build": "tsup && npm run build:browser",
     "build:browser": "rollup -c rollup.config.mjs",
     "dev": "tsup --watch",
-    "test": "vitest",
-    "test:check": "vitest run --reporter=dot 2>&1 | tail -5",
-    "test:coverage": "vitest run --coverage",
+    "test": "bash ../../scripts/vitest-run.sh",
+    "test:check": "VITEST_QUIET=1 bash ../../scripts/vitest-run.sh --reporter=dot",
+    "test:coverage": "bash ../../scripts/vitest-run.sh --coverage",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src --ext ts,tsx",
     "validate-dictionaries": "node scripts/validate-dictionaries.js"
@@ -65,8 +65,8 @@
   },
   "homepage": "https://github.com/codetalcott/hyperfixi/tree/main/packages/i18n#readme",
   "dependencies": {
-    "@hyperfixi/core": "^2.5.1",
-    "@lokascript/semantic": "^2.5.1",
+    "@hyperfixi/core": "^2.6.0",
+    "@lokascript/semantic": "^2.6.0",
     "esbuild": "^0.28.0",
     "happy-dom": "^20.8.9",
     "vite": "^7.1.12"

package/src/browser.ts

@@ -127,6 +127,7 @@ export {
   frenchProfile,
   portugueseProfile,
   indonesianProfile,
+  malayProfile,
   quechuaProfile,
   swahiliProfile,
   hebrewProfile,

package/src/command-primary-roles.test.ts

@@ -0,0 +1,59 @@
+/**
+ * COMMAND_PRIMARY_ROLES ↔ semantic schema alignment
+ *
+ * `COMMAND_PRIMARY_ROLES` (constants.ts) is a local mirror of the `primaryRole`
+ * field on each `CommandSchema` exported by `@lokascript/semantic`. It's kept
+ * local — rather than importing the schemas into the transformer — so the i18n
+ * browser bundle doesn't have to pull in the whole semantic graph just to read a
+ * handful of role labels.
+ *
+ * This test guarantees the local copy can't silently drift from the source of
+ * truth: every non-`patient` primary role in the schemas must be present (and
+ * identical) here, and every entry here must match a schema. The test imports
+ * the schemas, but tests don't ship in the bundle.
+ *
+ * @see packages/i18n/src/constants.ts
+ * @see docs-internal/ZH_BLOCK_BODY_SCOPE.md (#1 — transformer role model)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { commandSchemas } from '@lokascript/semantic';
+import { COMMAND_PRIMARY_ROLES } from './constants';
+
+describe('COMMAND_PRIMARY_ROLES ↔ semantic schema alignment', () => {
+  const schemaEntries = Object.entries(commandSchemas) as Array<[string, { primaryRole: string }]>;
+
+  it('every non-patient schema primaryRole is mirrored locally with the same value', () => {
+    const missingOrWrong: string[] = [];
+    for (const [action, schema] of schemaEntries) {
+      if (schema.primaryRole === 'patient') continue;
+      if (COMMAND_PRIMARY_ROLES[action] !== schema.primaryRole) {
+        missingOrWrong.push(
+          `${action}: schema=${schema.primaryRole} local=${COMMAND_PRIMARY_ROLES[action] ?? '(missing)'}`
+        );
+      }
+    }
+    expect(
+      missingOrWrong,
+      `COMMAND_PRIMARY_ROLES (packages/i18n/src/constants.ts) drifted from @lokascript/semantic command schemas:\n  ${missingOrWrong.join('\n  ')}\nUpdate the local map to match.`
+    ).toEqual([]);
+  });
+
+  it('every local entry matches a schema primaryRole (no stale/patient entries)', () => {
+    const stale: string[] = [];
+    for (const [action, role] of Object.entries(COMMAND_PRIMARY_ROLES)) {
+      const schema = commandSchemas[action as keyof typeof commandSchemas];
+      if (!schema) {
+        stale.push(`${action}: no such command schema`);
+      } else if (schema.primaryRole === 'patient') {
+        stale.push(`${action}: schema primaryRole is 'patient' (the default) — drop it`);
+      } else if (schema.primaryRole !== role) {
+        stale.push(`${action}: local=${role} schema=${schema.primaryRole}`);
+      }
+    }
+    expect(
+      stale,
+      `COMMAND_PRIMARY_ROLES contains stale entries vs @lokascript/semantic:\n  ${stale.join('\n  ')}`
+    ).toEqual([]);
+  });
+});

package/src/constants.ts

@@ -29,6 +29,50 @@ export const ENGLISH_MODIFIER_ROLES: Readonly<Record<string, SemanticRole>> = {
   for: 'duration',
 } as const;
 
+/**
+ * Maps a command verb to its **primary** semantic role — 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`, …) but wrong for commands whose leading argument is a
+ * non-patient — e.g. `wait <duration>`. Marking a duration as a patient emits a
+ * spurious object-marker in the target language (Chinese `等待 把 1s`, ungrammatical;
+ * Japanese `1s を 待つ`; Korean `1s 를 대기`), which the semantic parser then fails to
+ * match — 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 — transformer role model)
+ */
+export const COMMAND_PRIMARY_ROLES: Readonly<Record<string, SemanticRole>> = {
+  set: 'destination',
+  on: 'event',
+  trigger: 'event',
+  send: 'event',
+  wait: 'duration',
+  fetch: 'source',
+  get: 'source',
+  if: 'condition',
+  unless: 'condition',
+  while: 'condition',
+  repeat: 'loopType',
+  go: 'destination',
+  scroll: 'destination',
+  tell: 'destination',
+  default: 'destination',
+  swap: 'destination',
+  // morph deliberately absent: its schema primaryRole is `patient` (the
+  // element being morphed — aligned with the transformer's patient marking
+  // in the session-9 role-layout swap), and patient is the default.
+  bind: 'destination',
+} as const;
+
 /**
  * English modifier keywords (derived from ENGLISH_MODIFIER_ROLES)
  */
@@ -110,6 +154,13 @@ export const ENGLISH_COMMANDS: Set<string> = new Set([
   'trigger',
   'unless',
   'wait',
+  // v2.x reactive + realtime + service-worker DSL commands
+  'live',
+  'bind',
+  'eventsource',
+  'socket',
+  'worker',
+  'intercept',
 ]);
 
 // =============================================================================

package/src/dictionaries/ar.ts

@@ -19,7 +19,10 @@ export const ar: Dictionary = {
     hide: 'اخف',
     show: 'اظهر',
     if: 'إذا',
-    unless: 'إلا إذا',
+    // Single-token form: the semantic ar tokenizer splits the two-word `إلا إذا`
+    // into `إلا` + `إذا`(if), which derails the `unless` block. `إلا` alone is the
+    // conventional Arabic shorthand and matches the ar profile's unless keyword.
+    unless: 'إلا',
     repeat: 'كرر',
     for: 'لكل',
     while: 'بينما',
@@ -49,19 +52,20 @@ export const ar: Dictionary = {
     js: 'جافاسكربت',
     async: 'متزامن',
     render: 'ارسم',
-    swap: 'بدّل',
+    swap: 'استبدل', // profile primary; 'بدّل' is toggle's word (parsed as toggle)
     morph: 'حوّل',
     settle: 'استقر',
     append: 'ألحق',
     exit: 'اخرج',
     install: 'ثبّت',
     breakpoint: 'نقطة-توقف',
-    clear: 'امسح',
+    clear: 'نظّف', // امسح is a remove alternative in the profile
     close: 'أغلق',
     open: 'افتح',
     select: 'اختر',
     clone: 'استنسخ',
     prepend: 'سبق',
+    socket: 'مقبس',
   },
 
   modifiers: {
@@ -131,6 +135,7 @@ export const ar: Dictionary = {
     otherwise: 'خلاف ذلك',
     end: 'النهاية',
     live: 'حي',
+    bind: 'اربط',
     changes: 'يتغير',
   },
 

package/src/dictionaries/bn.ts

@@ -34,7 +34,7 @@ export const bengaliDictionary: Dictionary = {
     throw: 'নিক্ষেপ',
     continue: 'চালিয়ে যান',
     make: 'তৈরি করুন',
-    append: 'শেষে যোগ',
+    append: 'জুড়ুন',
     prepend: 'শুরুতে যোগ',
     focus: 'ফোকাস',
     blur: 'ঝাপসা',
@@ -63,6 +63,7 @@ export const bengaliDictionary: Dictionary = {
     close: 'বন্ধ',
     open: 'খুলুন',
     select: 'নির্বাচন',
+    socket: 'সকেট',
   },
 
   modifiers: {
@@ -124,6 +125,7 @@ export const bengaliDictionary: Dictionary = {
     end: 'শেষ',
     then: 'তারপর',
     live: 'লাইভ',
+    bind: 'বাইন্ড',
     changes: 'পরিবর্তিত হলে',
   },
 

package/src/dictionaries/de.ts

@@ -16,9 +16,17 @@ export const de: Dictionary = {
     add: 'hinzufügen',
     remove: 'entfernen',
     toggle: 'umschalten',
+    // command blur (the events section has the blur EVENT word; without this
+    // entry the transformer fell back to it and no profile read it as the verb)
+    blur: 'defokussieren',
     hide: 'verstecken',
     show: 'zeigen',
-    if: 'wenn',
+    // Align with the semantic German profile's `if` primary (`falls`). The previous
+    // `wenn` collides with the profile's `when` keyword (German `wenn` = both
+    // "if" and "when"), so a transformed `if` resolved to `when` and the conditional
+    // wrapper never formed (`if`/`put` dropped). Same dict↔profile alignment as id
+    // `toggle` / get-value. `when` is unaffected (separate dict entry).
+    if: 'falls',
     unless: 'wennnicht',
     repeat: 'wiederholen',
     for: 'für',
@@ -28,7 +36,7 @@ export const de: Dictionary = {
     break: 'unterbrechen',
     halt: 'anhalten',
     wait: 'warten',
-    fetch: 'holen',
+    fetch: 'abrufen',
     call: 'aufrufen',
     return: 'zurückgeben',
     make: 'erstellen',
@@ -56,12 +64,13 @@ export const de: Dictionary = {
     exit: 'beenden',
     install: 'installieren',
     breakpoint: 'haltepunkt',
-    clear: 'löschen',
+    clear: 'bereinigen', // löschen is a remove alternative in the profile
     close: 'schließen',
     open: 'öffnen',
     select: 'auswählen',
     clone: 'klonen',
     prepend: 'voranstellen',
+    focus: 'fokussieren',
   },
 
   modifiers: {
@@ -192,7 +201,13 @@ export const de: Dictionary = {
     prev: 'vorh',
     at: 'bei',
     random: 'zufällig',
-    closest: 'nächste',
+    // `nächste` already serves `next` (line above). German `nächste` is
+    // genuinely ambiguous (next/nearest), so emitting it for `closest` too
+    // collided: the semantic tokenizer normalizes `nächste`→next (a deliberate
+    // last-wins choice — see german.ts), and a closest reading is impossible to
+    // recover. Use the unambiguous `nächstgelegene` ("nearest-located") for
+    // closest so the two readings stay distinct end-to-end.
+    closest: 'nächstgelegene',
     parent: 'elternteil',
     children: 'kinder',
     within: 'innerhalb',

package/src/dictionaries/derive.ts

@@ -106,6 +106,10 @@ const COMMAND_KEYWORDS = [
   // Focus
   'focus',
   'blur',
+  // Streaming / concurrency (postdated the original list — keep in sync with profiles)
+  'socket',
+  'eventsource',
+  'worker',
 ] as const;
 
 /**

package/src/dictionaries/en.ts

@@ -55,6 +55,15 @@ export const en: Dictionary = {
     decrement: 'decrement',
     default: 'default',
 
+    // Reactivity Commands
+    bind: 'bind',
+
+    // Realtime / service-worker Commands
+    eventsource: 'eventsource',
+    socket: 'socket',
+    worker: 'worker',
+    intercept: 'intercept',
+
     // Navigation Commands
     go: 'go',
     pushUrl: 'pushUrl',