littlewing 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,360 @@
+declare namespace exports_ast {
+	export { unaryOp, subtract, number, negate, multiply, modulo, identifier, functionCall, exponentiate, divide, binaryOp, assign, add };
+}
+/**
+* Runtime value type - can be a number, Date, or unknown (for function results)
+*/
+type RuntimeValue = number | Date | unknown;
+/**
+* Execution context providing global functions and variables
+* Functions must accept any arguments and return a number or Date
+* Variables must be numbers or Dates
+*/
+interface ExecutionContext {
+	functions?: Record<string, (...args: any[]) => number | Date>;
+	variables?: Record<string, number | Date>;
+}
+/**
+* Token types for lexer output
+*/
+declare enum TokenType {
+	NUMBER = "NUMBER",
+	STRING = "STRING",
+	IDENTIFIER = "IDENTIFIER",
+	PLUS = "PLUS",
+	MINUS = "MINUS",
+	STAR = "STAR",
+	SLASH = "SLASH",
+	PERCENT = "PERCENT",
+	CARET = "CARET",
+	LPAREN = "LPAREN",
+	RPAREN = "RPAREN",
+	EQUALS = "EQUALS",
+	COMMA = "COMMA",
+	EOF = "EOF"
+}
+/**
+* Token produced by lexer
+*/
+interface Token {
+	type: TokenType;
+	value: string | number;
+	position: number;
+}
+/**
+* AST Node - base type
+*/
+type ASTNode = Program | NumberLiteral | StringLiteral | Identifier | BinaryOp | UnaryOp | FunctionCall | Assignment;
+/**
+* Program node (multiple statements)
+*/
+interface Program {
+	type: "Program";
+	statements: ASTNode[];
+}
+/**
+* Number literal (123, 45.67)
+*/
+interface NumberLiteral {
+	type: "NumberLiteral";
+	value: number;
+}
+/**
+* String literal ('hello', '2025-10-01')
+*/
+interface StringLiteral {
+	type: "StringLiteral";
+	value: string;
+}
+/**
+* Identifier (variable or function name)
+*/
+interface Identifier {
+	type: "Identifier";
+	name: string;
+}
+/**
+* Binary operation (a + b, x * y, etc.)
+*/
+interface BinaryOp {
+	type: "BinaryOp";
+	left: ASTNode;
+	operator: "+" | "-" | "*" | "/" | "%" | "^";
+	right: ASTNode;
+}
+/**
+* Unary operation (-x, -5, etc.)
+*/
+interface UnaryOp {
+	type: "UnaryOp";
+	operator: "-";
+	argument: ASTNode;
+}
+/**
+* Function call (now(), abs(-5), etc.)
+*/
+interface FunctionCall {
+	type: "FunctionCall";
+	name: string;
+	arguments: ASTNode[];
+}
+/**
+* Variable assignment (x = 5)
+*/
+interface Assignment {
+	type: "Assignment";
+	name: string;
+	value: ASTNode;
+}
+/**
+* Builder functions for creating AST nodes manually
+*/
+/**
+* Create a number literal node
+*/
+declare function number(value: number): NumberLiteral;
+/**
+* Create an identifier node
+*/
+declare function identifier(name: string): Identifier;
+/**
+* Create a binary operation node
+*/
+declare function binaryOp(left: ASTNode, operator: "+" | "-" | "*" | "/" | "%" | "^", right: ASTNode): BinaryOp;
+/**
+* Create a unary operation node (unary minus)
+*/
+declare function unaryOp(argument: ASTNode): UnaryOp;
+/**
+* Create a function call node
+*/
+declare function functionCall(name: string, args?: ASTNode[]): FunctionCall;
+/**
+* Create a variable assignment node
+*/
+declare function assign(name: string, value: ASTNode): Assignment;
+/**
+* Convenience functions for common operations
+*/
+/**
+* Create an addition operation
+*/
+declare function add(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a subtraction operation
+*/
+declare function subtract(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a multiplication operation
+*/
+declare function multiply(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a division operation
+*/
+declare function divide(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a modulo operation
+*/
+declare function modulo(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create an exponentiation operation
+*/
+declare function exponentiate(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a negation operation
+*/
+declare function negate(argument: ASTNode): UnaryOp;
+/**
+* Default execution context with common Math functions and date utilities
+* Users can use this as-is or spread it into their own context
+*
+* @example
+* // Use as-is
+* execute('abs(-5)', defaultContext)
+*
+* @example
+* // Spread into custom context
+* execute('now() + minutes(5)', {
+*   ...defaultContext,
+*   variables: { customVar: 42 }
+* })
+*/
+declare const defaultContext: ExecutionContext;
+/**
+* Executor - evaluates an AST with given context
+*/
+declare class Executor {
+	private context;
+	private variables;
+	constructor(context?: ExecutionContext);
+	/**
+	* Execute an AST node and return the result
+	*/
+	execute(node: ASTNode): RuntimeValue;
+	/**
+	* Execute a program (multiple statements)
+	*/
+	private executeProgram;
+	/**
+	* Execute a number literal
+	*/
+	private executeNumberLiteral;
+	/**
+	* Execute a string literal
+	*/
+	private executeStringLiteral;
+	/**
+	* Execute an identifier (variable reference)
+	*/
+	private executeIdentifier;
+	/**
+	* Execute a binary operation
+	*/
+	private executeBinaryOp;
+	/**
+	* Execute a unary operation
+	*/
+	private executeUnaryOp;
+	/**
+	* Execute a function call
+	*/
+	private executeFunctionCall;
+	/**
+	* Execute a variable assignment
+	*/
+	private executeAssignment;
+	/**
+	* Add two values (handles Date + number, number + Date, Date + Date, number + number)
+	*/
+	private add;
+	/**
+	* Subtract two values (handles Date - number, number - Date, Date - Date, number - number)
+	*/
+	private subtract;
+	/**
+	* Multiply two values (number * number only)
+	*/
+	private multiply;
+	/**
+	* Divide two values (number / number only)
+	*/
+	private divide;
+	/**
+	* Modulo operation (number % number only)
+	*/
+	private modulo;
+	/**
+	* Exponentiation operation (number ^ number only)
+	*/
+	private exponentiate;
+	/**
+	* Get type name for error messages
+	*/
+	private typeOf;
+}
+/**
+* Execute source code with given context
+*/
+declare function execute(source: string, context?: ExecutionContext): RuntimeValue;
+/**
+* Lexer - converts source code into tokens
+*/
+declare class Lexer {
+	private source;
+	private position;
+	constructor(source: string);
+	/**
+	* Tokenize the entire source and return all tokens
+	*/
+	tokenize(): Token[];
+	/**
+	* Get the next token from the source
+	*/
+	nextToken(): Token;
+	/**
+	* Skip whitespace and comments
+	*/
+	private skipWhitespaceAndComments;
+	/**
+	* Read a number token
+	*/
+	private readNumber;
+	/**
+	* Read an identifier token
+	*/
+	private readIdentifier;
+	/**
+	* Read a string token
+	*/
+	private readString;
+	/**
+	* Get character at position
+	*/
+	private getCharAt;
+	/**
+	* Peek at the next character without consuming it
+	*/
+	private peek;
+	/**
+	* Check if character is a digit
+	*/
+	private isDigit;
+	/**
+	* Check if character is a letter
+	*/
+	private isLetter;
+	/**
+	* Check if character is whitespace
+	*/
+	private isWhitespace;
+}
+/**
+* Parser using Pratt parsing (top-down operator precedence)
+*/
+declare class Parser {
+	private tokens;
+	private current;
+	constructor(tokens: Token[]);
+	/**
+	* Parse tokens into an AST
+	* Supports multiple statements separated by semicolons
+	*/
+	parse(): ASTNode;
+	/**
+	* Parse an expression with Pratt parsing (precedence climbing)
+	*/
+	private parseExpression;
+	/**
+	* Parse prefix (unary) expressions
+	*/
+	private parsePrefix;
+	/**
+	* Parse function call arguments
+	*/
+	private parseFunctionArguments;
+	/**
+	* Get operator precedence
+	*/
+	private getPrecedence;
+	/**
+	* Get unary operator precedence
+	*/
+	private getUnaryPrecedence;
+	/**
+	* Check if token is a binary operator
+	*/
+	private isBinaryOperator;
+	/**
+	* Get current token
+	*/
+	private peek;
+	/**
+	* Advance to next token
+	*/
+	private advance;
+}
+/**
+* Parse source code string into AST
+*/
+declare function parseSource(source: string): ASTNode;
+export { parseSource, execute, defaultContext, exports_ast as ast, TokenType, Token, RuntimeValue, Parser, Lexer, Executor, ExecutionContext, ASTNode };