@hyperfixi/core 2.0.0

package/dist/commands/navigation/go.d.ts

@@ -0,0 +1,35 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface GoCommandInput {
+    args: unknown[];
+}
+export interface GoCommandOutput {
+    result: string | HTMLElement;
+    type: 'back' | 'url' | 'scroll';
+}
+export declare class GoCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<GoCommandInput>;
+    execute(input: GoCommandInput, context: TypedExecutionContext): Promise<GoCommandOutput>;
+    private isUrlNavigation;
+    private goBack;
+    private navigateToUrl;
+    private isValidUrl;
+    private scrollToElement;
+    private mapVerticalPosition;
+    private mapHorizontalPosition;
+    private parseScrollPosition;
+    private parseScrollTarget;
+    private parseScrollOffset;
+    private resolveScrollTarget;
+    private calculateScrollPosition;
+}
+export declare const createGoCommand: () => GoCommand;
+export default GoCommand;
+//# sourceMappingURL=go.d.ts.map

package/dist/commands/navigation/push-url.d.ts

@@ -0,0 +1,35 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+import { type UrlCommandInput } from '../helpers/url-argument-parser';
+export type HistoryMode = 'push' | 'replace';
+export interface HistoryCommandInput extends UrlCommandInput {
+    mode: HistoryMode;
+}
+export interface HistoryCommandOutput {
+    url: string;
+    title?: string;
+    mode: HistoryMode;
+}
+export declare class HistoryCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+        commandName?: string;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<HistoryCommandInput>;
+    execute(input: HistoryCommandInput, _context: TypedExecutionContext): Promise<HistoryCommandOutput>;
+}
+export { HistoryCommand as PushUrlCommand };
+export { HistoryCommand as ReplaceUrlCommand };
+export type PushUrlCommandInput = HistoryCommandInput;
+export type ReplaceUrlCommandInput = HistoryCommandInput;
+export type PushUrlCommandOutput = HistoryCommandOutput;
+export type ReplaceUrlCommandOutput = HistoryCommandOutput;
+export declare const createHistoryCommand: () => HistoryCommand;
+export declare const createPushUrlCommand: () => HistoryCommand;
+export declare const createReplaceUrlCommand: () => HistoryCommand;
+export default HistoryCommand;
+//# sourceMappingURL=push-url.d.ts.map

package/dist/commands/navigation/replace-url.d.ts

@@ -0,0 +1,3 @@
+export { HistoryCommand as ReplaceUrlCommand, createReplaceUrlCommand, type ReplaceUrlCommandInput, type ReplaceUrlCommandOutput, } from './push-url';
+export { HistoryCommand as default } from './push-url';
+//# sourceMappingURL=replace-url.d.ts.map

package/dist/commands/templates/render.d.ts

@@ -0,0 +1,48 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+export interface RenderCommandInput {
+    template: unknown;
+    variables?: Record<string, unknown>;
+}
+export interface RenderCommandOutput {
+    element: Element | null;
+    rendered: string;
+    directivesProcessed: string[];
+}
+export declare class RenderCommand {
+    readonly name = "render";
+    static readonly metadata: {
+        readonly description: "Render templates with @if, @else, and @repeat directives";
+        readonly syntax: readonly ["render <template>", "render <template> with <variables>", "render <template> with (key: value, ...)"];
+        readonly examples: readonly ["render myTemplate", "render myTemplate with (name: \"Alice\")", "render \"<template>Hello ${name}!</template>\" with (name: \"World\")", "render template with (items: data)"];
+        readonly category: "templates";
+        readonly sideEffects: readonly ["dom-creation", "template-execution"];
+    };
+    get metadata(): {
+        readonly description: "Render templates with @if, @else, and @repeat directives";
+        readonly syntax: readonly ["render <template>", "render <template> with <variables>", "render <template> with (key: value, ...)"];
+        readonly examples: readonly ["render myTemplate", "render myTemplate with (name: \"Alice\")", "render \"<template>Hello ${name}!</template>\" with (name: \"World\")", "render template with (items: data)"];
+        readonly category: "templates";
+        readonly sideEffects: readonly ["dom-creation", "template-execution"];
+    };
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<RenderCommandInput>;
+    execute(input: RenderCommandInput, context: TypedExecutionContext): Promise<RenderCommandOutput>;
+    private extractTemplateContent;
+    private createTemplateContext;
+    private processTemplate;
+    private processRepeatDirective;
+    private processIfDirective;
+    private extractDirectiveBlock;
+    private extractIfElseBlock;
+    private processVariableInterpolation;
+    private evaluateExpression;
+    private resolveVariable;
+    private escapeHtml;
+    private createDOMElement;
+}
+export declare function createRenderCommand(): RenderCommand;
+//# sourceMappingURL=render.d.ts.map

package/dist/commands/utility/beep.d.ts

@@ -0,0 +1,32 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface BeepCommandInput {
+    expressions?: any[];
+}
+export interface BeepCommandOutput {
+    expressionCount: number;
+    debugged: boolean;
+    outputs: Array<{
+        value: any;
+        type: string;
+        representation: string;
+    }>;
+}
+export declare class BeepCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<BeepCommandInput>;
+    execute(input: BeepCommandInput, context: TypedExecutionContext): Promise<BeepCommandOutput>;
+    private debugContext;
+    private debugExpression;
+    private getType;
+    private getRepresentation;
+}
+export declare const createBeepCommand: () => BeepCommand;
+export default BeepCommand;
+//# sourceMappingURL=beep.d.ts.map

package/dist/commands/utility/copy.d.ts

@@ -0,0 +1,29 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface CopyCommandInput {
+    source: string | HTMLElement;
+    format?: 'text' | 'html';
+}
+export interface CopyCommandOutput {
+    success: boolean;
+    text: string;
+    format: 'text' | 'html';
+    method: 'clipboard-api' | 'execCommand' | 'fallback';
+}
+export declare class CopyCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<CopyCommandInput>;
+    execute(input: CopyCommandInput, context: TypedExecutionContext): Promise<CopyCommandOutput>;
+    private extractText;
+    private copyUsingExecCommand;
+    private dispatchCopyEvent;
+}
+export declare const createCopyCommand: () => CopyCommand;
+export default CopyCommand;
+//# sourceMappingURL=copy.d.ts.map

package/dist/commands/utility/log.d.ts

@@ -0,0 +1,24 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface LogCommandInput {
+    values: unknown[];
+}
+export interface LogCommandOutput {
+    values: unknown[];
+    loggedAt: Date;
+}
+export declare class LogCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<LogCommandInput>;
+    execute(input: LogCommandInput, _context: TypedExecutionContext): Promise<undefined>;
+    validate(input: unknown): input is LogCommandInput;
+}
+export declare const createLogCommand: () => LogCommand;
+export default LogCommand;
+//# sourceMappingURL=log.d.ts.map

package/dist/commands/utility/pick.d.ts

@@ -0,0 +1,26 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface PickCommandInput {
+    items?: unknown[];
+    array?: unknown[];
+}
+export interface PickCommandOutput {
+    selectedItem: unknown;
+    selectedIndex: number;
+    sourceLength: number;
+    sourceType: 'items' | 'array';
+}
+export declare class PickCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PickCommandInput>;
+    execute(input: PickCommandInput, context: TypedExecutionContext): Promise<PickCommandOutput>;
+}
+export declare const createPickCommand: () => PickCommand;
+export default PickCommand;
+//# sourceMappingURL=pick.d.ts.map

package/dist/commands/utility/tell.d.ts

@@ -0,0 +1,26 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface TellCommandInput {
+    target: HTMLElement | HTMLElement[] | string;
+    commands: any[];
+}
+export interface TellCommandOutput {
+    targetElements: HTMLElement[];
+    commandResults: any[];
+    executionCount: number;
+}
+export declare class TellCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<TellCommandInput>;
+    execute(input: TellCommandInput, context: TypedExecutionContext): Promise<TellCommandOutput>;
+    private executeCommand;
+}
+export declare const createTellCommand: () => TellCommand;
+export default TellCommand;
+//# sourceMappingURL=tell.d.ts.map

package/dist/compatibility/browser-bundle-animation-generated.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-animation-generated.d.ts.map

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

@@ -0,0 +1,63 @@
+import { createContext } from '../core/context';
+import type { KeywordResolver } from '../parser/types';
+import { createKeywordProvider, GrammarTransformer, translate, getProfile, getSupportedLocales } from '@lokascript/i18n/browser';
+declare const api: {
+    runtime: {
+        parse: (code: string) => import("../parser/parser").ParseResult;
+        execute: (code: string, context?: any) => Promise<unknown>;
+    };
+    parse: (code: string) => import("../parser/parser").ParseResult;
+    compile: (code: string) => {
+        success: boolean;
+        ast: import("..").ASTNode | undefined;
+        errors: import("..").ParseError[];
+        tokens: import("..").Token[];
+        compilationTime: number;
+    };
+    execute: (codeOrAst: string | any, context?: any) => Promise<unknown>;
+    run: (code: string, context?: any) => Promise<unknown>;
+    evaluate: (code: string, context?: any) => Promise<unknown>;
+    processNode: (element: Element | Document) => void;
+    process: (element: Element | Document) => void;
+    createContext: typeof createContext;
+    attributeProcessor: import("../dom/minimal-attribute-processor").MinimalAttributeProcessor;
+    version: string;
+    i18n: {
+        getLocale(): string;
+        setLocale(locale: string): void;
+        getAvailableLocales(): string[];
+        detectAndSetLocale(): string;
+        registerLocale(locale: string, provider: KeywordResolver): void;
+        toLocale(code: string, targetLocale?: string): string;
+        toEnglish(code: string, sourceLocale?: string): string;
+        translate: typeof translate;
+        createTransformer(sourceLocale: string, targetLocale: string): GrammarTransformer;
+        getProfile: typeof getProfile;
+        getSupportedGrammarLocales: typeof getSupportedLocales;
+        profiles: Record<string, any>;
+        dictionaries: {
+            en: {};
+            es: any;
+            ja: any;
+            fr: any;
+            de: any;
+            ar: any;
+            ko: any;
+            zh: any;
+            tr: any;
+            id: any;
+            pt: any;
+            qu: any;
+            sw: any;
+        };
+        createKeywordProvider: typeof createKeywordProvider;
+    };
+    commands: string[];
+    locales: string[];
+    eval: (code: string, context?: any) => Promise<unknown>;
+    init: (options?: {
+        autoDetectLocale?: boolean;
+    }) => void;
+};
+export default api;
+//# sourceMappingURL=browser-bundle-classic-i18n.d.ts.map

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

@@ -0,0 +1,17 @@
+import { createContext } from '../core/context';
+declare const api: {
+    runtime: {
+        parse: (code: string) => import("../parser/parser").ParseResult;
+        execute: (code: string, context?: any) => Promise<unknown>;
+    };
+    parse: (code: string) => import("../parser/parser").ParseResult;
+    execute: (code: string, context?: any) => Promise<unknown>;
+    createContext: typeof createContext;
+    attributeProcessor: import("../dom/minimal-attribute-processor").MinimalAttributeProcessor;
+    version: string;
+    commands: string[];
+    eval: (code: string, context?: any) => Promise<unknown>;
+    init: () => Promise<void>;
+};
+export default api;
+//# sourceMappingURL=browser-bundle-classic.d.ts.map

package/dist/compatibility/browser-bundle-forms-generated.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-forms-generated.d.ts.map

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

@@ -0,0 +1,28 @@
+import { tokenize } from '../parser/hybrid/tokenizer';
+import type { ASTNode } from '../parser/hybrid/ast-types';
+import { addCommandAliases, addEventAliases } from '../parser/hybrid/aliases';
+export interface Context {
+    me: Element;
+    event?: Event;
+    it?: any;
+    you?: Element;
+    locals: Map<string, any>;
+    globals: Map<string, any>;
+}
+declare function evaluate(node: ASTNode, ctx: Context): Promise<any>;
+declare function processElements(root?: Element | Document): void;
+declare const api: {
+    version: string;
+    parse(code: string): ASTNode;
+    execute(code: string, element?: Element): Promise<any>;
+    init: typeof processElements;
+    process: typeof processElements;
+    addAliases: typeof addCommandAliases;
+    addEventAliases: typeof addEventAliases;
+    tokenize: typeof tokenize;
+    evaluate: typeof evaluate;
+    commands: string[];
+    blocks: string[];
+};
+export default api;
+//# sourceMappingURL=browser-bundle-hybrid-complete.d.ts.map

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

@@ -0,0 +1,43 @@
+import { HtmxAttributeProcessor, FIXI_ATTRS, HTMX_ATTRS, type HtmxProcessorOptions, type FxInitEventDetail, type FxConfigEventDetail, type FxAfterEventDetail, type FxFinallyEventDetail } from '../htmx/htmx-attribute-processor.js';
+import { translateToHyperscript, hasHtmxAttributes, hasFxAttributes, hasAnyAttributes, type HtmxConfig } from '../htmx/htmx-translator.js';
+interface HtmxCompatOptions extends HtmxProcessorOptions {
+    processHyperscript?: boolean;
+}
+declare function enableHtmxCompatibility(options?: HtmxCompatOptions): void;
+declare function disableHtmxCompatibility(): void;
+declare function getHtmxProcessor(): HtmxAttributeProcessor | null;
+declare function translateHtmx(element: Element): string;
+declare const api: {
+    version: string;
+    enableHtmxCompatibility: typeof enableHtmxCompatibility;
+    disableHtmxCompatibility: typeof disableHtmxCompatibility;
+    getHtmxProcessor: typeof getHtmxProcessor;
+    translateHtmx: typeof translateHtmx;
+    hasHtmxAttributes: typeof hasHtmxAttributes;
+    hasFxAttributes: typeof hasFxAttributes;
+    hasAnyAttributes: typeof hasAnyAttributes;
+    HtmxAttributeProcessor: typeof HtmxAttributeProcessor;
+    translateToHyperscript: typeof translateToHyperscript;
+    features: {
+        htmx: boolean;
+        fixi: boolean;
+        hyperscript: boolean;
+    };
+    htmxAttributes: string[];
+    fixiAttributes: string[];
+    fixiEvents: string[];
+    parse(code: string): import("../parser/hybrid-parser.js").HybridASTNode;
+    execute(code: string, element?: Element): Promise<any>;
+    init: (root?: Element | Document) => void;
+    process: (root?: Element | Document) => void;
+    addAliases: typeof import("../parser/hybrid/aliases.js").addCommandAliases;
+    addEventAliases: typeof import("../parser/hybrid/aliases.js").addEventAliases;
+    tokenize: typeof import("../parser/hybrid-parser.js").tokenize;
+    evaluate: (node: import("../parser/hybrid-parser.js").HybridASTNode, ctx: import("./browser-bundle-hybrid-complete.js").Context) => Promise<any>;
+    commands: string[];
+    blocks: string[];
+};
+export default api;
+export { enableHtmxCompatibility, disableHtmxCompatibility, translateHtmx, HtmxAttributeProcessor, hasFxAttributes, hasAnyAttributes, FIXI_ATTRS, HTMX_ATTRS, };
+export type { HtmxConfig, HtmxCompatOptions, HtmxProcessorOptions, FxInitEventDetail, FxConfigEventDetail, FxAfterEventDetail, FxFinallyEventDetail, };
+//# sourceMappingURL=browser-bundle-hybrid-hx.d.ts.map

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

@@ -0,0 +1,25 @@
+interface LiteCommand {
+    name: string;
+    args: string[];
+    target?: string;
+    modifier?: string;
+}
+interface LiteEventHandler {
+    event: string;
+    filter?: string;
+    commands: LiteCommand[];
+}
+declare function parseLite(code: string): LiteEventHandler | LiteCommand[];
+declare function processElements(root?: Element | Document): void;
+declare const api: {
+    version: string;
+    parse: typeof parseLite;
+    execute: (code: string, element?: Element) => Promise<any>;
+    init: typeof processElements;
+    process: typeof processElements;
+    addAliases: (aliases: Record<string, string>) => void;
+    addEventAliases: (aliases: Record<string, string>) => void;
+    commands: string[];
+};
+export default api;
+//# sourceMappingURL=browser-bundle-lite-plus.d.ts.map

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

@@ -0,0 +1,23 @@
+interface LiteCommand {
+    name: string;
+    args: string[];
+    target?: string;
+    modifier?: string;
+}
+interface LiteEventHandler {
+    event: string;
+    filter?: string;
+    commands: LiteCommand[];
+}
+declare function parseLite(code: string): LiteEventHandler | LiteCommand[];
+declare function processElements(root?: Element | Document): void;
+declare const api: {
+    version: string;
+    parse: typeof parseLite;
+    execute: (code: string, element?: Element) => Promise<any>;
+    init: typeof processElements;
+    process: typeof processElements;
+    commands: string[];
+};
+export default api;
+//# sourceMappingURL=browser-bundle-lite.d.ts.map

package/dist/compatibility/browser-bundle-minimal-generated.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-minimal-generated.d.ts.map

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

@@ -0,0 +1,17 @@
+import { createContext } from '../core/context';
+declare const api: {
+    runtime: {
+        parse: (code: string) => import("../parser/parser").ParseResult;
+        execute: (code: string, context?: any) => Promise<unknown>;
+    };
+    parse: (code: string) => import("../parser/parser").ParseResult;
+    execute: (code: string, context?: any) => Promise<unknown>;
+    createContext: typeof createContext;
+    attributeProcessor: import("../dom/minimal-attribute-processor").MinimalAttributeProcessor;
+    version: string;
+    commands: string[];
+    eval: (code: string, context?: any) => Promise<unknown>;
+    init: () => void;
+};
+export default api;
+//# sourceMappingURL=browser-bundle-minimal-v2.d.ts.map

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

@@ -0,0 +1,8 @@
+import { Runtime } from '../runtime/runtime';
+import { parse } from '../parser/parser';
+import { defaultAttributeProcessor } from '../dom/attribute-processor';
+import { createContext } from '../core/context';
+export declare function createMinimalRuntime(): Runtime;
+declare const runtime: Runtime;
+export { runtime, parse, createContext, defaultAttributeProcessor };
+//# sourceMappingURL=browser-bundle-minimal.d.ts.map

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

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

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

@@ -0,0 +1,19 @@
+import { createContext } from '../core/context';
+import type { ASTNode } from '../types/base-types';
+declare const api: {
+    execute(code: string, lang: string, context?: any): Promise<any>;
+    parse(code: string, lang: string): ASTNode | null;
+    translate(code: string, sourceLang: string, targetLang: string): string;
+    getAllTranslations(code: string, sourceLang: string): Record<string, string>;
+    createContext: typeof createContext;
+    runtime: import("../runtime/runtime-experimental").RuntimeExperimental;
+    version: string;
+    commands: readonly ["hide", "show", "add", "remove", "toggle", "put", "make", "wait", "fetch", "set", "get", "increment", "decrement", "default", "trigger", "send", "go", "if", "repeat", "break", "continue", "halt", "return", "exit", "unless", "throw", "call", "pseudo-command", "append", "transition", "measure", "settle", "take", "js", "async", "log", "tell", "copy", "pick", "beep", "install", "render"];
+    supportedLanguages: readonly ["en", "ja", "ar", "es", "ko", "zh", "tr", "pt", "fr", "de", "id", "qu", "sw"];
+    bundleType: "multilingual";
+    processNode: (element: Element | Document) => Promise<void>;
+    process: (element: Element | Document) => Promise<void>;
+};
+export default api;
+export { api as hyperfixi };
+//# sourceMappingURL=browser-bundle-multilingual.d.ts.map

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

@@ -0,0 +1,24 @@
+import { createContext } from '../core/context';
+import type { ASTNode } from '../types/base-types';
+import { getSupportedLanguages } from '@lokascript/semantic';
+declare const api: {
+    execute(code: string, lang: string, context?: any): Promise<any>;
+    parse(code: string, lang: string): ASTNode | null;
+    translate(code: string, sourceLang: string, targetLang: string): string;
+    getAllTranslations(code: string, sourceLang: string): Record<string, string>;
+    tokenize(code: string, lang: string): import("@lokascript/semantic").TokenStream;
+    isLanguageSupported(lang: string): boolean;
+    getTokenizer(lang: string): import("@lokascript/semantic").LanguageTokenizer | undefined;
+    createContext: typeof createContext;
+    runtime: import("../runtime/runtime-experimental").RuntimeExperimental;
+    analyzer: import("@lokascript/semantic").SemanticAnalyzer;
+    version: string;
+    semanticVersion: string;
+    commands: readonly ["hide", "show", "add", "remove", "toggle", "put", "make", "wait", "fetch", "set", "get", "increment", "decrement", "default", "trigger", "send", "go", "if", "repeat", "break", "continue", "halt", "return", "exit", "unless", "throw", "call", "pseudo-command", "append", "transition", "measure", "settle", "take", "js", "async", "log", "tell", "copy", "pick", "beep", "install", "render"];
+    supportedLanguages: readonly ["en", "ja", "ar", "es", "ko", "zh", "tr", "pt", "fr", "de", "id", "qu", "sw"];
+    getSupportedLanguages: typeof getSupportedLanguages;
+    bundleType: "semantic-complete";
+};
+export default api;
+export { api as hyperfixi };
+//# sourceMappingURL=browser-bundle-semantic-complete.d.ts.map

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

@@ -0,0 +1,17 @@
+import { createContext } from '../core/context';
+declare const api: {
+    runtime: {
+        parse: (code: string) => import("../parser/parser").ParseResult;
+        execute: (code: string, context?: any) => Promise<unknown>;
+    };
+    parse: (code: string) => import("../parser/parser").ParseResult;
+    execute: (code: string, context?: any) => Promise<unknown>;
+    createContext: typeof createContext;
+    attributeProcessor: import("../dom/minimal-attribute-processor").MinimalAttributeProcessor;
+    version: string;
+    commands: string[];
+    eval: (code: string, context?: any) => Promise<unknown>;
+    init: () => void;
+};
+export default api;
+//# sourceMappingURL=browser-bundle-standard-v2.d.ts.map

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

@@ -0,0 +1,8 @@
+import { Runtime } from '../runtime/runtime';
+import { parse } from '../parser/parser';
+import { defaultAttributeProcessor } from '../dom/attribute-processor';
+import { createContext } from '../core/context';
+export declare function createStandardRuntime(): Runtime;
+declare const runtime: Runtime;
+export { runtime, parse, createContext, defaultAttributeProcessor };
+//# sourceMappingURL=browser-bundle-standard.d.ts.map