pegjs / pegjs / 597

597

Pull #459

travis-ci

web-flow 
<a href="https://github.com/pegjs/pegjs/commit/<a class=hub.com/pegjs/pegjs/commit/5df0b265b3974b082af44ae35ad5ec00fd8059f1">5df0b265b<a href="https://github.com/pegjs/pegjs/commit/5df0b265b3974b082af44ae35ad5ec00fd8059f1">&quot;&gt;Replace PUSH opcode with PUSH_EMPTY_STRING opcode because it only used with empty strings

(cherry picked from commit </a><a class="double-link" href="https://github.com/pegjs/pegjs/commit/<a class="double-link" href="https://github.com/pegjs/pegjs/commit/a86c58e762aae6ba61b93ff5828360d4fc9b1e49">a86c58e76</a>">a86c58e76</a><a href="https://github.com/pegjs/pegjs/commit/5df0b265b3974b082af44ae35ad5ec00fd8059f1">)
Pull Request #459: Move all codegeneration from `generateBytecode` pass to `generateJs` pass

953 of 1069 branches covered (89.15%)

Branch coverage included in aggregate %.

361 of 361 new or added lines in 3 files covered. (100.0%)

2374 of 2525 relevant lines covered (94.02%)

14426.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.76
/lib/parser/index.js
1 
// Generated by PEG.js v0.11.0-dev, https://pegjs.org/
2 









3



/* eslint-disable */










4












5



"use strict";










6












7



var ast = require("./ast");




3✔





8



var util = require("../util");




3✔





9












10



function peg$subclass(child, parent) {










11



  function C() { this.constructor = child; }




3✔





12



  C.prototype = parent.prototype;




3✔





13



  child.prototype = new C();




3✔





14



}










15












16



function peg$SyntaxError(message, expected, found, location) {










17



  this.message = message;




189✔





18



  this.expected = expected;




189✔





19



  this.found = found;




189✔





20



  this.location = location;




189✔





21



  this.name = "SyntaxError";




189✔





22












23



  // istanbul ignore next










24



  if (typeof Error.captureStackTrace === "function") {










25



    Error.captureStackTrace(this, peg$SyntaxError);










26



  }










27



}










28












29



peg$subclass(peg$SyntaxError, Error);




3✔





30












31



peg$SyntaxError.buildMessage = function(expected, found) {




3✔





32



  var DESCRIBE_EXPECTATION_FNS = {




72✔





33



    literal: function(expectation) {










34



      return "\"" + literalEscape(expectation.text) + "\"";




675✔





35



    },










36












37



    class: function(expectation) {










38



      var escapedParts = expectation.parts.map(function(part) {




×







39



        return Array.isArray(part)





×







40



          ? classEscape(part[0]) + "-" + classEscape(part[1])










41



          : classEscape(part);










42



      });










43












44



      return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";





×







45



    },










46












47



    any: function() {










48



      return "any character";




15✔





49



    },










50












51



    end: function() {










52



      return "end of input";




×







53



    },










54












55



    other: function(expectation) {










56



      return expectation.description;




864✔





57



    },










58












59



    not: function(expectation) {










60



      return "not " + describeExpectation(expectation.expected);




105✔





61



    }










62



  };










63












64



  function hex(ch) {










65



    return ch.charCodeAt(0).toString(16).toUpperCase();




×







66



  }










67












68



  function literalEscape(s) {










69



    return s




741✔





70



      .replace(/\\/g, "\\\\")










71



      .replace(/"/g,  "\\\"")










72



      .replace(/\0/g, "\\0")










73



      .replace(/\t/g, "\\t")










74



      .replace(/\n/g, "\\n")










75



      .replace(/\r/g, "\\r")










76



      .replace(/[\x00-\x0F]/g,          function(ch) { return "\\x0" + hex(ch); })




×







77



      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return "\\x"  + hex(ch); });




×







78



  }










79












80



  function classEscape(s) {










81



    return s




×







82



      .replace(/\\/g, "\\\\")










83



      .replace(/\]/g, "\\]")










84



      .replace(/\^/g, "\\^")










85



      .replace(/-/g,  "\\-")










86



      .replace(/\0/g, "\\0")










87



      .replace(/\t/g, "\\t")










88



      .replace(/\n/g, "\\n")










89



      .replace(/\r/g, "\\r")










90



      .replace(/[\x00-\x0F]/g,          function(ch) { return "\\x0" + hex(ch); })




×







91



      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return "\\x"  + hex(ch); });




×







92



  }










93












94



  function describeExpectation(expectation) {










95



    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);




1,659✔





96



  }










97












98



  function describeExpected(expected) {










99



    var descriptions = expected.map(describeExpectation);




72✔





100



    var i, j;










101












102



    descriptions.sort();




72✔





103












104



    if (descriptions.length > 0) {





72!





105



      for (i = 1, j = 1; i < descriptions.length; i++) {




72✔





106



        if (descriptions[i - 1] !== descriptions[i]) {





1,482✔





107



          descriptions[j] = descriptions[i];




726✔





108



          j++;




726✔





109



        }










110



      }










111



      descriptions.length = j;




72✔





112



    }










113












114



    switch (descriptions.length) {





72!





115



      case 1:










116



        return descriptions[0];




×







117












118



      case 2:










119



        return descriptions[0] + " or " + descriptions[1];




×







120












121



      default:










122



        return descriptions.slice(0, -1).join(", ")




72✔





123



          + ", or "










124



          + descriptions[descriptions.length - 1];










125



    }










126



  }










127












128



  function describeFound(found) {










129



    return found ? "\"" + literalEscape(found) + "\"" : "end of input";





72✔





130



  }










131












132



  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";




72✔





133



};










134












135



function peg$parse(input, options) {










136



  options = options !== undefined ? options : {};





5,193!





137












138



  var peg$FAILED = {};




5,193✔





139












140



  var peg$startRuleFunctions = { Grammar: peg$parseGrammar };




5,193✔





141



  var peg$startRuleFunction = peg$parseGrammar;




5,193✔





142













143



  var peg$c0 = "=";




5,193✔






144



  var peg$c1 = "/";




5,193✔






145



  var peg$c2 = ":";




5,193✔






146



  var peg$c3 = "$";




5,193✔






147



  var peg$c4 = "&";




5,193✔






148



  var peg$c5 = "!";




5,193✔






149



  var peg$c6 = "?";




5,193✔






150



  var peg$c7 = "*";




5,193✔






151



  var peg$c8 = "+";




5,193✔






152



  var peg$c9 = "(";




5,193✔






153



  var peg$c10 = ")";




5,193✔






154



  var peg$c11 = "\t";




5,193✔






155



  var peg$c12 = "\v";




5,193✔






156



  var peg$c13 = "\f";




5,193✔






157



  var peg$c14 = " ";




5,193✔






158



  var peg$c15 = "\xA0";




5,193✔






159



  var peg$c16 = "\uFEFF";




5,193✔






160



  var peg$c17 = "\n";




5,193✔






161



  var peg$c18 = "\r\n";




5,193✔






162



  var peg$c19 = "\r";




5,193✔






163



  var peg$c20 = "\u2028";




5,193✔






164



  var peg$c21 = "\u2029";




5,193✔






165



  var peg$c22 = "/*";




5,193✔






166



  var peg$c23 = "*/";




5,193✔






167



  var peg$c24 = "//";




5,193✔






168



  var peg$c25 = "_";




5,193✔






169



  var peg$c26 = "\\";




5,193✔






170



  var peg$c27 = "\u200C";




5,193✔






171



  var peg$c28 = "\u200D";




5,193✔






172



  var peg$c29 = "i";




5,193✔






173



  var peg$c30 = "\"";




5,193✔






174



  var peg$c31 = "'";




5,193✔






175



  var peg$c32 = "[";




5,193✔






176



  var peg$c33 = "^";




5,193✔






177



  var peg$c34 = "]";




5,193✔






178



  var peg$c35 = "-";




5,193✔






179



  var peg$c36 = "0";




5,193✔






180



  var peg$c37 = "b";




5,193✔






181



  var peg$c38 = "f";




5,193✔






182



  var peg$c39 = "n";




5,193✔






183



  var peg$c40 = "r";




5,193✔






184



  var peg$c41 = "t";




5,193✔






185



  var peg$c42 = "v";




5,193✔






186



  var peg$c43 = "x";




5,193✔






187



  var peg$c44 = "u";




5,193✔






188



  var peg$c45 = ".";




5,193✔






189



  var peg$c46 = "{";




5,193✔






190



  var peg$c47 = "}";




5,193✔






191



  var peg$c48 = ";";




5,193✔





192













193



  var peg$r0 = /^[\n\r\u2028\u2029]/;




5,193✔






194



  var peg$r1 = /^[0-9]/;




5,193✔






195



  var peg$r2 = /^[0-9a-f]/i;




5,193✔






196



  var peg$r3 = /^[{}]/;




5,193✔






197



  var peg$r4 = /^[a-z\xB5\xDF-\xF6\xF8-\xFF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137-\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148-\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C-\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA-\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9-\u01BA\u01BD-\u01BF\u01C6\u01C9\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC-\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF-\u01F0\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F-\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u0293\u0295-\u02AF\u0371\u0373\u0377\u037B-\u037D\u0390\u03AC-\u03CE\u03D0-\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F8\u03FB-\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE-\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0561-\u0587\u13F8-\u13FD\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB0-\u1FB4\u1FB6-\u1FB7\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FC7\u1FD0-\u1FD3\u1FD6-\u1FD7\u1FE0-\u1FE7\u1FF2-\u1FF4\u1FF6-\u1FF7\u210A\u210E-\u210F\u2113\u212F\u2134\u2139\u213C-\u213D\u2146-\u2149\u214E\u2184\u2C30-\u2C5E\u2C61\u2C65-\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73-\u2C74\u2C76-\u2C7B\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3-\u2CE4\u2CEC\u2CEE\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F\uA771-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787\uA78C\uA78E\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7B5\uA7B7\uA7FA\uAB30-\uAB5A\uAB60-\uAB65\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF41-\uFF5A]/;




5,193✔






198



  var peg$r5 = /^[\u02B0-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0374\u037A\u0559\u0640\u06E5-\u06E6\u07F4-\u07F5\u07FA\u081A\u0824\u0828\u0971\u0E46\u0EC6\u10FC\u17D7\u1843\u1AA7\u1C78-\u1C7D\u1D2C-\u1D6A\u1D78\u1D9B-\u1DBF\u2071\u207F\u2090-\u209C\u2C7C-\u2C7D\u2D6F\u2E2F\u3005\u3031-\u3035\u303B\u309D-\u309E\u30FC-\u30FE\uA015\uA4F8-\uA4FD\uA60C\uA67F\uA69C-\uA69D\uA717-\uA71F\uA770\uA788\uA7F8-\uA7F9\uA9CF\uA9E6\uAA70\uAADD\uAAF3-\uAAF4\uAB5C-\uAB5F\uFF70\uFF9E-\uFF9F]/;




5,193✔






199



  var peg$r6 = /^[\xAA\xBA\u01BB\u01C0-\u01C3\u0294\u05D0-\u05EA\u05F0-\u05F2\u0620-\u063F\u0641-\u064A\u066E-\u066F\u0671-\u06D3\u06D5\u06EE-\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u0800-\u0815\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098C\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC-\u09DD\u09DF-\u09E1\u09F0-\u09F1\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33\u0A35-\u0A36\u0A38-\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0-\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F-\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B5C-\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60-\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0-\u0CE1\u0CF1-\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E45\u0E81-\u0E82\u0E84\u0E87-\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065-\u1066\u106E-\u1070\u1075-\u1081\u108E\u10D0-\u10FA\u10FD-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17DC\u1820-\u1842\u1844-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE-\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C77\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5-\u1CF6\u2135-\u2138\u2D30-\u2D67\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3006\u303C\u3041-\u3096\u309F\u30A1-\u30FA\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA014\uA016-\uA48C\uA4D0-\uA4F7\uA500-\uA60B\uA610-\uA61F\uA62A-\uA62B\uA66E\uA6A0-\uA6E5\uA78F\uA7F7\uA7FB-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9E0-\uA9E4\uA9E7-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA6F\uAA71-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADC\uAAE0-\uAAEA\uAAF2\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40-\uFB41\uFB43-\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF66-\uFF6F\uFF71-\uFF9D\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/;




5,193✔






200



  var peg$r7 = /^[\u01C5\u01C8\u01CB\u01F2\u1F88-\u1F8F\u1F98-\u1F9F\u1FA8-\u1FAF\u1FBC\u1FCC\u1FFC]/;




5,193✔






201



  var peg$r8 = /^[A-Z\xC0-\xD6\xD8-\xDE\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178-\u0179\u017B\u017D\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018B\u018E-\u0191\u0193-\u0194\u0196-\u0198\u019C-\u019D\u019F-\u01A0\u01A2\u01A4\u01A6-\u01A7\u01A9\u01AC\u01AE-\u01AF\u01B1-\u01B3\u01B5\u01B7-\u01B8\u01BC\u01C4\u01C7\u01CA\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F1\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A-\u023B\u023D-\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E-\u038F\u0391-\u03A1\u03A3-\u03AB\u03CF\u03D2-\u03D4\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F4\u03F7\u03F9-\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0-\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u10A0-\u10C5\u10C7\u10CD\u13A0-\u13F5\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1FB8-\u1FBB\u1FC8-\u1FCB\u1FD8-\u1FDB\u1FE8-\u1FEC\u1FF8-\u1FFB\u2102\u2107\u210B-\u210D\u2110-\u2112\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u2130-\u2133\u213E-\u213F\u2145\u2183\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D-\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AD\uA7B0-\uA7B4\uA7B6\uFF21-\uFF3A]/;




5,193✔






202



  var peg$r9 = /^[\u0903\u093B\u093E-\u0940\u0949-\u094C\u094E-\u094F\u0982-\u0983\u09BE-\u09C0\u09C7-\u09C8\u09CB-\u09CC\u09D7\u0A03\u0A3E-\u0A40\u0A83\u0ABE-\u0AC0\u0AC9\u0ACB-\u0ACC\u0B02-\u0B03\u0B3E\u0B40\u0B47-\u0B48\u0B4B-\u0B4C\u0B57\u0BBE-\u0BBF\u0BC1-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD7\u0C01-\u0C03\u0C41-\u0C44\u0C82-\u0C83\u0CBE\u0CC0-\u0CC4\u0CC7-\u0CC8\u0CCA-\u0CCB\u0CD5-\u0CD6\u0D02-\u0D03\u0D3E-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D57\u0D82-\u0D83\u0DCF-\u0DD1\u0DD8-\u0DDF\u0DF2-\u0DF3\u0F3E-\u0F3F\u0F7F\u102B-\u102C\u1031\u1038\u103B-\u103C\u1056-\u1057\u1062-\u1064\u1067-\u106D\u1083-\u1084\u1087-\u108C\u108F\u109A-\u109C\u17B6\u17BE-\u17C5\u17C7-\u17C8\u1923-\u1926\u1929-\u192B\u1930-\u1931\u1933-\u1938\u1A19-\u1A1A\u1A55\u1A57\u1A61\u1A63-\u1A64\u1A6D-\u1A72\u1B04\u1B35\u1B3B\u1B3D-\u1B41\u1B43-\u1B44\u1B82\u1BA1\u1BA6-\u1BA7\u1BAA\u1BE7\u1BEA-\u1BEC\u1BEE\u1BF2-\u1BF3\u1C24-\u1C2B\u1C34-\u1C35\u1CE1\u1CF2-\u1CF3\u302E-\u302F\uA823-\uA824\uA827\uA880-\uA881\uA8B4-\uA8C3\uA952-\uA953\uA983\uA9B4-\uA9B5\uA9BA-\uA9BB\uA9BD-\uA9C0\uAA2F-\uAA30\uAA33-\uAA34\uAA4D\uAA7B\uAA7D\uAAEB\uAAEE-\uAAEF\uAAF5\uABE3-\uABE4\uABE6-\uABE7\uABE9-\uABEA\uABEC]/;




5,193✔






203



  var peg$r10 = /^[\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1-\u05C2\u05C4-\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7-\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962-\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2-\u09E3\u0A01-\u0A02\u0A3C\u0A41-\u0A42\u0A47-\u0A48\u0A4B-\u0A4D\u0A51\u0A70-\u0A71\u0A75\u0A81-\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7-\u0AC8\u0ACD\u0AE2-\u0AE3\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B56\u0B62-\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55-\u0C56\u0C62-\u0C63\u0C81\u0CBC\u0CBF\u0CC6\u0CCC-\u0CCD\u0CE2-\u0CE3\u0D01\u0D41-\u0D44\u0D4D\u0D62-\u0D63\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB-\u0EBC\u0EC8-\u0ECD\u0F18-\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86-\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039-\u103A\u103D-\u103E\u1058-\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752-\u1753\u1772-\u1773\u17B4-\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193B\u1A17-\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ABD\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80-\u1B81\u1BA2-\u1BA5\u1BA8-\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8-\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8-\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099-\u309A\uA66F\uA674-\uA67D\uA69E-\uA69F\uA6F0-\uA6F1\uA802\uA806\uA80B\uA825-\uA826\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9E5\uAA29-\uAA2E\uAA31-\uAA32\uAA35-\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7-\uAAB8\uAABE-\uAABF\uAAC1\uAAEC-\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/;




5,193✔






204



  var peg$r11 = /^[0-9\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19]/;




5,193✔






205



  var peg$r12 = /^[\u16EE-\u16F0\u2160-\u2182\u2185-\u2188\u3007\u3021-\u3029\u3038-\u303A\uA6E6-\uA6EF]/;




5,193✔






206



  var peg$r13 = /^[_\u203F-\u2040\u2054\uFE33-\uFE34\uFE4D-\uFE4F\uFF3F]/;




5,193✔






207



  var peg$r14 = /^[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/;




5,193✔





208













209



  var peg$e0 = peg$literalExpectation("=", false);




5,193✔






210



  var peg$e1 = peg$literalExpectation("/", false);




5,193✔






211



  var peg$e2 = peg$literalExpectation(":", false);




5,193✔






212



  var peg$e3 = peg$literalExpectation("$", false);




5,193✔






213



  var peg$e4 = peg$literalExpectation("&", false);




5,193✔






214



  var peg$e5 = peg$literalExpectation("!", false);




5,193✔






215



  var peg$e6 = peg$literalExpectation("?", false);




5,193✔






216



  var peg$e7 = peg$literalExpectation("*", false);




5,193✔






217



  var peg$e8 = peg$literalExpectation("+", false);




5,193✔






218



  var peg$e9 = peg$literalExpectation("(", false);




5,193✔






219



  var peg$e10 = peg$literalExpectation(")", false);




5,193✔






220



  var peg$e11 = peg$anyExpectation();




5,193✔






221



  var peg$e12 = peg$otherExpectation("whitespace");




5,193✔






222



  var peg$e13 = peg$classExpectation(["\n", "\r", "\u2028", "\u2029"], false, false);




5,193✔






223



  var peg$e14 = peg$otherExpectation("end of line");




5,193✔






224



  var peg$e15 = peg$otherExpectation("comment");




5,193✔






225



  var peg$e16 = peg$literalExpectation("/*", false);




5,193✔






226



  var peg$e17 = peg$literalExpectation("*/", false);




5,193✔






227



  var peg$e18 = peg$literalExpectation("//", false);




5,193✔






228



  var peg$e19 = peg$otherExpectation("identifier");




5,193✔






229



  var peg$e20 = peg$otherExpectation("literal");




5,193✔






230



  var peg$e21 = peg$otherExpectation("string");




5,193✔






231



  var peg$e22 = peg$otherExpectation("character class");




5,193✔






232



  var peg$e23 = peg$literalExpectation(".", false);




5,193✔






233



  var peg$e24 = peg$otherExpectation("code block");




5,193✔






234



  var peg$e25 = peg$literalExpectation(";", false);




5,193✔





235













236



  var peg$f0 = function(initializer, rules) {




5,193✔





237



        return new ast.Grammar(




5,004✔





238



          extractOptional(initializer, 0),










239



          extractList(rules, 0),










240



          location()










241



        );










242



      };











243



  var peg$f1 = function(code) {




5,193✔





244



        return createNode( "initializer", { code: code } );




357✔





245



      };











246



  var peg$f2 = function(name, displayName, expression) {




5,193✔





247



        return createNode( "rule", {




6,042✔





248



          name: name,










249



          expression: displayName !== null





6,042


✔





250



            ? createNode( "named", {










251



                name: displayName[0],










252



                expression: expression,










253



              } )










254



            : expression,










255



        } );










256



      };











257



  var peg$f3 = function(head, tail) {




5,193✔





258



        return tail.length > 0





8,931✔





259



          ? createNode( "choice", {










260



              alternatives: buildList(head, tail, 3),










261



            } )










262



          : head;










263



      };











264



  var peg$f4 = function(expression, code) {




5,193✔





265



        return code !== null





10,179✔





266



          ? createNode( "action", {










267



              expression: expression,










268



              code: code[1],










269



            } )










270



          : expression;










271



      };











272



  var peg$f5 = function(head, tail) {




5,193✔





273



        return tail.length > 0





10,185✔





274



          ? createNode( "sequence", {










275



              elements: buildList(head, tail, 1),










276



            } )










277



          : head;










278



      };











279



  var peg$f6 = function(label, expression) {




5,193✔





280



        if (RESERVED_WORDS.indexOf(label[0]) >= 0) {





2,805✔





281



          error(`Label can't be a reserved word "${label[0]}".`, label[1]);




108✔





282



        }










283












284



        return createNode( "labeled", {




2,697✔





285



          label: label[0],










286



          expression: expression,










287



        } );










288



      };











289



  var peg$f7 = function(operator, expression) {




5,193✔





290



        return createNode( OPS_TO_PREFIXED_TYPES[operator], {




777✔





291



          expression: expression,










292



        } );










293



      };











294



  var peg$f8 = function(expression, operator) {




5,193✔





295



        return createNode( OPS_TO_SUFFIXED_TYPES[operator], {




1,272✔





296



          expression: expression,










297



        } );










298



      };











299



  var peg$f9 = function(expression) {




5,193✔





300



        // The purpose of the "group" AST node is just to isolate label scope. We










301



        // don't need to put it around nodes that can't contain any labels or










302



        // nodes that already isolate label scope themselves. This leaves us with










303



        // "labeled" and "sequence".










304



        return expression.type === "labeled" || expression.type === "sequence"





2,871✔





305



            ? createNode( "group", { expression: expression } )










306



            : expression;










307



      };











308



  var peg$f10 = function(name) {




5,193✔





309



        return createNode( "rule_ref", { name: name } );




3,327✔





310



      };











311



  var peg$f11 = function(operator, code) {




5,193✔





312



        return createNode( OPS_TO_SEMANTIC_PREDICATE_TYPES[operator], { code: code } );




2,604✔





313



      };











314



  var peg$f12 = function(name) { return [name, location()]; };




5,193✔






315



  var peg$f13 = function(head, tail) { return head + tail.join(""); };




15,960✔






316



  var peg$f14 = function(sequence) { return sequence; };




5,193✔






317



  var peg$f15 = function(value, ignoreCase) {




5,193✔





318



        return createNode( "literal", {




16,665✔





319



          value: value,










320



          ignoreCase: ignoreCase !== null,










321



        } );










322



      };











323



  var peg$f16 = function(chars) { return chars.join(""); };




17,211✔






324



  var peg$f17 = function() { return text(); };




20,820✔






325



  var peg$f18 = function(inverted, parts, ignoreCase) {




5,193✔





326



        return createNode( "class", {




1,020✔





327



          parts: parts.filter(part => part !== ""),




1,005✔





328



          inverted: inverted !== null,










329



          ignoreCase: ignoreCase !== null,










330



        } );










331



      };











332



  var peg$f19 = function(begin, end) {




5,193✔





333



        if (begin.charCodeAt(0) > end.charCodeAt(0)) {





426✔





334



          error(




3✔





335



            "Invalid character range: " + text() + "."










336



          );










337



        }










338












339



        return [begin, end];




423✔





340



      };











341



  var peg$f20 = function() { return ""; };




5,193✔






342



  var peg$f21 = function() { return "\0"; };




5,193✔






343



  var peg$f22 = function() { return "\b"; };




5,193✔






344



  var peg$f23 = function() { return "\f"; };




5,193✔






345



  var peg$f24 = function() { return "\n"; };




5,193✔






346



  var peg$f25 = function() { return "\r"; };




5,193✔






347



  var peg$f26 = function() { return "\t"; };




5,193✔






348



  var peg$f27 = function() { return "\v"; };




5,193✔






349



  var peg$f28 = function(digits) {




5,193✔





350



        return String.fromCharCode(parseInt(digits, 16));




33✔





351



      };











352



  var peg$f29 = function() { return createNode( "any", {} ); };




5,193✔






353



  var peg$f30 = function(code) { return code; };




5,193✔






354



  var peg$f31 = function() { error("Unbalanced brace."); };




5,193✔





355












356



  var peg$currPos = 0;




5,193✔





357



  var peg$savedPos = 0;




5,193✔





358



  var peg$posDetailsCache = [{ line: 1, column: 1 }];




5,193✔





359



  var peg$expected = [];




5,193✔





360



  var peg$silentFails = 0;




5,193✔





361












362



  var peg$result;










363












364



  if ("startRule" in options) {





5,193!





365



    if (!(options.startRule in peg$startRuleFunctions)) {





×







366



      throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");




×







367



    }










368












369



    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];




×







370



  }










371












372



  function text() {










373



    return input.substring(peg$savedPos, peg$currPos);




20,823✔





374



  }










375












376



  function offset() {










377



    return peg$savedPos;




×







378



  }










379












380



  function range() {










381



    return [peg$savedPos, peg$currPos];




×







382



  }










383












384



  function location() {










385



    return peg$computeLocation(peg$savedPos, peg$currPos);




52,902✔





386



  }










387












388



  function expected(description, location) {










389



    location = location !== undefined





×







390



      ? location










391



      : peg$computeLocation(peg$savedPos, peg$currPos);










392












393



    throw peg$buildStructuredError(




×







394



      [peg$otherExpectation(description)],










395



      input.substring(peg$savedPos, peg$currPos),










396



      location










397



    );










398



  }










399












400



  function error(message, location) {










401



    location = location !== undefined





117✔





402



      ? location










403



      : peg$computeLocation(peg$savedPos, peg$currPos);










404












405



    throw peg$buildSimpleError(message, location);




117✔





406



  }










407












408



  function peg$literalExpectation(text, ignoreCase) {










409



    return { type: "literal", text: text, ignoreCase: ignoreCase };




83,088✔





410



  }










411












412



  function peg$classExpectation(parts, inverted, ignoreCase) {










413



    return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };




5,193✔





414



  }










415












416



  function peg$anyExpectation() {










417



    return { type: "any" };




5,193✔





418



  }










419












420



  function peg$endExpectation() {










421



    return { type: "end" };




×







422



  }










423












424



  function peg$otherExpectation(description) {










425



    return { type: "other", description: description };




41,544✔





426



  }










427












428



  function peg$computePosDetails(pos) {










429



    var details = peg$posDetailsCache[pos];




105,966✔





430



    var p;










431












432



    if (details) {





105,966✔





433



      return details;




71,406✔





434



    } else {










435



      p = pos - 1;




34,560✔





436



      while (!peg$posDetailsCache[p]) {




34,560✔





437



        p--;




153,489✔





438



      }










439












440



      details = peg$posDetailsCache[p];




34,560✔





441



      details = {




34,560✔





442



        line: details.line,










443



        column: details.column










444



      };










445












446



      while (p < pos) {




34,560✔





447



        if (input.charCodeAt(p) === 10) {





188,049✔





448



          details.line++;




2,406✔





449



          details.column = 1;




2,406✔





450



        } else {










451



          details.column++;




185,643✔





452



        }










453












454



        p++;




188,049✔





455



      }










456












457



      peg$posDetailsCache[pos] = details;




34,560✔





458












459



      return details;




34,560✔





460



    }










461



  }










462












463



  function peg$computeLocation(startPos, endPos) {










464



    var startPosDetails = peg$computePosDetails(startPos);




52,983✔





465



    var endPosDetails = peg$computePosDetails(endPos);




52,983✔





466












467



    return {




52,983✔





468



      start: {










469



        offset: startPos,










470



        line: startPosDetails.line,










471



        column: startPosDetails.column










472



      },










473



      end: {










474



        offset: endPos,










475



        line: endPosDetails.line,










476



        column: endPosDetails.column










477



      }










478



    };










479



  }










480












481



  function peg$begin() {










482



    peg$expected.push({ pos: peg$currPos, variants: [] });




161,349✔





483



  }










484












485



  function peg$expect(expected) {










486



    var top = peg$expected[peg$expected.length - 1];




863,391✔





487












488



    if (peg$currPos < top.pos) { return; }





863,391✔





489












490



    if (peg$currPos > top.pos) {





669,891✔





491



      top.pos = peg$currPos;




65,841✔





492



      top.variants = [];




65,841✔





493



    }










494












495



    top.variants.push(expected);




669,891✔





496



  }










497












498



  function peg$end(invert) {










499



    var expected = peg$expected.pop();




156,156✔





500



    var top = peg$expected[peg$expected.length - 1];




156,156✔





501



    var variants = expected.variants;




156,156✔





502












503



    if (top.pos !== expected.pos) { return; }





156,156✔





504












505



    if (invert) {





8,862!





506



      variants = variants.map(function(e) {




8,862✔





507



        return e.type === "not" ? e.expected : { type: "not", expected: e };





24,450!





508



      });










509



    }










510












511



    Array.prototype.push.apply(top.variants, variants);




8,862✔





512



  }










513












514



  function peg$buildSimpleError(message, location) {










515



    return new peg$SyntaxError(message, null, null, location);




117✔





516



  }










517












518



  function peg$buildStructuredError(expected, found, location) {










519



    return new peg$SyntaxError(




72✔





520



      peg$SyntaxError.buildMessage(expected, found),










521



      expected,










522



      found,










523



      location










524



    );










525



  }










526












527



  function peg$buildError() {










528



    var expected = peg$expected[0];




72✔





529



    var failPos = expected.pos;




72✔





530












531



    return peg$buildStructuredError(




72✔





532



      expected.variants,










533



      failPos < input.length ? input.charAt(failPos) : null,





72


✔





534



      failPos < input.length





72


✔





535



        ? peg$computeLocation(failPos, failPos + 1)










536



        : peg$computeLocation(failPos, failPos)










537



    );










538



  }










539












540



  function peg$parseGrammar() {










541



    var s0, s1, s2, s3, s4, s5, s6;










542












543



    s0 = peg$currPos;




5,193✔





544



    s1 = peg$parse__();




5,193✔





545



    s2 = peg$currPos;




5,193✔





546



    s3 = peg$parseInitializer();




5,193✔





547



    if (s3 !== peg$FAILED) {





5,193✔





548



      s4 = peg$parse__();




357✔





549



      s3 = [s3, s4];




357✔





550



      s2 = s3;




357✔





551



    } else {










552



      peg$currPos = s2;




4,836✔





553



      s2 = peg$FAILED;




4,836✔





554



    }










555



    if (s2 === peg$FAILED) {





5,193✔





556



      s2 = null;




4,836✔





557



    }










558



    s3 = [];




5,193✔





559



    s4 = peg$currPos;




5,193✔





560



    s5 = peg$parseRule();




5,193✔





561



    if (s5 !== peg$FAILED) {





5,076✔





562



      s6 = peg$parse__();




5,004✔





563



      s5 = [s5, s6];




5,004✔





564



      s4 = s5;




5,004✔





565



    } else {










566



      peg$currPos = s4;




72✔





567



      s4 = peg$FAILED;




72✔





568



    }










569



    if (s4 !== peg$FAILED) {





5,076✔





570



      while (s4 !== peg$FAILED) {




5,004✔





571



        s3.push(s4);




6,042✔





572



        s4 = peg$currPos;




6,042✔





573



        s5 = peg$parseRule();




6,042✔





574



        if (s5 !== peg$FAILED) {





6,042✔





575



          s6 = peg$parse__();




1,038✔





576



          s5 = [s5, s6];




1,038✔





577



          s4 = s5;




1,038✔





578



        } else {










579



          peg$currPos = s4;




5,004✔





580



          s4 = peg$FAILED;




5,004✔





581



        }










582



      }










583



    } else {










584



      s3 = peg$FAILED;




72✔





585



    }










586



    if (s3 !== peg$FAILED) {





5,076✔





587



      peg$savedPos = s0;




5,004✔






588



      s0 = peg$f0(s2, s3);




5,004✔





589



    } else {










590



      peg$currPos = s0;




72✔





591



      s0 = peg$FAILED;




72✔





592



    }










593












594



    return s0;




5,076✔





595



  }










596












597



  function peg$parseInitializer() {










598



    var s0, s1, s2;










599












600



    s0 = peg$currPos;




5,193✔





601



    s1 = peg$parseCodeBlock();




5,193✔





602



    if (s1 !== peg$FAILED) {





5,193✔





603



      s2 = peg$parseEOS();




357✔





604



      if (s2 !== peg$FAILED) {





357!





605



        peg$savedPos = s0;




357✔






606



        s0 = peg$f1(s1);




357✔





607



      } else {










608



        peg$currPos = s0;




×







609



        s0 = peg$FAILED;




×







610



      }










611



    } else {










612



      peg$currPos = s0;




4,836✔





613



      s0 = peg$FAILED;




4,836✔





614



    }










615












616



    return s0;




5,193✔





617



  }










618












619



  function peg$parseRule() {










620



    var s0, s1, s2, s3, s4, s5, s6, s7;










621












622



    s0 = peg$currPos;




11,235✔





623



    s1 = peg$parseIdentifierName();




11,235✔





624



    if (s1 !== peg$FAILED) {





11,235✔





625



      s2 = peg$parse__();




6,225✔





626



      s3 = peg$currPos;




6,225✔





627



      s4 = peg$parseStringLiteral();




6,225✔





628



      if (s4 !== peg$FAILED) {





6,225✔





629



        s5 = peg$parse__();




108✔





630



        s4 = [s4, s5];




108✔





631



        s3 = s4;




108✔





632



      } else {










633



        peg$currPos = s3;




6,117✔





634



        s3 = peg$FAILED;




6,117✔





635



      }










636



      if (s3 === peg$FAILED) {





6,225✔





637



        s3 = null;




6,117✔





638



      }











639



      if (peg$silentFails === 0) { peg$expect(peg$e0); }





6,225!





640



      if (input.charCodeAt(peg$currPos) === 61) {





6,225!






641



        s4 = peg$c0;




6,225✔





642



        peg$currPos++;




6,225✔





643



      } else {










644



        s4 = peg$FAILED;




×







645



      }










646



      if (s4 !== peg$FAILED) {





6,225!





647



        s5 = peg$parse__();




6,225✔





648



        s6 = peg$parseChoiceExpression();




6,225✔





649



        if (s6 !== peg$FAILED) {





6,108✔





650



          s7 = peg$parseEOS();




6,060✔





651



          if (s7 !== peg$FAILED) {





6,060✔





652



            peg$savedPos = s0;




6,042✔






653



            s0 = peg$f2(s1, s3, s6);




6,042✔





654



          } else {










655



            peg$currPos = s0;




18✔





656



            s0 = peg$FAILED;




18✔





657



          }










658



        } else {










659



          peg$currPos = s0;




48✔





660



          s0 = peg$FAILED;




48✔





661



        }










662



      } else {










663



        peg$currPos = s0;




×







664



        s0 = peg$FAILED;




×







665



      }










666



    } else {










667



      peg$currPos = s0;




5,010✔





668



      s0 = peg$FAILED;




5,010✔





669



    }










670












671



    return s0;




11,118✔





672



  }










673












674



  function peg$parseChoiceExpression() {










675



    var s0, s1, s2, s3, s4, s5, s6, s7;










676












677



    s0 = peg$currPos;




9,096✔





678



    s1 = peg$parseActionExpression();




9,096✔





679



    if (s1 !== peg$FAILED) {





8,979✔





680



      s2 = [];




8,931✔





681



      s3 = peg$currPos;




8,931✔





682



      s4 = peg$parse__();




8,931✔






683



      if (peg$silentFails === 0) { peg$expect(peg$e1); }





8,931!





684



      if (input.charCodeAt(peg$currPos) === 47) {





8,931✔






685



        s5 = peg$c1;




837✔





686



        peg$currPos++;




837✔





687



      } else {










688



        s5 = peg$FAILED;




8,094✔





689



      }










690



      if (s5 !== peg$FAILED) {





8,931✔





691



        s6 = peg$parse__();




837✔





692



        s7 = peg$parseActionExpression();




837✔





693



        if (s7 !== peg$FAILED) {





837✔





694



          s4 = [s4, s5, s6, s7];




834✔





695



          s3 = s4;




834✔





696



        } else {










697



          peg$currPos = s3;




3✔





698



          s3 = peg$FAILED;




3✔





699



        }










700



      } else {










701



        peg$currPos = s3;




8,094✔





702



        s3 = peg$FAILED;




8,094✔





703



      }










704



      while (s3 !== peg$FAILED) {




8,931✔





705



        s2.push(s3);




1,248✔





706



        s3 = peg$currPos;




1,248✔





707



        s4 = peg$parse__();




1,248✔






708



        if (peg$silentFails === 0) { peg$expect(peg$e1); }





1,248!





709



        if (input.charCodeAt(peg$currPos) === 47) {





1,248✔






710



          s5 = peg$c1;




414✔





711



          peg$currPos++;




414✔





712



        } else {










713



          s5 = peg$FAILED;




834✔





714



        }










715



        if (s5 !== peg$FAILED) {





1,248✔





716



          s6 = peg$parse__();




414✔





717



          s7 = peg$parseActionExpression();




414✔





718



          if (s7 !== peg$FAILED) {





414!





719



            s4 = [s4, s5, s6, s7];




414✔





720



            s3 = s4;




414✔





721



          } else {










722



            peg$currPos = s3;




×







723



            s3 = peg$FAILED;




×







724



          }










725



        } else {










726



          peg$currPos = s3;




834✔





727



          s3 = peg$FAILED;




834✔





728



        }










729



      }










730



      peg$savedPos = s0;




8,931✔






731



      s0 = peg$f3(s1, s2);




8,931✔





732



    } else {










733



      peg$currPos = s0;




48✔





734



      s0 = peg$FAILED;




48✔





735



    }










736












737



    return s0;




8,979✔





738



  }










739












740



  function peg$parseActionExpression() {










741



    var s0, s1, s2, s3, s4;










742












743



    s0 = peg$currPos;




10,347✔





744



    s1 = peg$parseSequenceExpression();




10,347✔





745



    if (s1 !== peg$FAILED) {





10,236✔





746



      s2 = peg$currPos;




10,185✔





747



      s3 = peg$parse__();




10,185✔





748



      s4 = peg$parseCodeBlock();




10,185✔





749



      if (s4 !== peg$FAILED) {





10,179✔





750



        s3 = [s3, s4];




1,539✔





751



        s2 = s3;




1,539✔





752



      } else {










753



        peg$currPos = s2;




8,640✔





754



        s2 = peg$FAILED;




8,640✔





755



      }










756



      if (s2 === peg$FAILED) {





10,179✔





757



        s2 = null;




8,640✔





758



      }










759



      peg$savedPos = s0;




10,179✔






760



      s0 = peg$f4(s1, s2);




10,179✔





761



    } else {










762



      peg$currPos = s0;




51✔





763



      s0 = peg$FAILED;




51✔





764



    }










765












766



    return s0;




10,230✔





767



  }










768












769



  function peg$parseSequenceExpression() {










770



    var s0, s1, s2, s3, s4, s5;










771












772



    s0 = peg$currPos;




10,347✔





773



    s1 = peg$parseLabeledExpression();




10,347✔





774



    if (s1 !== peg$FAILED) {





10,236✔





775



      s2 = [];




10,185✔





776



      s3 = peg$currPos;




10,185✔





777



      s4 = peg$parse__();




10,185✔





778



      s5 = peg$parseLabeledExpression();




10,185✔





779



      if (s5 !== peg$FAILED) {





10,185✔





780



        s4 = [s4, s5];




3,102✔





781



        s3 = s4;




3,102✔





782



      } else {










783



        peg$currPos = s3;




7,083✔





784



        s3 = peg$FAILED;




7,083✔





785



      }










786



      while (s3 !== peg$FAILED) {




10,185✔





787



        s2.push(s3);




3,897✔





788



        s3 = peg$currPos;




3,897✔





789



        s4 = peg$parse__();




3,897✔





790



        s5 = peg$parseLabeledExpression();




3,897✔





791



        if (s5 !== peg$FAILED) {





3,897✔





792



          s4 = [s4, s5];




795✔





793



          s3 = s4;




795✔





794



        } else {










795



          peg$currPos = s3;




3,102✔





796



          s3 = peg$FAILED;




3,102✔





797



        }










798



      }










799



      peg$savedPos = s0;




10,185✔






800



      s0 = peg$f5(s1, s2);




10,185✔





801



    } else {










802



      peg$currPos = s0;




51✔





803



      s0 = peg$FAILED;




51✔





804



    }










805












806



    return s0;




10,236✔





807



  }










808












809



  function peg$parseLabeledExpression() {










810



    var s0, s1, s2, s3, s4, s5;










811












812



    s0 = peg$currPos;




24,429✔





813



    s1 = peg$parseIdentifier();




24,429✔





814



    if (s1 !== peg$FAILED) {





24,429✔





815



      s2 = peg$parse__();




4,980✔






816



      if (peg$silentFails === 0) { peg$expect(peg$e2); }





4,980!





817



      if (input.charCodeAt(peg$currPos) === 58) {





4,980✔






818



        s3 = peg$c2;




2,805✔





819



        peg$currPos++;




2,805✔





820



      } else {










821



        s3 = peg$FAILED;




2,175✔





822



      }










823



      if (s3 !== peg$FAILED) {





4,980✔





824



        s4 = peg$parse__();




2,805✔





825



        s5 = peg$parsePrefixedExpression();




2,805✔





826



        if (s5 !== peg$FAILED) {





2,805!





827



          peg$savedPos = s0;




2,805✔






828



          s0 = peg$f6(s1, s5);




2,805✔





829



        } else {










830



          peg$currPos = s0;




×







831



          s0 = peg$FAILED;




×







832



        }










833



      } else {










834



        peg$currPos = s0;




2,175✔





835



        s0 = peg$FAILED;




2,175✔





836



      }










837



    } else {










838



      peg$currPos = s0;




19,449✔





839



      s0 = peg$FAILED;




19,449✔





840



    }










841



    if (s0 === peg$FAILED) {





24,321✔





842



      s0 = peg$parsePrefixedExpression();




21,624✔





843



    }










844












845



    return s0;




24,318✔





846



  }










847












848



  function peg$parsePrefixedExpression() {










849



    var s0, s1, s2, s3;










850












851



    s0 = peg$currPos;




24,429✔





852



    s1 = peg$parsePrefixedOperator();




24,429✔





853



    if (s1 !== peg$FAILED) {





24,429✔





854



      s2 = peg$parse__();




2,082✔





855



      s3 = peg$parseSuffixedExpression();




2,082✔





856



      if (s3 !== peg$FAILED) {





2,082✔





857



        peg$savedPos = s0;




777✔






858



        s0 = peg$f7(s1, s3);




777✔





859



      } else {










860



        peg$currPos = s0;




1,305✔





861



        s0 = peg$FAILED;




1,305✔





862



      }










863



    } else {










864



      peg$currPos = s0;




22,347✔





865



      s0 = peg$FAILED;




22,347✔





866



    }










867



    if (s0 === peg$FAILED) {





24,429✔





868



      s0 = peg$parseSuffixedExpression();




23,652✔





869



    }










870












871



    return s0;




24,426✔





872



  }










873












874



  function peg$parsePrefixedOperator() {










875



    var s0;










876













877



    if (peg$silentFails === 0) { peg$expect(peg$e3); }





24,429!





878



    if (input.charCodeAt(peg$currPos) === 36) {





24,429✔






879



      s0 = peg$c3;




153✔





880



      peg$currPos++;




153✔





881



    } else {










882



      s0 = peg$FAILED;




24,276✔





883



    }










884



    if (s0 === peg$FAILED) {





24,429✔






885



      if (peg$silentFails === 0) { peg$expect(peg$e4); }





24,276!





886



      if (input.charCodeAt(peg$currPos) === 38) {





24,276✔






887



        s0 = peg$c4;




900✔





888



        peg$currPos++;




900✔





889



      } else {










890



        s0 = peg$FAILED;




23,376✔





891



      }










892



      if (s0 === peg$FAILED) {





24,276✔






893



        if (peg$silentFails === 0) { peg$expect(peg$e5); }





23,376!





894



        if (input.charCodeAt(peg$currPos) === 33) {





23,376✔






895



          s0 = peg$c5;




1,029✔





896



          peg$currPos++;




1,029✔





897



        } else {










898



          s0 = peg$FAILED;




22,347✔





899



        }










900



      }










901



    }










902












903



    return s0;




24,429✔





904



  }










905












906



  function peg$parseSuffixedExpression() {










907



    var s0, s1, s2, s3;










908












909



    s0 = peg$currPos;




25,734✔





910



    s1 = peg$parsePrimaryExpression();




25,734✔





911



    if (s1 !== peg$FAILED) {





25,731✔





912



      s2 = peg$parse__();




14,190✔





913



      s3 = peg$parseSuffixedOperator();




14,190✔





914



      if (s3 !== peg$FAILED) {





14,190✔





915



        peg$savedPos = s0;




1,272✔






916



        s0 = peg$f8(s1, s3);




1,272✔





917



      } else {










918



        peg$currPos = s0;




12,918✔





919



        s0 = peg$FAILED;




12,918✔





920



      }










921



    } else {










922



      peg$currPos = s0;




11,541✔





923



      s0 = peg$FAILED;




11,541✔





924



    }










925



    if (s0 === peg$FAILED) {





25,731✔





926



      s0 = peg$parsePrimaryExpression();




24,459✔





927



    }










928












929



    return s0;




25,731✔





930



  }










931












932



  function peg$parseSuffixedOperator() {










933



    var s0;










934













935



    if (peg$silentFails === 0) { peg$expect(peg$e6); }





14,190!





936



    if (input.charCodeAt(peg$currPos) === 63) {





14,190✔






937



      s0 = peg$c6;




318✔





938



      peg$currPos++;




318✔





939



    } else {










940



      s0 = peg$FAILED;




13,872✔





941



    }










942



    if (s0 === peg$FAILED) {





14,190✔






943



      if (peg$silentFails === 0) { peg$expect(peg$e7); }





13,872!





944



      if (input.charCodeAt(peg$currPos) === 42) {





13,872✔






945



        s0 = peg$c7;




510✔





946



        peg$currPos++;




510✔





947



      } else {










948



        s0 = peg$FAILED;




13,362✔





949



      }










950



      if (s0 === peg$FAILED) {





13,872✔






951



        if (peg$silentFails === 0) { peg$expect(peg$e8); }





13,362!





952



        if (input.charCodeAt(peg$currPos) === 43) {





13,362✔






953



          s0 = peg$c8;




444✔





954



          peg$currPos++;




444✔





955



        } else {










956



          s0 = peg$FAILED;




12,918✔





957



        }










958



      }










959



    }










960












961



    return s0;




14,190✔





962



  }










963












964



  function peg$parsePrimaryExpression() {










965



    var s0, s1, s2, s3, s4, s5;










966












967



    s0 = peg$parseLiteralMatcher();




50,193✔





968



    if (s0 === peg$FAILED) {





50,193✔





969



      s0 = peg$parseCharacterClassMatcher();




33,528✔





970



      if (s0 === peg$FAILED) {





33,525✔





971



        s0 = peg$parseAnyMatcher();




32,505✔





972



        if (s0 === peg$FAILED) {





32,505✔





973



          s0 = peg$parseRuleReferenceExpression();




31,884✔





974



          if (s0 === peg$FAILED) {





31,884✔





975



            s0 = peg$parseSemanticPredicateExpression();




28,557✔





976



            if (s0 === peg$FAILED) {





28,557✔





977



              s0 = peg$currPos;




25,953✔






978



              if (peg$silentFails === 0) { peg$expect(peg$e9); }





25,953!





979



              if (input.charCodeAt(peg$currPos) === 40) {





25,953✔






980



                s1 = peg$c9;




2,871✔





981



                peg$currPos++;




2,871✔





982



              } else {










983



                s1 = peg$FAILED;




23,082✔





984



              }










985



              if (s1 !== peg$FAILED) {





25,953✔





986



                s2 = peg$parse__();




2,871✔





987



                s3 = peg$parseChoiceExpression();




2,871✔





988



                if (s3 !== peg$FAILED) {





2,871!





989



                  s4 = peg$parse__();




2,871✔






990



                  if (peg$silentFails === 0) { peg$expect(peg$e10); }





2,871!





991



                  if (input.charCodeAt(peg$currPos) === 41) {





2,871!






992



                    s5 = peg$c10;




2,871✔





993



                    peg$currPos++;




2,871✔





994



                  } else {










995



                    s5 = peg$FAILED;




×







996



                  }










997



                  if (s5 !== peg$FAILED) {





2,871!





998



                    peg$savedPos = s0;




2,871✔






999



                    s0 = peg$f9(s3);




2,871✔





1000



                  } else {










1001



                    peg$currPos = s0;




×







1002



                    s0 = peg$FAILED;




×







1003



                  }










1004



                } else {










1005



                  peg$currPos = s0;




×







1006



                  s0 = peg$FAILED;




×







1007



                }










1008



              } else {










1009



                peg$currPos = s0;




23,082✔





1010



                s0 = peg$FAILED;




23,082✔





1011



              }










1012



            }










1013



          }










1014



        }










1015



      }










1016



    }










1017












1018



    return s0;




50,190✔





1019



  }










1020












1021



  function peg$parseRuleReferenceExpression() {










1022



    var s0, s1, s2, s3, s4, s5, s6, s7;










1023












1024



    s0 = peg$currPos;




31,884✔





1025



    s1 = peg$parseIdentifierName();




31,884✔





1026



    if (s1 !== peg$FAILED) {





31,884✔





1027



      s2 = peg$currPos;




4,755✔





1028



      peg$begin();




4,755✔





1029



      s3 = peg$currPos;




4,755✔





1030



      s4 = peg$parse__();




4,755✔





1031



      s5 = peg$currPos;




4,755✔





1032



      s6 = peg$parseStringLiteral();




4,755✔





1033



      if (s6 !== peg$FAILED) {





4,755✔





1034



        s7 = peg$parse__();




438✔





1035



        s6 = [s6, s7];




438✔





1036



        s5 = s6;




438✔





1037



      } else {










1038



        peg$currPos = s5;




4,317✔





1039



        s5 = peg$FAILED;




4,317✔





1040



      }










1041



      if (s5 === peg$FAILED) {





4,755✔





1042



        s5 = null;




4,317✔





1043



      }











1044



      if (peg$silentFails === 0) { peg$expect(peg$e0); }





4,755!





1045



      if (input.charCodeAt(peg$currPos) === 61) {





4,755✔






1046



        s6 = peg$c0;




1,428✔





1047



        peg$currPos++;




1,428✔





1048



      } else {










1049



        s6 = peg$FAILED;




3,327✔





1050



      }










1051



      if (s6 !== peg$FAILED) {





4,755✔





1052



        s4 = [s4, s5, s6];




1,428✔





1053



        s3 = s4;




1,428✔





1054



      } else {










1055



        peg$currPos = s3;




3,327✔





1056



        s3 = peg$FAILED;




3,327✔





1057



      }










1058



      peg$end(true);




4,755✔





1059



      if (s3 === peg$FAILED) {





4,755✔





1060



        s2 = undefined;




3,327✔





1061



      } else {










1062



        peg$currPos = s2;




1,428✔





1063



        s2 = peg$FAILED;




1,428✔





1064



      }










1065



      if (s2 !== peg$FAILED) {





4,755✔





1066



        peg$savedPos = s0;




3,327✔






1067



        s0 = peg$f10(s1);




3,327✔





1068



      } else {










1069



        peg$currPos = s0;




1,428✔





1070



        s0 = peg$FAILED;




1,428✔





1071



      }










1072



    } else {










1073



      peg$currPos = s0;




27,129✔





1074



      s0 = peg$FAILED;




27,129✔





1075



    }










1076












1077



    return s0;




31,884✔





1078



  }










1079












1080



  function peg$parseSemanticPredicateExpression() {










1081



    var s0, s1, s2, s3;










1082












1083



    s0 = peg$currPos;




28,557✔





1084



    s1 = peg$parseSemanticPredicateOperator();




28,557✔





1085



    if (s1 !== peg$FAILED) {





28,557✔





1086



      s2 = peg$parse__();




2,604✔





1087



      s3 = peg$parseCodeBlock();




2,604✔





1088



      if (s3 !== peg$FAILED) {





2,604!





1089



        peg$savedPos = s0;




2,604✔






1090



        s0 = peg$f11(s1, s3);




2,604✔





1091



      } else {










1092



        peg$currPos = s0;




×







1093



        s0 = peg$FAILED;




×







1094



      }










1095



    } else {










1096



      peg$currPos = s0;




25,953✔





1097



      s0 = peg$FAILED;




25,953✔





1098



    }










1099












1100



    return s0;




28,557✔





1101



  }










1102












1103



  function peg$parseSemanticPredicateOperator() {










1104



    var s0;










1105













1106



    if (peg$silentFails === 0) { peg$expect(peg$e4); }





28,557!





1107



    if (input.charCodeAt(peg$currPos) === 38) {





28,557✔






1108



      s0 = peg$c4;




1,302✔





1109



      peg$currPos++;




1,302✔





1110



    } else {










1111



      s0 = peg$FAILED;




27,255✔





1112



    }










1113



    if (s0 === peg$FAILED) {





28,557✔






1114



      if (peg$silentFails === 0) { peg$expect(peg$e5); }





27,255!





1115



      if (input.charCodeAt(peg$currPos) === 33) {





27,255✔






1116



        s0 = peg$c5;




1,302✔





1117



        peg$currPos++;




1,302✔





1118



      } else {










1119



        s0 = peg$FAILED;




25,953✔





1120



      }










1121



    }










1122












1123



    return s0;




28,557✔





1124



  }










1125












1126



  function peg$parseSourceCharacter() {










1127



    var s0;










1128













1129



    if (peg$silentFails === 0) { peg$expect(peg$e11); }





115,899✔





1130



    if (input.length > peg$currPos) {





115,899✔





1131



      s0 = input.charAt(peg$currPos);




115,854✔





1132



      peg$currPos++;




115,854✔





1133



    } else {










1134



      s0 = peg$FAILED;




45✔





1135



    }










1136












1137



    return s0;




115,899✔





1138



  }










1139












1140



  function peg$parseWhiteSpace() {










1141



    var s0;










1142













1143



    if (peg$silentFails === 0) { peg$expect(peg$e12); }





171,198!





1144



    peg$silentFails++;




171,198✔





1145



    if (input.charCodeAt(peg$currPos) === 9) {





171,198✔






1146



      s0 = peg$c11;




3✔





1147



      peg$currPos++;




3✔





1148



    } else {










1149



      s0 = peg$FAILED;




171,195✔





1150



    }










1151



    if (s0 === peg$FAILED) {





171,198✔





1152



      if (input.charCodeAt(peg$currPos) === 11) {





171,195✔






1153



        s0 = peg$c12;




3✔





1154



        peg$currPos++;




3✔





1155



      } else {










1156



        s0 = peg$FAILED;




171,192✔





1157



      }










1158



      if (s0 === peg$FAILED) {





171,195✔





1159



        if (input.charCodeAt(peg$currPos) === 12) {





171,192✔






1160



          s0 = peg$c13;




3✔





1161



          peg$currPos++;




3✔





1162



        } else {










1163



          s0 = peg$FAILED;




171,189✔





1164



        }










1165



        if (s0 === peg$FAILED) {





171,192✔





1166



          if (input.charCodeAt(peg$currPos) === 32) {





171,189✔






1167



            s0 = peg$c14;




49,326✔





1168



            peg$currPos++;




49,326✔





1169



          } else {










1170



            s0 = peg$FAILED;




121,863✔





1171



          }










1172



          if (s0 === peg$FAILED) {





171,189✔





1173



            if (input.charCodeAt(peg$currPos) === 160) {





121,863✔






1174



              s0 = peg$c15;




3✔





1175



              peg$currPos++;




3✔





1176



            } else {










1177



              s0 = peg$FAILED;




121,860✔





1178



            }










1179



            if (s0 === peg$FAILED) {





121,863✔





1180



              if (input.charCodeAt(peg$currPos) === 65279) {





121,860✔






1181



                s0 = peg$c16;




3✔





1182



                peg$currPos++;




3✔





1183



              } else {










1184



                s0 = peg$FAILED;




121,857✔





1185



              }










1186



              if (s0 === peg$FAILED) {





121,860✔





1187



                s0 = peg$parseZs();




121,857✔





1188



              }










1189



            }










1190



          }










1191



        }










1192



      }










1193



    }










1194



    peg$silentFails--;




171,198✔





1195












1196



    return s0;




171,198✔





1197



  }










1198












1199



  function peg$parseLineTerminator() {










1200



    var s0;










1201













1202



    if (peg$silentFails === 0) { peg$expect(peg$e13); }





21,201✔






1203



    if (peg$r0.test(input.charAt(peg$currPos))) {





21,201✔





1204



      s0 = input.charAt(peg$currPos);




126✔





1205



      peg$currPos++;




126✔





1206



    } else {










1207



      s0 = peg$FAILED;




21,075✔





1208



    }










1209












1210



    return s0;




21,201✔





1211



  }










1212












1213



  function peg$parseLineTerminatorSequence() {










1214



    var s0;










1215













1216



    if (peg$silentFails === 0) { peg$expect(peg$e14); }





121,890✔





1217



    peg$silentFails++;




121,890✔





1218



    if (input.charCodeAt(peg$currPos) === 10) {





121,890✔






1219



      s0 = peg$c17;




7,749✔





1220



      peg$currPos++;




7,749✔





1221



    } else {










1222



      s0 = peg$FAILED;




114,141✔





1223



    }










1224



    if (s0 === peg$FAILED) {





121,890✔






1225



      if (input.substr(peg$currPos, 2) === peg$c18) {





114,141✔






1226



        s0 = peg$c18;




195✔





1227



        peg$currPos += 2;




195✔





1228



      } else {










1229



        s0 = peg$FAILED;




113,946✔





1230



      }










1231



      if (s0 === peg$FAILED) {





114,141✔





1232



        if (input.charCodeAt(peg$currPos) === 13) {





113,946✔






1233



          s0 = peg$c19;




3✔





1234



          peg$currPos++;




3✔





1235



        } else {










1236



          s0 = peg$FAILED;




113,943✔





1237



        }










1238



        if (s0 === peg$FAILED) {





113,946✔





1239



          if (input.charCodeAt(peg$currPos) === 8232) {





113,943✔






1240



            s0 = peg$c20;




3✔





1241



            peg$currPos++;




3✔





1242



          } else {










1243



            s0 = peg$FAILED;




113,940✔





1244



          }










1245



          if (s0 === peg$FAILED) {





113,943✔





1246



            if (input.charCodeAt(peg$currPos) === 8233) {





113,940✔






1247



              s0 = peg$c21;




3✔





1248



              peg$currPos++;




3✔





1249



            } else {










1250



              s0 = peg$FAILED;




113,937✔





1251



            }










1252



          }










1253



        }










1254



      }










1255



    }










1256



    peg$silentFails--;




121,890✔





1257












1258



    return s0;




121,890✔





1259



  }










1260












1261



  function peg$parseComment() {










1262



    var s0;










1263













1264



    if (peg$silentFails === 0) { peg$expect(peg$e15); }





108,960!





1265



    peg$silentFails++;




108,960✔





1266



    s0 = peg$parseMultiLineComment();




108,960✔





1267



    if (s0 === peg$FAILED) {





108,960✔





1268



      s0 = peg$parseSingleLineComment();




108,861✔





1269



    }










1270



    peg$silentFails--;




108,960✔





1271












1272



    return s0;




108,960✔





1273



  }










1274












1275



  function peg$parseMultiLineComment() {










1276



    var s0, s1, s2, s3, s4, s5;










1277












1278



    s0 = peg$currPos;




108,960✔






1279



    if (input.substr(peg$currPos, 2) === peg$c22) {





108,960✔






1280



      s1 = peg$c22;




99✔





1281



      peg$currPos += 2;




99✔





1282



    } else {










1283



      s1 = peg$FAILED;




108,861✔





1284



    }










1285



    if (s1 !== peg$FAILED) {





108,960✔





1286



      s2 = [];




99✔





1287



      s3 = peg$currPos;




99✔





1288



      s4 = peg$currPos;




99✔





1289



      peg$begin();




99✔






1290



      if (input.substr(peg$currPos, 2) === peg$c23) {





99✔






1291



        s5 = peg$c23;




24✔





1292



        peg$currPos += 2;




24✔





1293



      } else {










1294



        s5 = peg$FAILED;




75✔





1295



      }










1296



      peg$end(true);




99✔





1297



      if (s5 === peg$FAILED) {





99✔





1298



        s4 = undefined;




75✔





1299



      } else {










1300



        peg$currPos = s4;




24✔





1301



        s4 = peg$FAILED;




24✔





1302



      }










1303



      if (s4 !== peg$FAILED) {





99✔





1304



        s5 = peg$parseSourceCharacter();




75✔





1305



        if (s5 !== peg$FAILED) {





75!





1306



          s4 = [s4, s5];




75✔





1307



          s3 = s4;




75✔





1308



        } else {










1309



          peg$currPos = s3;




×







1310



          s3 = peg$FAILED;




×







1311



        }










1312



      } else {










1313



        peg$currPos = s3;




24✔





1314



        s3 = peg$FAILED;




24✔





1315



      }










1316



      while (s3 !== peg$FAILED) {




99✔





1317



        s2.push(s3);




279✔





1318



        s3 = peg$currPos;




279✔





1319



        s4 = peg$currPos;




279✔





1320



        peg$begin();




279✔






1321



        if (input.substr(peg$currPos, 2) === peg$c23) {





279✔






1322



          s5 = peg$c23;




75✔





1323



          peg$currPos += 2;




75✔





1324



        } else {










1325



          s5 = peg$FAILED;




204✔





1326



        }










1327



        peg$end(true);




279✔





1328



        if (s5 === peg$FAILED) {





279✔





1329



          s4 = undefined;




204✔





1330



        } else {










1331



          peg$currPos = s4;




75✔





1332



          s4 = peg$FAILED;




75✔





1333



        }










1334



        if (s4 !== peg$FAILED) {





279✔





1335



          s5 = peg$parseSourceCharacter();




204✔





1336



          if (s5 !== peg$FAILED) {





204!





1337



            s4 = [s4, s5];




204✔





1338



            s3 = s4;




204✔





1339



          } else {










1340



            peg$currPos = s3;




×







1341



            s3 = peg$FAILED;




×







1342



          }










1343



        } else {










1344



          peg$currPos = s3;




75✔





1345



          s3 = peg$FAILED;




75✔





1346



        }










1347



      }











1348



      if (input.substr(peg$currPos, 2) === peg$c23) {





99!






1349



        s3 = peg$c23;




99✔





1350



        peg$currPos += 2;




99✔





1351



      } else {










1352



        s3 = peg$FAILED;




×







1353



      }










1354



      if (s3 !== peg$FAILED) {





99!





1355



        s1 = [s1, s2, s3];




99✔





1356



        s0 = s1;




99✔





1357



      } else {










1358



        peg$currPos = s0;




×







1359



        s0 = peg$FAILED;




×







1360



      }










1361



    } else {










1362



      peg$currPos = s0;




108,861✔





1363



      s0 = peg$FAILED;




108,861✔





1364



    }










1365












1366



    return s0;




108,960✔





1367



  }










1368












1369



  function peg$parseMultiLineCommentNoLineTerminator() {










1370



    var s0, s1, s2, s3, s4, s5;










1371












1372



    s0 = peg$currPos;




6,399✔






1373



    if (peg$silentFails === 0) { peg$expect(peg$e16); }





6,399!






1374



    if (input.substr(peg$currPos, 2) === peg$c22) {





6,399✔






1375



      s1 = peg$c22;




15✔





1376



      peg$currPos += 2;




15✔





1377



    } else {










1378



      s1 = peg$FAILED;




6,384✔





1379



    }










1380



    if (s1 !== peg$FAILED) {





6,399✔





1381



      s2 = [];




15✔





1382



      s3 = peg$currPos;




15✔





1383



      s4 = peg$currPos;




15✔





1384



      peg$begin();




15✔






1385



      if (peg$silentFails === 0) { peg$expect(peg$e17); }





15!






1386



      if (input.substr(peg$currPos, 2) === peg$c23) {





15✔






1387



        s5 = peg$c23;




3✔





1388



        peg$currPos += 2;




3✔





1389



      } else {










1390



        s5 = peg$FAILED;




12✔





1391



      }










1392



      if (s5 === peg$FAILED) {





15✔





1393



        s5 = peg$parseLineTerminator();




12✔





1394



      }










1395



      peg$end(true);




15✔





1396



      if (s5 === peg$FAILED) {





15✔





1397



        s4 = undefined;




9✔





1398



      } else {










1399



        peg$currPos = s4;




6✔





1400



        s4 = peg$FAILED;




6✔





1401



      }










1402



      if (s4 !== peg$FAILED) {





15✔





1403



        s5 = peg$parseSourceCharacter();




9✔





1404



        if (s5 !== peg$FAILED) {





9!





1405



          s4 = [s4, s5];




9✔





1406



          s3 = s4;




9✔





1407



        } else {










1408



          peg$currPos = s3;




×







1409



          s3 = peg$FAILED;




×







1410



        }










1411



      } else {










1412



        peg$currPos = s3;




6✔





1413



        s3 = peg$FAILED;




6✔





1414



      }










1415



      while (s3 !== peg$FAILED) {




15✔





1416



        s2.push(s3);




39✔





1417



        s3 = peg$currPos;




39✔





1418



        s4 = peg$currPos;




39✔





1419



        peg$begin();




39✔






1420



        if (peg$silentFails === 0) { peg$expect(peg$e17); }





39!






1421



        if (input.substr(peg$currPos, 2) === peg$c23) {





39✔






1422



          s5 = peg$c23;




9✔





1423



          peg$currPos += 2;




9✔





1424



        } else {










1425



          s5 = peg$FAILED;




30✔





1426



        }










1427



        if (s5 === peg$FAILED) {





39✔





1428



          s5 = peg$parseLineTerminator();




30✔





1429



        }










1430



        peg$end(true);




39✔





1431



        if (s5 === peg$FAILED) {





39✔





1432



          s4 = undefined;




30✔





1433



        } else {










1434



          peg$currPos = s4;




9✔





1435



          s4 = peg$FAILED;




9✔





1436



        }










1437



        if (s4 !== peg$FAILED) {





39✔





1438



          s5 = peg$parseSourceCharacter();




30✔





1439



          if (s5 !== peg$FAILED) {





30!





1440



            s4 = [s4, s5];




30✔





1441



            s3 = s4;




30✔





1442



          } else {










1443



            peg$currPos = s3;




×







1444



            s3 = peg$FAILED;




×







1445



          }










1446



        } else {










1447



          peg$currPos = s3;




9✔





1448



          s3 = peg$FAILED;




9✔





1449



        }










1450



      }











1451



      if (peg$silentFails === 0) { peg$expect(peg$e17); }





15!






1452



      if (input.substr(peg$currPos, 2) === peg$c23) {





15✔






1453



        s3 = peg$c23;




12✔





1454



        peg$currPos += 2;




12✔





1455



      } else {










1456



        s3 = peg$FAILED;




3✔





1457



      }










1458



      if (s3 !== peg$FAILED) {





15✔





1459



        s1 = [s1, s2, s3];




12✔





1460



        s0 = s1;




12✔





1461



      } else {










1462



        peg$currPos = s0;




3✔





1463



        s0 = peg$FAILED;




3✔





1464



      }










1465



    } else {










1466



      peg$currPos = s0;




6,384✔





1467



      s0 = peg$FAILED;




6,384✔





1468



    }










1469












1470



    return s0;




6,399✔





1471



  }










1472












1473



  function peg$parseSingleLineComment() {










1474



    var s0, s1, s2, s3, s4, s5;










1475












1476



    s0 = peg$currPos;




115,248✔






1477



    if (peg$silentFails === 0) { peg$expect(peg$e18); }





115,248✔






1478



    if (input.substr(peg$currPos, 2) === peg$c24) {





115,248✔






1479



      s1 = peg$c24;




33✔





1480



      peg$currPos += 2;




33✔





1481



    } else {










1482



      s1 = peg$FAILED;




115,215✔





1483



    }










1484



    if (s1 !== peg$FAILED) {





115,248✔





1485



      s2 = [];




33✔





1486



      s3 = peg$currPos;




33✔





1487



      s4 = peg$currPos;




33✔





1488



      peg$begin();




33✔





1489



      s5 = peg$parseLineTerminator();




33✔





1490



      peg$end(true);




33✔





1491



      if (s5 === peg$FAILED) {





33✔





1492



        s4 = undefined;




27✔





1493



      } else {










1494



        peg$currPos = s4;




6✔





1495



        s4 = peg$FAILED;




6✔





1496



      }










1497



      if (s4 !== peg$FAILED) {





33✔





1498



        s5 = peg$parseSourceCharacter();




27✔





1499



        if (s5 !== peg$FAILED) {





27!





1500



          s4 = [s4, s5];




27✔





1501



          s3 = s4;




27✔





1502



        } else {










1503



          peg$currPos = s3;




×







1504



          s3 = peg$FAILED;




×







1505



        }










1506



      } else {










1507



        peg$currPos = s3;




6✔





1508



        s3 = peg$FAILED;




6✔





1509



      }










1510



      while (s3 !== peg$FAILED) {




33✔





1511



        s2.push(s3);




180✔





1512



        s3 = peg$currPos;




180✔





1513



        s4 = peg$currPos;




180✔





1514



        peg$begin();




180✔





1515



        s5 = peg$parseLineTerminator();




180✔





1516



        peg$end(true);




180✔





1517



        if (s5 === peg$FAILED) {





180✔





1518



          s4 = undefined;




153✔





1519



        } else {










1520



          peg$currPos = s4;




27✔





1521



          s4 = peg$FAILED;




27✔





1522



        }










1523



        if (s4 !== peg$FAILED) {





180✔





1524



          s5 = peg$parseSourceCharacter();




153✔





1525



          if (s5 !== peg$FAILED) {





153!





1526



            s4 = [s4, s5];




153✔





1527



            s3 = s4;




153✔





1528



          } else {










1529



            peg$currPos = s3;




×







1530



            s3 = peg$FAILED;




×







1531



          }










1532



        } else {










1533



          peg$currPos = s3;




27✔





1534



          s3 = peg$FAILED;




27✔





1535



        }










1536



      }










1537



      s1 = [s1, s2];




33✔





1538



      s0 = s1;




33✔





1539



    } else {










1540



      peg$currPos = s0;




115,215✔





1541



      s0 = peg$FAILED;




115,215✔





1542



    }










1543












1544



    return s0;




115,248✔





1545



  }










1546












1547



  function peg$parseIdentifier() {










1548



    var s0, s1;










1549












1550



    s0 = peg$currPos;




24,429✔





1551



    s1 = peg$parseIdentifierName();




24,429✔





1552



    if (s1 !== peg$FAILED) {





24,429✔





1553



      peg$savedPos = s0;




4,980✔






1554



      s1 = peg$f12(s1);




4,980✔





1555



    }










1556



    s0 = s1;




24,429✔





1557












1558



    return s0;




24,429✔





1559



  }










1560












1561



  function peg$parseIdentifierName() {










1562



    var s0, s1, s2, s3;










1563













1564



    if (peg$silentFails === 0) { peg$expect(peg$e19); }





67,548!





1565



    peg$silentFails++;




67,548✔





1566



    s0 = peg$currPos;




67,548✔





1567



    s1 = peg$parseIdentifierStart();




67,548✔





1568



    if (s1 !== peg$FAILED) {





67,548✔





1569



      s2 = [];




15,960✔





1570



      s3 = peg$parseIdentifierPart();




15,960✔





1571



      while (s3 !== peg$FAILED) {




15,960✔





1572



        s2.push(s3);




41,148✔





1573



        s3 = peg$parseIdentifierPart();




41,148✔





1574



      }










1575



      peg$savedPos = s0;




15,960✔






1576



      s0 = peg$f13(s1, s2);




15,960✔





1577



    } else {










1578



      peg$currPos = s0;




51,588✔





1579



      s0 = peg$FAILED;




51,588✔





1580



    }










1581



    peg$silentFails--;




67,548✔





1582












1583



    return s0;




67,548✔





1584



  }










1585












1586



  function peg$parseIdentifierStart() {










1587



    var s0, s1, s2;










1588












1589



    s0 = peg$parseUnicodeLetter();




124,656✔





1590



    if (s0 === peg$FAILED) {





124,656✔





1591



      if (input.charCodeAt(peg$currPos) === 36) {





67,770✔






1592



        s0 = peg$c3;




159✔





1593



        peg$currPos++;




159✔





1594



      } else {










1595



        s0 = peg$FAILED;




67,611✔





1596



      }










1597



      if (s0 === peg$FAILED) {





67,770✔





1598



        if (input.charCodeAt(peg$currPos) === 95) {





67,611✔






1599



          s0 = peg$c25;




9✔





1600



          peg$currPos++;




9✔





1601



        } else {










1602



          s0 = peg$FAILED;




67,602✔





1603



        }










1604



        if (s0 === peg$FAILED) {





67,611✔





1605



          s0 = peg$currPos;




67,602✔





1606



          if (input.charCodeAt(peg$currPos) === 92) {





67,602✔






1607



            s1 = peg$c26;




9✔





1608



            peg$currPos++;




9✔





1609



          } else {










1610



            s1 = peg$FAILED;




67,593✔





1611



          }










1612



          if (s1 !== peg$FAILED) {





67,602✔





1613



            s2 = peg$parseUnicodeEscapeSequence();




9✔





1614



            if (s2 !== peg$FAILED) {





9!





1615



              peg$savedPos = s0;




9✔






1616



              s0 = peg$f14(s2);




9✔





1617



            } else {










1618



              peg$currPos = s0;




×







1619



              s0 = peg$FAILED;




×







1620



            }










1621



          } else {










1622



            peg$currPos = s0;




67,593✔





1623



            s0 = peg$FAILED;




67,593✔





1624



          }










1625



        }










1626



      }










1627



    }










1628












1629



    return s0;




124,656✔





1630



  }










1631












1632



  function peg$parseIdentifierPart() {










1633



    var s0;










1634












1635



    s0 = peg$parseIdentifierStart();




57,108✔





1636



    if (s0 === peg$FAILED) {





57,108✔





1637



      s0 = peg$parseUnicodeCombiningMark();




16,005✔





1638



      if (s0 === peg$FAILED) {





16,005✔





1639



        s0 = peg$parseNd();




15,996✔





1640



        if (s0 === peg$FAILED) {





15,996✔





1641



          s0 = peg$parsePc();




15,987✔





1642



          if (s0 === peg$FAILED) {





15,987✔





1643



            if (input.charCodeAt(peg$currPos) === 8204) {





15,978✔






1644



              s0 = peg$c27;




9✔





1645



              peg$currPos++;




9✔





1646



            } else {










1647



              s0 = peg$FAILED;




15,969✔





1648



            }










1649



            if (s0 === peg$FAILED) {





15,978✔





1650



              if (input.charCodeAt(peg$currPos) === 8205) {





15,969✔






1651



                s0 = peg$c28;




9✔





1652



                peg$currPos++;




9✔





1653



              } else {










1654



                s0 = peg$FAILED;




15,960✔





1655



              }










1656



            }










1657



          }










1658



        }










1659



      }










1660



    }










1661












1662



    return s0;




57,108✔





1663



  }










1664












1665



  function peg$parseUnicodeLetter() {










1666



    var s0;










1667












1668



    s0 = peg$parseLu();




124,656✔





1669



    if (s0 === peg$FAILED) {





124,656✔





1670



      s0 = peg$parseLl();




123,144✔





1671



      if (s0 === peg$FAILED) {





123,144✔





1672



        s0 = peg$parseLt();




67,770✔





1673



        if (s0 === peg$FAILED) {





67,770!





1674



          s0 = peg$parseLm();




67,770✔





1675



          if (s0 === peg$FAILED) {





67,770!





1676



            s0 = peg$parseLo();




67,770✔





1677



            if (s0 === peg$FAILED) {





67,770!





1678



              s0 = peg$parseNl();




67,770✔





1679



            }










1680



          }










1681



        }










1682



      }










1683



    }










1684












1685



    return s0;




124,656✔





1686



  }










1687












1688



  function peg$parseUnicodeCombiningMark() {










1689



    var s0;










1690












1691



    s0 = peg$parseMn();




16,005✔





1692



    if (s0 === peg$FAILED) {





16,005✔





1693



      s0 = peg$parseMc();




15,996✔





1694



    }










1695












1696



    return s0;




16,005✔





1697



  }










1698












1699



  function peg$parseLiteralMatcher() {










1700



    var s0, s1, s2;










1701













1702



    if (peg$silentFails === 0) { peg$expect(peg$e20); }





50,193!





1703



    peg$silentFails++;




50,193✔





1704



    s0 = peg$currPos;




50,193✔





1705



    s1 = peg$parseStringLiteral();




50,193✔





1706



    if (s1 !== peg$FAILED) {





50,193✔





1707



      if (input.charCodeAt(peg$currPos) === 105) {





16,665✔






1708



        s2 = peg$c29;




90✔





1709



        peg$currPos++;




90✔





1710



      } else {










1711



        s2 = peg$FAILED;




16,575✔





1712



      }










1713



      if (s2 === peg$FAILED) {





16,665✔





1714



        s2 = null;




16,575✔





1715



      }










1716



      peg$savedPos = s0;




16,665✔






1717



      s0 = peg$f15(s1, s2);




16,665✔





1718



    } else {










1719



      peg$currPos = s0;




33,528✔





1720



      s0 = peg$FAILED;




33,528✔





1721



    }










1722



    peg$silentFails--;




50,193✔





1723












1724



    return s0;




50,193✔





1725



  }










1726












1727



  function peg$parseStringLiteral() {










1728



    var s0, s1, s2, s3;










1729













1730



    if (peg$silentFails === 0) { peg$expect(peg$e21); }





61,173✔





1731



    peg$silentFails++;




61,173✔





1732



    s0 = peg$currPos;




61,173✔





1733



    if (input.charCodeAt(peg$currPos) === 34) {





61,173✔






1734



      s1 = peg$c30;




60✔





1735



      peg$currPos++;




60✔





1736



    } else {










1737



      s1 = peg$FAILED;




61,113✔





1738



    }










1739



    if (s1 !== peg$FAILED) {





61,173✔





1740



      s2 = [];




60✔





1741



      s3 = peg$parseDoubleStringCharacter();




60✔





1742



      while (s3 !== peg$FAILED) {




60✔





1743



        s2.push(s3);




48✔





1744



        s3 = peg$parseDoubleStringCharacter();




48✔





1745



      }










1746



      if (input.charCodeAt(peg$currPos) === 34) {





60✔






1747



        s3 = peg$c30;




42✔





1748



        peg$currPos++;




42✔





1749



      } else {










1750



        s3 = peg$FAILED;




18✔





1751



      }










1752



      if (s3 !== peg$FAILED) {





60✔





1753



        peg$savedPos = s0;




42✔






1754



        s0 = peg$f16(s2);




42✔





1755



      } else {










1756



        peg$currPos = s0;




18✔





1757



        s0 = peg$FAILED;




18✔





1758



      }










1759



    } else {










1760



      peg$currPos = s0;




61,113✔





1761



      s0 = peg$FAILED;




61,113✔





1762



    }










1763



    if (s0 === peg$FAILED) {





61,173✔





1764



      s0 = peg$currPos;




61,131✔





1765



      if (input.charCodeAt(peg$currPos) === 39) {





61,131✔






1766



        s1 = peg$c31;




17,217✔





1767



        peg$currPos++;




17,217✔





1768



      } else {










1769



        s1 = peg$FAILED;




43,914✔





1770



      }










1771



      if (s1 !== peg$FAILED) {





61,131✔





1772



        s2 = [];




17,217✔





1773



        s3 = peg$parseSingleStringCharacter();




17,217✔





1774



        while (s3 !== peg$FAILED) {




17,217✔





1775



          s2.push(s3);




19,206✔





1776



          s3 = peg$parseSingleStringCharacter();




19,206✔





1777



        }










1778



        if (input.charCodeAt(peg$currPos) === 39) {





17,217✔






1779



          s3 = peg$c31;




17,169✔





1780



          peg$currPos++;




17,169✔





1781



        } else {










1782



          s3 = peg$FAILED;




48✔





1783



        }










1784



        if (s3 !== peg$FAILED) {





17,217✔





1785



          peg$savedPos = s0;




17,169✔






1786



          s0 = peg$f16(s2);




17,169✔





1787



        } else {










1788



          peg$currPos = s0;




48✔





1789



          s0 = peg$FAILED;




48✔





1790



        }










1791



      } else {










1792



        peg$currPos = s0;




43,914✔





1793



        s0 = peg$FAILED;




43,914✔





1794



      }










1795



    }










1796



    peg$silentFails--;




61,173✔





1797












1798



    return s0;




61,173✔





1799



  }










1800












1801



  function peg$parseDoubleStringCharacter() {










1802



    var s0, s1, s2;










1803












1804



    s0 = peg$currPos;




108✔





1805



    s1 = peg$currPos;




108✔





1806



    peg$begin();




108✔





1807



    if (input.charCodeAt(peg$currPos) === 34) {





108✔






1808



      s2 = peg$c30;




42✔





1809



      peg$currPos++;




42✔





1810



    } else {










1811



      s2 = peg$FAILED;




66✔





1812



    }










1813



    if (s2 === peg$FAILED) {





108✔





1814



      if (input.charCodeAt(peg$currPos) === 92) {





66✔






1815



        s2 = peg$c26;




18✔





1816



        peg$currPos++;




18✔





1817



      } else {










1818



        s2 = peg$FAILED;




48✔





1819



      }










1820



      if (s2 === peg$FAILED) {





66✔





1821



        s2 = peg$parseLineTerminator();




48✔





1822



      }










1823



    }










1824



    peg$end(true);




108✔





1825



    if (s2 === peg$FAILED) {





108✔





1826



      s1 = undefined;




42✔





1827



    } else {










1828



      peg$currPos = s1;




66✔





1829



      s1 = peg$FAILED;




66✔





1830



    }










1831



    if (s1 !== peg$FAILED) {





108✔





1832



      s2 = peg$parseSourceCharacter();




42✔





1833



      if (s2 !== peg$FAILED) {





42✔





1834



        peg$savedPos = s0;




30✔






1835



        s0 = peg$f17();




30✔





1836



      } else {










1837



        peg$currPos = s0;




12✔





1838



        s0 = peg$FAILED;




12✔





1839



      }










1840



    } else {










1841



      peg$currPos = s0;




66✔





1842



      s0 = peg$FAILED;




66✔





1843



    }










1844



    if (s0 === peg$FAILED) {





108✔





1845



      s0 = peg$currPos;




78✔





1846



      if (input.charCodeAt(peg$currPos) === 92) {





78✔






1847



        s1 = peg$c26;




18✔





1848



        peg$currPos++;




18✔





1849



      } else {










1850



        s1 = peg$FAILED;




60✔





1851



      }










1852



      if (s1 !== peg$FAILED) {





78✔





1853



        s2 = peg$parseEscapeSequence();




18✔





1854



        if (s2 !== peg$FAILED) {





18✔





1855



          peg$savedPos = s0;




12✔






1856



          s0 = peg$f14(s2);




12✔





1857



        } else {










1858



          peg$currPos = s0;




6✔





1859



          s0 = peg$FAILED;




6✔





1860



        }










1861



      } else {










1862



        peg$currPos = s0;




60✔





1863



        s0 = peg$FAILED;




60✔





1864



      }










1865



      if (s0 === peg$FAILED) {





78✔





1866



        s0 = peg$parseLineContinuation();




66✔





1867



      }










1868



    }










1869












1870



    return s0;




108✔





1871



  }










1872












1873



  function peg$parseSingleStringCharacter() {










1874



    var s0, s1, s2;










1875












1876



    s0 = peg$currPos;




36,423✔





1877



    s1 = peg$currPos;




36,423✔





1878



    peg$begin();




36,423✔





1879



    if (input.charCodeAt(peg$currPos) === 39) {





36,423✔






1880



      s2 = peg$c31;




17,169✔





1881



      peg$currPos++;




17,169✔





1882



    } else {










1883



      s2 = peg$FAILED;




19,254✔





1884



    }










1885



    if (s2 === peg$FAILED) {





36,423✔





1886



      if (input.charCodeAt(peg$currPos) === 92) {





19,254✔






1887



        s2 = peg$c26;




426✔





1888



        peg$currPos++;




426✔





1889



      } else {










1890



        s2 = peg$FAILED;




18,828✔





1891



      }










1892



      if (s2 === peg$FAILED) {





19,254✔





1893



        s2 = peg$parseLineTerminator();




18,828✔





1894



      }










1895



    }










1896



    peg$end(true);




36,423✔





1897



    if (s2 === peg$FAILED) {





36,423✔





1898



      s1 = undefined;




18,798✔





1899



    } else {










1900



      peg$currPos = s1;




17,625✔





1901



      s1 = peg$FAILED;




17,625✔





1902



    }










1903



    if (s1 !== peg$FAILED) {





36,423✔





1904



      s2 = peg$parseSourceCharacter();




18,798✔





1905



      if (s2 !== peg$FAILED) {





18,798✔





1906



        peg$savedPos = s0;




18,786✔






1907



        s0 = peg$f17();




18,786✔





1908



      } else {










1909



        peg$currPos = s0;




12✔





1910



        s0 = peg$FAILED;




12✔





1911



      }










1912



    } else {










1913



      peg$currPos = s0;




17,625✔





1914



      s0 = peg$FAILED;




17,625✔





1915



    }










1916



    if (s0 === peg$FAILED) {





36,423✔





1917



      s0 = peg$currPos;




17,637✔





1918



      if (input.charCodeAt(peg$currPos) === 92) {





17,637✔






1919



        s1 = peg$c26;




426✔





1920



        peg$currPos++;




426✔





1921



      } else {










1922



        s1 = peg$FAILED;




17,211✔





1923



      }










1924



      if (s1 !== peg$FAILED) {





17,637✔





1925



        s2 = peg$parseEscapeSequence();




426✔





1926



        if (s2 !== peg$FAILED) {





426✔





1927



          peg$savedPos = s0;




408✔






1928



          s0 = peg$f14(s2);




408✔





1929



        } else {










1930



          peg$currPos = s0;




18✔





1931



          s0 = peg$FAILED;




18✔





1932



        }










1933



      } else {










1934



        peg$currPos = s0;




17,211✔





1935



        s0 = peg$FAILED;




17,211✔





1936



      }










1937



      if (s0 === peg$FAILED) {





17,637✔





1938



        s0 = peg$parseLineContinuation();




17,229✔





1939



      }










1940



    }










1941












1942



    return s0;




36,423✔





1943



  }










1944












1945



  function peg$parseCharacterClassMatcher() {










1946



    var s0, s1, s2, s3, s4, s5;










1947













1948



    if (peg$silentFails === 0) { peg$expect(peg$e22); }





33,528!





1949



    peg$silentFails++;




33,528✔





1950



    s0 = peg$currPos;




33,528✔





1951



    if (input.charCodeAt(peg$currPos) === 91) {





33,528✔






1952



      s1 = peg$c32;




1,035✔





1953



      peg$currPos++;




1,035✔





1954



    } else {










1955



      s1 = peg$FAILED;




32,493✔





1956



    }










1957



    if (s1 !== peg$FAILED) {





33,528✔





1958



      if (input.charCodeAt(peg$currPos) === 94) {





1,035✔






1959



        s2 = peg$c33;




66✔





1960



        peg$currPos++;




66✔





1961



      } else {










1962



        s2 = peg$FAILED;




969✔





1963



      }










1964



      if (s2 === peg$FAILED) {





1,035✔





1965



        s2 = null;




969✔





1966



      }










1967



      s3 = [];




1,035✔





1968



      s4 = peg$parseClassCharacterRange();




1,035✔





1969



      if (s4 === peg$FAILED) {





1,032✔





1970



        s4 = peg$parseClassCharacter();




657✔





1971



      }










1972



      while (s4 !== peg$FAILED) {




1,032✔





1973



        s3.push(s4);




1,011✔





1974



        s4 = peg$parseClassCharacterRange();




1,011✔





1975



        if (s4 === peg$FAILED) {





1,011✔





1976



          s4 = peg$parseClassCharacter();




963✔





1977



        }










1978



      }










1979



      if (input.charCodeAt(peg$currPos) === 93) {





1,032✔






1980



        s4 = peg$c34;




1,020✔





1981



        peg$currPos++;




1,020✔





1982



      } else {










1983



        s4 = peg$FAILED;




12✔





1984



      }










1985



      if (s4 !== peg$FAILED) {





1,032✔





1986



        if (input.charCodeAt(peg$currPos) === 105) {





1,020✔






1987



          s5 = peg$c29;




84✔





1988



          peg$currPos++;




84✔





1989



        } else {










1990



          s5 = peg$FAILED;




936✔





1991



        }










1992



        if (s5 === peg$FAILED) {





1,020✔





1993



          s5 = null;




936✔





1994



        }










1995



        peg$savedPos = s0;




1,020✔






1996



        s0 = peg$f18(s2, s3, s5);




1,020✔





1997



      } else {










1998



        peg$currPos = s0;




12✔





1999



        s0 = peg$FAILED;




12✔





2000



      }










2001



    } else {










2002



      peg$currPos = s0;




32,493✔





2003



      s0 = peg$FAILED;




32,493✔





2004



    }










2005



    peg$silentFails--;




33,525✔





2006












2007



    return s0;




33,525✔





2008



  }










2009












2010



  function peg$parseClassCharacterRange() {










2011



    var s0, s1, s2, s3;










2012












2013



    s0 = peg$currPos;




2,046✔





2014



    s1 = peg$parseClassCharacter();




2,046✔





2015



    if (s1 !== peg$FAILED) {





2,046✔





2016



      if (input.charCodeAt(peg$currPos) === 45) {





1,014✔






2017



        s2 = peg$c35;




426✔





2018



        peg$currPos++;




426✔





2019



      } else {










2020



        s2 = peg$FAILED;




588✔





2021



      }










2022



      if (s2 !== peg$FAILED) {





1,014✔





2023



        s3 = peg$parseClassCharacter();




426✔





2024



        if (s3 !== peg$FAILED) {





426!





2025



          peg$savedPos = s0;




426✔






2026



          s0 = peg$f19(s1, s3);




426✔





2027



        } else {










2028



          peg$currPos = s0;




×







2029



          s0 = peg$FAILED;




×







2030



        }










2031



      } else {










2032



        peg$currPos = s0;




588✔





2033



        s0 = peg$FAILED;




588✔





2034



      }










2035



    } else {










2036



      peg$currPos = s0;




1,032✔





2037



      s0 = peg$FAILED;




1,032✔





2038



    }










2039












2040



    return s0;




2,043✔





2041



  }










2042












2043



  function peg$parseClassCharacter() {










2044



    var s0, s1, s2;










2045












2046



    s0 = peg$currPos;




4,092✔





2047



    s1 = peg$currPos;




4,092✔





2048



    peg$begin();




4,092✔





2049



    if (input.charCodeAt(peg$currPos) === 93) {





4,092✔






2050



      s2 = peg$c34;




2,040✔





2051



      peg$currPos++;




2,040✔





2052



    } else {










2053



      s2 = peg$FAILED;




2,052✔





2054



    }










2055



    if (s2 === peg$FAILED) {





4,092✔





2056



      if (input.charCodeAt(peg$currPos) === 92) {





2,052✔






2057



        s2 = peg$c26;




48✔





2058



        peg$currPos++;




48✔





2059



      } else {










2060



        s2 = peg$FAILED;




2,004✔





2061



      }










2062



      if (s2 === peg$FAILED) {





2,052✔





2063



        s2 = peg$parseLineTerminator();




2,004✔





2064



      }










2065



    }










2066



    peg$end(true);




4,092✔





2067



    if (s2 === peg$FAILED) {





4,092✔





2068



      s1 = undefined;




1,992✔





2069



    } else {










2070



      peg$currPos = s1;




2,100✔





2071



      s1 = peg$FAILED;




2,100✔





2072



    }










2073



    if (s1 !== peg$FAILED) {





4,092✔





2074



      s2 = peg$parseSourceCharacter();




1,992✔





2075



      if (s2 !== peg$FAILED) {





1,992✔





2076



        peg$savedPos = s0;




1,980✔






2077



        s0 = peg$f17();




1,980✔





2078



      } else {










2079



        peg$currPos = s0;




12✔





2080



        s0 = peg$FAILED;




12✔





2081



      }










2082



    } else {










2083



      peg$currPos = s0;




2,100✔





2084



      s0 = peg$FAILED;




2,100✔





2085



    }










2086



    if (s0 === peg$FAILED) {





4,092✔





2087



      s0 = peg$currPos;




2,112✔





2088



      if (input.charCodeAt(peg$currPos) === 92) {





2,112✔






2089



        s1 = peg$c26;




48✔





2090



        peg$currPos++;




48✔





2091



      } else {










2092



        s1 = peg$FAILED;




2,064✔





2093



      }










2094



      if (s1 !== peg$FAILED) {





2,112✔





2095



        s2 = peg$parseEscapeSequence();




48✔





2096



        if (s2 !== peg$FAILED) {





48✔





2097



          peg$savedPos = s0;




24✔






2098



          s0 = peg$f14(s2);




24✔





2099



        } else {










2100



          peg$currPos = s0;




24✔





2101



          s0 = peg$FAILED;




24✔





2102



        }










2103



      } else {










2104



        peg$currPos = s0;




2,064✔





2105



        s0 = peg$FAILED;




2,064✔





2106



      }










2107



      if (s0 === peg$FAILED) {





2,112✔





2108



        s0 = peg$parseLineContinuation();




2,088✔





2109



      }










2110



    }










2111












2112



    return s0;




4,092✔





2113



  }










2114












2115



  function peg$parseLineContinuation() {










2116



    var s0, s1, s2;










2117












2118



    s0 = peg$currPos;




19,383✔





2119



    if (input.charCodeAt(peg$currPos) === 92) {





19,383✔






2120



      s1 = peg$c26;




48✔





2121



      peg$currPos++;




48✔





2122



    } else {










2123



      s1 = peg$FAILED;




19,335✔





2124



    }










2125



    if (s1 !== peg$FAILED) {





19,383✔





2126



      s2 = peg$parseLineTerminatorSequence();




48✔





2127



      if (s2 !== peg$FAILED) {





48✔





2128



        peg$savedPos = s0;




42✔






2129



        s0 = peg$f20();




42✔





2130



      } else {










2131



        peg$currPos = s0;




6✔





2132



        s0 = peg$FAILED;




6✔





2133



      }










2134



    } else {










2135



      peg$currPos = s0;




19,335✔





2136



      s0 = peg$FAILED;




19,335✔





2137



    }










2138












2139



    return s0;




19,383✔





2140



  }










2141












2142



  function peg$parseEscapeSequence() {










2143



    var s0, s1, s2, s3;










2144












2145



    s0 = peg$parseCharacterEscapeSequence();




492✔





2146



    if (s0 === peg$FAILED) {





492✔





2147



      s0 = peg$currPos;




78✔





2148



      if (input.charCodeAt(peg$currPos) === 48) {





78✔






2149



        s1 = peg$c36;




12✔





2150



        peg$currPos++;




12✔





2151



      } else {










2152



        s1 = peg$FAILED;




66✔





2153



      }










2154



      if (s1 !== peg$FAILED) {





78✔





2155



        s2 = peg$currPos;




12✔





2156



        peg$begin();




12✔





2157



        s3 = peg$parseDecimalDigit();




12✔





2158



        peg$end(true);




12✔





2159



        if (s3 === peg$FAILED) {





12✔





2160



          s2 = undefined;




6✔





2161



        } else {










2162



          peg$currPos = s2;




6✔





2163



          s2 = peg$FAILED;




6✔





2164



        }










2165



        if (s2 !== peg$FAILED) {





12✔





2166



          peg$savedPos = s0;




6✔






2167



          s0 = peg$f21();




6✔





2168



        } else {










2169



          peg$currPos = s0;




6✔





2170



          s0 = peg$FAILED;




6✔





2171



        }










2172



      } else {










2173



        peg$currPos = s0;




66✔





2174



        s0 = peg$FAILED;




66✔





2175



      }










2176



      if (s0 === peg$FAILED) {





78✔





2177



        s0 = peg$parseHexEscapeSequence();




72✔





2178



        if (s0 === peg$FAILED) {





72✔





2179



          s0 = peg$parseUnicodeEscapeSequence();




60✔





2180



        }










2181



      }










2182



    }










2183












2184



    return s0;




492✔





2185



  }










2186












2187



  function peg$parseCharacterEscapeSequence() {










2188



    var s0;










2189












2190



    s0 = peg$parseSingleEscapeCharacter();




492✔





2191



    if (s0 === peg$FAILED) {





492✔





2192



      s0 = peg$parseNonEscapeCharacter();




102✔





2193



    }










2194












2195



    return s0;




492✔





2196



  }










2197












2198



  function peg$parseSingleEscapeCharacter() {










2199



    var s0, s1;










2200












2201



    if (input.charCodeAt(peg$currPos) === 39) {





594✔






2202



      s0 = peg$c31;




12✔





2203



      peg$currPos++;




12✔





2204



    } else {










2205



      s0 = peg$FAILED;




582✔





2206



    }










2207



    if (s0 === peg$FAILED) {





594✔





2208



      if (input.charCodeAt(peg$currPos) === 34) {





582✔






2209



        s0 = peg$c30;




12✔





2210



        peg$currPos++;




12✔





2211



      } else {










2212



        s0 = peg$FAILED;




570✔





2213



      }










2214



      if (s0 === peg$FAILED) {





582✔





2215



        if (input.charCodeAt(peg$currPos) === 92) {





570✔






2216



          s0 = peg$c26;




6✔





2217



          peg$currPos++;




6✔





2218



        } else {










2219



          s0 = peg$FAILED;




564✔





2220



        }










2221



        if (s0 === peg$FAILED) {





570✔





2222



          s0 = peg$currPos;




564✔





2223



          if (input.charCodeAt(peg$currPos) === 98) {





564✔






2224



            s1 = peg$c37;




6✔





2225



            peg$currPos++;




6✔





2226



          } else {










2227



            s1 = peg$FAILED;




558✔





2228



          }










2229



          if (s1 !== peg$FAILED) {





564✔





2230



            peg$savedPos = s0;




6✔






2231



            s1 = peg$f22();




6✔





2232



          }










2233



          s0 = s1;




564✔





2234



          if (s0 === peg$FAILED) {





564✔





2235



            s0 = peg$currPos;




558✔





2236



            if (input.charCodeAt(peg$currPos) === 102) {





558✔






2237



              s1 = peg$c38;




6✔





2238



              peg$currPos++;




6✔





2239



            } else {










2240



              s1 = peg$FAILED;




552✔





2241



            }










2242



            if (s1 !== peg$FAILED) {





558✔





2243



              peg$savedPos = s0;




6✔






2244



              s1 = peg$f23();




6✔





2245



            }










2246



            s0 = s1;




558✔





2247



            if (s0 === peg$FAILED) {





558✔





2248



              s0 = peg$currPos;




552✔





2249



              if (input.charCodeAt(peg$currPos) === 110) {





552✔






2250



                s1 = peg$c39;




234✔





2251



                peg$currPos++;




234✔





2252



              } else {










2253



                s1 = peg$FAILED;




318✔





2254



              }










2255



              if (s1 !== peg$FAILED) {





552✔





2256



                peg$savedPos = s0;




234✔






2257



                s1 = peg$f24();




234✔





2258



              }










2259



              s0 = s1;




552✔





2260



              if (s0 === peg$FAILED) {





552✔





2261



                s0 = peg$currPos;




318✔





2262



                if (input.charCodeAt(peg$currPos) === 114) {





318✔






2263



                  s1 = peg$c40;




102✔





2264



                  peg$currPos++;




102✔





2265



                } else {










2266



                  s1 = peg$FAILED;




216✔





2267



                }










2268



                if (s1 !== peg$FAILED) {





318✔





2269



                  peg$savedPos = s0;




102✔






2270



                  s1 = peg$f25();




102✔





2271



                }










2272



                s0 = s1;




318✔





2273



                if (s0 === peg$FAILED) {





318✔





2274



                  s0 = peg$currPos;




216✔





2275



                  if (input.charCodeAt(peg$currPos) === 116) {





216✔






2276



                    s1 = peg$c41;




6✔





2277



                    peg$currPos++;




6✔





2278



                  } else {










2279



                    s1 = peg$FAILED;




210✔





2280



                  }










2281



                  if (s1 !== peg$FAILED) {





216✔





2282



                    peg$savedPos = s0;




6✔






2283



                    s1 = peg$f26();




6✔





2284



                  }










2285



                  s0 = s1;




216✔





2286



                  if (s0 === peg$FAILED) {





216✔





2287



                    s0 = peg$currPos;




210✔





2288



                    if (input.charCodeAt(peg$currPos) === 118) {





210✔






2289



                      s1 = peg$c42;




6✔





2290



                      peg$currPos++;




6✔





2291



                    } else {










2292



                      s1 = peg$FAILED;




204✔





2293



                    }










2294



                    if (s1 !== peg$FAILED) {





210✔





2295



                      peg$savedPos = s0;




6✔






2296



                      s1 = peg$f27();




6✔





2297



                    }










2298



                    s0 = s1;




210✔





2299



                  }










2300



                }










2301



              }










2302



            }










2303



          }










2304



        }










2305



      }










2306



    }










2307












2308



    return s0;




594✔





2309



  }










2310












2311



  function peg$parseNonEscapeCharacter() {










2312



    var s0, s1, s2;










2313












2314



    s0 = peg$currPos;




102✔





2315



    s1 = peg$currPos;




102✔





2316



    peg$begin();




102✔





2317



    s2 = peg$parseEscapeCharacter();




102✔





2318



    if (s2 === peg$FAILED) {





102✔





2319



      s2 = peg$parseLineTerminator();




66✔





2320



    }










2321



    peg$end(true);




102✔





2322



    if (s2 === peg$FAILED) {





102✔





2323



      s1 = undefined;




24✔





2324



    } else {










2325



      peg$currPos = s1;




78✔





2326



      s1 = peg$FAILED;




78✔





2327



    }










2328



    if (s1 !== peg$FAILED) {





102✔





2329



      s2 = peg$parseSourceCharacter();




24✔





2330



      if (s2 !== peg$FAILED) {





24!





2331



        peg$savedPos = s0;




24✔






2332



        s0 = peg$f17();




24✔





2333



      } else {










2334



        peg$currPos = s0;




×







2335



        s0 = peg$FAILED;




×







2336



      }










2337



    } else {










2338



      peg$currPos = s0;




78✔





2339



      s0 = peg$FAILED;




78✔





2340



    }










2341












2342



    return s0;




102✔





2343



  }










2344












2345



  function peg$parseEscapeCharacter() {










2346



    var s0;










2347












2348



    s0 = peg$parseSingleEscapeCharacter();




102✔





2349



    if (s0 === peg$FAILED) {





102!





2350



      s0 = peg$parseDecimalDigit();




102✔





2351



      if (s0 === peg$FAILED) {





102✔





2352



        if (input.charCodeAt(peg$currPos) === 120) {





90✔






2353



          s0 = peg$c43;




12✔





2354



          peg$currPos++;




12✔





2355



        } else {










2356



          s0 = peg$FAILED;




78✔





2357



        }










2358



        if (s0 === peg$FAILED) {





90✔





2359



          if (input.charCodeAt(peg$currPos) === 117) {





78✔






2360



            s0 = peg$c44;




12✔





2361



            peg$currPos++;




12✔





2362



          } else {










2363



            s0 = peg$FAILED;




66✔





2364



          }










2365



        }










2366



      }










2367



    }










2368












2369



    return s0;




102✔





2370



  }










2371












2372



  function peg$parseHexEscapeSequence() {










2373



    var s0, s1, s2, s3, s4, s5;










2374












2375



    s0 = peg$currPos;




72✔





2376



    if (input.charCodeAt(peg$currPos) === 120) {





72✔






2377



      s1 = peg$c43;




12✔





2378



      peg$currPos++;




12✔





2379



    } else {










2380



      s1 = peg$FAILED;




60✔





2381



    }










2382



    if (s1 !== peg$FAILED) {





72✔





2383



      s2 = peg$currPos;




12✔





2384



      s3 = peg$currPos;




12✔





2385



      s4 = peg$parseHexDigit();




12✔





2386



      if (s4 !== peg$FAILED) {





12!





2387



        s5 = peg$parseHexDigit();




12✔





2388



        if (s5 !== peg$FAILED) {





12!





2389



          s4 = [s4, s5];




12✔





2390



          s3 = s4;




12✔





2391



        } else {










2392



          peg$currPos = s3;




×







2393



          s3 = peg$FAILED;




×







2394



        }










2395



      } else {










2396



        peg$currPos = s3;




×







2397



        s3 = peg$FAILED;




×







2398



      }










2399



      if (s3 !== peg$FAILED) {





12!





2400



        s2 = input.substring(s2, peg$currPos);




12✔





2401



      } else {










2402



        s2 = s3;




×







2403



      }










2404



      if (s2 !== peg$FAILED) {





12!





2405



        peg$savedPos = s0;




12✔






2406



        s0 = peg$f28(s2);




12✔





2407



      } else {










2408



        peg$currPos = s0;




×







2409



        s0 = peg$FAILED;




×







2410



      }










2411



    } else {










2412



      peg$currPos = s0;




60✔





2413



      s0 = peg$FAILED;




60✔





2414



    }










2415












2416



    return s0;




72✔





2417



  }










2418












2419



  function peg$parseUnicodeEscapeSequence() {










2420



    var s0, s1, s2, s3, s4, s5, s6, s7;










2421












2422



    s0 = peg$currPos;




69✔





2423



    if (input.charCodeAt(peg$currPos) === 117) {





69✔






2424



      s1 = peg$c44;




21✔





2425



      peg$currPos++;




21✔





2426



    } else {










2427



      s1 = peg$FAILED;




48✔





2428



    }










2429



    if (s1 !== peg$FAILED) {





69✔





2430



      s2 = peg$currPos;




21✔





2431



      s3 = peg$currPos;




21✔





2432



      s4 = peg$parseHexDigit();




21✔





2433



      if (s4 !== peg$FAILED) {





21!





2434



        s5 = peg$parseHexDigit();




21✔





2435



        if (s5 !== peg$FAILED) {





21!





2436



          s6 = peg$parseHexDigit();




21✔





2437



          if (s6 !== peg$FAILED) {





21!





2438



            s7 = peg$parseHexDigit();




21✔





2439



            if (s7 !== peg$FAILED) {





21!





2440



              s4 = [s4, s5, s6, s7];




21✔





2441



              s3 = s4;




21✔





2442



            } else {










2443



              peg$currPos = s3;




×







2444



              s3 = peg$FAILED;




×







2445



            }










2446



          } else {










2447



            peg$currPos = s3;




×







2448



            s3 = peg$FAILED;




×







2449



          }










2450



        } else {










2451



          peg$currPos = s3;




×







2452



          s3 = peg$FAILED;




×







2453



        }










2454



      } else {










2455



        peg$currPos = s3;




×







2456



        s3 = peg$FAILED;




×







2457



      }










2458



      if (s3 !== peg$FAILED) {





21!





2459



        s2 = input.substring(s2, peg$currPos);




21✔





2460



      } else {










2461



        s2 = s3;




×







2462



      }










2463



      if (s2 !== peg$FAILED) {





21!





2464



        peg$savedPos = s0;




21✔






2465



        s0 = peg$f28(s2);




21✔





2466



      } else {










2467



        peg$currPos = s0;




×







2468



        s0 = peg$FAILED;




×







2469



      }










2470



    } else {










2471



      peg$currPos = s0;




48✔





2472



      s0 = peg$FAILED;




48✔





2473



    }










2474












2475



    return s0;




69✔





2476



  }










2477












2478



  function peg$parseDecimalDigit() {










2479



    var s0;










2480













2481



    if (peg$r1.test(input.charAt(peg$currPos))) {





114✔





2482



      s0 = input.charAt(peg$currPos);




18✔





2483



      peg$currPos++;




18✔





2484



    } else {










2485



      s0 = peg$FAILED;




96✔





2486



    }










2487












2488



    return s0;




114✔





2489



  }










2490












2491



  function peg$parseHexDigit() {










2492



    var s0;










2493













2494



    if (peg$r2.test(input.charAt(peg$currPos))) {





108!





2495



      s0 = input.charAt(peg$currPos);




108✔





2496



      peg$currPos++;




108✔





2497



    } else {










2498



      s0 = peg$FAILED;




×







2499



    }










2500












2501



    return s0;




108✔





2502



  }










2503












2504



  function peg$parseAnyMatcher() {










2505



    var s0, s1;










2506












2507



    s0 = peg$currPos;




32,505✔






2508



    if (peg$silentFails === 0) { peg$expect(peg$e23); }





32,505!





2509



    if (input.charCodeAt(peg$currPos) === 46) {





32,505✔






2510



      s1 = peg$c45;




621✔





2511



      peg$currPos++;




621✔





2512



    } else {










2513



      s1 = peg$FAILED;




31,884✔





2514



    }










2515



    if (s1 !== peg$FAILED) {





32,505✔





2516



      peg$savedPos = s0;




621✔






2517



      s1 = peg$f29();




621✔





2518



    }










2519



    s0 = s1;




32,505✔





2520












2521



    return s0;




32,505✔





2522



  }










2523












2524



  function peg$parseCodeBlock() {










2525



    var s0, s1, s2, s3;










2526













2527



    if (peg$silentFails === 0) { peg$expect(peg$e24); }





17,982!





2528



    peg$silentFails++;




17,982✔





2529



    s0 = peg$currPos;




17,982✔





2530



    if (input.charCodeAt(peg$currPos) === 123) {





17,982✔






2531



      s1 = peg$c46;




4,506✔





2532



      peg$currPos++;




4,506✔





2533



    } else {










2534



      s1 = peg$FAILED;




13,476✔





2535



    }










2536



    if (s1 !== peg$FAILED) {





17,982✔





2537



      s2 = peg$parseCode();




4,506✔





2538



      if (input.charCodeAt(peg$currPos) === 125) {





4,506✔






2539



        s3 = peg$c47;




4,500✔





2540



        peg$currPos++;




4,500✔





2541



      } else {










2542



        s3 = peg$FAILED;




6✔





2543



      }










2544



      if (s3 !== peg$FAILED) {





4,506✔





2545



        peg$savedPos = s0;




4,500✔






2546



        s0 = peg$f30(s2);




4,500✔





2547



      } else {










2548



        peg$currPos = s0;




6✔





2549



        s0 = peg$FAILED;




6✔





2550



      }










2551



    } else {










2552



      peg$currPos = s0;




13,476✔





2553



      s0 = peg$FAILED;




13,476✔





2554



    }










2555



    if (s0 === peg$FAILED) {





17,982✔





2556



      s0 = peg$currPos;




13,482✔





2557



      if (input.charCodeAt(peg$currPos) === 123) {





13,482✔






2558



        s1 = peg$c46;




6✔





2559



        peg$currPos++;




6✔





2560



      } else {










2561



        s1 = peg$FAILED;




13,476✔





2562



      }










2563



      if (s1 !== peg$FAILED) {





13,482✔





2564



        peg$savedPos = s0;




6✔






2565



        s1 = peg$f31();




6✔





2566



      }










2567



      s0 = s1;




13,476✔





2568



    }










2569



    peg$silentFails--;




17,976✔





2570












2571



    return s0;




17,976✔





2572



  }










2573












2574



  function peg$parseCode() {










2575



    var s0, s1, s2, s3, s4, s5;










2576












2577



    s0 = peg$currPos;




4,890✔





2578



    s1 = [];




4,890✔





2579



    s2 = [];




4,890✔





2580



    s3 = peg$currPos;




4,890✔





2581



    s4 = peg$currPos;




4,890✔





2582



    peg$begin();




4,890✔






2583



    if (peg$r3.test(input.charAt(peg$currPos))) {





4,890✔





2584



      s5 = input.charAt(peg$currPos);




21✔





2585



      peg$currPos++;




21✔





2586



    } else {










2587



      s5 = peg$FAILED;




4,869✔





2588



    }










2589



    peg$end(true);




4,890✔





2590



    if (s5 === peg$FAILED) {





4,890✔





2591



      s4 = undefined;




4,869✔





2592



    } else {










2593



      peg$currPos = s4;




21✔





2594



      s4 = peg$FAILED;




21✔





2595



    }










2596



    if (s4 !== peg$FAILED) {





4,890✔





2597



      s5 = peg$parseSourceCharacter();




4,869✔





2598



      if (s5 !== peg$FAILED) {





4,869!





2599



        s4 = [s4, s5];




4,869✔





2600



        s3 = s4;




4,869✔





2601



      } else {










2602



        peg$currPos = s3;




×







2603



        s3 = peg$FAILED;




×







2604



      }










2605



    } else {










2606



      peg$currPos = s3;




21✔





2607



      s3 = peg$FAILED;




21✔





2608



    }










2609



    if (s3 !== peg$FAILED) {





4,890✔





2610



      while (s3 !== peg$FAILED) {




4,869✔





2611



        s2.push(s3);




90,261✔





2612



        s3 = peg$currPos;




90,261✔





2613



        s4 = peg$currPos;




90,261✔





2614



        peg$begin();




90,261✔






2615



        if (peg$r3.test(input.charAt(peg$currPos))) {





90,261✔





2616



          s5 = input.charAt(peg$currPos);




4,866✔





2617



          peg$currPos++;




4,866✔





2618



        } else {










2619



          s5 = peg$FAILED;




85,395✔





2620



        }










2621



        peg$end(true);




90,261✔





2622



        if (s5 === peg$FAILED) {





90,261✔





2623



          s4 = undefined;




85,395✔





2624



        } else {










2625



          peg$currPos = s4;




4,866✔





2626



          s4 = peg$FAILED;




4,866✔





2627



        }










2628



        if (s4 !== peg$FAILED) {





90,261✔





2629



          s5 = peg$parseSourceCharacter();




85,395✔





2630



          if (s5 !== peg$FAILED) {





85,395✔





2631



            s4 = [s4, s5];




85,392✔





2632



            s3 = s4;




85,392✔





2633



          } else {










2634



            peg$currPos = s3;




3✔





2635



            s3 = peg$FAILED;




3✔





2636



          }










2637



        } else {










2638



          peg$currPos = s3;




4,866✔





2639



          s3 = peg$FAILED;




4,866✔





2640



        }










2641



      }










2642



    } else {










2643



      s2 = peg$FAILED;




21✔





2644



    }










2645



    if (s2 === peg$FAILED) {





4,890✔





2646



      s2 = peg$currPos;




21✔





2647



      if (input.charCodeAt(peg$currPos) === 123) {





21✔






2648



        s3 = peg$c46;




9✔





2649



        peg$currPos++;




9✔





2650



      } else {










2651



        s3 = peg$FAILED;




12✔





2652



      }










2653



      if (s3 !== peg$FAILED) {





21✔





2654



        s4 = peg$parseCode();




9✔





2655



        if (input.charCodeAt(peg$currPos) === 125) {





9!






2656



          s5 = peg$c47;




9✔





2657



          peg$currPos++;




9✔





2658



        } else {










2659



          s5 = peg$FAILED;




×







2660



        }










2661



        if (s5 !== peg$FAILED) {





9!





2662



          s3 = [s3, s4, s5];




9✔





2663



          s2 = s3;




9✔





2664



        } else {










2665



          peg$currPos = s2;




×







2666



          s2 = peg$FAILED;




×







2667



        }










2668



      } else {










2669



        peg$currPos = s2;




12✔





2670



        s2 = peg$FAILED;




12✔





2671



      }










2672



    }










2673



    while (s2 !== peg$FAILED) {




4,890✔





2674



      s1.push(s2);




5,622✔





2675



      s2 = [];




5,622✔





2676



      s3 = peg$currPos;




5,622✔





2677



      s4 = peg$currPos;




5,622✔





2678



      peg$begin();




5,622✔






2679



      if (peg$r3.test(input.charAt(peg$currPos))) {





5,622✔





2680



        s5 = input.charAt(peg$currPos);




5,247✔





2681



        peg$currPos++;




5,247✔





2682



      } else {










2683



        s5 = peg$FAILED;




375✔





2684



      }










2685



      peg$end(true);




5,622✔





2686



      if (s5 === peg$FAILED) {





5,622✔





2687



        s4 = undefined;




375✔





2688



      } else {










2689



        peg$currPos = s4;




5,247✔





2690



        s4 = peg$FAILED;




5,247✔





2691



      }










2692



      if (s4 !== peg$FAILED) {





5,622✔





2693



        s5 = peg$parseSourceCharacter();




375✔





2694



        if (s5 !== peg$FAILED) {





375✔





2695



          s4 = [s4, s5];




369✔





2696



          s3 = s4;




369✔





2697



        } else {










2698



          peg$currPos = s3;




6✔





2699



          s3 = peg$FAILED;




6✔





2700



        }










2701



      } else {










2702



        peg$currPos = s3;




5,247✔





2703



        s3 = peg$FAILED;




5,247✔





2704



      }










2705



      if (s3 !== peg$FAILED) {





5,622✔





2706



        while (s3 !== peg$FAILED) {




369✔





2707



          s2.push(s3);




4,275✔





2708



          s3 = peg$currPos;




4,275✔





2709



          s4 = peg$currPos;




4,275✔





2710



          peg$begin();




4,275✔






2711



          if (peg$r3.test(input.charAt(peg$currPos))) {





4,275✔





2712



            s5 = input.charAt(peg$currPos);




369✔





2713



            peg$currPos++;




369✔





2714



          } else {










2715



            s5 = peg$FAILED;




3,906✔





2716



          }










2717



          peg$end(true);




4,275✔





2718



          if (s5 === peg$FAILED) {





4,275✔





2719



            s4 = undefined;




3,906✔





2720



          } else {










2721



            peg$currPos = s4;




369✔





2722



            s4 = peg$FAILED;




369✔





2723



          }










2724



          if (s4 !== peg$FAILED) {





4,275✔





2725



            s5 = peg$parseSourceCharacter();




3,906✔





2726



            if (s5 !== peg$FAILED) {





3,906!





2727



              s4 = [s4, s5];




3,906✔





2728



              s3 = s4;




3,906✔





2729



            } else {










2730



              peg$currPos = s3;




×







2731



              s3 = peg$FAILED;




×







2732



            }










2733



          } else {










2734



            peg$currPos = s3;




369✔





2735



            s3 = peg$FAILED;




369✔





2736



          }










2737



        }










2738



      } else {










2739



        s2 = peg$FAILED;




5,253✔





2740



      }










2741



      if (s2 === peg$FAILED) {





5,622✔





2742



        s2 = peg$currPos;




5,253✔





2743



        if (input.charCodeAt(peg$currPos) === 123) {





5,253✔






2744



          s3 = peg$c46;




375✔





2745



          peg$currPos++;




375✔





2746



        } else {










2747



          s3 = peg$FAILED;




4,878✔





2748



        }










2749



        if (s3 !== peg$FAILED) {





5,253✔





2750



          s4 = peg$parseCode();




375✔





2751



          if (input.charCodeAt(peg$currPos) === 125) {





375!






2752



            s5 = peg$c47;




375✔





2753



            peg$currPos++;




375✔





2754



          } else {










2755



            s5 = peg$FAILED;




×







2756



          }










2757



          if (s5 !== peg$FAILED) {





375!





2758



            s3 = [s3, s4, s5];




375✔





2759



            s2 = s3;




375✔





2760



          } else {










2761



            peg$currPos = s2;




×







2762



            s2 = peg$FAILED;




×







2763



          }










2764



        } else {










2765



          peg$currPos = s2;




4,878✔





2766



          s2 = peg$FAILED;




4,878✔





2767



        }










2768



      }










2769



    }










2770



    s0 = input.substring(s0, peg$currPos);




4,890✔





2771












2772



    return s0;




4,890✔





2773



  }










2774












2775



  function peg$parseLl() {










2776



    var s0;










2777













2778



    if (peg$r4.test(input.charAt(peg$currPos))) {





123,144✔





2779



      s0 = input.charAt(peg$currPos);




55,374✔





2780



      peg$currPos++;




55,374✔





2781



    } else {










2782



      s0 = peg$FAILED;




67,770✔





2783



    }










2784












2785



    return s0;




123,144✔





2786



  }










2787












2788



  function peg$parseLm() {










2789



    var s0;










2790













2791



    if (peg$r5.test(input.charAt(peg$currPos))) {





67,770!





2792



      s0 = input.charAt(peg$currPos);




×







2793



      peg$currPos++;




×







2794



    } else {










2795



      s0 = peg$FAILED;




67,770✔





2796



    }










2797












2798



    return s0;




67,770✔





2799



  }










2800












2801



  function peg$parseLo() {










2802



    var s0;










2803













2804



    if (peg$r6.test(input.charAt(peg$currPos))) {





67,770!





2805



      s0 = input.charAt(peg$currPos);




×







2806



      peg$currPos++;




×







2807



    } else {










2808



      s0 = peg$FAILED;




67,770✔





2809



    }










2810












2811



    return s0;




67,770✔





2812



  }










2813












2814



  function peg$parseLt() {










2815



    var s0;










2816













2817



    if (peg$r7.test(input.charAt(peg$currPos))) {





67,770!





2818



      s0 = input.charAt(peg$currPos);




×







2819



      peg$currPos++;




×







2820



    } else {










2821



      s0 = peg$FAILED;




67,770✔





2822



    }










2823












2824



    return s0;




67,770✔





2825



  }










2826












2827



  function peg$parseLu() {










2828



    var s0;










2829













2830



    if (peg$r8.test(input.charAt(peg$currPos))) {





124,656✔





2831



      s0 = input.charAt(peg$currPos);




1,512✔





2832



      peg$currPos++;




1,512✔





2833



    } else {










2834



      s0 = peg$FAILED;




123,144✔





2835



    }










2836












2837



    return s0;




124,656✔





2838



  }










2839












2840



  function peg$parseMc() {










2841



    var s0;










2842













2843



    if (peg$r9.test(input.charAt(peg$currPos))) {





15,996!





2844



      s0 = input.charAt(peg$currPos);




×







2845



      peg$currPos++;




×







2846



    } else {










2847



      s0 = peg$FAILED;




15,996✔





2848



    }










2849












2850



    return s0;




15,996✔





2851



  }










2852












2853



  function peg$parseMn() {










2854



    var s0;










2855













2856



    if (peg$r10.test(input.charAt(peg$currPos))) {





16,005✔





2857



      s0 = input.charAt(peg$currPos);




9✔





2858



      peg$currPos++;




9✔





2859



    } else {










2860



      s0 = peg$FAILED;




15,996✔





2861



    }










2862












2863



    return s0;




16,005✔





2864



  }










2865












2866



  function peg$parseNd() {










2867



    var s0;










2868













2869



    if (peg$r11.test(input.charAt(peg$currPos))) {





15,996✔





2870



      s0 = input.charAt(peg$currPos);




9✔





2871



      peg$currPos++;




9✔





2872



    } else {










2873



      s0 = peg$FAILED;




15,987✔





2874



    }










2875












2876



    return s0;




15,996✔





2877



  }










2878












2879



  function peg$parseNl() {










2880



    var s0;










2881













2882



    if (peg$r12.test(input.charAt(peg$currPos))) {





67,770!





2883



      s0 = input.charAt(peg$currPos);




×







2884



      peg$currPos++;




×







2885



    } else {










2886



      s0 = peg$FAILED;




67,770✔





2887



    }










2888












2889



    return s0;




67,770✔





2890



  }










2891












2892



  function peg$parsePc() {










2893



    var s0;










2894













2895



    if (peg$r13.test(input.charAt(peg$currPos))) {





15,987✔





2896



      s0 = input.charAt(peg$currPos);




9✔





2897



      peg$currPos++;




9✔





2898



    } else {










2899



      s0 = peg$FAILED;




15,978✔





2900



    }










2901












2902



    return s0;




15,987✔





2903



  }










2904












2905



  function peg$parseZs() {










2906



    var s0;










2907













2908



    if (peg$r14.test(input.charAt(peg$currPos))) {





121,857✔





2909



      s0 = input.charAt(peg$currPos);




3✔





2910



      peg$currPos++;




3✔





2911



    } else {










2912



      s0 = peg$FAILED;




121,854✔





2913



    }










2914












2915



    return s0;




121,857✔





2916



  }










2917












2918



  function peg$parse__() {










2919



    var s0, s1;










2920












2921



    s0 = [];




108,831✔





2922



    s1 = peg$parseWhiteSpace();




108,831✔





2923



    if (s1 === peg$FAILED) {





108,831✔





2924



      s1 = peg$parseLineTerminatorSequence();




73,707✔





2925



      if (s1 === peg$FAILED) {





73,707✔





2926



        s1 = peg$parseComment();




67,539✔





2927



      }










2928



    }










2929



    while (s1 !== peg$FAILED) {




108,831✔





2930



      s0.push(s1);




54,990✔





2931



      s1 = peg$parseWhiteSpace();




54,990✔





2932



      if (s1 === peg$FAILED) {





54,990✔





2933



        s1 = peg$parseLineTerminatorSequence();




41,748✔





2934



        if (s1 === peg$FAILED) {





41,748✔





2935



          s1 = peg$parseComment();




41,421✔





2936



        }










2937



      }










2938



    }










2939












2940



    return s0;




108,831✔





2941



  }










2942












2943



  function peg$parse_() {










2944



    var s0, s1;










2945












2946



    s0 = [];




6,387✔





2947



    s1 = peg$parseWhiteSpace();




6,387✔





2948



    if (s1 === peg$FAILED) {





6,387✔





2949



      s1 = peg$parseMultiLineCommentNoLineTerminator();




6,219✔





2950



    }










2951



    while (s1 !== peg$FAILED) {




6,387✔





2952



      s0.push(s1);




990✔





2953



      s1 = peg$parseWhiteSpace();




990✔





2954



      if (s1 === peg$FAILED) {





990✔





2955



        s1 = peg$parseMultiLineCommentNoLineTerminator();




180✔





2956



      }










2957



    }










2958












2959



    return s0;




6,387✔





2960



  }










2961












2962



  function peg$parseEOS() {










2963



    var s0, s1, s2, s3;










2964












2965



    s0 = peg$currPos;




6,417✔





2966



    s1 = peg$parse__();




6,417✔






2967



    if (peg$silentFails === 0) { peg$expect(peg$e25); }





6,417!





2968



    if (input.charCodeAt(peg$currPos) === 59) {





6,417✔






2969



      s2 = peg$c48;




30✔





2970



      peg$currPos++;




30✔





2971



    } else {










2972



      s2 = peg$FAILED;




6,387✔





2973



    }










2974



    if (s2 !== peg$FAILED) {





6,417✔





2975



      s1 = [s1, s2];




30✔





2976



      s0 = s1;




30✔





2977



    } else {










2978



      peg$currPos = s0;




6,387✔





2979



      s0 = peg$FAILED;




6,387✔





2980



    }










2981



    if (s0 === peg$FAILED) {





6,417✔





2982



      s0 = peg$currPos;




6,387✔





2983



      s1 = peg$parse_();




6,387✔





2984



      s2 = peg$parseSingleLineComment();




6,387✔





2985



      if (s2 === peg$FAILED) {





6,387✔





2986



        s2 = null;




6,384✔





2987



      }










2988



      s3 = peg$parseLineTerminatorSequence();




6,387✔





2989



      if (s3 !== peg$FAILED) {





6,387✔





2990



        s1 = [s1, s2, s3];




1,416✔





2991



        s0 = s1;




1,416✔





2992



      } else {










2993



        peg$currPos = s0;




4,971✔





2994



        s0 = peg$FAILED;




4,971✔





2995



      }










2996



      if (s0 === peg$FAILED) {





6,387✔





2997



        s0 = peg$currPos;




4,971✔





2998



        s1 = peg$parse__();




4,971✔





2999



        s2 = peg$parseEOF();




4,971✔





3000



        if (s2 !== peg$FAILED) {





4,971✔





3001



          s1 = [s1, s2];




4,953✔





3002



          s0 = s1;




4,953✔





3003



        } else {










3004



          peg$currPos = s0;




18✔





3005



          s0 = peg$FAILED;




18✔





3006



        }










3007



      }










3008



    }










3009












3010



    return s0;




6,417✔





3011



  }










3012












3013



  function peg$parseEOF() {










3014



    var s0, s1;










3015












3016



    s0 = peg$currPos;




4,971✔





3017



    peg$begin();




4,971✔






3018



    if (peg$silentFails === 0) { peg$expect(peg$e11); }





4,971!





3019



    if (input.length > peg$currPos) {





4,971✔





3020



      s1 = input.charAt(peg$currPos);




18✔





3021



      peg$currPos++;




18✔





3022



    } else {










3023



      s1 = peg$FAILED;




4,953✔





3024



    }










3025



    peg$end(true);




4,971✔





3026



    if (s1 === peg$FAILED) {





4,971✔





3027



      s0 = undefined;




4,953✔





3028



    } else {










3029



      peg$currPos = s0;




18✔





3030



      s0 = peg$FAILED;




18✔





3031



    }










3032












3033



    return s0;




4,971✔





3034



  }










3035












3036












3037



    const OPS_TO_PREFIXED_TYPES = {




5,193✔





3038



      "$": "text",










3039



      "&": "simple_and",










3040



      "!": "simple_not"










3041



    };










3042












3043



    const OPS_TO_SUFFIXED_TYPES = {




5,193✔





3044



      "?": "optional",










3045



      "*": "zero_or_more",










3046



      "+": "one_or_more"










3047



    };










3048












3049



    const OPS_TO_SEMANTIC_PREDICATE_TYPES = {




5,193✔





3050



      "&": "semantic_and",










3051



      "!": "semantic_not"










3052



    };










3053












3054



    const RESERVED_WORDS = [




5,193✔





3055



      "break",










3056



      "case",










3057



      "catch",










3058



      "class",










3059



      "const",










3060



      "continue",










3061



      "debugger",










3062



      "default",










3063



      "delete",










3064



      "do",










3065



      "else",










3066



      "enum",










3067



      "export",










3068



      "extends",










3069



      "false",










3070



      "finally",










3071



      "for",










3072



      "function",










3073



      "if",










3074



      "import",










3075



      "instanceof",










3076



      "in",










3077



      "new",










3078



      "null",










3079



      "return",










3080



      "super",










3081



      "switch",










3082



      "this",










3083



      "throw",










3084



      "true",










3085



      "try",










3086



      "typeof",










3087



      "var",










3088



      "void",










3089



      "while",










3090



      "with"










3091



    ];










3092












3093



    function extractOptional(optional, index) {










3094



      return optional ? optional[index] : null;





5,004✔





3095



    }










3096












3097



    function extractList(list, index) {










3098



      return list.map(element => element[index]);




11,187✔





3099



    }










3100












3101



    function buildList(head, tail, index) {










3102



      return [head].concat(extractList(tail, index));




3,936✔





3103



    }










3104












3105



    function createNode( type, details ) {










3106



      const node = new ast.Node( type, location() );




42,918✔





3107



      util.extend( node, details );




42,918✔






3108



      return util.enforceFastProperties( node );




42,918✔





3109



    }










3110












3111












3112



  peg$begin();




5,193✔





3113



  peg$result = peg$startRuleFunction();




5,193✔





3114












3115



  if (peg$result !== peg$FAILED && peg$currPos === input.length) {





5,076✔





3116



    return peg$result;




5,004✔





3117



  } else {










3118



    if (peg$result !== peg$FAILED && peg$currPos < input.length) {





72!





3119



      peg$expect(peg$endExpectation());




×







3120



    }










3121












3122



    throw peg$buildError();




72✔





3123



  }










3124



}










3125












3126



module.exports = {




3✔





3127



  SyntaxError: peg$SyntaxError,










3128



  parse: peg$parse










3129



};
























    

  • 

    •