source: imaps-frontend/node_modules/esquery/dist/esquery.lite.js@ d565449

main
Last change on this file since d565449 was d565449, checked in by stefan toskovski <stefantoska84@…>, 4 weeks ago

Update repo after prototype presentation
  • Property mode set to 100644
File size: 105.4 KB
RevLine 
[d565449]1(function (global, factory) {
2 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('estraverse')) :
3 typeof define === 'function' && define.amd ? define(['estraverse'], factory) :
4 (global = global || self, global.esquery = factory(global.estraverse));
5}(this, (function (estraverse) { 'use strict';
6
7 estraverse = estraverse && Object.prototype.hasOwnProperty.call(estraverse, 'default') ? estraverse['default'] : estraverse;
8
9 function _iterableToArrayLimit(arr, i) {
10 var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
11 if (null != _i) {
12 var _s,
13 _e,
14 _x,
15 _r,
16 _arr = [],
17 _n = !0,
18 _d = !1;
19 try {
20 if (_x = (_i = _i.call(arr)).next, 0 === i) {
21 if (Object(_i) !== _i) return;
22 _n = !1;
23 } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
24 } catch (err) {
25 _d = !0, _e = err;
26 } finally {
27 try {
28 if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
29 } finally {
30 if (_d) throw _e;
31 }
32 }
33 return _arr;
34 }
35 }
36 function _typeof(obj) {
37 "@babel/helpers - typeof";
38
39 return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
40 return typeof obj;
41 } : function (obj) {
42 return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
43 }, _typeof(obj);
44 }
45 function _slicedToArray(arr, i) {
46 return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
47 }
48 function _toConsumableArray(arr) {
49 return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
50 }
51 function _arrayWithoutHoles(arr) {
52 if (Array.isArray(arr)) return _arrayLikeToArray(arr);
53 }
54 function _arrayWithHoles(arr) {
55 if (Array.isArray(arr)) return arr;
56 }
57 function _iterableToArray(iter) {
58 if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
59 }
60 function _unsupportedIterableToArray(o, minLen) {
61 if (!o) return;
62 if (typeof o === "string") return _arrayLikeToArray(o, minLen);
63 var n = Object.prototype.toString.call(o).slice(8, -1);
64 if (n === "Object" && o.constructor) n = o.constructor.name;
65 if (n === "Map" || n === "Set") return Array.from(o);
66 if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
67 }
68 function _arrayLikeToArray(arr, len) {
69 if (len == null || len > arr.length) len = arr.length;
70 for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
71 return arr2;
72 }
73 function _nonIterableSpread() {
74 throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
75 }
76 function _nonIterableRest() {
77 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
78 }
79
80 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
81
82 function createCommonjsModule(fn, module) {
83 return module = { exports: {} }, fn(module, module.exports), module.exports;
84 }
85
86 var parser = createCommonjsModule(function (module) {
87 /*
88 * Generated by PEG.js 0.10.0.
89 *
90 * http://pegjs.org/
91 */
92 (function (root, factory) {
93 if ( module.exports) {
94 module.exports = factory();
95 }
96 })(commonjsGlobal, function () {
97
98 function peg$subclass(child, parent) {
99 function ctor() {
100 this.constructor = child;
101 }
102 ctor.prototype = parent.prototype;
103 child.prototype = new ctor();
104 }
105 function peg$SyntaxError(message, expected, found, location) {
106 this.message = message;
107 this.expected = expected;
108 this.found = found;
109 this.location = location;
110 this.name = "SyntaxError";
111 if (typeof Error.captureStackTrace === "function") {
112 Error.captureStackTrace(this, peg$SyntaxError);
113 }
114 }
115 peg$subclass(peg$SyntaxError, Error);
116 peg$SyntaxError.buildMessage = function (expected, found) {
117 var DESCRIBE_EXPECTATION_FNS = {
118 literal: function literal(expectation) {
119 return "\"" + literalEscape(expectation.text) + "\"";
120 },
121 "class": function _class(expectation) {
122 var escapedParts = "",
123 i;
124 for (i = 0; i < expectation.parts.length; i++) {
125 escapedParts += expectation.parts[i] instanceof Array ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1]) : classEscape(expectation.parts[i]);
126 }
127 return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
128 },
129 any: function any(expectation) {
130 return "any character";
131 },
132 end: function end(expectation) {
133 return "end of input";
134 },
135 other: function other(expectation) {
136 return expectation.description;
137 }
138 };
139 function hex(ch) {
140 return ch.charCodeAt(0).toString(16).toUpperCase();
141 }
142 function literalEscape(s) {
143 return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\0/g, '\\0').replace(/\t/g, '\\t').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/[\x00-\x0F]/g, function (ch) {
144 return '\\x0' + hex(ch);
145 }).replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
146 return '\\x' + hex(ch);
147 });
148 }
149 function classEscape(s) {
150 return s.replace(/\\/g, '\\\\').replace(/\]/g, '\\]').replace(/\^/g, '\\^').replace(/-/g, '\\-').replace(/\0/g, '\\0').replace(/\t/g, '\\t').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/[\x00-\x0F]/g, function (ch) {
151 return '\\x0' + hex(ch);
152 }).replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
153 return '\\x' + hex(ch);
154 });
155 }
156 function describeExpectation(expectation) {
157 return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
158 }
159 function describeExpected(expected) {
160 var descriptions = new Array(expected.length),
161 i,
162 j;
163 for (i = 0; i < expected.length; i++) {
164 descriptions[i] = describeExpectation(expected[i]);
165 }
166 descriptions.sort();
167 if (descriptions.length > 0) {
168 for (i = 1, j = 1; i < descriptions.length; i++) {
169 if (descriptions[i - 1] !== descriptions[i]) {
170 descriptions[j] = descriptions[i];
171 j++;
172 }
173 }
174 descriptions.length = j;
175 }
176 switch (descriptions.length) {
177 case 1:
178 return descriptions[0];
179 case 2:
180 return descriptions[0] + " or " + descriptions[1];
181 default:
182 return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
183 }
184 }
185 function describeFound(found) {
186 return found ? "\"" + literalEscape(found) + "\"" : "end of input";
187 }
188 return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
189 };
190 function peg$parse(input, options) {
191 options = options !== void 0 ? options : {};
192 var peg$FAILED = {},
193 peg$startRuleFunctions = {
194 start: peg$parsestart
195 },
196 peg$startRuleFunction = peg$parsestart,
197 peg$c0 = function peg$c0(ss) {
198 return ss.length === 1 ? ss[0] : {
199 type: 'matches',
200 selectors: ss
201 };
202 },
203 peg$c1 = function peg$c1() {
204 return void 0;
205 },
206 peg$c2 = " ",
207 peg$c3 = peg$literalExpectation(" ", false),
208 peg$c4 = /^[^ [\],():#!=><~+.]/,
209 peg$c5 = peg$classExpectation([" ", "[", "]", ",", "(", ")", ":", "#", "!", "=", ">", "<", "~", "+", "."], true, false),
210 peg$c6 = function peg$c6(i) {
211 return i.join('');
212 },
213 peg$c7 = ">",
214 peg$c8 = peg$literalExpectation(">", false),
215 peg$c9 = function peg$c9() {
216 return 'child';
217 },
218 peg$c10 = "~",
219 peg$c11 = peg$literalExpectation("~", false),
220 peg$c12 = function peg$c12() {
221 return 'sibling';
222 },
223 peg$c13 = "+",
224 peg$c14 = peg$literalExpectation("+", false),
225 peg$c15 = function peg$c15() {
226 return 'adjacent';
227 },
228 peg$c16 = function peg$c16() {
229 return 'descendant';
230 },
231 peg$c17 = ",",
232 peg$c18 = peg$literalExpectation(",", false),
233 peg$c19 = function peg$c19(s, ss) {
234 return [s].concat(ss.map(function (s) {
235 return s[3];
236 }));
237 },
238 peg$c20 = function peg$c20(op, s) {
239 if (!op) return s;
240 return {
241 type: op,
242 left: {
243 type: 'exactNode'
244 },
245 right: s
246 };
247 },
248 peg$c21 = function peg$c21(a, ops) {
249 return ops.reduce(function (memo, rhs) {
250 return {
251 type: rhs[0],
252 left: memo,
253 right: rhs[1]
254 };
255 }, a);
256 },
257 peg$c22 = "!",
258 peg$c23 = peg$literalExpectation("!", false),
259 peg$c24 = function peg$c24(subject, as) {
260 var b = as.length === 1 ? as[0] : {
261 type: 'compound',
262 selectors: as
263 };
264 if (subject) b.subject = true;
265 return b;
266 },
267 peg$c25 = "*",
268 peg$c26 = peg$literalExpectation("*", false),
269 peg$c27 = function peg$c27(a) {
270 return {
271 type: 'wildcard',
272 value: a
273 };
274 },
275 peg$c28 = "#",
276 peg$c29 = peg$literalExpectation("#", false),
277 peg$c30 = function peg$c30(i) {
278 return {
279 type: 'identifier',
280 value: i
281 };
282 },
283 peg$c31 = "[",
284 peg$c32 = peg$literalExpectation("[", false),
285 peg$c33 = "]",
286 peg$c34 = peg$literalExpectation("]", false),
287 peg$c35 = function peg$c35(v) {
288 return v;
289 },
290 peg$c36 = /^[><!]/,
291 peg$c37 = peg$classExpectation([">", "<", "!"], false, false),
292 peg$c38 = "=",
293 peg$c39 = peg$literalExpectation("=", false),
294 peg$c40 = function peg$c40(a) {
295 return (a || '') + '=';
296 },
297 peg$c41 = /^[><]/,
298 peg$c42 = peg$classExpectation([">", "<"], false, false),
299 peg$c43 = ".",
300 peg$c44 = peg$literalExpectation(".", false),
301 peg$c45 = function peg$c45(a, as) {
302 return [].concat.apply([a], as).join('');
303 },
304 peg$c46 = function peg$c46(name, op, value) {
305 return {
306 type: 'attribute',
307 name: name,
308 operator: op,
309 value: value
310 };
311 },
312 peg$c47 = function peg$c47(name) {
313 return {
314 type: 'attribute',
315 name: name
316 };
317 },
318 peg$c48 = "\"",
319 peg$c49 = peg$literalExpectation("\"", false),
320 peg$c50 = /^[^\\"]/,
321 peg$c51 = peg$classExpectation(["\\", "\""], true, false),
322 peg$c52 = "\\",
323 peg$c53 = peg$literalExpectation("\\", false),
324 peg$c54 = peg$anyExpectation(),
325 peg$c55 = function peg$c55(a, b) {
326 return a + b;
327 },
328 peg$c56 = function peg$c56(d) {
329 return {
330 type: 'literal',
331 value: strUnescape(d.join(''))
332 };
333 },
334 peg$c57 = "'",
335 peg$c58 = peg$literalExpectation("'", false),
336 peg$c59 = /^[^\\']/,
337 peg$c60 = peg$classExpectation(["\\", "'"], true, false),
338 peg$c61 = /^[0-9]/,
339 peg$c62 = peg$classExpectation([["0", "9"]], false, false),
340 peg$c63 = function peg$c63(a, b) {
341 // Can use `a.flat().join('')` once supported
342 var leadingDecimals = a ? [].concat.apply([], a).join('') : '';
343 return {
344 type: 'literal',
345 value: parseFloat(leadingDecimals + b.join(''))
346 };
347 },
348 peg$c64 = function peg$c64(i) {
349 return {
350 type: 'literal',
351 value: i
352 };
353 },
354 peg$c65 = "type(",
355 peg$c66 = peg$literalExpectation("type(", false),
356 peg$c67 = /^[^ )]/,
357 peg$c68 = peg$classExpectation([" ", ")"], true, false),
358 peg$c69 = ")",
359 peg$c70 = peg$literalExpectation(")", false),
360 peg$c71 = function peg$c71(t) {
361 return {
362 type: 'type',
363 value: t.join('')
364 };
365 },
366 peg$c72 = /^[imsu]/,
367 peg$c73 = peg$classExpectation(["i", "m", "s", "u"], false, false),
368 peg$c74 = "/",
369 peg$c75 = peg$literalExpectation("/", false),
370 peg$c76 = /^[^\/]/,
371 peg$c77 = peg$classExpectation(["/"], true, false),
372 peg$c78 = function peg$c78(d, flgs) {
373 return {
374 type: 'regexp',
375 value: new RegExp(d.join(''), flgs ? flgs.join('') : '')
376 };
377 },
378 peg$c79 = function peg$c79(i, is) {
379 return {
380 type: 'field',
381 name: is.reduce(function (memo, p) {
382 return memo + p[0] + p[1];
383 }, i)
384 };
385 },
386 peg$c80 = ":not(",
387 peg$c81 = peg$literalExpectation(":not(", false),
388 peg$c82 = function peg$c82(ss) {
389 return {
390 type: 'not',
391 selectors: ss
392 };
393 },
394 peg$c83 = ":matches(",
395 peg$c84 = peg$literalExpectation(":matches(", false),
396 peg$c85 = function peg$c85(ss) {
397 return {
398 type: 'matches',
399 selectors: ss
400 };
401 },
402 peg$c86 = ":has(",
403 peg$c87 = peg$literalExpectation(":has(", false),
404 peg$c88 = function peg$c88(ss) {
405 return {
406 type: 'has',
407 selectors: ss
408 };
409 },
410 peg$c89 = ":first-child",
411 peg$c90 = peg$literalExpectation(":first-child", false),
412 peg$c91 = function peg$c91() {
413 return nth(1);
414 },
415 peg$c92 = ":last-child",
416 peg$c93 = peg$literalExpectation(":last-child", false),
417 peg$c94 = function peg$c94() {
418 return nthLast(1);
419 },
420 peg$c95 = ":nth-child(",
421 peg$c96 = peg$literalExpectation(":nth-child(", false),
422 peg$c97 = function peg$c97(n) {
423 return nth(parseInt(n.join(''), 10));
424 },
425 peg$c98 = ":nth-last-child(",
426 peg$c99 = peg$literalExpectation(":nth-last-child(", false),
427 peg$c100 = function peg$c100(n) {
428 return nthLast(parseInt(n.join(''), 10));
429 },
430 peg$c101 = ":",
431 peg$c102 = peg$literalExpectation(":", false),
432 peg$c103 = function peg$c103(c) {
433 return {
434 type: 'class',
435 name: c
436 };
437 },
438 peg$currPos = 0,
439 peg$posDetailsCache = [{
440 line: 1,
441 column: 1
442 }],
443 peg$maxFailPos = 0,
444 peg$maxFailExpected = [],
445 peg$resultsCache = {},
446 peg$result;
447 if ("startRule" in options) {
448 if (!(options.startRule in peg$startRuleFunctions)) {
449 throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
450 }
451 peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
452 }
453 function peg$literalExpectation(text, ignoreCase) {
454 return {
455 type: "literal",
456 text: text,
457 ignoreCase: ignoreCase
458 };
459 }
460 function peg$classExpectation(parts, inverted, ignoreCase) {
461 return {
462 type: "class",
463 parts: parts,
464 inverted: inverted,
465 ignoreCase: ignoreCase
466 };
467 }
468 function peg$anyExpectation() {
469 return {
470 type: "any"
471 };
472 }
473 function peg$endExpectation() {
474 return {
475 type: "end"
476 };
477 }
478 function peg$computePosDetails(pos) {
479 var details = peg$posDetailsCache[pos],
480 p;
481 if (details) {
482 return details;
483 } else {
484 p = pos - 1;
485 while (!peg$posDetailsCache[p]) {
486 p--;
487 }
488 details = peg$posDetailsCache[p];
489 details = {
490 line: details.line,
491 column: details.column
492 };
493 while (p < pos) {
494 if (input.charCodeAt(p) === 10) {
495 details.line++;
496 details.column = 1;
497 } else {
498 details.column++;
499 }
500 p++;
501 }
502 peg$posDetailsCache[pos] = details;
503 return details;
504 }
505 }
506 function peg$computeLocation(startPos, endPos) {
507 var startPosDetails = peg$computePosDetails(startPos),
508 endPosDetails = peg$computePosDetails(endPos);
509 return {
510 start: {
511 offset: startPos,
512 line: startPosDetails.line,
513 column: startPosDetails.column
514 },
515 end: {
516 offset: endPos,
517 line: endPosDetails.line,
518 column: endPosDetails.column
519 }
520 };
521 }
522 function peg$fail(expected) {
523 if (peg$currPos < peg$maxFailPos) {
524 return;
525 }
526 if (peg$currPos > peg$maxFailPos) {
527 peg$maxFailPos = peg$currPos;
528 peg$maxFailExpected = [];
529 }
530 peg$maxFailExpected.push(expected);
531 }
532 function peg$buildStructuredError(expected, found, location) {
533 return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
534 }
535 function peg$parsestart() {
536 var s0, s1, s2, s3;
537 var key = peg$currPos * 32 + 0,
538 cached = peg$resultsCache[key];
539 if (cached) {
540 peg$currPos = cached.nextPos;
541 return cached.result;
542 }
543 s0 = peg$currPos;
544 s1 = peg$parse_();
545 if (s1 !== peg$FAILED) {
546 s2 = peg$parseselectors();
547 if (s2 !== peg$FAILED) {
548 s3 = peg$parse_();
549 if (s3 !== peg$FAILED) {
550 s1 = peg$c0(s2);
551 s0 = s1;
552 } else {
553 peg$currPos = s0;
554 s0 = peg$FAILED;
555 }
556 } else {
557 peg$currPos = s0;
558 s0 = peg$FAILED;
559 }
560 } else {
561 peg$currPos = s0;
562 s0 = peg$FAILED;
563 }
564 if (s0 === peg$FAILED) {
565 s0 = peg$currPos;
566 s1 = peg$parse_();
567 if (s1 !== peg$FAILED) {
568 s1 = peg$c1();
569 }
570 s0 = s1;
571 }
572 peg$resultsCache[key] = {
573 nextPos: peg$currPos,
574 result: s0
575 };
576 return s0;
577 }
578 function peg$parse_() {
579 var s0, s1;
580 var key = peg$currPos * 32 + 1,
581 cached = peg$resultsCache[key];
582 if (cached) {
583 peg$currPos = cached.nextPos;
584 return cached.result;
585 }
586 s0 = [];
587 if (input.charCodeAt(peg$currPos) === 32) {
588 s1 = peg$c2;
589 peg$currPos++;
590 } else {
591 s1 = peg$FAILED;
592 {
593 peg$fail(peg$c3);
594 }
595 }
596 while (s1 !== peg$FAILED) {
597 s0.push(s1);
598 if (input.charCodeAt(peg$currPos) === 32) {
599 s1 = peg$c2;
600 peg$currPos++;
601 } else {
602 s1 = peg$FAILED;
603 {
604 peg$fail(peg$c3);
605 }
606 }
607 }
608 peg$resultsCache[key] = {
609 nextPos: peg$currPos,
610 result: s0
611 };
612 return s0;
613 }
614 function peg$parseidentifierName() {
615 var s0, s1, s2;
616 var key = peg$currPos * 32 + 2,
617 cached = peg$resultsCache[key];
618 if (cached) {
619 peg$currPos = cached.nextPos;
620 return cached.result;
621 }
622 s0 = peg$currPos;
623 s1 = [];
624 if (peg$c4.test(input.charAt(peg$currPos))) {
625 s2 = input.charAt(peg$currPos);
626 peg$currPos++;
627 } else {
628 s2 = peg$FAILED;
629 {
630 peg$fail(peg$c5);
631 }
632 }
633 if (s2 !== peg$FAILED) {
634 while (s2 !== peg$FAILED) {
635 s1.push(s2);
636 if (peg$c4.test(input.charAt(peg$currPos))) {
637 s2 = input.charAt(peg$currPos);
638 peg$currPos++;
639 } else {
640 s2 = peg$FAILED;
641 {
642 peg$fail(peg$c5);
643 }
644 }
645 }
646 } else {
647 s1 = peg$FAILED;
648 }
649 if (s1 !== peg$FAILED) {
650 s1 = peg$c6(s1);
651 }
652 s0 = s1;
653 peg$resultsCache[key] = {
654 nextPos: peg$currPos,
655 result: s0
656 };
657 return s0;
658 }
659 function peg$parsebinaryOp() {
660 var s0, s1, s2, s3;
661 var key = peg$currPos * 32 + 3,
662 cached = peg$resultsCache[key];
663 if (cached) {
664 peg$currPos = cached.nextPos;
665 return cached.result;
666 }
667 s0 = peg$currPos;
668 s1 = peg$parse_();
669 if (s1 !== peg$FAILED) {
670 if (input.charCodeAt(peg$currPos) === 62) {
671 s2 = peg$c7;
672 peg$currPos++;
673 } else {
674 s2 = peg$FAILED;
675 {
676 peg$fail(peg$c8);
677 }
678 }
679 if (s2 !== peg$FAILED) {
680 s3 = peg$parse_();
681 if (s3 !== peg$FAILED) {
682 s1 = peg$c9();
683 s0 = s1;
684 } else {
685 peg$currPos = s0;
686 s0 = peg$FAILED;
687 }
688 } else {
689 peg$currPos = s0;
690 s0 = peg$FAILED;
691 }
692 } else {
693 peg$currPos = s0;
694 s0 = peg$FAILED;
695 }
696 if (s0 === peg$FAILED) {
697 s0 = peg$currPos;
698 s1 = peg$parse_();
699 if (s1 !== peg$FAILED) {
700 if (input.charCodeAt(peg$currPos) === 126) {
701 s2 = peg$c10;
702 peg$currPos++;
703 } else {
704 s2 = peg$FAILED;
705 {
706 peg$fail(peg$c11);
707 }
708 }
709 if (s2 !== peg$FAILED) {
710 s3 = peg$parse_();
711 if (s3 !== peg$FAILED) {
712 s1 = peg$c12();
713 s0 = s1;
714 } else {
715 peg$currPos = s0;
716 s0 = peg$FAILED;
717 }
718 } else {
719 peg$currPos = s0;
720 s0 = peg$FAILED;
721 }
722 } else {
723 peg$currPos = s0;
724 s0 = peg$FAILED;
725 }
726 if (s0 === peg$FAILED) {
727 s0 = peg$currPos;
728 s1 = peg$parse_();
729 if (s1 !== peg$FAILED) {
730 if (input.charCodeAt(peg$currPos) === 43) {
731 s2 = peg$c13;
732 peg$currPos++;
733 } else {
734 s2 = peg$FAILED;
735 {
736 peg$fail(peg$c14);
737 }
738 }
739 if (s2 !== peg$FAILED) {
740 s3 = peg$parse_();
741 if (s3 !== peg$FAILED) {
742 s1 = peg$c15();
743 s0 = s1;
744 } else {
745 peg$currPos = s0;
746 s0 = peg$FAILED;
747 }
748 } else {
749 peg$currPos = s0;
750 s0 = peg$FAILED;
751 }
752 } else {
753 peg$currPos = s0;
754 s0 = peg$FAILED;
755 }
756 if (s0 === peg$FAILED) {
757 s0 = peg$currPos;
758 if (input.charCodeAt(peg$currPos) === 32) {
759 s1 = peg$c2;
760 peg$currPos++;
761 } else {
762 s1 = peg$FAILED;
763 {
764 peg$fail(peg$c3);
765 }
766 }
767 if (s1 !== peg$FAILED) {
768 s2 = peg$parse_();
769 if (s2 !== peg$FAILED) {
770 s1 = peg$c16();
771 s0 = s1;
772 } else {
773 peg$currPos = s0;
774 s0 = peg$FAILED;
775 }
776 } else {
777 peg$currPos = s0;
778 s0 = peg$FAILED;
779 }
780 }
781 }
782 }
783 peg$resultsCache[key] = {
784 nextPos: peg$currPos,
785 result: s0
786 };
787 return s0;
788 }
789 function peg$parsehasSelectors() {
790 var s0, s1, s2, s3, s4, s5, s6, s7;
791 var key = peg$currPos * 32 + 4,
792 cached = peg$resultsCache[key];
793 if (cached) {
794 peg$currPos = cached.nextPos;
795 return cached.result;
796 }
797 s0 = peg$currPos;
798 s1 = peg$parsehasSelector();
799 if (s1 !== peg$FAILED) {
800 s2 = [];
801 s3 = peg$currPos;
802 s4 = peg$parse_();
803 if (s4 !== peg$FAILED) {
804 if (input.charCodeAt(peg$currPos) === 44) {
805 s5 = peg$c17;
806 peg$currPos++;
807 } else {
808 s5 = peg$FAILED;
809 {
810 peg$fail(peg$c18);
811 }
812 }
813 if (s5 !== peg$FAILED) {
814 s6 = peg$parse_();
815 if (s6 !== peg$FAILED) {
816 s7 = peg$parsehasSelector();
817 if (s7 !== peg$FAILED) {
818 s4 = [s4, s5, s6, s7];
819 s3 = s4;
820 } else {
821 peg$currPos = s3;
822 s3 = peg$FAILED;
823 }
824 } else {
825 peg$currPos = s3;
826 s3 = peg$FAILED;
827 }
828 } else {
829 peg$currPos = s3;
830 s3 = peg$FAILED;
831 }
832 } else {
833 peg$currPos = s3;
834 s3 = peg$FAILED;
835 }
836 while (s3 !== peg$FAILED) {
837 s2.push(s3);
838 s3 = peg$currPos;
839 s4 = peg$parse_();
840 if (s4 !== peg$FAILED) {
841 if (input.charCodeAt(peg$currPos) === 44) {
842 s5 = peg$c17;
843 peg$currPos++;
844 } else {
845 s5 = peg$FAILED;
846 {
847 peg$fail(peg$c18);
848 }
849 }
850 if (s5 !== peg$FAILED) {
851 s6 = peg$parse_();
852 if (s6 !== peg$FAILED) {
853 s7 = peg$parsehasSelector();
854 if (s7 !== peg$FAILED) {
855 s4 = [s4, s5, s6, s7];
856 s3 = s4;
857 } else {
858 peg$currPos = s3;
859 s3 = peg$FAILED;
860 }
861 } else {
862 peg$currPos = s3;
863 s3 = peg$FAILED;
864 }
865 } else {
866 peg$currPos = s3;
867 s3 = peg$FAILED;
868 }
869 } else {
870 peg$currPos = s3;
871 s3 = peg$FAILED;
872 }
873 }
874 if (s2 !== peg$FAILED) {
875 s1 = peg$c19(s1, s2);
876 s0 = s1;
877 } else {
878 peg$currPos = s0;
879 s0 = peg$FAILED;
880 }
881 } else {
882 peg$currPos = s0;
883 s0 = peg$FAILED;
884 }
885 peg$resultsCache[key] = {
886 nextPos: peg$currPos,
887 result: s0
888 };
889 return s0;
890 }
891 function peg$parseselectors() {
892 var s0, s1, s2, s3, s4, s5, s6, s7;
893 var key = peg$currPos * 32 + 5,
894 cached = peg$resultsCache[key];
895 if (cached) {
896 peg$currPos = cached.nextPos;
897 return cached.result;
898 }
899 s0 = peg$currPos;
900 s1 = peg$parseselector();
901 if (s1 !== peg$FAILED) {
902 s2 = [];
903 s3 = peg$currPos;
904 s4 = peg$parse_();
905 if (s4 !== peg$FAILED) {
906 if (input.charCodeAt(peg$currPos) === 44) {
907 s5 = peg$c17;
908 peg$currPos++;
909 } else {
910 s5 = peg$FAILED;
911 {
912 peg$fail(peg$c18);
913 }
914 }
915 if (s5 !== peg$FAILED) {
916 s6 = peg$parse_();
917 if (s6 !== peg$FAILED) {
918 s7 = peg$parseselector();
919 if (s7 !== peg$FAILED) {
920 s4 = [s4, s5, s6, s7];
921 s3 = s4;
922 } else {
923 peg$currPos = s3;
924 s3 = peg$FAILED;
925 }
926 } else {
927 peg$currPos = s3;
928 s3 = peg$FAILED;
929 }
930 } else {
931 peg$currPos = s3;
932 s3 = peg$FAILED;
933 }
934 } else {
935 peg$currPos = s3;
936 s3 = peg$FAILED;
937 }
938 while (s3 !== peg$FAILED) {
939 s2.push(s3);
940 s3 = peg$currPos;
941 s4 = peg$parse_();
942 if (s4 !== peg$FAILED) {
943 if (input.charCodeAt(peg$currPos) === 44) {
944 s5 = peg$c17;
945 peg$currPos++;
946 } else {
947 s5 = peg$FAILED;
948 {
949 peg$fail(peg$c18);
950 }
951 }
952 if (s5 !== peg$FAILED) {
953 s6 = peg$parse_();
954 if (s6 !== peg$FAILED) {
955 s7 = peg$parseselector();
956 if (s7 !== peg$FAILED) {
957 s4 = [s4, s5, s6, s7];
958 s3 = s4;
959 } else {
960 peg$currPos = s3;
961 s3 = peg$FAILED;
962 }
963 } else {
964 peg$currPos = s3;
965 s3 = peg$FAILED;
966 }
967 } else {
968 peg$currPos = s3;
969 s3 = peg$FAILED;
970 }
971 } else {
972 peg$currPos = s3;
973 s3 = peg$FAILED;
974 }
975 }
976 if (s2 !== peg$FAILED) {
977 s1 = peg$c19(s1, s2);
978 s0 = s1;
979 } else {
980 peg$currPos = s0;
981 s0 = peg$FAILED;
982 }
983 } else {
984 peg$currPos = s0;
985 s0 = peg$FAILED;
986 }
987 peg$resultsCache[key] = {
988 nextPos: peg$currPos,
989 result: s0
990 };
991 return s0;
992 }
993 function peg$parsehasSelector() {
994 var s0, s1, s2;
995 var key = peg$currPos * 32 + 6,
996 cached = peg$resultsCache[key];
997 if (cached) {
998 peg$currPos = cached.nextPos;
999 return cached.result;
1000 }
1001 s0 = peg$currPos;
1002 s1 = peg$parsebinaryOp();
1003 if (s1 === peg$FAILED) {
1004 s1 = null;
1005 }
1006 if (s1 !== peg$FAILED) {
1007 s2 = peg$parseselector();
1008 if (s2 !== peg$FAILED) {
1009 s1 = peg$c20(s1, s2);
1010 s0 = s1;
1011 } else {
1012 peg$currPos = s0;
1013 s0 = peg$FAILED;
1014 }
1015 } else {
1016 peg$currPos = s0;
1017 s0 = peg$FAILED;
1018 }
1019 peg$resultsCache[key] = {
1020 nextPos: peg$currPos,
1021 result: s0
1022 };
1023 return s0;
1024 }
1025 function peg$parseselector() {
1026 var s0, s1, s2, s3, s4, s5;
1027 var key = peg$currPos * 32 + 7,
1028 cached = peg$resultsCache[key];
1029 if (cached) {
1030 peg$currPos = cached.nextPos;
1031 return cached.result;
1032 }
1033 s0 = peg$currPos;
1034 s1 = peg$parsesequence();
1035 if (s1 !== peg$FAILED) {
1036 s2 = [];
1037 s3 = peg$currPos;
1038 s4 = peg$parsebinaryOp();
1039 if (s4 !== peg$FAILED) {
1040 s5 = peg$parsesequence();
1041 if (s5 !== peg$FAILED) {
1042 s4 = [s4, s5];
1043 s3 = s4;
1044 } else {
1045 peg$currPos = s3;
1046 s3 = peg$FAILED;
1047 }
1048 } else {
1049 peg$currPos = s3;
1050 s3 = peg$FAILED;
1051 }
1052 while (s3 !== peg$FAILED) {
1053 s2.push(s3);
1054 s3 = peg$currPos;
1055 s4 = peg$parsebinaryOp();
1056 if (s4 !== peg$FAILED) {
1057 s5 = peg$parsesequence();
1058 if (s5 !== peg$FAILED) {
1059 s4 = [s4, s5];
1060 s3 = s4;
1061 } else {
1062 peg$currPos = s3;
1063 s3 = peg$FAILED;
1064 }
1065 } else {
1066 peg$currPos = s3;
1067 s3 = peg$FAILED;
1068 }
1069 }
1070 if (s2 !== peg$FAILED) {
1071 s1 = peg$c21(s1, s2);
1072 s0 = s1;
1073 } else {
1074 peg$currPos = s0;
1075 s0 = peg$FAILED;
1076 }
1077 } else {
1078 peg$currPos = s0;
1079 s0 = peg$FAILED;
1080 }
1081 peg$resultsCache[key] = {
1082 nextPos: peg$currPos,
1083 result: s0
1084 };
1085 return s0;
1086 }
1087 function peg$parsesequence() {
1088 var s0, s1, s2, s3;
1089 var key = peg$currPos * 32 + 8,
1090 cached = peg$resultsCache[key];
1091 if (cached) {
1092 peg$currPos = cached.nextPos;
1093 return cached.result;
1094 }
1095 s0 = peg$currPos;
1096 if (input.charCodeAt(peg$currPos) === 33) {
1097 s1 = peg$c22;
1098 peg$currPos++;
1099 } else {
1100 s1 = peg$FAILED;
1101 {
1102 peg$fail(peg$c23);
1103 }
1104 }
1105 if (s1 === peg$FAILED) {
1106 s1 = null;
1107 }
1108 if (s1 !== peg$FAILED) {
1109 s2 = [];
1110 s3 = peg$parseatom();
1111 if (s3 !== peg$FAILED) {
1112 while (s3 !== peg$FAILED) {
1113 s2.push(s3);
1114 s3 = peg$parseatom();
1115 }
1116 } else {
1117 s2 = peg$FAILED;
1118 }
1119 if (s2 !== peg$FAILED) {
1120 s1 = peg$c24(s1, s2);
1121 s0 = s1;
1122 } else {
1123 peg$currPos = s0;
1124 s0 = peg$FAILED;
1125 }
1126 } else {
1127 peg$currPos = s0;
1128 s0 = peg$FAILED;
1129 }
1130 peg$resultsCache[key] = {
1131 nextPos: peg$currPos,
1132 result: s0
1133 };
1134 return s0;
1135 }
1136 function peg$parseatom() {
1137 var s0;
1138 var key = peg$currPos * 32 + 9,
1139 cached = peg$resultsCache[key];
1140 if (cached) {
1141 peg$currPos = cached.nextPos;
1142 return cached.result;
1143 }
1144 s0 = peg$parsewildcard();
1145 if (s0 === peg$FAILED) {
1146 s0 = peg$parseidentifier();
1147 if (s0 === peg$FAILED) {
1148 s0 = peg$parseattr();
1149 if (s0 === peg$FAILED) {
1150 s0 = peg$parsefield();
1151 if (s0 === peg$FAILED) {
1152 s0 = peg$parsenegation();
1153 if (s0 === peg$FAILED) {
1154 s0 = peg$parsematches();
1155 if (s0 === peg$FAILED) {
1156 s0 = peg$parsehas();
1157 if (s0 === peg$FAILED) {
1158 s0 = peg$parsefirstChild();
1159 if (s0 === peg$FAILED) {
1160 s0 = peg$parselastChild();
1161 if (s0 === peg$FAILED) {
1162 s0 = peg$parsenthChild();
1163 if (s0 === peg$FAILED) {
1164 s0 = peg$parsenthLastChild();
1165 if (s0 === peg$FAILED) {
1166 s0 = peg$parseclass();
1167 }
1168 }
1169 }
1170 }
1171 }
1172 }
1173 }
1174 }
1175 }
1176 }
1177 }
1178 peg$resultsCache[key] = {
1179 nextPos: peg$currPos,
1180 result: s0
1181 };
1182 return s0;
1183 }
1184 function peg$parsewildcard() {
1185 var s0, s1;
1186 var key = peg$currPos * 32 + 10,
1187 cached = peg$resultsCache[key];
1188 if (cached) {
1189 peg$currPos = cached.nextPos;
1190 return cached.result;
1191 }
1192 s0 = peg$currPos;
1193 if (input.charCodeAt(peg$currPos) === 42) {
1194 s1 = peg$c25;
1195 peg$currPos++;
1196 } else {
1197 s1 = peg$FAILED;
1198 {
1199 peg$fail(peg$c26);
1200 }
1201 }
1202 if (s1 !== peg$FAILED) {
1203 s1 = peg$c27(s1);
1204 }
1205 s0 = s1;
1206 peg$resultsCache[key] = {
1207 nextPos: peg$currPos,
1208 result: s0
1209 };
1210 return s0;
1211 }
1212 function peg$parseidentifier() {
1213 var s0, s1, s2;
1214 var key = peg$currPos * 32 + 11,
1215 cached = peg$resultsCache[key];
1216 if (cached) {
1217 peg$currPos = cached.nextPos;
1218 return cached.result;
1219 }
1220 s0 = peg$currPos;
1221 if (input.charCodeAt(peg$currPos) === 35) {
1222 s1 = peg$c28;
1223 peg$currPos++;
1224 } else {
1225 s1 = peg$FAILED;
1226 {
1227 peg$fail(peg$c29);
1228 }
1229 }
1230 if (s1 === peg$FAILED) {
1231 s1 = null;
1232 }
1233 if (s1 !== peg$FAILED) {
1234 s2 = peg$parseidentifierName();
1235 if (s2 !== peg$FAILED) {
1236 s1 = peg$c30(s2);
1237 s0 = s1;
1238 } else {
1239 peg$currPos = s0;
1240 s0 = peg$FAILED;
1241 }
1242 } else {
1243 peg$currPos = s0;
1244 s0 = peg$FAILED;
1245 }
1246 peg$resultsCache[key] = {
1247 nextPos: peg$currPos,
1248 result: s0
1249 };
1250 return s0;
1251 }
1252 function peg$parseattr() {
1253 var s0, s1, s2, s3, s4, s5;
1254 var key = peg$currPos * 32 + 12,
1255 cached = peg$resultsCache[key];
1256 if (cached) {
1257 peg$currPos = cached.nextPos;
1258 return cached.result;
1259 }
1260 s0 = peg$currPos;
1261 if (input.charCodeAt(peg$currPos) === 91) {
1262 s1 = peg$c31;
1263 peg$currPos++;
1264 } else {
1265 s1 = peg$FAILED;
1266 {
1267 peg$fail(peg$c32);
1268 }
1269 }
1270 if (s1 !== peg$FAILED) {
1271 s2 = peg$parse_();
1272 if (s2 !== peg$FAILED) {
1273 s3 = peg$parseattrValue();
1274 if (s3 !== peg$FAILED) {
1275 s4 = peg$parse_();
1276 if (s4 !== peg$FAILED) {
1277 if (input.charCodeAt(peg$currPos) === 93) {
1278 s5 = peg$c33;
1279 peg$currPos++;
1280 } else {
1281 s5 = peg$FAILED;
1282 {
1283 peg$fail(peg$c34);
1284 }
1285 }
1286 if (s5 !== peg$FAILED) {
1287 s1 = peg$c35(s3);
1288 s0 = s1;
1289 } else {
1290 peg$currPos = s0;
1291 s0 = peg$FAILED;
1292 }
1293 } else {
1294 peg$currPos = s0;
1295 s0 = peg$FAILED;
1296 }
1297 } else {
1298 peg$currPos = s0;
1299 s0 = peg$FAILED;
1300 }
1301 } else {
1302 peg$currPos = s0;
1303 s0 = peg$FAILED;
1304 }
1305 } else {
1306 peg$currPos = s0;
1307 s0 = peg$FAILED;
1308 }
1309 peg$resultsCache[key] = {
1310 nextPos: peg$currPos,
1311 result: s0
1312 };
1313 return s0;
1314 }
1315 function peg$parseattrOps() {
1316 var s0, s1, s2;
1317 var key = peg$currPos * 32 + 13,
1318 cached = peg$resultsCache[key];
1319 if (cached) {
1320 peg$currPos = cached.nextPos;
1321 return cached.result;
1322 }
1323 s0 = peg$currPos;
1324 if (peg$c36.test(input.charAt(peg$currPos))) {
1325 s1 = input.charAt(peg$currPos);
1326 peg$currPos++;
1327 } else {
1328 s1 = peg$FAILED;
1329 {
1330 peg$fail(peg$c37);
1331 }
1332 }
1333 if (s1 === peg$FAILED) {
1334 s1 = null;
1335 }
1336 if (s1 !== peg$FAILED) {
1337 if (input.charCodeAt(peg$currPos) === 61) {
1338 s2 = peg$c38;
1339 peg$currPos++;
1340 } else {
1341 s2 = peg$FAILED;
1342 {
1343 peg$fail(peg$c39);
1344 }
1345 }
1346 if (s2 !== peg$FAILED) {
1347 s1 = peg$c40(s1);
1348 s0 = s1;
1349 } else {
1350 peg$currPos = s0;
1351 s0 = peg$FAILED;
1352 }
1353 } else {
1354 peg$currPos = s0;
1355 s0 = peg$FAILED;
1356 }
1357 if (s0 === peg$FAILED) {
1358 if (peg$c41.test(input.charAt(peg$currPos))) {
1359 s0 = input.charAt(peg$currPos);
1360 peg$currPos++;
1361 } else {
1362 s0 = peg$FAILED;
1363 {
1364 peg$fail(peg$c42);
1365 }
1366 }
1367 }
1368 peg$resultsCache[key] = {
1369 nextPos: peg$currPos,
1370 result: s0
1371 };
1372 return s0;
1373 }
1374 function peg$parseattrEqOps() {
1375 var s0, s1, s2;
1376 var key = peg$currPos * 32 + 14,
1377 cached = peg$resultsCache[key];
1378 if (cached) {
1379 peg$currPos = cached.nextPos;
1380 return cached.result;
1381 }
1382 s0 = peg$currPos;
1383 if (input.charCodeAt(peg$currPos) === 33) {
1384 s1 = peg$c22;
1385 peg$currPos++;
1386 } else {
1387 s1 = peg$FAILED;
1388 {
1389 peg$fail(peg$c23);
1390 }
1391 }
1392 if (s1 === peg$FAILED) {
1393 s1 = null;
1394 }
1395 if (s1 !== peg$FAILED) {
1396 if (input.charCodeAt(peg$currPos) === 61) {
1397 s2 = peg$c38;
1398 peg$currPos++;
1399 } else {
1400 s2 = peg$FAILED;
1401 {
1402 peg$fail(peg$c39);
1403 }
1404 }
1405 if (s2 !== peg$FAILED) {
1406 s1 = peg$c40(s1);
1407 s0 = s1;
1408 } else {
1409 peg$currPos = s0;
1410 s0 = peg$FAILED;
1411 }
1412 } else {
1413 peg$currPos = s0;
1414 s0 = peg$FAILED;
1415 }
1416 peg$resultsCache[key] = {
1417 nextPos: peg$currPos,
1418 result: s0
1419 };
1420 return s0;
1421 }
1422 function peg$parseattrName() {
1423 var s0, s1, s2, s3, s4, s5;
1424 var key = peg$currPos * 32 + 15,
1425 cached = peg$resultsCache[key];
1426 if (cached) {
1427 peg$currPos = cached.nextPos;
1428 return cached.result;
1429 }
1430 s0 = peg$currPos;
1431 s1 = peg$parseidentifierName();
1432 if (s1 !== peg$FAILED) {
1433 s2 = [];
1434 s3 = peg$currPos;
1435 if (input.charCodeAt(peg$currPos) === 46) {
1436 s4 = peg$c43;
1437 peg$currPos++;
1438 } else {
1439 s4 = peg$FAILED;
1440 {
1441 peg$fail(peg$c44);
1442 }
1443 }
1444 if (s4 !== peg$FAILED) {
1445 s5 = peg$parseidentifierName();
1446 if (s5 !== peg$FAILED) {
1447 s4 = [s4, s5];
1448 s3 = s4;
1449 } else {
1450 peg$currPos = s3;
1451 s3 = peg$FAILED;
1452 }
1453 } else {
1454 peg$currPos = s3;
1455 s3 = peg$FAILED;
1456 }
1457 while (s3 !== peg$FAILED) {
1458 s2.push(s3);
1459 s3 = peg$currPos;
1460 if (input.charCodeAt(peg$currPos) === 46) {
1461 s4 = peg$c43;
1462 peg$currPos++;
1463 } else {
1464 s4 = peg$FAILED;
1465 {
1466 peg$fail(peg$c44);
1467 }
1468 }
1469 if (s4 !== peg$FAILED) {
1470 s5 = peg$parseidentifierName();
1471 if (s5 !== peg$FAILED) {
1472 s4 = [s4, s5];
1473 s3 = s4;
1474 } else {
1475 peg$currPos = s3;
1476 s3 = peg$FAILED;
1477 }
1478 } else {
1479 peg$currPos = s3;
1480 s3 = peg$FAILED;
1481 }
1482 }
1483 if (s2 !== peg$FAILED) {
1484 s1 = peg$c45(s1, s2);
1485 s0 = s1;
1486 } else {
1487 peg$currPos = s0;
1488 s0 = peg$FAILED;
1489 }
1490 } else {
1491 peg$currPos = s0;
1492 s0 = peg$FAILED;
1493 }
1494 peg$resultsCache[key] = {
1495 nextPos: peg$currPos,
1496 result: s0
1497 };
1498 return s0;
1499 }
1500 function peg$parseattrValue() {
1501 var s0, s1, s2, s3, s4, s5;
1502 var key = peg$currPos * 32 + 16,
1503 cached = peg$resultsCache[key];
1504 if (cached) {
1505 peg$currPos = cached.nextPos;
1506 return cached.result;
1507 }
1508 s0 = peg$currPos;
1509 s1 = peg$parseattrName();
1510 if (s1 !== peg$FAILED) {
1511 s2 = peg$parse_();
1512 if (s2 !== peg$FAILED) {
1513 s3 = peg$parseattrEqOps();
1514 if (s3 !== peg$FAILED) {
1515 s4 = peg$parse_();
1516 if (s4 !== peg$FAILED) {
1517 s5 = peg$parsetype();
1518 if (s5 === peg$FAILED) {
1519 s5 = peg$parseregex();
1520 }
1521 if (s5 !== peg$FAILED) {
1522 s1 = peg$c46(s1, s3, s5);
1523 s0 = s1;
1524 } else {
1525 peg$currPos = s0;
1526 s0 = peg$FAILED;
1527 }
1528 } else {
1529 peg$currPos = s0;
1530 s0 = peg$FAILED;
1531 }
1532 } else {
1533 peg$currPos = s0;
1534 s0 = peg$FAILED;
1535 }
1536 } else {
1537 peg$currPos = s0;
1538 s0 = peg$FAILED;
1539 }
1540 } else {
1541 peg$currPos = s0;
1542 s0 = peg$FAILED;
1543 }
1544 if (s0 === peg$FAILED) {
1545 s0 = peg$currPos;
1546 s1 = peg$parseattrName();
1547 if (s1 !== peg$FAILED) {
1548 s2 = peg$parse_();
1549 if (s2 !== peg$FAILED) {
1550 s3 = peg$parseattrOps();
1551 if (s3 !== peg$FAILED) {
1552 s4 = peg$parse_();
1553 if (s4 !== peg$FAILED) {
1554 s5 = peg$parsestring();
1555 if (s5 === peg$FAILED) {
1556 s5 = peg$parsenumber();
1557 if (s5 === peg$FAILED) {
1558 s5 = peg$parsepath();
1559 }
1560 }
1561 if (s5 !== peg$FAILED) {
1562 s1 = peg$c46(s1, s3, s5);
1563 s0 = s1;
1564 } else {
1565 peg$currPos = s0;
1566 s0 = peg$FAILED;
1567 }
1568 } else {
1569 peg$currPos = s0;
1570 s0 = peg$FAILED;
1571 }
1572 } else {
1573 peg$currPos = s0;
1574 s0 = peg$FAILED;
1575 }
1576 } else {
1577 peg$currPos = s0;
1578 s0 = peg$FAILED;
1579 }
1580 } else {
1581 peg$currPos = s0;
1582 s0 = peg$FAILED;
1583 }
1584 if (s0 === peg$FAILED) {
1585 s0 = peg$currPos;
1586 s1 = peg$parseattrName();
1587 if (s1 !== peg$FAILED) {
1588 s1 = peg$c47(s1);
1589 }
1590 s0 = s1;
1591 }
1592 }
1593 peg$resultsCache[key] = {
1594 nextPos: peg$currPos,
1595 result: s0
1596 };
1597 return s0;
1598 }
1599 function peg$parsestring() {
1600 var s0, s1, s2, s3, s4, s5;
1601 var key = peg$currPos * 32 + 17,
1602 cached = peg$resultsCache[key];
1603 if (cached) {
1604 peg$currPos = cached.nextPos;
1605 return cached.result;
1606 }
1607 s0 = peg$currPos;
1608 if (input.charCodeAt(peg$currPos) === 34) {
1609 s1 = peg$c48;
1610 peg$currPos++;
1611 } else {
1612 s1 = peg$FAILED;
1613 {
1614 peg$fail(peg$c49);
1615 }
1616 }
1617 if (s1 !== peg$FAILED) {
1618 s2 = [];
1619 if (peg$c50.test(input.charAt(peg$currPos))) {
1620 s3 = input.charAt(peg$currPos);
1621 peg$currPos++;
1622 } else {
1623 s3 = peg$FAILED;
1624 {
1625 peg$fail(peg$c51);
1626 }
1627 }
1628 if (s3 === peg$FAILED) {
1629 s3 = peg$currPos;
1630 if (input.charCodeAt(peg$currPos) === 92) {
1631 s4 = peg$c52;
1632 peg$currPos++;
1633 } else {
1634 s4 = peg$FAILED;
1635 {
1636 peg$fail(peg$c53);
1637 }
1638 }
1639 if (s4 !== peg$FAILED) {
1640 if (input.length > peg$currPos) {
1641 s5 = input.charAt(peg$currPos);
1642 peg$currPos++;
1643 } else {
1644 s5 = peg$FAILED;
1645 {
1646 peg$fail(peg$c54);
1647 }
1648 }
1649 if (s5 !== peg$FAILED) {
1650 s4 = peg$c55(s4, s5);
1651 s3 = s4;
1652 } else {
1653 peg$currPos = s3;
1654 s3 = peg$FAILED;
1655 }
1656 } else {
1657 peg$currPos = s3;
1658 s3 = peg$FAILED;
1659 }
1660 }
1661 while (s3 !== peg$FAILED) {
1662 s2.push(s3);
1663 if (peg$c50.test(input.charAt(peg$currPos))) {
1664 s3 = input.charAt(peg$currPos);
1665 peg$currPos++;
1666 } else {
1667 s3 = peg$FAILED;
1668 {
1669 peg$fail(peg$c51);
1670 }
1671 }
1672 if (s3 === peg$FAILED) {
1673 s3 = peg$currPos;
1674 if (input.charCodeAt(peg$currPos) === 92) {
1675 s4 = peg$c52;
1676 peg$currPos++;
1677 } else {
1678 s4 = peg$FAILED;
1679 {
1680 peg$fail(peg$c53);
1681 }
1682 }
1683 if (s4 !== peg$FAILED) {
1684 if (input.length > peg$currPos) {
1685 s5 = input.charAt(peg$currPos);
1686 peg$currPos++;
1687 } else {
1688 s5 = peg$FAILED;
1689 {
1690 peg$fail(peg$c54);
1691 }
1692 }
1693 if (s5 !== peg$FAILED) {
1694 s4 = peg$c55(s4, s5);
1695 s3 = s4;
1696 } else {
1697 peg$currPos = s3;
1698 s3 = peg$FAILED;
1699 }
1700 } else {
1701 peg$currPos = s3;
1702 s3 = peg$FAILED;
1703 }
1704 }
1705 }
1706 if (s2 !== peg$FAILED) {
1707 if (input.charCodeAt(peg$currPos) === 34) {
1708 s3 = peg$c48;
1709 peg$currPos++;
1710 } else {
1711 s3 = peg$FAILED;
1712 {
1713 peg$fail(peg$c49);
1714 }
1715 }
1716 if (s3 !== peg$FAILED) {
1717 s1 = peg$c56(s2);
1718 s0 = s1;
1719 } else {
1720 peg$currPos = s0;
1721 s0 = peg$FAILED;
1722 }
1723 } else {
1724 peg$currPos = s0;
1725 s0 = peg$FAILED;
1726 }
1727 } else {
1728 peg$currPos = s0;
1729 s0 = peg$FAILED;
1730 }
1731 if (s0 === peg$FAILED) {
1732 s0 = peg$currPos;
1733 if (input.charCodeAt(peg$currPos) === 39) {
1734 s1 = peg$c57;
1735 peg$currPos++;
1736 } else {
1737 s1 = peg$FAILED;
1738 {
1739 peg$fail(peg$c58);
1740 }
1741 }
1742 if (s1 !== peg$FAILED) {
1743 s2 = [];
1744 if (peg$c59.test(input.charAt(peg$currPos))) {
1745 s3 = input.charAt(peg$currPos);
1746 peg$currPos++;
1747 } else {
1748 s3 = peg$FAILED;
1749 {
1750 peg$fail(peg$c60);
1751 }
1752 }
1753 if (s3 === peg$FAILED) {
1754 s3 = peg$currPos;
1755 if (input.charCodeAt(peg$currPos) === 92) {
1756 s4 = peg$c52;
1757 peg$currPos++;
1758 } else {
1759 s4 = peg$FAILED;
1760 {
1761 peg$fail(peg$c53);
1762 }
1763 }
1764 if (s4 !== peg$FAILED) {
1765 if (input.length > peg$currPos) {
1766 s5 = input.charAt(peg$currPos);
1767 peg$currPos++;
1768 } else {
1769 s5 = peg$FAILED;
1770 {
1771 peg$fail(peg$c54);
1772 }
1773 }
1774 if (s5 !== peg$FAILED) {
1775 s4 = peg$c55(s4, s5);
1776 s3 = s4;
1777 } else {
1778 peg$currPos = s3;
1779 s3 = peg$FAILED;
1780 }
1781 } else {
1782 peg$currPos = s3;
1783 s3 = peg$FAILED;
1784 }
1785 }
1786 while (s3 !== peg$FAILED) {
1787 s2.push(s3);
1788 if (peg$c59.test(input.charAt(peg$currPos))) {
1789 s3 = input.charAt(peg$currPos);
1790 peg$currPos++;
1791 } else {
1792 s3 = peg$FAILED;
1793 {
1794 peg$fail(peg$c60);
1795 }
1796 }
1797 if (s3 === peg$FAILED) {
1798 s3 = peg$currPos;
1799 if (input.charCodeAt(peg$currPos) === 92) {
1800 s4 = peg$c52;
1801 peg$currPos++;
1802 } else {
1803 s4 = peg$FAILED;
1804 {
1805 peg$fail(peg$c53);
1806 }
1807 }
1808 if (s4 !== peg$FAILED) {
1809 if (input.length > peg$currPos) {
1810 s5 = input.charAt(peg$currPos);
1811 peg$currPos++;
1812 } else {
1813 s5 = peg$FAILED;
1814 {
1815 peg$fail(peg$c54);
1816 }
1817 }
1818 if (s5 !== peg$FAILED) {
1819 s4 = peg$c55(s4, s5);
1820 s3 = s4;
1821 } else {
1822 peg$currPos = s3;
1823 s3 = peg$FAILED;
1824 }
1825 } else {
1826 peg$currPos = s3;
1827 s3 = peg$FAILED;
1828 }
1829 }
1830 }
1831 if (s2 !== peg$FAILED) {
1832 if (input.charCodeAt(peg$currPos) === 39) {
1833 s3 = peg$c57;
1834 peg$currPos++;
1835 } else {
1836 s3 = peg$FAILED;
1837 {
1838 peg$fail(peg$c58);
1839 }
1840 }
1841 if (s3 !== peg$FAILED) {
1842 s1 = peg$c56(s2);
1843 s0 = s1;
1844 } else {
1845 peg$currPos = s0;
1846 s0 = peg$FAILED;
1847 }
1848 } else {
1849 peg$currPos = s0;
1850 s0 = peg$FAILED;
1851 }
1852 } else {
1853 peg$currPos = s0;
1854 s0 = peg$FAILED;
1855 }
1856 }
1857 peg$resultsCache[key] = {
1858 nextPos: peg$currPos,
1859 result: s0
1860 };
1861 return s0;
1862 }
1863 function peg$parsenumber() {
1864 var s0, s1, s2, s3;
1865 var key = peg$currPos * 32 + 18,
1866 cached = peg$resultsCache[key];
1867 if (cached) {
1868 peg$currPos = cached.nextPos;
1869 return cached.result;
1870 }
1871 s0 = peg$currPos;
1872 s1 = peg$currPos;
1873 s2 = [];
1874 if (peg$c61.test(input.charAt(peg$currPos))) {
1875 s3 = input.charAt(peg$currPos);
1876 peg$currPos++;
1877 } else {
1878 s3 = peg$FAILED;
1879 {
1880 peg$fail(peg$c62);
1881 }
1882 }
1883 while (s3 !== peg$FAILED) {
1884 s2.push(s3);
1885 if (peg$c61.test(input.charAt(peg$currPos))) {
1886 s3 = input.charAt(peg$currPos);
1887 peg$currPos++;
1888 } else {
1889 s3 = peg$FAILED;
1890 {
1891 peg$fail(peg$c62);
1892 }
1893 }
1894 }
1895 if (s2 !== peg$FAILED) {
1896 if (input.charCodeAt(peg$currPos) === 46) {
1897 s3 = peg$c43;
1898 peg$currPos++;
1899 } else {
1900 s3 = peg$FAILED;
1901 {
1902 peg$fail(peg$c44);
1903 }
1904 }
1905 if (s3 !== peg$FAILED) {
1906 s2 = [s2, s3];
1907 s1 = s2;
1908 } else {
1909 peg$currPos = s1;
1910 s1 = peg$FAILED;
1911 }
1912 } else {
1913 peg$currPos = s1;
1914 s1 = peg$FAILED;
1915 }
1916 if (s1 === peg$FAILED) {
1917 s1 = null;
1918 }
1919 if (s1 !== peg$FAILED) {
1920 s2 = [];
1921 if (peg$c61.test(input.charAt(peg$currPos))) {
1922 s3 = input.charAt(peg$currPos);
1923 peg$currPos++;
1924 } else {
1925 s3 = peg$FAILED;
1926 {
1927 peg$fail(peg$c62);
1928 }
1929 }
1930 if (s3 !== peg$FAILED) {
1931 while (s3 !== peg$FAILED) {
1932 s2.push(s3);
1933 if (peg$c61.test(input.charAt(peg$currPos))) {
1934 s3 = input.charAt(peg$currPos);
1935 peg$currPos++;
1936 } else {
1937 s3 = peg$FAILED;
1938 {
1939 peg$fail(peg$c62);
1940 }
1941 }
1942 }
1943 } else {
1944 s2 = peg$FAILED;
1945 }
1946 if (s2 !== peg$FAILED) {
1947 s1 = peg$c63(s1, s2);
1948 s0 = s1;
1949 } else {
1950 peg$currPos = s0;
1951 s0 = peg$FAILED;
1952 }
1953 } else {
1954 peg$currPos = s0;
1955 s0 = peg$FAILED;
1956 }
1957 peg$resultsCache[key] = {
1958 nextPos: peg$currPos,
1959 result: s0
1960 };
1961 return s0;
1962 }
1963 function peg$parsepath() {
1964 var s0, s1;
1965 var key = peg$currPos * 32 + 19,
1966 cached = peg$resultsCache[key];
1967 if (cached) {
1968 peg$currPos = cached.nextPos;
1969 return cached.result;
1970 }
1971 s0 = peg$currPos;
1972 s1 = peg$parseidentifierName();
1973 if (s1 !== peg$FAILED) {
1974 s1 = peg$c64(s1);
1975 }
1976 s0 = s1;
1977 peg$resultsCache[key] = {
1978 nextPos: peg$currPos,
1979 result: s0
1980 };
1981 return s0;
1982 }
1983 function peg$parsetype() {
1984 var s0, s1, s2, s3, s4, s5;
1985 var key = peg$currPos * 32 + 20,
1986 cached = peg$resultsCache[key];
1987 if (cached) {
1988 peg$currPos = cached.nextPos;
1989 return cached.result;
1990 }
1991 s0 = peg$currPos;
1992 if (input.substr(peg$currPos, 5) === peg$c65) {
1993 s1 = peg$c65;
1994 peg$currPos += 5;
1995 } else {
1996 s1 = peg$FAILED;
1997 {
1998 peg$fail(peg$c66);
1999 }
2000 }
2001 if (s1 !== peg$FAILED) {
2002 s2 = peg$parse_();
2003 if (s2 !== peg$FAILED) {
2004 s3 = [];
2005 if (peg$c67.test(input.charAt(peg$currPos))) {
2006 s4 = input.charAt(peg$currPos);
2007 peg$currPos++;
2008 } else {
2009 s4 = peg$FAILED;
2010 {
2011 peg$fail(peg$c68);
2012 }
2013 }
2014 if (s4 !== peg$FAILED) {
2015 while (s4 !== peg$FAILED) {
2016 s3.push(s4);
2017 if (peg$c67.test(input.charAt(peg$currPos))) {
2018 s4 = input.charAt(peg$currPos);
2019 peg$currPos++;
2020 } else {
2021 s4 = peg$FAILED;
2022 {
2023 peg$fail(peg$c68);
2024 }
2025 }
2026 }
2027 } else {
2028 s3 = peg$FAILED;
2029 }
2030 if (s3 !== peg$FAILED) {
2031 s4 = peg$parse_();
2032 if (s4 !== peg$FAILED) {
2033 if (input.charCodeAt(peg$currPos) === 41) {
2034 s5 = peg$c69;
2035 peg$currPos++;
2036 } else {
2037 s5 = peg$FAILED;
2038 {
2039 peg$fail(peg$c70);
2040 }
2041 }
2042 if (s5 !== peg$FAILED) {
2043 s1 = peg$c71(s3);
2044 s0 = s1;
2045 } else {
2046 peg$currPos = s0;
2047 s0 = peg$FAILED;
2048 }
2049 } else {
2050 peg$currPos = s0;
2051 s0 = peg$FAILED;
2052 }
2053 } else {
2054 peg$currPos = s0;
2055 s0 = peg$FAILED;
2056 }
2057 } else {
2058 peg$currPos = s0;
2059 s0 = peg$FAILED;
2060 }
2061 } else {
2062 peg$currPos = s0;
2063 s0 = peg$FAILED;
2064 }
2065 peg$resultsCache[key] = {
2066 nextPos: peg$currPos,
2067 result: s0
2068 };
2069 return s0;
2070 }
2071 function peg$parseflags() {
2072 var s0, s1;
2073 var key = peg$currPos * 32 + 21,
2074 cached = peg$resultsCache[key];
2075 if (cached) {
2076 peg$currPos = cached.nextPos;
2077 return cached.result;
2078 }
2079 s0 = [];
2080 if (peg$c72.test(input.charAt(peg$currPos))) {
2081 s1 = input.charAt(peg$currPos);
2082 peg$currPos++;
2083 } else {
2084 s1 = peg$FAILED;
2085 {
2086 peg$fail(peg$c73);
2087 }
2088 }
2089 if (s1 !== peg$FAILED) {
2090 while (s1 !== peg$FAILED) {
2091 s0.push(s1);
2092 if (peg$c72.test(input.charAt(peg$currPos))) {
2093 s1 = input.charAt(peg$currPos);
2094 peg$currPos++;
2095 } else {
2096 s1 = peg$FAILED;
2097 {
2098 peg$fail(peg$c73);
2099 }
2100 }
2101 }
2102 } else {
2103 s0 = peg$FAILED;
2104 }
2105 peg$resultsCache[key] = {
2106 nextPos: peg$currPos,
2107 result: s0
2108 };
2109 return s0;
2110 }
2111 function peg$parseregex() {
2112 var s0, s1, s2, s3, s4;
2113 var key = peg$currPos * 32 + 22,
2114 cached = peg$resultsCache[key];
2115 if (cached) {
2116 peg$currPos = cached.nextPos;
2117 return cached.result;
2118 }
2119 s0 = peg$currPos;
2120 if (input.charCodeAt(peg$currPos) === 47) {
2121 s1 = peg$c74;
2122 peg$currPos++;
2123 } else {
2124 s1 = peg$FAILED;
2125 {
2126 peg$fail(peg$c75);
2127 }
2128 }
2129 if (s1 !== peg$FAILED) {
2130 s2 = [];
2131 if (peg$c76.test(input.charAt(peg$currPos))) {
2132 s3 = input.charAt(peg$currPos);
2133 peg$currPos++;
2134 } else {
2135 s3 = peg$FAILED;
2136 {
2137 peg$fail(peg$c77);
2138 }
2139 }
2140 if (s3 !== peg$FAILED) {
2141 while (s3 !== peg$FAILED) {
2142 s2.push(s3);
2143 if (peg$c76.test(input.charAt(peg$currPos))) {
2144 s3 = input.charAt(peg$currPos);
2145 peg$currPos++;
2146 } else {
2147 s3 = peg$FAILED;
2148 {
2149 peg$fail(peg$c77);
2150 }
2151 }
2152 }
2153 } else {
2154 s2 = peg$FAILED;
2155 }
2156 if (s2 !== peg$FAILED) {
2157 if (input.charCodeAt(peg$currPos) === 47) {
2158 s3 = peg$c74;
2159 peg$currPos++;
2160 } else {
2161 s3 = peg$FAILED;
2162 {
2163 peg$fail(peg$c75);
2164 }
2165 }
2166 if (s3 !== peg$FAILED) {
2167 s4 = peg$parseflags();
2168 if (s4 === peg$FAILED) {
2169 s4 = null;
2170 }
2171 if (s4 !== peg$FAILED) {
2172 s1 = peg$c78(s2, s4);
2173 s0 = s1;
2174 } else {
2175 peg$currPos = s0;
2176 s0 = peg$FAILED;
2177 }
2178 } else {
2179 peg$currPos = s0;
2180 s0 = peg$FAILED;
2181 }
2182 } else {
2183 peg$currPos = s0;
2184 s0 = peg$FAILED;
2185 }
2186 } else {
2187 peg$currPos = s0;
2188 s0 = peg$FAILED;
2189 }
2190 peg$resultsCache[key] = {
2191 nextPos: peg$currPos,
2192 result: s0
2193 };
2194 return s0;
2195 }
2196 function peg$parsefield() {
2197 var s0, s1, s2, s3, s4, s5, s6;
2198 var key = peg$currPos * 32 + 23,
2199 cached = peg$resultsCache[key];
2200 if (cached) {
2201 peg$currPos = cached.nextPos;
2202 return cached.result;
2203 }
2204 s0 = peg$currPos;
2205 if (input.charCodeAt(peg$currPos) === 46) {
2206 s1 = peg$c43;
2207 peg$currPos++;
2208 } else {
2209 s1 = peg$FAILED;
2210 {
2211 peg$fail(peg$c44);
2212 }
2213 }
2214 if (s1 !== peg$FAILED) {
2215 s2 = peg$parseidentifierName();
2216 if (s2 !== peg$FAILED) {
2217 s3 = [];
2218 s4 = peg$currPos;
2219 if (input.charCodeAt(peg$currPos) === 46) {
2220 s5 = peg$c43;
2221 peg$currPos++;
2222 } else {
2223 s5 = peg$FAILED;
2224 {
2225 peg$fail(peg$c44);
2226 }
2227 }
2228 if (s5 !== peg$FAILED) {
2229 s6 = peg$parseidentifierName();
2230 if (s6 !== peg$FAILED) {
2231 s5 = [s5, s6];
2232 s4 = s5;
2233 } else {
2234 peg$currPos = s4;
2235 s4 = peg$FAILED;
2236 }
2237 } else {
2238 peg$currPos = s4;
2239 s4 = peg$FAILED;
2240 }
2241 while (s4 !== peg$FAILED) {
2242 s3.push(s4);
2243 s4 = peg$currPos;
2244 if (input.charCodeAt(peg$currPos) === 46) {
2245 s5 = peg$c43;
2246 peg$currPos++;
2247 } else {
2248 s5 = peg$FAILED;
2249 {
2250 peg$fail(peg$c44);
2251 }
2252 }
2253 if (s5 !== peg$FAILED) {
2254 s6 = peg$parseidentifierName();
2255 if (s6 !== peg$FAILED) {
2256 s5 = [s5, s6];
2257 s4 = s5;
2258 } else {
2259 peg$currPos = s4;
2260 s4 = peg$FAILED;
2261 }
2262 } else {
2263 peg$currPos = s4;
2264 s4 = peg$FAILED;
2265 }
2266 }
2267 if (s3 !== peg$FAILED) {
2268 s1 = peg$c79(s2, s3);
2269 s0 = s1;
2270 } else {
2271 peg$currPos = s0;
2272 s0 = peg$FAILED;
2273 }
2274 } else {
2275 peg$currPos = s0;
2276 s0 = peg$FAILED;
2277 }
2278 } else {
2279 peg$currPos = s0;
2280 s0 = peg$FAILED;
2281 }
2282 peg$resultsCache[key] = {
2283 nextPos: peg$currPos,
2284 result: s0
2285 };
2286 return s0;
2287 }
2288 function peg$parsenegation() {
2289 var s0, s1, s2, s3, s4, s5;
2290 var key = peg$currPos * 32 + 24,
2291 cached = peg$resultsCache[key];
2292 if (cached) {
2293 peg$currPos = cached.nextPos;
2294 return cached.result;
2295 }
2296 s0 = peg$currPos;
2297 if (input.substr(peg$currPos, 5) === peg$c80) {
2298 s1 = peg$c80;
2299 peg$currPos += 5;
2300 } else {
2301 s1 = peg$FAILED;
2302 {
2303 peg$fail(peg$c81);
2304 }
2305 }
2306 if (s1 !== peg$FAILED) {
2307 s2 = peg$parse_();
2308 if (s2 !== peg$FAILED) {
2309 s3 = peg$parseselectors();
2310 if (s3 !== peg$FAILED) {
2311 s4 = peg$parse_();
2312 if (s4 !== peg$FAILED) {
2313 if (input.charCodeAt(peg$currPos) === 41) {
2314 s5 = peg$c69;
2315 peg$currPos++;
2316 } else {
2317 s5 = peg$FAILED;
2318 {
2319 peg$fail(peg$c70);
2320 }
2321 }
2322 if (s5 !== peg$FAILED) {
2323 s1 = peg$c82(s3);
2324 s0 = s1;
2325 } else {
2326 peg$currPos = s0;
2327 s0 = peg$FAILED;
2328 }
2329 } else {
2330 peg$currPos = s0;
2331 s0 = peg$FAILED;
2332 }
2333 } else {
2334 peg$currPos = s0;
2335 s0 = peg$FAILED;
2336 }
2337 } else {
2338 peg$currPos = s0;
2339 s0 = peg$FAILED;
2340 }
2341 } else {
2342 peg$currPos = s0;
2343 s0 = peg$FAILED;
2344 }
2345 peg$resultsCache[key] = {
2346 nextPos: peg$currPos,
2347 result: s0
2348 };
2349 return s0;
2350 }
2351 function peg$parsematches() {
2352 var s0, s1, s2, s3, s4, s5;
2353 var key = peg$currPos * 32 + 25,
2354 cached = peg$resultsCache[key];
2355 if (cached) {
2356 peg$currPos = cached.nextPos;
2357 return cached.result;
2358 }
2359 s0 = peg$currPos;
2360 if (input.substr(peg$currPos, 9) === peg$c83) {
2361 s1 = peg$c83;
2362 peg$currPos += 9;
2363 } else {
2364 s1 = peg$FAILED;
2365 {
2366 peg$fail(peg$c84);
2367 }
2368 }
2369 if (s1 !== peg$FAILED) {
2370 s2 = peg$parse_();
2371 if (s2 !== peg$FAILED) {
2372 s3 = peg$parseselectors();
2373 if (s3 !== peg$FAILED) {
2374 s4 = peg$parse_();
2375 if (s4 !== peg$FAILED) {
2376 if (input.charCodeAt(peg$currPos) === 41) {
2377 s5 = peg$c69;
2378 peg$currPos++;
2379 } else {
2380 s5 = peg$FAILED;
2381 {
2382 peg$fail(peg$c70);
2383 }
2384 }
2385 if (s5 !== peg$FAILED) {
2386 s1 = peg$c85(s3);
2387 s0 = s1;
2388 } else {
2389 peg$currPos = s0;
2390 s0 = peg$FAILED;
2391 }
2392 } else {
2393 peg$currPos = s0;
2394 s0 = peg$FAILED;
2395 }
2396 } else {
2397 peg$currPos = s0;
2398 s0 = peg$FAILED;
2399 }
2400 } else {
2401 peg$currPos = s0;
2402 s0 = peg$FAILED;
2403 }
2404 } else {
2405 peg$currPos = s0;
2406 s0 = peg$FAILED;
2407 }
2408 peg$resultsCache[key] = {
2409 nextPos: peg$currPos,
2410 result: s0
2411 };
2412 return s0;
2413 }
2414 function peg$parsehas() {
2415 var s0, s1, s2, s3, s4, s5;
2416 var key = peg$currPos * 32 + 26,
2417 cached = peg$resultsCache[key];
2418 if (cached) {
2419 peg$currPos = cached.nextPos;
2420 return cached.result;
2421 }
2422 s0 = peg$currPos;
2423 if (input.substr(peg$currPos, 5) === peg$c86) {
2424 s1 = peg$c86;
2425 peg$currPos += 5;
2426 } else {
2427 s1 = peg$FAILED;
2428 {
2429 peg$fail(peg$c87);
2430 }
2431 }
2432 if (s1 !== peg$FAILED) {
2433 s2 = peg$parse_();
2434 if (s2 !== peg$FAILED) {
2435 s3 = peg$parsehasSelectors();
2436 if (s3 !== peg$FAILED) {
2437 s4 = peg$parse_();
2438 if (s4 !== peg$FAILED) {
2439 if (input.charCodeAt(peg$currPos) === 41) {
2440 s5 = peg$c69;
2441 peg$currPos++;
2442 } else {
2443 s5 = peg$FAILED;
2444 {
2445 peg$fail(peg$c70);
2446 }
2447 }
2448 if (s5 !== peg$FAILED) {
2449 s1 = peg$c88(s3);
2450 s0 = s1;
2451 } else {
2452 peg$currPos = s0;
2453 s0 = peg$FAILED;
2454 }
2455 } else {
2456 peg$currPos = s0;
2457 s0 = peg$FAILED;
2458 }
2459 } else {
2460 peg$currPos = s0;
2461 s0 = peg$FAILED;
2462 }
2463 } else {
2464 peg$currPos = s0;
2465 s0 = peg$FAILED;
2466 }
2467 } else {
2468 peg$currPos = s0;
2469 s0 = peg$FAILED;
2470 }
2471 peg$resultsCache[key] = {
2472 nextPos: peg$currPos,
2473 result: s0
2474 };
2475 return s0;
2476 }
2477 function peg$parsefirstChild() {
2478 var s0, s1;
2479 var key = peg$currPos * 32 + 27,
2480 cached = peg$resultsCache[key];
2481 if (cached) {
2482 peg$currPos = cached.nextPos;
2483 return cached.result;
2484 }
2485 s0 = peg$currPos;
2486 if (input.substr(peg$currPos, 12) === peg$c89) {
2487 s1 = peg$c89;
2488 peg$currPos += 12;
2489 } else {
2490 s1 = peg$FAILED;
2491 {
2492 peg$fail(peg$c90);
2493 }
2494 }
2495 if (s1 !== peg$FAILED) {
2496 s1 = peg$c91();
2497 }
2498 s0 = s1;
2499 peg$resultsCache[key] = {
2500 nextPos: peg$currPos,
2501 result: s0
2502 };
2503 return s0;
2504 }
2505 function peg$parselastChild() {
2506 var s0, s1;
2507 var key = peg$currPos * 32 + 28,
2508 cached = peg$resultsCache[key];
2509 if (cached) {
2510 peg$currPos = cached.nextPos;
2511 return cached.result;
2512 }
2513 s0 = peg$currPos;
2514 if (input.substr(peg$currPos, 11) === peg$c92) {
2515 s1 = peg$c92;
2516 peg$currPos += 11;
2517 } else {
2518 s1 = peg$FAILED;
2519 {
2520 peg$fail(peg$c93);
2521 }
2522 }
2523 if (s1 !== peg$FAILED) {
2524 s1 = peg$c94();
2525 }
2526 s0 = s1;
2527 peg$resultsCache[key] = {
2528 nextPos: peg$currPos,
2529 result: s0
2530 };
2531 return s0;
2532 }
2533 function peg$parsenthChild() {
2534 var s0, s1, s2, s3, s4, s5;
2535 var key = peg$currPos * 32 + 29,
2536 cached = peg$resultsCache[key];
2537 if (cached) {
2538 peg$currPos = cached.nextPos;
2539 return cached.result;
2540 }
2541 s0 = peg$currPos;
2542 if (input.substr(peg$currPos, 11) === peg$c95) {
2543 s1 = peg$c95;
2544 peg$currPos += 11;
2545 } else {
2546 s1 = peg$FAILED;
2547 {
2548 peg$fail(peg$c96);
2549 }
2550 }
2551 if (s1 !== peg$FAILED) {
2552 s2 = peg$parse_();
2553 if (s2 !== peg$FAILED) {
2554 s3 = [];
2555 if (peg$c61.test(input.charAt(peg$currPos))) {
2556 s4 = input.charAt(peg$currPos);
2557 peg$currPos++;
2558 } else {
2559 s4 = peg$FAILED;
2560 {
2561 peg$fail(peg$c62);
2562 }
2563 }
2564 if (s4 !== peg$FAILED) {
2565 while (s4 !== peg$FAILED) {
2566 s3.push(s4);
2567 if (peg$c61.test(input.charAt(peg$currPos))) {
2568 s4 = input.charAt(peg$currPos);
2569 peg$currPos++;
2570 } else {
2571 s4 = peg$FAILED;
2572 {
2573 peg$fail(peg$c62);
2574 }
2575 }
2576 }
2577 } else {
2578 s3 = peg$FAILED;
2579 }
2580 if (s3 !== peg$FAILED) {
2581 s4 = peg$parse_();
2582 if (s4 !== peg$FAILED) {
2583 if (input.charCodeAt(peg$currPos) === 41) {
2584 s5 = peg$c69;
2585 peg$currPos++;
2586 } else {
2587 s5 = peg$FAILED;
2588 {
2589 peg$fail(peg$c70);
2590 }
2591 }
2592 if (s5 !== peg$FAILED) {
2593 s1 = peg$c97(s3);
2594 s0 = s1;
2595 } else {
2596 peg$currPos = s0;
2597 s0 = peg$FAILED;
2598 }
2599 } else {
2600 peg$currPos = s0;
2601 s0 = peg$FAILED;
2602 }
2603 } else {
2604 peg$currPos = s0;
2605 s0 = peg$FAILED;
2606 }
2607 } else {
2608 peg$currPos = s0;
2609 s0 = peg$FAILED;
2610 }
2611 } else {
2612 peg$currPos = s0;
2613 s0 = peg$FAILED;
2614 }
2615 peg$resultsCache[key] = {
2616 nextPos: peg$currPos,
2617 result: s0
2618 };
2619 return s0;
2620 }
2621 function peg$parsenthLastChild() {
2622 var s0, s1, s2, s3, s4, s5;
2623 var key = peg$currPos * 32 + 30,
2624 cached = peg$resultsCache[key];
2625 if (cached) {
2626 peg$currPos = cached.nextPos;
2627 return cached.result;
2628 }
2629 s0 = peg$currPos;
2630 if (input.substr(peg$currPos, 16) === peg$c98) {
2631 s1 = peg$c98;
2632 peg$currPos += 16;
2633 } else {
2634 s1 = peg$FAILED;
2635 {
2636 peg$fail(peg$c99);
2637 }
2638 }
2639 if (s1 !== peg$FAILED) {
2640 s2 = peg$parse_();
2641 if (s2 !== peg$FAILED) {
2642 s3 = [];
2643 if (peg$c61.test(input.charAt(peg$currPos))) {
2644 s4 = input.charAt(peg$currPos);
2645 peg$currPos++;
2646 } else {
2647 s4 = peg$FAILED;
2648 {
2649 peg$fail(peg$c62);
2650 }
2651 }
2652 if (s4 !== peg$FAILED) {
2653 while (s4 !== peg$FAILED) {
2654 s3.push(s4);
2655 if (peg$c61.test(input.charAt(peg$currPos))) {
2656 s4 = input.charAt(peg$currPos);
2657 peg$currPos++;
2658 } else {
2659 s4 = peg$FAILED;
2660 {
2661 peg$fail(peg$c62);
2662 }
2663 }
2664 }
2665 } else {
2666 s3 = peg$FAILED;
2667 }
2668 if (s3 !== peg$FAILED) {
2669 s4 = peg$parse_();
2670 if (s4 !== peg$FAILED) {
2671 if (input.charCodeAt(peg$currPos) === 41) {
2672 s5 = peg$c69;
2673 peg$currPos++;
2674 } else {
2675 s5 = peg$FAILED;
2676 {
2677 peg$fail(peg$c70);
2678 }
2679 }
2680 if (s5 !== peg$FAILED) {
2681 s1 = peg$c100(s3);
2682 s0 = s1;
2683 } else {
2684 peg$currPos = s0;
2685 s0 = peg$FAILED;
2686 }
2687 } else {
2688 peg$currPos = s0;
2689 s0 = peg$FAILED;
2690 }
2691 } else {
2692 peg$currPos = s0;
2693 s0 = peg$FAILED;
2694 }
2695 } else {
2696 peg$currPos = s0;
2697 s0 = peg$FAILED;
2698 }
2699 } else {
2700 peg$currPos = s0;
2701 s0 = peg$FAILED;
2702 }
2703 peg$resultsCache[key] = {
2704 nextPos: peg$currPos,
2705 result: s0
2706 };
2707 return s0;
2708 }
2709 function peg$parseclass() {
2710 var s0, s1, s2;
2711 var key = peg$currPos * 32 + 31,
2712 cached = peg$resultsCache[key];
2713 if (cached) {
2714 peg$currPos = cached.nextPos;
2715 return cached.result;
2716 }
2717 s0 = peg$currPos;
2718 if (input.charCodeAt(peg$currPos) === 58) {
2719 s1 = peg$c101;
2720 peg$currPos++;
2721 } else {
2722 s1 = peg$FAILED;
2723 {
2724 peg$fail(peg$c102);
2725 }
2726 }
2727 if (s1 !== peg$FAILED) {
2728 s2 = peg$parseidentifierName();
2729 if (s2 !== peg$FAILED) {
2730 s1 = peg$c103(s2);
2731 s0 = s1;
2732 } else {
2733 peg$currPos = s0;
2734 s0 = peg$FAILED;
2735 }
2736 } else {
2737 peg$currPos = s0;
2738 s0 = peg$FAILED;
2739 }
2740 peg$resultsCache[key] = {
2741 nextPos: peg$currPos,
2742 result: s0
2743 };
2744 return s0;
2745 }
2746 function nth(n) {
2747 return {
2748 type: 'nth-child',
2749 index: {
2750 type: 'literal',
2751 value: n
2752 }
2753 };
2754 }
2755 function nthLast(n) {
2756 return {
2757 type: 'nth-last-child',
2758 index: {
2759 type: 'literal',
2760 value: n
2761 }
2762 };
2763 }
2764 function strUnescape(s) {
2765 return s.replace(/\\(.)/g, function (match, ch) {
2766 switch (ch) {
2767 case 'b':
2768 return '\b';
2769 case 'f':
2770 return '\f';
2771 case 'n':
2772 return '\n';
2773 case 'r':
2774 return '\r';
2775 case 't':
2776 return '\t';
2777 case 'v':
2778 return '\v';
2779 default:
2780 return ch;
2781 }
2782 });
2783 }
2784 peg$result = peg$startRuleFunction();
2785 if (peg$result !== peg$FAILED && peg$currPos === input.length) {
2786 return peg$result;
2787 } else {
2788 if (peg$result !== peg$FAILED && peg$currPos < input.length) {
2789 peg$fail(peg$endExpectation());
2790 }
2791 throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
2792 }
2793 }
2794 return {
2795 SyntaxError: peg$SyntaxError,
2796 parse: peg$parse
2797 };
2798 });
2799 });
2800
2801 /**
2802 * @typedef {"LEFT_SIDE"|"RIGHT_SIDE"} Side
2803 */
2804
2805 var LEFT_SIDE = 'LEFT_SIDE';
2806 var RIGHT_SIDE = 'RIGHT_SIDE';
2807
2808 /**
2809 * @external AST
2810 * @see https://esprima.readthedocs.io/en/latest/syntax-tree-format.html
2811 */
2812
2813 /**
2814 * One of the rules of `grammar.pegjs`
2815 * @typedef {PlainObject} SelectorAST
2816 * @see grammar.pegjs
2817 */
2818
2819 /**
2820 * The `sequence` production of `grammar.pegjs`
2821 * @typedef {PlainObject} SelectorSequenceAST
2822 */
2823
2824 /**
2825 * Get the value of a property which may be multiple levels down
2826 * in the object.
2827 * @param {?PlainObject} obj
2828 * @param {string[]} keys
2829 * @returns {undefined|boolean|string|number|external:AST}
2830 */
2831 function getPath(obj, keys) {
2832 for (var i = 0; i < keys.length; ++i) {
2833 if (obj == null) {
2834 return obj;
2835 }
2836 obj = obj[keys[i]];
2837 }
2838 return obj;
2839 }
2840
2841 /**
2842 * Determine whether `node` can be reached by following `path`,
2843 * starting at `ancestor`.
2844 * @param {?external:AST} node
2845 * @param {?external:AST} ancestor
2846 * @param {string[]} path
2847 * @param {Integer} fromPathIndex
2848 * @returns {boolean}
2849 */
2850 function inPath(node, ancestor, path, fromPathIndex) {
2851 var current = ancestor;
2852 for (var i = fromPathIndex; i < path.length; ++i) {
2853 if (current == null) {
2854 return false;
2855 }
2856 var field = current[path[i]];
2857 if (Array.isArray(field)) {
2858 for (var k = 0; k < field.length; ++k) {
2859 if (inPath(node, field[k], path, i + 1)) {
2860 return true;
2861 }
2862 }
2863 return false;
2864 }
2865 current = field;
2866 }
2867 return node === current;
2868 }
2869
2870 /**
2871 * A generated matcher function for a selector.
2872 * @callback SelectorMatcher
2873 * @param {?SelectorAST} selector
2874 * @param {external:AST[]} [ancestry=[]]
2875 * @param {ESQueryOptions} [options]
2876 * @returns {void}
2877 */
2878
2879 /**
2880 * A WeakMap for holding cached matcher functions for selectors.
2881 * @type {WeakMap<SelectorAST, SelectorMatcher>}
2882 */
2883 var MATCHER_CACHE = typeof WeakMap === 'function' ? new WeakMap() : null;
2884
2885 /**
2886 * Look up a matcher function for `selector` in the cache.
2887 * If it does not exist, generate it with `generateMatcher` and add it to the cache.
2888 * In engines without WeakMap, the caching is skipped and matchers are generated with every call.
2889 * @param {?SelectorAST} selector
2890 * @returns {SelectorMatcher}
2891 */
2892 function getMatcher(selector) {
2893 if (selector == null) {
2894 return function () {
2895 return true;
2896 };
2897 }
2898 if (MATCHER_CACHE != null) {
2899 var matcher = MATCHER_CACHE.get(selector);
2900 if (matcher != null) {
2901 return matcher;
2902 }
2903 matcher = generateMatcher(selector);
2904 MATCHER_CACHE.set(selector, matcher);
2905 return matcher;
2906 }
2907 return generateMatcher(selector);
2908 }
2909
2910 /**
2911 * Create a matcher function for `selector`,
2912 * @param {?SelectorAST} selector
2913 * @returns {SelectorMatcher}
2914 */
2915 function generateMatcher(selector) {
2916 switch (selector.type) {
2917 case 'wildcard':
2918 return function () {
2919 return true;
2920 };
2921 case 'identifier':
2922 {
2923 var value = selector.value.toLowerCase();
2924 return function (node, ancestry, options) {
2925 var nodeTypeKey = options && options.nodeTypeKey || 'type';
2926 return value === node[nodeTypeKey].toLowerCase();
2927 };
2928 }
2929 case 'exactNode':
2930 return function (node, ancestry) {
2931 return ancestry.length === 0;
2932 };
2933 case 'field':
2934 {
2935 var path = selector.name.split('.');
2936 return function (node, ancestry) {
2937 var ancestor = ancestry[path.length - 1];
2938 return inPath(node, ancestor, path, 0);
2939 };
2940 }
2941 case 'matches':
2942 {
2943 var matchers = selector.selectors.map(getMatcher);
2944 return function (node, ancestry, options) {
2945 for (var i = 0; i < matchers.length; ++i) {
2946 if (matchers[i](node, ancestry, options)) {
2947 return true;
2948 }
2949 }
2950 return false;
2951 };
2952 }
2953 case 'compound':
2954 {
2955 var _matchers = selector.selectors.map(getMatcher);
2956 return function (node, ancestry, options) {
2957 for (var i = 0; i < _matchers.length; ++i) {
2958 if (!_matchers[i](node, ancestry, options)) {
2959 return false;
2960 }
2961 }
2962 return true;
2963 };
2964 }
2965 case 'not':
2966 {
2967 var _matchers2 = selector.selectors.map(getMatcher);
2968 return function (node, ancestry, options) {
2969 for (var i = 0; i < _matchers2.length; ++i) {
2970 if (_matchers2[i](node, ancestry, options)) {
2971 return false;
2972 }
2973 }
2974 return true;
2975 };
2976 }
2977 case 'has':
2978 {
2979 var _matchers3 = selector.selectors.map(getMatcher);
2980 return function (node, ancestry, options) {
2981 var result = false;
2982 var a = [];
2983 estraverse.traverse(node, {
2984 enter: function enter(node, parent) {
2985 if (parent != null) {
2986 a.unshift(parent);
2987 }
2988 for (var i = 0; i < _matchers3.length; ++i) {
2989 if (_matchers3[i](node, a, options)) {
2990 result = true;
2991 this["break"]();
2992 return;
2993 }
2994 }
2995 },
2996 leave: function leave() {
2997 a.shift();
2998 },
2999 keys: options && options.visitorKeys,
3000 fallback: options && options.fallback || 'iteration'
3001 });
3002 return result;
3003 };
3004 }
3005 case 'child':
3006 {
3007 var left = getMatcher(selector.left);
3008 var right = getMatcher(selector.right);
3009 return function (node, ancestry, options) {
3010 if (ancestry.length > 0 && right(node, ancestry, options)) {
3011 return left(ancestry[0], ancestry.slice(1), options);
3012 }
3013 return false;
3014 };
3015 }
3016 case 'descendant':
3017 {
3018 var _left = getMatcher(selector.left);
3019 var _right = getMatcher(selector.right);
3020 return function (node, ancestry, options) {
3021 if (_right(node, ancestry, options)) {
3022 for (var i = 0, l = ancestry.length; i < l; ++i) {
3023 if (_left(ancestry[i], ancestry.slice(i + 1), options)) {
3024 return true;
3025 }
3026 }
3027 }
3028 return false;
3029 };
3030 }
3031 case 'attribute':
3032 {
3033 var _path = selector.name.split('.');
3034 switch (selector.operator) {
3035 case void 0:
3036 return function (node) {
3037 return getPath(node, _path) != null;
3038 };
3039 case '=':
3040 switch (selector.value.type) {
3041 case 'regexp':
3042 return function (node) {
3043 var p = getPath(node, _path);
3044 return typeof p === 'string' && selector.value.value.test(p);
3045 };
3046 case 'literal':
3047 {
3048 var literal = "".concat(selector.value.value);
3049 return function (node) {
3050 return literal === "".concat(getPath(node, _path));
3051 };
3052 }
3053 case 'type':
3054 return function (node) {
3055 return selector.value.value === _typeof(getPath(node, _path));
3056 };
3057 }
3058 throw new Error("Unknown selector value type: ".concat(selector.value.type));
3059 case '!=':
3060 switch (selector.value.type) {
3061 case 'regexp':
3062 return function (node) {
3063 return !selector.value.value.test(getPath(node, _path));
3064 };
3065 case 'literal':
3066 {
3067 var _literal = "".concat(selector.value.value);
3068 return function (node) {
3069 return _literal !== "".concat(getPath(node, _path));
3070 };
3071 }
3072 case 'type':
3073 return function (node) {
3074 return selector.value.value !== _typeof(getPath(node, _path));
3075 };
3076 }
3077 throw new Error("Unknown selector value type: ".concat(selector.value.type));
3078 case '<=':
3079 return function (node) {
3080 return getPath(node, _path) <= selector.value.value;
3081 };
3082 case '<':
3083 return function (node) {
3084 return getPath(node, _path) < selector.value.value;
3085 };
3086 case '>':
3087 return function (node) {
3088 return getPath(node, _path) > selector.value.value;
3089 };
3090 case '>=':
3091 return function (node) {
3092 return getPath(node, _path) >= selector.value.value;
3093 };
3094 }
3095 throw new Error("Unknown operator: ".concat(selector.operator));
3096 }
3097 case 'sibling':
3098 {
3099 var _left2 = getMatcher(selector.left);
3100 var _right2 = getMatcher(selector.right);
3101 return function (node, ancestry, options) {
3102 return _right2(node, ancestry, options) && sibling(node, _left2, ancestry, LEFT_SIDE, options) || selector.left.subject && _left2(node, ancestry, options) && sibling(node, _right2, ancestry, RIGHT_SIDE, options);
3103 };
3104 }
3105 case 'adjacent':
3106 {
3107 var _left3 = getMatcher(selector.left);
3108 var _right3 = getMatcher(selector.right);
3109 return function (node, ancestry, options) {
3110 return _right3(node, ancestry, options) && adjacent(node, _left3, ancestry, LEFT_SIDE, options) || selector.right.subject && _left3(node, ancestry, options) && adjacent(node, _right3, ancestry, RIGHT_SIDE, options);
3111 };
3112 }
3113 case 'nth-child':
3114 {
3115 var nth = selector.index.value;
3116 var _right4 = getMatcher(selector.right);
3117 return function (node, ancestry, options) {
3118 return _right4(node, ancestry, options) && nthChild(node, ancestry, nth, options);
3119 };
3120 }
3121 case 'nth-last-child':
3122 {
3123 var _nth = -selector.index.value;
3124 var _right5 = getMatcher(selector.right);
3125 return function (node, ancestry, options) {
3126 return _right5(node, ancestry, options) && nthChild(node, ancestry, _nth, options);
3127 };
3128 }
3129 case 'class':
3130 {
3131 var name = selector.name.toLowerCase();
3132 return function (node, ancestry, options) {
3133 if (options && options.matchClass) {
3134 return options.matchClass(selector.name, node, ancestry);
3135 }
3136 if (options && options.nodeTypeKey) return false;
3137 switch (name) {
3138 case 'statement':
3139 if (node.type.slice(-9) === 'Statement') return true;
3140 // fallthrough: interface Declaration <: Statement { }
3141 case 'declaration':
3142 return node.type.slice(-11) === 'Declaration';
3143 case 'pattern':
3144 if (node.type.slice(-7) === 'Pattern') return true;
3145 // fallthrough: interface Expression <: Node, Pattern { }
3146 case 'expression':
3147 return node.type.slice(-10) === 'Expression' || node.type.slice(-7) === 'Literal' || node.type === 'Identifier' && (ancestry.length === 0 || ancestry[0].type !== 'MetaProperty') || node.type === 'MetaProperty';
3148 case 'function':
3149 return node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
3150 }
3151 throw new Error("Unknown class name: ".concat(selector.name));
3152 };
3153 }
3154 }
3155 throw new Error("Unknown selector type: ".concat(selector.type));
3156 }
3157
3158 /**
3159 * @callback TraverseOptionFallback
3160 * @param {external:AST} node The given node.
3161 * @returns {string[]} An array of visitor keys for the given node.
3162 */
3163
3164 /**
3165 * @callback ClassMatcher
3166 * @param {string} className The name of the class to match.
3167 * @param {external:AST} node The node to match against.
3168 * @param {Array<external:AST>} ancestry The ancestry of the node.
3169 * @returns {boolean} True if the node matches the class, false if not.
3170 */
3171
3172 /**
3173 * @typedef {object} ESQueryOptions
3174 * @property {string} [nodeTypeKey="type"] By passing `nodeTypeKey`, we can allow other ASTs to use ESQuery.
3175 * @property { { [nodeType: string]: string[] } } [visitorKeys] By passing `visitorKeys` mapping, we can extend the properties of the nodes that traverse the node.
3176 * @property {TraverseOptionFallback} [fallback] By passing `fallback` option, we can control the properties of traversing nodes when encountering unknown nodes.
3177 * @property {ClassMatcher} [matchClass] By passing `matchClass` option, we can customize the interpretation of classes.
3178 */
3179
3180 /**
3181 * Given a `node` and its ancestors, determine if `node` is matched
3182 * by `selector`.
3183 * @param {?external:AST} node
3184 * @param {?SelectorAST} selector
3185 * @param {external:AST[]} [ancestry=[]]
3186 * @param {ESQueryOptions} [options]
3187 * @throws {Error} Unknowns (operator, class name, selector type, or
3188 * selector value type)
3189 * @returns {boolean}
3190 */
3191 function matches(node, selector, ancestry, options) {
3192 if (!selector) {
3193 return true;
3194 }
3195 if (!node) {
3196 return false;
3197 }
3198 if (!ancestry) {
3199 ancestry = [];
3200 }
3201 return getMatcher(selector)(node, ancestry, options);
3202 }
3203
3204 /**
3205 * Get visitor keys of a given node.
3206 * @param {external:AST} node The AST node to get keys.
3207 * @param {ESQueryOptions|undefined} options
3208 * @returns {string[]} Visitor keys of the node.
3209 */
3210 function getVisitorKeys(node, options) {
3211 var nodeTypeKey = options && options.nodeTypeKey || 'type';
3212 var nodeType = node[nodeTypeKey];
3213 if (options && options.visitorKeys && options.visitorKeys[nodeType]) {
3214 return options.visitorKeys[nodeType];
3215 }
3216 if (estraverse.VisitorKeys[nodeType]) {
3217 return estraverse.VisitorKeys[nodeType];
3218 }
3219 if (options && typeof options.fallback === 'function') {
3220 return options.fallback(node);
3221 }
3222 // 'iteration' fallback
3223 return Object.keys(node).filter(function (key) {
3224 return key !== nodeTypeKey;
3225 });
3226 }
3227
3228 /**
3229 * Check whether the given value is an ASTNode or not.
3230 * @param {any} node The value to check.
3231 * @param {ESQueryOptions|undefined} options The options to use.
3232 * @returns {boolean} `true` if the value is an ASTNode.
3233 */
3234 function isNode(node, options) {
3235 var nodeTypeKey = options && options.nodeTypeKey || 'type';
3236 return node !== null && _typeof(node) === 'object' && typeof node[nodeTypeKey] === 'string';
3237 }
3238
3239 /**
3240 * Determines if the given node has a sibling that matches the
3241 * given selector matcher.
3242 * @param {external:AST} node
3243 * @param {SelectorMatcher} matcher
3244 * @param {external:AST[]} ancestry
3245 * @param {Side} side
3246 * @param {ESQueryOptions|undefined} options
3247 * @returns {boolean}
3248 */
3249 function sibling(node, matcher, ancestry, side, options) {
3250 var _ancestry = _slicedToArray(ancestry, 1),
3251 parent = _ancestry[0];
3252 if (!parent) {
3253 return false;
3254 }
3255 var keys = getVisitorKeys(parent, options);
3256 for (var i = 0; i < keys.length; ++i) {
3257 var listProp = parent[keys[i]];
3258 if (Array.isArray(listProp)) {
3259 var startIndex = listProp.indexOf(node);
3260 if (startIndex < 0) {
3261 continue;
3262 }
3263 var lowerBound = void 0,
3264 upperBound = void 0;
3265 if (side === LEFT_SIDE) {
3266 lowerBound = 0;
3267 upperBound = startIndex;
3268 } else {
3269 lowerBound = startIndex + 1;
3270 upperBound = listProp.length;
3271 }
3272 for (var k = lowerBound; k < upperBound; ++k) {
3273 if (isNode(listProp[k], options) && matcher(listProp[k], ancestry, options)) {
3274 return true;
3275 }
3276 }
3277 }
3278 }
3279 return false;
3280 }
3281
3282 /**
3283 * Determines if the given node has an adjacent sibling that matches
3284 * the given selector matcher.
3285 * @param {external:AST} node
3286 * @param {SelectorMatcher} matcher
3287 * @param {external:AST[]} ancestry
3288 * @param {Side} side
3289 * @param {ESQueryOptions|undefined} options
3290 * @returns {boolean}
3291 */
3292 function adjacent(node, matcher, ancestry, side, options) {
3293 var _ancestry2 = _slicedToArray(ancestry, 1),
3294 parent = _ancestry2[0];
3295 if (!parent) {
3296 return false;
3297 }
3298 var keys = getVisitorKeys(parent, options);
3299 for (var i = 0; i < keys.length; ++i) {
3300 var listProp = parent[keys[i]];
3301 if (Array.isArray(listProp)) {
3302 var idx = listProp.indexOf(node);
3303 if (idx < 0) {
3304 continue;
3305 }
3306 if (side === LEFT_SIDE && idx > 0 && isNode(listProp[idx - 1], options) && matcher(listProp[idx - 1], ancestry, options)) {
3307 return true;
3308 }
3309 if (side === RIGHT_SIDE && idx < listProp.length - 1 && isNode(listProp[idx + 1], options) && matcher(listProp[idx + 1], ancestry, options)) {
3310 return true;
3311 }
3312 }
3313 }
3314 return false;
3315 }
3316
3317 /**
3318 * Determines if the given node is the `nth` child.
3319 * If `nth` is negative then the position is counted
3320 * from the end of the list of children.
3321 * @param {external:AST} node
3322 * @param {external:AST[]} ancestry
3323 * @param {Integer} nth
3324 * @param {ESQueryOptions|undefined} options
3325 * @returns {boolean}
3326 */
3327 function nthChild(node, ancestry, nth, options) {
3328 if (nth === 0) {
3329 return false;
3330 }
3331 var _ancestry3 = _slicedToArray(ancestry, 1),
3332 parent = _ancestry3[0];
3333 if (!parent) {
3334 return false;
3335 }
3336 var keys = getVisitorKeys(parent, options);
3337 for (var i = 0; i < keys.length; ++i) {
3338 var listProp = parent[keys[i]];
3339 if (Array.isArray(listProp)) {
3340 var idx = nth < 0 ? listProp.length + nth : nth - 1;
3341 if (idx >= 0 && idx < listProp.length && listProp[idx] === node) {
3342 return true;
3343 }
3344 }
3345 }
3346 return false;
3347 }
3348
3349 /**
3350 * For each selector node marked as a subject, find the portion of the
3351 * selector that the subject must match.
3352 * @param {SelectorAST} selector
3353 * @param {SelectorAST} [ancestor] Defaults to `selector`
3354 * @returns {SelectorAST[]}
3355 */
3356 function subjects(selector, ancestor) {
3357 if (selector == null || _typeof(selector) != 'object') {
3358 return [];
3359 }
3360 if (ancestor == null) {
3361 ancestor = selector;
3362 }
3363 var results = selector.subject ? [ancestor] : [];
3364 var keys = Object.keys(selector);
3365 for (var i = 0; i < keys.length; ++i) {
3366 var p = keys[i];
3367 var sel = selector[p];
3368 results.push.apply(results, _toConsumableArray(subjects(sel, p === 'left' ? sel : ancestor)));
3369 }
3370 return results;
3371 }
3372
3373 /**
3374 * @callback TraverseVisitor
3375 * @param {?external:AST} node
3376 * @param {?external:AST} parent
3377 * @param {external:AST[]} ancestry
3378 */
3379
3380 /**
3381 * From a JS AST and a selector AST, collect all JS AST nodes that
3382 * match the selector.
3383 * @param {external:AST} ast
3384 * @param {?SelectorAST} selector
3385 * @param {TraverseVisitor} visitor
3386 * @param {ESQueryOptions} [options]
3387 * @returns {external:AST[]}
3388 */
3389 function traverse(ast, selector, visitor, options) {
3390 if (!selector) {
3391 return;
3392 }
3393 var ancestry = [];
3394 var matcher = getMatcher(selector);
3395 var altSubjects = subjects(selector).map(getMatcher);
3396 estraverse.traverse(ast, {
3397 enter: function enter(node, parent) {
3398 if (parent != null) {
3399 ancestry.unshift(parent);
3400 }
3401 if (matcher(node, ancestry, options)) {
3402 if (altSubjects.length) {
3403 for (var i = 0, l = altSubjects.length; i < l; ++i) {
3404 if (altSubjects[i](node, ancestry, options)) {
3405 visitor(node, parent, ancestry);
3406 }
3407 for (var k = 0, m = ancestry.length; k < m; ++k) {
3408 var succeedingAncestry = ancestry.slice(k + 1);
3409 if (altSubjects[i](ancestry[k], succeedingAncestry, options)) {
3410 visitor(ancestry[k], parent, succeedingAncestry);
3411 }
3412 }
3413 }
3414 } else {
3415 visitor(node, parent, ancestry);
3416 }
3417 }
3418 },
3419 leave: function leave() {
3420 ancestry.shift();
3421 },
3422 keys: options && options.visitorKeys,
3423 fallback: options && options.fallback || 'iteration'
3424 });
3425 }
3426
3427 /**
3428 * From a JS AST and a selector AST, collect all JS AST nodes that
3429 * match the selector.
3430 * @param {external:AST} ast
3431 * @param {?SelectorAST} selector
3432 * @param {ESQueryOptions} [options]
3433 * @returns {external:AST[]}
3434 */
3435 function match(ast, selector, options) {
3436 var results = [];
3437 traverse(ast, selector, function (node) {
3438 results.push(node);
3439 }, options);
3440 return results;
3441 }
3442
3443 /**
3444 * Parse a selector string and return its AST.
3445 * @param {string} selector
3446 * @returns {SelectorAST}
3447 */
3448 function parse(selector) {
3449 return parser.parse(selector);
3450 }
3451
3452 /**
3453 * Query the code AST using the selector string.
3454 * @param {external:AST} ast
3455 * @param {string} selector
3456 * @param {ESQueryOptions} [options]
3457 * @returns {external:AST[]}
3458 */
3459 function query(ast, selector, options) {
3460 return match(ast, parse(selector), options);
3461 }
3462 query.parse = parse;
3463 query.match = match;
3464 query.traverse = traverse;
3465 query.matches = matches;
3466 query.query = query;
3467
3468 return query;
3469
3470})));
Note: See TracBrowser for help on using the repository browser.