Skip to content

Lightpanda: the headless browser designed for AI and automation

avoid `local_arena` copies that nothing resets

nikneyma7a4ba2aaae5
diff --git a/src/browser/frame/node_factory.zig b/src/browser/frame/node_factory.zig
index c06d19ad0..554af37cf 100644
--- a/src/browser/frame/node_factory.zig
+++ b/src/browser/frame/node_factory.zig
@@ -946,8 +946,13 @@ pub fn createElementNS(document: *const Node.Document, namespace: Element.Namesp
else => {},
}
- const lower = try std.ascii.allocLowerString(frame.local_arena, name);
- const tag = std.meta.stringToEnum(Element.Tag, lower) orelse .unknown;
+ // No local_arena: the parser calls this outside of a JS call, where
+ // nothing resets it. A name longer than any Tag can't match one.
+ var lower_buf: [max_tag_len]u8 = undefined;
+ const tag: Element.Tag = if (name.len > lower_buf.len)
+ .unknown
+ else
+ std.meta.stringToEnum(Element.Tag, std.ascii.lowerString(&lower_buf, name)) orelse .unknown;
return createSvgElementT(document, Element.Svg.Generic, name, attribute_iterator, .{ ._tag = tag });
},
else => {
@@ -1301,6 +1306,14 @@ fn isXmlNameChar(c: u21) bool {
(c >= 0x203F and c <= 0x2040);
}
+const max_tag_len = blk: {
+ var max: usize = 0;
+ for (std.meta.fieldNames(Element.Tag)) |tag_name| {
+ max = @max(max, tag_name.len);
+ }
+ break :blk max;
+};
+
fn asUint(comptime string: anytype) @Int(
.unsigned,
@bitSizeOf(@TypeOf(string.*)) - 8, // (- 8) to exclude sentinel 0
diff --git a/src/browser/tests/document/create_element.html b/src/browser/tests/document/create_element.html
index d3522501b..5e359b1ac 100644
--- a/src/browser/tests/document/create_element.html
+++ b/src/browser/tests/document/create_element.html
@@ -28,3 +28,15 @@
testing.expectEqual(name.toUpperCase(), el.nodeName);
}
</script>
+
+<script id=knownTagNames>
+{
+ // one per element type that stores its tag: generic, heading, mod, quote,
+ // table cell, table col, table section
+ for (const name of ['section', 'h1', 'del', 'blockquote', 'td', 'colgroup', 'tbody']) {
+ const el = document.createElement(name);
+ testing.expectEqual(name.toUpperCase(), el.tagName);
+ testing.expectEqual(name.toUpperCase(), el.nodeName);
+ }
+}
+</script>
diff --git a/src/browser/tests/domexception.html b/src/browser/tests/domexception.html
index dfd7b890a..9f71fffe6 100644
--- a/src/browser/tests/domexception.html
+++ b/src/browser/tests/domexception.html
@@ -172,3 +172,12 @@
}, () => link.appendChild(content));
}
</script>
+
+<script id=long_message>
+{
+ // longer than the 1024-byte buffer toString used to format into
+ const msg = 'x'.repeat(2000);
+ const e = new DOMException(msg, 'SyntaxError');
+ testing.expectEqual('SyntaxError: ' + msg, e.toString());
+}
+</script>
diff --git a/src/browser/tests/net/url_search_params.html b/src/browser/tests/net/url_search_params.html
index 08b196225..baad9c1d4 100644
--- a/src/browser/tests/net/url_search_params.html
+++ b/src/browser/tests/net/url_search_params.html
@@ -723,3 +723,17 @@
testing.expectEqual('2', usp.get('xx'));
}
</script>
+
+<script id=longEscapedValue>
+{
+ // longer than the 1024-byte buffer values used to be decoded into
+ const usp = new URLSearchParams('a=' + '%41'.repeat(2000) + '&b=' + 'x+'.repeat(1000));
+ testing.expectEqual('A'.repeat(2000), usp.get('a'));
+ testing.expectEqual('x '.repeat(1000), usp.get('b'));
+
+ const url = new URL('https://example.com/?a=1');
+ testing.expectEqual('1', url.searchParams.get('a'));
+ url.search = 'a=' + '%42'.repeat(2000);
+ testing.expectEqual('B'.repeat(2000), url.searchParams.get('a'));
+}
+</script>
diff --git a/src/browser/webapi/Document.zig b/src/browser/webapi/Document.zig
index 0058e5dc9..8a59044ca 100644
--- a/src/browser/webapi/Document.zig
+++ b/src/browser/webapi/Document.zig
@@ -359,7 +359,11 @@ pub fn createElement(self: *Document, name: []const u8, options_: ?CreateElement
try validateElementName(name);
const ns: Element.Namespace, const normalized_name = blk: {
if (self._type == .html) {
- break :blk .{ .html, try std.ascii.allocLowerString(frame.local_arena, name) };
+ const lower = if (Element.Attribute.needsLowerCasing(name))
+ try std.ascii.allocLowerString(frame.local_arena, name)
+ else
+ name;
+ break :blk .{ .html, lower };
}
// Generic and XML documents create elements with null namespace
break :blk .{ .null, name };
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index a23cc1883..8ee38c7d3 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -372,8 +372,8 @@ pub fn getTagNameSpec(self: *const Element, allocator: Allocator) []const u8 {
.font => "FONT",
.frameset => "FRAMESET",
.form => "FORM",
- .generic => upperTagName(&he.subtype(Html.Generic)._tag_name, allocator),
- .heading => upperTagName(&he.subtype(Html.Heading)._tag_name, allocator),
+ .generic => upperTag(he.subtype(Html.Generic)._tag),
+ .heading => upperTag(he.subtype(Html.Heading)._tag),
.head => "HEAD",
.html => "HTML",
.hr => "HR",
@@ -393,7 +393,7 @@ pub fn getTagNameSpec(self: *const Element, allocator: Allocator) []const u8 {
.generic => "MEDIA",
},
.meter => "METER",
- .mod => upperTagName(&he.subtype(Html.Mod)._tag_name, allocator),
+ .mod => upperTag(he.subtype(Html.Mod)._tag),
.object => "OBJECT",
.ol => "OL",
.optgroup => "OPTGROUP",
@@ -404,7 +404,7 @@ pub fn getTagNameSpec(self: *const Element, allocator: Allocator) []const u8 {
.param => "PARAM",
.pre => "PRE",
.progress => "PROGRESS",
- .quote => upperTagName(&he.subtype(Html.Quote)._tag_name, allocator),
+ .quote => upperTag(he.subtype(Html.Quote)._tag),
.script => "SCRIPT",
.select => "SELECT",
.slot => "SLOT",
@@ -413,10 +413,10 @@ pub fn getTagNameSpec(self: *const Element, allocator: Allocator) []const u8 {
.style => "STYLE",
.table => "TABLE",
.table_caption => "CAPTION",
- .table_cell => upperTagName(&he.subtype(Html.TableCell)._tag_name, allocator),
- .table_col => upperTagName(&he.subtype(Html.TableCol)._tag_name, allocator),
+ .table_cell => upperTag(he.subtype(Html.TableCell)._tag),
+ .table_col => upperTag(he.subtype(Html.TableCol)._tag),
.table_row => "TR",
- .table_section => upperTagName(&he.subtype(Html.TableSection)._tag_name, allocator),
+ .table_section => upperTag(he.subtype(Html.TableSection)._tag),
.template => "TEMPLATE",
.textarea => "TEXTAREA",
.time => "TIME",
@@ -2391,6 +2391,23 @@ fn upperTagName(tag_name: *String, allocator: Allocator) []const u8 {
};
}
+// For the element types that store a Tag, whose name is always @tagName(tag).
+fn upperTag(tag: Tag) []const u8 {
+ @setEvalBranchQuota(10_000);
+ return switch (tag) {
+ inline else => |t| comptime upperLiteral(@tagName(t)),
+ };
+}
+
+fn upperLiteral(comptime lower: []const u8) *const [lower.len]u8 {
+ comptime {
+ var upper: [lower.len]u8 = undefined;
+ _ = std.ascii.upperString(&upper, lower);
+ const final = upper;
+ return &final;
+ }
+}
+
pub fn getTag(self: *const Element) Tag {
return switch (self._type) {
.html => blk: {
diff --git a/src/browser/webapi/Node.zig b/src/browser/webapi/Node.zig
index f22f347b7..0b17168b6 100644
--- a/src/browser/webapi/Node.zig
+++ b/src/browser/webapi/Node.zig
@@ -1422,7 +1422,10 @@ pub fn getElementsByTagName(self: *Node, tag_name: []const u8, frame: *Frame) !G
};
}
- const lower = try std.ascii.allocLowerString(frame.local_arena, tag_name);
+ const lower = if (Element.Attribute.needsLowerCasing(tag_name))
+ try std.ascii.allocLowerString(frame.local_arena, tag_name)
+ else
+ tag_name;
if (Node.Element.Tag.parseForMatch(lower)) |known| {
// optimized for known tag names, comparison
return .{
diff --git a/src/browser/webapi/css/CSSStyleDeclaration.zig b/src/browser/webapi/css/CSSStyleDeclaration.zig
index 5c4ae9f55..9efc08cc4 100644
--- a/src/browser/webapi/css/CSSStyleDeclaration.zig
+++ b/src/browser/webapi/css/CSSStyleDeclaration.zig
@@ -536,10 +536,9 @@ fn normalizePropertyName(allocator: Allocator, name: []const u8) []const u8 {
// Internal lookups (layout, CDP) pass lowercase names, often outside of a
// JS call where nothing resets local_arena.
- for (name) |c| {
- if (std.ascii.isUpper(c)) break;
- } else return name;
-
+ if (!Element.Attribute.needsLowerCasing(name)) {
+ return name;
+ }
return std.ascii.allocLowerString(allocator, name) catch name;
}
diff --git a/src/browser/webapi/css/CSSStyleProperties.zig b/src/browser/webapi/css/CSSStyleProperties.zig
index 4293987c5..e76cfb974 100644
--- a/src/browser/webapi/css/CSSStyleProperties.zig
+++ b/src/browser/webapi/css/CSSStyleProperties.zig
@@ -330,20 +330,19 @@ fn camelCaseToDashCase(allocator: Allocator, name: []const u8) ![]const u8 {
}
// Special case: cssFloat -> float
- const lower_name = try std.ascii.allocLowerString(allocator, name);
- if (std.mem.eql(u8, lower_name, "cssfloat")) {
+ if (std.ascii.eqlIgnoreCase(name, "cssfloat")) {
return "float";
}
// If already contains dashes, just return lowercased
if (std.mem.findScalar(u8, name, '-')) |_| {
- return lower_name;
+ return std.ascii.allocLowerString(allocator, name);
}
// Check if this looks like proper camelCase (starts with lowercase)
// If not (e.g. "COLOR", "BackgroundColor"), just lowercase it
if (name.len == 0 or !std.ascii.isLower(name[0])) {
- return lower_name;
+ return std.ascii.allocLowerString(allocator, name);
}
// Check for vendor prefixes: webkitTransform -> -webkit-transform
@@ -356,9 +355,13 @@ fn camelCaseToDashCase(allocator: Allocator, name: []const u8) ![]const u8 {
break :blk false;
};
- // name[0] is lowercase, so the vendor dash plus at most two bytes for
- // every other character fits in twice the length.
- const buf = try allocator.alloc(u8, name.len * 2);
+ // Every character, plus a dash before each uppercase one and the vendor
+ // prefix's leading dash.
+ var len = name.len + @intFromBool(has_vendor_prefix);
+ for (name) |c| {
+ len += @intFromBool(std.ascii.isUpper(c));
+ }
+ const buf = try allocator.alloc(u8, len);
var write_pos: usize = 0;
if (has_vendor_prefix) {
diff --git a/src/browser/webapi/element/Attribute.zig b/src/browser/webapi/element/Attribute.zig
index 97255e7fb..3f2e7da41 100644
--- a/src/browser/webapi/element/Attribute.zig
+++ b/src/browser/webapi/element/Attribute.zig
@@ -585,9 +585,11 @@ fn normalizeNameForLookup(name: String, frame: *Frame) !String {
pub fn needsLowerCasing(name: []const u8) bool {
var remaining = name;
if (comptime std.simd.suggestVectorLength(u8)) |vector_len| {
+ const V = @Vector(vector_len, u8);
while (remaining.len > vector_len) {
- const chunk: @Vector(vector_len, u8) = remaining[0..vector_len].*;
- if (@reduce(.Min, chunk) <= 'Z') {
+ const chunk: V = remaining[0..vector_len].*;
+ // 'A'...'Z' wrap to 0...25, every other byte to 26 or more
+ if (@reduce(.Min, chunk -% @as(V, @splat('A'))) < 26) {
return true;
}
remaining = remaining[vector_len..];
@@ -816,3 +818,17 @@ fn writeEscapedAttributeValue(value: []const u8, first_offset: usize, writer: *s
try writer.writeAll(remaining);
}
}
+
+const testing = @import("../../../testing.zig");
+test "Attribute: needsLowerCasing" {
+ try testing.expectEqual(false, needsLowerCasing(""));
+ try testing.expectEqual(false, needsLowerCasing("data-x"));
+ try testing.expectEqual(true, needsLowerCasing("data-X"));
+
+ // longer than any vector: '@' and '[' sit just outside 'A'...'Z'
+ const long = "access-control-allow-origin-0123456789-@[`{-access-control-allow-origin";
+ try testing.expectEqual(false, needsLowerCasing(long));
+ try testing.expectEqual(true, needsLowerCasing("A" ++ long));
+ try testing.expectEqual(true, needsLowerCasing(long ++ "Z"));
+ try testing.expectEqual(true, needsLowerCasing(long[0..20] ++ "M" ++ long[20..]));
+}
diff --git a/src/browser/webapi/net/Headers.zig b/src/browser/webapi/net/Headers.zig
index 827116705..ca0b3ade4 100644
--- a/src/browser/webapi/net/Headers.zig
+++ b/src/browser/webapi/net/Headers.zig
@@ -5,6 +5,7 @@ const js = @import("../../js/js.zig");
const Mime = @import("../../Mime.zig");
const KeyValueList = @import("../KeyValueList.zig");
+const Attribute = @import("../element/Attribute.zig");
const log = lp.log;
const Execution = js.Execution;
@@ -375,6 +376,9 @@ fn validateAndNormalizeName(name: []const u8, exec: *const Execution) ![]const u
}
fn normalizeHeaderName(allocator: Allocator, name: []const u8) Allocator.Error![]const u8 {
+ if (!Attribute.needsLowerCasing(name)) {
+ return name;
+ }
return std.ascii.allocLowerString(allocator, name);
}
diff --git a/src/browser/webapi/net/Request.zig b/src/browser/webapi/net/Request.zig
index a162fe268..7d983fbb5 100644
--- a/src/browser/webapi/net/Request.zig
+++ b/src/browser/webapi/net/Request.zig
@@ -133,7 +133,7 @@ pub fn init(input: Input, opts_: ?InitOpts, exec: *const Execution) !*Request {
}
const method = if (opts.method) |m|
- try parseMethod(m, exec)
+ try parseMethod(m)
else switch (input) {
.url => .GET,
.request => |r| r._method,
@@ -260,14 +260,8 @@ pub fn acquireRef(self: *Request) void {
self._rc.acquire();
}
-fn parseMethod(method: []const u8, exec: *const Execution) !http.Method {
- if (method.len > "propfind".len) {
- return error.TypeError;
- }
-
- const lower = try std.ascii.allocLowerString(exec.local_arena, method);
-
- const method_lookup = std.StaticStringMap(http.Method).initComptime(.{
+fn parseMethod(method: []const u8) !http.Method {
+ const method_lookup = std.StaticStringMapWithEql(http.Method, std.static_string_map.eqlAsciiIgnoreCase).initComptime(.{
.{ "get", .GET },
.{ "post", .POST },
.{ "delete", .DELETE },
@@ -277,7 +271,7 @@ fn parseMethod(method: []const u8, exec: *const Execution) !http.Method {
.{ "options", .OPTIONS },
.{ "propfind", .PROPFIND },
});
- return method_lookup.get(lower) orelse return error.TypeError;
+ return method_lookup.get(method) orelse return error.TypeError;
}
pub fn getUrl(self: *const Request) []const u8 {