增加井号重复判断

‘liusuyi’

2023-07-03 29d8ea701df5bba27bda837a550853b299207040

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
"use strict";
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.traverse = traverse;
 
var _nodePath = require("./node-path");
 
var _nodes = require("./nodes");
 
// recursively walks the AST starting at the given node. The callback is invoked for
// and object that has a 'type' property.
function walk(context, callback) {
  var stop = false;
 
  function innerWalk(context, callback) {
    if (stop) {
      return;
    }
 
    var node = context.node;
 
    if (node === undefined) {
      console.warn("traversing with an empty context");
      return;
    }
 
    if (node._deleted === true) {
      return;
    }
 
    var path = (0, _nodePath.createPath)(context);
    callback(node.type, path);
 
    if (path.shouldStop) {
      stop = true;
      return;
    }
 
    Object.keys(node).forEach(function (prop) {
      var value = node[prop];
 
      if (value === null || value === undefined) {
        return;
      }
 
      var valueAsArray = Array.isArray(value) ? value : [value];
      valueAsArray.forEach(function (childNode) {
        if (typeof childNode.type === "string") {
          var childContext = {
            node: childNode,
            parentKey: prop,
            parentPath: path,
            shouldStop: false,
            inList: Array.isArray(value)
          };
          innerWalk(childContext, callback);
        }
      });
    });
  }
 
  innerWalk(context, callback);
}
 
var noop = function noop() {};
 
function traverse(node, visitors) {
  var before = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : noop;
  var after = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : noop;
  Object.keys(visitors).forEach(function (visitor) {
    if (!_nodes.nodeAndUnionTypes.includes(visitor)) {
      throw new Error("Unexpected visitor ".concat(visitor));
    }
  });
  var context = {
    node: node,
    inList: false,
    shouldStop: false,
    parentPath: null,
    parentKey: null
  };
  walk(context, function (type, path) {
    if (typeof visitors[type] === "function") {
      before(type, path);
      visitors[type](path);
      after(type, path);
    }
 
    var unionTypes = _nodes.unionTypesMap[type];
 
    if (!unionTypes) {
      throw new Error("Unexpected node type ".concat(type));
    }
 
    unionTypes.forEach(function (unionType) {
      if (typeof visitors[unionType] === "function") {
        before(unionType, path);
        visitors[unionType](path);
        after(unionType, path);
      }
    });
  });
}