@hyperfixi/core 3.3.0 → 4.0.1

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

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

@@ -1,35 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface CallCommandInput {
-    expression: any;
-}
-export interface CallCommandOutput {
-    result: any;
-    wasAsync: boolean;
-    expressionType: 'function' | 'promise' | 'value';
-}
-export declare class CallCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Evaluate an expression and store the result in the it variable";
-        readonly syntax: readonly ["call <expression>"];
-        readonly examples: readonly ["call myFunction()", "call fetch(\"/api/data\")", "call element.focus()"];
-        readonly sideEffects: readonly ["function-execution", "context-mutation"];
-        readonly category: "execution";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Evaluate an expression and store the result in the it variable";
-        readonly syntax: readonly ["call <expression>"];
-        readonly examples: readonly ["call myFunction()", "call fetch(\"/api/data\")", "call element.focus()"];
-        readonly sideEffects: readonly ["function-execution", "context-mutation"];
-        readonly category: "execution";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'call'>, _evaluator: unknown, _context: ExecutionContext): Promise<CallCommandInput>;
-    execute(input: CallCommandInput, context: TypedExecutionContext): Promise<CallCommandOutput>;
-}
-export declare const createCallCommand: () => CallCommand;
-export default CallCommand;
-//# sourceMappingURL=call.d.ts.map

package/dist/commands/execution/focus.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 FocusCommandInput {
-    targets: HTMLElement[];
-}
-export declare class FocusCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Focus an element (calls HTMLElement.focus())";
-        readonly syntax: readonly ["focus", "focus <target>", "focus on <target>"];
-        readonly examples: readonly ["focus", "focus #search", "focus on <input/>"];
-        readonly sideEffects: readonly ["focus"];
-        readonly category: "execution";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Focus an element (calls HTMLElement.focus())";
-        readonly syntax: readonly ["focus", "focus <target>", "focus on <target>"];
-        readonly examples: readonly ["focus", "focus #search", "focus on <input/>"];
-        readonly sideEffects: readonly ["focus"];
-        readonly category: "execution";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'focus'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<FocusCommandInput>;
-    execute(input: FocusCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is FocusCommandInput;
-}
-export declare const createFocusCommand: () => FocusCommand;
-export default FocusCommand;
-//# sourceMappingURL=focus.d.ts.map

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

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

package/dist/commands/helpers/attribute-manipulation.d.ts

@@ -1,11 +0,0 @@
-export declare function isAttributeSyntax(expression: string): boolean;
-export declare function parseAttribute(expression: string): {
-    name: string;
-    value?: string;
-};
-export declare function parseAttributeName(expression: string): string;
-export declare function parseAttributeWithValue(expression: string): {
-    name: string;
-    value: string;
-};
-//# sourceMappingURL=attribute-manipulation.d.ts.map

package/dist/commands/helpers/attribute-target.d.ts

@@ -1,9 +0,0 @@
-import type { ExecutionContext } from '../../types/core';
-import type { ASTNode } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-export interface AttributeWriteTarget {
-    elements: HTMLElement[];
-    name: string;
-}
-export declare function resolveAttributeWriteTarget(node: ASTNode | Record<string, unknown> | undefined, evaluator: ExpressionEvaluator, context: ExecutionContext, getFallbackElements: () => Promise<HTMLElement[]>): Promise<AttributeWriteTarget | null>;
-//# sourceMappingURL=attribute-target.d.ts.map

package/dist/commands/helpers/batch-dom-operations.d.ts

@@ -1,12 +0,0 @@
-export declare function batchApply<T extends HTMLElement>(targets: T[], operation: (element: T) => void): T[];
-export declare function batchApplyItems<T extends HTMLElement, U>(targets: T[], items: U[], operation: (element: T, item: U) => void): T[];
-export declare function batchAddClasses(targets: HTMLElement[], classes: string[]): HTMLElement[];
-export declare function batchRemoveClasses(targets: HTMLElement[], classes: string[]): HTMLElement[];
-export declare function batchToggleClasses(targets: HTMLElement[], classes: string[]): HTMLElement[];
-export declare function batchSetAttribute(targets: HTMLElement[], name: string, value: string): HTMLElement[];
-export declare function batchRemoveAttribute(targets: HTMLElement[], name: string): HTMLElement[];
-export declare function batchToggleAttribute(targets: HTMLElement[], name: string, value?: string): HTMLElement[];
-export declare function toggleAttribute(element: HTMLElement, name: string, value?: string): void;
-export declare function batchSetStyles(targets: HTMLElement[], styles: Record<string, string>): HTMLElement[];
-export declare function batchRemoveStyles(targets: HTMLElement[], properties: string[]): HTMLElement[];
-//# sourceMappingURL=batch-dom-operations.d.ts.map

package/dist/commands/helpers/body-ops.d.ts

@@ -1,10 +0,0 @@
-import type { Op } from '../../types/program';
-interface HasBodies {
-    args: readonly unknown[];
-    bodies?: ReadonlyArray<Op | undefined>;
-    commandName?: string;
-}
-export declare function bodyOp(raw: HasBodies, index: number): Op;
-export declare function bodyOps(raw: HasBodies, from: number): Op[];
-export {};
-//# sourceMappingURL=body-ops.d.ts.map

package/dist/commands/helpers/class-manipulation.d.ts

@@ -1,11 +0,0 @@
-export declare function parseClasses(classValue: unknown): string[];
-export declare function isDynamicClass(className: string): boolean;
-export declare function extractDynamicExpression(className: string): string;
-export declare function isValidClassName(className: string): boolean;
-export declare function normalizeClassName(cls: string): string;
-export interface ClassResolutionContext {
-    readonly locals: Map<string, unknown>;
-    readonly globals: Map<string, unknown>;
-}
-export declare function resolveDynamicClasses(classes: string[], context: ClassResolutionContext): string[];
-//# sourceMappingURL=class-manipulation.d.ts.map

package/dist/commands/helpers/condition-helpers.d.ts

@@ -1,4 +0,0 @@
-import type { ExecutionContext } from '../../types/core';
-export declare function evaluateCondition(condition: unknown, context: ExecutionContext): boolean;
-export declare function isTruthy(value: unknown): boolean;
-//# sourceMappingURL=condition-helpers.d.ts.map

package/dist/commands/helpers/dom-mutation.d.ts

@@ -1,16 +0,0 @@
-export type ContentInsertPosition = 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend' | 'replace';
-export type SemanticPosition = 'before' | 'prepend' | 'append' | 'after' | 'into';
-export declare function toInsertPosition(position: SemanticPosition): ContentInsertPosition;
-export declare function looksLikeHTML(str: string): boolean;
-export declare function insertContent(target: HTMLElement, content: string | Node, position: ContentInsertPosition): void;
-export declare function insertContentSemantic(target: HTMLElement, content: string | Node, position: SemanticPosition): void;
-export declare function insertElementsInOrder(target: HTMLElement, elements: readonly HTMLElement[], position: ContentInsertPosition): void;
-export declare function removeElement(element: HTMLElement): boolean;
-export declare function removeElements(elements: HTMLElement[]): number;
-export declare function swapElements(element1: HTMLElement, element2: HTMLElement): boolean;
-export declare function cloneElement<T extends HTMLElement>(element: T, deep?: boolean): T;
-export declare function createElementFromHTML(html: string): HTMLElement | null;
-export declare function setInnerHTML(element: HTMLElement, html: string): void;
-export declare function setTextContent(element: HTMLElement, text: string): void;
-export declare function clearElement(element: HTMLElement): void;
-//# sourceMappingURL=dom-mutation.d.ts.map

package/dist/commands/helpers/duration-parsing.d.ts

@@ -1,8 +0,0 @@
-export declare function parseDuration(value: unknown, defaultMs?: number): number;
-export declare function parseDurationStrict(value: unknown): number;
-export declare function parseCSSDurations(durationString: string): number[];
-export declare function calculateMaxAnimationTime(durations: number[], delays: number[]): number;
-export declare function camelToKebab(str: string): string;
-export declare function kebabToCamel(str: string): string;
-export declare function formatDuration(ms: number): string;
-//# sourceMappingURL=duration-parsing.d.ts.map

package/dist/commands/helpers/element-property-access.d.ts

@@ -1,7 +0,0 @@
-export declare function getElementProperty(element: HTMLElement, property: string): unknown;
-export declare function setElementProperty(element: HTMLElement, property: string, value: unknown): void;
-export declare function getElementValue(element: HTMLElement): unknown;
-export declare function setElementValue(element: HTMLElement, value: unknown): void;
-export declare function isEmpty(value: unknown): boolean;
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-//# sourceMappingURL=element-property-access.d.ts.map

package/dist/commands/helpers/element-resolution.d.ts

@@ -1,16 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/base-types';
-export declare function resolveElement(target: string | HTMLElement | undefined, context: ExecutionContext | TypedExecutionContext, commandName?: string): HTMLElement;
-export declare function resolveElements(target: string | HTMLElement | HTMLElement[] | NodeList | undefined, context: ExecutionContext | TypedExecutionContext): HTMLElement[];
-export declare function asHTMLElement(value: unknown): HTMLElement;
-export declare function isContextRef(target: string): boolean;
-export declare function isCSSSelector(target: string): boolean;
-export declare function findClosest(element: HTMLElement, selector: string): HTMLElement | null;
-export declare function findAll(element: HTMLElement, selector: string): HTMLElement[];
-export declare function resolvePossessive(possessive: string, context: ExecutionContext | TypedExecutionContext, commandName?: string): HTMLElement;
-export interface ResolveTargetsOptions {
-    fallbackModifierKey?: string;
-}
-export declare function resolveTargetsFromArgs(args: unknown[], evaluator: {
-    evaluate: (arg: any, context: any) => Promise<any>;
-}, context: ExecutionContext | TypedExecutionContext, commandName: string, options?: ResolveTargetsOptions, modifiers?: Record<string, unknown>): Promise<HTMLElement[]>;
-//# sourceMappingURL=element-resolution.d.ts.map

package/dist/commands/helpers/error-helpers.d.ts

@@ -1,17 +0,0 @@
-import type { ValidationError } from '../../types/unified-types';
-import type { ExecutionError } from '../../types/result';
-export declare function missingArgument(commandName: string, argName: string): ValidationError;
-export declare function invalidTarget(commandName: string, selector: string): ValidationError;
-export declare function noTargetElements(commandName: string): ValidationError;
-export declare function invalidClassName(commandName: string, className: string): ValidationError;
-export declare function invalidAttributeName(commandName: string, attrName: string): ValidationError;
-export declare function invalidSelector(commandName: string, selector: string): ValidationError;
-export declare function invalidUrl(commandName: string, url: string): ValidationError;
-export declare function invalidContext(commandName: string): ValidationError;
-export declare function operationFailed(commandName: string, operation: string, reason?: string): ValidationError;
-export declare function parseError(commandName: string, details: string): ValidationError;
-export declare function executionError(commandName: string, message: string, cause?: Error): ExecutionError;
-export declare function unsupportedFeature(commandName: string, feature: string): ValidationError;
-export declare function toError(thrown: unknown): Error;
-export declare function throwValidation(error: ValidationError): never;
-//# sourceMappingURL=error-helpers.d.ts.map

package/dist/commands/helpers/event-helpers.d.ts

@@ -1,13 +0,0 @@
-export interface EventOptions {
-    bubbles?: boolean;
-    cancelable?: boolean;
-    composed?: boolean;
-}
-export declare function createCustomEvent(eventName: string, detail: unknown, options?: EventOptions): CustomEvent;
-export declare function parseEventValue(value: string): unknown;
-export declare function dispatchCustomEvent(target: EventTarget, eventName: string, detail?: unknown, options?: EventOptions): CustomEvent;
-export declare function dispatchLokaScriptEvent(target: EventTarget, eventName: string, detail?: unknown, options?: EventOptions): {
-    lokascript: CustomEvent;
-    hyperfixi: CustomEvent;
-};
-//# sourceMappingURL=event-helpers.d.ts.map