1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
/*
* Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/StringBuilder.h>
#include <AK/Utf8View.h>
#include <LibWeb/CSS/Serialize.h>
namespace Web::CSS {
// https://www.w3.org/TR/cssom-1/#escape-a-character
ErrorOr<void> escape_a_character(StringBuilder& builder, u32 character)
{
TRY(builder.try_append('\\'));
TRY(builder.try_append_code_point(character));
return {};
}
// https://www.w3.org/TR/cssom-1/#escape-a-character-as-code-point
ErrorOr<void> escape_a_character_as_code_point(StringBuilder& builder, u32 character)
{
TRY(builder.try_appendff("\\{:x} ", character));
return {};
}
// https://www.w3.org/TR/cssom-1/#serialize-an-identifier
ErrorOr<void> serialize_an_identifier(StringBuilder& builder, StringView ident)
{
Utf8View characters { ident };
auto first_character = characters.is_empty() ? 0 : *characters.begin();
// To serialize an identifier means to create a string represented by the concatenation of,
// for each character of the identifier:
for (auto character : characters) {
// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).
if (character == 0) {
TRY(builder.try_append_code_point(0xFFFD));
continue;
}
// If the character is in the range [\1-\1f] (U+0001 to U+001F) or is U+007F,
// then the character escaped as code point.
if ((character >= 0x0001 && character <= 0x001F) || (character == 0x007F)) {
TRY(escape_a_character_as_code_point(builder, character));
continue;
}
// If the character is the first character and is in the range [0-9] (U+0030 to U+0039),
// then the character escaped as code point.
if (builder.is_empty() && character >= '0' && character <= '9') {
TRY(escape_a_character_as_code_point(builder, character));
continue;
}
// If the character is the second character and is in the range [0-9] (U+0030 to U+0039)
// and the first character is a "-" (U+002D), then the character escaped as code point.
if (builder.length() == 1 && first_character == '-' && character >= '0' && character <= '9') {
TRY(escape_a_character_as_code_point(builder, character));
continue;
}
// If the character is the first character and is a "-" (U+002D), and there is no second
// character, then the escaped character.
if (builder.is_empty() && character == '-' && characters.length() == 1) {
TRY(escape_a_character(builder, character));
continue;
}
// If the character is not handled by one of the above rules and is greater than or equal to U+0080, is "-" (U+002D) or "_" (U+005F), or is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to U+005A), or \[a-z] (U+0061 to U+007A), then the character itself.
if ((character >= 0x0080)
|| (character == '-') || (character == '_')
|| (character >= '0' && character <= '9')
|| (character >= 'A' && character <= 'Z')
|| (character >= 'a' && character <= 'z')) {
TRY(builder.try_append_code_point(character));
continue;
}
// Otherwise, the escaped character.
TRY(escape_a_character(builder, character));
}
return {};
}
// https://www.w3.org/TR/cssom-1/#serialize-a-string
ErrorOr<void> serialize_a_string(StringBuilder& builder, StringView string)
{
Utf8View characters { string };
// To serialize a string means to create a string represented by '"' (U+0022), followed by the result
// of applying the rules below to each character of the given string, followed by '"' (U+0022):
TRY(builder.try_append('"'));
for (auto character : characters) {
// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).
if (character == 0) {
TRY(builder.try_append_code_point(0xFFFD));
continue;
}
// If the character is in the range [\1-\1f] (U+0001 to U+001F) or is U+007F, the character escaped as code point.
if ((character >= 0x0001 && character <= 0x001F) || (character == 0x007F)) {
TRY(escape_a_character_as_code_point(builder, character));
continue;
}
// If the character is '"' (U+0022) or "\" (U+005C), the escaped character.
if (character == 0x0022 || character == 0x005C) {
TRY(escape_a_character(builder, character));
continue;
}
// Otherwise, the character itself.
TRY(builder.try_append_code_point(character));
}
TRY(builder.try_append('"'));
return {};
}
// https://www.w3.org/TR/cssom-1/#serialize-a-url
ErrorOr<void> serialize_a_url(StringBuilder& builder, StringView url)
{
// To serialize a URL means to create a string represented by "url(",
// followed by the serialization of the URL as a string, followed by ")".
TRY(builder.try_append("url("sv));
TRY(serialize_a_string(builder, url.to_deprecated_string()));
TRY(builder.try_append(')'));
return {};
}
// https://www.w3.org/TR/cssom-1/#serialize-a-local
ErrorOr<void> serialize_a_local(StringBuilder& builder, StringView path)
{
// To serialize a LOCAL means to create a string represented by "local(",
// followed by the serialization of the LOCAL as a string, followed by ")".
TRY(builder.try_append("local("sv));
TRY(serialize_a_string(builder, path.to_deprecated_string()));
TRY(builder.try_append(')'));
return {};
}
// NOTE: No spec currently exists for serializing a <'unicode-range'>.
ErrorOr<void> serialize_unicode_ranges(StringBuilder& builder, Vector<UnicodeRange> const& unicode_ranges)
{
TRY(serialize_a_comma_separated_list(builder, unicode_ranges, [](auto& builder, UnicodeRange unicode_range) -> ErrorOr<void> {
return serialize_a_string(builder, TRY(unicode_range.to_string()));
}));
return {};
}
// https://www.w3.org/TR/css-color-4/#serializing-sRGB-values
ErrorOr<void> serialize_a_srgb_value(StringBuilder& builder, Color color)
{
// The serialized form is derived from the computed value and thus, uses either the rgb() or rgba() form
// (depending on whether the alpha is exactly 1, or not), with lowercase letters for the function name.
// NOTE: Since we use Gfx::Color, having an "alpha of 1" means its value is 255.
if (color.alpha() == 255)
TRY(builder.try_appendff("rgb({}, {}, {})"sv, color.red(), color.green(), color.blue()));
else
TRY(builder.try_appendff("rgba({}, {}, {}, {})"sv, color.red(), color.green(), color.blue(), (float)(color.alpha()) / 255.0f));
return {};
}
ErrorOr<String> escape_a_character(u32 character)
{
StringBuilder builder;
TRY(escape_a_character(builder, character));
return builder.to_string();
}
ErrorOr<String> escape_a_character_as_code_point(u32 character)
{
StringBuilder builder;
TRY(escape_a_character_as_code_point(builder, character));
return builder.to_string();
}
ErrorOr<String> serialize_an_identifier(StringView ident)
{
StringBuilder builder;
TRY(serialize_an_identifier(builder, ident));
return builder.to_string();
}
ErrorOr<String> serialize_a_string(StringView string)
{
StringBuilder builder;
TRY(serialize_a_string(builder, string));
return builder.to_string();
}
ErrorOr<String> serialize_a_url(StringView url)
{
StringBuilder builder;
TRY(serialize_a_url(builder, url));
return builder.to_string();
}
ErrorOr<String> serialize_a_srgb_value(Color color)
{
StringBuilder builder;
TRY(serialize_a_srgb_value(builder, color));
return builder.to_string();
}
}
|
