@hyperfixi/core 3.2.0 → 4.0.0

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

@@ -1,32 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface EmptyCommandInput {
-    targets: HTMLElement[];
-}
-export declare class EmptyCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Remove all children from an element (sets innerHTML to empty)";
-        readonly syntax: readonly ["empty", "empty <target>", "empty the <target>"];
-        readonly examples: readonly ["empty me", "empty #list", "empty .results"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Remove all children from an element (sets innerHTML to empty)";
-        readonly syntax: readonly ["empty", "empty <target>", "empty the <target>"];
-        readonly examples: readonly ["empty me", "empty #list", "empty .results"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'empty'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<EmptyCommandInput>;
-    execute(input: EmptyCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is EmptyCommandInput;
-}
-export declare const createEmptyCommand: () => EmptyCommand;
-export default EmptyCommand;
-//# sourceMappingURL=empty.d.ts.map

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

@@ -1,28 +0,0 @@
-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 {
-    static readonly metadata: {
-        readonly description: "Hide elements by setting display to none";
-        readonly syntax: "hide [<target>] [when <condition>]";
-        readonly examples: readonly ["hide me", "hide #modal", "hide .warnings", "hide <button/>", "hide <li/> when its textContent is empty"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Hide elements by setting display to none";
-        readonly syntax: "hide [<target>] [when <condition>]";
-        readonly examples: readonly ["hide me", "hide #modal", "hide .warnings", "hide <button/>", "hide <li/> when its textContent is empty"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    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

@@ -1,34 +0,0 @@
-import type { TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface MakeCommandInput {
-    article: 'a' | 'an';
-    expression: string | HTMLElement;
-    constructorArgs?: unknown[];
-    variableName?: string;
-}
-export declare class MakeCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Create DOM elements or class instances";
-        readonly syntax: readonly ["make a <tag#id.class1.class2/>", "make a <ClassName> from <args> called <identifier>"];
-        readonly examples: readonly ["make an <a.navlink/> called linkElement", "make a URL from \"/path/\", \"https://origin.example.com\""];
-        readonly sideEffects: readonly ["dom-creation", "data-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Create DOM elements or class instances";
-        readonly syntax: readonly ["make a <tag#id.class1.class2/>", "make a <ClassName> from <args> called <identifier>"];
-        readonly examples: readonly ["make an <a.navlink/> called linkElement", "make a URL from \"/path/\", \"https://origin.example.com\""];
-        readonly sideEffects: readonly ["dom-creation", "data-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'make'>, 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/open.d.ts

@@ -1,34 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export type OpenDialogMode = 'modal' | 'non-modal';
-export interface OpenCommandInput {
-    targets: HTMLElement[];
-    dialogMode: OpenDialogMode;
-}
-export declare class OpenCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Open a dialog, details element, or popover";
-        readonly syntax: readonly ["open [<target>]", "open <dialog> as modal", "open <dialog> as non-modal"];
-        readonly examples: readonly ["open", "open #myDialog", "open #details", "open #popup as non-modal"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Open a dialog, details element, or popover";
-        readonly syntax: readonly ["open [<target>]", "open <dialog> as modal", "open <dialog> as non-modal"];
-        readonly examples: readonly ["open", "open #myDialog", "open #details", "open #popup as non-modal"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'open'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<OpenCommandInput>;
-    execute(input: OpenCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is OpenCommandInput;
-}
-export declare const createOpenCommand: () => OpenCommand;
-export default OpenCommand;
-//# sourceMappingURL=open.d.ts.map

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

@@ -1,51 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type MorphOptions } from '../../lib/morph-adapter';
-import type { SwapStrategy } from './swap';
-import { type DecoratedCommand } from '../decorators';
-import type { PartialValidationResult } from '../../validation/partial-validation-types';
-import type { CommandRaw } from '../../ast/command-slots';
-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 {
-    static readonly metadata: {
-        readonly description: "Process <hx-partial> elements for multi-target swaps";
-        readonly syntax: readonly ["process partials in <content>", "process partials in <content> using view transition"];
-        readonly examples: readonly ["process partials in it", "process partials in fetchedHtml", "process partials in it using view transition"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "lokascript-extension";
-    };
-    get metadata(): {
-        readonly description: "Process <hx-partial> elements for multi-target swaps";
-        readonly syntax: readonly ["process partials in <content>", "process partials in <content> using view transition"];
-        readonly examples: readonly ["process partials in it", "process partials in fetchedHtml", "process partials in it using view transition"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "lokascript-extension";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'process'>, 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

@@ -1,42 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type ContentInsertPosition, type SemanticPosition } from '../helpers/dom-mutation';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export type InsertPosition = ContentInsertPosition;
-export interface PutCommandInput {
-    value: any;
-    targets: HTMLElement[];
-    position: SemanticPosition;
-    memberPath?: string;
-    variableName?: string;
-}
-export declare class PutCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Insert content into elements or properties";
-        readonly syntax: readonly ["put <value> into <target>", "put <value> before <target>", "put <value> after <target>"];
-        readonly examples: readonly ["put \"Hello World\" into me", "put <div>Content</div> before #target", "put value into #elem's innerHTML"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Insert content into elements or properties";
-        readonly syntax: readonly ["put <value> into <target>", "put <value> before <target>", "put <value> after <target>"];
-        readonly examples: readonly ["put \"Hello World\" into me", "put <div>Content</div> before #target", "put value into #elem's innerHTML"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'put'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PutCommandInput>;
-    execute(input: PutCommandInput, context: TypedExecutionContext): Promise<HTMLElement[]>;
-    private mapPosition;
-    private resolveTargets;
-    private parseValue;
-    private looksLikeCss;
-    private setProperty;
-}
-export declare const createPutCommand: () => PutCommand;
-export default PutCommand;
-//# sourceMappingURL=put.d.ts.map

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

@@ -1,46 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { DOMModificationBase } from './dom-modification-base';
-import type { CommandRaw } from '../../ast/command-slots';
-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 {
-    static readonly metadata: {
-        readonly description: "Remove CSS classes, attributes, styles, or elements from the DOM";
-        readonly syntax: "remove <classes|@attr|*prop|element> [from <target>]";
-        readonly examples: readonly ["remove .active from me", "remove \"active selected\" from <button/>", "remove .highlighted from #modal", "remove me", "remove closest .item"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Remove CSS classes, attributes, styles, or elements from the DOM";
-        readonly syntax: "remove <classes|@attr|*prop|element> [from <target>]";
-        readonly examples: readonly ["remove .active from me", "remove \"active selected\" from <button/>", "remove .highlighted from #modal", "remove me", "remove closest .item"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    protected readonly mode: "remove";
-    protected readonly preposition = "from";
-    parseInput(raw: CommandRaw<'remove'>, 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/reset.d.ts

@@ -1,32 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface ResetCommandInput {
-    targets: HTMLElement[];
-}
-export declare class ResetCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Reset a <form> element to its default values (HTMLFormElement.reset())";
-        readonly syntax: readonly ["reset", "reset <target>"];
-        readonly examples: readonly ["reset", "reset #myForm", "reset <form/>"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Reset a <form> element to its default values (HTMLFormElement.reset())";
-        readonly syntax: readonly ["reset", "reset <target>"];
-        readonly examples: readonly ["reset", "reset #myForm", "reset <form/>"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'reset'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ResetCommandInput>;
-    execute(input: ResetCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is ResetCommandInput;
-}
-export declare const createResetCommand: () => ResetCommand;
-export default ResetCommand;
-//# sourceMappingURL=reset.d.ts.map

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

@@ -1,32 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface SelectCommandInput {
-    targets: HTMLElement[];
-}
-export declare class SelectCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Select the contents of a text field, or select the contents of a DOM element";
-        readonly syntax: readonly ["select", "select <target>"];
-        readonly examples: readonly ["select #search", "select <textarea/>", "select me"];
-        readonly sideEffects: readonly ["focus", "dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Select the contents of a text field, or select the contents of a DOM element";
-        readonly syntax: readonly ["select", "select <target>"];
-        readonly examples: readonly ["select #search", "select <textarea/>", "select me"];
-        readonly sideEffects: readonly ["focus", "dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'select'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<SelectCommandInput>;
-    execute(input: SelectCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is SelectCommandInput;
-}
-export declare const createSelectCommand: () => SelectCommand;
-export default SelectCommand;
-//# sourceMappingURL=select.d.ts.map

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

@@ -1,29 +0,0 @@
-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 {
-    static readonly metadata: {
-        readonly description: "Show elements by restoring display property";
-        readonly syntax: "show [<target>] [when <condition>]";
-        readonly examples: readonly ["show me", "show #modal", "show .hidden", "show <button/>", "show <li/> when its textContent contains my value"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Show elements by restoring display property";
-        readonly syntax: "show [<target>] [when <condition>]";
-        readonly examples: readonly ["show me", "show #modal", "show .hidden", "show <button/>", "show <li/> when its textContent contains my value"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    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

@@ -1,65 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type SwapStrategy } from '../../lib/swap-executor';
-import type { MorphOptions } from '../../lib/morph-adapter';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export type { SwapStrategy } from '../../lib/swap-executor';
-export interface SwapCommandInput {
-    variant?: 'dom' | 'variable';
-    targets?: HTMLElement[];
-    content?: string | HTMLElement | null;
-    strategy?: SwapStrategy;
-    morphOptions?: MorphOptions;
-    useViewTransition?: boolean;
-    leftName?: string;
-    rightName?: string;
-}
-export declare class SwapCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Swap content into target elements with intelligent morphing support";
-        readonly syntax: readonly ["swap <target> with <content>", "swap [strategy] of <target> with <content>", "swap into <target> with <content>", "swap over <target> with <content>", "swap delete <target>", "swap <target> with <content> using view transition"];
-        readonly examples: readonly ["swap #target with it", "swap innerHTML of #target with it", "swap over #modal with fetchedContent", "swap delete #notification"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Swap content into target elements with intelligent morphing support";
-        readonly syntax: readonly ["swap <target> with <content>", "swap [strategy] of <target> with <content>", "swap into <target> with <content>", "swap over <target> with <content>", "swap delete <target>", "swap <target> with <content> using view transition"];
-        readonly examples: readonly ["swap #target with it", "swap innerHTML of #target with it", "swap over #modal with fetchedContent", "swap delete #notification"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'swap' | 'morph'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<SwapCommandInput>;
-    execute(input: SwapCommandInput, context: TypedExecutionContext): Promise<void>;
-}
-export declare class MorphCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Morph content into target elements (intelligent diffing, preserves state)";
-        readonly syntax: readonly ["morph <target> with <content>", "morph over <target> with <content>", "morph <target> with <content> using view transition"];
-        readonly examples: readonly ["morph #target with it", "morph over #modal with fetchedContent"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Morph content into target elements (intelligent diffing, preserves state)";
-        readonly syntax: readonly ["morph <target> with <content>", "morph over <target> with <content>", "morph <target> with <content> using view transition"];
-        readonly examples: readonly ["morph #target with it", "morph over #modal with fetchedContent"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'swap' | 'morph'>, 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

@@ -1,69 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type PropertyTarget } from '../helpers/property-target';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-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[];
-    duration?: number;
-    untilEvent?: string;
-} | {
-    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 {
-    static readonly metadata: {
-        readonly description: "Toggle classes, attributes, or interactive elements";
-        readonly syntax: readonly ["toggle <class> [on <target>]", "toggle @attr", "toggle <element> [as modal]", "toggle <expr> for <duration>"];
-        readonly examples: readonly ["toggle .active on me", "toggle @disabled", "toggle #myDialog as modal", "toggle .loading for 2s", "toggle between .expanded and .collapsed", "toggle .loading until click from #done"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Toggle classes, attributes, or interactive elements";
-        readonly syntax: readonly ["toggle <class> [on <target>]", "toggle @attr", "toggle <element> [as modal]", "toggle <expr> for <duration>"];
-        readonly examples: readonly ["toggle .active on me", "toggle @disabled", "toggle #myDialog as modal", "toggle .loading for 2s", "toggle between .expanded and .collapsed", "toggle .loading until click from #done"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'toggle'>, 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

@@ -1,22 +0,0 @@
-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;
-    inverse?: HTMLElement[];
-}
-export declare abstract class VisibilityCommandBase implements DecoratedCommand {
-    readonly name: string;
-    abstract readonly metadata: CommandMetadata;
-    protected abstract readonly mode: VisibilityMode;
-    readonly ownsConditionalModifier = true;
-    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

@@ -1,3 +0,0 @@
-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

@@ -1,49 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import type { EventOptions } from '../helpers/event-helpers';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export type { EventOptions } from '../helpers/event-helpers';
-export type EventDispatchMode = 'trigger' | 'send';
-export interface EventDispatchInput {
-    eventName: string;
-    detail?: unknown;
-    targets: EventTarget[];
-    options: EventOptions;
-    mode: EventDispatchMode;
-}
-export type TriggerCommandInput = Omit<EventDispatchInput, 'mode'>;
-export type SendCommandInput = Omit<EventDispatchInput, 'mode'>;
-export declare class EventDispatchCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Dispatch events on elements";
-        readonly syntax: readonly ["trigger <event> on <target>", "trigger <event>(<detail>) on <target>", "send <event> to <target>", "send <event>(<detail>) to <target>"];
-        readonly examples: readonly ["trigger click on #button", "trigger customEvent on me", "send dataEvent to #target", "send myEvent(count: 42) to me", "send saved to #form with bubbles cancelable"];
-        readonly sideEffects: readonly ["event-dispatch"];
-        readonly aliases: readonly ["send"];
-        readonly category: "event";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Dispatch events on elements";
-        readonly syntax: readonly ["trigger <event> on <target>", "trigger <event>(<detail>) on <target>", "send <event> to <target>", "send <event>(<detail>) to <target>"];
-        readonly examples: readonly ["trigger click on #button", "trigger customEvent on me", "send dataEvent to #target", "send myEvent(count: 42) to me", "send saved to #form with bubbles cancelable"];
-        readonly sideEffects: readonly ["event-dispatch"];
-        readonly aliases: readonly ["send"];
-        readonly category: "event";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'trigger'>, 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/blur.d.ts

@@ -1,32 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface BlurCommandInput {
-    targets: HTMLElement[];
-}
-export declare class BlurCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Remove focus from an element (calls HTMLElement.blur())";
-        readonly syntax: readonly ["blur", "blur <target>", "blur on <target>"];
-        readonly examples: readonly ["blur", "blur #search", "blur on <input/>"];
-        readonly sideEffects: readonly ["focus"];
-        readonly category: "execution";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Remove focus from an element (calls HTMLElement.blur())";
-        readonly syntax: readonly ["blur", "blur <target>", "blur on <target>"];
-        readonly examples: readonly ["blur", "blur #search", "blur on <input/>"];
-        readonly sideEffects: readonly ["focus"];
-        readonly category: "execution";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'blur'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<BlurCommandInput>;
-    execute(input: BlurCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is BlurCommandInput;
-}
-export declare const createBlurCommand: () => BlurCommand;
-export default BlurCommand;
-//# sourceMappingURL=blur.d.ts.map