Reduce duplicate sequences
It looks like you could use reduce to your advantage, and extracting a function to merge two sequences. (Edit: messed up 1st version; this should be better)

Tokens.prototype.reduceSequences = function () {
  // source and destination seem like slightly better names
  function merge(source, destination) {
    // can't merge, so return false
    if( !~destination.content.indexOf( source.content ) )
      return false;

    // no need to actually merge (source included in destination),
    // so just return true
    if( destination.content != source.content )
      return true;

    // otherwise, merge
    for( var i = 0, l = source.starts.length ; i &lt; l ; i++ ) {
      if( ~destination.starts.indexOf(source.starts[i]) ) continue;
      destination.starts.push( source.starts[i] );
      destination.ends.push( source.starts[i] + destination.tokenCount );
      destination.occurences.push( source.occurences[i] );
    }

    return true;
  }

  if(this.sequences.length &lt; 2) return;

  this.sequences = this.sequences.reduce(function (sequences, current) {
    var merged, i, l;

    for( i = 0, l = sequences.length ; i &lt; l &amp;&amp; !merged ; i++ )
      merged = merge(current, sequences[i]);

    if( !merged )
      sequences.push(current);

    return sequences;
  }, []);
}


I think that should work.

Oh, and yes, I've undone your brace-on-new-line style - sorry, couldn't help myself. But I've left out braces I'd usually include, so I've met you halfway! :)

If reduce is not an option, I can't really come up with anything besides extracting a merge function (basically a "lighter" refactoring). Like so

Tokens.prototype.reduceSequences = function () {
  // source and destination seem like slightly better names to use *here*
  // but they don't make as much sense in the loops below, IMO
  function merge(source, destination) {
    for( var i = 0, l = source.starts.length ; i &lt; l ; i++ ) {
      if( ~destination.starts.indexOf(source.starts[i]) ) continue;
      destination.starts.push( source.starts[i] );
      destination.ends.push( source.starts[i] + destination.tokenCount );
      destination.occurences.push( source.occurences[i] );
    }
  }

  var sequences = this.sequences;

  for( var outer = 1 ; outer &lt; sequences.length ; outer++) {
    for( var inner = 0 ; inner &lt; outer ; inner ++) {
      if( sequences[inner].content == sequences[outer].content ) {
        merge(sequences[outer], sequences[inner]);
        sequences.splice(outer, 1);
        outer = 0;
        break;
      }

      if( ~sequences[inner].content.indexOf( sequences[outer].content )  ) {
        sequences.splice(outer, 1);
        outer = 0;
        break;
      }
    }
  }
}


It's not brilliant, but either way it feels a tiny bit cleaner to encapsulate the "merge" step in a function.

By the way, var tokens = this.raw() didn't seem to be used for anything.

It might be more beneficial to simply add the merge function to your sequence objects, though. It'd clean up this particular code nicely. But you know better than I if something like that would make sense in your project.