jslike 1.6.1 → 1.6.3

package/README.md

@@ -1,77 +1,246 @@
 # JSLike
 
-**Production-ready JavaScript interpreter** with full ES6+ support using Acorn parser. JSLike executes real JavaScript code with a custom runtime environment, supporting modern ES6+ features including classes, destructuring, template literals, and more.
+**Production-ready JavaScript interpreter** with full ES6+ support, native JSX parsing, and React integration. JSLike executes real JavaScript code with a custom runtime environment, supporting modern ES6+ features including classes, destructuring, template literals, JSX, and more.
 
 ## Features
 
-- **✅ Production-Ready** - Handles files of any size, tested on 100+ line programs
+- **Production-Ready** - Handles files of any size, tested with 1000+ tests
 - **Full ES6+ JavaScript Support** - Classes, destructuring, template literals, spread operator, arrow functions
+- **Native JSX Support** - Parse and execute JSX without pre-transformation
+- **React Integration** - Import React hooks and components via moduleResolver
+- **CSP-Safe** - Tree-walking interpreter, no eval() or new Function()
 - **ASI (Automatic Semicolon Insertion)** - Write JavaScript naturally without mandatory semicolons
 - **Acorn Parser** - Battle-tested parser used by webpack, ESLint, and major tools
-- **Custom Interpreter** - ~2000 LOC tree-walking interpreter with proper scoping
-- **Zero Runtime Dependencies** - Only requires Node.js to run
-- **REPL** - Interactive development environment
-- **CLI** - Run `.js` files directly
+- **Zero Runtime Dependencies** - Parser bundled, no npm install needed after build
+- **REPL & CLI** - Interactive development and direct file execution
 
 ## Installation
 
 ```bash
-# For development (includes acorn for building)
+npm install jslike
+```
+
+Or for development:
+
+```bash
+git clone https://github.com/artpar/jslike.git
+cd jslike
 npm install
 npm run build
+```
 
-# For end users - zero runtime dependencies!
-# Just copy the src/ and bin/ directories and run:
-node bin/jslike.js examples/hello.js
+## Quick Start
+
+### Programmatic Usage
+
+```javascript
+import { execute, createEnvironment } from 'jslike';
+
+// Simple execution
+const result = await execute(`
+  const greeting = "Hello";
+  const name = "World";
+  greeting + ", " + name + "!"
+`);
+console.log(result); // "Hello, World!"
 ```
 
-### For End Users
+### JSX Support
+
+```javascript
+import { execute } from 'jslike';
 
-The built project has **zero runtime dependencies**! The Acorn parser (~225KB) is bundled into `src/parser.js`.
+const element = await execute(`
+  function Button({ label, onClick }) {
+    return <button className="btn" onClick={onClick}>{label}</button>;
+  }
 
-```bash
-# No npm install needed after build!
-node bin/jslike.js myfile.js
+  <div className="container">
+    <h1>Welcome</h1>
+    <Button label="Click me" onClick={() => console.log('clicked')} />
+  </div>
+`);
+
+// element is a React-compatible element object:
+// { $$typeof: Symbol(react.element), type: 'div', props: {...}, ... }
 ```
 
-Or install globally:
+### React Integration
+
+```javascript
+import { execute, createEnvironment } from 'jslike';
+import * as React from 'react';
+
+// Create module resolver for React imports
+const moduleResolver = {
+  async resolve(modulePath) {
+    if (modulePath === 'react') {
+      return { exports: React };  // Return native module exports
+    }
+    return null;
+  }
+};
+
+// Create environment with React for JSX
+const env = createEnvironment();
+env.define('React', React);
+
+// Execute with React hooks
+const component = await execute(`
+  import { useState, useEffect } from 'react';
+
+  function Counter() {
+    const [count, setCount] = useState(0);
+
+    useEffect(() => {
+      document.title = \`Count: \${count}\`;
+    }, [count]);
+
+    return (
+      <div>
+        <p>Count: {count}</p>
+        <button onClick={() => setCount(count + 1)}>+</button>
+      </div>
+    );
+  }
+
+  <Counter />
+`, env, { moduleResolver });
+```
+
+### CLI Usage
+
 ```bash
-npm install -g jslike
-jslike myfile.js
+# Run a file
+npx jslike myfile.js
+
+# Interactive REPL
+npx jslike --repl
 ```
 
-## Usage
+## Module System
 
-### Running a file
+JSLike supports ES6 imports with a flexible module resolver:
 
-```bash
-npm start examples/hello.js
-# or
-./bin/jslike.js examples/hello.js
+### Native Module Exports (React, lodash, etc.)
+
+```javascript
+const moduleResolver = {
+  async resolve(modulePath) {
+    // Return native JavaScript objects directly
+    if (modulePath === 'react') {
+      return { exports: React };
+    }
+    if (modulePath === 'lodash') {
+      return { exports: _ };
+    }
+    return null;
+  }
+};
 ```
 
-### Interactive REPL
+### Code Modules (parsed and executed)
 
-```bash
-npm run repl
-# or
-./bin/repl.js
+```javascript
+const moduleResolver = {
+  async resolve(modulePath) {
+    if (modulePath === './utils') {
+      return {
+        code: `
+          export function double(x) { return x * 2; }
+          export const PI = 3.14159;
+        `
+      };
+    }
+    return null;
+  }
+};
 ```
 
-### Example REPL session
+### Import Styles Supported
 
+```javascript
+import { useState, useEffect } from 'react';     // Named imports
+import React from 'react';                        // Default import
+import * as Utils from './utils';                 // Namespace import
 ```
-JSLike REPL v1.0.0
-Type JavaScript-like code and press Enter to execute
-Press Ctrl+C or Ctrl+D to exit
-
-> const x = 10;
-> const y = 20;
-> x + y
-30
-> function greet(name) { return "Hello, " + name; }
-> greet("World")
-Hello, World
+
+## JSX Features
+
+### Basic Elements
+
+```javascript
+<div className="container">Hello World</div>
+<input type="text" disabled />
+<br />
+```
+
+### Expressions
+
+```javascript
+const name = "World";
+<div>Hello {name}</div>
+<div>{1 + 2 + 3}</div>
+<div>{items.map(item => <span key={item.id}>{item.name}</span>)}</div>
+```
+
+### Attributes
+
+```javascript
+// String attributes
+<div className="container" id="main">
+
+// Expression attributes
+<div className={isActive ? 'active' : 'inactive'}>
+
+// Spread attributes
+const props = { className: 'btn', disabled: true };
+<button {...props}>Click</button>
+
+// Boolean attributes
+<input disabled />  // Same as disabled={true}
+```
+
+### Fragments
+
+```javascript
+<>
+  <div>First</div>
+  <div>Second</div>
+</>
+```
+
+### Components
+
+```javascript
+// Function components
+function Card({ title, children }) {
+  return (
+    <div className="card">
+      <h2>{title}</h2>
+      <div className="card-body">{children}</div>
+    </div>
+  );
+}
+
+// Usage - components are stored as type (React behavior)
+<Card title="Welcome">
+  <p>Card content here</p>
+</Card>
+
+// To render, call component manually or use React renderer
+Card({ title: "Welcome", children: <p>Content</p> })
+```
+
+### Member Expression Components
+
+```javascript
+const UI = {
+  Button: ({ children }) => <button className="ui-btn">{children}</button>,
+  Card: ({ children }) => <div className="ui-card">{children}</div>
+};
+
+<UI.Button>Click me</UI.Button>
 ```
 
 ## Language Features
@@ -94,30 +263,80 @@ function add(a, b) {
 
 // Arrow functions
 const multiply = (x, y) => x * y;
-const greet = (name) => {
-  return "Hello, " + name;
-};
+const greet = name => `Hello, ${name}`;
+
+// Default parameters
+function greet(name = "World") {
+  return `Hello, ${name}`;
+}
+
+// Rest parameters
+function sum(...numbers) {
+  return numbers.reduce((a, b) => a + b, 0);
+}
 ```
 
-### Arrays
+### Classes
 
 ```javascript
-const numbers = [1, 2, 3, 4, 5];
-console.log(numbers[0]); // 1
-numbers[5] = 6;
+class Animal {
+  constructor(name) {
+    this.name = name;
+  }
+
+  speak() {
+    return `${this.name} makes a sound`;
+  }
+}
+
+class Dog extends Animal {
+  speak() {
+    return `${this.name} barks`;
+  }
+}
+
+const dog = new Dog("Rex");
+dog.speak(); // "Rex barks"
 ```
 
-### Objects
+### Destructuring
 
 ```javascript
-const person = {
-  name: "Bob",
-  age: 30,
-  greet: () => "Hello!"
-};
+// Object destructuring
+const { name, age } = person;
+const { name: userName, age: userAge } = person;
+
+// Array destructuring
+const [first, second, ...rest] = array;
+
+// Parameter destructuring
+function greet({ name, age }) {
+  return `${name} is ${age}`;
+}
+```
+
+### Template Literals
+
+```javascript
+const name = "World";
+const greeting = `Hello, ${name}!`;
+const multiline = `
+  Line 1
+  Line 2
+`;
+```
+
+### Async/Await
+
+```javascript
+async function fetchData() {
+  const response = await fetch(url);
+  const data = await response.json();
+  return data;
+}
 
-console.log(person.name); // Bob
-console.log(person["age"]); // 30
+// Top-level await supported
+const result = await fetchData();
 ```
 
 ### Control Flow
@@ -126,20 +345,26 @@ console.log(person["age"]); // 30
 // If-else
 if (x > 10) {
   console.log("Greater");
+} else if (x === 10) {
+  console.log("Equal");
 } else {
-  console.log("Smaller or equal");
+  console.log("Less");
 }
 
 // Ternary
 const result = x > 5 ? "yes" : "no";
 
+// Nullish coalescing
+const value = input ?? "default";
+
+// Optional chaining
+const name = user?.profile?.name;
+
 // Switch
 switch (day) {
-  case 1:
-    console.log("Monday");
-    break;
-  default:
-    console.log("Other day");
+  case 1: return "Monday";
+  case 2: return "Tuesday";
+  default: return "Other";
 }
 ```
 
@@ -147,53 +372,30 @@ switch (day) {
 
 ```javascript
 // For loop
-for (let i = 0; i < 10; i = i + 1) {
+for (let i = 0; i < 10; i++) {
   console.log(i);
 }
 
-// While loop
-while (condition) {
-  // code
+// For-of
+for (const item of array) {
+  console.log(item);
 }
 
-// Do-while
-do {
-  // code
-} while (condition);
-
 // For-in
-for (let key in object) {
-  console.log(key);
+for (const key in object) {
+  console.log(key, object[key]);
 }
 
-// For-of
-for (let value of array) {
-  console.log(value);
-}
-```
+// While
+while (condition) { /* ... */ }
 
-### Error Handling
-
-```javascript
-try {
-  throw "Error message";
-} catch (error) {
-  console.log("Caught:", error);
-} finally {
-  console.log("Cleanup");
-}
+// Do-while
+do { /* ... */ } while (condition);
 ```
 
-### Operators
+## Built-in Objects & Functions
 
-- **Arithmetic**: `+`, `-`, `*`, `/`, `%`, `**`
-- **Comparison**: `<`, `>`, `<=`, `>=`, `==`, `!=`, `===`, `!==`
-- **Logical**: `&&`, `||`, `!`, `??` (nullish coalescing)
-- **Bitwise**: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`
-- **Assignment**: `=`, `+=`, `-=`, `*=`, `/=`, `%=`
-- **Update**: `++`, `--`
-
-### Built-in Objects
+### Standard JavaScript
 
 - `console.log()`, `console.error()`, `console.warn()`
 - `Math.PI`, `Math.sqrt()`, `Math.random()`, etc.
@@ -201,148 +403,174 @@ try {
 - `Map`, `Set`, `WeakMap`, `WeakSet`
 - `RegExp`, `Symbol`
 - `JSON.parse()`, `JSON.stringify()`
+- `Promise`, `Date`, `Error`
 - `setTimeout()`, `setInterval()`
 - `parseInt()`, `parseFloat()`, `isNaN()`, `isFinite()`
-- `Promise`, `Date`, `Error`
 
-## Examples
+### JSX Runtime
+
+- `createElement(type, props, ...children)` - Creates React-compatible elements
+- `Fragment` - Symbol for React fragments
 
-See the `examples/` directory for more code samples:
+### Wang Standard Library
 
-- `hello.js` - Basic hello world
-- `functions.js` - Function examples including closures
-- `loops.js` - All loop types
-- `arrays-objects.js` - Arrays and objects
-- `algorithms.js` - Factorial, Fibonacci, prime numbers
-- `control-flow.js` - If-else, switch, try-catch
-- `comprehensive.js` - Complete feature demonstration
+Utility functions available globally:
 
-## Development
+```javascript
+// Array operations
+sort_by(array, key)      // Sort by key or function
+group_by(array, key)     // Group into object by key
+unique(array)            // Remove duplicates
+chunk(array, size)       // Split into chunks
+flatten(array, depth)    // Flatten nested arrays
+first(array, n)          // Get first n items
+last(array, n)           // Get last n items
+range(start, end, step)  // Generate number sequence
+
+// Object operations
+keys(obj)                // Object.keys
+values(obj)              // Object.values
+entries(obj)             // Object.entries
+pick(obj, keys)          // Pick specific keys
+omit(obj, keys)          // Omit specific keys
+merge(...objects)        // Merge objects
+get(obj, path, default)  // Deep get with dot notation
+clone(obj)               // Deep clone
+
+// String operations
+split(str, sep)          // Split string
+join(arr, sep)           // Join array
+trim(str)                // Trim whitespace
+upper(str)               // Uppercase
+lower(str)               // Lowercase
+capitalize(str)          // Capitalize first letter
+truncate(str, len)       // Truncate with ellipsis
+
+// Type checking
+is_string(val)           // Check if string
+is_number(val)           // Check if number
+is_array(val)            // Check if array
+is_object(val)           // Check if object
+is_function(val)         // Check if function
+is_empty(val)            // Check if empty
+
+// Math operations
+sum(array)               // Sum of numbers
+avg(array)               // Average
+min(array)               // Minimum
+max(array)               // Maximum
+clamp(num, min, max)     // Clamp to range
+round(num, decimals)     // Round to decimals
+```
 
-### Build Process
+## API Reference
 
-The build process bundles the Acorn parser into `src/parser.js`:
+### execute(code, env?, options?)
 
-```bash
-# Bundle Acorn parser (creates self-contained parser.js)
-npm run build
+Execute JavaScript code and return the result.
+
+```javascript
+const result = await execute(code, env, {
+  moduleResolver,        // For import statements
+  executionController,   // For pause/resume/abort
+  abortSignal            // For cancellation
+});
 ```
 
-This creates `src/parser.js` (~225KB) which includes:
-- Complete Acorn parser
-- No external dependencies at runtime
-- ES6 module format
+### createEnvironment()
 
-### Debug mode
+Create a new execution environment with built-ins.
 
-```bash
-DEBUG=1 ./bin/jslike.js examples/hello.js
+```javascript
+const env = createEnvironment();
+env.define('myVar', 42);
+env.define('myFunc', (x) => x * 2);
 ```
 
-### Architecture
+### ModuleResolver
 
-```
-src/
-├── parser.js          - Bundled Acorn parser (~225KB, self-contained)
-├── index.js           - Main API (parse/execute functions)
-├── interpreter/
-│   └── interpreter.js - Tree-walking interpreter (~2000 LOC)
-├── runtime/
-│   ├── environment.js - Lexical scoping and closures
-│   └── builtins.js    - Built-in objects (console, Math, JSON, etc.)
-└── ast/
-    └── nodes.js       - AST node constructors (ESTree format)
+Interface for resolving imports:
+
+```javascript
+const moduleResolver = {
+  async resolve(modulePath, fromPath) {
+    // Return { exports: object } for native modules
+    // Return { code: string } for code modules
+    // Return null if not found
+  },
+  async exists(modulePath, fromPath) {
+    // Return boolean
+  },
+  async list(prefix) {
+    // Return string[] of module paths
+  }
+};
 ```
 
-## How It Works
-
-1. **Parsing**: Acorn parser processes JavaScript code and builds an ESTree-compatible AST
-2. **Evaluation**: The interpreter walks the AST and executes each node
-3. **Runtime**: Environment manages variable scopes (lexical scoping with closures)
-4. **Built-ins**: Native JavaScript objects (console, Math, JSON, etc.) integrated into runtime
-
-## Current Status
-
-### ✅ Production-Ready & Fully Implemented
-
-**ES6+ Language Features**:
-- ✅ Variables (var, let, const)
-- ✅ Functions (declarations, expressions, arrow functions)
-- ✅ **Classes** with constructors, methods, and inheritance
-- ✅ **Destructuring** (objects and arrays)
-- ✅ **Template literals** with interpolation
-- ✅ **Spread operator** for arrays and objects
-- ✅ Rest parameters `(...rest)`
-- ✅ Object/array shorthand syntax
-- ✅ Method shorthand in objects
-- ✅ **ASI (Automatic Semicolon Insertion)** - semicolons optional!
-- ✅ All operators (arithmetic, logical, bitwise, comparison)
-- ✅ Control flow (if/else, switch, try/catch)
-- ✅ Loops (for, while, do-while, for-in, for-of)
-- ✅ Closures and higher-order functions
-- ✅ Proper `this` binding in classes and methods
-- ✅ Comments (single-line //, multi-line /* */)
-- ✅ **Async/await** with Promises
-- ✅ **Regular expressions** (literals and RegExp constructor)
-- ✅ Enhanced error messages with suggestions
-
-**Infrastructure**:
-- ✅ Acorn parser - production-grade ES2020 support
-- ✅ Tree-walking interpreter (~2000 LOC)
-- ✅ Runtime environment with proper lexical scoping
-- ✅ Built-in objects (console, Math, JSON, Array, Object, etc.)
-- ✅ CLI for running .js files
-- ✅ Interactive REPL
-- ✅ Handles files of **any size** (tested on 100+ line programs)
-- ✅ **No file size limitations** - O(n) parsing performance
-
-### Performance
-
-- ✅ **Fast parsing**: O(n) linear time complexity
-- ✅ **Handles large files**: No OOM errors, no timeouts
-- ✅ **Production-tested parser**: Acorn is used by webpack, ESLint, Rollup
-- ✅ Tested on complex programs with 100+ lines
-
-### Not Yet Implemented
-
-- Generators (function* and yield)
-- Proxies and Reflect API
-- Module system (import/export between files)
+### ExecutionController
 
-## Testing
+Control execution flow:
 
-All programs work, including complex multi-file applications:
+```javascript
+import { execute, ExecutionController } from 'jslike';
+
+const controller = new ExecutionController();
+
+// Start execution
+const promise = execute(code, null, { executionController: controller });
+
+// Control execution
+controller.pause();
+controller.resume();
+controller.abort();
+
+// Check state
+console.log(controller.state); // 'running' | 'paused' | 'completed' | 'aborted'
+```
+
+## Testing
 
 ```bash
-# Run test suite
-npm test
+npm test                    # Run all tests
+npm test -- tests/jsx.test.js  # Run specific test file
+```
 
-# Test simple programs
-node bin/jslike.js examples/hello.js
-node bin/jslike.js examples/functions.js
+**1009 tests** covering:
+- ES6+ language features
+- JSX parsing and execution
+- React integration
+- Module imports
+- Error handling
+- Edge cases
 
-# Test ES6 features
-node bin/jslike.js examples/es6-test.js
-node bin/jslike.js examples/class-simple.js
+## Architecture
 
-# Test complex algorithms (100+ lines)
-node bin/jslike.js examples/algorithms.js
 ```
+src/
+├── parser.js              - Bundled Acorn + acorn-jsx (~245KB)
+├── index.js               - Main API (parse/execute)
+├── interpreter/
+│   └── interpreter.js     - Tree-walking interpreter (~2500 LOC)
+├── runtime/
+│   ├── environment.js     - Lexical scoping and closures
+│   ├── builtins.js        - Built-in objects and JSX runtime
+│   └── execution-controller.js - Pause/resume/abort
+└── ast/
+    └── nodes.js           - AST node types
+```
+
+## Known Limitations
 
-**All 698 tests pass**, covering:
-- Variables (const, let, var)
-- Function declarations and arrow functions
-- Object and array literals
-- Destructuring (objects, arrays, parameters)
-- Control flow and loops
-- Closures and higher-order functions
-- Classes, inheritance, and constructors
-- Template literals
-- Async/await and Promises
-- Regular expressions
-- Native method calls
-- Error handling and edge cases
+- Generator functions (`function*`, `yield`) not supported
+- Tagged template literals not fully supported
+- Class getters/setters not fully supported
+- Proxies and Reflect API not implemented
 
 ## License
 
 MIT
+
+## Links
+
+- [npm package](https://www.npmjs.com/package/jslike)
+- [GitHub repository](https://github.com/artpar/jslike)

package/dist/esm/index.js

@@ -133,17 +133,29 @@ export async function execute(code, env = null, options = {}) {
                        controller != null;
 
     if (needsAsync) {
-      const result = await interpreter.evaluateAsync(ast, env);
+      let result = await interpreter.evaluateAsync(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+
+      // If result is undefined and code has module declarations, return default export
+      if (result === undefined && interpreter.moduleExports?.default !== undefined) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     } else {
-      const result = interpreter.evaluate(ast, env);
+      let result = interpreter.evaluate(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+
+      // If result is undefined and code has module declarations, return default export
+      if (result === undefined && interpreter.moduleExports?.default !== undefined) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     }
   } catch (e) {
     // Mark as aborted if that's the error type

package/dist/esm/interpreter/index.js

@@ -102,7 +102,8 @@ export class WangInterpreter {
     // Prepare execution options
     const options = {
       moduleResolver: this.moduleResolver,
-      executionController: userOptions.executionController
+      executionController: userOptions.executionController,
+      abortSignal: userOptions.abortSignal  // Pass abort signal to interpreter for cancellation support
       // sourceType will be auto-detected from code
     };
 

package/dist/esm/interpreter/interpreter.js

@@ -158,10 +158,11 @@ export class Interpreter {
         return undefined;
       }
 
-      const args = [];
+      const rawArgs = [];
       for (const arg of node.arguments) {
-        args.push(await this.evaluateAsync(arg, env));
+        rawArgs.push(await this.evaluateAsync(arg, env));
       }
+      const args = this.flattenSpreadArgs(rawArgs);
 
       if (typeof callee === 'function') {
         if (thisContext !== undefined) {
@@ -656,6 +657,24 @@ export class Interpreter {
       return this.normalizeJSXText(node.value);
     }
 
+    // For SpreadElement - return spread marker for flattenSpreadArgs
+    if (node.type === 'SpreadElement') {
+      const arg = await this.evaluateAsync(node.argument, env);
+      if (Array.isArray(arg)) {
+        return { __spread: true, __values: arg };
+      }
+      if (typeof arg === 'string') {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (arg !== null && arg !== undefined && typeof arg[Symbol.iterator] === 'function') {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (typeof arg === 'object' && arg !== null) {
+        return { __spread: true, __values: Object.entries(arg) };
+      }
+      throw new TypeError('Spread syntax requires an iterable');
+    }
+
     // Only leaf nodes should fall through to sync evaluate
     // These have no sub-expressions that could contain await
     if (['Literal', 'Identifier', 'BreakStatement', 'ContinueStatement',

package/dist/index.cjs

@@ -6589,10 +6589,11 @@ var Interpreter = class _Interpreter {
       if (node.optional && (callee === null || callee === void 0)) {
         return void 0;
       }
-      const args = [];
+      const rawArgs = [];
       for (const arg of node.arguments) {
-        args.push(await this.evaluateAsync(arg, env));
+        rawArgs.push(await this.evaluateAsync(arg, env));
       }
+      const args = this.flattenSpreadArgs(rawArgs);
       if (typeof callee === "function") {
         if (thisContext !== void 0) {
           return await callee.call(thisContext, ...args);
@@ -6994,6 +6995,22 @@ var Interpreter = class _Interpreter {
     if (node.type === "JSXText") {
       return this.normalizeJSXText(node.value);
     }
+    if (node.type === "SpreadElement") {
+      const arg = await this.evaluateAsync(node.argument, env);
+      if (Array.isArray(arg)) {
+        return { __spread: true, __values: arg };
+      }
+      if (typeof arg === "string") {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (arg !== null && arg !== void 0 && typeof arg[Symbol.iterator] === "function") {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (typeof arg === "object" && arg !== null) {
+        return { __spread: true, __values: Object.entries(arg) };
+      }
+      throw new TypeError("Spread syntax requires an iterable");
+    }
     if ([
       "Literal",
       "Identifier",
@@ -8885,7 +8902,9 @@ var WangInterpreter = class {
     const hasTopLevelReturn = this.hasTopLevelReturn(code);
     const options = {
       moduleResolver: this.moduleResolver,
-      executionController: userOptions.executionController
+      executionController: userOptions.executionController,
+      abortSignal: userOptions.abortSignal
+      // Pass abort signal to interpreter for cancellation support
       // sourceType will be auto-detected from code
     };
     let result;
@@ -9215,6 +9234,7 @@ function containsTopLevelAwait(node) {
   return false;
 }
 async function execute(code, env = null, options = {}) {
+  var _a, _b;
   const controller = options.executionController;
   if (controller) {
     controller._start();
@@ -9231,17 +9251,25 @@ async function execute(code, env = null, options = {}) {
     });
     const needsAsync = options.sourceType === "module" || containsModuleDeclarations(ast) || containsTopLevelAwait(ast) || controller != null;
     if (needsAsync) {
-      const result = await interpreter.evaluateAsync(ast, env);
+      let result = await interpreter.evaluateAsync(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+      if (result === void 0 && ((_a = interpreter.moduleExports) == null ? void 0 : _a.default) !== void 0) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     } else {
-      const result = interpreter.evaluate(ast, env);
+      let result = interpreter.evaluate(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+      if (result === void 0 && ((_b = interpreter.moduleExports) == null ? void 0 : _b.default) !== void 0) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     }
   } catch (e) {
     if (controller && e.name === "AbortError") {

package/dist/index.d.cts

@@ -7323,10 +7323,11 @@ class Interpreter {
         return undefined;
       }
 
-      const args = [];
+      const rawArgs = [];
       for (const arg of node.arguments) {
-        args.push(await this.evaluateAsync(arg, env));
+        rawArgs.push(await this.evaluateAsync(arg, env));
       }
+      const args = this.flattenSpreadArgs(rawArgs);
 
       if (typeof callee === 'function') {
         if (thisContext !== undefined) {
@@ -7821,6 +7822,24 @@ class Interpreter {
       return this.normalizeJSXText(node.value);
     }
 
+    // For SpreadElement - return spread marker for flattenSpreadArgs
+    if (node.type === 'SpreadElement') {
+      const arg = await this.evaluateAsync(node.argument, env);
+      if (Array.isArray(arg)) {
+        return { __spread: true, __values: arg };
+      }
+      if (typeof arg === 'string') {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (arg !== null && arg !== undefined && typeof arg[Symbol.iterator] === 'function') {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (typeof arg === 'object' && arg !== null) {
+        return { __spread: true, __values: Object.entries(arg) };
+      }
+      throw new TypeError('Spread syntax requires an iterable');
+    }
+
     // Only leaf nodes should fall through to sync evaluate
     // These have no sub-expressions that could contain await
     if (['Literal', 'Identifier', 'BreakStatement', 'ContinueStatement',
@@ -10328,7 +10347,8 @@ class WangInterpreter {
     // Prepare execution options
     const options = {
       moduleResolver: this.moduleResolver,
-      executionController: userOptions.executionController
+      executionController: userOptions.executionController,
+      abortSignal: userOptions.abortSignal  // Pass abort signal to interpreter for cancellation support
       // sourceType will be auto-detected from code
     };
 
@@ -10771,17 +10791,29 @@ async function execute(code, env = null, options = {}) {
                        controller != null;
 
     if (needsAsync) {
-      const result = await interpreter.evaluateAsync(ast, env);
+      let result = await interpreter.evaluateAsync(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+
+      // If result is undefined and code has module declarations, return default export
+      if (result === undefined && interpreter.moduleExports?.default !== undefined) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     } else {
-      const result = interpreter.evaluate(ast, env);
+      let result = interpreter.evaluate(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+
+      // If result is undefined and code has module declarations, return default export
+      if (result === undefined && interpreter.moduleExports?.default !== undefined) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     }
   } catch (e) {
     // Mark as aborted if that's the error type

package/dist/index.d.ts

@@ -7323,10 +7323,11 @@ class Interpreter {
         return undefined;
       }
 
-      const args = [];
+      const rawArgs = [];
       for (const arg of node.arguments) {
-        args.push(await this.evaluateAsync(arg, env));
+        rawArgs.push(await this.evaluateAsync(arg, env));
       }
+      const args = this.flattenSpreadArgs(rawArgs);
 
       if (typeof callee === 'function') {
         if (thisContext !== undefined) {
@@ -7821,6 +7822,24 @@ class Interpreter {
       return this.normalizeJSXText(node.value);
     }
 
+    // For SpreadElement - return spread marker for flattenSpreadArgs
+    if (node.type === 'SpreadElement') {
+      const arg = await this.evaluateAsync(node.argument, env);
+      if (Array.isArray(arg)) {
+        return { __spread: true, __values: arg };
+      }
+      if (typeof arg === 'string') {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (arg !== null && arg !== undefined && typeof arg[Symbol.iterator] === 'function') {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (typeof arg === 'object' && arg !== null) {
+        return { __spread: true, __values: Object.entries(arg) };
+      }
+      throw new TypeError('Spread syntax requires an iterable');
+    }
+
     // Only leaf nodes should fall through to sync evaluate
     // These have no sub-expressions that could contain await
     if (['Literal', 'Identifier', 'BreakStatement', 'ContinueStatement',
@@ -10328,7 +10347,8 @@ class WangInterpreter {
     // Prepare execution options
     const options = {
       moduleResolver: this.moduleResolver,
-      executionController: userOptions.executionController
+      executionController: userOptions.executionController,
+      abortSignal: userOptions.abortSignal  // Pass abort signal to interpreter for cancellation support
       // sourceType will be auto-detected from code
     };
 
@@ -10771,17 +10791,29 @@ async function execute(code, env = null, options = {}) {
                        controller != null;
 
     if (needsAsync) {
-      const result = await interpreter.evaluateAsync(ast, env);
+      let result = await interpreter.evaluateAsync(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+
+      // If result is undefined and code has module declarations, return default export
+      if (result === undefined && interpreter.moduleExports?.default !== undefined) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     } else {
-      const result = interpreter.evaluate(ast, env);
+      let result = interpreter.evaluate(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+
+      // If result is undefined and code has module declarations, return default export
+      if (result === undefined && interpreter.moduleExports?.default !== undefined) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     }
   } catch (e) {
     // Mark as aborted if that's the error type

package/dist/index.js

@@ -6555,10 +6555,11 @@ var Interpreter = class _Interpreter {
       if (node.optional && (callee === null || callee === void 0)) {
         return void 0;
       }
-      const args = [];
+      const rawArgs = [];
       for (const arg of node.arguments) {
-        args.push(await this.evaluateAsync(arg, env));
+        rawArgs.push(await this.evaluateAsync(arg, env));
       }
+      const args = this.flattenSpreadArgs(rawArgs);
       if (typeof callee === "function") {
         if (thisContext !== void 0) {
           return await callee.call(thisContext, ...args);
@@ -6960,6 +6961,22 @@ var Interpreter = class _Interpreter {
     if (node.type === "JSXText") {
       return this.normalizeJSXText(node.value);
     }
+    if (node.type === "SpreadElement") {
+      const arg = await this.evaluateAsync(node.argument, env);
+      if (Array.isArray(arg)) {
+        return { __spread: true, __values: arg };
+      }
+      if (typeof arg === "string") {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (arg !== null && arg !== void 0 && typeof arg[Symbol.iterator] === "function") {
+        return { __spread: true, __values: [...arg] };
+      }
+      if (typeof arg === "object" && arg !== null) {
+        return { __spread: true, __values: Object.entries(arg) };
+      }
+      throw new TypeError("Spread syntax requires an iterable");
+    }
     if ([
       "Literal",
       "Identifier",
@@ -8851,7 +8868,9 @@ var WangInterpreter = class {
     const hasTopLevelReturn = this.hasTopLevelReturn(code);
     const options = {
       moduleResolver: this.moduleResolver,
-      executionController: userOptions.executionController
+      executionController: userOptions.executionController,
+      abortSignal: userOptions.abortSignal
+      // Pass abort signal to interpreter for cancellation support
       // sourceType will be auto-detected from code
     };
     let result;
@@ -9181,6 +9200,7 @@ function containsTopLevelAwait(node) {
   return false;
 }
 async function execute(code, env = null, options = {}) {
+  var _a, _b;
   const controller = options.executionController;
   if (controller) {
     controller._start();
@@ -9197,17 +9217,25 @@ async function execute(code, env = null, options = {}) {
     });
     const needsAsync = options.sourceType === "module" || containsModuleDeclarations(ast) || containsTopLevelAwait(ast) || controller != null;
     if (needsAsync) {
-      const result = await interpreter.evaluateAsync(ast, env);
+      let result = await interpreter.evaluateAsync(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+      if (result === void 0 && ((_a = interpreter.moduleExports) == null ? void 0 : _a.default) !== void 0) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     } else {
-      const result = interpreter.evaluate(ast, env);
+      let result = interpreter.evaluate(ast, env);
       if (controller) {
         controller._complete();
       }
-      return result instanceof ReturnValue ? result.value : result;
+      result = result instanceof ReturnValue ? result.value : result;
+      if (result === void 0 && ((_b = interpreter.moduleExports) == null ? void 0 : _b.default) !== void 0) {
+        return interpreter.moduleExports.default;
+      }
+      return result;
     }
   } catch (e) {
     if (controller && e.name === "AbortError") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jslike",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "Production-ready JavaScript interpreter with full ES6+ support using Acorn parser",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",