littlewing 0.6.0 → 0.7.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 brielov
+Copyright (c) 2025 Gabriel Vaquer <brielov@icloud.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -12,7 +12,7 @@ execute("2 + 3 * 4"); // → 14
 execute("radius = 5; area = 3.14159 * radius ^ 2", defaultContext); // → 78.54
 
 // Date arithmetic with timestamps
-execute("deadline = now() + days(7)", defaultContext); // → timestamp 7 days from now
+execute("deadline = NOW() + FROM_DAYS(7)", defaultContext); // → timestamp 7 days from now
 
 // Conditional logic
 execute("score = 85; grade = score >= 90 ? 100 : 90", {
@@ -23,12 +23,13 @@ execute("score = 85; grade = score >= 90 ? 100 : 90", {
 ## Features
 
 - **Numbers-only** - Every value is a number. Simple, predictable, fast.
-- **Zero dependencies** - 5.20 KB gzipped, perfect for browser bundles
+- **Zero dependencies** - 6.15 KB gzipped, perfect for browser bundles
 - **O(n) performance** - Linear time parsing and execution
 - **Safe evaluation** - No eval(), no code generation, no security risks
 - **Timestamp arithmetic** - Built-in date/time functions using numeric timestamps
 - **Extensible** - Add custom functions and variables via context
 - **Type-safe** - Full TypeScript support with strict types
+- **99%+ test coverage** - 276 tests with 99.39% function coverage, 99.56% line coverage
 
 ## Installation
 
@@ -70,22 +71,33 @@ execute("age >= 18 ? 100 : 0", { variables: { age: 21 } }); // → 100
 import { execute, defaultContext } from "littlewing";
 
 // Math functions
-execute("abs(-42)", defaultContext); // → 42
-execute("sqrt(16)", defaultContext); // → 4
-execute("max(3, 7, 2)", defaultContext); // → 7
+execute("ABS(-42)", defaultContext); // → 42
+execute("SQRT(16)", defaultContext); // → 4
+execute("MAX(3, 7, 2)", defaultContext); // → 7
 
 // Current timestamp
-execute("now()", defaultContext); // → 1704067200000
+execute("NOW()", defaultContext); // → 1704067200000
 
 // Date arithmetic
-execute("now() + hours(2)", defaultContext); // → timestamp 2 hours from now
-execute("tomorrow = now() + days(1)", defaultContext); // → tomorrow's timestamp
+execute("NOW() + FROM_HOURS(2)", defaultContext); // → timestamp 2 hours from now
+execute("tomorrow = NOW() + FROM_DAYS(1)", defaultContext); // → tomorrow's timestamp
 
 // Extract date components
 const ctx = { ...defaultContext, variables: { ts: Date.now() } };
-execute("year(ts)", ctx); // → 2024
-execute("month(ts)", ctx); // → 11
-execute("day(ts)", ctx); // → 6
+execute("GET_YEAR(ts)", ctx); // → 2024
+execute("GET_MONTH(ts)", ctx); // → 11
+execute("GET_DAY(ts)", ctx); // → 6
+
+// Calculate time differences
+const ts1 = Date.now();
+const ts2 = ts1 + 1000 * 60 * 60 * 5; // 5 hours later
+const context = { ...defaultContext, variables: { ts1, ts2 } };
+execute("DIFFERENCE_IN_HOURS(ts1, ts2)", context); // → 5
+
+// Date arithmetic and comparisons
+execute("ADD_DAYS(NOW(), 7)", defaultContext); // → 7 days from now
+execute("START_OF_DAY(NOW())", defaultContext); // → today at 00:00:00.000
+execute("IS_WEEKEND(NOW())", defaultContext); // → 1 if today is Sat/Sun, else 0
 ```
 
 ### Custom Functions and Variables
@@ -150,7 +162,7 @@ Execute an expression and return the result.
 
 ```typescript
 execute("2 + 2"); // → 4
-execute("abs(-5)", { functions: { abs: Math.abs } }); // → 5
+execute("ABS(-5)", { functions: { ABS: Math.abs } }); // → 5
 ```
 
 #### `parseSource(source: string): ASTNode`
@@ -197,11 +209,23 @@ interface ExecutionContext {
 
 The `defaultContext` includes these built-in functions:
 
-**Math:** `abs`, `ceil`, `floor`, `round`, `sqrt`, `min`, `max`, `sin`, `cos`, `tan`, `log`, `log10`, `exp`
+**Math:** `ABS`, `CEIL`, `FLOOR`, `ROUND`, `SQRT`, `MIN`, `MAX`, `SIN`, `COS`, `TAN`, `LOG`, `LOG10`, `EXP`
 
-**Time:** `now`, `timestamp`, `milliseconds`, `seconds`, `minutes`, `hours`, `days`, `weeks`
+**Timestamps:** `NOW`, `DATE`
 
-**Date components:** `year`, `month`, `day`, `hour`, `minute`, `second`, `weekday`
+**Time converters (to milliseconds):** `FROM_SECONDS`, `FROM_MINUTES`, `FROM_HOURS`, `FROM_DAYS`, `FROM_WEEKS`, `FROM_MONTHS`, `FROM_YEARS`
+
+**Date component extractors:** `GET_YEAR`, `GET_MONTH`, `GET_DAY`, `GET_HOUR`, `GET_MINUTE`, `GET_SECOND`, `GET_WEEKDAY`, `GET_MILLISECOND`, `GET_DAY_OF_YEAR`, `GET_QUARTER`
+
+**Time differences (always positive):** `DIFFERENCE_IN_SECONDS`, `DIFFERENCE_IN_MINUTES`, `DIFFERENCE_IN_HOURS`, `DIFFERENCE_IN_DAYS`, `DIFFERENCE_IN_WEEKS`
+
+**Start/End of period:** `START_OF_DAY`, `END_OF_DAY`, `START_OF_WEEK`, `START_OF_MONTH`, `END_OF_MONTH`, `START_OF_YEAR`, `END_OF_YEAR`, `START_OF_QUARTER`
+
+**Date arithmetic:** `ADD_DAYS`, `ADD_MONTHS`, `ADD_YEARS`
+
+**Date comparisons:** `IS_BEFORE`, `IS_AFTER`, `IS_SAME_DAY`, `IS_WEEKEND`, `IS_LEAP_YEAR`
+
+**Unix time:** `TO_UNIX_SECONDS`, `FROM_UNIX_SECONDS`
 
 ## Use Cases
 

package/dist/index.d.ts

@@ -1,6 +1,3 @@
-declare namespace exports_ast {
-	export { unaryOp, subtract, program, number, notEquals, negate, multiply, modulo, logicalOr, logicalAnd, lessThan, lessEqual, identifier, greaterThan, greaterEqual, functionCall, exponentiate, equals, divide, conditional, binaryOp, assign, add };
-}
 /**
 * Runtime value type - only numbers
 */
@@ -134,6 +131,31 @@ declare function isAssignment(node: ASTNode): node is Assignment;
 declare function isProgram(node: ASTNode): node is Program;
 declare function isConditionalExpression(node: ASTNode): node is ConditionalExpression;
 /**
+* Extracts input variables from an AST.
+*
+* Input variables are those whose values can be determined without knowing
+* the values of other variables in the script. This includes:
+* - Literals (10, -5, 3.14)
+* - Unary minus of literals (-10)
+* - Constant expressions (2 + 3, -5 * 2)
+* - Function calls with constant arguments (MAX(10, 20), NOW())
+*
+* Computed variables (those that reference other variables) are excluded.
+*
+* @param ast - The AST to analyze (can be a single statement or Program node)
+* @returns Array of input variable names
+*
+* @example
+* ```typescript
+* const ast = parseSource('price = 100; tax = price * 0.08')
+* extractInputVariables(ast) // ['price']
+* ```
+*/
+declare function extractInputVariables(ast: ASTNode): string[];
+declare namespace exports_ast {
+	export { unaryOp, subtract, program, number, notEquals, negate, multiply, modulo, logicalOr, logicalAnd, lessThan, lessEqual, identifier, greaterThan, greaterEqual, functionCall, exponentiate, equals, divide, conditional, binaryOp, assign, add };
+}
+/**
 * Builder functions for creating AST nodes manually
 */
 /**
@@ -294,28 +316,217 @@ declare class CodeGenerator {
 * Generate source code from an AST node
 */
 declare function generate(node: ASTNode): string;
+declare namespace exports_date_utils {
+	export { TO_UNIX_SECONDS, START_OF_YEAR, START_OF_WEEK, START_OF_QUARTER, START_OF_MONTH, START_OF_DAY, NOW, IS_WEEKEND, IS_SAME_DAY, IS_LEAP_YEAR, IS_BEFORE, IS_AFTER, GET_YEAR, GET_WEEKDAY, GET_SECOND, GET_QUARTER, GET_MONTH, GET_MINUTE, GET_MILLISECOND, GET_HOUR, GET_DAY_OF_YEAR, GET_DAY, FROM_YEARS, FROM_WEEKS, FROM_UNIX_SECONDS, FROM_SECONDS, FROM_MONTHS, FROM_MINUTES, FROM_HOURS, FROM_DAYS, END_OF_YEAR, END_OF_MONTH, END_OF_DAY, DIFFERENCE_IN_WEEKS, DIFFERENCE_IN_SECONDS, DIFFERENCE_IN_MINUTES, DIFFERENCE_IN_HOURS, DIFFERENCE_IN_DAYS, DATE, ADD_YEARS, ADD_MONTHS, ADD_DAYS };
+}
+/**
+* Date utility functions for working with timestamps
+* All functions work with milliseconds since Unix epoch (numbers only)
+*/
+/**
+* Get current timestamp (milliseconds since Unix epoch)
+*/
+declare const NOW: () => number;
+/**
+* Create timestamp from date components
+* Year is required, all other parameters default to minimum values
+* Month is 1-based (1 = January, 12 = December)
+*/
+declare const DATE: (year: number, month?: number, day?: number, hour?: number, minute?: number, second?: number) => number;
+/**
+* Convert seconds to milliseconds
+*/
+declare const FROM_SECONDS: (s: number) => number;
+/**
+* Convert minutes to milliseconds
+*/
+declare const FROM_MINUTES: (m: number) => number;
+/**
+* Convert hours to milliseconds
+*/
+declare const FROM_HOURS: (h: number) => number;
+/**
+* Convert days to milliseconds
+*/
+declare const FROM_DAYS: (d: number) => number;
+/**
+* Convert weeks to milliseconds
+*/
+declare const FROM_WEEKS: (w: number) => number;
+/**
+* Convert months to milliseconds (approximate: 30 days per month)
+*/
+declare const FROM_MONTHS: (months: number) => number;
+/**
+* Convert years to milliseconds (approximate: 365 days per year)
+*/
+declare const FROM_YEARS: (years: number) => number;
+/**
+* Get the year from a timestamp
+*/
+declare const GET_YEAR: (timestamp: number) => number;
+/**
+* Get the month from a timestamp (1-based: 1 = January, 12 = December)
+*/
+declare const GET_MONTH: (timestamp: number) => number;
+/**
+* Get the day of month from a timestamp (1-31)
+*/
+declare const GET_DAY: (timestamp: number) => number;
+/**
+* Get the hour from a timestamp (0-23)
+*/
+declare const GET_HOUR: (timestamp: number) => number;
+/**
+* Get the minute from a timestamp (0-59)
+*/
+declare const GET_MINUTE: (timestamp: number) => number;
+/**
+* Get the second from a timestamp (0-59)
+*/
+declare const GET_SECOND: (timestamp: number) => number;
+/**
+* Get the millisecond component from a timestamp (0-999)
+*/
+declare const GET_MILLISECOND: (timestamp: number) => number;
+/**
+* Get the day of week from a timestamp (0 = Sunday, 6 = Saturday)
+*/
+declare const GET_WEEKDAY: (timestamp: number) => number;
+/**
+* Get the day of year (1-366) from a timestamp
+*/
+declare const GET_DAY_OF_YEAR: (timestamp: number) => number;
+/**
+* Get the quarter (1-4) from a timestamp
+*/
+declare const GET_QUARTER: (timestamp: number) => number;
+/**
+* Get the absolute difference between two timestamps in seconds
+*/
+declare const DIFFERENCE_IN_SECONDS: (ts1: number, ts2: number) => number;
+/**
+* Get the absolute difference between two timestamps in minutes
+*/
+declare const DIFFERENCE_IN_MINUTES: (ts1: number, ts2: number) => number;
+/**
+* Get the absolute difference between two timestamps in hours
+*/
+declare const DIFFERENCE_IN_HOURS: (ts1: number, ts2: number) => number;
+/**
+* Get the absolute difference between two timestamps in days
+*/
+declare const DIFFERENCE_IN_DAYS: (ts1: number, ts2: number) => number;
+/**
+* Get the absolute difference between two timestamps in weeks
+*/
+declare const DIFFERENCE_IN_WEEKS: (ts1: number, ts2: number) => number;
 /**
-* Default execution context with common Math functions and timestamp utilities
+* Get the start of day (00:00:00.000) for a given timestamp
+*/
+declare const START_OF_DAY: (timestamp: number) => number;
+/**
+* Get the end of day (23:59:59.999) for a given timestamp
+*/
+declare const END_OF_DAY: (timestamp: number) => number;
+/**
+* Get the start of week (Sunday at 00:00:00.000) for a given timestamp
+*/
+declare const START_OF_WEEK: (timestamp: number) => number;
+/**
+* Get the start of month (1st day at 00:00:00.000) for a given timestamp
+*/
+declare const START_OF_MONTH: (timestamp: number) => number;
+/**
+* Get the end of month (last day at 23:59:59.999) for a given timestamp
+*/
+declare const END_OF_MONTH: (timestamp: number) => number;
+/**
+* Get the start of year (Jan 1st at 00:00:00.000) for a given timestamp
+*/
+declare const START_OF_YEAR: (timestamp: number) => number;
+/**
+* Get the end of year (Dec 31st at 23:59:59.999) for a given timestamp
+*/
+declare const END_OF_YEAR: (timestamp: number) => number;
+/**
+* Add days to a timestamp
+*/
+declare const ADD_DAYS: (timestamp: number, days: number) => number;
+/**
+* Add months to a timestamp (handles variable month lengths correctly)
+*/
+declare const ADD_MONTHS: (timestamp: number, months: number) => number;
+/**
+* Add years to a timestamp
+*/
+declare const ADD_YEARS: (timestamp: number, years: number) => number;
+/**
+* Check if ts1 is before ts2
+* Returns 1 if true, 0 if false
+*/
+declare const IS_BEFORE: (ts1: number, ts2: number) => number;
+/**
+* Check if ts1 is after ts2
+* Returns 1 if true, 0 if false
+*/
+declare const IS_AFTER: (ts1: number, ts2: number) => number;
+/**
+* Check if two timestamps are on the same calendar day
+* Returns 1 if true, 0 if false
+*/
+declare const IS_SAME_DAY: (ts1: number, ts2: number) => number;
+/**
+* Check if timestamp falls on a weekend (Saturday or Sunday)
+* Returns 1 if true, 0 if false
+*/
+declare const IS_WEEKEND: (timestamp: number) => number;
+/**
+* Check if timestamp is in a leap year
+* Returns 1 if true, 0 if false
+*/
+declare const IS_LEAP_YEAR: (timestamp: number) => number;
+/**
+* Get the start of quarter for a given timestamp
+*/
+declare const START_OF_QUARTER: (timestamp: number) => number;
+/**
+* Convert millisecond timestamp to Unix seconds
+*/
+declare const TO_UNIX_SECONDS: (timestamp: number) => number;
+/**
+* Convert Unix seconds to millisecond timestamp
+*/
+declare const FROM_UNIX_SECONDS: (seconds: number) => number;
+/**
+* Default execution context with common Math functions and date/time utilities
 * Users can use this as-is or spread it into their own context
 *
+* All functions use UPPERCASE naming convention to avoid collisions with user variables.
 * 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)
+* execute('ABS(-5)', defaultContext)
 *
 * @example
 * // Spread into custom context
-* execute('now() + minutes(5)', {
+* execute('NOW() + FROM_MINUTES(5)', {
 *   ...defaultContext,
 *   variables: { customVar: 42 }
 * })
 *
 * @example
 * // Work with timestamps
-* const result = execute('now() + days(7)', defaultContext)
+* const result = execute('NOW() + FROM_DAYS(7)', defaultContext)
 * const futureDate = new Date(result) // Convert back to Date if needed
+*
+* @example
+* // Calculate time differences
+* const ts1 = Date.now()
+* const ts2 = ts1 + 1000 * 60 * 60 * 3 // 3 hours later
+* execute('DIFFERENCE_IN_HOURS(ts1, ts2)', { ...defaultContext, variables: { ts1, ts2 } })
 */
 declare const defaultContext: ExecutionContext;
 /**
@@ -493,4 +704,4 @@ declare class Parser {
 * @returns Parsed AST
 */
 declare function parseSource(source: string): ASTNode;
-export { parseSource, optimize, isUnaryOp, isProgram, isNumberLiteral, isIdentifier, isFunctionCall, isConditionalExpression, 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, isConditionalExpression, isBinaryOp, isAssignment, generate, extractInputVariables, execute, defaultContext, exports_date_utils as dateUtils, exports_ast as ast, UnaryOp, TokenType, Token, RuntimeValue, Program, Parser, Operator, NumberLiteral, Lexer, Identifier, FunctionCall, Executor, ExecutionContext, ConditionalExpression, CodeGenerator, BinaryOp, Assignment, ASTNode };

package/dist/index.js

@@ -10,6 +10,92 @@ var __export = (target, all) => {
     });
 };
 
+// src/types.ts
+var TokenType;
+((TokenType2) => {
+  TokenType2["NUMBER"] = "NUMBER";
+  TokenType2["IDENTIFIER"] = "IDENTIFIER";
+  TokenType2["PLUS"] = "PLUS";
+  TokenType2["MINUS"] = "MINUS";
+  TokenType2["STAR"] = "STAR";
+  TokenType2["SLASH"] = "SLASH";
+  TokenType2["PERCENT"] = "PERCENT";
+  TokenType2["CARET"] = "CARET";
+  TokenType2["DOUBLE_EQUALS"] = "DOUBLE_EQUALS";
+  TokenType2["NOT_EQUALS"] = "NOT_EQUALS";
+  TokenType2["LESS_THAN"] = "LESS_THAN";
+  TokenType2["GREATER_THAN"] = "GREATER_THAN";
+  TokenType2["LESS_EQUAL"] = "LESS_EQUAL";
+  TokenType2["GREATER_EQUAL"] = "GREATER_EQUAL";
+  TokenType2["LOGICAL_AND"] = "LOGICAL_AND";
+  TokenType2["LOGICAL_OR"] = "LOGICAL_OR";
+  TokenType2["LPAREN"] = "LPAREN";
+  TokenType2["RPAREN"] = "RPAREN";
+  TokenType2["EQUALS"] = "EQUALS";
+  TokenType2["COMMA"] = "COMMA";
+  TokenType2["QUESTION"] = "QUESTION";
+  TokenType2["COLON"] = "COLON";
+  TokenType2["EOF"] = "EOF";
+})(TokenType ||= {});
+function isNumberLiteral(node) {
+  return node.type === "NumberLiteral";
+}
+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";
+}
+function isConditionalExpression(node) {
+  return node.type === "ConditionalExpression";
+}
+
+// src/analyzer.ts
+function extractInputVariables(ast) {
+  const inputVars = new Set;
+  const statements = isProgram(ast) ? ast.statements : [ast];
+  for (const statement of statements) {
+    if (isAssignment(statement)) {
+      if (!containsVariableReference(statement.value)) {
+        inputVars.add(statement.name);
+      }
+    }
+  }
+  return Array.from(inputVars);
+}
+function containsVariableReference(node) {
+  if (isIdentifier(node)) {
+    return true;
+  }
+  if (isNumberLiteral(node)) {
+    return false;
+  }
+  if (isBinaryOp(node)) {
+    return containsVariableReference(node.left) || containsVariableReference(node.right);
+  }
+  if (isUnaryOp(node)) {
+    return containsVariableReference(node.argument);
+  }
+  if (isFunctionCall(node)) {
+    return node.arguments.some((arg) => containsVariableReference(arg));
+  }
+  if (isConditionalExpression(node)) {
+    return containsVariableReference(node.condition) || containsVariableReference(node.consequent) || containsVariableReference(node.alternate);
+  }
+  return false;
+}
 // src/ast.ts
 var exports_ast = {};
 __export(exports_ast, {
@@ -137,58 +223,6 @@ function logicalAnd(left, right) {
 function logicalOr(left, right) {
   return binaryOp(left, "||", right);
 }
-// src/types.ts
-var TokenType;
-((TokenType2) => {
-  TokenType2["NUMBER"] = "NUMBER";
-  TokenType2["IDENTIFIER"] = "IDENTIFIER";
-  TokenType2["PLUS"] = "PLUS";
-  TokenType2["MINUS"] = "MINUS";
-  TokenType2["STAR"] = "STAR";
-  TokenType2["SLASH"] = "SLASH";
-  TokenType2["PERCENT"] = "PERCENT";
-  TokenType2["CARET"] = "CARET";
-  TokenType2["DOUBLE_EQUALS"] = "DOUBLE_EQUALS";
-  TokenType2["NOT_EQUALS"] = "NOT_EQUALS";
-  TokenType2["LESS_THAN"] = "LESS_THAN";
-  TokenType2["GREATER_THAN"] = "GREATER_THAN";
-  TokenType2["LESS_EQUAL"] = "LESS_EQUAL";
-  TokenType2["GREATER_EQUAL"] = "GREATER_EQUAL";
-  TokenType2["LOGICAL_AND"] = "LOGICAL_AND";
-  TokenType2["LOGICAL_OR"] = "LOGICAL_OR";
-  TokenType2["LPAREN"] = "LPAREN";
-  TokenType2["RPAREN"] = "RPAREN";
-  TokenType2["EQUALS"] = "EQUALS";
-  TokenType2["COMMA"] = "COMMA";
-  TokenType2["QUESTION"] = "QUESTION";
-  TokenType2["COLON"] = "COLON";
-  TokenType2["EOF"] = "EOF";
-})(TokenType ||= {});
-function isNumberLiteral(node) {
-  return node.type === "NumberLiteral";
-}
-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";
-}
-function isConditionalExpression(node) {
-  return node.type === "ConditionalExpression";
-}
-
 // src/utils.ts
 function evaluateBinaryOperation(operator, left, right) {
   switch (operator) {
@@ -373,37 +407,187 @@ function generate(node) {
   const generator = new CodeGenerator;
   return generator.generate(node);
 }
+// src/date-utils.ts
+var exports_date_utils = {};
+__export(exports_date_utils, {
+  TO_UNIX_SECONDS: () => TO_UNIX_SECONDS,
+  START_OF_YEAR: () => START_OF_YEAR,
+  START_OF_WEEK: () => START_OF_WEEK,
+  START_OF_QUARTER: () => START_OF_QUARTER,
+  START_OF_MONTH: () => START_OF_MONTH,
+  START_OF_DAY: () => START_OF_DAY,
+  NOW: () => NOW,
+  IS_WEEKEND: () => IS_WEEKEND,
+  IS_SAME_DAY: () => IS_SAME_DAY,
+  IS_LEAP_YEAR: () => IS_LEAP_YEAR,
+  IS_BEFORE: () => IS_BEFORE,
+  IS_AFTER: () => IS_AFTER,
+  GET_YEAR: () => GET_YEAR,
+  GET_WEEKDAY: () => GET_WEEKDAY,
+  GET_SECOND: () => GET_SECOND,
+  GET_QUARTER: () => GET_QUARTER,
+  GET_MONTH: () => GET_MONTH,
+  GET_MINUTE: () => GET_MINUTE,
+  GET_MILLISECOND: () => GET_MILLISECOND,
+  GET_HOUR: () => GET_HOUR,
+  GET_DAY_OF_YEAR: () => GET_DAY_OF_YEAR,
+  GET_DAY: () => GET_DAY,
+  FROM_YEARS: () => FROM_YEARS,
+  FROM_WEEKS: () => FROM_WEEKS,
+  FROM_UNIX_SECONDS: () => FROM_UNIX_SECONDS,
+  FROM_SECONDS: () => FROM_SECONDS,
+  FROM_MONTHS: () => FROM_MONTHS,
+  FROM_MINUTES: () => FROM_MINUTES,
+  FROM_HOURS: () => FROM_HOURS,
+  FROM_DAYS: () => FROM_DAYS,
+  END_OF_YEAR: () => END_OF_YEAR,
+  END_OF_MONTH: () => END_OF_MONTH,
+  END_OF_DAY: () => END_OF_DAY,
+  DIFFERENCE_IN_WEEKS: () => DIFFERENCE_IN_WEEKS,
+  DIFFERENCE_IN_SECONDS: () => DIFFERENCE_IN_SECONDS,
+  DIFFERENCE_IN_MINUTES: () => DIFFERENCE_IN_MINUTES,
+  DIFFERENCE_IN_HOURS: () => DIFFERENCE_IN_HOURS,
+  DIFFERENCE_IN_DAYS: () => DIFFERENCE_IN_DAYS,
+  DATE: () => DATE,
+  ADD_YEARS: () => ADD_YEARS,
+  ADD_MONTHS: () => ADD_MONTHS,
+  ADD_DAYS: () => ADD_DAYS
+});
+var NOW = () => Date.now();
+var DATE = (year, month = 1, day = 1, hour = 0, minute = 0, second = 0) => new Date(year, month - 1, day, hour, minute, second).getTime();
+var FROM_SECONDS = (s) => s * 1000;
+var FROM_MINUTES = (m) => m * 60 * 1000;
+var FROM_HOURS = (h) => h * 60 * 60 * 1000;
+var FROM_DAYS = (d) => d * 24 * 60 * 60 * 1000;
+var FROM_WEEKS = (w) => w * 7 * 24 * 60 * 60 * 1000;
+var FROM_MONTHS = (months) => months * 30 * 24 * 60 * 60 * 1000;
+var FROM_YEARS = (years) => years * 365 * 24 * 60 * 60 * 1000;
+var GET_YEAR = (timestamp) => new Date(timestamp).getFullYear();
+var GET_MONTH = (timestamp) => new Date(timestamp).getMonth() + 1;
+var GET_DAY = (timestamp) => new Date(timestamp).getDate();
+var GET_HOUR = (timestamp) => new Date(timestamp).getHours();
+var GET_MINUTE = (timestamp) => new Date(timestamp).getMinutes();
+var GET_SECOND = (timestamp) => new Date(timestamp).getSeconds();
+var GET_MILLISECOND = (timestamp) => new Date(timestamp).getMilliseconds();
+var GET_WEEKDAY = (timestamp) => new Date(timestamp).getDay();
+var GET_DAY_OF_YEAR = (timestamp) => {
+  const date = new Date(timestamp);
+  const start = new Date(date.getFullYear(), 0, 0);
+  const diff = date.getTime() - start.getTime();
+  const oneDay = 1000 * 60 * 60 * 24;
+  return Math.floor(diff / oneDay);
+};
+var GET_QUARTER = (timestamp) => {
+  const month = new Date(timestamp).getMonth();
+  return Math.floor(month / 3) + 1;
+};
+var DIFFERENCE_IN_SECONDS = (ts1, ts2) => Math.abs(ts1 - ts2) / 1000;
+var DIFFERENCE_IN_MINUTES = (ts1, ts2) => Math.abs(ts1 - ts2) / (60 * 1000);
+var DIFFERENCE_IN_HOURS = (ts1, ts2) => Math.abs(ts1 - ts2) / (60 * 60 * 1000);
+var DIFFERENCE_IN_DAYS = (ts1, ts2) => Math.abs(ts1 - ts2) / (24 * 60 * 60 * 1000);
+var DIFFERENCE_IN_WEEKS = (ts1, ts2) => Math.abs(ts1 - ts2) / (7 * 24 * 60 * 60 * 1000);
+var START_OF_DAY = (timestamp) => {
+  const date = new Date(timestamp);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+};
+var END_OF_DAY = (timestamp) => {
+  const date = new Date(timestamp);
+  date.setHours(23, 59, 59, 999);
+  return date.getTime();
+};
+var START_OF_WEEK = (timestamp) => {
+  const date = new Date(timestamp);
+  const day = date.getDay();
+  const diff = date.getDate() - day;
+  date.setDate(diff);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+};
+var START_OF_MONTH = (timestamp) => {
+  const date = new Date(timestamp);
+  date.setDate(1);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+};
+var END_OF_MONTH = (timestamp) => {
+  const date = new Date(timestamp);
+  date.setMonth(date.getMonth() + 1, 0);
+  date.setHours(23, 59, 59, 999);
+  return date.getTime();
+};
+var START_OF_YEAR = (timestamp) => {
+  const date = new Date(timestamp);
+  date.setMonth(0, 1);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+};
+var END_OF_YEAR = (timestamp) => {
+  const date = new Date(timestamp);
+  date.setMonth(11, 31);
+  date.setHours(23, 59, 59, 999);
+  return date.getTime();
+};
+var ADD_DAYS = (timestamp, days) => {
+  const date = new Date(timestamp);
+  date.setDate(date.getDate() + days);
+  return date.getTime();
+};
+var ADD_MONTHS = (timestamp, months) => {
+  const date = new Date(timestamp);
+  date.setMonth(date.getMonth() + months);
+  return date.getTime();
+};
+var ADD_YEARS = (timestamp, years) => {
+  const date = new Date(timestamp);
+  date.setFullYear(date.getFullYear() + years);
+  return date.getTime();
+};
+var IS_BEFORE = (ts1, ts2) => {
+  return ts1 < ts2 ? 1 : 0;
+};
+var IS_AFTER = (ts1, ts2) => {
+  return ts1 > ts2 ? 1 : 0;
+};
+var IS_SAME_DAY = (ts1, ts2) => {
+  const date1 = new Date(ts1);
+  const date2 = new Date(ts2);
+  return date1.getFullYear() === date2.getFullYear() && date1.getMonth() === date2.getMonth() && date1.getDate() === date2.getDate() ? 1 : 0;
+};
+var IS_WEEKEND = (timestamp) => {
+  const day = new Date(timestamp).getDay();
+  return day === 0 || day === 6 ? 1 : 0;
+};
+var IS_LEAP_YEAR = (timestamp) => {
+  const year = new Date(timestamp).getFullYear();
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 1 : 0;
+};
+var START_OF_QUARTER = (timestamp) => {
+  const date = new Date(timestamp);
+  const quarter = Math.floor(date.getMonth() / 3);
+  date.setMonth(quarter * 3, 1);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+};
+var TO_UNIX_SECONDS = (timestamp) => Math.floor(timestamp / 1000);
+var FROM_UNIX_SECONDS = (seconds) => seconds * 1000;
 // src/defaults.ts
 var defaultContext = {
   functions: {
-    abs: Math.abs,
-    ceil: Math.ceil,
-    floor: Math.floor,
-    round: Math.round,
-    sqrt: Math.sqrt,
-    min: Math.min,
-    max: Math.max,
-    sin: Math.sin,
-    cos: Math.cos,
-    tan: Math.tan,
-    log: Math.log,
-    log10: Math.log10,
-    exp: Math.exp,
-    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,
-    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()
+    ABS: Math.abs,
+    CEIL: Math.ceil,
+    FLOOR: Math.floor,
+    ROUND: Math.round,
+    SQRT: Math.sqrt,
+    MIN: Math.min,
+    MAX: Math.max,
+    SIN: Math.sin,
+    COS: Math.cos,
+    TAN: Math.tan,
+    LOG: Math.log,
+    LOG10: Math.log10,
+    EXP: Math.exp,
+    ...exports_date_utils
   }
 };
 // src/lexer.ts
@@ -908,8 +1092,10 @@ export {
   isBinaryOp,
   isAssignment,
   generate,
+  extractInputVariables,
   execute,
   defaultContext,
+  exports_date_utils as dateUtils,
   exports_ast as ast,
   TokenType,
   Parser,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "littlewing",
-	"version": "0.6.0",
+	"version": "0.7.1",
 	"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",