private static ImageFormat ToSystemImageFormat(PdfRendererImageFormat pdfRendererImageFormat)
        {
            switch (pdfRendererImageFormat)
            {
            case PdfRendererImageFormat.Bmp:
                return(ImageFormat.Bmp);

            case PdfRendererImageFormat.Gif:
                return(ImageFormat.Gif);

            case PdfRendererImageFormat.Jpeg:
                return(ImageFormat.Jpeg);

            case PdfRendererImageFormat.Png:
            default:
                return(ImageFormat.Png);

            case PdfRendererImageFormat.Tiff:
                return(ImageFormat.Tiff);
            }
        }
        /// <summary>
        /// <inheritdoc/>
        /// </summary>
        /// <param name="page"></param>
        /// <param name="pageScale"></param>
        /// <param name="imageFormat"></param>
        /// <returns></returns>
        public byte[] Render(Page page, double pageScale, PdfRendererImageFormat imageFormat = PdfRendererImageFormat.Png)
        {
            using (var ms = new MemoryStream())
                using (var bitmap = new Bitmap((int)Math.Ceiling(page.Width * pageScale), (int)Math.Ceiling(page.Height * pageScale), PixelFormat.Format32bppRgb))
                    using (var currentGraphics = Graphics.FromImage(bitmap))
                    {
                        //bitmap.SetResolution(300, 300);
                        currentGraphics.SmoothingMode      = SmoothingMode.HighQuality;
                        currentGraphics.CompositingQuality = CompositingQuality.HighQuality;
                        currentGraphics.InterpolationMode  = InterpolationMode.HighQualityBicubic;
                        currentGraphics.PixelOffsetMode    = PixelOffsetMode.HighQuality;
                        currentGraphics.Clear(Color.White);

                        // flip transform
                        currentGraphics.Transform = GetInitialMatrix(page.Rotation.Value, page.CropBox);
                        currentGraphics.TranslateTransform(0, -(float)page.Height, MatrixOrder.Append);
                        currentGraphics.ScaleTransform((float)pageScale, -(float)pageScale, MatrixOrder.Append);

                        foreach (var image in page.GetImages())
                        {
                            DrawImage(image, currentGraphics);
                        }

                        foreach (var path in page.ExperimentalAccess.Paths)
                        {
                            GraphicsPath gp = new GraphicsPath();
                            foreach (var subpath in path)
                            {
                                foreach (var command in subpath.Commands)
                                {
                                    if (command is Move)
                                    {
                                        gp.StartFigure();
                                    }
                                    else if (command is Line line)
                                    {
                                        gp.AddLine((float)line.From.X, (float)line.From.Y, (float)line.To.X, (float)line.To.Y);
                                    }
                                    else if (command is BezierCurve curve)
                                    {
                                        gp.AddBezier((float)curve.StartPoint.X, (float)curve.StartPoint.Y,
                                                     (float)curve.FirstControlPoint.X, (float)curve.FirstControlPoint.Y,
                                                     (float)curve.SecondControlPoint.X, (float)curve.SecondControlPoint.Y,
                                                     (float)curve.EndPoint.X, (float)curve.EndPoint.Y);
                                    }
                                    else if (command is Close)
                                    {
                                        gp.CloseFigure();
                                    }
                                    else
                                    {
                                        throw new ArgumentException();
                                    }
                                }
                            }

                            if (path.IsFilled)
                            {
                                gp.FillMode = ToSystemFillMode(path.FillingRule);
#pragma warning disable IDE0063 // Use simple 'using' statement
                                using (var brush = new SolidBrush(ToSystemColor(path.FillColor)))
#pragma warning restore IDE0063 // Use simple 'using' statement
                                {
                                    currentGraphics.FillPath(brush, gp);
                                }
                            }

                            if (path.IsStroked)
                            {
                                try
                                {
#pragma warning disable IDE0063 // Use simple 'using' statement
                                    using (var pen = new Pen(ToSystemColor(path.StrokeColor)))
#pragma warning restore IDE0063 // Use simple 'using' statement
                                    {
                                        currentGraphics.DrawPath(pen, gp);
                                    }
                                }
                                catch (OutOfMemoryException)
                                {
                                    //you will get an OutOfMemoryException if you try to use a LinearGradientBrush to fill a rectangle whose width or height is zero
                                    var bounds = gp.GetBounds();
                                    if (bounds.Width >= 1 && bounds.Height >= 1)
                                    {
                                        throw;
                                    }
                                }
                            }
                        }

                        bitmap.Save(ms, ToSystemImageFormat(imageFormat));
                        return(ms.ToArray());
                    }
        }