@hyperfixi/core 3.2.0 → 4.0.0

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

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

@@ -1,37 +0,0 @@
-export interface EventWaitResult<T = Event> {
-    event: T | null;
-    timedOut: boolean;
-    cancelled: boolean;
-}
-export interface TransitionWaitResult {
-    completed: boolean;
-    cancelled: boolean;
-}
-export interface AnimationWaitResult {
-    completed: boolean;
-    type: 'transition' | 'animation' | 'timeout';
-}
-export declare function waitForEvent<T extends Event = Event>(target: EventTarget, eventName: string, timeout?: number, signal?: AbortSignal): Promise<EventWaitResult<T>>;
-export declare function waitForTime(ms: number): Promise<void>;
-export declare function waitForTransitionEnd(element: HTMLElement, property: string, duration: number): Promise<TransitionWaitResult>;
-export declare function waitForAnimationComplete(element: HTMLElement, computedAnimationTime: number, userTimeout: number): Promise<AnimationWaitResult>;
-export type WaitCondition = {
-    type: 'time';
-    ms: number;
-} | {
-    type: 'event';
-    target: EventTarget;
-    eventName: string;
-};
-export interface RaceResult {
-    winner: WaitCondition;
-    result: number | Event;
-}
-export declare function waitForFirst(conditions: WaitCondition[]): Promise<RaceResult>;
-export declare function createGuardedFinisher<T>(cleanup: () => void, resolve: (value: T) => void): (result: T) => void;
-export declare function createOnceGuard<T extends (...args: any[]) => void>(callback: T): (...args: Parameters<T>) => void;
-export declare function createCleanupManager(): {
-    add: (fn: () => void) => void;
-    cleanup: () => void;
-};
-//# sourceMappingURL=event-waiting.d.ts.map

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

@@ -1,32 +0,0 @@
-export { convertToNumber, getVariableValue, setVariableValue, resolveElementRef, getElementPropertyValue, setElementPropertyValue, getCurrentNumericValue, setTargetValue, } from './variable-access';
-export { getElementProperty, setElementProperty, getElementValue, setElementValue, isEmpty, isPlainObject, } from './element-property-access';
-export { isPropertyOfExpressionNode, isPropertyAccessNode, isPropertyTargetString, resolvePropertyTargetFromNode, resolvePropertyTargetFromAccessNode, resolvePropertyTargetFromString, resolveAnyPropertyTarget, readPropertyTarget, writePropertyTarget, togglePropertyTarget, } from './property-target';
-export type { PropertyTarget, PropertyOfExpressionNode, PropertyAccessNode, } from './property-target';
-export { resolveElement, resolveElements, resolveTargetsFromArgs, asHTMLElement, isContextRef, isCSSSelector, findClosest, findAll, resolvePossessive, } from './element-resolution';
-export type { ResolveTargetsOptions } from './element-resolution';
-export { parseDuration, parseDurationStrict, parseCSSDurations, calculateMaxAnimationTime, camelToKebab, kebabToCamel, formatDuration, } from './duration-parsing';
-export { parseClasses, isValidClassName, normalizeClassName } from './class-manipulation';
-export { isAttributeSyntax, parseAttribute, parseAttributeName, parseAttributeWithValue, } from './attribute-manipulation';
-export { createCustomEvent, parseEventValue, dispatchCustomEvent } from './event-helpers';
-export type { EventOptions } from './event-helpers';
-export { evaluateCondition, isTruthy } from './condition-helpers';
-export { validateUrl, isExternalUrl, isSafeUrl, normalizeUrl, extractSearchParams, buildUrlWithParams, } from './url-validation';
-export { parseCSSProperty, isCSSPropertySyntax, parseToggleableCSSProperty, getComputedStyleValue, setStyleValue, removeStyleProperty, toggleCSSProperty, isDisplayNone, isVisibilityHidden, isOpacityZero, } from './style-manipulation';
-export type { ToggleableCSSProperty, ParsedCSSProperty } from './style-manipulation';
-export { detectSelectorType, isSmartElementTag, isSmartElementSelector, extractSelectorValue, isClassSelectorNode, isIdSelectorNode, isBareSmartElementNode, SMART_ELEMENT_TAGS, evaluateFirstArg, detectInputType, } from './selector-type-detection';
-export type { SelectorType, SmartElementTag, CommandInputType, ParsedFirstArg, } from './selector-type-detection';
-export { validateTargetArray, isValidTargetArray, validateStringArray, isValidStringArray, validateTypeDiscriminator, isValidType, validateDefined, isDefined, validateNonEmptyString, isNonEmptyString, combineValidations, createValidator, } from './input-validator';
-export type { ValidationResult as InputValidationResult } from './input-validator';
-export { detectSmartElementType, resolveSmartElementTargets, toggleDialog, toggleDetails, toggleSelect, toggleSmartElement, isSmartElement, isDialogElement, isDetailsElement, isSelectElement, isSummaryElement, } from './smart-element';
-export type { SmartElementType, DialogMode } from './smart-element';
-export { toInsertPosition, looksLikeHTML, insertContent, insertContentSemantic, insertElementsInOrder, removeElement, removeElements, swapElements, cloneElement, createElementFromHTML, setInnerHTML, setTextContent, clearElement, } from './dom-mutation';
-export type { ContentInsertPosition, SemanticPosition } from './dom-mutation';
-export { batchApply, batchApplyItems, batchAddClasses, batchRemoveClasses, batchToggleClasses, batchSetAttribute, batchRemoveAttribute, batchToggleAttribute, toggleAttribute, batchSetStyles, batchRemoveStyles, } from './batch-dom-operations';
-export { waitForEvent, waitForTime, waitForTransitionEnd, waitForAnimationComplete, waitForFirst, createGuardedFinisher, createOnceGuard, createCleanupManager, } from './event-waiting';
-export type { EventWaitResult, TransitionWaitResult, AnimationWaitResult, WaitCondition, RaceResult, } from './event-waiting';
-export { createReversionFn, setupDurationReversion, setupEventReversion, setupTemporalModifiers, setupTemporalModifiersForElements, } from './temporal-modifiers';
-export type { ToggleType, CleanupFn, TemporalModifierOptions } from './temporal-modifiers';
-export { executeLoop, createForLoopConfig, createTimesLoopConfig, createWhileLoopConfig, createUntilLoopConfig, createUntilEventLoopConfig, createForeverLoopConfig, } from './loop-executor';
-export type { LoopConfig, LoopIterationContext, LoopResult } from './loop-executor';
-export { missingArgument, invalidTarget, noTargetElements, invalidClassName, invalidAttributeName, invalidSelector, invalidUrl, invalidContext, operationFailed, parseError, executionError, unsupportedFeature, toError, throwValidation, } from './error-helpers';
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/helpers/input-validator.d.ts

@@ -1,23 +0,0 @@
-export interface ValidationResult {
-    valid: boolean;
-    error?: string;
-}
-export declare function validateTargetArray(targets: unknown[], commandName?: string): ValidationResult;
-export declare function isValidTargetArray(targets: unknown[]): targets is HTMLElement[];
-export declare function validateStringArray(arr: unknown[], fieldName?: string, minLength?: number): ValidationResult;
-export declare function isValidStringArray(arr: unknown[], minLength?: number): arr is string[];
-export declare function validateTypeDiscriminator<T extends string>(type: unknown, allowed: readonly T[], commandName?: string): ValidationResult;
-export declare function isValidType<T extends string>(type: unknown, allowed: readonly T[]): type is T;
-export declare function validateDefined(value: unknown, fieldName: string): ValidationResult;
-export declare function isDefined<T>(value: T | null | undefined): value is T;
-export declare function validateNonEmptyString(value: unknown, fieldName: string): ValidationResult;
-export declare function isNonEmptyString(value: unknown): value is string;
-export declare function combineValidations(...results: ValidationResult[]): ValidationResult;
-export declare function createValidator(commandName: string): {
-    targets: (targets: unknown[]) => ValidationResult;
-    strings: (arr: unknown[], fieldName: string, minLength?: number) => ValidationResult;
-    type: <T extends string>(type: unknown, allowed: readonly T[]) => ValidationResult;
-    defined: (value: unknown, fieldName: string) => ValidationResult;
-    nonEmptyString: (value: unknown, fieldName: string) => ValidationResult;
-};
-//# sourceMappingURL=input-validator.d.ts.map

package/dist/commands/helpers/loop-executor.d.ts

@@ -1,56 +0,0 @@
-import type { TypedExecutionContext } from '../../types/core';
-import type { ExecutionSignal } from '../../types/result';
-import type { Op } from '../../types/program';
-export interface LoopConfig {
-    type: 'for' | 'times' | 'while' | 'until' | 'until-event' | 'forever';
-    maxIterations?: number;
-    shouldContinue: (ctx: LoopIterationContext) => boolean | Promise<boolean>;
-    beforeIteration?: (ctx: LoopIterationContext, context: TypedExecutionContext) => void | Promise<void>;
-    eventSetup?: {
-        eventName: string;
-        target: EventTarget;
-        onEvent: () => void;
-    };
-}
-export interface LoopIterationContext {
-    index: number;
-    item?: unknown;
-    collection?: unknown[];
-    count?: number;
-    conditionExpr?: unknown;
-    indexVariable?: string;
-    itemVariable?: string;
-    eventFired?: boolean;
-}
-export interface LoopResult {
-    iterations: number;
-    lastResult: unknown;
-    interrupted: boolean;
-    signal?: ExecutionSignal;
-}
-export declare function executeLoop(config: LoopConfig, context: TypedExecutionContext, iterCtx: LoopIterationContext, body: Op): Promise<LoopResult>;
-export declare function createForLoopConfig(collection: unknown[], itemVariable: string, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createTimesLoopConfig(count: number, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createWhileLoopConfig(conditionExpr: unknown, evaluateCondition: (expr: unknown, ctx: TypedExecutionContext) => boolean | Promise<boolean>, context: TypedExecutionContext, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createUntilLoopConfig(conditionExpr: unknown, evaluateCondition: (expr: unknown, ctx: TypedExecutionContext) => boolean | Promise<boolean>, context: TypedExecutionContext, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createUntilEventLoopConfig(eventName: string, eventTarget: EventTarget, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createForeverLoopConfig(indexVariable?: string, maxIterations?: number): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-//# sourceMappingURL=loop-executor.d.ts.map

package/dist/commands/helpers/numeric-target-parser.d.ts

@@ -1,21 +0,0 @@
-import type { ASTNode, ExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type NodeWriterFn } from '../../parser/extensions';
-export interface NumericTargetRawInput {
-    args: ASTNode[];
-    modifiers: Record<string, ASTNode>;
-}
-export interface NumericCustomWrite {
-    node: ASTNode;
-    writer: NodeWriterFn;
-    currentValue: number;
-}
-export interface NumericTargetInput {
-    target: string | HTMLElement | number | Record<string, unknown>;
-    property?: string;
-    scope?: 'global' | 'local';
-    amount: number;
-    customWrite?: NumericCustomWrite;
-}
-export declare function parseNumericTargetInput(raw: NumericTargetRawInput, evaluator: ExpressionEvaluator, context: ExecutionContext, commandName: string): Promise<NumericTargetInput>;
-//# sourceMappingURL=numeric-target-parser.d.ts.map

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

@@ -1,20 +0,0 @@
-import type { ASTNode, ExecutionContext } from '../../types/base-types';
-import type { PropertyOfExpressionNode, PropertyAccessNode } from '../../ast/nodes';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-export interface PropertyTarget {
-    element: HTMLElement;
-    property: string;
-}
-export type { PropertyOfExpressionNode, PropertyAccessNode };
-import { isPropertyOfExpressionNode as isPropertyOfExpressionNodeGuard, isPropertyAccessNode as isPropertyAccessNodeGuard } from '../../ast/guards';
-export declare const isPropertyOfExpressionNode: typeof isPropertyOfExpressionNodeGuard;
-export declare const isPropertyAccessNode: typeof isPropertyAccessNodeGuard;
-export declare function isPropertyTargetString(value: unknown): value is string;
-export declare function resolvePropertyTargetFromNode(node: PropertyOfExpressionNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PropertyTarget | null>;
-export declare function resolvePropertyTargetFromAccessNode(node: PropertyAccessNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PropertyTarget | null>;
-export declare function resolvePropertyTargetFromString(value: string, context: ExecutionContext): PropertyTarget | null;
-export declare function resolveAnyPropertyTarget(node: ASTNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PropertyTarget | null>;
-export declare function readPropertyTarget(target: PropertyTarget): unknown;
-export declare function writePropertyTarget(target: PropertyTarget, value: unknown): void;
-export declare function togglePropertyTarget(target: PropertyTarget): unknown;
-//# sourceMappingURL=property-target.d.ts.map

package/dist/commands/helpers/selector-type-detection.d.ts

@@ -1,24 +0,0 @@
-import type { ASTNode, ExecutionContext } from '../../types/base-types';
-export type SelectorType = 'class' | 'attribute' | 'css-property' | 'element' | 'identifier' | 'unknown';
-export type SmartElementTag = 'dialog' | 'details' | 'summary' | 'select';
-export declare const SMART_ELEMENT_TAGS: readonly SmartElementTag[];
-export declare function detectSelectorType(value: string): SelectorType;
-export declare function isSmartElementTag(tag: string): tag is SmartElementTag;
-export declare function isSmartElementSelector(selector: string): boolean;
-export declare function extractSelectorValue(node: ASTNode): string | null;
-export declare function isClassSelectorNode(node: ASTNode): boolean;
-export declare function isIdSelectorNode(node: ASTNode): boolean;
-export declare function isCSSPropertySelectorNode(node: ASTNode): boolean;
-export declare function isAttributeSelectorNode(node: ASTNode): boolean;
-export declare function extractAttributeValue(node: ASTNode): string | null;
-export declare function isBareSmartElementNode(node: ASTNode): boolean;
-export type CommandInputType = 'classes' | 'attribute' | 'css-property' | 'element' | 'styles' | 'unknown';
-export interface ParsedFirstArg {
-    value: unknown;
-    extractedFromNode: boolean;
-}
-export declare function evaluateFirstArg(firstArg: ASTNode, evaluator: {
-    evaluate: (node: ASTNode, context: ExecutionContext) => Promise<unknown>;
-}, context: ExecutionContext): Promise<ParsedFirstArg>;
-export declare function detectInputType(value: string): CommandInputType;
-//# sourceMappingURL=selector-type-detection.d.ts.map

package/dist/commands/helpers/slots.d.ts

@@ -1,5 +0,0 @@
-import type { ExecutionContext, ExpressionNode } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-export declare function requireSlot(node: ExpressionNode | undefined, what: string): ExpressionNode;
-export declare function evaluateSlot(evaluator: ExpressionEvaluator, context: ExecutionContext, node: ExpressionNode | undefined, what: string): Promise<unknown>;
-//# sourceMappingURL=slots.d.ts.map

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

@@ -1,16 +0,0 @@
-export type SmartElementType = 'dialog' | 'details' | 'select' | null;
-export type DialogMode = 'modal' | 'non-modal';
-export declare function detectSmartElementType(elements: HTMLElement[]): SmartElementType;
-export declare function resolveSmartElementTargets(elements: HTMLElement[]): HTMLElement[];
-export declare function toggleDialog(dialog: HTMLDialogElement, mode: DialogMode): void;
-export declare function toggleDetails(details: HTMLDetailsElement): void;
-export declare function toggleSelect(select: HTMLSelectElement): void;
-export declare function toggleSmartElement(element: HTMLElement, type: SmartElementType, options?: {
-    dialogMode?: DialogMode;
-}): boolean;
-export declare function isSmartElement(element: HTMLElement): boolean;
-export declare function isDialogElement(element: HTMLElement): element is HTMLDialogElement;
-export declare function isDetailsElement(element: HTMLElement): element is HTMLDetailsElement;
-export declare function isSelectElement(element: HTMLElement): element is HTMLSelectElement;
-export declare function isSummaryElement(element: HTMLElement): boolean;
-//# sourceMappingURL=smart-element.d.ts.map

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

@@ -1,16 +0,0 @@
-export type ToggleableCSSProperty = 'display' | 'visibility' | 'opacity';
-export interface ParsedCSSProperty {
-    property: string;
-    value?: string;
-}
-export declare function parseCSSProperty(expression: string): ParsedCSSProperty | null;
-export declare function isCSSPropertySyntax(value: string): boolean;
-export declare function parseToggleableCSSProperty(expression: string): ToggleableCSSProperty | null;
-export declare function getComputedStyleValue(element: HTMLElement, property: string): string;
-export declare function setStyleValue(element: HTMLElement, property: string, value: string): void;
-export declare function removeStyleProperty(element: HTMLElement, property: string): void;
-export declare function toggleCSSProperty(element: HTMLElement, property: ToggleableCSSProperty): void;
-export declare function isDisplayNone(element: HTMLElement): boolean;
-export declare function isVisibilityHidden(element: HTMLElement): boolean;
-export declare function isOpacityZero(element: HTMLElement): boolean;
-//# sourceMappingURL=style-manipulation.d.ts.map

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

@@ -1,5 +0,0 @@
-export declare function resolveTargetElements(matches: unknown, selector: unknown, fromQuery?: boolean): unknown;
-export declare function queryTargetElements(selector: string): HTMLElement[];
-export declare function toElementListFiltered(value: unknown): HTMLElement[] | null;
-export declare function toElementListStrict(value: unknown): HTMLElement[] | null;
-//# sourceMappingURL=target-elements.d.ts.map

package/dist/commands/helpers/temporal-modifiers.d.ts

@@ -1,15 +0,0 @@
-export type ToggleType = 'class' | 'attribute';
-export type CleanupFn = () => void;
-export declare function createReversionFn(element: HTMLElement, toggleType: ToggleType, identifier: string): () => void;
-export declare function setupDurationReversion(element: HTMLElement, toggleType: ToggleType, identifier: string, duration: number): CleanupFn;
-export declare function setupEventReversion(element: HTMLElement, toggleType: ToggleType, identifier: string, eventName: string): CleanupFn;
-export interface TemporalModifierOptions {
-    element: HTMLElement;
-    toggleType: ToggleType;
-    identifier: string;
-    duration?: number;
-    untilEvent?: string;
-}
-export declare function setupTemporalModifiers(options: TemporalModifierOptions): CleanupFn[];
-export declare function setupTemporalModifiersForElements(elements: HTMLElement[], toggleType: ToggleType, identifier: string, duration?: number, untilEvent?: string): CleanupFn;
-//# sourceMappingURL=temporal-modifiers.d.ts.map

package/dist/commands/helpers/url-argument-parser.d.ts

@@ -1,13 +0,0 @@
-import type { ExecutionContext, ExpressionNode } from '../../types/core';
-import type { ASTNode } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-export interface UrlCommandInput {
-    url: string;
-    title?: string;
-    state?: Record<string, unknown>;
-}
-export declare function parseUrlArguments(raw: {
-    args: ASTNode[];
-    modifiers?: Record<string, ExpressionNode>;
-}, evaluator: ExpressionEvaluator, context: ExecutionContext, commandName: string): Promise<UrlCommandInput>;
-//# sourceMappingURL=url-argument-parser.d.ts.map

package/dist/commands/helpers/url-validation.d.ts

@@ -1,7 +0,0 @@
-export declare function validateUrl(url: unknown, commandName: string, debugInfo?: string): string;
-export declare function isExternalUrl(url: string): boolean;
-export declare function isSafeUrl(url: string): boolean;
-export declare function normalizeUrl(url: string): string;
-export declare function extractSearchParams(url: string): URLSearchParams;
-export declare function buildUrlWithParams(basePath: string, params: Record<string, string> | URLSearchParams | FormData): string;
-//# sourceMappingURL=url-validation.d.ts.map

package/dist/commands/helpers/variable-access.d.ts

@@ -1,13 +0,0 @@
-import type { ExecutionContext } from '../../types/base-types';
-export declare function convertToNumber(value: unknown): number;
-export declare function counterAmount(value: unknown): number;
-export declare function counterValue(value: unknown): number;
-export declare function getVariableValue(name: string, context: ExecutionContext, preferredScope?: string): unknown;
-export declare function setVariableValue(name: string, value: unknown, context: ExecutionContext, preferredScope?: string): void;
-export declare function resolveElementRef(elementRef: string, context: ExecutionContext): unknown;
-export declare function getElementPropertyValue(propertyPath: string, context: ExecutionContext): number;
-export declare function setElementPropertyValue(propertyPath: string, value: unknown, context: ExecutionContext): void;
-export declare function isObjectOwner(value: unknown): value is Record<string, unknown>;
-export declare function getCurrentNumericValue(target: string | HTMLElement | number | Record<string, unknown>, property: string | undefined, scope: string | undefined, context: ExecutionContext): number;
-export declare function setTargetValue(target: string | HTMLElement | number | Record<string, unknown>, property: string | undefined, scope: string | undefined, newValue: unknown, context: ExecutionContext): void;
-//# sourceMappingURL=variable-access.d.ts.map

package/dist/commands/helpers/visibility-target-parser.d.ts

@@ -1,15 +0,0 @@
-import type { ASTNode, ExecutionContext, ExpressionNode } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-export interface VisibilityRawInput {
-    args: ASTNode[];
-    modifiers: Record<string, ExpressionNode>;
-}
-export interface VisibilityInput {
-    targets: HTMLElement[];
-}
-export declare function parseVisibilityInput(raw: VisibilityRawInput, evaluator: ExpressionEvaluator, context: ExecutionContext, commandName: string): Promise<VisibilityInput>;
-export declare function partitionByCondition(targets: HTMLElement[], condition: ASTNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<{
-    matched: HTMLElement[];
-    unmatched: HTMLElement[];
-}>;
-//# sourceMappingURL=visibility-target-parser.d.ts.map