@hyperfixi/core 3.3.0 → 4.0.1

package/dist/parser/regex-parser.mjs

@@ -1,419 +0,0 @@
-function createProcessElements(parse, run, errorLabel) {
-    return (root = document) => {
-        root.querySelectorAll('[_]').forEach(el => {
-            const code = el.getAttribute('_');
-            if (!code)
-                return;
-            try {
-                run(parse(code), el);
-            }
-            catch (err) {
-                console.error(`HyperFixi ${errorLabel} error:`, err, 'Code:', code);
-            }
-        });
-    };
-}
-function installBundleGlobal(api, processElements, globalName = 'hyperfixi') {
-    if (typeof window === 'undefined')
-        return;
-    window[globalName] = api;
-    if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', () => processElements());
-    }
-    else {
-        processElements();
-    }
-}
-
-function parseLite(code) {
-    const trimmed = code.trim();
-    const onMatch = trimmed.match(/^on\s+(\w+)(?:\s+from\s+([^\s]+))?\s+(.+)$/i);
-    if (onMatch) {
-        return {
-            event: onMatch[1],
-            filter: onMatch[2],
-            commands: parseCommands(onMatch[3]),
-        };
-    }
-    const everyMatch = trimmed.match(/^every\s+(\d+)(ms|s)?\s+(.+)$/i);
-    if (everyMatch) {
-        const ms = everyMatch[2] === 's' ? parseInt(everyMatch[1]) * 1000 : parseInt(everyMatch[1]);
-        return {
-            event: `interval:${ms}`,
-            commands: parseCommands(everyMatch[3]),
-        };
-    }
-    const initMatch = trimmed.match(/^init\s+(.+)$/i);
-    if (initMatch) {
-        return {
-            event: 'init',
-            commands: parseCommands(initMatch[1]),
-        };
-    }
-    return parseCommands(trimmed);
-}
-function parseCommands(code) {
-    const parts = code.split(/\s+(?:then|and)\s+/i);
-    return parts.map(parseCommand).filter(Boolean);
-}
-function parseCommand(code) {
-    const trimmed = code.trim();
-    if (!trimmed)
-        return null;
-    let match = trimmed.match(/^toggle\s+(\.\w+|\w+)(?:\s+on\s+(.+))?$/i);
-    if (match) {
-        return { name: 'toggle', args: [match[1]], target: match[2] };
-    }
-    match = trimmed.match(/^add\s+(\.\w+|\w+)(?:\s+to\s+(.+))?$/i);
-    if (match) {
-        return { name: 'add', args: [match[1]], target: match[2] };
-    }
-    match = trimmed.match(/^remove\s+(\.\w+)(?:\s+from\s+(.+))?$/i);
-    if (match) {
-        return { name: 'remove', args: [match[1]], target: match[2] };
-    }
-    match = trimmed.match(/^remove\s+(.+)$/i);
-    if (match) {
-        return { name: 'remove', args: [], target: match[1] };
-    }
-    match = trimmed.match(/^put\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s+(into|before|after)\s+(.+)$/i);
-    if (match) {
-        const content = match[1] || match[2] || match[3];
-        return { name: 'put', args: [content], modifier: match[4], target: match[5] };
-    }
-    match = trimmed.match(/^set\s+(.+?)\s+to\s+(.+)$/i);
-    if (match) {
-        return { name: 'set', args: [match[1], match[2]] };
-    }
-    match = trimmed.match(/^log\s+(.+)$/i);
-    if (match) {
-        return { name: 'log', args: [match[1]] };
-    }
-    match = trimmed.match(/^send\s+(\w+)(?:\s+to\s+(.+))?$/i);
-    if (match) {
-        return { name: 'send', args: [match[1]], target: match[2] };
-    }
-    match = trimmed.match(/^wait\s+(\d+)(ms|s)?$/i);
-    if (match) {
-        const ms = match[2] === 's' ? parseInt(match[1]) * 1000 : parseInt(match[1]);
-        return { name: 'wait', args: [ms.toString()] };
-    }
-    match = trimmed.match(/^(if|unless)\s+(.+?)\s+(toggle|add|remove|put|set|log|send|wait)\s+(.+)$/i);
-    if (match) {
-        const innerCmd = parseCommand(`${match[3]} ${match[4]}`);
-        if (innerCmd) {
-            innerCmd.modifier = match[1].toLowerCase();
-            innerCmd.args.unshift(match[2]);
-            return innerCmd;
-        }
-    }
-    match = trimmed.match(/^(show|hide)(?:\s+(.+))?$/i);
-    if (match) {
-        const target = match[2];
-        return match[1].toLowerCase() === 'show'
-            ? { name: 'remove', args: ['.hidden'], target }
-            : { name: 'add', args: ['.hidden'], target };
-    }
-    const parts = trimmed.split(/\s+/);
-    if (parts.length > 0) {
-        return { name: parts[0], args: parts.slice(1) };
-    }
-    return null;
-}
-const elementVars = new WeakMap();
-function elemScope(el) {
-    let m = elementVars.get(el);
-    if (!m) {
-        m = new Map();
-        elementVars.set(el, m);
-    }
-    return m;
-}
-function resolveTarget(target, me) {
-    if (!target)
-        return me;
-    const t = target.trim();
-    if (t === 'me')
-        return me;
-    if (t === 'body')
-        return document.body;
-    if (t.startsWith('#') || t.startsWith('.') || t.startsWith('[')) {
-        const elements = document.querySelectorAll(t);
-        return elements.length === 1 ? elements[0] : Array.from(elements);
-    }
-    if (/^\w+$/.test(t) && document.getElementById(t)) {
-        return document.getElementById(t);
-    }
-    return me;
-}
-function getClassName(arg) {
-    return arg.startsWith('.') ? arg.slice(1) : arg;
-}
-async function executeCommand(cmd, me, locals) {
-    const target = resolveTarget(cmd.target, me);
-    const elements = Array.isArray(target) ? target : target ? [target] : [me];
-    switch (cmd.name) {
-        case 'toggle': {
-            const className = getClassName(cmd.args[0]);
-            for (const el of elements) {
-                el.classList.toggle(className);
-            }
-            return elements.length === 1 ? elements[0] : elements;
-        }
-        case 'add': {
-            const className = getClassName(cmd.args[0]);
-            for (const el of elements) {
-                el.classList.add(className);
-            }
-            return elements.length === 1 ? elements[0] : elements;
-        }
-        case 'remove': {
-            if (cmd.args[0]) {
-                const className = getClassName(cmd.args[0]);
-                for (const el of elements) {
-                    el.classList.remove(className);
-                }
-            }
-            else {
-                for (const el of elements) {
-                    el.remove();
-                }
-            }
-            return null;
-        }
-        case 'put': {
-            const content = evaluateValue(cmd.args[0], me);
-            for (const el of elements) {
-                switch (cmd.modifier?.toLowerCase()) {
-                    case 'into':
-                        el.innerHTML = String(content);
-                        break;
-                    case 'before':
-                        el.insertAdjacentHTML('beforebegin', String(content));
-                        break;
-                    case 'after':
-                        el.insertAdjacentHTML('afterend', String(content));
-                        break;
-                    default:
-                        el.innerHTML = String(content);
-                }
-            }
-            return elements.length === 1 ? elements[0] : elements;
-        }
-        case 'set': {
-            const [targetExpr, valueExpr] = cmd.args;
-            const value = evaluateValue(valueExpr, me);
-            if (targetExpr.startsWith(':')) {
-                elemScope(me).set(targetExpr.slice(1), value);
-                return value;
-            }
-            const propMatch = targetExpr.match(/^(.+?)(?:'s|\.)\s*(\w+)$/);
-            if (propMatch) {
-                const obj = resolveTarget(propMatch[1], me);
-                if (obj) {
-                    obj[propMatch[2]] = value;
-                    return obj;
-                }
-            }
-            return value;
-        }
-        case 'log': {
-            const value = evaluateValue(cmd.args.join(' '), me);
-            console.log(value);
-            return value;
-        }
-        case 'send': {
-            const eventName = cmd.args[0];
-            const event = new CustomEvent(eventName, { bubbles: true });
-            for (const el of elements) {
-                el.dispatchEvent(event);
-            }
-            return event;
-        }
-        case 'wait': {
-            const ms = parseInt(cmd.args[0]) || 0;
-            await new Promise(resolve => setTimeout(resolve, ms));
-            return ms;
-        }
-        default:
-            console.error(`[hyperfixi] Unknown command "${cmd.name}" \u2014 not in this bundle. Use hyperfixi.js (full bundle).`);
-            return null;
-    }
-}
-function evaluateValue(expr, me, locals) {
-    if (!expr)
-        return undefined;
-    const e = expr.trim();
-    if ((e.startsWith('"') && e.endsWith('"')) || (e.startsWith("'") && e.endsWith("'"))) {
-        return e.slice(1, -1);
-    }
-    if (/^-?\d+(\.\d+)?$/.test(e)) {
-        return parseFloat(e);
-    }
-    if (e === 'true')
-        return true;
-    if (e === 'false')
-        return false;
-    if (e === 'null')
-        return null;
-    if (e.startsWith(':')) {
-        return elemScope(me).get(e.slice(1));
-    }
-    if (e === 'me')
-        return me;
-    if (e === 'my')
-        return me;
-    if (e === 'body')
-        return document.body;
-    const propMatch = e.match(/^(me|my)\.(\w+)$/);
-    if (propMatch) {
-        return me[propMatch[2]];
-    }
-    return e;
-}
-async function executeParsed(parsed, me, locals = new Map()) {
-    if (Array.isArray(parsed)) {
-        let result;
-        for (const cmd of parsed) {
-            if (cmd.modifier === 'if' || cmd.modifier === 'unless') {
-                const condition = evaluateCondition(cmd.args[0], me);
-                const shouldRun = cmd.modifier === 'if' ? condition : !condition;
-                if (!shouldRun)
-                    continue;
-                cmd.args.shift();
-            }
-            result = await executeCommand(cmd, me);
-        }
-        return result;
-    }
-    const handler = parsed;
-    const targetEl = handler.filter ? document.querySelector(handler.filter) : me;
-    const eventName = handler.event;
-    if (eventName.startsWith('interval:')) {
-        const ms = parseInt(eventName.split(':')[1]);
-        setInterval(async () => {
-            new Map(locals);
-            for (const cmd of handler.commands) {
-                await executeCommand(cmd, me);
-            }
-        }, ms);
-        return me;
-    }
-    if (eventName === 'init') {
-        new Map(locals);
-        for (const cmd of handler.commands) {
-            await executeCommand(cmd, me);
-        }
-        return me;
-    }
-    if (targetEl) {
-        targetEl.addEventListener(eventName, async (event) => {
-            const handlerLocals = new Map(locals);
-            handlerLocals.set('event', event);
-            for (const cmd of handler.commands) {
-                await executeCommand(cmd, me);
-            }
-        });
-    }
-    return me;
-}
-function evaluateCondition(expr, me, locals) {
-    const e = expr.trim();
-    const hasMatch = e.match(/^(me|my)\s+has\s+\.(\w+)$/i);
-    if (hasMatch) {
-        return me.classList.contains(hasMatch[2]);
-    }
-    const propMatch = e.match(/^(me|my)\.(\w+)$/i);
-    if (propMatch) {
-        return Boolean(me[propMatch[2]]);
-    }
-    if (e.startsWith(':')) {
-        return Boolean(elemScope(me).get(e.slice(1)));
-    }
-    const value = evaluateValue(e, me);
-    return Boolean(value);
-}
-const processElements = createProcessElements(parseLite, executeParsed, 'Lite');
-const api = {
-    version: '1.0.0-lite',
-    parse: parseLite,
-    execute: async (code, element) => executeParsed(parseLite(code), element || document.body),
-    init: processElements,
-    process: processElements,
-    commands: ['add', 'remove', 'toggle', 'put', 'set', 'log', 'send', 'wait'],
-};
-installBundleGlobal(api, processElements);
-
-class RegexParserImpl {
-    constructor() {
-        this.name = 'regex';
-        this.supportedCommands = [
-            'add',
-            'remove',
-            'toggle',
-            'put',
-            'set',
-            'log',
-            'send',
-            'wait',
-        ];
-    }
-    parse(code) {
-        const result = api.parse(code);
-        if ('event' in result) {
-            return {
-                type: 'eventHandler',
-                event: result.event,
-                filter: result.filter,
-                commands: result.commands.map(cmd => this.convertCommand(cmd)),
-            };
-        }
-        if (Array.isArray(result)) {
-            if (result.length === 1) {
-                return this.convertCommand(result[0]);
-            }
-            return {
-                type: 'sequence',
-                commands: result.map(cmd => this.convertCommand(cmd)),
-            };
-        }
-        return this.convertCommand(result);
-    }
-    convertCommand(cmd) {
-        return {
-            type: 'command',
-            name: cmd.name,
-            args: cmd.args.map(arg => ({
-                type: 'literal',
-                value: arg,
-            })),
-            ...(cmd.target && {
-                target: {
-                    type: 'selector',
-                    value: cmd.target,
-                },
-            }),
-        };
-    }
-    parseCommands(code) {
-        const result = this.parse(code);
-        if (result.type === 'sequence' && 'commands' in result) {
-            return result.commands;
-        }
-        return [result];
-    }
-    supports(syntax) {
-        const firstWord = syntax.trim().split(/\s+/)[0]?.toLowerCase();
-        if (firstWord === 'on' || firstWord === 'every' || firstWord === 'init') {
-            return true;
-        }
-        return this.supportedCommands.includes(firstWord);
-    }
-}
-const regexParser = new RegexParserImpl();
-function createRegexParser() {
-    return new RegexParserImpl();
-}
-
-export { createRegexParser, regexParser };
-//# sourceMappingURL=regex-parser.mjs.map

package/dist/parser/runtime.d.ts

@@ -1,14 +0,0 @@
-import type { ExecutionContext } from '../types/core';
-import type { ExecutionResult } from '../types/result';
-import { setGlobal } from './extensions';
-export { setGlobal };
-import { type AnyNode } from '../ast/legacy';
-export declare function evaluateAST(node: AnyNode, context: ExecutionContext): Promise<any>;
-export declare function evaluateASTWithResult(node: AnyNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
-export declare class NotSyncEvaluable extends Error {
-    constructor(nodeType: string);
-}
-export declare function evaluateExpressionSync(node: AnyNode, context: ExecutionContext): unknown;
-export declare function evaluateExpressionFromSourceSync(source: string, context: ExecutionContext): unknown;
-export declare function evaluateExpressionFromSource(source: string, context: ExecutionContext): Promise<any>;
-//# sourceMappingURL=runtime.d.ts.map

package/dist/parser/semantic-integration.d.ts

@@ -1,17 +0,0 @@
-export declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.5;
-import type { ASTNode } from '../types/base-types';
-export interface FrontEndParseResult {
-    ast: ASTNode | null;
-    usedDirectPath: boolean;
-    confidence: number;
-    lang: string;
-    fallbackText: string | null;
-    warnings?: string[];
-}
-export interface FrontEnd {
-    readonly name: string;
-    parseToAST(code: string, lang: string): Promise<FrontEndParseResult>;
-    parse?(code: string, lang: string): Promise<unknown>;
-    render?(node: unknown, lang: string): Promise<string>;
-}
-//# sourceMappingURL=semantic-integration.d.ts.map

package/dist/parser/token-consumer.d.ts

@@ -1,34 +0,0 @@
-import type { ASTNode, Token } from '../types/core';
-export interface ParserInterface {
-    isAtEnd(): boolean;
-    check(value: string): boolean;
-    checkTokenType(type: string): boolean;
-    advance(): Token;
-    peek(): Token;
-    parsePrimary(): ASTNode;
-    parseExpression(): ASTNode;
-    isCommand(name: string): boolean;
-}
-export interface ParseUntilOptions {
-    additionalTerminators?: string[];
-    allowExpressions?: boolean;
-    stopAtCommands?: boolean;
-    stopWhen?: (parser: ParserInterface) => boolean;
-}
-export declare class TokenConsumer {
-    private parser;
-    constructor(parser: ParserInterface);
-    parseArgsUntilTerminator(options?: ParseUntilOptions): ASTNode[];
-    private shouldStopParsing;
-    consumeOptionalThe(): boolean;
-    consumeOptionalArticle(): 'a' | 'an' | null;
-    parsePrepositionTarget(preposition: string, parseExpression?: boolean): {
-        preposition: string;
-        target: ASTNode;
-    } | null;
-    parseOptionalModifiers(prepositions: Record<string, boolean>): Record<string, ASTNode>;
-    isAtCommandSeparator(): boolean;
-    consumeOptionalSeparator(): 'then' | 'and' | null;
-    tryParseKeywordPhrase(keywords: string[]): string | null;
-}
-//# sourceMappingURL=token-consumer.d.ts.map

package/dist/parser/token-predicates.d.ts

@@ -1,77 +0,0 @@
-import type { Token } from '../types/core';
-export declare function isCommand(token: Token): boolean;
-export declare function isKeyword(token: Token): boolean;
-export declare function isEvent(token: Token): boolean;
-export declare function isContextVar(token: Token): boolean;
-export declare function isLogicalOperator(token: Token): boolean;
-export declare function isComparisonOperator(token: Token): boolean;
-export declare function isIdentifierLike(token: Token): boolean;
-export declare function isSelector(token: Token): boolean;
-export declare function isBasicSelector(token: Token): boolean;
-export declare function isLiteral(token: Token): boolean;
-export declare function isOperator(token: Token): boolean;
-export declare function isReference(token: Token): boolean;
-export declare function isTimeExpression(token: Token): boolean;
-export declare function isSymbol(token: Token): boolean;
-export declare function isComment(token: Token): boolean;
-export declare function isIdentifier(token: Token): boolean;
-export declare function isString(token: Token): boolean;
-export declare function isNumber(token: Token): boolean;
-export declare function isBoolean(token: Token): boolean;
-export declare function isTemplateLiteral(token: Token): boolean;
-export declare function isQueryReference(token: Token): boolean;
-export declare function isIdSelector(token: Token): boolean;
-export declare function isClassSelector(token: Token): boolean;
-export declare function isCssSelector(token: Token): boolean;
-export declare function isGlobalVar(token: Token): boolean;
-export declare function isBasicOperator(token: Token): boolean;
-export declare function hasValue(token: Token, value: string): boolean;
-export declare function hasValueIn(token: Token, values: readonly string[]): boolean;
-export declare function isOperatorValue(token: Token, value: string): boolean;
-export declare function isPossessive(token: Token): boolean;
-export declare function isDot(token: Token): boolean;
-export declare function isOptionalChain(token: Token): boolean;
-export declare function isOpenBracket(token: Token): boolean;
-export declare function isOpenParen(token: Token): boolean;
-export declare function canStartExpression(token: Token): boolean;
-export declare function isCommandTerminator(token: Token): boolean;
-export declare const TokenPredicates: {
-    isCommand: typeof isCommand;
-    isKeyword: typeof isKeyword;
-    isEvent: typeof isEvent;
-    isContextVar: typeof isContextVar;
-    isLogicalOperator: typeof isLogicalOperator;
-    isComparisonOperator: typeof isComparisonOperator;
-    isIdentifierLike: typeof isIdentifierLike;
-    isSelector: typeof isSelector;
-    isBasicSelector: typeof isBasicSelector;
-    isLiteral: typeof isLiteral;
-    isOperator: typeof isOperator;
-    isReference: typeof isReference;
-    isTimeExpression: typeof isTimeExpression;
-    isSymbol: typeof isSymbol;
-    isComment: typeof isComment;
-    isIdentifier: typeof isIdentifier;
-    isString: typeof isString;
-    isNumber: typeof isNumber;
-    isBoolean: typeof isBoolean;
-    isTemplateLiteral: typeof isTemplateLiteral;
-    isQueryReference: typeof isQueryReference;
-    isIdSelector: typeof isIdSelector;
-    isClassSelector: typeof isClassSelector;
-    isCssSelector: typeof isCssSelector;
-    isGlobalVar: typeof isGlobalVar;
-    isBasicOperator: typeof isBasicOperator;
-    hasValue: typeof hasValue;
-    hasValueIn: typeof hasValueIn;
-    isOperatorValue: typeof isOperatorValue;
-    isPossessive: typeof isPossessive;
-    isDot: typeof isDot;
-    isOptionalChain: typeof isOptionalChain;
-    isOpenBracket: typeof isOpenBracket;
-    isOpenParen: typeof isOpenParen;
-    canStartExpression: typeof canStartExpression;
-    isCommandTerminator: typeof isCommandTerminator;
-};
-export default TokenPredicates;
-//# sourceMappingURL=token-predicates.d.ts.map

package/dist/parser/tokenizer.d.ts

@@ -1,28 +0,0 @@
-import type { Token } from '../types/core';
-export type { Token } from '../types/core';
-export declare enum TokenKind {
-    IDENTIFIER = "identifier",
-    STRING = "string",
-    NUMBER = "number",
-    SELECTOR = "selector",
-    OPERATOR = "operator",
-    TIME = "time",
-    TEMPLATE = "template",
-    COMMENT = "comment",
-    SYMBOL = "symbol",
-    UNKNOWN = "unknown"
-}
-export interface Tokenizer {
-    input: string;
-    position: number;
-    line: number;
-    column: number;
-    tokens: Token[];
-}
-export declare function createTokenizer(): Tokenizer;
-export declare function tokenize(input: string): Token[];
-export declare function lineColumnAt(input: string, offset: number): {
-    line: number;
-    column: number;
-};
-//# sourceMappingURL=tokenizer.d.ts.map

package/dist/parser/types.d.ts

@@ -1,105 +0,0 @@
-export type TokenType = 'STRING' | 'NUMBER' | 'BOOLEAN' | 'NULL' | 'IDENTIFIER' | 'KEYWORD' | 'OPERATOR' | 'COMPARISON' | 'LOGICAL' | 'ASSIGNMENT' | 'LPAREN' | 'RPAREN' | 'LBRACKET' | 'RBRACKET' | 'LBRACE' | 'RBRACE' | 'COMMA' | 'DOT' | 'COLON' | 'SEMICOLON' | 'APOSTROPHE' | 'WHITESPACE' | 'NEWLINE' | 'EOF' | 'UNKNOWN';
-export interface Token {
-    type: TokenType;
-    value: string;
-    position: number;
-    line: number;
-    column: number;
-}
-export type ASTNodeType = 'Literal' | 'Identifier' | 'BinaryExpression' | 'UnaryExpression' | 'CallExpression' | 'MemberExpression' | 'ConditionalExpression' | 'ExpressionStatement' | 'BlockStatement' | 'EventStatement' | 'CommandStatement' | 'EventHandler' | 'Command' | 'Selector' | 'PropertyAccess' | 'PossessiveExpression';
-export interface BaseASTNode {
-    type: ASTNodeType;
-    position: {
-        start: number;
-        end: number;
-        line: number;
-        column: number;
-    };
-}
-export interface LiteralNode extends BaseASTNode {
-    type: 'Literal';
-    value: string | number | boolean | null;
-    raw: string;
-}
-export interface IdentifierNode extends BaseASTNode {
-    type: 'Identifier';
-    name: string;
-}
-export interface BinaryExpressionNode extends BaseASTNode {
-    type: 'BinaryExpression';
-    operator: string;
-    left: ASTNode;
-    right: ASTNode;
-}
-export interface UnaryExpressionNode extends BaseASTNode {
-    type: 'UnaryExpression';
-    operator: string;
-    argument: ASTNode;
-    prefix: boolean;
-}
-export interface CallExpressionNode extends BaseASTNode {
-    type: 'CallExpression';
-    callee: ASTNode;
-    arguments: ASTNode[];
-}
-export interface MemberExpressionNode extends BaseASTNode {
-    type: 'MemberExpression';
-    object: ASTNode;
-    property: ASTNode;
-    computed: boolean;
-}
-export interface EventHandlerNode extends BaseASTNode {
-    type: 'EventHandler';
-    event: string;
-    selector?: string;
-    commands: CommandNode[];
-}
-export interface CommandNode extends BaseASTNode {
-    type: 'Command';
-    name: string;
-    arguments: ASTNode[];
-    target?: ASTNode;
-}
-export interface SelectorNode extends BaseASTNode {
-    type: 'Selector';
-    value: string;
-}
-export interface PossessiveExpressionNode extends BaseASTNode {
-    type: 'PossessiveExpression';
-    object: ASTNode;
-    property: ASTNode;
-}
-export type ASTNode = LiteralNode | IdentifierNode | BinaryExpressionNode | UnaryExpressionNode | CallExpressionNode | MemberExpressionNode | EventHandlerNode | CommandNode | SelectorNode | PossessiveExpressionNode;
-export interface ParseResult {
-    ast: ASTNode;
-    tokens: Token[];
-    errors: ParseError[];
-}
-export interface ParseError {
-    name?: string;
-    message: string;
-    position: number;
-    line: number;
-    column: number;
-    token?: Token;
-}
-export interface KeywordResolver {
-    resolve(token: string): string | undefined;
-    isCommand(token: string): boolean;
-    isKeyword(token: string): boolean;
-}
-export interface ParserOptions {
-    includeWhitespace?: boolean;
-    includeComments?: boolean;
-    strict?: boolean;
-    keywords?: KeywordResolver;
-    registryIntegration?: ParserRegistryIntegration;
-}
-export interface ParserRegistryIntegration {
-    hasEventSource(eventName: string): boolean;
-    getEventSource(eventName: string): {
-        name: string;
-    } | undefined;
-}
-export declare const HYPERSCRIPT_KEYWORDS: Set<string>;
-//# sourceMappingURL=types.d.ts.map