Package org.codehaus.groovy.runtime

# Class StringGroovyMethods

java.lang.Object
org.codehaus.groovy.runtime.DefaultGroovyMethodsSupport
org.codehaus.groovy.runtime.StringGroovyMethods

public class StringGroovyMethods extends DefaultGroovyMethodsSupport
This class defines new groovy methods which appear on String-related JDK classes (String, CharSequence, Matcher) inside the Groovy environment. Static methods are used with the first parameter being the destination class, e.g. `public static String reverse(String self)` provides a `reverse()` method for `String`.

NOTE: While this class contains many 'public' static methods, it is primarily regarded as an internal class (its internal package name suggests this also). We value backwards compatibility of these methods when used within Groovy but value less backwards compatibility at the Java method call level. I.e. future versions of Groovy may remove or move a method call in this file but would normally aim to keep the method available from within Groovy.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `StringGroovyMethods()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static StringBuilder`
  `append(StringBuilder sb, GStringImpl gs)`
  Append the GString to the StringBuilder using a more efficient approach than Java's default approach for a CharSequence.
  `static boolean`
  `asBoolean(CharSequence chars)`
  Coerces a CharSequence to a boolean value.
  `static boolean`
  `asBoolean(Matcher matcher)`
  Coerces a Matcher instance to a boolean value.
  `static <T> T`
  `asType(GString self, Class<T> c)`
  Converts the GString to a File, or delegates to the default `DefaultGroovyMethods.asType(Object,Class)`.
  `static <T> T`
  `asType(CharSequence self, Class<T> c)`
  Provides a method to perform custom 'dynamic' type conversion to the given class using the `as` operator.
  `static <T> T`
  `asType(String self, Class<T> c)`
  Provides a method to perform custom 'dynamic' type conversion to the given class using the `as` operator.
  `static Pattern`
  `bitwiseNegate(CharSequence self)`
  Turns a CharSequence into a regular expression Pattern.
  `static String`
  `capitalize(CharSequence self)`
  Convenience method to capitalize the first letter of a CharSequence (typically the first letter of a word).
  `static String`
  `center(CharSequence self, Number numberOfChars)`
  Pads a CharSequence to a minimum length specified by `numberOfChars` by adding the space character around it as many times as needed so that it remains centered.
  `static String`
  `center(CharSequence self, Number numberOfChars, CharSequence padding)`
  Pad a CharSequence to a minimum length specified by `numberOfChars`, appending the supplied padding CharSequence around the original as many times as needed keeping it centered.
  `static String`
  `collectReplacements(String self, Closure<String> transform)`
  Iterates through this String a character at a time collecting either the original character or a transformed replacement String.
  `static String`
  `collectReplacements(String self, List<Function<Character,Optional<String>>> transforms)`
  Iterates through this String a character at a time collecting either the original character or a transformed replacement String.
  `static boolean`
  `contains(CharSequence self, CharSequence text)`
  Provides an implementation of contains() like `Collection.contains(Object)` to make CharSequences more polymorphic.
  `static boolean`
  `containsIgnoreCase(CharSequence self, CharSequence searchString)`
  Checks whether this CharSequence contains the `searchString` ignoring the caseConsiderations.
  `static int`
  `count(CharSequence self, CharSequence text)`
  Counts the number of occurrences of a sub CharSequence.
  `static String`
  `denormalize(CharSequence self)`
  Return a CharSequence with lines (separated by LF, CR/LF, or CR) terminated by the platform specific line separator.
  `static String`
  `drop(GString self, int num)`
  A GString variant of the equivalent CharSequence method.
  `static CharSequence`
  `drop(CharSequence self, int num)`
  Drops the given number of chars from the head of this CharSequence if they are available.
  `static String`
  `drop(String self, int num)`
  A String variant of the equivalent CharSequence method.
  `static String`
  `dropRight(GString self, int num)`
  A GString variant of the equivalent CharSequence method `dropRight(CharSequence,int)`.
  `static CharSequence`
  `dropRight(CharSequence self, int num)`
  Returns new CharSequence after removing the right `num` chars.
  `static String`
  `dropRight(String self, int num)`
  A String variant of the equivalent CharSequence method `dropRight(CharSequence,int)`.
  `static String`
  `dropWhile(GString self, Closure condition)`
  A GString variant of the equivalent CharSequence method.
  `static String`
  `dropWhile(CharSequence self, Closure condition)`
  Creates a suffix of the given CharSequence by dropping as many characters as possible from the front of the original CharSequence such that calling the given closure condition evaluates to true when passed each of the dropped characters.
  `static CharSequence`
  `dropWhile$$bridge(CharSequence self, Closure condition)`
  Deprecated.
  `static <T> T`
  `eachLine(CharSequence self, int firstLine, Closure<T> closure)`
  Iterates through this CharSequence line by line.
  `static <T> T`
  `eachLine(CharSequence self, Closure<T> closure)`
  Iterates through this CharSequence line by line.
  `static String`
  `eachMatch(String self, String regex, Closure closure)`
  Process each regex group matched substring of the given string.
  `static String`
  `eachMatch(String self, Pattern pattern, Closure closure)`
  Processes each regex group matched substring of the given pattern.
  `static <T extends CharSequence>
  T`
  `eachMatch(T self, CharSequence regex, Closure closure)`
  Processes each regex group matched substring of the given CharSequence.
  `static <T extends CharSequence>
  T`
  `eachMatch(T self, Pattern pattern, Closure closure)`
  Processes each regex group matched substring of the given pattern.
  `static boolean`
  `endsWithAny(CharSequence self, CharSequence... suffixes)`
  Tests if this CharSequence ends with any specified suffixes.
  `static boolean`
  `endsWithIgnoreCase(CharSequence self, CharSequence searchString)`
  Checks whether this CharSequence ends with the `searchString` ignoring the case considerations.
  `static String`
  `expand(CharSequence self)`
  Expands all tabs into spaces with tabStops of size 8.
  `static String`
  `expand(CharSequence self, int tabStop)`
  Expands all tabs into spaces.
  `static String`
  `expandLine(CharSequence self, int tabStop)`
  Expands all tabs into spaces.
  `static String`
  `find(CharSequence self, CharSequence regex)`
  Finds the first occurrence of a regular expression String within a String.
  `static String`
  `find(CharSequence self, CharSequence regex, Closure closure)`
  Returns the result of calling a closure with the first occurrence of a regular expression found within a CharSequence.
  `static String`
  `find(CharSequence self, Pattern pattern)`
  Finds the first occurrence of a compiled regular expression Pattern within a String.
  `static String`
  `find(CharSequence self, Pattern pattern, Closure closure)`
  Returns the result of calling a closure with the first occurrence of a compiled regular expression found within a String.
  `static List<String>`
  `findAll(CharSequence self, CharSequence regex)`
  Returns a (possibly empty) list of all occurrences of a regular expression (provided as a CharSequence) found within a CharSequence.
  `static <T> List<T>`
  `findAll(CharSequence self, CharSequence regex, Closure<T> closure)`
  Finds all occurrences of a regular expression string within a CharSequence.
  `static List<String>`
  `findAll(CharSequence self, Pattern pattern)`
  Returns a (possibly empty) list of all occurrences of a regular expression (in Pattern format) found within a CharSequence.
  `static <T> List<T>`
  `findAll(CharSequence self, Pattern pattern, Closure<T> closure)`
  Finds all occurrences of a compiled regular expression Pattern within a CharSequence.
  `static List<List<String>>`
  `findAllGroups(CharSequence self, CharSequence regex)`
  Returns a (possibly empty) list of all occurrences of a regular expression within a CharSequence, with each occurrence represented by a List containing the full match followed by each capture group.
  `static List<List<String>>`
  `findAllGroups(CharSequence self, Pattern pattern)`
  Returns a (possibly empty) list of all occurrences of a compiled regular expression Pattern within a CharSequence, with each occurrence represented by a List containing the full match followed by each capture group.
  `static List<BalancedGroup>`
  `findBalancedGroups(CharSequence self, String openRegex, String closeRegex)`
  Finds balanced (nested) groups in this CharSequence using default options (no ignore pattern; opening and closing delimiters are kept in the match text).
  `static List<BalancedGroup>`
  `findBalancedGroups(CharSequence self, String openRegex, String closeRegex, BalancedGroup.MatchOptions options)`
  Finds balanced (nested) groups in this CharSequence with the given options.
  `static List<String>`
  `findGroups(CharSequence self, CharSequence regex)`
  Finds the first occurrence of a regular expression within a CharSequence and returns the full match followed by each capture group as a List.
  `static List<String>`
  `findGroups(CharSequence self, Pattern pattern)`
  Finds the first occurrence of a compiled regular expression Pattern within a CharSequence and returns the full match followed by each capture group as a List.
  `static String`
  `getAt(GString self, int index)`
  Supports the subscript operator for GString.
  `static String`
  `getAt(GString self, IntRange range)`
  Supports the range subscript operator for GString with IntRange.
  `static String`
  `getAt(GString self, Range range)`
  Supports the range subscript operator for GString.
  `static CharSequence`
  `getAt(CharSequence self, int index)`
  Supports the subscript operator for CharSequence.
  `static String`
  `getAt(CharSequence self, EmptyRange range)`
  Supports the range subscript operator for CharSequence or StringBuffer with EmptyRange
  `static CharSequence`
  `getAt(CharSequence self, IntRange range)`
  Supports the range subscript operator for CharSequence with IntRange.
  `static CharSequence`
  `getAt(CharSequence self, Range range)`
  Supports the range subscript operator for CharSequence.
  `static String`
  `getAt(CharSequence self, Collection indices)`
  Selects a List of characters from a CharSequence using a Collection to identify the indices to be selected.
  `static String`
  `getAt(String self, int index)`
  Supports the subscript operator for String.
  `static String`
  `getAt(String self, IntRange range)`
  Supports the range subscript operator for String with IntRange.
  `static String`
  `getAt(String self, Range range)`
  Supports the range subscript operator for String.
  `static Object`
  `getAt(Matcher self, int index)`
  Supports the subscript operator, e.g.
  `static List`
  `getAt(Matcher self, Collection indices)`
  Selects a List of values from a Matcher using a Collection to identify the indices to be selected.
  `static char[]`
  `getChars(CharSequence self)`
  Converts the given CharSequence into an array of characters.
  `static int[]`
  `getCodePoints(CharSequence self)`
  Converts the given CharSequence into an array of code point values including any surrogate pairs as per `String.codePoints()`.
  `static int`
  `getCount(Matcher self)`
  Finds the number of Strings matched to the given Matcher.
  `static int`
  `getLength(StringBuffer self)`
  Provides a `getLength` alias for `length` for `StringBuffer`, supporting assignment arithmetic operator expressions involving the otherwise write-only length property.
  `static int`
  `getLength(StringBuilder self)`
  Provides a `getLength` alias for `length` for `StringBuilder`, supporting assignment arithmetic operator expressions involving the otherwise write-only length property.
  `static boolean`
  `hasGroup(Matcher self)`
  Checks whether a Matcher contains a group or not.
  `static boolean`
  `isAllWhitespace(CharSequence self)`
  Returns true if a CharSequence only contains whitespace characters.
  `static Boolean`
  `isAtLeast(String left, String right)`
  Compares a String representing a number to another.
  `static boolean`
  `isBigDecimal(CharSequence self)`
  Determines if a CharSequence can be parsed as a BigDecimal.
  `static boolean`
  `isBigInteger(CharSequence self)`
  Determines if a CharSequence can be parsed as a BigInteger.
  `static boolean`
  `isBlank(CharSequence self)`
  Tests if this CharSequence is blank.
  `static boolean`
  `isCase(CharSequence caseValue, Object switchValue)`
  'Case' implementation for a CharSequence, which uses equals between the toString() of the caseValue and the switchValue.
  `static boolean`
  `isCase(Pattern caseValue, Object switchValue)`
  'Case' implementation for the `Pattern` class, which allows testing a String against a number of regular expressions.
  `static boolean`
  `isDouble(CharSequence self)`
  Determines if a CharSequence can be parsed as a Double.
  `static boolean`
  `isFloat(CharSequence self)`
  Determines if a CharSequence can be parsed as a Float.
  `static boolean`
  `isInteger(CharSequence self)`
  Determines if a CharSequence can be parsed as an Integer.
  `static boolean`
  `isLong(CharSequence self)`
  Determines if a CharSequence can be parsed as a Long.
  `static boolean`
  `isNotCase(CharSequence caseValue, Object switchValue)`
  `static boolean`
  `isNotCase(Pattern caseValue, Object switchValue)`
  `static boolean`
  `isNumber(CharSequence self)`
  Determines if a CharSequence can be parsed as a Number.
  `static Iterator`
  `iterator(Matcher self)`
  Returns an `Iterator` which traverses each match.
  `static StringBuilder`
  `leftShift(CharSequence self, Object value)`
  Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a CharSequence.
  `static StringBuffer`
  `leftShift(StringBuffer self, Object value)`
  Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a StringBuffer.
  `static StringBuilder`
  `leftShift(StringBuilder self, Object value)`
  Overloads the left shift operator to provide syntactic sugar for appending to a StringBuilder.
  `static StringBuffer`
  `leftShift(String self, Object value)`
  Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a String.
  `static boolean`
  `matches(CharSequence self, Pattern pattern)`
  Determines if a CharSequence matches the given regular expression.
  `static boolean`
  `matchesPartially(Matcher self)`
  Given a matcher that matches a string against a pattern, returns true when the string matches the pattern or if a longer string, could match the pattern.
  `static String`
  `minus(CharSequence self, Object target)`
  Removes a part of a CharSequence by replacing the first occurrence of target within self with empty string and returns the result.
  `static String`
  `minus(CharSequence self, Pattern pattern)`
  Removes a part of a CharSequence.
  `static String`
  `multiply(CharSequence self, Number factor)`
  Repeats a CharSequence a certain number of times.
  `static String`
  `next(CharSequence self)`
  Overloads the `++` operator for the class CharSequence.
  `static String`
  `next(CharSequence self, int n)`
  A variant of next with an integer count parameter; equivalent to calling next() count times.
  `static String`
  `normalize(CharSequence self)`
  Returns a String with linefeeds and carriage returns normalized to linefeeds.
  `static String`
  `padLeft(CharSequence self, Number numberOfChars)`
  Pads a CharSequence to a minimum length specified by `numberOfChars` by adding the space character to the left as many times as needed.
  `static String`
  `padLeft(CharSequence self, Number numberOfChars, CharSequence padding)`
  Pads a CharSequence to a minimum length specified by `numberOfChars`, adding the supplied padding CharSequence as many times as needed to the left.
  `static String`
  `padRight(CharSequence self, Number numberOfChars)`
  Pads a CharSequence to a minimum length specified by `numberOfChars` by adding the space character to the right as many times as needed.
  `static String`
  `padRight(CharSequence self, Number numberOfChars, CharSequence padding)`
  Pads a CharSequence to a minimum length specified by `numberOfChars`, adding the supplied padding CharSequence as many times as needed to the right.
  `static String`
  `plus(CharSequence left, Object right)`
  Appends the String representation of the given operand to this CharSequence.
  `static String`
  `plus(Number left, String right)`
  Appends a String to the string representation of this number.
  `static String`
  `plus(StringBuffer left, String right)`
  Appends a String to this StringBuffer.
  `static String`
  `plus(String left, CharSequence right)`
  Appends the String representation of the given operand to this string.
  `static String`
  `previous(CharSequence self)`
  Overloads the `--` operator for the class CharSequence.
  `static String`
  `previous(CharSequence self, int n)`
  A variant of previous with an integer count parameter; equivalent to calling previous() count times.
  `static void`
  `putAt(StringBuffer self, EmptyRange range, Object value)`
  Supports the range subscript operator for StringBuffer.
  `static void`
  `putAt(StringBuffer self, IntRange range, Object value)`
  Supports the range subscript operator for StringBuffer.
  `static List<String>`
  `readLines(CharSequence self)`
  Returns the lines of a CharSequence as a List of String.
  `static String`
  `replace(CharSequence self, int capacity, Map<CharSequence,CharSequence> replacements)`
  Replaces all occurrences of replacement CharSequences (supplied via a map) within a provided CharSequence with control over the internally created StringBuilder's capacity.
  `static String`
  `replace(CharSequence self, Map<CharSequence,CharSequence> replacements)`
  Replaces all occurrences of replacement CharSequences (supplied via a map) within a provided CharSequence.
  `static String`
  `replaceAll(CharSequence self, CharSequence regex, Closure closure)`
  Replaces all occurrences of a captured group by the result of calling a closure on that text.
  `static String`
  `replaceAll(CharSequence self, CharSequence regex, CharSequence replacement)`
  Replaces each substring of this CharSequence that matches the given regular expression with the given replacement.
  `static String`
  `replaceAll(CharSequence self, Pattern pattern, Closure closure)`
  Replaces all occurrences of a captured group by the result of a closure call on that text.
  `static String`
  `replaceAll(CharSequence self, Pattern pattern, CharSequence replacement)`
  Replaces all substrings of a CharSequence that match the given compiled regular expression with the given replacement.
  `static String`
  `replaceFirst(CharSequence self, CharSequence regex, Closure closure)`
  Replaces the first occurrence of a captured group by the result of a closure call on that text.
  `static String`
  `replaceFirst(CharSequence self, CharSequence regex, CharSequence replacement)`
  Replaces the first substring of this CharSequence that matches the given regular expression with the given replacement.
  `static String`
  `replaceFirst(CharSequence self, Pattern pattern, Closure closure)`
  Replaces the first occurrence of a captured group by the result of a closure call on that text.
  `static String`
  `replaceFirst(CharSequence self, Pattern pattern, CharSequence replacement)`
  Replaces the first substring of a CharSequence that matches the given compiled regular expression with the given replacement.
  `static String`
  `reverse(CharSequence self)`
  Creates a String which is the reverse (backwards) of this CharSequence
  `static void`
  `setIndex(Matcher self, int index)`
  Sets the position of the given Matcher to the given index.
  `static int`
  `size(CharSequence self)`
  Provides the standard Groovy `size()` method for `CharSequence`.
  `static int`
  `size(String self)`
  Deprecated.
  `static int`
  `size(StringBuffer self)`
  Deprecated.
  `static long`
  `size(Matcher self)`
  Provides the standard Groovy `size()` method for `Matcher`.
  `static String[]`
  `split(CharSequence self)`
  Splits a CharSequence (with whitespace as delimiter).
  `static <T> T`
  `splitEachLine(CharSequence self, CharSequence regex, Closure<T> closure)`
  Iterates through the given CharSequence line by line, splitting each line using the given regex delimiter.
  `static <T> T`
  `splitEachLine(CharSequence self, Pattern pattern, Closure<T> closure)`
  Iterates through the given CharSequence line by line, splitting each line using the given separator Pattern.
  `static boolean`
  `startsWithAny(CharSequence self, CharSequence... prefixes)`
  Tests if this CharSequence starts with any specified prefixes.
  `static boolean`
  `startsWithIgnoreCase(CharSequence self, CharSequence searchString)`
  Checks whether this CharSequence starts with the `searchString` ignoring the case considerations.
  `static String`
  `stripIndent(CharSequence self)`
  Strips leading spaces from every line in a CharSequence.
  `static String`
  `stripIndent(CharSequence self, boolean forceGroovyBehavior)`
  Same logic as `stripIndent(CharSequence)` if `forceGroovyBehavior` is `true`, otherwise `stripIndent` from JDK 13+ will be invoked.
  `static String`
  `stripIndent(CharSequence self, int numChars)`
  Strips `numChars` leading characters from every line in a CharSequence.
  `static String`
  `stripMargin(CharSequence self)`
  Strips leading whitespace/control characters followed by '|' from every line in a CharSequence.
  `static String`
  `stripMargin(CharSequence self, char marginChar)`
  Strips leading whitespace/control characters followed by `marginChar` from every line in a CharSequence.
  `static String`
  `stripMargin(CharSequence self, CharSequence marginChar)`
  Strips leading whitespace/control characters followed by `marginChar` from every line in a CharSequence.
  `static String`
  `take(GString self, int num)`
  A GString variant of the equivalent CharSequence method.
  `static CharSequence`
  `take(CharSequence self, int num)`
  Returns the first `num` elements from this CharSequence.
  `static String`
  `take(String self, int num)`
  A String variant of the equivalent CharSequence method.
  `static String`
  `takeAfter(GString self, CharSequence searchString)`
  A GString variant of the equivalent CharSequence method `takeAfter(CharSequence,CharSequence)`.
  `static CharSequence`
  `takeAfter(CharSequence self, CharSequence searchString)`
  Returns the `CharSequence` that exists after the first occurrence of the given `searchString` in this CharSequence.
  `static String`
  `takeAfter(String self, CharSequence searchString)`
  A String variant of the equivalent CharSequence method `takeAfter(CharSequence,CharSequence)`.
  `static String`
  `takeBefore(GString self, String searchString)`
  A GString variant of the equivalent CharSequence method `takeBefore(CharSequence,CharSequence)`.
  `static CharSequence`
  `takeBefore(CharSequence self, CharSequence searchString)`
  Returns the `CharSequence` that exists before the first occurrence of the given `searchString` in this CharSequence.
  `static String`
  `takeBefore(String self, String searchString)`
  A String variant of the equivalent CharSequence method `takeBefore(CharSequence,CharSequence)`.
  `static String`
  `takeBetween(GString self, CharSequence enclosure)`
  A GString variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence)`.
  `static String`
  `takeBetween(GString self, CharSequence enclosure, int occurrence)`
  A GString variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,int)`.
  `static String`
  `takeBetween(GString self, CharSequence from, CharSequence to)`
  A GString variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,CharSequence)`.
  `static String`
  `takeBetween(GString self, CharSequence from, CharSequence to, int occurrence)`
  A GString variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,CharSequence,int)`.
  `static CharSequence`
  `takeBetween(CharSequence self, CharSequence enclosure)`
  Takes the characters between the first occurrence of the two subsequent `enclosure` strings.
  `static CharSequence`
  `takeBetween(CharSequence self, CharSequence enclosure, int occurrence)`
  Takes the characters between nth (specified by occurrence) pair of `enclosure` strings.
  `static CharSequence`
  `takeBetween(CharSequence self, CharSequence from, CharSequence to)`
  Returns the CharSequence that is in between the first occurrence of the given `from` and `to` CharSequences and empty if the unavailable inputs are given.
  `static CharSequence`
  `takeBetween(CharSequence self, CharSequence from, CharSequence to, int occurrence)`
  Returns the CharSequence that is in between the given the nth (specified by occurrence) pair of `from` and `to` CharSequences and empty if the unavailable inputs are given.
  `static String`
  `takeBetween(String self, CharSequence enclosure)`
  A String variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence)`.
  `static String`
  `takeBetween(String self, CharSequence enclosure, int occurrence)`
  A String variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,int)`.
  `static String`
  `takeBetween(String self, CharSequence from, CharSequence to)`
  A String variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,CharSequence)`.
  `static String`
  `takeBetween(String self, CharSequence from, CharSequence to, int occurrence)`
  A String variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,CharSequence,int)`.
  `static String`
  `takeRight(GString self, int num)`
  A String variant of the equivalent CharSequence method `takeRight(CharSequence,int)`.
  `static CharSequence`
  `takeRight(CharSequence self, int num)`
  Returns the last `num` elements from this CharSequence.
  `static String`
  `takeRight(String self, int num)`
  A GString variant of the equivalent CharSequence method `takeRight(CharSequence,int)`.
  `static String`
  `takeWhile(GString self, Closure condition)`
  A GString variant of the equivalent GString method.
  `static String`
  `takeWhile(CharSequence self, Closure condition)`
  Returns the longest prefix of this CharSequence where each element passed to the given closure evaluates to true.
  `static CharSequence`
  `takeWhile$$bridge(CharSequence self, Closure condition)`
  Deprecated.
  `static BigDecimal`
  `toBigDecimal(CharSequence self)`
  Parses a CharSequence into a BigDecimal
  `static BigInteger`
  `toBigInteger(CharSequence self)`
  Parses a CharSequence into a BigInteger
  `static Boolean`
  `toBoolean(String self)`
  Converts the given string into a Boolean object.
  `static Character`
  `toCharacter(String self)`
  Converts the given string into a Character object using the first character in the string.
  `static Number`
  `toCurrencyNumber(CharSequence self, Locale locale)`
  Parses a CharSequence into a Number using the currency format of the given locale.
  `static Double`
  `toDouble(CharSequence self)`
  Parses a CharSequence into a Double.
  `static Float`
  `toFloat(CharSequence self)`
  Parses a CharSequence into a Float.
  `static Integer`
  `toInteger(CharSequence self)`
  Parses a CharSequence into an Integer.
  `static List<String>`
  `tokenize(CharSequence self)`
  Tokenizes a CharSequence (with a whitespace as the delimiter).
  `static List<String>`
  `tokenize(CharSequence self, Character delimiter)`
  Tokenizes a CharSequence based on the given character delimiter.
  `static List<String>`
  `tokenize(CharSequence self, CharSequence delimiters)`
  Tokenizes a CharSequence based on the given CharSequence.
  `static List<String>`
  `toList(CharSequence self)`
  Converts the given CharSequence into a List of Strings of one character.
  `static Long`
  `toLong(CharSequence self)`
  Parses a CharSequence into a Long
  `static Number`
  `toNumber(CharSequence self, Locale locale)`
  Parses a CharSequence into a Number using the given locale, honouring locale-specific grouping and decimal symbols.
  `static Number`
  `toPercentNumber(CharSequence self, Locale locale)`
  Parses a CharSequence into a Number using the percent format of the given locale.
  `static Set<String>`
  `toSet(CharSequence self)`
  Converts the given CharSequence into a Set of unique Strings of one character.
  `static Short`
  `toShort(CharSequence self)`
  Parses a CharSequence into a Short.
  `static String`
  `tr(CharSequence self, CharSequence sourceSet, CharSequence replacementSet)`
  Translates a CharSequence by replacing characters from the sourceSet with characters from replacementSet.
  `static String`
  `uncapitalize(CharSequence self)`
  Convenience method to uncapitalize the first letter of a CharSequence (typically the first letter of a word).
  `static String`
  `unexpand(CharSequence self)`
  Replaces sequences of whitespaces with tabs using tabStops of size 8.
  `static String`
  `unexpand(CharSequence self, int tabStop)`
  Replaces sequences of whitespaces with tabs.
  `static String`
  `unexpandLine(CharSequence self, int tabStop)`
  Replaces sequences of whitespaces with tabs within a line.

  ### Methods inherited from class org.codehaus.groovy.runtime.DefaultGroovyMethodsSupport

  `cloneSimilarCollection, cloneSimilarMap, closeQuietly, closeWithWarning, createSimilarArray, createSimilarCollection, createSimilarCollection, createSimilarCollection, createSimilarList, createSimilarMap, createSimilarOrDefaultCollection, createSimilarQueue, createSimilarSet, normaliseIndex, sameType, sameType, subListBorders, subListBorders, subListRange, writeUTF16BomIfRequired, writeUTF16BomIfRequired, writeUTF16BomIfRequired, writeUTF16BomIfRequired`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### StringGroovyMethods

    public StringGroovyMethods()

- ## Method Details

  - ### asBoolean

    public static boolean asBoolean(CharSequence chars)
    Coerces a CharSequence to a boolean value. A sequence string is coerced to `false` if it is of length 0, and to `true` otherwise.
    Parameters:
      `chars` - the character sequence
    Returns:
      the boolean value
    Since:
      1.7.0

  - ### asBoolean

    public static boolean asBoolean(Matcher matcher)
    Coerces a Matcher instance to a boolean value.
    Parameters:
      `matcher` - the matcher
    Returns:
      the boolean value
    Since:
      1.7.0

  - ### asType

    public static <T> T asType(CharSequence self, Class<T> c)
    Provides a method to perform custom 'dynamic' type conversion to the given class using the `as` operator.
    Parameters:
      `self` - a CharSequence
      `c` - the desired class
    Returns:
      the converted object
    Since:
      1.8.2
    See Also:
      - `asType(String,Class)`

  - ### asType

    public static <T> T asType(GString self, Class<T> c)
    Converts the GString to a File, or delegates to the default `DefaultGroovyMethods.asType(Object,Class)`.
    Parameters:
      `self` - a GString
      `c` - the desired class
    Returns:
      the converted object
    Since:
      1.5.0

  - ### asType

    public static <T> T asType(String self, Class<T> c)
    Provides a method to perform custom 'dynamic' type conversion to the given class using the `as` operator.

    Example: `'123' as Double`

    By default, the following types are supported:

    - List
    - BigDecimal
    - BigInteger
    - Long
    - Integer
    - Short
    - Byte
    - Character
    - Double
    - Float
    - File
    - Subclasses of Enum
    If any other type is given, the call is delegated to `DefaultGroovyMethods.asType(Object,Class)`.
    Parameters:
      `self` - a String
      `c` - the desired class
    Returns:
      the converted object
    Since:
      1.0

  - ### bitwiseNegate

    public static Pattern bitwiseNegate(CharSequence self)
    Turns a CharSequence into a regular expression Pattern.
    Parameters:
      `self` - a String to convert into a regular expression
    Returns:
      the regular expression pattern
    Since:
      1.8.2

  - ### append

    public static StringBuilder append(StringBuilder sb, GStringImpl gs)
    Append the GString to the StringBuilder using a more efficient approach than Java's default approach for a CharSequence.
    Parameters:
      `sb` - a StringBuilder
      `gs` - a GStringImpl
    Returns:
      the StringBuilder
    Since:
      3.0.8

  - ### uncapitalize

    public static String uncapitalize(CharSequence self)
    Convenience method to uncapitalize the first letter of a CharSequence (typically the first letter of a word). Example usage:

         assert 'H'.uncapitalize() == 'h'
         assert 'Hello'.uncapitalize() == 'hello'
         assert 'Hello world'.uncapitalize() == 'hello world'
         assert 'Hello World'.uncapitalize() == 'hello World'
         assert 'hello world' == 'Hello World'.split(' ').collect{ it.uncapitalize() }.join(' ')

    Parameters:
      `self` - The CharSequence to uncapitalize
    Returns:
      A String containing the uncapitalized toString() of the CharSequence
    Since:
      2.4.8

  - ### capitalize

    public static String capitalize(CharSequence self)
    Convenience method to capitalize the first letter of a CharSequence (typically the first letter of a word). Example usage:

         assert 'h'.capitalize() == 'H'
         assert 'hello'.capitalize() == 'Hello'
         assert 'hello world'.capitalize() == 'Hello world'
         assert 'Hello World' ==
             'hello world'.split(' ').collect{ it.capitalize() }.join(' ')

    Parameters:
      `self` - The CharSequence to capitalize
    Returns:
      A String containing the capitalized toString() of the CharSequence
    Since:
      1.8.2

  - ### center

    public static String center(CharSequence self, Number numberOfChars)
    Pads a CharSequence to a minimum length specified by `numberOfChars` by adding the space character around it as many times as needed so that it remains centered.

    If the String is already the same size or bigger than the target `numberOfChars`, then the original String is returned. An example:

         ['A', 'BB', 'CCC', 'DDDD'].each{ println '|' + it.center(6) + '|' }

    will produce output like:

         |  A   |
         |  BB  |
         | CCC  |
         | DDDD |

    Parameters:
      `self` - a CharSequence object
      `numberOfChars` - the total minimum number of characters of the result
    Returns:
      the centered toString() of this CharSequence with padded characters around it
    Since:
      1.8.2

  - ### center

    public static String center(CharSequence self, Number numberOfChars, CharSequence padding)
    Pad a CharSequence to a minimum length specified by `numberOfChars`, appending the supplied padding CharSequence around the original as many times as needed keeping it centered. If the String is already the same size or bigger than the target `numberOfChars`, then the original String is returned. An example:

         ['A', 'BB', 'CCC', 'DDDD'].each{ println '|' + it.center(6, '+') + '|' }

    will produce output like:

         |++A+++|
         |++BB++|
         |+CCC++|
         |+DDDD+|

    Parameters:
      `self` - a CharSequence object
      `numberOfChars` - the total minimum number of characters of the resulting CharSequence
      `padding` - the characters used for padding
    Returns:
      the centered toString() of this CharSequence with padded characters around it
    Since:
      1.8.2

  - ### contains

    public static boolean contains(CharSequence self, CharSequence text)
    Provides an implementation of contains() like `Collection.contains(Object)` to make CharSequences more polymorphic.
    Parameters:
      `self` - a CharSequence
      `text` - the CharSequence to look for
    Returns:
      true if this CharSequence contains the given text
    Since:
      1.8.2

  - ### count

    public static int count(CharSequence self, CharSequence text)
    Counts the number of occurrences of a sub CharSequence.
    Parameters:
      `self` - a CharSequence
      `text` - a sub CharSequence
    Returns:
      the number of occurrences of the given CharSequence inside this CharSequence
    Since:
      1.8.2

  - ### denormalize

    public static String denormalize(CharSequence self)
    Return a CharSequence with lines (separated by LF, CR/LF, or CR) terminated by the platform specific line separator.
    Parameters:
      `self` - a CharSequence object
    Returns:
      the denormalized toString() of this CharSequence
    Since:
      1.8.2

  - ### drop

    public static CharSequence drop(CharSequence self, int num)
    Drops the given number of chars from the head of this CharSequence if they are available.

             def text = "Groovy"
             assert text.drop( 0 ) == 'Groovy'
             assert text.drop( 2 ) == 'oovy'
             assert text.drop( 7 ) == ''

    Parameters:
      `self` - the original CharSequence
      `num` - the number of characters to drop from this String
    Returns:
      a CharSequence consisting of all characters except the first `num` ones, or else an empty String, if this CharSequence has less than `num` characters.
    Since:
      1.8.1

  - ### drop

    public static String drop(GString self, int num)
    A GString variant of the equivalent CharSequence method.
    Parameters:
      `self` - the original GString
      `num` - the number of characters to drop from this GString
    Returns:
      a String consisting of all characters except the first `num` ones, or else an empty String, if the toString() of this GString has less than `num` characters.
    Since:
      2.3.7
    See Also:
      - `drop(String,int)`

  - ### drop

    public static String drop(String self, int num)
    A String variant of the equivalent CharSequence method.
    Parameters:
      `self` - the original String
      `num` - the number of characters to drop from this String
    Returns:
      a String consisting of all characters except the first `num` ones, or else an empty String, if the String has less than `num` characters.
    Since:
      2.5.5
    See Also:
      - `drop(CharSequence,int)`

  - ### dropWhile

    public static String dropWhile(CharSequence self, @ClosureParams(value=FromString.class,conflictResolutionStrategy=PickFirstResolver.class,options={"String","Character"}) Closure condition)
    Creates a suffix of the given CharSequence by dropping as many characters as possible from the front of the original CharSequence such that calling the given closure condition evaluates to true when passed each of the dropped characters.

         def text = "Groovy"
         assert text.dropWhile{ false } == 'Groovy'
         assert text.dropWhile{ true } == ''
         assert text.dropWhile{ it < 'Z' } == 'roovy'
         assert text.dropWhile{ it != 'v' } == 'vy'

    Parameters:
      `self` - the original CharSequence
      `condition` - the closure that while continuously evaluating to true will cause us to drop elements from the front of the original CharSequence
    Returns:
      the shortest suffix of the given CharSequence such that the given closure condition evaluates to true for each element dropped from the front of the CharSequence
    Since:
      2.0.0

  - ### dropWhile$$bridge

    @Deprecated public static CharSequence dropWhile$$bridge(CharSequence self, @ClosureParams(value=FromString.class,conflictResolutionStrategy=PickFirstResolver.class,options={"String","Character"}) Closure condition)
    Deprecated.

  - ### dropWhile

    public static String dropWhile(GString self, @ClosureParams(value=FromString.class,conflictResolutionStrategy=PickFirstResolver.class,options={"String","Character"}) Closure condition)
    A GString variant of the equivalent CharSequence method.
    Parameters:
      `self` - the original GString
      `condition` - the closure that while continuously evaluating to true will cause us to drop elements from the front of the original GString
    Returns:
      the shortest suffix of the given GString such that the given closure condition evaluates to true for each element dropped from the front of the CharSequence
    Since:
      2.3.7
    See Also:
      - `dropWhile(CharSequence,Closure)`

  - ### eachLine

    public static <T> T eachLine(CharSequence self, @ClosureParams(value=FromString.class,options={"String","String,Integer"}) Closure<T> closure) throws IOException
    Iterates through this CharSequence line by line. Each line is passed to the given 1 or 2 arg closure. If a 2 arg closure is found the line count is passed as the second argument.
    Parameters:
      `self` - a CharSequence
      `closure` - a closure
    Returns:
      the last value returned by the closure
    Throws:
      `IOException` - if an error occurs
    Since:
      1.8.2

  - ### eachLine

    public static <T> T eachLine(CharSequence self, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"}) Closure<T> closure) throws IOException
    Iterates through this CharSequence line by line. Each line is passed to the given 1 or 2 arg closure. If a 2 arg closure is found the line count is passed as the second argument.
    Parameters:
      `self` - a CharSequence
      `firstLine` - the line number value used for the first line (default is 1, set to 0 to start counting from 0)
      `closure` - a closure (arg 1 is line, optional arg 2 is line number)
    Returns:
      the last value returned by the closure
    Throws:
      `IOException` - if an error occurs
    Since:
      1.8.2

  - ### collectReplacements

    public static String collectReplacements(String self, @ClosureParams(value=FromString.class,conflictResolutionStrategy=PickFirstResolver.class,options={"String","Character"}) Closure<String> transform)
    Iterates through this String a character at a time collecting either the original character or a transformed replacement String. The `transform` Closure should return `null` to indicate that no transformation is required for the given character.

         assert "Groovy".collectReplacements{ it == 'o' ? '_O_' : null } == 'Gr_O__O_vy'
         assert "Groovy".collectReplacements{ it.equalsIgnoreCase('O') ? '_O_' : null } == 'Gr_O__O_vy'
         assert "Groovy".collectReplacements{ char c -> c == 'o' ? '_O_' : null } == 'Gr_O__O_vy'
         assert "Groovy".collectReplacements{ Character c -> c == 'o' ? '_O_' : null } == 'Gr_O__O_vy'
         assert "B&W".collectReplacements{ it == '&' ? '&' : null } == 'B&W'

    Parameters:
      `self` - the original String
    Returns:
      A new string in which all characters that require escaping have been replaced with the corresponding replacements as determined by the `transform` Closure.
    Since:
      2.1.0

  - ### collectReplacements

    public static String collectReplacements(String self, List<Function<Character,Optional<String>>> transforms)
    Iterates through this String a character at a time collecting either the original character or a transformed replacement String. The return value is an `Optional` either having a value equal to the transformed replacement String or `empty()` to indicate that no transformation is required.

         import java.util.function.Function
         import static java.util.Optional.*

         Function<Character, Optional<String>> xform1 = s -> s == 'o' ? of('_O') : empty()
         Function<Character, Optional<String>> xform2 = { it == 'G' ? of('G_') : empty() }
         assert "Groovy".collectReplacements([xform1, xform2]) == 'G_r_O_Ovy'

    Parameters:
      `self` - the original String
      `transforms` - one or more transforms which potentially convert a single character to a transformed string
    Returns:
      A new string in which all characters that require escaping have been replaced with the corresponding replacements as determined by the `transform` function.
    Since:
      3.0.6

  - ### eachMatch

    public static <T extends CharSequence> T eachMatch(T self, CharSequence regex, @ClosureParams(value=FromString.class,options={"List<String>","String[]"}) Closure closure)
    Processes each regex group matched substring of the given CharSequence. If the closure parameter takes one argument, an array with all match groups is passed to it. If the closure takes as many arguments as there are match groups, then each parameter will be one match group.
    Parameters:
      `self` - the source CharSequence
      `regex` - a Regex CharSequence
      `closure` - a closure with one parameter or as many parameters as groups
    Returns:
      the source CharSequence
    Since:
      1.8.2
    See Also:
      - `eachMatch(String,String,Closure)`

  - ### eachMatch

    public static <T extends CharSequence> T eachMatch(T self, Pattern pattern, @ClosureParams(value=FromString.class,options={"List<String>","String[]"}) Closure closure)
    Processes each regex group matched substring of the given pattern. If the closure parameter takes one argument, an array with all match groups is passed to it. If the closure takes as many arguments as there are match groups, then each parameter will be one match group.
    Parameters:
      `self` - the source CharSequence
      `pattern` - a regex Pattern
      `closure` - a closure with one parameter or as many parameters as groups
    Returns:
      the source CharSequence
    Since:
      1.8.2
    See Also:
      - `eachMatch(String,Pattern,Closure)`

  - ### eachMatch

    public static String eachMatch(String self, Pattern pattern, @ClosureParams(value=FromString.class,options={"List<String>","String[]"}) Closure closure)
    Processes each regex group matched substring of the given pattern. If the closure parameter takes one argument, an array with all match groups is passed to it. If the closure takes as many arguments as there are match groups, then each parameter will be one match group.
    Parameters:
      `self` - the source string
      `pattern` - a regex Pattern
      `closure` - a closure with one parameter or as many parameters as groups
    Returns:
      the source string
    Since:
      1.6.1

  - ### eachMatch

    public static String eachMatch(String self, String regex, @ClosureParams(value=FromString.class,options={"List<String>","String[]"}) Closure closure)
    Process each regex group matched substring of the given string. If the closure parameter takes one argument, an array with all match groups is passed to it. If the closure takes as many arguments as there are match groups, then each parameter will be one match group.
    Parameters:
      `self` - the source string
      `regex` - a Regex string
      `closure` - a closure with one parameter or as many parameters as groups
    Returns:
      the source string
    Since:
      1.6.0

  - ### expand

    public static String expand(CharSequence self)
    Expands all tabs into spaces with tabStops of size 8.
    Parameters:
      `self` - A CharSequence to expand
    Returns:
      The expanded toString() of this CharSequence
    Since:
      1.8.2

  - ### expand

    public static String expand(CharSequence self, int tabStop)
    Expands all tabs into spaces. If the CharSequence has multiple lines, expand each line - restarting tab stops at the start of each line.
    Parameters:
      `self` - A CharSequence to expand
      `tabStop` - The number of spaces a tab represents
    Returns:
      The expanded toString() of this CharSequence
    Since:
      1.8.2

  - ### expandLine

    public static String expandLine(CharSequence self, int tabStop)
    Expands all tabs into spaces. Assumes the CharSequence represents a single line of text.
    Parameters:
      `self` - A line to expand
      `tabStop` - The number of spaces a tab represents
    Returns:
      The expanded toString() of this CharSequence
    Since:
      1.8.2

  - ### find

    public static String find(CharSequence self, CharSequence regex)
    Finds the first occurrence of a regular expression String within a String. If the regex doesn't match, null will be returned.

    For example, if the regex doesn't match the result is null:

             assert "New York, NY".find(/\d{5}/) == null

    If it does match, we get the matching string back:

              assert "New York, NY 10292-0098".find(/\d{5}/) == "10292"

    If we have capture groups in our expression, we still get back the full match

              assert "New York, NY 10292-0098".find(/(\d{5})-?(\d{4})/) == "10292-0098"

    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex
    Returns:
      a String containing the matched portion, or null if the regex doesn't match
    Since:
      1.8.2
    See Also:
      - `find(CharSequence,Pattern)`

  - ### find

    public static String find(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class,options={"java.util.List<java.lang.String>","java.lang.String[]"}) Closure closure)
    Returns the result of calling a closure with the first occurrence of a regular expression found within a CharSequence. If the regex doesn't match, the closure will not be called and find will return null.
    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex CharSequence
      `closure` - the closure that will be passed the full match, plus each of the capturing groups (if any)
    Returns:
      a String containing the result of calling the closure (calling toString() if needed), or null if the regex pattern doesn't match
    Since:
      1.8.2
    See Also:
      - `find(CharSequence,Pattern,Closure)`

  - ### find

    public static String find(CharSequence self, Pattern pattern)
    Finds the first occurrence of a compiled regular expression Pattern within a String. If the pattern doesn't match, null will be returned.

    For example, if the pattern doesn't match the result is null:

             assert "New York, NY".find(~/\d{5}/) == null

    If it does match, we get the matching string back:

              assert "New York, NY 10292-0098".find(~/\d{5}/) == "10292"

    If we have capture groups in our expression, the groups are ignored and we get back the full match:

              assert "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/) == "10292-0098"

    If you need to work with capture groups, then use the closure version of this method or use Groovy's matcher operators or use `eachMatch`.
    Parameters:
      `self` - a CharSequence
      `pattern` - the compiled regex Pattern
    Returns:
      a String containing the matched portion, or null if the regex pattern doesn't match
    Since:
      1.8.2

  - ### find

    public static String find(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class,options={"java.util.List<java.lang.String>","java.lang.String[]"}) Closure closure)
    Returns the result of calling a closure with the first occurrence of a compiled regular expression found within a String. If the regex doesn't match, the closure will not be called and find will return null.

    For example, if the pattern doesn't match, the result is null:

             assert "New York, NY".find(~/\d{5}/) { match -> return "-$match-"} == null

    If it does match and we don't have any capture groups in our regex, there is a single parameter on the closure that the match gets passed to:

              assert "New York, NY 10292-0098".find(~/\d{5}/) { match -> return "-$match-"} == "-10292-"

    If we have capture groups in our expression, our closure has one parameter for the match, followed by one for each of the capture groups:

              assert "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/) { match, zip, plusFour ->
                  assert match == "10292-0098"
                  assert zip == "10292"
                  assert plusFour == "0098"
                  return zip
              } == "10292"

    If we have capture groups in our expression, and our closure has one parameter, the closure will be passed an array with the first element corresponding to the whole match, followed by an element for each of the capture groups:

              assert "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/) { array ->
                  assert array[0] == "10292-0098"
                  assert array[1] == "10292"
                  assert array[2] == "0098"
                  return array[1]
              } == "10292"

    If a capture group is optional, and doesn't match, then the corresponding value for that capture group passed to the closure will be null as illustrated here:

              assert "adsf 233-9999 adsf".find(~/(\d{3})?-?(\d{3})-(\d{4})/) { match, areaCode, exchange, stationNumber ->
                  assert "233-9999" == match
                  assert null == areaCode
                  assert "233" == exchange
                  assert "9999" == stationNumber
                  return "$exchange$stationNumber"
              } == "2339999"

    Parameters:
      `self` - a CharSequence
      `pattern` - the compiled regex Pattern
      `closure` - the closure that will be passed the full match, plus each of the capturing groups (if any)
    Returns:
      a String containing the result of calling the closure (calling toString() if needed), or null if the regex pattern doesn't match
    Since:
      1.8.2

  - ### findGroups

    public static List<String> findGroups(CharSequence self, CharSequence regex)
    Finds the first occurrence of a regular expression within a CharSequence and returns the full match followed by each capture group as a List. If the regex doesn't match, an empty List is returned. Because multi-assignment pads missing elements with null, the same destructuring expression works whether or not the regex matches:

         def (all, zip, plus4) = "New York, NY 10292-0098".findGroups(/(\d{5})-(\d{4})/)
         assert all == "10292-0098"
         assert zip == "10292"
         assert plus4 == "0098"

         def (a2, z2, p2) = "New York, NY".findGroups(/(\d{5})-(\d{4})/)
         assert [a2, z2, p2] == [null, null, null]

    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex CharSequence
    Returns:
      a List containing the full match followed by each capture group, or an empty List if there is no match
    Since:
      6.0.0
    See Also:
      - `findGroups(CharSequence,Pattern)`

  - ### findGroups

    public static List<String> findGroups(CharSequence self, Pattern pattern)
    Finds the first occurrence of a compiled regular expression Pattern within a CharSequence and returns the full match followed by each capture group as a List. If the pattern doesn't match, an empty List is returned.

         def (all, zip, plus4) = "New York, NY 10292-0098".findGroups(~/(\d{5})-(\d{4})/)
         assert all == "10292-0098"
         assert zip == "10292"
         assert plus4 == "0098"

         assert "New York, NY".findGroups(~/(\d{5})-(\d{4})/) == []
         def (a2, z2, p2) = "New York, NY".findGroups(~/(\d{5})-(\d{4})/)
         assert [a2, z2, p2] == [null, null, null]

    Parameters:
      `self` - a CharSequence
      `pattern` - the compiled regex Pattern
    Returns:
      a List containing the full match followed by each capture group, or an empty List if there is no match
    Since:
      6.0.0

  - ### findAll

    public static List<String> findAll(CharSequence self, CharSequence regex)
    Returns a (possibly empty) list of all occurrences of a regular expression (provided as a CharSequence) found within a CharSequence.

    For example, if the regex doesn't match, it returns an empty list:

         assert "foo".findAll(/(\w*) Fish/) == []

    Any regular expression matches are returned in a list, and all regex capture groupings are ignored, only the full match is returned:

         def expected = ["One Fish", "Two Fish", "Red Fish", "Blue Fish"]
         assert "One Fish, Two Fish, Red Fish, Blue Fish".findAll(/(\w*) Fish/) == expected

    If you need to work with capture groups, then use the closure version of this method or use Groovy's matcher operators or use `eachMatch`.
    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex CharSequence
    Returns:
      a List containing all full matches of the regex within the CharSequence, an empty list will be returned if there are no matches
    Since:
      1.8.2
    See Also:
      - `findAll(CharSequence,Pattern)`

  - ### findAll

    public static <T> List<T> findAll(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class,options={"java.util.List<java.lang.String>","java.lang.String[]"}) Closure<T> closure)
    Finds all occurrences of a regular expression string within a CharSequence. Any matches are passed to the specified closure. The closure is expected to have the full match in the first parameter. If there are any capture groups, they will be placed in subsequent parameters.

    If there are no matches, the closure will not be called, and an empty List will be returned.

    For example, if the regex doesn't match, it returns an empty list:

         assert "foo".findAll(/(\w*) Fish/) { match, firstWord -> return firstWord } == []

    Any regular expression matches are passed to the closure, if there are no capture groups, there will be one parameter for the match:

         assert "I could not, would not, with a fox.".findAll(/.ould/) { match -> "${match}n't"} == ["couldn't", "wouldn't"]

    If there are capture groups, the first parameter will be the match followed by one parameter for each capture group:

         def orig = "There's a Wocket in my Pocket"
         assert orig.findAll(/(.)ocket/) { match, firstLetter -> "$firstLetter > $match" } == ["W > Wocket", "P > Pocket"]

    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex CharSequence
      `closure` - will be passed the full match plus each of the capturing groups (if any)
    Returns:
      a List containing all results from calling the closure with each full match (and potentially capturing groups) of the regex within the CharSequence, an empty list will be returned if there are no matches
    Since:
      1.8.2
    See Also:
      - `findAll(CharSequence,Pattern,Closure)`

  - ### findAll

    public static List<String> findAll(CharSequence self, Pattern pattern)
    Returns a (possibly empty) list of all occurrences of a regular expression (in Pattern format) found within a CharSequence.

    For example, if the pattern doesn't match, it returns an empty list:

         assert "foo".findAll(~/(\w*) Fish/) == []

    Any regular expression matches are returned in a list, and all regex capture groupings are ignored, only the full match is returned:

         def expected = ["One Fish", "Two Fish", "Red Fish", "Blue Fish"]
         assert "One Fish, Two Fish, Red Fish, Blue Fish".findAll(~/(\w*) Fish/) == expected

    Parameters:
      `self` - a CharSequence
      `pattern` - the compiled regex Pattern
    Returns:
      a List containing all full matches of the Pattern within the CharSequence, an empty list will be returned if there are no matches
    Since:
      1.8.2

  - ### findAll

    public static <T> List<T> findAll(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class,options={"java.util.List<java.lang.String>","java.lang.String[]"}) Closure<T> closure)
    Finds all occurrences of a compiled regular expression Pattern within a CharSequence. Any matches are passed to the specified closure. The closure is expected to have the full match in the first parameter. If there are any capture groups, they will be placed in subsequent parameters.

    If there are no matches, the closure will not be called, and an empty List will be returned.

    For example, if the pattern doesn't match, it returns an empty list:

         assert "foo".findAll(~/(\w*) Fish/) { match, firstWord -> return firstWord } == []

    Any regular expression matches are passed to the closure, if there are no capture groups, there will be one parameter for the match:

         assert "I could not, would not, with a fox.".findAll(~/.ould/) { match -> "${match}n't"} == ["couldn't", "wouldn't"]

    If there are capture groups, the first parameter will be the match followed by one parameter for each capture group:

         def orig = "There's a Wocket in my Pocket"
         assert orig.findAll(~/(.)ocket/) { match, firstLetter -> "$firstLetter > $match" } == ["W > Wocket", "P > Pocket"]

    Parameters:
      `self` - a CharSequence
      `pattern` - the compiled regex Pattern
      `closure` - will be passed the full match plus each of the capturing groups (if any)
    Returns:
      a List containing all results from calling the closure with each full match (and potentially capturing groups) of the regex pattern within the CharSequence, an empty list will be returned if there are no matches
    Since:
      1.8.2

  - ### findAllGroups

    public static List<List<String>> findAllGroups(CharSequence self, CharSequence regex)
    Returns a (possibly empty) list of all occurrences of a regular expression within a CharSequence, with each occurrence represented by a List containing the full match followed by each capture group.

         def input = "Type=apple Price=2.34; Type=pear Price=3.56"
         def pairs = input.findAllGroups(/Type=(\w+) Price=([\d.]+)/).collect { all, t, p -> "$t:$p" }
         assert pairs == ["apple:2.34", "pear:3.56"]

         assert "none here".findAllGroups(/Type=(\w+) Price=([\d.]+)/) == []

    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex CharSequence
    Returns:
      a List of Lists, one per match, each containing the full match followed by each capture group; an empty List if there are no matches
    Since:
      6.0.0
    See Also:
      - `findAllGroups(CharSequence,Pattern)`

  - ### findAllGroups

    public static List<List<String>> findAllGroups(CharSequence self, Pattern pattern)
    Returns a (possibly empty) list of all occurrences of a compiled regular expression Pattern within a CharSequence, with each occurrence represented by a List containing the full match followed by each capture group.

         def input = "Type=apple Price=2.34; Type=pear Price=3.56"
         def pairs = input.findAllGroups(~/Type=(\w+) Price=([\d.]+)/).collect { all, t, p -> "$t:$p" }
         assert pairs == ["apple:2.34", "pear:3.56"]

         assert "none here".findAllGroups(~/Type=(\w+) Price=([\d.]+)/) == []

    Parameters:
      `self` - a CharSequence
      `pattern` - the compiled regex Pattern
    Returns:
      a List of Lists, one per match, each containing the full match followed by each capture group; an empty List if there are no matches
    Since:
      6.0.0

  - ### getAt

    public static String getAt(CharSequence self, Collection indices)
    Selects a List of characters from a CharSequence using a Collection to identify the indices to be selected.
    Parameters:
      `self` - a CharSequence
      `indices` - a Collection of indices
    Returns:
      a String consisting of the characters at the given indices
    Since:
      1.0

  - ### getAt

    public static String getAt(CharSequence self, EmptyRange range)
    Supports the range subscript operator for CharSequence or StringBuffer with EmptyRange
    Parameters:
      `self` - a CharSequence
      `range` - an EmptyRange
    Returns:
      the empty String
    Since:
      1.5.0

  - ### getAt

    public static CharSequence getAt(CharSequence self, int index)
    Supports the subscript operator for CharSequence.
    Parameters:
      `self` - a CharSequence
      `index` - the index of the Character to get
    Returns:
      the Character at the given index
    Since:
      1.0

  - ### getAt

    public static String getAt(GString self, int index)
    Supports the subscript operator for GString.
    Parameters:
      `self` - a GString
      `index` - the index of the Character to get
    Returns:
      the Character at the given index
    Since:
      2.3.7

  - ### getAt

    public static CharSequence getAt(CharSequence self, IntRange range)
    Supports the range subscript operator for CharSequence with IntRange.
    Parameters:
      `self` - a CharSequence
      `range` - an IntRange
    Returns:
      the subsequence CharSequence
    Since:
      1.0

  - ### getAt

    public static String getAt(GString self, IntRange range)
    Supports the range subscript operator for GString with IntRange.
    Parameters:
      `self` - a GString
      `range` - an IntRange
    Returns:
      the String of characters corresponding to the provided range
    Since:
      2.3.7

  - ### getAt

    public static CharSequence getAt(CharSequence self, Range range)
    Supports the range subscript operator for CharSequence.
    Parameters:
      `self` - a CharSequence
      `range` - a Range
    Returns:
      the subsequence CharSequence
    Since:
      1.0

  - ### getAt

    public static String getAt(GString self, Range range)
    Supports the range subscript operator for GString.
    Parameters:
      `self` - a GString
      `range` - a Range
    Returns:
      the String of characters corresponding to the provided range
    Since:
      2.3.7

  - ### getAt

    public static List getAt(Matcher self, Collection indices)
    Selects a List of values from a Matcher using a Collection to identify the indices to be selected.
    Parameters:
      `self` - a Matcher
      `indices` - a Collection of indices
    Returns:
      a String of the values at the given indices
    Since:
      1.6.0

  - ### getAt

    public static Object getAt(Matcher self, int index)
    Supports the subscript operator, e.g. `matcher[index]`, for a `Matcher`.

    For an example using no group match,

            def p = /ab[d|f]/
            def m = "abcabdabeabf" =~ p
            assert 2 == m.count
            assert 2 == m.size() // synonym for m.getCount()
            assert ! m.hasGroup()
            assert 0 == m.groupCount()
            def matches = ["abd", "abf"]
            for (i in 0..<m.count) {
              assert m[i] == matches[i]
            }

    For an example using group matches,

            def p = /(?:ab([c|d|e|f]))/
            def m = "abcabdabeabf" =~ p
            assert 4 == m.count
            assert m.hasGroup()
            assert 1 == m.groupCount()
            def matches = [["abc", "c"], ["abd", "d"], ["abe", "e"], ["abf", "f"]]
            for (i in 0..<m.count) {
              assert m[i] == matches[i]
            }

    For another example using group matches,

            def m = "abcabdabeabfabxyzabx" =~ /(?:ab([d|x-z]+))/
            assert 3 == m.count
            assert m.hasGroup()
            assert 1 == m.groupCount()
            def matches = [["abd", "d"], ["abxyz", "xyz"], ["abx", "x"]]
            for (i in 0..<m.count) {
              assert m[i] == matches[i]
            }

    Parameters:
      `self` - a Matcher
      `index` - an index
    Returns:
      object a matched String if no groups matched, list of matched groups otherwise.
    Since:
      1.0

  - ### matchesPartially

    public static boolean matchesPartially(Matcher self)
    Given a matcher that matches a string against a pattern, returns true when the string matches the pattern or if a longer string, could match the pattern. For example:

             def emailPattern = /\w+@\w+\.\w{2,}/

             def matcher = "john@doe" =~ emailPattern
             assert matcher.matchesPartially()

             matcher = "john@doe.com" =~ emailPattern
             assert matcher.matchesPartially()

             matcher = "john@@" =~ emailPattern
             assert !matcher.matchesPartially()

    Parameters:
      `self` - the Matcher
    Returns:
      true if more input to the String could make the matcher match the associated pattern, false otherwise.
    Since:
      2.0.0

  - ### getAt

    public static String getAt(String self, int index)
    Supports the subscript operator for String.
    Parameters:
      `self` - a String
      `index` - the index of the Character to get
    Returns:
      the Character at the given index
    Since:
      1.0

  - ### getAt

    public static String getAt(String self, IntRange range)
    Supports the range subscript operator for String with IntRange.
    Parameters:
      `self` - a String
      `range` - an IntRange
    Returns:
      the resulting String
    Since:
      1.0

  - ### getAt

    public static String getAt(String self, Range range)
    Supports the range subscript operator for String.
    Parameters:
      `self` - a String
      `range` - a Range
    Returns:
      a substring corresponding to the Range
    Since:
      1.0

  - ### getChars

    public static char[] getChars(CharSequence self)
    Converts the given CharSequence into an array of characters.
    Parameters:
      `self` - a CharSequence
    Returns:
      an array of characters
    Since:
      1.8.2

  - ### getCodePoints

    public static int[] getCodePoints(CharSequence self)
    Converts the given CharSequence into an array of code point values including any surrogate pairs as per `String.codePoints()`.
    Parameters:
      `self` - a CharSequence
    Returns:
      an array of ints
    Since:
      5.0.0

  - ### getCount

    public static int getCount(Matcher self)
    Finds the number of Strings matched to the given Matcher.
    Parameters:
      `self` - a Matcher
    Returns:
      int the number of Strings matched to the given matcher.
    Since:
      1.0

  - ### hasGroup

    public static boolean hasGroup(Matcher self)
    Checks whether a Matcher contains a group or not.
    Parameters:
      `self` - a Matcher
    Returns:
      boolean `true` if matcher contains at least one group.
    Since:
      1.0

  - ### isAllWhitespace

    public static boolean isAllWhitespace(CharSequence self)
    Returns true if a CharSequence only contains whitespace characters.
    Parameters:
      `self` - The CharSequence to check the characters in
    Returns:
      true If all characters are whitespace characters
    Since:
      1.8.2

  - ### isBigDecimal

    public static boolean isBigDecimal(CharSequence self)
    Determines if a CharSequence can be parsed as a BigDecimal.
    Parameters:
      `self` - a CharSequence
    Returns:
      true if the CharSequence can be parsed
    Since:
      1.8.2

  - ### isBigInteger

    public static boolean isBigInteger(CharSequence self)
    Determines if a CharSequence can be parsed as a BigInteger.
    Parameters:
      `self` - a CharSequence
    Returns:
      true if the CharSequence can be parsed
    Since:
      1.8.2

  - ### isCase

    public static boolean isCase(CharSequence caseValue, Object switchValue)
    'Case' implementation for a CharSequence, which uses equals between the toString() of the caseValue and the switchValue. This allows CharSequence values to be used in switch statements. For example:

         switch( str ) {
           case 'one' :
           // etc...
         }

    Note that this returns `true` for the case where both the 'switch' and 'case' operand is `null`.
    Parameters:
      `caseValue` - the case value
      `switchValue` - the switch value
    Returns:
      true if the switchValue's toString() equals the caseValue
    Since:
      1.8.2

  - ### isCase

    public static boolean isCase(Pattern caseValue, Object switchValue)
    'Case' implementation for the `Pattern` class, which allows testing a String against a number of regular expressions.

    For example:

        switch( str ) {
           case ~/one/ :
             // the regex 'one' matches the value of str
         }

    Note that this returns true for the case where both the pattern and the 'switch' values are `null`.
    Parameters:
      `caseValue` - the case value
      `switchValue` - the switch value
    Returns:
      true if the switchValue is deemed to match the caseValue
    Since:
      1.0

  - ### isDouble

    public static boolean isDouble(CharSequence self)
    Determines if a CharSequence can be parsed as a Double.
    Parameters:
      `self` - a CharSequence
    Returns:
      true if the CharSequence can be parsed
    Since:
      1.8.2

  - ### isFloat

    public static boolean isFloat(CharSequence self)
    Determines if a CharSequence can be parsed as a Float.
    Parameters:
      `self` - a CharSequence
    Returns:
      true if the CharSequence can be parsed
    Since:
      1.8.2

  - ### isInteger

    public static boolean isInteger(CharSequence self)
    Determines if a CharSequence can be parsed as an Integer.
    Parameters:
      `self` - a CharSequence
    Returns:
      true if the CharSequence can be parsed
    Since:
      1.8.2

  - ### isLong

    public static boolean isLong(CharSequence self)
    Determines if a CharSequence can be parsed as a Long.
    Parameters:
      `self` - a CharSequence
    Returns:
      true if the CharSequence can be parsed
    Since:
      1.8.2

  - ### isNotCase

    public static boolean isNotCase(CharSequence caseValue, Object switchValue)
    Since:
      4.0.0

  - ### isNotCase

    public static boolean isNotCase(Pattern caseValue, Object switchValue)
    Since:
      4.0.0

  - ### isNumber

    public static boolean isNumber(CharSequence self)
    Determines if a CharSequence can be parsed as a Number.
    Parameters:
      `self` - a CharSequence
    Returns:
      true if the CharSequence can be parsed
    Since:
      1.8.2
    See Also:
      - `isBigDecimal(CharSequence)`

  - ### iterator

    public static Iterator iterator(Matcher self)
    Returns an `Iterator` which traverses each match.
    Parameters:
      `self` - a Matcher object
    Returns:
      an Iterator for a Matcher
    Since:
      1.0
    See Also:
      - `Matcher.group()`

  - ### leftShift

    public static StringBuilder leftShift(CharSequence self, Object value)
    Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a CharSequence.
    Parameters:
      `self` - a CharSequence
      `value` - an Object
    Returns:
      a StringBuilder built from this CharSequence
    Since:
      1.8.2

  - ### leftShift

    public static StringBuffer leftShift(String self, Object value)
    Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a String.
    Parameters:
      `self` - a String
      `value` - an Object
    Returns:
      a StringBuffer built from this string
    Since:
      1.0

  - ### leftShift

    public static StringBuffer leftShift(StringBuffer self, Object value)
    Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a StringBuffer.
    Parameters:
      `self` - a StringBuffer
      `value` - a value to append
    Returns:
      the StringBuffer on which this operation was invoked
    Since:
      1.0

  - ### leftShift

    public static StringBuilder leftShift(StringBuilder self, Object value)
    Overloads the left shift operator to provide syntactic sugar for appending to a StringBuilder.
    Parameters:
      `self` - a StringBuilder
      `value` - an Object
    Returns:
      the original StringBuilder
    Since:
      1.8.2

  - ### matches

    public static boolean matches(CharSequence self, Pattern pattern)
    Determines if a CharSequence matches the given regular expression.
    Parameters:
      `self` - the CharSequence that is to be matched
      `pattern` - the regex Pattern to which the string of interest is to be matched
    Returns:
      true if the CharSequence matches
    Since:
      1.8.2
    See Also:
      - `String.matches(String)`

  - ### minus

    public static String minus(CharSequence self, Object target)
    Removes a part of a CharSequence by replacing the first occurrence of target within self with empty string and returns the result.
    Parameters:
      `self` - a CharSequence
      `target` - an object representing the part to remove
    Returns:
      a String containing the original minus the part to be removed
    Since:
      1.8.2

  - ### minus

    public static String minus(CharSequence self, Pattern pattern)
    Removes a part of a CharSequence. This replaces the first occurrence of the pattern within self with empty string and returns the result.
    Parameters:
      `self` - a String
      `pattern` - a Pattern representing the part to remove
    Returns:
      a String minus the part to be removed
    Since:
      2.2.0

  - ### multiply

    public static String multiply(CharSequence self, Number factor)
    Repeats a CharSequence a certain number of times.
    Parameters:
      `self` - a CharSequence to be repeated
      `factor` - the number of times the CharSequence should be repeated
    Returns:
      a String composed of a repetition
    Throws:
      `IllegalArgumentException` - if the number of repetitions is < 0
    Since:
      1.8.2

  - ### next

    public static String next(CharSequence self)
    Overloads the `++` operator for the class CharSequence. It increments the last character in the given CharSequence. If the last character in the CharSequence is Character.MAX_VALUE a Character.MIN_VALUE will be appended. The empty CharSequence is incremented to a string consisting of the character Character.MIN_VALUE.
    Parameters:
      `self` - a CharSequence
    Returns:
      a value obtained by incrementing the toString() of the CharSequence
    Since:
      1.8.2

  - ### next

    public static String next(CharSequence self, int n)
    A variant of next with an integer count parameter; equivalent to calling next() count times.

         assert 'a'.next(1) == 'a'.next()
         assert 'a'.next(4) == 'e'
         assert 'a'.next(0) == 'a'
         assert 'a'.next(25) == 'z'
         assert 'A'.next(32) == 'a'
         assert (0..4).collect('a'::next) == 'a'..'e'
         assert 'car'.next(2) == 'cat'

    Parameters:
      `self` - a CharSequence
      `n` - how many times to increment
    Returns:
      a value obtained by incrementing the toString() of the CharSequence n times
    Since:
      5.0.0
    See Also:
      - `next(CharSequence)`

  - ### normalize

    public static String normalize(CharSequence self)
    Returns a String with linefeeds and carriage returns normalized to linefeeds.
    Parameters:
      `self` - a CharSequence object
    Returns:
      the normalized toString() for the CharSequence
    Since:
      1.8.2

  - ### padLeft

    public static String padLeft(CharSequence self, Number numberOfChars)
    Pads a CharSequence to a minimum length specified by `numberOfChars` by adding the space character to the left as many times as needed. If the String is already the same size or bigger than the target `numberOfChars`, then the original String is returned. An example:

         println 'Numbers:'
         [1, 10, 100, 1000].each{ println it.toString().padLeft(5) }

    will produce output like:

         Numbers:
             1
            10
           100
          1000

    Parameters:
      `self` - a CharSequence object
      `numberOfChars` - the total minimum number of characters of the resulting CharSequence
    Returns:
      the CharSequence padded to the left as a String
    Since:
      1.8.2
    See Also:
      - `padLeft(CharSequence,Number,CharSequence)`

  - ### padLeft

    public static String padLeft(CharSequence self, Number numberOfChars, CharSequence padding)
    Pads a CharSequence to a minimum length specified by `numberOfChars`, adding the supplied padding CharSequence as many times as needed to the left. If the CharSequence is already the same size or bigger than the target `numberOfChars`, then the toString() of the original CharSequence is returned. An example:

         println 'Numbers:'
         [1, 10, 100, 1000].each{ println it.toString().padLeft(5, '*') }
         [2, 20, 200, 2000].each{ println it.toString().padLeft(5, '*_') }

    will produce output like:

         Numbers:
         ****1
         ***10
         **100
         *1000
         *_*_2
         *_*20
         *_200
         *2000

    Parameters:
      `self` - a CharSequence object
      `numberOfChars` - the total minimum number of characters of the resulting CharSequence
      `padding` - the characters used for padding
    Returns:
      the CharSequence padded to the left as a String
    Since:
      1.8.2

  - ### padRight

    public static String padRight(CharSequence self, Number numberOfChars)
    Pads a CharSequence to a minimum length specified by `numberOfChars` by adding the space character to the right as many times as needed. If the CharSequence is already the same size or bigger than the target `numberOfChars`, then the toString() of the original CharSequence is returned. An example:

         ['A', 'BB', 'CCC', 'DDDD'].each{ println it.padRight(5) + it.size() }

    will produce output like:

         A    1
         BB   2
         CCC  3
         DDDD 4

    Parameters:
      `self` - a CharSequence object
      `numberOfChars` - the total minimum number of characters of the resulting string
    Returns:
      the CharSequence padded to the right as a String
    Since:
      1.8.2

  - ### padRight

    public static String padRight(CharSequence self, Number numberOfChars, CharSequence padding)
    Pads a CharSequence to a minimum length specified by `numberOfChars`, adding the supplied padding CharSequence as many times as needed to the right. If the CharSequence is already the same size or bigger than the target `numberOfChars`, then the toString() of the original CharSequence is returned. An example:

         ['A', 'BB', 'CCC', 'DDDD'].each{ println it.padRight(5, '#') + it.size() }

    will produce output like:

         A####1
         BB###2
         CCC##3
         DDDD#4

    Parameters:
      `self` - a CharSequence object
      `numberOfChars` - the total minimum number of characters of the resulting CharSequence
      `padding` - the characters used for padding
    Returns:
      the CharSequence padded to the right as a String
    Since:
      1.8.2

  - ### plus

    @GroovyABI(since="3.0.0") public static String plus(CharSequence left, Object right)
    Appends the String representation of the given operand to this CharSequence.
    Parameters:
      `left` - a CharSequence
      `right` - any Object
    Returns:
      the original toString() of the CharSequence with the object appended
    Since:
      1.8.2

  - ### plus

    public static String plus(Number left, String right)
    Appends a String to the string representation of this number.
    Parameters:
      `left` - a Number
      `right` - a String
    Returns:
      a String
    Since:
      1.0

  - ### plus

    public static String plus(String left, CharSequence right)
    Appends the String representation of the given operand to this string.
    Parameters:
      `left` - a String
      `right` - any CharSequence
    Returns:
      the new string with the object appended
    Since:
      2.2

  - ### plus

    public static String plus(StringBuffer left, String right)
    Appends a String to this StringBuffer.
    Parameters:
      `left` - a StringBuffer
      `right` - a String
    Returns:
      a String
    Since:
      1.0

  - ### previous

    public static String previous(CharSequence self)
    Overloads the `--` operator for the class CharSequence. It decrements the last character in the given CharSequence. If the last character in the CharSequence is Character.MIN_VALUE it will be deleted. The empty CharSequence can't be decremented.
    Parameters:
      `self` - a CharSequence
    Returns:
      a String with a decremented character at the end
    Since:
      1.8.2

  - ### previous

    public static String previous(CharSequence self, int n)
    A variant of previous with an integer count parameter; equivalent to calling previous() count times.

         assert 'b'.previous(1) == 'b'.previous()
         assert 'e'.previous(4) == 'a'
         assert 'a'.previous(0) == 'a'
         assert 'z'.previous(25) == 'a'
         assert 'a'.previous(32) == 'A'
         assert (0..4).collect('z'::previous) == 'z'..'v'
         assert 'cat'.previous(2) == 'car'

    Parameters:
      `self` - a CharSequence
      `n` - how many times to decrement
    Returns:
      a value obtained by decrementing the toString() of the CharSequence n times
    Since:
      5.0.0
    See Also:
      - `previous(CharSequence)`

  - ### putAt

    public static void putAt(StringBuffer self, EmptyRange range, Object value)
    Supports the range subscript operator for StringBuffer.
    Parameters:
      `self` - a StringBuffer
      `range` - a Range
      `value` - the object that's toString() will be inserted
    Since:
      1.0

  - ### putAt

    public static void putAt(StringBuffer self, IntRange range, Object value)
    Supports the range subscript operator for StringBuffer. Index values are treated as characters within the buffer.
    Parameters:
      `self` - a StringBuffer
      `range` - a Range
      `value` - the object that's toString() will be inserted
    Since:
      1.0

  - ### readLines

    public static List<String> readLines(CharSequence self)
    Returns the lines of a CharSequence as a List of String.
    Parameters:
      `self` - a CharSequence object
    Returns:
      a list of lines
    Since:
      1.8.2

  - ### replaceAll

    public static String replaceAll(CharSequence self, CharSequence regex, CharSequence replacement)
    Replaces each substring of this CharSequence that matches the given regular expression with the given replacement.

         assert "foo".replaceAll('o', 'X') == 'fXX'

    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex
      `replacement` - the string to be substituted for each match
    Returns:
      the toString() of the CharSequence with content replaced
    Throws:
      `PatternSyntaxException` - if the regular expression's syntax is invalid
    Since:
      1.8.2
    See Also:
      - `String.replaceAll(String,String)`

  - ### replaceAll

    public static String replaceAll(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class,options={"List<String>","String[]"}) Closure closure)
    Replaces all occurrences of a captured group by the result of calling a closure on that text.

    Examples:

             assert "hello world".replaceAll("(o)") { it[0].toUpperCase() } == "hellO wOrld"

             assert "foobar-FooBar-".replaceAll("(([fF][oO]{2})[bB]ar)", { Object[] it -> it[0].toUpperCase() }) == "FOOBAR-FOOBAR-"

             // Here,
             //   it[0] is the global string of the matched group
             //   it[1] is the first string in the matched group
             //   it[2] is the second string in the matched group

             assert "foobar-FooBar-".replaceAll("(([fF][oO]{2})[bB]ar)", { x, y, z -> z.toUpperCase() }) == "FOO-FOO-"

             // Here,
             //   x is the global string of the matched group
             //   y is the first string in the matched group
             //   z is the second string in the matched group

    Note that unlike String.replaceAll(String regex, String replacement), where the replacement string treats '$' and '\' specially (for group substitution), the result of the closure is converted to a string and that value is used literally for the replacement.
    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex
      `closure` - the closure to apply on each captured group
    Returns:
      the toString() of the CharSequence with content replaced
    Throws:
      `PatternSyntaxException` - if the regular expression's syntax is invalid
    Since:
      1.8.2
    See Also:
      - `replaceAll(CharSequence,Pattern,Closure)`

  - ### replaceAll

    public static String replaceAll(CharSequence self, Pattern pattern, CharSequence replacement)
    Replaces all substrings of a CharSequence that match the given compiled regular expression with the given replacement.

    Note that backslashes (`\`) and dollar signs (`$`) in the replacement string may cause the results to be different from if it were being treated as a literal replacement string; see `Matcher.replaceAll(java.lang.String)`. Use `Matcher.quoteReplacement(java.lang.String)` to suppress the special meaning of these characters, if desired.

         assert "foo".replaceAll(~'o', 'X') == 'fXX'

    Parameters:
      `self` - the CharSequence that is to be matched
      `pattern` - the regex Pattern to which the CharSequence of interest is to be matched
      `replacement` - the CharSequence to be substituted for the first match
    Returns:
      the toString() of the CharSequence with content replaced
    Since:
      1.8.2

  - ### replaceAll

    public static String replaceAll(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class,options={"List<String>","String[]"}) Closure closure)
    Replaces all occurrences of a captured group by the result of a closure call on that text.

    For examples,

             assert "hello world".replaceAll(~"(o)") { it[0].toUpperCase() } == "hellO wOrld"

             assert "foobar-FooBar-".replaceAll(~"(([fF][oO]{2})[bB]ar)", { it[0].toUpperCase() }) == "FOOBAR-FOOBAR-"

             // Here,
             //   it[0] is the global string of the matched group
             //   it[1] is the first string in the matched group
             //   it[2] is the second string in the matched group

             assert "foobar-FooBar-".replaceAll(~"(([fF][oO]{2})[bB]ar)", { Object[] it -> it[0].toUpperCase() }) == "FOOBAR-FOOBAR-"

             // Here,
             //   it[0] is the global string of the matched group
             //   it[1] is the first string in the matched group
             //   it[2] is the second string in the matched group

             assert "foobar-FooBar-".replaceAll("(([fF][oO]{2})[bB]ar)", { x, y, z -> z.toUpperCase() }) == "FOO-FOO-"

             // Here,
             //   x is the global string of the matched group
             //   y is the first string in the matched group
             //   z is the second string in the matched group

    Note that unlike String.replaceAll(String regex, String replacement), where the replacement string treats '$' and '\' specially (for group substitution), the result of the closure is converted to a string and that value is used literally for the replacement.
    Parameters:
      `self` - a CharSequence
      `pattern` - the capturing regex Pattern
      `closure` - the closure to apply on each captured group
    Returns:
      the toString() of the CharSequence with replaced content
    Since:
      1.8.2
    See Also:
      - `Matcher.quoteReplacement(String)`

  - ### replaceFirst

    public static String replaceFirst(CharSequence self, CharSequence regex, CharSequence replacement)
    Replaces the first substring of this CharSequence that matches the given regular expression with the given replacement.
    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex
      `replacement` - the CharSequence to be substituted for each match
    Throws:
      `PatternSyntaxException` - if the regular expression's syntax is invalid
    Since:
      1.8.2
    See Also:
      - `String.replaceFirst(String,String)`

  - ### replaceFirst

    public static String replaceFirst(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class,options={"List<String>","String[]"}) Closure closure)
    Replaces the first occurrence of a captured group by the result of a closure call on that text.

    For example (with some replaceAll variants thrown in for comparison purposes),

         assert "hello world".replaceFirst("(o)") { it[0].toUpperCase() } == "hellO world" // first match
         assert "hello world".replaceAll("(o)") { it[0].toUpperCase() } == "hellO wOrld" // all matches

         assert "one fish, two fish".replaceFirst(/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() } == '1-FISH, two fish'
         assert "one fish, two fish".replaceAll(/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() } == '1-FISH, 2-FISH'

    Parameters:
      `self` - a CharSequence
      `regex` - the capturing regex
      `closure` - the closure to apply on the first captured group
    Throws:
      `PatternSyntaxException` - if the regular expression's syntax is invalid
    Since:
      1.8.2

  - ### replaceFirst

    public static String replaceFirst(CharSequence self, Pattern pattern, CharSequence replacement)
    Replaces the first substring of a CharSequence that matches the given compiled regular expression with the given replacement.

    Note that backslashes (`\`) and dollar signs (`$`) in the replacement string may cause the results to be different from if it were being treated as a literal replacement string; see `Matcher.replaceFirst(java.lang.String)`. Use `Matcher.quoteReplacement(java.lang.String)` to suppress the special meaning of these characters, if desired.

         assert "foo".replaceFirst('o', 'X') == 'fXo'

    Parameters:
      `self` - the CharSequence that is to be matched
      `pattern` - the regex Pattern to which the CharSequence of interest is to be matched
      `replacement` - the CharSequence to be substituted for the first match
    Since:
      1.8.2

  - ### replaceFirst

    public static String replaceFirst(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class,options={"List<String>","String[]"}) Closure closure)
    Replaces the first occurrence of a captured group by the result of a closure call on that text.

    For example (with some replaceAll variants thrown in for comparison purposes),

         assert "hellO world" == "hello world".replaceFirst(~"(o)") { it[0].toUpperCase() } // first match
         assert "hellO wOrld" == "hello world".replaceAll(~"(o)") { it[0].toUpperCase() }   // all matches

         assert '1-FISH, two fish' == "one fish, two fish".replaceFirst(~/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() }
         assert '1-FISH, 2-FISH' == "one fish, two fish".replaceAll(~/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() }

    Parameters:
      `self` - a CharSequence
      `pattern` - the capturing regex Pattern
      `closure` - the closure to apply on the first captured group
    Since:
      1.8.2

  - ### replace

    public static String replace(CharSequence self, Map<CharSequence,CharSequence> replacements)
    Replaces all occurrences of replacement CharSequences (supplied via a map) within a provided CharSequence.

         assert 'foobar'.replace(f:'b', foo:'bar') == 'boobar'
         assert 'foobar'.replace(foo:'bar', f:'b') == 'barbar'
         def replacements = [foo:'bar', f:'b', b: 'f', bar:'boo']
         assert 'foobar'.replace(replacements) == 'barfar'

    Parameters:
      `self` - a CharSequence
      `replacements` - a map of before (key) and after (value) pairs processed in the natural order of the map
    Returns:
      a String formed from the provided CharSequence after performing all of the replacements
    Since:
      2.5.0

  - ### replace

    public static String replace(CharSequence self, int capacity, Map<CharSequence,CharSequence> replacements)
    Replaces all occurrences of replacement CharSequences (supplied via a map) within a provided CharSequence with control over the internally created StringBuilder's capacity. This method uses a StringBuilder internally. Java auto-expands a StringBuilder's capacity if needed. In rare circumstances, the overhead involved with repeatedly expanding the StringBuilder may become significant. If you have measured the performance of your application and found this to be a significant bottleneck, use this variant to have complete control over the internally created StringBuilder's capacity.

         assert 'foobar'.replace(9, [r:'rbaz']) == 'foobarbaz'
         assert 'foobar'.replace(1, [fooba:'']) == 'r'

    Parameters:
      `self` - a CharSequence
      `capacity` - an optimization parameter, set to size after replacements or a little larger to avoid resizing overheads
      `replacements` - a map of before (key) and after (value) pairs processed in the natural order of the map
    Returns:
      a String formed from the provided CharSequence after performing all of the replacements
    Since:
      2.5.0

  - ### reverse

    public static String reverse(CharSequence self)
    Creates a String which is the reverse (backwards) of this CharSequence
    Parameters:
      `self` - a CharSequence
    Returns:
      a new String with all the characters reversed.
    Since:
      1.8.2

  - ### setIndex

    public static void setIndex(Matcher self, int index)
    Sets the position of the given Matcher to the given index.
    Parameters:
      `self` - a Matcher
      `index` - the index number
    Since:
      1.0

  - ### size

    public static int size(CharSequence self)
    Provides the standard Groovy `size()` method for `CharSequence`.
    Parameters:
      `self` - a CharSequence
    Returns:
      the length of the CharSequence
    Since:
      1.8.2

  - ### getLength

    public static int getLength(StringBuilder self)
    Provides a `getLength` alias for `length` for `StringBuilder`, supporting assignment arithmetic operator expressions involving the otherwise write-only length property.

         def sb = new StringBuilder()
         sb << 'foobar'
         sb.length -= 3
         assert sb.toString() == 'foo'

    Parameters:
      `self` - a StringBuilder
    Returns:
      the length of the StringBuilder
    Since:
      5.0.0

  - ### getLength

    public static int getLength(StringBuffer self)
    Provides a `getLength` alias for `length` for `StringBuffer`, supporting assignment arithmetic operator expressions involving the otherwise write-only length property.

         def sb = new StringBuffer()
         sb << 'foobar'
         sb.length -= 3
         assert sb.toString() == 'foo'

    Parameters:
      `self` - a StringBuffer
    Returns:
      the length of the StringBuffer
    Since:
      5.0.0

  - ### size

    public static long size(Matcher self)
    Provides the standard Groovy `size()` method for `Matcher`.
    Parameters:
      `self` - a matcher object
    Returns:
      the matcher's size (count)
    Since:
      1.5.0

  - ### size

    @Deprecated public static int size(String self)
    Deprecated.
    Provides the standard Groovy `size()` method for `String`.
    Parameters:
      `self` - a String
    Returns:
      the length of the String
    Since:
      1.0
    See Also:
      - `size(CharSequence)`

  - ### size

    @Deprecated public static int size(StringBuffer self)
    Deprecated.
    Provides the standard Groovy `size()` method for `StringBuffer`.
    Parameters:
      `self` - a StringBuffer
    Returns:
      the length of the StringBuffer
    Since:
      1.0
    See Also:
      - `size(CharSequence)`

  - ### isAtLeast

    public static Boolean isAtLeast(String left, String right)
    Compares a String representing a number to another. A fluent API style alias for `compareTo` on `BigDecimal`.
    Parameters:
      `left` - a String representing a number
      `right` - a String representing a number
    Returns:
      true if the value represented by left is equal to or bigger than the value represented by right
    Since:
      3.0.1

  - ### split

    public static String[] split(CharSequence self)
    Splits a CharSequence (with whitespace as delimiter). Similar to tokenize, but returns an Array of String instead of a List.
    Parameters:
      `self` - the CharSequence to split
    Returns:
      String[] result of split
    Since:
      1.8.2

  - ### splitEachLine

    public static <T> T splitEachLine(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class,options={"List<String>","String[]"},conflictResolutionStrategy=PickFirstResolver.class) Closure<T> closure) throws IOException
    Iterates through the given CharSequence line by line, splitting each line using the given regex delimiter. The list of tokens for each line is then passed to the given closure.
    Parameters:
      `self` - a CharSequence
      `regex` - the delimiting regular expression
      `closure` - a closure
    Returns:
      the last value returned by the closure
    Throws:
      `IOException` - if an error occurs
      `PatternSyntaxException` - if the regular expression's syntax is invalid
    Since:
      1.8.2
    See Also:
      - `splitEachLine(CharSequence,Pattern,Closure)`

  - ### splitEachLine

    public static <T> T splitEachLine(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class,options={"List<String>","String[]"},conflictResolutionStrategy=PickFirstResolver.class) Closure<T> closure)
    Iterates through the given CharSequence line by line, splitting each line using the given separator Pattern. The list of tokens for each line is then passed to the given closure.
    Parameters:
      `self` - a CharSequence
      `pattern` - the regular expression Pattern for the delimiter
      `closure` - a closure
    Returns:
      the last value returned by the closure
    Since:
      1.8.2

  - ### stripIndent

    public static String stripIndent(CharSequence self)
    Strips leading spaces from every line in a CharSequence. The line with the least number of leading spaces determines the number to remove. Lines only containing whitespace are ignored when calculating the number of leading spaces to strip.

         assert '  A\n B\nC' == '   A\n  B\n C'.stripIndent()

    Parameters:
      `self` - a CharSequence to strip the leading spaces from
    Returns:
      the stripped `toString()` of the CharSequence
    Since:
      1.8.2

  - ### stripIndent

    @Incubating public static String stripIndent(CharSequence self, boolean forceGroovyBehavior)
    Same logic as `stripIndent(CharSequence)` if `forceGroovyBehavior` is `true`, otherwise `stripIndent` from JDK 13+ will be invoked.
    Parameters:
      `self` - The CharSequence to strip the leading spaces from
      `forceGroovyBehavior` - force groovy behavior to avoid conflicts with Java stripIndent
    Since:
      3.0.0

  - ### stripIndent

    public static String stripIndent(CharSequence self, int numChars)
    Strips `numChars` leading characters from every line in a CharSequence.

         assert 'DEF\n456' == '''ABCDEF\n123456'''.stripIndent(3)

    Parameters:
      `self` - The CharSequence to strip the characters from
      `numChars` - The number of characters to strip
    Returns:
      the stripped String
    Since:
      1.8.2

  - ### stripMargin

    public static String stripMargin(CharSequence self)
    Strips leading whitespace/control characters followed by '|' from every line in a CharSequence.

         assert 'ABC\n123\n456' == '''ABC
                                     |123
                                     |456'''.stripMargin()

    Parameters:
      `self` - The CharSequence to strip the margin from
    Returns:
      the stripped String
    Since:
      1.8.2
    See Also:
      - `stripMargin(CharSequence,char)`

  - ### stripMargin

    public static String stripMargin(CharSequence self, char marginChar)
    Strips leading whitespace/control characters followed by `marginChar` from every line in a CharSequence.

         assert 'ABC\n123\n456' == '''ABC
                                     *123
                                     *456'''.stripMargin('*')

    Parameters:
      `self` - The CharSequence to strip the margin from
      `marginChar` - Any character that serves as margin delimiter
    Returns:
      the stripped String
    Since:
      1.8.2

  - ### stripMargin

    public static String stripMargin(CharSequence self, CharSequence marginChar)
    Strips leading whitespace/control characters followed by `marginChar` from every line in a CharSequence.
    Parameters:
      `self` - The CharSequence to strip the margin from
      `marginChar` - Any character that serves as margin delimiter
    Returns:
      the stripped CharSequence
    Since:
      1.8.2

  - ### take

    public static CharSequence take(CharSequence self, int num)
    Returns the first `num` elements from this CharSequence.

         def text = "Groovy"
         assert text.take( 0 ) == ''
         assert text.take( 2 ) == 'Gr'
         assert text.take( 7 ) == 'Groovy'

    Parameters:
      `self` - the original CharSequence
      `num` - the number of chars to take from this CharSequence
    Returns:
      a CharSequence consisting of the first `num` chars, or else the whole CharSequence if it has less than `num` elements.
    Since:
      1.8.1

  - ### take

    public static String take(GString self, int num)
    A GString variant of the equivalent CharSequence method.
    Parameters:
      `self` - the original GString
      `num` - the number of chars to take from this GString
    Returns:
      a String consisting of the first `num` chars, or else the whole GString if it has less than `num` elements.
    Since:
      2.3.7

  - ### take

    public static String take(String self, int num)
    A String variant of the equivalent CharSequence method.
    Parameters:
      `self` - the original String
      `num` - the number of chars to take from this String
    Returns:
      a String consisting of the first `num` chars, or else the whole String if it has less than `num` elements.
    Since:
      2.5.5

  - ### takeWhile

    public static String takeWhile(CharSequence self, @ClosureParams(value=FromString.class,conflictResolutionStrategy=PickFirstResolver.class,options={"String","Character"}) Closure condition)
    Returns the longest prefix of this CharSequence where each element passed to the given closure evaluates to true.

         def text = "Groovy"
         assert text.takeWhile{ it < 'A' } == ''
         assert text.takeWhile{ it < 'Z' } == 'G'
         assert text.takeWhile{ it != 'v' } == 'Groo'
         assert text.takeWhile{ it < 'z' } == 'Groovy'

    Parameters:
      `self` - the original CharSequence
      `condition` - the closure that must evaluate to true to continue taking elements
    Returns:
      a prefix of elements in the CharSequence where each element passed to the given closure evaluates to true
    Since:
      2.0.0

  - ### takeWhile$$bridge

    @Deprecated public static CharSequence takeWhile$$bridge(CharSequence self, @ClosureParams(value=FromString.class,conflictResolutionStrategy=PickFirstResolver.class,options={"String","Character"}) Closure condition)
    Deprecated.

  - ### takeWhile

    public static String takeWhile(GString self, @ClosureParams(value=FromString.class,conflictResolutionStrategy=PickFirstResolver.class,options={"String","Character"}) Closure condition)
    A GString variant of the equivalent GString method.
    Parameters:
      `self` - the original GString
      `condition` - the closure that must evaluate to true to continue taking elements
    Returns:
      a prefix of elements in the GString where each element passed to the given closure evaluates to true
    Since:
      2.3.7

  - ### toBigDecimal

    public static BigDecimal toBigDecimal(CharSequence self)
    Parses a CharSequence into a BigDecimal
    Parameters:
      `self` - a CharSequence
    Returns:
      a BigDecimal
    Since:
      1.8.2

  - ### toBigInteger

    public static BigInteger toBigInteger(CharSequence self)
    Parses a CharSequence into a BigInteger
    Parameters:
      `self` - a CharSequence
    Returns:
      a BigInteger
    Since:
      1.8.2

  - ### toNumber

    public static Number toNumber(CharSequence self, Locale locale)
    Parses a CharSequence into a Number using the given locale, honouring locale-specific grouping and decimal symbols. Like `toBigDecimal(CharSequence)`, parsing is strict: the entire (trimmed) CharSequence must be a valid number, and the result is an exact `BigDecimal`.

         assert '1.234,5'.toNumber(Locale.GERMANY) == 1234.5

    There is no locale-aware formatting counterpart: use `String.format(Locale, String, Object...)`, e.g. `String.format(Locale.GERMANY, '%,.3f', n)`. Note that unlike this method, such formatting rounds to the given number of fraction digits; `Object.toString()` gives the exact, locale-free form.
    Parameters:
      `self` - a CharSequence
      `locale` - the locale defining the number symbols
    Returns:
      the parsed Number (a BigDecimal)
    Throws:
      `NumberFormatException` - if the CharSequence cannot be parsed in full
    Since:
      6.0.0
    See Also:
      - `toBigDecimal(CharSequence)`
      - `String.format(Locale, String, Object...)`
      - `NumberFormat.getNumberInstance(Locale)`

  - ### toCurrencyNumber

    public static Number toCurrencyNumber(CharSequence self, Locale locale)
    Parses a CharSequence into a Number using the currency format of the given locale. The result is an exact `BigDecimal`.

         assert '$1,234.50'.toCurrencyNumber(Locale.US) == 1234.50g

    No default-locale variant is provided. Input carries the locale of wherever it came from (a file, a request, a database), which is less often the JVM default than is the case for human-facing output. Where the default locale is a fair assumption, such as a console application reading what the user typed, pass `Locale.getDefault()` explicitly.
    Parameters:
      `self` - a CharSequence
      `locale` - the locale defining the currency format
    Returns:
      the parsed Number (a BigDecimal)
    Throws:
      `NumberFormatException` - if the CharSequence cannot be parsed
    Since:
      6.0.0
    See Also:
      - `DefaultGroovyMethods.toCurrencyString(Number, Locale)`
      - `NumberFormat.getCurrencyInstance(Locale)`

  - ### toPercentNumber

    public static Number toPercentNumber(CharSequence self, Locale locale)
    Parses a CharSequence into a Number using the percent format of the given locale. The percent value is unscaled (divided by 100). The result is an exact `BigDecimal`.

         assert '50%'.toPercentNumber(Locale.US) == 0.5

    No default-locale variant is provided. Input carries the locale of wherever it came from (a file, a request, a database), which is less often the JVM default than is the case for human-facing output. Where the default locale is a fair assumption, such as a console application reading what the user typed, pass `Locale.getDefault()` explicitly.
    Parameters:
      `self` - a CharSequence
      `locale` - the locale defining the percent format
    Returns:
      the parsed Number (a BigDecimal)
    Throws:
      `NumberFormatException` - if the CharSequence cannot be parsed
    Since:
      6.0.0
    See Also:
      - `DefaultGroovyMethods.toPercentString(Number, Locale)`
      - `NumberFormat.getPercentInstance(Locale)`

  - ### toBoolean

    public static Boolean toBoolean(String self)
    Converts the given string into a Boolean object. If the trimmed string is "true", "y" or "1" (ignoring case) then the result is true otherwise it is false.
    Parameters:
      `self` - a String
    Returns:
      The Boolean value
    Since:
      1.0

  - ### toCharacter

    public static Character toCharacter(String self)
    Converts the given string into a Character object using the first character in the string.
    Parameters:
      `self` - a String
    Returns:
      the first Character
    Since:
      1.0

  - ### toDouble

    public static Double toDouble(CharSequence self)
    Parses a CharSequence into a Double.
    Parameters:
      `self` - a CharSequence
    Returns:
      a Double
    Since:
      1.8.2

  - ### toFloat

    public static Float toFloat(CharSequence self)
    Parses a CharSequence into a Float.
    Parameters:
      `self` - a CharSequence
    Returns:
      a Float
    Since:
      1.8.2

  - ### toInteger

    public static Integer toInteger(CharSequence self)
    Parses a CharSequence into an Integer.
    Parameters:
      `self` - a CharSequence
    Returns:
      an Integer
    Since:
      1.8.2

  - ### tokenize

    public static List<String> tokenize(CharSequence self)
    Tokenizes a CharSequence (with a whitespace as the delimiter).
    Parameters:
      `self` - a CharSequence
    Returns:
      a List of tokens
    Since:
      1.8.2
    See Also:
      - `StringTokenizer(String)`

  - ### tokenize

    public static List<String> tokenize(CharSequence self, Character delimiter)
    Tokenizes a CharSequence based on the given character delimiter.

    For example:

         char pathSep = ':'
         assert "/tmp:/usr".tokenize(pathSep) == ["/tmp", "/usr"]

    Parameters:
      `self` - a CharSequence
      `delimiter` - the delimiter
    Returns:
      a List of tokens
    Since:
      1.8.2
    See Also:
      - `StringTokenizer(String,String)`

  - ### tokenize

    public static List<String> tokenize(CharSequence self, CharSequence delimiters)
    Tokenizes a CharSequence based on the given CharSequence. Each character in the CharSequence is a separate delimiter.
    Parameters:
      `self` - a CharSequence
      `delimiters` - the delimiters
    Returns:
      a List of tokens
    Since:
      1.8.2
    See Also:
      - `StringTokenizer(String,String)`

  - ### toList

    public static List<String> toList(CharSequence self)
    Converts the given CharSequence into a List of Strings of one character.
    Parameters:
      `self` - a CharSequence
    Returns:
      a List of characters (a 1-character String)
    Since:
      1.8.2

  - ### toLong

    public static Long toLong(CharSequence self)
    Parses a CharSequence into a Long
    Parameters:
      `self` - a CharSequence
    Returns:
      a Long
    Since:
      1.8.2

  - ### toSet

    public static Set<String> toSet(CharSequence self)
    Converts the given CharSequence into a Set of unique Strings of one character.
    Parameters:
      `self` - a CharSequence
    Returns:
      a Set of unique characters (each a 1-character String)
    Since:
      1.8.2

  - ### toShort

    public static Short toShort(CharSequence self)
    Parses a CharSequence into a Short.
    Parameters:
      `self` - a CharSequence
    Returns:
      a Short
    Since:
      1.8.2

  - ### tr

    public static String tr(CharSequence self, CharSequence sourceSet, CharSequence replacementSet) throws ClassNotFoundException
    Translates a CharSequence by replacing characters from the sourceSet with characters from replacementSet. If the first character from sourceSet appears in the CharSequence, it will be replaced with the first character from replacementSet. If the second character from sourceSet appears in the CharSequence, it will be replaced with the second character from replacementSet. and so on for all provided replacement characters.

    Here is an example which converts the vowels in a word from lower to uppercase:

         assert 'hello'.tr('aeiou', 'AEIOU') == 'hEllO'

    A character range using regex-style syntax can also be used, e.g. here is an example which converts a word from lower to uppercase:

         assert 'hello'.tr('a-z', 'A-Z') == 'HELLO'

    Hyphens at the start or end of sourceSet or replacementSet are treated as normal hyphens and are not considered to be part of a range specification. Similarly, a hyphen immediately after an earlier range is treated as a normal hyphen. So, '-x', 'x-' have no ranges while 'a-c-e' has the range 'a-c' plus the '-' character plus the 'e' character.

    Unlike the unix tr command, Groovy's tr command supports reverse ranges, e.g.:

         assert 'hello'.tr('z-a', 'Z-A') == 'HELLO'

    If replacementSet is smaller than sourceSet, then the last character from replacementSet is used as the replacement for all remaining source characters as shown here:

         assert 'Hello World!'.tr('a-z', 'A') == 'HAAAA WAAAA!'

    If sourceSet contains repeated characters, the last specified replacement is used as shown here:

         assert 'Hello World!'.tr('lloo', '1234') == 'He224 W4r2d!'

    The functionality provided by tr can be achieved using regular expressions but tr provides a much more compact notation and efficient implementation for certain scenarios.
    Parameters:
      `self` - the CharSequence that is to be translated
      `sourceSet` - the set of characters to translate from
      `replacementSet` - the set of replacement characters
    Returns:
      The resulting translated `String`
    Throws:
      `ClassNotFoundException`
    Since:
      1.8.2
    See Also:
      - `StringUtil.tr(String,String,String)`

  - ### unexpand

    public static String unexpand(CharSequence self)
    Replaces sequences of whitespaces with tabs using tabStops of size 8.
    Parameters:
      `self` - A CharSequence to unexpand
    Returns:
      an unexpanded String
    Since:
      1.8.2

  - ### unexpand

    public static String unexpand(CharSequence self, int tabStop)
    Replaces sequences of whitespaces with tabs.
    Parameters:
      `self` - A CharSequence to unexpand
      `tabStop` - The number of spaces a tab represents
    Returns:
      an unexpanded String
    Since:
      1.8.2

  - ### unexpandLine

    public static String unexpandLine(CharSequence self, int tabStop)
    Replaces sequences of whitespaces with tabs within a line.
    Parameters:
      `self` - A line to unexpand
      `tabStop` - The number of spaces a tab represents
    Returns:
      an unexpanded String
    Since:
      1.8.2

  - ### startsWithAny

    public static boolean startsWithAny(CharSequence self, CharSequence... prefixes)
    Tests if this CharSequence starts with any specified prefixes.
    Parameters:
      `prefixes` - the prefixes.
    Returns:
      `true` if this CharSequence starts with any specified prefixes.
    Since:
      2.4.14

  - ### endsWithAny

    public static boolean endsWithAny(CharSequence self, CharSequence... suffixes)
    Tests if this CharSequence ends with any specified suffixes.
    Parameters:
      `suffixes` - the suffixes.
    Returns:
      `true` if this CharSequence ends with any specified suffixes
    Since:
      2.4.14

  - ### isBlank

    public static boolean isBlank(CharSequence self)
    Tests if this CharSequence is blank.
    Returns:
      `true` if this CharSequence is blank
    Since:
      2.5.0
    See Also:
      - `isAllWhitespace(CharSequence)`

  - ### takeRight

    public static CharSequence takeRight(CharSequence self, int num)
    Returns the last `num` elements from this CharSequence.

         def text = "Groovy"
         assert text.takeRight( 0 ) == ''
         assert text.takeRight( 2 ) == 'vy'
         assert text.takeRight( 7 ) == 'Groovy'

    Parameters:
      `self` - the original CharSequence
      `num` - the number of chars to take from this CharSequence from the right
    Returns:
      a CharSequence consisting of the last `num` chars, or else the whole CharSequence if it has less than `num` elements.
    Since:
      3.0.0

  - ### takeRight

    public static String takeRight(String self, int num)
    A GString variant of the equivalent CharSequence method `takeRight(CharSequence,int)`.
    Parameters:
      `self` - the original CharSequence
      `num` - the number of chars to take from this CharSequence from the right
    Returns:
      a String consisting of the last `num` chars, or else the whole CharSequence if it has less than `num` elements.
    Since:
      3.0.0

  - ### takeRight

    public static String takeRight(GString self, int num)
    A String variant of the equivalent CharSequence method `takeRight(CharSequence,int)`.
    Parameters:
      `self` - the original GString
      `num` - the number of chars to take from this GString from the right
    Returns:
      a String consisting of the last `num` chars, or else the whole GString if it has less than `num` elements.
    Since:
      3.0.0

  - ### takeAfter

    public static CharSequence takeAfter(CharSequence self, CharSequence searchString)
    Returns the `CharSequence` that exists after the first occurrence of the given `searchString` in this CharSequence.

         def text = "Groovy development. Groovy team"
         assert text.takeAfter( 'Groovy' )           == ' development. Groovy team'
         assert text.takeAfter( 'team' )             == ''
         assert text.takeAfter( '' )                 == ''
         assert text.takeAfter( 'Unavailable text' ) == ''
         assert text.takeAfter( null )               == ''

    Parameters:
      `self` - the original CharSequence
      `searchString` - CharSequence that is searched in this CharSequence
    Returns:
      CharSequence that is after the given searchString and empty string if it does not exist
    Since:
      3.0.0

  - ### takeAfter

    public static String takeAfter(String self, CharSequence searchString)
    A String variant of the equivalent CharSequence method `takeAfter(CharSequence,CharSequence)`.
    Parameters:
      `self` - the original CharSequence
      `searchString` - String that is searched in this CharSequence
    Returns:
      String that is after the given searchString and empty string if it does not exist
    Since:
      3.0.0

  - ### takeAfter

    public static String takeAfter(GString self, CharSequence searchString)
    A GString variant of the equivalent CharSequence method `takeAfter(CharSequence,CharSequence)`.
    Parameters:
      `self` - the original CharSequence
      `searchString` - CharSequence that is searched in this CharSequence
    Returns:
      String that is after the given searchString and empty string if it does not exist
    Since:
      3.0.0

  - ### takeBefore

    public static CharSequence takeBefore(CharSequence self, CharSequence searchString)
    Returns the `CharSequence` that exists before the first occurrence of the given `searchString` in this CharSequence.

         def text = "Groovy development. Groovy team"

         assert text.takeBefore( ' Groovy ' )         == 'Groovy development.'
         assert text.takeBefore( ' ' )                == 'Groovy'
         assert text.takeBefore( 'Unavailable text' ) == ''
         assert text.takeBefore( null )               == ''

    Parameters:
      `self` - the original CharSequence
      `searchString` - CharSequence that is searched in this CharSequence
    Returns:
      CharSequence that is before the given searchString
    Since:
      3.0.0

  - ### takeBefore

    public static String takeBefore(GString self, String searchString)
    A GString variant of the equivalent CharSequence method `takeBefore(CharSequence,CharSequence)`.
    Parameters:
      `self` - the original CharSequence
      `searchString` - CharSequence that is searched in this CharSequence
    Returns:
      String that is before the given searchString
    Since:
      3.0.0

  - ### takeBefore

    public static String takeBefore(String self, String searchString)
    A String variant of the equivalent CharSequence method `takeBefore(CharSequence,CharSequence)`.
    Parameters:
      `self` - the original CharSequence
      `searchString` - CharSequence that is searched in this CharSequence
    Returns:
      String that is before the given searchString
    Since:
      3.0.0

  - ### dropRight

    public static CharSequence dropRight(CharSequence self, int num)
    Returns new CharSequence after removing the right `num` chars. Returns empty String if the `num` is greater than the length of the CharSequence.

         def text = "groovy"

         assert text.dropRight(  3 ) == 'gro'
         assert text.dropRight(  6 ) == ''
         assert text.dropRight(  0 ) == 'groovy'
         assert text.dropRight( -1 ) == 'groovy'
         assert text.dropRight( 10 ) == ''

    Parameters:
      `self` - the original CharSequence
      `num` - number of characters
    Returns:
      CharSequence after removing the right `num` chars and empty of the `num` is greater than the length of the CharSequence
    Since:
      3.0.0

  - ### dropRight

    public static String dropRight(String self, int num)
    A String variant of the equivalent CharSequence method `dropRight(CharSequence,int)`.
    Parameters:
      `self` - the original CharSequence
      `num` - number of characters
    Returns:
      String after removing the right `num` chars and empty of the `num` is greater than the length of the CharSequence
    Since:
      3.0.0

  - ### dropRight

    public static String dropRight(GString self, int num)
    A GString variant of the equivalent CharSequence method `dropRight(CharSequence,int)`.
    Parameters:
      `self` - the original CharSequence
      `num` - number of characters
    Returns:
      String after removing the right `num` chars and empty of the `num` is greater than the length of the CharSequence
    Since:
      3.0.0

  - ### takeBetween

    public static CharSequence takeBetween(CharSequence self, CharSequence from, CharSequence to)
    Returns the CharSequence that is in between the first occurrence of the given `from` and `to` CharSequences and empty if the unavailable inputs are given.

         def text = "Groovy"

         assert text.takeBetween( 'r', 'v' ) == 'oo'
         assert text.takeBetween( 'r', 'z' ) == ''
         assert text.takeBetween( 'a', 'r' ) == ''

    Parameters:
      `self` - the original CharSequence
      `from` - beginning of search
      `to` - end of search
    Returns:
      the CharSequence that is in between the given two CharSequences and empty if the unavailable inputs are given
    Since:
      3.0.0
    See Also:
      - `takeBetween(CharSequence,CharSequence,CharSequence,int)`

  - ### takeBetween

    public static String takeBetween(String self, CharSequence from, CharSequence to)
    A String variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,CharSequence)`.
    Parameters:
      `self` - the original CharSequence
      `from` - beginning of search
      `to` - end of search
    Returns:
      String that is in between the given two CharSequences and empty if the unavailable inputs are given
    Since:
      3.0.0

  - ### takeBetween

    public static String takeBetween(GString self, CharSequence from, CharSequence to)
    A GString variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,CharSequence)`.
    Parameters:
      `self` - the original CharSequence
      `from` - beginning of search
      `to` - end of search
    Returns:
      String that is in between the given two CharSequences and empty if the unavailable inputs are given
    Since:
      3.0.0

  - ### takeBetween

    public static CharSequence takeBetween(CharSequence self, CharSequence enclosure)
    Takes the characters between the first occurrence of the two subsequent `enclosure` strings.

         def text = "name = 'some name'"

         assert text.takeBetween( "'" ) == 'some name'
         assert text.takeBetween( 'z' ) == ''

    Parameters:
      `self` - Original CharSequence
      `enclosure` - Enclosure CharSequence
    Returns:
      CharSequence between the 2 subsequent `enclosure` strings
    Since:
      3.0.0
    See Also:
      - `takeBetween(CharSequence,CharSequence,int)`

  - ### takeBetween

    public static String takeBetween(String self, CharSequence enclosure)
    A String variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence)`.
    Parameters:
      `self` - Original String
      `enclosure` - Enclosure CharSequence
    Returns:
      String between the 2 subsequent `enclosure` strings
    Since:
      3.0.0

  - ### takeBetween

    public static String takeBetween(GString self, CharSequence enclosure)
    A GString variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence)`.
    Parameters:
      `self` - Original GString
      `enclosure` - Enclosure CharSequence
    Returns:
      String between the 2 subsequent `enclosure` strings
    Since:
      3.0.0

  - ### takeBetween

    public static CharSequence takeBetween(CharSequence self, CharSequence from, CharSequence to, int occurrence)
    Returns the CharSequence that is in between the given the nth (specified by occurrence) pair of `from` and `to` CharSequences and empty if the unavailable inputs are given.

         def text = "t1=10 ms, t2=100 ms"

         assert text.takeBetween( '=', ' ', 0 ) == '10'
         assert text.takeBetween( '=', ' ', 1 ) == '100'
         assert text.takeBetween( 't1', 'z' ) == ''

    Parameters:
      `self` - the original CharSequence
      `from` - beginning of search
      `to` - end of search
      `occurrence` - nth occurrence that is to be returned. 0 represents first one
    Returns:
      the CharSequence that is in between the given the nth (specified by occurrence) pair of `from` and `to` CharSequences and empty if the unavailable inputs are given.
    Since:
      3.0.0
    See Also:
      - `takeBetween(CharSequence,CharSequence,CharSequence)`

  - ### takeBetween

    public static String takeBetween(String self, CharSequence from, CharSequence to, int occurrence)
    A String variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,CharSequence,int)`.
    Parameters:
      `self` - the original String
      `from` - beginning of search
      `to` - end of search
      `occurrence` - nth occurrence that is to be returned. 0 represents first one
    Returns:
      the String that is in between the given nth (specified by occurrence) pair of `from` and `to` CharSequences and empty if the unavailable inputs are given.
    Since:
      3.0.0

  - ### takeBetween

    public static String takeBetween(GString self, CharSequence from, CharSequence to, int occurrence)
    A GString variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,CharSequence,int)`.
    Parameters:
      `self` - the original GString
      `from` - beginning of search
      `to` - end of search
      `occurrence` - nth occurrence that is to be returned. 0 represents first one
    Returns:
      the String that is in between the given nth (specified by occurrence) pair of `from` and `to` CharSequences and empty if the unavailable inputs are given.
    Since:
      3.0.0

  - ### takeBetween

    public static CharSequence takeBetween(CharSequence self, CharSequence enclosure, int occurrence)
    Takes the characters between nth (specified by occurrence) pair of `enclosure` strings.

         def text = "t1='10' ms, t2='100' ms"

         assert text.takeBetween( "'", 0 ) == '10'
         assert text.takeBetween( "'", 1 ) == '100'
         assert text.takeBetween( "'", 2 ) == ''

    Parameters:
      `self` - Original CharSequence
      `enclosure` - Enclosure CharSequence
      `occurrence` - nth occurrence being returned
    Returns:
      CharSequence between the nth occurrence of pair of `enclosure` strings
    Since:
      3.0.0
    See Also:
      - `takeBetween(CharSequence,CharSequence,int)`

  - ### takeBetween

    public static String takeBetween(String self, CharSequence enclosure, int occurrence)
    A String variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,int)`.
    Parameters:
      `self` - Original String
      `enclosure` - Enclosure CharSequence
      `occurrence` - nth occurrence being returned
    Returns:
      String between the nth occurrence of pair of `enclosure` strings
    Since:
      3.0.0

  - ### takeBetween

    public static String takeBetween(GString self, CharSequence enclosure, int occurrence)
    A GString variant of the equivalent CharSequence method `takeBetween(CharSequence,CharSequence,int)`.
    Parameters:
      `self` - Original GString
      `enclosure` - Enclosure CharSequence
      `occurrence` - nth occurrence being returned
    Returns:
      String between the nth occurrence of pair of `enclosure` strings
    Since:
      3.0.0

  - ### startsWithIgnoreCase

    public static boolean startsWithIgnoreCase(CharSequence self, CharSequence searchString)
    Checks whether this CharSequence starts with the `searchString` ignoring the case considerations.
    Parameters:
      `self` - the original CharSequence
      `searchString` - CharSequence being checked against this
    Returns:
      `true` if the character sequence represented by the argument is a prefix of this CharSequence ignoring the case considerations. `false` otherwise. Returns false if the argument is null
    Since:
      3.0.0

  - ### endsWithIgnoreCase

    public static boolean endsWithIgnoreCase(CharSequence self, CharSequence searchString)
    Checks whether this CharSequence ends with the `searchString` ignoring the case considerations.
    Parameters:
      `self` - the original CharSequence
      `searchString` - CharSequence bring checked against this
    Returns:
      `true` if the character sequence represented by the argument is a suffix of this CharSequence ignoring the case considerations. `false` otherwise. Returns false if the argument is null
    Since:
      3.0.0

  - ### containsIgnoreCase

    public static boolean containsIgnoreCase(CharSequence self, CharSequence searchString)
    Checks whether this CharSequence contains the `searchString` ignoring the caseConsiderations.
    Parameters:
      `self` - the original CharSequence
      `searchString` - CharSequence being checked against this
    Returns:
      `true` if the character sequence represented by the argument exists in this CharSequence ignoring the case considerations. `false` otherwise. Returns false if the argument is null
    Since:
      3.0.0

  - ### findBalancedGroups

    public static List<BalancedGroup> findBalancedGroups(CharSequence self, String openRegex, String closeRegex)
    Finds balanced (nested) groups in this CharSequence using default options (no ignore pattern; opening and closing delimiters are kept in the match text).

    This is Groovy's structured alternative to .NET regex balancing groups (`(?&lt;Open&gt;…)` / `(?&lt;Close-Open&gt;…)` / `(?(Open)(?!))`). Delegates to `BalancedGroup.find(CharSequence, String, String)`. Java `Pattern` cannot express capture-stack push/pop, so nesting is resolved with an explicit stack and the result is a tree of `BalancedGroup` nodes (with `BalancedGroup.getStart()`/`BalancedGroup.getEnd()` offsets comparable to .NET `Capture.Index`/`Length`).

         def text = 'Root: (A + (B * C) + (D(E)))'
         def roots = text.findBalancedGroups(/\(/, /\)/)
         assert roots.size() == 1
         assert roots[0].matchedString == '(A + (B * C) + (D(E)))'
         assert roots[0].children*.matchedString == ['(B * C)', '(D(E))']
         assert roots[0].children[1].children[0].matchedString == '(E)'
         assert text.substring(roots[0].start, roots[0].end) == roots[0].matchedString
         assert roots[0].children[0].depth == 1

    Unmatched closers are ignored; unclosed openers are dropped but completed groups nested inside them are still returned (more tolerant than a strict .NET `(?(Open)(?!))` whole-string match).

    Parameters:
      `self` - a CharSequence
      `openRegex` - regular expression for the opening delimiter (must not be empty)
      `closeRegex` - regular expression for the closing delimiter (must not be empty)
    Returns:
      an unmodifiable list of outermost `BalancedGroup` nodes (empty if none)
    Throws:
      `NullPointerException` - if `self`, `openRegex`, or `closeRegex` is `null`
      `IllegalArgumentException` - if `openRegex` or `closeRegex` is empty
      `PatternSyntaxException` - if a pattern is not a valid Java regex
    Since:
      6.0.0
    See Also:
      - `BalancedGroup.find(CharSequence, String, String)`
      - `findBalancedGroups(CharSequence, String, String, BalancedGroup.MatchOptions)`

  - ### findBalancedGroups

    public static List<BalancedGroup> findBalancedGroups(CharSequence self, String openRegex, String closeRegex, BalancedGroup.MatchOptions options)
    Finds balanced (nested) groups in this CharSequence with the given options. Delegates to `BalancedGroup.find(CharSequence, String, String, BalancedGroup.MatchOptions)`.

         import groovy.util.regex.BalancedGroup
         def opts = BalancedGroup.MatchOptions.defaults().withIncludeEdges(false)
         def g = 'func(arg1, arg2)'.findBalancedGroups(/\(/, /\)/, opts)[0]
         assert g.matchedString == 'arg1, arg2'
         assert g.start == 5 && g.end == 15
         assert g.fullStart == 4 && g.fullEnd == 16

         def code = 'if (true) { String s = "}"; }'
         def ignoreStrings = BalancedGroup.MatchOptions.defaults()
             .withIgnoreRegex(/"(?:\\.|[^"\\])*"/)
         assert code.findBalancedGroups(/\{/, /\}/, ignoreStrings)[0].matchedString == '{ String s = "}"; }'

    `BalancedGroup.MatchOptions.includeEdges()``false` keeps only the interior text (like .NET's balancing capture of the interval between the open capture and the close). `BalancedGroup.MatchOptions.ignoreRegex()` skips spans such as string literals—the usual substitute for a hand-built “neither delimiter” class in a .NET balancing pattern.

    If `options` is `null`, `BalancedGroup.MatchOptions.defaults()` is used. Named groups `OPEN`, `CLOSE`, and `IGNORE` are reserved by the scanner.

    Parameters:
      `self` - a CharSequence
      `openRegex` - regular expression for the opening delimiter (must not be empty)
      `closeRegex` - regular expression for the closing delimiter (must not be empty)
      `options` - match options, or `null` for defaults
    Returns:
      an unmodifiable list of outermost `BalancedGroup` nodes (empty if none)
    Throws:
      `NullPointerException` - if `self`, `openRegex`, or `closeRegex` is `null`
      `IllegalArgumentException` - if `openRegex` or `closeRegex` is empty
      `PatternSyntaxException` - if a pattern is not a valid Java regex
    Since:
      6.0.0
    See Also:
      - `BalancedGroup.find(CharSequence, String, String, BalancedGroup.MatchOptions)`
      - `findBalancedGroups(CharSequence, String, String)`