1. module recast
   1. function recast.parse (source, options)
   2. function recast.print (node, options)
   3. function recast.visit (node, methods)

module recast

function recast.parse (source, options)

• description and source-code

  function parse(source, options) {
    options = normalizeOptions(options);
  
    var lines = fromString(source, options);
  
    var sourceWithoutTabs = lines.toString({
      tabWidth: options.tabWidth,
      reuseWhitespace: false,
      useTabs: false
    });
  
    var comments = [];
    var program = options.parser.parse(sourceWithoutTabs, {
      jsx: true,
      loc: true,
      locations: true,
      range: options.range,
      comment: true,
      onComment: comments,
      tolerant: options.tolerant,
      ecmaVersion: 6,
      sourceType: 'module'
    });
  
    // If the source was empty, some parsers give loc.{start,end}.line
    // values of 0, instead of the minimum of 1.
    util.fixFaultyLocations(program, lines);
  
    program.loc = program.loc || {
      start: lines.firstPos(),
      end: lines.lastPos()
    };
  
    program.loc.lines = lines;
    program.loc.indent = 0;
  
    // Expand the Program node's .loc to include all comments, since
    // typically its .loc.start and .loc.end will coincide with those of the
    // first and last statements, respectively, excluding any comments that
    // fall outside that region.
    var trueProgramLoc = util.getTrueLoc(program, lines);
    program.loc.start = trueProgramLoc.start;
    program.loc.end = trueProgramLoc.end;
  
    if (program.comments) {
      comments = program.comments;
      delete program.comments;
    }
  
    // In order to ensure we reprint leading and trailing program comments,
    // wrap the original Program node with a File node.
    var file = program;
    if (file.type === "Program") {
      var file = b.file(program, options.sourceFileName || null);
      file.loc = {
        lines: lines,
        indent: 0,
        start: lines.firstPos(),
        end: lines.lastPos()
      };
    } else if (file.type === "File") {
      program = file.program;
    }
  
    // Passing file.program here instead of just file means that initial
    // comments will be attached to program.body[0] instead of program.
    attachComments(
      comments,
      program.body.length ? file.program : file,
      lines
    );
  
    // Return a copy of the original AST so that any changes made may be
    // compared to the original.
    return new TreeCopier(lines).copy(file);
  }

• example usage

  ...
      "  return a +",
      "    // Weird formatting, huh?",
      "    b;",
      "}"
  ].join("\n");
  
  // Parse the code using an interface similar to require("esprima").parse.
  var ast = recast.parse(code);
  ```
  Now do *whatever* you want to `ast`. Really, anything at all!
  
  See [ast-types](https://github.com/benjamn/ast-types) (especially the [def/core.js](https://github.com/benjamn/ast-types/blob/master
  /def/core.js)) module for a thorough overview of the `ast` api.
  ```js
  // Grab a reference to the function declaration we just parsed.
  var add = ast.program.body[0];
  ...

function recast.print (node, options)

• description and source-code

  function print(node, options) {
      return new Printer(options).print(node);
  }

• example usage

  ...
  ]);
  
  // Just for fun, because addition is commutative:
  add.params.push(add.params.shift());
  ```
  When you finish manipulating the AST, let `recast.print` work its magic:
  ```js
  var output = recast.print(ast).code;
  ```
  The `output` string now looks exactly like this, weird formatting and all:
  ```js
  var add = function(b, a) {
  return a +
    // Weird formatting, huh?
    b;
  ...

function recast.visit (node, methods)

• description and source-code

  function visit(node, methods) {
      return PathVisitor.fromMethodsObject(methods).visit(node);
  }

• example usage

  ...
      value: parse
  },
  
  /**
   * Traverse and potentially modify an abstract syntax tree using a
   * convenient visitor syntax:
   *
   *   recast.visit(ast, {
   *     names: [],
   *     visitIdentifier: function(path) {
   *       var node = path.value;
   *       this.visitor.names.push(node.name);
   *       this.traverse(path);
   *     }
   *   });
  ...