text: /**
   * Modules in this bundle
   * @license
   * 
   * call-matcher:
   *   license: MIT
   *   author: Takuto Wada <takuto.wada@gmail.com>
   *   homepage: https://github.com/twada/call-matcher
   *   version: 0.1.0
   * 
   * array-filter:
   *   license: MIT
   *   author: Julian Gruber <mail@juliangruber.com>
   *   maintainers: juliangruber <julian@juliangruber.com>
   *   homepage: https://github.com/juliangruber/array-filter
   *   version: 1.0.0
   * 
   * array-foreach:
   *   license: MIT
   *   author: Takuto Wada <takuto.wada@gmail.com>
   *   maintainers: twada <takuto.wada@gmail.com>
   *   homepage: https://github.com/twada/array-foreach
   *   version: 1.0.1
   * 
   * array-map:
   *   license: MIT
   *   author: James Halliday <mail@substack.net>
   *   maintainers: substack <mail@substack.net>
   *   homepage: https://github.com/substack/array-map
   *   version: 0.0.0
   * 
   * array-reduce:
   *   license: MIT
   *   author: James Halliday <mail@substack.net>
   *   maintainers: substack <mail@substack.net>
   *   homepage: https://github.com/substack/array-reduce
   *   version: 0.0.0
   * 
   * deep-equal:
   *   license: MIT
   *   author: James Halliday <mail@substack.net>
   *   maintainers: substack <mail@substack.net>
   *   homepage: https://github.com/substack/node-deep-equal#readme
   *   version: 1.0.1
   * 
   * espurify:
   *   license: MIT
   *   author: Takuto Wada <takuto.wada@gmail.com>
   *   maintainers: twada <takuto.wada@gmail.com>
   *   homepage: https://github.com/estools/espurify
   *   version: 1.5.0
   * 
   * estraverse:
   *   license: BSD-2-Clause
   *   maintainers: constellation <utatane.tea@gmail.com>, michaelficarra <npm@michael.ficarra.me>, nzakas <nicholas@nczconsulting.com>
   *   homepage: https://github.com/estools/estraverse
   *   version: 4.1.1
   * 
   * indexof:
   *   maintainers: tjholowaychuk <tj@vision-media.ca>
   *   version: 0.0.1
   * 
   * isarray:
   *   license: MIT
   *   author: Julian Gruber <mail@juliangruber.com>
   *   maintainers: juliangruber <julian@juliangruber.com>
   *   homepage: https://github.com/juliangruber/isarray
   *   version: 1.0.0
   * 
   * object-keys:
   *   license: MIT
   *   author: Jordan Harband <ljharb@gmail.com>
   *   maintainers: ljharb <ljharb@gmail.com>
   *   contributors: Jordan Harband <ljharb@gmail.com>, Raynos <raynos2@gmail.com>, Nathan Rajlich <nathan@tootallnate.net>, Ivan Starkov <istarkov@gmail.com>, Gary Katsevman <git@gkatsev.com>
   *   homepage: https://github.com/ljharb/object-keys#readme
   *   version: 1.0.9
   * 
   * xtend:
   *   license: MIT
   *   author: Raynos <raynos2@gmail.com>
   *   maintainers: raynos <raynos2@gmail.com>
   *   contributors: Jake Verbaten, Matt Esch
   *   homepage: https://github.com/Raynos/xtend
   *   version: 4.0.1
   * 
   * This header is generated by licensify (https://github.com/twada/licensify)
   */
  (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.CallMatcher = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw (f.code="MODULE_NOT_FOUND", f)}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
  /**
   * call-matcher:
   *   ECMAScript CallExpression matcher made from function/method signature
   * 
   * https://github.com/twada/call-matcher
   *
   * Copyright (c) 2015 Takuto Wada
   * Licensed under the MIT license.
   *   https://github.com/twada/call-matcher/blob/master/MIT-LICENSE.txt
   */
  'use strict';
  /* jshint -W024 */
  
  var estraverse = _dereq_('estraverse');
  var espurify = _dereq_('espurify');
  var syntax = estraverse.Syntax;
  var hasOwn = Object.prototype.hasOwnProperty;
  var forEach = _dereq_('array-foreach');
  var map = _dereq_('array-map');
  var filter = _dereq_('array-filter');
  var reduce = _dereq_('array-reduce');
  var indexOf = _dereq_('indexof');
  var deepEqual = _dereq_('deep-equal');
  var notCallExprMessage = 'Argument should be in the form of CallExpression';
  var duplicatedArgMessage = 'Duplicate argument name: ';
  var invalidFormMessage = 'Argument should be in the form of `name` or `[name]`';
  
  function CallMatcher (signatureAst, options) {
      validateApiExpression(signatureAst);
      this.visitorKeys = options.visitorKeys || estraverse.VisitorKeys;
      if (options.astWhiteList) {
          this.purifyAst = espurify.cloneWithWhitelist(options.astWhiteList);
      } else {
          this.purifyAst = espurify;
      }
      this.signatureAst = signatureAst;
      this.signatureCalleeDepth = astDepth(signatureAst.callee, this.visitorKeys);
      this.numMaxArgs = this.signatureAst.arguments.length;
      this.numMinArgs = filter(this.signatureAst.arguments, identifiers).length;
  }
  
  CallMatcher.prototype.test = function (currentNode) {
      var calleeMatched = this.isCalleeMatched(currentNode);
      var numArgs;
      if (calleeMatched) {
          numArgs = currentNode.arguments.length;
          return this.numMinArgs <= numArgs && numArgs <= this.numMaxArgs;
      }
      return false;
  };
  
  CallMatcher.prototype.matchArgument = function (currentNode, parentNode) {
      if (isCalleeOfParent(currentNode, parentNode)) {
          return null;
      }
      if (this.test(parentNode)) {
          var indexOfCurrentArg = indexOf(parentNode.arguments, currentNode);
          var numOptional = parentNode.arguments.length - this.numMinArgs;
          var matchedSignatures = reduce(this.argumentSignatures(), function (accum, argSig) {
              if (argSig.kind === 'mandatory') {
                  accum.push(argSig);
              }
              if (argSig.kind === 'optional' && 0 < numOptional) {
                  numOptional -= 1;
                  accum.push(argSig);
              }
              return accum;
          }, []);
          return matchedSignatures[indexOfCurrentArg];
      }
      return null;
  };
  
  CallMatcher.prototype.calleeAst = function () {
      return this.purifyAst(this.signatureAst.callee);
  };
  
  CallMatcher.prototype.argumentSignatures = function () {
      return map(this.signatureAst.arguments, toArgumentSignature);
  };
  
  CallMatcher.prototype.isCalleeMatched = function (node) {
      if (!isCallExpression(node)) {
          return false;
      }
      if (!this.isSameDepthAsSignatureCallee(node.callee)) {
          return false;
      }
      return deepEqual(this.purifyAst(this.signatureAst.callee), this.purifyAst(node.callee));
  };
  
  CallMatcher.prototype.isSameDepthAsSignatureCallee = function (ast) {
      var depth = this.signatureCalleeDepth;
      var currentDepth = 0;
      estraverse.traverse(ast, {
          keys: this.visitorKeys,
          enter: function (currentNode, parentNode) {
              var path = this.path();
              var pathDepth = path ? path.length : 0;
              if (currentDepth < pathDepth) {
                  currentDepth = pathDepth;
              }
              if (depth < currentDepth) {
                  this['break']();
              }
          }
      });
      return (depth === currentDepth);
  };
  
  function toArgumentSignature (argSignatureNode) {
      switch(argSignatureNode.type) {
      case syntax.Identifier:
          return {
              name: argSignatureNode.name,
              kind: 'mandatory'
          };
      case syntax.ArrayExpression:
          return {
              name: argSignatureNode.elements[0].name,
              kind: 'optional'
          };
      default:
          return null;
      }
  }
  
  function astDepth (ast, visitorKeys) {
      var maxDepth = 0;
      estraverse.traverse(ast, {
          keys: visitorKeys,
          enter: function (currentNode, parentNode) {
              var path = this.path();
              var pathDepth = path ? path.length : 0;
              if (maxDepth < pathDepth) {
                  maxDepth = pathDepth;
              }
          }
      });
      return maxDepth;
  }
  
  function isCallExpression (node) {
      return node && node.type === syntax.CallExpression;
  }
  
  function isCalleeOfParent(currentNode, parentNode) {
      return parentNode && currentNode &&
          parentNode.type === syntax.CallExpression &&
          parentNode.callee === currentNode;
  }
  
  function identifiers (node) {
      return node.type === syntax.Identifier;
  }
  
  function validateApiExpression (callExpression) {
      if (!callExpression || !callExpression.type) {
          throw new Error(notCallExprMessage);
      }
      if (callExpression.type !== syntax.CallExpression) {
          throw new Error(notCallExprMessage);
      }
      var names = {};
      forEach(callExpression.arguments, function (arg) {
          var name = validateArg(arg);
          if (hasOwn.call(names, name)) {
              throw new Error(duplicatedArgMessage + name);
          } else {
              names[name] = name;
          }
      });
  }
  
  function validateArg (arg) {
      var inner;
      switch(arg.type) {
      case syntax.Identifier:
          return arg.name;
      case syntax.ArrayExpression:
          if (arg.elements.length !== 1) {
              throw new Error(invalidFormMessage);
          }
          inner = arg.elements[0];
          if (inner.type !== syntax.Identifier) {
              throw new Error(invalidFormMessage);
          }
          return inner.name;
      default:
          throw new Error(invalidFormMessage);
      }
  }
  
  module.exports = CallMatcher;
  
  },{"array-filter":2,"array-foreach":3,"array-map":4,"array-reduce":5,"deep-equal":6,"espurify":9,"estraverse":13,"indexof":15}],2:[function(_dereq_,module,exports){
  
  /**
   * Array#filter.
   *
   * @param {Array} arr
   * @param {Function} fn
   * @param {Object=} self
   * @return {Array}
   * @throw TypeError
   */
  
  module.exports = function (arr, fn, self) {
    if (arr.filter) return arr.filter(fn, self);
    if (void 0 === arr || null === arr) throw new TypeError;
    if ('function' != typeof fn) throw new TypeError;
    var ret = [];
    for (var i = 0; i < arr.length; i++) {
      if (!hasOwn.call(arr, i)) continue;
      var val = arr[i];
      if (fn.call(self, val, i, arr)) ret.push(val);
    }
    return ret;
  };
  
  var hasOwn = Object.prototype.hasOwnProperty;
  
  },{}],3:[function(_dereq_,module,exports){
  /**
   * array-foreach
   *   Array#forEach ponyfill for older browsers
   *   (Ponyfill: A polyfill that doesn't overwrite the native method)
   * 
   * https://github.com/twada/array-foreach
   *
   * Copyright (c) 2015 Takuto Wada
   * Licensed under the MIT license.
   *   http://twada.mit-license.org/
   */
  'use strict';
  
  module.exports = function forEach (ary, callback, thisArg) {
      if (ary.forEach) {
          ary.forEach(callback, thisArg);
          return;
      }
      for (var i = 0; i < ary.length; i+=1) {
          callback.call(thisArg, ary[i], i, ary);
      }
  };
  
  },{}],4:[function(_dereq_,module,exports){
  module.exports = function (xs, f) {
      if (xs.map) return xs.map(f);
      var res = [];
      for (var i = 0; i < xs.length; i++) {
          var x = xs[i];
          if (hasOwn.call(xs, i)) res.push(f(x, i, xs));
      }
      return res;
  };
  
  var hasOwn = Object.prototype.hasOwnProperty;
  
  },{}],5:[function(_dereq_,module,exports){
  var hasOwn = Object.prototype.hasOwnProperty;
  
  module.exports = function (xs, f, acc) {
      var hasAcc = arguments.length >= 3;
      if (hasAcc && xs.reduce) return xs.reduce(f, acc);
      if (xs.reduce) return xs.reduce(f);
      
      for (var i = 0; i < xs.length; i++) {
          if (!hasOwn.call(xs, i)) continue;
          if (!hasAcc) {
              acc = xs[i];
              hasAcc = true;
              continue;
          }
          acc = f(acc, xs[i], i);
      }
      return acc;
  };
  
  },{}],6:[function(_dereq_,module,exports){
  var pSlice = Array.prototype.slice;
  var objectKeys = _dereq_('./lib/keys.js');
  var isArguments = _dereq_('./lib/is_arguments.js');
  
  var deepEqual = module.exports = function (actual, expected, opts) {
    if (!opts) opts = {};
    // 7.1. All identical values are equivalent, as determined by ===.
    if (actual === expected) {
      return true;
  
    } else if (actual instanceof Date && expected instanceof Date) {
      return actual.getTime() === expected.getTime();
  
    // 7.3. Other pairs that do not both pass typeof value == 'object',
    // equivalence is determined by ==.
    } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {
      return opts.strict ? actual === expected : actual == expected;
  
    // 7.4. For all other Object pairs, including Array objects, equivalence is
    // determined by having the same number of owned properties (as verified
    // with Object.prototype.hasOwnProperty.call), the same set of keys
    // (although not necessarily the same order), equivalent values for every
    // corresponding key, and an identical 'prototype' property. Note: this
    // accounts for both named and indexed properties on Arrays.
    } else {
      return objEquiv(actual, expected, opts);
    }
  }
  
  function isUndefinedOrNull(value) {
    return value === null || value === undefined;
  }
  
  function isBuffer (x) {
    if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;
    if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
      return false;
    }
    if (x.length > 0 && typeof x[0] !== 'number') return false;
    return true;
  }
  
  function objEquiv(a, b, opts) {
    var i, key;
    if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
      return false;
    // an identical 'prototype' property.
    if (a.prototype !== b.prototype) return false;
    //~~~I've managed to break Object.keys through screwy arguments passing.
    //   Converting to array solves the problem.
    if (isArguments(a)) {
      if (!isArguments(b)) {
        return false;
      }
      a = pSlice.call(a);
      b = pSlice.call(b);
      return deepEqual(a, b, opts);
    }
    if (isBuffer(a)) {
      if (!isBuffer(b)) {
        return false;
      }
      if (a.length !== b.length) return false;
      for (i = 0; i < a.length; i++) {
        if (a[i] !== b[i]) return false;
      }
      return true;
    }
    try {
      var ka = objectKeys(a),
          kb = objectKeys(b);
    } catch (e) {//happens when one is a string literal and the other isn't
      return false;
    }
    // having the same number of owned properties (keys incorporates
    // hasOwnProperty)
    if (ka.length != kb.length)
      return false;
    //the same set of keys (although not necessarily the same order),
    ka.sort();
    kb.sort();
    //~~~cheap key test
    for (i = ka.length - 1; i >= 0; i--) {
      if (ka[i] != kb[i])
        return false;
    }
    //equivalent values for every corresponding key, and
    //~~~possibly expensive deep test
    for (i = ka.length - 1; i >= 0; i--) {
      key = ka[i];
      if (!deepEqual(a[key], b[key], opts)) return false;
    }
    return typeof a === typeof b;
  }
  
  },{"./lib/is_arguments.js":7,"./lib/keys.js":8}],7:[function(_dereq_,module,exports){
  var supportsArgumentsClass = (function(){
    return Object.prototype.toString.call(arguments)
  })() == '[object Arguments]';
  
  exports = module.exports = supportsArgumentsClass ? supported : unsupported;
  
  exports.supported = supported;
  function supported(object) {
    return Object.prototype.toString.call(object) == '[object Arguments]';
  };
  
  exports.unsupported = unsupported;
  function unsupported(object){
    return object &&
      typeof object == 'object' &&
      typeof object.length == 'number' &&
      Object.prototype.hasOwnProperty.call(object, 'callee') &&
      !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||
      false;
  };
  
  },{}],8:[function(_dereq_,module,exports){
  exports = module.exports = typeof Object.keys === 'function'
    ? Object.keys : shim;
  
  exports.shim = shim;
  function shim (obj) {
    var keys = [];
    for (var key in obj) keys.push(key);
    return keys;
  }
  
  },{}],9:[function(_dereq_,module,exports){
  /**
   * espurify - Clone new AST without extra properties
   * 
   * https://github.com/estools/espurify
   *
   * Copyright (c) 2014-2015 Takuto Wada
   * Licensed under the MIT license.
   *   https://github.com/estools/espurify/blob/master/MIT-LICENSE.txt
   */
  'use strict';
  
  var createWhitelist = _dereq_('./lib/create-whitelist');
  var cloneWithWhitelist = _dereq_('./lib/clone-ast');
  
  function createCloneFunction (options) {
      return cloneWithWhitelist(createWhitelist(options));
  }
  
  var espurify = createCloneFunction();
  espurify.customize = createCloneFunction;
  espurify.cloneWithWhitelist = cloneWithWhitelist;
  module.exports = espurify;
  
  },{"./lib/clone-ast":11,"./lib/create-whitelist":12}],10:[function(_dereq_,module,exports){
  module.exports = {
      ArrayExpression: ['type', 'elements'],
      ArrayPattern: ['type', 'elements'],
      ArrowFunctionExpression: ['type', 'id', 'params', 'body', 'generator', 'expression'],
      AssignmentExpression: ['type', 'operator', 'left', 'right'],
      AssignmentPattern: ['type', 'left', 'right'],
      BinaryExpression: ['type', 'operator', 'left', 'right'],
      BlockStatement: ['type', 'body'],
      BreakStatement: ['type', 'label'],
      CallExpression: ['type', 'callee', 'arguments'],
      CatchClause: ['type', 'param', 'guard', 'body'],
      ClassBody: ['type', 'body'],
      ClassDeclaration: ['type', 'id', 'superClass', 'body'],
      ClassExpression: ['type', 'id', 'superClass', 'body'],
      ConditionalExpression: ['type', 'test', 'alternate', 'consequent'],
      ContinueStatement: ['type', 'label'],
      DebuggerStatement: ['type'],
      DoWhileStatement: ['type', 'body', 'test'],
      EmptyStatement: ['type'],
      ExportAllDeclaration: ['type', 'source'],
      ExportDefaultDeclaration: ['type', 'declaration'],
      ExportNamedDeclaration: ['type', 'declaration', 'specifiers', 'source'],
      ExportSpecifier: ['type', 'exported', 'local'],
      ExpressionStatement: ['type', 'expression'],
      ForInStatement: ['type', 'left', 'right', 'body'],
      ForOfStatement: ['type', 'left', 'right', 'body'],
      ForStatement: ['type', 'init', 'test', 'update', 'body'],
      FunctionDeclaration: ['type', 'id', 'params', 'body', 'generator'],
      FunctionExpression: ['type', 'id', 'params', 'body', 'generator'],
      Identifier: ['type', 'name'],
      IfStatement: ['type', 'test', 'consequent', 'alternate'],
      ImportDeclaration: ['type', 'specifiers', 'source'],
      ImportDefaultSpecifier: ['type', 'local'],
      ImportNamespaceSpecifier: ['type', 'local'],
      ImportSpecifier: ['type', 'imported', 'local'],
      LabeledStatement: ['type', 'label', 'body'],
      Literal: ['type', 'value', 'regex'],
      LogicalExpression: ['type', 'operator', 'left', 'right'],
      MemberExpression: ['type', 'object', 'property', 'computed'],
      MetaProperty: ['type', 'meta', 'property'],
      MethodDefinition: ['type', 'key', 'value', 'kind', 'computed', 'static'],
      NewExpression: ['type', 'callee', 'arguments'],
      ObjectExpression: ['type', 'properties'],
      ObjectPattern: ['type', 'properties'],
      Program: ['type', 'body', 'sourceType'],
      Property: ['type', 'key', 'value', 'kind', 'method', 'shorthand', 'computed'],
      RestElement: ['type', 'argument'],
      ReturnStatement: ['type', 'argument'],
      SequenceExpression: ['type', 'expressions'],
      SpreadElement: ['type', 'argument'],
      Super: ['type'],
      SwitchCase: ['type', 'test', 'consequent'],
      SwitchStatement: ['type', 'discriminant', 'cases', 'lexical'],
      TaggedTemplateExpression: ['type', 'tag', 'quasi'],
      TemplateElement: ['type', 'tail', 'value'],
      TemplateLiteral: ['type', 'quasis', 'expressions'],
      ThisExpression: ['type'],
      ThrowStatement: ['type', 'argument'],
      TryStatement: ['type', 'block', 'handler', 'finalizer'],
      UnaryExpression: ['type', 'operator', 'prefix', 'argument'],
      UpdateExpression: ['type', 'operator', 'argument', 'prefix'],
      VariableDeclaration: ['type', 'declarations', 'kind'],
      VariableDeclarator: ['type', 'id', 'init'],
      WhileStatement: ['type', 'test', 'body'],
      WithStatement: ['type', 'object', 'body'],
      YieldExpression: ['type', 'argument', 'delegate']
  };
  
  },{}],11:[function(_dereq_,module,exports){
  'use strict';
  
  var isArray = _dereq_('isarray');
  var objectKeys = _dereq_('object-keys');
  var indexOf = _dereq_('indexof');
  var reduce = _dereq_('array-reduce');
  
  module.exports = function cloneWithWhitelist (astWhiteList) {
      var whitelist = reduce(objectKeys(astWhiteList), function (props, key) {
          var currentProps = astWhiteList[key];
          var prepend = [];
          if (indexOf(currentProps, 'type') === -1) {
              prepend.push('type');
          }
          props[key] = prepend.concat(currentProps);
          return props;
      }, {});
  
      function cloneRoot (ast) {
          return cloneContainer({}, ast);
      }
  
      function cloneContainer (collector, obj) {
          if (isArray(obj)) {
              return cloneArray(collector, obj);
          } else if (obj.type && whitelist[obj.type]) {
              return cloneNode(collector, obj);
          } else {
              return cloneObj(collector, obj);
          }
      }
  
      function cloneArray (collector, ary) {
          var i, len;
          for (i = 0, len = ary.length; i < len; i += 1) {
              collector.push(cloneOf(ary[i]));
          }
          return collector;
      }
  
      function cloneNode (collector, obj) {
          var i, len, props = whitelist[obj.type];
          for (i = 0, len = props.length; i < len; i += 1) {
              cloneProperty(collector, obj, props[i]);
          }
          return collector;
      }
  
      function cloneObj (collector, obj) {
          var key;
          for (key in obj) {
              cloneProperty(collector, obj, key);
          }
          return collector;
      }
  
      function cloneProperty (collector, obj, key) {
          if (obj.hasOwnProperty(key)) {
              collector[key] = cloneOf(obj[key]);
          }
      }
  
      function cloneOf (val) {
          if (typeof val === 'object' && val !== null) {
              if (val instanceof RegExp) {
                  return new RegExp(val);
              } else {
                  return cloneContainer(isArray(val) ? [] : {}, val);
              }
          } else {
              return val;
          }
      }
  
      return cloneRoot;
  };
  
  },{"array-reduce":5,"indexof":15,"isarray":16,"object-keys":17}],12:[function(_dereq_,module,exports){
  'use strict';
  
  var defaultProps = _dereq_('./ast-properties');
  var objectKeys = _dereq_('object-keys');
  var extend = _dereq_('xtend');
  
  module.exports = function createWhitelist (options) {
      var opts = extend({}, options);
      var typeName, i, len;
      var keys = objectKeys(defaultProps);
      var result = {};
      for (i = 0, len = keys.length; i < len; i += 1) {
          typeName = keys[i];
          result[typeName] = [].concat(defaultProps[typeName]).concat(opts.extra);
      }
      return result;
  };
  
  },{"./ast-properties":10,"object-keys":17,"xtend":19}],13:[function(_dereq_,module,exports){
  /*
    Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
    Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
  
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are met:
  
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
  
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
  /*jslint vars:false, bitwise:true*/
  /*jshint indent:4*/
  /*global exports:true*/
  (function clone(exports) {
      'use strict';
  
      var Syntax,
          isArray,
          VisitorOption,
          VisitorKeys,
          objectCreate,
          objectKeys,
          BREAK,
          SKIP,
          REMOVE;
  
      function ignoreJSHintError() { }
  
      isArray = Array.isArray;
      if (!isArray) {
          isArray = function isArray(array) {
              return Object.prototype.toString.call(array) === '[object Array]';
          };
      }
  
      function deepCopy(obj) {
          var ret = {}, key, val;
          for (key in obj) {
              if (obj.hasOwnProperty(key)) {
                  val = obj[key];
                  if (typeof val === 'object' && val !== null) {
                      ret[key] = deepCopy(val);
                  } else {
                      ret[key] = val;
                  }
              }
          }
          return ret;
      }
  
      function shallowCopy(obj) {
          var ret = {}, key;
          for (key in obj) {
              if (obj.hasOwnProperty(key)) {
                  ret[key] = obj[key];
              }
          }
          return ret;
      }
      ignoreJSHintError(shallowCopy);
  
      // based on LLVM libc++ upper_bound / lower_bound
      // MIT License
  
      function upperBound(array, func) {
          var diff, len, i, current;
  
          len = array.length;
          i = 0;
  
          while (len) {
              diff = len >>> 1;
              current = i + diff;
              if (func(array[current])) {
                  len = diff;
              } else {
                  i = current + 1;
                  len -= diff + 1;
              }
          }
          return i;
      }
  
      function lowerBound(array, func) {
          var diff, len, i, current;
  
          len = array.length;
          i = 0;
  
          while (len) {
              diff = len >>> 1;
              current = i + diff;
              if (func(array[current])) {
                  i = current + 1;
                  len -= diff + 1;
              } else {
                  len = diff;
              }
          }
          return i;
      }
      ignoreJSHintError(lowerBound);
  
      objectCreate = Object.create || (function () {
          function F() { }
  
          return function (o) {
              F.prototype = o;
              return new F();
          };
      })();
  
      objectKeys = Object.keys || function (o) {
          var keys = [], key;
          for (key in o) {
              keys.push(key);
          }
          return keys;
      };
  
      function extend(to, from) {
          var keys = objectKeys(from), key, i, len;
          for (i = 0, len = keys.length; i < len; i += 1) {
              key = keys[i];
              to[key] = from[key];
          }
          return to;
      }
  
      Syntax = {
          AssignmentExpression: 'AssignmentExpression',
          AssignmentPattern: 'AssignmentPattern',
          ArrayExpression: 'ArrayExpression',
          ArrayPattern: 'ArrayPattern',
          ArrowFunctionExpression: 'ArrowFunctionExpression',
          AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
          BlockStatement: 'BlockStatement',
          BinaryExpression: 'BinaryExpression',
          BreakStatement: 'BreakStatement',
          CallExpression: 'CallExpression',
          CatchClause: 'CatchClause',
          ClassBody: 'ClassBody',
          ClassDeclaration: 'ClassDeclaration',
          ClassExpression: 'ClassExpression',
          ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
          ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
          ConditionalExpression: 'ConditionalExpression',
          ContinueStatement: 'ContinueStatement',
          DebuggerStatement: 'DebuggerStatement',
          DirectiveStatement: 'DirectiveStatement',
          DoWhileStatement: 'DoWhileStatement',
          EmptyStatement: 'EmptyStatement',
          ExportAllDeclaration: 'ExportAllDeclaration',
          ExportDefaultDeclaration: 'ExportDefaultDeclaration',
          ExportNamedDeclaration: 'ExportNamedDeclaration',
          ExportSpecifier: 'ExportSpecifier',
          ExpressionStatement: 'ExpressionStatement',
          ForStatement: 'ForStatement',
          ForInStatement: 'ForInStatement',
          ForOfStatement: 'ForOfStatement',
          FunctionDeclaration: 'FunctionDeclaration',
          FunctionExpression: 'FunctionExpression',
          GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
          Identifier: 'Identifier',
          IfStatement: 'IfStatement',
          ImportDeclaration: 'ImportDeclaration',
          ImportDefaultSpecifier: 'ImportDefaultSpecifier',
          ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
          ImportSpecifier: 'ImportSpecifier',
          Literal: 'Literal',
          LabeledStatement: 'LabeledStatement',
          LogicalExpression: 'LogicalExpression',
          MemberExpression: 'MemberExpression',
          MetaProperty: 'MetaProperty',
          MethodDefinition: 'MethodDefinition',
          ModuleSpecifier: 'ModuleSpecifier',
          NewExpression: 'NewExpression',
          ObjectExpression: 'ObjectExpression',
          ObjectPattern: 'ObjectPattern',
          Program: 'Program',
          Property: 'Property',
          RestElement: 'RestElement',
          ReturnStatement: 'ReturnStatement',
          SequenceExpression: 'SequenceExpression',
          SpreadElement: 'SpreadElement',
          Super: 'Super',
          SwitchStatement: 'SwitchStatement',
          SwitchCase: 'SwitchCase',
          TaggedTemplateExpression: 'TaggedTemplateExpression',
          TemplateElement: 'TemplateElement',
          TemplateLiteral: 'TemplateLiteral',
          ThisExpression: 'ThisExpression',
          ThrowStatement: 'ThrowStatement',
          TryStatement: 'TryStatement',
          UnaryExpression: 'UnaryExpression',
          UpdateExpression: 'UpdateExpression',
          VariableDeclaration: 'VariableDeclaration',
          VariableDeclarator: 'VariableDeclarator',
          WhileStatement: 'WhileStatement',
          WithStatement: 'WithStatement',
          YieldExpression: 'YieldExpression'
      };
  
      VisitorKeys = {
          AssignmentExpression: ['left', 'right'],
          AssignmentPattern: ['left', 'right'],
          ArrayExpression: ['elements'],
          ArrayPattern: ['elements'],
          ArrowFunctionExpression: ['params', 'body'],
          AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
          BlockStatement: ['body'],
          BinaryExpression: ['left', 'right'],
          BreakStatement: ['label'],
          CallExpression: ['callee', 'arguments'],
          CatchClause: ['param', 'body'],
          ClassBody: ['body'],
          ClassDeclaration: ['id', 'superClass', 'body'],
          ClassExpression: ['id', 'superClass', 'body'],
          ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
          ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
          ConditionalExpression: ['test', 'consequent', 'alternate'],
          ContinueStatement: ['label'],
          DebuggerStatement: [],
          DirectiveStatement: [],
          DoWhileStatement: ['body', 'test'],
          EmptyStatement: [],
          ExportAllDeclaration: ['source'],
          ExportDefaultDeclaration: ['declaration'],
          ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
          ExportSpecifier: ['exported', 'local'],
          ExpressionStatement: ['expression'],
          ForStatement: ['init', 'test', 'update', 'body'],
          ForInStatement: ['left', 'right', 'body'],
          ForOfStatement: ['left', 'right', 'body'],
          FunctionDeclaration: ['id', 'params', 'body'],
          FunctionExpression: ['id', 'params', 'body'],
          GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
          Identifier: [],
          IfStatement: ['test', 'consequent', 'alternate'],
          ImportDeclaration: ['specifiers', 'source'],
          ImportDefaultSpecifier: ['local'],
          ImportNamespaceSpecifier: ['local'],
          ImportSpecifier: ['imported', 'local'],
          Literal: [],
          LabeledStatement: ['label', 'body'],
          LogicalExpression: ['left', 'right'],
          MemberExpression: ['object', 'property'],
          MetaProperty: ['meta', 'property'],
          MethodDefinition: ['key', 'value'],
          ModuleSpecifier: [],
          NewExpression: ['callee', 'arguments'],
          ObjectExpression: ['properties'],
          ObjectPattern: ['properties'],
          Program: ['body'],
          Property: ['key', 'value'],
          RestElement: [ 'argument' ],
          ReturnStatement: ['argument'],
          SequenceExpression: ['expressions'],
          SpreadElement: ['argument'],
          Super: [],
          SwitchStatement: ['discriminant', 'cases'],
          SwitchCase: ['test', 'consequent'],
          TaggedTemplateExpression: ['tag', 'quasi'],
          TemplateElement: [],
          TemplateLiteral: ['quasis', 'expressions'],
          ThisExpression: [],
          ThrowStatement: ['argument'],
          TryStatement: ['block', 'handler', 'finalizer'],
          UnaryExpression: ['argument'],
          UpdateExpression: ['argument'],
          VariableDeclaration: ['declarations'],
          VariableDeclarator: ['id', 'init'],
          WhileStatement: ['test', 'body'],
          WithStatement: ['object', 'body'],
          YieldExpression: ['argument']
      };
  
      // unique id
      BREAK = {};
      SKIP = {};
      REMOVE = {};
  
      VisitorOption = {
          Break: BREAK,
          Skip: SKIP,
          Remove: REMOVE
      };
  
      function Reference(parent, key) {
          this.parent = parent;
          this.key = key;
      }
  
      Reference.prototype.replace = function replace(node) {
          this.parent[this.key] = node;
      };
  
      Reference.prototype.remove = function remove() {
          if (isArray(this.parent)) {
              this.parent.splice(this.key, 1);
              return true;
          } else {
              this.replace(null);
              return false;
          }
      };
  
      function Element(node, path, wrap, ref) {
          this.node = node;
          this.path = path;
          this.wrap = wrap;
          this.ref = ref;
      }
  
      function Controller() { }
  
      // API:
      // return property path array from root to current node
      Controller.prototype.path = function path() {
          var i, iz, j, jz, result, element;
  
          function addToPath(result, path) {
              if (isArray(path)) {
                  for (j = 0, jz = path.length; j < jz; ++j) {
                      result.push(path[j]);
                  }
              } else {
                  result.push(path);
              }
          }
  
          // root node
          if (!this.__current.path) {
              return null;
          }
  
          // first node is sentinel, second node is root element
          result = [];
          for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
              element = this.__leavelist[i];
              addToPath(result, element.path);
          }
          addToPath(result, this.__current.path);
          return result;
      };
  
      // API:
      // return type of current node
      Controller.prototype.type = function () {
          var node = this.current();
          return node.type || this.__current.wrap;
      };
  
      // API:
      // return array of parent elements
      Controller.prototype.parents = function parents() {
          var i, iz, result;
  
          // first node is sentinel
          result = [];
          for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
              result.push(this.__leavelist[i].node);
          }
  
          return result;
      };
  
      // API:
      // return current node
      Controller.prototype.current = function current() {
          return this.__current.node;
      };
  
      Controller.prototype.__execute = function __execute(callback, element) {
          var previous, result;
  
          result = undefined;
  
          previous  = this.__current;
          this.__current = element;
          this.__state = null;
          if (callback) {
              result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
          }
          this.__current = previous;
  
          return result;
      };
  
      // API:
      // notify control skip / break
      Controller.prototype.notify = function notify(flag) {
          this.__state = flag;
      };
  
      // API:
      // skip child nodes of current node
      Controller.prototype.skip = function () {
          this.notify(SKIP);
      };
  
      // API:
      // break traversals
      Controller.prototype['break'] = function () {
          this.notify(BREAK);
      };
  
      // API:
      // remove node
      Controller.prototype.remove = function () {
          this.notify(REMOVE);
      };
  
      Controller.prototype.__initialize = function(root, visitor) {
          this.visitor = visitor;
          this.root = root;
          this.__worklist = [];
          this.__leavelist = [];
          this.__current = null;
          this.__state = null;
          this.__fallback = visitor.fallback === 'iteration';
          this.__keys = VisitorKeys;
          if (visitor.keys) {
              this.__keys = extend(objectCreate(this.__keys), visitor.keys);
          }
      };
  
      function isNode(node) {
          if (node == null) {
              return false;
          }
          return typeof node === 'object' && typeof node.type === 'string';
      }
  
      function isProperty(nodeType, key) {
          return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
      }
  
      Controller.prototype.traverse = function traverse(root, visitor) {
          var worklist,
              leavelist,
              element,
              node,
              nodeType,
              ret,
              key,
              current,
              current2,
              candidates,
              candidate,
              sentinel;
  
          this.__initialize(root, visitor);
  
          sentinel = {};
  
          // reference
          worklist = this.__worklist;
          leavelist = this.__leavelist;
  
          // initialize
          worklist.push(new Element(root, null, null, null));
          leavelist.push(new Element(null, null, null, null));
  
          while (worklist.length) {
              element = worklist.pop();
  
              if (element === sentinel) {
                  element = leavelist.pop();
  
                  ret = this.__execute(visitor.leave, element);
  
                  if (this.__state === BREAK || ret === BREAK) {
                      return;
                  }
                  continue;
              }
  
              if (element.node) {
  
                  ret = this.__execute(visitor.enter, element);
  
                  if (this.__state === BREAK || ret === BREAK) {
                      return;
                  }
  
                  worklist.push(sentinel);
                  leavelist.push(element);
  
                  if (this.__state === SKIP || ret === SKIP) {
                      continue;
                  }
  
                  node = element.node;
                  nodeType = node.type || element.wrap;
                  candidates = this.__keys[nodeType];
                  if (!candidates) {
                      if (this.__fallback) {
                          candidates = objectKeys(node);
                      } else {
                          throw new Error('Unknown node type ' + nodeType + '.');
                      }
                  }
  
                  current = candidates.length;
                  while ((current -= 1) >= 0) {
                      key = candidates[current];
                      candidate = node[key];
                      if (!candidate) {
                          continue;
                      }
  
                      if (isArray(candidate)) {
                          current2 = candidate.length;
                          while ((current2 -= 1) >= 0) {
                              if (!candidate[current2]) {
                                  continue;
                              }
                              if (isProperty(nodeType, candidates[current])) {
                                  element = new Element(candidate[current2], [key, current2], 'Property', null);
                              } else if (isNode(candidate[current2])) {
                                  element = new Element(candidate[current2], [key, current2], null, null);
                              } else {
                                  continue;
                              }
                              worklist.push(element);
                          }
                      } else if (isNode(candidate)) {
                          worklist.push(new Element(candidate, key, null, null));
                      }
                  }
              }
          }
      };
  
      Controller.prototype.replace = function replace(root, visitor) {
          function removeElem(element) {
              var i,
                  key,
                  nextElem,
                  parent;
  
              if (element.ref.remove()) {
                  // When the reference is an element of an array.
                  key = element.ref.key;
                  parent = element.ref.parent;
  
                  // If removed from array, then decrease following items' keys.
                  i = worklist.length;
                  while (i--) {
                      nextElem = worklist[i];
                      if (nextElem.ref && nextElem.ref.parent === parent) {
                          if  (nextElem.ref.key < key) {
                              break;
                          }
                          --nextElem.ref.key;
                      }
                  }
              }
          }
  
          var worklist,
              leavelist,
              node,
              nodeType,
              target,
              element,
              current,
              current2,
              candidates,
              candidate,
              sentinel,
              outer,
              key;
  
          this.__initialize(root, visitor);
  
          sentinel = {};
  
          // reference
          worklist = this.__worklist;
          leavelist = this.__leavelist;
  
          // initialize
          outer = {
              root: root
          };
          element = new Element(root, null, null, new Reference(outer, 'root'));
          worklist.push(element);
          leavelist.push(element);
  
          while (worklist.length) {
              element = worklist.pop();
  
              if (element === sentinel) {
                  element = leavelist.pop();
  
                  target = this.__execute(visitor.leave, element);
  
                  // node may be replaced with null,
                  // so distinguish between undefined and null in this place
                  if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
                      // replace
                      element.ref.replace(target);
                  }
  
                  if (this.__state === REMOVE || target === REMOVE) {
                      removeElem(element);
                  }
  
                  if (this.__state === BREAK || target === BREAK) {
                      return outer.root;
                  }
                  continue;
              }
  
              target = this.__execute(visitor.enter, element);
  
              // node may be replaced with null,
              // so distinguish between undefined and null in this place
              if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
                  // replace
                  element.ref.replace(target);
                  element.node = target;
              }
  
              if (this.__state === REMOVE || target === REMOVE) {
                  removeElem(element);
                  element.node = null;
              }
  
              if (this.__state === BREAK || target === BREAK) {
                  return outer.root;
              }
  
              // node may be null
              node = element.node;
              if (!node) {
                  continue;
              }
  
              worklist.push(sentinel);
              leavelist.push(element);
  
              if (this.__state === SKIP || target === SKIP) {
                  continue;
              }
  
              nodeType = node.type || element.wrap;
              candidates = this.__keys[nodeType];
              if (!candidates) {
                  if (this.__fallback) {
                      candidates = objectKeys(node);
                  } else {
                      throw new Error('Unknown node type ' + nodeType + '.');
                  }
              }
  
              current = candidates.length;
              while ((current -= 1) >= 0) {
                  key = candidates[current];
                  candidate = node[key];
                  if (!candidate) {
                      continue;
                  }
  
                  if (isArray(candidate)) {
                      current2 = candidate.length;
                      while ((current2 -= 1) >= 0) {
                          if (!candidate[current2]) {
                              continue;
                          }
                          if (isProperty(nodeType, candidates[current])) {
                              element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
                          } else if (isNode(candidate[current2])) {
                              element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
                          } else {
                              continue;
                          }
                          worklist.push(element);
                      }
                  } else if (isNode(candidate)) {
                      worklist.push(new Element(candidate, key, null, new Reference(node, key)));
                  }
              }
          }
  
          return outer.root;
      };
  
      function traverse(root, visitor) {
          var controller = new Controller();
          return controller.traverse(root, visitor);
      }
  
      function replace(root, visitor) {
          var controller = new Controller();
          return controller.replace(root, visitor);
      }
  
      function extendCommentRange(comment, tokens) {
          var target;
  
          target = upperBound(tokens, function search(token) {
              return token.range[0] > comment.range[0];
          });
  
          comment.extendedRange = [comment.range[0], comment.range[1]];
  
          if (target !== tokens.length) {
              comment.extendedRange[1] = tokens[target].range[0];
          }
  
          target -= 1;
          if (target >= 0) {
              comment.extendedRange[0] = tokens[target].range[1];
          }
  
          return comment;
      }
  
      function attachComments(tree, providedComments, tokens) {
          // At first, we should calculate extended comment ranges.
          var comments = [], comment, len, i, cursor;
  
          if (!tree.range) {
              throw new Error('attachComments needs range information');
          }
  
          // tokens array is empty, we attach comments to tree as 'leadingComments'
          if (!tokens.length) {
              if (providedComments.length) {
                  for (i = 0, len = providedComments.length; i < len; i += 1) {
                      comment = deepCopy(providedComments[i]);
                      comment.extendedRange = [0, tree.range[0]];
                      comments.push(comment);
                  }
                  tree.leadingComments = comments;
              }
              return tree;
          }
  
          for (i = 0, len = providedComments.length; i < len; i += 1) {
              comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
          }
  
          // This is based on John Freeman's implementation.
          cursor = 0;
          traverse(tree, {
              enter: function (node) {
                  var comment;
  
                  while (cursor < comments.length) {
                      comment = comments[cursor];
                      if (comment.extendedRange[1] > node.range[0]) {
                          break;
                      }
  
                      if (comment.extendedRange[1] === node.range[0]) {
                          if (!node.leadingComments) {
                              node.leadingComments = [];
                          }
                          node.leadingComments.push(comment);
                          comments.splice(cursor, 1);
                      } else {
                          cursor += 1;
                      }
                  }
  
                  // already out of owned node
                  if (cursor === comments.length) {
                      return VisitorOption.Break;
                  }
  
                  if (comments[cursor].extendedRange[0] > node.range[1]) {
                      return VisitorOption.Skip;
                  }
              }
          });
  
          cursor = 0;
          traverse(tree, {
              leave: function (node) {
                  var comment;
  
                  while (cursor < comments.length) {
                      comment = comments[cursor];
                      if (node.range[1] < comment.extendedRange[0]) {
                          break;
                      }
  
                      if (node.range[1] === comment.extendedRange[0]) {
                          if (!node.trailingComments) {
                              node.trailingComments = [];
                          }
                          node.trailingComments.push(comment);
                          comments.splice(cursor, 1);
                      } else {
                          cursor += 1;
                      }
                  }
  
                  // already out of owned node
                  if (cursor === comments.length) {
                      return VisitorOption.Break;
                  }
  
                  if (comments[cursor].extendedRange[0] > node.range[1]) {
                      return VisitorOption.Skip;
                  }
              }
          });
  
          return tree;
      }
  
      exports.version = _dereq_('./package.json').version;
      exports.Syntax = Syntax;
      exports.traverse = traverse;
      exports.replace = replace;
      exports.attachComments = attachComments;
      exports.VisitorKeys = VisitorKeys;
      exports.VisitorOption = VisitorOption;
      exports.Controller = Controller;
      exports.cloneEnvironment = function () { return clone({}); };
  
      return exports;
  }(exports));
  /* vim: set sw=4 ts=4 et tw=80 : */
  
  },{"./package.json":14}],14:[function(_dereq_,module,exports){
  module.exports={
    "_args": [
      [
        "estraverse@^4.0.0",
        "/Users/takuto/src/github.com/twada/call-matcher"
      ]
    ],
    "_from": "estraverse@>=4.0.0 <5.0.0",
    "_id": "estraverse@4.1.1",
    "_inCache": true,
    "_installable": true,
    "_location": "/estraverse",
    "_nodeVersion": "4.1.1",
    "_npmUser": {
      "email": "utatane.tea@gmail.com",
      "name": "constellation"
    },
    "_npmVersion": "2.14.4",
    "_phantomChildren": {},
    "_requested": {
      "name": "estraverse",
      "raw": "estraverse@^4.0.0",
      "rawSpec": "^4.0.0",
      "scope": null,
      "spec": ">=4.0.0 <5.0.0",
      "type": "range"
    },
    "_requiredBy": [
      "/",
      "/esrecurse"
    ],
    "_resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.1.1.tgz",
    "_shasum": "f6caca728933a850ef90661d0e17982ba47111a2",
    "_shrinkwrap": null,
    "_spec": "estraverse@^4.0.0",
    "_where": "/Users/takuto/src/github.com/twada/call-matcher",
    "bugs": {
      "url": "https://github.com/estools/estraverse/issues"
    },
    "dependencies": {},
    "description": "ECMAScript JS AST traversal functions",
    "devDependencies": {
      "chai": "^2.1.1",
      "coffee-script": "^1.8.0",
      "espree": "^1.11.0",
      "gulp": "^3.8.10",
      "gulp-bump": "^0.2.2",
      "gulp-filter": "^2.0.0",
      "gulp-git": "^1.0.1",
      "gulp-tag-version": "^1.2.1",
      "jshint": "^2.5.6",
      "mocha": "^2.1.0"
    },
    "directories": {},
    "dist": {
      "shasum": "f6caca728933a850ef90661d0e17982ba47111a2",
      "tarball": "http://registry.npmjs.org/estraverse/-/estraverse-4.1.1.tgz"
    },
    "engines": {
      "node": ">=0.10.0"
    },
    "gitHead": "bbcccbfe98296585e4311c8755e1d00dcd581e3c",
    "homepage": "https://github.com/estools/estraverse",
    "license": "BSD-2-Clause",
    "main": "estraverse.js",
    "maintainers": [
      {
        "name": "constellation",
        "email": "utatane.tea@gmail.com"
      },
      {
        "name": "michaelficarra",
        "email": "npm@michael.ficarra.me"
      },
      {
        "name": "nzakas",
        "email": "nicholas@nczconsulting.com"
      }
    ],
    "name": "estraverse",
    "optionalDependencies": {},
    "readme": "ERROR: No README data found!",
    "repository": {
      "type": "git",
      "url": "git+ssh://git@github.com/estools/estraverse.git"
    },
    "scripts": {
      "lint": "jshint estraverse.js",
      "test": "npm run-script lint && npm run-script unit-test",
      "unit-test": "mocha --compilers coffee:coffee-script/register"
    },
    "version": "4.1.1"
  }
  
  },{}],15:[function(_dereq_,module,exports){
  
  var indexOf = [].indexOf;
  
  module.exports = function(arr, obj){
    if (indexOf) return arr.indexOf(obj);
    for (var i = 0; i < arr.length; ++i) {
      if (arr[i] === obj) return i;
    }
    return -1;
  };
  },{}],16:[function(_dereq_,module,exports){
  var toString = {}.toString;
  
  module.exports = Array.isArray || function (arr) {
    return toString.call(arr) == '[object Array]';
  };
  
  },{}],17:[function(_dereq_,module,exports){
  'use strict';
  
  // modified from https://github.com/es-shims/es5-shim
  var has = Object.prototype.hasOwnProperty;
  var toStr = Object.prototype.toString;
  var slice = Array.prototype.slice;
  var isArgs = _dereq_('./isArguments');
  var hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString');
  var hasProtoEnumBug = function () {}.propertyIsEnumerable('prototype');
  var dontEnums = [
  	'toString',
  	'toLocaleString',
  	'valueOf',
  	'hasOwnProperty',
  	'isPrototypeOf',
  	'propertyIsEnumerable',
  	'constructor'
  ];
  var equalsConstructorPrototype = function (o) {
  	var ctor = o.constructor;
  	return ctor && ctor.prototype === o;
  };
  var blacklistedKeys = {
  	$console: true,
  	$frame: true,
  	$frameElement: true,
  	$frames: true,
  	$parent: true,
  	$self: true,
  	$webkitIndexedDB: true,
  	$webkitStorageInfo: true,
  	$window: true
  };
  var hasAutomationEqualityBug = (function () {
  	/* global window */
  	if (typeof window === 'undefined') { return false; }
  	for (var k in window) {
  		try {
  			if (!blacklistedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
  				try {
  					equalsConstructorPrototype(window[k]);
  				} catch (e) {
  					return true;
  				}
  			}
  		} catch (e) {
  			return true;
  		}
  	}
  	return false;
  }());
  var equalsConstructorPrototypeIfNotBuggy = function (o) {
  	/* global window */
  	if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
  		return equalsConstructorPrototype(o);
  	}
  	try {
  		return equalsConstructorPrototype(o);
  	} catch (e) {
  		return false;
  	}
  };
  
  var keysShim = function keys(object) {
  	var isObject = object !== null && typeof object === 'object';
  	var isFunction = toStr.call(object) === '[object Function]';
  	var isArguments = isArgs(object);
  	var isString = isObject && toStr.call(object) === '[object String]';
  	var theKeys = [];
  
  	if (!isObject && !isFunction && !isArguments) {
  		throw new TypeError('Object.keys called on a non-object');
  	}
  
  	var skipProto = hasProtoEnumBug && isFunction;
  	if (isString && object.length > 0 && !has.call(object, 0)) {
  		for (var i = 0; i < object.length; ++i) {
  			theKeys.push(String(i));
  		}
  	}
  
  	if (isArguments && object.length > 0) {
  		for (var j = 0; j < object.length; ++j) {
  			theKeys.push(String(j));
  		}
  	} else {
  		for (var name in object) {
  			if (!(skipProto && name === 'prototype') && has.call(object, name)) {
  				theKeys.push(String(name));
  			}
  		}
  	}
  
  	if (hasDontEnumBug) {
  		var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
  
  		for (var k = 0; k < dontEnums.length; ++k) {
  			if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
  				theKeys.push(dontEnums[k]);
  			}
  		}
  	}
  	return theKeys;
  };
  
  keysShim.shim = function shimObjectKeys() {
  	if (Object.keys) {
  		var keysWorksWithArguments = (function () {
  			// Safari 5.0 bug
  			return (Object.keys(arguments) || '').length === 2;
  		}(1, 2));
  		if (!keysWorksWithArguments) {
  			var originalKeys = Object.keys;
  			Object.keys = function keys(object) {
  				if (isArgs(object)) {
  					return originalKeys(slice.call(object));
  				} else {
  					return originalKeys(object);
  				}
  			};
  		}
  	} else {
  		Object.keys = keysShim;
  	}
  	return Object.keys || keysShim;
  };
  
  module.exports = keysShim;
  
  },{"./isArguments":18}],18:[function(_dereq_,module,exports){
  'use strict';
  
  var toStr = Object.prototype.toString;
  
  module.exports = function isArguments(value) {
  	var str = toStr.call(value);
  	var isArgs = str === '[object Arguments]';
  	if (!isArgs) {
  		isArgs = str !== '[object Array]' &&
  			value !== null &&
  			typeof value === 'object' &&
  			typeof value.length === 'number' &&
  			value.length >= 0 &&
  			toStr.call(value.callee) === '[object Function]';
  	}
  	return isArgs;
  };
  
  },{}],19:[function(_dereq_,module,exports){
  module.exports = extend
  
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  
  function extend() {
      var target = {}
  
      for (var i = 0; i < arguments.length; i++) {
          var source = arguments[i]
  
          for (var key in source) {
              if (hasOwnProperty.call(source, key)) {
                  target[key] = source[key]
              }
          }
      }
  
      return target
  }
  
  },{}]},{},[1])(1)
  });
  