@lokascript/semantic 1.2.1 → 2.0.0

package/dist/parser/pattern-matcher.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Pattern Matcher
+ *
+ * Matches tokenized input against language patterns to extract semantic roles.
+ * This is the core algorithm for multilingual parsing.
+ */
+import type { LanguagePattern, PatternMatchResult, TokenStream } from '../types';
+export declare class PatternMatcher {
+    /** 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 static values and defaults 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): import('../types').EventModifiers | undefined;
+}
+/**
+ * Singleton pattern matcher instance.
+ */
+export declare const patternMatcher: PatternMatcher;
+/**
+ * Match tokens against a pattern.
+ */
+export declare function matchPattern(tokens: TokenStream, pattern: LanguagePattern): PatternMatchResult | null;
+/**
+ * Match tokens against multiple patterns, return best match.
+ */
+export declare function matchBest(tokens: TokenStream, patterns: LanguagePattern[]): PatternMatchResult | null;
+//# sourceMappingURL=pattern-matcher.d.ts.map

package/dist/parser/pattern-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-matcher.d.ts","sourceRoot":"","sources":["../../src/parser/pattern-matcher.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,eAAe,EAEf,kBAAkB,EAIlB,WAAW,EAEZ,MAAM,UAAU,CAAC;AAiBlB,qBAAa,cAAc;IACzB,6DAA6D;IAC7D,OAAO,CAAC,cAAc,CAA8B;IAEpD;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,GAAG,kBAAkB,GAAG,IAAI;IAiCtF;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,eAAe,EAAE,GAAG,kBAAkB,GAAG,IAAI;IAmCtF;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoC1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAoBzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAoCzB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAuGtB;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IA4EpC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAyC3B;;;;OAIG;IACH,OAAO,CAAC,4BAA4B;IAwDpC;;;;OAIG;IACH,OAAO,CAAC,gCAAgC;IAmGxC;;;;OAIG;IACH,OAAO,CAAC,oCAAoC;IAoC5C;;;;;;;;OAQG;IACH,OAAO,CAAC,kCAAkC;IAwC1C;;OAEG;IACH,OAAO,CAAC,eAAe;IA0BvB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAwBpB;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,mBAAmB,CAAa;IAMxC,kEAAkE;IAClE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAM;IAEhD,kDAAkD;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAM;IAE7C;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAyC5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAqCzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;;;;;;;;OASG;IACH,OAAO,CAAC,mBAAmB;IA8D3B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,2BAA2B;IAwDnC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,+BAA+B;IA0DvC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAA+B;IAE1E;;;OAGG;IACH,OAAO,CAAC,cAAc;IA+BtB;;;;;;OAMG;IACH,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,UAAU,EAAE,cAAc,GAAG,SAAS;CA0D1F;AAMD;;GAEG;AACH,eAAO,MAAM,cAAc,gBAAuB,CAAC;AAEnD;;GAEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,eAAe,GACvB,kBAAkB,GAAG,IAAI,CAE3B;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,eAAe,EAAE,GAC1B,kBAAkB,GAAG,IAAI,CAE3B"}

package/dist/parser/semantic-parser.d.ts

@@ -0,0 +1,238 @@
+/**
+ * Semantic Parser
+ *
+ * The main parser that converts natural language hyperscript to semantic nodes.
+ * Combines tokenization and pattern matching.
+ */
+import type { SemanticNode, SemanticParser as ISemanticParser, ActionType } from '../types';
+export declare class SemanticParserImpl implements ISemanticParser {
+    /**
+     * 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;
+    /**
+     * Build a lookup from native verb keywords to action names for a language profile.
+     */
+    private static buildVerbLookup;
+    /**
+     * Build a lookup from role marker strings to role names.
+     */
+    private static buildMarkerToRoleLookup;
+    /**
+     * Parse an SOV clause by finding command verbs and extracting roles from surrounding tokens.
+     *
+     * The grammar transformer often produces "verb-in-middle" order for two-role commands:
+     *   "[role1] [marker1] [verb] [role2] [marker2]"
+     *
+     * This method:
+     * 1. Scans for recognized command verbs in the token stream
+     * 2. For each verb, extracts pre-verb and post-verb tokens as roles
+     * 3. Uses marker tokens to determine which semantic role each value belongs to
+     */
+    private parseSOVClauseByVerbAnchoring;
+    /**
+     * Extract semantic roles from pre-verb and post-verb token groups using marker analysis.
+     *
+     * Recognizes patterns like:
+     *   pre-verb:  [expr] [を]   → patient (obj marker)
+     *   post-verb: [expr] [に]   → destination (to marker)
+     *   pre-verb:  [expr] [から] → source (from marker)
+     */
+    private extractRolesFromMarkedTokens;
+    /**
+     * Map a marker-derived role name to the appropriate semantic role for a command,
+     * handling cases where marker roles overlap (e.g., both patient and destination
+     * use similar particles in some languages).
+     */
+    private mapRoleForCommand;
+    /**
+     * Convert a sequence of tokens into a single SemanticValue.
+     */
+    private tokensToSemanticValue;
+    /**
+     * Convert a single token to a SemanticValue.
+     */
+    private tokenToSemanticValue;
+    /**
+     * Parse body commands with support for grammar-transformed patterns.
+     * Used after a grammar-transformed pattern with continuation marker.
+     */
+    private parseBodyWithGrammarPatterns;
+    /**
+     * Try parsing input as a multi-command compound (no event wrapper).
+     * Handles standalone command sequences separated by then-keywords.
+     * Used as a last resort when no event trigger is detected.
+     */
+    private tryCompoundCommandParsing;
+    /**
+     * Known event names for detection (common DOM events).
+     */
+    private static readonly KNOWN_EVENTS;
+    /**
+     * SOV event marker particles per language (postpositions that mark the event role).
+     * Korean has no event marker particle -- the event keyword stands alone.
+     */
+    private static readonly SOV_EVENT_MARKERS;
+    /**
+     * SOV source markers ("from" equivalents) and window tokens per language.
+     * Used to strip "from window/elsewhere" event modifiers.
+     */
+    private static readonly SOV_SOURCE_MARKERS;
+    /**
+     * Try to extract an embedded event trigger from SOV grammar-transformed text.
+     *
+     * SOV languages embed the event trigger within the sentence:
+     *   JA: ".active を クリック で 切り替え"  (patient event-marker action)
+     *   KO: ".active 를 클릭 에 토글"          (patient event-marker action)
+     *   TR: ".active i tıklama de değiştir"   (patient event-marker action)
+     *
+     * This method detects the [event_keyword] [event_particle] pair,
+     * removes those tokens, and parses the remaining tokens as command body.
+     */
+    private trySOVEventExtraction;
+    /**
+     * 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;
+    /**
+     * Standalone event modifier keywords (loanwords used across languages).
+     * Pattern: `[modifier] [preposition?] [duration?] [rest...]`
+     */
+    private static readonly STANDALONE_MODIFIERS;
+    /**
+     * "Or" conjunction keywords across languages for multiple events.
+     * Maps lowercase keyword → true. Used to detect "click or keydown" patterns.
+     */
+    private static readonly OR_KEYWORDS;
+    /**
+     * Extract standalone event modifiers from the beginning of input.
+     * Returns the modifiers (if any) and the remaining input string.
+     */
+    private extractStandaloneModifiers;
+    /**
+     * Apply standalone modifiers to an event handler node.
+     */
+    private applyModifiers;
+    /**
+     * Extract "or" conjunction events from the token stream.
+     * If the next tokens follow the pattern "or EVENT [or EVENT ...]",
+     * consume them and return the additional event values.
+     *
+     * The token stream is advanced past any consumed "or EVENT" tokens.
+     */
+    private extractOrConjunctionEvents;
+}
+/**
+ * Singleton parser instance.
+ */
+export declare const semanticParser: SemanticParserImpl;
+/**
+ * Parse input in the specified language.
+ */
+export declare function parse(input: string, language: string): SemanticNode;
+/**
+ * Check if input can be parsed.
+ */
+export declare function canParse(input: string, language: string): boolean;
+/**
+ * Parse and return command type if parseable.
+ */
+export declare function getCommandType(input: string, language: string): ActionType | null;
+/**
+ * Tokenize input for a specific language.
+ */
+export declare function tokenize(input: string, language: string): import("../types").TokenStream;
+/**
+ * Get list of supported languages.
+ */
+export declare function getSupportedLanguages(): string[];
+/**
+ * Translate hyperscript between languages.
+ */
+export declare function translate(input: string, sourceLang: string, targetLang: string): string;
+/**
+ * Get translations for all supported languages.
+ */
+export declare function getAllTranslations(input: string, sourceLang: string): Record<string, string>;
+/**
+ * Create a semantic analyzer for parsing with confidence scores.
+ */
+export declare function createSemanticAnalyzer(): {
+    analyze(input: string, language: string): {
+        node: SemanticNode;
+        confidence: number;
+        success: boolean;
+        error?: never;
+    } | {
+        node: null;
+        confidence: number;
+        success: boolean;
+        error: unknown;
+    };
+};
+/**
+ * Render a SemanticNode to hyperscript in a specific language.
+ */
+export declare function render(node: SemanticNode, language: string): string;
+/**
+ * Render a SemanticNode in explicit syntax format.
+ */
+export declare function renderExplicit(node: SemanticNode): string;
+/**
+ * Parse explicit syntax format.
+ */
+export declare function parseExplicit(input: string): SemanticNode;
+/**
+ * Convert natural language to explicit syntax.
+ */
+export declare function toExplicit(input: string, language: string): string;
+/**
+ * Convert explicit syntax to natural language.
+ */
+export declare function fromExplicit(input: string, targetLang: string): string;
+/**
+ * Round-trip conversion for testing.
+ */
+export declare function roundTrip(input: string, language: string): string;
+//# sourceMappingURL=semantic-parser.d.ts.map

package/dist/parser/semantic-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-parser.d.ts","sourceRoot":"","sources":["../../src/parser/semantic-parser.ts"],"names":[],"mappings":"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"}

package/dist/parser/utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parser Utilities
+ *
+ * Shared utilities for pattern-generator and pattern-matcher.
+ */
+export { ROLE_PRIORITY, getRolePriority, sortRolesByPriority, sortRolesByWordOrder, type WordOrder, type RoleWithPosition, } from './role-positioning';
+export { resolveMarkerForRole, getAllMarkersForRole, getDefaultRoleMarker, type RoleSpecWithMarker, type ResolvedMarker, } from './marker-resolution';
+export { isTypeCompatible, validateValueType, isCSSSelector, isClassName, isIdSelector, isCSSPropertyRef, isNumericValue, isPropertyName, isVariableRef, isBuiltInReference, } from './type-validation';
+//# sourceMappingURL=index.d.ts.map

package/dist/parser/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/parser/utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,KAAK,SAAS,EACd,KAAK,gBAAgB,GACtB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,kBAAkB,EACvB,KAAK,cAAc,GACpB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,aAAa,EACb,kBAAkB,GACnB,MAAM,mBAAmB,CAAC"}

package/dist/parser/utils/marker-resolution.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Marker Resolution Utility
+ *
+ * Shared utilities for resolving role markers from language profiles.
+ * Used by pattern-generator to build tokens and extraction rules.
+ */
+import type { SemanticRole } from '../../types';
+import type { LanguageProfile, RoleMarker } from '../../generators/language-profiles';
+/**
+ * Minimum interface for role specs that can have marker resolution.
+ * Compatible with the RoleSpec type from command-schemas.
+ */
+export interface RoleSpecWithMarker {
+    role: SemanticRole;
+    markerOverride?: Record<string, string | undefined>;
+}
+/**
+ * Resolved marker information for a role.
+ */
+export interface ResolvedMarker {
+    /** Primary marker string (may be empty string for no marker) */
+    primary: string;
+    /** Alternative markers */
+    alternatives?: string[];
+    /** Position relative to role value */
+    position: 'before' | 'after';
+    /** Whether this is an override marker */
+    isOverride: boolean;
+}
+/**
+ * Resolve the marker for a role in a specific language.
+ *
+ * Checks for command-specific marker overrides first,
+ * then falls back to the default marker from the language profile.
+ *
+ * @param roleSpec Role specification with optional override
+ * @param profile Language profile with role markers
+ * @returns Resolved marker info, or null if no marker
+ */
+export declare function resolveMarkerForRole(roleSpec: RoleSpecWithMarker, profile: LanguageProfile): ResolvedMarker | null;
+/**
+ * Get all markers (primary + alternatives) for a role.
+ *
+ * @param roleSpec Role specification
+ * @param profile Language profile
+ * @returns Array of marker strings, or empty array if no markers
+ */
+export declare function getAllMarkersForRole(roleSpec: RoleSpecWithMarker, profile: LanguageProfile): string[];
+/**
+ * Get the default role marker from a language profile.
+ *
+ * @param profile Language profile
+ * @param role Semantic role
+ * @returns Role marker or undefined
+ */
+export declare function getDefaultRoleMarker(profile: LanguageProfile, role: SemanticRole): RoleMarker | undefined;
+//# sourceMappingURL=marker-resolution.d.ts.map

package/dist/parser/utils/marker-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker-resolution.d.ts","sourceRoot":"","sources":["../../../src/parser/utils/marker-resolution.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAEtF;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,YAAY,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,0BAA0B;IAC1B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,sCAAsC;IACtC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC;IAC7B,yCAAyC;IACzC,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,eAAe,GACvB,cAAc,GAAG,IAAI,CA2BvB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,eAAe,GACvB,MAAM,EAAE,CAWV;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,YAAY,GACjB,UAAU,GAAG,SAAS,CAExB"}

package/dist/parser/utils/possessive-keywords.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Possessive Keywords Utility
+ *
+ * Provides functions to look up possessive keywords from language profiles.
+ * Used by pattern-matcher to recognize possessive expressions like "my value".
+ */
+import type { LanguageProfile } from '../../generators/profiles/types';
+/**
+ * Get the reference for a possessive keyword from a language profile.
+ *
+ * @param profile Language profile
+ * @param keyword Possessive keyword (e.g., 'my', 'your', 'its')
+ * @returns The reference (e.g., 'me', 'you', 'it') or undefined if not found
+ */
+export declare function getPossessiveReference(profile: LanguageProfile, keyword: string): string | undefined;
+/**
+ * Check if a keyword is a possessive keyword in the given profile.
+ *
+ * @param profile Language profile
+ * @param keyword Keyword to check
+ * @returns True if the keyword is a possessive keyword
+ */
+export declare function isPossessiveKeyword(profile: LanguageProfile, keyword: string): boolean;
+/**
+ * Get all possessive keywords from a language profile.
+ *
+ * @param profile Language profile
+ * @returns Record of possessive keywords to references, or empty object
+ */
+export declare function getAllPossessiveKeywords(profile: LanguageProfile): Record<string, string>;
+//# sourceMappingURL=possessive-keywords.d.ts.map

package/dist/parser/utils/possessive-keywords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"possessive-keywords.d.ts","sourceRoot":"","sources":["../../../src/parser/utils/possessive-keywords.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAEtF;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEzF"}

package/dist/parser/utils/role-positioning.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Role Positioning Utility
+ *
+ * Shared utilities for sorting and positioning semantic roles based on word order.
+ * Used by pattern-generator and pattern-matcher to ensure consistent behavior.
+ */
+import type { SemanticRole } from '../../types';
+import type { WordOrder } from '../../generators/profiles/types';
+/**
+ * Priority order for semantic roles used in pattern matching.
+ * Lower number = higher priority (comes first in pattern).
+ * Only includes roles commonly used in patterns.
+ */
+export declare const ROLE_PRIORITY: Partial<Record<SemanticRole, number>>;
+/**
+ * Get the priority of a semantic role.
+ * Returns 99 for unknown/unlisted roles.
+ */
+export declare function getRolePriority(role: SemanticRole): number;
+/**
+ * Sort semantic roles by their priority.
+ * Patient comes first, then destination, source, etc.
+ */
+export declare function sortRolesByPriority(roles: SemanticRole[]): SemanticRole[];
+export type { WordOrder };
+/**
+ * Minimum interface for roles that can be sorted by position.
+ */
+export interface RoleWithPosition {
+    role: SemanticRole;
+    sovPosition?: number;
+    svoPosition?: number;
+}
+/**
+ * Sort roles by their position for a given word order.
+ *
+ * @param roles Array of role specs with position info
+ * @param wordOrder The word order to use (SVO, SOV, VSO)
+ * @returns Sorted array of roles
+ */
+export declare function sortRolesByWordOrder<T extends RoleWithPosition>(roles: readonly T[], wordOrder: WordOrder): T[];
+//# sourceMappingURL=role-positioning.d.ts.map

package/dist/parser/utils/role-positioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-positioning.d.ts","sourceRoot":"","sources":["../../../src/parser/utils/role-positioning.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAO/D,CAAC;AAEF;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAE1D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAEzE;AAGD,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,YAAY,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,gBAAgB,EAC7D,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,SAAS,EAAE,SAAS,GACnB,CAAC,EAAE,CAOL"}

package/dist/parser/utils/type-validation.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Type Validation Utility
+ *
+ * Shared utilities for validating semantic value types against expected types.
+ * Used by pattern-matcher to validate captured role values.
+ */
+import type { SemanticValue } from '../../types';
+/**
+ * Semantic value type strings.
+ */
+export type SemanticValueType = SemanticValue['type'];
+/**
+ * Check if a value type matches any of the expected types.
+ *
+ * The 'expression' type is treated as a wildcard that matches any value.
+ * The 'property-path' type is compatible with selector, reference, and expression.
+ *
+ * @param actualType The actual type of the value
+ * @param expectedTypes Array of expected types
+ * @returns True if the type is compatible
+ */
+export declare function isTypeCompatible(actualType: SemanticValueType | string, expectedTypes: (SemanticValueType | string)[]): boolean;
+/**
+ * Validate a semantic value against expected types.
+ *
+ * @param value The semantic value to validate
+ * @param expectedTypes Array of expected types (empty means any type is valid)
+ * @returns True if the value type is valid
+ */
+export declare function validateValueType(value: SemanticValue, expectedTypes?: (SemanticValueType | string)[]): boolean;
+/**
+ * Check if a value is a CSS selector.
+ */
+export declare function isCSSSelector(value: string): boolean;
+/**
+ * Check if a value is a class name (starts with .).
+ */
+export declare function isClassName(value: string): boolean;
+/**
+ * Check if a value is an ID selector (starts with #).
+ */
+export declare function isIdSelector(value: string): boolean;
+/**
+ * Check if a value is a CSS property reference (starts with *).
+ */
+export declare function isCSSPropertyRef(value: string): boolean;
+/**
+ * Check if a value is a numeric value.
+ */
+export declare function isNumericValue(value: string): boolean;
+/**
+ * Check if a value is a property name (identifier-like).
+ */
+export declare function isPropertyName(value: string): boolean;
+/**
+ * Check if a value is a variable reference (starts with :).
+ */
+export declare function isVariableRef(value: string): boolean;
+/**
+ * Check if a value is a built-in reference (me, you, it, etc.).
+ */
+export declare function isBuiltInReference(value: string): boolean;
+//# sourceMappingURL=type-validation.d.ts.map

package/dist/parser/utils/type-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-validation.d.ts","sourceRoot":"","sources":["../../../src/parser/utils/type-validation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;AAEtD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,iBAAiB,GAAG,MAAM,EACtC,aAAa,EAAE,CAAC,iBAAiB,GAAG,MAAM,CAAC,EAAE,GAC5C,OAAO,CAsBT;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,aAAa,EACpB,aAAa,CAAC,EAAE,CAAC,iBAAiB,GAAG,MAAM,CAAC,EAAE,GAC7C,OAAO,CAMT;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAUrD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGzD"}