anchor.diff:      PaintHolder<PieChartData> holder,
     ) {
       final data = holder.data;
  -    final shouldDrawSeparators =
  -        data.sectionsSpace != 0 && data.sections.length > 1;
  -
       final viewSize = canvasWrapper.size;
  -
  -    if (shouldDrawSeparators) {
  -      canvasWrapper.saveLayer(
  -          Rect.fromLTWH(0, 0, viewSize.width, viewSize.height), Paint());
  -    }
   
       final center = Offset(viewSize.width / 2, viewSize.height / 2);
   
  
positive.code:         return;
        }
  
        final startRadians = radians(tempAngle);
        final sweepRadians = radians(sectionDegree);
        final endRadians = startRadians + sweepRadians;
  
        final startLineDirection =
            Offset(math.cos(startRadians), math.sin(startRadians));
        final startLineFrom = center + startLineDirection * centerRadius;
        final startLineTo = startLineFrom + startLineDirection * section.radius;
        final startLine = Line(startLineFrom, startLineTo);
  
        final endLineDirection =
            Offset(math.cos(endRadians), math.sin(endRadians));
        final endLineFrom = center + endLineDirection * centerRadius;
        final endLineTo = endLineFrom + endLineDirection * section.radius;
        final endLine = Line(endLineFrom, endLineTo);
  
        final sectionPath = _generateSectionPath(startLine, endLine, startRadians,
            endRadians, sectionRadiusRect, centerRadiusRect);
  
        _sectionPaint.color = section.color;
        _sectionPaint.style = PaintingStyle.fill;
        canvasWrapper.drawPath(sectionPath, _sectionPaint);
  
        if (section.borderSide.width != 0.0 &&
            section.borderSide.color.opacity != 0.0) {
          canvasWrapper.saveLayer(
              Rect.fromLTWH(0, 0, viewSize.width, viewSize.height), Paint());
          canvasWrapper.clipPath(sectionPath);
  
          _sectionStrokePaint.strokeWidth = section.borderSide.width * 2;
          _sectionStrokePaint.color = section.borderSide.color;
          canvasWrapper.drawPath(
            sectionPath,
            _sectionStrokePaint,
          );
          canvasWrapper.restore();
        }
        tempAngle += sectionDegree;
      }
  
      if (shouldDrawSeparators) {
        _removeSectionsSpace(canvasWrapper, holder, centerRadius);
      }
    }
  
    /// Generates a path around a section
    Path _generateSectionPath(
      Line startLine,
      Line endLine,
      double startRadians,
      double endRadians,
      Rect sectionRadiusRect,
      Rect centerRadiusRect,
    ) {
      final sweepRadians = endRadians - startRadians;
      return Path()
        ..moveTo(startLine.from.dx, startLine.from.dy)
        ..lineTo(startLine.to.dx, startLine.to.dy)
        ..arcTo(sectionRadiusRect, startRadians, sweepRadians, false)
  
negative.code:       ..arcTo(centerRadiusRect, endRadians, -sweepRadians, false)
        ..moveTo(startLine.from.dx, startLine.from.dy)
        ..close();
  
      /// Subtract section space from the sectionPath
      if (sectionSpace != 0) {
        final startLineSeparatorPath = _createRectPathAroundLine(
            Line(startLineFrom, startLineTo), sectionSpace);
        sectionPath = Path.combine(
            PathOperation.difference, sectionPath, startLineSeparatorPath);
  
        final endLineSeparatorPath =
            _createRectPathAroundLine(Line(endLineFrom, endLineTo), sectionSpace);
        sectionPath = Path.combine(
            PathOperation.difference, sectionPath, endLineSeparatorPath);
      }
  
      return sectionPath;
    }
  
    /// Creates a rect around a narrow line
    Path _createRectPathAroundLine(Line line, double width) {
      width = width / 2;
      final normalized = line.normalize();
  
      final verticalAngle = line.direction() + (math.pi / 2);
      final verticalDirection =
          Offset(math.cos(verticalAngle), math.sin(verticalAngle));
  
      final startPoint1 = Offset(
        line.from.dx -
            (normalized * (width / 2)).dx -
            (verticalDirection * width).dx,
        line.from.dy -
            (normalized * (width / 2)).dy -
            (verticalDirection * width).dy,
      );
  
      final startPoint2 = Offset(
        line.to.dx +
            (normalized * (width / 2)).dx -
            (verticalDirection * width).dx,
        line.to.dy +
            (normalized * (width / 2)).dy -
            (verticalDirection * width).dy,
      );
  
      final startPoint3 = Offset(
        startPoint2.dx + (verticalDirection * (width * 2)).dx,
        startPoint2.dy + (verticalDirection * (width * 2)).dy,
      );
  
      final startPoint4 = Offset(
        startPoint1.dx + (verticalDirection * (width * 2)).dx,
        startPoint1.dy + (verticalDirection * (width * 2)).dy,
      );
  
      return Path()
        ..moveTo(startPoint1.dx, startPoint1.dy)
        ..lineTo(startPoint2.dx, startPoint2.dy)
        ..lineTo(startPoint3.dx, startPoint3.dy)
        ..lineTo(startPoint4.dx, startPoint4.dy)
        ..lineTo(startPoint1.dx, startPoint1.dy);
    }
  
    void _drawSection(PieChartSectionData section, Path sectionPath,
        CanvasWrapper canvasWrapper) {
      _sectionPaint.color = section.color;
      _sectionPaint.style = PaintingStyle.fill;
      canvasWrapper.drawPath(sectionPath, _sectionPaint);
    }
  
    void _drawSectionStroke(PieChartSectionData section, Path sectionPath,
        CanvasWrapper canvasWrapper, Size viewSize) {
      if (section.borderSide.width != 0.0 &&
          section.borderSide.color.opacity != 0.0) {
        canvasWrapper.saveLayer(
            Rect.fromLTWH(0, 0, viewSize.width, viewSize.height), Paint());
        canvasWrapper.clipPath(sectionPath);
  
        _sectionStrokePaint.strokeWidth = section.borderSide.width * 2;
        _sectionStrokePaint.color = section.borderSide.color;
        canvasWrapper.drawPath(
          sectionPath,
          _sectionStrokePaint,
        );
        canvasWrapper.restore();
      }
    }
  
    /// Calculates layout of overlaying elements, includes:
  