private static CursorPagingRange SliceRange(
        CursorPagingArguments arguments,
        int maxElementCount)
    {
        // [SPEC] if after is set then remove all elements of edges before and including
        // afterEdge.
        //
        // The cursor is increased by one so that the index points to the element after
        var startIndex = arguments.After is { } a
            ? IndexEdge <TEntity> .DeserializeCursor(a) + 1
            : 0;

        // [SPEC] if before is set then remove all elements of edges before and including
        // beforeEdge.
        var before = arguments.Before is { } b
            ? IndexEdge <TEntity> .DeserializeCursor(b)
            : maxElementCount;

        // if after is negative we have know how much of the offset was in the negative range.
        // The amount of positions that are in the negative range, have to be subtracted from
        // the take or we will fetch too many items.
        var startOffsetCorrection = 0;

        if (startIndex < 0)
        {
            startOffsetCorrection = Math.Abs(startIndex);
            startIndex            = 0;
        }

        CursorPagingRange range = new(startIndex, before);

        //[SPEC] If first is less than 0 throw an error
        ValidateFirst(arguments, out var first);

        if (first is not null)
        {
            first -= startOffsetCorrection;
            if (first < 0)
            {
                first = 0;
            }
        }

        //[SPEC] Slice edges to be of length first by removing edges from the end of edges.
        range.Take(first);

        //[SPEC] if last is less than 0 throw an error
        ValidateLast(arguments, out var last);

        //[SPEC] Slice edges to be of length last by removing edges from the start of edges.
        range.TakeLast(last);

        return(range);
    }
        public static ICursorPageSlice <T> SliceAsCursorPage <T>(this IEnumerable <T> items, string?after, int?first, string?before, int?last)
            where T : class
        {
            //Do nothing if there are no results...
            if (!items.Any())
            {
                return(new CursorPageSlice <T>(Enumerable.Empty <ICursorResult <T> >(), 0, false, false));
            }

            var afterIndex = after != null
                ? IndexEdge <string> .DeserializeCursor(after)
                : 0;

            var beforeIndex = before != null
                ? IndexEdge <string> .DeserializeCursor(before)
                : 0;

            //FIRST log the index of all items in the list BEFORE slicing, as these indexes are
            //  the Cursor Indexes for paging up/down the entire list, & ICursorResult is the Decorator
            //  around the Entity Models.

            //NOTE: We MUST materialize this after applying index values to prevent ongoing increments...
            int index = 0;
            IEnumerable <ICursorResult <T> > slice = items
                                                     .Select(c => new CursorResult <T>(c, ++index))
                                                     .ToList();

            int totalCount = slice.Count();

            //If After specified, remove all before After (or skip past After)
            if (afterIndex > 0 && slice.Last().CursorIndex > afterIndex)
            {
                slice = slice.Skip(afterIndex);
            }

            //If Before is specified, remove all after Before (Skip Until Before is reached)
            if (beforeIndex > 0 && slice.Last().CursorIndex > beforeIndex)
            {
                slice = slice.SkipWhile(c => c.CursorIndex < beforeIndex);
            }

            //If First is specified, then take the first/top rows from the current Slice!
            if (first.HasValue && first > 0 && slice.Count() > first)
            {
                slice = slice.Take(first.Value);
            }

            //If First is specified, then take the first/top rows from the current Slice!
            if (last.HasValue && last > 0 && slice.Count() > last)
            {
                slice = slice.TakeLast(last.Value);
            }

            //Wrap all results into a PagedCursor Slice result wit Total Count...
            //NOTE: to ensure our pagination is complete, we materialize the Results!
            var results     = slice.ToList();
            var firstCursor = results.FirstOrDefault();
            var lastCursor  = results.LastOrDefault();

            var cursorPageSlice = new CursorPageSlice <T>(
                results,
                totalCount,
                hasPreviousPage: firstCursor?.CursorIndex > 1,
                hasNextPage: lastCursor?.CursorIndex < totalCount
                );

            return(cursorPageSlice);
        }