littlewing 0.1.0

package/dist/index.js

@@ -0,0 +1,673 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/ast.ts
+var exports_ast = {};
+__export(exports_ast, {
+  unaryOp: () => unaryOp,
+  subtract: () => subtract,
+  number: () => number,
+  negate: () => negate,
+  multiply: () => multiply,
+  modulo: () => modulo,
+  identifier: () => identifier,
+  functionCall: () => functionCall,
+  exponentiate: () => exponentiate,
+  divide: () => divide,
+  binaryOp: () => binaryOp,
+  assign: () => assign,
+  add: () => add
+});
+function number(value) {
+  return {
+    type: "NumberLiteral",
+    value
+  };
+}
+function identifier(name) {
+  return {
+    type: "Identifier",
+    name
+  };
+}
+function binaryOp(left, operator, right) {
+  return {
+    type: "BinaryOp",
+    left,
+    operator,
+    right
+  };
+}
+function unaryOp(argument) {
+  return {
+    type: "UnaryOp",
+    operator: "-",
+    argument
+  };
+}
+function functionCall(name, args = []) {
+  return {
+    type: "FunctionCall",
+    name,
+    arguments: args
+  };
+}
+function assign(name, value) {
+  return {
+    type: "Assignment",
+    name,
+    value
+  };
+}
+function add(left, right) {
+  return binaryOp(left, "+", right);
+}
+function subtract(left, right) {
+  return binaryOp(left, "-", right);
+}
+function multiply(left, right) {
+  return binaryOp(left, "*", right);
+}
+function divide(left, right) {
+  return binaryOp(left, "/", right);
+}
+function modulo(left, right) {
+  return binaryOp(left, "%", right);
+}
+function exponentiate(left, right) {
+  return binaryOp(left, "^", right);
+}
+function negate(argument) {
+  return unaryOp(argument);
+}
+// 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: () => new Date,
+    date: (...args) => new Date(...args),
+    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
+  }
+};
+// 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;
+  position = 0;
+  constructor(source) {
+    this.source = source;
+  }
+  tokenize() {
+    const tokens = [];
+    while (true) {
+      const token = this.nextToken();
+      tokens.push(token);
+      if (token.type === "EOF" /* EOF */) {
+        break;
+      }
+    }
+    return tokens;
+  }
+  nextToken() {
+    this.skipWhitespaceAndComments();
+    if (this.position >= this.source.length) {
+      return { type: "EOF" /* EOF */, value: "", position: this.position };
+    }
+    const char = this.getCharAt(this.position);
+    const start = this.position;
+    if (this.isDigit(char)) {
+      return this.readNumber();
+    }
+    if (char === "'") {
+      return this.readString();
+    }
+    if (this.isLetter(char) || char === "_") {
+      return this.readIdentifier();
+    }
+    switch (char) {
+      case "+":
+        this.position++;
+        return { type: "PLUS" /* PLUS */, value: "+", position: start };
+      case "-":
+        this.position++;
+        return { type: "MINUS" /* MINUS */, value: "-", position: start };
+      case "*":
+        this.position++;
+        return { type: "STAR" /* STAR */, value: "*", position: start };
+      case "/":
+        this.position++;
+        return { type: "SLASH" /* SLASH */, value: "/", position: start };
+      case "%":
+        this.position++;
+        return { type: "PERCENT" /* PERCENT */, value: "%", position: start };
+      case "^":
+        this.position++;
+        return { type: "CARET" /* CARET */, value: "^", position: start };
+      case "(":
+        this.position++;
+        return { type: "LPAREN" /* LPAREN */, value: "(", position: start };
+      case ")":
+        this.position++;
+        return { type: "RPAREN" /* RPAREN */, value: ")", position: start };
+      case "=":
+        this.position++;
+        return { type: "EQUALS" /* EQUALS */, value: "=", position: start };
+      case ",":
+        this.position++;
+        return { type: "COMMA" /* COMMA */, value: ",", position: start };
+      case ";":
+        this.position++;
+        return this.nextToken();
+      default:
+        throw new Error(`Unexpected character '${char}' at position ${start}`);
+    }
+  }
+  skipWhitespaceAndComments() {
+    while (this.position < this.source.length) {
+      const char = this.getCharAt(this.position);
+      if (this.isWhitespace(char)) {
+        this.position++;
+        continue;
+      }
+      if (char === "/" && this.peek() === "/") {
+        while (this.position < this.source.length && this.getCharAt(this.position) !== `
+`) {
+          this.position++;
+        }
+        continue;
+      }
+      break;
+    }
+  }
+  readNumber() {
+    const start = this.position;
+    let hasDecimal = false;
+    while (this.position < this.source.length) {
+      const char = this.getCharAt(this.position);
+      if (this.isDigit(char)) {
+        this.position++;
+      } else if (char === "." && !hasDecimal) {
+        hasDecimal = true;
+        this.position++;
+      } else {
+        break;
+      }
+    }
+    const value = parseFloat(this.source.slice(start, this.position));
+    return { type: "NUMBER" /* NUMBER */, value, position: start };
+  }
+  readIdentifier() {
+    const start = this.position;
+    while (this.position < this.source.length) {
+      const char = this.getCharAt(this.position);
+      if (this.isLetter(char) || this.isDigit(char) || char === "_") {
+        this.position++;
+      } else {
+        break;
+      }
+    }
+    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] || "" : "";
+  }
+  peek() {
+    return this.getCharAt(this.position + 1);
+  }
+  isDigit(char) {
+    return char >= "0" && char <= "9";
+  }
+  isLetter(char) {
+    return char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+  }
+  isWhitespace(char) {
+    return char === " " || char === "\t" || char === `
+` || char === "\r";
+  }
+}
+
+// src/parser.ts
+class Parser {
+  tokens;
+  current = 0;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  parse() {
+    const statements = [];
+    while (this.peek().type !== "EOF" /* EOF */) {
+      statements.push(this.parseExpression(0));
+    }
+    if (statements.length === 0) {
+      throw new Error("Empty program");
+    }
+    if (statements.length === 1) {
+      const stmt = statements[0];
+      if (stmt === undefined) {
+        throw new Error("Unexpected undefined statement");
+      }
+      return stmt;
+    }
+    return {
+      type: "Program",
+      statements
+    };
+  }
+  parseExpression(minPrecedence) {
+    let left = this.parsePrefix();
+    while (true) {
+      const token = this.peek();
+      const precedence = this.getPrecedence(token.type);
+      if (precedence < minPrecedence) {
+        break;
+      }
+      if (token.type === "EQUALS" /* EQUALS */) {
+        if (left.type !== "Identifier") {
+          throw new Error("Invalid assignment target");
+        }
+        const identName = left.name;
+        this.advance();
+        const value = this.parseExpression(precedence + 1);
+        left = {
+          type: "Assignment",
+          name: identName,
+          value
+        };
+      } else if (this.isBinaryOperator(token.type)) {
+        const operator = token.value;
+        this.advance();
+        const right = this.parseExpression(precedence + 1);
+        left = {
+          type: "BinaryOp",
+          left,
+          operator,
+          right
+        };
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  parsePrefix() {
+    const token = this.peek();
+    if (token.type === "MINUS" /* MINUS */) {
+      this.advance();
+      const argument = this.parseExpression(this.getUnaryPrecedence());
+      return {
+        type: "UnaryOp",
+        operator: "-",
+        argument
+      };
+    }
+    if (token.type === "LPAREN" /* LPAREN */) {
+      this.advance();
+      const expr = this.parseExpression(0);
+      if (this.peek().type !== "RPAREN" /* RPAREN */) {
+        throw new Error("Expected closing parenthesis");
+      }
+      this.advance();
+      return expr;
+    }
+    if (token.type === "NUMBER" /* NUMBER */) {
+      this.advance();
+      return {
+        type: "NumberLiteral",
+        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();
+      if (this.peek().type === "LPAREN" /* LPAREN */) {
+        this.advance();
+        const args = this.parseFunctionArguments();
+        if (this.peek().type !== "RPAREN" /* RPAREN */) {
+          throw new Error("Expected closing parenthesis");
+        }
+        this.advance();
+        return {
+          type: "FunctionCall",
+          name,
+          arguments: args
+        };
+      }
+      return {
+        type: "Identifier",
+        name
+      };
+    }
+    throw new Error(`Unexpected token: ${token.value}`);
+  }
+  parseFunctionArguments() {
+    const args = [];
+    if (this.peek().type === "RPAREN" /* RPAREN */) {
+      return args;
+    }
+    args.push(this.parseExpression(0));
+    while (this.peek().type === "COMMA" /* COMMA */) {
+      this.advance();
+      args.push(this.parseExpression(0));
+    }
+    return args;
+  }
+  getPrecedence(type) {
+    switch (type) {
+      case "EQUALS" /* EQUALS */:
+        return 1;
+      case "PLUS" /* PLUS */:
+      case "MINUS" /* MINUS */:
+        return 2;
+      case "STAR" /* STAR */:
+      case "SLASH" /* SLASH */:
+      case "PERCENT" /* PERCENT */:
+        return 3;
+      case "CARET" /* CARET */:
+        return 4;
+      default:
+        return 0;
+    }
+  }
+  getUnaryPrecedence() {
+    return 5;
+  }
+  isBinaryOperator(type) {
+    return type === "PLUS" /* PLUS */ || type === "MINUS" /* MINUS */ || type === "STAR" /* STAR */ || type === "SLASH" /* SLASH */ || type === "PERCENT" /* PERCENT */ || type === "CARET" /* CARET */;
+  }
+  peek() {
+    if (this.current >= this.tokens.length) {
+      return { type: "EOF" /* EOF */, value: "", position: -1 };
+    }
+    const token = this.tokens[this.current];
+    if (token === undefined) {
+      return { type: "EOF" /* EOF */, value: "", position: -1 };
+    }
+    return token;
+  }
+  advance() {
+    this.current++;
+  }
+}
+function parseSource(source) {
+  const lexer = new Lexer(source);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  return parser.parse();
+}
+
+// src/executor.ts
+class Executor {
+  context;
+  variables;
+  constructor(context = {}) {
+    this.context = context;
+    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`);
+    }
+  }
+  executeProgram(node) {
+    let result;
+    for (const statement of node.statements) {
+      result = this.execute(statement);
+    }
+    return result;
+  }
+  executeNumberLiteral(node) {
+    return node.value;
+  }
+  executeStringLiteral(node) {
+    return node.value;
+  }
+  executeIdentifier(node) {
+    const value = this.variables.get(node.name);
+    if (value === undefined) {
+      throw new Error(`Undefined variable: ${node.name}`);
+    }
+    return value;
+  }
+  executeBinaryOp(node) {
+    const left = this.execute(node.left);
+    const right = this.execute(node.right);
+    switch (node.operator) {
+      case "+":
+        return this.add(left, right);
+      case "-":
+        return this.subtract(left, right);
+      case "*":
+        return this.multiply(left, right);
+      case "/":
+        return this.divide(left, right);
+      case "%":
+        return this.modulo(left, right);
+      case "^":
+        return this.exponentiate(left, right);
+      default:
+        throw new Error(`Unknown operator: ${node.operator}`);
+    }
+  }
+  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}`);
+    }
+    throw new Error(`Unknown unary operator: ${node.operator}`);
+  }
+  executeFunctionCall(node) {
+    const fn = this.context.functions?.[node.name];
+    if (fn === undefined) {
+      throw new Error(`Undefined function: ${node.name}`);
+    }
+    if (typeof fn !== "function") {
+      throw new Error(`${node.name} is not a function`);
+    }
+    const args = node.arguments.map((arg) => this.execute(arg));
+    return fn(...args);
+  }
+  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)}`);
+  }
+  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();
+    }
+    throw new Error(`Cannot subtract ${this.typeOf(right)} from ${this.typeOf(left)}`);
+  }
+  multiply(left, right) {
+    if (typeof left === "number" && typeof right === "number") {
+      return left * right;
+    }
+    throw new Error(`Cannot multiply ${this.typeOf(left)} and ${this.typeOf(right)}`);
+  }
+  divide(left, right) {
+    if (typeof left === "number" && typeof right === "number") {
+      if (right === 0) {
+        throw new Error("Division by zero");
+      }
+      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") {
+      if (right === 0) {
+        throw new Error("Division by zero");
+      }
+      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") {
+      return left ** right;
+    }
+    throw new Error(`Cannot exponentiate ${this.typeOf(left)} by ${this.typeOf(right)}`);
+  }
+  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,
+  execute,
+  defaultContext,
+  exports_ast as ast,
+  TokenType,
+  Parser,
+  Lexer,
+  Executor
+};