@lokascript/i18n 1.0.0

package/dist/transformer-Ckask-yw.d.cts

@@ -0,0 +1,1041 @@
+/**
+ * KeywordProvider interface for locale-aware parsing.
+ *
+ * This interface allows the parser to resolve non-English keywords
+ * to their canonical English equivalents, enabling multilingual
+ * hyperscript syntax.
+ *
+ * @example
+ * ```typescript
+ * import { esKeywords } from '@lokascript/i18n/parser/es';
+ * const parser = new Parser({ keywords: esKeywords });
+ * parser.parse('en clic alternar .active'); // Works!
+ * ```
+ */
+interface KeywordProvider {
+    /** The locale code for this provider (e.g., 'es', 'ja') */
+    readonly locale: string;
+    /**
+     * Resolve a token to its canonical (English) keyword.
+     * Returns undefined if the token is not a recognized keyword.
+     *
+     * @example
+     * esKeywords.resolve('alternar') // 'toggle'
+     * esKeywords.resolve('en')       // 'on'
+     * esKeywords.resolve('unknown')  // undefined
+     */
+    resolve(token: string): string | undefined;
+    /**
+     * Check if the token is a command in this locale.
+     * Includes both locale keywords and English fallbacks.
+     */
+    isCommand(token: string): boolean;
+    /**
+     * Check if the token is a keyword (non-command) in this locale.
+     * Includes modifiers, logical operators, events, etc.
+     */
+    isKeyword(token: string): boolean;
+    /**
+     * Check if the token is an event name in this locale.
+     */
+    isEvent(token: string): boolean;
+    /**
+     * Check if the token is a modifier/preposition in this locale.
+     */
+    isModifier(token: string): boolean;
+    /**
+     * Check if the token is a logical operator in this locale.
+     */
+    isLogical(token: string): boolean;
+    /**
+     * Check if the token is a value keyword (me, it, true, etc.) in this locale.
+     */
+    isValue(token: string): boolean;
+    /**
+     * Check if the token is an expression keyword (first, last, closest, etc.) in this locale.
+     */
+    isExpression(token: string): boolean;
+    /**
+     * Get all command names in this locale (for completions).
+     */
+    getCommands(): string[];
+    /**
+     * Get all keywords in this locale (for completions).
+     */
+    getKeywords(): string[];
+    /**
+     * Get the locale keyword for an English canonical keyword.
+     * Useful for error messages and IDE completions in native language.
+     *
+     * @example
+     * esKeywords.toLocale('toggle') // 'alternar'
+     */
+    toLocale(englishKeyword: string): string | undefined;
+}
+/**
+ * Options for creating a keyword provider.
+ */
+interface KeywordProviderOptions {
+    /**
+     * When true, English keywords are always accepted alongside locale keywords.
+     * This allows mixing: "en click alternar .active"
+     * @default true
+     */
+    allowEnglishFallback?: boolean;
+    /**
+     * Categories to include. If not specified, all categories are included.
+     */
+    categories?: Array<'commands' | 'modifiers' | 'events' | 'logical' | 'temporal' | 'values' | 'attributes' | 'expressions'>;
+}
+
+/**
+ * Dictionary category names as a union type for type-safe access.
+ */
+type DictionaryCategory = 'commands' | 'modifiers' | 'events' | 'logical' | 'temporal' | 'values' | 'attributes' | 'expressions';
+/**
+ * All valid dictionary categories.
+ */
+declare const DICTIONARY_CATEGORIES: readonly DictionaryCategory[];
+/**
+ * Dictionary structure for i18n translations.
+ * Maps English canonical keywords to locale-specific translations.
+ *
+ * Note: Index signature removed for stricter type safety.
+ * Use DICTIONARY_CATEGORIES to iterate over categories.
+ */
+interface Dictionary {
+    commands: Record<string, string>;
+    modifiers: Record<string, string>;
+    events: Record<string, string>;
+    logical: Record<string, string>;
+    temporal: Record<string, string>;
+    values: Record<string, string>;
+    attributes: Record<string, string>;
+    expressions: Record<string, string>;
+}
+/**
+ * Type guard to check if a string is a valid dictionary category.
+ */
+declare function isDictionaryCategory(key: string): key is DictionaryCategory;
+/**
+ * Safely get a category from a dictionary with type narrowing.
+ * Returns undefined if the category doesn't exist.
+ */
+declare function getDictionaryCategory(dict: Dictionary, category: string): Record<string, string> | undefined;
+/**
+ * Iterate over all categories in a dictionary with proper typing.
+ */
+declare function forEachCategory(dict: Dictionary, callback: (category: DictionaryCategory, entries: Record<string, string>) => void): void;
+/**
+ * Find a translation in any category of a dictionary.
+ * Returns the English key if found, undefined otherwise.
+ */
+declare function findInDictionary(dict: Dictionary, localizedWord: string): {
+    category: DictionaryCategory;
+    englishKey: string;
+} | undefined;
+/**
+ * Find a translation for an English word in any category.
+ * Returns the localized word if found, undefined otherwise.
+ */
+declare function translateFromEnglish(dict: Dictionary, englishWord: string): string | undefined;
+interface I18nConfig {
+    locale: string;
+    fallbackLocale?: string;
+    dictionaries?: Record<string, Dictionary>;
+    detectLocale?: boolean;
+    rtlLocales?: string[];
+    preserveOriginalAttribute?: string;
+}
+interface TranslationOptions {
+    from?: string;
+    to: string;
+    preserveOriginal?: boolean;
+    validate?: boolean;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+    coverage: {
+        total: number;
+        translated: number;
+        missing: string[];
+    };
+}
+interface ValidationError {
+    type: 'missing' | 'invalid' | 'duplicate';
+    key: string;
+    message: string;
+}
+interface ValidationWarning {
+    type: 'unused' | 'deprecated' | 'inconsistent';
+    key: string;
+    message: string;
+}
+interface LocaleMetadata {
+    code: string;
+    name: string;
+    nativeName: string;
+    rtl: boolean;
+    pluralRules?: (n: number) => string;
+}
+interface TranslationContext {
+    locale: string;
+    direction: 'ltr' | 'rtl';
+    dictionary: Dictionary;
+    metadata: LocaleMetadata;
+}
+type TokenType = 'command' | 'modifier' | 'event' | 'logical' | 'temporal' | 'value' | 'attribute' | 'expression' | 'identifier' | 'operator' | 'literal';
+interface Token {
+    type: TokenType;
+    value: string;
+    translated?: string;
+    position: {
+        start: number;
+        end: number;
+        line: number;
+        column: number;
+    };
+}
+interface TranslationResult {
+    translated: string;
+    original?: string;
+    tokens: Token[];
+    locale: {
+        from: string;
+        to: string;
+    };
+    warnings?: string[];
+}
+
+/**
+ * Generalized Grammar System for Multilingual Hyperscript
+ *
+ * This system abstracts grammatical patterns across language families,
+ * enabling deep multilingual support without per-language hardcoding.
+ *
+ * Key Linguistic Concepts:
+ * - Word Order: SVO, SOV, VSO (and variations)
+ * - Adposition Type: Preposition (English) vs Postposition (Japanese/Korean)
+ * - Morphology: Isolating (Chinese) vs Agglutinative (Turkish) vs Fusional (Arabic)
+ * - Text Direction: LTR vs RTL
+ */
+/**
+ * Semantic roles in hyperscript commands.
+ * These are universal across all 13 supported languages - only the surface form changes.
+ *
+ * ## Core Thematic Roles (from linguistic theory)
+ * | Role        | Usage | Purpose                     | Example                   |
+ * |-------------|-------|-----------------------------|---------------------------|
+ * | action      | 100%  | Command verb                | toggle, put, fetch        |
+ * | patient     | 90%   | What is acted upon          | .active, #count           |
+ * | destination | 40%   | Where something goes        | into #output, to .class   |
+ * | source      | 13%   | Where something comes from  | from #input, from URL     |
+ * | event       | 106%  | Trigger events              | click, keydown, submit    |
+ * | condition   | 8%    | Boolean expressions         | if x > 5, when visible    |
+ * | agent       | 0%    | Who performs action         | Reserved for future use   |
+ * | goal        | 1%    | Target value/state          | to 'red' (in transition)  |
+ *
+ * ## Quantitative Roles (answer "how much/long")
+ * | Role     | Usage | Purpose        | Example              |
+ * |----------|-------|----------------|----------------------|
+ * | quantity | 7%    | Numeric amount | by 5, 3 times        |
+ * | duration | 1%    | Time span      | for 5 seconds, 500ms |
+ *
+ * ## Adverbial/Modifier Roles (answer "how/by what means")
+ * | Role         | Usage | Purpose                   | Example           |
+ * |--------------|-------|---------------------------|-------------------|
+ * | style        | 2%    | Animation/behavior        | with fade         |
+ * | manner       | 2%    | Insertion position        | before, after     |
+ * | method       | 1%    | HTTP method/technique     | via POST, as GET  |
+ * | responseType | 1%    | Response format           | as json, as html  |
+ *
+ * ## Control Flow Roles
+ * | Role     | Usage | Purpose      | Example               |
+ * |----------|-------|--------------|-----------------------|
+ * | loopType | 6%    | Loop variant | forever, until, times |
+ *
+ * ## Design Notes
+ * - Low-usage roles (agent, goal, method, responseType) are intentionally kept for:
+ *   - Linguistic completeness across all 13 languages
+ *   - Future extensibility (AI agents, server-side execution)
+ *   - Command-specific semantics (fetch, transition)
+ * - Each role has distinct grammatical markers per language (see profiles/index.ts)
+ * - Usage percentages based on pattern database analysis
+ */
+type SemanticRole = 'action' | 'agent' | 'patient' | 'source' | 'destination' | 'goal' | 'event' | 'condition' | 'quantity' | 'duration' | 'responseType' | 'method' | 'style' | 'manner' | 'loopType' | 'continues';
+/**
+ * Word order patterns
+ * These represent the major typological categories
+ */
+type WordOrder = 'SVO' | 'SOV' | 'VSO' | 'VOS' | 'OVS' | 'OSV' | 'free';
+/**
+ * Where grammatical markers appear relative to their noun/verb
+ */
+type AdpositionType = 'preposition' | 'postposition' | 'circumposition' | 'none';
+/**
+ * Morphological typology - how words are constructed
+ */
+type MorphologyType = 'isolating' | 'agglutinative' | 'fusional' | 'polysynthetic';
+/**
+ * A grammatical marker (particle, case ending, preposition)
+ */
+interface GrammaticalMarker {
+    form: string;
+    role: SemanticRole;
+    position: AdpositionType;
+    required: boolean;
+    alternatives?: string[];
+}
+/**
+ * Complete grammatical profile for a language
+ * This captures the essential typological features needed for transformation
+ */
+interface LanguageProfile {
+    code: string;
+    name: string;
+    wordOrder: WordOrder;
+    adpositionType: AdpositionType;
+    morphology: MorphologyType;
+    direction: 'ltr' | 'rtl';
+    markers: GrammaticalMarker[];
+    canonicalOrder: SemanticRole[];
+    rules?: GrammarRule[];
+}
+/**
+ * Pattern for transforming hyperscript structures
+ */
+interface GrammarRule {
+    name: string;
+    description: string;
+    match: PatternMatcher;
+    transform: PatternTransform;
+    priority: number;
+}
+/**
+ * Matches a hyperscript pattern
+ */
+interface PatternMatcher {
+    commands?: string[];
+    requiredRoles: SemanticRole[];
+    optionalRoles?: SemanticRole[];
+    predicate?: (parsed: ParsedStatement) => boolean;
+}
+/**
+ * Defines how to transform a matched pattern
+ */
+interface PatternTransform {
+    roleOrder: SemanticRole[];
+    insertMarkers?: boolean;
+    custom?: (parsed: ParsedStatement, profile: LanguageProfile) => string;
+}
+/**
+ * A parsed hyperscript statement broken into semantic components
+ */
+interface ParsedStatement {
+    type: 'event-handler' | 'command' | 'conditional' | 'loop';
+    roles: Map<SemanticRole, ParsedElement>;
+    original: string;
+}
+/**
+ * A single element with its semantic role
+ */
+interface ParsedElement {
+    role: SemanticRole;
+    value: string;
+    translated?: string;
+    isSelector?: boolean;
+    isLiteral?: boolean;
+}
+/**
+ * Universal templates for common hyperscript patterns
+ * These define the semantic structure independent of surface form
+ */
+declare const UNIVERSAL_PATTERNS: {
+    readonly eventIncrement: {
+        readonly name: "event-increment";
+        readonly roles: SemanticRole[];
+        readonly english: "on {event} {action} {patient}";
+    };
+    readonly putInto: {
+        readonly name: "put-into";
+        readonly roles: SemanticRole[];
+        readonly english: "{action} {patient} into {destination}";
+    };
+    readonly addTo: {
+        readonly name: "add-to";
+        readonly roles: SemanticRole[];
+        readonly english: "{action} {patient} to {destination}";
+    };
+    readonly toggleOn: {
+        readonly name: "toggle-on";
+        readonly roles: SemanticRole[];
+        readonly english: "{action} {patient} on {destination}";
+    };
+    readonly waitDuration: {
+        readonly name: "wait-duration";
+        readonly roles: SemanticRole[];
+        readonly english: "{action} {quantity}";
+    };
+    readonly conditional: {
+        readonly name: "conditional";
+        readonly roles: SemanticRole[];
+        readonly english: "{action} {condition} then ... end";
+    };
+    readonly fetchAs: {
+        readonly name: "fetch-as";
+        readonly roles: SemanticRole[];
+        readonly english: "{action} {source} as {method}";
+    };
+    readonly showWith: {
+        readonly name: "show-with";
+        readonly roles: SemanticRole[];
+        readonly english: "{action} {patient} with {style}";
+    };
+    readonly transitionOver: {
+        readonly name: "transition-over";
+        readonly roles: SemanticRole[];
+        readonly english: "{action} {patient} over {duration}";
+    };
+};
+/**
+ * Default profiles for major language families
+ * Individual languages inherit and override these
+ */
+declare const LANGUAGE_FAMILY_DEFAULTS: Record<string, Partial<LanguageProfile>>;
+/**
+ * Reorder semantic roles according to target language.
+ * Includes a safety net to append any roles present in input
+ * but missing from the target order, preventing data loss.
+ */
+declare function reorderRoles(roles: Map<SemanticRole, ParsedElement>, targetOrder: SemanticRole[]): ParsedElement[];
+/**
+ * Insert grammatical markers between elements
+ */
+declare function insertMarkers(elements: ParsedElement[], markers: GrammaticalMarker[], adpositionType: AdpositionType): string[];
+/**
+ * Intelligently joins tokens, handling agglutinative suffixes and prefixes.
+ *
+ * Rules:
+ * 1. If a token ends with '-' (prefix marker), no space after it
+ * 2. If a token starts with '-' (suffix marker), no space before it
+ * 3. Removes the hyphen indicators from the final output
+ *
+ * Examples:
+ * - ['#count', '-ta'] → '#countta' (Quechua accusative suffix)
+ * - ['بـ-', 'الماوس'] → 'بـالماوس' (Arabic prefix attachment)
+ * - ['value', 'を'] → 'value を' (Japanese particle, normal spacing)
+ */
+declare function joinTokens(tokens: string[]): string;
+/**
+ * Transform a parsed statement to target language
+ */
+declare function transformStatement(parsed: ParsedStatement, _sourceProfile: LanguageProfile, targetProfile: LanguageProfile): string;
+
+/**
+ * Shared Constants for i18n Package
+ *
+ * Centralizes keyword definitions to eliminate duplication across
+ * transformer.ts, create-provider.ts, and other modules.
+ */
+
+/**
+ * English commands - the canonical set that the runtime understands.
+ */
+declare const ENGLISH_COMMANDS: Set<string>;
+/**
+ * English keywords that are not commands.
+ */
+declare const ENGLISH_KEYWORDS: Set<string>;
+/**
+ * English keywords that should always be recognized, even in non-English locales.
+ * These are HTML/DOM standard terms that developers worldwide use.
+ */
+declare const UNIVERSAL_ENGLISH_KEYWORDS: Set<string>;
+
+/**
+ * Creates a KeywordProvider from a dictionary.
+ *
+ * The provider creates reverse mappings (locale → English) for fast
+ * resolution during parsing.
+ *
+ * @example
+ * ```typescript
+ * import { es } from '../dictionaries/es';
+ * export const esKeywords = createKeywordProvider(es, 'es');
+ * ```
+ */
+declare function createKeywordProvider(dictionary: Dictionary, locale: string, options?: KeywordProviderOptions): KeywordProvider;
+/**
+ * Creates a default English-only keyword provider.
+ * This is used when no locale is specified.
+ */
+declare function createEnglishProvider(): KeywordProvider;
+
+declare const es: Dictionary;
+
+/**
+ * Spanish keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Spanish:
+ * - `en clic alternar .active` → parses as `on click toggle .active`
+ * - `si verdadero entonces registrar "hola"` → parses as `if true then log "hello"`
+ *
+ * English keywords are also accepted (mixed mode), so:
+ * - `en click alternar .active` also works (Spanish `en` + English `click`)
+ *
+ * @example
+ * ```typescript
+ * import { esKeywords } from '@lokascript/i18n/parser/es';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: esKeywords });
+ * parser.parse('en clic alternar .active');
+ * ```
+ */
+declare const esKeywords: KeywordProvider;
+
+declare const ja: Dictionary;
+
+/**
+ * Japanese keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Japanese:
+ * - `クリック で 切り替え .active` → parses as `on click toggle .active`
+ * - `もし 真 それから 記録 "こんにちは"` → parses as `if true then log "hello"`
+ *
+ * English keywords are also accepted (mixed mode), so:
+ * - `click で 切り替え .active` also works (English `click` + Japanese `で`, `切り替え`)
+ *
+ * Japanese is a useful test case because:
+ * - SOV word order (subject-object-verb) vs English SVO
+ * - No articles (a, an, the)
+ * - Unicode characters (tests tokenizer robustness)
+ *
+ * @example
+ * ```typescript
+ * import { jaKeywords } from '@lokascript/i18n/parser/ja';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: jaKeywords });
+ * parser.parse('クリック で 切り替え .active');
+ * ```
+ */
+declare const jaKeywords: KeywordProvider;
+
+declare const fr: Dictionary;
+
+/**
+ * French keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in French:
+ * - `sur clic basculer .active` → parses as `on click toggle .active`
+ * - `si vrai alors enregistrer "bonjour"` → parses as `if true then log "hello"`
+ *
+ * English keywords are also accepted (mixed mode), so:
+ * - `sur click basculer .active` also works (French `sur` + English `click`)
+ *
+ * @example
+ * ```typescript
+ * import { frKeywords } from '@lokascript/i18n/parser/fr';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: frKeywords });
+ * parser.parse('sur clic basculer .active');
+ * ```
+ */
+declare const frKeywords: KeywordProvider;
+
+declare const de: Dictionary;
+
+/**
+ * German keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in German:
+ * - `bei klick umschalten .active` → parses as `on click toggle .active`
+ * - `wenn wahr dann protokollieren "hallo"` → parses as `if true then log "hello"`
+ *
+ * English keywords are also accepted (mixed mode), so:
+ * - `bei click umschalten .active` also works (German `bei` + English `click`)
+ *
+ * German is a useful test case because:
+ * - Compound words (Zusammensetzungen) are common
+ * - Different word order in clauses (V2 in main, V-final in subordinate)
+ * - Case system (nominative, accusative, dative, genitive)
+ *
+ * @example
+ * ```typescript
+ * import { deKeywords } from '@lokascript/i18n/parser/de';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: deKeywords });
+ * parser.parse('bei klick umschalten .active');
+ * ```
+ */
+declare const deKeywords: KeywordProvider;
+
+declare const ar: Dictionary;
+
+/**
+ * Arabic keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Arabic:
+ * - `على نقر بدل .active` → parses as `on click toggle .active`
+ * - `إذا صحيح ثم سجل "مرحبا"` → parses as `if true then log "hello"`
+ *
+ * English keywords are also accepted (mixed mode), so:
+ * - `على click بدل .active` also works (Arabic `على` + English `click`)
+ *
+ * Arabic is a crucial test case because:
+ * - Right-to-left (RTL) script
+ * - Different character set (Unicode Arabic block)
+ * - Space-separated words with diacritics
+ * - Tests parser's Unicode handling robustly
+ *
+ * Note: The parser handles RTL text correctly because tokenization
+ * is based on whitespace/operator boundaries, not visual direction.
+ *
+ * @example
+ * ```typescript
+ * import { arKeywords } from '@lokascript/i18n/parser/ar';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: arKeywords });
+ * parser.parse('على نقر بدل .active');
+ * ```
+ */
+declare const arKeywords: KeywordProvider;
+
+declare const ko: Dictionary;
+
+/**
+ * Korean keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Korean:
+ * - `에 클릭 토글 .active` → parses as `on click toggle .active`
+ * - `만약 참 그러면 로그 "안녕하세요"` → parses as `if true then log "hello"`
+ *
+ * English keywords are also accepted (mixed mode), so:
+ * - `에 click 토글 .active` also works (Korean `에` + English `click`)
+ *
+ * Korean is a useful test case because:
+ * - SOV word order (Subject-Object-Verb)
+ * - Hangul script (syllabic blocks)
+ * - Agglutinative morphology with particles
+ * - Tests parser's Unicode handling with Korean characters
+ *
+ * @example
+ * ```typescript
+ * import { koKeywords } from '@lokascript/i18n/parser/ko';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: koKeywords });
+ * parser.parse('에 클릭 토글 .active');
+ * ```
+ */
+declare const koKeywords: KeywordProvider;
+
+declare const zh: Dictionary;
+
+/**
+ * Chinese (Simplified) keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Chinese:
+ * - `当 点击 切换 .active` → parses as `on click toggle .active`
+ * - `如果 真 那么 日志 "你好"` → parses as `if true then log "hello"`
+ *
+ * English keywords are also accepted (mixed mode), so:
+ * - `当 click 切换 .active` also works (Chinese `当` + English `click`)
+ *
+ * Chinese is a useful test case because:
+ * - SVO word order (similar to English)
+ * - Logographic script (Chinese characters)
+ * - Isolating morphology (minimal inflection)
+ * - Tests parser's Unicode handling with CJK characters
+ * - Large developer population
+ *
+ * @example
+ * ```typescript
+ * import { zhKeywords } from '@lokascript/i18n/parser/zh';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: zhKeywords });
+ * parser.parse('当 点击 切换 .active');
+ * ```
+ */
+declare const zhKeywords: KeywordProvider;
+
+declare const tr: Dictionary;
+
+/**
+ * Turkish keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Turkish:
+ * - `üzerinde tıklama değiştir .active` → parses as `on click toggle .active`
+ * - `eğer doğru ise kaydet "merhaba"` → parses as `if true then log "hello"`
+ *
+ * English keywords are also accepted (mixed mode), so:
+ * - `üzerinde click değiştir .active` also works (Turkish `üzerinde` + English `click`)
+ *
+ * Turkish is a useful test case because:
+ * - SOV word order (Subject-Object-Verb)
+ * - Agglutinative morphology with suffixes
+ * - Vowel harmony rules
+ * - Latin script with special characters (ı, ğ, ş, ç, ö, ü)
+ * - Tests parser's handling of extended Latin characters
+ *
+ * @example
+ * ```typescript
+ * import { trKeywords } from '@lokascript/i18n/parser/tr';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: trKeywords });
+ * parser.parse('üzerinde tıklama değiştir .active');
+ * ```
+ */
+declare const trKeywords: KeywordProvider;
+
+declare const id: Dictionary;
+
+/**
+ * Indonesian (Bahasa Indonesia) keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Indonesian:
+ * - `pada klik ganti .active` → parses as `on click toggle .active`
+ * - `jika benar lalu log "Halo"` → parses as `if true then log "Hello"`
+ *
+ * Indonesian is an SVO language with:
+ * - Agglutinative morphology (prefixes/suffixes)
+ * - No grammatical gender
+ * - Prepositions (like English)
+ * - Relatively simple syntax
+ *
+ * @example
+ * ```typescript
+ * import { idKeywords } from '@lokascript/i18n/parser/id';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: idKeywords });
+ * parser.parse('pada klik ganti .active');
+ * ```
+ */
+declare const idKeywords: KeywordProvider;
+
+declare const qu: Dictionary;
+
+/**
+ * Quechua (Runasimi) keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Quechua:
+ * - `ñitiy-pi yapay #count-ta` → parses as `on click increment #count`
+ *
+ * Quechua is an SOV language with:
+ * - Agglutinative/polysynthetic morphology
+ * - Extensive suffix system (case markers: -ta, -man, -pi, -manta, -wan)
+ * - Postpositions (unlike Spanish which uses prepositions)
+ * - Object-Verb word order
+ * - Evidentiality markers (not used in hyperscript)
+ *
+ * The grammar transformer handles suffix joining via hyphen notation
+ * (e.g., "#count-ta" attaches the accusative marker).
+ *
+ * @example
+ * ```typescript
+ * import { quKeywords } from '@lokascript/i18n/parser/qu';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: quKeywords });
+ * parser.parse('ñitiy-pi yapay #count-ta');
+ * ```
+ */
+declare const quKeywords: KeywordProvider;
+
+declare const sw: Dictionary;
+
+/**
+ * Swahili (Kiswahili) keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Swahili:
+ * - `kwenye bonyeza badilisha .active` → parses as `on click toggle .active`
+ * - `kama kweli basi andika "Habari"` → parses as `if true then log "Hello"`
+ *
+ * Swahili is an SVO Bantu language with:
+ * - Agglutinative verb morphology
+ * - Noun class system (simplified for hyperscript keywords)
+ * - Prepositions (unlike many other African languages)
+ * - Subject-verb agreement (not relevant for hyperscript)
+ *
+ * Swahili is widely spoken in East Africa and serves as a lingua franca
+ * for millions of speakers.
+ *
+ * @example
+ * ```typescript
+ * import { swKeywords } from '@lokascript/i18n/parser/sw';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: swKeywords });
+ * parser.parse('kwenye bonyeza badilisha .active');
+ * ```
+ */
+declare const swKeywords: KeywordProvider;
+
+/**
+ * Portuguese (Português) dictionary for hyperscript keywords.
+ * Brazilian Portuguese variant.
+ */
+declare const pt: Dictionary;
+
+/**
+ * Portuguese (Português) keyword provider for the hyperscript parser.
+ *
+ * Enables parsing hyperscript written in Portuguese:
+ * - `em clique alternar .active` → parses as `on click toggle .active`
+ * - `se verdadeiro então registrar "Olá"` → parses as `if true then log "Hello"`
+ *
+ * Portuguese is an SVO language with:
+ * - High mutual intelligibility with Spanish
+ * - Prepositions (like English and Spanish)
+ * - Gender agreement (simplified for hyperscript)
+ * - Fusional morphology
+ *
+ * Direct translation is supported between Portuguese and Spanish,
+ * avoiding the English pivot for more natural translations.
+ *
+ * @example
+ * ```typescript
+ * import { ptKeywords } from '@lokascript/i18n/parser/pt';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser({ keywords: ptKeywords });
+ * parser.parse('em clique alternar .active');
+ * ```
+ */
+declare const ptKeywords: KeywordProvider;
+
+/**
+ * LocaleManager - Centralized locale configuration for hyperscript parsing.
+ *
+ * Provides utilities for:
+ * - Setting/getting the default locale
+ * - Creating locale-aware parsers
+ * - Runtime locale switching
+ *
+ * @example
+ * ```typescript
+ * import { LocaleManager } from '@lokascript/i18n/parser';
+ * import { esKeywords, frKeywords } from '@lokascript/i18n/parser';
+ *
+ * // Register available locales
+ * LocaleManager.register('es', esKeywords);
+ * LocaleManager.register('fr', frKeywords);
+ *
+ * // Set default locale
+ * LocaleManager.setDefault('es');
+ *
+ * // Get keyword provider for parsing
+ * const provider = LocaleManager.get(); // Returns esKeywords
+ * const frProvider = LocaleManager.get('fr'); // Returns frKeywords
+ *
+ * // Use with parser
+ * const parser = new Parser({ keywords: LocaleManager.get() });
+ * ```
+ */
+declare class LocaleManager {
+    private static providers;
+    private static defaultLocale;
+    private static englishProvider;
+    /**
+     * Register a locale provider.
+     *
+     * @param locale - The locale code (e.g., 'es', 'ja', 'fr')
+     * @param provider - The KeywordProvider for this locale
+     */
+    static register(locale: string, provider: KeywordProvider): void;
+    /**
+     * Unregister a locale provider.
+     *
+     * @param locale - The locale code to remove
+     */
+    static unregister(locale: string): void;
+    /**
+     * Set the default locale.
+     *
+     * @param locale - The locale code to use as default
+     * @throws Error if the locale is not registered
+     */
+    static setDefault(locale: string): void;
+    /**
+     * Get the current default locale.
+     *
+     * @returns The default locale code
+     */
+    static getDefault(): string;
+    /**
+     * Get a keyword provider for a locale.
+     *
+     * @param locale - The locale code (optional, defaults to the default locale)
+     * @returns The KeywordProvider for the locale
+     * @throws Error if the locale is not registered
+     */
+    static get(locale?: string): KeywordProvider;
+    /**
+     * Check if a locale is registered.
+     *
+     * @param locale - The locale code to check
+     * @returns True if the locale is available
+     */
+    static has(locale: string): boolean;
+    /**
+     * Get all available locale codes.
+     *
+     * @returns Array of locale codes
+     */
+    static getAvailable(): string[];
+    /**
+     * Reset the LocaleManager to its initial state.
+     * Useful for testing.
+     */
+    static reset(): void;
+    /**
+     * Register all built-in locales at once.
+     *
+     * @example
+     * ```typescript
+     * import { LocaleManager } from '@lokascript/i18n/parser';
+     * import { esKeywords, jaKeywords, frKeywords, deKeywords, arKeywords } from '@lokascript/i18n/parser';
+     *
+     * LocaleManager.registerAll({
+     *   es: esKeywords,
+     *   ja: jaKeywords,
+     *   fr: frKeywords,
+     *   de: deKeywords,
+     *   ar: arKeywords,
+     * });
+     * ```
+     */
+    static registerAll(providers: Record<string, KeywordProvider>): void;
+}
+/**
+ * Quick utility to detect the browser's preferred locale and return
+ * a matching provider, falling back to English.
+ *
+ * @returns The KeywordProvider for the browser's locale or English
+ *
+ * @example
+ * ```typescript
+ * import { detectBrowserLocale } from '@lokascript/i18n/parser';
+ * import { Parser } from '@lokascript/core';
+ *
+ * // Auto-detect and use browser locale
+ * const parser = new Parser({ keywords: detectBrowserLocale() });
+ * ```
+ */
+declare function detectBrowserLocale(): KeywordProvider;
+
+/**
+ * Language Profiles Index
+ *
+ * Concrete implementations of LanguageProfile for supported languages.
+ * Each profile inherits from a language family default and adds
+ * language-specific markers and rules.
+ */
+
+declare const englishProfile: LanguageProfile;
+declare const japaneseProfile: LanguageProfile;
+declare const koreanProfile: LanguageProfile;
+declare const chineseProfile: LanguageProfile;
+declare const arabicProfile: LanguageProfile;
+declare const turkishProfile: LanguageProfile;
+declare const spanishProfile: LanguageProfile;
+declare const germanProfile: LanguageProfile;
+declare const frenchProfile: LanguageProfile;
+declare const portugueseProfile: LanguageProfile;
+declare const indonesianProfile: LanguageProfile;
+declare const quechuaProfile: LanguageProfile;
+declare const swahiliProfile: LanguageProfile;
+declare const profiles: Record<string, LanguageProfile>;
+declare function getProfile(locale: string): LanguageProfile | undefined;
+declare function getSupportedLocales(): string[];
+
+/**
+ * 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.
+ */
+
+/**
+ * Parse a hyperscript statement into semantic roles
+ * This is the core analysis step that identifies WHAT each part means
+ */
+declare function parseStatement(input: string, sourceLocale?: string): ParsedStatement | null;
+declare class GrammarTransformer {
+    private sourceProfile;
+    private targetProfile;
+    constructor(sourceLocale: string | undefined, targetLocale: string);
+    /**
+     * 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: string): string;
+    /**
+     * Transform a single hyperscript statement (no compound "then" chains).
+     */
+    private transformSingle;
+    /**
+     * Find the best matching rule for this statement
+     */
+    private findRule;
+    /**
+     * Check if a parsed statement matches a rule
+     */
+    private matchesRule;
+}
+/**
+ * Transform hyperscript from English to target language
+ */
+declare function toLocale(input: string, targetLocale: string): string;
+/**
+ * Transform hyperscript from source language to English
+ */
+declare function toEnglish(input: string, sourceLocale: string): string;
+/**
+ * Transform between any two languages.
+ *
+ * Uses direct translation for supported language pairs (ja↔zh, es↔pt, ko↔ja),
+ * falling back to English pivot for other pairs.
+ */
+declare function translate(input: string, sourceLocale: string, targetLocale: string): string;
+declare const examples: {
+    english: {
+        eventHandler: string;
+        putInto: string;
+        toggle: string;
+        wait: string;
+    };
+    japanese: {
+        eventHandler: string;
+        putInto: string;
+        toggle: string;
+        wait: string;
+    };
+    chinese: {
+        eventHandler: string;
+        putInto: string;
+        toggle: string;
+        wait: string;
+    };
+    arabic: {
+        eventHandler: string;
+        putInto: string;
+        toggle: string;
+        wait: string;
+    };
+};
+
+export { englishProfile as $, ptKeywords as A, pt as B, detectBrowserLocale as C, type AdpositionType as D, ENGLISH_COMMANDS as E, type LanguageProfile as F, type GrammaticalMarker as G, type GrammarRule as H, type PatternTransform as I, type ParsedStatement as J, type KeywordProvider as K, LocaleManager as L, type MorphologyType as M, type ParsedElement as N, UNIVERSAL_PATTERNS as O, type PatternMatcher as P, LANGUAGE_FAMILY_DEFAULTS as Q, reorderRoles as R, type SemanticRole as S, insertMarkers as T, UNIVERSAL_ENGLISH_KEYWORDS as U, joinTokens as V, type WordOrder as W, transformStatement as X, profiles as Y, getProfile as Z, getSupportedLocales as _, type KeywordProviderOptions as a, japaneseProfile as a0, koreanProfile as a1, chineseProfile as a2, arabicProfile as a3, turkishProfile as a4, spanishProfile as a5, germanProfile as a6, frenchProfile as a7, portugueseProfile as a8, indonesianProfile as a9, quechuaProfile as aa, swahiliProfile as ab, GrammarTransformer as ac, parseStatement as ad, toLocale as ae, toEnglish as af, translate as ag, examples as ah, type I18nConfig as ai, type TranslationOptions as aj, type TranslationResult as ak, type Dictionary as al, type ValidationResult as am, type Token as an, type DictionaryCategory as ao, type ValidationError as ap, type ValidationWarning as aq, type LocaleMetadata as ar, type TranslationContext as as, type TokenType as at, DICTIONARY_CATEGORIES as au, isDictionaryCategory as av, getDictionaryCategory as aw, forEachCategory as ax, findInDictionary as ay, translateFromEnglish as az, createEnglishProvider as b, createKeywordProvider as c, ENGLISH_KEYWORDS as d, esKeywords as e, es as f, ja as g, frKeywords as h, fr as i, jaKeywords as j, deKeywords as k, de as l, arKeywords as m, ar as n, koKeywords as o, ko as p, zh as q, tr as r, idKeywords as s, trKeywords as t, id as u, quKeywords as v, qu as w, swKeywords as x, sw as y, zhKeywords as z };