************* EMPHASIS / STRONG ****************
502977
@MemoMismatches
    public Rule UlOrStarLine() {
        // This keeps the parser from getting bogged down on long strings of '*', '_' or '~',
        // or strings of '*', '_' or '~' with space on each side:
        return NodeSequence(
                FirstOf(CharLine('_'), CharLine('*'), CharLine('~')),
                push(new TextNode(match()))
        );
    }
47343
@SuppressWarnings("fallthrough")
    protected void inlineWord() {
        int pos = bp;
        int depth = 0;
        loop:
        while (bp < buflen) {
            switch (ch) {
                case '\n':
                    newline = true;
                    // fallthrough

                case '\r': case '\f': case ' ': case '\t':
                    return;

                case '@':
                    if (newline)
                        break loop;

                case '{':
                    depth++;
                    break;

                case '}':
                    if (depth == 0 || --depth == 0)
                        return;
                    break;
            }
            newline = false;
            nextChar();
        }
    }
1140839
function(inlines) {
  var subj = this.subject,
      pos  = this.pos;
  if (subj.charAt(pos) === '\\') {
    if (subj.charAt(pos + 1) === '\n') {
      inlines.push({ t: 'Hardbreak' });
      this.pos = this.pos + 2;
      return 2;
    } else if (reEscapable.test(subj.charAt(pos + 1))) {
      inlines.push({ t: 'Str', c: subj.charAt(pos + 1) });
      this.pos = this.pos + 2;
      return 2;
    } else {
      this.pos++;
      inlines.push({t: 'Str', c: '\\'});
      return 1;
    }
  } else {
    return 0;
  }
}
630864
function() {
			var self = this;
			var content;

			content = '<div class="modaal-content-container">' +
					'<h1 id="modaal-title">' + self.options.confirm_title + '</h1>' +
					'<div class="modaal-confirm-content">' + self.options.confirm_content + '</div>' +
						'<div class="modaal-confirm-wrap">' +
							'<button type="button" class="modaal-confirm-btn modaal-ok" aria-label="Confirm">' + self.options.confirm_button_text + '</button>' +
							'<button type="button" class="modaal-confirm-btn modaal-cancel" aria-label="Cancel">' + self.options.confirm_cancel_button_text + '</button>' +
						'</div>' +
					'</div>' +
				'</div>';

			// now push content into markup
			self.build_modal(content);
		}
1193018
function(accent, state) {
  let text = accent === 'ul' ? '* ' : '1. ';
  if (hasMultiLineSelection(state)) {
    const {
      anchorKey,
      anchorOffset,
      focusKey,
      focusOffset,
      isBackward
    } = state.selection;
    const keys = [];
    let firstBefore, firstAfter, lastBefore, lastAfter;
    for (let i = 0; i < state.texts.size; i++) {
      keys.push(state.texts.get(i).key);
    }

    const lineText = state.texts.get(0).text;
    let pref, itemNum, div;
    if (accent === 'ul') {
      const ulMarker = getUlMarker(lineText);
      if (ulMarker) {
        text = ulMarker;
      } else {
        text = '* ';
      }
    } else {
      ({ pref, itemNum, div } = getOlNum(lineText));
    }

    let change = state.change();
    const keysLength = keys.length;
    const lastNum = keysLength - 1;
    for (let i = 0; i < keysLength; i++) {
      moveSelectionToLine(change, keys[i]); // eslint-disable-line no-use-before-define
      if (i === 0) {
        firstBefore = getTextLength(change);
      } else if (i === lastNum) {
        lastBefore = getTextLength(change);
      }
      if (i === 0 && !hasBlock(MATCH_SINGLE_RULE[accent], change.state) || i > 0) {
        text = accent === 'ul' ? text : `${pref}${itemNum}${div} `;
        change = wrapBlockForChange(MATCH_RULES[accent], text, change);// eslint-disable-line
        if (i === 0) {
          firstAfter = getTextLength(change);
        } else if (i === lastNum) {
          lastAfter = getTextLength(change);
        }
        itemNum++;
        continue;
      }
      if (i === 0) {
        firstAfter = firstBefore;
      } else if (i === lastNum) {
        lastAfter = lastBefore;
      }
      itemNum++;
    }
    change.select({
      anchorKey,
      anchorOffset: anchorOffset - firstBefore + firstAfter,
      focusKey,
      focusOffset: focusOffset - lastBefore + lastAfter,
      isFocused: true,
      isBackward
    });

    return change.state;
  } else {
    return wrapBlock(MATCH_RULES[accent], text, state);
  }
}
600811
public void addDeclaration(Element el, PseudoElementType pseudo, Declaration decl)
    {
        List<Declaration> list = getOrCreate(el, pseudo);
        list.add(decl);
    }
589360
private static void textLiteral( Consumer<? super LiteralNode> add, String literal )
    {
        add.accept( literal( literal, false ) );
    }
5804
function addParams(name,command,key,tag,emphasis)
		{
			var thisCssNo  = buttons.length+1;
			return buttons.push({name:name, cls:thisCssNo, command:command, key:key, tag:tag, emphasis:emphasis});
		}
489428
@Override
    public void addComment(XmlElement xmlElement) {
        xmlElement.addElement(new TextElement("<!--"));
        StringBuilder sb = new StringBuilder();
        sb.append("  WARNING - ");
        sb.append(MergeConstants.NEW_ELEMENT_TAG);
        xmlElement.addElement(new TextElement(sb.toString()));
        xmlElement.addElement(new TextElement("-->"));
    }
1267526
private boolean atomNeedsQuoting(final String s) {
        char c;

        if (s.length() == 0) {
            return true;
        }
        if (!isErlangLower(s.charAt(0))) {
            return true;
        }

        final int len = s.length();
        for (int i = 1; i < len; i++) {
            c = s.charAt(i);

            if (!isErlangLetter(c) && !isErlangDigit(c) && c != '@') {
                return true;
            }
        }
        return false;
    }
1256350
function(accent, state) {
  if (hasMultiLineSelection(state)) {
    const {
      anchorKey,
      anchorOffset,
      focusKey,
      focusOffset,
      isBackward
    } = state.selection;
    const keys = [];
    let firstBefore, firstAfter, lastBefore, lastAfter;
    for (let i = 0; i < state.texts.size; i++) {
      keys.push(state.texts.get(i).key);
    }

    let change = state.change();
    const keysLength = keys.length;
    const lastNum = keysLength - 1;
    for (let i = 0; i < keysLength; i++) {
      moveSelectionToLine(change, keys[i]);
      if (i === 0) {
        firstBefore = getTextLength(change);
      } else if (i === lastNum) {
        lastBefore = getTextLength(change);
      }
      change = unwrapListCallbacksForChange[accent](change);
      if (i === 0) {
        firstAfter = getTextLength(change);
      } else if (i === lastNum) {
        lastAfter = getTextLength(change);
      }
    }
    const newAnchorOffset = anchorOffset - (isBackward ? lastBefore - lastAfter : firstBefore - firstAfter);
    const newFocusOffset = focusOffset - (isBackward ? firstBefore - firstAfter : lastBefore - lastAfter);
    change.select({
      anchorKey,
      anchorOffset: newAnchorOffset < 0 ? 0 : newAnchorOffset,
      focusKey,
      focusOffset: newFocusOffset < 0 ? 0 : newFocusOffset,
      isFocused: true,
      isBackward
    });
    return change.state;
  } else {
    return unwrapListCallbacks[accent](state);
  }
}
979308
function onComment(isBlock, text, _s, _e, sLoc, eLoc) {

  var tRegex = /test\s*>\s*(.*)/i;
  var aRegex = /#\s*(.*)/i;
  var isTest = R.test(tRegex);
  var extractTest = R.pipe(R.match(tRegex), R.last(), R.trim());
  var isAssertion = R.test(aRegex);
  var extractAssertion = R.pipe(R.match(aRegex), R.last(), R.trim());
  var lastTestFound = R.last(tests);
  var newTest;

  function belongToTest(locLine, test) {
    return (test === undefined) ? false : locLine - 1 === test.loc.endLine;
  }

  function createEmptyTest(title) {
    return {
      title: title || null,
      loc: { startLine: sLoc.line, endLine: eLoc.line },
      assertions: []
    };
  }

  function addAssertionToTest(assertion, test) {
    test.assertions.push(assertion);
    test.loc.endLine = eLoc.line;
    return test;
  }

  function setTestTitle(title, test) {
    test.title = title;
    return test;
  }

  function buildTest(test, string) {
    if (isTest(string)) {
      setTestTitle(extractTest(string), test);
    } else if (isAssertion(string)) {
      addAssertionToTest(extractAssertion(string), test);
    }
    return test;
  }

  if (!isBlock) {
    if (isTest(text)) {
      newTest = R.pipe(extractTest, createEmptyTest)(text);
      tests.push(newTest);
    } else if (isAssertion(text) && belongToTest(sLoc.line, lastTestFound)) {
      addAssertionToTest(extractAssertion(text), lastTestFound);
    }
  }

  if (isBlock && isTest(text)) {
    newTest = R.reduce(buildTest, createEmptyTest(), R.split('\n', text));
    tests.push(newTest);
  }
}
1290334
function ParserInline() {
  var i;

  /**
   * ParserInline#ruler -> Ruler
   *
   * [[Ruler]] instance. Keep configuration of inline rules.
   **/
  this.ruler = new Ruler();

  for (i = 0; i < _rules.length; i++) {
    this.ruler.push(_rules[i][0], _rules[i][1]);
  }

  /**
   * ParserInline#ruler2 -> Ruler
   *
   * [[Ruler]] instance. Second ruler used for post-processing
   * (e.g. in emphasis-like rules).
   **/
  this.ruler2 = new Ruler();

  for (i = 0; i < _rules2.length; i++) {
    this.ruler2.push(_rules2[i][0], _rules2[i][1]);
  }
}
764658
@Override
    public void beginLink(ResourceReference reference, boolean freestanding, Map<String, String> parameters)
    {
        markNotEmpty();
        startContainerBlock();
        super.beginLink(reference, freestanding, parameters);
    }
533755
function() {
        var line, lines = this.sourceText.split(/\n/mg),
            lineLen = lines.length;

        var inCommenting, curComment, closeCommentIdx;

        for (var i = 0; i < lineLen; ++i) {
            line = lines[i].trim();
            if (line.startsWith('/**')) {
                inCommenting = true;
                curComment = new Comment();
                //Comment closed has to starts with "*/"
            } else if (line.startsWith('*/')) {
                inCommenting = false;
                closeCommentIdx = i;
            } else if (!inCommenting && (1 === i - closeCommentIdx) && /(\bfunction\b\s*?(\w+?)\s*\(([^\(\)]*)\))|((\w+)?\s*(?::|=)\s*function\s*\(([^\(\)]*)\))/.test(line)) {
                curComment.setFunc(RegExp.$2 || RegExp.$5, RegExp.$3 || RegExp.$6);
                if ('string' !== typeof curComment.getTag('ignore')) {
                    this.Comments.push(curComment);
                }
                curComment = null;
            } else if (!inCommenting && (1 === i - closeCommentIdx) && /(\w+)\s*(?::|=)(?!\s*function)/.test(line)) {
                curComment.setAttr(RegExp.$1);
                if ('string' !== typeof curComment.getTag('ignore')) {
                    this.Comments.push(curComment);
                }
                curComment = null;
            } else if (inCommenting) {
                line = line.replace(/^\*/, '').trim();
                if (/^@(\w+)([^\r\n]*)/.test(line)) {
                    curComment.addTag(RegExp.$1, RegExp.$2 || "");
                } else {
                    curComment.addDesc(line);
                }
            }

        } //for

        this._merge();
    }
284643
function() {
    this._super.apply(this, arguments);

    if (this._options.through) {
      this._options.through = inflection.singularize(this._options.through);
    }
  }
1087776
@Override
    public void severe(String msg) {
        if (isLoggable(Level.SEVERE)) {
            log(Level.SEVERE, msg);
        }
    }