diff --git a/jcommons/org.eclipse.statet.jcommons.util-tests/src/org/eclipse/statet/jcommons/util/StringUtilsTest.java b/jcommons/org.eclipse.statet.jcommons.util-tests/src/org/eclipse/statet/jcommons/util/StringUtilsTest.java
index 2f2d4ab..46e91f0 100644
--- a/jcommons/org.eclipse.statet.jcommons.util-tests/src/org/eclipse/statet/jcommons/util/StringUtilsTest.java
+++ b/jcommons/org.eclipse.statet.jcommons.util-tests/src/org/eclipse/statet/jcommons/util/StringUtilsTest.java
@@ -15,6 +15,14 @@
 package org.eclipse.statet.jcommons.util;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import static org.eclipse.statet.jcommons.collections.ImCollections.emptyList;
+import static org.eclipse.statet.jcommons.collections.ImCollections.newList;
 
 import org.junit.jupiter.api.Test;
 
@@ -36,4 +44,658 @@
 		assertEquals("U+FFFFFFFF", StringUtils.formatCodePoint(0xFFFFFFFF)); // <invalid>
 	}
 	
+	
+	@Test
+	public void firstIndexOfNonTrim_StringFromToIndex() {
+		assertEquals(0, StringUtils.firstIndexOfNonTrim("", 0, 0));
+		assertEquals(1, StringUtils.firstIndexOfNonTrim(" ", 0, 1));
+		assertEquals(2, StringUtils.firstIndexOfNonTrim(" \t", 0, 2));
+		assertEquals(4, StringUtils.firstIndexOfNonTrim(" \n\t ", 0, 4));
+		assertEquals(1, StringUtils.firstIndexOfNonTrim("\n", 0, 1));
+		assertEquals(0, StringUtils.firstIndexOfNonTrim("abc", 0, 1));
+		assertEquals(3, StringUtils.firstIndexOfNonTrim(" \n\ta ", 0, 5));
+		
+		assertEquals(1, StringUtils.firstIndexOfNonTrim(" ", 1, 1));
+		assertEquals(2, StringUtils.firstIndexOfNonTrim(" \t", 1, 2));
+		assertEquals(4, StringUtils.firstIndexOfNonTrim(" \n\t ", 2, 4));
+		assertEquals(1, StringUtils.firstIndexOfNonTrim("abc", 1, 2));
+		assertEquals(3, StringUtils.firstIndexOfNonTrim(" \n\ta ", 2, 5));
+		
+		assertEquals(0, StringUtils.firstIndexOfNonTrim(" ", 0, 0));
+		assertEquals(1, StringUtils.firstIndexOfNonTrim(" \t", 0, 1));
+		assertEquals(2, StringUtils.firstIndexOfNonTrim(" \n\t ", 0, 2));
+		assertEquals(1, StringUtils.firstIndexOfNonTrim("abc", 1, 2));
+		assertEquals(2, StringUtils.firstIndexOfNonTrim(" \na\t ", 1, 3));
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstIndexOfNonTrim_StringFromToIndex_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfNonTrim(null, 0, 4) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfNonTrim(null, 0, 0) );
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstIndexOfNonTrim("abc", -1, 0) );
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstIndexOfNonTrim("abc", 0, 4) );
+	}
+	
+	@Test
+	public void firstIndexOfNonTrim_String() {
+		assertEquals(0, StringUtils.firstIndexOfNonTrim(""));
+		assertEquals(1, StringUtils.firstIndexOfNonTrim(" "));
+		assertEquals(2, StringUtils.firstIndexOfNonTrim(" \t"));
+		assertEquals(4, StringUtils.firstIndexOfNonTrim(" \n\t "));
+		assertEquals(1, StringUtils.firstIndexOfNonTrim("\n"));
+		assertEquals(0, StringUtils.firstIndexOfNonTrim("abc"));
+		assertEquals(3, StringUtils.firstIndexOfNonTrim(" \n\ta "));
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstIndexOfNonTrim_String_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfNonTrim(null) );
+	}
+	
+	@Test
+	public void lastIndexOfNonTrim_StringFromToIndex() {
+		assertEquals(0, StringUtils.lastIndexOfNonTrim("", 0, 0));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(" ", 0, 1));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(" \t", 0, 2));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(" \n\t ", 0, 4));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim("\n", 0, 1));
+		assertEquals(1, StringUtils.lastIndexOfNonTrim("abc", 0, 1));
+		assertEquals(4, StringUtils.lastIndexOfNonTrim(" \n\ta ", 0, 5));
+		
+		assertEquals(1, StringUtils.lastIndexOfNonTrim(" ", 1, 1));
+		assertEquals(1, StringUtils.lastIndexOfNonTrim(" \t", 1, 2));
+		assertEquals(2, StringUtils.lastIndexOfNonTrim(" \n\t ", 2, 4));
+		assertEquals(2, StringUtils.lastIndexOfNonTrim("abc", 1, 2));
+		assertEquals(4, StringUtils.lastIndexOfNonTrim(" \n\ta ", 2, 5));
+		
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(" ", 0, 0));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(" \t", 0, 1));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(" \n\t ", 0, 2));
+		assertEquals(2, StringUtils.lastIndexOfNonTrim("abc", 1, 2));
+		assertEquals(3, StringUtils.lastIndexOfNonTrim(" \na\t ", 1, 3));
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void lastIndexOfNonTrim_StringFromToIndex_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.lastIndexOfNonTrim(null, 0, 4) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.lastIndexOfNonTrim(null, 0, 0) );
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.lastIndexOfNonTrim("abc", -1, 0) );
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.lastIndexOfNonTrim("abc", 0, 4) );
+	}
+	
+	@Test
+	public void lastIndexOfNonTrim_String() {
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(""));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(" "));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(" \t"));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim(" \n\t "));
+		assertEquals(0, StringUtils.lastIndexOfNonTrim("\n"));
+		assertEquals(3, StringUtils.lastIndexOfNonTrim("abc"));
+		assertEquals(4, StringUtils.lastIndexOfNonTrim(" \n\ta "));
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void lastIndexOfNonTrim_String_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.lastIndexOfNonTrim(null) );
+	}
+	
+	
+	@Test
+	public void trim_StringFromToIndex() {
+		assertEquals("", StringUtils.trim("", 0, 0));
+		assertEquals("", StringUtils.trim(" ", 0, 1));
+		assertEquals("", StringUtils.trim(" \t", 0, 2));
+		assertEquals("", StringUtils.trim(" \n\t ", 0, 4));
+		assertEquals("", StringUtils.trim("\n", 0, 1));
+		assertEquals("a", StringUtils.trim("abc", 0, 1));
+		assertEquals("a", StringUtils.trim(" \n\ta ", 0, 5));
+		
+		assertEquals("", StringUtils.trim(" ", 1, 1));
+		assertEquals("", StringUtils.trim(" \t", 1, 2));
+		assertEquals("", StringUtils.trim(" \n\t ", 2, 4));
+		assertEquals("b", StringUtils.trim("abc", 1, 2));
+		assertEquals("a", StringUtils.trim(" \n\ta ", 2, 5));
+		
+		assertEquals("", StringUtils.trim(" ", 0, 0));
+		assertEquals("", StringUtils.trim(" \t", 0, 1));
+		assertEquals("", StringUtils.trim(" \n\t ", 0, 2));
+		assertEquals("b", StringUtils.trim("abc", 1, 2));
+		assertEquals("a", StringUtils.trim(" \na\t ", 1, 3));
+		assertEquals("", StringUtils.trim(" \na\t ", 1, 2));
+	}
+	
+	@Test
+	public void isTrimEmpty_StringFromToIndex() {
+		assertTrue(StringUtils.isTrimEmpty("", 0, 0));
+		assertTrue(StringUtils.isTrimEmpty(" ", 0, 1));
+		assertTrue(StringUtils.isTrimEmpty(" \t", 0, 2));
+		assertTrue(StringUtils.isTrimEmpty(" \n\t ", 0, 4));
+		assertTrue(StringUtils.isTrimEmpty("\n", 0, 1));
+		assertFalse(StringUtils.isTrimEmpty("abc", 0, 1));
+		assertFalse(StringUtils.isTrimEmpty(" \n\ta ", 0, 5));
+		
+		assertTrue(StringUtils.isTrimEmpty(" ", 1, 1));
+		assertTrue(StringUtils.isTrimEmpty(" \t", 1, 2));
+		assertTrue(StringUtils.isTrimEmpty(" \n\t ", 2, 4));
+		assertFalse(StringUtils.isTrimEmpty("abc", 1, 2));
+		assertFalse(StringUtils.isTrimEmpty(" \n\ta ", 2, 5));
+		
+		assertTrue(StringUtils.isTrimEmpty(" ", 0, 0));
+		assertTrue(StringUtils.isTrimEmpty(" \t", 0, 1));
+		assertTrue(StringUtils.isTrimEmpty(" \n\t ", 0, 2));
+		assertFalse(StringUtils.isTrimEmpty("abc", 1, 2));
+		assertFalse(StringUtils.isTrimEmpty(" \na\t ", 1, 3));
+		assertTrue(StringUtils.isTrimEmpty(" \na\t ", 1, 2));
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void isTrimEmpty_StringFromToIndex_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.isTrimEmpty(null, 0, 4) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.isTrimEmpty(null, 0, 0) );
+	}
+	
+	@Test
+	public void isTrimEmpty_String() {
+		assertTrue(StringUtils.isTrimEmpty(""));
+		assertTrue(StringUtils.isTrimEmpty(" "));
+		assertTrue(StringUtils.isTrimEmpty(" \t"));
+		assertTrue(StringUtils.isTrimEmpty(" \n\t "));
+		assertTrue(StringUtils.isTrimEmpty("\n"));
+		assertFalse(StringUtils.isTrimEmpty("a"));
+		assertFalse(StringUtils.isTrimEmpty(" \n\ta "));
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void isTrimEmpty_String_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.isTrimEmpty(null) );
+	}
+	
+	
+	@Test
+	public void containsAny_String() {
+		boolean match;
+		
+		match= StringUtils.containsAny("xxxxxxxxxx", emptyList());
+		assertFalse(match);
+		
+		match= StringUtils.containsAny("xxxxxxxxxx", newList("a", "ab", "abc"));
+		assertFalse(match);
+		
+		match= StringUtils.containsAny("foobarabcd", newList("a", "ab", "abc"));
+		assertTrue(match);
+		
+		match= StringUtils.containsAny("foobarabcd", newList("ab", "abc"));
+		assertTrue(match);
+		
+		match= StringUtils.containsAny("foobarabcd", newList("ab", "ab"));
+		assertTrue(match);
+		
+		match= StringUtils.containsAny("foobarabcd", newList("", "ab", "abc"));
+		assertTrue(match);
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void containsAny_String_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.containsAny((String)null, newList("abc")) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.containsAny("foobarabcd", null) );
+//		assertThrows(NullPointerException.class, () ->
+//				StringUtils.containsAny("foobarabcd", newList("abc", null)) );
+	}
+	
+	
+	@Test
+	public void containsAny_StringBuilder() {
+		boolean match;
+		
+		match= StringUtils.containsAny(new StringBuilder("xxxxxxxxxx"), emptyList());
+		assertFalse(match);
+		
+		match= StringUtils.containsAny(new StringBuilder("xxxxxxxxxx"), newList("a", "ab", "abc"));
+		assertFalse(match);
+		
+		match= StringUtils.containsAny(new StringBuilder("foobarabcd"), newList("a", "ab", "abc"));
+		assertTrue(match);
+		
+		match= StringUtils.containsAny(new StringBuilder("foobarabcd"), newList("ab", "abc"));
+		assertTrue(match);
+		
+		match= StringUtils.containsAny(new StringBuilder("foobarabcd"), newList("ab", "ab"));
+		assertTrue(match);
+		
+		match= StringUtils.containsAny(new StringBuilder("foobarabcd"), newList("", "ab", "abc"));
+		assertTrue(match);
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void containsAny_StringBuilder_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.containsAny((StringBuilder)null, newList("abc")) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.containsAny(new StringBuilder("foobarabcd"), null) );
+//		assertThrows(NullPointerException.class, () ->
+//				StringUtils.containsAny(new StringBuilder("foobarabcd"), newList("abc", null)) );
+	}
+	
+	
+	@Test
+	public void firstIndexOfAny_StringFromIndex() {
+		int match;
+		
+		match= StringUtils.firstIndexOfAny("xxxxxxxxxx", emptyList(), 0);
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny("xxxxxxxxxx", newList("a", "ab", "abc"), 0);
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("a", "ab", "abc"), 0);
+		assertEquals(4, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("ab", "ab"), 0);
+		assertEquals(6, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("", "ab", "abc"), 0);
+		assertEquals(0, match);
+		
+		match= StringUtils.firstIndexOfAny("xxxxxxxxxx", emptyList(), 5);
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny("xaxxabcxxx", newList("a", "ab", "abc"), 5);
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("a", "ab", "abc"), 5);
+		assertEquals(6, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("", "ab", "abc"), 5);
+		assertEquals(5, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("a", "ab", "abc"), "foobarabcd".length());
+		assertEquals(-1, match);
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstIndexOfAny_StringFromIndex_argCheck() {
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstIndexOfAny("foobarabcd", newList("abc"), -5) );
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstIndexOfAny("foobarabcd", newList("abc"), 20) );
+		
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny((String)null, newList("abc"), 5) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny("foobarabcd", null, 5) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny("foobarabcd", newList("abc", null), 5) );
+	}
+	
+	@Test
+	public void firstIndexOfAny_String() {
+		int match;
+		
+		match= StringUtils.firstIndexOfAny("xxxxxxxxxx", emptyList());
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny("xxxxxxxxxx", newList("a", "ab", "abc"));
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("a", "ab", "abc"));
+		assertEquals(4, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("ab", "abc"));
+		assertEquals(6, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("ab", "ab"));
+		assertEquals(6, match);
+		
+		match= StringUtils.firstIndexOfAny("foobarabcd", newList("", "ab", "abc"));
+		assertEquals(0, match);
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstIndexOfAny_String_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny((String)null, newList("abc")) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny("foobarabcd", null) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny("foobarabcd", newList("abc", null)) );
+	}
+	
+	
+	@Test
+	public void firstIndexOfAny_StringBuilderFromIndex() {
+		int match;
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("xxxxxxxxxx"), emptyList(), 0);
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("xxxxxxxxxx"), newList("a", "ab", "abc"), 0);
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("a", "ab", "abc"), 0);
+		assertEquals(4, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("ab", "ab"), 0);
+		assertEquals(6, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("", "ab", "abc"), 0);
+		assertEquals(0, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("xxxxxxxxxx"), emptyList(), 5);
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("xaxxabcxxx"), newList("a", "ab", "abc"), 5);
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("a", "ab", "abc"), 5);
+		assertEquals(6, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("", "ab", "abc"), 5);
+		assertEquals(5, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("a", "ab", "abc"), "foobarabcd".length());
+		assertEquals(-1, match);
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstIndexOfAny_StringBuilderFromIndex_argCheck() {
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("abc"), -5) );
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("abc"), 20) );
+		
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny((StringBuilder)null, newList("abc"), 5) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), null, 5) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("abc", null), 5) );
+	}
+	
+	@Test
+	public void firstIndexOfAny_StringBuilder() {
+		int match;
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("xxxxxxxxxx"), emptyList());
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("xxxxxxxxxx"), newList("a", "ab", "abc"));
+		assertEquals(-1, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("a", "ab", "abc"));
+		assertEquals(4, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("ab", "abc"));
+		assertEquals(6, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("ab", "ab"));
+		assertEquals(6, match);
+		
+		match= StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("", "ab", "abc"));
+		assertEquals(0, match);
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstIndexOfAny_StringBuilder_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny((StringBuilder)null, newList("abc")) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), null) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstIndexOfAny(new StringBuilder("foobarabcd"), newList("abc", null)) );
+	}
+	
+	
+	@Test
+	public void Match() {
+		StringUtils.Match match;
+		
+		match= new StringUtils.Match("abc", 2);
+		assertEquals("abc", match.getString());
+		assertEquals(2, match.getStartIndex());
+		assertEquals(2 + 3, match.getEndIndex());
+		assertEquals(3, match.getLength());
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void Match_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+			new StringUtils.Match(null, 2) );
+	}
+	
+	
+	@Test
+	public void firstMatchOfAny_StringFromIndex() {
+		StringUtils.Match match;
+		
+		match= StringUtils.firstMatchOfAny("xxxxxxxxxx", emptyList(), 0);
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny("xxxxxxxxxx", newList("a", "ab", "abc"), 0);
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("a", "ab", "abc"), 0);
+		assertNotNull(match);
+		assertEquals("a", match.getString());
+		assertEquals(4, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("ab", "ab"), 0);
+		assertNotNull(match);
+		assertEquals("ab", match.getString());
+		assertEquals(6, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("", "ab", "abc"), 0);
+		assertNotNull(match);
+		assertEquals("", match.getString());
+		assertEquals(0, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny("xxxxxxxxxx", emptyList(), 5);
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny("xaxxabcxxx", newList("a", "ab", "abc"), 5);
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("a", "ab", "abc"), 5);
+		assertNotNull(match);
+		assertEquals("abc", match.getString());
+		assertEquals(6, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("", "ab", "abc"), 5);
+		assertNotNull(match);
+		assertEquals("", match.getString());
+		assertEquals(5, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("a", "ab", "abc"), "foobarabcd".length());
+		assertNull(match);
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstMatchOfAny_StringFromIndex_argCheck() {
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstMatchOfAny("foobarabcd", newList("abc"), -5) );
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstMatchOfAny("foobarabcd", newList("abc"), 20) );
+		
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny((String)null, newList("abc"), 5) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny("foobarabcd", null, 5) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny("foobarabcd", newList("abc", null), 5) );
+	}
+	
+	@Test
+	public void firstMatchOfAny_String() {
+		StringUtils.Match match;
+		
+		match= StringUtils.firstMatchOfAny("xxxxxxxxxx", emptyList());
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny("xxxxxxxxxx", newList("a", "ab", "abc"));
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("a", "ab", "abc"));
+		assertNotNull(match);
+		assertEquals("a", match.getString());
+		assertEquals(4, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("ab", "abc"));
+		assertNotNull(match);
+		assertEquals("abc", match.getString());
+		assertEquals(6, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("ab", "ab"));
+		assertNotNull(match);
+		assertEquals("ab", match.getString());
+		assertEquals(6, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny("foobarabcd", newList("", "ab", "abc"));
+		assertNotNull(match);
+		assertEquals("", match.getString());
+		assertEquals(0, match.getStartIndex());
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstMatchOfAny_String_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny((String)null, newList("abc")) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny("foobarabcd", null) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny("foobarabcd", newList("abc", null)) );
+	}
+	
+	
+	@Test
+	public void firstMatchOfAny_StringBuilderFromIndex() {
+		StringUtils.Match match;
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("xxxxxxxxxx"), emptyList(), 0);
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("xxxxxxxxxx"), newList("a", "ab", "abc"), 0);
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("a", "ab", "abc"), 0);
+		assertNotNull(match);
+		assertEquals("a", match.getString());
+		assertEquals(4, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("ab", "ab"), 0);
+		assertNotNull(match);
+		assertEquals("ab", match.getString());
+		assertEquals(6, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("", "ab", "abc"), 0);
+		assertNotNull(match);
+		assertEquals("", match.getString());
+		assertEquals(0, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("xxxxxxxxxx"), emptyList(), 5);
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("xaxxabcxxx"), newList("a", "ab", "abc"), 5);
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("a", "ab", "abc"), 5);
+		assertNotNull(match);
+		assertEquals("abc", match.getString());
+		assertEquals(6, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("", "ab", "abc"), 5);
+		assertNotNull(match);
+		assertEquals("", match.getString());
+		assertEquals(5, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("a", "ab", "abc"), "foobarabcd".length());
+		assertNull(match);
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstMatchOfAny_StringBuilderFromIndex_argCheck() {
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("abc"), -5) );
+		assertThrows(StringIndexOutOfBoundsException.class, () ->
+				StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("abc"), 20) );
+		
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny((StringBuilder)null, newList("abc"), 5) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), null, 5) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("abc", null), 5) );
+	}
+	
+	@Test
+	public void firstMatchOfAny_StringBuilder() {
+		StringUtils.Match match;
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("xxxxxxxxxx"), emptyList());
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("xxxxxxxxxx"), newList("a", "ab", "abc"));
+		assertNull(match);
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("a", "ab", "abc"));
+		assertNotNull(match);
+		assertEquals("a", match.getString());
+		assertEquals(4, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("ab", "abc"));
+		assertNotNull(match);
+		assertEquals("abc", match.getString());
+		assertEquals(6, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("ab", "ab"));
+		assertNotNull(match);
+		assertEquals("ab", match.getString());
+		assertEquals(6, match.getStartIndex());
+		
+		match= StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("", "ab", "abc"));
+		assertNotNull(match);
+		assertEquals("", match.getString());
+		assertEquals(0, match.getStartIndex());
+	}
+	
+	@Test
+	@SuppressWarnings("null")
+	public void firstMatchOfAny_StringBuilder_argCheck() {
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny((StringBuilder)null, newList("abc")) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), null) );
+		assertThrows(NullPointerException.class, () ->
+				StringUtils.firstMatchOfAny(new StringBuilder("foobarabcd"), newList("abc", null)) );
+	}
+	
 }
diff --git a/jcommons/org.eclipse.statet.jcommons.util/src/org/eclipse/statet/jcommons/util/StringUtils.java b/jcommons/org.eclipse.statet.jcommons.util/src/org/eclipse/statet/jcommons/util/StringUtils.java
index 7986a9f..f0abe50 100644
--- a/jcommons/org.eclipse.statet.jcommons.util/src/org/eclipse/statet/jcommons/util/StringUtils.java
+++ b/jcommons/org.eclipse.statet.jcommons.util/src/org/eclipse/statet/jcommons/util/StringUtils.java
@@ -14,11 +14,15 @@
 
 package org.eclipse.statet.jcommons.util;
 
+import static org.eclipse.statet.jcommons.lang.ObjectUtils.nonNullAssert;
+
+import org.eclipse.statet.jcommons.collections.ImCollection;
 import org.eclipse.statet.jcommons.lang.NonNullByDefault;
+import org.eclipse.statet.jcommons.lang.Nullable;
 
 
 @NonNullByDefault
-public class StringUtils {
+public final class StringUtils {
 	
 	
 	private static final byte[] U_DIGITS= {
@@ -48,6 +52,324 @@
 	}
 	
 	
+	public static int firstIndexOfNonTrim(final String s, int start, final int end) {
+		if (start < 0 || end > s.length()) {
+			throw new StringIndexOutOfBoundsException();
+		}
+		while (start < end && s.charAt(start) <= ' ') {
+			start++;
+		}
+		return start;
+	}
+	
+	public static int firstIndexOfNonTrim(final String s) {
+		int start= 0;
+		final int end= s.length();
+		while (start < end && s.charAt(start) <= ' ') {
+			start++;
+		}
+		return start;
+	}
+	
+	public static int lastIndexOfNonTrim(final String s, final int start, int end) {
+		if (start < 0 || end > s.length()) {
+			throw new StringIndexOutOfBoundsException();
+		}
+		while (start < end && s.charAt(end - 1) <= ' ') {
+			end--;
+		}
+		return end;
+	}
+	
+	public static int lastIndexOfNonTrim(final String s) {
+		int end= s.length();
+		while (0 < end && s.charAt(end - 1) <= ' ') {
+			end--;
+		}
+		return end;
+	}
+	
+	public static String trim(final String s, int start, int end) {
+		if (start < 0 || end > s.length()) {
+			throw new StringIndexOutOfBoundsException();
+		}
+		if (start == 0 && end == s.length()) {
+			return s.trim();
+		}
+		while (start < end && s.charAt(start) <= ' ') {
+			start++;
+		}
+		while (start < end && s.charAt(end - 1) <= ' ') {
+			end--;
+		}
+		return s.substring(start, end);
+	}
+	
+	public static boolean isTrimEmpty(final String s) {
+		int start= 0;
+		final int end= s.length();
+		while (start < end && s.charAt(start) <= ' ') {
+			start++;
+		}
+		return (start == end);
+	}
+	
+	public static boolean isTrimEmpty(final String s, int start, final int end) {
+		if (start < 0 || end > s.length()) {
+			throw new StringIndexOutOfBoundsException();
+		}
+		while (start < end && s.charAt(start) <= ' ') {
+			start++;
+		}
+		return (start == end);
+	}
+	
+	
+	public static boolean containsAny(final String s, final ImCollection<String> searchStrings) {
+		String prevString= null;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				continue;
+			}
+			prevString= searchString;
+			if (s.indexOf(searchString) >= 0) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	public static boolean containsAny(final StringBuilder s, final ImCollection<String> searchStrings) {
+		String prevString= null;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				continue;
+			}
+			prevString= searchString;
+			if (s.indexOf(searchString) >= 0) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	
+	public static int firstIndexOfAny(final String s, final ImCollection<String> searchStrings,
+			final int fromIndex) {
+		if (fromIndex < 0 || fromIndex > s.length()) {
+			throw new StringIndexOutOfBoundsException(fromIndex);
+		}
+		int matchIndex= Integer.MAX_VALUE;
+		String prevString= null;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				continue;
+			}
+			prevString= searchString;
+			final int index= s.indexOf(searchString, fromIndex);
+			if (index >= 0 && index < matchIndex) {
+				matchIndex= index;
+			}
+		}
+		return (matchIndex != Integer.MAX_VALUE) ? matchIndex : -1;
+	}
+	
+	public static int firstIndexOfAny(final String s, final ImCollection<String> searchStrings) {
+		int matchIndex= Integer.MAX_VALUE;
+		String prevString= null;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				continue;
+			}
+			prevString= searchString;
+			final int index= s.indexOf(searchString);
+			if (index >= 0 && index < matchIndex) {
+				matchIndex= index;
+			}
+		}
+		return (matchIndex != Integer.MAX_VALUE) ? matchIndex : -1;
+	}
+	
+	public static int firstIndexOfAny(final StringBuilder s, final ImCollection<String> searchStrings,
+			final int fromIndex) {
+		if (fromIndex < 0 || fromIndex > s.length()) {
+			throw new StringIndexOutOfBoundsException(fromIndex);
+		}
+		int matchIndex= Integer.MAX_VALUE;
+		String prevString= null;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				continue;
+			}
+			prevString= searchString;
+			final int index= s.indexOf(searchString, fromIndex);
+			if (index >= 0 && index < matchIndex) {
+				matchIndex= index;
+			}
+		}
+		return (matchIndex != Integer.MAX_VALUE) ? matchIndex : -1;
+	}
+	
+	public static int firstIndexOfAny(final StringBuilder s, final ImCollection<String> searchStrings) {
+		int matchIndex= Integer.MAX_VALUE;
+		String prevString= null;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				continue;
+			}
+			prevString= searchString;
+			final int index= s.indexOf(searchString);
+			if (index >= 0 && index < matchIndex) {
+				matchIndex= index;
+			}
+		}
+		return (matchIndex != Integer.MAX_VALUE) ? matchIndex : -1;
+	}
+	
+	
+	public static final class Match {
+		
+		
+		private final String string;
+		
+		private final int startIndex;
+		
+		
+		public Match(final String string, final int startIndex) {
+			this.string= nonNullAssert(string);
+			this.startIndex= startIndex;
+		}
+		
+		
+		public String getString() {
+			return this.string;
+		}
+		
+		public int getStartIndex() {
+			return this.startIndex;
+		}
+		
+		public int getEndIndex() {
+			return this.startIndex + this.string.length();
+		}
+		
+		public int getLength() {
+			return this.string.length();
+		}
+		
+	}
+	
+	@SuppressWarnings("null")
+	public static @Nullable Match firstMatchOfAny(final String s, final ImCollection<String> searchStrings,
+			final int fromIndex) {
+		if (fromIndex < 0 || fromIndex > s.length()) {
+			throw new StringIndexOutOfBoundsException(fromIndex);
+		}
+		String matchString= null;
+		int matchIndex= Integer.MAX_VALUE;
+		String prevString= null;
+		boolean prevMatch= false;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				if (prevMatch && s.startsWith(searchString, matchIndex)) {
+					matchString= prevString= searchString;
+				}
+				continue;
+			}
+			final int index= s.indexOf(searchString, fromIndex);
+			if (prevMatch= (index >= 0
+					&& (index < matchIndex 
+								|| index == matchIndex && searchString.length() > matchString.length() ))) {
+				matchString= searchString;
+				matchIndex= index;
+			}
+			prevString= searchString;
+		}
+		return (matchString != null) ? new Match(matchString, matchIndex) : null;
+	}
+	
+	@SuppressWarnings("null")
+	public static @Nullable Match firstMatchOfAny(final String s, final ImCollection<String> searchStrings) {
+		String matchString= null;
+		int matchIndex= Integer.MAX_VALUE;
+		String prevString= null;
+		boolean prevMatch= false;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				if (prevMatch && s.startsWith(searchString, matchIndex)) {
+					matchString= searchString;
+				}
+				continue;
+			}
+			final int index= s.indexOf(searchString);
+			if (prevMatch= (index >= 0
+					&& (index < matchIndex 
+							|| index == matchIndex && searchString.length() > matchString.length() ))) {
+				matchString= searchString;
+				matchIndex= index;
+			}
+			prevString= searchString;
+		}
+		return (matchString != null) ? new Match(matchString, matchIndex) : null;
+	}
+	
+	@SuppressWarnings("null")
+	public static @Nullable Match firstMatchOfAny(final StringBuilder s, final ImCollection<String> searchStrings,
+			final int fromIndex) {
+		if (fromIndex < 0 || fromIndex > s.length()) {
+			throw new StringIndexOutOfBoundsException(fromIndex);
+		}
+		String matchString= null;
+		int matchIndex= Integer.MAX_VALUE;
+		String prevString= null;
+		boolean prevMatch= false;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				if (prevMatch && matchIndex + searchString.length() <= s.length()
+						&& s.substring(matchIndex, matchIndex + searchString.length()).equals(searchString) ) {
+					matchString= prevString= searchString;
+				}
+				continue;
+			}
+			final int index= s.indexOf(searchString, fromIndex);
+			if (prevMatch= (index >= 0
+					&& (index < matchIndex 
+							|| index == matchIndex && searchString.length() > matchString.length() ))) {
+				matchString= searchString;
+				matchIndex= index;
+			}
+			prevString= searchString;
+		}
+		return (matchString != null) ? new Match(matchString, matchIndex) : null;
+	}
+	
+	@SuppressWarnings("null")
+	public static @Nullable Match firstMatchOfAny(final StringBuilder s, final ImCollection<String> searchStrings) {
+		String matchString= null;
+		int matchIndex= Integer.MAX_VALUE;
+		String prevString= null;
+		boolean prevMatch= false;
+		for (final String searchString : searchStrings) {
+			if (prevString != null && searchString.startsWith(prevString)) {
+				if (prevMatch && matchIndex + searchString.length() <= s.length()
+						&& s.substring(matchIndex, matchIndex + searchString.length()).equals(searchString) ) {
+					matchString= prevString= searchString;
+				}
+				continue;
+			}
+			final int index= s.indexOf(searchString);
+			if (prevMatch= (index >= 0
+					&& (index < matchIndex 
+							|| index == matchIndex && searchString.length() > matchString.length() ))) {
+				matchString= searchString;
+				matchIndex= index;
+			}
+			prevString= searchString;
+		}
+		return (matchString != null) ? new Match(matchString, matchIndex) : null;
+	}
+	
+	
 	private StringUtils() {
 	}