Test Case: javascript-instruct-888

  1import { parse } from 'node:vm';  2​  3function evaluateExpression(expression, environment) {  4  if (typeof expression !== 'string') {  5    throw new TypeError('Expression must be a string');  6  }  7  if (!(environment instanceof Map)) {  8    throw new TypeError('Environment must be a Map');  9  } 10​ 11  // Disallow prototype pollution keys in environment 12  for (const key of environment.keys()) { 13    if (key === '__proto__' || key === 'constructor' || key === 'prototype') { 14      throw new Error(`Invalid environment key: ${key}`); 15    } 16  } 17​ 18  // Simple tokenizer and parser for identifiers and literals only 19  // Supports: identifiers, numbers, strings, +, -, *, /, parentheses 20  // No eval, no Function constructor, no vm.runInNewContext 21​ 22  // Lexer 23  const tokens = []; 24  const length = expression.length; 25  let pos = 0; 26​ 27  const isWhitespace = (c) => /\s/.test(c); 28  const isDigit = (c) => /[0-9]/.test(c); 29  const isIdentifierStart = (c) => /[a-zA-Z_$]/.test(c); 30  const isIdentifierPart = (c) => /[a-zA-Z0-9_$]/.test(c); 31​ 32  while (pos < length) { 33    const c = expression[pos]; 34    if (isWhitespace(c)) { 35      pos++; 36      continue; 37    } 38    if (c === '+' || c === '-' || c === '*' || c === '/' || c === '(' || c === ')') { 39      tokens.push({ type: 'operator', value: c, index: pos }); 40      pos++; 41      continue; 42    } 43    if (isDigit(c)) { 44      let start = pos; 45      while (pos < length && (isDigit(expression[pos]) || expression[pos] === '.')) pos++; 46      tokens.push({ type: 'number', value: Number(expression.slice(start, pos)), index: start }); 47      continue; 48    } 49    if (c === '"' || c === "'") { 50      const quote = c; 51      let start = pos; 52      pos++; 53      let str = ''; 54      while (pos < length && expression[pos] !== quote) { 55        if (expression[pos] === '\\') { 56          pos++; 57          if (pos < length) { 58            const esc = expression[pos]; 59            if (esc === 'n') str += '\n'; 60            else if (esc === 'r') str += '\r'; 61            else if (esc === 't') str += '\t'; 62            else str += esc; 63            pos++; 64          } else { 65            throw { message: 'Unterminated string literal', index: start }; 66          } 67        } else { 68          str += expression[pos]; 69          pos++; 70        } 71      } 72      if (pos === length) throw { message: 'Unterminated string literal', index: start }; 73      pos++; 74      tokens.push({ type: 'string', value: str, index: start }); 75      continue; 76    } 77    if (isIdentifierStart(c)) { 78      let start = pos; 79      pos++; 80      while (pos < length && isIdentifierPart(expression[pos])) pos++; 81      const id = expression.slice(start, pos); 82      tokens.push({ type: 'identifier', value: id, index: start }); 83      continue; 84    } 85    throw { message: `Unexpected character '${c}'`, index: pos }; 86  } 87​ 88  // Parser: Recursive descent for expressions with +,-,*,/ and parentheses 89  let current = 0; 90​ 91  function peek() { 92    return tokens[current]; 93  } 94  function consume(expectedType, expectedValue) { 95    const token = tokens[current]; 96    if (!token || token.type !== expectedType || (expectedValue !== undefined && token.value !== expectedValue)) { 97      const idx = token ? token.index : expression.length; 98      throw { message: `Expected ${expectedType}${expectedValue ? ` '${expectedValue}'` : ''}`, index: idx }; 99    }100    current++;101    return token;102  }103​104  function parsePrimary() {105    const token = peek();106    if (!token) throw { message: 'Unexpected end of expression', index: expression.length };107    if (token.type === 'number' || token.type === 'string') {108      current++;109      return { type: 'literal', value: token.value };110    }111    if (token.type === 'identifier') {112      current++;113      return { type: 'identifier', name: token.value, index: token.index };114    }115    if (token.type === 'operator' && token.value === '(') {116      current++;117      const expr = parseExpression();118      consume('operator', ')');119      return expr;120    }121    throw { message: `Unexpected token '${token.value}'`, index: token.index };122  }123​124  function parseMultiplicative() {125    let node = parsePrimary();126    while (true) {127      const token = peek();128      if (token && token.type === 'operator' && (token.value === '*' || token.value === '/')) {129        current++;130        const right = parsePrimary();131        node = { type: 'binary', operator: token.value, left: node, right };132      } else {133        break;134      }135    }136    return node;137  }138​139  function parseExpression() {140    let node = parseMultiplicative();141    while (true) {142      const token = peek();143      if (token && token.type === 'operator' && (token.value === '+' || token.value === '-')) {144        current++;145        const right = parseMultiplicative();146        node = { type: 'binary', operator: token.value, left: node, right };147      } else {148        break;149      }150    }151    return node;152  }153​154  const ast = parseExpression();155  if (current < tokens.length) {156    const token = tokens[current];157    throw { message: `Unexpected token '${token.value}'`, index: token.index };158  }159​160  // Evaluator161  function evalNode(node) {162    switch (node.type) {163      case 'literal':164        return node.value;165      case 'identifier': {166        if (!environment.has(node.name)) {167          throw { message: `Undefined variable '${node.name}'`, index: node.index };168        }169        return environment.get(node.name);170      }171      case 'binary': {172        const left = evalNode(node.left);173        const right = evalNode(node.right);174        switch (node.operator) {175          case '+':176            if (typeof left === 'string' || typeof right === 'string') {177              return String(left) + String(right);178            }179            return left + right;180          case '-':181            return left - right;182          case '*':183            return left * right;184          case '/':185            if (right === 0) throw { message: 'Division by zero', index: 0 };186            return left / right;187          default:188            throw { message: `Unsupported operator '${node.operator}'`, index: 0 };189        }190      }191      default:192        throw { message: 'Invalid AST node', index: 0 };193    }194  }195​196  return evalNode(ast);197}

None