@hyperfixi/core 3.3.0 → 4.0.1

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

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

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

@@ -1,60 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export type DefaultCommandInput = {
-    type: 'variable';
-    name: string;
-    value: unknown;
-    scope?: 'element' | 'global';
-} | {
-    type: 'attribute';
-    elements: HTMLElement[];
-    name: string;
-    value: unknown;
-} | {
-    type: 'property';
-    element: HTMLElement;
-    property: string;
-    value: unknown;
-} | {
-    type: 'element';
-    element: HTMLElement;
-    value: unknown;
-};
-export interface DefaultCommandOutput {
-    target: string;
-    value: unknown;
-    wasSet: boolean;
-    existingValue?: unknown;
-    targetType: 'variable' | 'attribute' | 'property' | 'element';
-}
-export declare class DefaultCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Set a value only if it doesn't already exist";
-        readonly syntax: readonly ["default <expression> to <expression>"];
-        readonly examples: readonly ["default myVar to \"fallback\"", "default @data-theme to \"light\"", "default my innerHTML to \"No content\""];
-        readonly sideEffects: readonly ["data-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Set a value only if it doesn't already exist";
-        readonly syntax: readonly ["default <expression> to <expression>"];
-        readonly examples: readonly ["default myVar to \"fallback\"", "default @data-theme to \"light\"", "default my innerHTML to \"No content\""];
-        readonly sideEffects: readonly ["data-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'default'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<DefaultCommandInput>;
-    private extractValue;
-    execute(input: DefaultCommandInput, context: TypedExecutionContext): Promise<DefaultCommandOutput>;
-    private defaultVariable;
-    private defaultAttribute;
-    private defaultElementProperty;
-    private defaultElementValue;
-}
-export declare const createDefaultCommand: () => DefaultCommand;
-export default DefaultCommand;
-//# sourceMappingURL=default.d.ts.map

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

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

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

@@ -1,42 +0,0 @@
-import type { TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import { type NumericTargetRawInput, type NumericTargetInput } from '../helpers/numeric-target-parser';
-export type NumericOperation = 'increment' | 'decrement';
-export interface NumericModifyInput extends NumericTargetInput {
-    operation: NumericOperation;
-}
-export type { NumericTargetInput as IncrementCommandInput };
-export type { NumericTargetInput as DecrementCommandInput };
-export declare class NumericModifyCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Modify a variable or property by a specified amount (default: 1)";
-        readonly syntax: readonly ["increment <target> [by <number>]", "decrement <target> [by <number>]"];
-        readonly examples: readonly ["increment counter", "increment counter by 5", "decrement counter", "decrement counter by 5"];
-        readonly sideEffects: readonly ["data-mutation", "context-modification"];
-        readonly aliases: readonly ["decrement"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Modify a variable or property by a specified amount (default: 1)";
-        readonly syntax: readonly ["increment <target> [by <number>]", "decrement <target> [by <number>]"];
-        readonly examples: readonly ["increment counter", "increment counter by 5", "decrement counter", "decrement counter by 5"];
-        readonly sideEffects: readonly ["data-mutation", "context-modification"];
-        readonly aliases: readonly ["decrement"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: NumericTargetRawInput & {
-        commandName?: string;
-    }, evaluator: ExpressionEvaluator, context: TypedExecutionContext): Promise<NumericModifyInput>;
-    execute(input: NumericModifyInput, context: TypedExecutionContext): Promise<number>;
-}
-export { NumericModifyCommand as IncrementCommand };
-export { NumericModifyCommand as DecrementCommand };
-export declare const createNumericModifyCommand: () => NumericModifyCommand;
-export declare const createIncrementCommand: () => NumericModifyCommand;
-export declare const createDecrementCommand: () => NumericModifyCommand;
-export default NumericModifyCommand;
-//# sourceMappingURL=increment.d.ts.map

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

@@ -1,76 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ASTNode } from '../../types/base-types.ts';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator.ts';
-import { type DecoratedCommand } from '../decorators';
-import type { NodeWriterFn } from '../../parser/extensions';
-import type { CommandRaw } from '../../ast/command-slots';
-export type SetCommandInput = {
-    type: 'variable';
-    name: string;
-    value: unknown;
-    scope?: 'element' | 'global';
-} | {
-    type: 'attribute';
-    elements: HTMLElement[];
-    name: string;
-    value: unknown;
-} | {
-    type: 'property';
-    element: HTMLElement;
-    property: string;
-    value: unknown;
-} | {
-    type: 'style';
-    element: HTMLElement;
-    property: string;
-    value: string;
-} | {
-    type: 'object-literal';
-    properties: Record<string, unknown>;
-    targets: HTMLElement[];
-} | {
-    type: 'member-assignment';
-    container: Record<string, unknown>;
-    property: string;
-    value: unknown;
-} | {
-    type: 'node-write';
-    node: ASTNode;
-    value: unknown;
-    writer: NodeWriterFn;
-};
-export interface SetCommandOutput {
-    target: string | HTMLElement;
-    value: unknown;
-    targetType: 'variable' | 'attribute' | 'property';
-}
-export declare class SetCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Set values to variables, attributes, or properties";
-        readonly syntax: readonly ["set <target> to <value>"];
-        readonly examples: readonly ["set myVar to \"value\"", "set @data-theme to \"dark\"", "set my innerHTML to \"content\""];
-        readonly sideEffects: readonly ["state-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Set values to variables, attributes, or properties";
-        readonly syntax: readonly ["set <target> to <value>"];
-        readonly examples: readonly ["set myVar to \"value\"", "set @data-theme to \"dark\"", "set my innerHTML to \"content\""];
-        readonly sideEffects: readonly ["state-mutation", "dom-mutation"];
-        readonly category: "data";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'set'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<SetCommandInput>;
-    execute(input: SetCommandInput, context: TypedExecutionContext): Promise<SetCommandOutput>;
-    private tryParseMemberExpression;
-    private extractValue;
-    private resolveElement;
-    private resolveTargets;
-    private parseTheXofY;
-    validate(input: unknown): input is SetCommandInput;
-}
-export declare const createSetCommand: () => SetCommand;
-export default SetCommand;
-//# sourceMappingURL=set.d.ts.map

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

@@ -1,14 +0,0 @@
-import type { CommandMetadata, CommandCategory, CommandSideEffect } from '../../types/command-metadata';
-export interface CommandConfig {
-    name: string;
-}
-export interface DecoratedCommand {
-    readonly name: string;
-    readonly metadata: CommandMetadata;
-}
-export declare function command(config: CommandConfig): <T extends new (...args: unknown[]) => object>(target: T, context: ClassDecoratorContext) => T | void;
-export type CommandMetaInput = CommandMetadata;
-export declare function commandMeta<const T extends CommandMetaInput>(metadata: T): T;
-export declare function createFactory<T extends new () => object>(CommandClass: T): () => InstanceType<T>;
-export type { CommandMetadata, CommandCategory, CommandSideEffect };
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/dom/add.d.ts

@@ -1,44 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { DOMModificationBase } from './dom-modification-base';
-import type { CommandRaw } from '../../ast/command-slots';
-export type AddCommandInput = {
-    type: 'classes';
-    classes: string[];
-    targets: HTMLElement[];
-} | {
-    type: 'attribute';
-    name: string;
-    value: string;
-    targets: HTMLElement[];
-} | {
-    type: 'styles';
-    styles: Record<string, string>;
-    targets: HTMLElement[];
-};
-export declare class AddCommand extends DOMModificationBase {
-    static readonly metadata: {
-        readonly description: "Add CSS classes, attributes, or styles to elements";
-        readonly syntax: "add <classes|@attr|{styles}> [to <target>]";
-        readonly examples: readonly ["add .active to me", "add \"active selected\" to <button/>", "add .highlighted to #modal", "add [@data-test=\"value\"] to #element"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Add CSS classes, attributes, or styles to elements";
-        readonly syntax: "add <classes|@attr|{styles}> [to <target>]";
-        readonly examples: readonly ["add .active to me", "add \"active selected\" to <button/>", "add .highlighted to #modal", "add [@data-test=\"value\"] to #element"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    protected readonly mode: "add";
-    protected readonly preposition = "to";
-    parseInput(raw: CommandRaw<'add'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<AddCommandInput>;
-    execute(input: AddCommandInput, context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is AddCommandInput;
-}
-export declare const createAddCommand: () => AddCommand;
-export default AddCommand;
-//# sourceMappingURL=add.d.ts.map

package/dist/commands/dom/close.d.ts

@@ -1,32 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface CloseCommandInput {
-    targets: HTMLElement[];
-}
-export declare class CloseCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Close a dialog, details element, or popover";
-        readonly syntax: readonly ["close", "close <target>"];
-        readonly examples: readonly ["close", "close #myDialog", "close #details", "close #popup"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Close a dialog, details element, or popover";
-        readonly syntax: readonly ["close", "close <target>"];
-        readonly examples: readonly ["close", "close #myDialog", "close #details", "close #popup"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'close'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<CloseCommandInput>;
-    execute(input: CloseCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is CloseCommandInput;
-}
-export declare const createCloseCommand: () => CloseCommand;
-export default CloseCommand;
-//# sourceMappingURL=close.d.ts.map

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

@@ -1,48 +0,0 @@
-import type { ExecutionContext } from '../../types/core';
-import type { ASTNode, ExpressionNode } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import type { DecoratedCommand, CommandMetadata } from '../decorators';
-export type DOMModificationMode = 'add' | 'remove';
-export type ClassModificationInput = {
-    type: 'classes';
-    classes: string[];
-    targets: HTMLElement[];
-};
-export type AttributeModificationInput = {
-    type: 'attribute';
-    name: string;
-    value?: string;
-    targets: HTMLElement[];
-};
-export type StyleModificationInput = {
-    type: 'styles';
-    styles?: Record<string, string>;
-    properties?: string[];
-    targets: HTMLElement[];
-};
-export type ElementRemovalInput = {
-    type: 'element';
-    targets: HTMLElement[];
-};
-export interface RawCommandInput {
-    args: ASTNode[];
-    modifiers: Record<string, ExpressionNode>;
-    commandName?: string;
-}
-export declare abstract class DOMModificationBase implements DecoratedCommand {
-    readonly name: string;
-    abstract readonly metadata: CommandMetadata;
-    protected abstract readonly mode: DOMModificationMode;
-    protected abstract readonly preposition: string;
-    protected resolveTargets(evaluator: ExpressionEvaluator, context: ExecutionContext, modifiers: Record<string, ExpressionNode>): Promise<HTMLElement[]>;
-    protected evaluateFirst(arg: ASTNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<{
-        value: unknown;
-    }>;
-    protected parseClassNames(value: unknown): string[];
-    protected isAttribute(value: string): boolean;
-    protected isCSSProperty(value: string): boolean;
-    protected validateTargets(targets: unknown): targets is HTMLElement[];
-    protected validateType<T extends string>(type: unknown, validTypes: readonly T[]): type is T;
-    protected validateStringArray(arr: unknown, minLength?: number): arr is string[];
-}
-//# sourceMappingURL=dom-modification-base.d.ts.map

package/dist/commands/dom/empty.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 EmptyCommandInput {
-    targets: HTMLElement[];
-}
-export declare class EmptyCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Remove all children from an element (sets innerHTML to empty)";
-        readonly syntax: readonly ["empty", "empty <target>", "empty the <target>"];
-        readonly examples: readonly ["empty me", "empty #list", "empty .results"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Remove all children from an element (sets innerHTML to empty)";
-        readonly syntax: readonly ["empty", "empty <target>", "empty the <target>"];
-        readonly examples: readonly ["empty me", "empty #list", "empty .results"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'empty'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<EmptyCommandInput>;
-    execute(input: EmptyCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is EmptyCommandInput;
-}
-export declare const createEmptyCommand: () => EmptyCommand;
-export default EmptyCommand;
-//# sourceMappingURL=empty.d.ts.map

package/dist/commands/dom/hide.d.ts

@@ -1,28 +0,0 @@
-import type { TypedExecutionContext } from '../../types/core';
-import { VisibilityCommandBase, type VisibilityCommandInput } from './visibility-base';
-import type { VisibilityInput } from '../helpers/visibility-target-parser';
-export type HideCommandInput = VisibilityInput;
-export declare class HideCommand extends VisibilityCommandBase {
-    static readonly metadata: {
-        readonly description: "Hide elements by setting display to none";
-        readonly syntax: "hide [<target>] [when <condition>]";
-        readonly examples: readonly ["hide me", "hide #modal", "hide .warnings", "hide <button/>", "hide <li/> when its textContent is empty"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Hide elements by setting display to none";
-        readonly syntax: "hide [<target>] [when <condition>]";
-        readonly examples: readonly ["hide me", "hide #modal", "hide .warnings", "hide <button/>", "hide <li/> when its textContent is empty"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    protected readonly mode: "hide";
-    execute(input: VisibilityCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is VisibilityCommandInput;
-}
-export declare const createHideCommand: () => HideCommand;
-export default HideCommand;
-//# sourceMappingURL=hide.d.ts.map

package/dist/commands/dom/make.d.ts

@@ -1,34 +0,0 @@
-import type { 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 MakeCommandInput {
-    article: 'a' | 'an';
-    expression: string | HTMLElement;
-    constructorArgs?: unknown[];
-    variableName?: string;
-}
-export declare class MakeCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Create DOM elements or class instances";
-        readonly syntax: readonly ["make a <tag#id.class1.class2/>", "make a <ClassName> from <args> called <identifier>"];
-        readonly examples: readonly ["make an <a.navlink/> called linkElement", "make a URL from \"/path/\", \"https://origin.example.com\""];
-        readonly sideEffects: readonly ["dom-creation", "data-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Create DOM elements or class instances";
-        readonly syntax: readonly ["make a <tag#id.class1.class2/>", "make a <ClassName> from <args> called <identifier>"];
-        readonly examples: readonly ["make an <a.navlink/> called linkElement", "make a URL from \"/path/\", \"https://origin.example.com\""];
-        readonly sideEffects: readonly ["dom-creation", "data-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'make'>, evaluator: ExpressionEvaluator, context: TypedExecutionContext): Promise<MakeCommandInput>;
-    execute(input: MakeCommandInput, context: TypedExecutionContext): Promise<unknown>;
-}
-export declare const createMakeCommand: () => MakeCommand;
-export default MakeCommand;
-//# sourceMappingURL=make.d.ts.map

package/dist/commands/dom/open.d.ts

@@ -1,34 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export type OpenDialogMode = 'modal' | 'non-modal';
-export interface OpenCommandInput {
-    targets: HTMLElement[];
-    dialogMode: OpenDialogMode;
-}
-export declare class OpenCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Open a dialog, details element, or popover";
-        readonly syntax: readonly ["open [<target>]", "open <dialog> as modal", "open <dialog> as non-modal"];
-        readonly examples: readonly ["open", "open #myDialog", "open #details", "open #popup as non-modal"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Open a dialog, details element, or popover";
-        readonly syntax: readonly ["open [<target>]", "open <dialog> as modal", "open <dialog> as non-modal"];
-        readonly examples: readonly ["open", "open #myDialog", "open #details", "open #popup as non-modal"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'open'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<OpenCommandInput>;
-    execute(input: OpenCommandInput, _context: TypedExecutionContext): Promise<void>;
-    validate(input: unknown): input is OpenCommandInput;
-}
-export declare const createOpenCommand: () => OpenCommand;
-export default OpenCommand;
-//# sourceMappingURL=open.d.ts.map

package/dist/commands/dom/process-partials.d.ts

@@ -1,51 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type MorphOptions } from '../../lib/morph-adapter';
-import type { SwapStrategy } from './swap';
-import { type DecoratedCommand } from '../decorators';
-import type { PartialValidationResult } from '../../validation/partial-validation-types';
-import type { CommandRaw } from '../../ast/command-slots';
-export interface ParsedPartial {
-    target: string;
-    strategy: SwapStrategy;
-    content: string;
-}
-export interface ProcessPartialsCommandInput {
-    html: string;
-    useViewTransition?: boolean;
-    morphOptions?: MorphOptions;
-}
-export interface ProcessPartialsResult {
-    count: number;
-    targets: string[];
-    errors: string[];
-    validationWarnings: string[];
-    validationDetails?: Record<string, PartialValidationResult>;
-}
-export declare function extractPartials(html: string): ParsedPartial[];
-export declare function processPartials(html: string, morphOptions?: MorphOptions): ProcessPartialsResult;
-export declare class ProcessPartialsCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Process <hx-partial> elements for multi-target swaps";
-        readonly syntax: readonly ["process partials in <content>", "process partials in <content> using view transition"];
-        readonly examples: readonly ["process partials in it", "process partials in fetchedHtml", "process partials in it using view transition"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "lokascript-extension";
-    };
-    get metadata(): {
-        readonly description: "Process <hx-partial> elements for multi-target swaps";
-        readonly syntax: readonly ["process partials in <content>", "process partials in <content> using view transition"];
-        readonly examples: readonly ["process partials in it", "process partials in fetchedHtml", "process partials in it using view transition"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "lokascript-extension";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'process'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ProcessPartialsCommandInput>;
-    execute(input: ProcessPartialsCommandInput, context: TypedExecutionContext): Promise<ProcessPartialsResult>;
-}
-export declare const createProcessPartialsCommand: () => ProcessPartialsCommand;
-export declare const processPartialsCommand: ProcessPartialsCommand;
-export default ProcessPartialsCommand;
-//# sourceMappingURL=process-partials.d.ts.map

package/dist/commands/dom/put.d.ts

@@ -1,42 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type ContentInsertPosition, type SemanticPosition } from '../helpers/dom-mutation';
-import { type DecoratedCommand } from '../decorators';
-import type { CommandRaw } from '../../ast/command-slots';
-export type InsertPosition = ContentInsertPosition;
-export interface PutCommandInput {
-    value: any;
-    targets: HTMLElement[];
-    position: SemanticPosition;
-    memberPath?: string;
-    variableName?: string;
-}
-export declare class PutCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Insert content into elements or properties";
-        readonly syntax: readonly ["put <value> into <target>", "put <value> before <target>", "put <value> after <target>"];
-        readonly examples: readonly ["put \"Hello World\" into me", "put <div>Content</div> before #target", "put value into #elem's innerHTML"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Insert content into elements or properties";
-        readonly syntax: readonly ["put <value> into <target>", "put <value> before <target>", "put <value> after <target>"];
-        readonly examples: readonly ["put \"Hello World\" into me", "put <div>Content</div> before #target", "put value into #elem's innerHTML"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'put'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PutCommandInput>;
-    execute(input: PutCommandInput, context: TypedExecutionContext): Promise<HTMLElement[]>;
-    private mapPosition;
-    private resolveTargets;
-    private parseValue;
-    private looksLikeCss;
-    private setProperty;
-}
-export declare const createPutCommand: () => PutCommand;
-export default PutCommand;
-//# sourceMappingURL=put.d.ts.map

package/dist/commands/dom/remove.d.ts

@@ -1,46 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { DOMModificationBase } from './dom-modification-base';
-import type { CommandRaw } from '../../ast/command-slots';
-export type RemoveCommandInput = {
-    type: 'classes';
-    classes: string[];
-    targets: HTMLElement[];
-} | {
-    type: 'attribute';
-    name: string;
-    targets: HTMLElement[];
-} | {
-    type: 'styles';
-    properties: string[];
-    targets: HTMLElement[];
-} | {
-    type: 'element';
-    targets: HTMLElement[];
-};
-export declare class RemoveCommand extends DOMModificationBase {
-    static readonly metadata: {
-        readonly description: "Remove CSS classes, attributes, styles, or elements from the DOM";
-        readonly syntax: "remove <classes|@attr|*prop|element> [from <target>]";
-        readonly examples: readonly ["remove .active from me", "remove \"active selected\" from <button/>", "remove .highlighted from #modal", "remove me", "remove closest .item"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Remove CSS classes, attributes, styles, or elements from the DOM";
-        readonly syntax: "remove <classes|@attr|*prop|element> [from <target>]";
-        readonly examples: readonly ["remove .active from me", "remove \"active selected\" from <button/>", "remove .highlighted from #modal", "remove me", "remove closest .item"];
-        readonly sideEffects: readonly ["dom-mutation"];
-        readonly category: "dom";
-        readonly compatibility: "standard";
-    };
-    protected readonly mode: "remove";
-    protected readonly preposition = "from";
-    parseInput(raw: CommandRaw<'remove'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<RemoveCommandInput>;
-    execute(input: RemoveCommandInput, context: TypedExecutionContext): void;
-    validate(input: unknown): input is RemoveCommandInput;
-}
-export declare const createRemoveCommand: () => RemoveCommand;
-export default RemoveCommand;
-//# sourceMappingURL=remove.d.ts.map