littlewing 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -107,6 +107,17 @@ interface Assignment {
 	value: ASTNode;
 }
 /**
+* Type guard functions for discriminated union narrowing
+*/
+declare function isNumberLiteral(node: ASTNode): node is NumberLiteral;
+declare function isStringLiteral(node: ASTNode): node is StringLiteral;
+declare function isIdentifier(node: ASTNode): node is Identifier;
+declare function isBinaryOp(node: ASTNode): node is BinaryOp;
+declare function isUnaryOp(node: ASTNode): node is UnaryOp;
+declare function isFunctionCall(node: ASTNode): node is FunctionCall;
+declare function isAssignment(node: ASTNode): node is Assignment;
+declare function isProgram(node: ASTNode): node is Program;
+/**
 * Builder functions for creating AST nodes manually
 */
 /**
@@ -165,6 +176,67 @@ declare function exponentiate(left: ASTNode, right: ASTNode): BinaryOp;
 */
 declare function negate(argument: ASTNode): UnaryOp;
 /**
+* CodeGenerator - converts AST nodes back to source code
+*/
+declare class CodeGenerator {
+	/**
+	* Generate source code from an AST node
+	*/
+	generate(node: ASTNode): string;
+	/**
+	* Generate code for a program (multiple statements)
+	*/
+	private generateProgram;
+	/**
+	* Generate code for a number literal
+	*/
+	private generateNumberLiteral;
+	/**
+	* Generate code for a string literal
+	*/
+	private generateStringLiteral;
+	/**
+	* Generate code for an identifier
+	*/
+	private generateIdentifier;
+	/**
+	* Generate code for a binary operation
+	*/
+	private generateBinaryOp;
+	/**
+	* Generate code for a unary operation
+	*/
+	private generateUnaryOp;
+	/**
+	* Generate code for a function call
+	*/
+	private generateFunctionCall;
+	/**
+	* Generate code for a variable assignment
+	*/
+	private generateAssignment;
+	/**
+	* Check if left operand needs parentheses based on operator precedence
+	* - For left-associative operators: parens only if strictly lower precedence
+	* - For right-associative operators (^): parens if lower or equal precedence
+	*/
+	private needsParensLeft;
+	/**
+	* Check if right operand needs parentheses based on operator precedence and associativity
+	* - For right-associative operators (^): parens if strictly lower precedence
+	* - For left-associative operators: parens if lower or equal precedence
+	*/
+	private needsParensRight;
+	/**
+	* Get precedence of an operator (higher number = higher precedence)
+	*/
+	private getPrecedence;
+}
+/**
+* Generate source code from an AST node
+*/
+declare function generate(node: ASTNode): string;
+/**
 * Default execution context with common Math functions and date utilities
 * Users can use this as-is or spread it into their own context
 *
@@ -357,4 +429,4 @@ declare class Parser {
 * 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 };
+export { parseSource, isUnaryOp, isStringLiteral, isProgram, isNumberLiteral, isIdentifier, isFunctionCall, isBinaryOp, isAssignment, generate, execute, defaultContext, exports_ast as ast, TokenType, Token, RuntimeValue, Parser, Lexer, Executor, ExecutionContext, CodeGenerator, ASTNode };

package/dist/index.js

@@ -89,6 +89,145 @@ function exponentiate(left, right) {
 function negate(argument) {
   return unaryOp(argument);
 }
+// src/types.ts
+var TokenType;
+((TokenType2) => {
+  TokenType2["NUMBER"] = "NUMBER";
+  TokenType2["STRING"] = "STRING";
+  TokenType2["IDENTIFIER"] = "IDENTIFIER";
+  TokenType2["PLUS"] = "PLUS";
+  TokenType2["MINUS"] = "MINUS";
+  TokenType2["STAR"] = "STAR";
+  TokenType2["SLASH"] = "SLASH";
+  TokenType2["PERCENT"] = "PERCENT";
+  TokenType2["CARET"] = "CARET";
+  TokenType2["LPAREN"] = "LPAREN";
+  TokenType2["RPAREN"] = "RPAREN";
+  TokenType2["EQUALS"] = "EQUALS";
+  TokenType2["COMMA"] = "COMMA";
+  TokenType2["EOF"] = "EOF";
+})(TokenType ||= {});
+function isNumberLiteral(node) {
+  return node.type === "NumberLiteral";
+}
+function isStringLiteral(node) {
+  return node.type === "StringLiteral";
+}
+function isIdentifier(node) {
+  return node.type === "Identifier";
+}
+function isBinaryOp(node) {
+  return node.type === "BinaryOp";
+}
+function isUnaryOp(node) {
+  return node.type === "UnaryOp";
+}
+function isFunctionCall(node) {
+  return node.type === "FunctionCall";
+}
+function isAssignment(node) {
+  return node.type === "Assignment";
+}
+function isProgram(node) {
+  return node.type === "Program";
+}
+
+// src/codegen.ts
+class CodeGenerator {
+  generate(node) {
+    if (isProgram(node))
+      return this.generateProgram(node);
+    if (isNumberLiteral(node))
+      return this.generateNumberLiteral(node);
+    if (isStringLiteral(node))
+      return this.generateStringLiteral(node);
+    if (isIdentifier(node))
+      return this.generateIdentifier(node);
+    if (isBinaryOp(node))
+      return this.generateBinaryOp(node);
+    if (isUnaryOp(node))
+      return this.generateUnaryOp(node);
+    if (isFunctionCall(node))
+      return this.generateFunctionCall(node);
+    if (isAssignment(node))
+      return this.generateAssignment(node);
+    throw new Error(`Unknown node type`);
+  }
+  generateProgram(node) {
+    return node.statements.map((stmt) => this.generate(stmt)).join("; ");
+  }
+  generateNumberLiteral(node) {
+    return String(node.value);
+  }
+  generateStringLiteral(node) {
+    return `'${node.value}'`;
+  }
+  generateIdentifier(node) {
+    return node.name;
+  }
+  generateBinaryOp(node) {
+    const left = this.generate(node.left);
+    const right = this.generate(node.right);
+    const leftNeedsParens = this.needsParensLeft(node.left, node.operator);
+    const leftCode = leftNeedsParens ? `(${left})` : left;
+    const rightNeedsParens = this.needsParensRight(node.right, node.operator);
+    const rightCode = rightNeedsParens ? `(${right})` : right;
+    return `${leftCode} ${node.operator} ${rightCode}`;
+  }
+  generateUnaryOp(node) {
+    const arg = this.generate(node.argument);
+    const needsParens = isBinaryOp(node.argument) || isAssignment(node.argument);
+    const argCode = needsParens ? `(${arg})` : arg;
+    return `-${argCode}`;
+  }
+  generateFunctionCall(node) {
+    const args = node.arguments.map((arg) => this.generate(arg)).join(", ");
+    return `${node.name}(${args})`;
+  }
+  generateAssignment(node) {
+    const value = this.generate(node.value);
+    return `${node.name} = ${value}`;
+  }
+  needsParensLeft(node, operator) {
+    if (!isBinaryOp(node))
+      return false;
+    const nodePrecedence = this.getPrecedence(node.operator);
+    const operatorPrecedence = this.getPrecedence(operator);
+    if (operator === "^") {
+      return nodePrecedence <= operatorPrecedence;
+    }
+    return nodePrecedence < operatorPrecedence;
+  }
+  needsParensRight(node, operator) {
+    if (!isBinaryOp(node))
+      return false;
+    const nodePrecedence = this.getPrecedence(node.operator);
+    const operatorPrecedence = this.getPrecedence(operator);
+    if (operator === "^") {
+      return nodePrecedence < operatorPrecedence;
+    }
+    return nodePrecedence <= operatorPrecedence;
+  }
+  getPrecedence(operator) {
+    switch (operator) {
+      case "^":
+        return 4;
+      case "*":
+      case "/":
+      case "%":
+        return 3;
+      case "+":
+      case "-":
+        return 2;
+      default:
+        return 0;
+    }
+  }
+}
+function generate(node) {
+  const generator = new CodeGenerator;
+  return generator.generate(node);
+}
 // src/defaults.ts
 var defaultContext = {
   functions: {
@@ -114,25 +253,6 @@ var defaultContext = {
     days: (d) => d * 24 * 60 * 60 * 1000
   }
 };
-// src/types.ts
-var TokenType;
-((TokenType2) => {
-  TokenType2["NUMBER"] = "NUMBER";
-  TokenType2["STRING"] = "STRING";
-  TokenType2["IDENTIFIER"] = "IDENTIFIER";
-  TokenType2["PLUS"] = "PLUS";
-  TokenType2["MINUS"] = "MINUS";
-  TokenType2["STAR"] = "STAR";
-  TokenType2["SLASH"] = "SLASH";
-  TokenType2["PERCENT"] = "PERCENT";
-  TokenType2["CARET"] = "CARET";
-  TokenType2["LPAREN"] = "LPAREN";
-  TokenType2["RPAREN"] = "RPAREN";
-  TokenType2["EQUALS"] = "EQUALS";
-  TokenType2["COMMA"] = "COMMA";
-  TokenType2["EOF"] = "EOF";
-})(TokenType ||= {});
-
 // src/lexer.ts
 class Lexer {
   source;
@@ -496,26 +616,23 @@ class Executor {
     this.variables = new Map(Object.entries(context.variables || {}));
   }
   execute(node) {
-    switch (node.type) {
-      case "Program":
-        return this.executeProgram(node);
-      case "NumberLiteral":
-        return this.executeNumberLiteral(node);
-      case "StringLiteral":
-        return this.executeStringLiteral(node);
-      case "Identifier":
-        return this.executeIdentifier(node);
-      case "BinaryOp":
-        return this.executeBinaryOp(node);
-      case "UnaryOp":
-        return this.executeUnaryOp(node);
-      case "FunctionCall":
-        return this.executeFunctionCall(node);
-      case "Assignment":
-        return this.executeAssignment(node);
-      default:
-        throw new Error(`Unknown node type`);
-    }
+    if (isProgram(node))
+      return this.executeProgram(node);
+    if (isNumberLiteral(node))
+      return this.executeNumberLiteral(node);
+    if (isStringLiteral(node))
+      return this.executeStringLiteral(node);
+    if (isIdentifier(node))
+      return this.executeIdentifier(node);
+    if (isBinaryOp(node))
+      return this.executeBinaryOp(node);
+    if (isUnaryOp(node))
+      return this.executeUnaryOp(node);
+    if (isFunctionCall(node))
+      return this.executeFunctionCall(node);
+    if (isAssignment(node))
+      return this.executeAssignment(node);
+    throw new Error(`Unknown node type`);
   }
   executeProgram(node) {
     let result;
@@ -663,11 +780,21 @@ function execute(source, context) {
 }
 export {
   parseSource,
+  isUnaryOp,
+  isStringLiteral,
+  isProgram,
+  isNumberLiteral,
+  isIdentifier,
+  isFunctionCall,
+  isBinaryOp,
+  isAssignment,
+  generate,
   execute,
   defaultContext,
   exports_ast as ast,
   TokenType,
   Parser,
   Lexer,
-  Executor
+  Executor,
+  CodeGenerator
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "littlewing",
-	"version": "0.1.0",
+	"version": "0.3.0",
 	"description": "A minimal, high-performance arithmetic expression language with lexer, parser, and executor. Optimized for browsers with zero dependencies and type-safe execution.",
 	"keywords": [
 		"arithmetic",