/* Input is a list of comma separated fully qualified class names
542914
private Class[] parseRecoverableExceptionClassNames(String recoverableExceptionClassNames) {
    if (recoverableExceptionClassNames != null) {
      recoverableExceptionClassNames = recoverableExceptionClassNames.trim();
      if (recoverableExceptionClassNames.length() == 0) {
        recoverableExceptionClassNames = null;
      }
    }
    if (recoverableExceptionClassNames == null) {
      return new Class[0];
    } 
    String[] classNames = recoverableExceptionClassNames.split(",");
    Class[] classes = new Class[classNames.length];
    for (int i = 0; i < classNames.length; i++) {
      try {
        classes[i] = Class.forName(classNames[i].trim());
      } catch (ClassNotFoundException e) {
        throw new RuntimeException(e);
      }
    }
    return classes;
  }
279817
function processHtmlAttributes(input = {}) {
    const attributes = {};
    const htmlAttributes = input.htmlAttributes;
    const wildcardAttributes = input['*'];

    let obj = htmlAttributes || wildcardAttributes;
    if (htmlAttributes && wildcardAttributes) {
        obj = Object.assign(wildcardAttributes, htmlAttributes);
    }

    if (obj) {
        Object.keys(obj).forEach((key) => {
            attributes[camelToKebab(key)] = obj[key];
        });
    }

    return attributes;
}
183012
function( input ) {

    var self = this

    return input.replace(
      /[=][?]([^?]+)[?]([a-z])[?]([^?]*)[?][=]/gi,
      function( match, charset, type, data ) {

        type = type.toUpperCase()

        return type === 'B' ?
          self.decodeBase64( data, charset ) :
          self.decodeQP( data, charset, true )

      }
    )

  }
826848
function uniqueStrings(input){
	const output = {};
	for(let i = 0, l = input.length; i < l; ++i)
		output[input[i]] = true;
	return Object.keys(output);
}
1049346
protected List<AuthorizationValue> transform(List<AuthorizationValue> input) {
        if (input == null) {
            return null;
        }

        List<AuthorizationValue> output = new ArrayList<>();

        for (AuthorizationValue value : input) {
            AuthorizationValue v = new AuthorizationValue();

            v.setKeyName(value.getKeyName());
            v.setValue(value.getValue());
            v.setType(value.getType());

            output.add(v);
        }

        return output;
    }
1206569
function(input) {
    return input.replace(/\{{2,}/g, function(match) {
      return match.length > 2 ? match.substr(2) : '<%=';
    }).replace(/\}{2,}/g, function(match) {
      return match.length > 2 ? match.substr(2) : '%>';
    });
  }
1052299
function simpleCloneInputData(input) {
    // make a simple copy of the pointers because we will get a reference if we don't
    // we only need clientXY for the calculations
    var pointers = [];
    var i = 0;
    while (i < input.pointers.length) {
        pointers[i] = {
            clientX: round(input.pointers[i].clientX),
            clientY: round(input.pointers[i].clientY)
        };
        i++;
    }

    return {
        timeStamp: now(),
        pointers: pointers,
        center: getCenter(pointers),
        deltaX: input.deltaX,
        deltaY: input.deltaY
    };
}
863154
function toCodePoint(input, separator = "-") {
  const codePoints = [];
  for (let codePoint of input) {
    codePoints.push(codePoint.codePointAt(0).toString(16));
  }
  return codePoints.join(separator);
}
690013
private String removeScriptTags(String input) {

        Pattern removePattern = Pattern.compile("<script[^>]*?>[\\s\\S]*?<\\/script>");
        Matcher match = removePattern.matcher(input);
        return match.replaceAll("");
    }
463024
public static String asString(final Object[] input, final String delim) {
        final StringBuffer sb = new StringBuffer();
        for (int i = 0 ; i < input.length ; i++) {
            if (i > 0) {
                sb.append(delim);
            }
            sb.append(input[i].toString());
        }
        return sb.toString();
    }
53224
protected void processInput(String input) {
        String command = input.trim();
        if (!command.isEmpty()) {
            runCommand(command);
        }
    }
876790
function match(input, patterns = []){
	if(!patterns || 0 === patterns.length)
		return false;
	
	input    = String(input);
	patterns = arrayify(patterns).filter(Boolean);
	for(const pattern of patterns)
		if((pattern === input && "string" === typeof pattern)
		|| (pattern instanceof RegExp) && pattern.test(input))
			return true;
	return false;
}
1322888
@Nonnull
    public static List<String> splitAtCommasAndTrim(Iterable<String> input) {
        if(input==null) {
            return Collections.emptyList();
        }
        Iterable<String> nonEmptyInputs = Iterables.filter(input, Predicates.notNull());
        return Lists.newArrayList(Iterables.concat(Iterables.transform(nonEmptyInputs, COMMA_SPLITTER)));
    }
474537
function checkClass(className, output) {
  var hasBinding
  var tempClassList
  var classList = []
  var tempCode

  className = className.trim()
  if (className) {
    tempClassList = className.split(' ')

    // handle space in bindings
    var expStart = -1
    var expEnd = -1
    tempClassList.forEach(function (subName, index) {
      if (subName.indexOf('{{') > -1 && subName.indexOf('}}') === -1) {
        expStart = index
      }
      else if (expStart !== -1 && subName.indexOf('}}') > -1) {
        expEnd = index
        classList.push(tempClassList.slice(expStart, expEnd + 1).join(''))
        expStart = -1
        expEnd = -1
      }
      else if ((expStart === -1 && expEnd === -1) || (subName.indexOf('{{') > -1 && subName.indexOf('}}') > -1)) {
        classList.push(subName)
      }
    })

    classList = classList.map(function (subName) {
      if (exp.isExpr(subName)) {
        hasBinding = true
        return exp(subName, false)
      }
      return '\'' + subName + '\''
    })

    // need to be improved and catch more errors
    if (hasBinding) {
      tempCode = '(function () {return [' + classList.join(', ') + ']})'
      output.result.classList = eval(tempCode)
    }
    else {
      output.result.classList = classList.map(function (subName) {
        return subName.substr(1, subName.length - 2)
      })
    }
  }
}
855269
function match(input) {
    let lowerInput = input.toLowerCase();
    let simpleMatch = _simpleMatch(lowerInput);
    let complexMatch = _complexMatch(lowerInput);
    let output = simpleMatch.concat(complexMatch);

    return output;
}
536232
public Token[] tokenize(String input) 
    {
        Token[] initialTokens = innerTokenizer.tokenize(input);
        List tokens = new ArrayList();
        for (int i=0; i<initialTokens.length; i++) {
            Token tok = initialTokens[i];
            String str = "^"+tok.getValue()+"$";
            if (keepOldTokens) tokens.add( intern(str) );
            for (int lo=0; lo<str.length(); lo++) {
                for (int len=minNGramSize; len<=maxNGramSize; len++) {
                    if (lo+len<str.length()) {
                        tokens.add( innerTokenizer.intern( str.substring(lo,lo+len) )); 
                    }
                }
            }
        }
        return (Token[]) tokens.toArray(new BasicToken[tokens.size()]);
    }
543210
private static String[] split(String input) {
        char macroStart = MACRO_START.charAt(0);
        char macroEnd = MACRO_END.charAt(0);

        int startIndex = 0;
        boolean inMacro = false;

        List<String> list = new ArrayList<String>();

        for (int endIndex = 0; endIndex < input.length(); endIndex++) {
            char chr = input.charAt(endIndex);

            if (!inMacro) {
                if (chr == macroStart) {
                    String result = input.substring(startIndex, endIndex);
                    if (result.length() > 0) {
                        list.add(result);
                    }
                    inMacro = true;
                    startIndex = endIndex;
                }
            } else {
                if (chr == macroEnd) {
                    String result = input.substring(startIndex, endIndex + 1);
                    if (result.length() > 0) {
                        list.add(result);
                    }
                    inMacro = false;
                    startIndex = endIndex + 1;
                }
            }
        }

        String result = input.substring(startIndex);
        if (result.length() > 0) {
            list.add(result);
        }

        return list.toArray(new String[list.size()]);
    }