@hyperfixi/core 3.2.0 → 4.0.0

package/dist/commands/control-flow/halt.d.ts

@@ -1,39 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-import type { HaltSignal } from '../../types/result';
-export interface HaltCommandInput {
-    target?: unknown;
-}
-export interface HaltEventOutput {
-    halted: true;
-    timestamp: number;
-    eventHalted?: boolean;
-}
-export type HaltCommandOutput = HaltEventOutput | HaltSignal;
-export declare class HaltCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Stop command execution or prevent event defaults";
-        readonly syntax: readonly ["halt", "halt the event"];
-        readonly examples: readonly ["halt", "halt the event", "if error then halt", "on click halt the event then log \"clicked\""];
-        readonly sideEffects: readonly ["control-flow", "event-prevention"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Stop command execution or prevent event defaults";
-        readonly syntax: readonly ["halt", "halt the event"];
-        readonly examples: readonly ["halt", "halt the event", "if error then halt", "on click halt the event then log \"clicked\""];
-        readonly sideEffects: readonly ["control-flow", "event-prevention"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'halt'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<HaltCommandInput>;
-    execute(input: HaltCommandInput, context: TypedExecutionContext): Promise<HaltCommandOutput>;
-    private isEvent;
-}
-export declare const createHaltCommand: () => HaltCommand;
-export default HaltCommand;
-//# sourceMappingURL=halt.d.ts.map

package/dist/commands/control-flow/if.d.ts

@@ -1,58 +0,0 @@
-import type { ExecutionSignal } from '../../types/result';
-import type { Op } from '../../types/program';
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ASTNode } 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 ConditionalMode = 'if' | 'unless';
-export interface ConditionalCommandInput {
-    mode: ConditionalMode;
-    condition: unknown;
-    thenCommands: Op;
-    elseCommands?: Op;
-}
-export interface IfCommandInput extends ConditionalCommandInput {
-}
-export interface UnlessCommandInput {
-    condition: unknown;
-    commands: ASTNode[];
-}
-export interface ConditionalCommandOutput {
-    mode: ConditionalMode;
-    conditionResult: boolean;
-    executedBranch: 'then' | 'else' | 'none';
-    result: unknown;
-}
-export interface IfCommandOutput extends ConditionalCommandOutput {
-}
-export declare class ConditionalCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Conditional execution based on boolean expressions";
-        readonly syntax: readonly ["if <condition> then <commands>", "if <condition> then <commands> else <commands>", "unless <condition> <commands>"];
-        readonly examples: readonly ["if x > 5 then add .active", "if user.isAdmin then show #adminPanel else hide #adminPanel", "unless user.isLoggedIn showLoginForm"];
-        readonly sideEffects: readonly ["conditional-execution"];
-        readonly aliases: readonly ["unless"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Conditional execution based on boolean expressions";
-        readonly syntax: readonly ["if <condition> then <commands>", "if <condition> then <commands> else <commands>", "unless <condition> <commands>"];
-        readonly examples: readonly ["if x > 5 then add .active", "if user.isAdmin then show #adminPanel else hide #adminPanel", "unless user.isLoggedIn showLoginForm"];
-        readonly sideEffects: readonly ["conditional-execution"];
-        readonly aliases: readonly ["unless"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'if'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ConditionalCommandInput>;
-    execute(input: ConditionalCommandInput, context: TypedExecutionContext): Promise<ConditionalCommandOutput | ExecutionSignal>;
-}
-export declare const createConditionalCommand: () => ConditionalCommand;
-export { ConditionalCommand as IfCommand };
-export declare const createIfCommand: () => ConditionalCommand;
-export { ConditionalCommand as UnlessCommand };
-export declare const createUnlessCommand: () => ConditionalCommand;
-export default ConditionalCommand;
-//# sourceMappingURL=if.d.ts.map

package/dist/commands/control-flow/repeat.d.ts

@@ -1,50 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-import type { ExecutionSignal } from '../../types/result';
-import type { Op } from '../../types/program';
-export interface RepeatCommandInput {
-    type: 'for' | 'times' | 'while' | 'until' | 'until-event' | 'forever';
-    variable?: string;
-    collection?: unknown[];
-    condition?: unknown;
-    count?: number;
-    indexVariable?: string;
-    commands?: Op;
-    elseCommands?: Op;
-    bottomTested?: boolean;
-    eventName?: string;
-    eventTarget?: EventTarget;
-}
-export interface RepeatCommandOutput {
-    type: string;
-    iterations: number;
-    completed: boolean;
-    lastResult?: unknown;
-    interrupted?: boolean;
-}
-export declare class RepeatCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Iteration in hyperscript - for-in, counted, conditional, event-driven, and infinite loops";
-        readonly syntax: readonly ["repeat for <var> in <collection> { <commands> }", "repeat <count> times { <commands> }", "repeat while <condition> { <commands> }", "repeat until <condition> { <commands> }", "repeat forever { <commands> }"];
-        readonly examples: readonly ["repeat for item in items { log item }", "repeat 5 times { log \"hello\" }", "repeat for item in items index i log i end"];
-        readonly sideEffects: readonly ["iteration", "conditional-execution"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Iteration in hyperscript - for-in, counted, conditional, event-driven, and infinite loops";
-        readonly syntax: readonly ["repeat for <var> in <collection> { <commands> }", "repeat <count> times { <commands> }", "repeat while <condition> { <commands> }", "repeat until <condition> { <commands> }", "repeat forever { <commands> }"];
-        readonly examples: readonly ["repeat for item in items { log item }", "repeat 5 times { log \"hello\" }", "repeat for item in items index i log i end"];
-        readonly sideEffects: readonly ["iteration", "conditional-execution"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'repeat'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<RepeatCommandInput>;
-    execute(input: RepeatCommandInput, context: TypedExecutionContext): Promise<RepeatCommandOutput | ExecutionSignal>;
-}
-export declare const createRepeatCommand: () => RepeatCommand;
-export default RepeatCommand;
-//# sourceMappingURL=repeat.d.ts.map

package/dist/commands/control-flow/return.d.ts

@@ -1,33 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-import type { ReturnSignal } from '../../types/result';
-export interface ReturnCommandInput {
-    value?: unknown;
-}
-export type ReturnCommandOutput = ReturnSignal;
-export declare class ReturnCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Return a value from a command sequence or function, terminating execution";
-        readonly syntax: readonly ["return", "return <value>"];
-        readonly examples: readonly ["return", "return 42", "return user.name", "if found then return result"];
-        readonly sideEffects: readonly ["control-flow", "context-mutation"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Return a value from a command sequence or function, terminating execution";
-        readonly syntax: readonly ["return", "return <value>"];
-        readonly examples: readonly ["return", "return 42", "return user.name", "if found then return result"];
-        readonly sideEffects: readonly ["control-flow", "context-mutation"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'return'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ReturnCommandInput>;
-    execute(input: ReturnCommandInput, context: TypedExecutionContext): Promise<ReturnCommandOutput>;
-}
-export declare const createReturnCommand: () => ReturnCommand;
-export default ReturnCommand;
-//# sourceMappingURL=return.d.ts.map

package/dist/commands/control-flow/signal-base.d.ts

@@ -1,18 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import type { DecoratedCommand, CommandMetadata } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-import type { ExitSignal, BreakSignal, ContinueSignal } from '../../types/result';
-export type SignalType = 'break' | 'continue' | 'exit';
-export interface SignalCommandInput {
-    signalType: SignalType;
-}
-export type SignalCommandOutput = ExitSignal | BreakSignal | ContinueSignal;
-export declare abstract class ControlFlowSignalBase implements DecoratedCommand {
-    readonly name: string;
-    abstract readonly metadata: CommandMetadata;
-    protected abstract readonly signalType: SignalType;
-    parseInput(_raw: CommandRaw<'break' | 'continue' | 'exit'>, _evaluator: ExpressionEvaluator, _context: ExecutionContext): Promise<SignalCommandInput>;
-    execute(_input: SignalCommandInput, _context: TypedExecutionContext): Promise<SignalCommandOutput>;
-}
-//# sourceMappingURL=signal-base.d.ts.map

package/dist/commands/control-flow/throw.d.ts

@@ -1,34 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface ThrowCommandInput {
-    message: string | Error | unknown;
-}
-export interface ThrowCommandOutput {
-    error: Error;
-}
-export declare class ThrowCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Throw an error with a specified message";
-        readonly syntax: readonly ["throw <message>"];
-        readonly examples: readonly ["throw \"Invalid input\"", "if not valid then throw \"Validation failed\""];
-        readonly sideEffects: readonly ["error-throwing", "execution-termination"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Throw an error with a specified message";
-        readonly syntax: readonly ["throw <message>"];
-        readonly examples: readonly ["throw \"Invalid input\"", "if not valid then throw \"Validation failed\""];
-        readonly sideEffects: readonly ["error-throwing", "execution-termination"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'throw'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ThrowCommandInput>;
-    execute(input: ThrowCommandInput, _context: TypedExecutionContext): Promise<ThrowCommandOutput>;
-}
-export declare const createThrowCommand: () => ThrowCommand;
-export default ThrowCommand;
-//# sourceMappingURL=throw.d.ts.map

package/dist/commands/control-flow/unless.d.ts

@@ -1,3 +0,0 @@
-export { ConditionalCommand as UnlessCommand, createUnlessCommand, type UnlessCommandInput, type ConditionalCommandOutput as UnlessCommandOutput, } from './if';
-export { ConditionalCommand as default } from './if';
-//# sourceMappingURL=unless.d.ts.map

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

@@ -1,37 +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 ClearCommandInput = {
-    type: 'variable';
-    name: string;
-    scope?: string;
-} | {
-    type: 'form-fields';
-    targets: HTMLElement[];
-};
-export declare class ClearCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Reset a variable to null or clear the value of a form field (<input>, <textarea>, <select>)";
-        readonly syntax: readonly ["clear <var>", "clear :var", "clear <target>"];
-        readonly examples: readonly ["clear :count", "clear myVar", "clear #search", "clear <textarea/>"];
-        readonly sideEffects: readonly ["state-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Reset a variable to null or clear the value of a form field (<input>, <textarea>, <select>)";
-        readonly syntax: readonly ["clear <var>", "clear :var", "clear <target>"];
-        readonly examples: readonly ["clear :count", "clear myVar", "clear #search", "clear <textarea/>"];
-        readonly sideEffects: readonly ["state-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'clear'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ClearCommandInput>;
-    execute(input: ClearCommandInput, context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is ClearCommandInput;
-}
-export declare const createClearCommand: () => ClearCommand;
-export default ClearCommand;
-//# sourceMappingURL=clear.d.ts.map

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

@@ -1,3 +0,0 @@
-export { NumericModifyCommand as DecrementCommand, createDecrementCommand, type DecrementCommandInput, } from './increment';
-export { NumericModifyCommand as default } from './increment';
-//# sourceMappingURL=decrement.d.ts.map

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

@@ -1,60 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export type DefaultCommandInput = {
-    type: 'variable';
-    name: string;
-    value: unknown;
-    scope?: 'element' | 'global';
-} | {
-    type: 'attribute';
-    elements: HTMLElement[];
-    name: string;
-    value: unknown;
-} | {
-    type: 'property';
-    element: HTMLElement;
-    property: string;
-    value: unknown;
-} | {
-    type: 'element';
-    element: 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 {
-    static readonly metadata: {
-        readonly description: "Set a value only if it doesn't already exist";
-        readonly syntax: readonly ["default <expression> to <expression>"];
-        readonly examples: readonly ["default myVar to \"fallback\"", "default @data-theme to \"light\"", "default my innerHTML to \"No content\""];
-        readonly sideEffects: readonly ["data-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Set a value only if it doesn't already exist";
-        readonly syntax: readonly ["default <expression> to <expression>"];
-        readonly examples: readonly ["default myVar to \"fallback\"", "default @data-theme to \"light\"", "default my innerHTML to \"No content\""];
-        readonly sideEffects: readonly ["data-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'default'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<DefaultCommandInput>;
-    private extractValue;
-    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

@@ -1,35 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface GetCommandInput {
-    value: unknown;
-}
-export interface GetCommandOutput {
-    value: unknown;
-}
-export declare class GetCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Evaluate an expression and store the result in it";
-        readonly syntax: "get <expression>";
-        readonly examples: readonly ["get #my-dialog", "get <button/>", "get me.parentElement"];
-        readonly sideEffects: readonly ["context-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Evaluate an expression and store the result in it";
-        readonly syntax: "get <expression>";
-        readonly examples: readonly ["get #my-dialog", "get <button/>", "get me.parentElement"];
-        readonly sideEffects: readonly ["context-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'get'>, 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

@@ -1,42 +0,0 @@
-import type { TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } 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 {
-    static readonly metadata: {
-        readonly description: "Modify a variable or property by a specified amount (default: 1)";
-        readonly syntax: readonly ["increment <target> [by <number>]", "decrement <target> [by <number>]"];
-        readonly examples: readonly ["increment counter", "increment counter by 5", "decrement counter", "decrement counter by 5"];
-        readonly sideEffects: readonly ["data-mutation", "context-modification"];
-        readonly aliases: readonly ["decrement"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Modify a variable or property by a specified amount (default: 1)";
-        readonly syntax: readonly ["increment <target> [by <number>]", "decrement <target> [by <number>]"];
-        readonly examples: readonly ["increment counter", "increment counter by 5", "decrement counter", "decrement counter by 5"];
-        readonly sideEffects: readonly ["data-mutation", "context-modification"];
-        readonly aliases: readonly ["decrement"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    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

@@ -1,76 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ASTNode } from '../../types/base-types.ts';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator.ts';
-import { type DecoratedCommand } from '../decorators';
-import type { NodeWriterFn } from '../../parser/extensions';
-import type { CommandRaw } from '../../ast/command-slots';
-export type SetCommandInput = {
-    type: 'variable';
-    name: string;
-    value: unknown;
-    scope?: 'element' | 'global';
-} | {
-    type: 'attribute';
-    elements: 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;
-} | {
-    type: 'node-write';
-    node: ASTNode;
-    value: unknown;
-    writer: NodeWriterFn;
-};
-export interface SetCommandOutput {
-    target: string | HTMLElement;
-    value: unknown;
-    targetType: 'variable' | 'attribute' | 'property';
-}
-export declare class SetCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Set values to variables, attributes, or properties";
-        readonly syntax: readonly ["set <target> to <value>"];
-        readonly examples: readonly ["set myVar to \"value\"", "set @data-theme to \"dark\"", "set my innerHTML to \"content\""];
-        readonly sideEffects: readonly ["state-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Set values to variables, attributes, or properties";
-        readonly syntax: readonly ["set <target> to <value>"];
-        readonly examples: readonly ["set myVar to \"value\"", "set @data-theme to \"dark\"", "set my innerHTML to \"content\""];
-        readonly sideEffects: readonly ["state-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'set'>, 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

@@ -1,14 +0,0 @@
-import type { CommandMetadata, CommandCategory, CommandSideEffect } from '../../types/command-metadata';
-export interface CommandConfig {
-    name: string;
-}
-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 type CommandMetaInput = CommandMetadata;
-export declare function commandMeta<const T extends CommandMetaInput>(metadata: T): T;
-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/add.d.ts

@@ -1,44 +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 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 {
-    static readonly metadata: {
-        readonly description: "Add CSS classes, attributes, or styles to elements";
-        readonly syntax: "add <classes|@attr|{styles}> [to <target>]";
-        readonly examples: readonly ["add .active to me", "add \"active selected\" to <button/>", "add .highlighted to #modal", "add [@data-test=\"value\"] to #element"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Add CSS classes, attributes, or styles to elements";
-        readonly syntax: "add <classes|@attr|{styles}> [to <target>]";
-        readonly examples: readonly ["add .active to me", "add \"active selected\" to <button/>", "add .highlighted to #modal", "add [@data-test=\"value\"] to #element"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    protected readonly mode: "add";
-    protected readonly preposition = "to";
-    parseInput(raw: CommandRaw<'add'>, 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/close.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 CloseCommandInput {
-    targets: HTMLElement[];
-}
-export declare class CloseCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Close a dialog, details element, or popover";
-        readonly syntax: readonly ["close", "close <target>"];
-        readonly examples: readonly ["close", "close #myDialog", "close #details", "close #popup"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Close a dialog, details element, or popover";
-        readonly syntax: readonly ["close", "close <target>"];
-        readonly examples: readonly ["close", "close #myDialog", "close #details", "close #popup"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'close'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<CloseCommandInput>;
-    execute(input: CloseCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is CloseCommandInput;
-}
-export declare const createCloseCommand: () => CloseCommand;
-export default CloseCommand;
-//# sourceMappingURL=close.d.ts.map

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

@@ -1,48 +0,0 @@
-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;
-    abstract readonly metadata: CommandMetadata;
-    protected abstract readonly mode: DOMModificationMode;
-    protected abstract readonly preposition: string;
-    protected resolveTargets(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