jslike 1.1.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jslike",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "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

@@ -1,7 +1,7 @@
 // Use bundled Acorn parser for zero runtime dependencies
 import { parse as acornParse } from './parser.js';
 import { Interpreter } from './interpreter/interpreter.js';
-import { Environment } from './runtime/environment.js';
+import { Environment, ReturnValue } from './runtime/environment.js';
 import { createGlobalEnvironment } from './runtime/builtins.js';
 
 // Helper to detect if code contains module syntax or top-level await
@@ -23,215 +23,22 @@ 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: false     // Don't track source locations (faster)
+      locations: true,     // Track source locations for better error messages
+      allowReturnOutsideFunction: true  // Allow top-level return statements
     });
   } catch (error) {
     // Reformat error message for consistency
@@ -318,10 +125,10 @@ export async function execute(code, env = null, options = {}) {
 
   if (needsAsync) {
     const result = await interpreter.evaluateAsync(ast, userEnv);
-    return result;
+    return result instanceof ReturnValue ? result.value : result;
   } else {
     const result = interpreter.evaluate(ast, userEnv);
-    return result;
+    return result instanceof ReturnValue ? result.value : result;
   }
 }
 
@@ -330,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

@@ -75,6 +75,10 @@ export class Interpreter {
       let result = undefined;
       for (const statement of node.body) {
         result = await this.evaluateAsync(statement, env);
+        // Handle top-level return and throw
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
       }
       return result;
     }

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,