{
  type: "Program",
  body: [
    {
      type: "VariableDeclaration",
      kind: "let",
      declarations: [
        {
          type: "VariableDeclarator",
          id: { type: "Identifier", name: "x" },
          init: {
            type: "BinaryExpression",
            operator: "+",
            left: { type: "Literal", value: 1 },
            right: { type: "Literal", value: 2 }
          }
        }
      ]
    }
  ]
}

const acorn = require('acorn');
const code = 'let x = 1 + 2;';
const ast = acorn.parse(code, { ecmaVersion: 2025 });
console.log(ast);

const estr*erse = require('estr*erse');
estr*erse.tr*erse(ast, {
  enter: function(node) {
    if (node.type === 'FunctionDeclaration') {
      console.log('Found function:', node.id.name);
    }
  }
});

function tokenize(input) {
  const tokens = [];
  let i = 0;
  while (i < input.length) {
    const char = input[i];
    if (char === '+') {
      tokens.push({ type: 'operator', value: '+' });
      i++;
      continue;
    }
    if (/\d/.test(char)) {
      let num = '';
      while (i < input.length && /\d/.test(input[i])) {
        num += input[i++];
      }
      tokens.push({ type: 'number', value: Number(num) });
      continue;
    }
    if (char === ' ') { i++; continue; }
    throw new Error(`Unknown char: ${char}`);
  }
  return tokens;
}

function parse(tokens) {
  let current = 0;
  const walk = () => {
    let token = tokens[current];
    if (token.type === 'number') {
      current++;
      return {
        type: 'NumberLiteral',
        value: token.value
      };
    }
    token = tokens[current];
    if (token.type === 'operator' && token.value === '+') {
      current++;
      return {
        type: 'BinaryExpression',
        operator: '+',
        left: walk(),
        right: walk()
      };
    }
    throw new Error('Invalid syntax');
  };
  const ast = {
    type: 'Program',
    body: []
  };
  while (current < tokens.length) {
    ast.body.push(walk());
  }
  return ast;
}