@hyperfixi/core 2.0.0

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

@@ -0,0 +1,11 @@
+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/batch-dom-operations.d.ts

@@ -0,0 +1,12 @@
+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/class-manipulation.d.ts

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

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

@@ -0,0 +1,15 @@
+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 | HTMLElement, position: ContentInsertPosition): void;
+export declare function insertContentSemantic(target: HTMLElement, content: string | HTMLElement, position: SemanticPosition): 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

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

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

@@ -0,0 +1,17 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/base-types';
+export declare function resolveElement(target: string | HTMLElement | undefined, context: ExecutionContext | TypedExecutionContext): 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): HTMLElement;
+export interface ResolveTargetsOptions {
+    filterPrepositions?: boolean;
+    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

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

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

@@ -0,0 +1,37 @@
+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): 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

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

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

@@ -0,0 +1,53 @@
+import type { TypedExecutionContext } from '../../types/core';
+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;
+}
+export declare function executeLoop(config: LoopConfig, commands: unknown, context: TypedExecutionContext, iterCtx: LoopIterationContext, executeCommands: (cmds: unknown, ctx: TypedExecutionContext) => Promise<unknown>): 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, context: TypedExecutionContext, indexVariable?: string): {
+    config: LoopConfig;
+    iterCtx: LoopIterationContext;
+};
+export declare function createUntilLoopConfig(conditionExpr: unknown, evaluateCondition: (expr: unknown, ctx: TypedExecutionContext) => 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

@@ -0,0 +1,14 @@
+import type { ASTNode, ExecutionContext } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+export interface NumericTargetRawInput {
+    args: ASTNode[];
+    modifiers: Record<string, ASTNode>;
+}
+export interface NumericTargetInput {
+    target: string | HTMLElement | number;
+    property?: string;
+    scope?: 'global' | 'local';
+    amount: number;
+}
+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

@@ -0,0 +1,30 @@
+import type { ASTNode, ExecutionContext } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+export interface PropertyTarget {
+    element: HTMLElement;
+    property: string;
+}
+export interface PropertyOfExpressionNode {
+    type: 'propertyOfExpression';
+    property: {
+        type: 'identifier';
+        name: string;
+    };
+    target: ASTNode;
+}
+export interface PropertyAccessNode {
+    type: 'propertyAccess';
+    object: ASTNode;
+    property: string;
+}
+export declare function isPropertyOfExpressionNode(node: unknown): node is PropertyOfExpressionNode;
+export declare function isPropertyAccessNode(node: unknown): node is PropertyAccessNode;
+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

@@ -0,0 +1,24 @@
+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/smart-element.d.ts

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

@@ -0,0 +1,16 @@
+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/temporal-modifiers.d.ts

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

@@ -0,0 +1,10 @@
+import type { ExecutionContext } 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(args: ASTNode[], evaluator: ExpressionEvaluator, context: ExecutionContext, commandName: string): Promise<UrlCommandInput>;
+//# sourceMappingURL=url-argument-parser.d.ts.map

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

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

@@ -0,0 +1,10 @@
+import type { ExecutionContext } from '../../types/base-types';
+export declare function convertToNumber(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 getCurrentNumericValue(target: string | HTMLElement | number, property: string | undefined, scope: string | undefined, context: ExecutionContext): number;
+export declare function setTargetValue(target: string | HTMLElement | number, 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

@@ -0,0 +1,11 @@
+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>;
+//# sourceMappingURL=visibility-target-parser.d.ts.map

package/dist/commands/index.d.ts

@@ -0,0 +1,139 @@
+export { createHideCommand as hide } from './dom/hide';
+export { createShowCommand as show } from './dom/show';
+export { createAddCommand as add } from './dom/add';
+export { createRemoveCommand as remove } from './dom/remove';
+export { createToggleCommand as toggle } from './dom/toggle';
+export { createPutCommand as put } from './dom/put';
+export { createMakeCommand as make } from './dom/make';
+export { createSwapCommand as swap, createMorphCommand as morph } from './dom/swap';
+export { createProcessPartialsCommand as processPartialsCmd } from './dom/process-partials';
+export { createWaitCommand as wait } from './async/wait';
+export { createFetchCommand as fetch } from './async/fetch';
+export { createSetCommand as set } from './data/set';
+export { createGetCommand as get } from './data/get';
+export { createIncrementCommand as increment } from './data/increment';
+export { createDecrementCommand as decrement } from './data/decrement';
+export { createDefaultCommand as defaultCmd } from './data/default';
+export { createLogCommand as log } from './utility/log';
+export { createTellCommand as tell } from './utility/tell';
+export { createCopyCommand as copy } from './utility/copy';
+export { createPickCommand as pick } from './utility/pick';
+export { createBeepCommand as beep } from './utility/beep';
+export { createTriggerCommand as trigger } from './events/trigger';
+export { createSendCommand as send } from './events/send';
+export { createGoCommand as go } from './navigation/go';
+export { createPushUrlCommand as pushUrl } from './navigation/push-url';
+export { createReplaceUrlCommand as replaceUrl } from './navigation/replace-url';
+export { createIfCommand as if_ } from './control-flow/if';
+export { createUnlessCommand as unless } from './control-flow/unless';
+export { createRepeatCommand as repeat } from './control-flow/repeat';
+export { createBreakCommand as break_ } from './control-flow/break';
+export { createContinueCommand as continue_ } from './control-flow/continue';
+export { createHaltCommand as halt } from './control-flow/halt';
+export { createReturnCommand as return_ } from './control-flow/return';
+export { createExitCommand as exit } from './control-flow/exit';
+export { createThrowCommand as throw_ } from './control-flow/throw';
+export { createCallCommand as call } from './execution/call';
+export { createPseudoCommand as pseudo } from './execution/pseudo-command';
+export { createAppendCommand as append } from './content/append';
+export { createTransitionCommand as transition } from './animation/transition';
+export { createMeasureCommand as measure } from './animation/measure';
+export { createSettleCommand as settle } from './animation/settle';
+export { createTakeCommand as take } from './animation/take';
+export { createJsCommand as js } from './advanced/js';
+export { createAsyncCommand as async_ } from './advanced/async';
+export { createInstallCommand as install } from './behaviors/install';
+export { createRenderCommand as render } from './templates/render';
+export { HideCommand, createHideCommand } from './dom/hide';
+export { ShowCommand, createShowCommand } from './dom/show';
+export { AddCommand, createAddCommand } from './dom/add';
+export { RemoveCommand, createRemoveCommand } from './dom/remove';
+export { ToggleCommand, createToggleCommand } from './dom/toggle';
+export { PutCommand, createPutCommand } from './dom/put';
+export { MakeCommand, createMakeCommand } from './dom/make';
+export { swapCommand, morphCommand, createSwapCommand, createMorphCommand } from './dom/swap';
+export { processPartialsCommand, createProcessPartialsCommand, extractPartials, processPartials, } from './dom/process-partials';
+export { WaitCommand, createWaitCommand } from './async/wait';
+export { FetchCommand, createFetchCommand, registerFetchResponseType, getCustomResponseType, } from './async/fetch';
+export { SetCommand, createSetCommand } from './data/set';
+export { GetCommand, createGetCommand } from './data/get';
+export { NumericModifyCommand, createNumericModifyCommand, IncrementCommand, createIncrementCommand, } from './data/increment';
+export { DecrementCommand, createDecrementCommand } from './data/decrement';
+export { LogCommand, createLogCommand } from './utility/log';
+export { EventDispatchCommand, createEventDispatchCommand, TriggerCommand, createTriggerCommand, } from './events/trigger';
+export { SendCommand, createSendCommand } from './events/send';
+export { GoCommand, createGoCommand } from './navigation/go';
+export { HistoryCommand, createHistoryCommand, PushUrlCommand, createPushUrlCommand, } from './navigation/push-url';
+export { ReplaceUrlCommand, createReplaceUrlCommand } from './navigation/replace-url';
+export { ConditionalCommand, createConditionalCommand, IfCommand, createIfCommand, } from './control-flow/if';
+export { RepeatCommand, createRepeatCommand } from './control-flow/repeat';
+export { BreakCommand, createBreakCommand } from './control-flow/break';
+export { ContinueCommand, createContinueCommand } from './control-flow/continue';
+export { HaltCommand, createHaltCommand } from './control-flow/halt';
+export { ReturnCommand, createReturnCommand } from './control-flow/return';
+export { ExitCommand, createExitCommand } from './control-flow/exit';
+export { CallCommand, createCallCommand } from './execution/call';
+export { AppendCommand, createAppendCommand } from './content/append';
+export { TransitionCommand, createTransitionCommand } from './animation/transition';
+export { MeasureCommand, createMeasureCommand } from './animation/measure';
+export { SettleCommand, createSettleCommand } from './animation/settle';
+export { JsCommand, createJsCommand } from './advanced/js';
+export { AsyncCommand, createAsyncCommand } from './advanced/async';
+export { UnlessCommand, createUnlessCommand } from './control-flow/unless';
+export { DefaultCommand, createDefaultCommand } from './data/default';
+export { PseudoCommand, createPseudoCommand } from './execution/pseudo-command';
+export { TellCommand, createTellCommand } from './utility/tell';
+export { CopyCommand, createCopyCommand } from './utility/copy';
+export { PickCommand, createPickCommand } from './utility/pick';
+export { ThrowCommand, createThrowCommand } from './control-flow/throw';
+export { BeepCommand, createBeepCommand } from './utility/beep';
+export { InstallCommand, createInstallCommand } from './behaviors/install';
+export { TakeCommand, createTakeCommand } from './animation/take';
+export { RenderCommand, createRenderCommand } from './templates/render';
+export type { HideCommandInput } from './dom/hide';
+export type { ShowCommandInput } from './dom/show';
+export type { AddCommandInput } from './dom/add';
+export type { RemoveCommandInput } from './dom/remove';
+export type { ToggleCommandInput } from './dom/toggle';
+export type { PutCommandInput } from './dom/put';
+export type { MakeCommandInput } from './dom/make';
+export type { SwapCommandInput, SwapStrategy } from './dom/swap';
+export type { ProcessPartialsCommandInput, ParsedPartial, ProcessPartialsResult, } from './dom/process-partials';
+export type { WaitCommandInput } from './async/wait';
+export type { FetchCommandInput, FetchResponseTypeConfig } from './async/fetch';
+export type { SetCommandInput } from './data/set';
+export type { GetCommandInput } from './data/get';
+export type { NumericModifyInput, NumericOperation, IncrementCommandInput } from './data/increment';
+export type { DecrementCommandInput } from './data/decrement';
+export type { LogCommandInput } from './utility/log';
+export type { EventDispatchInput, EventDispatchMode, TriggerCommandInput } from './events/trigger';
+export type { SendCommandInput } from './events/send';
+export type { GoCommandInput } from './navigation/go';
+export type { HistoryCommandInput, HistoryMode, PushUrlCommandInput } from './navigation/push-url';
+export type { ReplaceUrlCommandInput } from './navigation/replace-url';
+export type { ConditionalCommandInput, ConditionalCommandOutput, ConditionalMode, IfCommandInput, IfCommandOutput, } from './control-flow/if';
+export type { RepeatCommandInput } from './control-flow/repeat';
+export type { BreakCommandInput } from './control-flow/break';
+export type { ContinueCommandInput } from './control-flow/continue';
+export type { HaltCommandInput } from './control-flow/halt';
+export type { ReturnCommandInput } from './control-flow/return';
+export type { ExitCommandInput } from './control-flow/exit';
+export type { CallCommandInput } from './execution/call';
+export type { AppendCommandInput } from './content/append';
+export type { TransitionCommandInput } from './animation/transition';
+export type { MeasureCommandInput } from './animation/measure';
+export type { SettleCommandInput } from './animation/settle';
+export type { JsCommandInput } from './advanced/js';
+export type { AsyncCommandInput } from './advanced/async';
+export type { UnlessCommandInput } from './control-flow/unless';
+export type { DefaultCommandInput } from './data/default';
+export type { PseudoCommandInput } from './execution/pseudo-command';
+export type { TellCommandInput } from './utility/tell';
+export type { CopyCommandInput } from './utility/copy';
+export type { PickCommandInput } from './utility/pick';
+export type { ThrowCommandInput } from './control-flow/throw';
+export type { BeepCommandInput } from './utility/beep';
+export type { InstallCommandInput } from './behaviors/install';
+export type { TakeCommandInput } from './animation/take';
+export type { RenderCommandInput } from './templates/render';
+//# sourceMappingURL=index.d.ts.map