jslike 1.6.3 → 1.7.1

package/dist/esm/interpreter/interpreter.js

@@ -219,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);
@@ -822,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);
 
@@ -1255,8 +1308,14 @@ export class Interpreter {
     // Get function name for call stack tracking
     const funcName = metadata.name || func.name || 'anonymous';
 
-    // Bind 'this' if provided (for method calls)
-    if (thisContext !== undefined) {
+    // Bind 'this': for arrow functions use captured this (lexical), for regular functions use call-site this
+    if (metadata.isArrow) {
+      // Arrow functions use lexically captured 'this', ignoring call-site 'this'
+      if (metadata.capturedThis !== undefined) {
+        funcEnv.define('this', metadata.capturedThis);
+      }
+    } else if (thisContext !== undefined) {
+      // Regular functions use 'this' from the call site
       funcEnv.define('this', thisContext);
     }
 
@@ -1437,13 +1496,28 @@ export class Interpreter {
   }
 
   evaluateFunctionExpression(node, env) {
+    const isArrow = node.type === 'ArrowFunctionExpression';
+
+    // For arrow functions, capture 'this' lexically from the enclosing scope
+    let capturedThis;
+    if (isArrow) {
+      try {
+        capturedThis = env.get('this');
+      } catch (e) {
+        // 'this' not defined in enclosing scope, leave undefined
+        capturedThis = undefined;
+      }
+    }
+
     const funcMetadata = {
       __isFunction: true,
       params: node.params,
       body: node.body,
       closure: env,
-      expression: node.type === 'ArrowFunctionExpression' && node.expression,
-      async: node.async || false
+      expression: isArrow && node.expression,
+      async: node.async || false,
+      isArrow: isArrow,
+      capturedThis: isArrow ? capturedThis : undefined
     };
 
     // Wrap in actual JavaScript function so it can be called by native code
@@ -2066,6 +2140,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

@@ -6632,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 === "&&") {
@@ -7115,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":
@@ -7465,7 +7504,11 @@ var Interpreter = class _Interpreter {
     const metadata = func.__metadata || func;
     const funcEnv = new Environment(metadata.closure);
     const funcName = metadata.name || func.name || "anonymous";
-    if (thisContext !== void 0) {
+    if (metadata.isArrow) {
+      if (metadata.capturedThis !== void 0) {
+        funcEnv.define("this", metadata.capturedThis);
+      }
+    } else if (thisContext !== void 0) {
       funcEnv.define("this", thisContext);
     }
     for (let i = 0; i < metadata.params.length; i++) {
@@ -7600,13 +7643,24 @@ var Interpreter = class _Interpreter {
     return obj;
   }
   evaluateFunctionExpression(node, env) {
+    const isArrow = node.type === "ArrowFunctionExpression";
+    let capturedThis;
+    if (isArrow) {
+      try {
+        capturedThis = env.get("this");
+      } catch (e) {
+        capturedThis = void 0;
+      }
+    }
     const funcMetadata = {
       __isFunction: true,
       params: node.params,
       body: node.body,
       closure: env,
-      expression: node.type === "ArrowFunctionExpression" && node.expression,
-      async: node.async || false
+      expression: isArrow && node.expression,
+      async: node.async || false,
+      isArrow,
+      capturedThis: isArrow ? capturedThis : void 0
     };
     const interpreter = this;
     const wrappedFunc = funcMetadata.async ? async function(...args) {
@@ -8058,6 +8112,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);

package/dist/index.d.cts

@@ -7384,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);
@@ -7987,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);
 
@@ -8420,8 +8473,14 @@ class Interpreter {
     // Get function name for call stack tracking
     const funcName = metadata.name || func.name || 'anonymous';
 
-    // Bind 'this' if provided (for method calls)
-    if (thisContext !== undefined) {
+    // Bind 'this': for arrow functions use captured this (lexical), for regular functions use call-site this
+    if (metadata.isArrow) {
+      // Arrow functions use lexically captured 'this', ignoring call-site 'this'
+      if (metadata.capturedThis !== undefined) {
+        funcEnv.define('this', metadata.capturedThis);
+      }
+    } else if (thisContext !== undefined) {
+      // Regular functions use 'this' from the call site
       funcEnv.define('this', thisContext);
     }
 
@@ -8602,13 +8661,28 @@ class Interpreter {
   }
 
   evaluateFunctionExpression(node, env) {
+    const isArrow = node.type === 'ArrowFunctionExpression';
+
+    // For arrow functions, capture 'this' lexically from the enclosing scope
+    let capturedThis;
+    if (isArrow) {
+      try {
+        capturedThis = env.get('this');
+      } catch (e) {
+        // 'this' not defined in enclosing scope, leave undefined
+        capturedThis = undefined;
+      }
+    }
+
     const funcMetadata = {
       __isFunction: true,
       params: node.params,
       body: node.body,
       closure: env,
-      expression: node.type === 'ArrowFunctionExpression' && node.expression,
-      async: node.async || false
+      expression: isArrow && node.expression,
+      async: node.async || false,
+      isArrow: isArrow,
+      capturedThis: isArrow ? capturedThis : undefined
     };
 
     // Wrap in actual JavaScript function so it can be called by native code
@@ -9231,6 +9305,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);

package/dist/index.d.ts

@@ -7384,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);
@@ -7987,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);
 
@@ -8420,8 +8473,14 @@ class Interpreter {
     // Get function name for call stack tracking
     const funcName = metadata.name || func.name || 'anonymous';
 
-    // Bind 'this' if provided (for method calls)
-    if (thisContext !== undefined) {
+    // Bind 'this': for arrow functions use captured this (lexical), for regular functions use call-site this
+    if (metadata.isArrow) {
+      // Arrow functions use lexically captured 'this', ignoring call-site 'this'
+      if (metadata.capturedThis !== undefined) {
+        funcEnv.define('this', metadata.capturedThis);
+      }
+    } else if (thisContext !== undefined) {
+      // Regular functions use 'this' from the call site
       funcEnv.define('this', thisContext);
     }
 
@@ -8602,13 +8661,28 @@ class Interpreter {
   }
 
   evaluateFunctionExpression(node, env) {
+    const isArrow = node.type === 'ArrowFunctionExpression';
+
+    // For arrow functions, capture 'this' lexically from the enclosing scope
+    let capturedThis;
+    if (isArrow) {
+      try {
+        capturedThis = env.get('this');
+      } catch (e) {
+        // 'this' not defined in enclosing scope, leave undefined
+        capturedThis = undefined;
+      }
+    }
+
     const funcMetadata = {
       __isFunction: true,
       params: node.params,
       body: node.body,
       closure: env,
-      expression: node.type === 'ArrowFunctionExpression' && node.expression,
-      async: node.async || false
+      expression: isArrow && node.expression,
+      async: node.async || false,
+      isArrow: isArrow,
+      capturedThis: isArrow ? capturedThis : undefined
     };
 
     // Wrap in actual JavaScript function so it can be called by native code
@@ -9231,6 +9305,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);

package/dist/index.js

@@ -6598,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 === "&&") {
@@ -7081,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":
@@ -7431,7 +7470,11 @@ var Interpreter = class _Interpreter {
     const metadata = func.__metadata || func;
     const funcEnv = new Environment(metadata.closure);
     const funcName = metadata.name || func.name || "anonymous";
-    if (thisContext !== void 0) {
+    if (metadata.isArrow) {
+      if (metadata.capturedThis !== void 0) {
+        funcEnv.define("this", metadata.capturedThis);
+      }
+    } else if (thisContext !== void 0) {
       funcEnv.define("this", thisContext);
     }
     for (let i = 0; i < metadata.params.length; i++) {
@@ -7566,13 +7609,24 @@ var Interpreter = class _Interpreter {
     return obj;
   }
   evaluateFunctionExpression(node, env) {
+    const isArrow = node.type === "ArrowFunctionExpression";
+    let capturedThis;
+    if (isArrow) {
+      try {
+        capturedThis = env.get("this");
+      } catch (e) {
+        capturedThis = void 0;
+      }
+    }
     const funcMetadata = {
       __isFunction: true,
       params: node.params,
       body: node.body,
       closure: env,
-      expression: node.type === "ArrowFunctionExpression" && node.expression,
-      async: node.async || false
+      expression: isArrow && node.expression,
+      async: node.async || false,
+      isArrow,
+      capturedThis: isArrow ? capturedThis : void 0
     };
     const interpreter = this;
     const wrappedFunc = funcMetadata.async ? async function(...args) {
@@ -8024,6 +8078,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);

package/package.json

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