@hyperfixi/core 2.0.0

package/dist/parser/parser-constants.d.ts

@@ -0,0 +1,102 @@
+export declare const KEYWORDS: {
+    readonly THEN: "then";
+    readonly ELSE: "else";
+    readonly END: "end";
+    readonly AND: "and";
+    readonly OR: "or";
+    readonly NOT: "not";
+    readonly IF: "if";
+    readonly UNLESS: "unless";
+    readonly FOR: "for";
+    readonly WHILE: "while";
+    readonly UNTIL: "until";
+    readonly FOREVER: "forever";
+    readonly TIMES: "times";
+    readonly EACH: "each";
+    readonly INDEX: "index";
+    readonly IN: "in";
+    readonly TO: "to";
+    readonly FROM: "from";
+    readonly INTO: "into";
+    readonly WITH: "with";
+    readonly WITHOUT: "without";
+    readonly OF: "of";
+    readonly AT: "at";
+    readonly BY: "by";
+    readonly BETWEEN: "between";
+    readonly AS: "as";
+    readonly MATCHES: "matches";
+    readonly CONTAINS: "contains";
+    readonly ON: "on";
+    readonly WHEN: "when";
+    readonly WHERE: "where";
+    readonly EVERY: "every";
+    readonly EVENT: "event";
+    readonly INIT: "init";
+    readonly DEF: "def";
+    readonly BEHAVIOR: "behavior";
+    readonly GLOBAL: "global";
+    readonly LOCAL: "local";
+    readonly THE: "the";
+    readonly A: "a";
+    readonly AN: "an";
+    readonly FIRST: "first";
+    readonly LAST: "last";
+    readonly START: "start";
+    readonly BEFORE: "before";
+    readonly AFTER: "after";
+};
+export declare const COMMAND_TERMINATORS: readonly ["then", "and", "else", "end", "on"];
+export declare const COMMANDS: Set<string>;
+export declare const COMPOUND_COMMANDS: Set<string>;
+export declare const CONTROL_FLOW_COMMANDS: Set<string>;
+export declare const PUT_OPERATIONS: {
+    readonly INTO: "into";
+    readonly BEFORE: "before";
+    readonly AFTER: "after";
+    readonly AT: "at";
+    readonly AT_START_OF: "at start of";
+    readonly AT_END_OF: "at end of";
+};
+export declare const PUT_OPERATION_KEYWORDS: readonly ["into", "before", "after", "at", "at start of", "at end of", "at the start of", "at the end of"];
+export declare const REPEAT_TYPES: {
+    readonly FOR: "for";
+    readonly WHILE: "while";
+    readonly UNTIL: "until";
+    readonly FOREVER: "forever";
+    readonly TIMES: "times";
+    readonly IN: "in";
+};
+export declare const WAIT_TYPES: {
+    readonly FOR: "for";
+    readonly A: "a";
+    readonly AN: "an";
+};
+export declare const EVENT_KEYWORDS: {
+    readonly EVENT: "event";
+    readonly EVENTS: "events";
+    readonly FROM: "from";
+    readonly QUEUE: "queue";
+    readonly CALLED: "called";
+};
+export declare const TOGGLE_MODALITIES: {
+    readonly MODAL: "modal";
+    readonly POPOVER: "popover";
+};
+export declare const HYPERSCRIPT_KEYWORDS: Set<string>;
+export declare const CommandClassification: {
+    isCommand(name: string): boolean;
+    isCompoundCommand(name: string): boolean;
+    isControlFlowCommand(name: string): boolean;
+    isKeyword(name: string): boolean;
+    isTerminator(keyword: string): boolean;
+    isPutOperation(keyword: string): boolean;
+    isCSSFunction(name: string): boolean;
+};
+export declare const CSS_FUNCTIONS: Set<string>;
+export declare const CONTEXT_VARS: Set<string>;
+export declare const LOGICAL_OPERATORS: Set<string>;
+export declare const COMPARISON_OPERATORS: Set<string>;
+export declare const DOM_EVENTS: Set<string>;
+export declare const TOKENIZER_KEYWORDS: Set<string>;
+//# sourceMappingURL=parser-constants.d.ts.map

package/dist/parser/parser-interface.d.ts

@@ -0,0 +1,11 @@
+import type { ASTNode, CommandNode } from '../types/base-types';
+export interface ParserInterface {
+    parse(code: string): CommandNode | ASTNode;
+    parseCommands?(code: string): (CommandNode | ASTNode)[];
+    supports?(syntax: string): boolean;
+    readonly supportedCommands?: readonly string[];
+    readonly name: string;
+}
+export type ParserFactory = () => ParserInterface;
+export declare function isParserInterface(obj: unknown): obj is ParserInterface;
+//# sourceMappingURL=parser-interface.d.ts.map

package/dist/parser/parser-types.d.ts

@@ -0,0 +1,175 @@
+import type { Token, ASTNode, CommandNode } from '../types/core';
+import { TokenType } from './tokenizer';
+export interface Position {
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+}
+export interface IdentifierNode extends ASTNode {
+    type: 'identifier';
+    name: string;
+    scope?: 'local' | 'global';
+}
+export interface LiteralNode extends ASTNode {
+    type: 'literal';
+    value: unknown;
+    raw: string;
+}
+export interface BinaryExpressionNode extends ASTNode {
+    type: 'binaryExpression';
+    operator: string;
+    left: ASTNode;
+    right: ASTNode;
+}
+export interface UnaryExpressionNode extends ASTNode {
+    type: 'unaryExpression';
+    operator: string;
+    argument: ASTNode;
+    prefix: boolean;
+}
+export interface CallExpressionNode extends ASTNode {
+    type: 'callExpression';
+    callee: ASTNode;
+    arguments: ASTNode[];
+}
+export interface MemberExpressionNode extends ASTNode {
+    type: 'memberExpression';
+    object: ASTNode;
+    property: ASTNode;
+    computed: boolean;
+}
+export interface SelectorNode extends ASTNode {
+    type: 'selector';
+    value: string;
+}
+export interface PossessiveExpressionNode extends ASTNode {
+    type: 'possessiveExpression';
+    object: ASTNode;
+    property: ASTNode;
+}
+export interface BlockNode extends ASTNode {
+    type: 'block';
+    commands: ASTNode[];
+}
+export interface StringLiteralNode extends ASTNode {
+    type: 'string';
+    value: string;
+}
+export interface ObjectLiteralNode extends ASTNode {
+    type: 'objectLiteral';
+    properties: Array<{
+        key: ASTNode;
+        value: ASTNode;
+    }>;
+}
+export interface ArrayLiteralNode extends ASTNode {
+    type: 'arrayLiteral';
+    elements: ASTNode[];
+}
+export interface PropertyOfExpressionNode extends ASTNode {
+    type: 'propertyOfExpression';
+    property: ASTNode;
+    target: ASTNode;
+}
+export interface CommandSequenceNode extends ASTNode {
+    type: 'CommandSequence';
+    commands: ASTNode[];
+}
+export interface ProgramNode extends ASTNode {
+    type: 'Program';
+    statements: ASTNode[];
+}
+export interface MultiWordPattern {
+    command: string;
+    keywords: string[];
+    minArgs?: number;
+    maxArgs?: number;
+}
+export interface ParserContext {
+    readonly tokens: Token[];
+    current: number;
+    advance(): Token;
+    peek(): Token;
+    previous(): Token;
+    consume(expected: string | TokenType, message: string): Token;
+    check(value: string): boolean;
+    checkIdentifierLike(): boolean;
+    checkSelector(): boolean;
+    checkAnySelector(): boolean;
+    checkLiteral(): boolean;
+    checkReference(): boolean;
+    checkTimeExpression(): boolean;
+    checkEvent(): boolean;
+    checkIsCommand(): boolean;
+    checkContextVar(): boolean;
+    match(...types: Array<string | TokenType>): boolean;
+    matchOperator(operator: string): boolean;
+    isAtEnd(): boolean;
+    createIdentifier(name: string): IdentifierNode;
+    createLiteral(value: unknown, raw: string): ASTNode;
+    createSelector(value: string): ASTNode;
+    createBinaryExpression(operator: string, left: ASTNode, right: ASTNode): ASTNode;
+    createUnaryExpression(operator: string, operand: ASTNode, prefix?: boolean): ASTNode;
+    createMemberExpression(object: ASTNode, property: ASTNode, computed: boolean): ASTNode;
+    createPossessiveExpression(object: ASTNode, property: ASTNode): ASTNode;
+    createCallExpression(callee: ASTNode, args: ASTNode[]): ASTNode;
+    createErrorNode(): ASTNode;
+    createProgramNode(statements: ASTNode[]): ASTNode;
+    createCommandFromIdentifier(identifierNode: IdentifierNode): CommandNode;
+    parseExpression(): ASTNode;
+    parsePrimary(): ASTNode;
+    parseCall(): ASTNode;
+    parseAssignment(): ASTNode;
+    parseLogicalOr(): ASTNode;
+    parseLogicalAnd(): ASTNode;
+    parseEquality(): ASTNode;
+    parseComparison(): ASTNode;
+    parseAddition(): ASTNode;
+    parseMultiplication(): ASTNode;
+    parseImplicitBinary(): ASTNode;
+    parseConditional(): ASTNode;
+    parseConditionalBranch(): ASTNode;
+    parseEventHandler(): ASTNode;
+    parseBehaviorDefinition(): ASTNode;
+    parseNavigationFunction(): ASTNode;
+    parseMyPropertyAccess(): ASTNode;
+    parseDollarExpression(): ASTNode;
+    parseHyperscriptSelector(): ASTNode;
+    parseAttributeOrArrayLiteral(): ASTNode;
+    parseObjectLiteral(): ASTNode;
+    parseCSSObjectLiteral(): ASTNode;
+    parseCommand(): CommandNode;
+    parseCommandSequence(): ASTNode;
+    parseCommandListUntilEnd(): ASTNode[];
+    savePosition(): number;
+    restorePosition(pos: number): void;
+    peekAt(offset: number): Token | null;
+    getPosition(): Position;
+    addError(message: string): void;
+    addWarning(warning: string): void;
+    isCommand(name: string): boolean;
+    isCompoundCommand(name: string): boolean;
+    isKeyword(name: string): boolean;
+    getMultiWordPattern(commandName: string): MultiWordPattern | null;
+    resolveKeyword(value: string): string;
+    getInputSlice(start: number, end?: number): string;
+}
+export type CommandParserFunction = (token: Token, context: ParserContext) => CommandNode;
+export type CompoundCommandParserFunction = (identifierNode: IdentifierNode, context: ParserContext) => CommandNode | null;
+export type TokenNavigationFunction = (context: ParserContext) => Token | boolean;
+export type ASTNodeCreatorFunction = (...args: any[]) => ASTNode;
+export type ExpressionParserFunction = (context: ParserContext) => ASTNode;
+export interface ParseResult {
+    success: boolean;
+    node?: ASTNode;
+    error?: {
+        name: string;
+        message: string;
+        line?: number;
+        column?: number;
+        position?: number;
+    };
+    warnings?: string[];
+}
+//# sourceMappingURL=parser-types.d.ts.map

package/dist/parser/parser.d.ts

@@ -0,0 +1,146 @@
+import type { Token, ParseResult as CoreParseResult } from '../types/core';
+import type { ParserOptions } from './types';
+export type ParseResult = CoreParseResult;
+export type { ParseError } from './types';
+export declare class Parser {
+    private tokens;
+    private current;
+    private error;
+    private warnings;
+    private keywordResolver?;
+    private semanticAdapter?;
+    private originalInput?;
+    private registryIntegration?;
+    private static readonly POSTFIX_UNARY_OPERATORS;
+    constructor(tokens: Token[], options?: ParserOptions, originalInput?: string);
+    private resolveKeyword;
+    private addWarning;
+    parse(): ParseResult;
+    private parseExpression;
+    private parseAssignment;
+    private parseLogicalOr;
+    private parseLogicalAnd;
+    private parseEquality;
+    private parseComparison;
+    private parseAddition;
+    private parseMultiplication;
+    private parseUnary;
+    private parseImplicitBinary;
+    private isCommand;
+    private isKeyword;
+    private createCommandFromIdentifier;
+    private isCompoundCommand;
+    private parseCompoundCommand;
+    private parsePutCommand;
+    private parseSetCommand;
+    private parseHaltCommand;
+    private parseMeasureCommand;
+    private parseTriggerCommand;
+    private parseCommandListUntilEnd;
+    private parseRepeatCommand;
+    private parseForCommand;
+    private parseWaitCommand;
+    private parseInstallCommand;
+    private parseTransitionCommand;
+    private parseAddCommand;
+    private parseIfCommand;
+    private parseRemoveCommand;
+    private parseToggleCommand;
+    private parseRegularCommand;
+    private parseCall;
+    private parsePrimary;
+    private parseDollarExpression;
+    private parseHyperscriptSelector;
+    private parseObjectLiteral;
+    private parseCSSObjectLiteral;
+    private parseConstructorCall;
+    private parseTopLevelInitBlock;
+    private parseDefFeature;
+    private parseEventNameWithNamespace;
+    private static readonly PSEUDO_COMMAND_PREPOSITIONS;
+    private callExprToCommandNode;
+    private createPseudoCommandNode;
+    private tryParsePseudoCommand;
+    private parseCommandWithErrorRecovery;
+    private parseEventHandler;
+    private parseBehaviorDefinition;
+    private parseCommandSequence;
+    private getMultiWordPattern;
+    private isTokenKeyword;
+    private parseMultiWordCommand;
+    private parseCommandBlock;
+    private trySemanticParse;
+    private getRemainingInput;
+    private skipToCommandBoundary;
+    private parseCommand;
+    private parseConditional;
+    private parseConditionalBranch;
+    private parseNavigationFunction;
+    private parseTheXofY;
+    private parseContextPropertyAccess;
+    private parseMyPropertyAccess;
+    private finishCall;
+    private createLiteral;
+    private createIdentifier;
+    private createBinaryExpression;
+    private createUnaryExpression;
+    private createCallExpression;
+    private createMemberExpression;
+    private createSelector;
+    private createPossessiveExpression;
+    private createErrorNode;
+    private processEscapeSequences;
+    private createProgramNode;
+    private match;
+    private matchOperator;
+    private check;
+    private checkPredicate;
+    private matchPredicate;
+    private checkSelector;
+    private matchSelector;
+    private checkAnySelector;
+    private checkLiteral;
+    private checkIdentifierLike;
+    private checkIsCommand;
+    private checkCommandTerminator;
+    private checkReference;
+    private checkTimeExpression;
+    private checkEvent;
+    private checkContextVar;
+    private checkComment;
+    private checkIdentifier;
+    private checkKeyword;
+    private checkString;
+    private matchString;
+    private checkNumber;
+    private matchNumber;
+    private checkBoolean;
+    private matchBoolean;
+    private checkTemplateLiteral;
+    private matchTemplateLiteral;
+    private checkQueryReference;
+    private matchQueryReference;
+    private checkIdSelector;
+    private checkClassSelector;
+    private checkCssSelector;
+    private checkBasicOperator;
+    private matchBasicOperator;
+    private matchTimeExpression;
+    private matchIdentifierLike;
+    private matchComparisonOperator;
+    private consumePredicate;
+    private consumeIdentifier;
+    private consumeIdentifierLike;
+    private consumeEvent;
+    private advance;
+    private isAtEnd;
+    private peek;
+    private previous;
+    private consume;
+    private addError;
+    private parseAttributeOrArrayLiteral;
+    private getPosition;
+    getContext(): import('./parser-types').ParserContext;
+}
+export declare function parse(input: string, options?: ParserOptions): ParseResult;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser/regex-parser.d.ts

@@ -0,0 +1,4 @@
+import type { ParserInterface } from './parser-interface';
+export declare const regexParser: ParserInterface;
+export declare function createRegexParser(): ParserInterface;
+//# sourceMappingURL=regex-parser.d.ts.map