source: imaps-frontend/node_modules/esquery/parser.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: 71.1 KB
Line 
1/*
2 * Generated by PEG.js 0.10.0.
3 *
4 * http://pegjs.org/
5 */
6(function(root, factory) {
7 if (typeof define === "function" && define.amd) {
8 define([], factory);
9 } else if (typeof module === "object" && module.exports) {
10 module.exports = factory();
11 }
12})(this, function() {
13 "use strict";
14
15 function peg$subclass(child, parent) {
16 function ctor() { this.constructor = child; }
17 ctor.prototype = parent.prototype;
18 child.prototype = new ctor();
19 }
20
21 function peg$SyntaxError(message, expected, found, location) {
22 this.message = message;
23 this.expected = expected;
24 this.found = found;
25 this.location = location;
26 this.name = "SyntaxError";
27
28 if (typeof Error.captureStackTrace === "function") {
29 Error.captureStackTrace(this, peg$SyntaxError);
30 }
31 }
32
33 peg$subclass(peg$SyntaxError, Error);
34
35 peg$SyntaxError.buildMessage = function(expected, found) {
36 var DESCRIBE_EXPECTATION_FNS = {
37 literal: function(expectation) {
38 return "\"" + literalEscape(expectation.text) + "\"";
39 },
40
41 "class": function(expectation) {
42 var escapedParts = "",
43 i;
44
45 for (i = 0; i < expectation.parts.length; i++) {
46 escapedParts += expectation.parts[i] instanceof Array
47 ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1])
48 : classEscape(expectation.parts[i]);
49 }
50
51 return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
52 },
53
54 any: function(expectation) {
55 return "any character";
56 },
57
58 end: function(expectation) {
59 return "end of input";
60 },
61
62 other: function(expectation) {
63 return expectation.description;
64 }
65 };
66
67 function hex(ch) {
68 return ch.charCodeAt(0).toString(16).toUpperCase();
69 }
70
71 function literalEscape(s) {
72 return s
73 .replace(/\\/g, '\\\\')
74 .replace(/"/g, '\\"')
75 .replace(/\0/g, '\\0')
76 .replace(/\t/g, '\\t')
77 .replace(/\n/g, '\\n')
78 .replace(/\r/g, '\\r')
79 .replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
80 .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); });
81 }
82
83 function classEscape(s) {
84 return s
85 .replace(/\\/g, '\\\\')
86 .replace(/\]/g, '\\]')
87 .replace(/\^/g, '\\^')
88 .replace(/-/g, '\\-')
89 .replace(/\0/g, '\\0')
90 .replace(/\t/g, '\\t')
91 .replace(/\n/g, '\\n')
92 .replace(/\r/g, '\\r')
93 .replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
94 .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); });
95 }
96
97 function describeExpectation(expectation) {
98 return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
99 }
100
101 function describeExpected(expected) {
102 var descriptions = new Array(expected.length),
103 i, j;
104
105 for (i = 0; i < expected.length; i++) {
106 descriptions[i] = describeExpectation(expected[i]);
107 }
108
109 descriptions.sort();
110
111 if (descriptions.length > 0) {
112 for (i = 1, j = 1; i < descriptions.length; i++) {
113 if (descriptions[i - 1] !== descriptions[i]) {
114 descriptions[j] = descriptions[i];
115 j++;
116 }
117 }
118 descriptions.length = j;
119 }
120
121 switch (descriptions.length) {
122 case 1:
123 return descriptions[0];
124
125 case 2:
126 return descriptions[0] + " or " + descriptions[1];
127
128 default:
129 return descriptions.slice(0, -1).join(", ")
130 + ", or "
131 + descriptions[descriptions.length - 1];
132 }
133 }
134
135 function describeFound(found) {
136 return found ? "\"" + literalEscape(found) + "\"" : "end of input";
137 }
138
139 return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
140 };
141
142 function peg$parse(input, options) {
143 options = options !== void 0 ? options : {};
144
145 var peg$FAILED = {},
146
147 peg$startRuleFunctions = { start: peg$parsestart },
148 peg$startRuleFunction = peg$parsestart,
149
150 peg$c0 = function(ss) {
151 return ss.length === 1 ? ss[0] : { type: 'matches', selectors: ss };
152 },
153 peg$c1 = function() { return void 0; },
154 peg$c2 = " ",
155 peg$c3 = peg$literalExpectation(" ", false),
156 peg$c4 = /^[^ [\],():#!=><~+.]/,
157 peg$c5 = peg$classExpectation([" ", "[", "]", ",", "(", ")", ":", "#", "!", "=", ">", "<", "~", "+", "."], true, false),
158 peg$c6 = function(i) { return i.join(''); },
159 peg$c7 = ">",
160 peg$c8 = peg$literalExpectation(">", false),
161 peg$c9 = function() { return 'child'; },
162 peg$c10 = "~",
163 peg$c11 = peg$literalExpectation("~", false),
164 peg$c12 = function() { return 'sibling'; },
165 peg$c13 = "+",
166 peg$c14 = peg$literalExpectation("+", false),
167 peg$c15 = function() { return 'adjacent'; },
168 peg$c16 = function() { return 'descendant'; },
169 peg$c17 = ",",
170 peg$c18 = peg$literalExpectation(",", false),
171 peg$c19 = function(s, ss) {
172 return [s].concat(ss.map(function (s) { return s[3]; }));
173 },
174 peg$c20 = function(op, s) {
175 if (!op) return s;
176 return { type: op, left: { type: 'exactNode' }, right: s };
177 },
178 peg$c21 = function(a, ops) {
179 return ops.reduce(function (memo, rhs) {
180 return { type: rhs[0], left: memo, right: rhs[1] };
181 }, a);
182 },
183 peg$c22 = "!",
184 peg$c23 = peg$literalExpectation("!", false),
185 peg$c24 = function(subject, as) {
186 const b = as.length === 1 ? as[0] : { type: 'compound', selectors: as };
187 if(subject) b.subject = true;
188 return b;
189 },
190 peg$c25 = "*",
191 peg$c26 = peg$literalExpectation("*", false),
192 peg$c27 = function(a) { return { type: 'wildcard', value: a }; },
193 peg$c28 = "#",
194 peg$c29 = peg$literalExpectation("#", false),
195 peg$c30 = function(i) { return { type: 'identifier', value: i }; },
196 peg$c31 = "[",
197 peg$c32 = peg$literalExpectation("[", false),
198 peg$c33 = "]",
199 peg$c34 = peg$literalExpectation("]", false),
200 peg$c35 = function(v) { return v; },
201 peg$c36 = /^[><!]/,
202 peg$c37 = peg$classExpectation([">", "<", "!"], false, false),
203 peg$c38 = "=",
204 peg$c39 = peg$literalExpectation("=", false),
205 peg$c40 = function(a) { return (a || '') + '='; },
206 peg$c41 = /^[><]/,
207 peg$c42 = peg$classExpectation([">", "<"], false, false),
208 peg$c43 = ".",
209 peg$c44 = peg$literalExpectation(".", false),
210 peg$c45 = function(a, as) {
211 return [].concat.apply([a], as).join('');
212 },
213 peg$c46 = function(name, op, value) {
214 return { type: 'attribute', name: name, operator: op, value: value };
215 },
216 peg$c47 = function(name) { return { type: 'attribute', name: name }; },
217 peg$c48 = "\"",
218 peg$c49 = peg$literalExpectation("\"", false),
219 peg$c50 = /^[^\\"]/,
220 peg$c51 = peg$classExpectation(["\\", "\""], true, false),
221 peg$c52 = "\\",
222 peg$c53 = peg$literalExpectation("\\", false),
223 peg$c54 = peg$anyExpectation(),
224 peg$c55 = function(a, b) { return a + b; },
225 peg$c56 = function(d) {
226 return { type: 'literal', value: strUnescape(d.join('')) };
227 },
228 peg$c57 = "'",
229 peg$c58 = peg$literalExpectation("'", false),
230 peg$c59 = /^[^\\']/,
231 peg$c60 = peg$classExpectation(["\\", "'"], true, false),
232 peg$c61 = /^[0-9]/,
233 peg$c62 = peg$classExpectation([["0", "9"]], false, false),
234 peg$c63 = function(a, b) {
235 // Can use `a.flat().join('')` once supported
236 const leadingDecimals = a ? [].concat.apply([], a).join('') : '';
237 return { type: 'literal', value: parseFloat(leadingDecimals + b.join('')) };
238 },
239 peg$c64 = function(i) { return { type: 'literal', value: i }; },
240 peg$c65 = "type(",
241 peg$c66 = peg$literalExpectation("type(", false),
242 peg$c67 = /^[^ )]/,
243 peg$c68 = peg$classExpectation([" ", ")"], true, false),
244 peg$c69 = ")",
245 peg$c70 = peg$literalExpectation(")", false),
246 peg$c71 = function(t) { return { type: 'type', value: t.join('') }; },
247 peg$c72 = /^[imsu]/,
248 peg$c73 = peg$classExpectation(["i", "m", "s", "u"], false, false),
249 peg$c74 = "/",
250 peg$c75 = peg$literalExpectation("/", false),
251 peg$c76 = /^[^\/]/,
252 peg$c77 = peg$classExpectation(["/"], true, false),
253 peg$c78 = function(d, flgs) { return {
254 type: 'regexp', value: new RegExp(d.join(''), flgs ? flgs.join('') : '') };
255 },
256 peg$c79 = function(i, is) {
257 return { type: 'field', name: is.reduce(function(memo, p){ return memo + p[0] + p[1]; }, i)};
258 },
259 peg$c80 = ":not(",
260 peg$c81 = peg$literalExpectation(":not(", false),
261 peg$c82 = function(ss) { return { type: 'not', selectors: ss }; },
262 peg$c83 = ":matches(",
263 peg$c84 = peg$literalExpectation(":matches(", false),
264 peg$c85 = function(ss) { return { type: 'matches', selectors: ss }; },
265 peg$c86 = ":has(",
266 peg$c87 = peg$literalExpectation(":has(", false),
267 peg$c88 = function(ss) { return { type: 'has', selectors: ss }; },
268 peg$c89 = ":first-child",
269 peg$c90 = peg$literalExpectation(":first-child", false),
270 peg$c91 = function() { return nth(1); },
271 peg$c92 = ":last-child",
272 peg$c93 = peg$literalExpectation(":last-child", false),
273 peg$c94 = function() { return nthLast(1); },
274 peg$c95 = ":nth-child(",
275 peg$c96 = peg$literalExpectation(":nth-child(", false),
276 peg$c97 = function(n) { return nth(parseInt(n.join(''), 10)); },
277 peg$c98 = ":nth-last-child(",
278 peg$c99 = peg$literalExpectation(":nth-last-child(", false),
279 peg$c100 = function(n) { return nthLast(parseInt(n.join(''), 10)); },
280 peg$c101 = ":",
281 peg$c102 = peg$literalExpectation(":", false),
282 peg$c103 = function(c) {
283 return { type: 'class', name: c };
284 },
285
286 peg$currPos = 0,
287 peg$savedPos = 0,
288 peg$posDetailsCache = [{ line: 1, column: 1 }],
289 peg$maxFailPos = 0,
290 peg$maxFailExpected = [],
291 peg$silentFails = 0,
292
293 peg$resultsCache = {},
294
295 peg$result;
296
297 if ("startRule" in options) {
298 if (!(options.startRule in peg$startRuleFunctions)) {
299 throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
300 }
301
302 peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
303 }
304
305 function text() {
306 return input.substring(peg$savedPos, peg$currPos);
307 }
308
309 function location() {
310 return peg$computeLocation(peg$savedPos, peg$currPos);
311 }
312
313 function expected(description, location) {
314 location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
315
316 throw peg$buildStructuredError(
317 [peg$otherExpectation(description)],
318 input.substring(peg$savedPos, peg$currPos),
319 location
320 );
321 }
322
323 function error(message, location) {
324 location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
325
326 throw peg$buildSimpleError(message, location);
327 }
328
329 function peg$literalExpectation(text, ignoreCase) {
330 return { type: "literal", text: text, ignoreCase: ignoreCase };
331 }
332
333 function peg$classExpectation(parts, inverted, ignoreCase) {
334 return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
335 }
336
337 function peg$anyExpectation() {
338 return { type: "any" };
339 }
340
341 function peg$endExpectation() {
342 return { type: "end" };
343 }
344
345 function peg$otherExpectation(description) {
346 return { type: "other", description: description };
347 }
348
349 function peg$computePosDetails(pos) {
350 var details = peg$posDetailsCache[pos], p;
351
352 if (details) {
353 return details;
354 } else {
355 p = pos - 1;
356 while (!peg$posDetailsCache[p]) {
357 p--;
358 }
359
360 details = peg$posDetailsCache[p];
361 details = {
362 line: details.line,
363 column: details.column
364 };
365
366 while (p < pos) {
367 if (input.charCodeAt(p) === 10) {
368 details.line++;
369 details.column = 1;
370 } else {
371 details.column++;
372 }
373
374 p++;
375 }
376
377 peg$posDetailsCache[pos] = details;
378 return details;
379 }
380 }
381
382 function peg$computeLocation(startPos, endPos) {
383 var startPosDetails = peg$computePosDetails(startPos),
384 endPosDetails = peg$computePosDetails(endPos);
385
386 return {
387 start: {
388 offset: startPos,
389 line: startPosDetails.line,
390 column: startPosDetails.column
391 },
392 end: {
393 offset: endPos,
394 line: endPosDetails.line,
395 column: endPosDetails.column
396 }
397 };
398 }
399
400 function peg$fail(expected) {
401 if (peg$currPos < peg$maxFailPos) { return; }
402
403 if (peg$currPos > peg$maxFailPos) {
404 peg$maxFailPos = peg$currPos;
405 peg$maxFailExpected = [];
406 }
407
408 peg$maxFailExpected.push(expected);
409 }
410
411 function peg$buildSimpleError(message, location) {
412 return new peg$SyntaxError(message, null, null, location);
413 }
414
415 function peg$buildStructuredError(expected, found, location) {
416 return new peg$SyntaxError(
417 peg$SyntaxError.buildMessage(expected, found),
418 expected,
419 found,
420 location
421 );
422 }
423
424 function peg$parsestart() {
425 var s0, s1, s2, s3;
426
427 var key = peg$currPos * 32 + 0,
428 cached = peg$resultsCache[key];
429
430 if (cached) {
431 peg$currPos = cached.nextPos;
432
433 return cached.result;
434 }
435
436 s0 = peg$currPos;
437 s1 = peg$parse_();
438 if (s1 !== peg$FAILED) {
439 s2 = peg$parseselectors();
440 if (s2 !== peg$FAILED) {
441 s3 = peg$parse_();
442 if (s3 !== peg$FAILED) {
443 peg$savedPos = s0;
444 s1 = peg$c0(s2);
445 s0 = s1;
446 } else {
447 peg$currPos = s0;
448 s0 = peg$FAILED;
449 }
450 } else {
451 peg$currPos = s0;
452 s0 = peg$FAILED;
453 }
454 } else {
455 peg$currPos = s0;
456 s0 = peg$FAILED;
457 }
458 if (s0 === peg$FAILED) {
459 s0 = peg$currPos;
460 s1 = peg$parse_();
461 if (s1 !== peg$FAILED) {
462 peg$savedPos = s0;
463 s1 = peg$c1();
464 }
465 s0 = s1;
466 }
467
468 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
469
470 return s0;
471 }
472
473 function peg$parse_() {
474 var s0, s1;
475
476 var key = peg$currPos * 32 + 1,
477 cached = peg$resultsCache[key];
478
479 if (cached) {
480 peg$currPos = cached.nextPos;
481
482 return cached.result;
483 }
484
485 s0 = [];
486 if (input.charCodeAt(peg$currPos) === 32) {
487 s1 = peg$c2;
488 peg$currPos++;
489 } else {
490 s1 = peg$FAILED;
491 if (peg$silentFails === 0) { peg$fail(peg$c3); }
492 }
493 while (s1 !== peg$FAILED) {
494 s0.push(s1);
495 if (input.charCodeAt(peg$currPos) === 32) {
496 s1 = peg$c2;
497 peg$currPos++;
498 } else {
499 s1 = peg$FAILED;
500 if (peg$silentFails === 0) { peg$fail(peg$c3); }
501 }
502 }
503
504 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
505
506 return s0;
507 }
508
509 function peg$parseidentifierName() {
510 var s0, s1, s2;
511
512 var key = peg$currPos * 32 + 2,
513 cached = peg$resultsCache[key];
514
515 if (cached) {
516 peg$currPos = cached.nextPos;
517
518 return cached.result;
519 }
520
521 s0 = peg$currPos;
522 s1 = [];
523 if (peg$c4.test(input.charAt(peg$currPos))) {
524 s2 = input.charAt(peg$currPos);
525 peg$currPos++;
526 } else {
527 s2 = peg$FAILED;
528 if (peg$silentFails === 0) { peg$fail(peg$c5); }
529 }
530 if (s2 !== peg$FAILED) {
531 while (s2 !== peg$FAILED) {
532 s1.push(s2);
533 if (peg$c4.test(input.charAt(peg$currPos))) {
534 s2 = input.charAt(peg$currPos);
535 peg$currPos++;
536 } else {
537 s2 = peg$FAILED;
538 if (peg$silentFails === 0) { peg$fail(peg$c5); }
539 }
540 }
541 } else {
542 s1 = peg$FAILED;
543 }
544 if (s1 !== peg$FAILED) {
545 peg$savedPos = s0;
546 s1 = peg$c6(s1);
547 }
548 s0 = s1;
549
550 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
551
552 return s0;
553 }
554
555 function peg$parsebinaryOp() {
556 var s0, s1, s2, s3;
557
558 var key = peg$currPos * 32 + 3,
559 cached = peg$resultsCache[key];
560
561 if (cached) {
562 peg$currPos = cached.nextPos;
563
564 return cached.result;
565 }
566
567 s0 = peg$currPos;
568 s1 = peg$parse_();
569 if (s1 !== peg$FAILED) {
570 if (input.charCodeAt(peg$currPos) === 62) {
571 s2 = peg$c7;
572 peg$currPos++;
573 } else {
574 s2 = peg$FAILED;
575 if (peg$silentFails === 0) { peg$fail(peg$c8); }
576 }
577 if (s2 !== peg$FAILED) {
578 s3 = peg$parse_();
579 if (s3 !== peg$FAILED) {
580 peg$savedPos = s0;
581 s1 = peg$c9();
582 s0 = s1;
583 } else {
584 peg$currPos = s0;
585 s0 = peg$FAILED;
586 }
587 } else {
588 peg$currPos = s0;
589 s0 = peg$FAILED;
590 }
591 } else {
592 peg$currPos = s0;
593 s0 = peg$FAILED;
594 }
595 if (s0 === peg$FAILED) {
596 s0 = peg$currPos;
597 s1 = peg$parse_();
598 if (s1 !== peg$FAILED) {
599 if (input.charCodeAt(peg$currPos) === 126) {
600 s2 = peg$c10;
601 peg$currPos++;
602 } else {
603 s2 = peg$FAILED;
604 if (peg$silentFails === 0) { peg$fail(peg$c11); }
605 }
606 if (s2 !== peg$FAILED) {
607 s3 = peg$parse_();
608 if (s3 !== peg$FAILED) {
609 peg$savedPos = s0;
610 s1 = peg$c12();
611 s0 = s1;
612 } else {
613 peg$currPos = s0;
614 s0 = peg$FAILED;
615 }
616 } else {
617 peg$currPos = s0;
618 s0 = peg$FAILED;
619 }
620 } else {
621 peg$currPos = s0;
622 s0 = peg$FAILED;
623 }
624 if (s0 === peg$FAILED) {
625 s0 = peg$currPos;
626 s1 = peg$parse_();
627 if (s1 !== peg$FAILED) {
628 if (input.charCodeAt(peg$currPos) === 43) {
629 s2 = peg$c13;
630 peg$currPos++;
631 } else {
632 s2 = peg$FAILED;
633 if (peg$silentFails === 0) { peg$fail(peg$c14); }
634 }
635 if (s2 !== peg$FAILED) {
636 s3 = peg$parse_();
637 if (s3 !== peg$FAILED) {
638 peg$savedPos = s0;
639 s1 = peg$c15();
640 s0 = s1;
641 } else {
642 peg$currPos = s0;
643 s0 = peg$FAILED;
644 }
645 } else {
646 peg$currPos = s0;
647 s0 = peg$FAILED;
648 }
649 } else {
650 peg$currPos = s0;
651 s0 = peg$FAILED;
652 }
653 if (s0 === peg$FAILED) {
654 s0 = peg$currPos;
655 if (input.charCodeAt(peg$currPos) === 32) {
656 s1 = peg$c2;
657 peg$currPos++;
658 } else {
659 s1 = peg$FAILED;
660 if (peg$silentFails === 0) { peg$fail(peg$c3); }
661 }
662 if (s1 !== peg$FAILED) {
663 s2 = peg$parse_();
664 if (s2 !== peg$FAILED) {
665 peg$savedPos = s0;
666 s1 = peg$c16();
667 s0 = s1;
668 } else {
669 peg$currPos = s0;
670 s0 = peg$FAILED;
671 }
672 } else {
673 peg$currPos = s0;
674 s0 = peg$FAILED;
675 }
676 }
677 }
678 }
679
680 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
681
682 return s0;
683 }
684
685 function peg$parsehasSelectors() {
686 var s0, s1, s2, s3, s4, s5, s6, s7;
687
688 var key = peg$currPos * 32 + 4,
689 cached = peg$resultsCache[key];
690
691 if (cached) {
692 peg$currPos = cached.nextPos;
693
694 return cached.result;
695 }
696
697 s0 = peg$currPos;
698 s1 = peg$parsehasSelector();
699 if (s1 !== peg$FAILED) {
700 s2 = [];
701 s3 = peg$currPos;
702 s4 = peg$parse_();
703 if (s4 !== peg$FAILED) {
704 if (input.charCodeAt(peg$currPos) === 44) {
705 s5 = peg$c17;
706 peg$currPos++;
707 } else {
708 s5 = peg$FAILED;
709 if (peg$silentFails === 0) { peg$fail(peg$c18); }
710 }
711 if (s5 !== peg$FAILED) {
712 s6 = peg$parse_();
713 if (s6 !== peg$FAILED) {
714 s7 = peg$parsehasSelector();
715 if (s7 !== peg$FAILED) {
716 s4 = [s4, s5, s6, s7];
717 s3 = s4;
718 } else {
719 peg$currPos = s3;
720 s3 = peg$FAILED;
721 }
722 } else {
723 peg$currPos = s3;
724 s3 = peg$FAILED;
725 }
726 } else {
727 peg$currPos = s3;
728 s3 = peg$FAILED;
729 }
730 } else {
731 peg$currPos = s3;
732 s3 = peg$FAILED;
733 }
734 while (s3 !== peg$FAILED) {
735 s2.push(s3);
736 s3 = peg$currPos;
737 s4 = peg$parse_();
738 if (s4 !== peg$FAILED) {
739 if (input.charCodeAt(peg$currPos) === 44) {
740 s5 = peg$c17;
741 peg$currPos++;
742 } else {
743 s5 = peg$FAILED;
744 if (peg$silentFails === 0) { peg$fail(peg$c18); }
745 }
746 if (s5 !== peg$FAILED) {
747 s6 = peg$parse_();
748 if (s6 !== peg$FAILED) {
749 s7 = peg$parsehasSelector();
750 if (s7 !== peg$FAILED) {
751 s4 = [s4, s5, s6, s7];
752 s3 = s4;
753 } else {
754 peg$currPos = s3;
755 s3 = peg$FAILED;
756 }
757 } else {
758 peg$currPos = s3;
759 s3 = peg$FAILED;
760 }
761 } else {
762 peg$currPos = s3;
763 s3 = peg$FAILED;
764 }
765 } else {
766 peg$currPos = s3;
767 s3 = peg$FAILED;
768 }
769 }
770 if (s2 !== peg$FAILED) {
771 peg$savedPos = s0;
772 s1 = peg$c19(s1, s2);
773 s0 = s1;
774 } else {
775 peg$currPos = s0;
776 s0 = peg$FAILED;
777 }
778 } else {
779 peg$currPos = s0;
780 s0 = peg$FAILED;
781 }
782
783 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
784
785 return s0;
786 }
787
788 function peg$parseselectors() {
789 var s0, s1, s2, s3, s4, s5, s6, s7;
790
791 var key = peg$currPos * 32 + 5,
792 cached = peg$resultsCache[key];
793
794 if (cached) {
795 peg$currPos = cached.nextPos;
796
797 return cached.result;
798 }
799
800 s0 = peg$currPos;
801 s1 = peg$parseselector();
802 if (s1 !== peg$FAILED) {
803 s2 = [];
804 s3 = peg$currPos;
805 s4 = peg$parse_();
806 if (s4 !== peg$FAILED) {
807 if (input.charCodeAt(peg$currPos) === 44) {
808 s5 = peg$c17;
809 peg$currPos++;
810 } else {
811 s5 = peg$FAILED;
812 if (peg$silentFails === 0) { peg$fail(peg$c18); }
813 }
814 if (s5 !== peg$FAILED) {
815 s6 = peg$parse_();
816 if (s6 !== peg$FAILED) {
817 s7 = peg$parseselector();
818 if (s7 !== peg$FAILED) {
819 s4 = [s4, s5, s6, s7];
820 s3 = s4;
821 } else {
822 peg$currPos = s3;
823 s3 = peg$FAILED;
824 }
825 } else {
826 peg$currPos = s3;
827 s3 = peg$FAILED;
828 }
829 } else {
830 peg$currPos = s3;
831 s3 = peg$FAILED;
832 }
833 } else {
834 peg$currPos = s3;
835 s3 = peg$FAILED;
836 }
837 while (s3 !== peg$FAILED) {
838 s2.push(s3);
839 s3 = peg$currPos;
840 s4 = peg$parse_();
841 if (s4 !== peg$FAILED) {
842 if (input.charCodeAt(peg$currPos) === 44) {
843 s5 = peg$c17;
844 peg$currPos++;
845 } else {
846 s5 = peg$FAILED;
847 if (peg$silentFails === 0) { peg$fail(peg$c18); }
848 }
849 if (s5 !== peg$FAILED) {
850 s6 = peg$parse_();
851 if (s6 !== peg$FAILED) {
852 s7 = peg$parseselector();
853 if (s7 !== peg$FAILED) {
854 s4 = [s4, s5, s6, s7];
855 s3 = s4;
856 } else {
857 peg$currPos = s3;
858 s3 = peg$FAILED;
859 }
860 } else {
861 peg$currPos = s3;
862 s3 = peg$FAILED;
863 }
864 } else {
865 peg$currPos = s3;
866 s3 = peg$FAILED;
867 }
868 } else {
869 peg$currPos = s3;
870 s3 = peg$FAILED;
871 }
872 }
873 if (s2 !== peg$FAILED) {
874 peg$savedPos = s0;
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
886 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
887
888 return s0;
889 }
890
891 function peg$parsehasSelector() {
892 var s0, s1, s2;
893
894 var key = peg$currPos * 32 + 6,
895 cached = peg$resultsCache[key];
896
897 if (cached) {
898 peg$currPos = cached.nextPos;
899
900 return cached.result;
901 }
902
903 s0 = peg$currPos;
904 s1 = peg$parsebinaryOp();
905 if (s1 === peg$FAILED) {
906 s1 = null;
907 }
908 if (s1 !== peg$FAILED) {
909 s2 = peg$parseselector();
910 if (s2 !== peg$FAILED) {
911 peg$savedPos = s0;
912 s1 = peg$c20(s1, s2);
913 s0 = s1;
914 } else {
915 peg$currPos = s0;
916 s0 = peg$FAILED;
917 }
918 } else {
919 peg$currPos = s0;
920 s0 = peg$FAILED;
921 }
922
923 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
924
925 return s0;
926 }
927
928 function peg$parseselector() {
929 var s0, s1, s2, s3, s4, s5;
930
931 var key = peg$currPos * 32 + 7,
932 cached = peg$resultsCache[key];
933
934 if (cached) {
935 peg$currPos = cached.nextPos;
936
937 return cached.result;
938 }
939
940 s0 = peg$currPos;
941 s1 = peg$parsesequence();
942 if (s1 !== peg$FAILED) {
943 s2 = [];
944 s3 = peg$currPos;
945 s4 = peg$parsebinaryOp();
946 if (s4 !== peg$FAILED) {
947 s5 = peg$parsesequence();
948 if (s5 !== peg$FAILED) {
949 s4 = [s4, s5];
950 s3 = s4;
951 } else {
952 peg$currPos = s3;
953 s3 = peg$FAILED;
954 }
955 } else {
956 peg$currPos = s3;
957 s3 = peg$FAILED;
958 }
959 while (s3 !== peg$FAILED) {
960 s2.push(s3);
961 s3 = peg$currPos;
962 s4 = peg$parsebinaryOp();
963 if (s4 !== peg$FAILED) {
964 s5 = peg$parsesequence();
965 if (s5 !== peg$FAILED) {
966 s4 = [s4, s5];
967 s3 = s4;
968 } else {
969 peg$currPos = s3;
970 s3 = peg$FAILED;
971 }
972 } else {
973 peg$currPos = s3;
974 s3 = peg$FAILED;
975 }
976 }
977 if (s2 !== peg$FAILED) {
978 peg$savedPos = s0;
979 s1 = peg$c21(s1, s2);
980 s0 = s1;
981 } else {
982 peg$currPos = s0;
983 s0 = peg$FAILED;
984 }
985 } else {
986 peg$currPos = s0;
987 s0 = peg$FAILED;
988 }
989
990 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
991
992 return s0;
993 }
994
995 function peg$parsesequence() {
996 var s0, s1, s2, s3;
997
998 var key = peg$currPos * 32 + 8,
999 cached = peg$resultsCache[key];
1000
1001 if (cached) {
1002 peg$currPos = cached.nextPos;
1003
1004 return cached.result;
1005 }
1006
1007 s0 = peg$currPos;
1008 if (input.charCodeAt(peg$currPos) === 33) {
1009 s1 = peg$c22;
1010 peg$currPos++;
1011 } else {
1012 s1 = peg$FAILED;
1013 if (peg$silentFails === 0) { peg$fail(peg$c23); }
1014 }
1015 if (s1 === peg$FAILED) {
1016 s1 = null;
1017 }
1018 if (s1 !== peg$FAILED) {
1019 s2 = [];
1020 s3 = peg$parseatom();
1021 if (s3 !== peg$FAILED) {
1022 while (s3 !== peg$FAILED) {
1023 s2.push(s3);
1024 s3 = peg$parseatom();
1025 }
1026 } else {
1027 s2 = peg$FAILED;
1028 }
1029 if (s2 !== peg$FAILED) {
1030 peg$savedPos = s0;
1031 s1 = peg$c24(s1, s2);
1032 s0 = s1;
1033 } else {
1034 peg$currPos = s0;
1035 s0 = peg$FAILED;
1036 }
1037 } else {
1038 peg$currPos = s0;
1039 s0 = peg$FAILED;
1040 }
1041
1042 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1043
1044 return s0;
1045 }
1046
1047 function peg$parseatom() {
1048 var s0;
1049
1050 var key = peg$currPos * 32 + 9,
1051 cached = peg$resultsCache[key];
1052
1053 if (cached) {
1054 peg$currPos = cached.nextPos;
1055
1056 return cached.result;
1057 }
1058
1059 s0 = peg$parsewildcard();
1060 if (s0 === peg$FAILED) {
1061 s0 = peg$parseidentifier();
1062 if (s0 === peg$FAILED) {
1063 s0 = peg$parseattr();
1064 if (s0 === peg$FAILED) {
1065 s0 = peg$parsefield();
1066 if (s0 === peg$FAILED) {
1067 s0 = peg$parsenegation();
1068 if (s0 === peg$FAILED) {
1069 s0 = peg$parsematches();
1070 if (s0 === peg$FAILED) {
1071 s0 = peg$parsehas();
1072 if (s0 === peg$FAILED) {
1073 s0 = peg$parsefirstChild();
1074 if (s0 === peg$FAILED) {
1075 s0 = peg$parselastChild();
1076 if (s0 === peg$FAILED) {
1077 s0 = peg$parsenthChild();
1078 if (s0 === peg$FAILED) {
1079 s0 = peg$parsenthLastChild();
1080 if (s0 === peg$FAILED) {
1081 s0 = peg$parseclass();
1082 }
1083 }
1084 }
1085 }
1086 }
1087 }
1088 }
1089 }
1090 }
1091 }
1092 }
1093
1094 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1095
1096 return s0;
1097 }
1098
1099 function peg$parsewildcard() {
1100 var s0, s1;
1101
1102 var key = peg$currPos * 32 + 10,
1103 cached = peg$resultsCache[key];
1104
1105 if (cached) {
1106 peg$currPos = cached.nextPos;
1107
1108 return cached.result;
1109 }
1110
1111 s0 = peg$currPos;
1112 if (input.charCodeAt(peg$currPos) === 42) {
1113 s1 = peg$c25;
1114 peg$currPos++;
1115 } else {
1116 s1 = peg$FAILED;
1117 if (peg$silentFails === 0) { peg$fail(peg$c26); }
1118 }
1119 if (s1 !== peg$FAILED) {
1120 peg$savedPos = s0;
1121 s1 = peg$c27(s1);
1122 }
1123 s0 = s1;
1124
1125 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1126
1127 return s0;
1128 }
1129
1130 function peg$parseidentifier() {
1131 var s0, s1, s2;
1132
1133 var key = peg$currPos * 32 + 11,
1134 cached = peg$resultsCache[key];
1135
1136 if (cached) {
1137 peg$currPos = cached.nextPos;
1138
1139 return cached.result;
1140 }
1141
1142 s0 = peg$currPos;
1143 if (input.charCodeAt(peg$currPos) === 35) {
1144 s1 = peg$c28;
1145 peg$currPos++;
1146 } else {
1147 s1 = peg$FAILED;
1148 if (peg$silentFails === 0) { peg$fail(peg$c29); }
1149 }
1150 if (s1 === peg$FAILED) {
1151 s1 = null;
1152 }
1153 if (s1 !== peg$FAILED) {
1154 s2 = peg$parseidentifierName();
1155 if (s2 !== peg$FAILED) {
1156 peg$savedPos = s0;
1157 s1 = peg$c30(s2);
1158 s0 = s1;
1159 } else {
1160 peg$currPos = s0;
1161 s0 = peg$FAILED;
1162 }
1163 } else {
1164 peg$currPos = s0;
1165 s0 = peg$FAILED;
1166 }
1167
1168 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1169
1170 return s0;
1171 }
1172
1173 function peg$parseattr() {
1174 var s0, s1, s2, s3, s4, s5;
1175
1176 var key = peg$currPos * 32 + 12,
1177 cached = peg$resultsCache[key];
1178
1179 if (cached) {
1180 peg$currPos = cached.nextPos;
1181
1182 return cached.result;
1183 }
1184
1185 s0 = peg$currPos;
1186 if (input.charCodeAt(peg$currPos) === 91) {
1187 s1 = peg$c31;
1188 peg$currPos++;
1189 } else {
1190 s1 = peg$FAILED;
1191 if (peg$silentFails === 0) { peg$fail(peg$c32); }
1192 }
1193 if (s1 !== peg$FAILED) {
1194 s2 = peg$parse_();
1195 if (s2 !== peg$FAILED) {
1196 s3 = peg$parseattrValue();
1197 if (s3 !== peg$FAILED) {
1198 s4 = peg$parse_();
1199 if (s4 !== peg$FAILED) {
1200 if (input.charCodeAt(peg$currPos) === 93) {
1201 s5 = peg$c33;
1202 peg$currPos++;
1203 } else {
1204 s5 = peg$FAILED;
1205 if (peg$silentFails === 0) { peg$fail(peg$c34); }
1206 }
1207 if (s5 !== peg$FAILED) {
1208 peg$savedPos = s0;
1209 s1 = peg$c35(s3);
1210 s0 = s1;
1211 } else {
1212 peg$currPos = s0;
1213 s0 = peg$FAILED;
1214 }
1215 } else {
1216 peg$currPos = s0;
1217 s0 = peg$FAILED;
1218 }
1219 } else {
1220 peg$currPos = s0;
1221 s0 = peg$FAILED;
1222 }
1223 } else {
1224 peg$currPos = s0;
1225 s0 = peg$FAILED;
1226 }
1227 } else {
1228 peg$currPos = s0;
1229 s0 = peg$FAILED;
1230 }
1231
1232 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1233
1234 return s0;
1235 }
1236
1237 function peg$parseattrOps() {
1238 var s0, s1, s2;
1239
1240 var key = peg$currPos * 32 + 13,
1241 cached = peg$resultsCache[key];
1242
1243 if (cached) {
1244 peg$currPos = cached.nextPos;
1245
1246 return cached.result;
1247 }
1248
1249 s0 = peg$currPos;
1250 if (peg$c36.test(input.charAt(peg$currPos))) {
1251 s1 = input.charAt(peg$currPos);
1252 peg$currPos++;
1253 } else {
1254 s1 = peg$FAILED;
1255 if (peg$silentFails === 0) { peg$fail(peg$c37); }
1256 }
1257 if (s1 === peg$FAILED) {
1258 s1 = null;
1259 }
1260 if (s1 !== peg$FAILED) {
1261 if (input.charCodeAt(peg$currPos) === 61) {
1262 s2 = peg$c38;
1263 peg$currPos++;
1264 } else {
1265 s2 = peg$FAILED;
1266 if (peg$silentFails === 0) { peg$fail(peg$c39); }
1267 }
1268 if (s2 !== peg$FAILED) {
1269 peg$savedPos = s0;
1270 s1 = peg$c40(s1);
1271 s0 = s1;
1272 } else {
1273 peg$currPos = s0;
1274 s0 = peg$FAILED;
1275 }
1276 } else {
1277 peg$currPos = s0;
1278 s0 = peg$FAILED;
1279 }
1280 if (s0 === peg$FAILED) {
1281 if (peg$c41.test(input.charAt(peg$currPos))) {
1282 s0 = input.charAt(peg$currPos);
1283 peg$currPos++;
1284 } else {
1285 s0 = peg$FAILED;
1286 if (peg$silentFails === 0) { peg$fail(peg$c42); }
1287 }
1288 }
1289
1290 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1291
1292 return s0;
1293 }
1294
1295 function peg$parseattrEqOps() {
1296 var s0, s1, s2;
1297
1298 var key = peg$currPos * 32 + 14,
1299 cached = peg$resultsCache[key];
1300
1301 if (cached) {
1302 peg$currPos = cached.nextPos;
1303
1304 return cached.result;
1305 }
1306
1307 s0 = peg$currPos;
1308 if (input.charCodeAt(peg$currPos) === 33) {
1309 s1 = peg$c22;
1310 peg$currPos++;
1311 } else {
1312 s1 = peg$FAILED;
1313 if (peg$silentFails === 0) { peg$fail(peg$c23); }
1314 }
1315 if (s1 === peg$FAILED) {
1316 s1 = null;
1317 }
1318 if (s1 !== peg$FAILED) {
1319 if (input.charCodeAt(peg$currPos) === 61) {
1320 s2 = peg$c38;
1321 peg$currPos++;
1322 } else {
1323 s2 = peg$FAILED;
1324 if (peg$silentFails === 0) { peg$fail(peg$c39); }
1325 }
1326 if (s2 !== peg$FAILED) {
1327 peg$savedPos = s0;
1328 s1 = peg$c40(s1);
1329 s0 = s1;
1330 } else {
1331 peg$currPos = s0;
1332 s0 = peg$FAILED;
1333 }
1334 } else {
1335 peg$currPos = s0;
1336 s0 = peg$FAILED;
1337 }
1338
1339 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1340
1341 return s0;
1342 }
1343
1344 function peg$parseattrName() {
1345 var s0, s1, s2, s3, s4, s5;
1346
1347 var key = peg$currPos * 32 + 15,
1348 cached = peg$resultsCache[key];
1349
1350 if (cached) {
1351 peg$currPos = cached.nextPos;
1352
1353 return cached.result;
1354 }
1355
1356 s0 = peg$currPos;
1357 s1 = peg$parseidentifierName();
1358 if (s1 !== peg$FAILED) {
1359 s2 = [];
1360 s3 = peg$currPos;
1361 if (input.charCodeAt(peg$currPos) === 46) {
1362 s4 = peg$c43;
1363 peg$currPos++;
1364 } else {
1365 s4 = peg$FAILED;
1366 if (peg$silentFails === 0) { peg$fail(peg$c44); }
1367 }
1368 if (s4 !== peg$FAILED) {
1369 s5 = peg$parseidentifierName();
1370 if (s5 !== peg$FAILED) {
1371 s4 = [s4, s5];
1372 s3 = s4;
1373 } else {
1374 peg$currPos = s3;
1375 s3 = peg$FAILED;
1376 }
1377 } else {
1378 peg$currPos = s3;
1379 s3 = peg$FAILED;
1380 }
1381 while (s3 !== peg$FAILED) {
1382 s2.push(s3);
1383 s3 = peg$currPos;
1384 if (input.charCodeAt(peg$currPos) === 46) {
1385 s4 = peg$c43;
1386 peg$currPos++;
1387 } else {
1388 s4 = peg$FAILED;
1389 if (peg$silentFails === 0) { peg$fail(peg$c44); }
1390 }
1391 if (s4 !== peg$FAILED) {
1392 s5 = peg$parseidentifierName();
1393 if (s5 !== peg$FAILED) {
1394 s4 = [s4, s5];
1395 s3 = s4;
1396 } else {
1397 peg$currPos = s3;
1398 s3 = peg$FAILED;
1399 }
1400 } else {
1401 peg$currPos = s3;
1402 s3 = peg$FAILED;
1403 }
1404 }
1405 if (s2 !== peg$FAILED) {
1406 peg$savedPos = s0;
1407 s1 = peg$c45(s1, s2);
1408 s0 = s1;
1409 } else {
1410 peg$currPos = s0;
1411 s0 = peg$FAILED;
1412 }
1413 } else {
1414 peg$currPos = s0;
1415 s0 = peg$FAILED;
1416 }
1417
1418 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1419
1420 return s0;
1421 }
1422
1423 function peg$parseattrValue() {
1424 var s0, s1, s2, s3, s4, s5;
1425
1426 var key = peg$currPos * 32 + 16,
1427 cached = peg$resultsCache[key];
1428
1429 if (cached) {
1430 peg$currPos = cached.nextPos;
1431
1432 return cached.result;
1433 }
1434
1435 s0 = peg$currPos;
1436 s1 = peg$parseattrName();
1437 if (s1 !== peg$FAILED) {
1438 s2 = peg$parse_();
1439 if (s2 !== peg$FAILED) {
1440 s3 = peg$parseattrEqOps();
1441 if (s3 !== peg$FAILED) {
1442 s4 = peg$parse_();
1443 if (s4 !== peg$FAILED) {
1444 s5 = peg$parsetype();
1445 if (s5 === peg$FAILED) {
1446 s5 = peg$parseregex();
1447 }
1448 if (s5 !== peg$FAILED) {
1449 peg$savedPos = s0;
1450 s1 = peg$c46(s1, s3, s5);
1451 s0 = s1;
1452 } else {
1453 peg$currPos = s0;
1454 s0 = peg$FAILED;
1455 }
1456 } else {
1457 peg$currPos = s0;
1458 s0 = peg$FAILED;
1459 }
1460 } else {
1461 peg$currPos = s0;
1462 s0 = peg$FAILED;
1463 }
1464 } else {
1465 peg$currPos = s0;
1466 s0 = peg$FAILED;
1467 }
1468 } else {
1469 peg$currPos = s0;
1470 s0 = peg$FAILED;
1471 }
1472 if (s0 === peg$FAILED) {
1473 s0 = peg$currPos;
1474 s1 = peg$parseattrName();
1475 if (s1 !== peg$FAILED) {
1476 s2 = peg$parse_();
1477 if (s2 !== peg$FAILED) {
1478 s3 = peg$parseattrOps();
1479 if (s3 !== peg$FAILED) {
1480 s4 = peg$parse_();
1481 if (s4 !== peg$FAILED) {
1482 s5 = peg$parsestring();
1483 if (s5 === peg$FAILED) {
1484 s5 = peg$parsenumber();
1485 if (s5 === peg$FAILED) {
1486 s5 = peg$parsepath();
1487 }
1488 }
1489 if (s5 !== peg$FAILED) {
1490 peg$savedPos = s0;
1491 s1 = peg$c46(s1, s3, s5);
1492 s0 = s1;
1493 } else {
1494 peg$currPos = s0;
1495 s0 = peg$FAILED;
1496 }
1497 } else {
1498 peg$currPos = s0;
1499 s0 = peg$FAILED;
1500 }
1501 } else {
1502 peg$currPos = s0;
1503 s0 = peg$FAILED;
1504 }
1505 } else {
1506 peg$currPos = s0;
1507 s0 = peg$FAILED;
1508 }
1509 } else {
1510 peg$currPos = s0;
1511 s0 = peg$FAILED;
1512 }
1513 if (s0 === peg$FAILED) {
1514 s0 = peg$currPos;
1515 s1 = peg$parseattrName();
1516 if (s1 !== peg$FAILED) {
1517 peg$savedPos = s0;
1518 s1 = peg$c47(s1);
1519 }
1520 s0 = s1;
1521 }
1522 }
1523
1524 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1525
1526 return s0;
1527 }
1528
1529 function peg$parsestring() {
1530 var s0, s1, s2, s3, s4, s5;
1531
1532 var key = peg$currPos * 32 + 17,
1533 cached = peg$resultsCache[key];
1534
1535 if (cached) {
1536 peg$currPos = cached.nextPos;
1537
1538 return cached.result;
1539 }
1540
1541 s0 = peg$currPos;
1542 if (input.charCodeAt(peg$currPos) === 34) {
1543 s1 = peg$c48;
1544 peg$currPos++;
1545 } else {
1546 s1 = peg$FAILED;
1547 if (peg$silentFails === 0) { peg$fail(peg$c49); }
1548 }
1549 if (s1 !== peg$FAILED) {
1550 s2 = [];
1551 if (peg$c50.test(input.charAt(peg$currPos))) {
1552 s3 = input.charAt(peg$currPos);
1553 peg$currPos++;
1554 } else {
1555 s3 = peg$FAILED;
1556 if (peg$silentFails === 0) { peg$fail(peg$c51); }
1557 }
1558 if (s3 === peg$FAILED) {
1559 s3 = peg$currPos;
1560 if (input.charCodeAt(peg$currPos) === 92) {
1561 s4 = peg$c52;
1562 peg$currPos++;
1563 } else {
1564 s4 = peg$FAILED;
1565 if (peg$silentFails === 0) { peg$fail(peg$c53); }
1566 }
1567 if (s4 !== peg$FAILED) {
1568 if (input.length > peg$currPos) {
1569 s5 = input.charAt(peg$currPos);
1570 peg$currPos++;
1571 } else {
1572 s5 = peg$FAILED;
1573 if (peg$silentFails === 0) { peg$fail(peg$c54); }
1574 }
1575 if (s5 !== peg$FAILED) {
1576 peg$savedPos = s3;
1577 s4 = peg$c55(s4, s5);
1578 s3 = s4;
1579 } else {
1580 peg$currPos = s3;
1581 s3 = peg$FAILED;
1582 }
1583 } else {
1584 peg$currPos = s3;
1585 s3 = peg$FAILED;
1586 }
1587 }
1588 while (s3 !== peg$FAILED) {
1589 s2.push(s3);
1590 if (peg$c50.test(input.charAt(peg$currPos))) {
1591 s3 = input.charAt(peg$currPos);
1592 peg$currPos++;
1593 } else {
1594 s3 = peg$FAILED;
1595 if (peg$silentFails === 0) { peg$fail(peg$c51); }
1596 }
1597 if (s3 === peg$FAILED) {
1598 s3 = peg$currPos;
1599 if (input.charCodeAt(peg$currPos) === 92) {
1600 s4 = peg$c52;
1601 peg$currPos++;
1602 } else {
1603 s4 = peg$FAILED;
1604 if (peg$silentFails === 0) { peg$fail(peg$c53); }
1605 }
1606 if (s4 !== peg$FAILED) {
1607 if (input.length > peg$currPos) {
1608 s5 = input.charAt(peg$currPos);
1609 peg$currPos++;
1610 } else {
1611 s5 = peg$FAILED;
1612 if (peg$silentFails === 0) { peg$fail(peg$c54); }
1613 }
1614 if (s5 !== peg$FAILED) {
1615 peg$savedPos = s3;
1616 s4 = peg$c55(s4, s5);
1617 s3 = s4;
1618 } else {
1619 peg$currPos = s3;
1620 s3 = peg$FAILED;
1621 }
1622 } else {
1623 peg$currPos = s3;
1624 s3 = peg$FAILED;
1625 }
1626 }
1627 }
1628 if (s2 !== peg$FAILED) {
1629 if (input.charCodeAt(peg$currPos) === 34) {
1630 s3 = peg$c48;
1631 peg$currPos++;
1632 } else {
1633 s3 = peg$FAILED;
1634 if (peg$silentFails === 0) { peg$fail(peg$c49); }
1635 }
1636 if (s3 !== peg$FAILED) {
1637 peg$savedPos = s0;
1638 s1 = peg$c56(s2);
1639 s0 = s1;
1640 } else {
1641 peg$currPos = s0;
1642 s0 = peg$FAILED;
1643 }
1644 } else {
1645 peg$currPos = s0;
1646 s0 = peg$FAILED;
1647 }
1648 } else {
1649 peg$currPos = s0;
1650 s0 = peg$FAILED;
1651 }
1652 if (s0 === peg$FAILED) {
1653 s0 = peg$currPos;
1654 if (input.charCodeAt(peg$currPos) === 39) {
1655 s1 = peg$c57;
1656 peg$currPos++;
1657 } else {
1658 s1 = peg$FAILED;
1659 if (peg$silentFails === 0) { peg$fail(peg$c58); }
1660 }
1661 if (s1 !== peg$FAILED) {
1662 s2 = [];
1663 if (peg$c59.test(input.charAt(peg$currPos))) {
1664 s3 = input.charAt(peg$currPos);
1665 peg$currPos++;
1666 } else {
1667 s3 = peg$FAILED;
1668 if (peg$silentFails === 0) { peg$fail(peg$c60); }
1669 }
1670 if (s3 === peg$FAILED) {
1671 s3 = peg$currPos;
1672 if (input.charCodeAt(peg$currPos) === 92) {
1673 s4 = peg$c52;
1674 peg$currPos++;
1675 } else {
1676 s4 = peg$FAILED;
1677 if (peg$silentFails === 0) { peg$fail(peg$c53); }
1678 }
1679 if (s4 !== peg$FAILED) {
1680 if (input.length > peg$currPos) {
1681 s5 = input.charAt(peg$currPos);
1682 peg$currPos++;
1683 } else {
1684 s5 = peg$FAILED;
1685 if (peg$silentFails === 0) { peg$fail(peg$c54); }
1686 }
1687 if (s5 !== peg$FAILED) {
1688 peg$savedPos = s3;
1689 s4 = peg$c55(s4, s5);
1690 s3 = s4;
1691 } else {
1692 peg$currPos = s3;
1693 s3 = peg$FAILED;
1694 }
1695 } else {
1696 peg$currPos = s3;
1697 s3 = peg$FAILED;
1698 }
1699 }
1700 while (s3 !== peg$FAILED) {
1701 s2.push(s3);
1702 if (peg$c59.test(input.charAt(peg$currPos))) {
1703 s3 = input.charAt(peg$currPos);
1704 peg$currPos++;
1705 } else {
1706 s3 = peg$FAILED;
1707 if (peg$silentFails === 0) { peg$fail(peg$c60); }
1708 }
1709 if (s3 === peg$FAILED) {
1710 s3 = peg$currPos;
1711 if (input.charCodeAt(peg$currPos) === 92) {
1712 s4 = peg$c52;
1713 peg$currPos++;
1714 } else {
1715 s4 = peg$FAILED;
1716 if (peg$silentFails === 0) { peg$fail(peg$c53); }
1717 }
1718 if (s4 !== peg$FAILED) {
1719 if (input.length > peg$currPos) {
1720 s5 = input.charAt(peg$currPos);
1721 peg$currPos++;
1722 } else {
1723 s5 = peg$FAILED;
1724 if (peg$silentFails === 0) { peg$fail(peg$c54); }
1725 }
1726 if (s5 !== peg$FAILED) {
1727 peg$savedPos = s3;
1728 s4 = peg$c55(s4, s5);
1729 s3 = s4;
1730 } else {
1731 peg$currPos = s3;
1732 s3 = peg$FAILED;
1733 }
1734 } else {
1735 peg$currPos = s3;
1736 s3 = peg$FAILED;
1737 }
1738 }
1739 }
1740 if (s2 !== peg$FAILED) {
1741 if (input.charCodeAt(peg$currPos) === 39) {
1742 s3 = peg$c57;
1743 peg$currPos++;
1744 } else {
1745 s3 = peg$FAILED;
1746 if (peg$silentFails === 0) { peg$fail(peg$c58); }
1747 }
1748 if (s3 !== peg$FAILED) {
1749 peg$savedPos = s0;
1750 s1 = peg$c56(s2);
1751 s0 = s1;
1752 } else {
1753 peg$currPos = s0;
1754 s0 = peg$FAILED;
1755 }
1756 } else {
1757 peg$currPos = s0;
1758 s0 = peg$FAILED;
1759 }
1760 } else {
1761 peg$currPos = s0;
1762 s0 = peg$FAILED;
1763 }
1764 }
1765
1766 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1767
1768 return s0;
1769 }
1770
1771 function peg$parsenumber() {
1772 var s0, s1, s2, s3;
1773
1774 var key = peg$currPos * 32 + 18,
1775 cached = peg$resultsCache[key];
1776
1777 if (cached) {
1778 peg$currPos = cached.nextPos;
1779
1780 return cached.result;
1781 }
1782
1783 s0 = peg$currPos;
1784 s1 = peg$currPos;
1785 s2 = [];
1786 if (peg$c61.test(input.charAt(peg$currPos))) {
1787 s3 = input.charAt(peg$currPos);
1788 peg$currPos++;
1789 } else {
1790 s3 = peg$FAILED;
1791 if (peg$silentFails === 0) { peg$fail(peg$c62); }
1792 }
1793 while (s3 !== peg$FAILED) {
1794 s2.push(s3);
1795 if (peg$c61.test(input.charAt(peg$currPos))) {
1796 s3 = input.charAt(peg$currPos);
1797 peg$currPos++;
1798 } else {
1799 s3 = peg$FAILED;
1800 if (peg$silentFails === 0) { peg$fail(peg$c62); }
1801 }
1802 }
1803 if (s2 !== peg$FAILED) {
1804 if (input.charCodeAt(peg$currPos) === 46) {
1805 s3 = peg$c43;
1806 peg$currPos++;
1807 } else {
1808 s3 = peg$FAILED;
1809 if (peg$silentFails === 0) { peg$fail(peg$c44); }
1810 }
1811 if (s3 !== peg$FAILED) {
1812 s2 = [s2, s3];
1813 s1 = s2;
1814 } else {
1815 peg$currPos = s1;
1816 s1 = peg$FAILED;
1817 }
1818 } else {
1819 peg$currPos = s1;
1820 s1 = peg$FAILED;
1821 }
1822 if (s1 === peg$FAILED) {
1823 s1 = null;
1824 }
1825 if (s1 !== peg$FAILED) {
1826 s2 = [];
1827 if (peg$c61.test(input.charAt(peg$currPos))) {
1828 s3 = input.charAt(peg$currPos);
1829 peg$currPos++;
1830 } else {
1831 s3 = peg$FAILED;
1832 if (peg$silentFails === 0) { peg$fail(peg$c62); }
1833 }
1834 if (s3 !== peg$FAILED) {
1835 while (s3 !== peg$FAILED) {
1836 s2.push(s3);
1837 if (peg$c61.test(input.charAt(peg$currPos))) {
1838 s3 = input.charAt(peg$currPos);
1839 peg$currPos++;
1840 } else {
1841 s3 = peg$FAILED;
1842 if (peg$silentFails === 0) { peg$fail(peg$c62); }
1843 }
1844 }
1845 } else {
1846 s2 = peg$FAILED;
1847 }
1848 if (s2 !== peg$FAILED) {
1849 peg$savedPos = s0;
1850 s1 = peg$c63(s1, s2);
1851 s0 = s1;
1852 } else {
1853 peg$currPos = s0;
1854 s0 = peg$FAILED;
1855 }
1856 } else {
1857 peg$currPos = s0;
1858 s0 = peg$FAILED;
1859 }
1860
1861 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1862
1863 return s0;
1864 }
1865
1866 function peg$parsepath() {
1867 var s0, s1;
1868
1869 var key = peg$currPos * 32 + 19,
1870 cached = peg$resultsCache[key];
1871
1872 if (cached) {
1873 peg$currPos = cached.nextPos;
1874
1875 return cached.result;
1876 }
1877
1878 s0 = peg$currPos;
1879 s1 = peg$parseidentifierName();
1880 if (s1 !== peg$FAILED) {
1881 peg$savedPos = s0;
1882 s1 = peg$c64(s1);
1883 }
1884 s0 = s1;
1885
1886 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1887
1888 return s0;
1889 }
1890
1891 function peg$parsetype() {
1892 var s0, s1, s2, s3, s4, s5;
1893
1894 var key = peg$currPos * 32 + 20,
1895 cached = peg$resultsCache[key];
1896
1897 if (cached) {
1898 peg$currPos = cached.nextPos;
1899
1900 return cached.result;
1901 }
1902
1903 s0 = peg$currPos;
1904 if (input.substr(peg$currPos, 5) === peg$c65) {
1905 s1 = peg$c65;
1906 peg$currPos += 5;
1907 } else {
1908 s1 = peg$FAILED;
1909 if (peg$silentFails === 0) { peg$fail(peg$c66); }
1910 }
1911 if (s1 !== peg$FAILED) {
1912 s2 = peg$parse_();
1913 if (s2 !== peg$FAILED) {
1914 s3 = [];
1915 if (peg$c67.test(input.charAt(peg$currPos))) {
1916 s4 = input.charAt(peg$currPos);
1917 peg$currPos++;
1918 } else {
1919 s4 = peg$FAILED;
1920 if (peg$silentFails === 0) { peg$fail(peg$c68); }
1921 }
1922 if (s4 !== peg$FAILED) {
1923 while (s4 !== peg$FAILED) {
1924 s3.push(s4);
1925 if (peg$c67.test(input.charAt(peg$currPos))) {
1926 s4 = input.charAt(peg$currPos);
1927 peg$currPos++;
1928 } else {
1929 s4 = peg$FAILED;
1930 if (peg$silentFails === 0) { peg$fail(peg$c68); }
1931 }
1932 }
1933 } else {
1934 s3 = peg$FAILED;
1935 }
1936 if (s3 !== peg$FAILED) {
1937 s4 = peg$parse_();
1938 if (s4 !== peg$FAILED) {
1939 if (input.charCodeAt(peg$currPos) === 41) {
1940 s5 = peg$c69;
1941 peg$currPos++;
1942 } else {
1943 s5 = peg$FAILED;
1944 if (peg$silentFails === 0) { peg$fail(peg$c70); }
1945 }
1946 if (s5 !== peg$FAILED) {
1947 peg$savedPos = s0;
1948 s1 = peg$c71(s3);
1949 s0 = s1;
1950 } else {
1951 peg$currPos = s0;
1952 s0 = peg$FAILED;
1953 }
1954 } else {
1955 peg$currPos = s0;
1956 s0 = peg$FAILED;
1957 }
1958 } else {
1959 peg$currPos = s0;
1960 s0 = peg$FAILED;
1961 }
1962 } else {
1963 peg$currPos = s0;
1964 s0 = peg$FAILED;
1965 }
1966 } else {
1967 peg$currPos = s0;
1968 s0 = peg$FAILED;
1969 }
1970
1971 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1972
1973 return s0;
1974 }
1975
1976 function peg$parseflags() {
1977 var s0, s1;
1978
1979 var key = peg$currPos * 32 + 21,
1980 cached = peg$resultsCache[key];
1981
1982 if (cached) {
1983 peg$currPos = cached.nextPos;
1984
1985 return cached.result;
1986 }
1987
1988 s0 = [];
1989 if (peg$c72.test(input.charAt(peg$currPos))) {
1990 s1 = input.charAt(peg$currPos);
1991 peg$currPos++;
1992 } else {
1993 s1 = peg$FAILED;
1994 if (peg$silentFails === 0) { peg$fail(peg$c73); }
1995 }
1996 if (s1 !== peg$FAILED) {
1997 while (s1 !== peg$FAILED) {
1998 s0.push(s1);
1999 if (peg$c72.test(input.charAt(peg$currPos))) {
2000 s1 = input.charAt(peg$currPos);
2001 peg$currPos++;
2002 } else {
2003 s1 = peg$FAILED;
2004 if (peg$silentFails === 0) { peg$fail(peg$c73); }
2005 }
2006 }
2007 } else {
2008 s0 = peg$FAILED;
2009 }
2010
2011 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2012
2013 return s0;
2014 }
2015
2016 function peg$parseregex() {
2017 var s0, s1, s2, s3, s4;
2018
2019 var key = peg$currPos * 32 + 22,
2020 cached = peg$resultsCache[key];
2021
2022 if (cached) {
2023 peg$currPos = cached.nextPos;
2024
2025 return cached.result;
2026 }
2027
2028 s0 = peg$currPos;
2029 if (input.charCodeAt(peg$currPos) === 47) {
2030 s1 = peg$c74;
2031 peg$currPos++;
2032 } else {
2033 s1 = peg$FAILED;
2034 if (peg$silentFails === 0) { peg$fail(peg$c75); }
2035 }
2036 if (s1 !== peg$FAILED) {
2037 s2 = [];
2038 if (peg$c76.test(input.charAt(peg$currPos))) {
2039 s3 = input.charAt(peg$currPos);
2040 peg$currPos++;
2041 } else {
2042 s3 = peg$FAILED;
2043 if (peg$silentFails === 0) { peg$fail(peg$c77); }
2044 }
2045 if (s3 !== peg$FAILED) {
2046 while (s3 !== peg$FAILED) {
2047 s2.push(s3);
2048 if (peg$c76.test(input.charAt(peg$currPos))) {
2049 s3 = input.charAt(peg$currPos);
2050 peg$currPos++;
2051 } else {
2052 s3 = peg$FAILED;
2053 if (peg$silentFails === 0) { peg$fail(peg$c77); }
2054 }
2055 }
2056 } else {
2057 s2 = peg$FAILED;
2058 }
2059 if (s2 !== peg$FAILED) {
2060 if (input.charCodeAt(peg$currPos) === 47) {
2061 s3 = peg$c74;
2062 peg$currPos++;
2063 } else {
2064 s3 = peg$FAILED;
2065 if (peg$silentFails === 0) { peg$fail(peg$c75); }
2066 }
2067 if (s3 !== peg$FAILED) {
2068 s4 = peg$parseflags();
2069 if (s4 === peg$FAILED) {
2070 s4 = null;
2071 }
2072 if (s4 !== peg$FAILED) {
2073 peg$savedPos = s0;
2074 s1 = peg$c78(s2, s4);
2075 s0 = s1;
2076 } else {
2077 peg$currPos = s0;
2078 s0 = peg$FAILED;
2079 }
2080 } else {
2081 peg$currPos = s0;
2082 s0 = peg$FAILED;
2083 }
2084 } else {
2085 peg$currPos = s0;
2086 s0 = peg$FAILED;
2087 }
2088 } else {
2089 peg$currPos = s0;
2090 s0 = peg$FAILED;
2091 }
2092
2093 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2094
2095 return s0;
2096 }
2097
2098 function peg$parsefield() {
2099 var s0, s1, s2, s3, s4, s5, s6;
2100
2101 var key = peg$currPos * 32 + 23,
2102 cached = peg$resultsCache[key];
2103
2104 if (cached) {
2105 peg$currPos = cached.nextPos;
2106
2107 return cached.result;
2108 }
2109
2110 s0 = peg$currPos;
2111 if (input.charCodeAt(peg$currPos) === 46) {
2112 s1 = peg$c43;
2113 peg$currPos++;
2114 } else {
2115 s1 = peg$FAILED;
2116 if (peg$silentFails === 0) { peg$fail(peg$c44); }
2117 }
2118 if (s1 !== peg$FAILED) {
2119 s2 = peg$parseidentifierName();
2120 if (s2 !== peg$FAILED) {
2121 s3 = [];
2122 s4 = peg$currPos;
2123 if (input.charCodeAt(peg$currPos) === 46) {
2124 s5 = peg$c43;
2125 peg$currPos++;
2126 } else {
2127 s5 = peg$FAILED;
2128 if (peg$silentFails === 0) { peg$fail(peg$c44); }
2129 }
2130 if (s5 !== peg$FAILED) {
2131 s6 = peg$parseidentifierName();
2132 if (s6 !== peg$FAILED) {
2133 s5 = [s5, s6];
2134 s4 = s5;
2135 } else {
2136 peg$currPos = s4;
2137 s4 = peg$FAILED;
2138 }
2139 } else {
2140 peg$currPos = s4;
2141 s4 = peg$FAILED;
2142 }
2143 while (s4 !== peg$FAILED) {
2144 s3.push(s4);
2145 s4 = peg$currPos;
2146 if (input.charCodeAt(peg$currPos) === 46) {
2147 s5 = peg$c43;
2148 peg$currPos++;
2149 } else {
2150 s5 = peg$FAILED;
2151 if (peg$silentFails === 0) { peg$fail(peg$c44); }
2152 }
2153 if (s5 !== peg$FAILED) {
2154 s6 = peg$parseidentifierName();
2155 if (s6 !== peg$FAILED) {
2156 s5 = [s5, s6];
2157 s4 = s5;
2158 } else {
2159 peg$currPos = s4;
2160 s4 = peg$FAILED;
2161 }
2162 } else {
2163 peg$currPos = s4;
2164 s4 = peg$FAILED;
2165 }
2166 }
2167 if (s3 !== peg$FAILED) {
2168 peg$savedPos = s0;
2169 s1 = peg$c79(s2, s3);
2170 s0 = s1;
2171 } else {
2172 peg$currPos = s0;
2173 s0 = peg$FAILED;
2174 }
2175 } else {
2176 peg$currPos = s0;
2177 s0 = peg$FAILED;
2178 }
2179 } else {
2180 peg$currPos = s0;
2181 s0 = peg$FAILED;
2182 }
2183
2184 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2185
2186 return s0;
2187 }
2188
2189 function peg$parsenegation() {
2190 var s0, s1, s2, s3, s4, s5;
2191
2192 var key = peg$currPos * 32 + 24,
2193 cached = peg$resultsCache[key];
2194
2195 if (cached) {
2196 peg$currPos = cached.nextPos;
2197
2198 return cached.result;
2199 }
2200
2201 s0 = peg$currPos;
2202 if (input.substr(peg$currPos, 5) === peg$c80) {
2203 s1 = peg$c80;
2204 peg$currPos += 5;
2205 } else {
2206 s1 = peg$FAILED;
2207 if (peg$silentFails === 0) { peg$fail(peg$c81); }
2208 }
2209 if (s1 !== peg$FAILED) {
2210 s2 = peg$parse_();
2211 if (s2 !== peg$FAILED) {
2212 s3 = peg$parseselectors();
2213 if (s3 !== peg$FAILED) {
2214 s4 = peg$parse_();
2215 if (s4 !== peg$FAILED) {
2216 if (input.charCodeAt(peg$currPos) === 41) {
2217 s5 = peg$c69;
2218 peg$currPos++;
2219 } else {
2220 s5 = peg$FAILED;
2221 if (peg$silentFails === 0) { peg$fail(peg$c70); }
2222 }
2223 if (s5 !== peg$FAILED) {
2224 peg$savedPos = s0;
2225 s1 = peg$c82(s3);
2226 s0 = s1;
2227 } else {
2228 peg$currPos = s0;
2229 s0 = peg$FAILED;
2230 }
2231 } else {
2232 peg$currPos = s0;
2233 s0 = peg$FAILED;
2234 }
2235 } else {
2236 peg$currPos = s0;
2237 s0 = peg$FAILED;
2238 }
2239 } else {
2240 peg$currPos = s0;
2241 s0 = peg$FAILED;
2242 }
2243 } else {
2244 peg$currPos = s0;
2245 s0 = peg$FAILED;
2246 }
2247
2248 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2249
2250 return s0;
2251 }
2252
2253 function peg$parsematches() {
2254 var s0, s1, s2, s3, s4, s5;
2255
2256 var key = peg$currPos * 32 + 25,
2257 cached = peg$resultsCache[key];
2258
2259 if (cached) {
2260 peg$currPos = cached.nextPos;
2261
2262 return cached.result;
2263 }
2264
2265 s0 = peg$currPos;
2266 if (input.substr(peg$currPos, 9) === peg$c83) {
2267 s1 = peg$c83;
2268 peg$currPos += 9;
2269 } else {
2270 s1 = peg$FAILED;
2271 if (peg$silentFails === 0) { peg$fail(peg$c84); }
2272 }
2273 if (s1 !== peg$FAILED) {
2274 s2 = peg$parse_();
2275 if (s2 !== peg$FAILED) {
2276 s3 = peg$parseselectors();
2277 if (s3 !== peg$FAILED) {
2278 s4 = peg$parse_();
2279 if (s4 !== peg$FAILED) {
2280 if (input.charCodeAt(peg$currPos) === 41) {
2281 s5 = peg$c69;
2282 peg$currPos++;
2283 } else {
2284 s5 = peg$FAILED;
2285 if (peg$silentFails === 0) { peg$fail(peg$c70); }
2286 }
2287 if (s5 !== peg$FAILED) {
2288 peg$savedPos = s0;
2289 s1 = peg$c85(s3);
2290 s0 = s1;
2291 } else {
2292 peg$currPos = s0;
2293 s0 = peg$FAILED;
2294 }
2295 } else {
2296 peg$currPos = s0;
2297 s0 = peg$FAILED;
2298 }
2299 } else {
2300 peg$currPos = s0;
2301 s0 = peg$FAILED;
2302 }
2303 } else {
2304 peg$currPos = s0;
2305 s0 = peg$FAILED;
2306 }
2307 } else {
2308 peg$currPos = s0;
2309 s0 = peg$FAILED;
2310 }
2311
2312 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2313
2314 return s0;
2315 }
2316
2317 function peg$parsehas() {
2318 var s0, s1, s2, s3, s4, s5;
2319
2320 var key = peg$currPos * 32 + 26,
2321 cached = peg$resultsCache[key];
2322
2323 if (cached) {
2324 peg$currPos = cached.nextPos;
2325
2326 return cached.result;
2327 }
2328
2329 s0 = peg$currPos;
2330 if (input.substr(peg$currPos, 5) === peg$c86) {
2331 s1 = peg$c86;
2332 peg$currPos += 5;
2333 } else {
2334 s1 = peg$FAILED;
2335 if (peg$silentFails === 0) { peg$fail(peg$c87); }
2336 }
2337 if (s1 !== peg$FAILED) {
2338 s2 = peg$parse_();
2339 if (s2 !== peg$FAILED) {
2340 s3 = peg$parsehasSelectors();
2341 if (s3 !== peg$FAILED) {
2342 s4 = peg$parse_();
2343 if (s4 !== peg$FAILED) {
2344 if (input.charCodeAt(peg$currPos) === 41) {
2345 s5 = peg$c69;
2346 peg$currPos++;
2347 } else {
2348 s5 = peg$FAILED;
2349 if (peg$silentFails === 0) { peg$fail(peg$c70); }
2350 }
2351 if (s5 !== peg$FAILED) {
2352 peg$savedPos = s0;
2353 s1 = peg$c88(s3);
2354 s0 = s1;
2355 } else {
2356 peg$currPos = s0;
2357 s0 = peg$FAILED;
2358 }
2359 } else {
2360 peg$currPos = s0;
2361 s0 = peg$FAILED;
2362 }
2363 } else {
2364 peg$currPos = s0;
2365 s0 = peg$FAILED;
2366 }
2367 } else {
2368 peg$currPos = s0;
2369 s0 = peg$FAILED;
2370 }
2371 } else {
2372 peg$currPos = s0;
2373 s0 = peg$FAILED;
2374 }
2375
2376 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2377
2378 return s0;
2379 }
2380
2381 function peg$parsefirstChild() {
2382 var s0, s1;
2383
2384 var key = peg$currPos * 32 + 27,
2385 cached = peg$resultsCache[key];
2386
2387 if (cached) {
2388 peg$currPos = cached.nextPos;
2389
2390 return cached.result;
2391 }
2392
2393 s0 = peg$currPos;
2394 if (input.substr(peg$currPos, 12) === peg$c89) {
2395 s1 = peg$c89;
2396 peg$currPos += 12;
2397 } else {
2398 s1 = peg$FAILED;
2399 if (peg$silentFails === 0) { peg$fail(peg$c90); }
2400 }
2401 if (s1 !== peg$FAILED) {
2402 peg$savedPos = s0;
2403 s1 = peg$c91();
2404 }
2405 s0 = s1;
2406
2407 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2408
2409 return s0;
2410 }
2411
2412 function peg$parselastChild() {
2413 var s0, s1;
2414
2415 var key = peg$currPos * 32 + 28,
2416 cached = peg$resultsCache[key];
2417
2418 if (cached) {
2419 peg$currPos = cached.nextPos;
2420
2421 return cached.result;
2422 }
2423
2424 s0 = peg$currPos;
2425 if (input.substr(peg$currPos, 11) === peg$c92) {
2426 s1 = peg$c92;
2427 peg$currPos += 11;
2428 } else {
2429 s1 = peg$FAILED;
2430 if (peg$silentFails === 0) { peg$fail(peg$c93); }
2431 }
2432 if (s1 !== peg$FAILED) {
2433 peg$savedPos = s0;
2434 s1 = peg$c94();
2435 }
2436 s0 = s1;
2437
2438 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2439
2440 return s0;
2441 }
2442
2443 function peg$parsenthChild() {
2444 var s0, s1, s2, s3, s4, s5;
2445
2446 var key = peg$currPos * 32 + 29,
2447 cached = peg$resultsCache[key];
2448
2449 if (cached) {
2450 peg$currPos = cached.nextPos;
2451
2452 return cached.result;
2453 }
2454
2455 s0 = peg$currPos;
2456 if (input.substr(peg$currPos, 11) === peg$c95) {
2457 s1 = peg$c95;
2458 peg$currPos += 11;
2459 } else {
2460 s1 = peg$FAILED;
2461 if (peg$silentFails === 0) { peg$fail(peg$c96); }
2462 }
2463 if (s1 !== peg$FAILED) {
2464 s2 = peg$parse_();
2465 if (s2 !== peg$FAILED) {
2466 s3 = [];
2467 if (peg$c61.test(input.charAt(peg$currPos))) {
2468 s4 = input.charAt(peg$currPos);
2469 peg$currPos++;
2470 } else {
2471 s4 = peg$FAILED;
2472 if (peg$silentFails === 0) { peg$fail(peg$c62); }
2473 }
2474 if (s4 !== peg$FAILED) {
2475 while (s4 !== peg$FAILED) {
2476 s3.push(s4);
2477 if (peg$c61.test(input.charAt(peg$currPos))) {
2478 s4 = input.charAt(peg$currPos);
2479 peg$currPos++;
2480 } else {
2481 s4 = peg$FAILED;
2482 if (peg$silentFails === 0) { peg$fail(peg$c62); }
2483 }
2484 }
2485 } else {
2486 s3 = peg$FAILED;
2487 }
2488 if (s3 !== peg$FAILED) {
2489 s4 = peg$parse_();
2490 if (s4 !== peg$FAILED) {
2491 if (input.charCodeAt(peg$currPos) === 41) {
2492 s5 = peg$c69;
2493 peg$currPos++;
2494 } else {
2495 s5 = peg$FAILED;
2496 if (peg$silentFails === 0) { peg$fail(peg$c70); }
2497 }
2498 if (s5 !== peg$FAILED) {
2499 peg$savedPos = s0;
2500 s1 = peg$c97(s3);
2501 s0 = s1;
2502 } else {
2503 peg$currPos = s0;
2504 s0 = peg$FAILED;
2505 }
2506 } else {
2507 peg$currPos = s0;
2508 s0 = peg$FAILED;
2509 }
2510 } else {
2511 peg$currPos = s0;
2512 s0 = peg$FAILED;
2513 }
2514 } else {
2515 peg$currPos = s0;
2516 s0 = peg$FAILED;
2517 }
2518 } else {
2519 peg$currPos = s0;
2520 s0 = peg$FAILED;
2521 }
2522
2523 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2524
2525 return s0;
2526 }
2527
2528 function peg$parsenthLastChild() {
2529 var s0, s1, s2, s3, s4, s5;
2530
2531 var key = peg$currPos * 32 + 30,
2532 cached = peg$resultsCache[key];
2533
2534 if (cached) {
2535 peg$currPos = cached.nextPos;
2536
2537 return cached.result;
2538 }
2539
2540 s0 = peg$currPos;
2541 if (input.substr(peg$currPos, 16) === peg$c98) {
2542 s1 = peg$c98;
2543 peg$currPos += 16;
2544 } else {
2545 s1 = peg$FAILED;
2546 if (peg$silentFails === 0) { peg$fail(peg$c99); }
2547 }
2548 if (s1 !== peg$FAILED) {
2549 s2 = peg$parse_();
2550 if (s2 !== peg$FAILED) {
2551 s3 = [];
2552 if (peg$c61.test(input.charAt(peg$currPos))) {
2553 s4 = input.charAt(peg$currPos);
2554 peg$currPos++;
2555 } else {
2556 s4 = peg$FAILED;
2557 if (peg$silentFails === 0) { peg$fail(peg$c62); }
2558 }
2559 if (s4 !== peg$FAILED) {
2560 while (s4 !== peg$FAILED) {
2561 s3.push(s4);
2562 if (peg$c61.test(input.charAt(peg$currPos))) {
2563 s4 = input.charAt(peg$currPos);
2564 peg$currPos++;
2565 } else {
2566 s4 = peg$FAILED;
2567 if (peg$silentFails === 0) { peg$fail(peg$c62); }
2568 }
2569 }
2570 } else {
2571 s3 = peg$FAILED;
2572 }
2573 if (s3 !== peg$FAILED) {
2574 s4 = peg$parse_();
2575 if (s4 !== peg$FAILED) {
2576 if (input.charCodeAt(peg$currPos) === 41) {
2577 s5 = peg$c69;
2578 peg$currPos++;
2579 } else {
2580 s5 = peg$FAILED;
2581 if (peg$silentFails === 0) { peg$fail(peg$c70); }
2582 }
2583 if (s5 !== peg$FAILED) {
2584 peg$savedPos = s0;
2585 s1 = peg$c100(s3);
2586 s0 = s1;
2587 } else {
2588 peg$currPos = s0;
2589 s0 = peg$FAILED;
2590 }
2591 } else {
2592 peg$currPos = s0;
2593 s0 = peg$FAILED;
2594 }
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
2608 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2609
2610 return s0;
2611 }
2612
2613 function peg$parseclass() {
2614 var s0, s1, s2;
2615
2616 var key = peg$currPos * 32 + 31,
2617 cached = peg$resultsCache[key];
2618
2619 if (cached) {
2620 peg$currPos = cached.nextPos;
2621
2622 return cached.result;
2623 }
2624
2625 s0 = peg$currPos;
2626 if (input.charCodeAt(peg$currPos) === 58) {
2627 s1 = peg$c101;
2628 peg$currPos++;
2629 } else {
2630 s1 = peg$FAILED;
2631 if (peg$silentFails === 0) { peg$fail(peg$c102); }
2632 }
2633 if (s1 !== peg$FAILED) {
2634 s2 = peg$parseidentifierName();
2635 if (s2 !== peg$FAILED) {
2636 peg$savedPos = s0;
2637 s1 = peg$c103(s2);
2638 s0 = s1;
2639 } else {
2640 peg$currPos = s0;
2641 s0 = peg$FAILED;
2642 }
2643 } else {
2644 peg$currPos = s0;
2645 s0 = peg$FAILED;
2646 }
2647
2648 peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2649
2650 return s0;
2651 }
2652
2653
2654 function nth(n) { return { type: 'nth-child', index: { type: 'literal', value: n } }; }
2655 function nthLast(n) { return { type: 'nth-last-child', index: { type: 'literal', value: n } }; }
2656 function strUnescape(s) {
2657 return s.replace(/\\(.)/g, function(match, ch) {
2658 switch(ch) {
2659 case 'b': return '\b';
2660 case 'f': return '\f';
2661 case 'n': return '\n';
2662 case 'r': return '\r';
2663 case 't': return '\t';
2664 case 'v': return '\v';
2665 default: return ch;
2666 }
2667 });
2668 }
2669
2670
2671 peg$result = peg$startRuleFunction();
2672
2673 if (peg$result !== peg$FAILED && peg$currPos === input.length) {
2674 return peg$result;
2675 } else {
2676 if (peg$result !== peg$FAILED && peg$currPos < input.length) {
2677 peg$fail(peg$endExpectation());
2678 }
2679
2680 throw peg$buildStructuredError(
2681 peg$maxFailExpected,
2682 peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
2683 peg$maxFailPos < input.length
2684 ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
2685 : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
2686 );
2687 }
2688 }
2689
2690 return {
2691 SyntaxError: peg$SyntaxError,
2692 parse: peg$parse
2693 };
2694});
Note: See TracBrowser for help on using the repository browser.