@hyperfixi/core 3.2.0 → 4.0.0

package/dist/chunks/index-uCOQ8Qn0.js

@@ -1,2 +0,0 @@
-let t=null;async function n(){if(!t)try{t=await(import("./index-DQi2o8Lk.js"))}catch{throw Error("@lokascript/framework is required for LSE support. Install it: npm install @lokascript/framework")}return t}function r(){if(t)return!0;try{return require.resolve("@lokascript/framework"),!0}catch{return!1}}async function a(t,r){return(await n()).parseExplicit(t,r)}async function i(t){return(await n()).isExplicitSyntax(t)}async function o(t){return(await n()).renderExplicit(t)}async function e(t){return(await n()).fromInterchangeNode(t)}async function c(t){return(await n()).toProtocolJSON(t)}async function u(t){return(await n()).fromProtocolJSON(t)}async function s(t){return(await n()).validateProtocolJSON(t)}async function f(t){return(await n()).toEnvelopeJSON(t)}async function l(t){return(await n()).fromEnvelopeJSON(t)}async function w(t){return(await n()).isEnvelope(t)}async function p(t){return(await n()).semanticNodeToRuntimeAST(t)}export{l as fromEnvelopeJSON,e as fromInterchangeNode,u as fromProtocolJSON,w as isEnvelope,i as isExplicitSyntax,r as isLSEAvailable,a as parseExplicit,o as renderExplicit,p as semanticNodeToRuntimeAST,f as toEnvelopeJSON,c as toProtocolJSON,s as validateProtocolJSON};
-//# sourceMappingURL=index-uCOQ8Qn0.js.map

package/dist/commands/advanced/js.d.ts

@@ -1,40 +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 JsCommandInput {
-    code: string;
-    parameters?: string[];
-}
-export interface JsCommandOutput {
-    result: unknown;
-    executed: boolean;
-    codeLength: number;
-    parameters?: string[];
-    preserveArrayResult: true;
-}
-export declare class JsCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Execute inline JavaScript code with access to hyperscript context";
-        readonly syntax: readonly ["js <code> end", "js(param1, param2) <code> end"];
-        readonly examples: readonly ["js console.log(\"Hello\") end", "js(x, y) return x + y end", "js me.style.color = \"red\" end"];
-        readonly sideEffects: readonly ["code-execution", "data-mutation"];
-        readonly category: "advanced";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Execute inline JavaScript code with access to hyperscript context";
-        readonly syntax: readonly ["js <code> end", "js(param1, param2) <code> end"];
-        readonly examples: readonly ["js console.log(\"Hello\") end", "js(x, y) return x + y end", "js me.style.color = \"red\" end"];
-        readonly sideEffects: readonly ["code-execution", "data-mutation"];
-        readonly category: "advanced";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'js'>, _evaluator: ExpressionEvaluator, _context: ExecutionContext): Promise<JsCommandInput>;
-    execute(input: JsCommandInput, context: TypedExecutionContext): Promise<JsCommandOutput>;
-    private createExecutionContext;
-}
-export declare const createJsCommand: () => JsCommand;
-export default JsCommand;
-//# sourceMappingURL=js.d.ts.map

package/dist/commands/animation/measure.d.ts

@@ -1,43 +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 MeasureCommandInput {
-    target?: string | HTMLElement;
-    property?: string;
-    variable?: string;
-}
-export interface MeasureCommandOutput {
-    result: number;
-    wasAsync: boolean;
-    element: HTMLElement;
-    property: string;
-    value: number;
-    unit: string;
-    stored?: boolean;
-}
-export declare class MeasureCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Measure DOM element dimensions, positions, and properties";
-        readonly syntax: readonly ["measure", "measure <property>", "measure <target> <property>"];
-        readonly examples: readonly ["measure", "measure width", "measure #element height", "measure x and set dragX"];
-        readonly sideEffects: readonly ["data-mutation"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Measure DOM element dimensions, positions, and properties";
-        readonly syntax: readonly ["measure", "measure <property>", "measure <target> <property>"];
-        readonly examples: readonly ["measure", "measure width", "measure #element height", "measure x and set dragX"];
-        readonly sideEffects: readonly ["data-mutation"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'measure'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<MeasureCommandInput>;
-    execute(input: MeasureCommandInput, context: TypedExecutionContext): Promise<MeasureCommandOutput>;
-    private getMeasurement;
-}
-export declare const createMeasureCommand: () => MeasureCommand;
-export default MeasureCommand;
-//# sourceMappingURL=measure.d.ts.map

package/dist/commands/animation/settle.d.ts

@@ -1,38 +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 SettleCommandInput {
-    target?: string | HTMLElement;
-    timeout?: number | string;
-}
-export interface SettleCommandOutput {
-    element: HTMLElement;
-    settled: boolean;
-    timeout: number;
-    duration: number;
-}
-export declare class SettleCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Wait for CSS transitions and animations to complete";
-        readonly syntax: "settle [<target>] [for <timeout>]";
-        readonly examples: readonly ["settle", "settle #animated-element", "settle for 3000"];
-        readonly sideEffects: readonly ["timing"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Wait for CSS transitions and animations to complete";
-        readonly syntax: "settle [<target>] [for <timeout>]";
-        readonly examples: readonly ["settle", "settle #animated-element", "settle for 3000"];
-        readonly sideEffects: readonly ["timing"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'settle'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<SettleCommandInput>;
-    execute(input: SettleCommandInput, context: TypedExecutionContext): Promise<SettleCommandOutput>;
-}
-export declare const createSettleCommand: () => SettleCommand;
-export default SettleCommand;
-//# sourceMappingURL=settle.d.ts.map

package/dist/commands/animation/start-view-transition.d.ts

@@ -1,38 +0,0 @@
-import type { ExecutionSignal } from '../../types/result';
-import type { Op } from '../../types/program';
-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 StartViewTransitionInput {
-    transitionName?: string;
-    body: Op[];
-}
-export interface StartViewTransitionOutput {
-    usedViewTransition: boolean;
-    commandsExecuted: number;
-}
-export declare class StartViewTransitionCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Wrap a block of commands in document.startViewTransition()";
-        readonly syntax: readonly ["start view transition [using <type>] <body> end"];
-        readonly examples: readonly ["start view transition add .highlight to me end", "start view transition using \"slide\" add .active to #panel end", "start view transition using \"slide\" then put result into #panel end"];
-        readonly sideEffects: readonly ["animation", "dom-mutation"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Wrap a block of commands in document.startViewTransition()";
-        readonly syntax: readonly ["start view transition [using <type>] <body> end"];
-        readonly examples: readonly ["start view transition add .highlight to me end", "start view transition using \"slide\" add .active to #panel end", "start view transition using \"slide\" then put result into #panel end"];
-        readonly sideEffects: readonly ["animation", "dom-mutation"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'start'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<StartViewTransitionInput>;
-    execute(input: StartViewTransitionInput, context: TypedExecutionContext): Promise<StartViewTransitionOutput | ExecutionSignal>;
-}
-export declare const createStartViewTransitionCommand: () => StartViewTransitionCommand;
-export default StartViewTransitionCommand;
-//# sourceMappingURL=start-view-transition.d.ts.map

package/dist/commands/animation/take.d.ts

@@ -1,41 +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 TakeCommandInput {
-    property: string;
-    source?: unknown;
-    target?: unknown;
-}
-export interface TakeCommandOutput {
-    targetElement: HTMLElement;
-    property: string;
-    value: unknown;
-}
-export declare class TakeCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Move classes, attributes, and properties from one element to another";
-        readonly syntax: readonly ["take <class> [from <source>] [for <recipient>]", "take <property> from <source>", "take <property> from <source> and put it on <target>"];
-        readonly examples: readonly ["take .active from .tab for me", "take class from <#source/>", "take @data-value from <.source/> and put it on <#target/>"];
-        readonly sideEffects: readonly ["dom-mutation", "property-transfer"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Move classes, attributes, and properties from one element to another";
-        readonly syntax: readonly ["take <class> [from <source>] [for <recipient>]", "take <property> from <source>", "take <property> from <source> and put it on <target>"];
-        readonly examples: readonly ["take .active from .tab for me", "take class from <#source/>", "take @data-value from <.source/> and put it on <#target/>"];
-        readonly sideEffects: readonly ["dom-mutation", "property-transfer"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'take'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<TakeCommandInput>;
-    execute(input: TakeCommandInput, context: TypedExecutionContext): Promise<TakeCommandOutput>;
-    private firstOf;
-    private takeProperty;
-    private putProperty;
-}
-export declare const createTakeCommand: () => TakeCommand;
-export default TakeCommand;
-//# sourceMappingURL=take.d.ts.map

package/dist/commands/animation/transition.d.ts

@@ -1,49 +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 TransitionPairInput {
-    target?: string | HTMLElement | HTMLElement[];
-    property: string;
-    value: string | number;
-    from?: string | number;
-}
-export interface TransitionCommandInput extends TransitionPairInput {
-    duration?: number | string;
-    timingFunction?: string;
-    using?: string;
-    pairs?: TransitionPairInput[];
-}
-export interface TransitionCommandOutput {
-    element: HTMLElement;
-    property: string;
-    fromValue: string;
-    toValue: string;
-    duration: number;
-    completed: boolean;
-}
-export declare class TransitionCommand implements DecoratedCommand {
-    static readonly metadata: {
-        readonly description: "Animate CSS properties using CSS transitions";
-        readonly syntax: "transition <property> [from <value>] to <value> [<property> … to <value>]… [over <duration>] [using <css> | with <timing>]";
-        readonly examples: readonly ["transition opacity to 0.5", "transition my *opacity to 0 over 200ms", "transition #box's *opacity to 0 over 200ms", "transition left to 100px over 500ms", "transition background-color to red over 1s with ease-in-out", "transition *width to 100px *height to 50px over 300ms", "transition *opacity of #panel from 0 to 1 over 200ms", "transition my *opacity to 0 using \"opacity 1s ease-in\""];
-        readonly sideEffects: readonly ["style-change", "timing"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    get metadata(): {
-        readonly description: "Animate CSS properties using CSS transitions";
-        readonly syntax: "transition <property> [from <value>] to <value> [<property> … to <value>]… [over <duration>] [using <css> | with <timing>]";
-        readonly examples: readonly ["transition opacity to 0.5", "transition my *opacity to 0 over 200ms", "transition #box's *opacity to 0 over 200ms", "transition left to 100px over 500ms", "transition background-color to red over 1s with ease-in-out", "transition *width to 100px *height to 50px over 300ms", "transition *opacity of #panel from 0 to 1 over 200ms", "transition my *opacity to 0 using \"opacity 1s ease-in\""];
-        readonly sideEffects: readonly ["style-change", "timing"];
-        readonly category: "animation";
-        readonly compatibility: "standard";
-    };
-    readonly name: string;
-    parseInput(raw: CommandRaw<'transition'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<TransitionCommandInput>;
-    private laterPairs;
-    execute(input: TransitionCommandInput, context: TypedExecutionContext): Promise<TransitionCommandOutput>;
-}
-export declare const createTransitionCommand: () => TransitionCommand;
-export default TransitionCommand;
-//# sourceMappingURL=transition.d.ts.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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