docs: function hasOrGetNext(m, mod, x, y, id) {
          var nRows, nCols;
  
          // Check if there is any match yet.
          if (!J.isArray(this.resolvedMatches) || !this.resolvedMatches.length) {
              throw new Error('Matcher.' + m + ': no resolved matches found.');
          }
  
          nRows = this.resolvedMatches.length - 1;
  
          // No x, No y get the next match.
          if ('undefined' === typeof x) {
              // Check both x and y.
              if ('undefined' !== typeof y) {
                  throw new Error('Matcher.' + m +
                                  ': cannot specify y without x.');
              }
  
              // No match was ever requested.
              if (null === this.x) {
                  this.x = 0;
                  this.y = 0;
                  return fetchMatch[mod].call(this, 0, 0, id);
              }
  
              x = this.x;
              y = this.y + 1;
              if (x <= nRows) {
                  nCols = this.resolvedMatches[x].length - 1;
                  if (y <= nCols) {
                      if (mod) {
                          this.x = x;
                          this.y = y;
                          return fetchMatch[mod].call(this, x, y, id);
                          // return this.resolvedMatches[x][y];
                      }
                      else {
                          return true;
                      }
                  }
                  else {
                      x = x + 1;
                      y = 0;
                      if (mod) {
                          this.x = x;
                          this.y = y;
                      }
                      if (x <= nRows) {
                          return fetchMatch[mod].call(this, x, y, id);
                          // return mod ? this.resolvedMatches[x][y] : true;
                      }
                      else {
                          return mod ? null : false;
                      }
                  }
              }
              else {
                  return mod ? null : false;
              }
          }
          // End undefined x.
  
          // Validate x.
          if ('number' !== typeof x) {
              throw new TypeError('Matcher.' + m + ': x must be number ' +
                                  'or undefined. Found: ' + x);
          }
          else if (x < 0 || isNaN(x)) {
              throw new Error('Matcher.' + m + ': x cannot be negative or NaN. ' +
                              'Found: ' + x);
          }
  
          if (x > nRows) {
              if (mod) {
                  this.x = x;
                  this.y = 0;
                  return null;
              }
              else {
                  return false;
              }
          }
  
          // Default y (whole row).
          if ('undefined' === typeof y) {
              if (mod) {
                  this.x = x;
                  this.y = this.resolvedMatches[nRows].length;
                  // Return the whole row.
                  return fetchMatch[mod].call(this, x, y, id);
                  // return this.resolvedMatches[x];
              }
              else {
                  return true;
              }
          }
  
          // Validate y.
          if ('number' !== typeof y) {
              throw new TypeError('Matcher.' + m  + ': y must be number ' +
                                  'or undefined.');
          }
          else if (y < 0 || isNaN(y)) {
              throw new Error('Matcher.' + m + ': y cannot be negative or NaN. ' +
                              'Found: ' + y);
          }
  
          nCols = this.resolvedMatches[x].length - 1;
  
          // Valid x,y match.
          if (y <= nCols) {
              if (mod) {
                  this.x = x;
                  this.y = y;
                  return fetchMatch[mod].call(this, x, y);
                  // return this.resolvedMatches[x][y];
              }
              else {
                  return true;
              }
          }
          // Out of bound.
          else {
              if (mod) {
                  this.x = x;
                  this.y = y;
                  return null;
              }
              else {
                  return false;
              }
          }
      }