@lokascript/semantic 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,3426 @@
+/**
+ * Grammar Types for Semantic Multilingual Parsing
+ *
+ * These types define the semantic role system used across all 13 supported languages.
+ * Originally from @lokascript/i18n, now consolidated here for package independence.
+ *
+ * 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$1 = '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[];
+}
+
+/**
+ * Semantic-First Multilingual Hyperscript Types
+ *
+ * This module defines the canonical semantic representation that all languages
+ * parse to and render from. The semantic layer is language-neutral - it captures
+ * the MEANING of hyperscript commands independent of surface syntax.
+ */
+
+/**
+ * Canonical action names (English-based internally, but not visible to users)
+ * These map to hyperscript commands and are used in the semantic AST.
+ */
+type ActionType = 'toggle' | 'add' | 'remove' | 'put' | 'append' | 'prepend' | 'take' | 'make' | 'clone' | 'swap' | 'morph' | 'set' | 'get' | 'increment' | 'decrement' | 'log' | 'show' | 'hide' | 'transition' | 'on' | 'trigger' | 'send' | 'focus' | 'blur' | 'go' | 'wait' | 'fetch' | 'settle' | 'measure' | 'install' | 'if' | 'unless' | 'else' | 'repeat' | 'for' | 'while' | 'continue' | 'halt' | 'throw' | 'call' | 'return' | 'js' | 'async' | 'tell' | 'default' | 'init' | 'behavior' | 'compound';
+/**
+ * A semantic value represents a typed piece of data in a semantic node.
+ * Values are language-neutral - they capture what something IS, not how it's written.
+ */
+type SemanticValue = LiteralValue | SelectorValue | ReferenceValue | PropertyPathValue | ExpressionValue;
+interface LiteralValue {
+    readonly type: 'literal';
+    readonly value: string | number | boolean;
+    readonly dataType?: 'string' | 'number' | 'boolean' | 'duration';
+}
+interface SelectorValue {
+    readonly type: 'selector';
+    readonly value: string;
+    readonly selectorKind: 'id' | 'class' | 'attribute' | 'element' | 'complex';
+}
+interface ReferenceValue {
+    readonly type: 'reference';
+    readonly value: 'me' | 'you' | 'it' | 'result' | 'event' | 'target' | 'body';
+}
+interface PropertyPathValue {
+    readonly type: 'property-path';
+    readonly object: SemanticValue;
+    readonly property: string;
+}
+interface ExpressionValue {
+    readonly type: 'expression';
+    /** Raw expression string for complex expressions that need further parsing */
+    readonly raw: string;
+}
+/**
+ * Base interface for all semantic nodes.
+ * Semantic nodes capture the MEANING of hyperscript constructs.
+ */
+interface SemanticNode {
+    readonly kind: 'command' | 'event-handler' | 'conditional' | 'compound' | 'loop';
+    readonly action: ActionType;
+    readonly roles: ReadonlyMap<SemanticRole, SemanticValue>;
+    readonly metadata?: SemanticMetadata;
+}
+/**
+ * Metadata about the source of a semantic node.
+ * Useful for debugging, error messages, and round-trip conversion.
+ */
+interface SemanticMetadata {
+    readonly sourceLanguage?: string;
+    readonly sourceText?: string;
+    readonly sourcePosition?: SourcePosition;
+    readonly patternId?: string;
+}
+interface SourcePosition {
+    readonly start: number;
+    readonly end: number;
+    readonly line?: number;
+    readonly column?: number;
+}
+/**
+ * A command semantic node - represents a single hyperscript command.
+ */
+interface CommandSemanticNode extends SemanticNode {
+    readonly kind: 'command';
+}
+/**
+ * An event handler semantic node - represents "on [event] [commands]".
+ */
+interface EventHandlerSemanticNode extends SemanticNode {
+    readonly kind: 'event-handler';
+    readonly action: 'on';
+    readonly body: SemanticNode[];
+    readonly eventModifiers?: EventModifiers;
+    /**
+     * Event parameter names for destructuring.
+     * E.g., for "on click(clientX, clientY)", this would be ['clientX', 'clientY']
+     */
+    readonly parameterNames?: readonly string[];
+}
+interface EventModifiers {
+    readonly once?: boolean;
+    readonly debounce?: number;
+    readonly throttle?: number;
+    readonly queue?: 'first' | 'last' | 'all' | 'none';
+    readonly from?: SemanticValue;
+}
+/**
+ * A conditional semantic node - represents "if [condition] then [body] else [body]".
+ */
+interface ConditionalSemanticNode extends SemanticNode {
+    readonly kind: 'conditional';
+    readonly action: 'if';
+    readonly thenBranch: SemanticNode[];
+    readonly elseBranch?: SemanticNode[];
+}
+/**
+ * A compound semantic node - represents multiple chained statements.
+ */
+interface CompoundSemanticNode extends SemanticNode {
+    readonly kind: 'compound';
+    readonly statements: SemanticNode[];
+    readonly chainType: 'then' | 'and' | 'async';
+}
+/**
+ * Loop variant discriminant for different loop types.
+ */
+type LoopVariant = 'forever' | 'times' | 'for' | 'while' | 'until';
+/**
+ * A loop semantic node - represents repeat/for/while loops.
+ */
+interface LoopSemanticNode extends SemanticNode {
+    readonly kind: 'loop';
+    readonly action: 'repeat' | 'for' | 'while';
+    /** The type of loop (forever, times, for, while, until) */
+    readonly loopVariant: LoopVariant;
+    /** Commands to execute in each iteration */
+    readonly body: SemanticNode[];
+    /** Loop variable name for 'for' loops (e.g., 'item' in 'for item in list') */
+    readonly loopVariable?: string;
+    /** Index variable name if specified (e.g., 'i' in 'for item with index i') */
+    readonly indexVariable?: string;
+}
+/**
+ * A pattern defines how a semantic structure appears in a specific language.
+ * Patterns enable bidirectional conversion: parse (natural → semantic) and
+ * render (semantic → natural).
+ */
+interface LanguagePattern {
+    /** Unique identifier for this pattern */
+    readonly id: string;
+    /** ISO 639-1 language code */
+    readonly language: string;
+    /** Which command this pattern matches */
+    readonly command: ActionType;
+    /** Priority for disambiguation (higher = checked first) */
+    readonly priority: number;
+    /** The pattern template with role placeholders */
+    readonly template: PatternTemplate;
+    /** Rules for extracting semantic roles from matched tokens */
+    readonly extraction: ExtractionRules;
+    /** Optional constraints on when this pattern applies */
+    readonly constraints?: PatternConstraints;
+}
+/**
+ * A pattern template defines the expected token sequence.
+ *
+ * Template syntax:
+ * - Literal tokens: "toggle", "を", "على"
+ * - Role placeholders: {patient}, {target}, {destination}
+ * - Optional groups: [on {target}]
+ * - Alternatives in extraction (not in template string)
+ *
+ * Example templates:
+ * - English: "toggle {patient} [on {target}]"
+ * - Japanese: "{target} の {patient} を 切り替え"
+ * - Arabic: "بدّل {patient} [على {target}]"
+ */
+interface PatternTemplate {
+    /** Human-readable template string */
+    readonly format: string;
+    /** Parsed token sequence for matching */
+    readonly tokens: PatternToken[];
+}
+type PatternToken = LiteralPatternToken | RolePatternToken | GroupPatternToken;
+interface LiteralPatternToken {
+    readonly type: 'literal';
+    readonly value: string;
+    /** Alternative spellings/forms that also match */
+    readonly alternatives?: string[];
+}
+interface RolePatternToken {
+    readonly type: 'role';
+    readonly role: SemanticRole;
+    readonly optional?: boolean;
+    /** Expected value types (for validation) */
+    readonly expectedTypes?: Array<SemanticValue['type']>;
+}
+interface GroupPatternToken {
+    readonly type: 'group';
+    readonly tokens: PatternToken[];
+    readonly optional?: boolean;
+}
+/**
+ * Rules for extracting semantic values from matched tokens.
+ */
+interface ExtractionRules {
+    readonly [role: string]: ExtractionRule;
+}
+interface ExtractionRule {
+    /** Position-based extraction (0-indexed from pattern start) */
+    readonly position?: number;
+    /** Marker-based extraction (find value after this marker) */
+    readonly marker?: string;
+    /** Alternative markers that also work */
+    readonly markerAlternatives?: string[];
+    /** Transform the extracted value */
+    readonly transform?: (raw: string) => SemanticValue;
+    /** Default value if not found (for optional roles) */
+    readonly default?: SemanticValue;
+}
+/**
+ * Additional constraints on pattern applicability.
+ */
+interface PatternConstraints {
+    /** Required roles that must be present */
+    readonly requiredRoles?: SemanticRole[];
+    /** Roles that must NOT be present */
+    readonly forbiddenRoles?: SemanticRole[];
+    /** Valid selector types for the patient role */
+    readonly validPatientTypes?: Array<SelectorValue['selectorKind']>;
+    /** Pattern IDs this conflicts with */
+    readonly conflictsWith?: string[];
+}
+/**
+ * A token from language-specific tokenization.
+ */
+interface LanguageToken {
+    readonly value: string;
+    readonly kind: TokenKind;
+    readonly position: SourcePosition;
+    /** Normalized form from explicit keyword map (e.g., 切り替え → toggle) */
+    readonly normalized?: string;
+    /** Morphologically normalized stem (e.g., 切り替えた → 切り替え) */
+    readonly stem?: string;
+    /** Confidence in the morphological stem (0.0-1.0) */
+    readonly stemConfidence?: number;
+    /** Additional metadata for specific token types (e.g., event modifier data) */
+    readonly metadata?: Record<string, unknown>;
+}
+type TokenKind = 'keyword' | 'selector' | 'literal' | 'particle' | 'conjunction' | 'event-modifier' | 'identifier' | 'operator' | 'punctuation' | 'url';
+/**
+ * A stream of tokens with navigation capabilities.
+ */
+interface TokenStream {
+    readonly tokens: readonly LanguageToken[];
+    readonly language: string;
+    /** Look at token at current position + offset without consuming */
+    peek(offset?: number): LanguageToken | null;
+    /** Consume and return current token, advance position */
+    advance(): LanguageToken;
+    /** Check if we've consumed all tokens */
+    isAtEnd(): boolean;
+    /** Save current position for backtracking */
+    mark(): StreamMark;
+    /** Restore to a saved position */
+    reset(mark: StreamMark): void;
+    /** Get current position */
+    position(): number;
+}
+interface StreamMark {
+    readonly position: number;
+}
+/**
+ * Result of successfully matching a pattern.
+ */
+interface PatternMatchResult {
+    readonly pattern: LanguagePattern;
+    readonly captured: ReadonlyMap<SemanticRole, SemanticValue>;
+    readonly consumedTokens: number;
+    readonly confidence: number;
+}
+/**
+ * Error when pattern matching fails.
+ */
+interface PatternMatchError {
+    readonly message: string;
+    readonly position: SourcePosition;
+    readonly expectedPatterns?: string[];
+    readonly partialMatch?: Partial<PatternMatchResult>;
+}
+/**
+ * Language-specific tokenizer interface.
+ * Each language implements its own tokenizer to handle:
+ * - Word boundaries (spaces for English, particles for Japanese)
+ * - Character sets (ASCII, CJK, Arabic, etc.)
+ * - Special markers (particles, prefixes, suffixes)
+ */
+interface LanguageTokenizer {
+    readonly language: string;
+    readonly direction: 'ltr' | 'rtl';
+    /** Convert input string to token stream */
+    tokenize(input: string): TokenStream;
+    /** Classify a single token */
+    classifyToken(token: string): TokenKind;
+}
+/**
+ * Main parser interface - converts natural language to semantic nodes.
+ */
+interface SemanticParser {
+    /** Parse input in specified language to semantic node */
+    parse(input: string, language: string): SemanticNode;
+    /** Check if input can be parsed in the specified language */
+    canParse(input: string, language: string): boolean;
+    /** Get all supported languages */
+    supportedLanguages(): string[];
+}
+/**
+ * Renderer interface - converts semantic nodes to natural language.
+ */
+interface SemanticRenderer {
+    /** Render semantic node in specified language */
+    render(node: SemanticNode, language: string): string;
+    /** Render semantic node in explicit mode */
+    renderExplicit(node: SemanticNode): string;
+    /** Get all supported languages */
+    supportedLanguages(): string[];
+}
+/**
+ * Create a selector semantic value from a CSS selector string.
+ */
+declare function createSelector(value: string): SelectorValue;
+/**
+ * Create a literal semantic value.
+ */
+declare function createLiteral(value: string | number | boolean, dataType?: LiteralValue['dataType']): LiteralValue;
+/**
+ * Create a reference semantic value.
+ */
+declare function createReference(value: ReferenceValue['value']): ReferenceValue;
+/**
+ * Create a property path semantic value.
+ */
+declare function createPropertyPath(object: SemanticValue, property: string): PropertyPathValue;
+/**
+ * Create a semantic node with the given action and roles.
+ */
+declare function createCommandNode(action: ActionType, roles: Record<string, SemanticValue>, metadata?: SemanticMetadata): CommandSemanticNode;
+/**
+ * Create an event handler semantic node.
+ */
+declare function createEventHandler(event: SemanticValue, body: SemanticNode[], modifiers?: EventModifiers, metadata?: SemanticMetadata, parameterNames?: string[]): EventHandlerSemanticNode;
+/**
+ * Create a compound semantic node (for chained statements).
+ */
+declare function createCompoundNode(statements: SemanticNode[], chainType?: 'then' | 'and' | 'async', metadata?: SemanticMetadata): CompoundSemanticNode;
+/**
+ * Create a conditional semantic node (if/else).
+ */
+declare function createConditionalNode(condition: SemanticValue, thenBranch: SemanticNode[], elseBranch?: SemanticNode[], metadata?: SemanticMetadata): ConditionalSemanticNode;
+/**
+ * Create a loop semantic node.
+ */
+declare function createLoopNode(action: 'repeat' | 'for' | 'while', loopVariant: LoopVariant, roles: Record<string, SemanticValue>, body: SemanticNode[], options?: {
+    loopVariable?: string;
+    indexVariable?: string;
+    metadata?: SemanticMetadata;
+}): LoopSemanticNode;
+/**
+ * Argument with semantic role attached.
+ */
+type SemanticArgument = SemanticValue & {
+    role?: SemanticRole;
+};
+/**
+ * Result of semantic parsing (used by command validator).
+ */
+interface SemanticParseResult {
+    /** The action/command type */
+    readonly action: ActionType;
+    /** Confidence score (0-1) */
+    readonly confidence: number;
+    /** Source language code */
+    readonly language: string;
+    /** Parsed arguments with roles */
+    readonly arguments: SemanticArgument[];
+}
+
+/**
+ * Morphological Normalizer Types
+ *
+ * Defines interfaces for language-specific morphological analysis.
+ * Normalizers reduce conjugated/inflected forms to canonical stems
+ * that can be matched against keyword dictionaries.
+ */
+/**
+ * Result of morphological normalization.
+ */
+interface NormalizationResult {
+    /** The extracted stem/root form */
+    readonly stem: string;
+    /** Confidence in the normalization (0.0-1.0) */
+    readonly confidence: number;
+    /** Optional metadata about the transformation */
+    readonly metadata?: NormalizationMetadata;
+}
+/**
+ * Metadata about morphological transformations applied.
+ */
+interface NormalizationMetadata {
+    /** Prefixes that were removed */
+    readonly removedPrefixes?: readonly string[];
+    /** Suffixes that were removed */
+    readonly removedSuffixes?: readonly string[];
+    /** Type of conjugation detected */
+    readonly conjugationType?: ConjugationType;
+    /** Original form classification */
+    readonly originalForm?: string;
+    /** Applied transformation rules (for debugging) */
+    readonly appliedRules?: readonly string[];
+}
+/**
+ * Types of verb conjugation/inflection.
+ */
+type ConjugationType = 'present' | 'past' | 'future' | 'progressive' | 'perfect' | 'imperative' | 'subjunctive' | 'conditional' | 'passive' | 'causative' | 'polite' | 'humble' | 'honorific' | 'negative' | 'potential' | 'volitional' | 'conditional-tara' | 'conditional-to' | 'conditional-ba' | 'connective' | 'conditional-myeon' | 'temporal-ttae' | 'causal-nikka' | 'honorific-conditional' | 'honorific-temporal' | 'honorific-causal' | 'honorific-past' | 'honorific-polite' | 'sequential-after' | 'sequential-before' | 'immediate' | 'obligation' | 'reflexive' | 'reflexive-imperative' | 'gerund' | 'participle' | 'conditional-idha' | 'temporal-indama' | 'temporal-hina' | 'temporal-lamma' | 'past-verb' | 'conditional-se' | 'temporal-ince' | 'temporal-dikce' | 'aorist' | 'optative' | 'necessitative' | 'request' | 'casual-request' | 'contracted' | 'contracted-past' | 'compound' | 'te-form' | 'dictionary';
+/**
+ * Interface for language-specific morphological normalizers.
+ *
+ * Normalizers attempt to reduce inflected word forms to their
+ * canonical stems. This enables matching conjugated verbs against
+ * keyword dictionaries that only contain base forms.
+ *
+ * Example (Japanese):
+ *   切り替えた (past) → { stem: '切り替え', confidence: 0.85 }
+ *   切り替えます (polite) → { stem: '切り替え', confidence: 0.85 }
+ *
+ * Example (Spanish):
+ *   mostrarse (reflexive infinitive) → { stem: 'mostrar', confidence: 0.85 }
+ *   alternando (gerund) → { stem: 'alternar', confidence: 0.85 }
+ */
+interface MorphologicalNormalizer {
+    /** Language code this normalizer handles */
+    readonly language: string;
+    /**
+     * Normalize a word to its canonical stem form.
+     *
+     * @param word - The word to normalize
+     * @returns Normalization result with stem and confidence
+     */
+    normalize(word: string): NormalizationResult;
+    /**
+     * Check if a word appears to be a verb form that can be normalized.
+     * Optional optimization to skip normalization for non-verb tokens.
+     *
+     * @param word - The word to check
+     * @returns true if the word might be a normalizable verb form
+     */
+    isNormalizable?(word: string): boolean;
+}
+
+/**
+ * Base Tokenizer
+ *
+ * Provides the TokenStream implementation and shared tokenization utilities.
+ * Language-specific tokenizers extend these base utilities.
+ */
+
+/**
+ * Configuration for a native language time unit pattern.
+ * Used by tryNumberWithTimeUnits() to match language-specific time units.
+ */
+interface TimeUnitMapping {
+    /** The pattern to match (e.g., 'segundos', 'ミリ秒') */
+    readonly pattern: string;
+    /** The standard suffix to use (ms, s, m, h) */
+    readonly suffix: string;
+    /** Length of the pattern (for optimization) */
+    readonly length: number;
+    /** Whether to check for word boundary after the pattern */
+    readonly checkBoundary?: boolean;
+    /** Character that cannot follow the pattern (e.g., 's' for 'm' to avoid 'ms') */
+    readonly notFollowedBy?: string;
+    /** Whether to do case-insensitive matching */
+    readonly caseInsensitive?: boolean;
+}
+/**
+ * Concrete implementation of TokenStream.
+ */
+declare class TokenStreamImpl implements TokenStream {
+    readonly tokens: readonly LanguageToken[];
+    readonly language: string;
+    private pos;
+    constructor(tokens: LanguageToken[], language: string);
+    peek(offset?: number): LanguageToken | null;
+    advance(): LanguageToken;
+    isAtEnd(): boolean;
+    mark(): StreamMark;
+    reset(mark: StreamMark): void;
+    position(): number;
+    /**
+     * Get remaining tokens as an array.
+     */
+    remaining(): LanguageToken[];
+    /**
+     * Consume tokens while predicate is true.
+     */
+    takeWhile(predicate: (token: LanguageToken) => boolean): LanguageToken[];
+    /**
+     * Skip tokens while predicate is true.
+     */
+    skipWhile(predicate: (token: LanguageToken) => boolean): void;
+}
+/**
+ * Keyword entry for tokenizer - maps native word to normalized English form.
+ */
+interface KeywordEntry {
+    readonly native: string;
+    readonly normalized: string;
+}
+/**
+ * Profile interface for keyword derivation.
+ * Matches the structure of LanguageProfile but only includes fields needed for tokenization.
+ */
+interface TokenizerProfile {
+    readonly keywords?: Record<string, {
+        primary: string;
+        alternatives?: string[];
+        normalized?: string;
+    }>;
+    readonly references?: Record<string, string>;
+    readonly roleMarkers?: Record<string, {
+        primary: string;
+        alternatives?: string[];
+        position?: string;
+    }>;
+}
+/**
+ * Abstract base class for language-specific tokenizers.
+ * Provides common functionality for CSS selectors, strings, and numbers.
+ */
+declare abstract class BaseTokenizer implements LanguageTokenizer {
+    abstract readonly language: string;
+    abstract readonly direction: 'ltr' | 'rtl';
+    /** Optional morphological normalizer for this language */
+    protected normalizer?: MorphologicalNormalizer;
+    /** Keywords derived from profile, sorted longest-first for greedy matching */
+    protected profileKeywords: KeywordEntry[];
+    /** Map for O(1) keyword lookups by lowercase native word */
+    protected profileKeywordMap: Map<string, KeywordEntry>;
+    abstract tokenize(input: string): TokenStream;
+    abstract classifyToken(token: string): TokenKind;
+    /**
+     * Initialize keyword mappings from a language profile.
+     * Builds a list of native→english mappings from:
+     * - profile.keywords (primary + alternatives)
+     * - profile.references (me, it, you, etc.)
+     * - profile.roleMarkers (into, from, with, etc.)
+     *
+     * Results are sorted longest-first for greedy matching (important for non-space languages).
+     * Extras take precedence over profile entries when there are duplicates.
+     *
+     * @param profile - Language profile containing keyword translations
+     * @param extras - Additional keyword entries to include (literals, positional, events)
+     */
+    protected initializeKeywordsFromProfile(profile: TokenizerProfile, extras?: KeywordEntry[]): void;
+    /**
+     * Remove diacritical marks from a word for normalization.
+     * Primarily for Arabic (shadda, fatha, kasra, damma, sukun, etc.)
+     * but could be extended for other languages.
+     *
+     * @param word - Word to normalize
+     * @returns Word without diacritics
+     */
+    protected removeDiacritics(word: string): string;
+    /**
+     * Try to match a keyword from profile at the current position.
+     * Uses longest-first greedy matching (important for non-space languages).
+     *
+     * @param input - Input string
+     * @param pos - Current position
+     * @returns Token if matched, null otherwise
+     */
+    protected tryProfileKeyword(input: string, pos: number): LanguageToken | null;
+    /**
+     * Check if the remaining input starts with any known keyword.
+     * Useful for non-space languages to detect word boundaries.
+     *
+     * @param input - Input string
+     * @param pos - Current position
+     * @returns true if a keyword starts at this position
+     */
+    protected isKeywordStart(input: string, pos: number): boolean;
+    /**
+     * Look up a keyword by native word (case-insensitive).
+     * O(1) lookup using the keyword map.
+     *
+     * @param native - Native word to look up
+     * @returns KeywordEntry if found, undefined otherwise
+     */
+    protected lookupKeyword(native: string): KeywordEntry | undefined;
+    /**
+     * Check if a word is a known keyword (case-insensitive).
+     * O(1) lookup using the keyword map.
+     *
+     * @param native - Native word to check
+     * @returns true if the word is a keyword
+     */
+    protected isKeyword(native: string): boolean;
+    /**
+     * Set the morphological normalizer for this tokenizer.
+     */
+    setNormalizer(normalizer: MorphologicalNormalizer): void;
+    /**
+     * Try to normalize a word using the morphological normalizer.
+     * Returns null if no normalizer is set or normalization fails.
+     *
+     * Note: We don't check isNormalizable() here because the individual tokenizers
+     * historically called normalize() directly without that check. The normalize()
+     * method itself handles returning noChange() for words that can't be normalized.
+     */
+    protected tryNormalize(word: string): NormalizationResult | null;
+    /**
+     * Try morphological normalization and keyword lookup.
+     *
+     * If the word can be normalized to a stem that matches a known keyword,
+     * returns a keyword token with morphological metadata (stem, stemConfidence).
+     *
+     * This is the common pattern for handling conjugated verbs across languages:
+     * 1. Normalize the word (e.g., "toggled" → "toggle")
+     * 2. Look up the stem in the keyword map
+     * 3. Create a token with both the original form and stem metadata
+     *
+     * @param word - The word to normalize and look up
+     * @param startPos - Start position for the token
+     * @param endPos - End position for the token
+     * @returns Token if stem matches a keyword, null otherwise
+     */
+    protected tryMorphKeywordMatch(word: string, startPos: number, endPos: number): LanguageToken | null;
+    /**
+     * Try to extract a CSS selector at the current position.
+     */
+    protected trySelector(input: string, pos: number): LanguageToken | null;
+    /**
+     * Try to extract an event modifier at the current position.
+     * Event modifiers are .once, .debounce(N), .throttle(N), .queue(strategy)
+     */
+    protected tryEventModifier(input: string, pos: number): LanguageToken | null;
+    /**
+     * Try to extract a string literal at the current position.
+     */
+    protected tryString(input: string, pos: number): LanguageToken | null;
+    /**
+     * Try to extract a number at the current position.
+     */
+    protected tryNumber(input: string, pos: number): LanguageToken | null;
+    /**
+     * Configuration for native language time units.
+     * Maps patterns to their standard suffix (ms, s, m, h).
+     */
+    protected static readonly STANDARD_TIME_UNITS: readonly TimeUnitMapping[];
+    /**
+     * Try to match a time unit from a list of patterns.
+     *
+     * @param input - Input string
+     * @param pos - Position after the number
+     * @param timeUnits - Array of time unit mappings (native pattern → standard suffix)
+     * @param skipWhitespace - Whether to skip whitespace before time unit (default: false)
+     * @returns Object with matched suffix and new position, or null if no match
+     */
+    protected tryMatchTimeUnit(input: string, pos: number, timeUnits: readonly TimeUnitMapping[], skipWhitespace?: boolean): {
+        suffix: string;
+        endPos: number;
+    } | null;
+    /**
+     * Parse a base number (sign, integer, decimal) without time units.
+     * Returns the number string and end position.
+     *
+     * @param input - Input string
+     * @param startPos - Start position
+     * @param allowSign - Whether to allow +/- sign (default: true)
+     * @returns Object with number string and end position, or null
+     */
+    protected parseBaseNumber(input: string, startPos: number, allowSign?: boolean): {
+        number: string;
+        endPos: number;
+    } | null;
+    /**
+     * Try to extract a number with native language time units.
+     *
+     * This is a template method that handles the common pattern:
+     * 1. Parse the base number (sign, integer, decimal)
+     * 2. Try to match native language time units
+     * 3. Fall back to standard time units (ms, s, m, h)
+     *
+     * @param input - Input string
+     * @param pos - Start position
+     * @param nativeTimeUnits - Language-specific time unit mappings
+     * @param options - Configuration options
+     * @returns Token if number found, null otherwise
+     */
+    protected tryNumberWithTimeUnits(input: string, pos: number, nativeTimeUnits: readonly TimeUnitMapping[], options?: {
+        allowSign?: boolean;
+        skipWhitespace?: boolean;
+    }): LanguageToken | null;
+    /**
+     * Try to extract a URL at the current position.
+     * Handles /path, ./path, ../path, //domain.com, http://, https://
+     */
+    protected tryUrl(input: string, pos: number): LanguageToken | null;
+    /**
+     * Try to extract a variable reference (:varname) at the current position.
+     * In hyperscript, :x refers to a local variable named x.
+     */
+    protected tryVariableRef(input: string, pos: number): LanguageToken | null;
+    /**
+     * Try to extract an operator or punctuation token at the current position.
+     * Handles two-character operators (==, !=, etc.) and single-character operators.
+     */
+    protected tryOperator(input: string, pos: number): LanguageToken | null;
+    /**
+     * Try to match a multi-character particle from a list.
+     *
+     * Used by languages like Japanese, Korean, and Chinese that have
+     * multi-character particles (e.g., Japanese から, まで, より).
+     *
+     * @param input - Input string
+     * @param pos - Current position
+     * @param particles - Array of multi-character particles to match
+     * @returns Token if matched, null otherwise
+     */
+    protected tryMultiCharParticle(input: string, pos: number, particles: readonly string[]): LanguageToken | null;
+}
+
+/**
+ * Arabic Tokenizer
+ *
+ * Tokenizes Arabic hyperscript input.
+ * Arabic is challenging because:
+ * - Right-to-left (RTL) text direction
+ * - Prefix prepositions that attach to words (بـ, لـ, كـ)
+ * - Root-pattern morphology
+ * - CSS selectors are LTR islands within RTL text
+ */
+
+declare class ArabicTokenizer extends BaseTokenizer {
+    readonly language = "ar";
+    readonly direction: "rtl";
+    constructor();
+    tokenize(input: string): TokenStream;
+    classifyToken(token: string): TokenKind;
+    /**
+     * Try to match an Arabic preposition.
+     * Attaches prepositionValue metadata for disambiguation in pattern matching.
+     */
+    private tryPreposition;
+    /**
+     * Try to extract a proclitic (conjunction or preposition) that's attached to the following word.
+     *
+     * Arabic proclitics attach directly to words without space:
+     * - والنقر → و + النقر (and + the-click)
+     * - فالتبديل → ف + التبديل (then + the-toggle)
+     * - بالنقر → ب + النقر (with + the-click)
+     * - ولالنقر → و + ل + النقر (and + to + the-click)
+     *
+     * This enables:
+     * - Polysyndetic coordination: A وB وC
+     * - Attached prepositions: بالنقر (with-the-click)
+     * - Multi-proclitic sequences: ولالنقر (and-to-the-click)
+     *
+     * Returns null if:
+     * - Not a proclitic character/sequence
+     * - Proclitic is standalone (followed by space)
+     * - Remaining word is too short (< 2 chars, to avoid false positives)
+     * - Full word is a recognized keyword (e.g., بدل should NOT be split to ب + دل)
+     *
+     * @see NATIVE_REVIEW_NEEDED.md for implementation rationale
+     */
+    private tryProclitic;
+    /**
+     * Extract an Arabic word.
+     * Uses morphological normalization to handle prefix/suffix variations.
+     * Attaches metadata for temporal markers (formality, confidence).
+     */
+    private extractArabicWord;
+    /**
+     * Extract an ASCII word.
+     */
+    private extractAsciiWord;
+    /**
+     * Extract a number, including Arabic time unit suffixes.
+     * Arabic allows space between number and unit.
+     */
+    private extractArabicNumber;
+}
+/**
+ * Singleton instance.
+ */
+declare const arabicTokenizer: ArabicTokenizer;
+
+/**
+ * Language Profile Types
+ *
+ * Type definitions for language profiles, separated for tree-shaking.
+ */
+
+/**
+ * Word order in a language (for declarative statements).
+ */
+type WordOrder = 'SVO' | 'SOV' | 'VSO' | 'VOS' | 'OSV' | 'OVS';
+/**
+ * How grammatical relationships are marked.
+ */
+type MarkingStrategy$1 = 'preposition' | 'postposition' | 'particle' | 'case-suffix';
+/**
+ * A grammatical marker (preposition, particle, etc.) for a semantic role.
+ */
+interface RoleMarker {
+    /** Primary marker for this role */
+    readonly primary: string;
+    /** Alternative markers that also work */
+    readonly alternatives?: string[];
+    /** Position relative to the role value */
+    readonly position: 'before' | 'after';
+}
+/**
+ * Verb form configuration for a language.
+ */
+interface VerbConfig$1 {
+    /** Position of verb in the sentence */
+    readonly position: 'start' | 'end' | 'second';
+    /** Common verb suffixes/conjugations to recognize */
+    readonly suffixes?: string[];
+    /** Whether the language commonly drops subjects */
+    readonly subjectDrop?: boolean;
+}
+/**
+ * Configuration for possessive expression construction.
+ * Defines how "X's property" is expressed in a language.
+ */
+interface PossessiveConfig {
+    /** Possessive marker (e.g., "'s" in English, "の" in Japanese) */
+    readonly marker: string;
+    /** Position of marker: 'after-object' (X's Y), 'between' (X の Y), 'before-property' */
+    readonly markerPosition: 'after-object' | 'between' | 'before-property';
+    /** Special possessive forms (e.g., 'me' → 'my' in English) */
+    readonly specialForms?: Record<string, string>;
+    /** Whether to use possessive adjectives instead of marker (e.g., Spanish mi/tu/su) */
+    readonly usePossessiveAdjectives?: boolean;
+    /**
+     * Possessive keywords mapped to their corresponding reference.
+     * Used by pattern-matcher to recognize possessive expressions.
+     * Example: { my: 'me', your: 'you', its: 'it' }
+     */
+    readonly keywords?: Record<string, string>;
+}
+/**
+ * Complete language profile for pattern generation.
+ */
+interface LanguageProfile {
+    /** ISO 639-1 language code */
+    readonly code: string;
+    /** Human-readable language name */
+    readonly name: string;
+    /** Native name */
+    readonly nativeName: string;
+    /** Text direction */
+    readonly direction: 'ltr' | 'rtl';
+    /** Primary word order */
+    readonly wordOrder: WordOrder;
+    /** How this language marks grammatical roles */
+    readonly markingStrategy: MarkingStrategy$1;
+    /** Markers for each semantic role */
+    readonly roleMarkers: Partial<Record<SemanticRole, RoleMarker>>;
+    /** Verb configuration */
+    readonly verb: VerbConfig$1;
+    /** Command keyword translations */
+    readonly keywords: Record<string, KeywordTranslation$1>;
+    /** Whether the language uses spaces between words */
+    readonly usesSpaces: boolean;
+    /** Special tokenization notes */
+    readonly tokenization?: TokenizationConfig$1;
+    /** Reference translations (me, it, you, etc.) */
+    readonly references?: Record<string, string>;
+    /** Possessive expression configuration */
+    readonly possessive?: PossessiveConfig;
+    /** Event handler pattern configuration (for simple SVO languages) */
+    readonly eventHandler?: EventHandlerConfig;
+    /**
+     * Default verb form for command keywords. Defaults to 'infinitive'.
+     *
+     * Based on software UI localization research:
+     * - 'infinitive': Spanish, French, German, Portuguese, Russian (industry standard)
+     * - 'imperative': Polish
+     * - 'base': English, Japanese, Korean (no distinction or same form)
+     *
+     * Individual keywords can override this via KeywordTranslation.form
+     */
+    readonly defaultVerbForm?: VerbForm;
+}
+/**
+ * Configuration for event handler pattern generation.
+ * Used by simple SVO languages that don't need hand-crafted patterns.
+ */
+interface EventHandlerConfig {
+    /** Primary event keyword (e.g., 'on', 'bei', 'sur') */
+    readonly keyword: KeywordTranslation$1;
+    /** Source filter marker (e.g., 'from', 'von', 'de') */
+    readonly sourceMarker: RoleMarker;
+    /** Conditional keyword (e.g., 'when', 'wenn', 'quand') */
+    readonly conditionalKeyword?: KeywordTranslation$1;
+}
+/**
+ * Verb form used for command keywords.
+ *
+ * Based on software localization research:
+ * - 'infinitive': Standard for most languages (Spanish, French, German, Russian)
+ *   Example: "Guardar", "Enregistrer", "Speichern"
+ * - 'imperative': Used by some languages (Polish)
+ *   Example: "Zapisz", "Otwórz"
+ * - 'base': For languages where forms are identical (English, Japanese, Korean)
+ *   or where the distinction doesn't apply
+ */
+type VerbForm = 'infinitive' | 'imperative' | 'base';
+/**
+ * Translation of a command keyword.
+ */
+interface KeywordTranslation$1 {
+    /** Primary translation (used for output/rendering) */
+    readonly primary: string;
+    /** Alternative forms for parsing (conjugations, synonyms, informal variants) */
+    readonly alternatives?: string[];
+    /** Normalized English form for internal matching */
+    readonly normalized?: string;
+    /**
+     * The grammatical form of 'primary'. Defaults to 'infinitive'.
+     * This documents the form used and enables future form-switching features.
+     * - 'infinitive': Dictionary form (alternar, basculer) - industry standard
+     * - 'imperative': Command form (alterna, bascule) - for Polish, etc.
+     * - 'base': Same form for both (toggle, トグル) - English, Japanese, Korean
+     */
+    readonly form?: VerbForm;
+}
+/**
+ * Special tokenization configuration.
+ */
+interface TokenizationConfig$1 {
+    /** Particles to recognize (for particle languages) */
+    readonly particles?: string[];
+    /** Prefixes to recognize (for prefixing languages) */
+    readonly prefixes?: string[];
+    /** Word boundary detection strategy */
+    readonly boundaryStrategy?: 'space' | 'particle' | 'character';
+}
+
+/**
+ * Arabic Language Profile
+ *
+ * VSO word order, prepositions, RTL (right-to-left), space-separated.
+ * Features root-based morphology and rich verb conjugation.
+ */
+
+declare const arabicProfile: LanguageProfile;
+
+/**
+ * German Language Profile
+ *
+ * SVO word order (V2 in main clauses), prepositions, space-separated.
+ * Features case system, compound words, and verb-second word order in main clauses.
+ */
+
+declare const germanProfile: LanguageProfile;
+
+/**
+ * English Tokenizer
+ *
+ * Tokenizes English hyperscript input.
+ * English uses space-separated words with prepositions.
+ */
+
+declare class EnglishTokenizer extends BaseTokenizer {
+    readonly language = "en";
+    readonly direction: "ltr";
+    constructor();
+    tokenize(input: string): TokenStream;
+    classifyToken(token: string): TokenKind;
+    /**
+     * Extract a word (identifier or keyword) from the input.
+     * Handles namespaced event names like "draggable:start".
+     */
+    private extractWord;
+    /**
+     * Try to convert an identifier followed by "class" to a class selector.
+     * E.g., "active class" → ".active"
+     *
+     * This enables natural English syntax like:
+     * - "toggle the active class" → "toggle .active"
+     * - "add the visible class" → "add .visible"
+     */
+    private tryConvertToClassSelector;
+}
+/**
+ * Singleton instance.
+ */
+declare const englishTokenizer: EnglishTokenizer;
+
+/**
+ * English Language Profile
+ *
+ * SVO word order, prepositions, space-separated.
+ */
+
+declare const englishProfile: LanguageProfile;
+
+/**
+ * Spanish Tokenizer
+ *
+ * Tokenizes Spanish hyperscript input.
+ * Spanish is relatively straightforward as it:
+ * - Uses space-separated words like English
+ * - Has similar preposition structure (SVO)
+ * - Uses accent marks that need proper handling
+ */
+
+declare class SpanishTokenizer extends BaseTokenizer {
+    readonly language = "es";
+    readonly direction: "ltr";
+    constructor();
+    tokenize(input: string): TokenStream;
+    classifyToken(token: string): TokenKind;
+    /**
+     * Try to match multi-word phrases that function as single units.
+     * Multi-word phrases are included in profileKeywords and sorted longest-first,
+     * so they'll be matched before their constituent words.
+     */
+    private tryMultiWordPhrase;
+    /**
+     * Extract a Spanish word.
+     *
+     * Uses morphological normalization to handle:
+     * - Reflexive verbs (mostrarse → mostrar)
+     * - Verb conjugations (alternando → alternar)
+     */
+    private extractSpanishWord;
+    /**
+     * Extract a number, including Spanish time unit suffixes.
+     */
+    private extractSpanishNumber;
+}
+/**
+ * Singleton instance.
+ */
+declare const spanishTokenizer: SpanishTokenizer;
+
+/**
+ * Spanish Language Profile
+ *
+ * SVO word order, prepositions, space-separated.
+ * Features rich verb conjugation with pro-drop (subject omission).
+ */
+
+declare const spanishProfile: LanguageProfile;
+
+/**
+ * French Language Profile
+ *
+ * SVO word order, prepositions, space-separated.
+ * Features rich verb conjugation and gendered articles.
+ */
+
+declare const frenchProfile: LanguageProfile;
+
+/**
+ * Indonesian Language Profile
+ *
+ * SVO word order, prepositions, space-separated, agglutinative.
+ * Features affixation for verb derivation (me-, ber-, di-, -kan, -i).
+ */
+
+declare const indonesianProfile: LanguageProfile;
+
+/**
+ * Japanese Tokenizer
+ *
+ * Tokenizes Japanese hyperscript input.
+ * Japanese is challenging because:
+ * - No spaces between words
+ * - Particles (助詞) mark grammatical roles
+ * - Mixed scripts (hiragana, katakana, kanji, romaji)
+ * - CSS selectors are embedded ASCII
+ */
+
+declare class JapaneseTokenizer extends BaseTokenizer {
+    readonly language = "ja";
+    readonly direction: "ltr";
+    constructor();
+    tokenize(input: string): TokenStream;
+    classifyToken(token: string): TokenKind;
+    /**
+     * Extract a Japanese word (sequence of kanji/kana).
+     * Stops at particles, ASCII, or whitespace.
+     *
+     * Uses morphological normalization to handle verb conjugations:
+     * 1. First checks if the exact word is in the keyword map
+     * 2. If not found, tries to strip conjugation suffixes and check again
+     */
+    private extractJapaneseWord;
+    /**
+     * Extract an ASCII word (for mixed Japanese/English content).
+     */
+    private extractAsciiWord;
+    /**
+     * Extract a number, including Japanese time unit suffixes.
+     * Japanese time units attach directly without whitespace.
+     */
+    private extractJapaneseNumber;
+}
+/**
+ * Singleton instance.
+ */
+declare const japaneseTokenizer: JapaneseTokenizer;
+
+/**
+ * Japanese Language Profile
+ *
+ * SOV word order, particles (を, に, で, etc.), no spaces between words.
+ * Agglutinative language with rich verb conjugation.
+ */
+
+declare const japaneseProfile: LanguageProfile;
+
+/**
+ * Korean Tokenizer
+ *
+ * Tokenizes Korean hyperscript input.
+ * Korean is an agglutinative language with:
+ * - Hangul syllable blocks (가-힣)
+ * - Particles (조사) mark grammatical roles
+ * - 하다 verbs (noun + 하다)
+ * - CSS selectors are embedded ASCII
+ */
+
+declare class KoreanTokenizer extends BaseTokenizer {
+    readonly language = "ko";
+    readonly direction: "ltr";
+    constructor();
+    tokenize(input: string): TokenStream;
+    classifyToken(token: string): TokenKind;
+    /**
+     * Extract a Korean word (sequence of Hangul).
+     * Prioritizes known keywords, then uses particle-based word boundaries.
+     *
+     * Uses morphological normalization to handle verb conjugations.
+     */
+    private extractKoreanWord;
+    /**
+     * Extract an ASCII word (for mixed Korean/English content).
+     */
+    private extractAsciiWord;
+    /**
+     * Extract a number, including Korean time unit suffixes.
+     * Korean time units attach directly without whitespace.
+     */
+    private extractKoreanNumber;
+}
+/**
+ * Singleton instance.
+ */
+declare const koreanTokenizer: KoreanTokenizer;
+
+/**
+ * Korean Language Profile
+ *
+ * SOV word order, particles (을/를, 에, 에서, etc.), space-separated between words.
+ * Agglutinative language with particles attaching to words.
+ */
+
+declare const koreanProfile: LanguageProfile;
+
+/**
+ * Portuguese Language Profile
+ *
+ * SVO word order, prepositions, space-separated.
+ * Features rich verb conjugation with pro-drop (subject omission).
+ */
+
+declare const portugueseProfile: LanguageProfile;
+
+/**
+ * Quechua Language Profile
+ *
+ * SOV word order, postpositions (suffixes), polysynthetic/agglutinative.
+ * Indigenous language of the Andean region with rich morphology.
+ */
+
+declare const quechuaProfile: LanguageProfile;
+
+/**
+ * Swahili Language Profile
+ *
+ * SVO word order, prepositions, space-separated, agglutinative.
+ * Features noun class system (18 classes) and verb agreement prefixes.
+ */
+
+declare const swahiliProfile: LanguageProfile;
+
+/**
+ * Turkish Tokenizer
+ *
+ * Tokenizes Turkish hyperscript input.
+ * Turkish is challenging because:
+ * - Highly agglutinative (many suffixes attach to words)
+ * - Strict vowel harmony rules
+ * - Postpositions instead of prepositions
+ * - No grammatical gender
+ * - Word order is typically SOV
+ */
+
+declare class TurkishTokenizer extends BaseTokenizer {
+    readonly language = "tr";
+    readonly direction: "ltr";
+    constructor();
+    tokenize(input: string): TokenStream;
+    classifyToken(token: string): TokenKind;
+    /**
+     * Extract a Turkish word.
+     * Uses morphological normalization to handle verb conjugations.
+     */
+    private extractTurkishWord;
+    /**
+     * Extract a number, including Turkish time unit suffixes.
+     */
+    private extractTurkishNumber;
+}
+/**
+ * Singleton instance.
+ */
+declare const turkishTokenizer: TurkishTokenizer;
+
+/**
+ * Turkish Language Profile
+ *
+ * SOV word order, case suffixes (agglutinative), space-separated.
+ * Features vowel harmony and extensive suffixation.
+ */
+
+declare const turkishProfile: LanguageProfile;
+
+/**
+ * Chinese Tokenizer
+ *
+ * Tokenizes Chinese hyperscript input.
+ * Chinese is challenging because:
+ * - No spaces between words (like Japanese)
+ * - Uses CJK characters (shared with Japanese Kanji)
+ * - SVO word order (like English)
+ * - Uses prepositions (把, 在, 从, etc.) for grammatical roles
+ * - No conjugation (unlike Japanese/Korean)
+ * - CSS selectors are embedded ASCII
+ */
+
+declare class ChineseTokenizer extends BaseTokenizer {
+    readonly language = "zh";
+    readonly direction: "ltr";
+    constructor();
+    tokenize(input: string): TokenStream;
+    classifyToken(token: string): TokenKind;
+    /**
+     * Extract a Chinese word.
+     * Uses greedy matching to find the longest known keyword.
+     * Chinese doesn't have inflection, so we don't need morphological normalization.
+     * profileKeywords is already sorted longest-first, enabling greedy matching.
+     */
+    private extractChineseWord;
+    /**
+     * Extract an ASCII word (for mixed Chinese/English content).
+     */
+    private extractAsciiWord;
+    /**
+     * Try to extract a string literal, including Chinese quotes.
+     * Chinese quotes: \u201C " (open) \u201D " (close) \u2018 ' (open) \u2019 ' (close)
+     */
+    private tryChineseString;
+    /**
+     * Extract a number, including Chinese time unit suffixes.
+     * Chinese time units attach directly without whitespace.
+     */
+    private extractChineseNumber;
+}
+/**
+ * Singleton instance.
+ */
+declare const chineseTokenizer: ChineseTokenizer;
+
+/**
+ * Chinese (Simplified) Language Profile
+ *
+ * SVO word order, no markers (relies on word order), no spaces between words.
+ * Isolating language with topic-comment structure and optional BA construction.
+ */
+
+declare const chineseProfile: LanguageProfile;
+
+/**
+ * Pattern Registry
+ *
+ * Pattern cache and lookup functions for the semantic parser.
+ */
+
+/**
+ * Get all patterns.
+ * @deprecated Use getPatternsForLanguage() for tree-shaking.
+ */
+declare function getAllPatterns(): LanguagePattern[];
+/**
+ * Get all patterns for a specific language.
+ * Uses caching for performance.
+ */
+declare function getPatternsForLanguage(language: string): LanguagePattern[];
+/**
+ * Get patterns for a specific language and command.
+ */
+declare function getPatternsForLanguageAndCommand(language: string, command: ActionType): LanguagePattern[];
+/**
+ * Get all supported languages.
+ */
+declare function getSupportedLanguages$3(): string[];
+/**
+ * Get all supported commands.
+ */
+declare function getSupportedCommands(): ActionType[];
+/**
+ * Find a pattern by ID.
+ */
+declare function getPatternById(id: string): LanguagePattern | undefined;
+interface PatternStats {
+    totalPatterns: number;
+    byLanguage: Record<string, number>;
+    byCommand: Record<string, number>;
+}
+/**
+ * Get statistics about registered patterns.
+ */
+declare function getPatternStats(): PatternStats;
+
+/**
+ * Toggle Command Patterns
+ *
+ * Hand-crafted patterns for "toggle" command across languages.
+ *
+ * @generated This file is auto-generated. Do not edit manually.
+ */
+
+/**
+ * Get toggle patterns for a specific language.
+ */
+declare function getTogglePatternsForLanguage(language: string): LanguagePattern[];
+
+/**
+ * Put Command Patterns
+ *
+ * Hand-crafted patterns for "put" command across languages.
+ *
+ * @generated This file is auto-generated. Do not edit manually.
+ */
+
+/**
+ * Get put patterns for a specific language.
+ */
+declare function getPutPatternsForLanguage(language: string): LanguagePattern[];
+
+/**
+ * EventHandler Command Patterns
+ *
+ * Hand-crafted patterns for "event-handler" command across languages.
+ *
+ * @generated This file is auto-generated. Do not edit manually.
+ */
+
+/**
+ * Get event-handler patterns for a specific language.
+ */
+declare function getEventHandlerPatternsForLanguage(language: string): LanguagePattern[];
+
+/**
+ * Shared Event Handler Utilities
+ *
+ * Event name translations and normalization used across all languages.
+ */
+/**
+ * Common event names translated across languages.
+ * Used by tokenizers to normalize event names to English.
+ */
+declare const eventNameTranslations: Record<string, Record<string, string>>;
+/**
+ * Normalize an event name to English.
+ */
+declare function normalizeEventName(event: string, language: string): string;
+
+/**
+ * Tokenizer Registry
+ *
+ * Provides a unified interface for tokenization.
+ * Delegates to the central registry for language lookups.
+ *
+ * For tree-shaking, import specific tokenizers directly:
+ *   import { englishTokenizer } from './tokenizers/english';
+ *
+ * To register languages, import the language modules:
+ *   import '@lokascript/semantic/languages/en';
+ */
+
+/**
+ * Get a tokenizer for the specified language.
+ * Returns undefined if language is not registered.
+ */
+declare function getTokenizer(language: string): LanguageTokenizer | undefined;
+/**
+ * Tokenize input in the specified language.
+ * @throws Error if language is not registered
+ */
+declare function tokenize(input: string, language: string): TokenStream;
+/**
+ * Get all supported languages.
+ * Returns only languages that have been registered.
+ */
+declare function getSupportedLanguages$2(): string[];
+/**
+ * Check if a language is supported.
+ */
+declare function isLanguageSupported$1(language: string): boolean;
+/**
+ * Register a custom tokenizer.
+ * Note: For full language support, use registerLanguage() from registry instead.
+ */
+declare function registerTokenizer(tokenizer: LanguageTokenizer): void;
+
+declare class PatternMatcher$1 {
+    /** Current language profile for the pattern being matched */
+    private currentProfile;
+    /**
+     * Try to match a single pattern against the token stream.
+     * Returns the match result or null if no match.
+     */
+    matchPattern(tokens: TokenStream, pattern: LanguagePattern): PatternMatchResult | null;
+    /**
+     * Try to match multiple patterns, return the best match.
+     */
+    matchBest(tokens: TokenStream, patterns: LanguagePattern[]): PatternMatchResult | null;
+    /**
+     * Match a sequence of pattern tokens against the token stream.
+     */
+    private matchTokenSequence;
+    /**
+     * Match a single pattern token against the current position in the stream.
+     */
+    private matchPatternToken;
+    /**
+     * Match a literal pattern token (keyword or particle).
+     */
+    private matchLiteralToken;
+    /**
+     * Match a role pattern token (captures a semantic value).
+     * Handles multi-token expressions like:
+     * - 'my value' (possessive keyword + property)
+     * - '#dialog.showModal()' (method call)
+     * - "#element's *opacity" (possessive selector + property)
+     */
+    private matchRoleToken;
+    /**
+     * Try to match a possessive expression like 'my value' or 'its innerHTML'.
+     * Returns the PropertyPathValue if matched, or null if not.
+     */
+    private tryMatchPossessiveExpression;
+    /**
+     * Check if a keyword is a structural keyword (preposition, control flow, etc.)
+     * that shouldn't be consumed as a property name.
+     */
+    private isStructuralKeyword;
+    /**
+     * Try to match a method call expression like '#dialog.showModal()'.
+     * Pattern: selector + '.' + identifier + '(' + [args] + ')'
+     * Returns an expression value if matched, or null if not.
+     */
+    private tryMatchMethodCallExpression;
+    /**
+     * Try to match a property access expression like 'userData.name' or 'it.data'.
+     * Pattern: (identifier | keyword) + '.' + identifier [+ '.' + identifier ...]
+     * Returns an expression value if matched, or null if not.
+     */
+    private tryMatchPropertyAccessExpression;
+    /**
+     * Try to match a possessive selector expression like "#element's *opacity".
+     * Pattern: selector + "'s" + (selector | identifier)
+     * Returns a property-path value if matched, or null if not.
+     */
+    private tryMatchPossessiveSelectorExpression;
+    /**
+     * Try to match a selector + property expression like "#output.innerText".
+     * This handles cases where the tokenizer produces two selector tokens:
+     * - #output (id selector)
+     * - .innerText (looks like class selector, but is actually property)
+     *
+     * Pattern: id-selector + class-selector-that-is-actually-property
+     * Returns a property-path value if matched, or null if not.
+     */
+    private tryMatchSelectorPropertyExpression;
+    /**
+     * Match a group pattern token (optional sequence).
+     */
+    private matchGroupToken;
+    /**
+     * Get the type of match for a token against a value.
+     * Used for confidence calculation.
+     */
+    private getMatchType;
+    /**
+     * Track stem matches for confidence calculation.
+     * This is set during matching and read during confidence calculation.
+     */
+    private stemMatchCount;
+    private totalKeywordMatches;
+    /** Maximum depth for nested property access (e.g., a.b.c.d...) */
+    private static readonly MAX_PROPERTY_DEPTH;
+    /** Maximum number of arguments in method calls */
+    private static readonly MAX_METHOD_ARGS;
+    /**
+     * Convert a language token to a semantic value.
+     */
+    private tokenToSemanticValue;
+    /**
+     * Parse a literal value (string, number, boolean).
+     */
+    private parseLiteralValue;
+    /**
+     * Apply extraction rules to fill in default values for missing roles.
+     */
+    private applyExtractionRules;
+    /**
+     * Check if a pattern token is optional.
+     */
+    private isOptional;
+    /**
+     * Calculate confidence score for a match (0-1).
+     *
+     * Confidence is reduced for:
+     * - Stem matches (morphological normalization has inherent uncertainty)
+     * - Missing optional roles (but less penalty if role has a default value)
+     *
+     * Confidence is increased for:
+     * - VSO languages (Arabic) when pattern starts with a verb
+     */
+    private calculateConfidence;
+    /**
+     * Calculate confidence boost for VSO (Verb-Subject-Object) language patterns.
+     * Arabic naturally uses VSO word order, so patterns that start with a verb
+     * should receive a confidence boost.
+     *
+     * Returns +0.15 confidence boost if:
+     * - Language is Arabic ('ar')
+     * - Pattern's first token is a verb keyword
+     *
+     * @param pattern The language pattern being matched
+     * @returns Confidence boost (0 or 0.15)
+     */
+    private calculateVSOConfidenceBoost;
+    /**
+     * Arabic preposition disambiguation for confidence adjustment.
+     *
+     * Different Arabic prepositions are more or less natural for different semantic roles:
+     * - على (on/upon) is preferred for patient/target roles (element selectors)
+     * - إلى (to) is preferred for destination roles
+     * - من (from) is preferred for source roles
+     * - في (in) is preferred for location roles
+     *
+     * This method analyzes the prepositions used with captured semantic roles and
+     * adjusts confidence based on idiomaticity:
+     * - +0.10 for highly idiomatic preposition choices
+     * - -0.10 for less natural preposition choices
+     *
+     * @param pattern The language pattern being matched
+     * @param captured The captured semantic values
+     * @returns Confidence adjustment (-0.10 to +0.10)
+     */
+    private arabicPrepositionDisambiguation;
+    /**
+     * Noise words that can be skipped in English for more natural syntax.
+     * - "the" before selectors: "toggle the .active" → "toggle .active"
+     * - "class" after class selectors: "add the .visible class" → "add .visible"
+     */
+    private static readonly ENGLISH_NOISE_WORDS;
+    /**
+     * Skip noise words like "the" before selectors.
+     * This enables more natural English syntax like "toggle the .active".
+     */
+    private skipNoiseWords;
+    /**
+     * Extract event modifiers from the token stream.
+     * Event modifiers are .once, .debounce(N), .throttle(N), .queue(strategy)
+     * that can appear after event names.
+     *
+     * Returns EventModifiers object or undefined if no modifiers found.
+     */
+    extractEventModifiers(tokens: TokenStream): EventModifiers | undefined;
+}
+/**
+ * Singleton pattern matcher instance.
+ */
+declare const patternMatcher: PatternMatcher$1;
+/**
+ * Match tokens against a pattern.
+ */
+declare function matchPattern(tokens: TokenStream, pattern: LanguagePattern): PatternMatchResult | null;
+/**
+ * Match tokens against multiple patterns, return best match.
+ */
+declare function matchBest(tokens: TokenStream, patterns: LanguagePattern[]): PatternMatchResult | null;
+
+declare class SemanticParserImpl implements SemanticParser {
+    /**
+     * Parse input in the specified language to a semantic node.
+     */
+    parse(input: string, language: string): SemanticNode;
+    /**
+     * Check if input can be parsed in the specified language.
+     */
+    canParse(input: string, language: string): boolean;
+    /**
+     * Get all supported languages.
+     */
+    supportedLanguages(): string[];
+    /**
+     * Build a command semantic node from a pattern match.
+     */
+    private buildCommand;
+    /**
+     * Build an event handler semantic node from a pattern match.
+     */
+    private buildEventHandler;
+    /**
+     * Parse body with proper clause separation.
+     * Splits the token stream at conjunction boundaries (then/それから/ثم/etc.)
+     * and parses each clause independently.
+     *
+     * This handles multi-clause patterns like:
+     * - "toggle .active then remove .hidden"
+     * - ".active を 切り替え それから .hidden を 削除"
+     * - "بدل .active ثم احذف .hidden"
+     *
+     * @param tokens Token stream to parse
+     * @param commandPatterns Command patterns for the language
+     * @param language Language code
+     * @returns Array of semantic nodes (one per clause)
+     */
+    private parseBodyWithClauses;
+    /**
+     * Parse a single clause (sequence of tokens between conjunctions).
+     * Returns array of semantic nodes parsed from the clause.
+     */
+    private parseClause;
+    /**
+     * Parse body commands with support for grammar-transformed patterns.
+     * Used after a grammar-transformed pattern with continuation marker.
+     */
+    private parseBodyWithGrammarPatterns;
+    /**
+     * Check if a token is a 'then' keyword in the given language.
+     */
+    private isThenKeyword;
+    /**
+     * Check if a token is an 'end' keyword in the given language.
+     */
+    private isEndKeyword;
+}
+/**
+ * Singleton parser instance.
+ */
+declare const semanticParser: SemanticParserImpl;
+/**
+ * Parse input in the specified language.
+ */
+declare function parse(input: string, language: string): SemanticNode;
+/**
+ * Check if input can be parsed.
+ */
+declare function canParse(input: string, language: string): boolean;
+/**
+ * Parse and return command type if parseable.
+ */
+declare function getCommandType(input: string, language: string): ActionType | null;
+
+/**
+ * Explicit Mode Parser
+ *
+ * Parses the explicit [command role:value ...] syntax.
+ * This syntax is universal across all languages and makes
+ * semantic roles visible for learning and debugging.
+ *
+ * Syntax:
+ *   [command role1:value1 role2:value2 ...]
+ *
+ * Examples:
+ *   [toggle class:.active target:#button]
+ *   [put content:"hello" destination:#output]
+ *   [on event:click body:[toggle class:.active]]
+ */
+
+/**
+ * Parse explicit syntax into a semantic node.
+ */
+declare function parseExplicit(input: string): SemanticNode;
+/**
+ * Check if input is explicit syntax.
+ */
+declare function isExplicitSyntax(input: string): boolean;
+
+/**
+ * Explicit Mode Renderer
+ *
+ * Renders semantic nodes to explicit [command role:value] syntax.
+ * Also renders to natural language syntax for any supported language.
+ */
+
+declare class SemanticRendererImpl implements SemanticRenderer {
+    /**
+     * Render a semantic node in the specified language.
+     */
+    render(node: SemanticNode, language: string): string;
+    /**
+     * Render a compound node (multiple statements chained with then/and).
+     */
+    private renderCompound;
+    /**
+     * Get the translated chain word for the given language.
+     */
+    private getChainWord;
+    /**
+     * Render a semantic node in explicit mode.
+     */
+    renderExplicit(node: SemanticNode): string;
+    /**
+     * Get all supported languages.
+     */
+    supportedLanguages(): string[];
+    /**
+     * Find the best pattern for rendering a semantic node.
+     *
+     * For rendering, we prefer "standard" patterns (e.g., "on click") over
+     * native idiom patterns (e.g., "when clicked") because standard patterns
+     * are more recognizable and closer to the original hyperscript syntax.
+     */
+    private findBestPattern;
+    /**
+     * Render a semantic node using a specific pattern.
+     */
+    private renderWithPattern;
+    /**
+     * Render a single pattern token.
+     */
+    private renderPatternToken;
+    /**
+     * Convert a semantic value to a string for explicit syntax.
+     */
+    private valueToString;
+    /**
+     * Convert a semantic value to natural language string.
+     * Uses language-specific possessive rendering when language is provided.
+     */
+    private valueToNaturalString;
+    /**
+     * Render a reference value in the target language.
+     */
+    private renderReference;
+    /**
+     * Render a property-path value (possessive expression) in the target language.
+     *
+     * Examples by language:
+     * - English: "my value", "its opacity", "#el's value"
+     * - Japanese: "自分の value", "それの opacity"
+     * - Korean: "내 value", "그것의 opacity"
+     * - Spanish: "mi value", "su opacity"
+     * - Chinese: "我的 value", "它的 opacity"
+     */
+    private renderPropertyPath;
+}
+/**
+ * Singleton renderer instance.
+ */
+declare const semanticRenderer: SemanticRendererImpl;
+/**
+ * Render a semantic node in the specified language.
+ */
+declare function render(node: SemanticNode, language: string): string;
+/**
+ * Render a semantic node in explicit mode.
+ */
+declare function renderExplicit(node: SemanticNode): string;
+
+/**
+ * Bidirectional Converter
+ *
+ * Converts between natural language syntax and explicit syntax,
+ * and between different natural languages.
+ */
+
+/**
+ * Convert natural language hyperscript to explicit syntax.
+ *
+ * @param input Natural language hyperscript
+ * @param sourceLanguage Source language code
+ * @returns Explicit syntax string
+ *
+ * @example
+ * toExplicit('toggle .active on #button', 'en')
+ * // → '[toggle patient:.active destination:#button]'
+ *
+ * toExplicit('#button の .active を 切り替え', 'ja')
+ * // → '[toggle patient:.active destination:#button]'
+ */
+declare function toExplicit(input: string, sourceLanguage: string): string;
+/**
+ * Convert explicit syntax to natural language.
+ *
+ * @param explicit Explicit syntax string
+ * @param targetLanguage Target language code
+ * @returns Natural language hyperscript
+ *
+ * @example
+ * fromExplicit('[toggle patient:.active destination:#button]', 'en')
+ * // → 'toggle .active on #button'
+ *
+ * fromExplicit('[toggle patient:.active destination:#button]', 'ja')
+ * // → '#button の .active を 切り替え'
+ */
+declare function fromExplicit(explicit: string, targetLanguage: string): string;
+/**
+ * Translate hyperscript from one language to another.
+ *
+ * @param input Natural language hyperscript
+ * @param sourceLanguage Source language code
+ * @param targetLanguage Target language code
+ * @returns Translated hyperscript
+ *
+ * @example
+ * translate('toggle .active on #button', 'en', 'ja')
+ * // → '#button の .active を 切り替え'
+ *
+ * translate('#button の .active を 切り替え', 'ja', 'ar')
+ * // → 'بدّل .active على #button'
+ */
+declare function translate(input: string, sourceLanguage: string, targetLanguage: string): string;
+/**
+ * Parse input (either explicit or natural language) to semantic node.
+ *
+ * @param input Hyperscript input (explicit or natural)
+ * @param language Language code (required for natural, ignored for explicit)
+ * @returns Semantic node
+ */
+declare function parseAny(input: string, language: string): SemanticNode;
+/**
+ * Round-trip validation: parse and re-render to verify consistency.
+ *
+ * When called with 2 arguments, returns an object with validation info.
+ * When called with 3 arguments, returns the rendered string directly.
+ *
+ * @param input Original input
+ * @param sourceLanguage Source language code
+ * @param targetLanguage Target language code (optional, if provided returns string only)
+ * @returns Object with original, semantic, re-rendered, and match status (or just string if targetLanguage provided)
+ */
+declare function roundTrip(input: string, sourceLanguage: string, targetLanguage?: string): string | {
+    original: string;
+    semantic: SemanticNode;
+    rendered: string;
+    matches: boolean;
+};
+/**
+ * Get all translations of a hyperscript statement.
+ *
+ * @param input Hyperscript input
+ * @param sourceLanguage Source language (or 'explicit')
+ * @param targetLanguages List of target language codes (defaults to all 13 supported languages)
+ * @returns Object mapping language codes to translations
+ */
+declare function getAllTranslations(input: string, sourceLanguage: string, targetLanguages?: string[]): Record<string, string>;
+/**
+ * Validate that a translation is semantically equivalent.
+ *
+ * @param original Original hyperscript
+ * @param translated Translated hyperscript
+ * @param originalLang Original language
+ * @param translatedLang Translated language
+ * @returns true if semantically equivalent
+ */
+declare function validateTranslation(original: string, translated: string, originalLang: string, translatedLang: string): boolean;
+
+/**
+ * Language Profiles
+ *
+ * Re-exports from individual profile files for backwards compatibility.
+ * For minimal bundles, import specific profiles directly:
+ *
+ * @example
+ * ```typescript
+ * // Tree-shakeable import
+ * import { englishProfile } from './profiles/english';
+ *
+ * // Full import (all profiles bundled)
+ * import { englishProfile, languageProfiles } from './language-profiles';
+ * ```
+ *
+ * @generated This file is auto-generated. Do not edit manually.
+ */
+
+/**
+ * All available language profiles.
+ * @deprecated Import individual profiles for tree-shaking.
+ */
+declare const languageProfiles: Record<string, LanguageProfile>;
+/**
+ * Get a language profile by code.
+ * @deprecated Use the registry's getProfile instead.
+ */
+declare function getProfile(code: string): LanguageProfile | undefined;
+/**
+ * Get all supported language codes.
+ * @deprecated Use the registry's getRegisteredLanguages instead.
+ */
+declare function getSupportedLanguages$1(): string[];
+/**
+ * Check if a language is supported.
+ * @deprecated Use the registry's isLanguageRegistered instead.
+ */
+declare function isLanguageSupported(code: string): boolean;
+
+/**
+ * Language Registry
+ *
+ * Central registration point for language support in the semantic parser.
+ * Languages self-register when their modules are imported, enabling
+ * tree-shaking for minimal bundles.
+ *
+ * @example
+ * ```typescript
+ * // Import only the languages you need
+ * import '@lokascript/semantic/languages/en';
+ * import '@lokascript/semantic/languages/es';
+ *
+ * // Now parse works for registered languages
+ * import { parse } from '@lokascript/semantic';
+ * parse('toggle .active', 'en');     // Works
+ * parse('alternar .activo', 'es');   // Works
+ * parse('切り替え .active', 'ja');    // Error: Language not registered
+ * ```
+ */
+
+/**
+ * Try to get a profile, returning undefined if not registered.
+ */
+declare function tryGetProfile(code: string): LanguageProfile | undefined;
+/**
+ * Get all registered language codes.
+ */
+declare function getRegisteredLanguages(): string[];
+
+/**
+ * Semantic Result Cache
+ *
+ * LRU cache for semantic analysis results to optimize repeated parsing.
+ *
+ * Design:
+ * - Cache key: `${language}:${input}` for simple, fast lookups
+ * - LRU eviction when max size reached
+ * - Optional TTL (time-to-live) for cache entries
+ * - Statistics for monitoring cache effectiveness
+ * - Thread-safe for browser environments (single-threaded)
+ */
+
+/**
+ * Cache configuration options.
+ */
+interface SemanticCacheConfig {
+    /** Maximum number of entries to cache. Default: 1000 */
+    maxSize?: number;
+    /** Time-to-live in milliseconds. 0 = no expiration. Default: 0 */
+    ttlMs?: number;
+    /** Enable/disable caching. Default: true */
+    enabled?: boolean;
+}
+/**
+ * Cache statistics.
+ */
+interface CacheStats {
+    /** Total cache hits */
+    hits: number;
+    /** Total cache misses */
+    misses: number;
+    /** Current cache size */
+    size: number;
+    /** Maximum cache size */
+    maxSize: number;
+    /** Hit rate (0-1) */
+    hitRate: number;
+    /** Total evictions due to size limit */
+    evictions: number;
+    /** Total expirations due to TTL */
+    expirations: number;
+    /** Whether caching is enabled */
+    enabled: boolean;
+}
+/**
+ * LRU Cache for semantic analysis results.
+ *
+ * Uses Map's insertion order for LRU eviction - when we access an entry,
+ * we delete and re-insert it to move it to the end (most recently used).
+ */
+declare class SemanticCache {
+    private cache;
+    private config;
+    private stats;
+    constructor(config?: SemanticCacheConfig);
+    /**
+     * Generate cache key from input and language.
+     */
+    private makeKey;
+    /**
+     * Check if an entry has expired.
+     */
+    private isExpired;
+    /**
+     * Evict the least recently used entry.
+     */
+    private evictLRU;
+    /**
+     * Get a cached result.
+     *
+     * @param input - The input string
+     * @param language - The language code
+     * @returns The cached result, or undefined if not found/expired
+     */
+    get(input: string, language: string): SemanticAnalysisResult | undefined;
+    /**
+     * Store a result in the cache.
+     *
+     * @param input - The input string
+     * @param language - The language code
+     * @param result - The analysis result to cache
+     */
+    set(input: string, language: string, result: SemanticAnalysisResult): void;
+    /**
+     * Check if a result is cached (without updating LRU).
+     */
+    has(input: string, language: string): boolean;
+    /**
+     * Remove a specific entry from the cache.
+     */
+    delete(input: string, language: string): boolean;
+    /**
+     * Clear all cached entries.
+     */
+    clear(): void;
+    /**
+     * Reset statistics.
+     */
+    resetStats(): void;
+    /**
+     * Get cache statistics.
+     */
+    getStats(): CacheStats;
+    /**
+     * Update cache configuration.
+     */
+    configure(config: Partial<SemanticCacheConfig>): void;
+    /**
+     * Enable caching.
+     */
+    enable(): void;
+    /**
+     * Disable caching.
+     */
+    disable(): void;
+    /**
+     * Get current configuration.
+     */
+    getConfig(): Readonly<Required<SemanticCacheConfig>>;
+}
+/**
+ * Default global cache instance.
+ */
+declare const semanticCache: SemanticCache;
+/**
+ * Create a cache with custom configuration.
+ */
+declare function createSemanticCache(config?: SemanticCacheConfig): SemanticCache;
+/**
+ * Decorator/wrapper for adding caching to an analyze function.
+ *
+ * @param analyzeFn - The analyze function to wrap
+ * @param cache - The cache instance to use
+ * @returns Wrapped function with caching
+ */
+declare function withCache<T extends (input: string, language: string) => SemanticAnalysisResult>(analyzeFn: T, cache?: SemanticCache): T;
+
+/**
+ * Core Parser Bridge
+ *
+ * Provides the SemanticAnalyzer interface that integrates semantic parsing
+ * into the core hyperscript parser. This bridge enables confidence-driven
+ * fallback between semantic and traditional parsing.
+ */
+
+/**
+ * Result of semantic analysis.
+ */
+interface SemanticAnalysisResult {
+    /** Confidence score (0-1) for this analysis */
+    readonly confidence: number;
+    /** The parsed command info (if successful) */
+    readonly command?: {
+        readonly name: ActionType;
+        readonly roles: ReadonlyMap<SemanticRole, SemanticValue>;
+    };
+    /** The full semantic node (if successful) */
+    readonly node?: SemanticNode;
+    /** Any errors encountered */
+    readonly errors?: string[];
+    /** Number of tokens consumed */
+    readonly tokensConsumed?: number;
+}
+/**
+ * Interface for semantic analysis that can be integrated into the core parser.
+ * This allows the core parser to optionally use semantic parsing with
+ * confidence-based fallback to traditional parsing.
+ */
+interface SemanticAnalyzer {
+    /**
+     * Analyze input in the specified language.
+     *
+     * @param input The input string to analyze
+     * @param language ISO 639-1 language code
+     * @returns Analysis result with confidence score
+     */
+    analyze(input: string, language: string): SemanticAnalysisResult;
+    /**
+     * Check if semantic parsing is available for a language.
+     */
+    supportsLanguage(language: string): boolean;
+    /**
+     * Get the list of supported languages.
+     */
+    supportedLanguages(): string[];
+    /**
+     * Get cache statistics.
+     */
+    getCacheStats(): CacheStats;
+    /**
+     * Clear the result cache.
+     */
+    clearCache(): void;
+    /**
+     * Configure the cache.
+     */
+    configureCache(config: Partial<SemanticCacheConfig>): void;
+}
+/**
+ * Options for creating a SemanticAnalyzer.
+ */
+interface SemanticAnalyzerOptions {
+    /** Cache configuration. Pass false to disable caching. */
+    cache?: SemanticCacheConfig | false;
+}
+/**
+ * Implementation of SemanticAnalyzer that wraps the semantic parser.
+ * Includes LRU caching for performance optimization on repeated inputs.
+ */
+declare class SemanticAnalyzerImpl implements SemanticAnalyzer {
+    private readonly patternMatcher;
+    private readonly languages;
+    private readonly cache;
+    constructor(options?: SemanticAnalyzerOptions);
+    analyze(input: string, language: string): SemanticAnalysisResult;
+    /**
+     * Perform analysis without cache lookup.
+     */
+    private analyzeUncached;
+    supportsLanguage(language: string): boolean;
+    supportedLanguages(): string[];
+    getCacheStats(): CacheStats;
+    clearCache(): void;
+    configureCache(config: Partial<SemanticCacheConfig>): void;
+    private buildSemanticNode;
+}
+/**
+ * Create a SemanticAnalyzer instance.
+ *
+ * @param options - Configuration options including cache settings
+ * @returns A new SemanticAnalyzer
+ *
+ * @example
+ * // Default: uses shared global cache
+ * const analyzer = createSemanticAnalyzer();
+ *
+ * @example
+ * // Custom cache size
+ * const analyzer = createSemanticAnalyzer({ cache: { maxSize: 500 } });
+ *
+ * @example
+ * // Disable caching
+ * const analyzer = createSemanticAnalyzer({ cache: false });
+ */
+declare function createSemanticAnalyzer(options?: SemanticAnalyzerOptions): SemanticAnalyzer;
+
+/**
+ * Default confidence threshold for preferring semantic parsing.
+ * If confidence is above this, use semantic result; otherwise fallback.
+ */
+declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.5;
+/**
+ * High confidence threshold for very certain matches.
+ */
+declare const HIGH_CONFIDENCE_THRESHOLD = 0.8;
+/**
+ * Determine if semantic analysis should be used based on confidence.
+ */
+declare function shouldUseSemanticResult(result: SemanticAnalysisResult, threshold?: number): boolean;
+/**
+ * Convert semantic roles to the format expected by core parser commands.
+ * This maps semantic roles to the positional/modifier structure used by
+ * the core command implementations.
+ *
+ * Role to preposition mapping:
+ * - patient → first positional arg
+ * - event → first positional arg
+ * - destination → 'into' (put) or 'on' (others)
+ * - source → 'from'
+ * - quantity → 'by'
+ * - duration → 'over' or 'for'
+ * - method → 'as'
+ * - style → 'with'
+ * - condition → 'if'
+ */
+declare function rolesToCommandArgs(roles: ReadonlyMap<SemanticRole, SemanticValue>, command: ActionType): {
+    args: SemanticValue[];
+    modifiers: Record<string, SemanticValue>;
+};
+
+/**
+ * Command Schemas
+ *
+ * Defines the semantic structure of each hyperscript command.
+ * Used by the pattern generator to create language-specific patterns.
+ */
+
+/**
+ * A role specification in a command schema.
+ */
+interface RoleSpec {
+    /** The semantic role */
+    readonly role: SemanticRole;
+    /** Description of what this role represents */
+    readonly description: string;
+    /** Whether this role is required */
+    readonly required: boolean;
+    /** Expected value types */
+    readonly expectedTypes: Array<'selector' | 'literal' | 'reference' | 'expression'>;
+    /** Default value if not provided */
+    readonly default?: SemanticValue;
+    /** Position hint for SVO languages (higher = earlier) */
+    readonly svoPosition?: number;
+    /** Position hint for SOV languages (higher = earlier) */
+    readonly sovPosition?: number;
+    /**
+     * Override the default role marker for this command.
+     * Maps language code to the marker to use (e.g., { en: 'to', es: 'a' }).
+     * If not specified, uses the language profile's default roleMarker.
+     */
+    readonly markerOverride?: Record<string, string>;
+}
+/**
+ * A precondition that must be met before command execution.
+ * Used for runtime error documentation.
+ */
+interface CommandPrecondition {
+    /** Human-readable condition description */
+    readonly condition: string;
+    /** Error code thrown when precondition fails */
+    readonly errorCode: string;
+    /** Error message template */
+    readonly message: string;
+}
+/**
+ * A command schema defines the semantic structure of a command.
+ */
+interface CommandSchema {
+    /** The action type (command name) */
+    readonly action: ActionType;
+    /** Human-readable description */
+    readonly description: string;
+    /** Roles this command accepts */
+    readonly roles: RoleSpec[];
+    /** The primary role (what the command acts on) */
+    readonly primaryRole: SemanticRole;
+    /** Category for grouping */
+    readonly category: CommandCategory;
+    /** Whether this command typically has a body (like event handlers) */
+    readonly hasBody?: boolean;
+    /** Notes about special handling */
+    readonly notes?: string;
+    /** Possible runtime error codes this command can throw */
+    readonly errorCodes?: readonly string[];
+    /** Preconditions that must be met before execution */
+    readonly preconditions?: readonly CommandPrecondition[];
+    /** Recovery hints mapping error code to suggestion */
+    readonly recoveryHints?: Readonly<Record<string, string>>;
+}
+/**
+ * Command categories for organization.
+ */
+type CommandCategory = 'dom-class' | 'dom-content' | 'dom-visibility' | 'variable' | 'event' | 'async' | 'navigation' | 'control-flow';
+/**
+ * Toggle command: adds class/attribute if absent, removes if present.
+ *
+ * Patterns:
+ * - EN: toggle .active on #button
+ * - JA: #button の .active を 切り替え
+ * - AR: بدّل .active على #button
+ */
+declare const toggleSchema: CommandSchema;
+/**
+ * Add command: adds a class or attribute.
+ */
+declare const addSchema: CommandSchema;
+/**
+ * Remove command: removes a class or attribute.
+ */
+declare const removeSchema: CommandSchema;
+/**
+ * Put command: puts content into a target.
+ *
+ * Patterns:
+ * - EN: put "hello" into #output
+ * - JA: #output に "hello" を 置く
+ * - AR: ضع "hello" في #output
+ */
+declare const putSchema: CommandSchema;
+/**
+ * Set command: sets a property or variable.
+ *
+ * Patterns:
+ * - EN: set :count to 10
+ * - ES: establecer :count a 10
+ * - JA: :count を 10 に 設定
+ * - KO: :x 에 5 을 설정 (uses default markers)
+ * - TR: :x e 5 i ayarla (uses default markers)
+ *
+ * Note: Only override markers for SVO languages where patient has no default marker.
+ * SOV languages (Korean, Japanese, Turkish) already have correct object markers.
+ */
+declare const setSchema: CommandSchema;
+/**
+ * Show command: makes an element visible.
+ */
+declare const showSchema: CommandSchema;
+/**
+ * Hide command: makes an element invisible.
+ */
+declare const hideSchema: CommandSchema;
+/**
+ * On command: event handler.
+ */
+declare const onSchema: CommandSchema;
+/**
+ * Trigger command: dispatches an event.
+ * Supports namespaced events like "draggable:start".
+ */
+declare const triggerSchema: CommandSchema;
+/**
+ * Wait command: pauses execution.
+ */
+declare const waitSchema: CommandSchema;
+/**
+ * Fetch command: makes HTTP request.
+ */
+declare const fetchSchema: CommandSchema;
+/**
+ * Increment command: increases a numeric value.
+ */
+declare const incrementSchema: CommandSchema;
+/**
+ * Decrement command: decreases a numeric value.
+ */
+declare const decrementSchema: CommandSchema;
+/**
+ * Append command: appends content to an element.
+ */
+declare const appendSchema: CommandSchema;
+/**
+ * Prepend command: prepends content to an element.
+ */
+declare const prependSchema: CommandSchema;
+/**
+ * All available command schemas.
+ */
+declare const commandSchemas: Record<ActionType, CommandSchema>;
+/**
+ * Get a command schema by action type.
+ */
+declare function getSchema$1(action: ActionType): CommandSchema | undefined;
+/**
+ * Get all schemas for a category.
+ */
+declare function getSchemasByCategory(category: CommandCategory): CommandSchema[];
+/**
+ * Get all fully-defined schemas (with roles).
+ */
+declare function getDefinedSchemas(): CommandSchema[];
+
+/**
+ * Pattern Generator
+ *
+ * Generates LanguagePattern objects from CommandSchema + LanguageProfile.
+ * This solves the pattern explosion problem by deriving patterns from
+ * high-level definitions rather than hand-writing each one.
+ */
+
+/**
+ * Configuration for pattern generation.
+ */
+interface GeneratorConfig {
+    /** Base priority for generated patterns (higher = checked first) */
+    basePriority?: number;
+    /** Whether to generate simple patterns (without optional roles) */
+    generateSimpleVariants?: boolean;
+    /** Whether to generate alternative keyword patterns */
+    generateAlternatives?: boolean;
+}
+/**
+ * Generate a pattern for a command in a specific language.
+ */
+declare function generatePattern(schema: CommandSchema, profile: LanguageProfile, config?: GeneratorConfig): LanguagePattern;
+/**
+ * Generate a simple variant pattern (without optional roles).
+ */
+declare function generateSimplePattern(schema: CommandSchema, profile: LanguageProfile, config?: GeneratorConfig): LanguagePattern | null;
+/**
+ * Generate all pattern variants for a command in a language.
+ */
+declare function generatePatternVariants(schema: CommandSchema, profile: LanguageProfile, config?: GeneratorConfig): LanguagePattern[];
+/**
+ * Generate patterns for all commands in a specific language.
+ */
+declare function generatePatternsForLanguage(profile: LanguageProfile, config?: GeneratorConfig): LanguagePattern[];
+/**
+ * Generate patterns for a command across specified profiles.
+ *
+ * @param schema Command schema to generate patterns for
+ * @param profiles Array of language profiles to generate patterns for (defaults to all registered)
+ * @param config Generator configuration
+ */
+declare function generatePatternsForCommand(schema: CommandSchema, profiles?: LanguageProfile[], config?: GeneratorConfig): LanguagePattern[];
+/**
+ * Generate all patterns for all commands across specified profiles.
+ *
+ * @param profiles Array of language profiles to generate patterns for (defaults to all registered)
+ * @param config Generator configuration
+ */
+declare function generateAllPatterns(profiles?: LanguageProfile[], config?: GeneratorConfig): LanguagePattern[];
+/**
+ * Get a summary of what patterns can be generated.
+ * Note: This requires the registry to have languages registered.
+ */
+declare function getGeneratorSummary(): {
+    languages: string[];
+    commands: string[];
+    totalPatterns: number;
+};
+/**
+ * Validate that all required keywords exist for a language.
+ */
+declare function validateLanguageKeywords(profile: LanguageProfile, schemas?: CommandSchema[]): {
+    missing: string[];
+    available: string[];
+};
+
+/**
+ * Per-Command Semantic Validation
+ *
+ * Validates semantic parse results against command schemas.
+ * Ensures that role assignments match expected types and constraints.
+ *
+ * Design Philosophy:
+ * - Command schemas are the source of truth for validation rules
+ * - Validation happens AFTER pattern matching, BEFORE AST conversion
+ * - Provides detailed error messages for debugging
+ * - Supports confidence scoring for ambiguous parses
+ *
+ * Integration with core validators:
+ * - Uses patterns from @lokascript/core's lightweight-validators where applicable
+ * - Type validation follows same patterns as runtime validation
+ * - Can be extended with custom validators using the same API
+ */
+
+/**
+ * Validation error with detailed context.
+ */
+interface ValidationError {
+    /** Error code for programmatic handling */
+    code: 'MISSING_REQUIRED_ROLE' | 'INVALID_TYPE' | 'UNKNOWN_ROLE' | 'CONSTRAINT_VIOLATION';
+    /** Human-readable message */
+    message: string;
+    /** The role that failed validation */
+    role?: SemanticRole;
+    /** Expected types */
+    expected?: string[];
+    /** Actual value */
+    actual?: SemanticValue;
+    /** Severity: 'error' blocks execution, 'warning' is logged */
+    severity: 'error' | 'warning';
+}
+/**
+ * Result of command validation.
+ */
+interface ValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Validation errors (if any) */
+    errors: ValidationError[];
+    /** Warnings (non-blocking issues) */
+    warnings: ValidationError[];
+    /** Confidence adjustment (-1 to +1) based on validation */
+    confidenceAdjustment: number;
+    /** Suggested fixes for errors */
+    suggestions: string[];
+}
+/**
+ * Maps action types to their schemas.
+ */
+declare const schemaRegistry: Map<ActionType, CommandSchema>;
+/**
+ * Get schema for an action type.
+ */
+declare function getSchema(action: ActionType): CommandSchema | undefined;
+/**
+ * Register a custom schema.
+ */
+declare function registerSchema(action: ActionType, schema: CommandSchema): void;
+/**
+ * Validate a semantic parse result against its command schema.
+ *
+ * @param result - The semantic parse result to validate
+ * @returns Validation result with errors, warnings, and confidence adjustment
+ */
+declare function validateSemanticResult(result: SemanticParseResult): ValidationResult;
+/**
+ * Apply validation to a parse result and adjust confidence.
+ *
+ * @param result - The semantic parse result
+ * @returns Updated result with adjusted confidence
+ */
+declare function validateAndAdjustConfidence(result: SemanticParseResult): SemanticParseResult & {
+    validation: ValidationResult;
+};
+
+/**
+ * Unified Language Profile
+ *
+ * Combines parsing-focused features (from semantic) with generation-focused
+ * features (from i18n) into a single profile structure.
+ *
+ * This enables:
+ * - Single source of truth for language configuration
+ * - Bidirectional conversion: parse (natural → semantic) and render (semantic → natural)
+ * - Consistent language support across packages
+ */
+
+/**
+ * How grammatical relationships are marked (unified from both packages).
+ *
+ * Maps to i18n's AdpositionType:
+ * - preposition → 'preposition'
+ * - postposition → 'postposition'
+ * - particle → 'postposition' (particles are typically postpositional)
+ * - case-suffix → 'postposition' (suffixes attach after)
+ */
+type MarkingStrategy = 'preposition' | 'postposition' | 'particle' | 'case-suffix';
+/**
+ * A grammatical marker for a semantic role.
+ * Unified from both packages' marker types.
+ */
+interface UnifiedRoleMarker {
+    /** Primary marker form */
+    readonly primary: string;
+    /** Alternative forms (conjugations, vowel harmony variants) */
+    readonly alternatives?: string[];
+    /** Position relative to the role value */
+    readonly position: 'before' | 'after';
+    /** Whether this marker is required */
+    readonly required?: boolean;
+}
+/**
+ * Verb form configuration for a language.
+ */
+interface VerbConfig {
+    /** Position of verb in the sentence */
+    readonly position: 'start' | 'end' | 'second';
+    /** Common verb suffixes/conjugations to recognize */
+    readonly suffixes?: string[];
+    /** Whether the language commonly drops subjects */
+    readonly subjectDrop?: boolean;
+}
+/**
+ * Translation of a command keyword.
+ */
+interface KeywordTranslation {
+    /** Primary translation */
+    readonly primary: string;
+    /** Alternative forms (conjugations, synonyms) */
+    readonly alternatives?: string[];
+    /** Normalized form for matching */
+    readonly normalized?: string;
+}
+/**
+ * Special tokenization configuration.
+ */
+interface TokenizationConfig {
+    /** Particles to recognize (for particle languages) */
+    readonly particles?: string[];
+    /** Prefixes to recognize (for prefixing languages) */
+    readonly prefixes?: string[];
+    /** Word boundary detection strategy */
+    readonly boundaryStrategy?: 'space' | 'particle' | 'character';
+}
+/**
+ * Unified Language Profile
+ *
+ * Combines all fields needed for both parsing and generation:
+ *
+ * **Shared fields:**
+ * - code, name, nativeName, direction, wordOrder
+ *
+ * **Parsing fields (from semantic):**
+ * - keywords: Command keyword translations
+ * - verb: Verb position and conjugation info
+ * - tokenization: Language-specific tokenization
+ * - usesSpaces: Word boundary info
+ *
+ * **Generation fields (from i18n):**
+ * - morphology: Morphological type for transformation
+ * - canonicalOrder: Role ordering for output
+ * - markers: Grammatical markers for roles
+ */
+interface UnifiedLanguageProfile {
+    /** ISO 639-1 language code */
+    readonly code: string;
+    /** Human-readable language name */
+    readonly name: string;
+    /** Native language name */
+    readonly nativeName: string;
+    /** Text direction */
+    readonly direction: 'ltr' | 'rtl';
+    /** Primary word order (SVO, SOV, VSO, etc.) */
+    readonly wordOrder: WordOrder$1;
+    /** How grammatical roles are marked */
+    readonly markingStrategy: MarkingStrategy;
+    /** Morphological typology */
+    readonly morphology: MorphologyType;
+    /** Whether the language uses spaces between words */
+    readonly usesSpaces: boolean;
+    /** Markers for each semantic role */
+    readonly roleMarkers: Partial<Record<SemanticRole, UnifiedRoleMarker>>;
+    /** Canonical role order for generation */
+    readonly canonicalOrder: SemanticRole[];
+    /** Verb configuration */
+    readonly verb: VerbConfig;
+    /** Command keyword translations */
+    readonly keywords: Record<string, KeywordTranslation>;
+    /** Special tokenization configuration */
+    readonly tokenization?: TokenizationConfig;
+    /** Special transformation rules */
+    readonly rules?: GrammarRule[];
+}
+/**
+ * Grammar rule for special transformations.
+ * (Imported from i18n for consistency)
+ */
+interface GrammarRule {
+    name: string;
+    description: string;
+    match: PatternMatcher;
+    transform: PatternTransform;
+    priority: number;
+}
+interface PatternMatcher {
+    commands?: string[];
+    requiredRoles: SemanticRole[];
+    optionalRoles?: SemanticRole[];
+    predicate?: (parsed: unknown) => boolean;
+}
+interface PatternTransform {
+    roleOrder: SemanticRole[];
+    insertMarkers?: boolean;
+    custom?: (parsed: unknown, profile: UnifiedLanguageProfile) => string;
+}
+/**
+ * Convert marking strategy to AdpositionType for i18n compatibility.
+ */
+declare function markingStrategyToAdpositionType(strategy: MarkingStrategy): AdpositionType;
+/**
+ * Convert UnifiedRoleMarker to GrammaticalMarker for i18n compatibility.
+ */
+declare function toGrammaticalMarker(role: SemanticRole, marker: UnifiedRoleMarker, strategy: MarkingStrategy): GrammaticalMarker;
+/**
+ * Convert UnifiedLanguageProfile to i18n LanguageProfile.
+ * This enables using unified profiles with existing i18n code.
+ */
+declare function toI18nProfile(unified: UnifiedLanguageProfile): {
+    code: string;
+    name: string;
+    wordOrder: WordOrder$1;
+    adpositionType: AdpositionType;
+    morphology: MorphologyType;
+    direction: 'ltr' | 'rtl';
+    markers: GrammaticalMarker[];
+    canonicalOrder: SemanticRole[];
+};
+/**
+ * Check if an object is a UnifiedLanguageProfile.
+ */
+declare function isUnifiedProfile(obj: unknown): obj is UnifiedLanguageProfile;
+
+/**
+ * Semantic Static Analysis
+ *
+ * Analyzes semantic nodes for potential issues:
+ * - Conflicting actions on same trigger
+ * - Accessibility problems (hover-only interactions)
+ * - Performance concerns (high-frequency triggers)
+ * - Invalid role combinations
+ *
+ * Can be used:
+ * - Standalone: analyze(input, lang)
+ * - Dev mode: Enabled via config, auto-warns on parse
+ * - Build time: Integrate with bundlers
+ */
+
+type WarningSeverity = 'error' | 'warning' | 'info';
+type WarningCode = 'HOVER_ONLY_INTERACTION' | 'HIGH_FREQUENCY_TRIGGER' | 'MISSING_REQUIRED_ROLE' | 'INVALID_ROLE_FOR_COMMAND' | 'CONFLICTING_ACTIONS' | 'UNREACHABLE_BEHAVIOR' | 'POTENTIAL_RACE_CONDITION';
+interface AnalysisWarning {
+    code: WarningCode;
+    severity: WarningSeverity;
+    message: string;
+    suggestion?: string;
+    location?: {
+        input: string;
+        role?: SemanticRole;
+    };
+}
+interface AnalysisResult {
+    valid: boolean;
+    warnings: AnalysisWarning[];
+    node: SemanticNode | null;
+}
+interface AnalysisConfig {
+    /** Enable accessibility checks (default: true) */
+    accessibility?: boolean;
+    /** Enable performance checks (default: true) */
+    performance?: boolean;
+    /** Enable schema validation (default: true) */
+    schema?: boolean;
+    /** Treat warnings as errors (default: false) */
+    strict?: boolean;
+}
+/**
+ * Check for hover-only interactions (accessibility issue).
+ */
+declare function checkAccessibility(node: SemanticNode, input: string): AnalysisWarning[];
+/**
+ * Check for high-frequency events without throttling.
+ */
+declare function checkPerformance(node: SemanticNode, input: string): AnalysisWarning[];
+/**
+ * Validate role combinations against command schema.
+ */
+declare function checkSchema(node: SemanticNode, input: string): AnalysisWarning[];
+/**
+ * Analyze multiple nodes together to detect conflicts.
+ */
+declare function analyzeMultiple(nodes: SemanticNode[], _config?: AnalysisConfig): AnalysisWarning[];
+/**
+ * Analyze a single hyperscript input for potential issues.
+ *
+ * @param input - The hyperscript text to analyze
+ * @param lang - The language of the input (default: 'en')
+ * @param config - Analysis configuration
+ * @returns Analysis result with warnings
+ *
+ * @example
+ * ```typescript
+ * const result = analyze('on hover show .tooltip', 'en');
+ * // result.warnings[0].code === 'HOVER_ONLY_INTERACTION'
+ * ```
+ */
+declare function analyze(input: string, lang?: string, config?: AnalysisConfig): AnalysisResult;
+/**
+ * Analyze multiple hyperscript inputs together.
+ *
+ * @param inputs - Array of hyperscript texts
+ * @param lang - The language of the inputs
+ * @param config - Analysis configuration
+ * @returns Combined analysis result
+ */
+declare function analyzeAll(inputs: string[], lang?: string, config?: AnalysisConfig): AnalysisResult;
+/**
+ * Enable dev mode analysis.
+ * When enabled, every parse() call will run analysis and log warnings.
+ */
+declare function enableDevMode(config?: AnalysisConfig): void;
+/**
+ * Disable dev mode analysis.
+ */
+declare function disableDevMode(): void;
+/**
+ * Check if dev mode is enabled.
+ */
+declare function isDevModeEnabled(): boolean;
+/**
+ * Get current dev mode config.
+ */
+declare function getDevModeConfig(): AnalysisConfig;
+/**
+ * Run dev mode analysis if enabled.
+ * Called internally by parser when dev mode is on.
+ */
+declare function devModeAnalyze(input: string, lang: string, node: SemanticNode | null): void;
+
+/**
+ * Expression Parser Types
+ *
+ * Defines AST node types for expressions that can be shared between
+ * the semantic package (AST building) and core package (runtime).
+ *
+ * These types are intentionally minimal and focused on expressions only.
+ */
+/**
+ * Base interface for all expression AST nodes
+ */
+interface ExpressionNode {
+    readonly type: string;
+    readonly start?: number | undefined;
+    readonly end?: number | undefined;
+    readonly line?: number | undefined;
+    readonly column?: number | undefined;
+}
+interface LiteralNode extends ExpressionNode {
+    readonly type: 'literal';
+    readonly value: string | number | boolean | null | undefined;
+    readonly raw?: string | undefined;
+    readonly dataType?: 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'duration' | undefined;
+}
+type SelectorKind = 'id' | 'class' | 'attribute' | 'element' | 'query' | 'complex';
+interface SelectorNode extends ExpressionNode {
+    readonly type: 'selector' | 'cssSelector' | 'idRef' | 'classRef';
+    readonly value?: string;
+    readonly selector?: string;
+    readonly selectorType?: SelectorKind;
+}
+type ContextType = 'me' | 'you' | 'it' | 'its' | 'my' | 'your' | 'result' | 'event' | 'target' | 'body' | 'detail';
+interface ContextReferenceNode extends ExpressionNode {
+    readonly type: 'contextReference' | 'symbol';
+    readonly contextType?: ContextType;
+    readonly name?: string;
+}
+interface PropertyAccessNode extends ExpressionNode {
+    readonly type: 'propertyAccess';
+    readonly object: ExpressionNode;
+    readonly property: string;
+}
+
+/**
+ * Semantic Value to AST Node Converters
+ *
+ * Converts SemanticValue types to AST expression nodes.
+ * Used by the AST builder to construct expression trees from semantic parsing results.
+ */
+
+/**
+ * Convert a SemanticValue to an AST ExpressionNode.
+ *
+ * @param value - The semantic value to convert
+ * @param warnings - Optional array to collect warnings about potentially incorrect type choices
+ * @returns The corresponding AST expression node
+ */
+declare function convertValue(value: SemanticValue, warnings?: string[]): ExpressionNode;
+/**
+ * Convert a LiteralValue to a LiteralNode.
+ */
+declare function convertLiteral(value: LiteralValue): LiteralNode;
+/**
+ * Convert a SelectorValue to a SelectorNode.
+ *
+ * @param value - The selector value to convert
+ * @param warnings - Optional array to collect warnings
+ */
+declare function convertSelector(value: SelectorValue, warnings?: string[]): SelectorNode;
+/**
+ * Convert a ReferenceValue to a ContextReferenceNode.
+ */
+declare function convertReference(value: ReferenceValue): ContextReferenceNode;
+/**
+ * Convert a PropertyPathValue to a PropertyAccessNode.
+ * Recursively converts the object part.
+ *
+ * @param value - The property path value to convert
+ * @param warnings - Optional array to collect warnings
+ */
+declare function convertPropertyPath(value: PropertyPathValue, warnings?: string[]): PropertyAccessNode;
+/**
+ * Convert an ExpressionValue (raw string) by parsing it with the expression parser.
+ * This is the fallback for complex expressions that couldn't be fully parsed
+ * at the semantic level.
+ */
+declare function convertExpression(value: ExpressionValue): ExpressionNode;
+
+/**
+ * Command-specific AST Mappers
+ *
+ * Each command can have a custom mapper that knows how to convert
+ * its semantic roles to the appropriate AST structure.
+ */
+
+/**
+ * Result from command mapping, including the AST and any warnings.
+ */
+interface CommandMapperResult {
+    ast: CommandNode;
+    warnings: string[];
+}
+/**
+ * Interface for command-specific AST mappers.
+ */
+interface CommandMapper {
+    /**
+     * The action type this mapper handles.
+     */
+    readonly action: ActionType;
+    /**
+     * Convert a CommandSemanticNode to a CommandNode.
+     *
+     * @param node - The semantic command node
+     * @param builder - The AST builder (for recursive building if needed)
+     * @returns The AST command node with any warnings, or just the AST node for backward compatibility
+     */
+    toAST(node: CommandSemanticNode, builder: ASTBuilder): CommandMapperResult | CommandNode;
+}
+/**
+ * Get the command mapper for an action type.
+ *
+ * @param action - The action type
+ * @returns The mapper, or undefined if no specific mapper exists
+ */
+declare function getCommandMapper(action: ActionType): CommandMapper | undefined;
+/**
+ * Register a custom command mapper.
+ *
+ * @param mapper - The command mapper to register
+ */
+declare function registerCommandMapper(mapper: CommandMapper): void;
+/**
+ * Get all registered command mappers.
+ */
+declare function getRegisteredMappers(): Map<ActionType, CommandMapper>;
+
+/**
+ * Semantic to AST Builder
+ *
+ * Converts SemanticNodes directly to AST nodes, bypassing the English text
+ * generation and re-parsing step.
+ *
+ * Flow:
+ *   Japanese → Semantic Parser → SemanticNode → AST Builder → AST
+ *
+ * Instead of:
+ *   Japanese → Semantic Parser → SemanticNode → English Text → Parser → AST
+ */
+
+/**
+ * Base AST node interface
+ */
+interface ASTNode {
+    readonly type: string;
+    readonly start?: number;
+    readonly end?: number;
+    readonly line?: number;
+    readonly column?: number;
+    [key: string]: unknown;
+}
+/**
+ * Command AST node
+ */
+interface CommandNode extends ASTNode {
+    readonly type: 'command';
+    readonly name: string;
+    readonly args: ExpressionNode[];
+    readonly modifiers?: Record<string, ExpressionNode>;
+    readonly isBlocking?: boolean;
+    readonly implicitTarget?: ExpressionNode;
+}
+/**
+ * Event handler AST node (compatible with @lokascript/core)
+ */
+interface EventHandlerNode extends ASTNode {
+    readonly type: 'eventHandler';
+    /** Primary event name */
+    readonly event: string;
+    /** All event names when using "on event1 or event2" syntax */
+    readonly events?: string[];
+    /** CSS selector for event delegation ("from" keyword) */
+    readonly selector?: string;
+    /** Target for "from" clause (as string or expression) */
+    readonly target?: string;
+    /** Optional event condition ("[condition]" syntax) */
+    readonly condition?: ASTNode;
+    /** Attribute name for mutation events ("of @attribute" syntax) */
+    readonly attributeName?: string;
+    /** Target element to watch for changes ("in <target>" syntax) */
+    readonly watchTarget?: ExpressionNode;
+    /** Event parameter names to destructure (e.g., ['clientX', 'clientY']) */
+    readonly args?: string[];
+    /** Event parameters (alias for args) */
+    readonly params?: string[];
+    /** Handler commands */
+    readonly commands: ASTNode[];
+}
+/**
+ * Conditional AST node (if/else)
+ *
+ * Note: For runtime compatibility, buildConditional() now produces a CommandNode
+ * with condition and branches as args, matching what IfCommand expects.
+ * This interface is retained for reference but not used as output.
+ */
+interface ConditionalNode extends ASTNode {
+    readonly type: 'if';
+    readonly condition: ExpressionNode;
+    readonly thenBranch: ASTNode[];
+    readonly elseBranch?: ASTNode[];
+}
+/**
+ * Command sequence node (runtime-compatible format for chained commands)
+ */
+interface CommandSequenceNode extends ASTNode {
+    readonly type: 'CommandSequence';
+    /** Commands in the sequence */
+    readonly commands: ASTNode[];
+}
+/**
+ * Block node (for grouping commands)
+ */
+interface BlockNode extends ASTNode {
+    readonly type: 'block';
+    readonly commands: ASTNode[];
+}
+interface ASTBuilderOptions {
+    /**
+     * Fallback function to parse complex expressions that can't be handled
+     * directly by the AST builder. Uses the expression-parser by default.
+     */
+    parseExpression?: (input: string) => ExpressionNode | null;
+}
+/**
+ * Builds AST nodes directly from SemanticNodes.
+ */
+declare class ASTBuilder {
+    /**
+     * Warnings collected during AST building (e.g., type inference issues).
+     */
+    warnings: string[];
+    constructor(_options?: ASTBuilderOptions);
+    /**
+     * Build an AST from a SemanticNode.
+     *
+     * @param node - The semantic node to convert
+     * @returns The corresponding AST node
+     */
+    build(node: SemanticNode): ASTNode;
+    /**
+     * Build a CommandNode from a CommandSemanticNode.
+     */
+    private buildCommand;
+    /**
+     * Generic command builder when no specific mapper is available.
+     * Maps roles to args in a predictable order.
+     */
+    private buildGenericCommand;
+    /**
+     * Map semantic roles to hyperscript modifier keywords.
+     */
+    private roleToModifierKey;
+    /**
+     * Build an EventHandlerNode from an EventHandlerSemanticNode.
+     */
+    private buildEventHandler;
+    /**
+     * Build a CommandNode from a ConditionalSemanticNode.
+     *
+     * Produces a command node with:
+     * - args[0]: condition expression
+     * - args[1]: then block (wrapped in { type: 'block', commands: [...] })
+     * - args[2]: else block (optional, same format)
+     *
+     * This format matches what IfCommand.parseInput() expects.
+     */
+    private buildConditional;
+    /**
+     * Build AST nodes from a CompoundSemanticNode.
+     *
+     * Converts to CommandSequence for runtime compatibility.
+     * The runtime recognizes 'CommandSequence' type and executes commands in order.
+     */
+    private buildCompound;
+    /**
+     * Build a CommandNode from a LoopSemanticNode.
+     *
+     * Produces a 'repeat' command with:
+     * - args[0]: loop type identifier (forever, times, for, while, until)
+     * - args[1]: count/condition/variable depending on loop type
+     * - args[2]: collection (for 'for' loops)
+     * - args[last]: body block
+     *
+     * This format matches what the repeat command parser produces.
+     */
+    private buildLoop;
+    /**
+     * Build a BlockNode from an array of semantic nodes.
+     * Useful for grouping commands in if/else branches.
+     */
+    buildBlock(nodes: SemanticNode[]): BlockNode;
+}
+/**
+ * Result from building an AST, including any warnings.
+ */
+interface BuildASTResult {
+    ast: ASTNode;
+    warnings: string[];
+}
+/**
+ * Build an AST from a SemanticNode using default options.
+ *
+ * @param node - The semantic node to convert
+ * @returns The corresponding AST node and any warnings
+ */
+declare function buildAST(node: SemanticNode): BuildASTResult;
+
+/**
+ * Language Loader
+ *
+ * Provides lazy loading capabilities for language modules.
+ * Languages can be loaded:
+ * 1. Via dynamic import from package subpath
+ * 2. From a URL (for CDN usage)
+ * 3. From a pre-loaded module object
+ *
+ * @example
+ * ```typescript
+ * import { loadLanguage, parse } from '@lokascript/semantic/browser/lazy';
+ *
+ * // Load Japanese on demand
+ * await loadLanguage('ja');
+ *
+ * // Now parsing works for Japanese
+ * parse('トグル .active', 'ja');
+ * ```
+ */
+
+/**
+ * Options for loading a language.
+ */
+interface LoadLanguageOptions {
+    /**
+     * URL to fetch the language module from (for CDN usage).
+     * The module should export: tokenizer, profile, patterns (or buildPatterns)
+     */
+    url?: string;
+    /**
+     * Pre-loaded module object.
+     * Use this if you've already imported the module.
+     */
+    module?: LanguageModule;
+    /**
+     * Skip loading if the language is already registered.
+     * Defaults to true.
+     */
+    skipIfRegistered?: boolean;
+}
+/**
+ * A language module that can be registered with the semantic parser.
+ */
+interface LanguageModule {
+    /** The language tokenizer */
+    tokenizer: LanguageTokenizer;
+    /** The language profile for pattern generation */
+    profile: LanguageProfile;
+    /** Pre-built patterns (optional) */
+    patterns?: LanguagePattern[];
+    /** Function to build patterns lazily (optional) */
+    buildPatterns?: () => LanguagePattern[];
+}
+/**
+ * Result of a language loading operation.
+ */
+interface LoadLanguageResult {
+    /** The language code that was loaded */
+    code: string;
+    /** Whether the language was newly loaded (false if already registered) */
+    loaded: boolean;
+    /** Error message if loading failed */
+    error?: string;
+}
+/**
+ * List of all supported language codes.
+ */
+declare const SUPPORTED_LANGUAGES: string[];
+/**
+ * Load a single language.
+ *
+ * @param code - The language code (e.g., 'en', 'ja', 'es')
+ * @param options - Loading options
+ * @returns Result indicating success or failure
+ *
+ * @example
+ * ```typescript
+ * // Load from package
+ * await loadLanguage('ja');
+ *
+ * // Load from CDN
+ * await loadLanguage('ko', {
+ *   url: 'https://cdn.example.com/hyperfixi-semantic-ko.js'
+ * });
+ *
+ * // Load from pre-loaded module
+ * await loadLanguage('en', { module: myEnglishModule });
+ * ```
+ */
+declare function loadLanguage(code: string, options?: LoadLanguageOptions): Promise<LoadLanguageResult>;
+/**
+ * Load multiple languages in parallel.
+ *
+ * @param codes - Array of language codes to load
+ * @param options - Loading options (applied to all languages)
+ * @returns Array of results for each language
+ *
+ * @example
+ * ```typescript
+ * // Load multiple languages
+ * const results = await loadLanguages(['en', 'es', 'ja']);
+ *
+ * // Check results
+ * for (const result of results) {
+ *   if (result.error) {
+ *     console.error(`Failed to load ${result.code}: ${result.error}`);
+ *   }
+ * }
+ * ```
+ */
+declare function loadLanguages(codes: string[], options?: Omit<LoadLanguageOptions, 'module'>): Promise<LoadLanguageResult[]>;
+/**
+ * Check if a language can be loaded (is supported).
+ */
+declare function canLoadLanguage(code: string): boolean;
+/**
+ * Get list of languages that are currently loaded.
+ */
+declare function getLoadedLanguages(): string[];
+/**
+ * Get list of languages that are not yet loaded.
+ */
+declare function getUnloadedLanguages(): string[];
+
+/**
+ * Confidence Calculator Utility
+ *
+ * Provides standalone confidence calculation for translations.
+ * Exposes the pattern matcher's confidence scoring for use in scripts.
+ */
+
+interface ConfidenceResult {
+    /** Confidence score from 0-1 */
+    confidence: number;
+    /** Whether the input parsed successfully */
+    parseSuccess: boolean;
+    /** Pattern ID that matched, if any */
+    patternId?: string;
+    /** The action type (command) that was parsed */
+    action?: ActionType;
+    /** Number of tokens consumed during matching */
+    tokensConsumed?: number;
+    /** Error message if parsing failed */
+    error?: string;
+}
+/**
+ * Calculate confidence score for a hyperscript translation.
+ *
+ * Uses the pattern matcher to determine how well the input matches
+ * available patterns for the given language.
+ *
+ * @param hyperscript - The hyperscript code to analyze
+ * @param language - The language code (e.g., 'ja', 'es', 'en')
+ * @returns Confidence result with score and match details
+ */
+declare function calculateTranslationConfidence(hyperscript: string, language: string): ConfidenceResult;
+interface ParseWithConfidenceResult {
+    node: SemanticNode | null;
+    confidence: number;
+    error: string | undefined;
+}
+/**
+ * Calculate confidence and parse to a semantic node in one call.
+ * Returns both the parsed node and the confidence score.
+ */
+declare function parseWithConfidence(hyperscript: string, language: string): ParseWithConfidenceResult;
+
+/**
+ * Semantic-First Multilingual Hyperscript
+ *
+ * This package provides a semantic-first approach to multilingual hyperscript,
+ * enabling true native-language syntax that feels natural to speakers of any language.
+ *
+ * Key Features:
+ * - Parse hyperscript from any supported language (en, ja, ar, es)
+ * - Translate between languages while preserving semantic meaning
+ * - Explicit mode syntax for learning and debugging
+ * - Bidirectional conversion: natural ↔ explicit ↔ natural
+ *
+ * @example
+ * // Parse Japanese to semantic
+ * const node = parse('#button の .active を 切り替え', 'ja');
+ *
+ * // Render in English
+ * const english = render(node, 'en');
+ * // → 'toggle .active on #button'
+ *
+ * // Render in explicit mode
+ * const explicit = renderExplicit(node);
+ * // → '[toggle patient:.active destination:#button]'
+ *
+ * // Translate directly
+ * const arabic = translate('toggle .active on #button', 'en', 'ar');
+ * // → 'بدّل .active على #button'
+ */
+
+/**
+ * Get all supported languages for parsing.
+ */
+declare function getSupportedLanguages(): string[];
+/**
+ * Version of the semantic package.
+ */
+declare const VERSION = "0.1.0";
+
+export { ASTBuilder, type ASTBuilderOptions, type ASTNode, type ActionType, type AnalysisConfig, type AnalysisResult, type AnalysisWarning, type BlockNode, type BuildASTResult, type CacheStats, type CommandCategory, type CommandMapper, type CommandMapperResult, type CommandNode, type CommandSchema, type CommandSemanticNode, type CommandSequenceNode, type CompoundSemanticNode, type ConditionalNode, type ConditionalSemanticNode, type ConfidenceResult, DEFAULT_CONFIDENCE_THRESHOLD, type EventHandlerNode, type EventHandlerSemanticNode, type EventModifiers, type ExpressionValue, type ExtractionRule, type ExtractionRules, type GeneratorConfig, type GroupPatternToken, HIGH_CONFIDENCE_THRESHOLD, type KeywordTranslation$1 as KeywordTranslation, SUPPORTED_LANGUAGES as LAZY_LOAD_LANGUAGES, type LanguageModule, type LanguagePattern, type LanguageProfile, type LanguageToken, type LanguageTokenizer, type LiteralPatternToken, type LiteralValue, type LoadLanguageOptions, type LoadLanguageResult, type LoopSemanticNode, type LoopVariant, type MarkingStrategy$1 as MarkingStrategy, type ParseWithConfidenceResult, type PatternConstraints, type PatternMatchError, type PatternMatchResult, PatternMatcher$1 as PatternMatcher, type PatternTemplate, type PatternToken, type PossessiveConfig, type PropertyPathValue, type ReferenceValue, type RoleMarker, type RolePatternToken, type RoleSpec, type SelectorValue, type SemanticAnalysisResult, type SemanticAnalyzer, SemanticAnalyzerImpl, SemanticCache, type SemanticCacheConfig, type SemanticMetadata, type SemanticNode, type SemanticParser, SemanticParserImpl, type SemanticRenderer, SemanticRendererImpl, type SemanticRole, type SemanticValue, type SourcePosition, type StreamMark, type TokenKind, type TokenStream, TokenStreamImpl, type TokenizationConfig$1 as TokenizationConfig, type GrammarRule as UnifiedGrammarRule, type UnifiedLanguageProfile, type PatternMatcher as UnifiedPatternMatcher, type PatternTransform as UnifiedPatternTransform, type UnifiedRoleMarker, VERSION, type ValidationError, type ValidationResult, type VerbConfig$1 as VerbConfig, type VerbForm, type WarningCode, type WarningSeverity, type WordOrder, addSchema, analyze, analyzeAll, analyzeMultiple, appendSchema, arabicProfile, arabicTokenizer, buildAST, calculateTranslationConfidence, canLoadLanguage, canParse, checkAccessibility, checkPerformance, checkSchema, chineseProfile, chineseTokenizer, commandSchemas, convertExpression, convertLiteral, convertPropertyPath, convertReference, convertSelector, convertValue, createCommandNode, createCompoundNode, createConditionalNode, createEventHandler, createLiteral, createLoopNode, createPropertyPath, createReference, createSelector, createSemanticAnalyzer, createSemanticCache, decrementSchema, devModeAnalyze, disableDevMode, enableDevMode, englishProfile, englishTokenizer, eventNameTranslations, fetchSchema, frenchProfile, fromExplicit, generateAllPatterns, generatePattern, generatePatternVariants, generatePatternsForCommand, generatePatternsForLanguage, generateSimplePattern, germanProfile, getAllPatterns, getAllTranslations, getCommandMapper, getCommandType, getDefinedSchemas, getDevModeConfig, getEventHandlerPatternsForLanguage, getSupportedLanguages$1 as getGeneratorLanguages, getGeneratorSummary, getLoadedLanguages, getPatternById, getPatternStats, getPatternsForLanguage, getPatternsForLanguageAndCommand, getProfile, getPutPatternsForLanguage, getRegisteredLanguages, getRegisteredMappers, getSchema$1 as getSchema, getSchemasByCategory, getSupportedCommands, getSupportedLanguages, getSupportedLanguages$3 as getSupportedPatternLanguages, getSupportedLanguages$2 as getSupportedTokenizerLanguages, getTogglePatternsForLanguage, getTokenizer, getUnloadedLanguages, getSchema as getValidatorSchema, hideSchema, incrementSchema, indonesianProfile, isDevModeEnabled, isExplicitSyntax, isLanguageSupported as isGeneratorLanguageSupported, isLanguageSupported$1 as isLanguageSupported, isUnifiedProfile, japaneseProfile, japaneseTokenizer, koreanProfile, koreanTokenizer, languageProfiles, loadLanguage, loadLanguages, markingStrategyToAdpositionType, matchBest, matchPattern, normalizeEventName, onSchema, parse, parseAny, parseExplicit, parseWithConfidence, patternMatcher, portugueseProfile, prependSchema, putSchema, quechuaProfile, registerCommandMapper, registerSchema, registerTokenizer, removeSchema, render, renderExplicit, rolesToCommandArgs, roundTrip, schemaRegistry, semanticCache, semanticParser, semanticRenderer, setSchema, shouldUseSemanticResult, showSchema, spanishProfile, spanishTokenizer, swahiliProfile, toExplicit, toGrammaticalMarker, toI18nProfile, toggleSchema, tokenize, translate, triggerSchema, tryGetProfile, turkishProfile, turkishTokenizer, validateAndAdjustConfidence, validateLanguageKeywords, validateSemanticResult, validateTranslation, waitSchema, withCache };