summaryrefslogtreecommitdiff
path: root/src/vector/svg.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/vector/svg.zig')
-rw-r--r--src/vector/svg.zig768
1 files changed, 768 insertions, 0 deletions
diff --git a/src/vector/svg.zig b/src/vector/svg.zig
new file mode 100644
index 0000000..9c0ec53
--- /dev/null
+++ b/src/vector/svg.zig
@@ -0,0 +1,768 @@
+//! SVG to `Drawing`: the static subset that documents (Typst's output in
+//! particular) are made of. Structure: `svg`, `g`, `defs`, `symbol`, `use`.
+//! Shapes: `path` (every command, arcs included), `rect`, `circle`,
+//! `ellipse`, `line`, `polyline`, `polygon`. Styling: presentation
+//! attributes and `style="..."`, inherited as SVG specifies; solid colors,
+//! linear and radial gradients; fill rules; stroke width, caps, joins, miter
+//! limit and dashes; `opacity`, `fill-opacity`, `stroke-opacity`.
+//!
+//! Not supported: text (Typst outlines it), filters, masks, clipping,
+//! patterns, markers, images, CSS stylesheets. Group opacity is approximated
+//! by multiplying it into each shape.
+const std = @import("std");
+const geom = @import("geom.zig");
+const Drawing = @import("Drawing.zig");
+const Vec = geom.Vec;
+const Affine = geom.Affine;
+
+pub const Error = error{ InvalidSvg, OutOfMemory };
+
+/// Parses `source` into a drawing allocated with `arena`.
+pub fn parse(arena: std.mem.Allocator, source: []const u8) Error!Drawing {
+ var doc = try Document.parse(arena, source);
+ const root = doc.root orelse return error.InvalidSvg;
+ if (!std.mem.eql(u8, doc.nodes.items[root].name, "svg")) return error.InvalidSvg;
+
+ var p: Parser = .{ .doc = &doc, .b = .init(arena), .arena = arena, .view = .{} };
+ const n = doc.nodes.items[root];
+ const w = doc.attr(n, "width");
+ const h = doc.attr(n, "height");
+ var view: geom.Rect = .{};
+ if (doc.attr(n, "viewBox")) |vb| {
+ var nums = Numbers{ .text = vb };
+ view = .{ .x = nums.next() orelse 0, .y = nums.next() orelse 0, .w = nums.next() orelse 0, .h = nums.next() orelse 0 };
+ }
+ var width = if (w) |v| lengthPx(v, view.w) else view.w;
+ var height = if (h) |v| lengthPx(v, view.h) else view.h;
+ if (view.w <= 0 or view.h <= 0) view = .{ .w = width, .h = height };
+ if (width <= 0) width = view.w;
+ if (height <= 0) height = view.h;
+ p.view = view;
+ try p.children(root, .identity, .{});
+ return p.b.finish(view, width, height);
+}
+
+// ---------------------------------------------------------------------------
+// A minimal XML reader: elements and attributes into flat arrays.
+
+const Attr = struct { name: []const u8, value: []const u8 };
+const Node = struct {
+ name: []const u8,
+ attrs: []const Attr,
+ first_child: ?u32 = null,
+ next_sibling: ?u32 = null,
+};
+
+const Document = struct {
+ nodes: std.ArrayList(Node) = .empty,
+ ids: std.StringHashMapUnmanaged(u32) = .empty,
+ root: ?u32 = null,
+
+ fn attr(doc: *const Document, n: Node, name: []const u8) ?[]const u8 {
+ _ = doc;
+ for (n.attrs) |a| if (std.mem.eql(u8, a.name, name)) return a.value;
+ return null;
+ }
+
+ fn parse(arena: std.mem.Allocator, s: []const u8) Error!Document {
+ var doc: Document = .{};
+ // Open elements, and the last child appended to each.
+ var stack: std.ArrayList(struct { node: u32, last: ?u32 }) = .empty;
+ var i: usize = 0;
+ while (std.mem.indexOfScalarPos(u8, s, i, '<')) |lt| {
+ i = lt + 1;
+ if (std.mem.startsWith(u8, s[i..], "!--")) {
+ i = (std.mem.indexOfPos(u8, s, i, "-->") orelse return error.InvalidSvg) + 3;
+ } else if (std.mem.startsWith(u8, s[i..], "![CDATA[")) {
+ i = (std.mem.indexOfPos(u8, s, i, "]]>") orelse return error.InvalidSvg) + 3;
+ } else if (s.len > i and (s[i] == '?' or s[i] == '!')) {
+ i = (std.mem.indexOfScalarPos(u8, s, i, '>') orelse return error.InvalidSvg) + 1;
+ } else if (s.len > i and s[i] == '/') {
+ i = (std.mem.indexOfScalarPos(u8, s, i, '>') orelse return error.InvalidSvg) + 1;
+ _ = stack.pop() orelse return error.InvalidSvg;
+ } else {
+ const name_end = std.mem.indexOfAnyPos(u8, s, i, " \t\r\n/>") orelse return error.InvalidSvg;
+ const name = localName(s[i..name_end]);
+ i = name_end;
+ var attrs: std.ArrayList(Attr) = .empty;
+ var self_closing = false;
+ while (true) {
+ while (i < s.len and std.ascii.isWhitespace(s[i])) i += 1;
+ if (i >= s.len) return error.InvalidSvg;
+ if (s[i] == '>') {
+ i += 1;
+ break;
+ }
+ if (s[i] == '/') {
+ self_closing = true;
+ i = (std.mem.indexOfScalarPos(u8, s, i, '>') orelse return error.InvalidSvg) + 1;
+ break;
+ }
+ const eq = std.mem.indexOfScalarPos(u8, s, i, '=') orelse return error.InvalidSvg;
+ const attr_name = std.mem.trim(u8, s[i..eq], " \t\r\n");
+ var q = eq + 1;
+ while (q < s.len and std.ascii.isWhitespace(s[q])) q += 1;
+ if (q >= s.len or (s[q] != '"' and s[q] != '\'')) return error.InvalidSvg;
+ const close = std.mem.indexOfScalarPos(u8, s, q + 1, s[q]) orelse return error.InvalidSvg;
+ try attrs.append(arena, .{ .name = attr_name, .value = try entities(arena, s[q + 1 .. close]) });
+ i = close + 1;
+ }
+ const index: u32 = @intCast(doc.nodes.items.len);
+ try doc.nodes.append(arena, .{ .name = name, .attrs = attrs.items });
+ for (attrs.items) |a| if (std.mem.eql(u8, a.name, "id")) try doc.ids.put(arena, a.value, index);
+ if (stack.items.len == 0) {
+ if (doc.root == null) doc.root = index;
+ } else {
+ const parent = &stack.items[stack.items.len - 1];
+ if (parent.last) |last| doc.nodes.items[last].next_sibling = index else doc.nodes.items[parent.node].first_child = index;
+ parent.last = index;
+ }
+ if (!self_closing) try stack.append(arena, .{ .node = index, .last = null });
+ }
+ }
+ return doc;
+ }
+};
+
+/// `svg:path` and `path` are the same element to us.
+fn localName(qualified: []const u8) []const u8 {
+ return if (std.mem.indexOfScalar(u8, qualified, ':')) |colon| qualified[colon + 1 ..] else qualified;
+}
+
+fn entities(arena: std.mem.Allocator, raw: []const u8) ![]const u8 {
+ if (std.mem.indexOfScalar(u8, raw, '&') == null) return raw;
+ var out: std.ArrayList(u8) = .empty;
+ var i: usize = 0;
+ while (i < raw.len) {
+ if (raw[i] == '&') if (std.mem.indexOfScalarPos(u8, raw, i, ';')) |semi| {
+ const name = raw[i + 1 .. semi];
+ const char: ?u21 = if (std.mem.eql(u8, name, "amp")) '&' else if (std.mem.eql(u8, name, "lt")) '<' else if (std.mem.eql(u8, name, "gt")) '>' else if (std.mem.eql(u8, name, "quot")) '"' else if (std.mem.eql(u8, name, "apos")) '\'' else if (name.len > 1 and name[0] == '#')
+ (if (name[1] == 'x') std.fmt.parseInt(u21, name[2..], 16) catch null else std.fmt.parseInt(u21, name[1..], 10) catch null)
+ else
+ null;
+ if (char) |ch| {
+ var buf: [4]u8 = undefined;
+ const len = std.unicode.utf8Encode(ch, &buf) catch 0;
+ try out.appendSlice(arena, buf[0..len]);
+ i = semi + 1;
+ continue;
+ }
+ };
+ try out.append(arena, raw[i]);
+ i += 1;
+ }
+ return out.items;
+}
+
+// ---------------------------------------------------------------------------
+// Tree walk: inherited style and transforms, shapes into the builder.
+
+const Parser = struct {
+ doc: *Document,
+ b: Drawing.Builder,
+ arena: std.mem.Allocator,
+ /// The root viewport, which `100%` lengths refer to.
+ view: geom.Rect,
+ /// Gradient ids already converted, by index in the builder.
+ gradients: std.StringHashMapUnmanaged(u32) = .empty,
+ /// Guards against `use` cycles.
+ depth: u32 = 0,
+
+ const Inherited = struct {
+ style: Drawing.Style = .{},
+ color: Drawing.Color = .{ 0, 0, 0, 1 },
+ /// The innermost viewport clip, in the drawing's user space.
+ clip: ?[4]Vec = null,
+ };
+
+ fn children(p: *Parser, index: u32, transform: Affine, inherited: Inherited) Error!void {
+ var child = p.doc.nodes.items[index].first_child;
+ while (child) |c| : (child = p.doc.nodes.items[c].next_sibling) try p.element(c, transform, inherited);
+ }
+
+ fn element(p: *Parser, index: u32, parent_transform: Affine, parent: Inherited) Error!void {
+ const n = p.doc.nodes.items[index];
+ const name = n.name;
+ const skip = [_][]const u8{ "defs", "symbol", "linearGradient", "radialGradient", "clipPath", "mask", "pattern", "marker", "style", "title", "desc", "metadata", "filter", "text", "image", "foreignObject" };
+ for (skip) |s| if (std.mem.eql(u8, name, s)) return;
+ if (p.depth > 64) return;
+ var inherited = parent;
+ try p.applyStyle(n, &inherited);
+ if (std.mem.eql(u8, p.doc.attr(n, "display") orelse "", "none")) return;
+ var transform = parent_transform;
+ if (p.doc.attr(n, "transform")) |t| transform = transform.mul(parseTransform(t));
+
+ if (std.mem.eql(u8, name, "g") or std.mem.eql(u8, name, "svg") or std.mem.eql(u8, name, "a") or std.mem.eql(u8, name, "switch")) {
+ if (std.mem.eql(u8, name, "svg")) transform = transform.mul(.translate(p.number(n, "x"), p.number(n, "y")));
+ return p.children(index, transform, inherited);
+ }
+ if (std.mem.eql(u8, name, "use")) {
+ const href = p.doc.attr(n, "href") orelse p.doc.attr(n, "xlink:href") orelse return;
+ if (href.len < 2 or href[0] != '#') return;
+ const target = p.doc.ids.get(href[1..]) orelse return;
+ transform = transform.mul(.translate(p.number(n, "x"), p.number(n, "y")));
+ p.depth += 1;
+ defer p.depth -= 1;
+ const t = p.doc.nodes.items[target];
+ if (std.mem.eql(u8, t.name, "symbol")) {
+ var sym = inherited;
+ try p.applyStyle(t, &sym);
+ // A symbol is a new viewport: the use's size, or the whole
+ // canvas; its viewBox maps into it, and it clips unless its
+ // overflow is visible.
+ const w = if (p.doc.attr(n, "width")) |v| lengthPx(v, p.view.w) else p.view.w;
+ const h = if (p.doc.attr(n, "height")) |v| lengthPx(v, p.view.h) else p.view.h;
+ const overflow = p.doc.attr(t, "overflow") orelse "hidden";
+ if (!std.mem.eql(u8, overflow, "visible") and !std.mem.eql(u8, overflow, "auto")) {
+ sym.clip = .{ transform.apply(.{ 0, 0 }), transform.apply(.{ w, 0 }), transform.apply(.{ w, h }), transform.apply(.{ 0, h }) };
+ }
+ var inner = transform;
+ if (p.doc.attr(t, "viewBox")) |vb| {
+ var nums = Numbers{ .text = vb };
+ const v: geom.Rect = .{ .x = nums.next() orelse 0, .y = nums.next() orelse 0, .w = nums.next() orelse 0, .h = nums.next() orelse 0 };
+ if (v.w > 0 and v.h > 0) {
+ const s = @min(w / v.w, h / v.h);
+ inner = inner.mul(.translate((w - v.w * s) / 2, (h - v.h * s) / 2)).mul(.scale(s, s)).mul(.translate(-v.x, -v.y));
+ }
+ }
+ return p.children(target, inner, sym);
+ }
+ return p.element(target, transform, inherited);
+ }
+
+ const b = &p.b;
+ if (std.mem.eql(u8, name, "path")) {
+ try pathData(b, p.arena, p.doc.attr(n, "d") orelse return);
+ } else if (std.mem.eql(u8, name, "rect")) {
+ const w = p.number(n, "width");
+ const h = p.number(n, "height");
+ if (w <= 0 or h <= 0) return;
+ var rx = p.doc.attr(n, "rx");
+ var ry = p.doc.attr(n, "ry");
+ if (rx == null) rx = ry;
+ if (ry == null) ry = rx;
+ const r: geom.Rect = .{ .x = p.number(n, "x"), .y = p.number(n, "y"), .w = w, .h = h };
+ const rxv = @min(if (rx) |v| parseLength(v) else 0, w / 2);
+ const ryv = @min(if (ry) |v| parseLength(v) else 0, h / 2);
+ if (rxv > 0 and ryv > 0) {
+ try b.roundedRect(r, rxv, ryv);
+ try b.closeSubpath(true);
+ } else try b.rect(r, 0);
+ } else if (std.mem.eql(u8, name, "circle")) {
+ const r = p.number(n, "r");
+ if (r <= 0) return;
+ try b.ellipse(.{ p.number(n, "cx"), p.number(n, "cy") }, r, r);
+ } else if (std.mem.eql(u8, name, "ellipse")) {
+ const rx = p.number(n, "rx");
+ const ry = p.number(n, "ry");
+ if (rx <= 0 or ry <= 0) return;
+ try b.ellipse(.{ p.number(n, "cx"), p.number(n, "cy") }, rx, ry);
+ } else if (std.mem.eql(u8, name, "line")) {
+ try b.lineTo(.{ p.number(n, "x1"), p.number(n, "y1") }, .{ p.number(n, "x2"), p.number(n, "y2") });
+ try b.closeSubpath(false);
+ } else if (std.mem.eql(u8, name, "polyline") or std.mem.eql(u8, name, "polygon")) {
+ var points: std.ArrayList(Vec) = .empty;
+ var nums = Numbers{ .text = p.doc.attr(n, "points") orelse return };
+ while (nums.next()) |x| try points.append(p.arena, .{ x, nums.next() orelse break });
+ try b.polyline(points.items, std.mem.eql(u8, name, "polygon"));
+ } else return;
+ const before = b.shapes.items.len;
+ try b.endShape(transform, inherited.style);
+ if (b.shapes.items.len > before) b.shapes.items[before].clip = inherited.clip;
+ }
+
+ fn number(p: *Parser, n: Node, name: []const u8) f32 {
+ return parseLength(p.doc.attr(n, name) orelse return 0);
+ }
+
+ /// Presentation attributes, then `style="..."` declarations on top.
+ fn applyStyle(p: *Parser, n: Node, inherited: *Inherited) Error!void {
+ // `opacity` multiplies down the tree (see `property`).
+ for (n.attrs) |a| try p.property(a.name, a.value, inherited);
+ if (p.doc.attr(n, "style")) |css| {
+ var decls = std.mem.tokenizeScalar(u8, css, ';');
+ while (decls.next()) |decl| {
+ const colon = std.mem.indexOfScalar(u8, decl, ':') orelse continue;
+ try p.property(std.mem.trim(u8, decl[0..colon], " \t\r\n"), std.mem.trim(u8, decl[colon + 1 ..], " \t\r\n"), inherited);
+ }
+ }
+ }
+
+ fn property(p: *Parser, name: []const u8, raw: []const u8, inherited: *Inherited) Error!void {
+ const value = std.mem.trim(u8, raw, " \t\r\n");
+ const s = &inherited.style;
+ const eql = std.mem.eql;
+ if (eql(u8, value, "inherit")) return;
+ if (eql(u8, name, "color")) {
+ if (parseColor(value, inherited.color)) |c| inherited.color = c;
+ } else if (eql(u8, name, "fill")) {
+ s.fill = try p.paint(value, inherited.color) orelse s.fill;
+ } else if (eql(u8, name, "stroke")) {
+ s.stroke = try p.paint(value, inherited.color) orelse s.stroke;
+ } else if (eql(u8, name, "fill-rule")) {
+ s.fill_rule = if (eql(u8, value, "evenodd")) .evenodd else .nonzero;
+ } else if (eql(u8, name, "fill-opacity")) {
+ s.fill_opacity = parseOpacity(value);
+ } else if (eql(u8, name, "stroke-opacity")) {
+ s.stroke_opacity = parseOpacity(value);
+ } else if (eql(u8, name, "opacity")) {
+ s.opacity *= parseOpacity(value);
+ } else if (eql(u8, name, "stroke-width")) {
+ s.stroke_width = parseLength(value);
+ } else if (eql(u8, name, "stroke-linecap")) {
+ s.cap = std.meta.stringToEnum(Drawing.Cap, value) orelse s.cap;
+ } else if (eql(u8, name, "stroke-linejoin")) {
+ s.join = if (eql(u8, value, "miter-clip") or eql(u8, value, "arcs")) .miter else std.meta.stringToEnum(Drawing.Join, value) orelse s.join;
+ } else if (eql(u8, name, "stroke-miterlimit")) {
+ s.miter_limit = @max(1, parseLength(value));
+ } else if (eql(u8, name, "stroke-dasharray")) {
+ s.dash_count = 0;
+ if (!eql(u8, value, "none")) {
+ var nums = Numbers{ .text = value };
+ var total: f32 = 0;
+ while (nums.next()) |d| {
+ if (s.dash_count == s.dashes.len or d < 0) break;
+ s.dashes[s.dash_count] = d;
+ s.dash_count += 1;
+ total += d;
+ }
+ if (total <= 0) s.dash_count = 0;
+ // An odd list repeats to make an even one.
+ if (s.dash_count % 2 == 1 and s.dash_count * 2 <= s.dashes.len) {
+ @memcpy(s.dashes[s.dash_count..][0..s.dash_count], s.dashes[0..s.dash_count]);
+ s.dash_count *= 2;
+ }
+ }
+ } else if (eql(u8, name, "stroke-dashoffset")) {
+ s.dash_offset = parseLength(value);
+ }
+ }
+
+ fn paint(p: *Parser, value: []const u8, current: Drawing.Color) Error!?Drawing.Paint {
+ if (std.mem.eql(u8, value, "none")) return .none;
+ if (std.mem.startsWith(u8, value, "url(")) {
+ const close = std.mem.indexOfScalar(u8, value, ')') orelse return null;
+ const ref = std.mem.trim(u8, value[4..close], " '\"");
+ if (ref.len > 1 and ref[0] == '#') if (try p.gradient(ref[1..])) |g| return .{ .gradient = g };
+ // A missing paint server falls back to what follows it, or none.
+ const fallback = std.mem.trim(u8, value[close + 1 ..], " ");
+ return if (fallback.len > 0) try p.paint(fallback, current) else .none;
+ }
+ return if (parseColor(value, current)) |c| .{ .color = c } else null;
+ }
+
+ fn gradient(p: *Parser, id: []const u8) Error!?u32 {
+ if (p.gradients.get(id)) |g| return g;
+ const index = p.doc.ids.get(id) orelse return null;
+ const n = p.doc.nodes.items[index];
+ const radial = std.mem.eql(u8, n.name, "radialGradient");
+ if (!radial and !std.mem.eql(u8, n.name, "linearGradient")) return null;
+ var g: Drawing.Gradient = .{ .kind = if (radial) .radial else .linear };
+ if (radial) {
+ g.p0 = .{ 0.5, 0.5 };
+ g.p1 = .{ 0.5, 0.5 };
+ }
+ // Attributes and stops come from the first element in the href chain
+ // that has them.
+ var chain: [8]Node = undefined;
+ var len: usize = 0;
+ var at: ?u32 = index;
+ while (at) |i| : (len += 1) {
+ if (len == chain.len) break;
+ chain[len] = p.doc.nodes.items[i];
+ const href = p.doc.attr(chain[len], "href") orelse p.doc.attr(chain[len], "xlink:href") orelse "";
+ at = if (href.len > 1 and href[0] == '#') p.doc.ids.get(href[1..]) else null;
+ }
+ const find = struct {
+ fn find(doc: *Document, nodes: []const Node, name: []const u8) ?[]const u8 {
+ for (nodes) |node| if (doc.attr(node, name)) |v| return v;
+ return null;
+ }
+ }.find;
+ const nodes = chain[0..len];
+ if (find(p.doc, nodes, "gradientUnits")) |u| g.bounding_box = !std.mem.eql(u8, u, "userSpaceOnUse");
+ if (find(p.doc, nodes, "gradientTransform")) |t| g.transform = parseTransform(t);
+ if (find(p.doc, nodes, "spreadMethod")) |s| g.spread = if (std.mem.eql(u8, s, "reflect")) .reflect else if (std.mem.eql(u8, s, "repeat")) .repeat else .pad;
+ const coord = struct {
+ fn coord(doc: *Document, ns: []const Node, name: []const u8, default: f32, bbox: bool) f32 {
+ const v = find(doc, ns, name) orelse return default;
+ const t = std.mem.trim(u8, v, " ");
+ if (bbox and t.len > 0 and t[t.len - 1] == '%') return (std.fmt.parseFloat(f32, t[0 .. t.len - 1]) catch 0) / 100;
+ return parseLength(t);
+ }
+ }.coord;
+ if (radial) {
+ const cx = coord(p.doc, nodes, "cx", 0.5, g.bounding_box);
+ const cy = coord(p.doc, nodes, "cy", 0.5, g.bounding_box);
+ g.p0 = .{ cx, cy };
+ g.p1 = .{ coord(p.doc, nodes, "fx", cx, g.bounding_box), coord(p.doc, nodes, "fy", cy, g.bounding_box) };
+ g.radius = coord(p.doc, nodes, "r", 0.5, g.bounding_box);
+ } else {
+ g.p0 = .{ coord(p.doc, nodes, "x1", 0, g.bounding_box), coord(p.doc, nodes, "y1", 0, g.bounding_box) };
+ g.p1 = .{ coord(p.doc, nodes, "x2", 1, g.bounding_box), coord(p.doc, nodes, "y2", 0, g.bounding_box) };
+ }
+ var stops: std.ArrayList(Drawing.Gradient.Stop) = .empty;
+ for (nodes) |node| {
+ var child = node.first_child;
+ while (child) |c| : (child = p.doc.nodes.items[c].next_sibling) {
+ const stop = p.doc.nodes.items[c];
+ if (!std.mem.eql(u8, stop.name, "stop")) continue;
+ var color: Drawing.Color = .{ 0, 0, 0, 1 };
+ var opacity: f32 = 1;
+ var offset: f32 = 0;
+ const apply = struct {
+ fn apply(name: []const u8, value: []const u8, col: *Drawing.Color, op: *f32, off: *f32) void {
+ const v = std.mem.trim(u8, value, " ");
+ if (std.mem.eql(u8, name, "stop-color")) {
+ if (parseColor(v, .{ 0, 0, 0, 1 })) |parsed| col.* = parsed;
+ } else if (std.mem.eql(u8, name, "stop-opacity")) {
+ op.* = parseOpacity(v);
+ } else if (std.mem.eql(u8, name, "offset")) {
+ off.* = parseOpacity(v);
+ }
+ }
+ }.apply;
+ for (stop.attrs) |a| apply(a.name, a.value, &color, &opacity, &offset);
+ if (p.doc.attr(stop, "style")) |css| {
+ var decls = std.mem.tokenizeScalar(u8, css, ';');
+ while (decls.next()) |decl| {
+ const colon = std.mem.indexOfScalar(u8, decl, ':') orelse continue;
+ apply(std.mem.trim(u8, decl[0..colon], " "), decl[colon + 1 ..], &color, &opacity, &offset);
+ }
+ }
+ color[3] *= opacity;
+ // Offsets never go backwards.
+ if (stops.items.len > 0) offset = @max(offset, stops.items[stops.items.len - 1].offset);
+ try stops.append(p.arena, .{ .offset = std.math.clamp(offset, 0, 1), .color = color });
+ }
+ if (stops.items.len > 0) break;
+ }
+ if (stops.items.len == 0) return null;
+ g.stops = stops.items;
+ const at_index: u32 = @intCast(p.b.gradients.items.len);
+ try p.b.gradients.append(p.arena, g);
+ try p.gradients.put(p.arena, id, at_index);
+ return at_index;
+ }
+};
+
+// ---------------------------------------------------------------------------
+// Values
+
+/// Numbers separated by whitespace and/or commas, SVG style: "1-2" is two
+/// numbers, ".5.5" too.
+pub const Numbers = struct {
+ text: []const u8,
+ i: usize = 0,
+
+ pub fn next(n: *Numbers) ?f32 {
+ n.skip();
+ if (n.i >= n.text.len) return null;
+ const start = n.i;
+ var j = n.i;
+ if (j < n.text.len and (n.text[j] == '+' or n.text[j] == '-')) j += 1;
+ var dot = false;
+ while (j < n.text.len) : (j += 1) {
+ const ch = n.text[j];
+ if (std.ascii.isDigit(ch)) continue;
+ if (ch == '.' and !dot) {
+ dot = true;
+ continue;
+ }
+ if ((ch == 'e' or ch == 'E') and j + 1 < n.text.len and (std.ascii.isDigit(n.text[j + 1]) or ((n.text[j + 1] == '-' or n.text[j + 1] == '+') and j + 2 < n.text.len and std.ascii.isDigit(n.text[j + 2])))) {
+ j += 2;
+ while (j < n.text.len and std.ascii.isDigit(n.text[j])) j += 1;
+ break;
+ }
+ break;
+ }
+ if (j == start) return null;
+ n.i = j;
+ return std.fmt.parseFloat(f32, n.text[start..j]) catch null;
+ }
+ /// A single `0`/`1` arc flag, which may be glued to what follows.
+ pub fn flag(n: *Numbers) ?bool {
+ n.skip();
+ if (n.i >= n.text.len) return null;
+ const ch = n.text[n.i];
+ if (ch != '0' and ch != '1') return null;
+ n.i += 1;
+ return ch == '1';
+ }
+ fn skip(n: *Numbers) void {
+ while (n.i < n.text.len and (std.ascii.isWhitespace(n.text[n.i]) or n.text[n.i] == ',')) n.i += 1;
+ }
+};
+
+/// A length in user units: unitless and px as-is, other absolute units
+/// converted at 96 dpi. Percentages and font units fall back to the number.
+pub fn parseLength(raw: []const u8) f32 {
+ const v = std.mem.trim(u8, raw, " \t\r\n");
+ var nums = Numbers{ .text = v };
+ const n = nums.next() orelse return 0;
+ const unit = std.mem.trim(u8, v[nums.i..], " ");
+ const scale: f32 = if (std.mem.eql(u8, unit, "pt")) 4.0 / 3.0 else if (std.mem.eql(u8, unit, "pc")) 16 else if (std.mem.eql(u8, unit, "in")) 96 else if (std.mem.eql(u8, unit, "cm")) 96.0 / 2.54 else if (std.mem.eql(u8, unit, "mm")) 96.0 / 25.4 else if (std.mem.eql(u8, unit, "em")) 16 else 1;
+ return n * scale;
+}
+
+/// Like `parseLength`, but a percentage of `reference`.
+fn lengthPx(raw: []const u8, reference: f32) f32 {
+ const v = std.mem.trim(u8, raw, " ");
+ if (v.len > 0 and v[v.len - 1] == '%') return (std.fmt.parseFloat(f32, v[0 .. v.len - 1]) catch 100) / 100 * reference;
+ return parseLength(v);
+}
+
+fn parseOpacity(raw: []const u8) f32 {
+ const v = std.mem.trim(u8, raw, " ");
+ if (v.len > 0 and v[v.len - 1] == '%') return std.math.clamp((std.fmt.parseFloat(f32, v[0 .. v.len - 1]) catch 100) / 100, 0, 1);
+ return std.math.clamp(std.fmt.parseFloat(f32, v) catch 1, 0, 1);
+}
+
+pub fn parseTransform(text: []const u8) Affine {
+ var m: Affine = .identity;
+ var i: usize = 0;
+ while (std.mem.indexOfScalarPos(u8, text, i, '(')) |open| {
+ const name = std.mem.trim(u8, text[i..open], " \t\r\n,");
+ const close = std.mem.indexOfScalarPos(u8, text, open, ')') orelse break;
+ var nums = Numbers{ .text = text[open + 1 .. close] };
+ var v: [6]f32 = @splat(0);
+ var count: usize = 0;
+ while (nums.next()) |x| : (count += 1) {
+ if (count == v.len) break;
+ v[count] = x;
+ }
+ const deg = std.math.pi / 180.0;
+ const t: Affine = if (std.mem.eql(u8, name, "matrix") and count == 6)
+ .{ .a = v[0], .b = v[1], .c = v[2], .d = v[3], .e = v[4], .f = v[5] }
+ else if (std.mem.eql(u8, name, "translate"))
+ .translate(v[0], if (count > 1) v[1] else 0)
+ else if (std.mem.eql(u8, name, "scale"))
+ .scale(v[0], if (count > 1) v[1] else v[0])
+ else if (std.mem.eql(u8, name, "rotate"))
+ Affine.translate(v[1], v[2]).mul(.rotate(v[0] * deg)).mul(.translate(-v[1], -v[2]))
+ else if (std.mem.eql(u8, name, "skewX"))
+ .skew(v[0] * deg, 0)
+ else if (std.mem.eql(u8, name, "skewY"))
+ .skew(0, v[0] * deg)
+ else
+ .identity;
+ m = m.mul(t);
+ i = close + 1;
+ }
+ return m;
+}
+
+/// `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`, `rgb()`/`rgba()` (numbers or
+/// percentages), `currentColor`, `transparent` and the common named colors.
+pub fn parseColor(raw: []const u8, current: Drawing.Color) ?Drawing.Color {
+ const v = std.mem.trim(u8, raw, " \t\r\n");
+ if (v.len == 0) return null;
+ if (v[0] == '#') {
+ const hex = v[1..];
+ const digit = struct {
+ fn d(ch: u8) ?f32 {
+ return @floatFromInt(std.fmt.charToDigit(ch, 16) catch return null);
+ }
+ }.d;
+ switch (hex.len) {
+ 3, 4 => {
+ var c: [4]f32 = .{ 0, 0, 0, 1 };
+ for (hex, 0..) |ch, i| c[i] = (digit(ch) orelse return null) * 17 / 255;
+ return c;
+ },
+ 6, 8 => {
+ var c: [4]f32 = .{ 0, 0, 0, 1 };
+ for (0..hex.len / 2) |i| c[i] = ((digit(hex[2 * i]) orelse return null) * 16 + (digit(hex[2 * i + 1]) orelse return null)) / 255;
+ return c;
+ },
+ else => return null,
+ }
+ }
+ if (std.ascii.startsWithIgnoreCase(v, "rgb")) {
+ const open = std.mem.indexOfScalar(u8, v, '(') orelse return null;
+ const close = std.mem.indexOfScalar(u8, v, ')') orelse return null;
+ var parts = std.mem.tokenizeAny(u8, v[open + 1 .. close], ", /");
+ var c: [4]f32 = .{ 0, 0, 0, 1 };
+ var i: usize = 0;
+ while (parts.next()) |part| : (i += 1) {
+ if (i == 4) break;
+ const pct = part[part.len - 1] == '%';
+ const n = std.fmt.parseFloat(f32, if (pct) part[0 .. part.len - 1] else part) catch return null;
+ c[i] = std.math.clamp(if (i == 3) (if (pct) n / 100 else n) else if (pct) n / 100 else n / 255, 0, 1);
+ }
+ return c;
+ }
+ if (std.ascii.eqlIgnoreCase(v, "currentColor")) return current;
+ if (std.ascii.eqlIgnoreCase(v, "transparent")) return .{ 0, 0, 0, 0 };
+ for (named) |entry| if (std.ascii.eqlIgnoreCase(v, entry[0])) {
+ const rgb: u24 = entry[1];
+ return .{ @as(f32, @floatFromInt(rgb >> 16)) / 255, @as(f32, @floatFromInt((rgb >> 8) & 0xff)) / 255, @as(f32, @floatFromInt(rgb & 0xff)) / 255, 1 };
+ };
+ return null;
+}
+
+const named = [_]struct { []const u8, u24 }{
+ .{ "black", 0x000000 }, .{ "white", 0xffffff }, .{ "red", 0xff0000 }, .{ "lime", 0x00ff00 },
+ .{ "green", 0x008000 }, .{ "blue", 0x0000ff }, .{ "yellow", 0xffff00 }, .{ "cyan", 0x00ffff },
+ .{ "aqua", 0x00ffff }, .{ "magenta", 0xff00ff }, .{ "fuchsia", 0xff00ff }, .{ "gray", 0x808080 },
+ .{ "grey", 0x808080 }, .{ "silver", 0xc0c0c0 }, .{ "maroon", 0x800000 }, .{ "olive", 0x808000 },
+ .{ "navy", 0x000080 }, .{ "purple", 0x800080 }, .{ "teal", 0x008080 }, .{ "orange", 0xffa500 },
+ .{ "pink", 0xffc0cb }, .{ "brown", 0xa52a2a }, .{ "gold", 0xffd700 }, .{ "indigo", 0x4b0082 },
+ .{ "violet", 0xee82ee }, .{ "coral", 0xff7f50 }, .{ "salmon", 0xfa8072 }, .{ "tomato", 0xff6347 },
+ .{ "orchid", 0xda70d6 }, .{ "crimson", 0xdc143c }, .{ "skyblue", 0x87ceeb }, .{ "steelblue", 0x4682b4 },
+ .{ "darkgray", 0xa9a9a9 }, .{ "lightgray", 0xd3d3d3 }, .{ "darkgreen", 0x006400 }, .{ "darkblue", 0x00008b },
+ .{ "darkred", 0x8b0000 }, .{ "lightblue", 0xadd8e6 }, .{ "turquoise", 0x40e0d0 }, .{ "khaki", 0xf0e68c },
+};
+
+/// Path data into cubics: every command, absolute and relative, with
+/// implicit repeats and the smooth-curve reflections.
+pub fn pathData(b: *Drawing.Builder, gpa: std.mem.Allocator, d: []const u8) !void {
+ var nums = Numbers{ .text = d };
+ var command: u8 = 0;
+ var current: Vec = .{ 0, 0 };
+ var start: Vec = .{ 0, 0 };
+ // Last control point, for S and T reflections.
+ var last_cubic: ?Vec = null;
+ var last_quad: ?Vec = null;
+ var arcs: std.ArrayList(geom.Cubic) = .empty;
+ while (true) {
+ nums.skip();
+ if (nums.i >= d.len) break;
+ const ch = d[nums.i];
+ if (std.ascii.isAlphabetic(ch) and ch != 'e' and ch != 'E') {
+ command = ch;
+ nums.i += 1;
+ if (ch == 'z' or ch == 'Z') {
+ if (@reduce(.Or, current != start)) try b.lineTo(current, start);
+ try b.closeSubpath(true);
+ current = start;
+ last_cubic = null;
+ last_quad = null;
+ continue;
+ }
+ } else if (command == 0) return;
+ const rel = std.ascii.isLower(command);
+ const base: Vec = if (rel) current else .{ 0, 0 };
+ const cubic_before = last_cubic;
+ const quad_before = last_quad;
+ last_cubic = null;
+ last_quad = null;
+ switch (std.ascii.toUpper(command)) {
+ 'M' => {
+ const p = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ try b.closeSubpath(false);
+ current = p;
+ start = p;
+ // Further pairs are line-tos.
+ command = if (rel) 'l' else 'L';
+ },
+ 'L' => {
+ const p = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ try b.lineTo(current, p);
+ current = p;
+ },
+ 'H' => {
+ const x = nums.next() orelse return;
+ const p: Vec = .{ if (rel) current[0] + x else x, current[1] };
+ try b.lineTo(current, p);
+ current = p;
+ },
+ 'V' => {
+ const y = nums.next() orelse return;
+ const p: Vec = .{ current[0], if (rel) current[1] + y else y };
+ try b.lineTo(current, p);
+ current = p;
+ },
+ 'C' => {
+ const c1 = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ const c2 = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ const p = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ try b.cubic(.{ current, c1, c2, p });
+ last_cubic = c2;
+ current = p;
+ },
+ 'S' => {
+ const c1 = if (cubic_before) |c| current * geom.splat(2) - c else current;
+ const c2 = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ const p = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ try b.cubic(.{ current, c1, c2, p });
+ last_cubic = c2;
+ current = p;
+ },
+ 'Q' => {
+ const c = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ const p = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ try b.cubic(geom.quad(current, c, p));
+ last_quad = c;
+ current = p;
+ },
+ 'T' => {
+ const c = if (quad_before) |q| current * geom.splat(2) - q else current;
+ const p = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ try b.cubic(geom.quad(current, c, p));
+ last_quad = c;
+ current = p;
+ },
+ 'A' => {
+ const rx = nums.next() orelse return;
+ const ry = nums.next() orelse return;
+ const rotation = nums.next() orelse return;
+ const large = nums.flag() orelse return;
+ const sweep = nums.flag() orelse return;
+ const p = base + Vec{ nums.next() orelse return, nums.next() orelse return };
+ arcs.clearRetainingCapacity();
+ try geom.arc(&arcs, gpa, current, .{ rx, ry }, rotation, large, sweep, p);
+ for (arcs.items) |c| try b.cubic(c);
+ current = p;
+ },
+ else => return,
+ }
+ }
+ try b.closeSubpath(false);
+}
+
+test "typst-style use of symbols, transforms and inherited fill" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ const d = try parse(arena.allocator(),
+ \\<svg viewBox="0 0 20 10" width="15pt" height="7.5pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+ \\<g transform="matrix(1 0 0 -1 4 8)"><use xlink:href="#g1" x="1" y="0" fill="#ff0000" fill-rule="evenodd"/></g>
+ \\<defs><symbol id="g1" overflow="visible"><path d="M 0 0m 1 1h 2v 2h -2Z"/></symbol></defs>
+ \\</svg>
+ );
+ try std.testing.expectEqual(@as(f32, 20), d.width);
+ try std.testing.expectEqual(@as(usize, 1), d.shapes.len);
+ const shape = d.shapes[0];
+ try std.testing.expectEqual(Drawing.FillRule.evenodd, shape.style.fill_rule);
+ try std.testing.expectEqual(Drawing.Color{ 1, 0, 0, 1 }, shape.style.fill.color);
+ try std.testing.expectEqual(@as(usize, 4), d.cubicsOf(d.subpathsOf(shape)[0]).len);
+ const corner = shape.transform.apply(d.cubics[0][0]);
+ try std.testing.expectEqual(geom.vec(6, 7), corner);
+}
+
+test "path data: implicit repeats, relative commands, smooth curves and arcs" {
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ var b: Drawing.Builder = .init(arena.allocator());
+ try pathData(&b, arena.allocator(), "M10-20l5 5 5-5h-1e1s1,2,3,4q1 1 2 0t2 0a5 5 0 1 0 10 0z");
+ try std.testing.expectEqual(@as(usize, 1), b.subpaths.items.len);
+ try std.testing.expect(b.subpaths.items[0].closed);
+ const cubics = b.cubics.items;
+ try std.testing.expectEqual(geom.vec(15, -15), cubics[0][3]);
+ try std.testing.expectEqual(geom.vec(20, -20), cubics[1][3]);
+ try std.testing.expectEqual(geom.vec(10, -20), cubics[2][3]);
+ // The first S has no previous curve: its first control is the current point.
+ try std.testing.expectEqual(geom.vec(10, -20), cubics[3][1]);
+ try std.testing.expectEqual(geom.vec(13, -16), cubics[3][3]);
+ var nums = Numbers{ .text = "1.5.5-2e-1" };
+ try std.testing.expectEqual(@as(f32, 1.5), nums.next().?);
+ try std.testing.expectEqual(@as(f32, 0.5), nums.next().?);
+ try std.testing.expectEqual(@as(f32, -0.2), nums.next().?);
+}
+
+test "colors and lengths" {
+ try std.testing.expectEqual(Drawing.Color{ 1, 1, 1, 1 }, parseColor("#fff", .{ 0, 0, 0, 1 }).?);
+ try std.testing.expectEqual(Drawing.Color{ 0, 0.5, 1, 1 }, parseColor("rgb(0, 50%, 255)", .{ 0, 0, 0, 1 }).?);
+ try std.testing.expectEqual(@as(f32, 20), parseLength("15pt"));
+ try std.testing.expectEqual(@as(f32, 0.5), parseOpacity("50%"));
+}