.config/coc/extensions/node_modules/coc-prettier/node_modules/esrecurse/README.md

   1 ### Esrecurse [![Build Status](https://travis-ci.org/estools/esrecurse.svg?branch=master)](https://travis-ci.org/estools/esrecurse)
   2
   3 Esrecurse ([esrecurse](https://github.com/estools/esrecurse)) is
   4 [ECMAScript](https://www.ecma-international.org/publications/standards/Ecma-262.htm)
   5 recursive traversing functionality.
   6
   7 ### Example Usage
   8
   9 The following code will output all variables declared at the root of a file.
  10
  11 ```javascript
  12 esrecurse.visit(ast, {
  13     XXXStatement: function (node) {
  14         this.visit(node.left);
  15         // do something...
  16         this.visit(node.right);
  17     }
  18 });
  19 ```
  20
  21 We can use `Visitor` instance.
  22
  23 ```javascript
  24 var visitor = new esrecurse.Visitor({
  25     XXXStatement: function (node) {
  26         this.visit(node.left);
  27         // do something...
  28         this.visit(node.right);
  29     }
  30 });
  31
  32 visitor.visit(ast);
  33 ```
  34
  35 We can inherit `Visitor` instance easily.
  36
  37 ```javascript
  38 class Derived extends esrecurse.Visitor {
  39     constructor()
  40     {
  41         super(null);
  42     }
  43
  44     XXXStatement(node) {
  45     }
  46 }
  47 ```
  48
  49 ```javascript
  50 function DerivedVisitor() {
  51     esrecurse.Visitor.call(/* this for constructor */  this  /* visitor object automatically becomes this. */);
  52 }
  53 util.inherits(DerivedVisitor, esrecurse.Visitor);
  54 DerivedVisitor.prototype.XXXStatement = function (node) {
  55     this.visit(node.left);
  56     // do something...
  57     this.visit(node.right);
  58 };
  59 ```
  60
  61 And you can invoke default visiting operation inside custom visit operation.
  62
  63 ```javascript
  64 function DerivedVisitor() {
  65     esrecurse.Visitor.call(/* this for constructor */  this  /* visitor object automatically becomes this. */);
  66 }
  67 util.inherits(DerivedVisitor, esrecurse.Visitor);
  68 DerivedVisitor.prototype.XXXStatement = function (node) {
  69     // do something...
  70     this.visitChildren(node);
  71 };
  72 ```
  73
  74 The `childVisitorKeys` option does customize the behaviour of `this.visitChildren(node)`.
  75 We can use user-defined node types.
  76
  77 ```javascript
  78 // This tree contains a user-defined `TestExpression` node.
  79 var tree = {
  80     type: 'TestExpression',
  81
  82     // This 'argument' is the property containing the other **node**.
  83     argument: {
  84         type: 'Literal',
  85         value: 20
  86     },
  87
  88     // This 'extended' is the property not containing the other **node**.
  89     extended: true
  90 };
  91 esrecurse.visit(
  92     ast,
  93     {
  94         Literal: function (node) {
  95             // do something...
  96         }
  97     },
  98     {
  99         // Extending the existing traversing rules.
 100         childVisitorKeys: {
 101             // TargetNodeName: [ 'keys', 'containing', 'the', 'other', '**node**' ]
 102             TestExpression: ['argument']
 103         }
 104     }
 105 );
 106 ```
 107
 108 We can use the `fallback` option as well.
 109 If the `fallback` option is `"iteration"`, `esrecurse` would visit all enumerable properties of unknown nodes.
 110 Please note circular references cause the stack overflow. AST might have circular references in additional properties for some purpose (e.g. `node.parent`).
 111
 112 ```javascript
 113 esrecurse.visit(
 114     ast,
 115     {
 116         Literal: function (node) {
 117             // do something...
 118         }
 119     },
 120     {
 121         fallback: 'iteration'
 122     }
 123 );
 124 ```
 125
 126 If the `fallback` option is a function, `esrecurse` calls this function to determine the enumerable properties of unknown nodes.
 127 Please note circular references cause the stack overflow. AST might have circular references in additional properties for some purpose (e.g. `node.parent`).
 128
 129 ```javascript
 130 esrecurse.visit(
 131     ast,
 132     {
 133         Literal: function (node) {
 134             // do something...
 135         }
 136     },
 137     {
 138         fallback: function (node) {
 139             return Object.keys(node).filter(function(key) {
 140                 return key !== 'argument'
 141             });
 142         }
 143     }
 144 );
 145 ```
 146
 147 ### License
 148
 149 Copyright (C) 2014 [Yusuke Suzuki](https://github.com/Constellation)
 150  (twitter: [@Constellation](https://twitter.com/Constellation)) and other contributors.
 151
 152 Redistribution and use in source and binary forms, with or without
 153 modification, are permitted provided that the following conditions are met:
 154
 155   * Redistributions of source code must retain the above copyright
 156     notice, this list of conditions and the following disclaimer.
 157
 158   * Redistributions in binary form must reproduce the above copyright
 159     notice, this list of conditions and the following disclaimer in the
 160     documentation and/or other materials provided with the distribution.
 161
 162 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 163 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 164 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 165 ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
 166 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 167 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 168 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 169 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 170 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 171 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.