Search target string to find the first index of any string in the given string list, starting at the specified index

@param target
@param fromIndex
@param indexWith
@return
966437
public static int indexAny(String target, Integer fromIndex, List<String> indexWith) {
		if (isNull(target)) {
			return INDEX_NONE_EXISTS;
		}
		
		return matcher(target).indexs(fromIndex, checkNotNull(indexWith).toArray(new String[indexWith.size()]));
	}
343632
function project(value, fromIndex) {
  var index = fromIndex
  var length = value.length
  var size

  while (index < length) {
    if (!projectCharacter(value.charCodeAt(index))) {
      break
    }

    index++
  }

  size = fromIndex - index

  if (
    !size ||
    size > MAX_PROJECT_LENGTH ||
    value.slice(index - GIT_SUFFIX.length, index) === GIT_SUFFIX
  ) {
    return -1
  }

  return index
}
1283055
protected final Object listLookup(List list, int index) {
        LOGGER.trace("get value in List index " + index);
        return list.get(index);
    }
134339
function mapWithIndex (range, index) {
  return {
    start: range.start,
    end: range.end,
    index: index
  }
}
527694
private void ensureIndex(final int index) {
        if (index < 0) throw new IndexOutOfBoundsException("Index (" + index + ") is negative");
        if (index > size())
            throw new IndexOutOfBoundsException("Index (" + index + ") is greater than list size (" + (size()) + ")");
    }
146789
public static <T> Level0ArrayOperator<String[],String> on(final String[] target) {
        return onArrayOf(Types.STRING, target);
    }
244387
@Override
    public List<R> subList(int fromIndex, int toIndex) {
        List<R> r = new ArrayList<>();
        Iterator<R> itr = iterator();
        hudson.util.Iterators.skip(itr, fromIndex);
        for (int i=toIndex-fromIndex; i>0; i--) {
            r.add(itr.next());
        }
        return r;
    }
780573
public static int binarySearch(final char[] a, final int fromIndex, final int toIndex, final char key) {
        return Array.binarySearch(a, fromIndex, toIndex, key);
    }
910638
public static int indexAny(String target, String... indexWith) {
		return indexAny(target, 0, Arrays.asList(indexWith));
	}
537425
function stringStartsWith (str, val, startIndex) {
  var rest = '' + str
  return (arguments.length === 1 ? rest : rest.substring(startIndex)).indexOf(val) === 0
}
795224
public static boolean startAny(String target, Integer toffset, String... startWith) {
		return startAny(target, toffset, Arrays.asList(startWith));
	}
168784
public static Object getIndex(Object array, int index)
            throws UtilTargetError {
        Interpreter.debug("getIndex: ", array, ", index=", index);
        try {
            if ( array instanceof List )
                return ((List<?>) array).get(index);
            Object val = Array.get(array, index);
            return Primitive.wrap( val, Types.arrayElementType(array.getClass()) );
        } catch( IndexOutOfBoundsException e1 ) {
            int len = array instanceof List
                    ? ((List<?>) array).size()
                    : Array.getLength(array);
            throw new UtilTargetError("Index " + index
                    + " out-of-bounds for length " + len, e1);
        }
    }
239630
protected final Token lookahead(int index) throws ScanException, ParseException {
		if (lookahead.isEmpty()) {
			lookahead = new LinkedList<LookaheadToken>();
		}
		while (index >= lookahead.size()) {
			lookahead.add(new LookaheadToken(scanner.next(), scanner.getPosition()));
		}
		return lookahead.get(index).token;
	}
302304
public static Betner betnNext(String target, String leftSameWithRight) {
		return betn(target).betweenNext(leftSameWithRight);
	}
871069
public boolean matches(String target, int start, int end) {
		return this.matches(target, start, end, (Match) null);
	}
735212
public SearchResponse searchAllWithTargetCount(String index, String type) {
        return searchAllWithTargetCount(index, type, null, null);
    }
1169366
public static void checkIndex(final int from, final int until, final int size) {
		if (from < 0) {
			throw new ArrayIndexOutOfBoundsException("fromIndex = " + from);
		}
		if (until > size) {
			throw new ArrayIndexOutOfBoundsException(format(
				"Invalid index range: [%d, %s)", from, until
			));
		}
		if (from > until) {
			throw new IllegalArgumentException(format(
				"fromIndex(%d) > toIndex(%d)", from, until
			));
		}
	}