System.Func.Invoke(TItem)

public static List<replacedem> ItemsWithMaxValues<replacedem>(this IEnumerable<replacedem> source, Func<replacedem, double> selector)
		{
			source.ThrowOnNull(nameof(source));
			selector.ThrowOnNull(nameof(selector));

			double maxValue = double.MinValue;
			List<replacedem> result = new List<replacedem>(capacity: 2);

			foreach (replacedem item in source)
			{
				double value = selector(item);

				if (maxValue > value)
					continue;

				if (maxValue < value)
				{
					result.Clear();
					maxValue = value;
				}
				
				result.Add(item);
			}

			return result;
		}

public IEnumerable<IDataPoint<replacedem>> GetData()
        {
            var data = Items
         .Select(d => new ListPoint<replacedem>
         {
             X = XValue.Compile().Invoke(d),
             Y = new List<decimal>
             {
                         Open.Compile().Invoke(d),
                         High.Compile().Invoke(d),
                         Low.Compile().Invoke(d),
                       Close.Compile().Invoke(d)
             },
             Items = Items
         });

            if (OrderBy != null)
            {
                data = data.OrderBy(o => OrderBy.Compile().Invoke(o));
            }
            else if (OrderByDescending != null)
            {
                data = data.OrderByDescending(o => OrderByDescending.Compile().Invoke(o));
            }

            return data;

        }

public IEnumerable<IDataPoint<replacedem>> GetData()
        {
            IEnumerable<DataPoint<replacedem>> data;

            if (YValue != null)
            {
                data = Items.Select(e => new DataPoint<replacedem>
                {
                    X = XValue.Compile().Invoke(e),
                    Y = YValue.Compile().Invoke(e),
                    Items = new List<replacedem> { e }
                });

            }
            else if (YAggregate != null)
            {
                data = Items.GroupBy(e => XValue.Compile().Invoke(e))
               .Select(d => new DataPoint<replacedem>
               {
                   X = d.Key,
                   Y = YAggregate.Compile().Invoke(d),
                   Items = d.ToList()
               });
            }
            else
            {
                return new List<IDataPoint<replacedem>>();
            }


            if (OrderBy != null)
            {
                data = data.OrderBy(o => OrderBy.Compile().Invoke(o));
            }
            else if (OrderByDescending != null)
            {
                data = data.OrderByDescending(o => OrderByDescending.Compile().Invoke(o));
            }

            return data;
        }

public static IEnumerable<IGrouping<TKey, replacedem>> GroupByContiguous<TKey, replacedem>(this IEnumerable<replacedem> items, Func<replacedem, TKey> keySelector)
        {
            Grouping<TKey, replacedem> currentGroup = null;
            foreach (replacedem item in items)
            {
                TKey key = keySelector(item);
                if (currentGroup != null && !EqualityComparer<TKey>.Default.Equals(key, currentGroup.Key))
                {
                    yield return currentGroup;
                    currentGroup = null;
                }

                if (currentGroup == null)
                    currentGroup = new Grouping<TKey, replacedem>(key);

                currentGroup.Items.Add(item);
            }
            if (currentGroup != null)
                yield return currentGroup;
        }

protected override TKey GetKeyForItem(replacedem item)
        {
            return _getKeyForItemFunction(item);
        }

public static IEnumerable<replacedem> RoundRobin<replacedem, TKey>(this IList<replacedem> source, Func<replacedem, TKey> predicate)
		{
			List<TKey> keys = source.Select(predicate)
									.Distinct()
									.ToList();

			SortedList<TKey, int> queueIndices = new SortedList<TKey, int>();

			foreach (var key in keys)
				queueIndices.Add(key, 0);

			while (queueIndices.Count > 0)
			{
				foreach (var key in keys)
				{
					if (!queueIndices.ContainsKey(key))
						continue;

					int index = queueIndices[key];

					while (index < source.Count)
					{
						var item = source[index];

						index++;

						if (Equals(predicate(item), key))
						{
							yield return item;
							break;
						}
					}

					if (index == source.Count)
						queueIndices.Remove(key);
					else
						queueIndices[key] = index;
				}
			}
		}

private void Process(replacedem item)
        {
            var pendingDependencies = getDependencies(item)
                .Where(key => !sortedItems.Contains(key))
                .ToArray();

            if (pendingDependencies.Length > 0)
            {
                waitList.Add(item, pendingDependencies);
            }
            else
            {
                readyToOutput.Enqueue(item);
            }
        }

private void Release(replacedem item)
        {
            var key = getKey(item);
            sortedItems.Add(key);

            var releasedItems = waitList.Remove(key);
            if (releasedItems != null)
            {
                foreach (var releasedItem in releasedItems)
                {
                    readyToOutput.Enqueue(releasedItem);
                }
            }
        }

public object Invoke(replacedem item)
        {
            return Factory.Invoke(item);
        }

public async Task EmitActiveAsync()
        {
            _oldActive = Nodes.Values.Where(r => r.IsActive).Select(r => ItemKey(r.Item)).ToList();
            if (ListComparer.Equals(_oldActive, Active))
            {
                //nothing change
                return;
            }

            Active = _oldActive;

            if (OnActiveUpdate.HasDelegate)
            {
                var active = Nodes.Values.Where(r => r.IsActive).Select(r => r.Item).ToList();
                _ = OnActiveUpdate.InvokeAsync(active);
            }

            if (ActiveChanged.HasDelegate)
            {
                await ActiveChanged.InvokeAsync(Active);
            }
            else
            {
                StateHasChanged();
            }
        }

public async Task EmitOpenAsync()
        {
            _oldOpen = Nodes.Values.Where(r => r.IsOpen).Select(r => ItemKey(r.Item)).ToList();
            if (ListComparer.Equals(_oldOpen, Open))
            {
                //nothing change
                return;
            }

            Open = _oldOpen;

            if (OnOpenUpdate.HasDelegate)
            {
                var open = Nodes.Values.Where(r => r.IsOpen).Select(r => r.Item).ToList();
                _ = OnOpenUpdate.InvokeAsync(open);
            }

            if (OpenChanged.HasDelegate)
            {
                await OpenChanged.InvokeAsync(Open);
            }
        }

public async Task EmitSelectedAsync()
        {
            _oldValue = Nodes.Values.Where(r => r.IsSelected).Select(r => ItemKey(r.Item)).ToList();
            if (ListComparer.Equals(_oldValue, Value))
            {
                //nothing change
                return;
            }

            Value = _oldValue;

            if (OnInput.HasDelegate)
            {
                var value = Nodes.Values.Where(r => r.IsSelected).Select(r => r.Item).ToList();
                _ = OnInput.InvokeAsync(value);
            }

            if (ValueChanged.HasDelegate)
            {
                await ValueChanged.InvokeAsync(Value);
            }
            else
            {
                StateHasChanged();
            }
        }

private bool FilterTreeItems(replacedem item, ref List<TKey> excluded)
        {
            if (FilterTreeItem(item, Search, ItemText))
            {
                return true;
            }

            var children = ItemChildren(item);

            if (children != null)
            {
                var match = false;

                foreach (var child in children)
                {
                    if (FilterTreeItems(child, ref excluded))
                    {
                        match = true;
                    }
                }

                if (match)
                {
                    return true;
                }
            }

            excluded.Add(ItemKey(item));
            return false;
        }

private bool FilterTreeItem(replacedem item, string search, Func<replacedem, string> itemText)
        {
            var text = itemText(item).ToString();
            return text.ToLower().IndexOf(search.ToLower()) > -1;
        }

private void UpdateOpen()
        {
            if (Open == null || !Open.Any())
            {
                return;
            }

            foreach (var nodeState in Nodes.Values)
            {
                var key = ItemKey(nodeState.Item);
                if (Open.Contains(key))
                {
                    nodeState.IsOpen = true;
                }
                else
                {
                    nodeState.IsOpen = false;
                }
            }
        }

private void UpdateActive()
        {
            if (Active == null || !Active.Any())
            {
                return;
            }

            var hasActive = false;
            foreach (var nodeState in Nodes.Values)
            {
                var key = ItemKey(nodeState.Item);
                if (Active.Contains(key) && (MultipleActive || !hasActive))
                {
                    nodeState.IsActive = true;
                    hasActive = true;
                }
                else
                {
                    nodeState.IsActive = false;
                }
            }
        }

private void BuildTree(List<replacedem> items, TKey parent)
        {
            foreach (var item in items)
            {
                var key = ItemKey(item);
                var children = ItemChildren(item) ?? new List<replacedem>();

                var nodeState = new NodeState<replacedem, TKey>
                {
                    Children = children.Select(ItemKey),
                    IsOpen = OpenAll,
                    Item = item,
                    Parent = parent
                };
                Nodes.Add(key, nodeState);

                BuildTree(children, key);
            }
        }

public async Task CheckChildren()
        {
            if (Children == null || Children.Any() || LoadChildren == null || _hasLoaded) return;

            IsLoading = true;

            try
            {
                await LoadChildren(Item);
            }
            finally
            {
                IsLoading = false;
                _hasLoaded = true;
            }
        }

IList<replacedem> FlattenList(IEnumerable<replacedem> groupedItems, Func<replacedem,IEnumerable<replacedem>> subGroupSelector)
        {
            IList<replacedem> flattenedItems = new System.Collections.Generic.List<replacedem>();

            foreach (replacedem? item in groupedItems)
            {
                IEnumerable<replacedem>? subItems = subGroupSelector(item);
                if (subItems == null || !subItems.Any())
                    flattenedItems.Add(item);
                else
                {
                    IList<replacedem>? moreItems = FlattenList(subItems, subGroupSelector);
                    flattenedItems.AddRange(moreItems);
                }
            }

            return flattenedItems;
        }

public static int GetPlainItemsCount(replacedem item, Func<replacedem, IEnumerable<replacedem>> subgroupSelector)
        {
            IEnumerable<replacedem>? subItems = subgroupSelector(item);
            if (subItems == null || !subItems.Any())
                return 1;
            else
            {
                int count = 0;
                foreach (replacedem? subItem in subItems)
                {
                    int subcount = GroupedList<replacedem,TKey>.GetPlainItemsCount(subItem, subgroupSelector);
                    count += subcount;
                }
                return count;
            }
        }

private string GetSelectedSuggestionClreplaced(replacedem item, int index)
        {
            const string resultClreplaced = "blazored-typeahead__active-item";
            TValue value = ConvertMethod(item);

            if (Equals(value, Value) || (Values?.Contains(value) ?? false))
            {
                if (index == SelectedIndex)
                {
                    return "blazored-typeahead__selected-item-highlighted";
                }

                return "blazored-typeahead__selected-item";
            }

            if (index == SelectedIndex)
            {
                return resultClreplaced;
            }

            return Equals(value, Value) ? resultClreplaced : string.Empty;
        }

private async Task SelectResult(replacedem item)
        {
            var value = ConvertMethod(item);
       
            if (IsMultiselect)
            {
                var valueList = Values ?? new List<TValue>();

                if (valueList.Contains(value))
                    valueList.Remove(value);
                else
                    valueList.Add(value);

                await ValuesChanged.InvokeAsync(valueList);
            }
            else
            {
                if (Value != null && Value.Equals(value)) return;
                Value = value;
                await ValueChanged.InvokeAsync(value);
            }

            _editContext?.NotifyFieldChanged(_fieldIdentifier);

            Initialize();
        }

public override View GetChildView(
			int groupPosition, int childPosition, 
			bool isLastChild, View convertView, ViewGroup parent)
		{
			var view = convertView;

			var item = groupings[groupPosition][childPosition];
			int layoutId = getLayoutIdFunc(item);

			if (view == null)
			{
				view = inflater.Inflate(/*Resource.Layout.OptionTemplate_Boolean*/layoutId, null);
			}
			else
			{
				if (bindingsDictionary.TryGetValue(view, out BoundViewData viewData))
				{
					var currentDataContext = viewData.DataContext;

					if (currentDataContext != null && currentDataContext.Equals(item)
						&& viewData.Applicator.HasBindings)
					{
						return view;
					}

					viewData.Applicator.RemoveBindings();

					/* If the item is not of the same type, do not reuse the view. */
					if (viewData.DataContext.GetType() != item.GetType())
					{
						view = inflater.Inflate(layoutId, null);
					}
				}
			}

			var applicator = new XmlBindingApplicator();
			applicator.ApplyBindings(view, item, layoutId);
			bindingsDictionary[view] = new BoundViewData(applicator, item);
			reverseLookup[item] = view;
			
			return view;
		}

protected void TryAddToCache<replacedem, TK, TV>(
            string cacheKeyType,
            IEnumerable<replacedem> items,
            Func<replacedem, TK> key,
            Func<replacedem, TV> value)
            where TK : notnull
        {
            if (_cache is not null)
            {
                foreach (replacedem item in items)
                {
                    TaskCacheKey cacheKey = new(cacheKeyType, key(item));
                    _cache.TryAdd(cacheKey, () => Task.FromResult(value(item)));
                }
            }
        }

public object GetReplacement(object dbValue)
        {
            return _getterFunc((replacedem) dbValue);
        }

public void Add(replacedem item)
    {
      if (!set.Add(item) && IsSet)
        return;
      list.Add(item);
      var clreplacedes = Clreplacedifier.Invoke(item);
      foreach (var @clreplaced in clreplacedes) {
        var clreplacedList = clreplacedified.GetValueOrDefault(@clreplaced);
        if (clreplacedList==null) {
          clreplacedList = new List<replacedem>();
          clreplacedified.Add(@clreplaced, clreplacedList);
        }
        clreplacedList.Add(item);
      }
    }

public override replacedem Add(replacedem item, bool replaceIfExists)
    {
      ArgumentValidator.EnsureArgumentNotNull(item, "item");
      var key = KeyExtractor(item);
      var cached = new KeyValuePair<TKey, replacedem>(key, item);
      KeyValuePair<TKey, replacedem> oldCached;
      if (deque.TryChangeValue(key, cached, true, replaceIfExists, out oldCached)) {
        if (!replaceIfExists)
          return oldCached.Value;
        size -= sizeExtractor(oldCached.Value);
        if (chainedCache!=null)
          chainedCache.Add(oldCached.Value, true);
        ItemRemoved(key);
      }
      size += sizeExtractor(item);
      while (size > maxSize && deque.Count > 0) {
        oldCached = deque.PopBottom();
        size -= sizeExtractor(oldCached.Value);
        if (chainedCache!=null)
          chainedCache.Add(oldCached.Value, true);
        ItemRemoved(key);
      }
      ItemAdded(key);
      return item;
    }

public override void RemoveKey(TKey key, bool removeCompletely)
    {
      KeyValuePair<TKey, replacedem> oldCached;
      if (deque.TryGetValue(key, out oldCached)) {
        deque.Remove(key);
        size -= sizeExtractor(oldCached.Value);
        if (chainedCache!=null) {
          if (removeCompletely)
            chainedCache.RemoveKey(key);
          else
            chainedCache.Add(oldCached.Value, true);
        }
        ItemRemoved(key);
      }
    }

public static IEnumerable<replacedem> Unfold<replacedem>(replacedem first, Func<replacedem, replacedem> next)
    {
      ArgumentValidator.EnsureArgumentNotNull(next, "next");
      var current = first;
      while (current!=null) {
        yield return current;
        current = next.Invoke(current);
      }
    }

public static IEnumerable<replacedem> Unfold<replacedem>(replacedem first, Func<replacedem, bool> include, Func<replacedem, replacedem> next)
    {
      ArgumentValidator.EnsureArgumentNotNull(next, "next");
      var current = first;
      while (include.Invoke(current)) {
        yield return current;
        current = next.Invoke(current);
      }
    }

public static IEnumerable<replacedem> Flatten<replacedem>(this IEnumerable<replacedem> root,
      Func<replacedem, IEnumerable<replacedem>> childrenExtractor, Action<replacedem> exitAction, bool rootFirst)
    {
      // The validation of arguments is omitted to increase performance.
      foreach (var item in root) {
        var children = childrenExtractor.Invoke(item);
        if(rootFirst)
          yield return item;
        if(children != null)
          foreach (var childItem in children.Flatten(childrenExtractor, exitAction, rootFirst))
            yield return childItem;
        if(!rootFirst)
          yield return item;
        if(exitAction != null)
          exitAction.Invoke(item);
      }
    }

public override void Clear()
    {
      while (deque.Count > 0) {
        var cached = deque.PopBottom();
        var key = cached.Key;
        size -= sizeExtractor(cached.Value);
        if (chainedCache!=null)
          chainedCache.Add(cached.Value, true);
        ItemRemoved(key);
      }
      size = 0;
      Cleared();
    }

public bool Remove(replacedem item)
    {
      if (!set.Remove(item))
        return false;
      list.Remove(item);
      var clreplacedes = Clreplacedifier.Invoke(item);
      foreach (var @clreplaced in clreplacedes) {
        var clreplacedList = clreplacedified[@clreplaced];
        clreplacedList.Remove(item);
        if (clreplacedList.Count==0)
          clreplacedified.Remove(@clreplaced);
      }
      return true;
    }

public void Register(replacedem item)
    {
      GetContainer(flagExtractor(item)).Add(item);
    }

private int[] GetDoneIndices<replacedem>(List<replacedem> items, Func<replacedem, bool> itemDonePredicate)
        {
            var doneIndices = new List<int>();
            for (int i = 0; i < items.Count; i++)
            {
                if (itemDonePredicate(items[i]))
                {
                    doneIndices.Add(i);
                }
            }
            return doneIndices.ToArray();
        }

public static Dictionary<TKey, TValue> IntoDictionary<replacedem, TKey, TValue>(this IEnumerable<replacedem> self, Dictionary<TKey, TValue> target, Func<replacedem, TKey> keySelector, Func<replacedem, TValue> valueSelector)
		{
			foreach (var item in self)
			{
				target[keySelector(item)] = valueSelector(item);
			}

			return target;
		}

public static ImmutableArray<TResult> SelectAsArray<replacedem, TResult>(this ImmutableArray<replacedem> array, Func<replacedem, bool> predicate, Func<replacedem, TResult> selector)
        {
            if (array.Length == 0)
            {
                return ImmutableArray<TResult>.Empty;
            }

            var builder = ArrayBuilder<TResult>.GetInstance();
            foreach (var item in array)
            {
                if (predicate(item))
                {
                    builder.Add(selector(item));
                }
            }

            return builder.ToImmutableAndFree();
        }

public static ImmutableArray<TResult> SelectAsArray<replacedem, TResult>(this ArrayBuilder<replacedem> items, Func<replacedem, TResult> map)
        {
            switch (items.Count)
            {
                case 0:
                    return ImmutableArray<TResult>.Empty;

                case 1:
                    return ImmutableArray.Create(map(items[0]));

                case 2:
                    return ImmutableArray.Create(map(items[0]), map(items[1]));

                case 3:
                    return ImmutableArray.Create(map(items[0]), map(items[1]), map(items[2]));

                case 4:
                    return ImmutableArray.Create(map(items[0]), map(items[1]), map(items[2]), map(items[3]));

                default:
                    var builder = ArrayBuilder<TResult>.GetInstance(items.Count);
                    foreach (var item in items)
                    {
                        builder.Add(map(item));
                    }

                    return builder.ToImmutableAndFree();
            }
        }

protected override TKey GetKeyForItem(replacedem item)
        {
            return _keyDelegate(item);
        }

private static void VerifySorted<TList, replacedem, TKey>(
            TList items, 
            Func<replacedem, TKey> keyGet,
            Func<int, TKey> oracleGet,
            Func<TKey, bool> oracleContains,
            IComparer<TKey> comparer) where TList : IList<replacedem>
        {
            TKey previous = keyGet(items[0]);

            for (int i = 0; i < items.Count; ++i)
            {
                TKey current = keyGet(items[i]);
                TKey oracle = oracleGet(i);

                replacedert.True(comparer.Compare(previous, current) <= 0, $"Expect: {previous} <= {current}");
                replacedert.True(comparer.Compare(previous, oracle) <= 0, $"Expect: {previous} <= {oracle}");
                replacedert.True(comparer.Compare(current, oracle) == 0, $"Expect: {current} == {oracle}");

                // FlatBuffers c# has a bug where binary search is broken when using default values.
                // replacedert.True(oracleContains(current));
            }
        }

public static TReturn FirstValue<replacedem, TReturn>(this IEnumerable<replacedem> enumerable, Func<replacedem, TReturn> func)
            where TReturn : clreplaced
        {
            foreach (replacedem item in enumerable)
            {
                TReturn @object = func(item);
                if (@object != null) return @object;
            }

            return null;
        }

private void AddSelecreplacedemFromValue(TValue value)
        {
            var item = Items.FirstOrDefault(e => EqualityComparer<TValue>.Default.Equals(ConvertExpression(e), value));
            if (item != null)
            {
                selectedItems.Add(item);
            }
        }

private void SetDefaultExpanded(IList<replacedem> items)
        {
            foreach (var item in items)
            {
                if (!IsExpanded(item) && DefaultExpanded(item))
                {
                    expandedItems.Add(item);
                }

                SetDefaultExpanded(ChildSelector(item));
            }
        }

private string GetSelectedText(replacedem item)
        {
            if (SelectedTextExpression == null) return item.ToString();
            return SelectedTextExpression.Invoke(item);
        }

private bool IsDisabled(replacedem item)
        {
            return DisabledExpression != null ? DisabledExpression(item) : false;
        }

private TValue GetValue(replacedem item)
        {
            return ConvertExpression.Invoke(item);
        }

private bool IsHighlighted(replacedem item)
        {
            if (highlighted == null) { return false; }

            if (IdExpression != null)
            {
                return IdExpression.Invoke(highlighted) == IdExpression.Invoke(item);
            }

            return highlighted.Equals(item);
        }

private bool IsSelected(replacedem item)
        {
            if (IdExpression != null)
            {
                return selectedItems.FirstOrDefault(e => IdExpression.Invoke(e) == IdExpression.Invoke(item)) != null;
            }

            return selectedItems.Contains(item);
        }

private void PopulateItemList()
        {
            itemList = new List<Lisreplacedem<replacedem, TValue>>();

            if (Items != null)
            {
                foreach (var item in Items)
                {
                    var lisreplacedem = new Lisreplacedem<replacedem, TValue>
                    {
                        Text = GetText(item),
                        Value = GetValue(item),
                        Item = item
                    };

                    if (DisabledExpression != null)
                    {
                        lisreplacedem.Disabled = DisabledExpression(item);
                    }

                    itemList.Add(lisreplacedem);
                }
            }

        }

protected TValue GetValue(replacedem item)
        {
            if (ConvertExpression == null) return default;

            return ConvertExpression.Invoke(item);
        }