@hyperfixi/core 3.3.0 → 4.0.1

package/dist/commands/async/fetch.d.ts

@@ -1,61 +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 FetchResponseType = 'text' | 'json' | 'html' | 'response' | 'blob' | 'arrayBuffer';
-export interface FetchResponseTypeConfig {
-    accept?: string;
-    handler: (response: Response, context: TypedExecutionContext) => Promise<unknown>;
-}
-export declare function registerFetchResponseType(name: string, config: FetchResponseTypeConfig): void;
-export declare function getCustomResponseType(name: string): FetchResponseTypeConfig | undefined;
-export declare function registerFetchThrowsOn(patterns: RegExp[]): void;
-export declare function resetFetchThrowsOn(): void;
-export declare function shouldThrowOnStatus(status: number): boolean;
-export interface FetchCommandInput {
-    url: string;
-    responseType: string;
-    options: RequestInit;
-    throwOnError?: boolean;
-}
-export type FetchResponseData = string | Response | Blob | ArrayBuffer | DocumentFragment | HTMLElement | null | unknown;
-export interface FetchCommandOutput {
-    status: number;
-    statusText: string;
-    headers: Headers;
-    data: FetchResponseData;
-    url: string;
-    duration: number;
-}
-export declare class FetchCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Make HTTP requests with lifecycle event support";
-        readonly syntax: readonly ["fetch <url>", "fetch <url> as <type>", "fetch <url> with <options>"];
-        readonly examples: readonly ["fetch \"/api/data\"", "fetch \"/api/users\" as json", "fetch \"/api/save\" with { method:\"POST\" }", "fetch \"/api/optional\" as json do not throw"];
-        readonly sideEffects: readonly ["network", "event-dispatching"];
-        readonly category: "async";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Make HTTP requests with lifecycle event support";
-        readonly syntax: readonly ["fetch <url>", "fetch <url> as <type>", "fetch <url> with <options>"];
-        readonly examples: readonly ["fetch \"/api/data\"", "fetch \"/api/users\" as json", "fetch \"/api/save\" with { method:\"POST\" }", "fetch \"/api/optional\" as json do not throw"];
-        readonly sideEffects: readonly ["network", "event-dispatching"];
-        readonly category: "async";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'fetch'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<FetchCommandInput>;
-    execute(input: FetchCommandInput, context: TypedExecutionContext): Promise<FetchCommandOutput>;
-    private parseURL;
-    private parseResponseType;
-    private parseRequestOptions;
-    private parseHeaders;
-    private parseBody;
-    private handleResponse;
-    private parseHTML;
-    private dispatchEvent;
-}
-export declare const createFetchCommand: () => FetchCommand;
-export default FetchCommand;
-//# sourceMappingURL=fetch.d.ts.map

package/dist/commands/async/wait.d.ts

@@ -1,51 +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 WaitTimeInput {
-    type: 'time';
-    milliseconds: number;
-}
-export interface WaitEventInput {
-    type: 'event';
-    eventName: string;
-    target?: EventTarget;
-    destructure?: string[];
-}
-export interface WaitRaceInput {
-    type: 'race';
-    conditions: (WaitTimeInput | WaitEventInput)[];
-}
-export type WaitCommandInput = WaitTimeInput | WaitEventInput | WaitRaceInput;
-export interface WaitCommandOutput {
-    type: 'time' | 'event';
-    result: number | Event;
-    duration: number;
-}
-export declare class WaitCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Wait for time delay, event, or race condition";
-        readonly syntax: readonly ["wait <time>", "wait for <event>", "wait for <event> or <condition>"];
-        readonly examples: readonly ["wait 2s", "wait for click", "wait for click or 1s", "wait for mousemove(clientX, clientY)"];
-        readonly sideEffects: readonly ["time", "event-listening"];
-        readonly category: "async";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Wait for time delay, event, or race condition";
-        readonly syntax: readonly ["wait <time>", "wait for <event>", "wait for <event> or <condition>"];
-        readonly examples: readonly ["wait 2s", "wait for click", "wait for click or 1s", "wait for mousemove(clientX, clientY)"];
-        readonly sideEffects: readonly ["time", "event-listening"];
-        readonly category: "async";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'wait'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<WaitCommandInput>;
-    execute(input: WaitCommandInput, context: TypedExecutionContext): Promise<WaitCommandOutput>;
-    private parseTimeWait;
-    private parseEventArrayWait;
-    private executeRace;
-}
-export declare const createWaitCommand: () => WaitCommand;
-export default WaitCommand;
-//# sourceMappingURL=wait.d.ts.map

package/dist/commands/behaviors/install.d.ts

@@ -1,40 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface InstallCommandInput {
-    behaviorName: string;
-    parameters?: Record<string, unknown>;
-    target?: unknown;
-}
-export interface InstallCommandOutput {
-    success: boolean;
-    behaviorName: string;
-    installedCount: number;
-    instances: unknown[];
-}
-export declare class InstallCommand {
-    readonly name = "install";
-    static readonly metadata: {
-        readonly description: "Install a behavior on an element with optional parameters";
-        readonly syntax: readonly ["install <BehaviorName>", "install <BehaviorName> on <element>", "install <BehaviorName>(param: value)", "install <BehaviorName>(param: value) on <element>"];
-        readonly examples: readonly ["install Removable", "install Draggable on #box", "install Tooltip(text: \"Help\", position: \"top\")", "install Sortable(axis: \"y\") on .list", "install MyBehavior(foo: 42) on the first <div/>"];
-        readonly category: "behaviors";
-        readonly compatibility: "standard";
-        readonly sideEffects: readonly ["behavior-installation", "element-modification"];
-    };
-    get metadata(): {
-        readonly description: "Install a behavior on an element with optional parameters";
-        readonly syntax: readonly ["install <BehaviorName>", "install <BehaviorName> on <element>", "install <BehaviorName>(param: value)", "install <BehaviorName>(param: value) on <element>"];
-        readonly examples: readonly ["install Removable", "install Draggable on #box", "install Tooltip(text: \"Help\", position: \"top\")", "install Sortable(axis: \"y\") on .list", "install MyBehavior(foo: 42) on the first <div/>"];
-        readonly category: "behaviors";
-        readonly compatibility: "standard";
-        readonly sideEffects: readonly ["behavior-installation", "element-modification"];
-    };
-    parseInput(raw: CommandRaw<'install'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<InstallCommandInput>;
-    execute(input: InstallCommandInput, context: TypedExecutionContext): Promise<InstallCommandOutput>;
-    private resolveTarget;
-    private behaviorExists;
-    private installBehavior;
-}
-export declare function createInstallCommand(): InstallCommand;
-//# sourceMappingURL=install.d.ts.map

package/dist/commands/content/append.d.ts

@@ -1,26 +0,0 @@
-import { ContentInsertionCommand, type InsertionCommandInput, type InsertionCommandOutput } from './insertion-base';
-export type AppendCommandInput = InsertionCommandInput;
-export type AppendCommandOutput = InsertionCommandOutput;
-export declare class AppendCommand extends ContentInsertionCommand {
-    static readonly metadata: {
-        readonly description: "Add content to the end of a string, array, Set, or HTML element";
-        readonly syntax: readonly ["append <content>", "append <content> to <target>"];
-        readonly examples: readonly ["append \"Hello\"", "append \"World\" to greeting", "append item to myArray", "append \"<p>New</p>\" to #content", "append \" (edited)\" to #title's textContent"];
-        readonly sideEffects: readonly ["data-mutation", "dom-mutation"];
-        readonly category: "content";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Add content to the end of a string, array, Set, or HTML element";
-        readonly syntax: readonly ["append <content>", "append <content> to <target>"];
-        readonly examples: readonly ["append \"Hello\"", "append \"World\" to greeting", "append item to myArray", "append \"<p>New</p>\" to #content", "append \" (edited)\" to #title's textContent"];
-        readonly sideEffects: readonly ["data-mutation", "dom-mutation"];
-        readonly category: "content";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    constructor();
-}
-export declare const createAppendCommand: () => AppendCommand;
-export default AppendCommand;
-//# sourceMappingURL=append.d.ts.map

package/dist/commands/content/insertion-base.d.ts

@@ -1,60 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type SemanticPosition } from '../helpers/dom-mutation';
-import { type PropertyTarget } from '../helpers/property-target';
-import type { DecoratedCommand, CommandMetadata } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export type InsertionPosition = Extract<SemanticPosition, 'append' | 'prepend'>;
-export type InsertionCommandInput = {
-    kind: 'selector';
-    selector: string;
-    content: unknown;
-} | {
-    kind: 'elements';
-    elements: HTMLElement[];
-    content: unknown;
-} | {
-    kind: 'attribute';
-    elements: HTMLElement[];
-    name: string;
-    content: unknown;
-} | {
-    kind: 'property';
-    property: PropertyTarget;
-    content: unknown;
-} | {
-    kind: 'variable';
-    name: string;
-    scope?: 'element' | 'global';
-    content: unknown;
-} | {
-    kind: 'value';
-    target: unknown;
-    content: unknown;
-} | {
-    kind: 'implicit';
-    content: unknown;
-};
-export interface InsertionCommandOutput {
-    target: unknown;
-    value: unknown;
-    targetType: 'element' | 'attribute' | 'property' | 'variable' | 'array' | 'set' | 'result';
-}
-export declare abstract class ContentInsertionCommand implements DecoratedCommand {
-    protected readonly position: InsertionPosition;
-    readonly name: string;
-    abstract readonly metadata: CommandMetadata;
-    protected constructor(position: InsertionPosition);
-    private concat;
-    private pushInto;
-    parseInput(raw: CommandRaw<'append' | 'prepend'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<InsertionCommandInput>;
-    execute(input: InsertionCommandInput, context: TypedExecutionContext): Promise<InsertionCommandOutput>;
-    private insertIntoSelector;
-    private insertIntoEach;
-    private combineValue;
-    private targetTypeOf;
-    private executeVariable;
-    private execImplicit;
-    private done;
-}
-//# sourceMappingURL=insertion-base.d.ts.map

package/dist/commands/content/prepend.d.ts

@@ -1,26 +0,0 @@
-import { ContentInsertionCommand, type InsertionCommandInput, type InsertionCommandOutput } from './insertion-base';
-export type PrependCommandInput = InsertionCommandInput;
-export type PrependCommandOutput = InsertionCommandOutput;
-export declare class PrependCommand extends ContentInsertionCommand {
-    static readonly metadata: {
-        readonly description: "Add content to the start of a string, array, Set, or HTML element";
-        readonly syntax: readonly ["prepend <content>", "prepend <content> to <target>"];
-        readonly examples: readonly ["prepend \"Hello\"", "prepend \"World\" to greeting", "prepend item to myArray", "prepend \"<p>First</p>\" to #content"];
-        readonly sideEffects: readonly ["data-mutation", "dom-mutation"];
-        readonly category: "content";
-        readonly compatibility: "lokascript-extension";
-    };
-    get metadata(): {
-        readonly description: "Add content to the start of a string, array, Set, or HTML element";
-        readonly syntax: readonly ["prepend <content>", "prepend <content> to <target>"];
-        readonly examples: readonly ["prepend \"Hello\"", "prepend \"World\" to greeting", "prepend item to myArray", "prepend \"<p>First</p>\" to #content"];
-        readonly sideEffects: readonly ["data-mutation", "dom-mutation"];
-        readonly category: "content";
-        readonly compatibility: "lokascript-extension";
-    };
-    readonly name: string;
-    constructor();
-}
-export declare const createPrependCommand: () => PrependCommand;
-export default PrependCommand;
-//# sourceMappingURL=prepend.d.ts.map

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

@@ -1,29 +0,0 @@
-import { ControlFlowSignalBase } from './signal-base';
-export interface BreakCommandInput {
-}
-export interface BreakCommandOutput {
-    broken: true;
-    timestamp: number;
-}
-export declare class BreakCommand extends ControlFlowSignalBase {
-    static readonly metadata: {
-        readonly description: "Exit from the current loop (repeat, for, while, until)";
-        readonly syntax: readonly ["break"];
-        readonly examples: readonly ["break", "if found then break", "repeat for item in items { if item == target then break }"];
-        readonly sideEffects: readonly ["control-flow"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Exit from the current loop (repeat, for, while, until)";
-        readonly syntax: readonly ["break"];
-        readonly examples: readonly ["break", "if found then break", "repeat for item in items { if item == target then break }"];
-        readonly sideEffects: readonly ["control-flow"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    protected readonly signalType: "break";
-}
-export declare const createBreakCommand: () => BreakCommand;
-export default BreakCommand;
-//# sourceMappingURL=break.d.ts.map

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

@@ -1,29 +0,0 @@
-import { ControlFlowSignalBase } from './signal-base';
-export interface ContinueCommandInput {
-}
-export interface ContinueCommandOutput {
-    continued: true;
-    timestamp: number;
-}
-export declare class ContinueCommand extends ControlFlowSignalBase {
-    static readonly metadata: {
-        readonly description: "Skip to the next iteration of the current loop";
-        readonly syntax: readonly ["continue"];
-        readonly examples: readonly ["continue", "if item.isInvalid then continue", "repeat for item in items { if item.skip then continue; process item }"];
-        readonly sideEffects: readonly ["control-flow"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Skip to the next iteration of the current loop";
-        readonly syntax: readonly ["continue"];
-        readonly examples: readonly ["continue", "if item.isInvalid then continue", "repeat for item in items { if item.skip then continue; process item }"];
-        readonly sideEffects: readonly ["control-flow"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    protected readonly signalType: "continue";
-}
-export declare const createContinueCommand: () => ContinueCommand;
-export default ContinueCommand;
-//# sourceMappingURL=continue.d.ts.map

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

@@ -1,29 +0,0 @@
-import { ControlFlowSignalBase } from './signal-base';
-export interface ExitCommandInput {
-}
-export interface ExitCommandOutput {
-    exited: boolean;
-    timestamp: number;
-}
-export declare class ExitCommand extends ControlFlowSignalBase {
-    static readonly metadata: {
-        readonly description: "Immediately terminate execution of the current event handler or behavior";
-        readonly syntax: readonly ["exit"];
-        readonly examples: readonly ["exit", "if no draggedItem exit", "on click if disabled exit"];
-        readonly sideEffects: readonly ["control-flow"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Immediately terminate execution of the current event handler or behavior";
-        readonly syntax: readonly ["exit"];
-        readonly examples: readonly ["exit", "if no draggedItem exit", "on click if disabled exit"];
-        readonly sideEffects: readonly ["control-flow"];
-        readonly category: "control-flow";
-        readonly compatibility: "standard";
-    };
-    protected readonly signalType: "exit";
-}
-export declare const createExitCommand: () => ExitCommand;
-export default ExitCommand;
-//# sourceMappingURL=exit.d.ts.map

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