private static string RemoveValuesInternal(string source, int? quantity, string extraction, StringComparison comparisonRule, The position = The.Beginning)
        {
            if (quantity < 0)
                throw new ArgumentOutOfRangeException("quantity", "Negative quantity is not supported");

            if (quantity == 0)
                return source;

            return source.Remove(extraction,
                (s, e) =>
                {
                    var indexes = source.IndexesOf(extraction, comparisonRule, position);
                    if (quantity != null)
                        indexes = indexes.Take(quantity.Value);
                    if (position == The.End)
                        indexes = indexes.Reverse();

                    var indexesArray = indexes.ToArray();

                    if (!indexesArray.Any())
                        return source;

                    var start = 0;
                    var resultStringLength = source.Length - indexesArray.Length * extraction.Length;
                    var builder = new StringBuilder(resultStringLength);
                    foreach (var index in indexes)
                    {
                        builder.Append(source.Substring(start, index - start));
                        start = index + extraction.Length;
                    }
                    builder.Append(source.Substring(start));
                    return builder.ToString();
                });
        }

 internal InsertStringAfter(InsertString insertString, string marker)
 {
     _insertString = insertString;
     _marker = marker;
     _ignoreCase = false;
     _position = The.Beginning;
 }

 internal RemoveStringToFirstOccurrence(RemoveString removeString, string marker)
 {
     _removeString = removeString;
     _marker = marker;
     _ignoreCase = false;
     _position = The.Beginning;
 }

 internal RemoveValue(string source, string extraction)
 {
     _source = source;
     _extraction = extraction;
     _ignoreCase = false;
     _position = The.Beginning;
 }

 internal RemoveStringStartingOccurrencePosition(RemoveString removeString, The position, int occurrenceCount, string marker)
 {
     _removeString = removeString;
     _position = position;
     _occurrenceCount = occurrenceCount;
     _marker = marker;
 }

 internal RemoveStringStartingOccurrenceToOccurrencePosition(RemoveStringStartingOccurrence source, The position, int occurrenceCount, string marker)
 {
     _source = source;
     _position = position;
     _occurrenceCount = occurrenceCount;
     _marker = marker;
 }

 internal RemoveStringStartingOccurrence(RemoveString removeString, int occurrenceCount, string marker)
 {
     _removeString = removeString;
     _occurrenceCount = occurrenceCount;
     _marker = marker;
     _ignoreCase = false;
     _position = The.Beginning;
 }

 internal RemoveValues(string source, int quantity, string extraction)
 {
     _source = source;
     _quantity = quantity;
     _extraction = extraction;
     _ignoreCase = false;
     _position = The.Beginning;
 }

 internal InsertStringBeforeOccurrence(InsertString insertString, int occurrenceCount, string marker)
 {
     _insertString = insertString;
     _occurrenceCount = occurrenceCount;
     _marker = marker;
     _ignoreCase = false;
     _position = The.Beginning;
 }

 internal RemoveStringStartingFirstOccurrencePosition(RemoveString removeString, The position, string marker)
 {
     _removeString = removeString;
     _position = position;
     _marker = marker;
     _ignoreCase = false;
     _from = The.Beginning;
 }

 internal RemoveStringStartingOccurrencePositionToOccurrence(RemoveStringStartingOccurrencePosition removeStringStartingOccurrencePosition, int occurrence, string marker)
 {
     _removeStringStartingOccurrencePosition = removeStringStartingOccurrencePosition;
     _occurrence = occurrence;
     _marker = marker;
     _ignoreCase = false;
     _position = The.Beginning;
 }

 internal RemoveStringToOccurrencePosition(RemoveString removeString, The position, int occurrence, string marker)
 {
     _removeString = removeString;
     _position = position;
     _occurrenceCount = occurrence;
     _marker = marker;
     _ignoreCase = false;
     _from = The.Beginning;
 }

        public static int? IndexOf(this string source, The position, int occurrenceCount, string marker, bool ignoreCase, The from)
        {
            var index = source.IndexOf(occurrenceCount, marker, ignoreCase, from);

            if (index == null)
                return null;

            int shift = position == The.StartOf ? 0 : marker.Length;
            return index.Value + shift;
        }

 public static string RemoveValues(this string source, int? quantity, string extraction, StringComparison comparisonRule, The position)
 {
     switch (position)
     {
         case The.Beginning:
         case The.End:
             return RemoveValuesInternal(source, quantity, extraction, comparisonRule, position);
         case The.StartOf:
         case The.EndOf:
         default:
             throw new ArgumentOutOfRangeException("position", "Only Beginning and End positions are supported by Remove().From() method");
     }
 }

 public static IEnumerable<int> IndexesOf(this string source, string marker, bool ignoreCase, The position)
 {
     switch (position)
     {
         case The.Beginning:
             return source.IndexesOf(marker, ignoreCase);
         case The.End:
             return source.IndexesOf(marker, ignoreCase).Reverse();
         case The.StartOf:
         case The.EndOf:
         default:
             throw new ArgumentOutOfRangeException("position", "Only Beginning and End positions are supported by IndexesOf().From() method");
     }
 }

 public static IEnumerable<int> IndexesOf(this string source, string marker, StringComparison comparisonRule, The position)
 {
     switch (position)
     {
         case The.Beginning:
             return source.IndexesOf(marker, comparisonRule);
         case The.End:
             return source.LastIndexesOf(marker, comparisonRule);
         case The.StartOf:
         case The.EndOf:
         default:
             throw new ArgumentOutOfRangeException("position", "Only Beginning and End positions are supported by IndexesOf().From() method");
     }
 }

        private static string InsertWithChecks(this string source, string insertion, string marker, bool ignoreCase, int occurrenceCount, The position, bool after)
        {
            if (occurrenceCount < 0)
                throw new ArgumentOutOfRangeException("occurrence", "Negative occurrence count is not supported");

            if (occurrenceCount == 0)
                return source;

            return source.Insert(insertion, marker,
                (s, i, m) =>
                {
                    var shift = after ? marker.Length : 0;
                    var indexes = s.IndexesOf(m, ignoreCase, position).Take(occurrenceCount).ToArray();
                    return indexes.Any() ? s.Insert(indexes.Last() + shift, i) : s;
                });
        }

 public static string RemoveStartingOrTo(this string source, string marker, bool ignoreCase, The from, bool isStarting)
 {
     switch (from)
     {
         case The.Beginning:
             return source.RemoveStartingOrTo(marker, ignoreCase, isStarting, fromBeginning: true);
         case The.End:
             return source.RemoveStartingOrTo(marker, ignoreCase, isStarting, fromBeginning: false);
         case The.StartOf:
         case The.EndOf:
         default:
             var methodName = isStarting ? "Starting" : "To";
             throw new ArgumentOutOfRangeException(
                 "position", "Only Beginning and End positions are supported by Remove().{0}().From() method".f(methodName));
     }
 }

 public static string Insert(
     this string source, string insertion, string marker, bool ignoreCase = false,
     The position = The.Beginning, int? occurrenceCount = null, bool after = false)
 {
     switch (position)
     {
         case The.Beginning:
         case The.End:
             return occurrenceCount != null
                 ? source.InsertWithChecks(insertion, marker, ignoreCase, occurrenceCount.Value, position, after)
                 : source.InsertWithChecks(insertion, marker, ignoreCase, position, after);
         case The.StartOf:
         case The.EndOf:
         default:
             throw new ArgumentOutOfRangeException("position", "Only Beginning and End positions are supported by Insert().From() method");
     }
 }

        public static string RemoveStartingOrToPosition(this string source, The position, int occurrenceCount, string marker, bool ignoreCase, The from, bool isStarting)
        {
            if (occurrenceCount < 0)
                throw new ArgumentOutOfRangeException("occurrenceCount", "Negative occurrence count is not supported");

            if (occurrenceCount == 0)
                return source;

            switch (position)
            {
                case The.StartOf:
                case The.EndOf:
                    break;
                case The.Beginning:
                case The.End:
                default:
                    throw new ArgumentOutOfRangeException("position", "Only StartOf and EndOf positions are supported by Remove().Starting() method");
            }

            return source.Remove(marker,
                (s, m) =>
                {
                    var indexes = source.IndexesOf(marker, ignoreCase, from).Skip(occurrenceCount - 1);

                    if (!indexes.Any())
                        return source;

                    int shift = position == The.StartOf ? 0 : marker.Length;
                    var index = indexes.First() + shift;

                    if (index >= source.Length)
                        return isStarting ? source : String.Empty;

                    return isStarting ? source.Substring(0, index) : source.Remove(0, index);
                },
                (s, m) =>
                {
                    return isStarting || position == The.EndOf ? null : String.Empty;
                });
        }