@hyperfixi/core 3.3.0 → 4.0.1

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

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

@@ -1,18 +0,0 @@
-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-modular.d.ts

@@ -1,42 +0,0 @@
-import { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart } from './eval-hyperscript';
-import { hyperscript } from '../api/hyperscript-api';
-import { defaultAttributeProcessor } from '../dom/attribute-processor';
-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';
-declare const hyperfixi: {
-    evalHyperScript: typeof evalHyperScript;
-    evalHyperScriptAsync: typeof evalHyperScriptAsync;
-    evalHyperScriptSmart: typeof evalHyperScriptSmart;
-    evaluate: typeof evalHyperScript;
-    compile: (code: string) => import("..").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("..").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;
-    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;
-    };
-    version: string;
-};
-export { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart, hyperscript, Parser, Runtime, tokenize, defaultAttributeProcessor, debug, styleBatcher, ObjectPool, };
-export default hyperfixi;
-//# sourceMappingURL=browser-modular.d.ts.map

package/dist/compatibility/browser-tests/helpers/semantic-page.d.ts

@@ -1,3 +0,0 @@
-import type { Page } from '@playwright/test';
-export declare function gotoSemanticPage(page: Page): Promise<void>;
-//# sourceMappingURL=semantic-page.d.ts.map

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

@@ -1,21 +0,0 @@
-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/bundle-shell.d.ts

@@ -1,13 +0,0 @@
-export declare const SHELL_CORE_KEYS: readonly ["version", "parse", "execute", "init", "process", "commands"];
-export interface BundleShellApi<TAst> {
-    version: string;
-    parse: (code: string) => TAst;
-    execute: (code: string, element?: Element) => Promise<unknown>;
-    init: (root?: Element | Document) => void;
-    process: (root?: Element | Document) => void;
-    commands: string[];
-    blocks?: string[];
-}
-export declare function createProcessElements<TAst>(parse: (code: string) => TAst, run: (ast: TAst, me: Element) => unknown, errorLabel: string): (root?: Element | Document) => void;
-export declare function installBundleGlobal(api: unknown, processElements: (root?: Element | Document) => void, globalName?: string): void;
-//# sourceMappingURL=bundle-shell.d.ts.map

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

@@ -1,4 +0,0 @@
-export declare const BUNDLES_WITH_COMMAND_LISTS: Readonly<Record<string, string>>;
-export declare const BUNDLES_WITH_FACTORY_LISTS: Readonly<Record<string, string>>;
-export declare const BUNDLES_INHERITING: Readonly<Record<string, string>>;
-//# sourceMappingURL=bundle-sources.d.ts.map

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

@@ -1,16 +0,0 @@
-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 evalHyperScriptSync(script: string, context?: HyperScriptContext | ExecutionContext): 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/hyperscript-adapter.d.ts

@@ -1,38 +0,0 @@
-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/core/ast-property-utils.d.ts

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

package/dist/core/context.d.ts

@@ -1,19 +0,0 @@
-import type { ExecutionContext } from '../types/core';
-export declare function getElementScopeMap(element: Element): Map<string, unknown>;
-export declare function resolveScopeOwner(context: ExecutionContext): Element | null;
-export declare function getElementVar(context: ExecutionContext, name: string): unknown;
-export declare function setElementVar(context: ExecutionContext, name: string, value: unknown): void;
-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

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

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

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

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

@@ -1,6 +0,0 @@
-import type { AnyNode } from '../ast/legacy';
-import type { ExecutionContext } from '../types/core';
-export interface ExpressionEvaluator {
-    evaluate(node: AnyNode, context: ExecutionContext): Promise<any>;
-}
-//# sourceMappingURL=expression-evaluator.d.ts.map

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

@@ -1,8 +0,0 @@
-import type { ExpressionImplementation } from '../types/core';
-export type ExpressionRegistry = ReadonlyMap<string, ExpressionImplementation>;
-interface ExpressionLike {
-    evaluate: (...args: any[]) => any;
-}
-export declare function createExpressionRegistry(...categories: ReadonlyArray<Readonly<Record<string, ExpressionLike>>>): ExpressionRegistry;
-export {};
-//# sourceMappingURL=expression-registry.d.ts.map

package/dist/core/scope-hooks.d.ts

@@ -1,24 +0,0 @@
-import type { ExecutionContext } from '../types/base-types';
-export type GlobalWriteHook = (name: string, value: unknown, context: ExecutionContext) => void;
-export type GlobalReadHook = (name: string, context: ExecutionContext) => void;
-export type LocalWriteHook = (name: string, value: unknown, context: ExecutionContext) => void;
-export type LocalReadHook = (name: string, context: ExecutionContext) => void;
-export declare function registerGlobalWriteHook(hook: GlobalWriteHook): () => void;
-export declare function registerGlobalReadHook(hook: GlobalReadHook): () => void;
-export declare function registerLocalWriteHook(hook: LocalWriteHook): () => void;
-export declare function registerLocalReadHook(hook: LocalReadHook): () => void;
-export declare function getGlobalWriteHooks(): Iterable<GlobalWriteHook>;
-export declare function getLocalWriteHooks(): Iterable<LocalWriteHook>;
-export declare function notifyGlobalRead(name: string, context: ExecutionContext): void;
-export declare function notifyLocalWrite(name: string, value: unknown, context: ExecutionContext): void;
-export declare function notifyLocalRead(name: string, context: ExecutionContext): void;
-export declare function setGlobal(context: ExecutionContext, name: string, value: unknown): void;
-export interface ScopeHooksSnapshot {
-    globalWriteHooks: GlobalWriteHook[];
-    globalReadHooks: GlobalReadHook[];
-    localWriteHooks: LocalWriteHook[];
-    localReadHooks: LocalReadHook[];
-}
-export declare function snapshotScopeHooks(): ScopeHooksSnapshot;
-export declare function restoreScopeHooks(snapshot: Partial<ScopeHooksSnapshot>): void;
-//# sourceMappingURL=scope-hooks.d.ts.map

package/dist/debug/debug-controller.d.ts

@@ -1,62 +0,0 @@
-import type { RuntimeHooks } from '../types/hooks';
-export type StepMode = 'continue' | 'over' | 'into' | 'out' | 'pause';
-export interface BreakpointCondition {
-    id: string;
-    type: 'command' | 'element' | 'expression';
-    value: string;
-    enabled: boolean;
-    hitCount: number;
-}
-export interface DebugSnapshot {
-    commandName: string;
-    element: Element | null;
-    variables: Record<string, unknown>;
-    timestamp: number;
-    depth: number;
-    index: number;
-}
-export interface DebugState {
-    enabled: boolean;
-    paused: boolean;
-    stepMode: StepMode;
-    callDepth: number;
-    pauseDepth: number;
-    currentSnapshot: DebugSnapshot | null;
-}
-export type DebugEventType = 'paused' | 'resumed' | 'snapshot' | 'enabled' | 'disabled';
-export type DebugEventListener = (data: DebugSnapshot | undefined) => void;
-export declare class DebugController {
-    private state;
-    private history;
-    private breakpoints;
-    private snapshotIndex;
-    private _resumeResolver;
-    private listeners;
-    readonly hooks: RuntimeHooks;
-    constructor();
-    on(event: DebugEventType, listener: DebugEventListener): () => void;
-    private emit;
-    enable(): void;
-    disable(): void;
-    get enabled(): boolean;
-    continue(): void;
-    pause(): void;
-    stepOver(): void;
-    stepInto(): void;
-    stepOut(): void;
-    private resume;
-    setBreakpoint(condition: Omit<BreakpointCondition, 'id' | 'hitCount'>): string;
-    removeBreakpoint(id: string): boolean;
-    getBreakpoints(): BreakpointCondition[];
-    clearBreakpoints(): void;
-    getState(): Readonly<DebugState>;
-    getHistory(): DebugSnapshot[];
-    clearHistory(): void;
-    private beforeExecute;
-    private afterExecute;
-    private shouldPause;
-    private hitBreakpoint;
-    private evaluateCondition;
-    private captureSnapshot;
-}
-//# sourceMappingURL=debug-controller.d.ts.map

package/dist/debug/index.d.ts

@@ -1,5 +0,0 @@
-export { DebugController } from './debug-controller';
-export type { StepMode, BreakpointCondition, DebugSnapshot, DebugState, DebugEventType, DebugEventListener, } from './debug-controller';
-import { DebugController } from './debug-controller';
-export declare function createDebugController(): DebugController;
-//# sourceMappingURL=index.d.ts.map

package/dist/dom/attribute-processor.d.ts

@@ -1,75 +0,0 @@
-import type { ASTNode, ExecutionContext } from '../types/base-types';
-import { detectLanguage } from './detect-language';
-export { detectLanguage };
-export interface CompileFailure {
-    message: string;
-    line: number;
-    column: number;
-    suggestion?: string;
-}
-export interface ProcessorCompileResult {
-    ok: boolean;
-    ast?: ASTNode;
-    errors?: CompileFailure[];
-}
-export interface CompileErrorReport {
-    source: 'attribute' | 'script';
-    code: string;
-    errors: CompileFailure[];
-    element: Element | null;
-}
-export interface ProcessorHost {
-    compileSync(code: string): ProcessorCompileResult;
-    compile(code: string, options: {
-        language: string;
-    }): Promise<ProcessorCompileResult>;
-    execute(ast: ASTNode, context: ExecutionContext): Promise<unknown>;
-    config: {
-        onCompileError: ((report: CompileErrorReport) => void) | null;
-    };
-}
-export declare function initializeAttributeProcessor(host: ProcessorHost): void;
-declare global {
-    interface Window {
-        __hyperfixi_behaviors_ready?: Promise<void>;
-    }
-}
-export interface AttributeProcessorOptions {
-    attributeName?: string;
-    autoScan?: boolean;
-    processOnlyNewElements?: boolean;
-    lazyParsing?: boolean;
-    chunkedProcessing?: boolean;
-    chunkSize?: number;
-}
-export declare class AttributeProcessor {
-    private processedElements;
-    private lazyStubs;
-    private options;
-    private observer;
-    private processedCount;
-    private readyEventDispatched;
-    private initialized;
-    constructor(options?: AttributeProcessorOptions);
-    init(): Promise<void>;
-    scanAndProcessAll(): Promise<void>;
-    private processElements;
-    processTree(root: Element): Promise<void>;
-    forget(root: Element): void;
-    private reportCompileError;
-    private processHyperscriptTag;
-    private processHyperscriptTagForElements;
-    private processHyperscriptTagGlobal;
-    processElement(element: HTMLElement): void;
-    processElementAsync(element: HTMLElement): Promise<void>;
-    private processElementsChunked;
-    private processElementLazy;
-    private hasMultipleHandlers;
-    private dispatchLoadEvent;
-    private dispatchReadyEvent;
-    private setupMutationObserver;
-    destroy(): void;
-    reset(): void;
-}
-export declare const defaultAttributeProcessor: AttributeProcessor;
-//# sourceMappingURL=attribute-processor.d.ts.map

package/dist/dom/detect-language.d.ts

@@ -1,3 +0,0 @@
-export declare const DEFAULT_LANGUAGE = "en";
-export declare function detectLanguage(element: Element): string;
-//# sourceMappingURL=detect-language.d.ts.map

package/dist/dom/minimal-attribute-processor.d.ts

@@ -1,20 +0,0 @@
-import type { ExecutionContext } from '../types/base-types';
-export interface MinimalRuntime {
-    execute(code: string, context?: ExecutionContext): Promise<any>;
-    parse(code: string): any;
-}
-export declare class MinimalAttributeProcessor {
-    private runtime;
-    private observer;
-    private initialized;
-    constructor(runtime: MinimalRuntime);
-    init(): void;
-    destroy(): void;
-    reset(): void;
-    scanAndProcessAll(): void;
-    private scanDocument;
-    scanElement(root: Element): void;
-    processElement(element: Element): void;
-}
-export declare function createMinimalAttributeProcessor(runtime: MinimalRuntime): MinimalAttributeProcessor;
-//# sourceMappingURL=minimal-attribute-processor.d.ts.map

package/dist/expressions/base-expression.d.ts

@@ -1,27 +0,0 @@
-import type { RuntimeValidator } from '../validation/lightweight-validators';
-import type { TypedExpressionContext, EvaluationResult, ValidationResult, ValidationError, ExpressionMetadata, EvaluationType, ExpressionCategory } from '../types/base-types';
-export declare abstract class BaseExpressionImpl<TInput = unknown, TOutput = unknown> {
-    abstract readonly name: string;
-    abstract readonly category: ExpressionCategory;
-    abstract readonly syntax: string;
-    abstract readonly description: string;
-    abstract readonly inputSchema: RuntimeValidator<TInput>;
-    abstract readonly outputType: EvaluationType;
-    abstract readonly metadata: ExpressionMetadata;
-    protected trackPerformance(context: TypedExpressionContext, input: unknown, result: EvaluationResult<TOutput>, startTime: number): void;
-    protected trackSimple(context: TypedExpressionContext, startTime: number, success: boolean, output?: unknown): void;
-    protected toBoolean(value: unknown): boolean;
-    protected success<T>(value: T, type: EvaluationResult<T>['type']): EvaluationResult<T>;
-    protected failure<T>(name: string, type: ValidationError['type'], message: string, code: string, suggestions?: readonly string[] | string[]): EvaluationResult<T>;
-    protected validationSuccess(): ValidationResult;
-    protected validationFailure(type: ValidationError['type'], message: string, suggestions?: string[]): ValidationResult;
-    protected isElement(value: unknown): value is Element;
-    protected inferType(value: unknown): EvaluationResult<unknown>['type'];
-    protected inferEvaluationType(value: unknown): EvaluationType;
-    protected normalizeCollection(collection: unknown): unknown[];
-    protected toNumber(value: unknown): number | null;
-    abstract evaluate(context: TypedExpressionContext, input: TInput): Promise<EvaluationResult<TOutput>>;
-    abstract validate(input: unknown): ValidationResult;
-}
-export declare function isBaseExpression(expr: unknown): expr is BaseExpressionImpl;
-//# sourceMappingURL=base-expression.d.ts.map

package/dist/expressions/bundles/common-expressions.d.ts

@@ -1,10 +0,0 @@
-import type { ExpressionRegistry } from '../../core/expression-registry';
-import { referencesExpressions } from '../references/index';
-import { logicalExpressions } from '../logical/index';
-import { specialExpressions } from '../special/index';
-import { mathematicalExpressions } from '../mathematical/index';
-import { conversionExpressions } from '../conversion/index';
-import { positionalExpressions } from '../positional/index';
-export declare function createCommonRegistry(): ExpressionRegistry;
-export { referencesExpressions, logicalExpressions, specialExpressions, mathematicalExpressions, conversionExpressions, positionalExpressions, };
-//# sourceMappingURL=common-expressions.d.ts.map

package/dist/expressions/bundles/core-expressions.d.ts

@@ -1,8 +0,0 @@
-import type { ExpressionRegistry } from '../../core/expression-registry';
-import { referencesExpressions } from '../references/index';
-import { logicalExpressions } from '../logical/index';
-import { specialExpressions } from '../special/index';
-import { mathematicalExpressions } from '../mathematical/index';
-export declare function createCoreRegistry(): ExpressionRegistry;
-export { referencesExpressions, logicalExpressions, specialExpressions, mathematicalExpressions };
-//# sourceMappingURL=core-expressions.d.ts.map

package/dist/expressions/bundles/full-expressions.d.ts

@@ -1,11 +0,0 @@
-import type { ExpressionRegistry } from '../../core/expression-registry';
-import { referencesExpressions } from '../references/index';
-import { logicalExpressions } from '../logical/index';
-import { specialExpressions } from '../special/index';
-import { mathematicalExpressions } from '../mathematical/index';
-import { conversionExpressions } from '../conversion/index';
-import { positionalExpressions } from '../positional/index';
-import { propertiesExpressions } from '../properties/index';
-export declare function createFullRegistry(): ExpressionRegistry;
-export { referencesExpressions, logicalExpressions, specialExpressions, mathematicalExpressions, conversionExpressions, positionalExpressions, propertiesExpressions, };
-//# sourceMappingURL=full-expressions.d.ts.map

package/dist/expressions/bundles/index.d.ts

@@ -1,7 +0,0 @@
-export { createCoreRegistry } from './core-expressions';
-export { createCommonRegistry } from './common-expressions';
-export { createFullRegistry } from './full-expressions';
-export { referencesExpressions, logicalExpressions, specialExpressions } from './core-expressions';
-export { conversionExpressions, positionalExpressions } from './common-expressions';
-export { propertiesExpressions } from './full-expressions';
-//# sourceMappingURL=index.d.ts.map

package/dist/expressions/collection/index.d.ts

@@ -1,10 +0,0 @@
-import type { AnyNode } from '../../ast/legacy';
-export type CollectionOperator = 'where' | 'sorted by' | 'mapped to' | 'split by' | 'joined by';
-export type SortOrder = 'asc' | 'desc';
-export declare function toIterableArray(value: unknown): unknown[];
-export declare function evaluateWhere(collection: unknown, predicate: AnyNode, evalWithIt: (node: AnyNode, it: unknown) => Promise<unknown>): Promise<unknown[]>;
-export declare function evaluateSortedBy(collection: unknown, keyExpr: AnyNode, order: SortOrder, evalWithIt: (node: AnyNode, it: unknown) => Promise<unknown>): Promise<unknown[]>;
-export declare function evaluateMappedTo(collection: unknown, expr: AnyNode, evalWithIt: (node: AnyNode, it: unknown) => Promise<unknown>): Promise<unknown[]>;
-export declare function evaluateSplitBy(value: unknown, separator: unknown): string[];
-export declare function evaluateJoinedBy(value: unknown, separator: unknown): string;
-//# sourceMappingURL=index.d.ts.map