diff --git a/shiny/iconvg/buffer.go b/shiny/iconvg/buffer.go
index fe5f44c..5bdad2a 100644
--- a/shiny/iconvg/buffer.go
+++ b/shiny/iconvg/buffer.go
@@ -191,6 +191,13 @@
 	return 4
 }
 
+func (b *buffer) encodeAngle(f float32) int {
+	// Normalize f to the range [0, 1).
+	g := float64(f)
+	g -= math.Floor(g)
+	return b.encodeZeroToOne(float32(g))
+}
+
 func (b *buffer) encodeZeroToOne(f float32) int {
 	if u := uint32(f * 15120); float32(u) == f*15120 && u < 15120 {
 		if u%126 == 0 {
diff --git a/shiny/iconvg/decode.go b/shiny/iconvg/decode.go
index e245e63..b5bb381 100644
--- a/shiny/iconvg/decode.go
+++ b/shiny/iconvg/decode.go
@@ -485,9 +485,30 @@
 			if p != nil && i != 0 {
 				p(nil, "%s, implicit\n", op)
 			}
-			src, err = decodeCoordinates(coords[:nCoords], p, src)
-			if err != nil {
-				return nil, nil, err
+			var largeArc, sweep bool
+			if op[0] != 'A' && op[0] != 'a' {
+				src, err = decodeCoordinates(coords[:nCoords], p, src)
+				if err != nil {
+					return nil, nil, err
+				}
+			} else {
+				// We have an absolute or relative arcTo.
+				src, err = decodeCoordinates(coords[:2], p, src)
+				if err != nil {
+					return nil, nil, err
+				}
+				coords[2], src, err = decodeAngle(p, src)
+				if err != nil {
+					return nil, nil, err
+				}
+				largeArc, sweep, src, err = decodeArcToFlags(p, src)
+				if err != nil {
+					return nil, nil, err
+				}
+				src, err = decodeCoordinates(coords[4:6], p, src)
+				if err != nil {
+					return nil, nil, err
+				}
 			}
 
 			if dst == nil {
@@ -496,54 +517,27 @@
 			switch op[0] {
 			case 'L':
 				dst.AbsLineTo(coords[0], coords[1])
-				continue
 			case 'l':
 				dst.RelLineTo(coords[0], coords[1])
-				continue
 			case 'T':
 				dst.AbsSmoothQuadTo(coords[0], coords[1])
-				continue
 			case 't':
 				dst.RelSmoothQuadTo(coords[0], coords[1])
-				continue
 			case 'Q':
 				dst.AbsQuadTo(coords[0], coords[1], coords[2], coords[3])
-				continue
 			case 'q':
 				dst.RelQuadTo(coords[0], coords[1], coords[2], coords[3])
-				continue
 			case 'S':
 				dst.AbsSmoothCubeTo(coords[0], coords[1], coords[2], coords[3])
-				continue
 			case 's':
 				dst.RelSmoothCubeTo(coords[0], coords[1], coords[2], coords[3])
-				continue
 			case 'C':
 				dst.AbsCubeTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5])
-				continue
 			case 'c':
 				dst.RelCubeTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5])
-				continue
-			}
-
-			// We have an absolute or relative arcTo.
-			src, err = decodeCoordinates(coords[:3], p, src)
-			if err != nil {
-				return nil, nil, err
-			}
-			var largeArc, sweep bool
-			largeArc, sweep, src, err = decodeArcToFlags(p, src)
-			if err != nil {
-				return nil, nil, err
-			}
-			src, err = decodeCoordinates(coords[4:6], p, src)
-			if err != nil {
-				return nil, nil, err
-			}
-
-			if op[0] == 'A' {
+			case 'A':
 				dst.AbsArcTo(coords[0], coords[1], coords[2], largeArc, sweep, coords[4], coords[5])
-			} else {
+			case 'a':
 				dst.RelArcTo(coords[0], coords[1], coords[2], largeArc, sweep, coords[4], coords[5])
 			}
 		}
@@ -665,6 +659,17 @@
 	return src, nil
 }
 
+func decodeAngle(p printer, src buffer) (float32, buffer, error) {
+	x, n := src.decodeZeroToOne()
+	if n == 0 {
+		return 0, nil, errInvalidNumber
+	}
+	if p != nil {
+		p(src[:n], "    %v × 360 degrees (%v degrees)\n", x, x*360)
+	}
+	return x, src[n:], nil
+}
+
 func decodeArcToFlags(p printer, src buffer) (bool, bool, buffer, error) {
 	x, n := src.decodeNatural()
 	if n == 0 {
diff --git a/shiny/iconvg/decode_test.go b/shiny/iconvg/decode_test.go
index 71ee314..26b780b 100644
--- a/shiny/iconvg/decode_test.go
+++ b/shiny/iconvg/decode_test.go
@@ -132,6 +132,7 @@
 }{
 	{"testdata/action-info.lores", ""},
 	{"testdata/action-info.hires", ""},
+	{"testdata/arcs", ""},
 	{"testdata/blank", ""},
 	{"testdata/lod-polygon", ";64"},
 	{"testdata/video-005.primitive", ""},
diff --git a/shiny/iconvg/encode.go b/shiny/iconvg/encode.go
index 9b1bb88..9e00bfd 100644
--- a/shiny/iconvg/encode.go
+++ b/shiny/iconvg/encode.go
@@ -145,39 +145,37 @@
 	return e.lod0, e.lod1
 }
 
-func (e *Encoder) SetCSel(cSel uint8) {
-	if e.err != nil {
+func (e *Encoder) checkModeStyling() {
+	if e.mode == modeStyling {
 		return
 	}
-	if e.mode != modeStyling {
-		if e.mode == modeInitial {
-			e.appendDefaultMetadata()
-		} else {
-			e.err = errStylingOpsUsedInDrawingMode
-			return
-		}
+	if e.mode == modeInitial {
+		e.appendDefaultMetadata()
+		return
+	}
+	e.err = errStylingOpsUsedInDrawingMode
+}
+
+func (e *Encoder) SetCSel(cSel uint8) {
+	e.checkModeStyling()
+	if e.err != nil {
+		return
 	}
 	e.cSel = cSel & 0x3f
 	e.buf = append(e.buf, e.cSel)
 }
 
 func (e *Encoder) SetNSel(nSel uint8) {
+	e.checkModeStyling()
 	if e.err != nil {
 		return
 	}
-	if e.mode != modeStyling {
-		if e.mode == modeInitial {
-			e.appendDefaultMetadata()
-		} else {
-			e.err = errStylingOpsUsedInDrawingMode
-			return
-		}
-	}
 	e.nSel = nSel & 0x3f
 	e.buf = append(e.buf, e.nSel|0x40)
 }
 
 func (e *Encoder) SetCReg(adj uint8, incr bool, c Color) {
+	e.checkModeStyling()
 	if e.err != nil {
 		return
 	}
@@ -216,6 +214,7 @@
 }
 
 func (e *Encoder) SetNReg(adj uint8, incr bool, f float32) {
+	e.checkModeStyling()
 	if e.err != nil {
 		return
 	}
@@ -249,17 +248,10 @@
 }
 
 func (e *Encoder) SetLOD(lod0, lod1 float32) {
+	e.checkModeStyling()
 	if e.err != nil {
 		return
 	}
-	if e.mode != modeStyling {
-		if e.mode == modeInitial {
-			e.appendDefaultMetadata()
-		} else {
-			e.err = errStylingOpsUsedInDrawingMode
-			return
-		}
-	}
 	e.lod0 = lod0
 	e.lod1 = lod1
 	e.buf = append(e.buf, 0xc7)
@@ -268,17 +260,10 @@
 }
 
 func (e *Encoder) StartPath(adj uint8, x, y float32) {
+	e.checkModeStyling()
 	if e.err != nil {
 		return
 	}
-	if e.mode != modeStyling {
-		if e.mode == modeInitial {
-			e.appendDefaultMetadata()
-		} else {
-			e.err = errStylingOpsUsedInDrawingMode
-			return
-		}
-	}
 	if adj < 0 || 6 < adj {
 		e.err = errInvalidSelectorAdjustment
 		return
@@ -389,7 +374,7 @@
 				for j := m; j > 0; j-- {
 					e.buf.encodeCoordinate(e.quantize(e.drawArgs[i+0]))
 					e.buf.encodeCoordinate(e.quantize(e.drawArgs[i+1]))
-					e.buf.encodeZeroToOne(e.drawArgs[i+2])
+					e.buf.encodeAngle(e.drawArgs[i+2])
 					e.buf.encodeNatural(uint32(e.drawArgs[i+3]))
 					e.buf.encodeCoordinate(e.quantize(e.drawArgs[i+4]))
 					e.buf.encodeCoordinate(e.quantize(e.drawArgs[i+5]))
diff --git a/shiny/iconvg/encode_test.go b/shiny/iconvg/encode_test.go
index 7d28cdd..6b1bdf9 100644
--- a/shiny/iconvg/encode_test.go
+++ b/shiny/iconvg/encode_test.go
@@ -86,6 +86,49 @@
 	}
 }
 
+func TestEncodeArcs(t *testing.T) {
+	var e Encoder
+
+	e.SetCReg(1, false, RGBAColor(color.RGBA{0xff, 0x00, 0x00, 0xff}))
+	e.SetCReg(2, false, RGBAColor(color.RGBA{0xff, 0xff, 0x00, 0xff}))
+	e.SetCReg(3, false, RGBAColor(color.RGBA{0x00, 0x00, 0x00, 0xff}))
+	e.SetCReg(4, false, RGBAColor(color.RGBA{0x00, 0x00, 0x80, 0xff}))
+
+	e.StartPath(1, -10, 0)
+	e.RelHLineTo(-15)
+	e.RelArcTo(15, 15, 0, true, false, 15, -15)
+	e.ClosePathEndPath()
+
+	e.StartPath(2, -14, -4)
+	e.RelVLineTo(-15)
+	e.RelArcTo(15, 15, 0, false, false, -15, 15)
+	e.ClosePathEndPath()
+
+	const thirtyDegrees = 30.0 / 360
+	e.StartPath(3, -15, 30)
+	e.RelLineTo(5.0, -2.5)
+	e.RelArcTo(2.5, 2.5, -thirtyDegrees, false, true, 5.0, -2.5)
+	e.RelLineTo(5.0, -2.5)
+	e.RelArcTo(2.5, 5.0, -thirtyDegrees, false, true, 5.0, -2.5)
+	e.RelLineTo(5.0, -2.5)
+	e.RelArcTo(2.5, 7.5, -thirtyDegrees, false, true, 5.0, -2.5)
+	e.RelLineTo(5.0, -2.5)
+	e.RelArcTo(2.5, 10.0, -thirtyDegrees, false, true, 5.0, -2.5)
+	e.RelLineTo(5.0, -2.5)
+	e.AbsVLineTo(30)
+	e.ClosePathEndPath()
+
+	for largeArc := 0; largeArc <= 1; largeArc++ {
+		for sweep := 0; sweep <= 1; sweep++ {
+			e.StartPath(4, 10+8*float32(sweep), -28+8*float32(largeArc))
+			e.RelArcTo(6, 3, 0, largeArc != 0, sweep != 0, 6, 3)
+			e.ClosePathEndPath()
+		}
+	}
+
+	testEncode(t, &e, "testdata/arcs.ivg")
+}
+
 var video005PrimitiveSVGData = []struct {
 	r, g, b uint32
 	x0, y0  int
diff --git a/shiny/iconvg/rasterizer.go b/shiny/iconvg/rasterizer.go
index ce3c95d..30f79c0 100644
--- a/shiny/iconvg/rasterizer.go
+++ b/shiny/iconvg/rasterizer.go
@@ -8,6 +8,7 @@
 	"image"
 	"image/color"
 	"image/draw"
+	"math"
 
 	"golang.org/x/image/math/f32"
 	"golang.org/x/image/vector"
@@ -120,6 +121,9 @@
 	z.lod0, z.lod1 = lod0, lod1
 }
 
+func (z *Rasterizer) unabsX(x float32) float32 { return x/z.scaleX - z.biasX }
+func (z *Rasterizer) unabsY(y float32) float32 { return y/z.scaleY - z.biasY }
+
 func (z *Rasterizer) absX(x float32) float32 { return z.scaleX * (x + z.biasX) }
 func (z *Rasterizer) absY(y float32) float32 { return z.scaleY * (y + z.biasY) }
 func (z *Rasterizer) relX(x float32) float32 { return z.scaleX * x }
@@ -335,13 +339,165 @@
 		return
 	}
 	z.prevSmoothType = smoothTypeNone
-	// TODO: implement.
+
+	// We follow the "Conversion from endpoint to center parameterization"
+	// algorithm as per
+	// https://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
+
+	// There seems to be a bug in the spec's "implementation notes".
+	//
+	// Actual implementations, such as
+	//	- https://git.gnome.org/browse/librsvg/tree/rsvg-path.c
+	//	- http://svn.apache.org/repos/asf/xmlgraphics/batik/branches/svg11/sources/org/apache/batik/ext/awt/geom/ExtendedGeneralPath.java
+	//	- https://java.net/projects/svgsalamander/sources/svn/content/trunk/svg-core/src/main/java/com/kitfox/svg/pathcmd/Arc.java
+	//	- https://github.com/millermedeiros/SVGParser/blob/master/com/millermedeiros/geom/SVGArc.as
+	// do something slightly different (marked with a †).
+
+	// (†) The Abs isn't part of the spec. Neither is checking that Rx and Ry
+	// are non-zero (and non-NaN).
+	Rx := math.Abs(float64(rx))
+	Ry := math.Abs(float64(ry))
+	if !(Rx > 0 && Ry > 0) {
+		z.z.LineTo(f32.Vec2{x, y})
+		return
+	}
+
+	// We work in IconVG coordinates (e.g. from -32 to +32 by default), rather
+	// than destination image coordinates (e.g. the width of the dst image),
+	// since the rx and ry radii also need to be scaled, but their scaling
+	// factors can be different, and aren't trivial to calculate due to
+	// xAxisRotation.
+	//
+	// We convert back to destination image coordinates via absX and absY calls
+	// later, during arcSegmentTo.
+	pen := z.z.Pen()
+	x1 := float64(z.unabsX(pen[0]))
+	y1 := float64(z.unabsY(pen[1]))
+	x2 := float64(z.unabsX(x))
+	y2 := float64(z.unabsY(y))
+
+	phi := 2 * math.Pi * float64(xAxisRotation)
+
+	// Step 1: Compute (x1′, y1′)
+	halfDx := (x1 - x2) / 2
+	halfDy := (y1 - y2) / 2
+	cosPhi := math.Cos(phi)
+	sinPhi := math.Sin(phi)
+	x1Prime := +cosPhi*halfDx + sinPhi*halfDy
+	y1Prime := -sinPhi*halfDx + cosPhi*halfDy
+
+	// Step 2: Compute (cx′, cy′)
+	rxSq := Rx * Rx
+	rySq := Ry * Ry
+	x1PrimeSq := x1Prime * x1Prime
+	y1PrimeSq := y1Prime * y1Prime
+
+	// (†) Check that the radii are large enough.
+	radiiCheck := x1PrimeSq/rxSq + y1PrimeSq/rySq
+	if radiiCheck > 1 {
+		c := math.Sqrt(radiiCheck)
+		Rx *= c
+		Ry *= c
+		rxSq = Rx * Rx
+		rySq = Ry * Ry
+	}
+
+	denom := rxSq*y1PrimeSq + rySq*x1PrimeSq
+	step2 := 0.0
+	if a := rxSq*rySq/denom - 1; a > 0 {
+		step2 = math.Sqrt(a)
+	}
+	if largeArc == sweep {
+		step2 = -step2
+	}
+	cxPrime := +step2 * Rx * y1Prime / Ry
+	cyPrime := -step2 * Ry * x1Prime / Rx
+
+	// Step 3: Compute (cx, cy) from (cx′, cy′)
+	cx := +cosPhi*cxPrime - sinPhi*cyPrime + (x1+x2)/2
+	cy := +sinPhi*cxPrime + cosPhi*cyPrime + (y1+y2)/2
+
+	// Step 4: Compute θ1 and Δθ
+	ax := (+x1Prime - cxPrime) / Rx
+	ay := (+y1Prime - cyPrime) / Ry
+	bx := (-x1Prime - cxPrime) / Rx
+	by := (-y1Prime - cyPrime) / Ry
+	theta1 := angle(1, 0, ax, ay)
+	deltaTheta := angle(ax, ay, bx, by)
+	if sweep {
+		if deltaTheta < 0 {
+			deltaTheta += 2 * math.Pi
+		}
+	} else {
+		if deltaTheta > 0 {
+			deltaTheta -= 2 * math.Pi
+		}
+	}
+
+	// This ends the
+	// https://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
+	// algorithm. What follows below is specific to this implementation.
+
+	// We approximate an arc by one or more cubic Bézier curves.
+	n := int(math.Ceil(math.Abs(deltaTheta) / (math.Pi/2 + 0.001)))
+	for i := 0; i < n; i++ {
+		z.arcSegmentTo(cx, cy,
+			theta1+deltaTheta*float64(i+0)/float64(n),
+			theta1+deltaTheta*float64(i+1)/float64(n),
+			Rx, Ry, cosPhi, sinPhi,
+		)
+	}
+}
+
+// arcSegmentTo approximates an arc by a cubic Bézier curve. The mathematical
+// formulae for the control points are the same as that used by librsvg.
+func (z *Rasterizer) arcSegmentTo(cx, cy, theta1, theta2, rx, ry, cosPhi, sinPhi float64) {
+	halfDeltaTheta := (theta2 - theta1) * 0.5
+	q := math.Sin(halfDeltaTheta * 0.5)
+	t := (8 * q * q) / (3 * math.Sin(halfDeltaTheta))
+	cos1 := math.Cos(theta1)
+	sin1 := math.Sin(theta1)
+	cos2 := math.Cos(theta2)
+	sin2 := math.Sin(theta2)
+	x1 := rx * (+cos1 - t*sin1)
+	y1 := ry * (+sin1 + t*cos1)
+	x2 := rx * (+cos2 + t*sin2)
+	y2 := ry * (+sin2 - t*cos2)
+	x3 := rx * (+cos2)
+	y3 := ry * (+sin2)
+	z.z.CubeTo(f32.Vec2{
+		z.absX(float32(cx + cosPhi*x1 - sinPhi*y1)),
+		z.absY(float32(cy + sinPhi*x1 + cosPhi*y1)),
+	}, f32.Vec2{
+		z.absX(float32(cx + cosPhi*x2 - sinPhi*y2)),
+		z.absY(float32(cy + sinPhi*x2 + cosPhi*y2)),
+	}, f32.Vec2{
+		z.absX(float32(cx + cosPhi*x3 - sinPhi*y3)),
+		z.absY(float32(cy + sinPhi*x3 + cosPhi*y3)),
+	})
 }
 
 func (z *Rasterizer) RelArcTo(rx, ry, xAxisRotation float32, largeArc, sweep bool, x, y float32) {
-	if z.disabled {
-		return
+	a := z.relVec2(x, y)
+	z.AbsArcTo(rx, ry, xAxisRotation, largeArc, sweep, a[0], a[1])
+}
+
+// angle returns the angle between the u and v vectors.
+func angle(ux, uy, vx, vy float64) float64 {
+	uNorm := math.Sqrt(ux*ux + uy*uy)
+	vNorm := math.Sqrt(vx*vx + vy*vy)
+	norm := uNorm * vNorm
+	cos := (ux*vx + uy*vy) / norm
+	ret := 0.0
+	if cos <= -1 {
+		ret = math.Pi
+	} else if cos >= +1 {
+		ret = 0
+	} else {
+		ret = math.Acos(cos)
 	}
-	z.prevSmoothType = smoothTypeNone
-	// TODO: implement.
+	if ux*vy < uy*vx {
+		return -ret
+	}
+	return +ret
 }
diff --git a/shiny/iconvg/testdata/README b/shiny/iconvg/testdata/README
index 67eb33c..c883fe3 100644
--- a/shiny/iconvg/testdata/README
+++ b/shiny/iconvg/testdata/README
@@ -15,6 +15,15 @@
 
 
 
+arcs.ivg is inspired by the two examples at
+https://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands
+
+arcs.ivg.disassembly is a disassembly of that IconVG file.
+
+arcs.png is a rendering of that IconVG file.
+
+
+
 blank.ivg is a blank, square graphic.
 
 blank.ivg.disassembly is a disassembly of that IconVG file.
diff --git a/shiny/iconvg/testdata/arcs.ivg b/shiny/iconvg/testdata/arcs.ivg
new file mode 100644
index 0000000..f03a704
--- /dev/null
+++ b/shiny/iconvg/testdata/arcs.ivg
Binary files differ
diff --git a/shiny/iconvg/testdata/arcs.ivg.disassembly b/shiny/iconvg/testdata/arcs.ivg.disassembly
new file mode 100644
index 0000000..1c2eb05
--- /dev/null
+++ b/shiny/iconvg/testdata/arcs.ivg.disassembly
@@ -0,0 +1,129 @@
+89 49 56 47   IconVG Magic identifier
+00            Number of metadata chunks: 0
+81            Set CREG[CSEL-1] to a 1 byte color
+64                RGBA ff0000ff
+82            Set CREG[CSEL-2] to a 1 byte color
+78                RGBA ffff00ff
+83            Set CREG[CSEL-3] to a 1 byte color
+00                RGBA 000000ff
+84            Set CREG[CSEL-4] to a 1 byte color
+02                RGBA 000080ff
+c1            Start path, filled with CREG[CSEL-1]; M (absolute moveTo)
+6c                -10
+80                +0
+e7            h (relative horizontal lineTo)
+62                -15
+d0            a (relative arcTo), 1 reps
+9e                +15
+9e                +15
+00                0 × 360 degrees (0 degrees)
+02                0x1 (largeArc=1, sweep=0)
+9e                +15
+62                -15
+e1            z (closePath); end path
+c2            Start path, filled with CREG[CSEL-2]; M (absolute moveTo)
+64                -14
+78                -4
+e9            v (relative vertical lineTo)
+62                -15
+d0            a (relative arcTo), 1 reps
+9e                +15
+9e                +15
+00                0 × 360 degrees (0 degrees)
+00                0x0 (largeArc=0, sweep=0)
+62                -15
+9e                +15
+e1            z (closePath); end path
+c3            Start path, filled with CREG[CSEL-3]; M (absolute moveTo)
+62                -15
+bc                +30
+20            l (relative lineTo), 1 reps
+8a                +5
+81 7d             -2.5
+d0            a (relative arcTo), 1 reps
+81 82             +2.5
+81 82             +2.5
+dc                0.9166667 × 360 degrees (330 degrees)
+04                0x2 (largeArc=0, sweep=1)
+8a                +5
+81 7d             -2.5
+20            l (relative lineTo), 1 reps
+8a                +5
+81 7d             -2.5
+d0            a (relative arcTo), 1 reps
+81 82             +2.5
+8a                +5
+dc                0.9166667 × 360 degrees (330 degrees)
+04                0x2 (largeArc=0, sweep=1)
+8a                +5
+81 7d             -2.5
+20            l (relative lineTo), 1 reps
+8a                +5
+81 7d             -2.5
+d0            a (relative arcTo), 1 reps
+81 82             +2.5
+81 87             +7.5
+dc                0.9166667 × 360 degrees (330 degrees)
+04                0x2 (largeArc=0, sweep=1)
+8a                +5
+81 7d             -2.5
+20            l (relative lineTo), 1 reps
+8a                +5
+81 7d             -2.5
+d0            a (relative arcTo), 1 reps
+81 82             +2.5
+94                +10
+dc                0.9166667 × 360 degrees (330 degrees)
+04                0x2 (largeArc=0, sweep=1)
+8a                +5
+81 7d             -2.5
+20            l (relative lineTo), 1 reps
+8a                +5
+81 7d             -2.5
+e8            V (absolute vertical lineTo)
+bc                +30
+e1            z (closePath); end path
+c4            Start path, filled with CREG[CSEL-4]; M (absolute moveTo)
+94                +10
+48                -28
+d0            a (relative arcTo), 1 reps
+8c                +6
+86                +3
+00                0 × 360 degrees (0 degrees)
+00                0x0 (largeArc=0, sweep=0)
+8c                +6
+86                +3
+e1            z (closePath); end path
+c4            Start path, filled with CREG[CSEL-4]; M (absolute moveTo)
+a4                +18
+48                -28
+d0            a (relative arcTo), 1 reps
+8c                +6
+86                +3
+00                0 × 360 degrees (0 degrees)
+04                0x2 (largeArc=0, sweep=1)
+8c                +6
+86                +3
+e1            z (closePath); end path
+c4            Start path, filled with CREG[CSEL-4]; M (absolute moveTo)
+94                +10
+58                -20
+d0            a (relative arcTo), 1 reps
+8c                +6
+86                +3
+00                0 × 360 degrees (0 degrees)
+02                0x1 (largeArc=1, sweep=0)
+8c                +6
+86                +3
+e1            z (closePath); end path
+c4            Start path, filled with CREG[CSEL-4]; M (absolute moveTo)
+a4                +18
+58                -20
+d0            a (relative arcTo), 1 reps
+8c                +6
+86                +3
+00                0 × 360 degrees (0 degrees)
+06                0x3 (largeArc=1, sweep=1)
+8c                +6
+86                +3
+e1            z (closePath); end path
diff --git a/shiny/iconvg/testdata/arcs.png b/shiny/iconvg/testdata/arcs.png
new file mode 100644
index 0000000..acebcaa
--- /dev/null
+++ b/shiny/iconvg/testdata/arcs.png
Binary files differ