docs: function addChildrenRecursively(node) {
              if (!node || ts.isToken(node)) {
                  return;
              }
              switch (node.kind) {
                  case 148 /* Constructor */:
                      // Get parameter properties, and treat them as being on the *same* level as the constructor, not under it.
                      var ctr = node;
                      addNodeWithRecursiveChild(ctr, ctr.body);
                      // Parameter properties are children of the class, not the constructor.
                      for (var _i = 0, _a = ctr.parameters; _i < _a.length; _i++) {
                          var param = _a[_i];
                          if (ts.isParameterPropertyDeclaration(param)) {
                              addLeafNode(param);
                          }
                      }
                      break;
                  case 147 /* MethodDeclaration */:
                  case 149 /* GetAccessor */:
                  case 150 /* SetAccessor */:
                  case 146 /* MethodSignature */:
                      if (!ts.hasDynamicName(node)) {
                          addNodeWithRecursiveChild(node, node.body);
                      }
                      break;
                  case 145 /* PropertyDeclaration */:
                  case 144 /* PropertySignature */:
                      if (!ts.hasDynamicName(node)) {
                          addLeafNode(node);
                      }
                      break;
                  case 231 /* ImportClause */:
                      var importClause = node;
                      // Handle default import case e.g.:
                      //    import d from "mod";
                      if (importClause.name) {
                          addLeafNode(importClause);
                      }
                      // Handle named bindings in imports e.g.:
                      //    import * as NS from "mod";
                      //    import {a, b as B} from "mod";
                      var namedBindings = importClause.namedBindings;
                      if (namedBindings) {
                          if (namedBindings.kind === 232 /* NamespaceImport */) {
                              addLeafNode(namedBindings);
                          }
                          else {
                              for (var _b = 0, _c = namedBindings.elements; _b < _c.length; _b++) {
                                  var element = _c[_b];
                                  addLeafNode(element);
                              }
                          }
                      }
                      break;
                  case 169 /* BindingElement */:
                  case 218 /* VariableDeclaration */:
                      var decl = node;
                      var name_38 = decl.name;
                      if (ts.isBindingPattern(name_38)) {
                          addChildrenRecursively(name_38);
                      }
                      else if (decl.initializer && isFunctionOrClassExpression(decl.initializer)) {
                          // For `const x = function() {}`, just use the function node, not the const.
                          addChildrenRecursively(decl.initializer);
                      }
                      else {
                          addNodeWithRecursiveChild(decl, decl.initializer);
                      }
                      break;
                  case 180 /* ArrowFunction */:
                  case 220 /* FunctionDeclaration */:
                  case 179 /* FunctionExpression */:
                      addNodeWithRecursiveChild(node, node.body);
                      break;
                  case 224 /* EnumDeclaration */:
                      startNode(node);
                      for (var _d = 0, _e = node.members; _d < _e.length; _d++) {
                          var member = _e[_d];
                          if (!isComputedProperty(member)) {
                              addLeafNode(member);
                          }
                      }
                      endNode();
                      break;
                  case 221 /* ClassDeclaration */:
                  case 192 /* ClassExpression */:
                  case 222 /* InterfaceDeclaration */:
                      startNode(node);
                      for (var _f = 0, _g = node.members; _f < _g.length; _f++) {
                          var member = _g[_f];
                          addChildrenRecursively(member);
                      }
                      endNode();
                      break;
                  case 225 /* ModuleDeclaration */:
                      addNodeWithRecursiveChild(node, getInteriorModule(node).body);
                      break;
                  case 238 /* ExportSpecifier */:
                  case 229 /* ImportEqualsDeclaration */:
                  case 153 /* IndexSignature */:
                  case 151 /* CallSignature */:
                  case 152 /* ConstructSignature */:
                  case 223 /* TypeAliasDeclaration */:
                      addLeafNode(node);
                      break;
                  default:
                      if (node.jsDocComments) {
                          for (var _h = 0, _j = node.jsDocComments; _h < _j.length; _h++) {
                              var jsDocComment = _j[_h];
                              for (var _k = 0, _l = jsDocComment.tags; _k < _l.length; _k++) {
                                  var tag = _l[_k];
                                  if (tag.kind === 279 /* JSDocTypedefTag */) {
                                      addLeafNode(tag);
                                  }
                              }
                          }
                      }
                      ts.forEachChild(node, addChildrenRecursively);
              }
          }