@hyperfixi/core 2.0.0

package/dist/compatibility/browser-bundle-textshelf-minimal.d.ts

@@ -0,0 +1,16 @@
+import type { ASTNode } from '../parser/hybrid/ast-types';
+declare function processElements(root?: Element | Document): void;
+declare const api: {
+    version: string;
+    parse(code: string): ASTNode;
+    execute(code: string, element?: Element): Promise<any>;
+    run: (code: string, element?: Element) => Promise<any>;
+    eval: (code: string, element?: Element) => Promise<any>;
+    init: typeof processElements;
+    process: typeof processElements;
+    commands: string[];
+    parserName: string;
+};
+export default api;
+export { api, processElements };
+//# sourceMappingURL=browser-bundle-textshelf-minimal.d.ts.map

package/dist/compatibility/browser-bundle-textshelf-profile.d.ts

@@ -0,0 +1,18 @@
+import { type LokaScriptRuntime } from '../runtime/runtime-factory';
+declare const hyperfixi: LokaScriptRuntime;
+declare function processElements(root?: Element | Document): void;
+declare const api: {
+    version: string;
+    parse: (code: string) => any;
+    execute: (code: string, element?: Element) => Promise<unknown>;
+    run: (code: string, element?: Element) => Promise<unknown>;
+    eval: (code: string, element?: Element) => Promise<unknown>;
+    init: () => void;
+    process: typeof processElements;
+    runtime: import("..").RuntimeBase;
+    commands: string[];
+    parserName: string;
+};
+export default api;
+export { hyperfixi, api, processElements };
+//# sourceMappingURL=browser-bundle-textshelf-profile.d.ts.map

package/dist/compatibility/browser-bundle.d.ts

@@ -0,0 +1,140 @@
+import { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart } from './eval-hyperscript';
+import { hyperscript, config } from '../api/lokascript-api';
+import type { RuntimeHooks } from '../types/hooks';
+import { defaultAttributeProcessor } from '../dom/attribute-processor';
+import { tailwindExtension } from '../extensions/tailwind';
+import { Parser } from '../parser/parser';
+import { Runtime } from '../runtime/runtime';
+import { tokenize } from '../parser/tokenizer';
+import { debug, debugControl } from '../utils/debug';
+import { styleBatcher, ObjectPool } from '../utils/performance';
+import { enableDebugEvents, disableDebugEvents, isDebugEnabled, getDebugStats, resetDebugStats, getEventHistory, replayEvents } from '../utils/debug-events';
+import { createSemanticAnalyzer, parse as semanticParse, translate, render, toExplicit, fromExplicit } from '@lokascript/semantic';
+import type { LokaScriptRegistry } from '../registry';
+import { registerFetchResponseType } from '../commands/async/fetch';
+import type { CompileResult, NewCompileOptions } from '../api/hyperscript-api';
+interface HyperFixiBrowserAPI {
+    evalHyperScript: typeof evalHyperScript;
+    evalHyperScriptAsync: typeof evalHyperScriptAsync;
+    evalHyperScriptSmart: typeof evalHyperScriptSmart;
+    tailwindExtension: typeof tailwindExtension;
+    compile: (code: string, options?: NewCompileOptions) => CompileResult;
+    compileSync: (code: string, options?: NewCompileOptions) => CompileResult;
+    compileMultilingual: (code: string, language: string) => Promise<CompileResult>;
+    execute: typeof hyperscript.execute;
+    run: (code: string, context?: any) => Promise<unknown>;
+    createContext: typeof hyperscript.createContext;
+    createRuntime: typeof hyperscript.createRuntime;
+    processNode: (element: Element | Document) => Promise<void>;
+    process: (element: Element | Document) => Promise<void>;
+    Parser: typeof Parser;
+    Runtime: typeof Runtime;
+    tokenize: typeof tokenize;
+    attributeProcessor: typeof defaultAttributeProcessor;
+    debug: typeof debug;
+    debugControl: typeof debugControl;
+    styleBatcher: typeof styleBatcher;
+    ObjectPool: typeof ObjectPool;
+    semantic: {
+        createAnalyzer: typeof createSemanticAnalyzer;
+        parse: typeof semanticParse;
+        translate: typeof translate;
+        render: typeof render;
+        toExplicit: typeof toExplicit;
+        fromExplicit: typeof fromExplicit;
+        supportedLanguages: string[];
+    };
+    semanticDebug: {
+        enable: typeof enableDebugEvents;
+        disable: typeof disableDebugEvents;
+        isEnabled: typeof isDebugEnabled;
+        getStats: typeof getDebugStats;
+        resetStats: typeof resetDebugStats;
+        getEventHistory: typeof getEventHistory;
+        replayEvents: typeof replayEvents;
+    };
+    config: typeof config;
+    registerHooks: (name: string, hooks: RuntimeHooks) => void;
+    unregisterHooks: (name: string) => boolean;
+    getRegisteredHooks: () => string[];
+    registry: LokaScriptRegistry;
+    registerFetchResponseType: typeof registerFetchResponseType;
+}
+declare global {
+    interface Window {
+        hyperfixi: HyperFixiBrowserAPI;
+        lokascript: HyperFixiBrowserAPI;
+        evalHyperScript: typeof evalHyperScript;
+        evalHyperScriptAsync: typeof evalHyperScriptAsync;
+        evalHyperScriptSmart: typeof evalHyperScriptSmart;
+    }
+}
+declare const hyperfixiAPI: {
+    evalHyperScript: typeof evalHyperScript;
+    evalHyperScriptAsync: typeof evalHyperScriptAsync;
+    evalHyperScriptSmart: typeof evalHyperScriptSmart;
+    evaluate: typeof evalHyperScript;
+    compile: (code: string, options?: NewCompileOptions) => CompileResult;
+    compileSync: (code: string, options?: NewCompileOptions) => CompileResult;
+    compileMultilingual: (code: string, language: string) => Promise<CompileResult>;
+    execute: (ast: import("..").ASTNode, context?: import("../registry").ExecutionContext) => Promise<unknown>;
+    run: (code: string, context?: any) => Promise<unknown>;
+    createContext: (element?: HTMLElement | null, parent?: import("../registry").ExecutionContext) => import("../registry").ExecutionContext;
+    createRuntime: (options?: import("../runtime/runtime").RuntimeOptions) => Runtime;
+    Parser: typeof Parser;
+    Runtime: typeof Runtime;
+    tokenize: typeof tokenize;
+    processNode: (element: Element | Document) => Promise<void>;
+    process: (element: Element | Document) => Promise<void>;
+    attributeProcessor: import("../dom/attribute-processor").AttributeProcessor;
+    tailwindExtension: import("../extensions/tailwind").TailwindExtension;
+    styleBatcher: import("../utils/performance").StyleBatcher;
+    ObjectPool: typeof ObjectPool;
+    debug: {
+        command: (...args: any[]) => void;
+        event: (...args: any[]) => void;
+        parse: (...args: any[]) => void;
+        expr: (...args: any[]) => void;
+        expressions: (...args: any[]) => void;
+        style: (...args: any[]) => void;
+        runtime: (...args: any[]) => void;
+        loop: (...args: any[]) => void;
+        async: (...args: any[]) => void;
+    };
+    debugControl: {
+        enable(): void;
+        disable(): void;
+        isEnabled(): boolean;
+        status(): {
+            enabled: boolean;
+            source: string;
+        };
+    };
+    semantic: {
+        createAnalyzer: typeof createSemanticAnalyzer;
+        parse: typeof semanticParse;
+        translate: typeof translate;
+        render: typeof render;
+        toExplicit: typeof toExplicit;
+        fromExplicit: typeof fromExplicit;
+        supportedLanguages: string[];
+    };
+    semanticDebug: {
+        enable: typeof enableDebugEvents;
+        disable: typeof disableDebugEvents;
+        isEnabled: typeof isDebugEnabled;
+        getStats: typeof getDebugStats;
+        resetStats: typeof resetDebugStats;
+        getEventHistory: typeof getEventHistory;
+        replayEvents: typeof replayEvents;
+    };
+    config: import("../api/hyperscript-api").HyperscriptConfig;
+    registerHooks: (name: string, hooks: RuntimeHooks) => void;
+    unregisterHooks: (name: string) => boolean;
+    getRegisteredHooks: () => string[];
+    registry: LokaScriptRegistry;
+    registerFetchResponseType: typeof registerFetchResponseType;
+    version: string;
+};
+export default hyperfixiAPI;
+//# sourceMappingURL=browser-bundle.d.ts.map

package/dist/compatibility/browser-modular.d.ts

@@ -0,0 +1,53 @@
+import { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart } from './eval-hyperscript';
+import { hyperscript } from '../api/hyperscript-api';
+import { defaultAttributeProcessor } from '../dom/attribute-processor';
+import { tailwindExtension } from '../extensions/tailwind';
+import { Parser } from '../parser/parser';
+import { Runtime } from '../runtime/runtime';
+import { tokenize } from '../parser/tokenizer';
+import { debug } from '../utils/debug';
+import { styleBatcher, ObjectPool } from '../utils/performance';
+import { preloadDocumentFeatures, loadRequiredFeatures, detectFeatures, isFeatureLoaded, getLoadedFeatures, preloadFeatures } from './feature-loader';
+declare const hyperfixi: {
+    evalHyperScript: typeof evalHyperScript;
+    evalHyperScriptAsync: typeof evalHyperScriptAsync;
+    evalHyperScriptSmart: typeof evalHyperScriptSmart;
+    evaluate: typeof evalHyperScript;
+    compile: (code: string) => import("../api/hyperscript-api").CompileResult;
+    execute: (ast: import("..").ASTNode, context?: import("..").ExecutionContext) => Promise<unknown>;
+    run: (code: string, context?: any) => Promise<unknown>;
+    createContext: (element?: HTMLElement | null, parent?: import("..").ExecutionContext) => import("..").ExecutionContext;
+    createRuntime: (options?: import("../runtime/runtime").RuntimeOptions) => Runtime;
+    Parser: typeof Parser;
+    Runtime: typeof Runtime;
+    tokenize: typeof tokenize;
+    processNode: (element: Element | Document) => Promise<void>;
+    process: (element: Element | Document) => Promise<void>;
+    attributeProcessor: import("../dom/attribute-processor").AttributeProcessor;
+    tailwindExtension: import("../extensions/tailwind").TailwindExtension;
+    styleBatcher: import("../utils/performance").StyleBatcher;
+    ObjectPool: typeof ObjectPool;
+    debug: {
+        command: (...args: any[]) => void;
+        event: (...args: any[]) => void;
+        parse: (...args: any[]) => void;
+        expr: (...args: any[]) => void;
+        expressions: (...args: any[]) => void;
+        style: (...args: any[]) => void;
+        runtime: (...args: any[]) => void;
+        loop: (...args: any[]) => void;
+        async: (...args: any[]) => void;
+    };
+    features: {
+        preloadDocument: typeof preloadDocumentFeatures;
+        loadRequired: typeof loadRequiredFeatures;
+        detect: typeof detectFeatures;
+        isLoaded: typeof isFeatureLoaded;
+        getLoaded: typeof getLoadedFeatures;
+        preload: typeof preloadFeatures;
+    };
+    version: string;
+};
+export { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart, hyperscript, Parser, Runtime, tokenize, defaultAttributeProcessor, tailwindExtension, debug, styleBatcher, ObjectPool, preloadDocumentFeatures, loadRequiredFeatures, detectFeatures, isFeatureLoaded, getLoadedFeatures, preloadFeatures, };
+export default hyperfixi;
+//# sourceMappingURL=browser-modular.d.ts.map

package/dist/compatibility/browser-tests/test-utils.d.ts

@@ -0,0 +1,21 @@
+import { Page } from '@playwright/test';
+export declare function waitForHyperfixi(page: Page, timeout?: number): Promise<void>;
+export declare function waitForEvalHyperScript(page: Page, timeout?: number): Promise<void>;
+export declare function waitForBehaviors(page: Page, timeout?: number): Promise<void>;
+export declare function waitForSemantic(page: Page, timeout?: number): Promise<void>;
+export declare function waitForMultilingual(page: Page, timeout?: number): Promise<void>;
+export declare function waitForClass(page: Page, selector: string, className: string, timeout?: number): Promise<void>;
+export declare function waitForNoClass(page: Page, selector: string, className: string, timeout?: number): Promise<void>;
+export declare function waitForText(page: Page, selector: string, expectedText: string | RegExp, timeout?: number): Promise<void>;
+export declare function waitForInnerHTML(page: Page, selector: string, expectedHTML: string, timeout?: number): Promise<void>;
+export declare function waitForVisible(page: Page, selector: string, timeout?: number): Promise<void>;
+export declare function waitForHidden(page: Page, selector: string, timeout?: number): Promise<void>;
+export interface ErrorCollector {
+    errors: string[];
+    attach: () => void;
+    clear: () => void;
+    getCriticalErrors: () => string[];
+}
+export declare function createErrorCollector(page: Page): ErrorCollector;
+export declare function expectNoCriticalErrors(collector: ErrorCollector): void;
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/compatibility/eval-hyperscript.d.ts

@@ -0,0 +1,15 @@
+import type { ExecutionContext } from '../types/core';
+export interface HyperScriptContext {
+    me?: any;
+    locals?: Record<string, any>;
+    it?: any;
+    result?: any;
+    you?: any;
+    globals?: Record<string, any>;
+    language?: string;
+}
+export declare function evalHyperScript(script: string, context?: HyperScriptContext | ExecutionContext): Promise<any>;
+export declare function evalHyperScriptAsync(expression: string, context?: HyperScriptContext | ExecutionContext): Promise<any>;
+export declare function isAsyncExpression(expression: string): boolean;
+export declare function evalHyperScriptSmart(expression: string, context?: HyperScriptContext | ExecutionContext): Promise<any>;
+//# sourceMappingURL=eval-hyperscript.d.ts.map

package/dist/compatibility/feature-loader.d.ts

@@ -0,0 +1,8 @@
+export declare function detectFeatures(code: string | string[]): Set<string>;
+export declare function loadRequiredFeatures(code: string | string[]): Promise<void>;
+export declare function collectHyperscriptFromDocument(): string[];
+export declare function preloadDocumentFeatures(): Promise<void>;
+export declare function isFeatureLoaded(feature: string): boolean;
+export declare function getLoadedFeatures(): string[];
+export declare function preloadFeatures(features: string[]): Promise<void>;
+//# sourceMappingURL=feature-loader.d.ts.map

package/dist/compatibility/hyperscript-adapter.d.ts

@@ -0,0 +1,38 @@
+export declare function make(htmlString: string): HTMLElement;
+export declare function clearWorkArea(): void;
+export declare function evalHyperScript(expressionSource: string, contextOptions?: {
+    me?: HTMLElement;
+    locals?: Record<string, any>;
+    globals?: Record<string, any>;
+    it?: any;
+    you?: HTMLElement;
+}): Promise<any>;
+export declare function evalHyperScriptSync(expressionSource: string, contextOptions?: {
+    me?: HTMLElement;
+    locals?: Record<string, any>;
+    globals?: Record<string, any>;
+    it?: any;
+    you?: HTMLElement;
+}): any;
+export declare function getParseErrorFor(source: string): string | null;
+export declare const testUtils: {
+    make: typeof make;
+    clearWorkArea: typeof clearWorkArea;
+    evalHyperScript: typeof evalHyperScript;
+    evalHyperScriptSync: typeof evalHyperScriptSync;
+    getParseErrorFor: typeof getParseErrorFor;
+};
+export declare function createHyperscriptCompat(): {
+    evaluate: typeof evalHyperScript;
+    make: typeof make;
+    clearWorkArea: typeof clearWorkArea;
+    getParseErrorFor: typeof getParseErrorFor;
+    version: string;
+    features: {
+        expressions: boolean;
+        commands: boolean;
+        parser: boolean;
+        events: boolean;
+    };
+};
+//# sourceMappingURL=hyperscript-adapter.d.ts.map

package/dist/compatibility/hyperscript-tests/test-adapter.d.ts

@@ -0,0 +1,13 @@
+export declare function createHyperScriptTestAdapter(): (src: string, ctx?: any) => Promise<any>;
+export declare const testUtils: {
+    evalHyperScript: (src: string, ctx?: any) => Promise<any>;
+    getParseErrorFor: (src: string, ctx?: any) => string;
+    byId: (id: string) => Element | null;
+    make: (htmlStr: string) => Element;
+    clearWorkArea: () => void;
+    getWorkArea: () => Element | null;
+    promiseAnIntIn: (millis: number) => Promise<number>;
+    promiseValueBackIn: (value: any, millis: number) => Promise<any>;
+    startsWith: (str: string, expected: string) => void;
+};
+//# sourceMappingURL=test-adapter.d.ts.map

package/dist/core/ast-property-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function extractPropertyName(property: any): any;
+//# sourceMappingURL=ast-property-utils.d.ts.map

package/dist/core/base-expression-evaluator.d.ts

@@ -0,0 +1,70 @@
+import type { ASTNode, ExecutionContext } from '../types/core';
+import type { ExecutionResult } from '../types/result';
+export declare class BaseExpressionEvaluator {
+    protected expressionRegistry: Map<string, any>;
+    constructor();
+    protected registerCategory(expressions: Record<string, any>): void;
+    protected unwrapSelectorResult<T>(value: T | T[] | NodeList): T;
+    evaluate(node: ASTNode, context: ExecutionContext): Promise<any>;
+    evaluateWithResult(node: ASTNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
+    protected evaluateArrayLiteral(node: any, context: ExecutionContext): Promise<any[]>;
+    protected evaluateObjectLiteral(node: any, context: ExecutionContext): Promise<Record<string, any>>;
+    protected evaluateConditionalExpression(node: any, context: ExecutionContext): Promise<any>;
+    protected evaluateTemplateLiteral(node: any, context: ExecutionContext): Promise<string>;
+    protected evaluateSimpleExpression(exprCode: string, context: ExecutionContext): Promise<any>;
+    protected resolveValue(name: string, context: ExecutionContext): Promise<any>;
+    protected evaluateIdentifier(node: {
+        name: string;
+        scope?: 'local' | 'global';
+    }, context: ExecutionContext): Promise<any>;
+    protected evaluateLiteral(node: {
+        value: any;
+    }, _context: ExecutionContext): Promise<any>;
+    protected evaluateContextReference(node: {
+        contextType: string;
+        name: string;
+    }, context: ExecutionContext): Promise<any>;
+    protected evaluateMemberExpression(node: any, context: ExecutionContext): Promise<any>;
+    private coerceArithmeticOperand;
+    protected evaluateBinaryExpression(node: any, context: ExecutionContext): Promise<any>;
+    protected evaluateUnaryExpression(node: any, context: ExecutionContext): Promise<any>;
+    protected evaluateCallExpression(node: any, context: ExecutionContext): Promise<any>;
+    private evaluateMethodCall;
+    protected evaluateSelector(node: {
+        value: string;
+    }, context: ExecutionContext): Promise<HTMLElement[]>;
+    protected evaluateAttributeAccess(node: {
+        attributeName: string;
+    }, context: ExecutionContext): string | boolean | null;
+    getAvailableExpressions(): string[];
+    protected evaluateDollarExpression(node: {
+        expression: any;
+    }, context: ExecutionContext): Promise<any>;
+    protected evaluatePossessiveExpression(node: any, context: ExecutionContext): Promise<any>;
+    hasExpression(name: string): boolean;
+    protected evaluateCSSSelector(node: {
+        selectorType: string;
+        selector: string;
+    }, context: ExecutionContext): Promise<HTMLElement | HTMLElement[] | null>;
+    protected evaluateIdSelector(node: {
+        value: string;
+    }, context: ExecutionContext): Promise<Element | null>;
+    protected evaluateQueryReference(node: {
+        selector: string;
+    }, context: ExecutionContext): Promise<NodeList>;
+    protected evaluatePropertyAccess(node: {
+        object: ASTNode;
+        property: {
+            name?: string;
+            value?: string;
+        };
+    }, context: ExecutionContext): Promise<any>;
+    protected evaluatePropertyOfExpression(node: {
+        property: {
+            name?: string;
+            value?: string;
+        };
+        target: ASTNode;
+    }, context: ExecutionContext): Promise<any>;
+}
+//# sourceMappingURL=base-expression-evaluator.d.ts.map

package/dist/core/binary-expression-evaluator.d.ts

@@ -0,0 +1,7 @@
+import type { ExecutionContext } from '../types/core';
+import type { EvaluateFn, UnwrapFn } from './evaluator-types';
+export declare function coerceArithmeticOperand(value: unknown): unknown;
+export declare function evaluateBinaryExpression(node: any, context: ExecutionContext, evaluate: EvaluateFn, unwrap: UnwrapFn, expressionRegistry: Map<string, any>, evaluateSelector: (node: {
+    value: string;
+}, context: ExecutionContext) => Promise<HTMLElement[]>): Promise<any>;
+//# sourceMappingURL=binary-expression-evaluator.d.ts.map

package/dist/core/call-expression-evaluator.d.ts

@@ -0,0 +1,7 @@
+import type { ExecutionContext } from '../types/core';
+import type { EvaluateFn, UnwrapFn } from './evaluator-types';
+export declare function evaluateCallExpression(node: any, context: ExecutionContext, evaluate: EvaluateFn, unwrap: UnwrapFn, expressionRegistry: Map<string, any>, evaluateSelector: (node: {
+    value: string;
+}, context: ExecutionContext) => Promise<HTMLElement[]>): Promise<any>;
+export declare function evaluateMethodCall(callee: any, args: any[], context: ExecutionContext, evaluate: EvaluateFn, unwrap: UnwrapFn): Promise<any>;
+//# sourceMappingURL=call-expression-evaluator.d.ts.map

package/dist/core/configurable-expression-evaluator.d.ts

@@ -0,0 +1,5 @@
+import { BaseExpressionEvaluator } from './base-expression-evaluator';
+export declare class ConfigurableExpressionEvaluator extends BaseExpressionEvaluator {
+    constructor(categories: Record<string, any>[]);
+}
+//# sourceMappingURL=configurable-expression-evaluator.d.ts.map

package/dist/core/context.d.ts

@@ -0,0 +1,15 @@
+import type { ExecutionContext } from '../types/core';
+export declare function createContext(element?: Element | null, globals?: Map<string, any>): ExecutionContext;
+export declare function getSharedGlobals(): Map<string, any>;
+export declare function createChildContext(parent: ExecutionContext, element?: Element | null): ExecutionContext;
+export declare function ensureContext(userContext?: Partial<ExecutionContext> | any): ExecutionContext;
+export declare function setContextValue(context: ExecutionContext, name: string, value: any, isGlobal?: boolean): void;
+export declare function getContextValue(context: ExecutionContext, name: string): any;
+export declare function hasContextValue(context: ExecutionContext, name: string): boolean;
+export declare function deleteContextValue(context: ExecutionContext, name: string): boolean;
+export declare function snapshotContext(context: ExecutionContext): Record<string, any>;
+export declare function restoreContext(context: ExecutionContext, snapshot: Record<string, any>): void;
+export declare function cloneContext(context: ExecutionContext): ExecutionContext;
+export declare function mergeContexts(target: ExecutionContext, source: ExecutionContext): void;
+export declare function getContextVariableNames(context: ExecutionContext): string[];
+//# sourceMappingURL=context.d.ts.map

package/dist/core/dom.d.ts

@@ -0,0 +1,15 @@
+export declare const SWAP_STRATEGIES: {
+    readonly OUTER_HTML: "outerHTML";
+    readonly INNER_HTML: "innerHTML";
+    readonly BEFORE_END: "beforeend";
+    readonly AFTER_BEGIN: "afterbegin";
+};
+export type SwapStrategy = (typeof SWAP_STRATEGIES)[keyof typeof SWAP_STRATEGIES];
+export type CustomSwapFn = (opts: {
+    target: Element;
+    text: string;
+}) => void;
+export declare function mapPlacementToSwap(placement: string): string;
+export declare function applySwap(target: Element, content: string, swapStrategy: string | CustomSwapFn): boolean;
+export declare function isElementInDocument(element: Element): boolean;
+//# sourceMappingURL=dom.d.ts.map

package/dist/core/evaluator-types.d.ts

@@ -0,0 +1,5 @@
+import type { ASTNode, ExecutionContext } from '../types/core';
+export type EvaluateFn = (node: ASTNode | any, context: ExecutionContext) => Promise<any>;
+export type UnwrapFn = (value: any) => any;
+export type EvaluateSelectorFn = (node: any, context: ExecutionContext) => Promise<any>;
+//# sourceMappingURL=evaluator-types.d.ts.map

package/dist/core/events.d.ts

@@ -0,0 +1,48 @@
+import type { HyperscriptEvent, ExecutionContext } from '../types/core';
+interface ListenerInfo {
+    element: HTMLElement;
+    eventType: string;
+    handler: EventListener;
+    options?: AddEventListenerOptions & {
+        delegated?: boolean;
+    };
+    wrappedHandler: EventListener;
+}
+export interface HyperscriptEventManager {
+    listeners: Map<string, ListenerInfo>;
+    delegatedListeners: Map<string, Set<string>>;
+}
+export type DelegationCleanupRegistrar = (cleanup: () => void, description: string) => void;
+export declare function setDelegationCleanupRegistrar(registrar: DelegationCleanupRegistrar): void;
+export declare function createEventManager(): HyperscriptEventManager;
+export declare function registerEventListener(manager: HyperscriptEventManager, element: HTMLElement, eventType: string, handler: EventListener, options?: AddEventListenerOptions & {
+    delegated?: boolean;
+}): string;
+export declare function unregisterEventListener(manager: HyperscriptEventManager, listenerId: string): boolean;
+export declare function dispatchCustomEvent(element: HTMLElement, eventType: string, detail?: any, options?: CustomEventInit): boolean;
+export declare function createHyperscriptEvent(eventName: string, data: {
+    element: HTMLElement;
+    context: ExecutionContext;
+    command?: string;
+    result?: any;
+    error?: Error;
+    originalEvent?: Event;
+}): HyperscriptEvent;
+export declare function setupEventDelegation(): void;
+export declare function cleanupEventDelegation(): void;
+export declare function registerManagerForDelegation(manager: HyperscriptEventManager): void;
+export declare function unregisterManagerFromDelegation(manager: HyperscriptEventManager): void;
+export declare function getActiveListeners(manager: HyperscriptEventManager): ListenerInfo[];
+export declare function getListenerCount(manager: HyperscriptEventManager): number;
+export declare function createDebouncedHandler(handler: EventListener, delay: number): EventListener;
+export declare function createThrottledHandler(handler: EventListener, limit: number): EventListener;
+export declare function createOnceHandler(handler: EventListener): EventListener;
+export declare function waitForEvent(element: EventTarget, eventType: string, timeout?: number): Promise<Event>;
+export declare function emitConfigEvent(element: HTMLElement, cfg: any): boolean;
+export declare function emitBeforeEvent(element: HTMLElement, cfg: any): boolean;
+export declare function emitAfterEvent(element: HTMLElement, cfg: any): boolean;
+export declare function emitErrorEvent(element: HTMLElement, error: Error, cfg: any, command: any): void;
+export declare function emitFinallyEvent(element: HTMLElement, cfg: any): void;
+export declare function emitSwappedEvent(element: HTMLElement, cfg: any): void;
+export {};
+//# sourceMappingURL=events.d.ts.map

package/dist/core/executor.d.ts

@@ -0,0 +1,34 @@
+export interface HyperscriptRuntime {
+    resolve(expression: unknown, context: unknown): Promise<unknown>;
+}
+export interface FetchOptions {
+    method?: string;
+    body?: BodyInit | null;
+    headers?: HeadersInit;
+}
+export interface ParsedFetchCommand {
+    options?: {
+        method?: unknown;
+        body?: unknown;
+        headers?: unknown;
+    };
+}
+export interface FixiConfig {
+    url: string;
+    method: string;
+    body: BodyInit | null | undefined;
+    headers: HeadersInit;
+    target: Element;
+    swap: string;
+    trigger: Event;
+    response: Response | null;
+    text: string | null;
+}
+export declare function executeHTTPRequest(url: string, options?: Partial<FetchOptions>): Promise<{
+    response: Response;
+    text: string;
+}>;
+export declare function resolveExpression(expression: unknown, runtime: HyperscriptRuntime, context: unknown): Promise<unknown>;
+export declare function buildFetchOptions(command: ParsedFetchCommand, runtime: HyperscriptRuntime, context: unknown): Promise<Partial<FetchOptions>>;
+export declare function createFixiConfig(url: string, options: Partial<FetchOptions>, element: Element, event: Event, target?: Element | null, swap?: string): FixiConfig;
+//# sourceMappingURL=executor.d.ts.map

package/dist/core/expression-evaluator.d.ts

@@ -0,0 +1,6 @@
+import { BaseExpressionEvaluator } from './base-expression-evaluator';
+export declare class ExpressionEvaluator extends BaseExpressionEvaluator {
+    constructor();
+    private registerExpressions;
+}
+//# sourceMappingURL=expression-evaluator.d.ts.map

package/dist/core/lazy-expression-evaluator.d.ts

@@ -0,0 +1,22 @@
+import type { ASTNode, ExecutionContext } from '../types/core';
+import { type ExpressionCategory } from '../expressions/expression-tiers';
+import { BaseExpressionEvaluator } from './base-expression-evaluator';
+export interface LazyExpressionEvaluatorOptions {
+    preload?: 'core' | 'common' | 'all' | 'none';
+    categories?: ExpressionCategory[];
+}
+export declare class LazyExpressionEvaluator extends BaseExpressionEvaluator {
+    private loadedCategories;
+    private loadPromises;
+    private options;
+    constructor(options?: LazyExpressionEvaluatorOptions);
+    private preloadExpressions;
+    private preloadTier;
+    private loadCategory;
+    private _loadCategoryImpl;
+    private getCategoryForNodeType;
+    evaluate(node: ASTNode, context: ExecutionContext): Promise<any>;
+    warmupExpressions(categories: string[]): Promise<void>;
+    getLoadedCategories(): string[];
+}
+//# sourceMappingURL=lazy-expression-evaluator.d.ts.map

package/dist/core/parser.d.ts

@@ -0,0 +1,21 @@
+export interface HyperscriptParser {
+    parseElementExpression(): unknown;
+    raiseParseError(tokens: TokenStream, message: string): never;
+}
+export interface TokenStream {
+    matchToken(token: string): boolean;
+}
+export interface BaseCommand {
+    url: unknown;
+    placement: string | null;
+    target: unknown;
+    options: Record<string, unknown>;
+}
+export declare function parseURL(parser: HyperscriptParser, tokens: TokenStream): unknown;
+export declare function parseTarget(parser: HyperscriptParser, _tokens: TokenStream): unknown;
+export declare function parseOptionValue(parser: HyperscriptParser, _tokens: TokenStream): unknown;
+export declare function parseColon(parser: HyperscriptParser, tokens: TokenStream): void;
+export declare function parseComma(tokens: TokenStream): boolean;
+export declare function parseOptionalAnd(tokens: TokenStream): boolean;
+export declare function createBaseCommand(url: unknown): BaseCommand;
+//# sourceMappingURL=parser.d.ts.map

package/dist/core/selector-evaluator.d.ts

@@ -0,0 +1,15 @@
+import type { ExecutionContext } from '../types/core';
+export declare function evaluateSelector(node: {
+    value: string;
+}, context: ExecutionContext): HTMLElement[];
+export declare function evaluateCSSSelector(node: {
+    selectorType: string;
+    selector: string;
+}, context: ExecutionContext): HTMLElement | HTMLElement[] | null;
+export declare function evaluateIdSelector(node: {
+    value: string;
+}, context: ExecutionContext): Element | null;
+export declare function evaluateQueryReference(node: {
+    selector: string;
+}, context: ExecutionContext): NodeList;
+//# sourceMappingURL=selector-evaluator.d.ts.map

package/dist/core/template-literal-evaluator.d.ts

@@ -0,0 +1,5 @@
+import type { ExecutionContext } from '../types/core';
+export declare function resolveValue(name: string, context: ExecutionContext): Promise<any>;
+export declare function evaluateSimpleExpression(exprCode: string, context: ExecutionContext): Promise<any>;
+export declare function evaluateTemplateLiteral(node: any, context: ExecutionContext): Promise<string>;
+//# sourceMappingURL=template-literal-evaluator.d.ts.map