function nextWord
179454
function calculateFit() {
      // ignore any further processing if we have total lines
      if (lineCount > lineClamp) {
        // move to the next word
        nextWord();
        return;
      }
      // create a text node to measure
      textNode = ctn(text.substr(lineStart, pos - lineStart));
      // place relevant nodes into the measurement element
      appendNodeAndQueueToElement(measure, textNode, pendingQueue);
      // take the measurement
      measureWidth = measure.clientWidth;
      // remove text node from node stack
      if (nodeStack.length) {
        nodeStack[nodeStack.length - 1].removeChild(textNode);
      }
      // have we exceeded allowed line width?
      if (lineWidth <= measureWidth) {
        if(wasNewLine) {
          // we have a long word so it gets a line of it's own
          lineText = text.substr(lineStart, Math.min(pos + 1, text.length) - lineStart);
          // next line start position
          lineStart = Math.min(pos + 1, text.length);
          // move to the next word
          nextWord();
        } else {
          // grab the text until this word
          lineText = text.substr(lineStart, wordStart - lineStart);
          // next line start position
          lineStart = wordStart;
        }
        // create a line element
        line = ce('span');
        // add text to the line element
        appendNodeAndQueueToElement(line, ctn(lineText), pendingQueue);
        // add the line element to the container
        el.appendChild(line);
        // flush the queue
        pendingQueue = [];
        // refresh the stack
        nodeStack = nodeStack.map((node) => node.cloneNode(false));
        // yes, we created a new line
        wasNewLine = true;
        ++lineCount;
      } else {
        // did not create a new line
        wasNewLine = false;
        // move to the next word
        nextWord();
      }
      // clear measurement element
      while (measure.firstChild !== null) {
        measure.removeChild(measure.firstChild);
      }
    }
262790
def find_previous_word_ending(self, count=1, WORD=False):
        
        if count < 0:
            return self.find_next_word_ending(count=-count, WORD=WORD)

        text_before_cursor = self.text_after_cursor[:1] + self.text_before_cursor[::-1]

        regex = _FIND_BIG_WORD_RE if WORD else _FIND_WORD_RE
        iterator = regex.finditer(text_before_cursor)

        try:
            for i, match in enumerate(iterator):
                # Take first match, unless it's the word on which we're right now.
                if i == 0 and match.start(1) == 0:
                    count += 1

                if i + 1 == count:
                    return -match.start(1) + 1
        except StopIteration:
            pass
288967
function nextTick(fn) {
  const promise = new Promise((resolve) => {
    proc.nextTick(() => {
      resolve(fn());
    });
  });

  return promise;
}
1041125
function next_tag_is(sentence, i, parameter) {
  if (i < sentence.taggedWords.length - 1) {
    return(sentence.taggedWords[i + 1].tag === parameter);
  }
  else {
    return(false);
  }
}
92088
function next(err) {
      var fn = fns[++index]
      var params = slice.call(arguments, 0)
      var values = params.slice(1)
      var length = input.length
      var pos = -1

      if (err) {
        done(err)
        return
      }

      /* Copy non-nully input into values. */
      while (++pos < length) {
        if (values[pos] === null || values[pos] === undefined) {
          values[pos] = input[pos]
        }
      }

      input = values

      /* Next or done. */
      if (fn) {
        wrap(fn, next).apply(null, input)
      } else {
        done.apply(null, [null].concat(input))
      }
    }
798192
function nextTick (next, err) {
  return process.nextTick(function () {
    try {
      next(err)
    } catch (e) {
      // istanbul ignore next
      next(e)
    }
  })
}
50425
def chain_add(word, next_word)
    markov_chains[word] ||= Hash.new(0)
    markov_chains[word][next_word] += 1
  end
1010662
function next(i, p, task) {
        let iResult = task ? { value: task, done: false } : i.next();
        try {
            if (iResult.done) {
                publish($state);
                return;
            }
            const result = iResult.value($state, p);
            /* Promise(Like) */
            if (result && typeof result.then === 'function') {
                result.then(resolved, rejected);
                publish($state);
                return;
                function resolved(t) {
                    const _t = (typeof t === 'function') && t;
                    next(i, p, _t);
                }
                ;
                function rejected(err) {
                    publish($state, err);
                }
            }
            if (!iResult.done) {
                result && setState(result);
                next(i, p);
                return;
            }
        }
        catch (e) {
            publish($state, e);
        }
    }
309882
function currentWord(x) {
    if ((x.b.data.wordWindow["0"] === token) &&
        (x.a === tag)) {
        return 1;
    }
    return 0;
  }
846841
private void advance() {
	String s = null;
	while (tokenizer.hasNext()) {
	    String nextToken = tokenizer.next();
	    // stop if the word should be returned
	    if (filter.accept(nextToken)) {
		s = nextToken;
		break;
	    }
	}
	next = s;
    }
664567
def backward_word(event):
    
    buff = event.current_buffer
    pos = buff.document.find_previous_word_beginning(count=event.arg)

    if pos:
        buff.cursor_position += pos
1031059
function nextQuestion() {
		if ( !hooks.length ) {
			if ( !!options.onDone ) {
				grunt.log.writeln( '' );
				grunt.log.writeln( options.onDone.blue );
			}
			done();
		} else {
			var hookConfig = hooks.shift();
			promptHook( hookConfig );
		}
	}
16761
def _forward_word(text, pos):
    
    while pos < len(text) and not text[pos].isalnum():
        pos += 1
    while pos < len(text) and text[pos].isalnum():
        pos += 1
    return text, pos
616240
def _nl_list_add(obj, prev, next_):
    
    prev.next_ = obj
    obj.prev = prev
    next_.prev = obj
    obj.next_ = next_
1053452
def next_weekday_in(weekday_abbreviation, direction, count, distance)
      count = direction.downcase == 'b' ? -count.to_i : count.to_i
      weekday = WEEKDAYS[weekday_abbreviation.downcase]

      case distance.downcase
      when "d"
      when "w"
        (@now + count * 7) + weekday[0] - @now.wday  
      when "m"
        future = @now >> count
        future + weekday[0] - future.wday
      when "y"
        future = @now >> count * 12
        future + weekday[0] - future.wday
      end
    end
277703
function nextBR(node, dir) {
      var link = dir + "Sibling", search = node[link];
      while (search && !isBR(search))
        search = search[link];
      return search;
    }
890105
def focus_next_matching(self, querystring):
        """"""
        self.focus_property(lambda x: x._message.matches(querystring),
                            self._tree.next_position)