semantic-primitives 0.1.0

package/dist/types/record/record.d.ts

@@ -0,0 +1,179 @@
+/**
+ * SemanticRecord
+ * A Record type with LLM-powered semantic understanding
+ *
+ * Implements shared interfaces:
+ * - Semantic<Record<K, V>> - Base semantic wrapper
+ * - Comparable<SemanticRecord<K, V>> - Semantic equality comparison
+ * - Validatable - Validation against semantic rules
+ * - Summarizable - Content summarization
+ * - SemanticAccessible - Semantic key lookup
+ * - SemanticGroupable - Semantic grouping
+ * - SemanticFilterable - Semantic filtering
+ * - PurposeInferable - Purpose inference
+ */
+import type { LLMClient } from '../../llm/client.ts';
+import type { SemanticGetResult, MissingSuggestion } from '../../shared/types.ts';
+import type { Semantic, Comparable } from '../../shared/interfaces.ts';
+export type { SemanticGetResult, MissingSuggestion, } from '../../shared/types.ts';
+/** Result of semantic equality comparison for records */
+export interface RecordSemanticEqualsResult {
+    equivalent: boolean;
+    keyMappings?: Record<string, string>;
+    confidence: number;
+}
+/** Result of key validation */
+export interface ValidateKeysResult {
+    valid: boolean;
+    invalidKeys: string[];
+    reasons: string[];
+}
+/** Invalid entry for value validation */
+export interface InvalidEntry<K, V> {
+    key: K;
+    value: V;
+    reason: string;
+}
+/** Result of value validation */
+export interface ValidateValuesResult<K, V> {
+    valid: boolean;
+    invalidEntries: InvalidEntry<K, V>[];
+}
+/** Result of purpose inference for records */
+export interface RecordInferPurposeResult {
+    purpose: string;
+    keyType: string;
+    valueType: string;
+    confidence: number;
+}
+/**
+ * SemanticRecord - Record with LLM-powered semantic understanding
+ *
+ * Unlike traditional records that only support exact key matching,
+ * semantic records can look up values using natural language queries,
+ * find semantically equivalent keys, and understand key-value relationships.
+ *
+ * @template K - The type of keys in the record (extends string | number | symbol)
+ * @template V - The type of values in the record
+ */
+export declare class SemanticRecord<K extends string | number | symbol, V> implements Semantic<Record<K, V>>, Comparable<SemanticRecord<K, V> | Record<K, V>, RecordSemanticEqualsResult> {
+    private readonly internalRecord;
+    private readonly client;
+    private readonly context?;
+    private constructor();
+    /**
+     * Create a SemanticRecord from an existing Record object
+     */
+    static from<K extends string | number | symbol, V>(record: Record<K, V>, context?: string, client?: LLMClient): SemanticRecord<K, V>;
+    /**
+     * Create an empty SemanticRecord
+     */
+    static empty<K extends string | number | symbol, V>(client?: LLMClient): SemanticRecord<K, V>;
+    /**
+     * Get the underlying Record value
+     */
+    valueOf(): Record<K, V>;
+    /**
+     * Get all keys
+     */
+    keys(): K[];
+    /**
+     * Get all values
+     */
+    values(): V[];
+    /**
+     * Get all entries
+     */
+    entries(): [K, V][];
+    /**
+     * Get the number of entries
+     */
+    get size(): number;
+    /**
+     * Get a value by exact key
+     */
+    get(key: K): V | undefined;
+    /**
+     * Check if record has exact key
+     */
+    has(key: K): boolean;
+    /**
+     * Get a value using semantic key matching.
+     * Finds the key that best matches the query, not just exact matches.
+     *
+     * @param query - Key or semantic query
+     * @param context - Optional context for matching
+     * @returns Value if found with match confidence
+     */
+    semanticGet(query: string, context?: Record<string, unknown>): Promise<SemanticGetResult<K, V>>;
+    /**
+     * Check if two records are semantically equivalent.
+     *
+     * @param other - Record to compare with
+     * @returns Equivalence result with key mappings
+     */
+    semanticallyEquals(other: SemanticRecord<K, V> | Record<K, V>): Promise<RecordSemanticEqualsResult>;
+    /**
+     * Validate keys against semantic rules.
+     *
+     * @param rules - Validation rules for keys
+     * @returns Validation result
+     */
+    validateKeys(rules: string[]): Promise<ValidateKeysResult>;
+    /**
+     * Validate values against semantic rules.
+     *
+     * @param rules - Validation rules for values
+     * @returns Validation result
+     */
+    validateValues(rules: string[]): Promise<ValidateValuesResult<K, V>>;
+    /**
+     * Infer the semantic purpose of this record.
+     *
+     * @returns Inferred purpose with key and value types
+     */
+    inferPurpose(): Promise<RecordInferPurposeResult>;
+    /**
+     * Filter entries by semantic criteria.
+     *
+     * @param criteria - Natural language filter
+     * @returns Filtered record
+     */
+    semanticFilter(criteria: string): Promise<SemanticRecord<K, V>>;
+    /**
+     * Suggest missing keys based on patterns.
+     *
+     * @returns Suggested keys with rationale
+     */
+    suggestMissingKeys(): Promise<MissingSuggestion[]>;
+    /**
+     * Group entries by semantic criteria.
+     *
+     * @param criteria - Grouping criteria
+     * @returns Object of groups
+     */
+    groupBy(criteria: string): Promise<Record<string, SemanticRecord<K, V>>>;
+    /**
+     * Summarize the record contents.
+     *
+     * @returns Human-readable summary
+     */
+    summarize(): Promise<string>;
+    /**
+     * Convert to string representation
+     */
+    toString(): string;
+    /**
+     * Convert to JSON
+     */
+    toJSON(): Record<K, V>;
+    /**
+     * Iterator support
+     */
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    /**
+     * Execute a function for each entry
+     */
+    forEach(callback: (value: V, key: K) => void): void;
+}
+//# sourceMappingURL=record.d.ts.map

package/dist/types/record/record.d.ts.map

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

package/dist/types/regexp/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * SemanticRegExp module
+ * Exports the SemanticRegExp class and related types
+ */
+export { SemanticRegExp, type FromOptions, type TestWithExplanationResult, type SimplifyResult } from './regexp.ts';
+export type { SemanticEqualsResult, ImprovementSuggestion, RegExpTestCases, ValidateResultWithWarnings, RelatedSuggestion, InferTypeResult, } from '../../shared/types.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/regexp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/regexp/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,yBAAyB,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAGpH,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,0BAA0B,EAC1B,iBAAiB,EACjB,eAAe,GAChB,MAAM,uBAAuB,CAAC"}

package/dist/types/regexp/prompts.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Prompts for SemanticRegExp LLM operations
+ * These prompts enable semantic understanding and manipulation of regular expressions
+ */
+/**
+ * System prompt for regex semantic operations
+ */
+export declare const REGEXP_SYSTEM_PROMPT = "You are an expert regular expression analyzer and generator. Your task is to help users understand, create, and improve regular expressions.\n\nYou must respond with valid JSON only, no additional text, markdown formatting, or code blocks.\n\nGuidelines:\n- Provide accurate regex patterns that work in JavaScript/TypeScript\n- Consider edge cases and common variations\n- Be precise about what patterns match and don't match\n- Provide confidence scores from 0.0 to 1.0\n- When generating regex, prefer readability over cleverness when possible";
+/**
+ * Prompt for creating regex from natural language description
+ */
+export declare function createFromPrompt(description: string, options?: {
+    flags?: string;
+    strict?: boolean;
+}): string;
+/**
+ * Prompt for semantic equality comparison between regexes
+ */
+export declare function createSemanticallyEqualsPrompt(pattern1: string, flags1: string, pattern2: string, flags2: string, testStrings?: string[]): string;
+/**
+ * Prompt for explaining what a regex matches
+ */
+export declare function createExplainPrompt(pattern: string, flags: string): string;
+/**
+ * Prompt for testing a string with explanation
+ */
+export declare function createTestWithExplanationPrompt(pattern: string, flags: string, input: string): string;
+/**
+ * Prompt for suggesting regex improvements
+ */
+export declare function createSuggestImprovementsPrompt(pattern: string, flags: string): string;
+/**
+ * Prompt for generating test cases
+ */
+export declare function createGenerateTestCasesPrompt(pattern: string, flags: string): string;
+/**
+ * Prompt for validating regex for issues
+ */
+export declare function createValidatePrompt(pattern: string, flags: string): string;
+/**
+ * Prompt for converting regex to readable format
+ */
+export declare function createToReadablePrompt(pattern: string, flags: string): string;
+/**
+ * Prompt for suggesting related patterns
+ */
+export declare function createSuggestRelatedPrompt(pattern: string, flags: string): string;
+/**
+ * Prompt for inferring data type matched by regex
+ */
+export declare function createInferDataTypePrompt(pattern: string, flags: string): string;
+/**
+ * Prompt for simplifying regex
+ */
+export declare function createSimplifyPrompt(pattern: string, flags: string): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/types/regexp/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/types/regexp/prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB,siBASyC,CAAC;AAE3E;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAC7C,MAAM,CAsBR;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,EAAE,GACrB,MAAM,CA4BR;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAmB1E;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,MAAM,CAuBR;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,MAAM,CAgBR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAoB3E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAgB7E;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,MAAM,CAqBR;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,MAAM,CAgBR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAqB3E"}

package/dist/types/regexp/regexp.d.ts

@@ -0,0 +1,160 @@
+/**
+ * SemanticRegExp
+ * A RegExp type with LLM-powered semantic understanding
+ *
+ * Provides semantic operations on regular expressions:
+ * - Natural language pattern creation
+ * - Human-readable explanation
+ * - Test case generation
+ * - Pattern validation and improvement suggestions
+ * - Data type inference
+ */
+import type { LLMClient } from '../../llm/client.ts';
+import type { SemanticEqualsResult, ImprovementSuggestion, RegExpTestCases, ValidateResultWithWarnings, RelatedSuggestion, InferTypeResult } from '../../shared/types.ts';
+import type { Semantic, Explainable, TypeInferable } from '../../shared/interfaces.ts';
+/** Options for creating regex from natural language */
+export interface FromOptions {
+    flags?: string;
+    strict?: boolean;
+}
+/** Result of testWithExplanation */
+export interface TestWithExplanationResult {
+    matches: boolean;
+    reason: string;
+    matchedPart?: string;
+}
+/** Result of simplify operation */
+export interface SimplifyResult {
+    regex: SemanticRegExp;
+    explanation: string;
+}
+/**
+ * SemanticRegExp - Regular expression with LLM-powered semantic understanding
+ *
+ * Extends native RegExp functionality with semantic operations like
+ * natural language pattern creation, explanation, and intelligent analysis.
+ */
+export declare class SemanticRegExp implements Semantic<RegExp>, Explainable, TypeInferable {
+    private readonly regex;
+    private readonly client;
+    private constructor();
+    /**
+     * Create a SemanticRegExp from an existing RegExp
+     */
+    static fromRegExp(regex: RegExp, client?: LLMClient): SemanticRegExp;
+    /**
+     * Create a SemanticRegExp from a pattern string
+     */
+    static fromPattern(pattern: string, flags?: string, client?: LLMClient): SemanticRegExp;
+    /**
+     * Create a regex from natural language description using LLM
+     *
+     * @param description - Natural language pattern description
+     * @param options - Creation options
+     * @param client - Optional LLM client
+     * @returns SemanticRegExp instance
+     *
+     * @example
+     * SemanticRegExp.from("email addresses")
+     * SemanticRegExp.from("phone numbers in US format")
+     * SemanticRegExp.from("URLs starting with https")
+     */
+    static from(description: string, options?: FromOptions, client?: LLMClient): Promise<SemanticRegExp>;
+    /**
+     * Get the underlying RegExp value
+     */
+    valueOf(): RegExp;
+    /**
+     * Get the regex source pattern
+     */
+    get source(): string;
+    /**
+     * Get the regex flags
+     */
+    get flags(): string;
+    /**
+     * Test if a string matches the regex
+     */
+    test(input: string): boolean;
+    /**
+     * Execute the regex on a string
+     */
+    exec(input: string): RegExpExecArray | null;
+    /**
+     * Check if two regexes match the same patterns semantically
+     *
+     * @param other - RegExp to compare
+     * @param testStrings - Optional strings to test against
+     * @returns Equivalence result with confidence
+     */
+    semanticallyEquals(other: RegExp | SemanticRegExp, testStrings?: string[]): Promise<SemanticEqualsResult>;
+    /**
+     * Explain what the regex matches in plain language
+     *
+     * @param context - Optional context for more relevant explanation
+     * @returns Human-readable explanation
+     */
+    explain(context?: string): Promise<string>;
+    /**
+     * Test a string and explain why it matched or didn't
+     *
+     * @param input - String to test
+     * @returns Match result with explanation
+     */
+    testWithExplanation(input: string): Promise<TestWithExplanationResult>;
+    /**
+     * Suggest improvements to the regex
+     *
+     * @returns Suggested improvements
+     */
+    suggestImprovements(): Promise<ImprovementSuggestion[]>;
+    /**
+     * Generate test cases for the regex
+     *
+     * @returns Test cases with strings that should and shouldn't match
+     */
+    generateTestCases(): Promise<RegExpTestCases>;
+    /**
+     * Validate the regex for common issues
+     *
+     * @returns Validation result with issues and warnings
+     */
+    validate(): Promise<ValidateResultWithWarnings>;
+    /**
+     * Convert to a more readable format
+     *
+     * @returns Readable regex representation
+     */
+    toReadable(): Promise<string>;
+    /**
+     * Find similar patterns that might also be needed
+     *
+     * @returns Related patterns with reasons
+     */
+    suggestRelated(): Promise<RelatedSuggestion[]>;
+    /**
+     * Detect what type of data this regex is designed to match
+     *
+     * @returns Inferred data type with confidence
+     */
+    inferDataType(): Promise<InferTypeResult>;
+    /**
+     * Alias for inferDataType to match TypeInferable interface
+     */
+    inferType(): Promise<InferTypeResult>;
+    /**
+     * Simplify the regex if possible
+     *
+     * @returns Simplified version with explanation, or null if not simplifiable
+     */
+    simplify(): Promise<SimplifyResult | null>;
+    /**
+     * Convert to string representation
+     */
+    toString(): string;
+    /**
+     * String tag for type identification
+     */
+    readonly [Symbol.toStringTag] = "SemanticRegExp";
+}
+//# sourceMappingURL=regexp.d.ts.map

package/dist/types/regexp/regexp.d.ts.map

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

package/dist/types/set/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SemanticSet module
+ * A set type with LLM-powered semantic understanding
+ */
+export { SemanticSet, type SemanticHasResult, type SemanticAddResult, type SetSemanticEqualsResult, type SetSummarizeOptions, type SetValidateResult, type InferThemeResult, } from './set.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/set/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/set/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,UAAU,CAAC"}

package/dist/types/set/prompts.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Prompts for SemanticSet LLM operations
+ * These prompts enable semantic operations on set collections
+ */
+/**
+ * System prompt for set semantic operations
+ */
+export declare const SET_SYSTEM_PROMPT = "You are a semantic set analyzer. Your task is to analyze sets and their elements to provide semantic understanding.\n\nYou must respond with valid JSON only, no additional text or explanation.\n\nGuidelines:\n- Consider element meanings, relationships, and uniqueness\n- Provide confidence scores from 0.0 to 1.0\n- Be precise and consistent in your analysis\n- Understand that sets represent unique value collections\n- Focus on semantic equivalence beyond exact string matching";
+/**
+ * Prompt for semantic has (membership check)
+ */
+export declare function createSemanticHasPrompt(setValues: unknown[], query: unknown): string;
+/**
+ * Prompt for semantic add (conditional add based on semantic equivalence)
+ */
+export declare function createSemanticAddPrompt(setValues: unknown[], value: unknown): string;
+/**
+ * Prompt for semantic equality comparison between sets
+ */
+export declare function createSemanticallyEqualsPrompt(set1Values: unknown[], set2Values: unknown[]): string;
+/**
+ * Prompt for semantic intersection
+ */
+export declare function createSemanticIntersectionPrompt(set1Values: unknown[], set2Values: unknown[]): string;
+/**
+ * Prompt for semantic union
+ */
+export declare function createSemanticUnionPrompt(set1Values: unknown[], set2Values: unknown[]): string;
+/**
+ * Prompt for semantic difference
+ */
+export declare function createSemanticDifferencePrompt(set1Values: unknown[], set2Values: unknown[]): string;
+/**
+ * Prompt for semantic filtering
+ */
+export declare function createSemanticFilterPrompt(setValues: unknown[], criteria: string): string;
+/**
+ * Prompt for grouping set values
+ */
+export declare function createGroupByPrompt(setValues: unknown[], criteria: string): string;
+/**
+ * Prompt for summarization
+ */
+export declare function createSummarizePrompt(setValues: unknown[], options?: {
+    maxLength?: number;
+    focus?: string;
+}): string;
+/**
+ * Prompt for suggesting related values
+ */
+export declare function createSuggestRelatedPrompt(setValues: unknown[]): string;
+/**
+ * Prompt for validation against rules
+ */
+export declare function createValidatePrompt(setValues: unknown[], rules: string[]): string;
+/**
+ * Prompt for inferring the theme of a set
+ */
+export declare function createInferThemePrompt(setValues: unknown[]): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/types/set/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/types/set/prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,oeAS+B,CAAC;AAE9D;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,OAAO,EAAE,EACpB,KAAK,EAAE,OAAO,GACb,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,OAAO,EAAE,EACpB,KAAK,EAAE,OAAO,GACb,MAAM,CAkBR;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,OAAO,EAAE,EACrB,UAAU,EAAE,OAAO,EAAE,GACpB,MAAM,CAuBR;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,OAAO,EAAE,EACrB,UAAU,EAAE,OAAO,EAAE,GACpB,MAAM,CAmBR;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,OAAO,EAAE,EACrB,UAAU,EAAE,OAAO,EAAE,GACpB,MAAM,CAwBR;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,OAAO,EAAE,EACrB,UAAU,EAAE,OAAO,EAAE,GACpB,MAAM,CAoBR;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,OAAO,EAAE,EACpB,QAAQ,EAAE,MAAM,GACf,MAAM,CAeR;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,OAAO,EAAE,EACpB,QAAQ,EAAE,MAAM,GACf,MAAM,CAkBR;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,OAAO,EAAE,EACpB,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/C,MAAM,CA2BR;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,OAAO,EAAE,GAAG,MAAM,CAoBvE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,OAAO,EAAE,EACpB,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,OAAO,EAAE,GAAG,MAAM,CAmBnE"}