jshint ignore:line
338868
function PropertyReference(parentReference, propertyKey) {
      _classCallCheck(this, PropertyReference);

      _CachedReference.call(this);

      var parentReferenceTag = parentReference.tag;
      var parentObjectTag = new _glimmerReference.UpdatableTag(_glimmerReference.CURRENT_TAG);

      this.tag = _glimmerReference.combine([parentReferenceTag, parentObjectTag]);
      this._parentReference = parentReference;
      this._parentObjectTag = parentObjectTag;
      this._propertyKey = propertyKey;
    }
387950
function goToNext() {
      count++;
      if (count === _.size(config)) {
        grunt.log.writeln(''); // line break
        grunt.log.ok('Ignored: %d', countIgnored);
        grunt.log.ok('Excluded: %d', countExcluded);
        grunt.log.ok('Processed: %d', countProcessed);
        done();
      }
    }
1208389
function processLine (context, comment) {
  const parsed = parse(COMMENT_DIRECTIVE_L, comment.value)
  if (parsed != null && comment.loc.start.line === comment.loc.end.line) {
    const line = comment.loc.start.line + (parsed.type === 'eslint-disable-line' ? 0 : 1)
    const column = -1
    disable(context, { line, column }, 'line', parsed.rules)
    enable(context, { line: line + 1, column }, 'line', parsed.rules)
  }
}
1219634
function discard_callsite(err, matcher){
  // Some JS environments do not have a
  // stack property on error objects.
  // If we are in such an environment
  // just return err as-is.
  if (err.stack) {
    err.stack = err.stack
      .split('\n')
      .filter(function(frame_str){
        return !matcher.test(frame_str);
      })
      .join('\n');
  }
  return err;
}
62411
function callback(err, hasError) {

    if (err !== null) {
        console.log(chalk.red('Error running JSHint over project: %j\n'), err);
    }

    if (hasError) {
        console.log(chalk.blue('\nSummary\n=======\n'));
        for (var errorCode in errors) {
            if (errors.hasOwnProperty(errorCode)) {
                displaySummary(errorCode);
            }
        }

        console.log('');

        if (totalErrors > 1) {
            console.log(chalk.red('Found %d errors.\n'), totalErrors);
        } else {
            console.log(chalk.red('Found 1 error.\n'));
        }
    } else {
        console.log(chalk.green('No JSHint errors found.\n'));
    }
}
404824
function () {
  var args = Array.prototype.slice.call(arguments);
  console.error();
  console.error.apply(console, [" "].concat(args));
  console.error();
  process.exit(1); // eslint-disable-line no-process-exit
}
1117769
function eachLine(str, callback)
    {
        var lines = splitLines(str);

        for (var i = 0; i < lines.length; i++)
            lines[i] = callback(lines[i], i);

        // include \r to enable copy-paste on windows (ie8) without getting everything on one line
        return lines.join('\r\n');
    }
810318
function stringify(data, visitor, indent) {
  if (typeof data === 'function' || typeof data === 'undefined') {
    // eslint-disable-next-line consistent-return
    return undefined;
  }

  indent = parseIndent(indent);

  const normalized = JSON.parse(JSON.stringify(data, visitor));

  function visitNode(node, options) {
    if (options == null) {
      options = {};
    }

    switch (typeof node) {
      case 'boolean':
        return `${node}`;

      case 'number':
        if (isFinite(node)) {
          return `${node}`;
        }
        return 'null';

      case 'string':
        return visitString(visitNode, indent, node, options);

      case 'object':
        if (node === null) {
          return 'null';
        } else if (Array.isArray(node)) {
          return visitArray(visitNode, indent, node, options);
        }
        return visitObject(visitNode, indent, node, options);

      default:
        // eslint-disable-next-line consistent-return
        return undefined;
    }
  }

  // eslint-disable-next-line consistent-return
  return visitNode(normalized);
}
392776
def ignore():
    # type: () -> List[str]
    

    def parse_line(line):   # pylint: disable=missing-docstring
        # Decode if necessary
        if not isinstance(line, string_types):
            line = line.decode('utf-8')

        # Strip comment
        line = line.split('#', 1)[0].strip()

        return line

    ignore_files = [
        conf.proj_path('.gitignore'),
        conf.proj_path('.git/info/exclude'),
        config().get('core.excludesfile')
    ]

    result = []
    for ignore_file in ignore_files:
        if not (ignore_file and os.path.exists(ignore_file)):
            continue

        with open(ignore_file) as fp:
            parsed = (parse_line(l) for l in fp.readlines())
            result += [x for x in parsed if x]

    return result
1135975
function TargetCommand(value, engine) {
        /* jshint ignore:start */
        var match = value.match(/^\s*([a-z0-9\/\._-]+)\s*(\(\s*master\s*=\s*([a-z0-9\/\._-]+)\s*\))?\s*/i);
        if (!match) {
            throw new Error('Invalid ' + this.type + ' syntax: ' + value);
        }
        /* jshint ignore:end */

        this.master = match[3];
        this.name = match[1];
        Command.call(this, value, engine);

        this.blocks = {};
    }
226928
function _cleanseInput(dirty){
      var clean = ''
      clean = dirty.replace('@', '')
      clean = clean.replace('#', '')
      clean = clean.replace(/\s/g, '')
      return clean
    }
111219
function(token){
                throw new SyntaxError("Unexpected token '" + token.value + "' at line " + token.startLine + ", col " + token.startCol + ".", token.startLine, token.startCol);
            }
727554
function (filePath, options)
    {
        gulpUtil.log(gulpUtil.colors.blue("jsHint"), pathHelper.makeRelative(filePath));

        var jsHintConfig = jsHintConfigHelper.getRules(xtend({
            lookup: false,
            esnext: false
        }, options));

        gulp.src(filePath)
            .pipe(plumber())
            .pipe(jshint(jsHintConfig))
            .pipe(jshint.reporter(jshintStylish));
    }
686174
private void skipScript() {
        if (!atTerminator()) {
            int oldIndex = index;
            ++index;

            char c;
            while (!isTerminatorOrIDSeparator(c = next()) && AsciiUtil.isAlpha(c));
            --index;

            if (index - oldIndex != 5) { // +1 to account for separator
                index = oldIndex;
            }
        }
    }
1369994
function ignore(fileMeta, opts) {
    if (typeof opts.ignore === 'function') {
        return opts.ignore(fileMeta, opts);
    }

    if (typeof opts.ignore === 'string' || Array.isArray(opts.ignore)) {
        return micromatch.any(fileMeta.sourceValue, opts.ignore);
    }

    return false;
}
30315
function(line) {
    header.resolveTempo();
    multilineVars.is_in_header = false;	// We should have gotten a key header by now, but just in case, this is definitely out of the header.
    var i = 0;
    var startOfLine = multilineVars.iChar;
    //multilineVars.havent_set_length = false;	// To late to set this now.
    // see if there is nothing but a comment on this line. If so, just ignore it. A full line comment is optional white space followed by %
    while (tokenizer.isWhiteSpace(line.charAt(i)) && i < line.length) {
      i++;
    }
    if (i === line.length || line.charAt(i) === '%') {
      return;

    }
    // Start with the standard staff, clef and key symbols on each line
    var delayStartNewLine = multilineVars.start_new_line;
    if (multilineVars.continueall === undefined)
      multilineVars.start_new_line = true;
    else
      multilineVars.start_new_line = false;
    var tripletNotesLeft = 0;

    // See if the line starts with a header field
    var retHeader = header.letter_to_body_header(line, i);
    if (retHeader[0] > 0) {
      i += retHeader[0];
      // TODO-PER: Handle inline headers
    }
    var el = { };

    while (i < line.length)
    {
      var startI = i;
      if (line.charAt(i) === '%')
        break;

      var retInlineHeader = header.letter_to_inline_header(line, i);
      if (retInlineHeader[0] > 0) {
        i += retInlineHeader[0];
        // TODO-PER: Handle inline headers
        //multilineVars.start_new_line = false;
      } else {
        // Wait until here to actually start the line because we know we're past the inline statements.
        if (delayStartNewLine) {
          startNewLine();
          delayStartNewLine = false;
        }

        // We need to decide if the following characters are a bar-marking or a note-group.
        // Unfortunately, that is ambiguous. Both can contain chord symbols and decorations.
        // If there is a grace note either before or after the chord symbols and decorations, then it is definitely a note-group.
        // If there is a bar marker, it is definitely a bar-marking.
        // If there is either a core-note or chord, it is definitely a note-group.
        // So, loop while we find grace-notes, chords-symbols, or decorations. [It is an error to have more than one grace-note group in a row; the others can be multiple]
        // Then, if there is a grace-note, we know where to go.
        // Else see if we have a chord, core-note, slur, triplet, or bar.

        var ret;
        while (1) {
          ret = tokenizer.eatWhiteSpace(line, i);
          if (ret > 0) {
            i += ret;
          }
          if (i > 0 && line.charAt(i-1) === '\x12') {
            // there is one case where a line continuation isn't the same as being on the same line, and that is if the next character after it is a header.
            ret = header.letter_to_body_header(line, i);
            if (ret[0] > 0) {
              // TODO: insert header here
              i = ret[0];
              multilineVars.start_new_line = false;
            }
          }
          // gather all the grace notes, chord symbols and decorations
          ret = letter_to_spacer(line, i);
          if (ret[0] > 0) {
            i += ret[0];
          }

          ret = letter_to_chord(line, i);
          if (ret[0] > 0) {
            // There could be more than one chord here if they have different positions.
            // If two chords have the same position, then connect them with newline.
            if (!el.chord)
              el.chord = [];
            var chordName = tokenizer.translateString(ret[1]);
            chordName = chordName.replace(/;/g, "\n");
            var addedChord = false;
            for (var ci = 0; ci < el.chord.length; ci++) {
              if (el.chord[ci].position === ret[2]) {
                addedChord = true;
                el.chord[ci].name += "\n" + chordName;
              }
            }
            if (addedChord === false) {
              if (ret[2] === null && ret[3])
                el.chord.push({name: chordName, rel_position: ret[3]});
              else
                el.chord.push({name: chordName, position: ret[2]});
            }

            i += ret[0];
            var ii = tokenizer.skipWhiteSpace(line.substring(i));
            if (ii > 0)
              el.force_end_beam_last = true;
            i += ii;
          } else {
            if (nonDecorations.indexOf(line.charAt(i)) === -1)
              ret = letter_to_accent(line, i);
            else ret = [ 0 ];
            if (ret[0] > 0) {
              if (ret[1] === null) {
                if (i + 1 < line.length)
                  startNewLine();	// There was a ! in the middle of the line. Start a new line if there is anything after it.
              } else if (ret[1].length > 0) {
                if (ret[1].indexOf("style=") === 0) {
                  el.style = ret[1].substr(6);
                } else {
                  if (el.decoration === undefined)
                    el.decoration = [];
                  el.decoration.push(ret[1]);
                }
              }
              i += ret[0];
            } else {
              ret = letter_to_grace(line, i);
              // TODO-PER: Be sure there aren't already grace notes defined. That is an error.
              if (ret[0] > 0) {
                el.gracenotes = ret[1];
                i += ret[0];
              } else
                break;
            }
          }
        }

        ret = letter_to_bar(line, i);
        if (ret[0] > 0) {
          // This is definitely a bar
          if (el.gracenotes !== undefined) {
            // Attach the grace note to an invisible note
            el.rest = { type: 'spacer' };
            el.duration = 0.125; // TODO-PER: I don't think the duration of this matters much, but figure out if it does.
            multilineVars.addFormattingOptions(el, tune.formatting, 'note');
            tune.appendElement('note', startOfLine+i, startOfLine+i+ret[0], el);
            multilineVars.measureNotEmpty = true;
            el = {};
          }
          var bar = {type: ret[1]};
          if (bar.type.length === 0)
            warn("Unknown bar type", line, i);
          else {
            if (multilineVars.inEnding && bar.type !== 'bar_thin') {
              bar.endEnding = true;
              multilineVars.inEnding = false;
            }
            if (ret[2]) {
              bar.startEnding = ret[2];
              if (multilineVars.inEnding)
                bar.endEnding = true;
              multilineVars.inEnding = true;
            }
            if (el.decoration !== undefined)
              bar.decoration = el.decoration;
            if (el.chord !== undefined)
              bar.chord = el.chord;
            if (bar.startEnding && multilineVars.barFirstEndingNum === undefined)
              multilineVars.barFirstEndingNum = multilineVars.currBarNumber;
            else if (bar.startEnding && bar.endEnding && multilineVars.barFirstEndingNum)
              multilineVars.currBarNumber = multilineVars.barFirstEndingNum;
            else if (bar.endEnding)
              multilineVars.barFirstEndingNum = undefined;
            if (bar.type !== 'bar_invisible' && multilineVars.measureNotEmpty) {
              multilineVars.currBarNumber++;
              if (multilineVars.barNumbers && multilineVars.currBarNumber % multilineVars.barNumbers === 0)
                multilineVars.barNumOnNextNote = multilineVars.currBarNumber;
            }
            multilineVars.addFormattingOptions(el, tune.formatting, 'bar');
            tune.appendElement('bar', startOfLine+i, startOfLine+i+ret[0], bar);
            multilineVars.measureNotEmpty = false;
            el = {};
          }
          i += ret[0];
        } else if (line[i] === '&') {	// backtrack to beginning of measure
          warn("Overlay not yet supported", line, i);
          i++;

        } else {
          // This is definitely a note group
          //
          // Look for as many open slurs and triplets as there are. (Note: only the first triplet is valid.)
          ret = letter_to_open_slurs_and_triplets(line, i);
          if (ret.consumed > 0) {
            if (ret.startSlur !== undefined)
              el.startSlur = ret.startSlur;
            if (ret.triplet !== undefined) {
              if (tripletNotesLeft > 0)
                warn("Can't nest triplets", line, i);
              else {
                el.startTriplet = ret.triplet;
                tripletNotesLeft = ret.num_notes === undefined ? ret.triplet : ret.num_notes;
              }
            }
            i += ret.consumed;
          }

          // handle chords.
          if (line.charAt(i) === '[') {
            var chordStartChar = i;
            i++;
            var chordDuration = null;

            var done = false;
            while (!done) {
              var chordNote = getCoreNote(line, i, {}, false);
              if (chordNote !== null) {
                if (chordNote.end_beam) {
                  el.end_beam = true;
                  delete chordNote.end_beam;
                }
                if (el.pitches === undefined) {
                  el.duration = chordNote.duration;
                  el.pitches = [ chordNote ];
                } else	// Just ignore the note lengths of all but the first note. The standard isn't clear here, but this seems less confusing.
                  el.pitches.push(chordNote);
                delete chordNote.duration;

                if (multilineVars.inTieChord[el.pitches.length]) {
                  chordNote.endTie = true;
                  multilineVars.inTieChord[el.pitches.length] = undefined;
                }
                if (chordNote.startTie)
                  multilineVars.inTieChord[el.pitches.length] = true;

                i  = chordNote.endChar;
                delete chordNote.endChar;
              } else if (line.charAt(i) === ' ') {
                // Spaces are not allowed in chords, but we can recover from it by ignoring it.
                warn("Spaces are not allowed in chords", line, i);
                i++;
              } else {
                if (i < line.length && line.charAt(i) === ']') {
                  // consume the close bracket
                  i++;

                  if (multilineVars.next_note_duration !== 0) {
                    el.duration = el.duration * multilineVars.next_note_duration;
                    multilineVars.next_note_duration = 0;
                  }

                  if (multilineVars.inTie) {
                    Common.each(el.pitches, function(pitch) { pitch.endTie = true; });
                    multilineVars.inTie = false;
                  }

                  if (tripletNotesLeft > 0) {
                    tripletNotesLeft--;
                    if (tripletNotesLeft === 0) {
                      el.endTriplet = true;
                    }
                  }

                  var postChordDone = false;
                  while (i < line.length && !postChordDone) {
                    switch (line.charAt(i)) {
                      case ' ':
                      case '\t':
                        addEndBeam(el);
                        break;
                      case ')':
                        if (el.endSlur === undefined) el.endSlur = 1; else el.endSlur++;
                        break;
                      case '-':
                        Common.each(el.pitches, function(pitch) { pitch.startTie = {}; });
                        multilineVars.inTie = true;
                        break;
                      case '>':
                      case '<':
                        var br2 = getBrokenRhythm(line, i);
                        i += br2[0] - 1;	// index gets incremented below, so we'll let that happen
                        multilineVars.next_note_duration = br2[2];
                        if (chordDuration)
                          chordDuration = chordDuration * br2[1];
                        else
                          chordDuration = br2[1];
                        break;
                      case '1':
                      case '2':
                      case '3':
                      case '4':
                      case '5':
                      case '6':
                      case '7':
                      case '8':
                      case '9':
                      case '/':
                        var fraction = tokenizer.getFraction(line, i);
                        chordDuration = fraction.value;
                        i = fraction.index;
                        if (line.charAt(i) === '-' || line.charAt(i) === ')' || line.charAt(i) === ' ' || line.charAt(i) === '<' || line.charAt(i) === '>')
                          i--; // Subtracting one because one is automatically added below
                        else
                          postChordDone = true;
                        break;
                      default:
                        postChordDone = true;
                        break;
                    }
                    if (!postChordDone) {
                      i++;
                    }
                  }
                } else
                  warn("Expected ']' to end the chords", line, i);

                if (el.pitches !== undefined) {
                  if (chordDuration !== null) {
                    el.duration = el.duration * chordDuration;
                  }
                  if (multilineVars.barNumOnNextNote) {
                    el.barNumber = multilineVars.barNumOnNextNote;
                    multilineVars.barNumOnNextNote = null;
                  }
                  multilineVars.addFormattingOptions(el, tune.formatting, 'note');
                  tune.appendElement('note', startOfLine+chordStartChar, startOfLine+i, el);
                  multilineVars.measureNotEmpty = true;
                  el = {};
                }
                done = true;
              }
            }

          } else {
            // Single pitch
            var el2 = {};
            var core = getCoreNote(line, i, el2, true);
            if (el2.endTie !== undefined) multilineVars.inTie = true;
            if (core !== null) {
              if (core.pitch !== undefined) {
                el.pitches = [ { } ];
                // TODO-PER: straighten this out so there is not so much copying: getCoreNote shouldn't change e'
                if (core.accidental !== undefined) el.pitches[0].accidental = core.accidental;
                el.pitches[0].pitch = core.pitch;
                if (core.endSlur !== undefined) el.pitches[0].endSlur = core.endSlur;
                if (core.endTie !== undefined) el.pitches[0].endTie = core.endTie;
                if (core.startSlur !== undefined) el.pitches[0].startSlur = core.startSlur;
                if (el.startSlur !== undefined) el.pitches[0].startSlur = el.startSlur;
                if (core.startTie !== undefined) el.pitches[0].startTie = core.startTie;
                if (el.startTie !== undefined) el.pitches[0].startTie = el.startTie;
              } else {
                el.rest = core.rest;
                if (core.endSlur !== undefined) el.endSlur = core.endSlur;
                if (core.endTie !== undefined) el.rest.endTie = core.endTie;
                if (core.startSlur !== undefined) el.startSlur = core.startSlur;
                if (core.startTie !== undefined) el.rest.startTie = core.startTie;
                if (el.startTie !== undefined) el.rest.startTie = el.startTie;
              }

              if (core.chord !== undefined) el.chord = core.chord;
              if (core.duration !== undefined) el.duration = core.duration;
              if (core.decoration !== undefined) el.decoration = core.decoration;
              if (core.graceNotes !== undefined) el.graceNotes = core.graceNotes;
              delete el.startSlur;
              if (multilineVars.inTie) {
                if (el.pitches !== undefined) {
                  el.pitches[0].endTie = true;
                  multilineVars.inTie = false;
                } else if (el.rest.type !== 'spacer') {
                  el.rest.endTie = true;
                  multilineVars.inTie = false;
                }
              }
              if (core.startTie || el.startTie)
                multilineVars.inTie = true;
              i  = core.endChar;

              if (tripletNotesLeft > 0) {
                tripletNotesLeft--;
                if (tripletNotesLeft === 0) {
                  el.endTriplet = true;
                }
              }

              if (core.end_beam)
                addEndBeam(el);

              // If there is a whole rest, then it should be the duration of the measure, not it's own duration. We need to special case it.
              if (el.rest && el.rest.type === 'rest' && el.duration === 1) {
                el.rest.type = 'whole';

                el.duration = durationOfMeasure(multilineVars);
              }

              if (multilineVars.barNumOnNextNote) {
                el.barNumber = multilineVars.barNumOnNextNote;
                multilineVars.barNumOnNextNote = null;
              }
              multilineVars.addFormattingOptions(el, tune.formatting, 'note');
              tune.appendElement('note', startOfLine+startI, startOfLine+i, el);
              multilineVars.measureNotEmpty = true;
              el = {};
            }
          }

          if (i === startI) {	// don't know what this is, so ignore it.
            if (line.charAt(i) !== ' ' && line.charAt(i) !== '`')
              warn("Unknown character ignored", line, i);
            i++;
          }
        }
      }
    }
  }
126818
function showHelp(){
  var jshint_proc = fork(require.resolve('jshint/bin/jshint'), ['-h'], {silent: true});
  var ts = through(function write(chunk){
    this.queue(chunk.toString().replace(/(jshint)\b/g, 'jsxhint'));
  }, function end() {
    // This feels like a hack. There might be a better way to do this.
    this.queue('\nThe above options are native to JSHint, which JSXHint extends.\n');
    this.queue('\x1b[1m'); // bold
    this.queue('\nJSXHint Options:\n');
    this.queue('\x1b[0m');
    this.queue('      --jsx-only         Only transform files with the .jsx extension.\n' +
               '                         Will run somewhat faster.\n');
    this.queue('      --babel            Use babel (6to5) instead of react esprima.\n' +
               '                         Useful if you are using es6-module, etc. You must \n' +
               '                         install the module `babel` manually with npm.\n');
    this.queue('      --babel-experimental  Use babel with experimental support for ES7.\n' +
               '                            Useful if you are using es7-async, etc.\n');
    this.queue('      --harmony          Use react esprima with ES6 transformation support.\n' +
               '                         Useful if you are using both es6-class and react.\n');
    this.queue('      --es6module             Pass the --es6module flag to react tools.\n');
    this.queue('      --non-strict-es6module  Pass this flag to react tools.\n');
    this.queue('      --transform-errors STRING   Whether to fail on transform errors.\n' +
               '                                  Valid: always, jsx, never (default: jsx)');
  });
  jshint_proc.stderr.pipe(ts).pipe(process.stderr);
}