text: /* parser generated by jison 0.4.18 */
  /*
    Returns a Parser object of the following structure:
  
    Parser: {
      yy: {}
    }
  
    Parser.prototype: {
      yy: {},
      trace: function(),
      symbols_: {associative list: name ==> number},
      terminals_: {associative list: number ==> name},
      productions_: [...],
      performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
      table: [...],
      defaultActions: {...},
      parseError: function(str, hash),
      parse: function(input),
  
      lexer: {
          EOF: 1,
          parseError: function(str, hash),
          setInput: function(input),
          input: function(),
          unput: function(str),
          more: function(),
          less: function(n),
          pastInput: function(),
          upcomingInput: function(),
          showPosition: function(),
          test_match: function(regex_match_array, rule_index),
          next: function(),
          lex: function(),
          begin: function(condition),
          popState: function(),
          _currentRules: function(),
          topState: function(),
          pushState: function(condition),
  
          options: {
              ranges: boolean           (optional: true ==> token location info will include a .range[] member)
              flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
              backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
          },
  
          performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
          rules: [...],
          conditions: {associative list: name ==> set},
      }
    }
  
  
    token location info (@$, _$, etc.): {
      first_line: n,
      last_line: n,
      first_column: n,
      last_column: n,
      range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
    }
  
  
    the parseError function receives a 'hash' object with these members for lexer and parser errors: {
      text:        (matched text)
      token:       (the produced terminal token, if any)
      line:        (yylineno)
    }
    while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
      loc:         (yylloc)
      expected:    (string describing the set of expected tokens)
      recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
    }
  */
  <<<<<<< HEAD
  var gramaticaXPath = (function() {
      var o = function(k, v, o, l) { for (o = o || {}, l = k.length; l--; o[k[l]] = v); return o },
          $V0 = [1, 5],
          $V1 = [1, 6],
          $V2 = [1, 8],
          $V3 = [1, 12],
          $V4 = [1, 19],
          $V5 = [1, 20],
          $V6 = [1, 21],
          $V7 = [1, 22],
          $V8 = [1, 23],
          $V9 = [1, 24],
          $Va = [1, 25],
          $Vb = [1, 26],
          $Vc = [1, 27],
          $Vd = [1, 28],
          $Ve = [1, 29],
          $Vf = [1, 30],
          $Vg = [1, 31],
          $Vh = [1, 13],
          $Vi = [1, 14],
          $Vj = [1, 15],
          $Vk = [1, 16],
          $Vl = [1, 17],
          $Vm = [1, 18],
          $Vn = [1, 36],
          $Vo = [1, 37],
          $Vp = [1, 35],
          $Vq = [8, 12, 13, 20, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 59, 60],
          $Vr = [5, 8, 9, 12],
          $Vs = [5, 8, 9, 12, 20, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34],
          $Vt = [1, 40],
          $Vu = [5, 8, 9, 12, 20, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 39],
          $Vv = [13, 25, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 59, 60],
          $Vw = [5, 8, 9, 12, 18, 20, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34],
          $Vx = [1, 54],
          $Vy = [1, 55],
          $Vz = [1, 56],
          $VA = [8, 12, 20, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34],
          $VB = [8, 9, 13, 25, 35, 36, 37, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 59, 60];
      var parser = {
          trace: function trace() {},
          yy: {},
          symbols_: { "error": 2, "ini": 3, "XPATH": 4, "EOF": 5, "ENTRY": 6, "LIST_STEP": 7, "slash": 8, "doubleSlash": 9, "STEP": 10, "LIST_STEPP": 11, "SEPARATE": 12, "PREDICATE": 13, "corcheteIzq": 14, "LIST_E": 15, "corcheteDer": 16, "E": 17, "LIST_EP": 18, "OP": 19, "add": 20, "minus": 21, "asterisk": 22, "equal": 23, "diferent": 24, "menor": 25, "menorIgual": 26, "mayorIgual": 27, "mayor": 28, "or": 29, "barra": 30, "and": 31, "mod": 32, "decimal": 33, "digits": 34, "cadena": 35, "AXIS": 36, "AXIS_NAME": 37, "doubleColon": 38, "ancestor": 39, "ancestor_or_self": 40, "attribute": 41, "child": 42, "descendant": 43, "descendant_or_self": 44, "following": 45, "following_sibling": 46, "namespace": 47, "parent": 48, "preceding": 49, "preceding_sibling": 50, "self": 51, "WILDCARD": 52, "twoPoint": 53, "point": 54, "at": 55, "id": 56, "node": 57, "parIzq": 58, "parDer": 59, "text": 60, "last": 61, "$accept": 0, "$end": 1 },
          terminals_: { 2: "error", 5: "EOF", 8: "slash", 9: "doubleSlash", 10: "STEP", 12: "SEPARATE", 14: "corcheteIzq", 16: "corcheteDer", 20: "add", 21: "minus", 22: "asterisk", 23: "equal", 24: "diferent", 25: "menor", 26: "menorIgual", 27: "mayorIgual", 28: "mayor", 29: "or", 30: "barra", 31: "and", 32: "mod", 33: "decimal", 34: "digits", 35: "cadena", 38: "doubleColon", 39: "ancestor", 40: "ancestor_or_self", 41: "attribute", 42: "child", 43: "descendant", 44: "descendant_or_self", 45: "following", 46: "following_sibling", 47: "namespace", 48: "parent", 49: "preceding", 50: "preceding_sibling", 51: "self", 53: "twoPoint", 54: "point", 55: "at", 56: "id", 57: "node", 58: "parIzq", 59: "parDer", 60: "text", 61: "last" },
          productions_: [0, [3, 2],
              [4, 2],
              [4, 1],
              [6, 1],
              [6, 1],
              [7, 2],
              [11, 3],
              [11, 0],
              [13, 3],
              [15, 2],
              [18, 3],
              [18, 0],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [19, 1],
              [17, 1],
              [17, 1],
              [17, 1],
              [17, 1],
              [17, 1],
              [36, 3],
              [36, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [37, 1],
              [52, 1],
              [52, 1],
              [52, 1],
              [52, 2],
              [52, 3],
              [52, 2],
              [52, 3],
              [52, 3],
              [52, 3]
          ],
          performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */ , $$ /* vstack */ , _$ /* lstack */ ) {
              /* this == yyval */
  
              var $0 = $$.length - 1;
              switch (yystate) {
                  case 1:
  
                      this.$ = new NodeDesc('INI');
                      this.$.setChild($$[$0 - 1]);
                      return this.$;
  
                      break;
                  case 2:
  
                      this.$ = new NodeDesc('XPATH');
                      this.$.setChild($$[$0 - 1]);
                      this.$.setChild($$[$0]);
  
  
                      break;
                  case 3:
  
                      this.$ = new NodeDesc('XPATH');
                      this.$.setChild($$[$0]);
  
                      break;
                  case 4:
                  case 5:
  
                      this.$ = new NodeDesc('ENTRY');
                      this.$.setChild($$[$0]);
  
                      break;
                  case 6:
  
                      this.$ = new NodeDesc('LIST_STEP');
                      this.$.setChild($$[$0 - 1]);
                      this.$.setChild($$[$0]);
  
  
                      break;
                  case 7:
  
                      this.$ = new nodo("list_step", new Array($$[$0]));
                      p.getGramatica("list_step")
                      break;
                  case 8:
                      this.$ = new nodo("seperate", new Array($$[$0 - 1], $$[$0]));
                      p.getGramatica("seperate")
                      break;
                  case 9:
                  case 10:
                  case 11:
                      this.$ = new nodo("seperate", new Array($$[$0]));
                      p.getGramatica("seperate")
                      break;
                  case 12:
                      this.$ = new nodo("step", new Array($$[$0 - 1], $$[$0]));
                      p.getGramatica("step")
                      break;
                  case 13:
                  case 14:
                  case 15:
                      this.$ = new nodo("step", new Array($$[$0]));
                      p.getGramatica("step")
                      break;
                  case 16:
                      this.$ = new nodo("list_e", new Array($$[$0 - 1], $$[$0]));
                      p.getGramatica("list_pred")
                      break;
                  case 17:
                      this.$ = new nodo("list_e", new Array($$[$0]));
                      p.getGramatica("list_pred")
                      break;
                  case 18:
                      this.$ = new nodo("predicate", new Array($$[$0 - 2], $$[$0 - 1], $$[$0]));
                      p.getGramatica("predicate")
                      break;
                  case 19:
                      this.$ = new nodo("list_e", new Array($$[$0 - 2], $$[$0 - 1], $$[$0]));
                      p.getGramatica("list_e")
                      break;
                  case 20:
                      this.$ = new nodo("list_e", new Array($$[$0]));
                      p.getGramatica("list_e")
  
                      break;
                  case 9:
  
                      this.$ = new NodeDesc(`PREDICATE`);
                      this.$.setChild($$[$0 - 2]);
                      this.$.setChild($$[$0 - 1]);
  
                      break;
                  case 10:
  
                      this.$ = new NodeDesc(`LIST_E`);
                      this.$.setChild($$[$0 - 1]);
                      this.$.setChild($$[$0]);
  
                      break;
                  case 11:
  
                      this.$ = new NodeDesc(`LIST_E'`);
                      this.$.setChild($$[$0 - 2]);
                      this.$.setChild($$[$0 - 1]);
                      this.$.setChild($$[$0]);
  
                      break;
                  case 13:
                  case 14:
                  case 15:
                  case 16:
                  case 17:
                  case 18:
                  case 19:
                  case 20:
                  case 21:
                  case 22:
                  case 23:
                  case 24:
                  case 25:
                  case 26:
  
                      this.$ = new NodeDesc(`OP`);
                      this.$.setChild($$[$0]);
  
                      break;
                  case 27:
                  case 28:
                  case 29:
                  case 30:
                  case 31:
  
                      this.$ = new NodeDesc(`E`);
                      this.$.setChild($$[$0]);
  
                      break;
                  case 32:
  
                      this.$ = new NodeDesc(`AXIS`);
                      this.$.setChild($$[$0 - 2]);
                      this.$.setChild($$[$0 - 1]);
                      this.$.setChild($$[$0]);
  
                      break;
                  case 33:
  
                      this.$ = new NodeDesc(`AXIS`);
                      this.$.setChild($$[$0]);
  
                      break;
                  case 34:
                  case 35:
                  case 36:
                  case 37:
                  case 38:
                  case 39:
                  case 40:
                  case 41:
                  case 42:
                  case 43:
                  case 44:
                  case 45:
                  case 46:
  
                      this.$ = new NodeDesc(`AXIS_NAME`);
                      this.$.setChild($$[$0]);
  
                      break;
                  case 47:
                  case 48:
                  case 49:
  
                      this.$ = new NodeDesc(`WILDCARD`);
                      this.$.setChild($$[$0]);
  
                      break;
                  case 50:
                  case 52:
  
                      this.$ = new NodeDesc(`WILDCARD`);
                      this.$.setChild($$[$0 - 1]);
                      this.$.setChild($$[$0]);
  
                      break;
                  case 51:
                  case 53:
                  case 54:
                  case 55:
  
                      this.$ = new NodeDesc(`WILDCARD`);
                      this.$.setChild($$[$0 - 2]);
                      this.$.setChild($$[$0 - 1]);
                      this.$.setChild($$[$0]);
  
                      break;
  =======
  var gramaticaXPath = (function(){
  var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,5],$V1=[1,6],$V2=[1,8],$V3=[1,12],$V4=[1,19],$V5=[1,20],$V6=[1,21],$V7=[1,22],$V8=[1,23],$V9=[1,24],$Va=[1,25],$Vb=[1,26],$Vc=[1,27],$Vd=[1,28],$Ve=[1,29],$Vf=[1,30],$Vg=[1,31],$Vh=[1,13],$Vi=[1,14],$Vj=[1,15],$Vk=[1,16],$Vl=[1,17],$Vm=[1,18],$Vn=[1,36],$Vo=[1,37],$Vp=[1,35],$Vq=[8,12,13,20,23,24,25,26,27,28,29,30,31,32,33,34,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,59,60],$Vr=[5,8,9,12],$Vs=[5,8,9,12,20,23,24,25,26,27,28,29,30,31,32,33,34],$Vt=[1,40],$Vu=[5,8,9,12,20,23,24,25,26,27,28,29,30,31,32,33,34,39],$Vv=[13,25,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,59,60],$Vw=[5,8,9,12,18,20,23,24,25,26,27,28,29,30,31,32,33,34],$Vx=[1,54],$Vy=[1,55],$Vz=[1,56],$VA=[8,12,20,23,24,25,26,27,28,29,30,31,32,33,34],$VB=[8,9,13,25,35,36,37,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,59,60];
  var parser = {trace: function trace () { },
  yy: {},
  symbols_: {"error":2,"ini":3,"XPATH":4,"EOF":5,"ENTRY":6,"LIST_STEP":7,"slash":8,"doubleSlash":9,"SEPERATE":10,"STEP":11,"barra":12,"id":13,"LIST_PREDICATE":14,"AXIS":15,"WILDCARD":16,"PREDICATE":17,"corcheteIzq":18,"LIST_E":19,"corcheteDer":20,"OP":21,"E":22,"add":23,"minus":24,"asterisk":25,"equal":26,"diferent":27,"menor":28,"menorIgual":29,"mayorIgual":30,"mayor":31,"or":32,"and":33,"mod":34,"decimal":35,"digits":36,"cadena":37,"AXIS_NAME":38,"doubleColon":39,"ancestor":40,"ancestor_or_self":41,"attribute":42,"child":43,"descendant":44,"descendant_or_self":45,"following":46,"following_sibling":47,"namespace":48,"parent":49,"preceding":50,"preceding_sibling":51,"self":52,"point":53,"twoPoint":54,"at":55,"node":56,"parIzq":57,"parDer":58,"text":59,"last":60,"$accept":0,"$end":1},
  terminals_: {2:"error",5:"EOF",8:"slash",9:"doubleSlash",12:"barra",13:"id",18:"corcheteIzq",20:"corcheteDer",23:"add",24:"minus",25:"asterisk",26:"equal",27:"diferent",28:"menor",29:"menorIgual",30:"mayorIgual",31:"mayor",32:"or",33:"and",34:"mod",35:"decimal",36:"digits",37:"cadena",39:"doubleColon",40:"ancestor",41:"ancestor_or_self",42:"attribute",43:"child",44:"descendant",45:"descendant_or_self",46:"following",47:"following_sibling",48:"namespace",49:"parent",50:"preceding",51:"preceding_sibling",52:"self",53:"point",54:"twoPoint",55:"at",56:"node",57:"parIzq",58:"parDer",59:"text",60:"last"},
  productions_: [0,[3,2],[4,2],[4,1],[6,1],[6,1],[7,3],[7,1],[10,2],[10,1],[10,1],[10,1],[11,2],[11,1],[11,1],[11,1],[14,2],[14,1],[17,3],[19,3],[19,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[22,1],[22,1],[22,1],[22,1],[22,1],[15,3],[15,1],[38,1],[38,1],[38,1],[38,1],[38,1],[38,1],[38,1],[38,1],[38,1],[38,1],[38,1],[38,1],[38,1],[16,1],[16,1],[16,1],[16,2],[16,3],[16,2],[16,3],[16,3],[16,3]],
  performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
  /* this == yyval */
  
  var $0 = $$.length - 1;
  switch (yystate) {
  case 1:
  /*console.log(p.getGramatica('ini'));*/ return new tree($$[$0-1],p.getGramatica("ini"));
  break;
  case 2:
  this.$=new nodo("xpath", new Array($$[$0-1],$$[$0]));p.getGramatica("xpath")
  break;
  case 3:
  this.$=new nodo("xpath", new Array($$[$0]));p.getGramatica("xpath")
  break;
  case 4:
  this.$=new nodo("entry", new Array($$[$0]));p.getGramatica("entry")
  break;
  case 5:
  this.$=new nodo("entry", new Array($$[$0]));p.getGramatica("entry") 
  break;
  case 6:
  this.$=new nodo("list_step", new Array($$[$0-2],$$[$0-1],$$[$0]));p.getGramatica("list_step")
  break;
  case 7:
  this.$=new nodo("list_step", new Array($$[$0]));p.getGramatica("list_step")
  break;
  case 8:
  this.$=new nodo("seperate", new Array($$[$0-1],$$[$0]));p.getGramatica("seperate")
  break;
  case 9: case 10: case 11:
  this.$=new nodo("seperate", new Array($$[$0]));p.getGramatica("seperate")
  break;
  case 12:
  this.$=new nodo("step", new Array($$[$0-1],$$[$0]));p.getGramatica("step")
  break;
  case 13: case 14: case 15:
  this.$=new nodo("step", new Array($$[$0]));p.getGramatica("step")
  break;
  case 16:
  this.$=new nodo("list_e", new Array($$[$0-1],$$[$0]));p.getGramatica("list_pred")
  break;
  case 17:
  this.$=new nodo("list_e", new Array($$[$0]));p.getGramatica("list_pred")
  break;
  case 18:
  this.$=new nodo("predicate", new Array($$[$0-2],$$[$0-1],$$[$0]));p.getGramatica("predicate")
  break;
  case 19:
  this.$=new nodo("list_e", new Array($$[$0-2],$$[$0-1],$$[$0]));p.getGramatica("list_e")
  break;
  case 20:
  this.$=new nodo("list_e", new Array($$[$0]));p.getGramatica("list_e")
  break;
  case 21: case 22: case 23: case 24: case 25: case 26: case 27: case 28: case 29: case 30: case 31: case 32: case 33: case 34:
  this.$=new nodo("operador", new Array($$[$0]));p.getGramatica("op")
  break;
  case 35: case 36: case 37: case 38: case 39:
  this.$=new nodo("E", new Array($$[$0]));p.getGramatica("e")
  break;
  case 40:
  this.$=new nodo("axis", new Array($$[$0-2],$$[$0-1],$$[$0]));p.getGramatica("axis")
  break;
  case 41:
  this.$=new nodo("axis", new Array($$[$0]));p.getGramatica("axis")
  break;
  case 42: case 43: case 44: case 45: case 46: case 47: case 48: case 49: case 50: case 51: case 52: case 53: case 54:
  this.$=new nodo("axis_name", new Array($$[$0]));p.getGramatica("axis_name")
  break;
  case 55: case 56: case 57:
  this.$=new nodo("wildcards", new Array($$[$0]));p.getGramatica("wild")
  break;
  case 58:
  this.$=new nodo("wildcard", new Array($$[$0-1],$$[$0]));p.getGramatica("wild") 
  break;
  case 59: case 62:
  this.$=new nodo("wildcards", new Array($$[$0-2],$$[$0-1],$$[$0]));p.getGramatica("wild")
  break;
  case 60:
  this.$=new nodo("wildcards", new Array($$[$0-1],$$[$0]));p.getGramatica("wild")
  break;
  case 61:
  this.$=new nodo("wildcards", new Array($$[$0-2]));p.getGramatica("wild")
  break;
  case 63:
  this.$=new nodo("wildcard", new Array($$[$0-2],$$[$0-1],$$[$0]));p.getGramatica("wild")
  break;
  }
  },
  table: [{3:1,4:2,6:3,7:4,8:$V0,9:$V1,11:7,13:$V2,15:9,16:10,25:$V3,38:11,40:$V4,41:$V5,42:$V6,43:$V7,44:$V8,45:$V9,46:$Va,47:$Vb,48:$Vc,49:$Vd,50:$Ve,51:$Vf,52:$Vg,53:$Vh,54:$Vi,55:$Vj,56:$Vk,59:$Vl,60:$Vm},{1:[3]},{5:[1,32]},{7:33,11:7,13:$V2,15:9,16:10,25:$V3,38:11,40:$V4,41:$V5,42:$V6,43:$V7,44:$V8,45:$V9,46:$Va,47:$Vb,48:$Vc,49:$Vd,50:$Ve,51:$Vf,52:$Vg,53:$Vh,54:$Vi,55:$Vj,56:$Vk,59:$Vl,60:$Vm},{5:[2,3],8:$Vn,9:$Vo,10:34,12:$Vp},o($Vq,[2,4]),o($Vq,[2,5]),o($Vr,[2,7]),o($Vs,[2,13],{14:38,17:39,18:$Vt}),o($Vs,[2,14]),o($Vs,[2,15]),o($Vs,[2,41],{39:[1,41]}),o($Vs,[2,55]),o($Vs,[2,56]),o($Vs,[2,57]),{13:[1,43],25:[1,42]},{57:[1,44]},{57:[1,45]},{57:[1,46]},o($Vu,[2,42]),o($Vu,[2,43]),o($Vu,[2,44]),o($Vu,[2,45]),o($Vu,[2,46]),o($Vu,[2,47]),o($Vu,[2,48]),o($Vu,[2,49]),o($Vu,[2,50]),o($Vu,[2,51]),o($Vu,[2,52]),o($Vu,[2,53]),o($Vu,[2,54]),{1:[2,1]},{5:[2,2],8:$Vn,9:$Vo,10:34,12:$Vp},{11:47,13:$V2,15:9,16:10,25:$V3,38:11,40:$V4,41:$V5,42:$V6,43:$V7,44:$V8,45:$V9,46:$Va,47:$Vb,48:$Vc,49:$Vd,50:$Ve,51:$Vf,52:$Vg,53:$Vh,54:$Vi,55:$Vj,56:$Vk,59:$Vl,60:$Vm},o($Vv,[2,9],{6:48,8:$V0,9:$V1}),o($Vv,[2,10]),o($Vv,[2,11]),o($Vs,[2,12],{17:49,18:$Vt}),o($Vw,[2,17]),{6:53,8:$V0,9:$V1,11:52,13:$V2,15:9,16:10,19:50,22:51,25:$V3,35:$Vx,36:$Vy,37:$Vz,38:11,40:$V4,41:$V5,42:$V6,43:$V7,44:$V8,45:$V9,46:$Va,47:$Vb,48:$Vc,49:$Vd,50:$Ve,51:$Vf,52:$Vg,53:$Vh,54:$Vi,55:$Vj,56:$Vk,59:$Vl,60:$Vm},{11:57,13:$V2,15:9,16:10,25:$V3,38:11,40:$V4,41:$V5,42:$V6,43:$V7,44:$V8,45:$V9,46:$Va,47:$Vb,48:$Vc,49:$Vd,50:$Ve,51:$Vf,52:$Vg,53:$Vh,54:$Vi,55:$Vj,56:$Vk,59:$Vl,60:$Vm},o($Vs,[2,58]),o($Vs,[2,60],{17:58,18:$Vt}),{58:[1,59]},{58:[1,60]},{58:[1,61]},o($Vr,[2,6]),o($Vv,[2,8]),o($Vw,[2,16]),{8:[1,67],12:[1,75],20:[1,62],21:63,23:[1,64],24:[1,65],25:[1,66],26:[1,68],27:[1,69],28:[1,70],29:[1,71],30:[1,72],31:[1,73],32:[1,74],33:[1,76],34:[1,77]},o($VA,[2,20]),o($VA,[2,35]),o($VA,[2,36]),o($VA,[2,37]),o($VA,[2,38]),o($VA,[2,39]),o($Vs,[2,40]),o($Vs,[2,59]),o($Vs,[2,61]),o($Vs,[2,62]),o($Vs,[2,63]),o($Vw,[2,18]),{6:53,8:$V0,9:$V1,11:52,13:$V2,15:9,16:10,22:78,25:$V3,35:$Vx,36:$Vy,37:$Vz,38:11,40:$V4,41:$V5,42:$V6,43:$V7,44:$V8,45:$V9,46:$Va,47:$Vb,48:$Vc,49:$Vd,50:$Ve,51:$Vf,52:$Vg,53:$Vh,54:$Vi,55:$Vj,56:$Vk,59:$Vl,60:$Vm},o($VB,[2,21]),o($VB,[2,22]),o($VB,[2,23]),o($VB,[2,24]),o($VB,[2,25]),o($VB,[2,26]),o($VB,[2,27]),o($VB,[2,28]),o($VB,[2,29]),o($VB,[2,30]),o($VB,[2,31]),o($VB,[2,32]),o($VB,[2,33]),o($VB,[2,34]),o($VA,[2,19])],
  defaultActions: {32:[2,1]},
  parseError: function parseError (str, hash) {
      if (hash.recoverable) {
          this.trace(str);
      } else {
          var error = new Error(str);
          error.hash = hash;
          throw error;
      }
  },
  parse: function parse(input) {
      var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
      var args = lstack.slice.call(arguments, 1);
      var lexer = Object.create(this.lexer);
      var sharedState = { yy: {} };
      for (var k in this.yy) {
          if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
              sharedState.yy[k] = this.yy[k];
          }
      }
      lexer.setInput(input, sharedState.yy);
      sharedState.yy.lexer = lexer;
      sharedState.yy.parser = this;
      if (typeof lexer.yylloc == 'undefined') {
          lexer.yylloc = {};
      }
      var yyloc = lexer.yylloc;
      lstack.push(yyloc);
      var ranges = lexer.options && lexer.options.ranges;
      if (typeof sharedState.yy.parseError === 'function') {
          this.parseError = sharedState.yy.parseError;
      } else {
          this.parseError = Object.getPrototypeOf(this).parseError;
      }
      function popStack(n) {
          stack.length = stack.length - 2 * n;
          vstack.length = vstack.length - n;
          lstack.length = lstack.length - n;
      }
      _token_stack:
          var lex = function () {
              var token;
              token = lexer.lex() || EOF;
              if (typeof token !== 'number') {
                  token = self.symbols_[token] || token;
  >>>>>>> c1b8f0839809259065b7ffe96d79f25d3c5844f9
              }
          },
          table: [{ 3: 1, 4: 2, 6: 3, 7: 4, 8: [1, 5], 9: [1, 6], 10: $V0 }, { 1: [3] }, { 5: [1, 8] }, { 7: 9, 10: $V0 }, { 5: [2, 3] }, { 10: [2, 4] }, { 10: [2, 5] }, { 5: $V1, 11: 10, 12: $V2 }, { 1: [2, 1] }, { 5: [2, 2] }, { 5: [2, 6] }, { 10: [1, 12] }, { 5: $V1, 11: 13, 12: $V2 }, { 5: [2, 7] }],
          defaultActions: { 4: [2, 3], 5: [2, 4], 6: [2, 5], 8: [2, 1], 9: [2, 2], 10: [2, 6], 13: [2, 7] },
          parseError: function parseError(str, hash) {
              if (hash.recoverable) {
                  this.trace(str);
              } else {
                  var error = new Error(str);
                  error.hash = hash;
                  throw error;
              }
          },
          parse: function parse(input) {
              var self = this,
                  stack = [0],
                  tstack = [],
                  vstack = [null],
                  lstack = [],
                  table = this.table,
                  yytext = '',
                  yylineno = 0,
                  yyleng = 0,
                  recovering = 0,
                  TERROR = 2,
                  EOF = 1;
              var args = lstack.slice.call(arguments, 1);
              var lexer = Object.create(this.lexer);
              var sharedState = { yy: {} };
              for (var k in this.yy) {
                  if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
                      sharedState.yy[k] = this.yy[k];
                  }
              }
              lexer.setInput(input, sharedState.yy);
              sharedState.yy.lexer = lexer;
              sharedState.yy.parser = this;
              if (typeof lexer.yylloc == 'undefined') {
                  lexer.yylloc = {};
              }
              var yyloc = lexer.yylloc;
              lstack.push(yyloc);
              var ranges = lexer.options && lexer.options.ranges;
              if (typeof sharedState.yy.parseError === 'function') {
                  this.parseError = sharedState.yy.parseError;
              } else {
                  this.parseError = Object.getPrototypeOf(this).parseError;
              }
  
              function popStack(n) {
                  stack.length = stack.length - 2 * n;
                  vstack.length = vstack.length - n;
                  lstack.length = lstack.length - n;
              }
              _token_stack:
                  var lex = function() {
                      var token;
                      token = lexer.lex() || EOF;
                      if (typeof token !== 'number') {
                          token = self.symbols_[token] || token;
                      }
                      return token;
                  };
              var symbol, preErrorSymbol, state, action, a, r, yyval = {},
                  p, len, newState, expected;
              while (true) {
                  state = stack[stack.length - 1];
                  if (this.defaultActions[state]) {
                      action = this.defaultActions[state];
                  } else {
                      if (symbol === null || typeof symbol == 'undefined') {
                          symbol = lex();
                      }
                      action = table[state] && table[state][symbol];
                  }
                  if (typeof action === 'undefined' || !action.length || !action[0]) {
                      var errStr = '';
                      expected = [];
                      for (p in table[state]) {
                          if (this.terminals_[p] && p > TERROR) {
                              expected.push('\'' + this.terminals_[p] + '\'');
                          }
                      }
                      if (lexer.showPosition) {
                          errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                      } else {
                          errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                      }
                      this.parseError(errStr, {
                          text: lexer.match,
                          token: this.terminals_[symbol] || symbol,
                          line: lexer.yylineno,
                          loc: yyloc,
                          expected: expected
                      });
                  }
                  if (action[0] instanceof Array && action.length > 1) {
                      throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
                  }
                  switch (action[0]) {
                      case 1:
                          stack.push(symbol);
                          vstack.push(lexer.yytext);
                          lstack.push(lexer.yylloc);
                          stack.push(action[1]);
                          symbol = null;
                          if (!preErrorSymbol) {
                              yyleng = lexer.yyleng;
                              yytext = lexer.yytext;
                              yylineno = lexer.yylineno;
                              yyloc = lexer.yylloc;
                              if (recovering > 0) {
                                  recovering--;
                              }
                          } else {
                              symbol = preErrorSymbol;
                              preErrorSymbol = null;
                          }
                          break;
                      case 2:
                          len = this.productions_[action[1]][1];
                          yyval.$ = vstack[vstack.length - len];
                          yyval._$ = {
                              first_line: lstack[lstack.length - (len || 1)].first_line,
                              last_line: lstack[lstack.length - 1].last_line,
                              first_column: lstack[lstack.length - (len || 1)].first_column,
                              last_column: lstack[lstack.length - 1].last_column
                          };
                          if (ranges) {
                              yyval._$.range = [
                                  lstack[lstack.length - (len || 1)].range[0],
                                  lstack[lstack.length - 1].range[1]
                              ];
                          }
                          r = this.performAction.apply(yyval, [
                              yytext,
                              yyleng,
                              yylineno,
                              sharedState.yy,
                              action[1],
                              vstack,
                              lstack
                          ].concat(args));
                          if (typeof r !== 'undefined') {
                              return r;
                          }
                          if (len) {
                              stack = stack.slice(0, -1 * len * 2);
                              vstack = vstack.slice(0, -1 * len);
                              lstack = lstack.slice(0, -1 * len);
                          }
                          stack.push(this.productions_[action[1]][0]);
                          vstack.push(yyval.$);
                          lstack.push(yyval._$);
                          newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                          stack.push(newState);
                          break;
                      case 3:
                          return true;
                  }
              }
              return true;
          }
      };
  
  <<<<<<< HEAD
  
      /* generated by jison-lex 0.3.4 */
      var lexer = (function() {
          var lexer = ({
  =======
         //const rep_gram = require("./XPATH/reporte/reporteGramatica").reporteGramatica;
       /*   const pro = require("./XPATH/reporte/produccion").producion;
          const tree = require("./XPATH/ast/ast").tree;
          const nodoX = require("./XPATH/ast/nodo").nodo;*/
        // let p = new producion();
  /* generated by jison-lex 0.3.4 */
  var lexer = (function(){
  var lexer = ({
  >>>>>>> c1b8f0839809259065b7ffe96d79f25d3c5844f9
  
              EOF: 1,
  
              parseError: function parseError(str, hash) {
                  if (this.yy.parser) {
                      this.yy.parser.parseError(str, hash);
                  } else {
                      throw new Error(str);
                  }
              },
  
              // resets the lexer, sets new input
              setInput: function(input, yy) {
                  this.yy = yy || this.yy || {};
                  this._input = input;
                  this._more = this._backtrack = this.done = false;
                  this.yylineno = this.yyleng = 0;
                  this.yytext = this.matched = this.match = '';
                  this.conditionStack = ['INITIAL'];
                  this.yylloc = {
                      first_line: 1,
                      first_column: 0,
                      last_line: 1,
                      last_column: 0
                  };
                  if (this.options.ranges) {
                      this.yylloc.range = [0, 0];
                  }
                  this.offset = 0;
                  return this;
              },
  
              // consumes and returns one char from the input
              input: function() {
                  var ch = this._input[0];
                  this.yytext += ch;
                  this.yyleng++;
                  this.offset++;
                  this.match += ch;
                  this.matched += ch;
                  var lines = ch.match(/(?:\r\n?|\n).*/g);
                  if (lines) {
                      this.yylineno++;
                      this.yylloc.last_line++;
                  } else {
                      this.yylloc.last_column++;
                  }
                  if (this.options.ranges) {
                      this.yylloc.range[1]++;
                  }
  
                  this._input = this._input.slice(1);
                  return ch;
              },
  
              // unshifts one char (or a string) into the input
              unput: function(ch) {
                  var len = ch.length;
                  var lines = ch.split(/(?:\r\n?|\n)/g);
  
                  this._input = ch + this._input;
                  this.yytext = this.yytext.substr(0, this.yytext.length - len);
                  //this.yyleng -= len;
                  this.offset -= len;
                  var oldLines = this.match.split(/(?:\r\n?|\n)/g);
                  this.match = this.match.substr(0, this.match.length - 1);
                  this.matched = this.matched.substr(0, this.matched.length - 1);
  
                  if (lines.length - 1) {
                      this.yylineno -= lines.length - 1;
                  }
                  var r = this.yylloc.range;
  
                  this.yylloc = {
                      first_line: this.yylloc.first_line,
                      last_line: this.yylineno + 1,
                      first_column: this.yylloc.first_column,
                      last_column: lines ?
                          (lines.length === oldLines.length ? this.yylloc.first_column : 0) +
                          oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
                  };
  
                  if (this.options.ranges) {
                      this.yylloc.range = [r[0], r[0] + this.yyleng - len];
                  }
                  this.yyleng = this.yytext.length;
                  return this;
              },
  
              // When called from action, caches matched text and appends it on next action
              more: function() {
                  this._more = true;
                  return this;
              },
  
              // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
              reject: function() {
                  if (this.options.backtrack_lexer) {
                      this._backtrack = true;
                  } else {
                      return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                          text: "",
                          token: null,
                          line: this.yylineno
                      });
  
                  }
                  return this;
              },
  
              // retain first n characters of the match
              less: function(n) {
                  this.unput(this.match.slice(n));
              },
  
              // displays already matched input, i.e. for error messages
              pastInput: function() {
                  var past = this.matched.substr(0, this.matched.length - this.match.length);
                  return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
              },
  
              // displays upcoming input, i.e. for error messages
              upcomingInput: function() {
                  var next = this.match;
                  if (next.length < 20) {
                      next += this._input.substr(0, 20 - next.length);
                  }
                  return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
              },
  
              // displays the character position where the lexing error occurred, i.e. for error messages
              showPosition: function() {
                  var pre = this.pastInput();
                  var c = new Array(pre.length + 1).join("-");
                  return pre + this.upcomingInput() + "\n" + c + "^";
              },
  
              // test the lexed token: return FALSE when not a match, otherwise return token
              test_match: function(match, indexed_rule) {
                  var token,
                      lines,
                      backup;
  
                  if (this.options.backtrack_lexer) {
                      // save context
                      backup = {
                          yylineno: this.yylineno,
                          yylloc: {
                              first_line: this.yylloc.first_line,
                              last_line: this.last_line,
                              first_column: this.yylloc.first_column,
                              last_column: this.yylloc.last_column
                          },
                          yytext: this.yytext,
                          match: this.match,
                          matches: this.matches,
                          matched: this.matched,
                          yyleng: this.yyleng,
                          offset: this.offset,
                          _more: this._more,
                          _input: this._input,
                          yy: this.yy,
                          conditionStack: this.conditionStack.slice(0),
                          done: this.done
                      };
                      if (this.options.ranges) {
                          backup.yylloc.range = this.yylloc.range.slice(0);
                      }
                  }
  
                  lines = match[0].match(/(?:\r\n?|\n).*/g);
                  if (lines) {
                      this.yylineno += lines.length;
                  }
                  this.yylloc = {
                      first_line: this.yylloc.last_line,
                      last_line: this.yylineno + 1,
                      first_column: this.yylloc.last_column,
                      last_column: lines ?
                          lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
                  };
                  this.yytext += match[0];
                  this.match += match[0];
                  this.matches = match;
                  this.yyleng = this.yytext.length;
                  if (this.options.ranges) {
                      this.yylloc.range = [this.offset, this.offset += this.yyleng];
                  }
                  this._more = false;
                  this._backtrack = false;
                  this._input = this._input.slice(match[0].length);
                  this.matched += match[0];
                  token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
                  if (this.done && this._input) {
                      this.done = false;
                  }
                  if (token) {
                      return token;
                  } else if (this._backtrack) {
                      // recover context
                      for (var k in backup) {
                          this[k] = backup[k];
                      }
                      return false; // rule action called reject() implying the next rule should be tested instead.
                  }
                  return false;
              },
  
              // return next match in input
              next: function() {
                  if (this.done) {
                      return this.EOF;
                  }
                  if (!this._input) {
                      this.done = true;
                  }
  
                  var token,
                      match,
                      tempMatch,
                      index;
                  if (!this._more) {
                      this.yytext = '';
                      this.match = '';
                  }
                  var rules = this._currentRules();
                  for (var i = 0; i < rules.length; i++) {
                      tempMatch = this._input.match(this.rules[rules[i]]);
                      if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                          match = tempMatch;
                          index = i;
                          if (this.options.backtrack_lexer) {
                              token = this.test_match(tempMatch, rules[i]);
                              if (token !== false) {
                                  return token;
                              } else if (this._backtrack) {
                                  match = false;
                                  continue; // rule action called reject() implying a rule MISmatch.
                              } else {
                                  // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                                  return false;
                              }
                          } else if (!this.options.flex) {
                              break;
                          }
                      }
                  }
                  if (match) {
                      token = this.test_match(match, rules[index]);
                      if (token !== false) {
                          return token;
                      }
                      // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                      return false;
                  }
  <<<<<<< HEAD
                  if (this._input === "") {
                      return this.EOF;
                  } else {
                      return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                          text: "",
                          token: null,
                          line: this.yylineno
                      });
                  }
              },
  
              // return next match that has a token
              lex: function lex() {
                  var r = this.next();
                  if (r) {
                      return r;
                  } else {
                      return this.lex();
                  }
              },
  
              // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
              begin: function begin(condition) {
                  this.conditionStack.push(condition);
              },
  
              // pop the previously active lexer condition state off the condition stack
              popState: function popState() {
                  var n = this.conditionStack.length - 1;
                  if (n > 0) {
                      return this.conditionStack.pop();
                  } else {
                      return this.conditionStack[0];
                  }
              },
  
              // produce the lexer rule set which is active for the currently active lexer condition state
              _currentRules: function _currentRules() {
                  if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                      return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
                  } else {
                      return this.conditions["INITIAL"].rules;
                  }
              },
  
              // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
              topState: function topState(n) {
                  n = this.conditionStack.length - 1 - Math.abs(n || 0);
                  if (n >= 0) {
                      return this.conditionStack[n];
                  } else {
                      return "INITIAL";
                  }
              },
  
              // alias for begin(condition)
              pushState: function pushState(condition) {
                  this.begin(condition);
              },
  
              // return the number of states currently on the stack
              stateStackSize: function stateStackSize() {
                  return this.conditionStack.length;
              },
              options: { "case-insensitive": true },
              performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
                  var YYSTATE = YY_START;
                  switch ($avoiding_name_collisions) {
                      case 0:
                          return 22;
                          break;
                      case 1:
                          return 53;
                          break;
                      case 2:
                          return 54;
                          break;
                      case 3:
                          return 58;
                          break;
                      case 4:
                          return 59;
                          break;
                      case 5:
                          return 'llaIzq';
                          break;
                      case 6:
                          return 'llaDer';
                          break;
                      case 7:
                          return 38;
                          break;
                      case 8:
                          return 'colon';
                          break;
                      case 9:
                          return 30;
                          break;
                      case 10:
                          return 14;
                          break;
                      case 11:
                          return 16;
                          break;
                      case 12:
                          return 'ptcoma';
                          break;
                      case 13:
                          return 20;
                          break;
                      case 14:
                          return 'comma';
                          break;
                      case 15:
                          return 21;
                          break;
                      case 16:
                          return 'arrow';
                          break;
                      case 17:
                          return 23;
                          break;
                      case 18:
                          return 9;
                          break;
                      case 19:
                          return 8;
                          break;
                      case 20:
                          return 24;
                          break;
                      case 21:
                          return 25;
                          break;
                      case 22:
                          return 26;
                          break;
                      case 23:
                          return 28;
                          break;
                      case 24:
                          return 27;
                          break;
                      case 25:
                          return 55;
                          break;
                      case 26:
                          return 29;
                          break;
                      case 27:
                          return 'let';
                          break;
                      case 28:
                          return 61;
                          break;
                      case 29:
                          return 31;
                          break;
                      case 30:
                          return 'div';
                          break;
                      case 31:
                          return 32;
                          break;
                      case 32:
                          return 60;
                          break;
                      case 33:
                          return 57;
                          break;
                      case 34:
                          return 42;
                          break;
                      case 35:
                          return 51;
                          break;
                      case 36:
                          return 48;
                          break;
                      case 37:
                          return 'comment';
                          break;
                      case 38:
                          return 'element';
                          break;
                      case 39:
                          return 39;
                          break;
                      case 40:
                          return 47;
                          break;
                      case 41:
                          return 41;
                          break;
                      case 42:
                          return 49;
                          break;
                      case 43:
                          return 45;
                          break;
                      case 44:
                          return 40;
                          break;
                      case 45:
                          return 44;
                          break;
                      case 46:
                          return 46;
                          break;
                      case 47:
                          return 50;
                          break;
                      case 48:
                          return 'processing_instruction';
                          break;
                      case 49:
                          break;
                      case 50:
                          break;
                      case 51:
                          return 'digits';
                          break;
                      case 52:
                          return 'decimal';
                          break;
                      case 53:
                          return 35;
                          break;
                      case 54:
                          return 56;
                          break;
                      case 55:
                          return 5;
                          break;
                      case 56:
                          console.error('Error');
  
                          break;
                  }
              },
              rules: [/^(?:\*)/i, /^(?:\.\.)/i, /^(?:\.)/i, /^(?:\()/i, /^(?:\))/i, /^(?:\{)/i, /^(?:\})/i, /^(?:::)/i, /^(?::)/i, /^(?:\|)/i, /^(?:\[)/i, /^(?:\])/i, /^(?:;)/i, /^(?:\+)/i, /^(?:,)/i, /^(?:-)/i, /^(?:=>)/i, /^(?:=)/i, /^(?:\/\/)/i, /^(?:\/)/i, /^(?:!=)/i, /^(?:<)/i, /^(?:<=)/i, /^(?:>)/i, /^(?:>=)/i, /^(?:@)/i, /^(?:or\b)/i, /^(?:let\b)/i, /^(?:last\b)/i, /^(?:and\b)/i, /^(?:div\b)/i, /^(?:mod\b)/i, /^(?:text\b)/i, /^(?:node\b)/i, /^(?:child\b)/i, /^(?:self\b)/i, /^(?:parent\b)/i, /^(?:comment\b)/i, /^(?:element\b)/i, /^(?:ancestor\b)/i, /^(?:namespace\b)/i, /^(?:attribute\b)/i, /^(?:preceding\b)/i, /^(?:following\b)/i, /^(?:ancestor_or_self\b)/i, /^(?:descendant_or_self\b)/i, /^(?:following_sibling\b)/i, /^(?:preceding_sibling\b)/i, /^(?:processing_instruction\b)/i, /^(?:[ \r\t]+)/i, /^(?:\n)/i, /^(?:[0-9]+)/i, /^(?:[0-9]+(\.[0-9]+)?)/i, /^(?:("({EscapeQuot}|[^"])*")|('\(\{EscapeApos\}\|\[\^'\]\)\*'))/i, /^(?:[A-Za-z_][A-Za-z_0-9]*)/i, /^(?:$)/i, /^(?:.)/i],
              conditions: { "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56], "inclusive": true } }
          });
          return lexer;
      })();
      parser.lexer = lexer;
  
      function Parser() {
          this.yy = {};
      }
      Parser.prototype = parser;
      parser.Parser = Parser;
      return new Parser;
  =======
              }
          }
          if (match) {
              token = this.test_match(match, rules[index]);
              if (token !== false) {
                  return token;
              }
              // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
              return false;
          }
          if (this._input === "") {
              return this.EOF;
          } else {
              return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                  text: "",
                  token: null,
                  line: this.yylineno
              });
          }
      },
  
  // return next match that has a token
  lex:function lex () {
          var r = this.next();
          if (r) {
              return r;
          } else {
              return this.lex();
          }
      },
  
  // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
  begin:function begin (condition) {
          this.conditionStack.push(condition);
      },
  
  // pop the previously active lexer condition state off the condition stack
  popState:function popState () {
          var n = this.conditionStack.length - 1;
          if (n > 0) {
              return this.conditionStack.pop();
          } else {
              return this.conditionStack[0];
          }
      },
  
  // produce the lexer rule set which is active for the currently active lexer condition state
  _currentRules:function _currentRules () {
          if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
              return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
          } else {
              return this.conditions["INITIAL"].rules;
          }
      },
  
  // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
  topState:function topState (n) {
          n = this.conditionStack.length - 1 - Math.abs(n || 0);
          if (n >= 0) {
              return this.conditionStack[n];
          } else {
              return "INITIAL";
          }
      },
  
  // alias for begin(condition)
  pushState:function pushState (condition) {
          this.begin(condition);
      },
  
  // return the number of states currently on the stack
  stateStackSize:function stateStackSize() {
          return this.conditionStack.length;
      },
  options: {"case-insensitive":true},
  performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
  var YYSTATE=YY_START;
  switch($avoiding_name_collisions) {
  case 0:return 25;
  break;
  case 1:return 54;
  break;
  case 2:return 53;
  break;
  case 3:return 57;
  break;
  case 4:return 58;
  break;
  case 5:return 'llaIzq';
  break;
  case 6:return 'llaDer';
  break;
  case 7:return 39;
  break;
  case 8:return 'colon';
  break;
  case 9:return 12;
  break;
  case 10:return 18;
  break;
  case 11:return 20;
  break;
  case 12:return 'ptcoma';
  break;
  case 13:return 23;
  break;
  case 14:return 'comma';
  break;
  case 15:return 24;
  break;
  case 16:return 'arrow';
  break;
  case 17:return 26;
  break;
  case 18:return 9;
  break;
  case 19:return 8;
  break;
  case 20:return 27;
  break;
  case 21:return 28;
  break;
  case 22:return 29;
  break;
  case 23:return 31;
  break;
  case 24:return 30;
  break;
  case 25:return 55;
  break;
  case 26:return 32;
  break;
  case 27:return 'let';
  break;
  case 28:return 60;
  break;
  case 29:return 33;
  break;
  case 30:return 'div';
  break;
  case 31:return 34;
  break;
  case 32:return 59;
  break;
  case 33:return 56;
  break;
  case 34:return 43;
  break;
  case 35:return 52;
  break;
  case 36:return 49;
  break;
  case 37:return 'comment';
  break;
  case 38:return 'element';
  break;
  case 39:return 40;
  break;
  case 40:return 48;
  break;
  case 41:return 42;
  break;
  case 42:return 50;
  break;
  case 43:return 46;
  break;
  case 44:return 41;
  break;
  case 45:return 45;
  break;
  case 46:return 47;
  break;
  case 47:return 51;
  break;
  case 48:return 'processing_instruction';
  break;
  case 49:
  break;
  case 50:
  break;
  case 51:return  'digits';
  break;
  case 52:return  'decimal';
  break;
  case 53:return 37;
  break;
  case 54:return 13;
  break;
  case 55:return 5;
  break;
  case 56:
          console.error('Error');
  
  break;
  }
  },
  rules: [/^(?:\*)/i,/^(?:\.\.)/i,/^(?:\.)/i,/^(?:\()/i,/^(?:\))/i,/^(?:\{)/i,/^(?:\})/i,/^(?:::)/i,/^(?::)/i,/^(?:\|)/i,/^(?:\[)/i,/^(?:\])/i,/^(?:;)/i,/^(?:\+)/i,/^(?:,)/i,/^(?:-)/i,/^(?:=>)/i,/^(?:=)/i,/^(?:\/\/)/i,/^(?:\/)/i,/^(?:!=)/i,/^(?:<)/i,/^(?:<=)/i,/^(?:>)/i,/^(?:>=)/i,/^(?:@)/i,/^(?:or\b)/i,/^(?:let\b)/i,/^(?:last\b)/i,/^(?:and\b)/i,/^(?:div\b)/i,/^(?:mod\b)/i,/^(?:text\b)/i,/^(?:node\b)/i,/^(?:child\b)/i,/^(?:self\b)/i,/^(?:parent\b)/i,/^(?:comment\b)/i,/^(?:element\b)/i,/^(?:ancestor\b)/i,/^(?:namespace\b)/i,/^(?:attribute\b)/i,/^(?:preceding\b)/i,/^(?:following\b)/i,/^(?:ancestor_or_self\b)/i,/^(?:descendant_or_self\b)/i,/^(?:following_sibling\b)/i,/^(?:preceding_sibling\b)/i,/^(?:processing_instruction\b)/i,/^(?:[ \r\t]+)/i,/^(?:\n)/i,/^(?:[0-9]+)/i,/^(?:[0-9]+(\.[0-9]+)?)/i,/^(?:("({EscapeQuot}|[^"])*")|('\(\{EscapeApos\}\|\[\^'\]\)\*'))/i,/^(?:[A-Za-z_][A-Za-z_0-9]*)/i,/^(?:$)/i,/^(?:.)/i],
  conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56],"inclusive":true}}
  });
  return lexer;
  })();
  parser.lexer = lexer;
  function Parser () {
    this.yy = {};
  }
  Parser.prototype = parser;parser.Parser = Parser;
  return new Parser;
  >>>>>>> c1b8f0839809259065b7ffe96d79f25d3c5844f9
  })();
  
  
  if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
      exports.parser = gramaticaXPath;
      exports.Parser = gramaticaXPath.Parser;
      exports.parse = function() { return gramaticaXPath.parse.apply(gramaticaXPath, arguments); };
      exports.main = function commonjsMain(args) {
          if (!args[1]) {
              console.log('Usage: ' + args[0] + ' FILE');
              process.exit(1);
          }
          var source = require('fs').readFileSync(require('path').normalize(args[1]), "utf8");
          return exports.parser.parse(source);
      };
      if (typeof module !== 'undefined' && require.main === module) {
          exports.main(process.argv.slice(1));
      }
  }