@hyperfixi/core 2.0.0

package/dist/commands/data/default.d.ts

@@ -0,0 +1,31 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface DefaultCommandInput {
+    target: string | HTMLElement;
+    value: unknown;
+}
+export interface DefaultCommandOutput {
+    target: string;
+    value: unknown;
+    wasSet: boolean;
+    existingValue?: unknown;
+    targetType: 'variable' | 'attribute' | 'property' | 'element';
+}
+export declare class DefaultCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<DefaultCommandInput>;
+    execute(input: DefaultCommandInput, context: TypedExecutionContext): Promise<DefaultCommandOutput>;
+    private defaultVariable;
+    private defaultAttribute;
+    private defaultElementProperty;
+    private defaultElementValue;
+}
+export declare const createDefaultCommand: () => DefaultCommand;
+export default DefaultCommand;
+//# sourceMappingURL=default.d.ts.map

package/dist/commands/data/get.d.ts

@@ -0,0 +1,23 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface GetCommandInput {
+    value: unknown;
+}
+export interface GetCommandOutput {
+    value: unknown;
+}
+export declare class GetCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<GetCommandInput>;
+    execute(input: GetCommandInput, context: TypedExecutionContext): GetCommandOutput;
+    validate(input: unknown): input is GetCommandInput;
+}
+export declare const createGetCommand: () => GetCommand;
+export default GetCommand;
+//# sourceMappingURL=get.d.ts.map

package/dist/commands/data/increment.d.ts

@@ -0,0 +1,25 @@
+import type { TypedExecutionContext } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+import { type NumericTargetRawInput, type NumericTargetInput } from '../helpers/numeric-target-parser';
+export type NumericOperation = 'increment' | 'decrement';
+export interface NumericModifyInput extends NumericTargetInput {
+    operation: NumericOperation;
+}
+export type { NumericTargetInput as IncrementCommandInput };
+export type { NumericTargetInput as DecrementCommandInput };
+export declare class NumericModifyCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: NumericTargetRawInput & {
+        commandName?: string;
+    }, evaluator: ExpressionEvaluator, context: TypedExecutionContext): Promise<NumericModifyInput>;
+    execute(input: NumericModifyInput, context: TypedExecutionContext): Promise<number>;
+}
+export { NumericModifyCommand as IncrementCommand };
+export { NumericModifyCommand as DecrementCommand };
+export declare const createNumericModifyCommand: () => NumericModifyCommand;
+export declare const createIncrementCommand: () => NumericModifyCommand;
+export declare const createDecrementCommand: () => NumericModifyCommand;
+export default NumericModifyCommand;
+//# sourceMappingURL=increment.d.ts.map

package/dist/commands/data/set.d.ts

@@ -0,0 +1,56 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types.ts';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator.ts';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export type SetCommandInput = {
+    type: 'variable';
+    name: string;
+    value: unknown;
+} | {
+    type: 'attribute';
+    element: HTMLElement;
+    name: string;
+    value: unknown;
+} | {
+    type: 'property';
+    element: HTMLElement;
+    property: string;
+    value: unknown;
+} | {
+    type: 'style';
+    element: HTMLElement;
+    property: string;
+    value: string;
+} | {
+    type: 'object-literal';
+    properties: Record<string, unknown>;
+    targets: HTMLElement[];
+} | {
+    type: 'member-assignment';
+    container: Record<string, unknown>;
+    property: string;
+    value: unknown;
+};
+export interface SetCommandOutput {
+    target: string | HTMLElement;
+    value: unknown;
+    targetType: 'variable' | 'attribute' | 'property';
+}
+export declare class SetCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<SetCommandInput>;
+    execute(input: SetCommandInput, context: TypedExecutionContext): Promise<SetCommandOutput>;
+    private tryParseMemberExpression;
+    private extractValue;
+    private resolveElement;
+    private resolveTargets;
+    private parseTheXofY;
+    validate(input: unknown): input is SetCommandInput;
+}
+export declare const createSetCommand: () => SetCommand;
+export default SetCommand;
+//# sourceMappingURL=set.d.ts.map

package/dist/commands/decorators/index.d.ts

@@ -0,0 +1,30 @@
+import type { CommandMetadata, CommandCategory, CommandSideEffect } from '../../types/command-metadata';
+export interface CommandConfig {
+    name: string;
+    category: CommandCategory;
+}
+export interface MetaConfig {
+    description: string;
+    syntax: string | readonly string[];
+    examples: readonly string[];
+    sideEffects?: readonly CommandSideEffect[];
+    deprecated?: boolean;
+    deprecationMessage?: string;
+    aliases?: readonly string[];
+    relatedCommands?: readonly string[];
+    isBlocking?: boolean;
+    hasBody?: boolean;
+    compatibility?: 'standard' | 'lokascript-extension' | 'experimental';
+}
+export interface DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+}
+export declare function command(config: CommandConfig): <T extends new (...args: unknown[]) => object>(target: T, context: ClassDecoratorContext) => T | void;
+export declare function meta(config: MetaConfig): <T extends new (...args: unknown[]) => object>(target: T, context: ClassDecoratorContext) => T | void;
+export declare function getCommandName<T extends new (...args: unknown[]) => object>(target: T): string | undefined;
+export declare function getCommandCategory<T extends new (...args: unknown[]) => object>(target: T): CommandCategory | undefined;
+export declare function getCommandMetadata<T extends new (...args: unknown[]) => object>(target: T): CommandMetadata | undefined;
+export declare function createFactory<T extends new () => object>(CommandClass: T): () => InstanceType<T>;
+export type { CommandMetadata, CommandCategory, CommandSideEffect };
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/dom/__tests__/add-standalone-helpers.d.ts

@@ -0,0 +1,11 @@
+import type { AddCommandInput } from '../add';
+export declare function isClassesInput(input: AddCommandInput): input is Extract<AddCommandInput, {
+    type: 'classes';
+}>;
+export declare function isAttributeInput(input: AddCommandInput): input is Extract<AddCommandInput, {
+    type: 'attribute';
+}>;
+export declare function isStylesInput(input: AddCommandInput): input is Extract<AddCommandInput, {
+    type: 'styles';
+}>;
+//# sourceMappingURL=add-standalone-helpers.d.ts.map

package/dist/commands/dom/add.d.ts

@@ -0,0 +1,31 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { DOMModificationBase } from './dom-modification-base';
+export type AddCommandInput = {
+    type: 'classes';
+    classes: string[];
+    targets: HTMLElement[];
+} | {
+    type: 'attribute';
+    name: string;
+    value: string;
+    targets: HTMLElement[];
+} | {
+    type: 'styles';
+    styles: Record<string, string>;
+    targets: HTMLElement[];
+};
+export declare class AddCommand extends DOMModificationBase {
+    protected readonly mode: "add";
+    protected readonly preposition = "to";
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<AddCommandInput>;
+    execute(input: AddCommandInput, context: TypedExecutionContext): Promise<void>;
+    validate(input: unknown): input is AddCommandInput;
+}
+export declare const createAddCommand: () => AddCommand;
+export default AddCommand;
+//# sourceMappingURL=add.d.ts.map

package/dist/commands/dom/dom-modification-base.d.ts

@@ -0,0 +1,48 @@
+import type { ExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import type { DecoratedCommand, CommandMetadata } from '../decorators';
+export type DOMModificationMode = 'add' | 'remove';
+export type ClassModificationInput = {
+    type: 'classes';
+    classes: string[];
+    targets: HTMLElement[];
+};
+export type AttributeModificationInput = {
+    type: 'attribute';
+    name: string;
+    value?: string;
+    targets: HTMLElement[];
+};
+export type StyleModificationInput = {
+    type: 'styles';
+    styles?: Record<string, string>;
+    properties?: string[];
+    targets: HTMLElement[];
+};
+export type ElementRemovalInput = {
+    type: 'element';
+    targets: HTMLElement[];
+};
+export interface RawCommandInput {
+    args: ASTNode[];
+    modifiers: Record<string, ExpressionNode>;
+    commandName?: string;
+}
+export declare abstract class DOMModificationBase implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    protected abstract readonly mode: DOMModificationMode;
+    protected abstract readonly preposition: string;
+    protected resolveTargets(args: ASTNode[], evaluator: ExpressionEvaluator, context: ExecutionContext, modifiers: Record<string, ExpressionNode>): Promise<HTMLElement[]>;
+    protected evaluateFirst(arg: ASTNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<{
+        value: unknown;
+    }>;
+    protected parseClassNames(value: unknown): string[];
+    protected isAttribute(value: string): boolean;
+    protected isCSSProperty(value: string): boolean;
+    protected validateTargets(targets: unknown): targets is HTMLElement[];
+    protected validateType<T extends string>(type: unknown, validTypes: readonly T[]): type is T;
+    protected validateStringArray(arr: unknown, minLength?: number): arr is string[];
+}
+//# sourceMappingURL=dom-modification-base.d.ts.map

package/dist/commands/dom/hide.d.ts

@@ -0,0 +1,12 @@
+import type { TypedExecutionContext } from '../../types/core';
+import { VisibilityCommandBase, type VisibilityCommandInput } from './visibility-base';
+import type { VisibilityInput } from '../helpers/visibility-target-parser';
+export type HideCommandInput = VisibilityInput;
+export declare class HideCommand extends VisibilityCommandBase {
+    protected readonly mode: "hide";
+    execute(input: VisibilityCommandInput, _context: TypedExecutionContext): Promise<void>;
+    validate(input: unknown): input is VisibilityCommandInput;
+}
+export declare const createHideCommand: () => HideCommand;
+export default HideCommand;
+//# sourceMappingURL=hide.d.ts.map

package/dist/commands/dom/make.d.ts

@@ -0,0 +1,21 @@
+import type { ASTNode, TypedExecutionContext } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface MakeCommandInput {
+    article: 'a' | 'an';
+    expression: string | HTMLElement;
+    constructorArgs?: unknown[];
+    variableName?: string;
+}
+export declare class MakeCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ASTNode>;
+    }, evaluator: ExpressionEvaluator, context: TypedExecutionContext): Promise<MakeCommandInput>;
+    execute(input: MakeCommandInput, context: TypedExecutionContext): Promise<unknown>;
+}
+export declare const createMakeCommand: () => MakeCommand;
+export default MakeCommand;
+//# sourceMappingURL=make.d.ts.map

package/dist/commands/dom/process-partials.d.ts

@@ -0,0 +1,39 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type MorphOptions } from '../../lib/morph-adapter';
+import type { SwapStrategy } from './swap';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+import type { PartialValidationResult } from '../../validation/partial-validation-types';
+export interface ParsedPartial {
+    target: string;
+    strategy: SwapStrategy;
+    content: string;
+}
+export interface ProcessPartialsCommandInput {
+    html: string;
+    useViewTransition?: boolean;
+    morphOptions?: MorphOptions;
+}
+export interface ProcessPartialsResult {
+    count: number;
+    targets: string[];
+    errors: string[];
+    validationWarnings: string[];
+    validationDetails?: Record<string, PartialValidationResult>;
+}
+export declare function extractPartials(html: string): ParsedPartial[];
+export declare function processPartials(html: string, morphOptions?: MorphOptions): ProcessPartialsResult;
+export declare class ProcessPartialsCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ProcessPartialsCommandInput>;
+    execute(input: ProcessPartialsCommandInput, context: TypedExecutionContext): Promise<ProcessPartialsResult>;
+}
+export declare const createProcessPartialsCommand: () => ProcessPartialsCommand;
+export declare const processPartialsCommand: ProcessPartialsCommand;
+export default ProcessPartialsCommand;
+//# sourceMappingURL=process-partials.d.ts.map

package/dist/commands/dom/put.d.ts

@@ -0,0 +1,31 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export type InsertPosition = 'replace' | 'beforeend' | 'afterend' | 'beforebegin' | 'afterbegin';
+export interface PutCommandInput {
+    value: any;
+    targets: HTMLElement[];
+    position: InsertPosition;
+    memberPath?: string;
+    variableName?: string;
+}
+export declare class PutCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PutCommandInput>;
+    execute(input: PutCommandInput, context: TypedExecutionContext): Promise<HTMLElement[]>;
+    private mapPosition;
+    private resolveTargets;
+    private parseValue;
+    private insertContent;
+    private resolveEvaluatedAsElements;
+    private looksLikeCss;
+    private setProperty;
+}
+export declare const createPutCommand: () => PutCommand;
+export default PutCommand;
+//# sourceMappingURL=put.d.ts.map

package/dist/commands/dom/remove.d.ts

@@ -0,0 +1,33 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { DOMModificationBase } from './dom-modification-base';
+export type RemoveCommandInput = {
+    type: 'classes';
+    classes: string[];
+    targets: HTMLElement[];
+} | {
+    type: 'attribute';
+    name: string;
+    targets: HTMLElement[];
+} | {
+    type: 'styles';
+    properties: string[];
+    targets: HTMLElement[];
+} | {
+    type: 'element';
+    targets: HTMLElement[];
+};
+export declare class RemoveCommand extends DOMModificationBase {
+    protected readonly mode: "remove";
+    protected readonly preposition = "from";
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<RemoveCommandInput>;
+    execute(input: RemoveCommandInput, context: TypedExecutionContext): void;
+    validate(input: unknown): input is RemoveCommandInput;
+}
+export declare const createRemoveCommand: () => RemoveCommand;
+export default RemoveCommand;
+//# sourceMappingURL=remove.d.ts.map

package/dist/commands/dom/show.d.ts

@@ -0,0 +1,13 @@
+import type { TypedExecutionContext } from '../../types/core';
+import { VisibilityCommandBase, type VisibilityCommandInput } from './visibility-base';
+export interface ShowCommandInput extends VisibilityCommandInput {
+    defaultDisplay: string;
+}
+export declare class ShowCommand extends VisibilityCommandBase {
+    protected readonly mode: "show";
+    execute(input: VisibilityCommandInput, _context: TypedExecutionContext): Promise<void>;
+    validate(input: unknown): input is VisibilityCommandInput;
+}
+export declare const createShowCommand: () => ShowCommand;
+export default ShowCommand;
+//# sourceMappingURL=show.d.ts.map

package/dist/commands/dom/swap.d.ts

@@ -0,0 +1,38 @@
+import type { ExecutionContext, TypedExecutionContext, ASTNode } from '../../types/core';
+import type { ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type SwapStrategy } from '../../lib/swap-executor';
+import type { MorphOptions } from '../../lib/morph-adapter';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export type { SwapStrategy } from '../../lib/swap-executor';
+export interface SwapCommandInput {
+    targets: HTMLElement[];
+    content: string | HTMLElement | null;
+    strategy: SwapStrategy;
+    morphOptions?: MorphOptions;
+    useViewTransition?: boolean;
+}
+export declare class SwapCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<SwapCommandInput>;
+    execute(input: SwapCommandInput, _context: TypedExecutionContext): Promise<void>;
+}
+export declare class MorphCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<SwapCommandInput>;
+    execute(input: SwapCommandInput, _context: TypedExecutionContext): Promise<void>;
+}
+export declare const createSwapCommand: () => SwapCommand;
+export declare const createMorphCommand: () => MorphCommand;
+export declare const swapCommand: SwapCommand;
+export declare const morphCommand: MorphCommand;
+export default SwapCommand;
+//# sourceMappingURL=swap.d.ts.map

package/dist/commands/dom/toggle.d.ts

@@ -0,0 +1,55 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type PropertyTarget } from '../helpers/property-target';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export type ToggleCommandInput = {
+    type: 'classes';
+    classes: string[];
+    targets: HTMLElement[];
+    duration?: number;
+    untilEvent?: string;
+} | {
+    type: 'attribute';
+    name: string;
+    value?: string;
+    targets: HTMLElement[];
+    duration?: number;
+    untilEvent?: string;
+} | {
+    type: 'css-property';
+    property: 'display' | 'visibility' | 'opacity';
+    targets: HTMLElement[];
+} | {
+    type: 'property';
+    target: PropertyTarget;
+} | {
+    type: 'dialog';
+    mode: 'modal' | 'non-modal';
+    targets: HTMLDialogElement[];
+} | {
+    type: 'details';
+    targets: HTMLDetailsElement[];
+} | {
+    type: 'select';
+    targets: HTMLSelectElement[];
+} | {
+    type: 'classes-between';
+    classA: string;
+    classB: string;
+    targets: HTMLElement[];
+    duration?: number;
+    untilEvent?: string;
+};
+export declare class ToggleCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ToggleCommandInput>;
+    execute(input: ToggleCommandInput, context: TypedExecutionContext): Promise<HTMLElement[]>;
+}
+export declare const createToggleCommand: () => ToggleCommand;
+export default ToggleCommand;
+//# sourceMappingURL=toggle.d.ts.map

package/dist/commands/dom/visibility-base.d.ts

@@ -0,0 +1,20 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import type { DecoratedCommand, CommandMetadata } from '../decorators';
+import { type VisibilityRawInput, type VisibilityInput } from '../helpers/visibility-target-parser';
+export type VisibilityMode = 'show' | 'hide';
+export interface VisibilityCommandInput extends VisibilityInput {
+    mode: VisibilityMode;
+    defaultDisplay?: string;
+}
+export declare abstract class VisibilityCommandBase implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    protected abstract readonly mode: VisibilityMode;
+    parseInput(raw: VisibilityRawInput, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<VisibilityCommandInput>;
+    abstract execute(input: VisibilityCommandInput, context: TypedExecutionContext): Promise<void>;
+    validate(input: unknown): input is VisibilityCommandInput;
+    protected showElement(element: HTMLElement, defaultDisplay?: string): void;
+    protected hideElement(element: HTMLElement): void;
+}
+//# sourceMappingURL=visibility-base.d.ts.map

package/dist/commands/events/send.d.ts

@@ -0,0 +1,3 @@
+export { EventDispatchCommand as SendCommand, createSendCommand, type SendCommandInput, type EventOptions, } from './trigger';
+export { EventDispatchCommand as default } from './trigger';
+//# sourceMappingURL=send.d.ts.map

package/dist/commands/events/trigger.d.ts

@@ -0,0 +1,36 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import type { EventOptions } from '../helpers/event-helpers';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export type { EventOptions } from '../helpers/event-helpers';
+export type EventDispatchMode = 'trigger' | 'send';
+export interface EventDispatchInput {
+    eventName: string;
+    detail?: any;
+    targets: EventTarget[];
+    options: EventOptions;
+    mode: EventDispatchMode;
+}
+export type TriggerCommandInput = Omit<EventDispatchInput, 'mode'>;
+export type SendCommandInput = Omit<EventDispatchInput, 'mode'>;
+export declare class EventDispatchCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+        commandName?: string;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<EventDispatchInput>;
+    execute(input: EventDispatchInput, context: TypedExecutionContext): Promise<void>;
+    private resolveTargets;
+    private parseEventDetail;
+    private parseEventOptions;
+}
+export { EventDispatchCommand as TriggerCommand };
+export { EventDispatchCommand as SendCommand };
+export declare const createEventDispatchCommand: () => EventDispatchCommand;
+export declare const createTriggerCommand: () => EventDispatchCommand;
+export declare const createSendCommand: () => EventDispatchCommand;
+export default EventDispatchCommand;
+//# sourceMappingURL=trigger.d.ts.map

package/dist/commands/execution/call.d.ts

@@ -0,0 +1,24 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface CallCommandInput {
+    expression: any;
+}
+export interface CallCommandOutput {
+    result: any;
+    wasAsync: boolean;
+    expressionType: 'function' | 'promise' | 'value';
+}
+export declare class CallCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, _evaluator: ExpressionEvaluator, _context: ExecutionContext): Promise<CallCommandInput>;
+    execute(input: CallCommandInput, context: TypedExecutionContext): Promise<CallCommandOutput>;
+}
+export declare const createCallCommand: () => CallCommand;
+export default CallCommand;
+//# sourceMappingURL=call.d.ts.map

package/dist/commands/execution/pseudo-command.d.ts

@@ -0,0 +1,42 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+export interface PseudoCommandInput {
+    methodName: string;
+    methodArgs: unknown[];
+    preposition?: 'from' | 'on' | 'with' | 'into' | 'at' | 'to';
+    targetExpression: unknown;
+}
+export interface PseudoCommandOutput {
+    result: unknown;
+    methodName: string;
+    target: unknown;
+}
+export declare class PseudoCommand {
+    readonly name = "pseudo-command";
+    static readonly metadata: {
+        readonly description: "Treat a method on an object as a top-level command";
+        readonly syntax: readonly ["<method>(<args>) [(to|on|with|into|from|at)] <expression>"];
+        readonly examples: readonly ["getElementById(\"d1\") from the document", "reload() the location of the window", "setAttribute(\"foo\", \"bar\") on me", "foo() on me"];
+        readonly category: "execution";
+        readonly sideEffects: readonly ["method-execution"];
+    };
+    get metadata(): {
+        readonly description: "Treat a method on an object as a top-level command";
+        readonly syntax: readonly ["<method>(<args>) [(to|on|with|into|from|at)] <expression>"];
+        readonly examples: readonly ["getElementById(\"d1\") from the document", "reload() the location of the window", "setAttribute(\"foo\", \"bar\") on me", "foo() on me"];
+        readonly category: "execution";
+        readonly sideEffects: readonly ["method-execution"];
+    };
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PseudoCommandInput>;
+    execute(input: PseudoCommandInput, context: TypedExecutionContext): Promise<PseudoCommandOutput>;
+    private resolveTarget;
+    private resolvePropertyPath;
+    private resolveMethod;
+    private executeMethod;
+}
+export declare function createPseudoCommand(): PseudoCommand;
+//# sourceMappingURL=pseudo-command.d.ts.map