anchor.diff:      );
     }
   
  -  Widget _buildCarousel({
  -    required ViewportOffset viewportOffset,
  -    required double itemSize,
  -  }) {
  +  Widget _buildCarousel(double itemSize) {
       return Container(
         height: itemSize,
         margin: widget.padding,
  -      child: Flow(
  -        delegate: CarouselFlowDelegate(
  -          viewportOffset: viewportOffset,
  -          filtersPerScreen: _filtersPerScreen,
  -        ),
  -        children: [
  -          for (int i = 0; i < filterCount; i++)
  -            FilterItem(
  -              onFilterSelected: () => _onFilterTapped(i),
  -              color: itemColor(i),
  -            ),
  -        ],
  +      child: PageView.builder(
  +        controller: _controller,
  +        itemCount: widget.filters.length,
  +        itemBuilder: (context, index) {
  +          return Center(
  +            child: AnimatedBuilder(
  +              animation: _controller,
  +              builder: (context, child) {
  +                if (!_controller.hasClients ||
  +                    !_controller.position.hasContentDimensions) {
  +                  // The PageViewController is not connected to the
  +                  // PageView widget yet. Return an empty box.
  +                  return SizedBox();
  +                }
  +
  +                // The integer index of the current page,
  +                // 0, 1, 2, 3, etc.
  +                final selectedIndex = _controller.page!.roundToDouble();
  +
  +                // The fractional amount that the current filter
  +                // is dragged to the left or right, e.g., 0.25 when
  +                // the current filter is dragged 25% to the left.
  +                final pageScrollAmount = _controller.page! - selectedIndex;
  +
  +                // The page-distance of a filter just before it
  +                // moves off screen.
  +                final maxScrollDistance = _filtersPerScreen / 2;
  +
  +                // The page-distance of this filter item from the
  +                // currently selected filter item.
  +                final pageDistanceFromSelected =
  +                    (selectedIndex - index + pageScrollAmount).abs();
  +
  +                // The percent distance of this filter item from the
  +                // center of the carousel, i.e., where the selector
  +                // ring sits.
  +                final percentFromCenter =
  +                    1.0 - pageDistanceFromSelected / maxScrollDistance;
  +
  +                final itemScale = 0.5 + (percentFromCenter * 0.5);
  +                final opacity = 0.25 + (percentFromCenter * 0.75);
  +
  +                return Transform.scale(
  +                  scale: itemScale,
  +                  child: Opacity(
  +                    opacity: opacity,
  +                    child: FilterItem(
  +                      color: itemColor(index),
  +                      onFilterSelected: () => _onFilterTapped(index),
  +                    ),
  +                  ),
  +                );
  +              },
  +            ),
  +          );
  +        },
         ),
       );
     }
  
positive.code:   }
  }
  
  class CarouselFlowDelegate extends FlowDelegate {
    CarouselFlowDelegate({
      required this.viewportOffset,
      required this.filtersPerScreen,
    }) : super(repaint: viewportOffset);
  
    final ViewportOffset viewportOffset;
    final int filtersPerScreen;
  
    @override
    void paintChildren(FlowPaintingContext context) {
      final count = context.childCount;
  
      // All available painting width
      final size = context.size.width;
  
      // The distance that a single item "page" takes up from the perspective
      // of the scroll paging system. We also use this size for the width and
      // height of a single item.
      final itemExtent = size / filtersPerScreen;
  
      // The current scroll position expressed as an item fraction, e.g., 0.0,
      // or 1.0, or 1.3, or 2.9, etc. A value of 1.3 indicates that item at
      // index 1 is active, and the user has scrolled 30% towards the item at
      // index 2.
      final active = viewportOffset.pixels / itemExtent;
  
      // Index of the first item we need to paint at this moment.
      // At most, we paint 3 items to the left of the active item.
      final min = math.max(0, active.floor() - 3).toInt();
  
      // Index of the last item we need to paint at this moment.
      // At most, we paint 3 items to the right of the active item.
      final max = math.min(count - 1, active.ceil() + 3).toInt();
  
      // Generate transforms for the visible items and sort by distance.
      for (var index = min; index <= max; index++) {
        final itemXFromCenter = itemExtent * index - viewportOffset.pixels;
        final percentFromCenter = 1.0 - (itemXFromCenter / (size / 2)).abs();
        final itemScale = 0.5 + (percentFromCenter * 0.5);
        final opacity = 0.25 + (percentFromCenter * 0.75);
  
        final itemTransform = Matrix4.identity()
          ..translate((size - itemExtent) / 2)
          ..translate(itemXFromCenter)
          ..translate(itemExtent / 2, itemExtent / 2)
          ..multiply(Matrix4.diagonal3Values(itemScale, itemScale, 1.0))
          ..translate(-itemExtent / 2, -itemExtent / 2);
  
        context.paintChild(
          index,
          transform: itemTransform,
          opacity: opacity,
        );
      }
    }
  
    @override
    bool shouldRepaint(covariant CarouselFlowDelegate oldDelegate) {
      return oldDelegate.viewportOffset != viewportOffset;
    }
  }
  
  @immutable
  class FilterItem extends StatelessWidget {
    FilterItem({
  
negative.code: 
    void _onPageChanged() {
      final page = (_controller.page ?? 0).round();
      widget.onFilterChanged(widget.filters[page]);
    }
  
    void _onFilterTapped(int index) {
  