Parse functions from string

function parseFunction(funcStr: string): (...args: any[]) => any {
  if (!funcStr || typeof funcStr !== "string") {
    throw new Error("Invalid function string: must be a non-empty string");
  }
  // Remove comments and normalize whitespace
  let cleanStr = funcStr
    .replace(/\/\*[\s\S]*?\*\//g, "") // Remove block comments
    .replace(/\/\/.*$/gm, "") // Remove line comments
    .trim();
  if (!cleanStr) {
    throw new Error("Invalid function string: empty after cleaning");
  }
  let match: RegExpMatchArray | null;
  try {
    // Regular function: function name(params) { body } or function(params) { body }
    match = cleanStr.match(
      /^(?:async\s+)?function\s*[^()]*\(([^)]*)\)\s*{([\s\S]*)}$/,
    );
    if (match) {
      let params = match[1]
        .split(",")
        .map((p) => p.trim())
        .filter(Boolean);
      let body = match[2].trim();
      return new Function(...params, body) as (...args: any[]) => any;
    }
    // Arrow function with braces: (params) => { body }
    match = cleanStr.match(/^(?:async\s+)?\(([^)]*)\)\s*=>\s*{([\s\S]*)}$/);
    if (match) {
      let params = match[1]
        .split(",")
        .map((p) => p.trim())
        .filter(Boolean);
      let body = match[2].trim();
      return new Function(...params, body) as (...args: any[]) => any;
    }
    // Arrow function with single parameter and braces: param => { body }
    match = cleanStr.match(/^(?:async\s+)?([^=\s(]+)\s*=>\s*{([\s\S]*)}$/);
    if (match) {
      let param = match[1].trim();
      let body = match[2].trim();
      return new Function(param, body) as (...args: any[]) => any;
    }
    // Simple arrow function with parentheses: (params) => expression
    match = cleanStr.match(/^(?:async\s+)?\(([^)]*)\)\s*=>\s*(.+)$/);
    if (match) {
      let params = match[1]
        .split(",")
        .map((p) => p.trim())
        .filter(Boolean);
      let expression = match[2].trim();
      return new Function(...params, `return (${expression})`) as (
        ...args: any[]
      ) => any;
    }
    // Single parameter arrow function: param => expression
    match = cleanStr.match(/^(?:async\s+)?([^=\s(]+)\s*=>\s*(.+)$/);
    if (match) {
      let param = match[1].trim();
      let expression = match[2].trim();
      return new Function(param, `return (${expression})`) as (
        ...args: any[]
      ) => any;
    }
    // If no patterns match, throw an error
    throw new Error(`Unsupported function format: ${cleanStr}`);
  } catch (error) {
    if (error instanceof SyntaxError) {
      throw new Error(`Invalid function syntax: ${error.message}`);
    }
    throw new Error(`Failed to create function: ${error.message}`);
  }
}