@hyperfixi/core 3.3.0 → 4.0.1

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

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

@@ -1,12 +0,0 @@
-import type { ASTNode } from '../types/base-types';
-import type { CommandNode } from '../ast/nodes';
-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

@@ -1,164 +0,0 @@
-import type { Token, ASTNode, CommandNode } from '../types/core';
-export interface Position {
-    start: number;
-    end: number;
-    line: number;
-    column: number;
-}
-export interface IdentifierNode extends ASTNode {
-    type: 'identifier';
-    name: string;
-    scope?: 'local' | 'element' | '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[];
-    closestTo?: 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 TokenStream {
-    readonly tokens: Token[];
-    current: number;
-    advance(): Token;
-    peek(): Token;
-    previous(): Token;
-    consume(expected: string, message: string): Token;
-    check(value: string): boolean;
-    match(...types: string[]): boolean;
-    matchOperator(operator: string): boolean;
-    isAtEnd(): boolean;
-    atEndOfInput(): boolean;
-    peekAt(offset: number): Token | null;
-}
-export interface TokenPredicates {
-    checkIdentifierLike(): boolean;
-    checkSelector(): boolean;
-    checkAnySelector(): boolean;
-    checkLiteral(): boolean;
-    checkReference(): boolean;
-    checkTimeExpression(): boolean;
-    checkEvent(): boolean;
-    checkIsCommand(): boolean;
-    checkContextVar(): boolean;
-}
-export interface ASTFactory {
-    createIdentifier(name: string): IdentifierNode;
-}
-export interface ExpressionParser {
-    parseExpression(): ASTNode;
-    parsePrimary(): ASTNode;
-    parseLogicalAnd(): ASTNode;
-    parseCSSObjectLiteral(): ASTNode;
-}
-export interface CommandParser {
-    parseCommand(): CommandNode;
-    parseCommandSequence(): ASTNode;
-    parseCommandListUntilEnd(construct?: string): ASTNode[];
-    parseCommandListUntilEndOrElse(): {
-        commands: ASTNode[];
-        hasElse: boolean;
-    };
-    parseRepeatBody(): {
-        commands: ASTNode[];
-        terminator: string;
-    };
-}
-export interface PositionCheckpoint {
-    savePosition(): number;
-    restorePosition(pos: number): void;
-    getPosition(): Position;
-}
-export interface ParserErrorHandler {
-    addError(message: string): void;
-    addWarning(warning: string): void;
-}
-export interface ParserUtilities {
-    isCommand(name: string): boolean;
-    isKeyword(name: string): boolean;
-    resolveKeyword(value: string): string;
-    getInputSlice(start: number, end?: number): string;
-}
-export interface ParserContext extends TokenStream, TokenPredicates, ASTFactory, ExpressionParser, CommandParser, PositionCheckpoint, ParserErrorHandler, ParserUtilities {
-}
-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

@@ -1,165 +0,0 @@
-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 errors;
-    private warnings;
-    private keywordResolver?;
-    private originalInput?;
-    private registryIntegration?;
-    private prattCache;
-    private static readonly POSTFIX_UNARY_OPERATORS;
-    constructor(tokens: Token[], options?: ParserOptions, originalInput?: string);
-    private resolveKeyword;
-    private addWarning;
-    parse(): ParseResult;
-    private parseInternal;
-    private parseExpression;
-    private static readonly PRATT_TABLE;
-    private parseExpressionPratt;
-    private parseBeepExpression;
-    private static readonly BEEP_OPERAND_BP;
-    private isStyleRefStar;
-    private isSpacedStyleRef;
-    private tryParseStringPostfix;
-    private isNumericPostfixRoot;
-    private canStartOperand;
-    private makePrattContext;
-    private parseLogicalAnd;
-    private parseImplicitBinary;
-    private isCommand;
-    private isKeyword;
-    private createCommandFromIdentifier;
-    private isCompoundCommand;
-    private parseCompoundCommand;
-    private parsePutCommand;
-    private parseSetCommand;
-    private parseHaltCommand;
-    private parseMeasureCommand;
-    private parseTriggerCommand;
-    private parseCommandListUntilTerminator;
-    private parseCommandListUntilEnd;
-    private parseCommandListUntilEndOrElse;
-    private parseRepeatBody;
-    private parseRepeatCommand;
-    private parseForCommand;
-    private parseWaitCommand;
-    private parseInstallCommand;
-    private parseTransitionCommand;
-    private parseAddCommand;
-    private parseIfCommand;
-    private parseRemoveCommand;
-    private parseToggleCommand;
-    private parseCall;
-    private parsePrimary;
-    private parseBlockLiteral;
-    private parseDollarExpression;
-    private parseHyperscriptSelector;
-    private parseObjectLiteral;
-    private parseCSSObjectLiteral;
-    private parseConstructorCall;
-    private parseTopLevelInitBlock;
-    private parseDefFeature;
-    private parseErrorAndFinallyBlocks;
-    private parseEventNameWithNamespace;
-    private static readonly PSEUDO_COMMAND_PREPOSITIONS;
-    private static readonly POSITIONAL_SOURCE_HEADS;
-    private callExprToCommandNode;
-    private createPseudoCommandNode;
-    private isArgumentListOnly;
-    private tryParsePseudoCommand;
-    private parseCommandWithErrorRecovery;
-    private parseTemporalKeywordModifiers;
-    private parseEventHandler;
-    private parseBehaviorDefinition;
-    private parseCommandSequence;
-    private isTokenKeyword;
-    private parseCommandBlock;
-    private parseCommand;
-    private parseCommandCore;
-    private parseConditional;
-    private parseConditionalBranch;
-    private parseNavigationFunction;
-    private parseRelativePositionalModifiers;
-    private parseRelativePositionalOperand;
-    private parseTheXofY;
-    private parseContextPropertyAccess;
-    private parseMyPropertyAccess;
-    private finishCall;
-    private createLiteral;
-    private createIdentifier;
-    private createBinaryExpression;
-    private createUnaryExpression;
-    private spanFromLeftmost;
-    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 checkEventNamedCall;
-    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 atEndOfInput;
-    private checkFeatureStart;
-    private peek;
-    private peekAt;
-    private previous;
-    private consume;
-    private addError;
-    private recordDroppedRange;
-    private recordDropped;
-    private recordDroppedExpression;
-    private synchronizeToCommandBoundary;
-    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/pratt-parser.d.ts

@@ -1,41 +0,0 @@
-import type { Token } from '../types/core';
-import type { ASTNode } from '../types/base-types';
-export type BindingPower = [left: number, right: number];
-export type PrefixHandler = (token: Token, ctx: PrattContext) => ASTNode;
-export type InfixHandler = (left: ASTNode, token: Token, ctx: PrattContext) => ASTNode;
-export interface BindingPowerEntry {
-    prefix?: {
-        bp: number;
-        handler: PrefixHandler;
-    };
-    infix?: {
-        bp: BindingPower;
-        handler: InfixHandler;
-    };
-}
-export type BindingPowerFragment = Map<string, BindingPowerEntry>;
-export interface PrattContext {
-    peek(): Token | undefined;
-    advance(): Token;
-    parseExpr(minBp: number): ASTNode;
-    isStopToken(): boolean;
-    atEnd(): boolean;
-}
-export declare const STOP_TOKENS: Set<string>;
-export declare const STOP_DELIMITERS: Set<string>;
-export declare function mergeFragments(...fragments: BindingPowerFragment[]): BindingPowerFragment;
-export declare function createPrattParser(table: BindingPowerFragment, parsePrimary: PrefixHandler): (tokens: Token[], pos: {
-    value: number;
-}, minBp?: number) => ASTNode;
-export declare function binaryHandler(left: ASTNode, token: Token, ctx: PrattContext): ASTNode;
-export declare function unaryHandler(token: Token, ctx: PrattContext): ASTNode;
-export declare function leftAssoc(bp: number, handler?: InfixHandler): Pick<BindingPowerEntry, 'infix'>;
-export declare function rightAssoc(bp: number, handler?: InfixHandler): Pick<BindingPowerEntry, 'infix'>;
-export declare function prefix(bp: number, handler?: PrefixHandler): Pick<BindingPowerEntry, 'prefix'>;
-export declare const CORE_FRAGMENT: BindingPowerFragment;
-export declare function parseOfOperand(ctx: PrattContext, minBp?: number): ASTNode;
-export declare const THE_OF_TARGET_BP: number;
-export declare const PARSER_COMPARISON_FRAGMENT: BindingPowerFragment;
-export declare const ASSIGNMENT_FRAGMENT: BindingPowerFragment;
-export declare const PARSER_TABLE: BindingPowerFragment;
-//# sourceMappingURL=pratt-parser.d.ts.map