littlewing 0.3.1 → 0.4.0

package/README.md

@@ -5,11 +5,11 @@ A minimal, high-performance arithmetic expression language with a complete lexer
 ## Features
 
 - 🚀 **Minimal & Fast** - O(n) algorithms throughout (lexer, parser, executor)
-- 📦 **Tiny Bundle** - 3.61 KB gzipped, zero dependencies
+- 📦 **Tiny Bundle** - 4.19 KB gzipped, zero dependencies
 - 🌐 **Browser Ready** - 100% ESM, no Node.js APIs
 - 🔒 **Type-Safe** - Strict TypeScript with full type coverage
-- ✅ **Thoroughly Tested** - 106 tests, 97.66% coverage
-- 📐 **Math Expressions** - Numbers, dates, operators, functions, variables
+- ✅ **Thoroughly Tested** - 128 tests, 98.61% line coverage
+- 📐 **Pure Arithmetic** - Numbers-only, clean semantics
 - 🎯 **Clean API** - Intuitive dual API (class-based + functional)
 - 📝 **Well Documented** - Complete JSDoc and examples
 
@@ -58,21 +58,40 @@ execute("pi * 2", context); // → 6.28318
 execute("maxValue - 25", context); // → 75
 ```
 
-### Date Support
+### Timestamp Arithmetic
+
+Littlewing uses a numbers-only type system. Timestamps (milliseconds since Unix epoch) are just numbers, enabling clean date arithmetic:
 
 ```typescript
 import { execute, defaultContext } from "littlewing";
 
-// Dates as first-class citizens
-execute("now()", defaultContext); // → Date object (current time)
-execute("date('2025-10-01')", defaultContext); // → Date object
-execute("now() + minutes(30)", defaultContext); // → Date 30 minutes from now
+// Get current timestamp
+execute("now()", defaultContext); // → 1704067200000 (number)
+
+// Create timestamp from date components
+execute("timestamp(2025, 10, 1)", defaultContext); // → timestamp for Oct 1, 2025
+
+// Add time durations (all return milliseconds)
+execute("now() + minutes(30)", defaultContext); // → timestamp 30 minutes from now
+execute("now() + hours(2) + minutes(15)", defaultContext); // → 2h 15m from now
 
 // Time conversion helpers
 execute("seconds(30)", defaultContext); // → 30000 (milliseconds)
 execute("minutes(5)", defaultContext); // → 300000 (milliseconds)
 execute("hours(2)", defaultContext); // → 7200000 (milliseconds)
-execute("days(1)", defaultContext); // → 86400000 (milliseconds)
+execute("days(7)", defaultContext); // → 604800000 (milliseconds)
+execute("weeks(2)", defaultContext); // → 1209600000 (milliseconds)
+
+// Extract components from timestamps
+const timestamp = new Date("2024-06-15T14:30:00").getTime();
+execute("year(t)", { ...defaultContext, variables: { t: timestamp } }); // → 2024
+execute("month(t)", { ...defaultContext, variables: { t: timestamp } }); // → 6 (June)
+execute("day(t)", { ...defaultContext, variables: { t: timestamp } }); // → 15
+execute("hour(t)", { ...defaultContext, variables: { t: timestamp } }); // → 14
+
+// Convert result back to Date when needed
+const result = execute("now() + days(7)", defaultContext);
+const futureDate = new Date(result); // JavaScript Date object
 ```
 
 ### Manual AST Construction
@@ -91,9 +110,10 @@ executor.execute(expr); // → 14
 ### Literals
 
 ```typescript
-42; // number
+42; // integer
 3.14; // floating point
-("hello"); // string (function arguments only)
+1.5e6; // scientific notation (1500000)
+2e-3; // negative exponent (0.002)
 ```
 
 ### Variables
@@ -140,7 +160,7 @@ Functions accept any number of arguments:
 ```typescript
 abs(-5); // → 5
 max(1, 5, 3); // → 5
-date("2025-01-01"); // → Date object
+timestamp(2025, 1, 1); // → timestamp
 ```
 
 ### Comments
@@ -165,9 +185,9 @@ execute("42"); // → 42
 
 ### Main Functions
 
-#### `execute(source: string, context?: ExecutionContext): RuntimeValue`
+#### `execute(source: string, context?: ExecutionContext): number`
 
-Execute source code with an optional execution context.
+Execute source code with an optional execution context. Always returns a number.
 
 ```typescript
 execute("2 + 2");
@@ -201,6 +221,23 @@ const regenerated = generate(tree); // → "2 + 3 * 4"
 parseSource(regenerated); // Same AST structure
 ```
 
+#### `optimize(node: ASTNode): ASTNode`
+
+Optimize an AST by performing constant folding. Evaluates expressions with only literals at compile-time.
+
+```typescript
+import { optimize, parseSource } from "littlewing";
+
+// Parse first, then optimize
+const ast = parseSource("2 + 3 * 4");
+const optimized = optimize(ast);
+// Transforms BinaryOp tree to NumberLiteral(14)
+
+// Useful for storing compact ASTs
+const compactAst = optimize(parseSource("1e6 + 2e6"));
+// → NumberLiteral(3000000)
+```
+
 ### Classes
 
 #### `Lexer`
@@ -262,6 +299,7 @@ ast.subtract(left, right);
 ast.multiply(left, right);
 ast.divide(left, right);
 ast.modulo(left, right);
+ast.exponentiate(left, right);
 ast.negate(argument);
 ast.assign("x", value);
 ast.functionCall("abs", [ast.number(-5)]);
@@ -278,11 +316,79 @@ import { defaultContext } from "littlewing";
 (abs, ceil, floor, round, sqrt, min, max);
 (sin, cos, tan, log, log10, exp);
 
-// Date functions
-(now, date);
+// Timestamp functions
+now(); // Current timestamp
+timestamp(year, month, day); // Create timestamp from date components
 
 // Time conversion (returns milliseconds)
-(milliseconds, seconds, minutes, hours, days);
+(milliseconds(n), seconds(n), minutes(n), hours(n), days(n), weeks(n));
+
+// Timestamp component extractors
+year(timestamp); // Extract year (e.g., 2024)
+month(timestamp); // Extract month (1-12, 1 = January)
+day(timestamp); // Extract day of month (1-31)
+hour(timestamp); // Extract hour (0-23)
+minute(timestamp); // Extract minute (0-59)
+second(timestamp); // Extract second (0-59)
+weekday(timestamp); // Extract day of week (0-6, 0 = Sunday)
+```
+
+## Advanced Features
+
+### Constant Folding Optimization
+
+The `optimize()` function performs constant folding, pre-calculating expressions with only literal values. This results in smaller ASTs and faster execution.
+
+**Without optimization:**
+
+```typescript
+import { parseSource } from "littlewing";
+
+const ast = parseSource("2 + 3 * 4");
+// AST: BinaryOp(+, NumberLiteral(2), BinaryOp(*, NumberLiteral(3), NumberLiteral(4)))
+// Size: 3 nodes
+```
+
+**With optimization:**
+
+```typescript
+import { optimize, parseSource } from "littlewing";
+
+const ast = optimize(parseSource("2 + 3 * 4"));
+// AST: NumberLiteral(14)
+// Size: 1 node - 67% smaller!
+```
+
+**When to use:**
+
+- **Storage:** Compact ASTs for databases or serialization
+- **Performance:** Faster execution (no runtime calculation needed)
+- **Network:** Smaller payload when transmitting ASTs
+- **Caching:** Pre-calculate expensive expressions once
+
+**What gets optimized:**
+
+- ✅ Binary operations with literals: `2 + 3` → `5`
+- ✅ Unary operations: `-5` → `-5`
+- ✅ Nested expressions: `2 + 3 * 4` → `14`
+- ✅ Scientific notation: `1e6 + 2e6` → `3000000`
+- ✅ Partial optimization: `x = 2 + 3` → `x = 5`
+- ❌ Variables: `x + 3` stays as-is (x is not a literal)
+- ❌ Functions: `sqrt(16)` stays as-is (might have side effects)
+
+### Scientific Notation
+
+Littlewing supports scientific notation for large or small numbers:
+
+```typescript
+execute("1.5e6"); // → 1500000
+execute("2e10"); // → 20000000000
+execute("3e-2"); // → 0.03
+execute("4E+5"); // → 400000
+
+// Works with optimization too
+const ast = parseSource("1e6 * 2", { optimize: true });
+// → NumberLiteral(2000000)
 ```
 
 ## Examples
@@ -293,7 +399,7 @@ import { defaultContext } from "littlewing";
 import { execute, defaultContext } from "littlewing";
 
 function calculate(expression: string): number {
-	return execute(expression, defaultContext) as number;
+	return execute(expression, defaultContext);
 }
 
 calculate("2 + 2 * 3"); // → 8
@@ -316,18 +422,28 @@ const context = {
 };
 
 const compound = execute("principal * (1 + rate) ^ years", context);
+// → 1102.5
 ```
 
-### Date Arithmetic
+### Timestamp Arithmetic
 
 ```typescript
 import { execute, defaultContext } from "littlewing";
 
-// 5 days from now
-const deadline = execute("now() + days(5)", defaultContext);
+// Calculate deadline
+const deadline = execute("now() + days(7)", defaultContext);
+const deadlineDate = new Date(deadline); // Convert to Date
 
-// Add 2 hours and 30 minutes
-const futureTime = execute("now() + hours(2) + minutes(30)", defaultContext);
+// Complex time calculations
+const result = execute("now() + weeks(2) + days(3) + hours(4)", defaultContext);
+
+// Time until event
+const eventTime = new Date("2025-12-31").getTime();
+const timeUntil = execute("event - now()", {
+	...defaultContext,
+	variables: { event: eventTime },
+});
+const daysUntil = timeUntil / (1000 * 60 * 60 * 24);
 ```
 
 ### Custom Functions
@@ -339,7 +455,7 @@ const context = {
 	functions: {
 		fahrenheit: (celsius) => (celsius * 9) / 5 + 32,
 		kilometers: (miles) => miles * 1.60934,
-		factorial: (n) => (n <= 1 ? 1 : n * factorial(n - 1)),
+		factorial: (n) => (n <= 1 ? 1 : n * context.functions.factorial(n - 1)),
 	},
 	variables: {
 		roomTemp: 20,
@@ -350,33 +466,54 @@ execute("fahrenheit(roomTemp)", context); // → 68
 execute("kilometers(5)", context); // → 8.0467
 ```
 
+### Scheduling System
+
+```typescript
+import { execute, defaultContext } from "littlewing";
+
+// Parse user's relative time expressions
+const tasks = [
+	{ name: "Review PR", due: "now() + hours(2)" },
+	{ name: "Deploy", due: "now() + days(1)" },
+	{ name: "Meeting", due: "timestamp(2025, 10, 15, 14, 30, 0)" },
+];
+
+const dueTimes = tasks.map((task) => ({
+	name: task.name,
+	dueTimestamp: execute(task.due, defaultContext),
+	dueDate: new Date(execute(task.due, defaultContext)),
+}));
+```
+
 ## Performance
 
 ### Algorithms
 
 - **Lexer**: O(n) single-pass tokenization
 - **Parser**: Optimal Pratt parsing with O(n) time complexity
-- **Executor**: O(n) tree-walk evaluation
+- **Executor**: O(n) tree-walk evaluation with no type checking overhead
 
 ### Bundle Size
 
-- Raw: 21.06 KB
-- Gzipped: **4.26 KB**
+- **4.19 KB gzipped** (19.60 KB raw)
 - Zero dependencies
+- Includes optimizer for constant folding
+- Fully tree-shakeable
 
 ### Test Coverage
 
-- 106 comprehensive tests
-- 95.99% code coverage
+- **128 tests** with **98.61% line coverage**
+- **98.52% function coverage**
 - All edge cases handled
+- Type-safe execution guaranteed
 
 ## Type Safety
 
 - Strict TypeScript mode
 - Zero implicit `any` types
 - Complete type annotations
-- Runtime type validation
-- Type guards on all operations
+- Single `RuntimeValue = number` type
+- No runtime type checking overhead
 
 ## Error Handling
 
@@ -384,9 +521,9 @@ Clear, actionable error messages for:
 
 - Undefined variables: `"Undefined variable: x"`
 - Undefined functions: `"Undefined function: abs"`
-- Type mismatches: `"Cannot add string and number"`
 - Division by zero: `"Division by zero"`
-- Invalid assignments: `"Cannot assign string to variable"`
+- Modulo by zero: `"Modulo by zero"`
+- Syntax errors with position information
 
 ## Browser Support
 
@@ -399,6 +536,18 @@ Clear, actionable error messages for:
 
 Works with Node.js 18+ via ESM imports.
 
+## Philosophy
+
+Littlewing embraces a **numbers-only** type system for maximum simplicity and performance:
+
+- **Pure arithmetic**: Every operation works on numbers
+- **No type checking overhead**: Operators don't need runtime type discrimination
+- **Timestamps as numbers**: Date arithmetic uses millisecond timestamps
+- **Clean semantics**: No ambiguous operations like `Date + Date`
+- **Flexibility**: Convert to/from JavaScript Dates at the boundaries
+
+This design keeps the language minimal while remaining powerful enough for real-world use cases.
+
 ## License
 
 MIT

package/dist/index.d.ts

@@ -2,24 +2,27 @@ 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)
+* Runtime value type - only numbers
 */
-type RuntimeValue = number | Date | unknown;
+type RuntimeValue = number;
+/**
+* Binary operator types
+*/
+type Operator = "+" | "-" | "*" | "/" | "%" | "^";
 /**
 * Execution context providing global functions and variables
-* Functions must accept any arguments and return a number or Date
-* Variables must be numbers or Dates
+* Functions must accept any arguments and return a number
+* Variables must be numbers
 */
 interface ExecutionContext {
-	functions?: Record<string, (...args: any[]) => number | Date>;
-	variables?: Record<string, number | Date>;
+	functions?: Record<string, (...args: any[]) => number>;
+	variables?: Record<string, number>;
 }
 /**
 * Token types for lexer output
 */
 declare enum TokenType {
 	NUMBER = "NUMBER",
-	STRING = "STRING",
 	IDENTIFIER = "IDENTIFIER",
 	PLUS = "PLUS",
 	MINUS = "MINUS",
@@ -44,7 +47,7 @@ interface Token {
 /**
 * AST Node - base type
 */
-type ASTNode = Program | NumberLiteral | StringLiteral | Identifier | BinaryOp | UnaryOp | FunctionCall | Assignment;
+type ASTNode = Program | NumberLiteral | Identifier | BinaryOp | UnaryOp | FunctionCall | Assignment;
 /**
 * Program node (multiple statements)
 */
@@ -60,13 +63,6 @@ interface NumberLiteral {
 	value: number;
 }
 /**
-* String literal ('hello', '2025-10-01')
-*/
-interface StringLiteral {
-	type: "StringLiteral";
-	value: string;
-}
-/**
 * Identifier (variable or function name)
 */
 interface Identifier {
@@ -79,7 +75,7 @@ interface Identifier {
 interface BinaryOp {
 	type: "BinaryOp";
 	left: ASTNode;
-	operator: "+" | "-" | "*" | "/" | "%" | "^";
+	operator: Operator;
 	right: ASTNode;
 }
 /**
@@ -110,7 +106,6 @@ interface Assignment {
 * 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;
@@ -131,7 +126,7 @@ declare function identifier(name: string): Identifier;
 /**
 * Create a binary operation node
 */
-declare function binaryOp(left: ASTNode, operator: "+" | "-" | "*" | "/" | "%" | "^", right: ASTNode): BinaryOp;
+declare function binaryOp(left: ASTNode, operator: Operator, right: ASTNode): BinaryOp;
 /**
 * Create a unary operation node (unary minus)
 */
@@ -192,10 +187,6 @@ declare class CodeGenerator {
 	*/
 	private generateNumberLiteral;
 	/**
-	* Generate code for a string literal
-	*/
-	private generateStringLiteral;
-	/**
 	* Generate code for an identifier
 	*/
 	private generateIdentifier;
@@ -237,9 +228,12 @@ declare class CodeGenerator {
 */
 declare function generate(node: ASTNode): string;
 /**
-* Default execution context with common Math functions and date utilities
+* Default execution context with common Math functions and timestamp utilities
 * Users can use this as-is or spread it into their own context
 *
+* All date-related functions work with timestamps (milliseconds since Unix epoch)
+* to maintain the language's numbers-only type system.
+*
 * @example
 * // Use as-is
 * execute('abs(-5)', defaultContext)
@@ -250,6 +244,11 @@ declare function generate(node: ASTNode): string;
 *   ...defaultContext,
 *   variables: { customVar: 42 }
 * })
+*
+* @example
+* // Work with timestamps
+* const result = execute('now() + days(7)', defaultContext)
+* const futureDate = new Date(result) // Convert back to Date if needed
 */
 declare const defaultContext: ExecutionContext;
 /**
@@ -272,10 +271,6 @@ declare class Executor {
 	*/
 	private executeNumberLiteral;
 	/**
-	* Execute a string literal
-	*/
-	private executeStringLiteral;
-	/**
 	* Execute an identifier (variable reference)
 	*/
 	private executeIdentifier;
@@ -295,34 +290,6 @@ declare class Executor {
 	* 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
@@ -349,6 +316,7 @@ declare class Lexer {
 	private skipWhitespaceAndComments;
 	/**
 	* Read a number token
+	* Supports: integers (42), decimals (3.14), and scientific notation (1.5e6, 2e-3)
 	*/
 	private readNumber;
 	/**
@@ -356,10 +324,6 @@ declare class Lexer {
 	*/
 	private readIdentifier;
 	/**
-	* Read a string token
-	*/
-	private readString;
-	/**
 	* Get character at position
 	*/
 	private getCharAt;
@@ -381,6 +345,14 @@ declare class Lexer {
 	private isWhitespace;
 }
 /**
+* Optimize an AST by performing constant folding
+* Recursively evaluates expressions with only literal values
+*
+* @param node - The AST node to optimize
+* @returns Optimized AST node
+*/
+declare function optimize(node: ASTNode): ASTNode;
+/**
 * Parser using Pratt parsing (top-down operator precedence)
 */
 declare class Parser {
@@ -427,6 +399,9 @@ declare class Parser {
 }
 /**
 * Parse source code string into AST
+*
+* @param source - The source code to parse
+* @returns Parsed AST
 */
 declare function parseSource(source: string): 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 };
+export { parseSource, optimize, isUnaryOp, 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

@@ -93,7 +93,6 @@ function negate(argument) {
 var TokenType;
 ((TokenType2) => {
   TokenType2["NUMBER"] = "NUMBER";
-  TokenType2["STRING"] = "STRING";
   TokenType2["IDENTIFIER"] = "IDENTIFIER";
   TokenType2["PLUS"] = "PLUS";
   TokenType2["MINUS"] = "MINUS";
@@ -110,9 +109,6 @@ var TokenType;
 function isNumberLiteral(node) {
   return node.type === "NumberLiteral";
 }
-function isStringLiteral(node) {
-  return node.type === "StringLiteral";
-}
 function isIdentifier(node) {
   return node.type === "Identifier";
 }
@@ -139,8 +135,6 @@ class CodeGenerator {
       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))
@@ -159,9 +153,6 @@ class CodeGenerator {
   generateNumberLiteral(node) {
     return String(node.value);
   }
-  generateStringLiteral(node) {
-    return `'${node.value}'`;
-  }
   generateIdentifier(node) {
     return node.name;
   }
@@ -244,13 +235,21 @@ var defaultContext = {
     log: Math.log,
     log10: Math.log10,
     exp: Math.exp,
-    now: () => new Date,
-    date: (...args) => new Date(...args),
+    now: () => Date.now(),
+    timestamp: (year, month, day, hour = 0, minute = 0, second = 0) => new Date(year, month - 1, day, hour, minute, second).getTime(),
     milliseconds: (ms) => ms,
     seconds: (s) => s * 1000,
     minutes: (m) => m * 60 * 1000,
     hours: (h) => h * 60 * 60 * 1000,
-    days: (d) => d * 24 * 60 * 60 * 1000
+    days: (d) => d * 24 * 60 * 60 * 1000,
+    weeks: (w) => w * 7 * 24 * 60 * 60 * 1000,
+    year: (timestamp) => new Date(timestamp).getFullYear(),
+    month: (timestamp) => new Date(timestamp).getMonth() + 1,
+    day: (timestamp) => new Date(timestamp).getDate(),
+    hour: (timestamp) => new Date(timestamp).getHours(),
+    minute: (timestamp) => new Date(timestamp).getMinutes(),
+    second: (timestamp) => new Date(timestamp).getSeconds(),
+    weekday: (timestamp) => new Date(timestamp).getDay()
   }
 };
 // src/lexer.ts
@@ -281,9 +280,6 @@ class Lexer {
     if (this.isDigit(char)) {
       return this.readNumber();
     }
-    if (char === "'") {
-      return this.readString();
-    }
     if (this.isLetter(char) || char === "_") {
       return this.readIdentifier();
     }
@@ -345,13 +341,28 @@ class Lexer {
   readNumber() {
     const start = this.position;
     let hasDecimal = false;
+    let hasExponent = false;
     while (this.position < this.source.length) {
       const char = this.getCharAt(this.position);
       if (this.isDigit(char)) {
         this.position++;
-      } else if (char === "." && !hasDecimal) {
+      } else if (char === "." && !hasDecimal && !hasExponent) {
         hasDecimal = true;
         this.position++;
+      } else if ((char === "e" || char === "E") && !hasExponent) {
+        hasExponent = true;
+        this.position++;
+        const nextChar = this.getCharAt(this.position);
+        if (nextChar === "+" || nextChar === "-") {
+          this.position++;
+        }
+        if (!this.isDigit(this.getCharAt(this.position))) {
+          throw new Error(`Invalid number: expected digit after exponent at position ${this.position}`);
+        }
+        while (this.position < this.source.length && this.isDigit(this.getCharAt(this.position))) {
+          this.position++;
+        }
+        break;
       } else {
         break;
       }
@@ -372,47 +383,6 @@ class Lexer {
     const name = this.source.slice(start, this.position);
     return { type: "IDENTIFIER" /* IDENTIFIER */, value: name, position: start };
   }
-  readString() {
-    const start = this.position;
-    this.position++;
-    let value = "";
-    while (this.position < this.source.length) {
-      const char = this.getCharAt(this.position);
-      if (char === "'") {
-        this.position++;
-        break;
-      }
-      if (char === "\\" && this.position + 1 < this.source.length) {
-        this.position++;
-        const escaped = this.getCharAt(this.position);
-        switch (escaped) {
-          case "n":
-            value += `
-`;
-            break;
-          case "t":
-            value += "\t";
-            break;
-          case "r":
-            value += "\r";
-            break;
-          case "'":
-            value += "'";
-            break;
-          case "\\":
-            value += "\\";
-            break;
-          default:
-            value += escaped;
-        }
-        this.position++;
-      } else {
-        value += char;
-        this.position++;
-      }
-    }
-    return { type: "STRING" /* STRING */, value, position: start };
-  }
   getCharAt(pos) {
     return pos < this.source.length ? this.source[pos] || "" : "";
   }
@@ -521,13 +491,6 @@ class Parser {
         value: token.value
       };
     }
-    if (token.type === "STRING" /* STRING */) {
-      this.advance();
-      return {
-        type: "StringLiteral",
-        value: token.value
-      };
-    }
     if (token.type === "IDENTIFIER" /* IDENTIFIER */) {
       const name = token.value;
       this.advance();
@@ -620,8 +583,6 @@ class Executor {
       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))
@@ -635,7 +596,7 @@ class Executor {
     throw new Error(`Unknown node type`);
   }
   executeProgram(node) {
-    let result;
+    let result = 0;
     for (const statement of node.statements) {
       result = this.execute(statement);
     }
@@ -644,9 +605,6 @@ class Executor {
   executeNumberLiteral(node) {
     return node.value;
   }
-  executeStringLiteral(node) {
-    return node.value;
-  }
   executeIdentifier(node) {
     const value = this.variables.get(node.name);
     if (value === undefined) {
@@ -659,17 +617,23 @@ class Executor {
     const right = this.execute(node.right);
     switch (node.operator) {
       case "+":
-        return this.add(left, right);
+        return left + right;
       case "-":
-        return this.subtract(left, right);
+        return left - right;
       case "*":
-        return this.multiply(left, right);
+        return left * right;
       case "/":
-        return this.divide(left, right);
+        if (right === 0) {
+          throw new Error("Division by zero");
+        }
+        return left / right;
       case "%":
-        return this.modulo(left, right);
+        if (right === 0) {
+          throw new Error("Modulo by zero");
+        }
+        return left % right;
       case "^":
-        return this.exponentiate(left, right);
+        return left ** right;
       default:
         throw new Error(`Unknown operator: ${node.operator}`);
     }
@@ -677,13 +641,7 @@ class Executor {
   executeUnaryOp(node) {
     const arg = this.execute(node.argument);
     if (node.operator === "-") {
-      if (typeof arg === "number") {
-        return -arg;
-      }
-      if (arg instanceof Date) {
-        return new Date(-arg.getTime());
-      }
-      throw new Error(`Cannot negate ${typeof arg}`);
+      return -arg;
     }
     throw new Error(`Unknown unary operator: ${node.operator}`);
   }
@@ -700,88 +658,82 @@ class Executor {
   }
   executeAssignment(node) {
     const value = this.execute(node.value);
-    if (typeof value !== "number" && !(value instanceof Date)) {
-      throw new Error(`Cannot assign ${typeof value} to variable. Only numbers and Dates are allowed.`);
-    }
     this.variables.set(node.name, value);
     return value;
   }
-  add(left, right) {
-    if (typeof left === "number" && typeof right === "number") {
-      return left + right;
-    }
-    if (left instanceof Date && typeof right === "number") {
-      return new Date(left.getTime() + right);
-    }
-    if (typeof left === "number" && right instanceof Date) {
-      return new Date(right.getTime() + left);
-    }
-    if (left instanceof Date && right instanceof Date) {
-      return new Date(left.getTime() + right.getTime());
-    }
-    throw new Error(`Cannot add ${this.typeOf(left)} and ${this.typeOf(right)}`);
+}
+function execute(source, context) {
+  const ast = parseSource(source);
+  const executor = new Executor(context);
+  return executor.execute(ast);
+}
+// src/optimizer.ts
+function optimize(node) {
+  if (isProgram(node)) {
+    return {
+      ...node,
+      statements: node.statements.map((stmt) => optimize(stmt))
+    };
   }
-  subtract(left, right) {
-    if (typeof left === "number" && typeof right === "number") {
-      return left - right;
-    }
-    if (left instanceof Date && typeof right === "number") {
-      return new Date(left.getTime() - right);
-    }
-    if (typeof left === "number" && right instanceof Date) {
-      return new Date(left - right.getTime());
-    }
-    if (left instanceof Date && right instanceof Date) {
-      return left.getTime() - right.getTime();
+  if (isAssignment(node)) {
+    return {
+      ...node,
+      value: optimize(node.value)
+    };
+  }
+  if (isBinaryOp(node)) {
+    const left = optimize(node.left);
+    const right = optimize(node.right);
+    if (isNumberLiteral(left) && isNumberLiteral(right)) {
+      const result = evaluateBinaryOp(node.operator, left.value, right.value);
+      return number(result);
     }
-    throw new Error(`Cannot subtract ${this.typeOf(right)} from ${this.typeOf(left)}`);
+    return {
+      ...node,
+      left,
+      right
+    };
   }
-  multiply(left, right) {
-    if (typeof left === "number" && typeof right === "number") {
-      return left * right;
+  if (isUnaryOp(node)) {
+    const argument = optimize(node.argument);
+    if (isNumberLiteral(argument)) {
+      return number(-argument.value);
     }
-    throw new Error(`Cannot multiply ${this.typeOf(left)} and ${this.typeOf(right)}`);
+    return {
+      ...node,
+      argument
+    };
   }
-  divide(left, right) {
-    if (typeof left === "number" && typeof right === "number") {
+  return node;
+}
+function evaluateBinaryOp(operator, left, right) {
+  switch (operator) {
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "/":
       if (right === 0) {
-        throw new Error("Division by zero");
+        throw new Error("Division by zero in constant folding");
       }
       return left / right;
-    }
-    throw new Error(`Cannot divide ${this.typeOf(left)} by ${this.typeOf(right)}`);
-  }
-  modulo(left, right) {
-    if (typeof left === "number" && typeof right === "number") {
+    case "%":
       if (right === 0) {
-        throw new Error("Division by zero");
+        throw new Error("Modulo by zero in constant folding");
       }
       return left % right;
-    }
-    throw new Error(`Cannot compute ${this.typeOf(left)} modulo ${this.typeOf(right)}`);
-  }
-  exponentiate(left, right) {
-    if (typeof left === "number" && typeof right === "number") {
+    case "^":
       return left ** right;
-    }
-    throw new Error(`Cannot exponentiate ${this.typeOf(left)} by ${this.typeOf(right)}`);
+    default:
+      throw new Error(`Unknown operator: ${operator}`);
   }
-  typeOf(value) {
-    if (value instanceof Date) {
-      return "Date";
-    }
-    return typeof value;
-  }
-}
-function execute(source, context) {
-  const ast = parseSource(source);
-  const executor = new Executor(context);
-  return executor.execute(ast);
 }
 export {
   parseSource,
+  optimize,
   isUnaryOp,
-  isStringLiteral,
   isProgram,
   isNumberLiteral,
   isIdentifier,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "littlewing",
-	"version": "0.3.1",
+	"version": "0.4.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",