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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
'use strict';
/* eslint-disable max-params */
/* Expose. */
module.exports = is;
/* Assert if `test` passes for `node`.
* When a `parent` node is known the `index` of node */
function is(test, node, index, parent, context) {
var hasParent = parent !== null && parent !== undefined;
var hasIndex = index !== null && index !== undefined;
var check = convert(test);
if (
hasIndex &&
(typeof index !== 'number' || index < 0 || index === Infinity)
) {
throw new Error('Expected positive finite index or child node');
}
if (hasParent && (!is(null, parent) || !parent.children)) {
throw new Error('Expected parent node');
}
if (!node || !node.type || typeof node.type !== 'string') {
return false;
}
if (hasParent !== hasIndex) {
throw new Error('Expected both parent and index');
}
return Boolean(check.call(context, node, index, parent));
}
function convert(test) {
if (typeof test === 'string') {
return typeFactory(test);
}
if (test === null || test === undefined) {
return ok;
}
if (typeof test === 'object') {
return ('length' in test ? anyFactory : matchesFactory)(test);
}
if (typeof test === 'function') {
return test;
}
throw new Error('Expected function, string, or object as test');
}
function convertAll(tests) {
var results = [];
var length = tests.length;
var index = -1;
while (++index < length) {
results[index] = convert(tests[index]);
}
return results;
}
/* Utility assert each property in `test` is represented
* in `node`, and each values are strictly equal. */
function matchesFactory(test) {
return matches;
function matches(node) {
var key;
for (key in test) {
if (node[key] !== test[key]) {
return false;
}
}
return true;
}
}
function anyFactory(tests) {
var checks = convertAll(tests);
var length = checks.length;
return matches;
function matches() {
var index = -1;
while (++index < length) {
if (checks[index].apply(this, arguments)) {
return true;
}
}
return false;
}
}
/* Utility to convert a string into a function which checks
* a given node’s type for said string. */
function typeFactory(test) {
return type;
function type(node) {
return Boolean(node && node.type === test);
}
}
/* Utility to return true. */
function ok() {
return true;
}
|
