@tokens-studio/tokenscript-interpreter 0.33.0 → 0.34.0

package/dist/chunk-AXH5N7KV.js

@@ -0,0 +1,99 @@
+// src/types.ts
+var Operations = /* @__PURE__ */ ((Operations2) => {
+  Operations2["SUBTRACT"] = "-";
+  Operations2["ADD"] = "+";
+  Operations2["MULTIPLY"] = "*";
+  Operations2["DIVIDE"] = "/";
+  Operations2["POWER"] = "^";
+  Operations2["LOGIC_AND"] = "&&";
+  Operations2["LOGIC_OR"] = "||";
+  Operations2["LOGIC_NOT"] = "!";
+  return Operations2;
+})(Operations || {});
+var SupportedFormats = /* @__PURE__ */ ((SupportedFormats2) => {
+  SupportedFormats2["PX"] = "px";
+  SupportedFormats2["EM"] = "em";
+  SupportedFormats2["REM"] = "rem";
+  SupportedFormats2["VW"] = "vw";
+  SupportedFormats2["VH"] = "vh";
+  SupportedFormats2["PT"] = "pt";
+  SupportedFormats2["IN"] = "in";
+  SupportedFormats2["CM"] = "cm";
+  SupportedFormats2["MM"] = "mm";
+  SupportedFormats2["DEG"] = "deg";
+  SupportedFormats2["PERCENTAGE"] = "%";
+  SupportedFormats2["S"] = "s";
+  SupportedFormats2["MS"] = "ms";
+  return SupportedFormats2;
+})(SupportedFormats || {});
+var ReservedKeyword = /* @__PURE__ */ ((ReservedKeyword2) => {
+  ReservedKeyword2["TRUE"] = "true";
+  ReservedKeyword2["FALSE"] = "false";
+  ReservedKeyword2["NULL"] = "null";
+  ReservedKeyword2["UNDEFINED"] = "undefined";
+  ReservedKeyword2["WHILE"] = "while";
+  ReservedKeyword2["IF"] = "if";
+  ReservedKeyword2["ELSE"] = "else";
+  ReservedKeyword2["ELIF"] = "elif";
+  ReservedKeyword2["RETURN"] = "return";
+  ReservedKeyword2["VARIABLE"] = "variable";
+  ReservedKeyword2["FOR"] = "for";
+  return ReservedKeyword2;
+})(ReservedKeyword || {});
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2["REFERENCE"] = "REFERENCE";
+  TokenType2["NUMBER"] = "NUMBER";
+  TokenType2["OPERATION"] = "OPERATION";
+  TokenType2["FORMAT"] = "FORMAT";
+  TokenType2["LPAREN"] = "LPAREN";
+  TokenType2["RPAREN"] = "RPAREN";
+  TokenType2["EOF"] = "EOF";
+  TokenType2["COMMA"] = "COMMA";
+  TokenType2["HEX_COLOR"] = "HEX_COLOR";
+  TokenType2["STRING"] = "STRING";
+  TokenType2["EXPLICIT_STRING"] = "EXPLICIT_STRING";
+  TokenType2["TEMPLATE_STRING"] = "TEMPLATE_STRING";
+  TokenType2["ASSIGN"] = "ASSIGN";
+  TokenType2["IS_EQ"] = "IS_EQ";
+  TokenType2["IS_GT"] = "GT";
+  TokenType2["IS_LT"] = "LT";
+  TokenType2["IS_GT_EQ"] = "IS_GT_EQ";
+  TokenType2["IS_LT_EQ"] = "IS_LT_EQ";
+  TokenType2["IS_NOT_EQ"] = "IS_NOT_EQ";
+  TokenType2["RESERVED_KEYWORD"] = "RESERVED_KEYWORD";
+  TokenType2["SEMICOLON"] = "SEMICOLON";
+  TokenType2["LOGIC_NOT"] = "LOGIC_NOT";
+  TokenType2["COLON"] = "COLON";
+  TokenType2["DOT"] = "DOT";
+  TokenType2["LOGIC_AND"] = "LOGIC_AND";
+  TokenType2["LOGIC_OR"] = "LOGIC_OR";
+  TokenType2["LBLOCK"] = "LBLOCK";
+  TokenType2["RBLOCK"] = "RBLOCK";
+  TokenType2["PARTIAL_REFERENCE"] = "PARTIAL_REFERENCE";
+  TokenType2["PARTIAL_STRING"] = "PARTIAL_STRING";
+  return TokenType2;
+})(TokenType || {});
+var UNINTERPRETED_KEYWORDS = [
+  "inside",
+  "outside",
+  "above",
+  "below",
+  "left",
+  "right",
+  "top",
+  "bottom",
+  "before",
+  "after",
+  "between",
+  "uppercase",
+  "lowercase",
+  "underline",
+  "none",
+  "innerShadow",
+  "outerShadow",
+  "shadow"
+];
+
+export { Operations, ReservedKeyword, SupportedFormats, TokenType, UNINTERPRETED_KEYWORDS };
+//# sourceMappingURL=chunk-AXH5N7KV.js.map
+//# sourceMappingURL=chunk-AXH5N7KV.js.map

package/dist/chunk-AXH5N7KV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"names":["Operations","SupportedFormats","ReservedKeyword","TokenType"],"mappings":";AAEO,IAAK,UAAA,qBAAAA,WAAAA,KAAL;AACL,EAAAA,YAAA,UAAA,CAAA,GAAW,GAAA;AACX,EAAAA,YAAA,KAAA,CAAA,GAAM,GAAA;AACN,EAAAA,YAAA,UAAA,CAAA,GAAW,GAAA;AACX,EAAAA,YAAA,QAAA,CAAA,GAAS,GAAA;AACT,EAAAA,YAAA,OAAA,CAAA,GAAQ,GAAA;AACR,EAAAA,YAAA,WAAA,CAAA,GAAY,IAAA;AACZ,EAAAA,YAAA,UAAA,CAAA,GAAW,IAAA;AACX,EAAAA,YAAA,WAAA,CAAA,GAAY,GAAA;AARF,EAAA,OAAAA,WAAAA;AAAA,CAAA,EAAA,UAAA,IAAA,EAAA;AAWL,IAAK,gBAAA,qBAAAC,iBAAAA,KAAL;AACL,EAAAA,kBAAA,IAAA,CAAA,GAAK,IAAA;AACL,EAAAA,kBAAA,IAAA,CAAA,GAAK,IAAA;AACL,EAAAA,kBAAA,KAAA,CAAA,GAAM,KAAA;AACN,EAAAA,kBAAA,IAAA,CAAA,GAAK,IAAA;AACL,EAAAA,kBAAA,IAAA,CAAA,GAAK,IAAA;AACL,EAAAA,kBAAA,IAAA,CAAA,GAAK,IAAA;AACL,EAAAA,kBAAA,IAAA,CAAA,GAAK,IAAA;AACL,EAAAA,kBAAA,IAAA,CAAA,GAAK,IAAA;AACL,EAAAA,kBAAA,IAAA,CAAA,GAAK,IAAA;AACL,EAAAA,kBAAA,KAAA,CAAA,GAAM,KAAA;AACN,EAAAA,kBAAA,YAAA,CAAA,GAAa,GAAA;AAEb,EAAAA,kBAAA,GAAA,CAAA,GAAI,GAAA;AACJ,EAAAA,kBAAA,IAAA,CAAA,GAAK,IAAA;AAdK,EAAA,OAAAA,iBAAAA;AAAA,CAAA,EAAA,gBAAA,IAAA,EAAA;AAiBL,IAAK,eAAA,qBAAAC,gBAAAA,KAAL;AACL,EAAAA,iBAAA,MAAA,CAAA,GAAO,MAAA;AACP,EAAAA,iBAAA,OAAA,CAAA,GAAQ,OAAA;AACR,EAAAA,iBAAA,MAAA,CAAA,GAAO,MAAA;AACP,EAAAA,iBAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,iBAAA,OAAA,CAAA,GAAQ,OAAA;AACR,EAAAA,iBAAA,IAAA,CAAA,GAAK,IAAA;AACL,EAAAA,iBAAA,MAAA,CAAA,GAAO,MAAA;AACP,EAAAA,iBAAA,MAAA,CAAA,GAAO,MAAA;AACP,EAAAA,iBAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,iBAAA,UAAA,CAAA,GAAW,UAAA;AACX,EAAAA,iBAAA,KAAA,CAAA,GAAM,KAAA;AAXI,EAAA,OAAAA,gBAAAA;AAAA,CAAA,EAAA,eAAA,IAAA,EAAA;AAcL,IAAK,SAAA,qBAAAC,UAAAA,KAAL;AACL,EAAAA,WAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,WAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,WAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,WAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,WAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,WAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,WAAA,KAAA,CAAA,GAAM,KAAA;AACN,EAAAA,WAAA,OAAA,CAAA,GAAQ,OAAA;AACR,EAAAA,WAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,WAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,WAAA,iBAAA,CAAA,GAAkB,iBAAA;AAClB,EAAAA,WAAA,iBAAA,CAAA,GAAkB,iBAAA;AAClB,EAAAA,WAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,WAAA,OAAA,CAAA,GAAQ,OAAA;AACR,EAAAA,WAAA,OAAA,CAAA,GAAQ,IAAA;AACR,EAAAA,WAAA,OAAA,CAAA,GAAQ,IAAA;AACR,EAAAA,WAAA,UAAA,CAAA,GAAW,UAAA;AACX,EAAAA,WAAA,UAAA,CAAA,GAAW,UAAA;AACX,EAAAA,WAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,WAAA,kBAAA,CAAA,GAAmB,kBAAA;AACnB,EAAAA,WAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,WAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,WAAA,OAAA,CAAA,GAAQ,OAAA;AACR,EAAAA,WAAA,KAAA,CAAA,GAAM,KAAA;AACN,EAAAA,WAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,WAAA,UAAA,CAAA,GAAW,UAAA;AACX,EAAAA,WAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,WAAA,QAAA,CAAA,GAAS,QAAA;AAET,EAAAA,WAAA,mBAAA,CAAA,GAAoB,mBAAA;AACpB,EAAAA,WAAA,gBAAA,CAAA,GAAiB,gBAAA;AA/BP,EAAA,OAAAA,UAAAA;AAAA,CAAA,EAAA,SAAA,IAAA,EAAA;AAoFL,IAAM,sBAAA,GAAmC;AAAA,EAC9C,QAAA;AAAA,EACA,SAAA;AAAA,EACA,OAAA;AAAA,EACA,OAAA;AAAA,EACA,MAAA;AAAA,EACA,OAAA;AAAA,EACA,KAAA;AAAA,EACA,QAAA;AAAA,EACA,QAAA;AAAA,EACA,OAAA;AAAA,EACA,SAAA;AAAA,EACA,WAAA;AAAA,EACA,WAAA;AAAA,EACA,WAAA;AAAA,EACA,MAAA;AAAA,EACA,aAAA;AAAA,EACA,aAAA;AAAA,EACA;AACF","file":"chunk-AXH5N7KV.js","sourcesContent":["import type { Config } from \"@interpreter/config/config\";\n\nexport enum Operations {\n  SUBTRACT = \"-\",\n  ADD = \"+\",\n  MULTIPLY = \"*\",\n  DIVIDE = \"/\",\n  POWER = \"^\",\n  LOGIC_AND = \"&&\",\n  LOGIC_OR = \"||\",\n  LOGIC_NOT = \"!\",\n}\n\nexport enum SupportedFormats {\n  PX = \"px\",\n  EM = \"em\",\n  REM = \"rem\",\n  VW = \"vw\",\n  VH = \"vh\",\n  PT = \"pt\",\n  IN = \"in\",\n  CM = \"cm\",\n  MM = \"mm\",\n  DEG = \"deg\",\n  PERCENTAGE = \"%\",\n  // Time units\n  S = \"s\",\n  MS = \"ms\",\n}\n\nexport enum ReservedKeyword {\n  TRUE = \"true\",\n  FALSE = \"false\",\n  NULL = \"null\",\n  UNDEFINED = \"undefined\",\n  WHILE = \"while\",\n  IF = \"if\",\n  ELSE = \"else\",\n  ELIF = \"elif\",\n  RETURN = \"return\",\n  VARIABLE = \"variable\",\n  FOR = \"for\",\n}\n\nexport enum TokenType {\n  REFERENCE = \"REFERENCE\",\n  NUMBER = \"NUMBER\",\n  OPERATION = \"OPERATION\",\n  FORMAT = \"FORMAT\",\n  LPAREN = \"LPAREN\",\n  RPAREN = \"RPAREN\",\n  EOF = \"EOF\",\n  COMMA = \"COMMA\",\n  HEX_COLOR = \"HEX_COLOR\",\n  STRING = \"STRING\",\n  EXPLICIT_STRING = \"EXPLICIT_STRING\",\n  TEMPLATE_STRING = \"TEMPLATE_STRING\",\n  ASSIGN = \"ASSIGN\",\n  IS_EQ = \"IS_EQ\",\n  IS_GT = \"GT\",\n  IS_LT = \"LT\",\n  IS_GT_EQ = \"IS_GT_EQ\",\n  IS_LT_EQ = \"IS_LT_EQ\",\n  IS_NOT_EQ = \"IS_NOT_EQ\",\n  RESERVED_KEYWORD = \"RESERVED_KEYWORD\",\n  SEMICOLON = \"SEMICOLON\",\n  LOGIC_NOT = \"LOGIC_NOT\",\n  COLON = \"COLON\",\n  DOT = \"DOT\",\n  LOGIC_AND = \"LOGIC_AND\",\n  LOGIC_OR = \"LOGIC_OR\",\n  LBLOCK = \"LBLOCK\",\n  RBLOCK = \"RBLOCK\",\n  // Partial tokens for tolerant parsing\n  PARTIAL_REFERENCE = \"PARTIAL_REFERENCE\",\n  PARTIAL_STRING = \"PARTIAL_STRING\",\n}\n\nexport interface Token {\n  type: TokenType;\n  value: any;\n  line: number;\n  pos: number;\n  endPos: number;\n}\n\nexport interface ASTNode {\n  token?: Token;\n  nodeType: string;\n}\n\n/**\n * Metadata attached to a symbol that is preserved across cloning operations.\n * This data is not accessible to the tokenscript language itself and is intended\n * for external use (e.g., storing token IDs for tracing).\n */\nexport type SymbolMetadata = Record<string, unknown>;\n\nexport interface ISymbolType {\n  type: string;\n  value: any;\n\n  /**\n   * Optional metadata attached to this symbol.\n   * This is a reference that is preserved (not cloned) during deepCopy/cloneIfMutable operations.\n   * It is not accessible to the tokenscript language and is intended for external use.\n   */\n  metadata?: SymbolMetadata;\n\n  cloneIfMutable(): ISymbolType;\n  deepCopy(): ISymbolType;\n\n  typeEquals(other: ISymbolType): boolean;\n  equals(other: ISymbolType): boolean;\n  validValue(value: any): boolean;\n\n  toJSON?(): any;\n  toString(): string;\n  getTypeName(): string;\n  toJs(options?: { recursive?: boolean; stringify?: boolean }): any;\n\n  hasMethod?(methodName: string, args: ISymbolType[]): boolean;\n  callMethod?(methodName: string, args: ISymbolType[]): ISymbolType | null | undefined;\n  hasAttribute?(attributeName: string): boolean;\n  getAttribute?(attributeName: string): ISymbolType | null;\n  setAttribute?(attributeName: string, value: ISymbolType, config?: Config): void;\n}\n\nexport const UNINTERPRETED_KEYWORDS: string[] = [\n  \"inside\",\n  \"outside\",\n  \"above\",\n  \"below\",\n  \"left\",\n  \"right\",\n  \"top\",\n  \"bottom\",\n  \"before\",\n  \"after\",\n  \"between\",\n  \"uppercase\",\n  \"lowercase\",\n  \"underline\",\n  \"none\",\n  \"innerShadow\",\n  \"outerShadow\",\n  \"shadow\",\n];\n\nexport type ReferenceRecordValue = string | number | ISymbolType;\n\nexport type ReferenceRecord = Record<string, ReferenceRecordValue | Array<ReferenceRecordValue>>;\n"]}

package/dist/cli.js

@@ -12,7 +12,7 @@ import * as readlineSync from 'readline-sync';
 
 // package.json
 var package_default = {
-  version: "0.32.0"};
+  version: "0.33.0"};
 
 // src/types.ts
 var SupportedFormats = /* @__PURE__ */ ((SupportedFormats2) => {
@@ -151,6 +151,13 @@ var StringNode = class {
     this.value = token.value;
   }
 };
+var TemplateStringNode = class {
+  constructor(parts, token) {
+    this.parts = parts;
+    this.token = token;
+    this.nodeType = "TemplateStringNode";
+  }
+};
 var UnaryOpNode = class {
   constructor(opToken, expr, token) {
     this.opToken = opToken;
@@ -398,6 +405,10 @@ function walkAST(node, onVisit) {
     for (const statement of node.statements) {
       walkAST(statement, onVisit);
     }
+  } else if (node instanceof TemplateStringNode) {
+    for (const part of node.parts) {
+      walkAST(part, onVisit);
+    }
   } else if (node instanceof AttributeAccessNode) {
     walkAST(node.left, onVisit);
     if (node.right instanceof FunctionCallNode || node.right instanceof PartialFunctionCallNode) {
@@ -2548,6 +2559,51 @@ var Lexer = class {
       endPos: this.pos
     };
   }
+  /**
+   * Read a backtick-delimited template string.
+   * Supports escape sequences: \{ \$ \` \\
+   * The raw content (with escapes preserved) is stored as the token value.
+   * The parser handles splitting into segments.
+   */
+  templateString() {
+    const startPos = this.pos;
+    this.eat("`");
+    let result = "";
+    while (this.currentChar !== null && this.currentChar !== "`") {
+      if (this.currentChar === "\\") {
+        const next = this.peek();
+        if (next === "{" || next === "$" || next === "`" || next === "\\") {
+          result += "\\";
+          result += next;
+          this.advance();
+          this.advance();
+          continue;
+        }
+      }
+      result += this.currentChar;
+      this.advance();
+    }
+    if (this.currentChar === null) {
+      if (this.tolerant) {
+        return {
+          type: "TEMPLATE_STRING" /* TEMPLATE_STRING */,
+          value: result,
+          line: this.line,
+          pos: startPos,
+          endPos: this.pos
+        };
+      }
+      this.error("LEXER_UNTERMINATED_TEMPLATE_STRING" /* UNTERMINATED_TEMPLATE_STRING */, {});
+    }
+    this.eat("`");
+    return {
+      type: "TEMPLATE_STRING" /* TEMPLATE_STRING */,
+      value: result,
+      line: this.line,
+      pos: startPos,
+      endPos: this.pos
+    };
+  }
   hexColor() {
     const startPos = this.pos;
     let result = "";
@@ -2598,6 +2654,9 @@ var Lexer = class {
       if (this.currentChar === "'" || this.currentChar === '"') {
         return this.collectToken(this.explicitString(this.currentChar));
       }
+      if (this.currentChar === "`") {
+        return this.collectToken(this.templateString());
+      }
       if (this.isValidIdentifierStart(this.currentChar)) {
         return this.collectToken(this.stringElement());
       }
@@ -2974,7 +3033,7 @@ var Lexer = class {
 };
 
 // src/interpreter/parser.ts
-var Parser = class {
+var Parser = class _Parser {
   constructor(lexer, options) {
     this.requiredReferences = /* @__PURE__ */ new Set();
     this.incompleteInfo = [];
@@ -3506,6 +3565,9 @@ ${contextText}`;
       node = this.attributeAccess(node);
       return node;
     }
+    if (token.type === "TEMPLATE_STRING" /* TEMPLATE_STRING */) {
+      return this.templateString();
+    }
     if (token.type === "EXPLICIT_STRING" /* EXPLICIT_STRING */) {
       this.eat("EXPLICIT_STRING" /* EXPLICIT_STRING */);
       let node = new StringNode(token);
@@ -3565,6 +3627,122 @@ ${contextText}`;
     this.eat("RPAREN" /* RPAREN */);
     return new FunctionCallNode(functionName.value, args, functionName);
   }
+  /**
+   * Parse a TEMPLATE_STRING token into a TemplateStringNode.
+   * Scans the raw content for:
+   *   - {ref.path} → ReferenceNode
+   *   - ${expression} → parsed sub-expression
+   *   - \{ \${ \` \\ → escaped literals (backslash removed)
+   *   - everything else → literal StringNode segments
+   */
+  templateString() {
+    const token = this.currentToken;
+    const raw = token.value;
+    this.eat("TEMPLATE_STRING" /* TEMPLATE_STRING */);
+    const parts = [];
+    let literal = "";
+    let i = 0;
+    const flushLiteral = () => {
+      if (literal.length > 0) {
+        parts.push(new StringNode({ ...token, value: literal }));
+        literal = "";
+      }
+    };
+    while (i < raw.length) {
+      const ch = raw[i];
+      if (ch === "\\" && i + 1 < raw.length) {
+        const next = raw[i + 1];
+        if (next === "{" || next === "`" || next === "\\") {
+          literal += next;
+          i += 2;
+          continue;
+        }
+        if (next === "$") {
+          if (i + 2 < raw.length && raw[i + 2] === "{") {
+            literal += "${";
+            i += 3;
+          } else {
+            literal += "$";
+            i += 2;
+          }
+          continue;
+        }
+      }
+      if (ch === "$" && i + 1 < raw.length && raw[i + 1] === "{") {
+        flushLiteral();
+        const start = i + 2;
+        let depth = 1;
+        let j = start;
+        while (j < raw.length && depth > 0) {
+          if (raw[j] === "`") {
+            this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+              message: "Nested template strings are not allowed inside ${...}"
+            });
+          }
+          if (raw[j] === "{") depth++;
+          else if (raw[j] === "}") depth--;
+          if (depth > 0) j++;
+        }
+        if (depth !== 0) {
+          this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+            message: "Unterminated ${...} in template string"
+          });
+        }
+        const exprStr = raw.slice(start, j);
+        const subLexer = new Lexer(exprStr);
+        const subParser = new _Parser(subLexer);
+        const exprNode = subParser.expr();
+        for (const ref of subParser.requiredReferences) {
+          this.requiredReferences.add(ref);
+        }
+        parts.push(exprNode);
+        i = j + 1;
+        continue;
+      }
+      if (ch === "{") {
+        flushLiteral();
+        const start = i + 1;
+        let j = start;
+        while (j < raw.length && raw[j] !== "}") {
+          if (raw[j] === "{") {
+            this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+              message: "Nested braces in template reference"
+            });
+          }
+          j++;
+        }
+        if (j >= raw.length) {
+          this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+            message: "Unterminated {ref} in template string"
+          });
+        }
+        let refPath = raw.slice(start, j);
+        refPath = refPath.replace(/[ \t]/g, "");
+        if (refPath.length === 0) {
+          this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+            message: "Empty reference in template string"
+          });
+        }
+        this.requiredReferences.add(refPath);
+        parts.push(
+          new ReferenceNode({
+            ...token,
+            type: "REFERENCE" /* REFERENCE */,
+            value: refPath
+          })
+        );
+        i = j + 1;
+        continue;
+      }
+      literal += ch;
+      i++;
+    }
+    flushLiteral();
+    if (parts.length === 1 && parts[0] instanceof StringNode) {
+      return parts[0];
+    }
+    return new TemplateStringNode(parts, token);
+  }
   parse(inlineMode = false) {
     if (this.tolerant && !inlineMode) {
       this.error("PARSER_TOLERANT_REQUIRES_INLINE" /* TOLERANT_REQUIRES_INLINE */);
@@ -8215,6 +8393,47 @@ var Interpreter = class {
   visitStringNode(node) {
     return new StringSymbol(node.value, this.config);
   }
+  visitTemplateStringNode(node) {
+    if (node.parts.length === 0) {
+      return new StringSymbol("", this.config);
+    }
+    if (node.parts.length === 1) {
+      const val = this.visit(node.parts[0]);
+      this.validateTemplateValue(val, node);
+      return val;
+    }
+    let result = "";
+    for (const part of node.parts) {
+      const val = this.visit(part);
+      this.validateTemplateValue(val, node);
+      result += val.toString();
+    }
+    return new StringSymbol(result, this.config);
+  }
+  /**
+   * Validate that a value is a primitive type allowed in template string interpolation.
+   * Lists, Dictionaries, and non-hex Colors are rejected.
+   */
+  validateTemplateValue(val, node) {
+    if (val instanceof ListSymbol) {
+      throw new InterpreterError("INT_TEMPLATE_INVALID_TYPE" /* TEMPLATE_INVALID_TYPE */, {
+        token: node.token,
+        data: { valueType: "List" }
+      });
+    }
+    if (val instanceof DictionarySymbol) {
+      throw new InterpreterError("INT_TEMPLATE_INVALID_TYPE" /* TEMPLATE_INVALID_TYPE */, {
+        token: node.token,
+        data: { valueType: "Dictionary" }
+      });
+    }
+    if (val instanceof ColorSymbol && !val.isHex()) {
+      throw new InterpreterError("INT_TEMPLATE_INVALID_TYPE" /* TEMPLATE_INVALID_TYPE */, {
+        token: node.token,
+        data: { valueType: `Color.${val.subType}` }
+      });
+    }
+  }
   /**
    * Bare identifiers are treated as string literals if not found as variables
    * Check symbol table first (variables override references), then references