jslike 1.6.2 → 1.7.0

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) {
@@ -218,6 +219,56 @@ export class Interpreter {
       return result;
     }
 
+    if (node.type === 'TaggedTemplateExpression') {
+      // 1. Evaluate tag function async (may contain awaits)
+      let thisContext = undefined;
+      let tagFunction;
+
+      if (node.tag.type === 'MemberExpression') {
+        thisContext = await this.evaluateAsync(node.tag.object, env);
+        const prop = node.tag.computed
+          ? await this.evaluateAsync(node.tag.property, env)
+          : node.tag.property.name;
+        tagFunction = thisContext[prop];
+      } else {
+        tagFunction = await this.evaluateAsync(node.tag, env);
+      }
+
+      // 2. Build strings array (synchronous - no awaits in quasis)
+      const strings = [];
+      const rawStrings = [];
+      for (const quasi of node.quasi.quasis) {
+        strings.push(quasi.value.cooked || quasi.value.raw);
+        rawStrings.push(quasi.value.raw);
+      }
+
+      Object.defineProperty(strings, 'raw', {
+        value: Object.freeze(rawStrings),
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+      Object.freeze(strings);
+
+      // 3. Evaluate expressions async (may contain awaits)
+      const values = [];
+      for (const expr of node.quasi.expressions) {
+        values.push(await this.evaluateAsync(expr, env));
+      }
+
+      // 4. Call tag function (may be async)
+      if (typeof tagFunction === 'function') {
+        if (thisContext !== undefined) {
+          return await tagFunction.call(thisContext, strings, ...values);
+        }
+        return await tagFunction(strings, ...values);
+      } else if (tagFunction && tagFunction.__isFunction) {
+        return await this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+      }
+
+      throw new TypeError('Tag must be a function');
+    }
+
     // For logical expressions with async operands (await support)
     if (node.type === 'LogicalExpression') {
       const left = await this.evaluateAsync(node.left, env);
@@ -656,6 +707,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',
@@ -803,6 +872,9 @@ export class Interpreter {
       case 'TemplateLiteral':
         return this.evaluateTemplateLiteral(node, env);
 
+      case 'TaggedTemplateExpression':
+        return this.evaluateTaggedTemplateExpression(node, env);
+
       case 'ClassDeclaration':
         return this.evaluateClassDeclaration(node, env);
 
@@ -2047,6 +2119,56 @@ export class Interpreter {
     return result;
   }
 
+  evaluateTaggedTemplateExpression(node, env) {
+    // 1. Evaluate the tag function, preserving 'this' context for member expressions
+    let thisContext = undefined;
+    let tagFunction;
+
+    if (node.tag.type === 'MemberExpression') {
+      // For method calls like obj.tag`...`, set this to obj
+      thisContext = this.evaluate(node.tag.object, env);
+      const prop = node.tag.computed
+        ? this.evaluate(node.tag.property, env)
+        : node.tag.property.name;
+      tagFunction = thisContext[prop];
+    } else {
+      tagFunction = this.evaluate(node.tag, env);
+    }
+
+    // 2. Build the strings array from quasis (cooked values)
+    const strings = [];
+    const rawStrings = [];
+    for (const quasi of node.quasi.quasis) {
+      strings.push(quasi.value.cooked || quasi.value.raw);
+      rawStrings.push(quasi.value.raw);
+    }
+
+    // 3. Add the raw property (frozen per ES6 spec)
+    Object.defineProperty(strings, 'raw', {
+      value: Object.freeze(rawStrings),
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    Object.freeze(strings);
+
+    // 4. Evaluate the embedded expressions
+    const values = node.quasi.expressions.map(expr => this.evaluate(expr, env));
+
+    // 5. Call the tag function with proper this context
+    if (typeof tagFunction === 'function') {
+      if (thisContext !== undefined) {
+        return tagFunction.call(thisContext, strings, ...values);
+      }
+      return tagFunction(strings, ...values);
+    } else if (tagFunction && tagFunction.__isFunction) {
+      // User-defined function
+      return this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+    }
+
+    throw new TypeError('Tag must be a function');
+  }
+
   evaluateClassDeclaration(node, env) {
     const className = node.id.name;
     const classFunc = this.createClass(node, env);

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);
@@ -6631,6 +6632,43 @@ var Interpreter = class _Interpreter {
       }
       return result;
     }
+    if (node.type === "TaggedTemplateExpression") {
+      let thisContext = void 0;
+      let tagFunction;
+      if (node.tag.type === "MemberExpression") {
+        thisContext = await this.evaluateAsync(node.tag.object, env);
+        const prop = node.tag.computed ? await this.evaluateAsync(node.tag.property, env) : node.tag.property.name;
+        tagFunction = thisContext[prop];
+      } else {
+        tagFunction = await this.evaluateAsync(node.tag, env);
+      }
+      const strings = [];
+      const rawStrings = [];
+      for (const quasi of node.quasi.quasis) {
+        strings.push(quasi.value.cooked || quasi.value.raw);
+        rawStrings.push(quasi.value.raw);
+      }
+      Object.defineProperty(strings, "raw", {
+        value: Object.freeze(rawStrings),
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+      Object.freeze(strings);
+      const values = [];
+      for (const expr of node.quasi.expressions) {
+        values.push(await this.evaluateAsync(expr, env));
+      }
+      if (typeof tagFunction === "function") {
+        if (thisContext !== void 0) {
+          return await tagFunction.call(thisContext, strings, ...values);
+        }
+        return await tagFunction(strings, ...values);
+      } else if (tagFunction && tagFunction.__isFunction) {
+        return await this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+      }
+      throw new TypeError("Tag must be a function");
+    }
     if (node.type === "LogicalExpression") {
       const left = await this.evaluateAsync(node.left, env);
       if (node.operator === "&&") {
@@ -6994,6 +7032,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",
@@ -7098,6 +7152,8 @@ var Interpreter = class _Interpreter {
       // ES6+ Features
       case "TemplateLiteral":
         return this.evaluateTemplateLiteral(node, env);
+      case "TaggedTemplateExpression":
+        return this.evaluateTaggedTemplateExpression(node, env);
       case "ClassDeclaration":
         return this.evaluateClassDeclaration(node, env);
       case "ClassExpression":
@@ -8041,6 +8097,40 @@ var Interpreter = class _Interpreter {
     }
     return result;
   }
+  evaluateTaggedTemplateExpression(node, env) {
+    let thisContext = void 0;
+    let tagFunction;
+    if (node.tag.type === "MemberExpression") {
+      thisContext = this.evaluate(node.tag.object, env);
+      const prop = node.tag.computed ? this.evaluate(node.tag.property, env) : node.tag.property.name;
+      tagFunction = thisContext[prop];
+    } else {
+      tagFunction = this.evaluate(node.tag, env);
+    }
+    const strings = [];
+    const rawStrings = [];
+    for (const quasi of node.quasi.quasis) {
+      strings.push(quasi.value.cooked || quasi.value.raw);
+      rawStrings.push(quasi.value.raw);
+    }
+    Object.defineProperty(strings, "raw", {
+      value: Object.freeze(rawStrings),
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    Object.freeze(strings);
+    const values = node.quasi.expressions.map((expr) => this.evaluate(expr, env));
+    if (typeof tagFunction === "function") {
+      if (thisContext !== void 0) {
+        return tagFunction.call(thisContext, strings, ...values);
+      }
+      return tagFunction(strings, ...values);
+    } else if (tagFunction && tagFunction.__isFunction) {
+      return this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+    }
+    throw new TypeError("Tag must be a function");
+  }
   evaluateClassDeclaration(node, env) {
     const className = node.id.name;
     const classFunc = this.createClass(node, env);
@@ -8885,7 +8975,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;

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) {
@@ -7383,6 +7384,56 @@ class Interpreter {
       return result;
     }
 
+    if (node.type === 'TaggedTemplateExpression') {
+      // 1. Evaluate tag function async (may contain awaits)
+      let thisContext = undefined;
+      let tagFunction;
+
+      if (node.tag.type === 'MemberExpression') {
+        thisContext = await this.evaluateAsync(node.tag.object, env);
+        const prop = node.tag.computed
+          ? await this.evaluateAsync(node.tag.property, env)
+          : node.tag.property.name;
+        tagFunction = thisContext[prop];
+      } else {
+        tagFunction = await this.evaluateAsync(node.tag, env);
+      }
+
+      // 2. Build strings array (synchronous - no awaits in quasis)
+      const strings = [];
+      const rawStrings = [];
+      for (const quasi of node.quasi.quasis) {
+        strings.push(quasi.value.cooked || quasi.value.raw);
+        rawStrings.push(quasi.value.raw);
+      }
+
+      Object.defineProperty(strings, 'raw', {
+        value: Object.freeze(rawStrings),
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+      Object.freeze(strings);
+
+      // 3. Evaluate expressions async (may contain awaits)
+      const values = [];
+      for (const expr of node.quasi.expressions) {
+        values.push(await this.evaluateAsync(expr, env));
+      }
+
+      // 4. Call tag function (may be async)
+      if (typeof tagFunction === 'function') {
+        if (thisContext !== undefined) {
+          return await tagFunction.call(thisContext, strings, ...values);
+        }
+        return await tagFunction(strings, ...values);
+      } else if (tagFunction && tagFunction.__isFunction) {
+        return await this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+      }
+
+      throw new TypeError('Tag must be a function');
+    }
+
     // For logical expressions with async operands (await support)
     if (node.type === 'LogicalExpression') {
       const left = await this.evaluateAsync(node.left, env);
@@ -7821,6 +7872,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',
@@ -7968,6 +8037,9 @@ class Interpreter {
       case 'TemplateLiteral':
         return this.evaluateTemplateLiteral(node, env);
 
+      case 'TaggedTemplateExpression':
+        return this.evaluateTaggedTemplateExpression(node, env);
+
       case 'ClassDeclaration':
         return this.evaluateClassDeclaration(node, env);
 
@@ -9212,6 +9284,56 @@ class Interpreter {
     return result;
   }
 
+  evaluateTaggedTemplateExpression(node, env) {
+    // 1. Evaluate the tag function, preserving 'this' context for member expressions
+    let thisContext = undefined;
+    let tagFunction;
+
+    if (node.tag.type === 'MemberExpression') {
+      // For method calls like obj.tag`...`, set this to obj
+      thisContext = this.evaluate(node.tag.object, env);
+      const prop = node.tag.computed
+        ? this.evaluate(node.tag.property, env)
+        : node.tag.property.name;
+      tagFunction = thisContext[prop];
+    } else {
+      tagFunction = this.evaluate(node.tag, env);
+    }
+
+    // 2. Build the strings array from quasis (cooked values)
+    const strings = [];
+    const rawStrings = [];
+    for (const quasi of node.quasi.quasis) {
+      strings.push(quasi.value.cooked || quasi.value.raw);
+      rawStrings.push(quasi.value.raw);
+    }
+
+    // 3. Add the raw property (frozen per ES6 spec)
+    Object.defineProperty(strings, 'raw', {
+      value: Object.freeze(rawStrings),
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    Object.freeze(strings);
+
+    // 4. Evaluate the embedded expressions
+    const values = node.quasi.expressions.map(expr => this.evaluate(expr, env));
+
+    // 5. Call the tag function with proper this context
+    if (typeof tagFunction === 'function') {
+      if (thisContext !== undefined) {
+        return tagFunction.call(thisContext, strings, ...values);
+      }
+      return tagFunction(strings, ...values);
+    } else if (tagFunction && tagFunction.__isFunction) {
+      // User-defined function
+      return this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+    }
+
+    throw new TypeError('Tag must be a function');
+  }
+
   evaluateClassDeclaration(node, env) {
     const className = node.id.name;
     const classFunc = this.createClass(node, env);
@@ -10328,7 +10450,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
     };
 

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) {
@@ -7383,6 +7384,56 @@ class Interpreter {
       return result;
     }
 
+    if (node.type === 'TaggedTemplateExpression') {
+      // 1. Evaluate tag function async (may contain awaits)
+      let thisContext = undefined;
+      let tagFunction;
+
+      if (node.tag.type === 'MemberExpression') {
+        thisContext = await this.evaluateAsync(node.tag.object, env);
+        const prop = node.tag.computed
+          ? await this.evaluateAsync(node.tag.property, env)
+          : node.tag.property.name;
+        tagFunction = thisContext[prop];
+      } else {
+        tagFunction = await this.evaluateAsync(node.tag, env);
+      }
+
+      // 2. Build strings array (synchronous - no awaits in quasis)
+      const strings = [];
+      const rawStrings = [];
+      for (const quasi of node.quasi.quasis) {
+        strings.push(quasi.value.cooked || quasi.value.raw);
+        rawStrings.push(quasi.value.raw);
+      }
+
+      Object.defineProperty(strings, 'raw', {
+        value: Object.freeze(rawStrings),
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+      Object.freeze(strings);
+
+      // 3. Evaluate expressions async (may contain awaits)
+      const values = [];
+      for (const expr of node.quasi.expressions) {
+        values.push(await this.evaluateAsync(expr, env));
+      }
+
+      // 4. Call tag function (may be async)
+      if (typeof tagFunction === 'function') {
+        if (thisContext !== undefined) {
+          return await tagFunction.call(thisContext, strings, ...values);
+        }
+        return await tagFunction(strings, ...values);
+      } else if (tagFunction && tagFunction.__isFunction) {
+        return await this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+      }
+
+      throw new TypeError('Tag must be a function');
+    }
+
     // For logical expressions with async operands (await support)
     if (node.type === 'LogicalExpression') {
       const left = await this.evaluateAsync(node.left, env);
@@ -7821,6 +7872,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',
@@ -7968,6 +8037,9 @@ class Interpreter {
       case 'TemplateLiteral':
         return this.evaluateTemplateLiteral(node, env);
 
+      case 'TaggedTemplateExpression':
+        return this.evaluateTaggedTemplateExpression(node, env);
+
       case 'ClassDeclaration':
         return this.evaluateClassDeclaration(node, env);
 
@@ -9212,6 +9284,56 @@ class Interpreter {
     return result;
   }
 
+  evaluateTaggedTemplateExpression(node, env) {
+    // 1. Evaluate the tag function, preserving 'this' context for member expressions
+    let thisContext = undefined;
+    let tagFunction;
+
+    if (node.tag.type === 'MemberExpression') {
+      // For method calls like obj.tag`...`, set this to obj
+      thisContext = this.evaluate(node.tag.object, env);
+      const prop = node.tag.computed
+        ? this.evaluate(node.tag.property, env)
+        : node.tag.property.name;
+      tagFunction = thisContext[prop];
+    } else {
+      tagFunction = this.evaluate(node.tag, env);
+    }
+
+    // 2. Build the strings array from quasis (cooked values)
+    const strings = [];
+    const rawStrings = [];
+    for (const quasi of node.quasi.quasis) {
+      strings.push(quasi.value.cooked || quasi.value.raw);
+      rawStrings.push(quasi.value.raw);
+    }
+
+    // 3. Add the raw property (frozen per ES6 spec)
+    Object.defineProperty(strings, 'raw', {
+      value: Object.freeze(rawStrings),
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    Object.freeze(strings);
+
+    // 4. Evaluate the embedded expressions
+    const values = node.quasi.expressions.map(expr => this.evaluate(expr, env));
+
+    // 5. Call the tag function with proper this context
+    if (typeof tagFunction === 'function') {
+      if (thisContext !== undefined) {
+        return tagFunction.call(thisContext, strings, ...values);
+      }
+      return tagFunction(strings, ...values);
+    } else if (tagFunction && tagFunction.__isFunction) {
+      // User-defined function
+      return this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+    }
+
+    throw new TypeError('Tag must be a function');
+  }
+
   evaluateClassDeclaration(node, env) {
     const className = node.id.name;
     const classFunc = this.createClass(node, env);
@@ -10328,7 +10450,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
     };
 

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);
@@ -6597,6 +6598,43 @@ var Interpreter = class _Interpreter {
       }
       return result;
     }
+    if (node.type === "TaggedTemplateExpression") {
+      let thisContext = void 0;
+      let tagFunction;
+      if (node.tag.type === "MemberExpression") {
+        thisContext = await this.evaluateAsync(node.tag.object, env);
+        const prop = node.tag.computed ? await this.evaluateAsync(node.tag.property, env) : node.tag.property.name;
+        tagFunction = thisContext[prop];
+      } else {
+        tagFunction = await this.evaluateAsync(node.tag, env);
+      }
+      const strings = [];
+      const rawStrings = [];
+      for (const quasi of node.quasi.quasis) {
+        strings.push(quasi.value.cooked || quasi.value.raw);
+        rawStrings.push(quasi.value.raw);
+      }
+      Object.defineProperty(strings, "raw", {
+        value: Object.freeze(rawStrings),
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+      Object.freeze(strings);
+      const values = [];
+      for (const expr of node.quasi.expressions) {
+        values.push(await this.evaluateAsync(expr, env));
+      }
+      if (typeof tagFunction === "function") {
+        if (thisContext !== void 0) {
+          return await tagFunction.call(thisContext, strings, ...values);
+        }
+        return await tagFunction(strings, ...values);
+      } else if (tagFunction && tagFunction.__isFunction) {
+        return await this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+      }
+      throw new TypeError("Tag must be a function");
+    }
     if (node.type === "LogicalExpression") {
       const left = await this.evaluateAsync(node.left, env);
       if (node.operator === "&&") {
@@ -6960,6 +6998,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",
@@ -7064,6 +7118,8 @@ var Interpreter = class _Interpreter {
       // ES6+ Features
       case "TemplateLiteral":
         return this.evaluateTemplateLiteral(node, env);
+      case "TaggedTemplateExpression":
+        return this.evaluateTaggedTemplateExpression(node, env);
       case "ClassDeclaration":
         return this.evaluateClassDeclaration(node, env);
       case "ClassExpression":
@@ -8007,6 +8063,40 @@ var Interpreter = class _Interpreter {
     }
     return result;
   }
+  evaluateTaggedTemplateExpression(node, env) {
+    let thisContext = void 0;
+    let tagFunction;
+    if (node.tag.type === "MemberExpression") {
+      thisContext = this.evaluate(node.tag.object, env);
+      const prop = node.tag.computed ? this.evaluate(node.tag.property, env) : node.tag.property.name;
+      tagFunction = thisContext[prop];
+    } else {
+      tagFunction = this.evaluate(node.tag, env);
+    }
+    const strings = [];
+    const rawStrings = [];
+    for (const quasi of node.quasi.quasis) {
+      strings.push(quasi.value.cooked || quasi.value.raw);
+      rawStrings.push(quasi.value.raw);
+    }
+    Object.defineProperty(strings, "raw", {
+      value: Object.freeze(rawStrings),
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    Object.freeze(strings);
+    const values = node.quasi.expressions.map((expr) => this.evaluate(expr, env));
+    if (typeof tagFunction === "function") {
+      if (thisContext !== void 0) {
+        return tagFunction.call(thisContext, strings, ...values);
+      }
+      return tagFunction(strings, ...values);
+    } else if (tagFunction && tagFunction.__isFunction) {
+      return this.callUserFunction(tagFunction, [strings, ...values], env, thisContext);
+    }
+    throw new TypeError("Tag must be a function");
+  }
   evaluateClassDeclaration(node, env) {
     const className = node.id.name;
     const classFunc = this.createClass(node, env);
@@ -8851,7 +8941,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;

package/package.json

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