emblem-source 0.2.7 → 0.2.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/dist/emblem.js +319 -291
 - data/dist/emblem.min.js +2 -2
 - metadata +2 -2
 
    
        data/dist/emblem.js
    CHANGED
    
    | 
         @@ -178,7 +178,7 @@ this.Emblem = {}; 
     | 
|
| 
       178 
178 
     | 
    
         | 
| 
       179 
179 
     | 
    
         
             
            Emblem = this.Emblem;
         
     | 
| 
       180 
180 
     | 
    
         | 
| 
       181 
     | 
    
         
            -
            Emblem.VERSION = "0.2. 
     | 
| 
      
 181 
     | 
    
         
            +
            Emblem.VERSION = "0.2.8";
         
     | 
| 
       182 
182 
     | 
    
         | 
| 
       183 
183 
     | 
    
         | 
| 
       184 
184 
     | 
    
         | 
| 
         @@ -449,9 +449,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       449 
449 
     | 
    
         
             
                    peg$c51 = "[a-zA-Z0-9_$\\-!?\\^]",
         
     | 
| 
       450 
450 
     | 
    
         
             
                    peg$c52 = function(s) { return s; },
         
     | 
| 
       451 
451 
     | 
    
         
             
                    peg$c53 = "Key",
         
     | 
| 
       452 
     | 
    
         
            -
                    peg$c54 =  
     | 
| 
       453 
     | 
    
         
            -
                    peg$c55 =  
     | 
| 
       454 
     | 
    
         
            -
                    peg$c56 = function( 
     | 
| 
      
 452 
     | 
    
         
            +
                    peg$c54 = ":",
         
     | 
| 
      
 453 
     | 
    
         
            +
                    peg$c55 = "\":\"",
         
     | 
| 
      
 454 
     | 
    
         
            +
                    peg$c56 = function(h) { return [h[0], h[2]]; },
         
     | 
| 
      
 455 
     | 
    
         
            +
                    peg$c57 = function(p) { return p; },
         
     | 
| 
      
 456 
     | 
    
         
            +
                    peg$c58 = function(first, tail) {
         
     | 
| 
       455 
457 
     | 
    
         
             
                      var ret = [first];
         
     | 
| 
       456 
458 
     | 
    
         
             
                      for(var i = 0; i < tail.length; ++i) {
         
     | 
| 
       457 
459 
     | 
    
         
             
                        //ret = ret.concat(tail[i]);
         
     | 
| 
         @@ -459,10 +461,10 @@ Emblem.Parser = (function() { 
     | 
|
| 
       459 
461 
     | 
    
         
             
                      }
         
     | 
| 
       460 
462 
     | 
    
         
             
                      return ret;
         
     | 
| 
       461 
463 
     | 
    
         
             
                    },
         
     | 
| 
       462 
     | 
    
         
            -
                    peg$ 
     | 
| 
       463 
     | 
    
         
            -
                    peg$ 
     | 
| 
       464 
     | 
    
         
            -
                    peg$ 
     | 
| 
       465 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 464 
     | 
    
         
            +
                    peg$c59 = "PathSeparator",
         
     | 
| 
      
 465 
     | 
    
         
            +
                    peg$c60 = /^[\/.]/,
         
     | 
| 
      
 466 
     | 
    
         
            +
                    peg$c61 = "[\\/.]",
         
     | 
| 
      
 467 
     | 
    
         
            +
                    peg$c62 = function(v) { 
         
     | 
| 
       466 
468 
     | 
    
         
             
                      var last = v[v.length - 1];
         
     | 
| 
       467 
469 
     | 
    
         
             
                      var match;
         
     | 
| 
       468 
470 
     | 
    
         
             
                      var suffixModifier;
         
     | 
| 
         @@ -476,30 +478,30 @@ Emblem.Parser = (function() { 
     | 
|
| 
       476 
478 
     | 
    
         | 
| 
       477 
479 
     | 
    
         
             
                      return idNode;
         
     | 
| 
       478 
480 
     | 
    
         
             
                    },
         
     | 
| 
       479 
     | 
    
         
            -
                    peg$ 
     | 
| 
       480 
     | 
    
         
            -
                    peg$ 
     | 
| 
       481 
     | 
    
         
            -
                    peg$ 
     | 
| 
       482 
     | 
    
         
            -
                    peg$ 
     | 
| 
       483 
     | 
    
         
            -
                    peg$ 
     | 
| 
       484 
     | 
    
         
            -
                    peg$ 
     | 
| 
       485 
     | 
    
         
            -
                    peg$ 
     | 
| 
       486 
     | 
    
         
            -
                    peg$ 
     | 
| 
       487 
     | 
    
         
            -
                    peg$ 
     | 
| 
       488 
     | 
    
         
            -
                    peg$ 
     | 
| 
       489 
     | 
    
         
            -
                    peg$ 
     | 
| 
       490 
     | 
    
         
            -
                    peg$ 
     | 
| 
       491 
     | 
    
         
            -
                    peg$ 
     | 
| 
       492 
     | 
    
         
            -
                    peg$ 
     | 
| 
       493 
     | 
    
         
            -
                    peg$ 
     | 
| 
       494 
     | 
    
         
            -
                    peg$ 
     | 
| 
       495 
     | 
    
         
            -
                    peg$ 
     | 
| 
       496 
     | 
    
         
            -
                    peg$ 
     | 
| 
       497 
     | 
    
         
            -
                    peg$ 
     | 
| 
       498 
     | 
    
         
            -
                    peg$ 
     | 
| 
       499 
     | 
    
         
            -
                    peg$ 
     | 
| 
       500 
     | 
    
         
            -
                    peg$ 
     | 
| 
       501 
     | 
    
         
            -
                    peg$ 
     | 
| 
       502 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 481 
     | 
    
         
            +
                    peg$c63 = function(v) { return new AST.StringNode(v); },
         
     | 
| 
      
 482 
     | 
    
         
            +
                    peg$c64 = function(v) { return new AST.IntegerNode(v); },
         
     | 
| 
      
 483 
     | 
    
         
            +
                    peg$c65 = function(v) { return new AST.BooleanNode(v); },
         
     | 
| 
      
 484 
     | 
    
         
            +
                    peg$c66 = "Boolean",
         
     | 
| 
      
 485 
     | 
    
         
            +
                    peg$c67 = "true",
         
     | 
| 
      
 486 
     | 
    
         
            +
                    peg$c68 = "\"true\"",
         
     | 
| 
      
 487 
     | 
    
         
            +
                    peg$c69 = "false",
         
     | 
| 
      
 488 
     | 
    
         
            +
                    peg$c70 = "\"false\"",
         
     | 
| 
      
 489 
     | 
    
         
            +
                    peg$c71 = "Integer",
         
     | 
| 
      
 490 
     | 
    
         
            +
                    peg$c72 = /^[0-9]/,
         
     | 
| 
      
 491 
     | 
    
         
            +
                    peg$c73 = "[0-9]",
         
     | 
| 
      
 492 
     | 
    
         
            +
                    peg$c74 = function(s) { return parseInt(s); },
         
     | 
| 
      
 493 
     | 
    
         
            +
                    peg$c75 = "\"",
         
     | 
| 
      
 494 
     | 
    
         
            +
                    peg$c76 = "\"\\\"\"",
         
     | 
| 
      
 495 
     | 
    
         
            +
                    peg$c77 = "'",
         
     | 
| 
      
 496 
     | 
    
         
            +
                    peg$c78 = "\"'\"",
         
     | 
| 
      
 497 
     | 
    
         
            +
                    peg$c79 = function(p) { return p[1]; },
         
     | 
| 
      
 498 
     | 
    
         
            +
                    peg$c80 = /^[^"}]/,
         
     | 
| 
      
 499 
     | 
    
         
            +
                    peg$c81 = "[^\"}]",
         
     | 
| 
      
 500 
     | 
    
         
            +
                    peg$c82 = /^[^'}]/,
         
     | 
| 
      
 501 
     | 
    
         
            +
                    peg$c83 = "[^'}]",
         
     | 
| 
      
 502 
     | 
    
         
            +
                    peg$c84 = /^[A-Za-z]/,
         
     | 
| 
      
 503 
     | 
    
         
            +
                    peg$c85 = "[A-Za-z]",
         
     | 
| 
      
 504 
     | 
    
         
            +
                    peg$c86 = function(ind, nodes, w) {
         
     | 
| 
       503 
505 
     | 
    
         
             
                      nodes.unshift(new AST.ContentNode(ind));
         
     | 
| 
       504 
506 
     | 
    
         | 
| 
       505 
507 
     | 
    
         
             
                      for(var i = 0; i < w.length; ++i) {
         
     | 
| 
         @@ -509,12 +511,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       509 
511 
     | 
    
         
             
                      }
         
     | 
| 
       510 
512 
     | 
    
         
             
                      return nodes; 
         
     | 
| 
       511 
513 
     | 
    
         
             
                    },
         
     | 
| 
       512 
     | 
    
         
            -
                    peg$ 
     | 
| 
       513 
     | 
    
         
            -
                    peg$ 
     | 
| 
       514 
     | 
    
         
            -
                    peg$ 
     | 
| 
       515 
     | 
    
         
            -
                    peg$ 
     | 
| 
       516 
     | 
    
         
            -
                    peg$ 
     | 
| 
       517 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 514 
     | 
    
         
            +
                    peg$c87 = /^[|`']/,
         
     | 
| 
      
 515 
     | 
    
         
            +
                    peg$c88 = "[|`']",
         
     | 
| 
      
 516 
     | 
    
         
            +
                    peg$c89 = "<",
         
     | 
| 
      
 517 
     | 
    
         
            +
                    peg$c90 = "\"<\"",
         
     | 
| 
      
 518 
     | 
    
         
            +
                    peg$c91 = function() { return '<'; },
         
     | 
| 
      
 519 
     | 
    
         
            +
                    peg$c92 = function(s, nodes, indentedNodes) { 
         
     | 
| 
       518 
520 
     | 
    
         
             
                      if(nodes.length || !indentedNodes) {
         
     | 
| 
       519 
521 
     | 
    
         
             
                        nodes.push("\n");
         
     | 
| 
       520 
522 
     | 
    
         
             
                      }
         
     | 
| 
         @@ -547,50 +549,50 @@ Emblem.Parser = (function() { 
     | 
|
| 
       547 
549 
     | 
    
         | 
| 
       548 
550 
     | 
    
         
             
                      return ret;
         
     | 
| 
       549 
551 
     | 
    
         
             
                    },
         
     | 
| 
       550 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 552 
     | 
    
         
            +
                    peg$c93 = function(first, tail) {
         
     | 
| 
       551 
553 
     | 
    
         
             
                      return textNodesResult(first, tail);
         
     | 
| 
       552 
554 
     | 
    
         
             
                    },
         
     | 
| 
       553 
     | 
    
         
            -
                    peg$ 
     | 
| 
       554 
     | 
    
         
            -
                    peg$ 
     | 
| 
       555 
     | 
    
         
            -
                    peg$ 
     | 
| 
       556 
     | 
    
         
            -
                    peg$ 
     | 
| 
       557 
     | 
    
         
            -
                    peg$ 
     | 
| 
       558 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 555 
     | 
    
         
            +
                    peg$c94 = function(first, tail) { return textNodesResult(first, tail); },
         
     | 
| 
      
 556 
     | 
    
         
            +
                    peg$c95 = "{",
         
     | 
| 
      
 557 
     | 
    
         
            +
                    peg$c96 = "\"{\"",
         
     | 
| 
      
 558 
     | 
    
         
            +
                    peg$c97 = /^[^}]/,
         
     | 
| 
      
 559 
     | 
    
         
            +
                    peg$c98 = "[^}]",
         
     | 
| 
      
 560 
     | 
    
         
            +
                    peg$c99 = function(text) {
         
     | 
| 
       559 
561 
     | 
    
         
             
                      // Force interpretation as mustache.
         
     | 
| 
       560 
562 
     | 
    
         
             
                      // TODO: change to just parse with a specific rule?
         
     | 
| 
       561 
563 
     | 
    
         
             
                      text = "=" + text;
         
     | 
| 
       562 
564 
     | 
    
         
             
                      return Emblem.parse(text).statements[0];
         
     | 
| 
       563 
565 
     | 
    
         
             
                    },
         
     | 
| 
       564 
     | 
    
         
            -
                    peg$ 
     | 
| 
       565 
     | 
    
         
            -
                    peg$ 
     | 
| 
       566 
     | 
    
         
            -
                    peg$ 
     | 
| 
       567 
     | 
    
         
            -
                    peg$ 
     | 
| 
       568 
     | 
    
         
            -
                    peg$ 
     | 
| 
       569 
     | 
    
         
            -
                    peg$ 
     | 
| 
       570 
     | 
    
         
            -
                    peg$ 
     | 
| 
       571 
     | 
    
         
            -
                    peg$ 
     | 
| 
       572 
     | 
    
         
            -
                    peg$ 
     | 
| 
       573 
     | 
    
         
            -
                    peg$ 
     | 
| 
       574 
     | 
    
         
            -
                    peg$ 
     | 
| 
       575 
     | 
    
         
            -
                    peg$ 
     | 
| 
       576 
     | 
    
         
            -
                    peg$ 
     | 
| 
       577 
     | 
    
         
            -
                    peg$ 
     | 
| 
       578 
     | 
    
         
            -
                    peg$ 
     | 
| 
       579 
     | 
    
         
            -
                    peg$ 
     | 
| 
       580 
     | 
    
         
            -
                    peg$ 
     | 
| 
       581 
     | 
    
         
            -
                    peg$ 
     | 
| 
       582 
     | 
    
         
            -
                    peg$ 
     | 
| 
       583 
     | 
    
         
            -
                    peg$ 
     | 
| 
       584 
     | 
    
         
            -
                    peg$ 
     | 
| 
       585 
     | 
    
         
            -
                    peg$ 
     | 
| 
       586 
     | 
    
         
            -
                    peg$ 
     | 
| 
       587 
     | 
    
         
            -
                    peg$ 
     | 
| 
       588 
     | 
    
         
            -
                    peg$ 
     | 
| 
       589 
     | 
    
         
            -
                    peg$ 
     | 
| 
       590 
     | 
    
         
            -
                    peg$ 
     | 
| 
       591 
     | 
    
         
            -
                    peg$ 
     | 
| 
       592 
     | 
    
         
            -
                    peg$ 
     | 
| 
       593 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 566 
     | 
    
         
            +
                    peg$c100 = function(m) { m.escaped = true; return m; },
         
     | 
| 
      
 567 
     | 
    
         
            +
                    peg$c101 = function(m) { m.escaped = false; return m; },
         
     | 
| 
      
 568 
     | 
    
         
            +
                    peg$c102 = function(a) { return new AST.ContentNode(a); },
         
     | 
| 
      
 569 
     | 
    
         
            +
                    peg$c103 = "any character",
         
     | 
| 
      
 570 
     | 
    
         
            +
                    peg$c104 = "SingleMustacheOpen",
         
     | 
| 
      
 571 
     | 
    
         
            +
                    peg$c105 = "DoubleMustacheOpen",
         
     | 
| 
      
 572 
     | 
    
         
            +
                    peg$c106 = "{{",
         
     | 
| 
      
 573 
     | 
    
         
            +
                    peg$c107 = "\"{{\"",
         
     | 
| 
      
 574 
     | 
    
         
            +
                    peg$c108 = "TripleMustacheOpen",
         
     | 
| 
      
 575 
     | 
    
         
            +
                    peg$c109 = "{{{",
         
     | 
| 
      
 576 
     | 
    
         
            +
                    peg$c110 = "\"{{{\"",
         
     | 
| 
      
 577 
     | 
    
         
            +
                    peg$c111 = "SingleMustacheClose",
         
     | 
| 
      
 578 
     | 
    
         
            +
                    peg$c112 = "}",
         
     | 
| 
      
 579 
     | 
    
         
            +
                    peg$c113 = "\"}\"",
         
     | 
| 
      
 580 
     | 
    
         
            +
                    peg$c114 = "DoubleMustacheClose",
         
     | 
| 
      
 581 
     | 
    
         
            +
                    peg$c115 = "}}",
         
     | 
| 
      
 582 
     | 
    
         
            +
                    peg$c116 = "\"}}\"",
         
     | 
| 
      
 583 
     | 
    
         
            +
                    peg$c117 = "TripleMustacheClose",
         
     | 
| 
      
 584 
     | 
    
         
            +
                    peg$c118 = "}}}",
         
     | 
| 
      
 585 
     | 
    
         
            +
                    peg$c119 = "\"}}}\"",
         
     | 
| 
      
 586 
     | 
    
         
            +
                    peg$c120 = "InterpolationOpen",
         
     | 
| 
      
 587 
     | 
    
         
            +
                    peg$c121 = "#{",
         
     | 
| 
      
 588 
     | 
    
         
            +
                    peg$c122 = "\"#{\"",
         
     | 
| 
      
 589 
     | 
    
         
            +
                    peg$c123 = "InterpolationClose",
         
     | 
| 
      
 590 
     | 
    
         
            +
                    peg$c124 = "==",
         
     | 
| 
      
 591 
     | 
    
         
            +
                    peg$c125 = "\"==\"",
         
     | 
| 
      
 592 
     | 
    
         
            +
                    peg$c126 = function() { return false; },
         
     | 
| 
      
 593 
     | 
    
         
            +
                    peg$c127 = function() { return true; },
         
     | 
| 
      
 594 
     | 
    
         
            +
                    peg$c128 = function(h, s) { return h || s; },
         
     | 
| 
      
 595 
     | 
    
         
            +
                    peg$c129 = function(h, inTagMustaches, fullAttributes) {
         
     | 
| 
       594 
596 
     | 
    
         
             
                      var tagName = h[0] || 'div',
         
     | 
| 
       595 
597 
     | 
    
         
             
                          shorthandAttributes = h[1] || [],
         
     | 
| 
       596 
598 
     | 
    
         
             
                          id = shorthandAttributes[0],
         
     | 
| 
         @@ -626,9 +628,9 @@ Emblem.Parser = (function() { 
     | 
|
| 
       626 
628 
     | 
    
         
             
                        return [tagOpenContent, new AST.ContentNode('</' + tagName + '>')];
         
     | 
| 
       627 
629 
     | 
    
         
             
                      }
         
     | 
| 
       628 
630 
     | 
    
         
             
                    },
         
     | 
| 
       629 
     | 
    
         
            -
                    peg$ 
     | 
| 
       630 
     | 
    
         
            -
                    peg$ 
     | 
| 
       631 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 631 
     | 
    
         
            +
                    peg$c130 = function(s) { return { shorthand: s, id: true}; },
         
     | 
| 
      
 632 
     | 
    
         
            +
                    peg$c131 = function(s) { return { shorthand: s }; },
         
     | 
| 
      
 633 
     | 
    
         
            +
                    peg$c132 = function(shorthands) {
         
     | 
| 
       632 
634 
     | 
    
         
             
                      var id, classes = [];
         
     | 
| 
       633 
635 
     | 
    
         
             
                      for(var i = 0, len = shorthands.length; i < len; ++i) {
         
     | 
| 
       634 
636 
     | 
    
         
             
                        var shorthand = shorthands[i];
         
     | 
| 
         @@ -641,28 +643,28 @@ Emblem.Parser = (function() { 
     | 
|
| 
       641 
643 
     | 
    
         | 
| 
       642 
644 
     | 
    
         
             
                      return [id, classes];
         
     | 
| 
       643 
645 
     | 
    
         
             
                    },
         
     | 
| 
       644 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 646 
     | 
    
         
            +
                    peg$c133 = function(a) {
         
     | 
| 
       645 
647 
     | 
    
         
             
                      return [new AST.ContentNode(' ')].concat(a); 
         
     | 
| 
       646 
648 
     | 
    
         
             
                    },
         
     | 
| 
       647 
     | 
    
         
            -
                    peg$ 
     | 
| 
       648 
     | 
    
         
            -
                    peg$ 
     | 
| 
       649 
     | 
    
         
            -
                    peg$ 
     | 
| 
       650 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 649 
     | 
    
         
            +
                    peg$c134 = /^[A-Za-z.0-9_\-]/,
         
     | 
| 
      
 650 
     | 
    
         
            +
                    peg$c135 = "[A-Za-z.0-9_\\-]",
         
     | 
| 
      
 651 
     | 
    
         
            +
                    peg$c136 = function(id) { return new AST.MustacheNode([id]); },
         
     | 
| 
      
 652 
     | 
    
         
            +
                    peg$c137 = function(event, mustacheNode) {
         
     | 
| 
       651 
653 
     | 
    
         
             
                      // Unshift the action helper and augment the hash
         
     | 
| 
       652 
654 
     | 
    
         
             
                      return [unshiftParam(mustacheNode, 'action', [['on', new AST.StringNode(event)]])];
         
     | 
| 
       653 
655 
     | 
    
         
             
                    },
         
     | 
| 
       654 
     | 
    
         
            -
                    peg$ 
     | 
| 
       655 
     | 
    
         
            -
                    peg$ 
     | 
| 
       656 
     | 
    
         
            -
                    peg$ 
     | 
| 
       657 
     | 
    
         
            -
                    peg$ 
     | 
| 
       658 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 656 
     | 
    
         
            +
                    peg$c138 = function(value) { return value.replace(/ *$/, ''); },
         
     | 
| 
      
 657 
     | 
    
         
            +
                    peg$c139 = "!",
         
     | 
| 
      
 658 
     | 
    
         
            +
                    peg$c140 = "\"!\"",
         
     | 
| 
      
 659 
     | 
    
         
            +
                    peg$c141 = function(key, value) { return IS_EMBER; },
         
     | 
| 
      
 660 
     | 
    
         
            +
                    peg$c142 = function(key, value) { 
         
     | 
| 
       659 
661 
     | 
    
         
             
                      var hashNode = new AST.HashNode([[key, new AST.StringNode(value)]]);
         
     | 
| 
       660 
662 
     | 
    
         
             
                      var params = [new AST.IdNode(['bindAttr'])];
         
     | 
| 
       661 
663 
     | 
    
         
             
                      var mustacheNode = new AST.MustacheNode(params, hashNode);
         
     | 
| 
       662 
664 
     | 
    
         | 
| 
       663 
665 
     | 
    
         
             
                      return [mustacheNode];
         
     | 
| 
       664 
666 
     | 
    
         
             
                    },
         
     | 
| 
       665 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 667 
     | 
    
         
            +
                    peg$c143 = function(key, id) { 
         
     | 
| 
       666 
668 
     | 
    
         
             
                      var mustacheNode = new AST.MustacheNode([id]);
         
     | 
| 
       667 
669 
     | 
    
         | 
| 
       668 
670 
     | 
    
         
             
                      if(IS_EMBER && id._emblemSuffixModifier === '!') {
         
     | 
| 
         @@ -675,31 +677,29 @@ Emblem.Parser = (function() { 
     | 
|
| 
       675 
677 
     | 
    
         
             
                        new AST.ContentNode('"'),
         
     | 
| 
       676 
678 
     | 
    
         
             
                      ];
         
     | 
| 
       677 
679 
     | 
    
         
             
                    },
         
     | 
| 
       678 
     | 
    
         
            -
                    peg$ 
     | 
| 
      
 680 
     | 
    
         
            +
                    peg$c144 = function(key, nodes) { 
         
     | 
| 
       679 
681 
     | 
    
         
             
                      var result = [ new AST.ContentNode(key + '=' + '"') ].concat(nodes);
         
     | 
| 
       680 
682 
     | 
    
         
             
                      return result.concat([new AST.ContentNode('"')]);
         
     | 
| 
       681 
683 
     | 
    
         
             
                    },
         
     | 
| 
       682 
     | 
    
         
            -
                    peg$ 
     | 
| 
       683 
     | 
    
         
            -
                    peg$ 
     | 
| 
       684 
     | 
    
         
            -
                    peg$ 
     | 
| 
       685 
     | 
    
         
            -
                    peg$ 
     | 
| 
       686 
     | 
    
         
            -
                    peg$ 
     | 
| 
       687 
     | 
    
         
            -
                    peg$ 
     | 
| 
       688 
     | 
    
         
            -
                    peg$ 
     | 
| 
       689 
     | 
    
         
            -
                    peg$ 
     | 
| 
       690 
     | 
    
         
            -
                    peg$ 
     | 
| 
       691 
     | 
    
         
            -
                    peg$ 
     | 
| 
       692 
     | 
    
         
            -
                    peg$ 
     | 
| 
       693 
     | 
    
         
            -
                    peg$ 
     | 
| 
       694 
     | 
    
         
            -
                    peg$ 
     | 
| 
       695 
     | 
    
         
            -
                    peg$ 
     | 
| 
       696 
     | 
    
         
            -
                    peg$ 
     | 
| 
       697 
     | 
    
         
            -
                    peg$ 
     | 
| 
       698 
     | 
    
         
            -
                    peg$ 
     | 
| 
       699 
     | 
    
         
            -
                    peg$ 
     | 
| 
       700 
     | 
    
         
            -
                    peg$ 
     | 
| 
       701 
     | 
    
         
            -
                    peg$c162 = ":",
         
     | 
| 
       702 
     | 
    
         
            -
                    peg$c163 = "\":\"",
         
     | 
| 
      
 684 
     | 
    
         
            +
                    peg$c145 = "_",
         
     | 
| 
      
 685 
     | 
    
         
            +
                    peg$c146 = "\"_\"",
         
     | 
| 
      
 686 
     | 
    
         
            +
                    peg$c147 = "-",
         
     | 
| 
      
 687 
     | 
    
         
            +
                    peg$c148 = "\"-\"",
         
     | 
| 
      
 688 
     | 
    
         
            +
                    peg$c149 = "%",
         
     | 
| 
      
 689 
     | 
    
         
            +
                    peg$c150 = "\"%\"",
         
     | 
| 
      
 690 
     | 
    
         
            +
                    peg$c151 = "#",
         
     | 
| 
      
 691 
     | 
    
         
            +
                    peg$c152 = "\"#\"",
         
     | 
| 
      
 692 
     | 
    
         
            +
                    peg$c153 = function(c) { return c;},
         
     | 
| 
      
 693 
     | 
    
         
            +
                    peg$c154 = "CSSIdentifier",
         
     | 
| 
      
 694 
     | 
    
         
            +
                    peg$c155 = /^[_a-zA-Z0-9\-]/,
         
     | 
| 
      
 695 
     | 
    
         
            +
                    peg$c156 = "[_a-zA-Z0-9\\-]",
         
     | 
| 
      
 696 
     | 
    
         
            +
                    peg$c157 = /^[_a-zA-Z]/,
         
     | 
| 
      
 697 
     | 
    
         
            +
                    peg$c158 = "[_a-zA-Z]",
         
     | 
| 
      
 698 
     | 
    
         
            +
                    peg$c159 = /^[\x80-\xFF]/,
         
     | 
| 
      
 699 
     | 
    
         
            +
                    peg$c160 = "[\\x80-\\xFF]",
         
     | 
| 
      
 700 
     | 
    
         
            +
                    peg$c161 = "KnownHTMLTagName",
         
     | 
| 
      
 701 
     | 
    
         
            +
                    peg$c162 = function(t) { return !!KNOWN_TAGS[t]; },
         
     | 
| 
      
 702 
     | 
    
         
            +
                    peg$c163 = function(t) { return t; },
         
     | 
| 
       703 
703 
     | 
    
         
             
                    peg$c164 = "a JS event",
         
     | 
| 
       704 
704 
     | 
    
         
             
                    peg$c165 = function(t) { return !!KNOWN_EVENTS[t]; },
         
     | 
| 
       705 
705 
     | 
    
         
             
                    peg$c166 = "INDENT",
         
     | 
| 
         @@ -2227,10 +2227,38 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2227 
2227 
     | 
    
         
             
                }
         
     | 
| 
       2228 
2228 
     | 
    
         | 
| 
       2229 
2229 
     | 
    
         
             
                function peg$parsekey() {
         
     | 
| 
       2230 
     | 
    
         
            -
                  var s0, s1;
         
     | 
| 
      
 2230 
     | 
    
         
            +
                  var s0, s1, s2;
         
     | 
| 
       2231 
2231 
     | 
    
         | 
| 
       2232 
2232 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       2233 
     | 
    
         
            -
                  s0 = peg$ 
     | 
| 
      
 2233 
     | 
    
         
            +
                  s0 = peg$currPos;
         
     | 
| 
      
 2234 
     | 
    
         
            +
                  s1 = [];
         
     | 
| 
      
 2235 
     | 
    
         
            +
                  s2 = peg$parsenmchar();
         
     | 
| 
      
 2236 
     | 
    
         
            +
                  if (s2 === null) {
         
     | 
| 
      
 2237 
     | 
    
         
            +
                    if (input.charCodeAt(peg$currPos) === 58) {
         
     | 
| 
      
 2238 
     | 
    
         
            +
                      s2 = peg$c54;
         
     | 
| 
      
 2239 
     | 
    
         
            +
                      peg$currPos++;
         
     | 
| 
      
 2240 
     | 
    
         
            +
                    } else {
         
     | 
| 
      
 2241 
     | 
    
         
            +
                      s2 = null;
         
     | 
| 
      
 2242 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c55); }
         
     | 
| 
      
 2243 
     | 
    
         
            +
                    }
         
     | 
| 
      
 2244 
     | 
    
         
            +
                  }
         
     | 
| 
      
 2245 
     | 
    
         
            +
                  while (s2 !== null) {
         
     | 
| 
      
 2246 
     | 
    
         
            +
                    s1.push(s2);
         
     | 
| 
      
 2247 
     | 
    
         
            +
                    s2 = peg$parsenmchar();
         
     | 
| 
      
 2248 
     | 
    
         
            +
                    if (s2 === null) {
         
     | 
| 
      
 2249 
     | 
    
         
            +
                      if (input.charCodeAt(peg$currPos) === 58) {
         
     | 
| 
      
 2250 
     | 
    
         
            +
                        s2 = peg$c54;
         
     | 
| 
      
 2251 
     | 
    
         
            +
                        peg$currPos++;
         
     | 
| 
      
 2252 
     | 
    
         
            +
                      } else {
         
     | 
| 
      
 2253 
     | 
    
         
            +
                        s2 = null;
         
     | 
| 
      
 2254 
     | 
    
         
            +
                        if (peg$silentFails === 0) { peg$fail(peg$c55); }
         
     | 
| 
      
 2255 
     | 
    
         
            +
                      }
         
     | 
| 
      
 2256 
     | 
    
         
            +
                    }
         
     | 
| 
      
 2257 
     | 
    
         
            +
                  }
         
     | 
| 
      
 2258 
     | 
    
         
            +
                  if (s1 !== null) {
         
     | 
| 
      
 2259 
     | 
    
         
            +
                    s1 = input.substring(s0, peg$currPos);
         
     | 
| 
      
 2260 
     | 
    
         
            +
                  }
         
     | 
| 
      
 2261 
     | 
    
         
            +
                  s0 = s1;
         
     | 
| 
       2234 
2262 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       2235 
2263 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       2236 
2264 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
         @@ -2362,7 +2390,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2362 
2390 
     | 
    
         
             
                    }
         
     | 
| 
       2363 
2391 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       2364 
2392 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       2365 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 2393 
     | 
    
         
            +
                      s1 = peg$c56(s2);
         
     | 
| 
       2366 
2394 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       2367 
2395 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       2368 
2396 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -2411,7 +2439,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2411 
2439 
     | 
    
         
             
                      s5 = peg$parsepathIdent();
         
     | 
| 
       2412 
2440 
     | 
    
         
             
                      if (s5 !== null) {
         
     | 
| 
       2413 
2441 
     | 
    
         
             
                        peg$reportedPos = s3;
         
     | 
| 
       2414 
     | 
    
         
            -
                        s4 = peg$ 
     | 
| 
      
 2442 
     | 
    
         
            +
                        s4 = peg$c57(s5);
         
     | 
| 
       2415 
2443 
     | 
    
         
             
                        if (s4 === null) {
         
     | 
| 
       2416 
2444 
     | 
    
         
             
                          peg$currPos = s3;
         
     | 
| 
       2417 
2445 
     | 
    
         
             
                          s3 = s4;
         
     | 
| 
         @@ -2434,7 +2462,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2434 
2462 
     | 
    
         
             
                        s5 = peg$parsepathIdent();
         
     | 
| 
       2435 
2463 
     | 
    
         
             
                        if (s5 !== null) {
         
     | 
| 
       2436 
2464 
     | 
    
         
             
                          peg$reportedPos = s3;
         
     | 
| 
       2437 
     | 
    
         
            -
                          s4 = peg$ 
     | 
| 
      
 2465 
     | 
    
         
            +
                          s4 = peg$c57(s5);
         
     | 
| 
       2438 
2466 
     | 
    
         
             
                          if (s4 === null) {
         
     | 
| 
       2439 
2467 
     | 
    
         
             
                            peg$currPos = s3;
         
     | 
| 
       2440 
2468 
     | 
    
         
             
                            s3 = s4;
         
     | 
| 
         @@ -2452,7 +2480,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2452 
2480 
     | 
    
         
             
                    }
         
     | 
| 
       2453 
2481 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       2454 
2482 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       2455 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 2483 
     | 
    
         
            +
                      s1 = peg$c58(s1,s2);
         
     | 
| 
       2456 
2484 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       2457 
2485 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       2458 
2486 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -2475,17 +2503,17 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2475 
2503 
     | 
    
         
             
                  var s0, s1;
         
     | 
| 
       2476 
2504 
     | 
    
         | 
| 
       2477 
2505 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       2478 
     | 
    
         
            -
                  if (peg$ 
     | 
| 
      
 2506 
     | 
    
         
            +
                  if (peg$c60.test(input.charAt(peg$currPos))) {
         
     | 
| 
       2479 
2507 
     | 
    
         
             
                    s0 = input.charAt(peg$currPos);
         
     | 
| 
       2480 
2508 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       2481 
2509 
     | 
    
         
             
                  } else {
         
     | 
| 
       2482 
2510 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       2483 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2511 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c61); }
         
     | 
| 
       2484 
2512 
     | 
    
         
             
                  }
         
     | 
| 
       2485 
2513 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       2486 
2514 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       2487 
2515 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       2488 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2516 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c59); }
         
     | 
| 
       2489 
2517 
     | 
    
         
             
                  }
         
     | 
| 
       2490 
2518 
     | 
    
         | 
| 
       2491 
2519 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -2498,7 +2526,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2498 
2526 
     | 
    
         
             
                  s1 = peg$parsepath();
         
     | 
| 
       2499 
2527 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       2500 
2528 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       2501 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 2529 
     | 
    
         
            +
                    s1 = peg$c62(s1);
         
     | 
| 
       2502 
2530 
     | 
    
         
             
                  }
         
     | 
| 
       2503 
2531 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       2504 
2532 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -2517,7 +2545,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2517 
2545 
     | 
    
         
             
                  s1 = peg$parsestring();
         
     | 
| 
       2518 
2546 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       2519 
2547 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       2520 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 2548 
     | 
    
         
            +
                    s1 = peg$c63(s1);
         
     | 
| 
       2521 
2549 
     | 
    
         
             
                  }
         
     | 
| 
       2522 
2550 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       2523 
2551 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -2536,7 +2564,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2536 
2564 
     | 
    
         
             
                  s1 = peg$parseinteger();
         
     | 
| 
       2537 
2565 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       2538 
2566 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       2539 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 2567 
     | 
    
         
            +
                    s1 = peg$c64(s1);
         
     | 
| 
       2540 
2568 
     | 
    
         
             
                  }
         
     | 
| 
       2541 
2569 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       2542 
2570 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -2555,7 +2583,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2555 
2583 
     | 
    
         
             
                  s1 = peg$parseboolean();
         
     | 
| 
       2556 
2584 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       2557 
2585 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       2558 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 2586 
     | 
    
         
            +
                    s1 = peg$c65(s1);
         
     | 
| 
       2559 
2587 
     | 
    
         
             
                  }
         
     | 
| 
       2560 
2588 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       2561 
2589 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -2571,26 +2599,26 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2571 
2599 
     | 
    
         
             
                  var s0, s1;
         
     | 
| 
       2572 
2600 
     | 
    
         | 
| 
       2573 
2601 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       2574 
     | 
    
         
            -
                  if (input.substr(peg$currPos, 4) === peg$ 
     | 
| 
       2575 
     | 
    
         
            -
                    s0 = peg$ 
     | 
| 
      
 2602 
     | 
    
         
            +
                  if (input.substr(peg$currPos, 4) === peg$c67) {
         
     | 
| 
      
 2603 
     | 
    
         
            +
                    s0 = peg$c67;
         
     | 
| 
       2576 
2604 
     | 
    
         
             
                    peg$currPos += 4;
         
     | 
| 
       2577 
2605 
     | 
    
         
             
                  } else {
         
     | 
| 
       2578 
2606 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       2579 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2607 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c68); }
         
     | 
| 
       2580 
2608 
     | 
    
         
             
                  }
         
     | 
| 
       2581 
2609 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       2582 
     | 
    
         
            -
                    if (input.substr(peg$currPos, 5) === peg$ 
     | 
| 
       2583 
     | 
    
         
            -
                      s0 = peg$ 
     | 
| 
      
 2610 
     | 
    
         
            +
                    if (input.substr(peg$currPos, 5) === peg$c69) {
         
     | 
| 
      
 2611 
     | 
    
         
            +
                      s0 = peg$c69;
         
     | 
| 
       2584 
2612 
     | 
    
         
             
                      peg$currPos += 5;
         
     | 
| 
       2585 
2613 
     | 
    
         
             
                    } else {
         
     | 
| 
       2586 
2614 
     | 
    
         
             
                      s0 = null;
         
     | 
| 
       2587 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2615 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c70); }
         
     | 
| 
       2588 
2616 
     | 
    
         
             
                    }
         
     | 
| 
       2589 
2617 
     | 
    
         
             
                  }
         
     | 
| 
       2590 
2618 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       2591 
2619 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       2592 
2620 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       2593 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2621 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c66); }
         
     | 
| 
       2594 
2622 
     | 
    
         
             
                  }
         
     | 
| 
       2595 
2623 
     | 
    
         | 
| 
       2596 
2624 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -2603,22 +2631,22 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2603 
2631 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       2604 
2632 
     | 
    
         
             
                  s1 = peg$currPos;
         
     | 
| 
       2605 
2633 
     | 
    
         
             
                  s2 = [];
         
     | 
| 
       2606 
     | 
    
         
            -
                  if (peg$ 
     | 
| 
      
 2634 
     | 
    
         
            +
                  if (peg$c72.test(input.charAt(peg$currPos))) {
         
     | 
| 
       2607 
2635 
     | 
    
         
             
                    s3 = input.charAt(peg$currPos);
         
     | 
| 
       2608 
2636 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       2609 
2637 
     | 
    
         
             
                  } else {
         
     | 
| 
       2610 
2638 
     | 
    
         
             
                    s3 = null;
         
     | 
| 
       2611 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2639 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c73); }
         
     | 
| 
       2612 
2640 
     | 
    
         
             
                  }
         
     | 
| 
       2613 
2641 
     | 
    
         
             
                  if (s3 !== null) {
         
     | 
| 
       2614 
2642 
     | 
    
         
             
                    while (s3 !== null) {
         
     | 
| 
       2615 
2643 
     | 
    
         
             
                      s2.push(s3);
         
     | 
| 
       2616 
     | 
    
         
            -
                      if (peg$ 
     | 
| 
      
 2644 
     | 
    
         
            +
                      if (peg$c72.test(input.charAt(peg$currPos))) {
         
     | 
| 
       2617 
2645 
     | 
    
         
             
                        s3 = input.charAt(peg$currPos);
         
     | 
| 
       2618 
2646 
     | 
    
         
             
                        peg$currPos++;
         
     | 
| 
       2619 
2647 
     | 
    
         
             
                      } else {
         
     | 
| 
       2620 
2648 
     | 
    
         
             
                        s3 = null;
         
     | 
| 
       2621 
     | 
    
         
            -
                        if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2649 
     | 
    
         
            +
                        if (peg$silentFails === 0) { peg$fail(peg$c73); }
         
     | 
| 
       2622 
2650 
     | 
    
         
             
                      }
         
     | 
| 
       2623 
2651 
     | 
    
         
             
                    }
         
     | 
| 
       2624 
2652 
     | 
    
         
             
                  } else {
         
     | 
| 
         @@ -2630,7 +2658,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2630 
2658 
     | 
    
         
             
                  s1 = s2;
         
     | 
| 
       2631 
2659 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       2632 
2660 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       2633 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 2661 
     | 
    
         
            +
                    s1 = peg$c74(s1);
         
     | 
| 
       2634 
2662 
     | 
    
         
             
                  }
         
     | 
| 
       2635 
2663 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       2636 
2664 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -2641,7 +2669,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2641 
2669 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       2642 
2670 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       2643 
2671 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       2644 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2672 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c71); }
         
     | 
| 
       2645 
2673 
     | 
    
         
             
                  }
         
     | 
| 
       2646 
2674 
     | 
    
         | 
| 
       2647 
2675 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -2653,21 +2681,21 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2653 
2681 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       2654 
2682 
     | 
    
         
             
                  s1 = peg$currPos;
         
     | 
| 
       2655 
2683 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 34) {
         
     | 
| 
       2656 
     | 
    
         
            -
                    s2 = peg$ 
     | 
| 
      
 2684 
     | 
    
         
            +
                    s2 = peg$c75;
         
     | 
| 
       2657 
2685 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       2658 
2686 
     | 
    
         
             
                  } else {
         
     | 
| 
       2659 
2687 
     | 
    
         
             
                    s2 = null;
         
     | 
| 
       2660 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2688 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c76); }
         
     | 
| 
       2661 
2689 
     | 
    
         
             
                  }
         
     | 
| 
       2662 
2690 
     | 
    
         
             
                  if (s2 !== null) {
         
     | 
| 
       2663 
2691 
     | 
    
         
             
                    s3 = peg$parsehashDoubleQuoteStringValue();
         
     | 
| 
       2664 
2692 
     | 
    
         
             
                    if (s3 !== null) {
         
     | 
| 
       2665 
2693 
     | 
    
         
             
                      if (input.charCodeAt(peg$currPos) === 34) {
         
     | 
| 
       2666 
     | 
    
         
            -
                        s4 = peg$ 
     | 
| 
      
 2694 
     | 
    
         
            +
                        s4 = peg$c75;
         
     | 
| 
       2667 
2695 
     | 
    
         
             
                        peg$currPos++;
         
     | 
| 
       2668 
2696 
     | 
    
         
             
                      } else {
         
     | 
| 
       2669 
2697 
     | 
    
         
             
                        s4 = null;
         
     | 
| 
       2670 
     | 
    
         
            -
                        if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2698 
     | 
    
         
            +
                        if (peg$silentFails === 0) { peg$fail(peg$c76); }
         
     | 
| 
       2671 
2699 
     | 
    
         
             
                      }
         
     | 
| 
       2672 
2700 
     | 
    
         
             
                      if (s4 !== null) {
         
     | 
| 
       2673 
2701 
     | 
    
         
             
                        s2 = [s2, s3, s4];
         
     | 
| 
         @@ -2687,21 +2715,21 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2687 
2715 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       2688 
2716 
     | 
    
         
             
                    s1 = peg$currPos;
         
     | 
| 
       2689 
2717 
     | 
    
         
             
                    if (input.charCodeAt(peg$currPos) === 39) {
         
     | 
| 
       2690 
     | 
    
         
            -
                      s2 = peg$ 
     | 
| 
      
 2718 
     | 
    
         
            +
                      s2 = peg$c77;
         
     | 
| 
       2691 
2719 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       2692 
2720 
     | 
    
         
             
                    } else {
         
     | 
| 
       2693 
2721 
     | 
    
         
             
                      s2 = null;
         
     | 
| 
       2694 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2722 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c78); }
         
     | 
| 
       2695 
2723 
     | 
    
         
             
                    }
         
     | 
| 
       2696 
2724 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       2697 
2725 
     | 
    
         
             
                      s3 = peg$parsehashSingleQuoteStringValue();
         
     | 
| 
       2698 
2726 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       2699 
2727 
     | 
    
         
             
                        if (input.charCodeAt(peg$currPos) === 39) {
         
     | 
| 
       2700 
     | 
    
         
            -
                          s4 = peg$ 
     | 
| 
      
 2728 
     | 
    
         
            +
                          s4 = peg$c77;
         
     | 
| 
       2701 
2729 
     | 
    
         
             
                          peg$currPos++;
         
     | 
| 
       2702 
2730 
     | 
    
         
             
                        } else {
         
     | 
| 
       2703 
2731 
     | 
    
         
             
                          s4 = null;
         
     | 
| 
       2704 
     | 
    
         
            -
                          if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2732 
     | 
    
         
            +
                          if (peg$silentFails === 0) { peg$fail(peg$c78); }
         
     | 
| 
       2705 
2733 
     | 
    
         
             
                        }
         
     | 
| 
       2706 
2734 
     | 
    
         
             
                        if (s4 !== null) {
         
     | 
| 
       2707 
2735 
     | 
    
         
             
                          s2 = [s2, s3, s4];
         
     | 
| 
         @@ -2721,7 +2749,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2721 
2749 
     | 
    
         
             
                  }
         
     | 
| 
       2722 
2750 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       2723 
2751 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       2724 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 2752 
     | 
    
         
            +
                    s1 = peg$c79(s1);
         
     | 
| 
       2725 
2753 
     | 
    
         
             
                  }
         
     | 
| 
       2726 
2754 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       2727 
2755 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -2750,12 +2778,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2750 
2778 
     | 
    
         
             
                    s3 = peg$c0;
         
     | 
| 
       2751 
2779 
     | 
    
         
             
                  }
         
     | 
| 
       2752 
2780 
     | 
    
         
             
                  if (s3 !== null) {
         
     | 
| 
       2753 
     | 
    
         
            -
                    if (peg$ 
     | 
| 
      
 2781 
     | 
    
         
            +
                    if (peg$c80.test(input.charAt(peg$currPos))) {
         
     | 
| 
       2754 
2782 
     | 
    
         
             
                      s4 = input.charAt(peg$currPos);
         
     | 
| 
       2755 
2783 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       2756 
2784 
     | 
    
         
             
                    } else {
         
     | 
| 
       2757 
2785 
     | 
    
         
             
                      s4 = null;
         
     | 
| 
       2758 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2786 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c81); }
         
     | 
| 
       2759 
2787 
     | 
    
         
             
                    }
         
     | 
| 
       2760 
2788 
     | 
    
         
             
                    if (s4 !== null) {
         
     | 
| 
       2761 
2789 
     | 
    
         
             
                      s3 = [s3, s4];
         
     | 
| 
         @@ -2782,12 +2810,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2782 
2810 
     | 
    
         
             
                      s3 = peg$c0;
         
     | 
| 
       2783 
2811 
     | 
    
         
             
                    }
         
     | 
| 
       2784 
2812 
     | 
    
         
             
                    if (s3 !== null) {
         
     | 
| 
       2785 
     | 
    
         
            -
                      if (peg$ 
     | 
| 
      
 2813 
     | 
    
         
            +
                      if (peg$c80.test(input.charAt(peg$currPos))) {
         
     | 
| 
       2786 
2814 
     | 
    
         
             
                        s4 = input.charAt(peg$currPos);
         
     | 
| 
       2787 
2815 
     | 
    
         
             
                        peg$currPos++;
         
     | 
| 
       2788 
2816 
     | 
    
         
             
                      } else {
         
     | 
| 
       2789 
2817 
     | 
    
         
             
                        s4 = null;
         
     | 
| 
       2790 
     | 
    
         
            -
                        if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2818 
     | 
    
         
            +
                        if (peg$silentFails === 0) { peg$fail(peg$c81); }
         
     | 
| 
       2791 
2819 
     | 
    
         
             
                      }
         
     | 
| 
       2792 
2820 
     | 
    
         
             
                      if (s4 !== null) {
         
     | 
| 
       2793 
2821 
     | 
    
         
             
                        s3 = [s3, s4];
         
     | 
| 
         @@ -2826,12 +2854,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2826 
2854 
     | 
    
         
             
                    s3 = peg$c0;
         
     | 
| 
       2827 
2855 
     | 
    
         
             
                  }
         
     | 
| 
       2828 
2856 
     | 
    
         
             
                  if (s3 !== null) {
         
     | 
| 
       2829 
     | 
    
         
            -
                    if (peg$ 
     | 
| 
      
 2857 
     | 
    
         
            +
                    if (peg$c82.test(input.charAt(peg$currPos))) {
         
     | 
| 
       2830 
2858 
     | 
    
         
             
                      s4 = input.charAt(peg$currPos);
         
     | 
| 
       2831 
2859 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       2832 
2860 
     | 
    
         
             
                    } else {
         
     | 
| 
       2833 
2861 
     | 
    
         
             
                      s4 = null;
         
     | 
| 
       2834 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2862 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c83); }
         
     | 
| 
       2835 
2863 
     | 
    
         
             
                    }
         
     | 
| 
       2836 
2864 
     | 
    
         
             
                    if (s4 !== null) {
         
     | 
| 
       2837 
2865 
     | 
    
         
             
                      s3 = [s3, s4];
         
     | 
| 
         @@ -2858,12 +2886,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2858 
2886 
     | 
    
         
             
                      s3 = peg$c0;
         
     | 
| 
       2859 
2887 
     | 
    
         
             
                    }
         
     | 
| 
       2860 
2888 
     | 
    
         
             
                    if (s3 !== null) {
         
     | 
| 
       2861 
     | 
    
         
            -
                      if (peg$ 
     | 
| 
      
 2889 
     | 
    
         
            +
                      if (peg$c82.test(input.charAt(peg$currPos))) {
         
     | 
| 
       2862 
2890 
     | 
    
         
             
                        s4 = input.charAt(peg$currPos);
         
     | 
| 
       2863 
2891 
     | 
    
         
             
                        peg$currPos++;
         
     | 
| 
       2864 
2892 
     | 
    
         
             
                      } else {
         
     | 
| 
       2865 
2893 
     | 
    
         
             
                        s4 = null;
         
     | 
| 
       2866 
     | 
    
         
            -
                        if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2894 
     | 
    
         
            +
                        if (peg$silentFails === 0) { peg$fail(peg$c83); }
         
     | 
| 
       2867 
2895 
     | 
    
         
             
                      }
         
     | 
| 
       2868 
2896 
     | 
    
         
             
                      if (s4 !== null) {
         
     | 
| 
       2869 
2897 
     | 
    
         
             
                        s3 = [s3, s4];
         
     | 
| 
         @@ -2888,12 +2916,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2888 
2916 
     | 
    
         
             
                function peg$parsealpha() {
         
     | 
| 
       2889 
2917 
     | 
    
         
             
                  var s0;
         
     | 
| 
       2890 
2918 
     | 
    
         | 
| 
       2891 
     | 
    
         
            -
                  if (peg$ 
     | 
| 
      
 2919 
     | 
    
         
            +
                  if (peg$c84.test(input.charAt(peg$currPos))) {
         
     | 
| 
       2892 
2920 
     | 
    
         
             
                    s0 = input.charAt(peg$currPos);
         
     | 
| 
       2893 
2921 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       2894 
2922 
     | 
    
         
             
                  } else {
         
     | 
| 
       2895 
2923 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       2896 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2924 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c85); }
         
     | 
| 
       2897 
2925 
     | 
    
         
             
                  }
         
     | 
| 
       2898 
2926 
     | 
    
         | 
| 
       2899 
2927 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -2917,7 +2945,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2917 
2945 
     | 
    
         
             
                        s4 = peg$parseanyDedent();
         
     | 
| 
       2918 
2946 
     | 
    
         
             
                        if (s4 !== null) {
         
     | 
| 
       2919 
2947 
     | 
    
         
             
                          peg$reportedPos = s0;
         
     | 
| 
       2920 
     | 
    
         
            -
                          s1 = peg$ 
     | 
| 
      
 2948 
     | 
    
         
            +
                          s1 = peg$c86(s1,s2,s3);
         
     | 
| 
       2921 
2949 
     | 
    
         
             
                          if (s1 === null) {
         
     | 
| 
       2922 
2950 
     | 
    
         
             
                            peg$currPos = s0;
         
     | 
| 
       2923 
2951 
     | 
    
         
             
                            s0 = s1;
         
     | 
| 
         @@ -2951,12 +2979,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2951 
2979 
     | 
    
         
             
                  var s0, s1, s2;
         
     | 
| 
       2952 
2980 
     | 
    
         | 
| 
       2953 
2981 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       2954 
     | 
    
         
            -
                  if (peg$ 
     | 
| 
      
 2982 
     | 
    
         
            +
                  if (peg$c87.test(input.charAt(peg$currPos))) {
         
     | 
| 
       2955 
2983 
     | 
    
         
             
                    s1 = input.charAt(peg$currPos);
         
     | 
| 
       2956 
2984 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       2957 
2985 
     | 
    
         
             
                  } else {
         
     | 
| 
       2958 
2986 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       2959 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 2987 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c88); }
         
     | 
| 
       2960 
2988 
     | 
    
         
             
                  }
         
     | 
| 
       2961 
2989 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       2962 
2990 
     | 
    
         
             
                    if (input.charCodeAt(peg$currPos) === 32) {
         
     | 
| 
         @@ -2991,11 +3019,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       2991 
3019 
     | 
    
         
             
                    s1 = peg$currPos;
         
     | 
| 
       2992 
3020 
     | 
    
         
             
                    peg$silentFails++;
         
     | 
| 
       2993 
3021 
     | 
    
         
             
                    if (input.charCodeAt(peg$currPos) === 60) {
         
     | 
| 
       2994 
     | 
    
         
            -
                      s2 = peg$ 
     | 
| 
      
 3022 
     | 
    
         
            +
                      s2 = peg$c89;
         
     | 
| 
       2995 
3023 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       2996 
3024 
     | 
    
         
             
                    } else {
         
     | 
| 
       2997 
3025 
     | 
    
         
             
                      s2 = null;
         
     | 
| 
       2998 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3026 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c90); }
         
     | 
| 
       2999 
3027 
     | 
    
         
             
                    }
         
     | 
| 
       3000 
3028 
     | 
    
         
             
                    peg$silentFails--;
         
     | 
| 
       3001 
3029 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
         @@ -3006,7 +3034,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3006 
3034 
     | 
    
         
             
                    }
         
     | 
| 
       3007 
3035 
     | 
    
         
             
                    if (s1 !== null) {
         
     | 
| 
       3008 
3036 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       3009 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 3037 
     | 
    
         
            +
                      s1 = peg$c91();
         
     | 
| 
       3010 
3038 
     | 
    
         
             
                    }
         
     | 
| 
       3011 
3039 
     | 
    
         
             
                    if (s1 === null) {
         
     | 
| 
       3012 
3040 
     | 
    
         
             
                      peg$currPos = s0;
         
     | 
| 
         @@ -3058,7 +3086,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3058 
3086 
     | 
    
         
             
                      }
         
     | 
| 
       3059 
3087 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       3060 
3088 
     | 
    
         
             
                        peg$reportedPos = s0;
         
     | 
| 
       3061 
     | 
    
         
            -
                        s1 = peg$ 
     | 
| 
      
 3089 
     | 
    
         
            +
                        s1 = peg$c92(s1,s2,s3);
         
     | 
| 
       3062 
3090 
     | 
    
         
             
                        if (s1 === null) {
         
     | 
| 
       3063 
3091 
     | 
    
         
             
                          peg$currPos = s0;
         
     | 
| 
       3064 
3092 
     | 
    
         
             
                          s0 = s1;
         
     | 
| 
         @@ -3134,7 +3162,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3134 
3162 
     | 
    
         
             
                      s3 = peg$parseTERM();
         
     | 
| 
       3135 
3163 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       3136 
3164 
     | 
    
         
             
                        peg$reportedPos = s0;
         
     | 
| 
       3137 
     | 
    
         
            -
                        s1 = peg$ 
     | 
| 
      
 3165 
     | 
    
         
            +
                        s1 = peg$c93(s1,s2);
         
     | 
| 
       3138 
3166 
     | 
    
         
             
                        if (s1 === null) {
         
     | 
| 
       3139 
3167 
     | 
    
         
             
                          peg$currPos = s0;
         
     | 
| 
       3140 
3168 
     | 
    
         
             
                          s0 = s1;
         
     | 
| 
         @@ -3162,21 +3190,21 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3162 
3190 
     | 
    
         | 
| 
       3163 
3191 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       3164 
3192 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 34) {
         
     | 
| 
       3165 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 3193 
     | 
    
         
            +
                    s1 = peg$c75;
         
     | 
| 
       3166 
3194 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       3167 
3195 
     | 
    
         
             
                  } else {
         
     | 
| 
       3168 
3196 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       3169 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3197 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c76); }
         
     | 
| 
       3170 
3198 
     | 
    
         
             
                  }
         
     | 
| 
       3171 
3199 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       3172 
3200 
     | 
    
         
             
                    s2 = peg$parseattributeTextNodesInner();
         
     | 
| 
       3173 
3201 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       3174 
3202 
     | 
    
         
             
                      if (input.charCodeAt(peg$currPos) === 34) {
         
     | 
| 
       3175 
     | 
    
         
            -
                        s3 = peg$ 
     | 
| 
      
 3203 
     | 
    
         
            +
                        s3 = peg$c75;
         
     | 
| 
       3176 
3204 
     | 
    
         
             
                        peg$currPos++;
         
     | 
| 
       3177 
3205 
     | 
    
         
             
                      } else {
         
     | 
| 
       3178 
3206 
     | 
    
         
             
                        s3 = null;
         
     | 
| 
       3179 
     | 
    
         
            -
                        if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3207 
     | 
    
         
            +
                        if (peg$silentFails === 0) { peg$fail(peg$c76); }
         
     | 
| 
       3180 
3208 
     | 
    
         
             
                      }
         
     | 
| 
       3181 
3209 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       3182 
3210 
     | 
    
         
             
                        peg$reportedPos = s0;
         
     | 
| 
         @@ -3202,21 +3230,21 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3202 
3230 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       3203 
3231 
     | 
    
         
             
                    s0 = peg$currPos;
         
     | 
| 
       3204 
3232 
     | 
    
         
             
                    if (input.charCodeAt(peg$currPos) === 39) {
         
     | 
| 
       3205 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 3233 
     | 
    
         
            +
                      s1 = peg$c77;
         
     | 
| 
       3206 
3234 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       3207 
3235 
     | 
    
         
             
                    } else {
         
     | 
| 
       3208 
3236 
     | 
    
         
             
                      s1 = null;
         
     | 
| 
       3209 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3237 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c78); }
         
     | 
| 
       3210 
3238 
     | 
    
         
             
                    }
         
     | 
| 
       3211 
3239 
     | 
    
         
             
                    if (s1 !== null) {
         
     | 
| 
       3212 
3240 
     | 
    
         
             
                      s2 = peg$parseattributeTextNodesInnerSingle();
         
     | 
| 
       3213 
3241 
     | 
    
         
             
                      if (s2 !== null) {
         
     | 
| 
       3214 
3242 
     | 
    
         
             
                        if (input.charCodeAt(peg$currPos) === 39) {
         
     | 
| 
       3215 
     | 
    
         
            -
                          s3 = peg$ 
     | 
| 
      
 3243 
     | 
    
         
            +
                          s3 = peg$c77;
         
     | 
| 
       3216 
3244 
     | 
    
         
             
                          peg$currPos++;
         
     | 
| 
       3217 
3245 
     | 
    
         
             
                        } else {
         
     | 
| 
       3218 
3246 
     | 
    
         
             
                          s3 = null;
         
     | 
| 
       3219 
     | 
    
         
            -
                          if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3247 
     | 
    
         
            +
                          if (peg$silentFails === 0) { peg$fail(peg$c78); }
         
     | 
| 
       3220 
3248 
     | 
    
         
             
                        }
         
     | 
| 
       3221 
3249 
     | 
    
         
             
                        if (s3 !== null) {
         
     | 
| 
       3222 
3250 
     | 
    
         
             
                          peg$reportedPos = s0;
         
     | 
| 
         @@ -3295,7 +3323,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3295 
3323 
     | 
    
         
             
                    }
         
     | 
| 
       3296 
3324 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       3297 
3325 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       3298 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 3326 
     | 
    
         
            +
                      s1 = peg$c94(s1,s2);
         
     | 
| 
       3299 
3327 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       3300 
3328 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       3301 
3329 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -3365,7 +3393,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3365 
3393 
     | 
    
         
             
                    }
         
     | 
| 
       3366 
3394 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       3367 
3395 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       3368 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 3396 
     | 
    
         
            +
                      s1 = peg$c94(s1,s2);
         
     | 
| 
       3369 
3397 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       3370 
3398 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       3371 
3399 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -3402,11 +3430,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3402 
3430 
     | 
    
         
             
                  s1 = peg$currPos;
         
     | 
| 
       3403 
3431 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       3404 
3432 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 123) {
         
     | 
| 
       3405 
     | 
    
         
            -
                    s2 = peg$ 
     | 
| 
      
 3433 
     | 
    
         
            +
                    s2 = peg$c95;
         
     | 
| 
       3406 
3434 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       3407 
3435 
     | 
    
         
             
                  } else {
         
     | 
| 
       3408 
3436 
     | 
    
         
             
                    s2 = null;
         
     | 
| 
       3409 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3437 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c96); }
         
     | 
| 
       3410 
3438 
     | 
    
         
             
                  }
         
     | 
| 
       3411 
3439 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       3412 
3440 
     | 
    
         
             
                  if (s2 === null) {
         
     | 
| 
         @@ -3418,21 +3446,21 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3418 
3446 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       3419 
3447 
     | 
    
         
             
                    s2 = peg$currPos;
         
     | 
| 
       3420 
3448 
     | 
    
         
             
                    s3 = [];
         
     | 
| 
       3421 
     | 
    
         
            -
                    if (peg$ 
     | 
| 
      
 3449 
     | 
    
         
            +
                    if (peg$c97.test(input.charAt(peg$currPos))) {
         
     | 
| 
       3422 
3450 
     | 
    
         
             
                      s4 = input.charAt(peg$currPos);
         
     | 
| 
       3423 
3451 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       3424 
3452 
     | 
    
         
             
                    } else {
         
     | 
| 
       3425 
3453 
     | 
    
         
             
                      s4 = null;
         
     | 
| 
       3426 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3454 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c98); }
         
     | 
| 
       3427 
3455 
     | 
    
         
             
                    }
         
     | 
| 
       3428 
3456 
     | 
    
         
             
                    while (s4 !== null) {
         
     | 
| 
       3429 
3457 
     | 
    
         
             
                      s3.push(s4);
         
     | 
| 
       3430 
     | 
    
         
            -
                      if (peg$ 
     | 
| 
      
 3458 
     | 
    
         
            +
                      if (peg$c97.test(input.charAt(peg$currPos))) {
         
     | 
| 
       3431 
3459 
     | 
    
         
             
                        s4 = input.charAt(peg$currPos);
         
     | 
| 
       3432 
3460 
     | 
    
         
             
                        peg$currPos++;
         
     | 
| 
       3433 
3461 
     | 
    
         
             
                      } else {
         
     | 
| 
       3434 
3462 
     | 
    
         
             
                        s4 = null;
         
     | 
| 
       3435 
     | 
    
         
            -
                        if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3463 
     | 
    
         
            +
                        if (peg$silentFails === 0) { peg$fail(peg$c98); }
         
     | 
| 
       3436 
3464 
     | 
    
         
             
                      }
         
     | 
| 
       3437 
3465 
     | 
    
         
             
                    }
         
     | 
| 
       3438 
3466 
     | 
    
         
             
                    if (s3 !== null) {
         
     | 
| 
         @@ -3441,7 +3469,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3441 
3469 
     | 
    
         
             
                    s2 = s3;
         
     | 
| 
       3442 
3470 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       3443 
3471 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       3444 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 3472 
     | 
    
         
            +
                      s1 = peg$c99(s2);
         
     | 
| 
       3445 
3473 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       3446 
3474 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       3447 
3475 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -3475,7 +3503,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3475 
3503 
     | 
    
         
             
                          s5 = peg$parsedoubleClose();
         
     | 
| 
       3476 
3504 
     | 
    
         
             
                          if (s5 !== null) {
         
     | 
| 
       3477 
3505 
     | 
    
         
             
                            peg$reportedPos = s0;
         
     | 
| 
       3478 
     | 
    
         
            -
                            s1 = peg$ 
     | 
| 
      
 3506 
     | 
    
         
            +
                            s1 = peg$c100(s3);
         
     | 
| 
       3479 
3507 
     | 
    
         
             
                            if (s1 === null) {
         
     | 
| 
       3480 
3508 
     | 
    
         
             
                              peg$currPos = s0;
         
     | 
| 
       3481 
3509 
     | 
    
         
             
                              s0 = s1;
         
     | 
| 
         @@ -3515,7 +3543,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3515 
3543 
     | 
    
         
             
                            s5 = peg$parsehashStacheClose();
         
     | 
| 
       3516 
3544 
     | 
    
         
             
                            if (s5 !== null) {
         
     | 
| 
       3517 
3545 
     | 
    
         
             
                              peg$reportedPos = s0;
         
     | 
| 
       3518 
     | 
    
         
            -
                              s1 = peg$ 
     | 
| 
      
 3546 
     | 
    
         
            +
                              s1 = peg$c100(s3);
         
     | 
| 
       3519 
3547 
     | 
    
         
             
                              if (s1 === null) {
         
     | 
| 
       3520 
3548 
     | 
    
         
             
                                peg$currPos = s0;
         
     | 
| 
       3521 
3549 
     | 
    
         
             
                                s0 = s1;
         
     | 
| 
         @@ -3562,7 +3590,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3562 
3590 
     | 
    
         
             
                          s5 = peg$parsetripleClose();
         
     | 
| 
       3563 
3591 
     | 
    
         
             
                          if (s5 !== null) {
         
     | 
| 
       3564 
3592 
     | 
    
         
             
                            peg$reportedPos = s0;
         
     | 
| 
       3565 
     | 
    
         
            -
                            s1 = peg$ 
     | 
| 
      
 3593 
     | 
    
         
            +
                            s1 = peg$c101(s3);
         
     | 
| 
       3566 
3594 
     | 
    
         
             
                            if (s1 === null) {
         
     | 
| 
       3567 
3595 
     | 
    
         
             
                              peg$currPos = s0;
         
     | 
| 
       3568 
3596 
     | 
    
         
             
                              s0 = s1;
         
     | 
| 
         @@ -3614,7 +3642,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3614 
3642 
     | 
    
         
             
                  s1 = s2;
         
     | 
| 
       3615 
3643 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       3616 
3644 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       3617 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 3645 
     | 
    
         
            +
                    s1 = peg$c102(s1);
         
     | 
| 
       3618 
3646 
     | 
    
         
             
                  }
         
     | 
| 
       3619 
3647 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       3620 
3648 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -3647,7 +3675,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3647 
3675 
     | 
    
         
             
                  s1 = s2;
         
     | 
| 
       3648 
3676 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       3649 
3677 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       3650 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 3678 
     | 
    
         
            +
                    s1 = peg$c102(s1);
         
     | 
| 
       3651 
3679 
     | 
    
         
             
                  }
         
     | 
| 
       3652 
3680 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       3653 
3681 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -3668,11 +3696,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3668 
3696 
     | 
    
         
             
                  s2 = peg$parsenonMustacheUnit();
         
     | 
| 
       3669 
3697 
     | 
    
         
             
                  if (s2 === null) {
         
     | 
| 
       3670 
3698 
     | 
    
         
             
                    if (input.charCodeAt(peg$currPos) === 34) {
         
     | 
| 
       3671 
     | 
    
         
            -
                      s2 = peg$ 
     | 
| 
      
 3699 
     | 
    
         
            +
                      s2 = peg$c75;
         
     | 
| 
       3672 
3700 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       3673 
3701 
     | 
    
         
             
                    } else {
         
     | 
| 
       3674 
3702 
     | 
    
         
             
                      s2 = null;
         
     | 
| 
       3675 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3703 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c76); }
         
     | 
| 
       3676 
3704 
     | 
    
         
             
                    }
         
     | 
| 
       3677 
3705 
     | 
    
         
             
                  }
         
     | 
| 
       3678 
3706 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
         @@ -3688,7 +3716,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3688 
3716 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       3689 
3717 
     | 
    
         
             
                    } else {
         
     | 
| 
       3690 
3718 
     | 
    
         
             
                      s2 = null;
         
     | 
| 
       3691 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3719 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c103); }
         
     | 
| 
       3692 
3720 
     | 
    
         
             
                    }
         
     | 
| 
       3693 
3721 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       3694 
3722 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
         @@ -3720,11 +3748,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3720 
3748 
     | 
    
         
             
                  s2 = peg$parsenonMustacheUnit();
         
     | 
| 
       3721 
3749 
     | 
    
         
             
                  if (s2 === null) {
         
     | 
| 
       3722 
3750 
     | 
    
         
             
                    if (input.charCodeAt(peg$currPos) === 39) {
         
     | 
| 
       3723 
     | 
    
         
            -
                      s2 = peg$ 
     | 
| 
      
 3751 
     | 
    
         
            +
                      s2 = peg$c77;
         
     | 
| 
       3724 
3752 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       3725 
3753 
     | 
    
         
             
                    } else {
         
     | 
| 
       3726 
3754 
     | 
    
         
             
                      s2 = null;
         
     | 
| 
       3727 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3755 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c78); }
         
     | 
| 
       3728 
3756 
     | 
    
         
             
                    }
         
     | 
| 
       3729 
3757 
     | 
    
         
             
                  }
         
     | 
| 
       3730 
3758 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
         @@ -3740,7 +3768,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3740 
3768 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       3741 
3769 
     | 
    
         
             
                    } else {
         
     | 
| 
       3742 
3770 
     | 
    
         
             
                      s2 = null;
         
     | 
| 
       3743 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3771 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c103); }
         
     | 
| 
       3744 
3772 
     | 
    
         
             
                    }
         
     | 
| 
       3745 
3773 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       3746 
3774 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
         @@ -3784,7 +3812,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3784 
3812 
     | 
    
         
             
                  s1 = s2;
         
     | 
| 
       3785 
3813 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       3786 
3814 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       3787 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 3815 
     | 
    
         
            +
                    s1 = peg$c102(s1);
         
     | 
| 
       3788 
3816 
     | 
    
         
             
                  }
         
     | 
| 
       3789 
3817 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       3790 
3818 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -3816,7 +3844,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3816 
3844 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       3817 
3845 
     | 
    
         
             
                    } else {
         
     | 
| 
       3818 
3846 
     | 
    
         
             
                      s2 = null;
         
     | 
| 
       3819 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3847 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c103); }
         
     | 
| 
       3820 
3848 
     | 
    
         
             
                    }
         
     | 
| 
       3821 
3849 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       3822 
3850 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
         @@ -3874,7 +3902,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3874 
3902 
     | 
    
         
             
                          s5 = peg$parsesingleClose();
         
     | 
| 
       3875 
3903 
     | 
    
         
             
                          if (s5 !== null) {
         
     | 
| 
       3876 
3904 
     | 
    
         
             
                            peg$reportedPos = s0;
         
     | 
| 
       3877 
     | 
    
         
            -
                            s1 = peg$ 
     | 
| 
      
 3905 
     | 
    
         
            +
                            s1 = peg$c100(s3);
         
     | 
| 
       3878 
3906 
     | 
    
         
             
                            if (s1 === null) {
         
     | 
| 
       3879 
3907 
     | 
    
         
             
                              peg$currPos = s0;
         
     | 
| 
       3880 
3908 
     | 
    
         
             
                              s0 = s1;
         
     | 
| 
         @@ -3924,16 +3952,16 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3924 
3952 
     | 
    
         | 
| 
       3925 
3953 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       3926 
3954 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 123) {
         
     | 
| 
       3927 
     | 
    
         
            -
                    s0 = peg$ 
     | 
| 
      
 3955 
     | 
    
         
            +
                    s0 = peg$c95;
         
     | 
| 
       3928 
3956 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       3929 
3957 
     | 
    
         
             
                  } else {
         
     | 
| 
       3930 
3958 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       3931 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3959 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c96); }
         
     | 
| 
       3932 
3960 
     | 
    
         
             
                  }
         
     | 
| 
       3933 
3961 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       3934 
3962 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       3935 
3963 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       3936 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3964 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c104); }
         
     | 
| 
       3937 
3965 
     | 
    
         
             
                  }
         
     | 
| 
       3938 
3966 
     | 
    
         | 
| 
       3939 
3967 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -3943,17 +3971,17 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3943 
3971 
     | 
    
         
             
                  var s0, s1;
         
     | 
| 
       3944 
3972 
     | 
    
         | 
| 
       3945 
3973 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       3946 
     | 
    
         
            -
                  if (input.substr(peg$currPos, 2) === peg$ 
     | 
| 
       3947 
     | 
    
         
            -
                    s0 = peg$ 
     | 
| 
      
 3974 
     | 
    
         
            +
                  if (input.substr(peg$currPos, 2) === peg$c106) {
         
     | 
| 
      
 3975 
     | 
    
         
            +
                    s0 = peg$c106;
         
     | 
| 
       3948 
3976 
     | 
    
         
             
                    peg$currPos += 2;
         
     | 
| 
       3949 
3977 
     | 
    
         
             
                  } else {
         
     | 
| 
       3950 
3978 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       3951 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3979 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c107); }
         
     | 
| 
       3952 
3980 
     | 
    
         
             
                  }
         
     | 
| 
       3953 
3981 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       3954 
3982 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       3955 
3983 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       3956 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3984 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c105); }
         
     | 
| 
       3957 
3985 
     | 
    
         
             
                  }
         
     | 
| 
       3958 
3986 
     | 
    
         | 
| 
       3959 
3987 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -3963,17 +3991,17 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3963 
3991 
     | 
    
         
             
                  var s0, s1;
         
     | 
| 
       3964 
3992 
     | 
    
         | 
| 
       3965 
3993 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       3966 
     | 
    
         
            -
                  if (input.substr(peg$currPos, 3) === peg$ 
     | 
| 
       3967 
     | 
    
         
            -
                    s0 = peg$ 
     | 
| 
      
 3994 
     | 
    
         
            +
                  if (input.substr(peg$currPos, 3) === peg$c109) {
         
     | 
| 
      
 3995 
     | 
    
         
            +
                    s0 = peg$c109;
         
     | 
| 
       3968 
3996 
     | 
    
         
             
                    peg$currPos += 3;
         
     | 
| 
       3969 
3997 
     | 
    
         
             
                  } else {
         
     | 
| 
       3970 
3998 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       3971 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 3999 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c110); }
         
     | 
| 
       3972 
4000 
     | 
    
         
             
                  }
         
     | 
| 
       3973 
4001 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       3974 
4002 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       3975 
4003 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       3976 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4004 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c108); }
         
     | 
| 
       3977 
4005 
     | 
    
         
             
                  }
         
     | 
| 
       3978 
4006 
     | 
    
         | 
| 
       3979 
4007 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -3984,16 +4012,16 @@ Emblem.Parser = (function() { 
     | 
|
| 
       3984 
4012 
     | 
    
         | 
| 
       3985 
4013 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       3986 
4014 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 125) {
         
     | 
| 
       3987 
     | 
    
         
            -
                    s0 = peg$ 
     | 
| 
      
 4015 
     | 
    
         
            +
                    s0 = peg$c112;
         
     | 
| 
       3988 
4016 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       3989 
4017 
     | 
    
         
             
                  } else {
         
     | 
| 
       3990 
4018 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       3991 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4019 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c113); }
         
     | 
| 
       3992 
4020 
     | 
    
         
             
                  }
         
     | 
| 
       3993 
4021 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       3994 
4022 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       3995 
4023 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       3996 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4024 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c111); }
         
     | 
| 
       3997 
4025 
     | 
    
         
             
                  }
         
     | 
| 
       3998 
4026 
     | 
    
         | 
| 
       3999 
4027 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -4003,17 +4031,17 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4003 
4031 
     | 
    
         
             
                  var s0, s1;
         
     | 
| 
       4004 
4032 
     | 
    
         | 
| 
       4005 
4033 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       4006 
     | 
    
         
            -
                  if (input.substr(peg$currPos, 2) === peg$ 
     | 
| 
       4007 
     | 
    
         
            -
                    s0 = peg$ 
     | 
| 
      
 4034 
     | 
    
         
            +
                  if (input.substr(peg$currPos, 2) === peg$c115) {
         
     | 
| 
      
 4035 
     | 
    
         
            +
                    s0 = peg$c115;
         
     | 
| 
       4008 
4036 
     | 
    
         
             
                    peg$currPos += 2;
         
     | 
| 
       4009 
4037 
     | 
    
         
             
                  } else {
         
     | 
| 
       4010 
4038 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       4011 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4039 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c116); }
         
     | 
| 
       4012 
4040 
     | 
    
         
             
                  }
         
     | 
| 
       4013 
4041 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       4014 
4042 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       4015 
4043 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       4016 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4044 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c114); }
         
     | 
| 
       4017 
4045 
     | 
    
         
             
                  }
         
     | 
| 
       4018 
4046 
     | 
    
         | 
| 
       4019 
4047 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -4023,17 +4051,17 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4023 
4051 
     | 
    
         
             
                  var s0, s1;
         
     | 
| 
       4024 
4052 
     | 
    
         | 
| 
       4025 
4053 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       4026 
     | 
    
         
            -
                  if (input.substr(peg$currPos, 3) === peg$ 
     | 
| 
       4027 
     | 
    
         
            -
                    s0 = peg$ 
     | 
| 
      
 4054 
     | 
    
         
            +
                  if (input.substr(peg$currPos, 3) === peg$c118) {
         
     | 
| 
      
 4055 
     | 
    
         
            +
                    s0 = peg$c118;
         
     | 
| 
       4028 
4056 
     | 
    
         
             
                    peg$currPos += 3;
         
     | 
| 
       4029 
4057 
     | 
    
         
             
                  } else {
         
     | 
| 
       4030 
4058 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       4031 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4059 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c119); }
         
     | 
| 
       4032 
4060 
     | 
    
         
             
                  }
         
     | 
| 
       4033 
4061 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       4034 
4062 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       4035 
4063 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       4036 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4064 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c117); }
         
     | 
| 
       4037 
4065 
     | 
    
         
             
                  }
         
     | 
| 
       4038 
4066 
     | 
    
         | 
| 
       4039 
4067 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -4043,17 +4071,17 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4043 
4071 
     | 
    
         
             
                  var s0, s1;
         
     | 
| 
       4044 
4072 
     | 
    
         | 
| 
       4045 
4073 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       4046 
     | 
    
         
            -
                  if (input.substr(peg$currPos, 2) === peg$ 
     | 
| 
       4047 
     | 
    
         
            -
                    s0 = peg$ 
     | 
| 
      
 4074 
     | 
    
         
            +
                  if (input.substr(peg$currPos, 2) === peg$c121) {
         
     | 
| 
      
 4075 
     | 
    
         
            +
                    s0 = peg$c121;
         
     | 
| 
       4048 
4076 
     | 
    
         
             
                    peg$currPos += 2;
         
     | 
| 
       4049 
4077 
     | 
    
         
             
                  } else {
         
     | 
| 
       4050 
4078 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       4051 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4079 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c122); }
         
     | 
| 
       4052 
4080 
     | 
    
         
             
                  }
         
     | 
| 
       4053 
4081 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       4054 
4082 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       4055 
4083 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       4056 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4084 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c120); }
         
     | 
| 
       4057 
4085 
     | 
    
         
             
                  }
         
     | 
| 
       4058 
4086 
     | 
    
         | 
| 
       4059 
4087 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -4064,16 +4092,16 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4064 
4092 
     | 
    
         | 
| 
       4065 
4093 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       4066 
4094 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 125) {
         
     | 
| 
       4067 
     | 
    
         
            -
                    s0 = peg$ 
     | 
| 
      
 4095 
     | 
    
         
            +
                    s0 = peg$c112;
         
     | 
| 
       4068 
4096 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       4069 
4097 
     | 
    
         
             
                  } else {
         
     | 
| 
       4070 
4098 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       4071 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4099 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c113); }
         
     | 
| 
       4072 
4100 
     | 
    
         
             
                  }
         
     | 
| 
       4073 
4101 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       4074 
4102 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       4075 
4103 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       4076 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4104 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c123); }
         
     | 
| 
       4077 
4105 
     | 
    
         
             
                  }
         
     | 
| 
       4078 
4106 
     | 
    
         | 
| 
       4079 
4107 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -4083,12 +4111,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4083 
4111 
     | 
    
         
             
                  var s0, s1, s2;
         
     | 
| 
       4084 
4112 
     | 
    
         | 
| 
       4085 
4113 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       4086 
     | 
    
         
            -
                  if (input.substr(peg$currPos, 2) === peg$ 
     | 
| 
       4087 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 4114 
     | 
    
         
            +
                  if (input.substr(peg$currPos, 2) === peg$c124) {
         
     | 
| 
      
 4115 
     | 
    
         
            +
                    s1 = peg$c124;
         
     | 
| 
       4088 
4116 
     | 
    
         
             
                    peg$currPos += 2;
         
     | 
| 
       4089 
4117 
     | 
    
         
             
                  } else {
         
     | 
| 
       4090 
4118 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       4091 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4119 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c125); }
         
     | 
| 
       4092 
4120 
     | 
    
         
             
                  }
         
     | 
| 
       4093 
4121 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       4094 
4122 
     | 
    
         
             
                    if (input.charCodeAt(peg$currPos) === 32) {
         
     | 
| 
         @@ -4103,7 +4131,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4103 
4131 
     | 
    
         
             
                    }
         
     | 
| 
       4104 
4132 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       4105 
4133 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       4106 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 4134 
     | 
    
         
            +
                      s1 = peg$c126();
         
     | 
| 
       4107 
4135 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       4108 
4136 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       4109 
4137 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -4140,7 +4168,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4140 
4168 
     | 
    
         
             
                      }
         
     | 
| 
       4141 
4169 
     | 
    
         
             
                      if (s2 !== null) {
         
     | 
| 
       4142 
4170 
     | 
    
         
             
                        peg$reportedPos = s0;
         
     | 
| 
       4143 
     | 
    
         
            -
                        s1 = peg$ 
     | 
| 
      
 4171 
     | 
    
         
            +
                        s1 = peg$c127();
         
     | 
| 
       4144 
4172 
     | 
    
         
             
                        if (s1 === null) {
         
     | 
| 
       4145 
4173 
     | 
    
         
             
                          peg$currPos = s0;
         
     | 
| 
       4146 
4174 
     | 
    
         
             
                          s0 = s1;
         
     | 
| 
         @@ -4186,7 +4214,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4186 
4214 
     | 
    
         
             
                      }
         
     | 
| 
       4187 
4215 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       4188 
4216 
     | 
    
         
             
                        peg$reportedPos = peg$currPos;
         
     | 
| 
       4189 
     | 
    
         
            -
                        s4 = peg$ 
     | 
| 
      
 4217 
     | 
    
         
            +
                        s4 = peg$c128(s1,s2);
         
     | 
| 
       4190 
4218 
     | 
    
         
             
                        if (s4) {
         
     | 
| 
       4191 
4219 
     | 
    
         
             
                          s4 = peg$c1;
         
     | 
| 
       4192 
4220 
     | 
    
         
             
                        } else {
         
     | 
| 
         @@ -4236,7 +4264,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4236 
4264 
     | 
    
         
             
                      }
         
     | 
| 
       4237 
4265 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       4238 
4266 
     | 
    
         
             
                        peg$reportedPos = s0;
         
     | 
| 
       4239 
     | 
    
         
            -
                        s1 = peg$ 
     | 
| 
      
 4267 
     | 
    
         
            +
                        s1 = peg$c129(s1,s2,s3);
         
     | 
| 
       4240 
4268 
     | 
    
         
             
                        if (s1 === null) {
         
     | 
| 
       4241 
4269 
     | 
    
         
             
                          peg$currPos = s0;
         
     | 
| 
       4242 
4270 
     | 
    
         
             
                          s0 = s1;
         
     | 
| 
         @@ -4268,7 +4296,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4268 
4296 
     | 
    
         
             
                  s3 = peg$parseidShorthand();
         
     | 
| 
       4269 
4297 
     | 
    
         
             
                  if (s3 !== null) {
         
     | 
| 
       4270 
4298 
     | 
    
         
             
                    peg$reportedPos = s2;
         
     | 
| 
       4271 
     | 
    
         
            -
                    s3 = peg$ 
     | 
| 
      
 4299 
     | 
    
         
            +
                    s3 = peg$c130(s3);
         
     | 
| 
       4272 
4300 
     | 
    
         
             
                  }
         
     | 
| 
       4273 
4301 
     | 
    
         
             
                  if (s3 === null) {
         
     | 
| 
       4274 
4302 
     | 
    
         
             
                    peg$currPos = s2;
         
     | 
| 
         @@ -4281,7 +4309,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4281 
4309 
     | 
    
         
             
                    s3 = peg$parseclassShorthand();
         
     | 
| 
       4282 
4310 
     | 
    
         
             
                    if (s3 !== null) {
         
     | 
| 
       4283 
4311 
     | 
    
         
             
                      peg$reportedPos = s2;
         
     | 
| 
       4284 
     | 
    
         
            -
                      s3 = peg$ 
     | 
| 
      
 4312 
     | 
    
         
            +
                      s3 = peg$c131(s3);
         
     | 
| 
       4285 
4313 
     | 
    
         
             
                    }
         
     | 
| 
       4286 
4314 
     | 
    
         
             
                    if (s3 === null) {
         
     | 
| 
       4287 
4315 
     | 
    
         
             
                      peg$currPos = s2;
         
     | 
| 
         @@ -4297,7 +4325,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4297 
4325 
     | 
    
         
             
                      s3 = peg$parseidShorthand();
         
     | 
| 
       4298 
4326 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       4299 
4327 
     | 
    
         
             
                        peg$reportedPos = s2;
         
     | 
| 
       4300 
     | 
    
         
            -
                        s3 = peg$ 
     | 
| 
      
 4328 
     | 
    
         
            +
                        s3 = peg$c130(s3);
         
     | 
| 
       4301 
4329 
     | 
    
         
             
                      }
         
     | 
| 
       4302 
4330 
     | 
    
         
             
                      if (s3 === null) {
         
     | 
| 
       4303 
4331 
     | 
    
         
             
                        peg$currPos = s2;
         
     | 
| 
         @@ -4310,7 +4338,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4310 
4338 
     | 
    
         
             
                        s3 = peg$parseclassShorthand();
         
     | 
| 
       4311 
4339 
     | 
    
         
             
                        if (s3 !== null) {
         
     | 
| 
       4312 
4340 
     | 
    
         
             
                          peg$reportedPos = s2;
         
     | 
| 
       4313 
     | 
    
         
            -
                          s3 = peg$ 
     | 
| 
      
 4341 
     | 
    
         
            +
                          s3 = peg$c131(s3);
         
     | 
| 
       4314 
4342 
     | 
    
         
             
                        }
         
     | 
| 
       4315 
4343 
     | 
    
         
             
                        if (s3 === null) {
         
     | 
| 
       4316 
4344 
     | 
    
         
             
                          peg$currPos = s2;
         
     | 
| 
         @@ -4325,7 +4353,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4325 
4353 
     | 
    
         
             
                  }
         
     | 
| 
       4326 
4354 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       4327 
4355 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       4328 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 4356 
     | 
    
         
            +
                    s1 = peg$c132(s1);
         
     | 
| 
       4329 
4357 
     | 
    
         
             
                  }
         
     | 
| 
       4330 
4358 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       4331 
4359 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -4376,7 +4404,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4376 
4404 
     | 
    
         
             
                    }
         
     | 
| 
       4377 
4405 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       4378 
4406 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       4379 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 4407 
     | 
    
         
            +
                      s1 = peg$c133(s2);
         
     | 
| 
       4380 
4408 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       4381 
4409 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       4382 
4410 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -4398,12 +4426,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4398 
4426 
     | 
    
         
             
                function peg$parseboundAttributeValueChar() {
         
     | 
| 
       4399 
4427 
     | 
    
         
             
                  var s0;
         
     | 
| 
       4400 
4428 
     | 
    
         | 
| 
       4401 
     | 
    
         
            -
                  if (peg$ 
     | 
| 
      
 4429 
     | 
    
         
            +
                  if (peg$c134.test(input.charAt(peg$currPos))) {
         
     | 
| 
       4402 
4430 
     | 
    
         
             
                    s0 = input.charAt(peg$currPos);
         
     | 
| 
       4403 
4431 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       4404 
4432 
     | 
    
         
             
                  } else {
         
     | 
| 
       4405 
4433 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       4406 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4434 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c135); }
         
     | 
| 
       4407 
4435 
     | 
    
         
             
                  }
         
     | 
| 
       4408 
4436 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       4409 
4437 
     | 
    
         
             
                    s0 = peg$parsenonSeparatorColon();
         
     | 
| 
         @@ -4421,7 +4449,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4421 
4449 
     | 
    
         
             
                    s1 = peg$parsepathIdNode();
         
     | 
| 
       4422 
4450 
     | 
    
         
             
                    if (s1 !== null) {
         
     | 
| 
       4423 
4451 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       4424 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 4452 
     | 
    
         
            +
                      s1 = peg$c136(s1);
         
     | 
| 
       4425 
4453 
     | 
    
         
             
                    }
         
     | 
| 
       4426 
4454 
     | 
    
         
             
                    if (s1 === null) {
         
     | 
| 
       4427 
4455 
     | 
    
         
             
                      peg$currPos = s0;
         
     | 
| 
         @@ -4440,21 +4468,21 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4440 
4468 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       4441 
4469 
     | 
    
         
             
                  s1 = peg$currPos;
         
     | 
| 
       4442 
4470 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 34) {
         
     | 
| 
       4443 
     | 
    
         
            -
                    s2 = peg$ 
     | 
| 
      
 4471 
     | 
    
         
            +
                    s2 = peg$c75;
         
     | 
| 
       4444 
4472 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       4445 
4473 
     | 
    
         
             
                  } else {
         
     | 
| 
       4446 
4474 
     | 
    
         
             
                    s2 = null;
         
     | 
| 
       4447 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4475 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c76); }
         
     | 
| 
       4448 
4476 
     | 
    
         
             
                  }
         
     | 
| 
       4449 
4477 
     | 
    
         
             
                  if (s2 !== null) {
         
     | 
| 
       4450 
4478 
     | 
    
         
             
                    s3 = peg$parseinMustache();
         
     | 
| 
       4451 
4479 
     | 
    
         
             
                    if (s3 !== null) {
         
     | 
| 
       4452 
4480 
     | 
    
         
             
                      if (input.charCodeAt(peg$currPos) === 34) {
         
     | 
| 
       4453 
     | 
    
         
            -
                        s4 = peg$ 
     | 
| 
      
 4481 
     | 
    
         
            +
                        s4 = peg$c75;
         
     | 
| 
       4454 
4482 
     | 
    
         
             
                        peg$currPos++;
         
     | 
| 
       4455 
4483 
     | 
    
         
             
                      } else {
         
     | 
| 
       4456 
4484 
     | 
    
         
             
                        s4 = null;
         
     | 
| 
       4457 
     | 
    
         
            -
                        if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4485 
     | 
    
         
            +
                        if (peg$silentFails === 0) { peg$fail(peg$c76); }
         
     | 
| 
       4458 
4486 
     | 
    
         
             
                      }
         
     | 
| 
       4459 
4487 
     | 
    
         
             
                      if (s4 !== null) {
         
     | 
| 
       4460 
4488 
     | 
    
         
             
                        s2 = [s2, s3, s4];
         
     | 
| 
         @@ -4474,21 +4502,21 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4474 
4502 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       4475 
4503 
     | 
    
         
             
                    s1 = peg$currPos;
         
     | 
| 
       4476 
4504 
     | 
    
         
             
                    if (input.charCodeAt(peg$currPos) === 39) {
         
     | 
| 
       4477 
     | 
    
         
            -
                      s2 = peg$ 
     | 
| 
      
 4505 
     | 
    
         
            +
                      s2 = peg$c77;
         
     | 
| 
       4478 
4506 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       4479 
4507 
     | 
    
         
             
                    } else {
         
     | 
| 
       4480 
4508 
     | 
    
         
             
                      s2 = null;
         
     | 
| 
       4481 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4509 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c78); }
         
     | 
| 
       4482 
4510 
     | 
    
         
             
                    }
         
     | 
| 
       4483 
4511 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       4484 
4512 
     | 
    
         
             
                      s3 = peg$parseinMustache();
         
     | 
| 
       4485 
4513 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       4486 
4514 
     | 
    
         
             
                        if (input.charCodeAt(peg$currPos) === 39) {
         
     | 
| 
       4487 
     | 
    
         
            -
                          s4 = peg$ 
     | 
| 
      
 4515 
     | 
    
         
            +
                          s4 = peg$c77;
         
     | 
| 
       4488 
4516 
     | 
    
         
             
                          peg$currPos++;
         
     | 
| 
       4489 
4517 
     | 
    
         
             
                        } else {
         
     | 
| 
       4490 
4518 
     | 
    
         
             
                          s4 = null;
         
     | 
| 
       4491 
     | 
    
         
            -
                          if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4519 
     | 
    
         
            +
                          if (peg$silentFails === 0) { peg$fail(peg$c78); }
         
     | 
| 
       4492 
4520 
     | 
    
         
             
                        }
         
     | 
| 
       4493 
4521 
     | 
    
         
             
                        if (s4 !== null) {
         
     | 
| 
       4494 
4522 
     | 
    
         
             
                          s2 = [s2, s3, s4];
         
     | 
| 
         @@ -4508,7 +4536,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4508 
4536 
     | 
    
         
             
                  }
         
     | 
| 
       4509 
4537 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       4510 
4538 
     | 
    
         
             
                    peg$reportedPos = s0;
         
     | 
| 
       4511 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 4539 
     | 
    
         
            +
                    s1 = peg$c79(s1);
         
     | 
| 
       4512 
4540 
     | 
    
         
             
                  }
         
     | 
| 
       4513 
4541 
     | 
    
         
             
                  if (s1 === null) {
         
     | 
| 
       4514 
4542 
     | 
    
         
             
                    peg$currPos = s0;
         
     | 
| 
         @@ -4537,7 +4565,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4537 
4565 
     | 
    
         
             
                      s3 = peg$parseactionValue();
         
     | 
| 
       4538 
4566 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       4539 
4567 
     | 
    
         
             
                        peg$reportedPos = s0;
         
     | 
| 
       4540 
     | 
    
         
            -
                        s1 = peg$ 
     | 
| 
      
 4568 
     | 
    
         
            +
                        s1 = peg$c137(s1,s3);
         
     | 
| 
       4541 
4569 
     | 
    
         
             
                        if (s1 === null) {
         
     | 
| 
       4542 
4570 
     | 
    
         
             
                          peg$currPos = s0;
         
     | 
| 
       4543 
4571 
     | 
    
         
             
                          s0 = s1;
         
     | 
| 
         @@ -4565,11 +4593,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4565 
4593 
     | 
    
         | 
| 
       4566 
4594 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       4567 
4595 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 123) {
         
     | 
| 
       4568 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 4596 
     | 
    
         
            +
                    s1 = peg$c95;
         
     | 
| 
       4569 
4597 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       4570 
4598 
     | 
    
         
             
                  } else {
         
     | 
| 
       4571 
4599 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       4572 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4600 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c96); }
         
     | 
| 
       4573 
4601 
     | 
    
         
             
                  }
         
     | 
| 
       4574 
4602 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       4575 
4603 
     | 
    
         
             
                    s2 = peg$parse_();
         
     | 
| 
         @@ -4611,15 +4639,15 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4611 
4639 
     | 
    
         
             
                        s4 = peg$parse_();
         
     | 
| 
       4612 
4640 
     | 
    
         
             
                        if (s4 !== null) {
         
     | 
| 
       4613 
4641 
     | 
    
         
             
                          if (input.charCodeAt(peg$currPos) === 125) {
         
     | 
| 
       4614 
     | 
    
         
            -
                            s5 = peg$ 
     | 
| 
      
 4642 
     | 
    
         
            +
                            s5 = peg$c112;
         
     | 
| 
       4615 
4643 
     | 
    
         
             
                            peg$currPos++;
         
     | 
| 
       4616 
4644 
     | 
    
         
             
                          } else {
         
     | 
| 
       4617 
4645 
     | 
    
         
             
                            s5 = null;
         
     | 
| 
       4618 
     | 
    
         
            -
                            if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4646 
     | 
    
         
            +
                            if (peg$silentFails === 0) { peg$fail(peg$c113); }
         
     | 
| 
       4619 
4647 
     | 
    
         
             
                          }
         
     | 
| 
       4620 
4648 
     | 
    
         
             
                          if (s5 !== null) {
         
     | 
| 
       4621 
4649 
     | 
    
         
             
                            peg$reportedPos = s0;
         
     | 
| 
       4622 
     | 
    
         
            -
                            s1 = peg$ 
     | 
| 
      
 4650 
     | 
    
         
            +
                            s1 = peg$c138(s3);
         
     | 
| 
       4623 
4651 
     | 
    
         
             
                            if (s1 === null) {
         
     | 
| 
       4624 
4652 
     | 
    
         
             
                              peg$currPos = s0;
         
     | 
| 
       4625 
4653 
     | 
    
         
             
                              s0 = s1;
         
     | 
| 
         @@ -4686,11 +4714,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4686 
4714 
     | 
    
         
             
                        s4 = peg$currPos;
         
     | 
| 
       4687 
4715 
     | 
    
         
             
                        peg$silentFails++;
         
     | 
| 
       4688 
4716 
     | 
    
         
             
                        if (input.charCodeAt(peg$currPos) === 33) {
         
     | 
| 
       4689 
     | 
    
         
            -
                          s5 = peg$ 
     | 
| 
      
 4717 
     | 
    
         
            +
                          s5 = peg$c139;
         
     | 
| 
       4690 
4718 
     | 
    
         
             
                          peg$currPos++;
         
     | 
| 
       4691 
4719 
     | 
    
         
             
                        } else {
         
     | 
| 
       4692 
4720 
     | 
    
         
             
                          s5 = null;
         
     | 
| 
       4693 
     | 
    
         
            -
                          if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4721 
     | 
    
         
            +
                          if (peg$silentFails === 0) { peg$fail(peg$c140); }
         
     | 
| 
       4694 
4722 
     | 
    
         
             
                        }
         
     | 
| 
       4695 
4723 
     | 
    
         
             
                        peg$silentFails--;
         
     | 
| 
       4696 
4724 
     | 
    
         
             
                        if (s5 === null) {
         
     | 
| 
         @@ -4701,7 +4729,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4701 
4729 
     | 
    
         
             
                        }
         
     | 
| 
       4702 
4730 
     | 
    
         
             
                        if (s4 !== null) {
         
     | 
| 
       4703 
4731 
     | 
    
         
             
                          peg$reportedPos = peg$currPos;
         
     | 
| 
       4704 
     | 
    
         
            -
                          s5 = peg$ 
     | 
| 
      
 4732 
     | 
    
         
            +
                          s5 = peg$c141(s1,s3);
         
     | 
| 
       4705 
4733 
     | 
    
         
             
                          if (s5) {
         
     | 
| 
       4706 
4734 
     | 
    
         
             
                            s5 = peg$c1;
         
     | 
| 
       4707 
4735 
     | 
    
         
             
                          } else {
         
     | 
| 
         @@ -4709,7 +4737,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4709 
4737 
     | 
    
         
             
                          }
         
     | 
| 
       4710 
4738 
     | 
    
         
             
                          if (s5 !== null) {
         
     | 
| 
       4711 
4739 
     | 
    
         
             
                            peg$reportedPos = s0;
         
     | 
| 
       4712 
     | 
    
         
            -
                            s1 = peg$ 
     | 
| 
      
 4740 
     | 
    
         
            +
                            s1 = peg$c142(s1,s3);
         
     | 
| 
       4713 
4741 
     | 
    
         
             
                            if (s1 === null) {
         
     | 
| 
       4714 
4742 
     | 
    
         
             
                              peg$currPos = s0;
         
     | 
| 
       4715 
4743 
     | 
    
         
             
                              s0 = s1;
         
     | 
| 
         @@ -4757,7 +4785,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4757 
4785 
     | 
    
         
             
                      s3 = peg$parsepathIdNode();
         
     | 
| 
       4758 
4786 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       4759 
4787 
     | 
    
         
             
                        peg$reportedPos = s0;
         
     | 
| 
       4760 
     | 
    
         
            -
                        s1 = peg$ 
     | 
| 
      
 4788 
     | 
    
         
            +
                        s1 = peg$c143(s1,s3);
         
     | 
| 
       4761 
4789 
     | 
    
         
             
                        if (s1 === null) {
         
     | 
| 
       4762 
4790 
     | 
    
         
             
                          peg$currPos = s0;
         
     | 
| 
       4763 
4791 
     | 
    
         
             
                          s0 = s1;
         
     | 
| 
         @@ -4797,7 +4825,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4797 
4825 
     | 
    
         
             
                      s3 = peg$parseattributeTextNodes();
         
     | 
| 
       4798 
4826 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       4799 
4827 
     | 
    
         
             
                        peg$reportedPos = s0;
         
     | 
| 
       4800 
     | 
    
         
            -
                        s1 = peg$ 
     | 
| 
      
 4828 
     | 
    
         
            +
                        s1 = peg$c144(s1,s3);
         
     | 
| 
       4801 
4829 
     | 
    
         
             
                        if (s1 === null) {
         
     | 
| 
       4802 
4830 
     | 
    
         
             
                          peg$currPos = s0;
         
     | 
| 
       4803 
4831 
     | 
    
         
             
                          s0 = s1;
         
     | 
| 
         @@ -4854,28 +4882,28 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4854 
4882 
     | 
    
         | 
| 
       4855 
4883 
     | 
    
         
             
                  s0 = peg$parsealpha();
         
     | 
| 
       4856 
4884 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       4857 
     | 
    
         
            -
                    if (peg$ 
     | 
| 
      
 4885 
     | 
    
         
            +
                    if (peg$c72.test(input.charAt(peg$currPos))) {
         
     | 
| 
       4858 
4886 
     | 
    
         
             
                      s0 = input.charAt(peg$currPos);
         
     | 
| 
       4859 
4887 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       4860 
4888 
     | 
    
         
             
                    } else {
         
     | 
| 
       4861 
4889 
     | 
    
         
             
                      s0 = null;
         
     | 
| 
       4862 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4890 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c73); }
         
     | 
| 
       4863 
4891 
     | 
    
         
             
                    }
         
     | 
| 
       4864 
4892 
     | 
    
         
             
                    if (s0 === null) {
         
     | 
| 
       4865 
4893 
     | 
    
         
             
                      if (input.charCodeAt(peg$currPos) === 95) {
         
     | 
| 
       4866 
     | 
    
         
            -
                        s0 = peg$ 
     | 
| 
      
 4894 
     | 
    
         
            +
                        s0 = peg$c145;
         
     | 
| 
       4867 
4895 
     | 
    
         
             
                        peg$currPos++;
         
     | 
| 
       4868 
4896 
     | 
    
         
             
                      } else {
         
     | 
| 
       4869 
4897 
     | 
    
         
             
                        s0 = null;
         
     | 
| 
       4870 
     | 
    
         
            -
                        if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4898 
     | 
    
         
            +
                        if (peg$silentFails === 0) { peg$fail(peg$c146); }
         
     | 
| 
       4871 
4899 
     | 
    
         
             
                      }
         
     | 
| 
       4872 
4900 
     | 
    
         
             
                      if (s0 === null) {
         
     | 
| 
       4873 
4901 
     | 
    
         
             
                        if (input.charCodeAt(peg$currPos) === 45) {
         
     | 
| 
       4874 
     | 
    
         
            -
                          s0 = peg$ 
     | 
| 
      
 4902 
     | 
    
         
            +
                          s0 = peg$c147;
         
     | 
| 
       4875 
4903 
     | 
    
         
             
                          peg$currPos++;
         
     | 
| 
       4876 
4904 
     | 
    
         
             
                        } else {
         
     | 
| 
       4877 
4905 
     | 
    
         
             
                          s0 = null;
         
     | 
| 
       4878 
     | 
    
         
            -
                          if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4906 
     | 
    
         
            +
                          if (peg$silentFails === 0) { peg$fail(peg$c148); }
         
     | 
| 
       4879 
4907 
     | 
    
         
             
                        }
         
     | 
| 
       4880 
4908 
     | 
    
         
             
                      }
         
     | 
| 
       4881 
4909 
     | 
    
         
             
                    }
         
     | 
| 
         @@ -4889,11 +4917,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4889 
4917 
     | 
    
         | 
| 
       4890 
4918 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       4891 
4919 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 37) {
         
     | 
| 
       4892 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 4920 
     | 
    
         
            +
                    s1 = peg$c149;
         
     | 
| 
       4893 
4921 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       4894 
4922 
     | 
    
         
             
                  } else {
         
     | 
| 
       4895 
4923 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       4896 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4924 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c150); }
         
     | 
| 
       4897 
4925 
     | 
    
         
             
                  }
         
     | 
| 
       4898 
4926 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       4899 
4927 
     | 
    
         
             
                    s2 = peg$parsecssIdentifier();
         
     | 
| 
         @@ -4923,17 +4951,17 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4923 
4951 
     | 
    
         | 
| 
       4924 
4952 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       4925 
4953 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 35) {
         
     | 
| 
       4926 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 4954 
     | 
    
         
            +
                    s1 = peg$c151;
         
     | 
| 
       4927 
4955 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       4928 
4956 
     | 
    
         
             
                  } else {
         
     | 
| 
       4929 
4957 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       4930 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 4958 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c152); }
         
     | 
| 
       4931 
4959 
     | 
    
         
             
                  }
         
     | 
| 
       4932 
4960 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       4933 
4961 
     | 
    
         
             
                    s2 = peg$parsecssIdentifier();
         
     | 
| 
       4934 
4962 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       4935 
4963 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       4936 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 4964 
     | 
    
         
            +
                      s1 = peg$c153(s2);
         
     | 
| 
       4937 
4965 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       4938 
4966 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       4939 
4967 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -4994,7 +5022,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       4994 
5022 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       4995 
5023 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       4996 
5024 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       4997 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 5025 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c154); }
         
     | 
| 
       4998 
5026 
     | 
    
         
             
                  }
         
     | 
| 
       4999 
5027 
     | 
    
         | 
| 
       5000 
5028 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -5021,12 +5049,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5021 
5049 
     | 
    
         
             
                function peg$parsenmchar() {
         
     | 
| 
       5022 
5050 
     | 
    
         
             
                  var s0;
         
     | 
| 
       5023 
5051 
     | 
    
         | 
| 
       5024 
     | 
    
         
            -
                  if (peg$ 
     | 
| 
      
 5052 
     | 
    
         
            +
                  if (peg$c155.test(input.charAt(peg$currPos))) {
         
     | 
| 
       5025 
5053 
     | 
    
         
             
                    s0 = input.charAt(peg$currPos);
         
     | 
| 
       5026 
5054 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       5027 
5055 
     | 
    
         
             
                  } else {
         
     | 
| 
       5028 
5056 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       5029 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 5057 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c156); }
         
     | 
| 
       5030 
5058 
     | 
    
         
             
                  }
         
     | 
| 
       5031 
5059 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       5032 
5060 
     | 
    
         
             
                    s0 = peg$parsenonascii();
         
     | 
| 
         @@ -5038,12 +5066,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5038 
5066 
     | 
    
         
             
                function peg$parsenmstart() {
         
     | 
| 
       5039 
5067 
     | 
    
         
             
                  var s0;
         
     | 
| 
       5040 
5068 
     | 
    
         | 
| 
       5041 
     | 
    
         
            -
                  if (peg$ 
     | 
| 
      
 5069 
     | 
    
         
            +
                  if (peg$c157.test(input.charAt(peg$currPos))) {
         
     | 
| 
       5042 
5070 
     | 
    
         
             
                    s0 = input.charAt(peg$currPos);
         
     | 
| 
       5043 
5071 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       5044 
5072 
     | 
    
         
             
                  } else {
         
     | 
| 
       5045 
5073 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       5046 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 5074 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c158); }
         
     | 
| 
       5047 
5075 
     | 
    
         
             
                  }
         
     | 
| 
       5048 
5076 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       5049 
5077 
     | 
    
         
             
                    s0 = peg$parsenonascii();
         
     | 
| 
         @@ -5055,12 +5083,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5055 
5083 
     | 
    
         
             
                function peg$parsenonascii() {
         
     | 
| 
       5056 
5084 
     | 
    
         
             
                  var s0;
         
     | 
| 
       5057 
5085 
     | 
    
         | 
| 
       5058 
     | 
    
         
            -
                  if (peg$ 
     | 
| 
      
 5086 
     | 
    
         
            +
                  if (peg$c159.test(input.charAt(peg$currPos))) {
         
     | 
| 
       5059 
5087 
     | 
    
         
             
                    s0 = input.charAt(peg$currPos);
         
     | 
| 
       5060 
5088 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       5061 
5089 
     | 
    
         
             
                  } else {
         
     | 
| 
       5062 
5090 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       5063 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 5091 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c160); }
         
     | 
| 
       5064 
5092 
     | 
    
         
             
                  }
         
     | 
| 
       5065 
5093 
     | 
    
         | 
| 
       5066 
5094 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -5094,11 +5122,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5094 
5122 
     | 
    
         
             
                  peg$silentFails++;
         
     | 
| 
       5095 
5123 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       5096 
5124 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 37) {
         
     | 
| 
       5097 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 5125 
     | 
    
         
            +
                    s1 = peg$c149;
         
     | 
| 
       5098 
5126 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       5099 
5127 
     | 
    
         
             
                  } else {
         
     | 
| 
       5100 
5128 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       5101 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 5129 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c150); }
         
     | 
| 
       5102 
5130 
     | 
    
         
             
                  }
         
     | 
| 
       5103 
5131 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       5104 
5132 
     | 
    
         
             
                    s2 = peg$parse_();
         
     | 
| 
         @@ -5131,7 +5159,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5131 
5159 
     | 
    
         
             
                  peg$silentFails--;
         
     | 
| 
       5132 
5160 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       5133 
5161 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       5134 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 5162 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c161); }
         
     | 
| 
       5135 
5163 
     | 
    
         
             
                  }
         
     | 
| 
       5136 
5164 
     | 
    
         | 
| 
       5137 
5165 
     | 
    
         
             
                  return s0;
         
     | 
| 
         @@ -5144,7 +5172,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5144 
5172 
     | 
    
         
             
                  s1 = peg$parsetagString();
         
     | 
| 
       5145 
5173 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       5146 
5174 
     | 
    
         
             
                    peg$reportedPos = peg$currPos;
         
     | 
| 
       5147 
     | 
    
         
            -
                    s2 = peg$ 
     | 
| 
      
 5175 
     | 
    
         
            +
                    s2 = peg$c162(s1);
         
     | 
| 
       5148 
5176 
     | 
    
         
             
                    if (s2) {
         
     | 
| 
       5149 
5177 
     | 
    
         
             
                      s2 = peg$c1;
         
     | 
| 
       5150 
5178 
     | 
    
         
             
                    } else {
         
     | 
| 
         @@ -5152,7 +5180,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5152 
5180 
     | 
    
         
             
                    }
         
     | 
| 
       5153 
5181 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       5154 
5182 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       5155 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 5183 
     | 
    
         
            +
                      s1 = peg$c163(s1);
         
     | 
| 
       5156 
5184 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       5157 
5185 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       5158 
5186 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -5174,12 +5202,12 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5174 
5202 
     | 
    
         
             
                function peg$parsetagChar() {
         
     | 
| 
       5175 
5203 
     | 
    
         
             
                  var s0;
         
     | 
| 
       5176 
5204 
     | 
    
         | 
| 
       5177 
     | 
    
         
            -
                  if (peg$ 
     | 
| 
      
 5205 
     | 
    
         
            +
                  if (peg$c155.test(input.charAt(peg$currPos))) {
         
     | 
| 
       5178 
5206 
     | 
    
         
             
                    s0 = input.charAt(peg$currPos);
         
     | 
| 
       5179 
5207 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       5180 
5208 
     | 
    
         
             
                  } else {
         
     | 
| 
       5181 
5209 
     | 
    
         
             
                    s0 = null;
         
     | 
| 
       5182 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 5210 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c156); }
         
     | 
| 
       5183 
5211 
     | 
    
         
             
                  }
         
     | 
| 
       5184 
5212 
     | 
    
         
             
                  if (s0 === null) {
         
     | 
| 
       5185 
5213 
     | 
    
         
             
                    s0 = peg$parsenonSeparatorColon();
         
     | 
| 
         @@ -5193,11 +5221,11 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5193 
5221 
     | 
    
         | 
| 
       5194 
5222 
     | 
    
         
             
                  s0 = peg$currPos;
         
     | 
| 
       5195 
5223 
     | 
    
         
             
                  if (input.charCodeAt(peg$currPos) === 58) {
         
     | 
| 
       5196 
     | 
    
         
            -
                    s1 = peg$ 
     | 
| 
      
 5224 
     | 
    
         
            +
                    s1 = peg$c54;
         
     | 
| 
       5197 
5225 
     | 
    
         
             
                    peg$currPos++;
         
     | 
| 
       5198 
5226 
     | 
    
         
             
                  } else {
         
     | 
| 
       5199 
5227 
     | 
    
         
             
                    s1 = null;
         
     | 
| 
       5200 
     | 
    
         
            -
                    if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 5228 
     | 
    
         
            +
                    if (peg$silentFails === 0) { peg$fail(peg$c55); }
         
     | 
| 
       5201 
5229 
     | 
    
         
             
                  }
         
     | 
| 
       5202 
5230 
     | 
    
         
             
                  if (s1 !== null) {
         
     | 
| 
       5203 
5231 
     | 
    
         
             
                    s2 = peg$currPos;
         
     | 
| 
         @@ -5253,7 +5281,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5253 
5281 
     | 
    
         
             
                    }
         
     | 
| 
       5254 
5282 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       5255 
5283 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     | 
| 
       5256 
     | 
    
         
            -
                      s1 = peg$ 
     | 
| 
      
 5284 
     | 
    
         
            +
                      s1 = peg$c163(s1);
         
     | 
| 
       5257 
5285 
     | 
    
         
             
                      if (s1 === null) {
         
     | 
| 
       5258 
5286 
     | 
    
         
             
                        peg$currPos = s0;
         
     | 
| 
       5259 
5287 
     | 
    
         
             
                        s0 = s1;
         
     | 
| 
         @@ -5431,7 +5459,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5431 
5459 
     | 
    
         
             
                      }
         
     | 
| 
       5432 
5460 
     | 
    
         
             
                      if (s3 !== null) {
         
     | 
| 
       5433 
5461 
     | 
    
         
             
                        peg$reportedPos = s0;
         
     | 
| 
       5434 
     | 
    
         
            -
                        s1 = peg$ 
     | 
| 
      
 5462 
     | 
    
         
            +
                        s1 = peg$c126();
         
     | 
| 
       5435 
5463 
     | 
    
         
             
                        if (s1 === null) {
         
     | 
| 
       5436 
5464 
     | 
    
         
             
                          peg$currPos = s0;
         
     | 
| 
       5437 
5465 
     | 
    
         
             
                          s0 = s1;
         
     | 
| 
         @@ -5569,7 +5597,7 @@ Emblem.Parser = (function() { 
     | 
|
| 
       5569 
5597 
     | 
    
         
             
                      peg$currPos++;
         
     | 
| 
       5570 
5598 
     | 
    
         
             
                    } else {
         
     | 
| 
       5571 
5599 
     | 
    
         
             
                      s2 = null;
         
     | 
| 
       5572 
     | 
    
         
            -
                      if (peg$silentFails === 0) { peg$fail(peg$ 
     | 
| 
      
 5600 
     | 
    
         
            +
                      if (peg$silentFails === 0) { peg$fail(peg$c103); }
         
     | 
| 
       5573 
5601 
     | 
    
         
             
                    }
         
     | 
| 
       5574 
5602 
     | 
    
         
             
                    if (s2 !== null) {
         
     | 
| 
       5575 
5603 
     | 
    
         
             
                      peg$reportedPos = s0;
         
     |