@hyperfixi/core 2.0.0

package/dist/expressions/logical/impl/index.d.ts

@@ -0,0 +1,54 @@
+import type { TypedExpressionContext, EvaluationType, ValidationResult, EvaluationResult } from '../../../types/base-types';
+import type { TypedExpressionImplementation, ExpressionMetadata, ExpressionCategory } from '../../../types/expression-types';
+import { BaseExpressionImpl } from '../../base-expression';
+type BinaryLogicalInput = any;
+type UnaryLogicalInput = any;
+export declare class AndExpression extends BaseExpressionImpl<BinaryLogicalInput, boolean> implements TypedExpressionImplementation<BinaryLogicalInput, boolean> {
+    readonly name = "and";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left and right";
+    readonly description = "Logical AND operation with comprehensive boolean type coercion";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: BinaryLogicalInput): Promise<EvaluationResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class OrExpression extends BaseExpressionImpl<BinaryLogicalInput, boolean> implements TypedExpressionImplementation<BinaryLogicalInput, boolean> {
+    readonly name = "or";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left or right";
+    readonly description = "Logical OR operation with comprehensive boolean type coercion";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: BinaryLogicalInput): Promise<EvaluationResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class NotExpression extends BaseExpressionImpl<UnaryLogicalInput, boolean> implements TypedExpressionImplementation<UnaryLogicalInput, boolean> {
+    readonly name = "not";
+    readonly category: ExpressionCategory;
+    readonly syntax = "not operand";
+    readonly description = "Logical NOT operation with comprehensive boolean type coercion";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: UnaryLogicalInput): Promise<EvaluationResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare function createAndExpression(): AndExpression;
+export declare function createOrExpression(): OrExpression;
+export declare function createNotExpression(): NotExpression;
+export declare const logicalExpressions: {
+    readonly and: AndExpression;
+    readonly or: OrExpression;
+    readonly not: NotExpression;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/logical/impl/pattern-matching.d.ts

@@ -0,0 +1,58 @@
+import type { TypedExpressionContext, ExpressionCategory, EvaluationType, ExpressionMetadata, ValidationResult } from '../../../types/expression-types';
+import type { EvaluationResult } from '../../../types/command-types';
+import { BaseExpressionImpl } from '../../base-expression';
+type PatternMatchInput = any;
+type ContainsInput = any;
+type InInput = any;
+export declare class MatchesExpression extends BaseExpressionImpl<PatternMatchInput, boolean> {
+    readonly name = "matches";
+    readonly category: ExpressionCategory;
+    readonly syntax = "value matches pattern";
+    readonly description = "Pattern matching with CSS selectors and regular expressions";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: PatternMatchInput): Promise<EvaluationResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+    private matchCSSSelector;
+    private isCSSSelector;
+    private isValidCSSSelector;
+}
+export declare class ContainsExpression extends BaseExpressionImpl<ContainsInput, boolean> {
+    readonly name = "contains";
+    readonly category: ExpressionCategory;
+    readonly syntax = "container contains item";
+    readonly description = "Tests if a container (array, string, object) contains an item";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: ContainsInput): Promise<EvaluationResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class InExpression extends BaseExpressionImpl<InInput, boolean> {
+    readonly name = "in";
+    readonly category: ExpressionCategory;
+    readonly syntax = "item in container";
+    readonly description = "Tests if an item is in a container (reverse of contains)";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: InInput): Promise<EvaluationResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare function createMatchesExpression(): MatchesExpression;
+export declare function createContainsExpression(): ContainsExpression;
+export declare function createInExpression(): InExpression;
+export declare const enhancedPatternMatchingExpressions: {
+    readonly matches: MatchesExpression;
+    readonly contains: ContainsExpression;
+    readonly in: InExpression;
+};
+export {};
+//# sourceMappingURL=pattern-matching.d.ts.map

package/dist/expressions/logical/index.d.ts

@@ -0,0 +1,59 @@
+import type { RuntimeValidator } from '../../validation/lightweight-validators';
+import type { ExpressionImplementation } from '../../types/core';
+import type { ExpressionMetadata, LLMDocumentation } from '../../types/expression-types';
+interface EnhancedExpressionImplementation extends ExpressionImplementation {
+    metadata?: ExpressionMetadata;
+    documentation?: LLMDocumentation;
+    inputSchema?: RuntimeValidator<unknown>;
+}
+export declare const equalsExpression: EnhancedExpressionImplementation;
+export declare const strictEqualsExpression: ExpressionImplementation;
+export declare const notEqualsExpression: ExpressionImplementation;
+export declare const strictNotEqualsExpression: ExpressionImplementation;
+export declare const lessThanExpression: ExpressionImplementation;
+export declare const lessThanOrEqualExpression: ExpressionImplementation;
+export declare const greaterThanExpression: ExpressionImplementation;
+export declare const greaterThanOrEqualExpression: ExpressionImplementation;
+export declare const andExpression: EnhancedExpressionImplementation;
+export declare const orExpression: ExpressionImplementation;
+export declare const notExpression: ExpressionImplementation;
+export declare const isEmptyExpression: ExpressionImplementation;
+export declare const noExpression: ExpressionImplementation;
+export declare const isNotEmptyExpression: ExpressionImplementation;
+export declare const existsExpression: ExpressionImplementation;
+export declare const doesNotExistExpression: ExpressionImplementation;
+export declare const containsExpression: ExpressionImplementation;
+export declare const doesNotContainExpression: ExpressionImplementation;
+export declare const startsWithExpression: ExpressionImplementation;
+export declare const endsWithExpression: ExpressionImplementation;
+export declare const matchesExpression: EnhancedExpressionImplementation;
+export declare const hasExpression: ExpressionImplementation;
+export declare const doesNotHaveExpression: ExpressionImplementation;
+export declare const logicalExpressions: {
+    readonly equals: EnhancedExpressionImplementation;
+    readonly strictEquals: ExpressionImplementation;
+    readonly notEquals: ExpressionImplementation;
+    readonly strictNotEquals: ExpressionImplementation;
+    readonly lessThan: ExpressionImplementation;
+    readonly lessThanOrEqual: ExpressionImplementation;
+    readonly greaterThan: ExpressionImplementation;
+    readonly greaterThanOrEqual: ExpressionImplementation;
+    readonly and: EnhancedExpressionImplementation;
+    readonly or: ExpressionImplementation;
+    readonly not: ExpressionImplementation;
+    readonly no: ExpressionImplementation;
+    readonly isEmpty: ExpressionImplementation;
+    readonly isNotEmpty: ExpressionImplementation;
+    readonly exists: ExpressionImplementation;
+    readonly doesNotExist: ExpressionImplementation;
+    readonly contains: ExpressionImplementation;
+    readonly doesNotContain: ExpressionImplementation;
+    readonly startsWith: ExpressionImplementation;
+    readonly endsWith: ExpressionImplementation;
+    readonly matches: EnhancedExpressionImplementation;
+    readonly has: ExpressionImplementation;
+    readonly doesNotHave: ExpressionImplementation;
+};
+export type LogicalExpressionName = keyof typeof logicalExpressions;
+export { AndExpression, OrExpression, NotExpression, createAndExpression, createOrExpression, createNotExpression, } from './impl/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/mathematical/index.d.ts

@@ -0,0 +1,69 @@
+import type { ValidationResult, TypedExecutionContext as TypedExpressionContext, EvaluationType, ExpressionMetadata, TypedResult, ExpressionCategory } from '../../types/index';
+interface BaseTypedExpression<T> {
+    readonly name: string;
+    readonly category: string;
+    readonly syntax: string;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: unknown): Promise<TypedResult<T>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class AdditionExpression implements BaseTypedExpression<number> {
+    readonly name = "addition";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left + right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class SubtractionExpression implements BaseTypedExpression<number> {
+    readonly name = "subtraction";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left - right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class MultiplicationExpression implements BaseTypedExpression<number> {
+    readonly name = "multiplication";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left * right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class DivisionExpression implements BaseTypedExpression<number> {
+    readonly name = "division";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left / right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class ModuloExpression implements BaseTypedExpression<number> {
+    readonly name = "modulo";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left mod right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare function createAdditionExpression(): AdditionExpression;
+export declare function createSubtractionExpression(): SubtractionExpression;
+export declare function createMultiplicationExpression(): MultiplicationExpression;
+export declare function createDivisionExpression(): DivisionExpression;
+export declare function createModuloExpression(): ModuloExpression;
+export declare const mathematicalExpressions: {
+    readonly addition: AdditionExpression;
+    readonly subtraction: SubtractionExpression;
+    readonly multiplication: MultiplicationExpression;
+    readonly division: DivisionExpression;
+    readonly modulo: ModuloExpression;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/positional/impl/bridge.d.ts

@@ -0,0 +1,95 @@
+import type { ExecutionContext, TypedExpressionContext, ExpressionEvaluationOptions } from '../../../types/base-types';
+export declare function createTypedExpressionContext(context: ExecutionContext, options?: ExpressionEvaluationOptions): TypedExpressionContext;
+export declare function updateExecutionContext(originalContext: ExecutionContext, typedContext: TypedExpressionContext): ExecutionContext;
+export declare class PositionalAdapter {
+    static evaluateFirst(context: ExecutionContext, collection?: unknown): Promise<unknown>;
+    static evaluateLast(context: ExecutionContext, collection?: unknown): Promise<unknown>;
+    static evaluateAt(context: ExecutionContext, index: number, collection?: unknown): Promise<unknown>;
+    static getExpressionMetadata(expressionName: string): import("../../../types/expression-types").ExpressionMetadata;
+    static getExpressionDocumentation(expressionName: string): unknown;
+    static validateExpressionInput(expressionName: string, input: unknown): import("../../../types/base-types").ValidationResult<unknown>;
+}
+export declare const EnhancedPositionalAdapter: typeof PositionalAdapter;
+export declare class LegacyCompatibilityLayer {
+    static firstExpression: {
+        name: string;
+        category: "Reference";
+        evaluatesTo: "Any";
+        evaluate(context: ExecutionContext, collection?: unknown): Promise<unknown>;
+        validate(args: unknown[]): string | null;
+    };
+    static lastExpression: {
+        name: string;
+        category: "Reference";
+        evaluatesTo: "Any";
+        evaluate(context: ExecutionContext, collection?: unknown): Promise<unknown>;
+        validate(args: unknown[]): string | null;
+    };
+    static atExpression: {
+        name: string;
+        category: "Reference";
+        evaluatesTo: "Any";
+        evaluate(context: ExecutionContext, index: number, collection?: unknown): Promise<unknown>;
+        validate(args: unknown[]): string | null;
+    };
+}
+export declare class ExpressionMigrationUtility {
+    private static migrationMap;
+    static enableEnhanced(expressionName: string): void;
+    static disableEnhanced(expressionName: string): void;
+    static isEnhancedEnabled(expressionName: string): boolean;
+    static getMigrationStatus(): {
+        [k: string]: boolean;
+    };
+    static enableAllEnhanced(): void;
+    static disableAllEnhanced(): void;
+}
+export declare class PositionalUtilities {
+    static safeFirst(context: ExecutionContext, collection?: unknown, fallback?: unknown): Promise<{
+        success: boolean;
+        value: unknown;
+        error?: unknown;
+    }>;
+    static safeLast(context: ExecutionContext, collection?: unknown, fallback?: unknown): Promise<{
+        success: boolean;
+        value: unknown;
+        error?: unknown;
+    }>;
+    static safeAt(context: ExecutionContext, index: number, collection?: unknown, fallback?: unknown): Promise<{
+        success: boolean;
+        value: unknown;
+        error?: unknown;
+    }>;
+    static batchPositionalOperations(context: ExecutionContext, operations: Array<{
+        type: 'first' | 'last' | 'at';
+        collection: unknown;
+        index?: number;
+        key?: string;
+    }>): Promise<{
+        success: boolean;
+        results: Record<string, unknown>;
+        errors: Array<unknown>;
+    }>;
+    static getAvailableOperations(): {
+        first: {
+            description: string;
+            complexity: string;
+        };
+        last: {
+            description: string;
+            complexity: string;
+        };
+        at: {
+            description: string;
+            complexity: string;
+        };
+    };
+    static analyzeCollection(collection: unknown): {
+        type: string;
+        length: number;
+        isIndexable: boolean;
+        supportsNegativeIndexing: boolean;
+        metadata: Record<string, unknown>;
+    };
+}
+//# sourceMappingURL=bridge.d.ts.map

package/dist/expressions/positional/impl/index.d.ts

@@ -0,0 +1,73 @@
+import type { TypedExpressionContext, EvaluationType, ValidationResult, EvaluationResult } from '../../../types/base-types';
+import type { TypedExpressionImplementation, ExpressionMetadata, ExpressionCategory } from '../../../types/expression-types';
+import { BaseExpressionImpl } from '../../base-expression';
+type CollectionInput = any;
+type IndexInput = any;
+type RandomInput = any;
+export declare class FirstExpression extends BaseExpressionImpl<CollectionInput, unknown> implements TypedExpressionImplementation<CollectionInput, unknown> {
+    readonly name = "first";
+    readonly category: ExpressionCategory;
+    readonly syntax = "first in collection";
+    readonly description = "Gets the first element from a collection";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: CollectionInput): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class LastExpression extends BaseExpressionImpl<CollectionInput, unknown> implements TypedExpressionImplementation<CollectionInput, unknown> {
+    readonly name = "last";
+    readonly category: ExpressionCategory;
+    readonly syntax = "last in collection";
+    readonly description = "Gets the last element from a collection";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: CollectionInput): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class AtExpression extends BaseExpressionImpl<IndexInput, unknown> implements TypedExpressionImplementation<IndexInput, unknown> {
+    readonly name = "at";
+    readonly category: ExpressionCategory;
+    readonly syntax = "collection[index] or collection at index";
+    readonly description = "Gets element at specific index from a collection";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: IndexInput): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+    private normalizeIndex;
+}
+export declare class RandomExpression extends BaseExpressionImpl<RandomInput, unknown> implements TypedExpressionImplementation<RandomInput, unknown> {
+    readonly name = "random";
+    readonly category: ExpressionCategory;
+    readonly syntax = "random in collection";
+    readonly description = "Gets a random element from a collection";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: RandomInput): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+    private getSecureRandomIndex;
+}
+export declare function createFirstExpression(): FirstExpression;
+export declare function createLastExpression(): LastExpression;
+export declare function createAtExpression(): AtExpression;
+export declare function createRandomExpression(): RandomExpression;
+export declare const positionalExpressions: {
+    readonly first: FirstExpression;
+    readonly last: LastExpression;
+    readonly at: AtExpression;
+    readonly random: RandomExpression;
+};
+export type PositionalExpressionName = keyof typeof positionalExpressions;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/positional/index.d.ts

@@ -0,0 +1,26 @@
+import type { ExpressionImplementation } from '../../types/core';
+export declare const firstExpression: ExpressionImplementation;
+export declare const lastExpression: ExpressionImplementation;
+export declare const atExpression: ExpressionImplementation;
+export declare const nextExpression: ExpressionImplementation;
+export declare const previousExpression: ExpressionImplementation;
+declare function findNextElementInDOM(startElement: Element, selector: string): HTMLElement | null;
+declare function findPreviousElementInDOM(startElement: Element, selector: string): HTMLElement | null;
+export declare const nextWithinExpression: ExpressionImplementation;
+export declare const previousWithinExpression: ExpressionImplementation;
+declare function findNextElementWithinContainer(startElement: Element, selector: string, container: Element): HTMLElement | null;
+declare function findPreviousElementWithinContainer(startElement: Element, selector: string, container: Element): HTMLElement | null;
+declare function getElementPosition(element: Element): number;
+export declare const positionalExpressions: {
+    readonly first: ExpressionImplementation;
+    readonly last: ExpressionImplementation;
+    readonly at: ExpressionImplementation;
+    readonly next: ExpressionImplementation;
+    readonly previous: ExpressionImplementation;
+    readonly nextWithin: ExpressionImplementation;
+    readonly previousWithin: ExpressionImplementation;
+};
+export type PositionalExpressionName = keyof typeof positionalExpressions;
+export { findNextElementInDOM, findPreviousElementInDOM, findNextElementWithinContainer, findPreviousElementWithinContainer, getElementPosition, };
+export { FirstExpression, LastExpression, createFirstExpression, createLastExpression, } from './impl/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/properties/impl/index.d.ts

@@ -0,0 +1,105 @@
+import type { BaseTypedExpression, TypedExpressionContext, EvaluationType, ExpressionMetadata, ValidationResult, EvaluationResult } from '../../../types/base-types';
+import type { ExpressionCategory } from '../../../types/expression-types';
+import { BaseExpressionImpl } from '../../base-expression';
+type PropertyAccessInput = any;
+type AttributeAccessInput = any;
+type ContextPropertyInput = any;
+type AttributeWithValueInput = any;
+export declare class PossessiveExpression extends BaseExpressionImpl<PropertyAccessInput, unknown> implements BaseTypedExpression<unknown> {
+    readonly name = "possessive";
+    readonly category: ExpressionCategory;
+    readonly syntax = "element's property";
+    readonly description = "Access object or element properties using possessive syntax";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: PropertyAccessInput): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+    private getProperty;
+    private getElementProperty;
+    private inferResultType;
+}
+export declare class MyExpression extends BaseExpressionImpl<ContextPropertyInput, unknown> implements BaseTypedExpression<unknown> {
+    readonly name = "my";
+    readonly category: ExpressionCategory;
+    readonly syntax = "my property";
+    readonly description = "Access properties of the current context element (me)";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: ContextPropertyInput): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class ItsExpression extends BaseExpressionImpl<ContextPropertyInput, unknown> implements BaseTypedExpression<unknown> {
+    readonly name = "its";
+    readonly category: ExpressionCategory;
+    readonly syntax = "its property";
+    readonly description = "Access properties of the it reference in context";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: ContextPropertyInput): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class YourExpression extends BaseExpressionImpl<ContextPropertyInput, unknown> implements BaseTypedExpression<unknown> {
+    readonly name = "your";
+    readonly category: ExpressionCategory;
+    readonly syntax = "your property";
+    readonly description = "Access properties of the you reference in context";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: ContextPropertyInput): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class AttributeExpression extends BaseExpressionImpl<AttributeAccessInput, string | null> implements BaseTypedExpression<string | null> {
+    readonly name = "attribute";
+    readonly category: ExpressionCategory;
+    readonly syntax = "@attribute or @attribute of element";
+    readonly description = "Access HTML attributes of DOM elements";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: AttributeAccessInput): Promise<EvaluationResult<string | null>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class AttributeWithValueExpression extends BaseExpressionImpl<AttributeWithValueInput, boolean> implements BaseTypedExpression<boolean> {
+    readonly name = "attributeWithValue";
+    readonly category: ExpressionCategory;
+    readonly syntax = "@attribute=value";
+    readonly description = "Check if element has attribute with specific value";
+    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: AttributeWithValueInput): Promise<EvaluationResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare function createPossessiveExpression(): PossessiveExpression;
+export declare function createMyExpression(): MyExpression;
+export declare function createItsExpression(): ItsExpression;
+export declare function createYourExpression(): YourExpression;
+export declare function createAttributeExpression(): AttributeExpression;
+export declare function createAttributeWithValueExpression(): AttributeWithValueExpression;
+export declare const propertyExpressions: {
+    readonly possessive: PossessiveExpression;
+    readonly my: MyExpression;
+    readonly its: ItsExpression;
+    readonly your: YourExpression;
+    readonly attribute: AttributeExpression;
+    readonly attributeWithValue: AttributeWithValueExpression;
+};
+export type PropertyExpressionName = keyof typeof propertyExpressions;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/properties/index.d.ts

@@ -0,0 +1,26 @@
+import type { ExpressionImplementation } from '../../types/core';
+import { getElementProperty } from '../property-access-utils';
+export { getElementProperty };
+export declare const possessiveExpression: ExpressionImplementation;
+export declare const myExpression: ExpressionImplementation;
+export declare const itsExpression: ExpressionImplementation;
+export declare const yourExpression: ExpressionImplementation;
+export declare const ofExpression: ExpressionImplementation;
+export declare const attributeExpression: ExpressionImplementation;
+export declare const attributeWithValueExpression: ExpressionImplementation;
+export declare const classReferenceExpression: ExpressionImplementation;
+export declare const idReferenceExpression: ExpressionImplementation;
+export { isDataAttribute, isAriaAttribute } from '../property-access-utils';
+export declare const propertiesExpressions: {
+    readonly possessive: ExpressionImplementation;
+    readonly my: ExpressionImplementation;
+    readonly its: ExpressionImplementation;
+    readonly your: ExpressionImplementation;
+    readonly of: ExpressionImplementation;
+    readonly attribute: ExpressionImplementation;
+    readonly attributeWithValue: ExpressionImplementation;
+    readonly classReference: ExpressionImplementation;
+    readonly idReference: ExpressionImplementation;
+};
+export type PropertyExpressionName = keyof typeof propertiesExpressions;
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/property/index.d.ts

@@ -0,0 +1,55 @@
+import type { ValidationResult, TypedExpressionContext, EvaluationType, ExpressionMetadata, EvaluationResult, ExpressionCategory } from '../../types/base-types';
+import type { HyperScriptValue } from '../../types/command-types';
+import { BaseExpressionImpl } from '../base-expression';
+type PropertyAccessInput = any;
+type PossessiveAccessInput = any;
+type AttributeAccessInput = any;
+export declare class MyExpression extends BaseExpressionImpl<PropertyAccessInput, HyperScriptValue> {
+    readonly name = "my";
+    readonly category: ExpressionCategory;
+    readonly syntax = "my property";
+    readonly description = "Accesses properties of the current context element (me) with validation";
+    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: PropertyAccessInput): Promise<EvaluationResult<HyperScriptValue>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class ItsExpression extends BaseExpressionImpl<PossessiveAccessInput, HyperScriptValue> {
+    readonly name = "its";
+    readonly category: ExpressionCategory;
+    readonly syntax = "target its property";
+    readonly description = "Generic possessive property access with comprehensive validation";
+    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: PossessiveAccessInput): Promise<EvaluationResult<HyperScriptValue>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class AttributeExpression extends BaseExpressionImpl<AttributeAccessInput, string | null> {
+    readonly name = "attribute";
+    readonly category: ExpressionCategory;
+    readonly syntax = "@attribute or element@attribute";
+    readonly description = "Accesses HTML attributes with comprehensive DOM validation";
+    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: AttributeAccessInput): Promise<EvaluationResult<string | null>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare function createMyExpression(): MyExpression;
+export declare function createItsExpression(): ItsExpression;
+export declare function createAttributeExpression(): AttributeExpression;
+export declare const propertyExpressions: {
+    readonly my: MyExpression;
+    readonly its: ItsExpression;
+    readonly attribute: AttributeExpression;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/property-access-utils.d.ts

@@ -0,0 +1,23 @@
+export declare function isElement(value: unknown): value is Element;
+export declare function isHTMLElement(value: unknown): value is HTMLElement;
+export declare function isDataAttribute(property: string): boolean;
+export declare function isAriaAttribute(property: string): boolean;
+export declare function accessStyleProperty(element: Element, styleProp: string): string | null;
+export declare function accessAttribute(element: Element, attrName: string): boolean | string | null;
+export declare function hasAttribute(element: Element, attrName: string): boolean;
+export declare function getElementProperty(element: Element, property: string): unknown;
+export declare function accessObjectProperty(object: unknown, property: string): unknown;
+export declare function accessProperty(object: unknown, property: string): Promise<unknown>;
+export declare const propertyAccessUtils: {
+    readonly isElement: typeof isElement;
+    readonly isHTMLElement: typeof isHTMLElement;
+    readonly isDataAttribute: typeof isDataAttribute;
+    readonly isAriaAttribute: typeof isAriaAttribute;
+    readonly accessStyleProperty: typeof accessStyleProperty;
+    readonly accessAttribute: typeof accessAttribute;
+    readonly hasAttribute: typeof hasAttribute;
+    readonly getElementProperty: typeof getElementProperty;
+    readonly accessObjectProperty: typeof accessObjectProperty;
+    readonly accessProperty: typeof accessProperty;
+};
+//# sourceMappingURL=property-access-utils.d.ts.map