Lightpanda: the headless browser designed for AI and automation
webapi: add live SVG collections
Madison Steiner2e45e6487af7
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zigindex a9e7adfa3..477081bd0 100644--- a/src/browser/Frame.zig+++ b/src/browser/Frame.zig@@ -89,6 +89,11 @@ pub const BUF_SIZE = 1024;const Frame = @This();+pub const SvgCollectionCleanup = struct {+ context: *anyopaque,+ callback: *const fn (*anyopaque, *Page) void,+};+// This is the "id" of the frame. It can be re-used from frame-to-frame, e.g.// when navigating._frame_id: u32,@@ -148,6 +153,7 @@ _element_namespace_uris: Element.NamespaceUriLookup = .empty,_svg_animated_lengths: AnimatedLength.Lookup = .empty,_svg_animated_preserve_aspect_ratios: AnimatedPreserveAspectRatio.Lookup = .empty,_svg_animated_strings: AnimatedString.Lookup = .empty,+_svg_collection_cleanups: std.ArrayList(SvgCollectionCleanup) = .empty,// Same as above, but for Nodes (slot assigments apply to both Element AND// Text nodes)@@ -503,6 +509,11 @@ pub fn deinit(self: *Frame) void {observers.deinit(self, page);+ for (self._svg_collection_cleanups.items) |cleanup| {+ cleanup.callback(cleanup.context, page);+ }+ self._svg_collection_cleanups = .empty;+var document = self.window._document;document._selection.releaseRef(page);@@ -535,6 +546,10 @@ pub fn deinit(self: *Frame) void {page.releaseArena(self.local_arena);}+pub fn registerSvgCollectionCleanup(self: *Frame, cleanup: SvgCollectionCleanup) !void {+ try self._svg_collection_cleanups.append(self.arena, cleanup);+}+pub fn trackWorker(self: *Frame, worker: *Worker) !void {try self.workers.append(self.arena, worker);}diff --git a/src/browser/js/bridge.zig b/src/browser/js/bridge.zigindex cdb6c021d..021bdb9e3 100644--- a/src/browser/js/bridge.zig+++ b/src/browser/js/bridge.zig@@ -1076,6 +1076,10 @@ pub const PageJsApis = flattenTypes(&.{@import("../webapi/svg/AnimatedLength.zig"),@import("../webapi/svg/PreserveAspectRatio.zig"),@import("../webapi/svg/AnimatedPreserveAspectRatio.zig"),+ @import("../webapi/svg/PointList.zig"),+ @import("../webapi/svg/TransformList.zig"),+ @import("../webapi/svg/AnimatedTransformList.zig"),+ @import("../webapi/svg/StringList.zig"),@import("../webapi/encoding/TextDecoder.zig"),@import("../webapi/encoding/TextEncoder.zig"),@import("../webapi/encoding/TextEncoderStream.zig"),diff --git a/src/browser/tests/element/svg/collections.html b/src/browser/tests/element/svg/collections.htmlnew file mode 100644index 000000000..f3dcadc3d--- /dev/null+++ b/src/browser/tests/element/svg/collections.html@@ -0,0 +1,201 @@+<!DOCTYPE html>+<script src="../../testing.js"></script>++<svg id=root>+ <polygon id=polygon points="0,0 10,20"></polygon>+ <polyline id=polyline points="1 2, 3 4"></polyline>+ <polyline id=many></polyline>+ <g id=group transform="translate(10 20) rotate(45 1 2)"+ requiredExtensions="urn:one urn:two" systemLanguage="en, fr"></g>+</svg>++<script id=pointLists>+{+ const root = $('#root');+ const polygon = $('#polygon');+ const points = polygon.points;+ const animated = polygon.animatedPoints;++ testing.expectEqual(true, points instanceof SVGPointList);+ testing.expectEqual(true, points === polygon.points);+ testing.expectEqual(true, animated === polygon.animatedPoints);+ testing.expectEqual(false, points === animated);+ testing.expectEqual(2, points.length);+ testing.expectEqual(2, points.numberOfItems);+ testing.expectEqual(true, points.getItem(0) === points.getItem(0));+ testing.expectEqual(10, points.getItem(1).x);+ testing.expectEqual(20, points.getItem(1).y);++ const oldPoint = points.getItem(0);+ oldPoint.x = 5;+ testing.expectEqual('5,0 10,20', polygon.getAttribute('points'));+ testing.expectEqual(5, animated.getItem(0).x);++ polygon.setAttribute('points', '1 2, 3 4');+ testing.expectEqual(2, points.length);+ testing.expectEqual(1, points.getItem(0).x);+ oldPoint.x = 99;+ testing.expectEqual('1 2, 3 4', polygon.getAttribute('points'));++ polygon.setAttribute('points', '1,2,3');+ testing.expectEqual(0, points.length);+ testing.expectEqual('1,2,3', polygon.getAttribute('points'));+ polygon.setAttribute('points', '0,0');++ const detached = root.createSVGPoint();+ detached.x = 7;+ detached.y = 8;+ testing.expectEqual(detached, points.appendItem(detached));+ const copied = points.appendItem(detached);+ testing.expectEqual(false, copied === detached);+ testing.expectEqual(3, points.length);+ detached.x = 9;+ testing.expectEqual(9, points.getItem(1).x);+ testing.expectEqual(7, copied.x);++ testing.expectEqual(detached, points.removeItem(1));+ detached.y = 12;+ testing.expectEqual(12, detached.y);+ testing.expectError('IndexSizeError', () => points.getItem(99));+ testing.expectError('IndexSizeError', () => points.replaceItem(root.createSVGPoint(), 99));+ testing.expectError('IndexSizeError', () => points.removeItem(99));++ testing.expectError('NoModificationAllowedError', () => animated.clear());+ testing.expectError('NoModificationAllowedError', () => animated.appendItem(root.createSVGPoint()));+ testing.expectError('NoModificationAllowedError', () => { animated.getItem(0).x = 4; });+}+</script>++<script id=pointListCapacityAndPolyline>+{+ const root = $('#root');+ const list = $('#many').points;+ for (let i = 0; i < 70; i++) {+ const point = root.createSVGPoint();+ point.x = i;+ point.y = -i;+ list.appendItem(point);+ }+ testing.expectEqual(70, list.numberOfItems);+ testing.expectEqual(69, list.getItem(69).x);+ testing.expectEqual(-69, list.getItem(69).y);++ const polyline = $('#polyline');+ testing.expectEqual(true, polyline.points instanceof SVGPointList);+ testing.expectEqual(2, polyline.points.length);+ const initialized = root.createSVGPoint();+ initialized.x = 4;+ initialized.y = 5;+ polyline.points.initialize(initialized);+ testing.expectEqual('4,5', polyline.getAttribute('points'));+ polyline.points.clear();+ testing.expectEqual('', polyline.getAttribute('points'));+}+</script>++<script id=transformLists>+{+ const root = $('#root');+ const group = $('#group');+ const animated = group.transform;+ const base = animated.baseVal;+ const anim = animated.animVal;++ testing.expectEqual(true, animated instanceof SVGAnimatedTransformList);+ testing.expectEqual(true, animated === group.transform);+ testing.expectEqual(true, base === animated.baseVal);+ testing.expectEqual(true, anim === animated.animVal);+ testing.expectEqual(false, base === anim);+ testing.expectEqual(true, base instanceof SVGTransformList);+ testing.expectEqual(2, base.numberOfItems);+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_TRANSLATE, base.getItem(0).type);+ testing.expectEqual(10, base.getItem(0).matrix.e);+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_ROTATE, base.getItem(1).type);+ testing.expectEqual(45, base.getItem(1).angle);+ testing.expectEqual(true, base.getItem(1).matrix === base.getItem(1).matrix);++ const oldTransform = base.getItem(0);+ oldTransform.setTranslate(3, 4);+ testing.expectEqual(true, group.getAttribute('transform').startsWith('translate(3 4)'));+ testing.expectEqual(3, anim.getItem(0).matrix.e);++ group.setAttribute('transform', 'scale(2)');+ testing.expectEqual(1, base.length);+ testing.expectEqual(2, base.getItem(0).matrix.a);+ oldTransform.setTranslate(8, 9);+ testing.expectEqual('scale(2)', group.getAttribute('transform'));++ const detached = root.createSVGTransform();+ detached.setSkewX(15);+ testing.expectEqual(detached, base.appendItem(detached));+ const copied = base.appendItem(detached);+ testing.expectEqual(false, copied === detached);+ testing.expectEqual(3, base.length);++ testing.expectError('IndexSizeError', () => base.getItem(99));+ testing.expectError('IndexSizeError', () => base.replaceItem(root.createSVGTransform(), 99));+ testing.expectError('IndexSizeError', () => base.removeItem(99));+ testing.expectError('NoModificationAllowedError', () => anim.clear());+ testing.expectError('NoModificationAllowedError', () => anim.appendItem(root.createSVGTransform()));+ testing.expectError('NoModificationAllowedError', () => anim.getItem(0).setScale(3, 3));++ const consolidated = base.consolidate();+ testing.expectEqual(true, consolidated instanceof SVGTransform);+ testing.expectEqual(SVGTransform.SVG_TRANSFORM_MATRIX, consolidated.type);+ testing.expectEqual(1, base.length);+ testing.expectEqual(true, group.getAttribute('transform').startsWith('matrix('));+}+</script>++<script id=transformParserRegression>+{+ const group = $('#group');+ group.setAttribute('transform', 'translate()');+ testing.expectEqual(0, group.transform.baseVal.length);+ testing.expectEqual('translate()', group.getAttribute('transform'));++ group.setAttribute('transform', 'translate(1 2) scale(3,4) rotate(30 5 6)');+ testing.expectEqual(3, group.transform.baseVal.length);+ testing.expectEqual(2, group.transform.baseVal.getItem(0).matrix.f);+ testing.expectEqual(4, group.transform.baseVal.getItem(1).matrix.d);+ testing.expectEqual(30, group.transform.baseVal.getItem(2).angle);++ testing.expectError('SyntaxError', () => new DOMMatrix('translate()'));+ testing.expectError('SyntaxError', () => new DOMMatrix('scale()'));+ const matrix = new DOMMatrix('translate(3px 4px) scale(2 3)');+ testing.expectEqual(3, matrix.e);+ testing.expectEqual(4, matrix.f);+}+</script>++<script id=stringLists>+{+ const group = $('#group');+ const required = group.requiredExtensions;+ const languages = group.systemLanguage;++ testing.expectEqual(true, required instanceof SVGStringList);+ testing.expectEqual(true, required === group.requiredExtensions);+ testing.expectEqual(true, languages === group.systemLanguage);+ testing.expectEqual(2, required.numberOfItems);+ testing.expectEqual('urn:one', required.getItem(0));+ testing.expectEqual(2, languages.length);+ testing.expectEqual('fr', languages.getItem(1));++ required.appendItem('urn:three');+ testing.expectEqual('urn:one urn:two urn:three', group.getAttribute('requiredExtensions'));+ testing.expectEqual('urn:two', required.removeItem(1));+ testing.expectEqual('urn:one urn:three', group.getAttribute('requiredExtensions'));+ testing.expectError('SyntaxError', () => required.appendItem('two words'));+ testing.expectError('IndexSizeError', () => required.getItem(99));++ languages.insertItemBefore('de', 1);+ testing.expectEqual('en, de, fr', group.getAttribute('systemLanguage'));+ group.setAttribute('systemLanguage', 'ja, ko');+ testing.expectEqual(2, languages.length);+ testing.expectEqual('ko', languages.getItem(1));+ group.setAttribute('systemLanguage', 'en,,fr');+ testing.expectEqual(0, languages.length);+ testing.expectEqual('en,,fr', group.getAttribute('systemLanguage'));+}+</script>diff --git a/src/browser/webapi/DOMMatrixReadOnly.zig b/src/browser/webapi/DOMMatrixReadOnly.zigindex d0340f942..052414ab8 100644--- a/src/browser/webapi/DOMMatrixReadOnly.zig+++ b/src/browser/webapi/DOMMatrixReadOnly.zig@@ -312,178 +312,274 @@ pub fn invertMatrix(m: [16]f64) ?[16]f64 {return out;}-// Parses a CSS <transform-list> (e.g. "matrix(1,0,0,1,10,20) scale(2)") and-// accumulates it into `m`. "none"/empty leave the matrix as identity.-pub fn parseTransformList(input: []const u8, m: *[16]f64, is_2d: *bool) !void {- const trimmed = std.mem.trim(u8, input, " \t\r\n");- if (trimmed.len == 0 or std.mem.eql(u8, trimmed, "none")) {- return;- }+pub const TransformSyntax = enum { css, svg };++pub const TransformKind = enum {+ matrix,+ matrix3d,+ translate,+ translate_x,+ translate_y,+ translate_z,+ translate_3d,+ scale,+ scale_x,+ scale_y,+ scale_z,+ scale_3d,+ rotate,+ rotate_x,+ rotate_y,+ rotate_z,+ rotate_3d,+ skew,+ skew_x,+ skew_y,+ perspective,+};- var i: usize = 0;- while (i < trimmed.len) {- // skip whitespace and separating commas- while (i < trimmed.len and (std.ascii.isWhitespace(trimmed[i]) or trimmed[i] == ',')) : (i += 1) {}- if (i >= trimmed.len) {- break;- }+pub const ParsedTransform = struct {+ kind: TransformKind,+ matrix: [16]f64,+ values: [16]f64,+ count: usize,+ is_2d: bool,+};++pub const TransformFunction = struct {+ name: []const u8,+ arguments: []const u8,+};- const name_start = i;- while (i < trimmed.len and trimmed[i] != '(') : (i += 1) {}- if (i >= trimmed.len) {+pub const TransformFunctionIterator = struct {+ input: []const u8,+ index: usize = 0,+ allow_comma: bool = false,++ pub fn next(self: *TransformFunctionIterator) !?TransformFunction {+ while (self.index < self.input.len and std.ascii.isWhitespace(self.input[self.index])) self.index += 1;+ if (self.index == self.input.len) return null;+ if (self.input[self.index] == ',') return error.SyntaxError;++ const name_start = self.index;+ while (self.index < self.input.len and+ (std.ascii.isAlphabetic(self.input[self.index]) or std.ascii.isDigit(self.input[self.index])))+ {+ self.index += 1;+ }+ if (self.index == name_start or self.index >= self.input.len or self.input[self.index] != '(') {return error.SyntaxError;}- const name = std.mem.trim(u8, trimmed[name_start..i], " \t\r\n");+ const name = self.input[name_start..self.index];+ self.index += 1;- i += 1; // consume '('- const args_start = i;- while (i < trimmed.len and trimmed[i] != ')') : (i += 1) {}- if (i >= trimmed.len) {+ const arguments_start = self.index;+ while (self.index < self.input.len and self.input[self.index] != ')') {+ if (self.input[self.index] == '(') return error.SyntaxError;+ self.index += 1;+ }+ if (self.index == self.input.len) return error.SyntaxError;+ const arguments = self.input[arguments_start..self.index];+ self.index += 1;++ var had_whitespace = false;+ while (self.index < self.input.len and std.ascii.isWhitespace(self.input[self.index])) {+ had_whitespace = true;+ self.index += 1;+ }+ if (self.index < self.input.len and self.input[self.index] == ',') {+ if (!self.allow_comma) return error.SyntaxError;+ self.index += 1;+ while (self.index < self.input.len and std.ascii.isWhitespace(self.input[self.index])) self.index += 1;+ if (self.index == self.input.len) return error.SyntaxError;+ } else if (self.index < self.input.len and !had_whitespace) {return error.SyntaxError;}- const args = trimmed[args_start..i];- i += 1; // consume ')'-- const func = try parseFunction(name, args, is_2d);- m.* = multiplyMatrix(m.*, func);+ return .{ .name = name, .arguments = arguments };}-}+};-fn parseFunction(name: []const u8, args: []const u8, is_2d: *bool) ![16]f64 {- var nums: [16]f64 = undefined;- var units: [16]ParsedValue.Unit = undefined;- var count: usize = 0;+// Parses a CSS <transform-list> (e.g. "matrix(1,0,0,1,10,20) scale(2)") and+// accumulates it into `m`. "none"/empty leave the matrix as identity.+pub fn parseTransformList(input: []const u8, m: *[16]f64, is_2d: *bool) !void {+ const trimmed = std.mem.trim(u8, input, " \t\r\n");+ if (trimmed.len == 0 or std.mem.eql(u8, trimmed, "none")) return;- var it = std.mem.splitScalar(u8, args, ',');- while (it.next()) |raw| {- const tok = std.mem.trim(u8, raw, " \t\r\n");- if (tok.len == 0) {- continue;- }- if (count >= 16) {- return error.SyntaxError;- }- const parsed = try ParsedValue.parse(tok);- nums[count] = parsed.value;- units[count] = parsed.unit;- count += 1;+ var iterator = TransformFunctionIterator{ .input = trimmed };+ while (try iterator.next()) |function| {+ const parsed = try parseTransformFunction(function, .css);+ m.* = multiplyMatrix(m.*, parsed.matrix);+ if (!parsed.is_2d) is_2d.* = false;}+}+pub fn parseTransformFunction(function: TransformFunction, syntax: TransformSyntax) !ParsedTransform {+ var values: [16]f64 = undefined;+ var units: [16]ParsedValue.Unit = undefined;+ const count = try parseArguments(function.arguments, &values, &units);+ const name = function.name;const Eql = std.mem.eql;+if (Eql(u8, name, "matrix")) {- if (count != 6) {- return error.SyntaxError;- }- return .{- nums[0], nums[1], 0, 0,- nums[2], nums[3], 0, 0,- 0, 0, 1, 0,- nums[4], nums[5], 0, 1,- };+ try requireCount(count, 6, 6);+ try requireUnitless(units[0..count]);+ return makeParsedTransform(.matrix, .{+ values[0], values[1], 0, 0,+ values[2], values[3], 0, 0,+ 0, 0, 1, 0,+ values[4], values[5], 0, 1,+ }, values, count, true);}if (Eql(u8, name, "matrix3d")) {- if (count != 16) {- return error.SyntaxError;- }- is_2d.* = false;- return nums;+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 16, 16);+ try requireUnitless(units[0..count]);+ return makeParsedTransform(.matrix3d, values, values, count, false);}if (Eql(u8, name, "translate")) {- const tx = nums[0];- const ty = if (count > 1) nums[1] else 0;- return translationMatrix(tx, ty, 0);+ try requireCount(count, 1, 2);+ if (syntax == .svg) try requireUnitless(units[0..count]);+ const ty = if (count == 2) values[1] else 0;+ return makeParsedTransform(.translate, translationMatrix(values[0], ty, 0), values, count, true);}-if (Eql(u8, name, "translateX")) {- return translationMatrix(nums[0], 0, 0);+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 1, 1);+ return makeParsedTransform(.translate_x, translationMatrix(values[0], 0, 0), values, count, true);}-if (Eql(u8, name, "translateY")) {- return translationMatrix(0, nums[0], 0);+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 1, 1);+ return makeParsedTransform(.translate_y, translationMatrix(0, values[0], 0), values, count, true);}-if (Eql(u8, name, "translateZ")) {- is_2d.* = false;- return translationMatrix(0, 0, nums[0]);+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 1, 1);+ return makeParsedTransform(.translate_z, translationMatrix(0, 0, values[0]), values, count, false);}-if (Eql(u8, name, "translate3d")) {- is_2d.* = false;- return translationMatrix(nums[0], nums[1], nums[2]);+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 3, 3);+ return makeParsedTransform(.translate_3d, translationMatrix(values[0], values[1], values[2]), values, count, false);}if (Eql(u8, name, "scale")) {- const sx = nums[0];- const sy = if (count > 1) nums[1] else sx;- return scaleMatrix(sx, sy, 1);+ try requireCount(count, 1, 2);+ try requireUnitless(units[0..count]);+ const sy = if (count == 2) values[1] else values[0];+ return makeParsedTransform(.scale, scaleMatrix(values[0], sy, 1), values, count, true);}-if (Eql(u8, name, "scaleX")) {- return scaleMatrix(nums[0], 1, 1);+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 1, 1);+ try requireUnitless(units[0..count]);+ return makeParsedTransform(.scale_x, scaleMatrix(values[0], 1, 1), values, count, true);}-if (Eql(u8, name, "scaleY")) {- return scaleMatrix(1, nums[0], 1);+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 1, 1);+ try requireUnitless(units[0..count]);+ return makeParsedTransform(.scale_y, scaleMatrix(1, values[0], 1), values, count, true);}-if (Eql(u8, name, "scaleZ")) {- is_2d.* = false;- return scaleMatrix(1, 1, nums[0]);+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 1, 1);+ try requireUnitless(units[0..count]);+ return makeParsedTransform(.scale_z, scaleMatrix(1, 1, values[0]), values, count, false);}-if (Eql(u8, name, "scale3d")) {- is_2d.* = false;- return scaleMatrix(nums[0], nums[1], nums[2]);- }- if (Eql(u8, name, "rotate") or Eql(u8, name, "rotateZ")) {- if (Eql(u8, name, "rotateZ")) is_2d.* = false;- return rotateZMatrix(toRadians(nums[0], units[0]));+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 3, 3);+ try requireUnitless(units[0..count]);+ return makeParsedTransform(.scale_3d, scaleMatrix(values[0], values[1], values[2]), values, count, false);+ }++ if (Eql(u8, name, "rotate")) {+ try requireCount(count, 1, if (syntax == .svg) 3 else 1);+ if (count != 1 and count != 3) return error.SyntaxError;+ try requireAngle(units[0]);+ if (syntax == .svg and units[0] != .none) return error.SyntaxError;+ if (count == 3) try requireUnitless(units[1..3]);+ var matrix = rotateZMatrix(toRadians(values[0], units[0]));+ if (count == 3) {+ matrix = multiplyMatrix(translationMatrix(values[1], values[2], 0), matrix);+ matrix = multiplyMatrix(matrix, translationMatrix(-values[1], -values[2], 0));+ }+ return makeParsedTransform(.rotate, matrix, values, count, true);}-- if (Eql(u8, name, "rotateX")) {- is_2d.* = false;- return rotateXMatrix(toRadians(nums[0], units[0]));+ if (Eql(u8, name, "rotateX") or Eql(u8, name, "rotateY") or Eql(u8, name, "rotateZ")) {+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 1, 1);+ try requireAngle(units[0]);+ if (Eql(u8, name, "rotateX")) return makeParsedTransform(.rotate_x, rotateXMatrix(toRadians(values[0], units[0])), values, count, false);+ if (Eql(u8, name, "rotateY")) return makeParsedTransform(.rotate_y, rotateYMatrix(toRadians(values[0], units[0])), values, count, false);+ return makeParsedTransform(.rotate_z, rotateZMatrix(toRadians(values[0], units[0])), values, count, false);}-- if (Eql(u8, name, "rotateY")) {- is_2d.* = false;- return rotateYMatrix(toRadians(nums[0], units[0]));- }-if (Eql(u8, name, "rotate3d")) {- is_2d.* = false;- if (count != 4) {- return error.SyntaxError;- }- return axisAngleMatrix(nums[0], nums[1], nums[2], toRadians(nums[3], units[3]));+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 4, 4);+ try requireUnitless(units[0..3]);+ try requireAngle(units[3]);+ return makeParsedTransform(.rotate_3d, axisAngleMatrix(values[0], values[1], values[2], toRadians(values[3], units[3])), values, count, false);}if (Eql(u8, name, "skew")) {- const ax = toRadians(nums[0], units[0]);- const ay = if (count > 1) toRadians(nums[1], units[1]) else 0;- return skewMatrix(ax, ay);+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 1, 2);+ try requireAngle(units[0]);+ if (count == 2) try requireAngle(units[1]);+ const ay = if (count == 2) toRadians(values[1], units[1]) else 0;+ return makeParsedTransform(.skew, skewMatrix(toRadians(values[0], units[0]), ay), values, count, true);}-- if (Eql(u8, name, "skewX")) {- return skewMatrix(toRadians(nums[0], units[0]), 0);- }-- if (Eql(u8, name, "skewY")) {- return skewMatrix(0, toRadians(nums[0], units[0]));+ if (Eql(u8, name, "skewX") or Eql(u8, name, "skewY")) {+ try requireCount(count, 1, 1);+ try requireAngle(units[0]);+ if (syntax == .svg and units[0] != .none) return error.SyntaxError;+ if (Eql(u8, name, "skewX")) return makeParsedTransform(.skew_x, skewMatrix(toRadians(values[0], units[0]), 0), values, count, true);+ return makeParsedTransform(.skew_y, skewMatrix(0, toRadians(values[0], units[0])), values, count, true);}if (Eql(u8, name, "perspective")) {- is_2d.* = false;- var out = identity();- if (nums[0] != 0) out[11] = -1.0 / nums[0];- return out;+ if (syntax == .svg) return error.SyntaxError;+ try requireCount(count, 1, 1);+ var matrix = identity();+ if (values[0] != 0) matrix[11] = -1.0 / values[0];+ return makeParsedTransform(.perspective, matrix, values, count, false);}return error.SyntaxError;}+fn makeParsedTransform(kind: TransformKind, matrix: [16]f64, values: [16]f64, count: usize, is_2d: bool) ParsedTransform {+ return .{ .kind = kind, .matrix = matrix, .values = values, .count = count, .is_2d = is_2d };+}++fn requireCount(count: usize, minimum: usize, maximum: usize) !void {+ if (count < minimum or count > maximum) return error.SyntaxError;+}++fn requireUnitless(units: []const ParsedValue.Unit) !void {+ for (units) |unit| if (unit != .none) return error.SyntaxError;+}++fn requireAngle(unit: ParsedValue.Unit) !void {+ if (unit == .other) return error.SyntaxError;+}++fn parseArguments(arguments: []const u8, values: *[16]f64, units: *[16]ParsedValue.Unit) !usize {+ var scanner = ArgumentScanner{ .input = arguments };+ var count: usize = 0;+ while (try scanner.next()) |value| {+ if (count == values.len) return error.SyntaxError;+ values[count] = value.value;+ units[count] = value.unit;+ count += 1;+ }+ return count;+}+pub fn toRadians(value: f64, unit: ParsedValue.Unit) f64 {return switch (unit) {.rad => value,@@ -491,6 +587,7 @@ pub fn toRadians(value: f64, unit: ParsedValue.Unit) f64 {.turn => value * std.math.tau,// bare numbers in rotate()/skew() are interpreted as degrees.deg, .none => value * std.math.pi / 180.0,+ .other => value,};}@@ -725,43 +822,75 @@ const ParsedValue = struct {rad,grad,turn,+ other,};+};- // Parses a single CSS dimension token: a number with an optional unit suffix.- // Length units are ignored (we don't resolve layout), so the numeric part is- // taken verbatim; angle units are recorded so they can be normalised.- fn parse(tok: []const u8) !ParsedValue {- var end: usize = 0;- while (end < tok.len) : (end += 1) {- const c = tok[end];- if ((c >= '0' and c <= '9') or c == '.' or c == '+' or c == '-' or c == 'e' or c == 'E') {- // 'e'/'E' is ambiguous with exponents; only treat as exponent when- // followed by a digit/sign.- if ((c == 'e' or c == 'E') and end > 0) {- if (end + 1 >= tok.len) break;- const nx = tok[end + 1];- if (!((nx >= '0' and nx <= '9') or nx == '+' or nx == '-')) break;- }- continue;- }- break;+const ArgumentScanner = struct {+ input: []const u8,+ index: usize = 0,+ first: bool = true,++ fn next(self: *ArgumentScanner) !?ParsedValue {+ var had_whitespace = false;+ while (self.index < self.input.len and std.ascii.isWhitespace(self.input[self.index])) {+ had_whitespace = true;+ self.index += 1;}- if (end == 0) {++ if (!self.first and self.index < self.input.len and self.input[self.index] == ',') {+ self.index += 1;+ while (self.index < self.input.len and std.ascii.isWhitespace(self.input[self.index])) self.index += 1;+ if (self.index == self.input.len) return error.SyntaxError;+ } else if (!self.first and self.index < self.input.len and !had_whitespace and+ self.input[self.index] != '+' and self.input[self.index] != '-')+ {return error.SyntaxError;}- const value = try std.fmt.parseFloat(f64, tok[0..end]);- const suffix = tok[end..];-- var unit: Unit = .none;- if (std.ascii.eqlIgnoreCase(suffix, "deg")) {- unit = .deg;- } else if (std.ascii.eqlIgnoreCase(suffix, "rad")) {- unit = .rad;- } else if (std.ascii.eqlIgnoreCase(suffix, "grad")) {- unit = .grad;- } else if (std.ascii.eqlIgnoreCase(suffix, "turn")) {- unit = .turn;++ if (self.index == self.input.len) return null;+ const start = self.index;+ if (self.input[self.index] == '+' or self.input[self.index] == '-') self.index += 1;++ var digits: usize = 0;+ while (self.index < self.input.len and std.ascii.isDigit(self.input[self.index])) : (self.index += 1) digits += 1;+ if (self.index < self.input.len and self.input[self.index] == '.') {+ self.index += 1;+ while (self.index < self.input.len and std.ascii.isDigit(self.input[self.index])) : (self.index += 1) digits += 1;+ }+ if (digits == 0) return error.SyntaxError;++ if (self.index < self.input.len and (self.input[self.index] == 'e' or self.input[self.index] == 'E')) {+ self.index += 1;+ if (self.index < self.input.len and (self.input[self.index] == '+' or self.input[self.index] == '-')) self.index += 1;+ const exponent_start = self.index;+ while (self.index < self.input.len and std.ascii.isDigit(self.input[self.index])) self.index += 1;+ if (self.index == exponent_start) return error.SyntaxError;+ }++ const number_end = self.index;+ while (self.index < self.input.len and+ (std.ascii.isAlphabetic(self.input[self.index]) or self.input[self.index] == '%'))+ {+ self.index += 1;}+ const suffix = self.input[number_end..self.index];+ const unit: ParsedValue.Unit = if (suffix.len == 0)+ .none+ else if (std.ascii.eqlIgnoreCase(suffix, "deg"))+ .deg+ else if (std.ascii.eqlIgnoreCase(suffix, "rad"))+ .rad+ else if (std.ascii.eqlIgnoreCase(suffix, "grad"))+ .grad+ else if (std.ascii.eqlIgnoreCase(suffix, "turn"))+ .turn+ else+ .other;++ const value = std.fmt.parseFloat(f64, self.input[start..number_end]) catch return error.SyntaxError;+ if (!std.math.isFinite(value)) return error.SyntaxError;+ self.first = false;return .{ .value = value, .unit = unit };}};diff --git a/src/browser/webapi/DOMPoint.zig b/src/browser/webapi/DOMPoint.zigindex 0df456604..753b28811 100644--- a/src/browser/webapi/DOMPoint.zig+++ b/src/browser/webapi/DOMPoint.zig@@ -17,6 +17,7 @@// along with this program. If not, see <https://www.gnu.org/licenses/>.const js = @import("../js/js.zig");+const Frame = @import("../Frame.zig");const Page = @import("../Page.zig");const RO = @import("DOMPointReadOnly.zig");@@ -77,17 +78,17 @@ pub fn getW(self: *const DOMPoint) f64 {return self._proto._w;}-pub fn setX(self: *DOMPoint, v: f64) void {- self._proto._x = v;+pub fn setX(self: *DOMPoint, v: f64, frame: *Frame) !void {+ try self._proto.setCoordinate(.x, v, frame);}-pub fn setY(self: *DOMPoint, v: f64) void {- self._proto._y = v;+pub fn setY(self: *DOMPoint, v: f64, frame: *Frame) !void {+ try self._proto.setCoordinate(.y, v, frame);}-pub fn setZ(self: *DOMPoint, v: f64) void {- self._proto._z = v;+pub fn setZ(self: *DOMPoint, v: f64, frame: *Frame) !void {+ try self._proto.setCoordinate(.z, v, frame);}-pub fn setW(self: *DOMPoint, v: f64) void {- self._proto._w = v;+pub fn setW(self: *DOMPoint, v: f64, frame: *Frame) !void {+ try self._proto.setCoordinate(.w, v, frame);}pub const JsApi = struct {diff --git a/src/browser/webapi/DOMPointReadOnly.zig b/src/browser/webapi/DOMPointReadOnly.zigindex db91e5a3f..2a349650e 100644--- a/src/browser/webapi/DOMPointReadOnly.zig+++ b/src/browser/webapi/DOMPointReadOnly.zig@@ -20,6 +20,7 @@ const std = @import("std");const lp = @import("lightpanda");const js = @import("../js/js.zig");+const Frame = @import("../Frame.zig");const Page = @import("../Page.zig");const DOMPoint = @import("DOMPoint.zig");const Matrix = @import("DOMMatrixReadOnly.zig");@@ -38,6 +39,15 @@ _x: f64,_y: f64,_z: f64,_w: f64,+_attachment: ?Attachment = null,++pub const Coordinate = enum { x, y, z, w };++pub const Attachment = struct {+ owner: *anyopaque,+ read_only: bool,+ mutate: *const fn (*anyopaque, *DOMPointReadOnly, Coordinate, f64, *Frame) anyerror!void,+};pub const Type = union(enum) {generic,@@ -132,6 +142,41 @@ pub fn getW(self: *const DOMPointReadOnly) f64 {return self._w;}+pub fn setCoordinate(self: *DOMPointReadOnly, coordinate: Coordinate, value: f64, frame: *Frame) !void {+ if (self._attachment) |attachment| {+ if (attachment.read_only) return error.NoModificationAllowed;+ return attachment.mutate(attachment.owner, self, coordinate, value, frame);+ }+ self.setCoordinateRaw(coordinate, value);+}++pub fn setCoordinateRaw(self: *DOMPointReadOnly, coordinate: Coordinate, value: f64) void {+ switch (coordinate) {+ .x => self._x = value,+ .y => self._y = value,+ .z => self._z = value,+ .w => self._w = value,+ }+}++pub fn attach(self: *DOMPointReadOnly, attachment: Attachment) void {+ self._attachment = attachment;+}++pub fn detach(self: *DOMPointReadOnly, owner: *anyopaque) void {+ const attachment = self._attachment orelse return;+ if (attachment.owner == owner) self._attachment = null;+}++pub fn isAttached(self: *const DOMPointReadOnly) bool {+ return self._attachment != null;+}++pub fn isAttachedTo(self: *const DOMPointReadOnly, owner: *anyopaque) bool {+ const attachment = self._attachment orelse return false;+ return attachment.owner == owner;+}+pub fn toJSON(self: *const DOMPointReadOnly) struct {x: f64,y: f64,diff --git a/src/browser/webapi/element/svg/Graphics.zig b/src/browser/webapi/element/svg/Graphics.zigindex ccb1386b9..cb9c27502 100644--- a/src/browser/webapi/element/svg/Graphics.zig+++ b/src/browser/webapi/element/svg/Graphics.zig@@ -17,9 +17,12 @@// along with this program. If not, see <https://www.gnu.org/licenses/>.const js = @import("../../../js/js.zig");+const Frame = @import("../../../Frame.zig");const Node = @import("../../Node.zig");const Element = @import("../../Element.zig");const SvgElement = @import("../Svg.zig");+const AnimatedTransformList = @import("../../svg/AnimatedTransformList.zig");+const StringList = @import("../../svg/StringList.zig");pub const Svg = @import("Svg.zig");pub const G = @import("G.zig");@@ -32,6 +35,9 @@ pub const Geometry = @import("Geometry.zig");const Graphics = @This();_proto: *SvgElement,_type: Type,+_transform: ?*AnimatedTransformList = null,+_required_extensions: ?*StringList = null,+_system_language: ?*StringList = null,pub const Type = union(enum) {svg: *Svg,@@ -72,4 +78,39 @@ pub const JsApi = struct {pub const prototype_chain = bridge.prototypeChain();pub var class_id: bridge.ClassId = undefined;};++ pub const transform = bridge.accessor(Graphics.getTransform, null, .{});+ pub const requiredExtensions = bridge.accessor(Graphics.getRequiredExtensions, null, .{});+ pub const systemLanguage = bridge.accessor(Graphics.getSystemLanguage, null, .{});};++pub fn getTransform(self: *Graphics, frame: *Frame) !*AnimatedTransformList {+ if (self._transform == null) {+ self._transform = try AnimatedTransformList.create(self.asElement(), frame);+ }+ return self._transform.?;+}++pub fn getRequiredExtensions(self: *Graphics, frame: *Frame) !*StringList {+ if (self._required_extensions == null) {+ self._required_extensions = try StringList.create(+ self.asElement(),+ .wrap("requiredExtensions"),+ .whitespace,+ frame,+ );+ }+ return self._required_extensions.?;+}++pub fn getSystemLanguage(self: *Graphics, frame: *Frame) !*StringList {+ if (self._system_language == null) {+ self._system_language = try StringList.create(+ self.asElement(),+ .wrap("systemLanguage"),+ .comma,+ frame,+ );+ }+ return self._system_language.?;+}diff --git a/src/browser/webapi/element/svg/Polygon.zig b/src/browser/webapi/element/svg/Polygon.zigindex 752917079..b81b2939c 100644--- a/src/browser/webapi/element/svg/Polygon.zig+++ b/src/browser/webapi/element/svg/Polygon.zig@@ -17,14 +17,18 @@// along with this program. If not, see <https://www.gnu.org/licenses/>.const js = @import("../../../js/js.zig");+const Frame = @import("../../../Frame.zig");const Node = @import("../../Node.zig");const Element = @import("../../Element.zig");const Geometry = @import("Geometry.zig");+const PointList = @import("../../svg/PointList.zig");const Polygon = @This();_proto: *Geometry,+_points: ?*PointList = null,+_animated_points: ?*PointList = null,pub fn asElement(self: *Polygon) *Element {return self._proto.asElement();@@ -41,4 +45,21 @@ pub const JsApi = struct {pub const prototype_chain = bridge.prototypeChain();pub var class_id: bridge.ClassId = undefined;};++ pub const points = bridge.accessor(Polygon.getPoints, null, .{});+ pub const animatedPoints = bridge.accessor(Polygon.getAnimatedPoints, null, .{});};++pub fn getPoints(self: *Polygon, frame: *Frame) !*PointList {+ if (self._points == null) {+ self._points = try PointList.create(self.asElement(), false, frame);+ }+ return self._points.?;+}++pub fn getAnimatedPoints(self: *Polygon, frame: *Frame) !*PointList {+ if (self._animated_points == null) {+ self._animated_points = try PointList.create(self.asElement(), true, frame);+ }+ return self._animated_points.?;+}diff --git a/src/browser/webapi/element/svg/Polyline.zig b/src/browser/webapi/element/svg/Polyline.zigindex a232e4950..7e1b3b19f 100644--- a/src/browser/webapi/element/svg/Polyline.zig+++ b/src/browser/webapi/element/svg/Polyline.zig@@ -17,14 +17,18 @@// along with this program. If not, see <https://www.gnu.org/licenses/>.const js = @import("../../../js/js.zig");+const Frame = @import("../../../Frame.zig");const Node = @import("../../Node.zig");const Element = @import("../../Element.zig");const Geometry = @import("Geometry.zig");+const PointList = @import("../../svg/PointList.zig");const Polyline = @This();_proto: *Geometry,+_points: ?*PointList = null,+_animated_points: ?*PointList = null,pub fn asElement(self: *Polyline) *Element {return self._proto.asElement();@@ -41,4 +45,21 @@ pub const JsApi = struct {pub const prototype_chain = bridge.prototypeChain();pub var class_id: bridge.ClassId = undefined;};++ pub const points = bridge.accessor(Polyline.getPoints, null, .{});+ pub const animatedPoints = bridge.accessor(Polyline.getAnimatedPoints, null, .{});};++pub fn getPoints(self: *Polyline, frame: *Frame) !*PointList {+ if (self._points == null) {+ self._points = try PointList.create(self.asElement(), false, frame);+ }+ return self._points.?;+}++pub fn getAnimatedPoints(self: *Polyline, frame: *Frame) !*PointList {+ if (self._animated_points == null) {+ self._animated_points = try PointList.create(self.asElement(), true, frame);+ }+ return self._animated_points.?;+}diff --git a/src/browser/webapi/svg/AnimatedTransformList.zig b/src/browser/webapi/svg/AnimatedTransformList.zignew file mode 100644index 000000000..8c62b1d12--- /dev/null+++ b/src/browser/webapi/svg/AnimatedTransformList.zig@@ -0,0 +1,46 @@+// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)+//+// This program is free software: you can redistribute it and/or modify+// it under the terms of the GNU Affero General Public License as published by+// the Free Software Foundation, either version 3 of the License, or+// (at your option) any later version.++const js = @import("../../js/js.zig");+const Frame = @import("../../Frame.zig");+const Element = @import("../Element.zig");+const TransformList = @import("TransformList.zig");++const AnimatedTransformList = @This();++_base_val: *TransformList,+_anim_val: *TransformList,++pub fn create(element: *Element, frame: *Frame) !*AnimatedTransformList {+ const base_val = try TransformList.create(element, false, frame);+ const anim_val = try TransformList.create(element, true, frame);+ return frame._factory.create(AnimatedTransformList{+ ._base_val = base_val,+ ._anim_val = anim_val,+ });+}++pub fn getBaseVal(self: *AnimatedTransformList) *TransformList {+ return self._base_val;+}++pub fn getAnimVal(self: *AnimatedTransformList) *TransformList {+ return self._anim_val;+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(AnimatedTransformList);++ pub const Meta = struct {+ pub const name = "SVGAnimatedTransformList";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const baseVal = bridge.accessor(AnimatedTransformList.getBaseVal, null, .{});+ pub const animVal = bridge.accessor(AnimatedTransformList.getAnimVal, null, .{});+};diff --git a/src/browser/webapi/svg/PointList.zig b/src/browser/webapi/svg/PointList.zignew file mode 100644index 000000000..2fef4c8f5--- /dev/null+++ b/src/browser/webapi/svg/PointList.zig@@ -0,0 +1,353 @@+// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)+//+// This program is free software: you can redistribute it and/or modify+// it under the terms of the GNU Affero General Public License as published by+// the Free Software Foundation, either version 3 of the License, or+// (at your option) any later version.++const std = @import("std");+const lp = @import("lightpanda");++const js = @import("../../js/js.zig");+const Frame = @import("../../Frame.zig");+const Page = @import("../../Page.zig");+const DOMPoint = @import("../DOMPoint.zig");+const DOMPointReadOnly = @import("../DOMPointReadOnly.zig");+const Element = @import("../Element.zig");++const PointList = @This();++_element: *Element,+_read_only: bool,+_items: std.ArrayList(*DOMPoint) = .empty,+_retired: std.ArrayList(*DOMPoint) = .empty,+_snapshot: ?[]const u8 = null,++pub fn create(element: *Element, read_only: bool, frame: *Frame) !*PointList {+ const self = try frame._factory.create(PointList{+ ._element = element,+ ._read_only = read_only,+ });+ try frame.registerSvgCollectionCleanup(.{+ .context = self,+ .callback = PointList.cleanup,+ });+ return self;+}++fn cleanup(context: *anyopaque, page: *Page) void {+ const self: *PointList = @ptrCast(@alignCast(context));+ for (self._items.items) |point| {+ point._proto.detach(self);+ point._proto.releaseRef(page);+ }+ for (self._retired.items) |point| {+ point._proto.releaseRef(page);+ }+ self._items.clearRetainingCapacity();+ self._retired.clearRetainingCapacity();+}++pub fn getLength(self: *PointList, frame: *Frame) !u32 {+ try self.sync(frame);+ return @intCast(self._items.items.len);+}++pub fn getNumberOfItems(self: *PointList, frame: *Frame) !u32 {+ return self.getLength(frame);+}++pub fn clear(self: *PointList, frame: *Frame) !void {+ try self.requireMutable();+ try self.sync(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 {+ try self.requireMutable();+ try self.sync(frame);++ const prepared = try self.prepareItem(item, frame);+ errdefer prepared._proto.releaseRef(frame._page);++ 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;+}++pub fn getItem(self: *PointList, index: u32, frame: *Frame) !*DOMPoint {+ try self.sync(frame);+ if (index >= self._items.items.len) return error.IndexSizeError;+ return self._items.items[index];+}++pub fn insertItemBefore(self: *PointList, item: *DOMPoint, index: u32, frame: *Frame) !*DOMPoint {+ try self.requireMutable();+ try self.sync(frame);++ const prepared = try self.prepareItem(item, frame);+ errdefer prepared._proto.releaseRef(frame._page);+ const at = @min(@as(usize, index), self._items.items.len);+ const next = try frame.local_arena.alloc(*DOMPoint, self._items.items.len + 1);+ @memcpy(next[0..at], self._items.items[0..at]);+ next[at] = prepared;+ @memcpy(next[at + 1 ..], self._items.items[at..]);++ try self._items.ensureUnusedCapacity(frame.arena, 1);+ try self.setAttribute(next, frame);+ self._items.insertAssumeCapacity(at, prepared);+ self.attach(prepared);+ return prepared;+}++pub fn replaceItem(self: *PointList, item: *DOMPoint, index: u32, frame: *Frame) !*DOMPoint {+ try self.requireMutable();+ try self.sync(frame);+ if (index >= self._items.items.len) return error.IndexSizeError;++ const prepared = try self.prepareItem(item, frame);+ errdefer prepared._proto.releaseRef(frame._page);+ const next = try frame.local_arena.dupe(*DOMPoint, self._items.items);+ next[index] = prepared;++ try self._retired.ensureUnusedCapacity(frame.arena, 1);+ try self.setAttribute(next, frame);+ const replaced = self._items.items[index];+ replaced._proto.detach(self);+ self._retired.appendAssumeCapacity(replaced);+ self._items.items[index] = prepared;+ self.attach(prepared);+ return prepared;+}++pub fn removeItem(self: *PointList, index: u32, frame: *Frame) !*DOMPoint {+ try self.requireMutable();+ try self.sync(frame);+ if (index >= self._items.items.len) return error.IndexSizeError;++ const next = try frame.local_arena.alloc(*DOMPoint, self._items.items.len - 1);+ @memcpy(next[0..index], self._items.items[0..index]);+ @memcpy(next[index..], self._items.items[index + 1 ..]);++ try self._retired.ensureUnusedCapacity(frame.arena, 1);+ try self.setAttribute(next, frame);+ const removed = self._items.orderedRemove(index);+ removed._proto.detach(self);+ self._retired.appendAssumeCapacity(removed);+ return removed;+}++pub fn appendItem(self: *PointList, item: *DOMPoint, frame: *Frame) !*DOMPoint {+ return self.insertItemBefore(item, std.math.maxInt(u32), frame);+}++fn requireMutable(self: *const PointList) !void {+ if (self._read_only) return error.NoModificationAllowed;+}++fn prepareItem(_: *PointList, item: *DOMPoint, frame: *Frame) !*DOMPoint {+ if (!std.math.isFinite(item._proto._x) or !std.math.isFinite(item._proto._y)) return error.TypeError;+ const prepared = if (item._proto.isAttached())+ try DOMPoint.create(item._proto._x, item._proto._y, item._proto._z, item._proto._w, frame._page)+ else+ item;+ prepared._proto.acquireRef();+ return prepared;+}++fn attach(self: *PointList, point: *DOMPoint) void {+ point._proto.attach(.{+ .owner = self,+ .read_only = self._read_only,+ .mutate = PointList.mutatePoint,+ });+}++fn mutatePoint(+ context: *anyopaque,+ point: *DOMPointReadOnly,+ coordinate: DOMPointReadOnly.Coordinate,+ value: f64,+ frame: *Frame,+) anyerror!void {+ const self: *PointList = @ptrCast(@alignCast(context));+ try self.sync(frame);++ // An external attribute mutation detaches the old item during sync. The+ // caller still owns that DOMPoint identity, but it no longer mutates the list.+ if (!point.isAttachedTo(self)) {+ point.setCoordinateRaw(coordinate, value);+ return;+ }++ if (coordinate == .z or coordinate == .w) {+ point.setCoordinateRaw(coordinate, value);+ return;+ }+ if (!std.math.isFinite(value)) return error.TypeError;++ const index = for (self._items.items, 0..) |candidate, i| {+ if (candidate._proto == point) break i;+ } else unreachable;++ try self.setAttributeWithOverride(index, coordinate, value, frame);+ point.setCoordinateRaw(coordinate, value);+}++fn sync(self: *PointList, frame: *Frame) !void {+ const raw = self._element.getAttributeSafe(comptime .wrap("points")) orelse "";+ if (self._snapshot) |snapshot| {+ if (std.mem.eql(u8, snapshot, raw)) return;+ }++ const snapshot = try frame.arena.dupe(u8, raw);+ 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);++ try self._items.ensureTotalCapacity(frame.arena, parsed.items.len);+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);+ self.retireAllAssumeCapacity();+ for (parsed.items) |point| {+ self._items.appendAssumeCapacity(point);+ self.attach(point);+ }+ parsed.clearRetainingCapacity();+ self._snapshot = snapshot;+}++fn parse(raw: []const u8, frame: *Frame) !std.ArrayList(*DOMPoint) {+ var scanner = NumberScanner{ .input = raw };+ var parsed: std.ArrayList(*DOMPoint) = .empty;+ errdefer for (parsed.items) |point| point._proto.releaseRef(frame._page);++ while (try scanner.next()) |x| {+ const y = (try scanner.next()) orelse return error.SyntaxError;+ const point = try DOMPoint.create(x, y, 0, 1, frame._page);+ point._proto.acquireRef();+ parsed.append(frame.local_arena, point) catch |err| {+ point._proto.releaseRef(frame._page);+ return err;+ };+ }+ return parsed;+}++fn retireAllAssumeCapacity(self: *PointList) void {+ for (self._items.items) |point| {+ point._proto.detach(self);+ self._retired.appendAssumeCapacity(point);+ }+ self._items.clearRetainingCapacity();+}++fn setAttribute(self: *PointList, items: []const *DOMPoint, frame: *Frame) !void {+ var serialized: std.Io.Writer.Allocating = .init(frame.local_arena);+ const writer = &serialized.writer;+ for (items, 0..) |point, i| {+ if (i != 0) try writer.writeByte(' ');+ try writer.print("{d},{d}", .{ point._proto._x, point._proto._y });+ }+ try self.commitAttribute(serialized.written(), frame);+}++fn setAttributeWithOverride(+ self: *PointList,+ index: usize,+ coordinate: DOMPointReadOnly.Coordinate,+ value: f64,+ frame: *Frame,+) !void {+ var serialized: std.Io.Writer.Allocating = .init(frame.local_arena);+ const writer = &serialized.writer;+ for (self._items.items, 0..) |point, i| {+ if (i != 0) try writer.writeByte(' ');+ const x = if (i == index and coordinate == .x) value else point._proto._x;+ const y = if (i == index and coordinate == .y) value else point._proto._y;+ try writer.print("{d},{d}", .{ x, y });+ }+ try self.commitAttribute(serialized.written(), frame);+}++fn commitAttribute(self: *PointList, serialized: []const u8, frame: *Frame) !void {+ const snapshot = try frame.arena.dupe(u8, serialized);+ try self._element.setAttributeSafe(comptime .wrap("points"), .wrap(serialized), frame);+ self._snapshot = snapshot;+}++const NumberScanner = struct {+ input: []const u8,+ index: usize = 0,+ first: bool = true,++ fn next(self: *NumberScanner) !?f64 {+ var had_whitespace = false;+ while (self.index < self.input.len and std.ascii.isWhitespace(self.input[self.index])) {+ had_whitespace = true;+ self.index += 1;+ }++ if (!self.first and self.index < self.input.len and self.input[self.index] == ',') {+ self.index += 1;+ while (self.index < self.input.len and std.ascii.isWhitespace(self.input[self.index])) self.index += 1;+ if (self.index == self.input.len) return error.SyntaxError;+ } else if (!self.first and self.index < self.input.len and !had_whitespace and+ self.input[self.index] != '+' and self.input[self.index] != '-')+ {+ return error.SyntaxError;+ }++ if (self.index == self.input.len) return null;+ const start = self.index;+ if (self.input[self.index] == '+' or self.input[self.index] == '-') self.index += 1;++ var digits: usize = 0;+ while (self.index < self.input.len and std.ascii.isDigit(self.input[self.index])) : (self.index += 1) digits += 1;+ if (self.index < self.input.len and self.input[self.index] == '.') {+ self.index += 1;+ while (self.index < self.input.len and std.ascii.isDigit(self.input[self.index])) : (self.index += 1) digits += 1;+ }+ if (digits == 0) return error.SyntaxError;++ if (self.index < self.input.len and (self.input[self.index] == 'e' or self.input[self.index] == 'E')) {+ self.index += 1;+ if (self.index < self.input.len and (self.input[self.index] == '+' or self.input[self.index] == '-')) self.index += 1;+ const exponent_start = self.index;+ while (self.index < self.input.len and std.ascii.isDigit(self.input[self.index])) self.index += 1;+ if (self.index == exponent_start) return error.SyntaxError;+ }++ const value = std.fmt.parseFloat(f64, self.input[start..self.index]) catch return error.SyntaxError;+ if (!std.math.isFinite(value)) return error.SyntaxError;+ self.first = false;+ return value;+ }+};++pub const JsApi = struct {+ pub const bridge = js.Bridge(PointList);++ pub const Meta = struct {+ pub const name = "SVGPointList";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const length = bridge.accessor(PointList.getLength, null, .{});+ pub const numberOfItems = bridge.accessor(PointList.getNumberOfItems, null, .{});+ pub const clear = bridge.function(PointList.clear, .{});+ pub const initialize = bridge.function(PointList.initialize, .{});+ pub const getItem = bridge.function(PointList.getItem, .{});+ pub const insertItemBefore = bridge.function(PointList.insertItemBefore, .{});+ pub const replaceItem = bridge.function(PointList.replaceItem, .{});+ pub const removeItem = bridge.function(PointList.removeItem, .{});+ pub const appendItem = bridge.function(PointList.appendItem, .{});+};diff --git a/src/browser/webapi/svg/StringList.zig b/src/browser/webapi/svg/StringList.zignew file mode 100644index 000000000..8c866209b--- /dev/null+++ b/src/browser/webapi/svg/StringList.zig@@ -0,0 +1,179 @@+// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)+//+// This program is free software: you can redistribute it and/or modify+// it under the terms of the GNU Affero General Public License as published by+// the Free Software Foundation, either version 3 of the License, or+// (at your option) any later version.++const std = @import("std");+const lp = @import("lightpanda");++const js = @import("../../js/js.zig");+const Frame = @import("../../Frame.zig");+const Element = @import("../Element.zig");++const StringList = @This();++pub const Delimiter = enum { whitespace, comma };++_element: *Element,+_attribute_name: lp.String,+_delimiter: Delimiter,+_items: std.ArrayList([]const u8) = .empty,+_snapshot: ?[]const u8 = null,++pub fn create(element: *Element, attribute_name: lp.String, delimiter: Delimiter, frame: *Frame) !*StringList {+ return frame._factory.create(StringList{+ ._element = element,+ ._attribute_name = attribute_name,+ ._delimiter = delimiter,+ });+}++pub fn getLength(self: *StringList, frame: *Frame) !u32 {+ try self.sync(frame);+ return @intCast(self._items.items.len);+}++pub fn getNumberOfItems(self: *StringList, frame: *Frame) !u32 {+ return self.getLength(frame);+}++pub fn clear(self: *StringList, frame: *Frame) !void {+ try self.commit(&.{}, frame);+}++pub fn initialize(self: *StringList, item: []const u8, frame: *Frame) ![]const u8 {+ try self.validateItem(item);+ try self.commit(&.{item}, frame);+ return self._items.items[0];+}++pub fn getItem(self: *StringList, index: u32, frame: *Frame) ![]const u8 {+ try self.sync(frame);+ if (index >= self._items.items.len) return error.IndexSizeError;+ return self._items.items[index];+}++pub fn insertItemBefore(self: *StringList, item: []const u8, index: u32, frame: *Frame) ![]const u8 {+ try self.validateItem(item);+ try self.sync(frame);+ const at = @min(@as(usize, index), self._items.items.len);+ const next = try frame.local_arena.alloc([]const u8, self._items.items.len + 1);+ @memcpy(next[0..at], self._items.items[0..at]);+ next[at] = item;+ @memcpy(next[at + 1 ..], self._items.items[at..]);+ try self.commit(next, frame);+ return self._items.items[at];+}++pub fn replaceItem(self: *StringList, item: []const u8, index: u32, frame: *Frame) ![]const u8 {+ try self.validateItem(item);+ try self.sync(frame);+ if (index >= self._items.items.len) return error.IndexSizeError;+ const next = try frame.local_arena.dupe([]const u8, self._items.items);+ next[index] = item;+ try self.commit(next, frame);+ return self._items.items[index];+}++pub fn removeItem(self: *StringList, index: u32, frame: *Frame) ![]const u8 {+ try self.sync(frame);+ if (index >= self._items.items.len) return error.IndexSizeError;+ const removed = try frame.local_arena.dupe(u8, self._items.items[index]);+ const next = try frame.local_arena.alloc([]const u8, self._items.items.len - 1);+ @memcpy(next[0..index], self._items.items[0..index]);+ @memcpy(next[index..], self._items.items[index + 1 ..]);+ try self.commit(next, frame);+ return removed;+}++pub fn appendItem(self: *StringList, item: []const u8, frame: *Frame) ![]const u8 {+ return self.insertItemBefore(item, std.math.maxInt(u32), frame);+}++fn validateItem(self: *const StringList, item: []const u8) !void {+ if (item.len == 0) return error.SyntaxError;+ for (item) |byte| {+ if (std.ascii.isWhitespace(byte) or (self._delimiter == .comma and byte == ',')) {+ return error.SyntaxError;+ }+ }+}++fn sync(self: *StringList, frame: *Frame) !void {+ const raw = self._element.getAttributeSafe(self._attribute_name) orelse "";+ if (self._snapshot) |snapshot| if (std.mem.eql(u8, snapshot, raw)) return;++ const snapshot = try frame.arena.dupe(u8, raw);+ var parsed = parse(snapshot, self._delimiter, frame.local_arena) catch |err| switch (err) {+ error.SyntaxError => std.ArrayList([]const u8).empty,+ else => return err,+ };+ try self._items.ensureTotalCapacity(frame.arena, parsed.items.len);+ self._items.clearRetainingCapacity();+ for (parsed.items) |item| self._items.appendAssumeCapacity(item);+ parsed.clearRetainingCapacity();+ self._snapshot = snapshot;+}++fn commit(self: *StringList, items: []const []const u8, frame: *Frame) !void {+ var serialized: std.Io.Writer.Allocating = .init(frame.local_arena);+ const writer = &serialized.writer;+ for (items, 0..) |item, i| {+ try self.validateItem(item);+ if (i != 0) try writer.writeAll(if (self._delimiter == .comma) ", " else " ");+ try writer.writeAll(item);+ }++ const serialized_bytes = serialized.written();+ const snapshot = try frame.arena.dupe(u8, serialized_bytes);+ var parsed = try parse(snapshot, self._delimiter, frame.local_arena);+ try self._items.ensureTotalCapacity(frame.arena, parsed.items.len);+ try self._element.setAttributeSafe(self._attribute_name, .wrap(serialized_bytes), frame);+ self._items.clearRetainingCapacity();+ for (parsed.items) |item| self._items.appendAssumeCapacity(item);+ parsed.clearRetainingCapacity();+ self._snapshot = snapshot;+}++fn parse(raw: []const u8, delimiter: Delimiter, allocator: std.mem.Allocator) !std.ArrayList([]const u8) {+ var items: std.ArrayList([]const u8) = .empty;+ switch (delimiter) {+ .whitespace => {+ var iterator = std.mem.tokenizeAny(u8, raw, " \t\r\n\x0c");+ while (iterator.next()) |item| try items.append(allocator, item);+ },+ .comma => {+ if (std.mem.trim(u8, raw, " \t\r\n\x0c").len == 0) return items;+ var iterator = std.mem.splitScalar(u8, raw, ',');+ while (iterator.next()) |part| {+ const item = std.mem.trim(u8, part, " \t\r\n\x0c");+ if (item.len == 0) return error.SyntaxError;+ for (item) |byte| if (std.ascii.isWhitespace(byte)) return error.SyntaxError;+ try items.append(allocator, item);+ }+ },+ }+ return items;+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(StringList);++ pub const Meta = struct {+ pub const name = "SVGStringList";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const length = bridge.accessor(StringList.getLength, null, .{});+ pub const numberOfItems = bridge.accessor(StringList.getNumberOfItems, null, .{});+ pub const clear = bridge.function(StringList.clear, .{});+ pub const initialize = bridge.function(StringList.initialize, .{});+ pub const getItem = bridge.function(StringList.getItem, .{});+ pub const insertItemBefore = bridge.function(StringList.insertItemBefore, .{});+ pub const replaceItem = bridge.function(StringList.replaceItem, .{});+ pub const removeItem = bridge.function(StringList.removeItem, .{});+ pub const appendItem = bridge.function(StringList.appendItem, .{});+};diff --git a/src/browser/webapi/svg/Transform.zig b/src/browser/webapi/svg/Transform.zigindex fe6c09e30..09d6f13a9 100644--- a/src/browser/webapi/svg/Transform.zig+++ b/src/browser/webapi/svg/Transform.zig@@ -43,7 +43,25 @@ pub const DOMMatrix2DInit = struct {_type: u16 = 1,_angle: f64 = 0,+_cx: f64 = 0,+_cy: f64 = 0,_matrix: *DOMMatrix,+_attachment: ?Attachment = null,++pub const State = struct {+ typ: u16,+ angle: f64,+ cx: f64,+ cy: f64,+ matrix: [16]f64,+ is_2d: bool,+};++pub const Attachment = struct {+ owner: *anyopaque,+ read_only: bool,+ mutate: *const fn (*anyopaque, *Transform, State, *Frame) anyerror!void,+};// The transform owns the matrix arena even when no JS wrapper currently// references `matrix`. Forwarding the transform's bridge lifetime keeps the@@ -58,15 +76,51 @@ 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 });}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 });}+pub fn fromParsed(parsed: RO.ParsedTransform, frame: *Frame) !*Transform {+ const typ: u16 = switch (parsed.kind) {+ .matrix => 1,+ .translate => 2,+ .scale => 3,+ .rotate => 4,+ .skew_x => 5,+ .skew_y => 6,+ else => return error.SyntaxError,+ };+ const matrix = try DOMMatrix.create(parsed.matrix, parsed.is_2d, frame._page);+ errdefer matrix._proto.deinit(frame._page);+ return 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,+ });+}++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{+ ._type = current.typ,+ ._angle = current.angle,+ ._cx = current.cx,+ ._cy = current.cy,+ ._matrix = matrix,+ });+}+pub fn getType(self: *const Transform) u16 {return self._type;}@@ -79,59 +133,106 @@ pub fn getAngle(self: *const Transform) f64 {return self._angle;}-pub fn setMatrix(self: *Transform, init: ?DOMMatrix2DInit) !void {+pub fn setMatrix(self: *Transform, init: ?DOMMatrix2DInit, frame: *Frame) !void {const parsed = try fixup2D(init orelse .{});- self.replaceMatrix(parsed.m, true);- self._type = 1;- self._angle = 0;+ try self.applyState(.{ .typ = 1, .angle = 0, .cx = 0, .cy = 0, .matrix = parsed.m, .is_2d = true }, frame);}-pub fn setTranslate(self: *Transform, tx: f64, ty: f64) !void {+pub fn setTranslate(self: *Transform, tx: f64, ty: f64, frame: *Frame) !void {try ensureFinite(&.{ tx, ty });- self.replaceMatrix(RO.translationMatrix(tx, ty, 0), true);- self._type = 2;- self._angle = 0;+ try self.applyState(.{ .typ = 2, .angle = 0, .cx = 0, .cy = 0, .matrix = RO.translationMatrix(tx, ty, 0), .is_2d = true }, frame);}-pub fn setScale(self: *Transform, sx: f64, sy: f64) !void {+pub fn setScale(self: *Transform, sx: f64, sy: f64, frame: *Frame) !void {try ensureFinite(&.{ sx, sy });- self.replaceMatrix(RO.scaleMatrix(sx, sy, 1), true);- self._type = 3;- self._angle = 0;+ try self.applyState(.{ .typ = 3, .angle = 0, .cx = 0, .cy = 0, .matrix = RO.scaleMatrix(sx, sy, 1), .is_2d = true }, frame);}-pub fn setRotate(self: *Transform, angle: f64, cx: f64, cy: f64) !void {+pub fn setRotate(self: *Transform, angle: f64, cx: f64, cy: f64, frame: *Frame) !void {try ensureFinite(&.{ angle, cx, cy });const radians = angle * std.math.pi / 180.0;var matrix = RO.translationMatrix(cx, cy, 0);matrix = RO.multiplyMatrix(matrix, RO.rotateZMatrix(radians));matrix = RO.multiplyMatrix(matrix, RO.translationMatrix(-cx, -cy, 0));- self.replaceMatrix(matrix, true);- self._type = 4;- self._angle = angle;+ try self.applyState(.{ .typ = 4, .angle = angle, .cx = cx, .cy = cy, .matrix = matrix, .is_2d = true }, frame);}-pub fn setSkewX(self: *Transform, angle: f64) !void {+pub fn setSkewX(self: *Transform, angle: f64, frame: *Frame) !void {try ensureFinite(&.{angle});- self.replaceMatrix(RO.skewMatrix(angle * std.math.pi / 180.0, 0), true);- self._type = 5;- self._angle = angle;+ try self.applyState(.{ .typ = 5, .angle = angle, .cx = 0, .cy = 0, .matrix = RO.skewMatrix(angle * std.math.pi / 180.0, 0), .is_2d = true }, frame);}-pub fn setSkewY(self: *Transform, angle: f64) !void {+pub fn setSkewY(self: *Transform, angle: f64, frame: *Frame) !void {try ensureFinite(&.{angle});- self.replaceMatrix(RO.skewMatrix(0, angle * std.math.pi / 180.0), true);- self._type = 6;- self._angle = angle;+ try self.applyState(.{ .typ = 6, .angle = angle, .cx = 0, .cy = 0, .matrix = RO.skewMatrix(0, angle * std.math.pi / 180.0), .is_2d = true }, frame);+}++pub fn getState(self: *const Transform) State {+ return .{+ .typ = self._type,+ .angle = self._angle,+ .cx = self._cx,+ .cy = self._cy,+ .matrix = self._matrix._proto._m,+ .is_2d = self._matrix._proto._is_2d,+ };}-fn replaceMatrix(self: *Transform, matrix: [16]f64, is_2d: bool) void {- self._matrix._proto._m = matrix;- self._matrix._proto._is_2d = is_2d;+pub fn applyStateRaw(self: *Transform, state: State) void {+ self._type = state.typ;+ 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;+}++fn applyState(self: *Transform, state: State, frame: *Frame) !void {+ try ensureFinite(&state.matrix);+ if (self._attachment) |attachment| {+ if (attachment.read_only) return error.NoModificationAllowed;+ return attachment.mutate(attachment.owner, self, state, frame);+ }+ self.applyStateRaw(state);+}++pub fn attach(self: *Transform, attachment: Attachment) void {+ self._attachment = attachment;+}++pub fn detach(self: *Transform, owner: *anyopaque) void {+ const attachment = self._attachment orelse return;+ if (attachment.owner == owner) self._attachment = null;+}++pub fn isAttached(self: *const Transform) bool {+ return self._attachment != null;+}++pub fn isAttachedTo(self: *const Transform, owner: *anyopaque) bool {+ const attachment = self._attachment orelse return false;+ return attachment.owner == owner;+}++pub fn writeState(state: State, writer: anytype) !void {+ switch (state.typ) {+ 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],+ }),+ 2 => try writer.print("translate({d} {d})", .{ state.matrix[12], state.matrix[13] }),+ 3 => try writer.print("scale({d} {d})", .{ state.matrix[0], state.matrix[5] }),+ 4 => if (state.cx == 0 and state.cy == 0)+ try writer.print("rotate({d})", .{state.angle})+ else+ try writer.print("rotate({d} {d} {d})", .{ state.angle, state.cx, state.cy }),+ 5 => try writer.print("skewX({d})", .{state.angle}),+ 6 => try writer.print("skewY({d})", .{state.angle}),+ else => return error.SyntaxError,+ }}fn fixup2D(init: DOMMatrix2DInit) !RO.Parsed {- return RO.fixupDict(.{+ const parsed = try RO.fixupDict(.{.a = init.a,.b = init.b,.c = init.c,@@ -146,6 +247,8 @@ fn fixup2D(init: DOMMatrix2DInit) !RO.Parsed {.m42 = init.m42,.is2D = true,});+ try ensureFinite(&parsed.m);+ return parsed;}fn ensureFinite(values: []const f64) !void {diff --git a/src/browser/webapi/svg/TransformList.zig b/src/browser/webapi/svg/TransformList.zignew file mode 100644index 000000000..8acc51faa--- /dev/null+++ b/src/browser/webapi/svg/TransformList.zig@@ -0,0 +1,302 @@+// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)+//+// This program is free software: you can redistribute it and/or modify+// it under the terms of the GNU Affero General Public License as published by+// the Free Software Foundation, either version 3 of the License, or+// (at your option) any later version.++const std = @import("std");++const js = @import("../../js/js.zig");+const Frame = @import("../../Frame.zig");+const Page = @import("../../Page.zig");+const DOMMatrixReadOnly = @import("../DOMMatrixReadOnly.zig");+const Element = @import("../Element.zig");+const Transform = @import("Transform.zig");++const TransformList = @This();++_element: *Element,+_read_only: bool,+_items: std.ArrayList(*Transform) = .empty,+_retired: std.ArrayList(*Transform) = .empty,+_snapshot: ?[]const u8 = null,++pub fn create(element: *Element, read_only: bool, frame: *Frame) !*TransformList {+ const self = try frame._factory.create(TransformList{+ ._element = element,+ ._read_only = read_only,+ });+ try frame.registerSvgCollectionCleanup(.{+ .context = self,+ .callback = TransformList.cleanup,+ });+ return self;+}++fn cleanup(context: *anyopaque, page: *Page) void {+ const self: *TransformList = @ptrCast(@alignCast(context));+ for (self._items.items) |transform| {+ transform.detach(self);+ transform.releaseRef(page);+ }+ for (self._retired.items) |transform| transform.releaseRef(page);+ self._items.clearRetainingCapacity();+ self._retired.clearRetainingCapacity();+}++pub fn getLength(self: *TransformList, frame: *Frame) !u32 {+ try self.sync(frame);+ return @intCast(self._items.items.len);+}++pub fn getNumberOfItems(self: *TransformList, frame: *Frame) !u32 {+ return self.getLength(frame);+}++pub fn clear(self: *TransformList, frame: *Frame) !void {+ try self.requireMutable();+ try self.sync(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 {+ try self.requireMutable();+ try self.sync(frame);+ const prepared = try self.prepareItem(item, frame);+ errdefer prepared.releaseRef(frame._page);++ 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;+}++pub fn getItem(self: *TransformList, index: u32, frame: *Frame) !*Transform {+ try self.sync(frame);+ if (index >= self._items.items.len) return error.IndexSizeError;+ return self._items.items[index];+}++pub fn insertItemBefore(self: *TransformList, item: *Transform, index: u32, frame: *Frame) !*Transform {+ try self.requireMutable();+ try self.sync(frame);+ const prepared = try self.prepareItem(item, frame);+ errdefer prepared.releaseRef(frame._page);+ const at = @min(@as(usize, index), self._items.items.len);+ const next = try frame.local_arena.alloc(*Transform, self._items.items.len + 1);+ @memcpy(next[0..at], self._items.items[0..at]);+ next[at] = prepared;+ @memcpy(next[at + 1 ..], self._items.items[at..]);++ try self._items.ensureUnusedCapacity(frame.arena, 1);+ try self.setAttribute(next, frame);+ self._items.insertAssumeCapacity(at, prepared);+ self.attach(prepared);+ return prepared;+}++pub fn replaceItem(self: *TransformList, item: *Transform, index: u32, frame: *Frame) !*Transform {+ try self.requireMutable();+ try self.sync(frame);+ if (index >= self._items.items.len) return error.IndexSizeError;+ const prepared = try self.prepareItem(item, frame);+ errdefer prepared.releaseRef(frame._page);+ const next = try frame.local_arena.dupe(*Transform, self._items.items);+ next[index] = prepared;++ try self._retired.ensureUnusedCapacity(frame.arena, 1);+ try self.setAttribute(next, frame);+ const replaced = self._items.items[index];+ replaced.detach(self);+ self._retired.appendAssumeCapacity(replaced);+ self._items.items[index] = prepared;+ self.attach(prepared);+ return prepared;+}++pub fn removeItem(self: *TransformList, index: u32, frame: *Frame) !*Transform {+ try self.requireMutable();+ try self.sync(frame);+ if (index >= self._items.items.len) return error.IndexSizeError;+ const next = try frame.local_arena.alloc(*Transform, self._items.items.len - 1);+ @memcpy(next[0..index], self._items.items[0..index]);+ @memcpy(next[index..], self._items.items[index + 1 ..]);++ try self._retired.ensureUnusedCapacity(frame.arena, 1);+ try self.setAttribute(next, frame);+ const removed = self._items.orderedRemove(index);+ removed.detach(self);+ self._retired.appendAssumeCapacity(removed);+ return removed;+}++pub fn appendItem(self: *TransformList, item: *Transform, frame: *Frame) !*Transform {+ return self.insertItemBefore(item, std.math.maxInt(u32), frame);+}++pub fn consolidate(self: *TransformList, frame: *Frame) !?*Transform {+ try self.requireMutable();+ try self.sync(frame);+ if (self._items.items.len == 0) return null;++ var matrix = DOMMatrixReadOnly.identity();+ for (self._items.items) |item| matrix = DOMMatrixReadOnly.multiplyMatrix(matrix, item.getState().matrix);+ 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];+ const consolidated = try Transform.fromParsed(.{+ .kind = .matrix,+ .matrix = matrix,+ .values = values,+ .count = 6,+ .is_2d = true,+ }, frame);+ consolidated.acquireRef();+ errdefer consolidated.releaseRef(frame._page);++ 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;+}++fn requireMutable(self: *const TransformList) !void {+ if (self._read_only) return error.NoModificationAllowed;+}++fn prepareItem(_: *TransformList, item: *Transform, frame: *Frame) !*Transform {+ const prepared = if (item.isAttached()) try item.clone(frame) else item;+ prepared.acquireRef();+ return prepared;+}++fn attach(self: *TransformList, transform: *Transform) void {+ transform.attach(.{+ .owner = self,+ .read_only = self._read_only,+ .mutate = TransformList.mutateTransform,+ });+}++fn mutateTransform(context: *anyopaque, transform: *Transform, state: Transform.State, frame: *Frame) anyerror!void {+ const self: *TransformList = @ptrCast(@alignCast(context));+ try self.sync(frame);+ if (!transform.isAttachedTo(self)) {+ transform.applyStateRaw(state);+ return;+ }+ const index = for (self._items.items, 0..) |candidate, i| {+ if (candidate == transform) break i;+ } else unreachable;+ try self.setAttributeWithOverride(index, state, frame);+ transform.applyStateRaw(state);+}++fn sync(self: *TransformList, frame: *Frame) !void {+ const raw = self._element.getAttributeSafe(comptime .wrap("transform")) orelse "";+ if (self._snapshot) |snapshot| if (std.mem.eql(u8, snapshot, raw)) return;+ const snapshot = try frame.arena.dupe(u8, raw);+ 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);++ try self._items.ensureTotalCapacity(frame.arena, parsed.items.len);+ try self._retired.ensureUnusedCapacity(frame.arena, self._items.items.len);+ self.retireAllAssumeCapacity();+ for (parsed.items) |transform| {+ self._items.appendAssumeCapacity(transform);+ self.attach(transform);+ }+ parsed.clearRetainingCapacity();+ self._snapshot = snapshot;+}++fn parse(raw: []const u8, frame: *Frame) !std.ArrayList(*Transform) {+ var parsed: std.ArrayList(*Transform) = .empty;+ errdefer for (parsed.items) |transform| transform.releaseRef(frame._page);+ const trimmed = std.mem.trim(u8, raw, " \t\r\n");+ if (trimmed.len == 0 or std.mem.eql(u8, trimmed, "none")) return parsed;++ var iterator = DOMMatrixReadOnly.TransformFunctionIterator{ .input = trimmed, .allow_comma = true };+ while (try iterator.next()) |function| {+ const value = try DOMMatrixReadOnly.parseTransformFunction(function, .svg);+ const transform = try Transform.fromParsed(value, frame);+ transform.acquireRef();+ parsed.append(frame.local_arena, transform) catch |err| {+ transform.releaseRef(frame._page);+ return err;+ };+ }+ return parsed;+}++fn retireAllAssumeCapacity(self: *TransformList) void {+ for (self._items.items) |transform| {+ transform.detach(self);+ self._retired.appendAssumeCapacity(transform);+ }+ self._items.clearRetainingCapacity();+}++fn setAttribute(self: *TransformList, items: []const *Transform, frame: *Frame) !void {+ var serialized: std.Io.Writer.Allocating = .init(frame.local_arena);+ const writer = &serialized.writer;+ for (items, 0..) |transform, i| {+ if (i != 0) try writer.writeByte(' ');+ try Transform.writeState(transform.getState(), writer);+ }+ try self.commitAttribute(serialized.written(), frame);+}++fn setAttributeWithOverride(self: *TransformList, index: usize, state: Transform.State, frame: *Frame) !void {+ var serialized: std.Io.Writer.Allocating = .init(frame.local_arena);+ const writer = &serialized.writer;+ for (self._items.items, 0..) |transform, i| {+ if (i != 0) try writer.writeByte(' ');+ try Transform.writeState(if (i == index) state else transform.getState(), writer);+ }+ try self.commitAttribute(serialized.written(), frame);+}++fn commitAttribute(self: *TransformList, serialized: []const u8, frame: *Frame) !void {+ const snapshot = try frame.arena.dupe(u8, serialized);+ try self._element.setAttributeSafe(comptime .wrap("transform"), .wrap(serialized), frame);+ self._snapshot = snapshot;+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(TransformList);++ pub const Meta = struct {+ pub const name = "SVGTransformList";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const length = bridge.accessor(TransformList.getLength, null, .{});+ pub const numberOfItems = bridge.accessor(TransformList.getNumberOfItems, null, .{});+ pub const clear = bridge.function(TransformList.clear, .{});+ pub const initialize = bridge.function(TransformList.initialize, .{});+ pub const getItem = bridge.function(TransformList.getItem, .{});+ pub const insertItemBefore = bridge.function(TransformList.insertItemBefore, .{});+ pub const replaceItem = bridge.function(TransformList.replaceItem, .{});+ pub const removeItem = bridge.function(TransformList.removeItem, .{});+ pub const appendItem = bridge.function(TransformList.appendItem, .{});+ pub const consolidate = bridge.function(TransformList.consolidate, .{});+};