littlewing 0.7.0 → 0.8.0

package/README.md

@@ -209,23 +209,21 @@ 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`, `CLAMP`, `SIN`, `COS`, `TAN`, `LOG`, `LOG10`, `EXP`
 
 **Timestamps:** `NOW`, `DATE`
 
-**Time converters (to milliseconds):** `FROM_SECONDS`, `FROM_MINUTES`, `FROM_HOURS`, `FROM_DAYS`, `FROM_WEEKS`, `FROM_MONTHS`, `FROM_YEARS`
+**Time converters (to milliseconds):** `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`
+**Time differences (always positive):** `DIFFERENCE_IN_SECONDS`, `DIFFERENCE_IN_MINUTES`, `DIFFERENCE_IN_HOURS`, `DIFFERENCE_IN_DAYS`, `DIFFERENCE_IN_WEEKS`, `DIFFERENCE_IN_MONTHS`, `DIFFERENCE_IN_YEARS`
 
 **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`
+**Date comparisons:** `IS_SAME_DAY`, `IS_WEEKEND`, `IS_LEAP_YEAR` (use `<`, `>`, `<=`, `>=` operators for before/after comparisons)
 
 ## 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
 */
 /**
@@ -295,35 +317,28 @@ declare class CodeGenerator {
 */
 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 };
+	export { START_OF_YEAR, START_OF_WEEK, START_OF_QUARTER, START_OF_MONTH, START_OF_DAY, NOW, IS_WEEKEND, IS_SAME_DAY, IS_LEAP_YEAR, 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_MONTHS, FROM_DAYS, END_OF_YEAR, END_OF_MONTH, END_OF_DAY, DIFFERENCE_IN_YEARS, DIFFERENCE_IN_WEEKS, DIFFERENCE_IN_SECONDS, DIFFERENCE_IN_MONTHS, 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)
+*
+* IMPORTANT: All functions use UTC timezone for consistency and predictability
+* across different server environments. This ensures the same inputs always
+* produce the same outputs regardless of the machine's local timezone.
 */
 /**
 * Get current timestamp (milliseconds since Unix epoch)
 */
 declare const NOW: () => number;
 /**
-* Create timestamp from date components
+* Create timestamp from date components (UTC timezone)
 * Year is required, all other parameters default to minimum values
 * Month is 1-based (1 = January, 12 = December)
+* All parameters are interpreted in UTC timezone for consistency
 */
 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;
@@ -333,150 +348,159 @@ declare const FROM_DAYS: (d: number) => number;
 declare const FROM_WEEKS: (w: number) => number;
 /**
 * Convert months to milliseconds (approximate: 30 days per month)
+* WARNING: This is an approximation. Not all months have 30 days.
+* For accurate month arithmetic, use ADD_MONTHS() instead.
 */
 declare const FROM_MONTHS: (months: number) => number;
 /**
 * Convert years to milliseconds (approximate: 365 days per year)
+* WARNING: This is an approximation. Leap years have 366 days.
+* For accurate year arithmetic, use ADD_YEARS() instead.
 */
 declare const FROM_YEARS: (years: number) => number;
 /**
-* Get the year from a timestamp
+* Get the year from a timestamp (UTC)
 */
 declare const GET_YEAR: (timestamp: number) => number;
 /**
-* Get the month from a timestamp (1-based: 1 = January, 12 = December)
+* Get the month from a timestamp (1-based: 1 = January, 12 = December, UTC)
 */
 declare const GET_MONTH: (timestamp: number) => number;
 /**
-* Get the day of month from a timestamp (1-31)
+* Get the day of month from a timestamp (1-31, UTC)
 */
 declare const GET_DAY: (timestamp: number) => number;
 /**
-* Get the hour from a timestamp (0-23)
+* Get the hour from a timestamp (0-23, UTC)
 */
 declare const GET_HOUR: (timestamp: number) => number;
 /**
-* Get the minute from a timestamp (0-59)
+* Get the minute from a timestamp (0-59, UTC)
 */
 declare const GET_MINUTE: (timestamp: number) => number;
 /**
-* Get the second from a timestamp (0-59)
+* Get the second from a timestamp (0-59, UTC)
 */
 declare const GET_SECOND: (timestamp: number) => number;
 /**
-* Get the millisecond component from a timestamp (0-999)
+* Get the millisecond component from a timestamp (0-999, UTC)
 */
 declare const GET_MILLISECOND: (timestamp: number) => number;
 /**
-* Get the day of week from a timestamp (0 = Sunday, 6 = Saturday)
+* Get the day of week from a timestamp (0 = Sunday, 6 = Saturday, UTC)
 */
 declare const GET_WEEKDAY: (timestamp: number) => number;
 /**
-* Get the day of year (1-366) from a timestamp
+* Get the day of year (1-366) from a timestamp (UTC)
+* January 1st = 1, December 31st = 365 or 366 (leap year)
 */
 declare const GET_DAY_OF_YEAR: (timestamp: number) => number;
 /**
-* Get the quarter (1-4) from a timestamp
+* Get the quarter (1-4) from a timestamp (UTC)
 */
 declare const GET_QUARTER: (timestamp: number) => number;
 /**
-* Get the absolute difference between two timestamps in seconds
+* Get the absolute difference between two timestamps in seconds (whole seconds)
 */
 declare const DIFFERENCE_IN_SECONDS: (ts1: number, ts2: number) => number;
 /**
-* Get the absolute difference between two timestamps in minutes
+* Get the absolute difference between two timestamps in minutes (whole minutes)
 */
 declare const DIFFERENCE_IN_MINUTES: (ts1: number, ts2: number) => number;
 /**
-* Get the absolute difference between two timestamps in hours
+* Get the absolute difference between two timestamps in hours (whole hours)
 */
 declare const DIFFERENCE_IN_HOURS: (ts1: number, ts2: number) => number;
 /**
-* Get the absolute difference between two timestamps in days
+* Get the absolute difference between two timestamps in days (whole days)
 */
 declare const DIFFERENCE_IN_DAYS: (ts1: number, ts2: number) => number;
 /**
-* Get the absolute difference between two timestamps in weeks
+* Get the absolute difference between two timestamps in weeks (whole weeks)
 */
 declare const DIFFERENCE_IN_WEEKS: (ts1: number, ts2: number) => number;
 /**
-* Get the start of day (00:00:00.000) for a given timestamp
+* Get the number of full calendar months between two timestamps (UTC)
+* Counts complete months where the same day-of-month has been reached
+*
+* Examples:
+*   Jan 15 → Feb 14 = 0 months (Feb 15 not reached yet)
+*   Jan 15 → Feb 15 = 1 month
+*   Jan 31 → Feb 28 = 0 months (Feb 31 doesn't exist)
+*   Jan 31 → Mar 31 = 2 months
+*/
+declare const DIFFERENCE_IN_MONTHS: (ts1: number, ts2: number) => number;
+/**
+* Get the number of full calendar years between two timestamps (UTC)
+* Counts complete years where the same month and day have been reached
+*
+* Examples:
+*   Jan 15, 2020 → Jan 14, 2021 = 0 years (Jan 15 not reached)
+*   Jan 15, 2020 → Jan 15, 2021 = 1 year
+*   Feb 29, 2020 → Feb 28, 2021 = 0 years (Feb 29 doesn't exist)
+*   Feb 29, 2020 → Mar 1, 2021 = 1 year
+*/
+declare const DIFFERENCE_IN_YEARS: (ts1: number, ts2: number) => number;
+/**
+* Get the start of day (00:00:00.000 UTC) 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
+* Get the end of day (23:59:59.999 UTC) 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
+* Get the start of week (Sunday at 00:00:00.000 UTC) 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
+* Get the start of month (1st day at 00:00:00.000 UTC) 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
+* Get the end of month (last day at 23:59:59.999 UTC) 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
+* Get the start of year (Jan 1st at 00:00:00.000 UTC) 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
+* Get the end of year (Dec 31st at 23:59:59.999 UTC) for a given timestamp
 */
 declare const END_OF_YEAR: (timestamp: number) => number;
 /**
-* Add days to a timestamp
+* Add days to a timestamp (UTC)
 */
 declare const ADD_DAYS: (timestamp: number, days: number) => number;
 /**
-* Add months to a timestamp (handles variable month lengths correctly)
+* Add months to a timestamp (handles variable month lengths correctly, UTC)
 */
 declare const ADD_MONTHS: (timestamp: number, months: number) => number;
 /**
-* Add years to a timestamp
+* Add years to a timestamp (UTC)
 */
 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
+* Check if two timestamps are on the same calendar day (UTC)
 * 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)
+* Check if timestamp falls on a weekend (Saturday or Sunday, UTC)
 * Returns 1 if true, 0 if false
 */
 declare const IS_WEEKEND: (timestamp: number) => number;
 /**
-* Check if timestamp is in a leap year
+* Check if timestamp is in a leap year (UTC)
 * Returns 1 if true, 0 if false
 */
 declare const IS_LEAP_YEAR: (timestamp: number) => number;
 /**
-* Get the start of quarter for a given timestamp
+* Get the start of quarter for a given timestamp (UTC)
 */
 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
 *
@@ -682,4 +706,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_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 };
+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) {
@@ -376,7 +410,6 @@ function 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,
@@ -386,8 +419,6 @@ __export(exports_date_utils, {
   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,
@@ -400,17 +431,15 @@ __export(exports_date_utils, {
   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_YEARS: () => DIFFERENCE_IN_YEARS,
   DIFFERENCE_IN_WEEKS: () => DIFFERENCE_IN_WEEKS,
   DIFFERENCE_IN_SECONDS: () => DIFFERENCE_IN_SECONDS,
+  DIFFERENCE_IN_MONTHS: () => DIFFERENCE_IN_MONTHS,
   DIFFERENCE_IN_MINUTES: () => DIFFERENCE_IN_MINUTES,
   DIFFERENCE_IN_HOURS: () => DIFFERENCE_IN_HOURS,
   DIFFERENCE_IN_DAYS: () => DIFFERENCE_IN_DAYS,
@@ -420,123 +449,114 @@ __export(exports_date_utils, {
   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 DATE = (year, month = 1, day = 1, hour = 0, minute = 0, second = 0) => Date.UTC(year, month - 1, day, hour, minute, second);
 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_YEAR = (timestamp) => new Date(timestamp).getUTCFullYear();
+var GET_MONTH = (timestamp) => new Date(timestamp).getUTCMonth() + 1;
+var GET_DAY = (timestamp) => new Date(timestamp).getUTCDate();
+var GET_HOUR = (timestamp) => new Date(timestamp).getUTCHours();
+var GET_MINUTE = (timestamp) => new Date(timestamp).getUTCMinutes();
+var GET_SECOND = (timestamp) => new Date(timestamp).getUTCSeconds();
+var GET_MILLISECOND = (timestamp) => new Date(timestamp).getUTCMilliseconds();
+var GET_WEEKDAY = (timestamp) => new Date(timestamp).getUTCDay();
 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);
+  const year = date.getUTCFullYear();
+  const startOfYear = Date.UTC(year, 0, 1);
+  const diff = timestamp - startOfYear;
+  const oneDay = 86400000;
+  return Math.floor(diff / oneDay) + 1;
 };
 var GET_QUARTER = (timestamp) => {
-  const month = new Date(timestamp).getMonth();
+  const month = new Date(timestamp).getUTCMonth();
   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 DIFFERENCE_IN_SECONDS = (ts1, ts2) => Math.floor(Math.abs(ts1 - ts2) / 1000);
+var DIFFERENCE_IN_MINUTES = (ts1, ts2) => Math.floor(Math.abs(ts1 - ts2) / (60 * 1000));
+var DIFFERENCE_IN_HOURS = (ts1, ts2) => Math.floor(Math.abs(ts1 - ts2) / (60 * 60 * 1000));
+var DIFFERENCE_IN_DAYS = (ts1, ts2) => Math.floor(Math.abs(ts1 - ts2) / (24 * 60 * 60 * 1000));
+var DIFFERENCE_IN_WEEKS = (ts1, ts2) => Math.floor(Math.abs(ts1 - ts2) / (7 * 24 * 60 * 60 * 1000));
+var DIFFERENCE_IN_MONTHS = (ts1, ts2) => {
+  const smaller = Math.min(ts1, ts2);
+  const larger = Math.max(ts1, ts2);
+  const date1 = new Date(smaller);
+  const date2 = new Date(larger);
+  const yearDiff = date2.getUTCFullYear() - date1.getUTCFullYear();
+  const monthDiff = date2.getUTCMonth() - date1.getUTCMonth();
+  let months = yearDiff * 12 + monthDiff;
+  if (date2.getUTCDate() < date1.getUTCDate()) {
+    months--;
+  }
+  return months;
+};
+var DIFFERENCE_IN_YEARS = (ts1, ts2) => {
+  return Math.floor(DIFFERENCE_IN_MONTHS(ts1, ts2) / 12);
+};
 var START_OF_DAY = (timestamp) => {
   const date = new Date(timestamp);
-  date.setHours(0, 0, 0, 0);
-  return date.getTime();
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 0, 0, 0, 0);
 };
 var END_OF_DAY = (timestamp) => {
   const date = new Date(timestamp);
-  date.setHours(23, 59, 59, 999);
-  return date.getTime();
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 23, 59, 59, 999);
 };
 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();
+  const dayOfWeek = date.getUTCDay();
+  const currentDay = date.getUTCDate();
+  const startDay = currentDay - dayOfWeek;
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), startDay, 0, 0, 0, 0);
 };
 var START_OF_MONTH = (timestamp) => {
   const date = new Date(timestamp);
-  date.setDate(1);
-  date.setHours(0, 0, 0, 0);
-  return date.getTime();
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1, 0, 0, 0, 0);
 };
 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();
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 0, 23, 59, 59, 999);
 };
 var START_OF_YEAR = (timestamp) => {
   const date = new Date(timestamp);
-  date.setMonth(0, 1);
-  date.setHours(0, 0, 0, 0);
-  return date.getTime();
+  return Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
 };
 var END_OF_YEAR = (timestamp) => {
   const date = new Date(timestamp);
-  date.setMonth(11, 31);
-  date.setHours(23, 59, 59, 999);
-  return date.getTime();
+  return Date.UTC(date.getUTCFullYear(), 11, 31, 23, 59, 59, 999);
 };
 var ADD_DAYS = (timestamp, days) => {
   const date = new Date(timestamp);
-  date.setDate(date.getDate() + days);
-  return date.getTime();
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() + days, date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds());
 };
 var ADD_MONTHS = (timestamp, months) => {
   const date = new Date(timestamp);
-  date.setMonth(date.getMonth() + months);
-  return date.getTime();
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + months, date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds());
 };
 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;
+  return Date.UTC(date.getUTCFullYear() + years, date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds());
 };
 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;
+  return date1.getUTCFullYear() === date2.getUTCFullYear() && date1.getUTCMonth() === date2.getUTCMonth() && date1.getUTCDate() === date2.getUTCDate() ? 1 : 0;
 };
 var IS_WEEKEND = (timestamp) => {
-  const day = new Date(timestamp).getDay();
+  const day = new Date(timestamp).getUTCDay();
   return day === 0 || day === 6 ? 1 : 0;
 };
 var IS_LEAP_YEAR = (timestamp) => {
-  const year = new Date(timestamp).getFullYear();
+  const year = new Date(timestamp).getUTCFullYear();
   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();
+  const month = date.getUTCMonth();
+  const quarterStartMonth = Math.floor(month / 3) * 3;
+  return Date.UTC(date.getUTCFullYear(), quarterStartMonth, 1, 0, 0, 0, 0);
 };
-var TO_UNIX_SECONDS = (timestamp) => Math.floor(timestamp / 1000);
-var FROM_UNIX_SECONDS = (seconds) => seconds * 1000;
 // src/defaults.ts
 var defaultContext = {
   functions: {
@@ -553,6 +573,9 @@ var defaultContext = {
     LOG: Math.log,
     LOG10: Math.log10,
     EXP: Math.exp,
+    CLAMP: (value, min, max) => {
+      return value < min ? min : value > max ? max : value;
+    },
     ...exports_date_utils
   }
 };
@@ -1058,6 +1081,7 @@ export {
   isBinaryOp,
   isAssignment,
   generate,
+  extractInputVariables,
   execute,
   defaultContext,
   exports_date_utils as dateUtils,

package/package.json

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