                 let transform = isRTL ? CGAffineTransform(scaleX: -1, y: 1).translatedBy(x: -size.width, y: 0) : .identity
                 let path = CGMutablePath()
                 // arrow body
-                path.move(to: endPoint, transform: transform)
-                path.addLine(to: endPoint.offsetBy(dx: -max(size.width - 2 * margin, arrow.width), dy: 0), transform: transform)
+                path.move(to: endPoint)
+                path.addLine(to: endPoint.offsetBy(dx: -max(size.width - 2 * margin, arrow.width), dy: 0))
                 // arrow head
-                path.move(to: endPoint, transform: transform)
-                path.addLine(to: endPoint.offsetBy(dx: -arrow.width, dy: +arrow.height), transform: transform)
-                path.move(to: endPoint, transform: transform)
-                path.addLine(to: endPoint.offsetBy(dx: -arrow.width, dy: -arrow.height), transform: transform)
+                path.move(to: endPoint)
+                path.addLine(to: endPoint.offsetBy(dx: -arrow.width, dy: +arrow.height))
+                path.move(to: endPoint)
+                path.addLine(to: endPoint.offsetBy(dx: -arrow.width, dy: -arrow.height))
+                return path.copy(strokingWithWidth: lineWidth, lineCap: .round, lineJoin: .miter, miterLimit: 0, transform: transform)
+            
+            case .space:
+                let radius = size.height / 15 + lineWidth
+                let rect = CGRect(x: (size.width - radius) / 2, y: (size.height - radius) / 2, width: radius, height: radius)
+                return CGPath(ellipseIn: rect, transform: nil)
+            
+            case .noBreakSpace:
+                let hat = CGMutablePath()
+                let hatCorner = CGPoint(x: 0.5 * size.width, y: 0.05 * size.height)
+                hat.addLines(between: [
+                    hatCorner.offsetBy(dx: -0.15 * size.height, dy: 0.18 * size.height),
+                    hatCorner,
+                    hatCorner.offsetBy(dx: 0.15 * size.height, dy: 0.18 * size.height),
+                ])
+                let path = CGMutablePath()
+                path.addPath(hat.copy(strokingWithWidth: lineWidth, lineCap: .round, lineJoin: .round, miterLimit: 0))
+                path.addPath(Self.space.path(in: size, lineWidth: lineWidth))
                 return path
             
-            case .space:
-                let radius = size.height / 15
-                let rect = CGRect(x: size.width / 2, y: size.height / 2, width: 0, height: 0)
-                let path = CGMutablePath()
-                path.addEllipse(in: rect.insetBy(dx: -radius, dy: -radius))
-                // draw a zero size dot to fill in the center
-                path.addEllipse(in: rect)
-                return path
-            
-            case .noBreakSpace:
-                let path = CGMutablePath()
-                let hatCorner = CGPoint(x: 0.5 * size.width, y: 0.05 * size.height)
-                path.move(to: hatCorner)
-                path.addLine(to: hatCorner.offsetBy(dx: -0.15 * size.height, dy: 0.18 * size.height))
-                path.move(to: hatCorner)
-                path.addLine(to: hatCorner.offsetBy(dx: 0.15 * size.height, dy: 0.18 * size.height))
-                path.addPath(Self.space.path(in: size))
-                return path
-            
             case .fullwidthSpace:
-                let length = 0.95 * min(size.width, size.height)
+                let length = 0.95 * min(size.width, size.height) - lineWidth
                 let radius = 0.1 * length
                 let rect = CGRect(x: (size.width - length) / 2, y: (size.height - length) / 2, width: length, height: length)
                 return CGPath(roundedRect: rect, cornerWidth: radius, cornerHeight: radius, transform: nil)
+                    .copy(strokingWithWidth: lineWidth, lineCap: .butt, lineJoin: .miter, miterLimit: 0)
             
             case .otherWhitespace:
                 let path = CGMutablePath()

                let rect = CGRect(origin: .zero, size: size).insetBy(dx: 0.1 * size.width, dy: 0)
                let radius = 0.1 * size.width
                path.addRoundedRect(in: rect, cornerWidth: radius, cornerHeight: radius)
                return path
        }
    }
    

                    CGPoint(x: 0.2 * size.width, y: 0.8 * size.height),
                    CGPoint(x: 0.8 * size.width, y: 0.8 * size.height),
                ])
                return path.copy(strokingWithWidth: lineWidth, lineCap: .round, lineJoin: .miter, miterLimit: 0)
                
            case .otherControl:
                let question = CGMutablePath()  // `?` mark in unit size
