jslike 1.2.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jslike",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Production-ready JavaScript interpreter with full ES6+ support using Acorn parser",
   "main": "src/index.js",
   "type": "module",

package/src/cli/wang-validate.js

@@ -3,7 +3,7 @@
 import { readFile } from 'fs/promises';
 import { stdin } from 'process';
 import { parse } from 'acorn';
-import { preprocessCode, isTopLevelAwait } from '../index.js';
+import { isTopLevelAwait } from '../index.js';
 
 const args = process.argv.slice(2);
 
@@ -59,12 +59,11 @@ async function validate() {
       process.exit(1);
     }
 
-    // Preprocess the code
-    const processedCode = preprocessCode(code);
-    const hasAwait = isTopLevelAwait(processedCode);
+    // Check for top-level await
+    const hasAwait = isTopLevelAwait(code);
 
     // Parse the code to validate syntax
-    const ast = parse(processedCode, {
+    const ast = parse(code, {
       ecmaVersion: 'latest',
       sourceType: hasAwait ? 'module' : 'script',
       locations: true

package/src/index.js

@@ -23,212 +23,18 @@ function containsModuleSyntax(code) {
   return false;
 }
 
-// Pre-process code to fix common patterns that fail in strict mode
-function preprocessCode(code) {
-  // Pattern: object literal at statement level with commas
-  // Example: let arr = [1,2,3]\n{ first: first(arr), last: last(arr) }
-  // This fails to parse because labeled statements can't have commas
-  // We need to wrap it in parentheses to make it an expression: ({ ... })
-
-  const lines = code.split('\n');
-  const result = [];
-
-  for (let i = 0; i < lines.length; i++) {
-    let line = lines[i];
-    const trimmed = line.trim();
-
-    // Handle array literals and parenthesized expressions at statement level
-    // Add semicolon to previous line to prevent ASI issues
-    // Example: let x = 10\n[a, b] parses as: let x = 10[a, b] without semicolon
-    // Example: let x = 2\n({ y: 3 }) parses as: let x = 2({ y: 3 }) without semicolon
-    // But don't add if previous line ends with an operator (continuing expression)
-    // Note: We DON'T handle standalone `{` here because it's too ambiguous (could be a block)
-    if ((trimmed.startsWith('[') || trimmed.startsWith('(')) && result.length > 0) {
-      // Skip back over empty lines and comments to find the last real statement
-      let targetIdx = result.length - 1;
-      while (targetIdx >= 0) {
-        const checkLine = result[targetIdx].trim();
-        if (checkLine && !checkLine.startsWith('//') && !checkLine.startsWith('/*')) {
-          break;
-        }
-        targetIdx--;
-      }
-
-      if (targetIdx >= 0) {
-        const prevLine = result[targetIdx];
-        const prevTrimmed = prevLine.trim();
-        // Don't add semicolon if previous line ends with an operator, block opener, or already has semicolon
-        // But / at the end might be a regex literal, not division operator
-        const endsWithOperator = /[+\-*%&|^<>=!?:]$/.test(prevTrimmed);
-        // Check for regex literal at end: /pattern/flags
-        const endsWithRegex = /\/[gims]*$/.test(prevTrimmed);
-        // Don't add if previous line looks like a control statement (if, while, etc.)
-        const isControlStatement = /^\s*(if|else|for|while|do|try|catch|finally|switch|function|class)\b/.test(prevTrimmed);
-        if (prevTrimmed && !prevTrimmed.endsWith(';') && !prevTrimmed.endsWith('{') &&
-            !prevTrimmed.endsWith('(') && !prevTrimmed.endsWith(',') && !endsWithOperator && !isControlStatement) {
-          result[targetIdx] = prevLine + ';';
-        }
-      }
-    }
-
-    // Handle inline object literals at statement level: { key: value, key2: value2 }
-    // Pattern: line has {...} with comma and/or colon inside (object-like)
-    // This needs to be wrapped in parens to avoid being parsed as a block
-    const hasInlineBlock = trimmed.match(/^(.*?)\s*\{([^{}]+)\}\s*$/);
-    if (hasInlineBlock && !trimmed.match(/^\s*(if|else|for|while|do|try|catch|finally|switch|function|class)\b/)) {
-      const before = hasInlineBlock[1].trim();
-      const inside = hasInlineBlock[2];
-
-      // Check if inside looks like object literal (has comma and/or colon)
-      const hasComma = inside.includes(',');
-      const hasColon = inside.includes(':');
-
-      // If nothing before or just await/return, and inside has object-like syntax, wrap it
-      if ((!before || before.match(/^(await|return)$/)) && (hasComma || hasColon)) {
-        // Check if previous line indicates we're inside an array/object (don't wrap in that case)
-        if (result.length > 0) {
-          const prevLine = result[result.length - 1];
-          const prevTrimmed = prevLine.trim();
-          // Skip wrapping if inside array or object literal
-          if (prevTrimmed.endsWith(',') || prevTrimmed.endsWith('[') || prevTrimmed.endsWith('{')) {
-            result.push(line);
-            continue;
-          }
-        }
-
-        // Add semicolon to previous line to avoid ASI issues
-        // Skip back over empty lines and comments
-        if (result.length > 0) {
-          let targetIdx = result.length - 1;
-          while (targetIdx >= 0) {
-            const checkLine = result[targetIdx].trim();
-            if (checkLine && !checkLine.startsWith('//') && !checkLine.startsWith('/*')) {
-              break;
-            }
-            targetIdx--;
-          }
-
-          if (targetIdx >= 0) {
-            const prevLine = result[targetIdx];
-            const prevTrimmed = prevLine.trim();
-            if (prevTrimmed && !prevTrimmed.endsWith(';') && !prevTrimmed.endsWith('{')) {
-              result[targetIdx] = prevLine + ';';
-            }
-          }
-        }
-
-        // Wrap just the {...} part
-        const objPart = trimmed.substring(trimmed.indexOf('{'));
-        const prefix = trimmed.substring(0, trimmed.indexOf('{'));
-        line = prefix + '(' + objPart + ')';
-        result.push(line);
-        continue;
-      }
-    }
-
-    // Check if this line starts a block that looks like an object literal
-    // BUT: don't wrap if previous line is a function declaration
-    if (trimmed === '{' && i < lines.length - 1) {
-      // Check if previous line is a function declaration
-      if (result.length > 0) {
-        const prevTrimmed = result[result.length - 1].trim();
-        if (prevTrimmed.match(/^\s*(async\s+)?function\s*\w*\s*\([^)]*\)\s*$/) ||
-            prevTrimmed.match(/\)\s*=>\s*$/) ||
-            prevTrimmed.match(/\s+(if|else|for|while|do|try|catch|finally|switch)\s*\([^)]*\)\s*$/)) {
-          // This is a function/control structure body, not an object literal
-          result.push(line);
-          continue;
-        }
-      }
-
-      // Look ahead to see if block contains colons and commas (object literal pattern)
-      let blockLines = [line];
-      let j = i + 1;
-      let braceCount = 1;
-      let hasColon = false;
-      let hasComma = false;
-
-      // Collect the block
-      while (j < lines.length && braceCount > 0) {
-        const nextLine = lines[j];
-        blockLines.push(nextLine);
-
-        // Count braces (simple heuristic, not perfect but good enough)
-        for (const char of nextLine) {
-          if (char === '{') braceCount++;
-          if (char === '}') braceCount--;
-        }
-
-        // Check for object literal indicators
-        if (nextLine.includes(':')) hasColon = true;
-        if (nextLine.includes(',')) hasComma = true;
-
-        j++;
-        if (braceCount === 0) break;
-      }
-
-      // If block looks like object literal (has both : and ,), wrap in parens
-      if (hasColon && hasComma) {
-        // Check if previous line needs a semicolon to avoid ASI issues
-        // (wrapping in parens can cause previous expression to be treated as function call)
-        // Skip back over empty lines and comments to find the last real statement
-        if (result.length > 0) {
-          let targetIdx = result.length - 1;
-          while (targetIdx >= 0) {
-            const checkLine = result[targetIdx].trim();
-            if (checkLine && !checkLine.startsWith('//') && !checkLine.startsWith('/*')) {
-              // Found a non-empty, non-comment line
-              break;
-            }
-            targetIdx--;
-          }
-
-          if (targetIdx >= 0) {
-            const targetLine = result[targetIdx];
-            const targetTrimmed = targetLine.trim();
-            // Add semicolon if line doesn't end with one
-            // Note: Even if it ends with }, we need semicolon (could be object literal)
-            // Only skip if it ends with ; or { (block statement opener)
-            if (targetTrimmed && !targetTrimmed.endsWith(';') && !targetTrimmed.endsWith('{')) {
-              result[targetIdx] = targetLine + ';';
-            }
-          }
-        }
-
-        result.push('(' + blockLines[0]);
-        for (let k = 1; k < blockLines.length - 1; k++) {
-          result.push(blockLines[k]);
-        }
-        // Add closing paren after closing brace
-        const lastLine = blockLines[blockLines.length - 1];
-        result.push(lastLine.replace('}', '})'));
-
-        // Skip the lines we already processed
-        i = j - 1;
-        continue;
-      }
-    }
-
-    result.push(line);
-  }
-
-  return result.join('\n');
-}
 
 export function parse(code, options = {}) {
-  // Pre-process code to handle patterns that fail in strict mode
-  const processedCode = preprocessCode(code);
-
   // Determine sourceType: use 'module' ONLY if explicitly requested or if code has imports/exports
   // Default to 'script' for better compatibility with labeled statements
   let sourceType = options.sourceType || 'script';
-  if (!options.sourceType && containsModuleSyntax(processedCode)) {
+  if (!options.sourceType && containsModuleSyntax(code)) {
     sourceType = 'module';
   }
 
   // Parse with Acorn
   try {
-    return acornParse(processedCode, {
+    return acornParse(code, {
       ecmaVersion: 2022,  // Support ES2022 features (including top-level await)
       sourceType: sourceType,
       locations: true,     // Track source locations for better error messages
@@ -331,7 +137,6 @@ export function createEnvironment() {
 }
 
 // Export utility functions for CLI tools
-export { preprocessCode };
 export const isTopLevelAwait = containsModuleSyntax;
 
 export { Interpreter } from './interpreter/interpreter.js';

package/src/interpreter/interpreter.js

@@ -35,9 +35,10 @@ export class Interpreter {
 
     // For block statements, evaluate each statement async
     if (node.type === 'BlockStatement') {
+      const blockEnv = new Environment(env);
       let result = undefined;
       for (const statement of node.body) {
-        result = await this.evaluateAsync(statement, env);
+        result = await this.evaluateAsync(statement, blockEnv);
         if (result instanceof ReturnValue || result instanceof ThrowSignal ||
             result instanceof BreakSignal || result instanceof ContinueSignal) {
           return result;
@@ -254,8 +255,360 @@ export class Interpreter {
       return result;
     }
 
-    // For everything else, delegate to sync evaluate
-    return this.evaluate(node, env);
+    // For ForStatement with async body
+    if (node.type === 'ForStatement') {
+      const forEnv = new Environment(env);
+      if (node.init) {
+        await this.evaluateAsync(node.init, forEnv);
+      }
+      while (!node.test || await this.evaluateAsync(node.test, forEnv)) {
+        const result = await this.evaluateAsync(node.body, forEnv);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          if (node.update) {
+            await this.evaluateAsync(node.update, forEnv);
+          }
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+        if (node.update) {
+          await this.evaluateAsync(node.update, forEnv);
+        }
+      }
+      return undefined;
+    }
+
+    // For ForOfStatement with async body
+    if (node.type === 'ForOfStatement') {
+      const forEnv = new Environment(env);
+      const iterable = await this.evaluateAsync(node.right, forEnv);
+      const declarator = node.left.declarations[0];
+      const isConst = node.left.kind === 'const';
+
+      for (const value of iterable) {
+        const iterEnv = forEnv.extend();
+        if (declarator.id.type === 'Identifier') {
+          iterEnv.define(declarator.id.name, value, isConst);
+        } else if (declarator.id.type === 'ArrayPattern') {
+          this.bindArrayPattern(declarator.id, value, iterEnv, isConst);
+        } else if (declarator.id.type === 'ObjectPattern') {
+          this.bindObjectPattern(declarator.id, value, iterEnv, isConst);
+        }
+        const result = await this.evaluateAsync(node.body, iterEnv);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+      }
+      return undefined;
+    }
+
+    // For ForInStatement with async body
+    if (node.type === 'ForInStatement') {
+      const forEnv = new Environment(env);
+      const obj = await this.evaluateAsync(node.right, forEnv);
+      if (obj === null || obj === undefined) {
+        throw new TypeError(`Cannot use 'in' operator to iterate over ${obj}`);
+      }
+      const varName = node.left.declarations[0].id.name;
+      forEnv.define(varName, undefined);
+
+      for (const key in obj) {
+        forEnv.set(varName, key);
+        const result = await this.evaluateAsync(node.body, forEnv);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+      }
+      return undefined;
+    }
+
+    // For WhileStatement with async body
+    if (node.type === 'WhileStatement') {
+      while (await this.evaluateAsync(node.test, env)) {
+        const result = await this.evaluateAsync(node.body, env);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+      }
+      return undefined;
+    }
+
+    // For DoWhileStatement with async body
+    if (node.type === 'DoWhileStatement') {
+      do {
+        const result = await this.evaluateAsync(node.body, env);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+      } while (await this.evaluateAsync(node.test, env));
+      return undefined;
+    }
+
+    // For IfStatement with async branches
+    if (node.type === 'IfStatement') {
+      const test = await this.evaluateAsync(node.test, env);
+      if (test) {
+        return await this.evaluateAsync(node.consequent, env);
+      } else if (node.alternate) {
+        return await this.evaluateAsync(node.alternate, env);
+      }
+      return undefined;
+    }
+
+    // For SwitchStatement with async cases
+    if (node.type === 'SwitchStatement') {
+      const discriminant = await this.evaluateAsync(node.discriminant, env);
+      let matched = false;
+
+      for (const switchCase of node.cases) {
+        if (!matched && switchCase.test) {
+          const testValue = await this.evaluateAsync(switchCase.test, env);
+          if (testValue === discriminant) {
+            matched = true;
+          }
+        } else if (!switchCase.test) {
+          matched = true;
+        }
+
+        if (matched) {
+          for (const statement of switchCase.consequent) {
+            const result = await this.evaluateAsync(statement, env);
+            if (result instanceof BreakSignal) {
+              return undefined;
+            }
+            if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+              return result;
+            }
+          }
+        }
+      }
+      return undefined;
+    }
+
+    // For ConditionalExpression (ternary) with async operands
+    if (node.type === 'ConditionalExpression') {
+      const test = await this.evaluateAsync(node.test, env);
+      return test
+        ? await this.evaluateAsync(node.consequent, env)
+        : await this.evaluateAsync(node.alternate, env);
+    }
+
+    // For AssignmentExpression with async value
+    if (node.type === 'AssignmentExpression') {
+      const value = await this.evaluateAsync(node.right, env);
+
+      if (node.left.type === 'Identifier') {
+        const name = node.left.name;
+        if (node.operator === '=') {
+          if (env.has(name)) {
+            env.set(name, value);
+          } else {
+            env.define(name, value);
+          }
+          return value;
+        } else {
+          const current = env.get(name);
+          const newValue = this.applyCompoundAssignment(node.operator, current, value);
+          env.set(name, newValue);
+          return newValue;
+        }
+      } else if (node.left.type === 'MemberExpression') {
+        const obj = await this.evaluateAsync(node.left.object, env);
+        const prop = node.left.computed
+          ? await this.evaluateAsync(node.left.property, env)
+          : node.left.property.name;
+
+        if (node.operator === '=') {
+          obj[prop] = value;
+          return value;
+        } else {
+          const newValue = this.applyCompoundAssignment(node.operator, obj[prop], value);
+          obj[prop] = newValue;
+          return newValue;
+        }
+      }
+      throw new Error('Invalid assignment target');
+    }
+
+    // For UnaryExpression with async argument
+    if (node.type === 'UnaryExpression') {
+      if (node.operator === 'delete' && node.argument.type === 'MemberExpression') {
+        const obj = await this.evaluateAsync(node.argument.object, env);
+        const prop = node.argument.computed
+          ? await this.evaluateAsync(node.argument.property, env)
+          : node.argument.property.name;
+        return delete obj[prop];
+      }
+      const argument = await this.evaluateAsync(node.argument, env);
+      switch (node.operator) {
+        case '+': return +argument;
+        case '-': return -argument;
+        case '!': return !argument;
+        case '~': return ~argument;
+        case 'typeof':
+          if (argument && argument.__isFunction) {
+            return 'function';
+          }
+          return typeof argument;
+        case 'void': return undefined;
+        case 'delete': return true;
+        default:
+          throw new Error(`Unknown unary operator: ${node.operator}`);
+      }
+    }
+
+    // For UpdateExpression with async member access
+    if (node.type === 'UpdateExpression') {
+      if (node.argument.type === 'Identifier') {
+        const name = node.argument.name;
+        const current = env.get(name);
+        const numericCurrent = (current === null || current === undefined) ? 0 : Number(current);
+        const newValue = node.operator === '++' ? numericCurrent + 1 : numericCurrent - 1;
+        env.set(name, newValue);
+        return node.prefix ? newValue : numericCurrent;
+      } else if (node.argument.type === 'MemberExpression') {
+        const obj = await this.evaluateAsync(node.argument.object, env);
+        if (obj === null || obj === undefined) {
+          throw new TypeError(
+            `Cannot read properties of ${obj} (reading '${
+              node.argument.computed
+                ? await this.evaluateAsync(node.argument.property, env)
+                : node.argument.property.name
+            }')`
+          );
+        }
+        const prop = node.argument.computed
+          ? await this.evaluateAsync(node.argument.property, env)
+          : node.argument.property.name;
+        let current = obj[prop];
+        const numericCurrent = (current === null || current === undefined) ? 0 : Number(current);
+        const newValue = node.operator === '++' ? numericCurrent + 1 : numericCurrent - 1;
+        obj[prop] = newValue;
+        return node.prefix ? newValue : numericCurrent;
+      }
+      throw new Error('Invalid update expression target');
+    }
+
+    // For ArrayExpression with async elements
+    if (node.type === 'ArrayExpression') {
+      const result = [];
+      for (const elem of node.elements) {
+        if (!elem) {
+          result.push(undefined);
+        } else if (elem.type === 'SpreadElement') {
+          const spreadValue = await this.evaluateAsync(elem.argument, env);
+          if (Array.isArray(spreadValue)) {
+            result.push(...spreadValue);
+          } else if (typeof spreadValue[Symbol.iterator] === 'function') {
+            result.push(...spreadValue);
+          } else {
+            throw new TypeError('Spread syntax requires an iterable');
+          }
+        } else {
+          result.push(await this.evaluateAsync(elem, env));
+        }
+      }
+      return result;
+    }
+
+    // For ObjectExpression with async values
+    if (node.type === 'ObjectExpression') {
+      const obj = {};
+      for (const prop of node.properties) {
+        if (prop.type === 'SpreadElement') {
+          const spreadValue = await this.evaluateAsync(prop.argument, env);
+          if (typeof spreadValue === 'object' && spreadValue !== null) {
+            Object.assign(obj, spreadValue);
+          }
+        } else {
+          const key = prop.key.type === 'Identifier' && !prop.computed
+            ? prop.key.name
+            : await this.evaluateAsync(prop.key, env);
+          const value = prop.value ? await this.evaluateAsync(prop.value, env) : env.get(key);
+          if (prop.method && prop.value.type === 'FunctionExpression') {
+            obj[key] = (...args) => {
+              const funcValue = this.evaluate(prop.value, env);
+              return this.callUserFunction(funcValue, args, env);
+            };
+          } else {
+            obj[key] = value;
+          }
+        }
+      }
+      return obj;
+    }
+
+    // For SequenceExpression with async expressions
+    if (node.type === 'SequenceExpression') {
+      let result;
+      for (const expr of node.expressions) {
+        result = await this.evaluateAsync(expr, env);
+      }
+      return result;
+    }
+
+    // For ThrowStatement with async argument
+    if (node.type === 'ThrowStatement') {
+      return new ThrowSignal(await this.evaluateAsync(node.argument, env));
+    }
+
+    // For FunctionDeclaration - define in environment
+    if (node.type === 'FunctionDeclaration') {
+      return this.evaluateFunctionDeclaration(node, env);
+    }
+
+    // For FunctionExpression/ArrowFunctionExpression - create function
+    if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+      return this.evaluateFunctionExpression(node, env);
+    }
+
+    // For ClassDeclaration
+    if (node.type === 'ClassDeclaration') {
+      return this.evaluateClassDeclaration(node, env);
+    }
+
+    // For ClassExpression
+    if (node.type === 'ClassExpression') {
+      return this.evaluateClassExpression(node, env);
+    }
+
+    // Only leaf nodes should fall through to sync evaluate
+    // These have no sub-expressions that could contain await
+    if (['Literal', 'Identifier', 'BreakStatement', 'ContinueStatement',
+         'EmptyStatement', 'ThisExpression', 'Super'].includes(node.type)) {
+      return this.evaluate(node, env);
+    }
+
+    // Safety check - if we get here, we missed a node type
+    throw new Error(`Unhandled node type in evaluateAsync: ${node.type}`);
   }
 
   evaluate(node, env) {

package/src/validator/index.js

@@ -2,7 +2,7 @@
  * WangValidator - Syntax validation for Wang/JSLike code
  */
 
-import { parse, preprocessCode } from '../index.js';
+import { parse } from '../index.js';
 
 export class WangValidator {
   /**
@@ -14,11 +14,8 @@ export class WangValidator {
    */
   validate(code, options = {}) {
     try {
-      // Preprocess code (handles ASI, etc.)
-      const processed = preprocessCode(code);
-
       // Parse the code
-      const ast = parse(processed);
+      const ast = parse(code);
 
       return {
         valid: true,