vue2-client 1.11.4 → 1.11.5

package/src/expression/core/Program.ts

@@ -0,0 +1,950 @@
+import Token from './Token'
+import Expression from './Expression'
+import Delegate from "./Delegate"
+import ExpressionType from "../enums/ExpressionType"
+import TokenType from "../enums/TokenType"
+import JSONArray from "../instances/JSONArray"
+
+/**
+ * 表达式入口
+ */
+export default class Program {
+  // 源程序
+  public readonly SOURCE : string;
+  public readonly SOURCE_LENGTH : number;
+  /**
+   * Token队列，用于回退
+   */
+  private readonly tokens: Token[] = [];
+  /**
+   * 字符串处理环节堆栈，$进入字符串处理环节，“{}”中间部分脱离字符串处理环节
+   */
+  private readonly inStrings: boolean[] = [];
+
+  /**
+   * 当前获取到的字符位置
+   */
+  private pos: number = 0;
+
+  /**
+   * 当前是否在字符串处理环节
+   */
+  private inString: boolean = false;
+
+  constructor(source: string) {
+    this.SOURCE = source;
+    this.SOURCE_LENGTH = this.SOURCE.length;
+  }
+
+  /**
+   * 调用解析过程
+   */
+  public parse(): Delegate {
+    // 执行完以下方法后就已经诞生了一个完整的执行流程，也就是被翻译成了一套完整的指令集。
+    return this.createDelegate(this.expression());
+  }
+
+  public parseExpression(expression: Expression): Delegate {
+    // 执行完以下方法后就已经诞生了一个完整的执行流程，也就是被翻译成了一套完整的指令集。
+    return this.createDelegate(expression);
+  }
+
+  /**
+   * 编译，产生可执行单元Delegate
+   */
+  public createDelegate(expression: Expression): Delegate {
+    return new Delegate(expression, this.SOURCE);
+  }
+
+  /**
+   * 获取完整表达式
+   */
+  public expression(): Expression {
+    let expression = this.CommaExp();
+    if (this.pos < this.SOURCE_LENGTH) {
+      throw new Error(this.GetExceptionMessage("需要逗号结尾!"));
+    }
+    return expression;
+  }
+
+  /**
+   * 逗号表达式=赋值表达式(,赋值表达式)*
+   */
+  private CommaExp(): Expression {
+    const exps: Expression[] = [];
+
+    const first: Expression = this.AssignExp();
+    exps.push(first);
+
+    let t: Token = this.GetToken();
+
+    // 没有结束
+    while (t.getType() === TokenType.Oper && (t.getValue() === "," || t.getValue() === ";" || t.getValue() === "\n")) {
+      const r: Expression = this.AssignExp();
+      exps.push(r);
+      t = this.GetToken();
+    }
+
+    this.tokens.push(t);
+
+    return Expression.Comma(exps, this.pos);
+  }
+
+  /**
+   * 赋值表达式=对象属性=一般表达式|一般表达式
+   */
+  private AssignExp(): Expression {
+    let t: Token = this.GetToken();
+
+    // 把第一个Token的位置记录下来，方便后面回退
+    const firstPos: number = t.getStartPos();
+
+    if (t.getType() !== TokenType.Identy) {
+      this.pos = firstPos;
+      this.tokens.length = 0; // Clear the tokens array
+      this.inString = false;
+      return this.Exp();
+    }
+
+    let objExp: Expression = Expression.Identity(t.getValue(), this.pos);
+    objExp = this.ObjectPath(objExp);
+
+    // 只能给对象属性或者变量赋值
+    if (objExp.type !== ExpressionType.Property && objExp.type !== ExpressionType.Identity) {
+      this.pos = firstPos;
+      this.tokens.length = 0;
+      this.inString = false;
+      return this.Exp();
+    }
+
+    t = this.GetToken();
+    if (t.getType() !== TokenType.Oper || t.getValue() !== "=") {
+      this.pos = firstPos;
+      this.tokens.length = 0;
+      this.inString = false;
+      return this.Exp();
+    }
+
+    const exp: Expression = this.Exp();
+
+    // 如果是属性赋值
+    if (objExp.type === ExpressionType.Property) {
+      // 从属性Expression中获取对象及属性名
+      const name: string = <string>objExp.value;
+      objExp = objExp.children[0] as Expression;
+      return Expression.Assign(objExp, exp, name, this.pos);
+    } else {
+      // Identity 变量赋值
+      return Expression.Assign(null, exp, <string>objExp.value, this.pos);
+    }
+  }
+
+  private Exp(): Expression {
+    let v: Expression = this.Logic();
+
+    // 是':'，表示条件，否则直接返回单结果
+    let t: Token = this.GetToken();
+    if (t.getType() === TokenType.Oper && t.getValue() === ":") {
+      // 第一项转换
+      let result: Expression = this.Logic();
+
+      // 下一个是","，继续读取下一个条件结果串，由于是右结合，只能采用递归
+      t = this.GetToken();
+      if (t.getType() === TokenType.Oper && t.getValue() === ",") {
+        // 第二项转换
+        let sExp: Expression = this.Exp();
+        // 返回
+        return Expression.Condition(v, result, sExp, this.SOURCE, this.pos);
+      } else {
+        throw new Error(this.GetExceptionMessage("必须有默认值!"));
+      }
+    } else {
+      this.tokens.push(t);  // Put the token back
+      return v;
+    }
+  }
+
+  private Logic(): Expression {
+    let t: Token = this.GetToken();
+
+    // !表达式
+    const hasNot: boolean = t.getType() === TokenType.Oper && t.getValue() === "!";
+    if (!hasNot) {
+      this.tokens.push(t);  // Put the token back if it's not '!'
+    }
+
+    let v: Expression = this.Compare();
+    if (hasNot) {
+      v = Expression.Not(v, this.SOURCE, this.pos);
+    }
+
+    t = this.GetToken();
+    while (t.getType() === TokenType.Oper && (t.getValue() === "&&" || t.getValue() === "||")) {
+      // 第二项转换
+      let exp: Expression = this.Logic();
+
+      // 执行
+      if (t.getValue() === "&&") {
+        v = Expression.And(v, exp, this.SOURCE, this.pos);
+      } else {
+        v = Expression.Or(v, exp, this.SOURCE, this.pos);
+      }
+
+      t = this.GetToken();
+    }
+
+    this.tokens.push(t);  // Put the token back
+    return v;
+  }
+
+  private Compare(): Expression {
+    let left: Expression = this.Math();
+    let t: Token = this.GetToken();
+
+    if (t.getType() === TokenType.Oper && (
+      t.getValue() === ">" || t.getValue() === ">=" ||
+      t.getValue() === "<" || t.getValue() === "<=" || t.getValue() === "=>")) {
+
+      if (t.getValue() === "=>") {
+        this.tokens.push(t);  // Push back the token for lambda handling
+        return this.Lambda();
+      }
+
+      let rExp: Expression = this.Math();
+
+      switch (t.getValue()) {
+        case ">":
+          return Expression.GreaterThan(left, rExp, this.SOURCE, this.pos);
+        case ">=":
+          return Expression.GreaterThanOrEqual(left, rExp, this.SOURCE, this.pos);
+        case "<":
+          return Expression.LessThan(left, rExp, this.SOURCE, this.pos);
+        case "<=":
+          return Expression.LessThanOrEqual(left, rExp, this.SOURCE, this.pos);
+      }
+    } else if (t.getType() === TokenType.Oper && (
+      t.getValue() === "==" || t.getValue() === "!=")) {
+
+      let rExp: Expression = this.Math();
+
+      // 相等比较
+      if (t.getValue() === "==") {
+        return Expression.Equal(left, rExp, this.SOURCE, this.pos);
+      } else {
+        return Expression.NotEqual(left, rExp, this.SOURCE, this.pos);
+      }
+    }
+
+    // 返回当前的表达式结果
+    this.tokens.push(t);  // Push the token back
+    return left;
+  }
+
+  private Math(): Expression {
+    let v: Expression = this.Mul();
+    let t: Token = this.GetToken();
+
+    while (t.getType() === TokenType.Oper && (t.getValue() === "+" || t.getValue() === "-")) {
+      // 转换操作数2为数字
+      let r: Expression = this.Mul();
+
+      // 开始运算
+      if (t.getValue() === "+") {
+        v = Expression.Add(v, r, this.SOURCE, this.pos);
+      } else {
+        v = Expression.Subtract(v, r, this.SOURCE, this.pos);
+      }
+
+      t = this.GetToken();
+    }
+
+    this.tokens.push(t); // Push the token back
+    return v;
+  }
+
+  private Lambda(): Expression {
+    let t: Token = this.GetToken();
+    if (t.getValue() !== "=>" || t.getValue() == null) {
+      throw new Error(this.GetExceptionMessage("lambda必须以=>开始"));
+    }
+
+    t = this.GetToken();
+    if (t.getValue() !== "{" || t.getValue() == null) {
+      throw new Error(this.GetExceptionMessage("lambda必须以{开始"));
+    }
+
+    // 取lambda中的表达式
+    const exp: Expression = this.CommaExp();
+
+    t = this.GetToken();
+    if (t.getValue() !== "}" || t.getValue() == null) {
+      throw new Error(this.GetExceptionMessage("lambda必须以}结束"));
+    }
+
+    return Expression.Lambda(exp, this.pos);
+  }
+
+  private Mul(): Expression {
+    let v: Expression = this.UnarySub();
+    let t: Token = this.GetToken();
+
+    while (t.getType() === TokenType.Oper && (t.getValue() === "*" || t.getValue() === "/" || t.getValue() === "%")) {
+      // Convert the second operand to a number
+      const r: Expression = this.UnarySub();
+
+      // Perform the operation
+      if (t.getValue() === "*") {
+        v = Expression.Multiply(v, r, this.SOURCE, this.pos);
+      } else if (t.getValue() === "/") {
+        v = Expression.Divide(v, r, this.SOURCE, this.pos);
+      } else {
+        v = Expression.Modulo(v, r, this.SOURCE, this.pos);
+      }
+
+      t = this.GetToken();
+    }
+
+    this.tokens.push(t);
+    return v;
+  }
+
+  private UnarySub(): Expression {
+    let t: Token = this.GetToken();
+    if (t.getType() === TokenType.Oper && t.getValue() === "-") {
+      let r: Expression = this.Item();
+      return Expression.Subtract(Expression.Constant(0, this.pos), r, this.SOURCE, this.pos);
+    }
+    this.tokens.push(t);  // Push the token back into the queue
+    return this.Item();
+  }
+
+  private Item(): Expression {
+    let objName: string = "";
+    // 获取对象表达式
+    let objExp: Expression = this.ItemHead(objName);
+    // 获取对象路径表达式
+    objExp = this.ObjectPath(objExp);
+    return objExp;
+  }
+
+  private ItemHead(name: string): Expression {
+    let t: Token = this.GetToken();
+
+    if (t.getType() === TokenType.Oper && t.getValue() === "(") {
+      let result: Expression = this.CommaExp();
+      t = this.GetToken();
+      if (t.getType() !== TokenType.Oper || t.getValue() !== ")") {
+        throw new Error(this.GetExceptionMessage("括号不匹配"));
+      }
+      return result;
+    } else if (t.getType() === TokenType.Oper && t.getValue() === "{") {
+      // JSON object
+      return this.Json();
+    } else if (t.getType() === TokenType.Oper && t.getValue() === "[") {
+      // JSON array
+      return this.JsonArray();
+    } else if (t.getType() === TokenType.Oper && (t.getValue() === "$" || t.getValue() === "\"")) {
+      // String concatenation sequence
+      return this.StringUnion();
+    } else if (t.getType() === TokenType.Int || t.getType() === TokenType.Double || t.getType() === TokenType.Bool) {
+      return Expression.Constant(t.getValue(), this.pos);
+    } else if (t.getType() === TokenType.Identy) {
+      let objName: string = <string>t.getValue();
+
+      switch (objName) {
+        case "return":
+          return Expression.Return(this.Exp(), this.pos);
+        case "try":
+          this.tokens.push(t); // Revert the token back to the queue
+          return this.Try();
+        case "throw":
+          return Expression.Throw(this.Exp(), this.pos);
+        case "validate":
+          return this.Validate();
+        case "assert":
+          return Expression.Assert(this.Exp(), this.pos);
+        case "break":
+          return Expression.Break(this.pos, undefined);
+        case "continue":
+          return Expression.Continue(this.pos, undefined);
+      }
+
+      // Return the object name
+      name += objName;
+      // Process the object name
+      return this.ObjectName(objName);
+    } else if (t.getType() === TokenType.Null) {
+      return Expression.Constant(null, this.pos);
+    }
+
+    throw new Error(this.GetExceptionMessage("单词类型错误：" + t.getType()));
+  }
+
+  /**
+   * TryCatch := try {expression} (catch(Exception类 名){表达式})* finally{表达式}?
+   */
+  private Try(): Expression {
+    let t: Token = this.GetToken();
+    if (t.getValue() !== "try") {
+      throw new Error(this.GetExceptionMessage("try-catch必须以try开始"));
+    }
+
+    t = this.GetToken();
+    if (t.getValue() !== "{") {
+      throw new Error(this.GetExceptionMessage("try块必须以{开始"));
+    }
+
+    // Get the expression inside the try block
+    let tryExp: Expression = this.CommaExp();
+
+    t = this.GetToken();
+    if (t.getValue() !== "}") {
+      throw new Error(this.GetExceptionMessage("try块必须以}结束"));
+    }
+
+    // Handle the catch part
+    let catches: Expression[] = this.Catch();
+
+    // Handle finally
+    let finallyExp: Expression | undefined = undefined;
+    t = this.GetToken();
+    if (t.getValue()) {
+      if (t.getValue() === "finally") {
+        t = this.GetToken();
+        if (t.getValue() !== "{") {
+          throw new Error(this.GetExceptionMessage("finally块必须以{开始"));
+        }
+
+        // Get the expression inside the finally block
+        finallyExp = this.CommaExp();
+        t = this.GetToken();
+        if (t.getValue() !== "}") {
+          throw new Error(this.GetExceptionMessage("finally块必须以}结束"));
+        }
+        t = this.GetToken();
+      }
+    }
+
+    this.tokens.push(t);
+
+    // Return the exception handling expression
+    return Expression.Try(tryExp, catches, this.pos, finallyExp);
+  }
+
+  /**
+   * catch部分处理
+   */
+  private Catch(): Expression[] {
+    let result: Expression[] = [];
+    let t: Token = this.GetToken();
+
+    while (t.getValue() === "catch") {
+      t = this.GetToken();
+      if (t.getValue() !== "(") {
+        throw new Error(this.GetExceptionMessage("catch块参数必须以(开始"));
+      }
+
+      // Get the class name
+      t = this.GetToken();
+      let className: string = <string>t.getValue();
+
+      // Get the variable name
+      t = this.GetToken();
+      let varName: string = <string>t.getValue();
+
+      t = this.GetToken();
+      if (t.getValue() !== ")") {
+        throw new Error(this.GetExceptionMessage("catch块参数必须以)结束"));
+      }
+
+      // Get the opening curly brace
+      t = this.GetToken();
+      if (t.getValue() !== "{") {
+        throw new Error(this.GetExceptionMessage("catch块必须以{开始"));
+      }
+
+      // Get the expression inside the catch block
+      let catchExp: Expression = this.CommaExp();
+      result.push(Expression.Catch(className, varName, catchExp, this.pos));
+
+      // Get the closing curly brace
+      t = this.GetToken();
+      if (t.getValue() !== "}") {
+        throw new Error(this.GetExceptionMessage("catch块必须以}结束"));
+      }
+
+      // Get the next token
+      t = this.GetToken();
+    }
+
+    this.tokens.push(t);
+    return result;
+  }
+
+  /**
+   * Validate block handling
+   */
+  private Validate(): Expression {
+    let t: Token = this.GetToken();
+    if (t.getValue() !== "{") {
+      throw new Error(this.GetExceptionMessage("validate只接收Json对象"));
+    }
+
+    // Get the expression in the validate block
+    let exp: Expression = this.Json();
+
+    // Return Validate processing expression
+    return Expression.Validate(exp, this.pos);
+  }
+
+  /**
+   * JSON Object ::= {} | {propertyName: propertyValue, propertyName: propertyValue}
+   */
+  private Json(): Expression {
+    let children: Expression[] = [];
+
+    let t: Token = this.GetToken();
+    // Empty object, return directly
+    if (t.getType() === TokenType.Oper && t.getValue() === "}") {
+      return Expression.Json(children, this.pos);
+    }
+
+    this.tokens.push(t);
+    children.push(this.Attr());
+    t = this.GetToken();
+
+    // If it's a comma, continue checking the next property
+    while (t.getType() === TokenType.Oper && t.getValue() === ",") {
+      let nextT: Token = this.GetToken();
+      if (nextT.getType() === TokenType.Oper && nextT.getValue() === "}") {
+        t = nextT;
+        break;
+      }
+      this.tokens.push(nextT);
+      children.push(this.Attr());
+      t = this.GetToken();
+    }
+
+    if (t.getType() !== TokenType.Oper || t.getValue() !== "}") {
+      throw new Error(this.GetExceptionMessage("JSON对象构建错误"));
+    }
+
+    return Expression.Json(children, this.pos);
+  }
+
+  /**
+   * JSON Array ::= []
+   */
+  private JsonArray(): Expression {
+    let t: Token = this.GetToken();
+    // Empty array, return directly
+    if (t.getType() === TokenType.Oper && t.getValue() === "]") {
+      // Return JSON array constant
+      return Expression.Constant(new JSONArray(), this.pos);
+    }
+
+    // Loop to get array contents
+    this.tokens.push(t);
+    let ps: Expression[] = this.Params();
+    t = this.GetToken();
+    if (t.getType() !== TokenType.Oper || t.getValue() !== "]") {
+      throw new Error(this.GetExceptionMessage("JSON集合构建错误"));
+    }
+
+    return Expression.Array(ps, this.pos);
+  }
+
+  /**
+   * Attribute-Value Pair ::= propertyName: propertyValue
+   */
+  private Attr(): Expression {
+    let name: Token = this.GetToken();
+    let value: string;
+    if (name.getType() === TokenType.Identy) {
+      value = <string>name.getValue();
+    } else if (name.getType() === TokenType.Oper && (name.getValue() === "$" || name.getValue() === "\"")) {
+      let expression: Expression = this.StringUnion().children[1] as Expression;
+      value = <string>expression.value;
+    } else {
+      throw new Error(this.GetExceptionMessage("JSON对象的key必须是属性名或字符串"));
+    }
+
+    let t: Token = this.GetToken();
+    if (t.getType() !== TokenType.Oper || t.getValue() !== ":") {
+      throw new Error(this.GetExceptionMessage("JSON构建错误"));
+    }
+
+    let exp: Expression = this.Exp();
+    return Expression.Attr(value, exp, this.pos);
+  }
+
+  /**
+   * Parse string concatenation sequence
+   */
+  private StringUnion(): Expression {
+    let exp: Expression = Expression.Constant("", this.pos);
+    let t: Token = this.GetToken();
+    // Object sequence
+    while ((t.getType() === TokenType.Oper && t.getValue() === "{") || t.getType() === TokenType.String) {
+      // If it's a string, return the concatenated result
+      if (t.getType() === TokenType.String) {
+        exp = Expression.Concat(exp, Expression.Constant(t.getValue(), this.pos), this.SOURCE, this.pos);
+      } else {
+        // Handle content inside the {}
+        let objExp: Expression = this.Exp();
+        t = this.GetToken();
+        if (t.getType() !== TokenType.Oper || t.getValue() !== "}") {
+          throw new Error(this.GetExceptionMessage("缺少'}'"));
+        }
+        // String concatenation
+        exp = Expression.Concat(exp, objExp, this.SOURCE, this.pos);
+      }
+      t = this.GetToken();
+    }
+    this.tokens.push(t);
+    return exp;
+  }
+
+  /**
+   * Get object and object expression by name
+   */
+  private ObjectName(objName: string): Expression {
+    return Expression.Identity(objName, this.pos);
+  }
+
+  /**
+   * Object path parsing, handles method calls, properties, and array indices
+   */
+  private ObjectPath(inExp: Expression): Expression {
+    let objExp: Expression = this.ArrayIndex(inExp);
+    let t: Token = this.GetToken();
+    while (t.getType() === TokenType.Oper && t.getValue() === ".") {
+      let nameToken: Token = this.GetToken();
+      let n: Token = this.GetToken();
+      if (n.getType() === TokenType.Oper && n.getValue() === "(") {
+        let name: string = <string>nameToken.getValue();
+        if (name === "each") {
+          objExp = this.For(objExp);
+        } else {
+          objExp = this.MethodCall(name, objExp);
+        }
+      } else {
+        this.tokens.push(n);
+        let pi: string = <string>nameToken.getValue();
+        objExp = Expression.Property(objExp, pi, this.pos);
+        objExp = this.ArrayIndex(objExp);
+      }
+      t = this.GetToken();
+    }
+    this.tokens.push(t);
+
+    return objExp;
+  }
+
+  /**
+   * Array index parsing with optional condition
+   */
+  private ArrayIndex(objExp: Expression): Expression {
+    let n: Token = this.GetToken();
+    if (n.getType() === TokenType.Oper && n.getValue() === "[") {
+      let exp: Expression = this.Exp();
+      n = this.GetToken();
+      if (n.getType() !== TokenType.Oper || n.getValue() !== "]") {
+        throw new Error(this.GetExceptionMessage("缺少']'"));
+      }
+      return Expression.ArrayIndex(objExp, exp, this.SOURCE, this.pos);
+    }
+    this.tokens.push(n);
+    return objExp;
+  }
+
+  /**
+   * For loop handling
+   */
+  private For(obj: Expression): Expression {
+    let exp: Expression = this.CommaExp();
+    let t: Token = this.GetToken();
+    if (t.getType() !== TokenType.Oper || t.getValue() !== ")") {
+      throw new Error(this.GetExceptionMessage("函数调用括号不匹配"));
+    }
+    return Expression.For(obj, exp, this.SOURCE, this.pos);
+  }
+
+  /**
+   * Method call handling with parameters
+   */
+  private MethodCall(name: string, obj: Expression): Expression {
+    let t: Token = this.GetToken();
+    if (t.getType() === TokenType.Oper && t.getValue() === ")") {
+      let ps: Expression[] = [];
+      return Expression.Call(obj, name, ps, this.pos);
+    }
+
+    this.tokens.push(t);
+    let ps: Expression[] = this.Params();
+    t = this.GetToken();
+    if (t.getType() !== TokenType.Oper || t.getValue() !== ")") {
+      throw new Error(this.GetExceptionMessage("函数调用括号不匹配"));
+    }
+
+    return Expression.Call(obj, name, ps, this.pos);
+  }
+
+  /**
+   * Function parameter list handling
+   */
+  private Params(): Expression[] {
+    let ps: Expression[] = [];
+    let name: string = this.paramName();
+    let exp: Expression = this.Exp();
+    this.procParam(ps, exp, name);
+    let t: Token = this.GetToken();
+    while (t.getType() === TokenType.Oper && t.getValue() === ",") {
+      name = this.paramName();
+      exp = this.Exp();
+      this.procParam(ps, exp, name);
+      t = this.GetToken();
+    }
+    this.tokens.push(t);
+    return ps;
+  }
+
+  /**
+   * Parse parameter name
+   */
+  private paramName(): string {
+    let t: Token = this.GetToken();
+    if (t.getType() === TokenType.Identy) {
+      let t1: Token = this.GetToken();
+      if (t1.getValue() === ":") {
+        return <string>t.getValue();
+      } else {
+        this.tokens.push(t);
+        this.tokens.push(t1);
+        return "";
+      }
+    } else {
+      this.tokens.push(t);
+      return "";
+    }
+  }
+
+  /**
+   * Process parameters, especially if it contains the "data" object
+   */
+  private procParam(ps: Expression[], exp: Expression, name: string): void {
+    let delegate: Delegate = this.createDelegate(exp);
+    if (delegate.containsKey("data")) {
+      ps.push(Expression.Constant(delegate, this.pos));
+    } else {
+      ps.push(Expression.Param(exp, name, this.pos));
+    }
+  }
+
+  /**
+   * Get exception message with position information
+   */
+  private GetExceptionMessage(msg: string): string {
+    let result: string = this.SOURCE.substring(0, this.pos) + " <- " + this.SOURCE.substring(this.pos);
+    return `${msg}：\n${result}`;
+  }
+
+  public GetToken(): Token {
+    // If there are tokens in the queue, return the last one saved
+    if (this.tokens.length > 0) {
+      return this.tokens.shift()!;
+    }
+
+    const sPos = this.pos;
+    let hasKeyword = this.pos < this.SOURCE_LENGTH;
+    let value: string | null = null;
+
+    if (hasKeyword) {
+      value = this.SOURCE.charAt(this.pos);
+    }
+
+    // If it's '{', save the previous state and change to non-string state
+    if (hasKeyword && value === '{') {
+      this.inStrings.push(this.inString);
+      this.inString = false;
+      const str = this.SOURCE.substring(this.pos, this.pos + 1);
+      this.pos += 1;
+      return new Token(TokenType.Oper, str, sPos);
+    }
+
+    // If in string state, process the string
+    if (this.inString) {
+      let startPos = this.pos;
+      while (hasKeyword && value !== '{' && value !== '}' && value !== '$' && value !== '\"') {
+        if (value === '\\') {
+          const nextStrValue = this.SOURCE.charAt(this.pos + 1);
+          if (this.pos + 1 < this.SOURCE_LENGTH && ['{', '}', '\"', '$', '\\'].includes(nextStrValue)) {
+            this.pos++;
+          } else {
+            break;
+          }
+        }
+        this.pos++;
+        if (this.pos < this.SOURCE_LENGTH) {
+          value = this.SOURCE.charAt(this.pos);
+        } else {
+          hasKeyword = false;
+        }
+      }
+      if (!(hasKeyword && value === '{')) {
+        this.inString = this.inStrings.pop()!;
+      }
+      const t = new Token(TokenType.String, this.SOURCE.substring(startPos, this.pos)
+        .replace("\\$", "$")
+        .replace("\\{", "{")
+        .replace("\\}", "}")
+        .replace("\\\"", "\"")
+        .replace("\\\\", "\\"), sPos);
+
+      if (hasKeyword && (value === '$' || value === '\"')) {
+        this.pos++;
+      }
+      return t;
+    }
+
+    // Skip whitespace and comments
+    while (hasKeyword && (value === ' ' || value === '\n' || value === '\t' || (this.pos < this.SOURCE_LENGTH - 2 && value === '/' && this.SOURCE.charAt(this.pos + 1) === '/'))) {
+      if (value !== ' ' && value !== '\n' && value !== '\t') {
+        this.pos += 2;
+        if (this.pos < this.SOURCE_LENGTH) {
+          value = this.SOURCE.charAt(this.pos);
+        } else {
+          hasKeyword = false;
+        }
+        while (hasKeyword && value !== '\n') {
+          this.pos++;
+          if (this.pos < this.SOURCE_LENGTH) {
+            value = this.SOURCE.charAt(this.pos);
+          } else {
+            hasKeyword = false;
+          }
+        }
+      }
+      this.pos++;
+      if (this.pos < this.SOURCE_LENGTH) {
+        value = this.SOURCE.charAt(this.pos);
+      } else {
+        hasKeyword = false;
+      }
+    }
+
+    // If we are at the end of the source, return an "End" token
+    if (this.pos === this.SOURCE_LENGTH) {
+      return new Token(TokenType.End, null, sPos);
+    }
+
+    if (value !== null) {
+      // Handle number tokens
+      if (value >= '0' && value <= '9') {
+        const oldPos = this.pos;
+        while (hasKeyword && value >= '0' && value <= '9') {
+          this.pos++;
+          if (this.pos < this.SOURCE_LENGTH) {
+            value = this.SOURCE.charAt(this.pos);
+          } else {
+            hasKeyword = false;
+          }
+        }
+
+        if (hasKeyword && value === '.') {
+          do {
+            this.pos++;
+            if (this.pos < this.SOURCE_LENGTH) {
+              value = this.SOURCE.charAt(this.pos);
+            } else {
+              hasKeyword = false;
+            }
+          } while (hasKeyword && value >= '0' && value <= '9');
+          const str = this.SOURCE.substring(oldPos, this.pos);
+          return new Token(TokenType.Double, parseFloat(str), sPos);
+        } else {
+          const str = this.SOURCE.substring(oldPos, this.pos);
+          return new Token(TokenType.Int, parseInt(str, 10), sPos);
+        }
+      }
+
+      // Handle identifier tokens
+      else if ((value >= 'a' && value <= 'z') || (value >= 'A' && value <= 'Z') || value === '_' || /[\u4e00-\u9fa5]/.test(value)) {
+        const oldPos = this.pos;
+        while (hasKeyword && ((value >= 'a' && value <= 'z') || (value >= 'A' && value <= 'Z') || (value >= '0' && value <= '9') || value === '_' || /[\u4e00-\u9fa5]/.test(value))) {
+          this.pos++;
+          if (this.pos < this.SOURCE_LENGTH) {
+            value = this.SOURCE.charAt(this.pos);
+          } else {
+            hasKeyword = false;
+          }
+        }
+        const str = this.SOURCE.substring(oldPos, this.pos);
+        switch (str) {
+          case 'false':
+          case 'true':
+            return new Token(TokenType.Bool, Boolean(str), sPos);
+          case 'null':
+            return new Token(TokenType.Null, null, sPos);
+          default:
+            return new Token(TokenType.Identy, str, sPos);
+        }
+      }
+
+      // Handle operators like &&, ||, and single-character operators
+      else if ((value === '&' && this.SOURCE.charAt(this.pos + 1) === '&') || (value === '|' && this.SOURCE.charAt(this.pos + 1) === '|')) {
+        const str = this.SOURCE.substring(this.pos, this.pos + 2);
+        this.pos += 2;
+        return new Token(TokenType.Oper, str, sPos);
+      }
+
+      // Handle other operators (+, -, *, /, etc.)
+      else if (['+', '-', '*', '/', '%', '>', '<', '!'].includes(value)) {
+        let str = '';
+        if (this.SOURCE.charAt(this.pos + 1) === '=') {
+          str = this.SOURCE.substring(this.pos, this.pos + 2);
+          this.pos += 2;
+        } else {
+          str = this.SOURCE.substring(this.pos, this.pos + 1);
+          this.pos += 1;
+        }
+        return new Token(TokenType.Oper, str, sPos);
+      }
+
+      // Handle '=' with different cases
+      else if (value === '=') {
+        let str = '';
+        if (this.SOURCE.charAt(this.pos + 1) === '=' || this.SOURCE.charAt(this.pos + 1) === '>') {
+          str = this.SOURCE.substring(this.pos, this.pos + 2);
+          this.pos += 2;
+        } else {
+          str = this.SOURCE.substring(this.pos, this.pos + 1);
+          this.pos += 1;
+        }
+        return new Token(TokenType.Oper, str, sPos);
+      }
+
+      // Single character operators like parentheses, commas, etc.
+      else if ('()[],;.:@{}"$'.includes(value)) {
+        if (value === '$' || value === '\"') {
+          this.inStrings.push(false);
+          this.inString = true;
+        } else if ((value === '{' || value === '}') && this.inStrings.length) {
+          if (value === '{') {
+            this.inStrings.push(false);
+            this.inString = false;
+          } else {
+            this.inString = this.inStrings.pop()!;
+          }
+        }
+        const str = this.SOURCE.substring(this.pos, this.pos + 1);
+        this.pos += 1;
+        return new Token(TokenType.Oper, str, sPos);
+      } else {
+        throw new Error(`Invalid token: '${value}'`);
+      }
+    }
+
+    throw new Error('Unknown error while parsing.');
+  }
+}