Lightpanda: the headless browser designed for AI and automation
svg: make live collection mutations transactional
Madison Steiner29109a2dea43
diff --git a/src/browser/tests/element/svg/collections.html b/src/browser/tests/element/svg/collections.htmlindex f3dcadc3d..43de72eeb 100644--- a/src/browser/tests/element/svg/collections.html+++ b/src/browser/tests/element/svg/collections.html@@ -7,6 +7,8 @@<polyline id=many></polyline><g id=group transform="translate(10 20) rotate(45 1 2)"requiredExtensions="urn:one urn:two" systemLanguage="en, fr"></g>+ <g id=matrixGroup transform="translate(1 2)"></g>+ <g id=replaceGroup transform="scale(1) translate(0 0)"></g></svg><script id=pointLists>@@ -147,6 +149,79 @@}</script>+<script id=transformMatrixReflection>+{+ const root = $('#root');+ const group = $('#matrixGroup');+ const base = group.transform.baseVal;+ const anim = group.transform.animVal;+ const transform = base.getItem(0);+ const matrix = transform.matrix;++ testing.expectEqual(true, matrix === transform.matrix);+ matrix.e = 5;+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_MATRIX, transform.type);+ testing.expectEqual(0, transform.angle);+ testing.expectEqual(true, group.getAttribute('transform').startsWith('matrix('));+ testing.expectEqual(5, anim.getItem(0).matrix.e);++ testing.expectEqual(matrix, matrix.translateSelf(2, 3));+ testing.expectEqual(7, matrix.e);+ testing.expectEqual(5, matrix.f);+ testing.expectEqual(7, anim.getItem(0).matrix.e);+ testing.expectEqual(5, anim.getItem(0).matrix.f);++ testing.expectEqual(matrix, matrix.setMatrixValue('matrix(1, 0, 0, 1, 9, 10)'));+ testing.expectEqual(9, matrix.e);+ testing.expectEqual(10, matrix.f);+ testing.expectEqual(9, anim.getItem(0).matrix.e);+ testing.expectEqual(10, anim.getItem(0).matrix.f);++ const animMatrix = anim.getItem(0).matrix;+ const beforeReadOnlyWrites = group.getAttribute('transform');+ testing.expectError('NoModificationAllowedError', () => { animMatrix.e = 99; });+ testing.expectError('NoModificationAllowedError', () => animMatrix.translateSelf(1, 1));+ testing.expectError('NoModificationAllowedError', () => animMatrix.setMatrixValue('scale(2)'));+ testing.expectEqual(beforeReadOnlyWrites, group.getAttribute('transform'));+ testing.expectEqual(9, animMatrix.e);++ group.setAttribute('transform', 'scale(4)');+ testing.expectEqual(1, base.length);+ matrix.e = 11;+ testing.expectEqual('scale(4)', group.getAttribute('transform'));+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_MATRIX, transform.type);+ testing.expectEqual(11, matrix.e);++ const detached = root.createSVGTransform();+ const detachedMatrix = detached.matrix;+ detachedMatrix.e = 13;+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_MATRIX, detached.type);+ testing.expectEqual(true, detachedMatrix === detached.matrix);+ detachedMatrix.m13 = 2;+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_UNKNOWN, detached.type);+ testing.expectEqual(false, detachedMatrix.is2D);++ testing.expectEqual(detached, base.initialize(detached));+ testing.expectEqual(true, group.getAttribute('transform').startsWith('matrix3d('));+ testing.expectEqual(2, base.getItem(0).matrix.m13);+ testing.expectEqual(2, anim.getItem(0).matrix.m13);+ testing.expectError('NoModificationAllowedError', () => { anim.getItem(0).matrix.m13 = 3; });++ const consolidated = base.consolidate();+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_UNKNOWN, consolidated.type);+ testing.expectEqual(false, consolidated.matrix.is2D);+ testing.expectEqual(true, group.getAttribute('transform').startsWith('matrix3d('));++ const replaceGroup = $('#replaceGroup');+ const replacement = root.createSVGTransform();+ replacement.setScale(10, 1);+ testing.expectEqual(replacement, replaceGroup.transform.baseVal.replaceItem(replacement, 0));+ testing.expectEqual(replacement, replaceGroup.transform.baseVal.getItem(0));+ testing.expectEqual(10, replacement.matrix.a);+ testing.expectEqual(true, replaceGroup.getAttribute('transform').startsWith('scale(10 1)'));+}+</script>+<script id=transformParserRegression>{const group = $('#group');diff --git a/src/browser/webapi/DOMMatrix.zig b/src/browser/webapi/DOMMatrix.zigindex 132fa52a7..1e375c5f9 100644--- a/src/browser/webapi/DOMMatrix.zig+++ b/src/browser/webapi/DOMMatrix.zig@@ -84,137 +84,158 @@ pub fn getF(self: *const DOMMatrix) f64 {return self._proto._m[13];}-pub fn setA(self: *DOMMatrix, v: f64) void {- self._proto._m[0] = v;+pub fn setA(self: *DOMMatrix, v: f64) !void {+ try self.setElement(0, v);}-pub fn setB(self: *DOMMatrix, v: f64) void {- self._proto._m[1] = v;+pub fn setB(self: *DOMMatrix, v: f64) !void {+ try self.setElement(1, v);}-pub fn setC(self: *DOMMatrix, v: f64) void {- self._proto._m[4] = v;+pub fn setC(self: *DOMMatrix, v: f64) !void {+ try self.setElement(4, v);}-pub fn setD(self: *DOMMatrix, v: f64) void {- self._proto._m[5] = v;+pub fn setD(self: *DOMMatrix, v: f64) !void {+ try self.setElement(5, v);}-pub fn setE(self: *DOMMatrix, v: f64) void {- self._proto._m[12] = v;+pub fn setE(self: *DOMMatrix, v: f64) !void {+ try self.setElement(12, v);}-pub fn setF(self: *DOMMatrix, v: f64) void {- self._proto._m[13] = v;+pub fn setF(self: *DOMMatrix, v: f64) !void {+ try self.setElement(13, v);}-pub fn translateSelf(self: *DOMMatrix, tx_: ?f64, ty_: ?f64, tz_: ?f64) *DOMMatrix {+pub fn translateSelf(self: *DOMMatrix, tx_: ?f64, ty_: ?f64, tz_: ?f64) !*DOMMatrix {const tz = tz_ orelse 0;- const p = self._proto;- p._m = RO.multiplyMatrix(p._m, RO.translationMatrix(tx_ orelse 0, ty_ orelse 0, tz));- if (tz != 0) p._is_2d = false;- return self;+ var state = self._proto.getState();+ state.matrix = RO.multiplyMatrix(state.matrix, RO.translationMatrix(tx_ orelse 0, ty_ orelse 0, tz));+ if (tz != 0) state.is_2d = false;+ return self.applyState(state);}-pub fn scaleSelf(self: *DOMMatrix, sx_: ?f64, sy_: ?f64, sz_: ?f64, ox_: ?f64, oy_: ?f64, oz_: ?f64) *DOMMatrix {+pub fn scaleSelf(self: *DOMMatrix, sx_: ?f64, sy_: ?f64, sz_: ?f64, ox_: ?f64, oy_: ?f64, oz_: ?f64) !*DOMMatrix {const sx = sx_ orelse 1;const sy = sy_ orelse sx;const sz = sz_ orelse 1;const ox = ox_ orelse 0;const oy = oy_ orelse 0;const oz = oz_ orelse 0;- const p = self._proto;- var m = RO.multiplyMatrix(p._m, RO.translationMatrix(ox, oy, oz));+ var state = self._proto.getState();+ var m = RO.multiplyMatrix(state.matrix, RO.translationMatrix(ox, oy, oz));m = RO.multiplyMatrix(m, RO.scaleMatrix(sx, sy, sz));m = RO.multiplyMatrix(m, RO.translationMatrix(-ox, -oy, -oz));- p._m = m;- if (sz != 1 or oz != 0) p._is_2d = false;- return self;+ state.matrix = m;+ if (sz != 1 or oz != 0) state.is_2d = false;+ return self.applyState(state);}-pub fn scale3dSelf(self: *DOMMatrix, scale_: ?f64, ox_: ?f64, oy_: ?f64, oz_: ?f64) *DOMMatrix {+pub fn scale3dSelf(self: *DOMMatrix, scale_: ?f64, ox_: ?f64, oy_: ?f64, oz_: ?f64) !*DOMMatrix {const s = scale_ orelse 1;const ox = ox_ orelse 0;const oy = oy_ orelse 0;const oz = oz_ orelse 0;- const p = self._proto;- var m = RO.multiplyMatrix(p._m, RO.translationMatrix(ox, oy, oz));+ var state = self._proto.getState();+ var m = RO.multiplyMatrix(state.matrix, RO.translationMatrix(ox, oy, oz));m = RO.multiplyMatrix(m, RO.scaleMatrix(s, s, s));m = RO.multiplyMatrix(m, RO.translationMatrix(-ox, -oy, -oz));- p._m = m;- if (s != 1) p._is_2d = false;- return self;+ state.matrix = m;+ if (s != 1) state.is_2d = false;+ return self.applyState(state);}-pub fn rotateSelf(self: *DOMMatrix, rx_: ?f64, ry_: ?f64, rz_: ?f64) *DOMMatrix {- const p = self._proto;+pub fn rotateSelf(self: *DOMMatrix, rx_: ?f64, ry_: ?f64, rz_: ?f64) !*DOMMatrix {+ var state = self._proto.getState();if (ry_ == null and rz_ == null) {- p._m = RO.multiplyMatrix(p._m, RO.rotateZMatrix(RO.toRadians(rx_ orelse 0, .deg)));+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateZMatrix(RO.toRadians(rx_ orelse 0, .deg)));} else {- p._m = RO.multiplyMatrix(p._m, RO.rotateXMatrix(RO.toRadians(rx_ orelse 0, .deg)));- p._m = RO.multiplyMatrix(p._m, RO.rotateYMatrix(RO.toRadians(ry_ orelse 0, .deg)));- p._m = RO.multiplyMatrix(p._m, RO.rotateZMatrix(RO.toRadians(rz_ orelse 0, .deg)));- p._is_2d = false;+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateXMatrix(RO.toRadians(rx_ orelse 0, .deg)));+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateYMatrix(RO.toRadians(ry_ orelse 0, .deg)));+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateZMatrix(RO.toRadians(rz_ orelse 0, .deg)));+ state.is_2d = false;}- return self;+ return self.applyState(state);}-pub fn rotateFromVectorSelf(self: *DOMMatrix, x_: ?f64, y_: ?f64) *DOMMatrix {+pub fn rotateFromVectorSelf(self: *DOMMatrix, x_: ?f64, y_: ?f64) !*DOMMatrix {const x = x_ orelse 0;const y = y_ orelse 0;const rad = if (x == 0 and y == 0) 0 else std.math.atan2(y, x);- const p = self._proto;- p._m = RO.multiplyMatrix(p._m, RO.rotateZMatrix(rad));- return self;+ var state = self._proto.getState();+ state.matrix = RO.multiplyMatrix(state.matrix, RO.rotateZMatrix(rad));+ return self.applyState(state);}-pub fn rotateAxisAngleSelf(self: *DOMMatrix, x_: ?f64, y_: ?f64, z_: ?f64, angle_: ?f64) *DOMMatrix {- const p = self._proto;- p._m = RO.multiplyMatrix(p._m, RO.axisAngleMatrix(x_ orelse 0, y_ orelse 0, z_ orelse 0, RO.toRadians(angle_ orelse 0, .deg)));- if ((x_ orelse 0) != 0 or (y_ orelse 0) != 0) p._is_2d = false;- return self;+pub fn rotateAxisAngleSelf(self: *DOMMatrix, x_: ?f64, y_: ?f64, z_: ?f64, angle_: ?f64) !*DOMMatrix {+ var state = self._proto.getState();+ state.matrix = RO.multiplyMatrix(state.matrix, RO.axisAngleMatrix(x_ orelse 0, y_ orelse 0, z_ orelse 0, RO.toRadians(angle_ orelse 0, .deg)));+ if ((x_ orelse 0) != 0 or (y_ orelse 0) != 0) state.is_2d = false;+ return self.applyState(state);}-pub fn skewXSelf(self: *DOMMatrix, sx_: ?f64) *DOMMatrix {- const p = self._proto;- p._m = RO.multiplyMatrix(p._m, RO.skewMatrix(RO.toRadians(sx_ orelse 0, .deg), 0));- return self;+pub fn skewXSelf(self: *DOMMatrix, sx_: ?f64) !*DOMMatrix {+ var state = self._proto.getState();+ state.matrix = RO.multiplyMatrix(state.matrix, RO.skewMatrix(RO.toRadians(sx_ orelse 0, .deg), 0));+ return self.applyState(state);}-pub fn skewYSelf(self: *DOMMatrix, sy_: ?f64) *DOMMatrix {- const p = self._proto;- p._m = RO.multiplyMatrix(p._m, RO.skewMatrix(0, RO.toRadians(sy_ orelse 0, .deg)));- return self;+pub fn skewYSelf(self: *DOMMatrix, sy_: ?f64) !*DOMMatrix {+ var state = self._proto.getState();+ state.matrix = RO.multiplyMatrix(state.matrix, RO.skewMatrix(0, RO.toRadians(sy_ orelse 0, .deg)));+ return self.applyState(state);}pub fn multiplySelf(self: *DOMMatrix, other_: ?RO.DOMMatrixInit) !*DOMMatrix {- const p = self._proto;const other = try RO.fixupDict(other_ orelse .{});- p._m = RO.multiplyMatrix(p._m, other.m);- p._is_2d = p._is_2d and other.is_2d;- return self;+ var state = self._proto.getState();+ state.matrix = RO.multiplyMatrix(state.matrix, other.m);+ state.is_2d = state.is_2d and other.is_2d;+ return self.applyState(state);}pub fn preMultiplySelf(self: *DOMMatrix, other_: ?RO.DOMMatrixInit) !*DOMMatrix {- const p = self._proto;const other = try RO.fixupDict(other_ orelse .{});- p._m = RO.multiplyMatrix(other.m, p._m);- p._is_2d = p._is_2d and other.is_2d;- return self;+ var state = self._proto.getState();+ state.matrix = RO.multiplyMatrix(other.m, state.matrix);+ state.is_2d = state.is_2d and other.is_2d;+ return self.applyState(state);}-pub fn invertSelf(self: *DOMMatrix) *DOMMatrix {- const p = self._proto;- if (RO.invertMatrix(p._m)) |v| {- p._m = v;+pub fn invertSelf(self: *DOMMatrix) !*DOMMatrix {+ var state = self._proto.getState();+ if (RO.invertMatrix(state.matrix)) |v| {+ state.matrix = v;} else {- p._m = .{std.math.nan(f64)} ** 16;- p._is_2d = false;+ state.matrix = .{std.math.nan(f64)} ** 16;+ state.is_2d = false;}- return self;+ return self.applyState(state);}pub fn setMatrixValue(self: *DOMMatrix, transform: []const u8) !*DOMMatrix {- var m = RO.identity();- var is_2d = true;- try RO.parseTransformList(transform, &m, &is_2d);- self._proto._m = m;- self._proto._is_2d = is_2d;+ var state: RO.State = .{ .matrix = RO.identity(), .is_2d = true };+ try RO.parseTransformList(transform, &state.matrix, &state.is_2d);+ try self._proto.applyState(state);+ return self;+}++fn setElement(self: *DOMMatrix, comptime index: usize, value: f64) !void {+ var state = self._proto.getState();+ state.matrix[index] = value;++ // Assigning a z/w element a value other than its identity drops the+ // 2D flag. Setting it back does not restore is2D.+ switch (index) {+ 2, 3, 6, 7, 8, 9, 11, 14 => if (value != 0) {+ state.is_2d = false;+ },+ 10, 15 => if (value != 1) {+ state.is_2d = false;+ },+ else => {},+ }+ try self._proto.applyState(state);+}++fn applyState(self: *DOMMatrix, state: RO.State) !*DOMMatrix {+ try self._proto.applyState(state);return self;}@@ -281,23 +302,10 @@ pub const JsApi = struct {}.get;}- fn setM(comptime idx: usize) fn (*DOMMatrix, f64) void {+ fn setM(comptime idx: usize) fn (*DOMMatrix, f64) anyerror!void {return struct {- fn set(self: *DOMMatrix, v: f64) void {- self._proto._m[idx] = v;- // Assigning a z/w element a value other than its identity drops the- // 2D flag. Setting it back to the identity value (0 for the- // off-diagonal elements, 1 for m33/m44) preserves is2D. Note `-0`- // compares equal to `0`, so it preserves it too, per spec.- switch (idx) {- 2, 3, 6, 7, 8, 9, 11, 14 => if (v != 0) {- self._proto._is_2d = false;- },- 10, 15 => if (v != 1) {- self._proto._is_2d = false;- },- else => {},- }+ fn set(self: *DOMMatrix, v: f64) !void {+ try self.setElement(idx, v);}}.set;}diff --git a/src/browser/webapi/DOMMatrixReadOnly.zig b/src/browser/webapi/DOMMatrixReadOnly.zigindex 052414ab8..d86f8dd66 100644--- a/src/browser/webapi/DOMMatrixReadOnly.zig+++ b/src/browser/webapi/DOMMatrixReadOnly.zig@@ -44,12 +44,24 @@ _arena: Allocator,// out[row] = sum_col _m[col*4 + row] * in[col]_m: [16]f64,_is_2d: bool,+_attachment: ?Attachment = null,pub const Type = union(enum) {generic,mutable: *DOMMatrix,};+pub const State = struct {+ matrix: [16]f64,+ is_2d: bool,+};++pub const Attachment = struct {+ owner: *anyopaque,+ read_only: bool,+ mutate: *const fn (*anyopaque, *DOMMatrixReadOnly, State) anyerror!void,+};+pub fn init(init_: ?js.Value, exec: *const js.Execution) !*DOMMatrixReadOnly {const parsed = try Parsed.init(init_, exec);return createBare(parsed.m, parsed.is_2d, exec.page);@@ -82,6 +94,40 @@ pub fn createBare(m: [16]f64, is_2d: bool, page: *Page) !*DOMMatrixReadOnly {return self;}+pub fn getState(self: *const DOMMatrixReadOnly) State {+ return .{+ .matrix = self._m,+ .is_2d = self._is_2d,+ };+}++pub fn applyState(self: *DOMMatrixReadOnly, state: State) !void {+ if (self._attachment) |attachment| {+ if (attachment.read_only) return error.NoModificationAllowed;+ return attachment.mutate(attachment.owner, self, state);+ }+ self.applyStateRaw(state);+}++pub fn applyStateRaw(self: *DOMMatrixReadOnly, state: State) void {+ self._m = state.matrix;+ self._is_2d = state.is_2d;+}++pub fn attach(self: *DOMMatrixReadOnly, attachment: Attachment) void {+ self._attachment = attachment;+}++pub fn detach(self: *DOMMatrixReadOnly, owner: *anyopaque) void {+ const attachment = self._attachment orelse return;+ if (attachment.owner == owner) self._attachment = null;+}++pub fn isAttachedTo(self: *const DOMMatrixReadOnly, owner: *anyopaque) bool {+ const attachment = self._attachment orelse return false;+ return attachment.owner == owner;+}+pub const DOMMatrixInit = struct {a: ?f64 = null,b: ?f64 = null,@@ -432,7 +478,6 @@ pub fn parseTransformFunction(function: TransformFunction, syntax: TransformSynt}if (Eql(u8, name, "matrix3d")) {- if (syntax == .svg) return error.SyntaxError;try requireCount(count, 16, 16);try requireUnitless(units[0..count]);return makeParsedTransform(.matrix3d, values, values, count, false);diff --git a/src/browser/webapi/svg/PointList.zig b/src/browser/webapi/svg/PointList.zigindex 558a04c89..e412b8ed1 100644--- a/src/browser/webapi/svg/PointList.zig+++ b/src/browser/webapi/svg/PointList.zig@@ -72,8 +72,9 @@ pub fn getNumberOfItems(self: *PointList, frame: *Frame) !u32 {pub fn clear(self: *PointList, frame: *Frame) !void {try self.requireMutable();try self.sync(frame);- try self.retireAll(frame);+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);try self.setAttribute(&.{}, frame);+ self.retireAllAssumeCapacity();}pub fn initialize(self: *PointList, item: *DOMPoint, frame: *Frame) !*DOMPoint {@@ -83,9 +84,10 @@ pub fn initialize(self: *PointList, item: *DOMPoint, frame: *Frame) !*DOMPoint {const prepared = try self.prepareItem(item, frame);errdefer prepared._proto.releaseRef(frame._page);- try self.retireAll(frame);try self._items.ensureTotalCapacity(frame.arena, 1);+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);try self.setAttribute(&.{prepared}, frame);+ self.retireAllAssumeCapacity();self._items.appendAssumeCapacity(prepared);self.attach(prepared);return prepared;@@ -218,17 +220,20 @@ fn sync(self: *PointList, frame: *Frame) !void {return;}- self._synced = false;var parsed = parse(raw, frame) catch |err| switch (err) {error.SyntaxError => std.ArrayList(*DOMPoint).empty,else => return err,};errdefer for (parsed.items) |point| point._proto.releaseRef(frame._page);- self._snapshot.clearRetainingCapacity();- try self._snapshot.appendSlice(frame.arena, raw);- try self.retireAll(frame);+ try self._snapshot.ensureTotalCapacity(frame.arena, raw.len);+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);try self._items.ensureTotalCapacity(frame.arena, parsed.items.len);++ self._synced = false;+ self._snapshot.clearRetainingCapacity();+ self._snapshot.appendSliceAssumeCapacity(raw);+ self.retireAllAssumeCapacity();for (parsed.items) |point| {self._items.appendAssumeCapacity(point);self.attach(point);@@ -264,9 +269,7 @@ fn parse(raw: []const u8, frame: *Frame) !std.ArrayList(*DOMPoint) {return parsed;}-fn retireAll(self: *PointList, frame: *Frame) !void {- self._synced = false;- try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);+fn retireAllAssumeCapacity(self: *PointList) void {for (self._items.items) |point| {point._proto.detach(self);self._retired.appendAssumeCapacity(point);@@ -303,10 +306,11 @@ fn setAttributeWithOverride(}fn commitAttribute(self: *PointList, serialized: []const u8, frame: *Frame) !void {- self._synced = false;+ try self._snapshot.ensureTotalCapacity(frame.arena, serialized.len);try self._element.setAttributeSafe(comptime .wrap("points"), .wrap(serialized), frame);+ self._synced = false;self._snapshot.clearRetainingCapacity();- try self._snapshot.appendSlice(frame.arena, serialized);+ self._snapshot.appendSliceAssumeCapacity(serialized);self._synced = true;}diff --git a/src/browser/webapi/svg/Transform.zig b/src/browser/webapi/svg/Transform.zigindex a1e427593..d79ab1839 100644--- a/src/browser/webapi/svg/Transform.zig+++ b/src/browser/webapi/svg/Transform.zig@@ -77,19 +77,24 @@ pub fn releaseRef(self: *Transform, page: *Page) void {pub fn detached(frame: *Frame) !*Transform {const matrix = try DOMMatrix.create(RO.identity(), true, frame._page);errdefer matrix._proto.deinit(frame._page);- return frame._factory.create(Transform{ ._matrix = matrix });+ const self = try frame._factory.create(Transform{ ._matrix = matrix });+ self.attachMatrix(false);+ return self;}pub fn fromMatrix(init: ?DOMMatrix2DInit, frame: *Frame) !*Transform {const parsed = try fixup2D(init orelse .{});const matrix = try DOMMatrix.create(parsed.m, true, frame._page);errdefer matrix._proto.deinit(frame._page);- return frame._factory.create(Transform{ ._matrix = matrix });+ const self = try frame._factory.create(Transform{ ._matrix = matrix });+ self.attachMatrix(false);+ return self;}pub fn fromParsed(parsed: RO.ParsedTransform, frame: *Frame) !*Transform {const typ: u16 = switch (parsed.kind) {.matrix => 1,+ .matrix3d => 0,.translate => 2,.scale => 3,.rotate => 4,@@ -99,26 +104,30 @@ pub fn fromParsed(parsed: RO.ParsedTransform, frame: *Frame) !*Transform {};const matrix = try DOMMatrix.create(parsed.matrix, parsed.is_2d, frame._page);errdefer matrix._proto.deinit(frame._page);- return frame._factory.create(Transform{+ const self = try frame._factory.create(Transform{._type = typ,._angle = if (typ >= 4) parsed.values[0] else 0,._cx = if (typ == 4 and parsed.count == 3) parsed.values[1] else 0,._cy = if (typ == 4 and parsed.count == 3) parsed.values[2] else 0,._matrix = matrix,});+ self.attachMatrix(false);+ return self;}pub fn clone(self: *const Transform, frame: *Frame) !*Transform {const current = self.getState();const matrix = try DOMMatrix.create(current.matrix, current.is_2d, frame._page);errdefer matrix._proto.deinit(frame._page);- return frame._factory.create(Transform{+ const cloned = try frame._factory.create(Transform{._type = current.typ,._angle = current.angle,._cx = current.cx,._cy = current.cy,._matrix = matrix,});+ cloned.attachMatrix(false);+ return cloned;}pub fn getType(self: *const Transform) u16 {@@ -183,8 +192,10 @@ pub fn applyStateRaw(self: *Transform, state: State) void {self._angle = state.angle;self._cx = state.cx;self._cy = state.cy;- self._matrix._proto._m = state.matrix;- self._matrix._proto._is_2d = state.is_2d;+ self._matrix._proto.applyStateRaw(.{+ .matrix = state.matrix,+ .is_2d = state.is_2d,+ });}fn applyState(self: *Transform, state: State) !void {@@ -198,11 +209,15 @@ fn applyState(self: *Transform, state: State) !void {pub fn attach(self: *Transform, attachment: Attachment) void {self._attachment = attachment;+ self.attachMatrix(attachment.read_only);}pub fn detach(self: *Transform, owner: *anyopaque) void {const attachment = self._attachment orelse return;- if (attachment.owner == owner) self._attachment = null;+ if (attachment.owner == owner) {+ self._attachment = null;+ self.attachMatrix(false);+ }}pub fn isAttached(self: *const Transform) bool {@@ -216,6 +231,12 @@ pub fn isAttachedTo(self: *const Transform, owner: *anyopaque) bool {pub fn writeState(state: State, writer: anytype) !void {switch (state.typ) {+ 0 => try writer.print("matrix3d({d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d}, {d})", .{+ state.matrix[0], state.matrix[1], state.matrix[2], state.matrix[3],+ state.matrix[4], state.matrix[5], state.matrix[6], state.matrix[7],+ state.matrix[8], state.matrix[9], state.matrix[10], state.matrix[11],+ state.matrix[12], state.matrix[13], state.matrix[14], state.matrix[15],+ }),1 => try writer.print("matrix({d} {d} {d} {d} {d} {d})", .{state.matrix[0], state.matrix[1], state.matrix[4], state.matrix[5], state.matrix[12], state.matrix[13],}),@@ -231,6 +252,26 @@ pub fn writeState(state: State, writer: anytype) !void {}}+fn attachMatrix(self: *Transform, read_only: bool) void {+ self._matrix._proto.attach(.{+ .owner = self,+ .read_only = read_only,+ .mutate = Transform.mutateMatrix,+ });+}++fn mutateMatrix(context: *anyopaque, _: *RO, state: RO.State) anyerror!void {+ const self: *Transform = @ptrCast(@alignCast(context));+ try self.applyState(.{+ .typ = if (state.is_2d) 1 else 0,+ .angle = 0,+ .cx = 0,+ .cy = 0,+ .matrix = state.matrix,+ .is_2d = state.is_2d,+ });+}+fn fixup2D(init: DOMMatrix2DInit) !RO.Parsed {const parsed = try RO.fixupDict(.{.a = init.a,diff --git a/src/browser/webapi/svg/TransformList.zig b/src/browser/webapi/svg/TransformList.zigindex 773b2557b..729e33223 100644--- a/src/browser/webapi/svg/TransformList.zig+++ b/src/browser/webapi/svg/TransformList.zig@@ -53,8 +53,9 @@ pub fn getNumberOfItems(self: *TransformList, frame: *Frame) !u32 {pub fn clear(self: *TransformList, frame: *Frame) !void {try self.requireMutable();try self.sync(frame);- try self.retireAll(frame);+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);try self.setAttribute(&.{}, frame);+ self.retireAllAssumeCapacity();}pub fn initialize(self: *TransformList, item: *Transform, frame: *Frame) !*Transform {@@ -63,9 +64,10 @@ pub fn initialize(self: *TransformList, item: *Transform, frame: *Frame) !*Transconst prepared = try self.prepareItem(item, frame);errdefer prepared.releaseRef(frame._page);- try self.retireAll(frame);try self._items.ensureTotalCapacity(frame.arena, 1);+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);try self.setAttribute(&.{prepared}, frame);+ self.retireAllAssumeCapacity();self._items.appendAssumeCapacity(prepared);self.attach(prepared);return prepared;@@ -140,28 +142,36 @@ pub fn consolidate(self: *TransformList, frame: *Frame) !?*Transform {if (self._items.items.len == 0) return null;var matrix = DOMMatrixReadOnly.identity();- for (self._items.items) |item| matrix = DOMMatrixReadOnly.multiplyMatrix(matrix, item.getState().matrix);+ var is_2d = true;+ for (self._items.items) |item| {+ const state = item.getState();+ matrix = DOMMatrixReadOnly.multiplyMatrix(matrix, state.matrix);+ is_2d = is_2d and state.is_2d;+ }for (matrix) |value| if (!std.math.isFinite(value)) return error.TypeError;- var values: [16]f64 = undefined;- values[0] = matrix[0];- values[1] = matrix[1];- values[2] = matrix[4];- values[3] = matrix[5];- values[4] = matrix[12];- values[5] = matrix[13];+ var values: [16]f64 = matrix;+ if (is_2d) {+ values[0] = matrix[0];+ values[1] = matrix[1];+ values[2] = matrix[4];+ values[3] = matrix[5];+ values[4] = matrix[12];+ values[5] = matrix[13];+ }const consolidated = try Transform.fromParsed(.{- .kind = .matrix,+ .kind = if (is_2d) .matrix else .matrix3d,.matrix = matrix,.values = values,- .count = 6,- .is_2d = true,+ .count = if (is_2d) 6 else 16,+ .is_2d = is_2d,}, frame);consolidated.acquireRef();errdefer consolidated.releaseRef(frame._page);- try self.retireAll(frame);try self._items.ensureTotalCapacity(frame.arena, 1);+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);try self.setAttribute(&.{consolidated}, frame);+ self.retireAllAssumeCapacity();self._items.appendAssumeCapacity(consolidated);self.attach(consolidated);return consolidated;@@ -206,17 +216,20 @@ fn sync(self: *TransformList, frame: *Frame) !void {const raw = self._element.getAttributeSafe(comptime .wrap("transform")) orelse "";if (self._synced and std.mem.eql(u8, self._snapshot.items, raw)) return;- self._synced = false;var parsed = parse(raw, frame) catch |err| switch (err) {error.SyntaxError => std.ArrayList(*Transform).empty,else => return err,};errdefer for (parsed.items) |transform| transform.releaseRef(frame._page);- self._snapshot.clearRetainingCapacity();- try self._snapshot.appendSlice(frame.arena, raw);- try self.retireAll(frame);+ try self._snapshot.ensureTotalCapacity(frame.arena, raw.len);+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);try self._items.ensureTotalCapacity(frame.arena, parsed.items.len);++ self._synced = false;+ self._snapshot.clearRetainingCapacity();+ self._snapshot.appendSliceAssumeCapacity(raw);+ self.retireAllAssumeCapacity();for (parsed.items) |transform| {self._items.appendAssumeCapacity(transform);self.attach(transform);@@ -254,9 +267,7 @@ fn parse(raw: []const u8, frame: *Frame) !std.ArrayList(*Transform) {return parsed;}-fn retireAll(self: *TransformList, frame: *Frame) !void {- self._synced = false;- try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);+fn retireAllAssumeCapacity(self: *TransformList) void {for (self._items.items) |transform| {transform.detach(self);self._retired.appendAssumeCapacity(transform);@@ -285,10 +296,11 @@ fn setAttributeWithOverride(self: *TransformList, index: usize, state: Transform}fn commitAttribute(self: *TransformList, serialized: []const u8, frame: *Frame) !void {- self._synced = false;+ try self._snapshot.ensureTotalCapacity(frame.arena, serialized.len);try self._element.setAttributeSafe(comptime .wrap("transform"), .wrap(serialized), frame);+ self._synced = false;self._snapshot.clearRetainingCapacity();- try self._snapshot.appendSlice(frame.arena, serialized);+ self._snapshot.appendSliceAssumeCapacity(serialized);self._synced = true;}