This ensures that calling `element.classList.toString()` always
produces the correct value.
(cherry picked from commit ec1f7779cb16223dab0ef9f7bf875c3f7b5724a9)
Previously, when creating a HTML element with
`document.createElementNS()` we would convert the given local name to
lowercase before deciding which element type to return. We now no
longer perform this lower case conversion, so if an uppercase local
name is provided, an element of type `HTMLUnknownElement` will be
returned. This aligns our implementation with the specification.
(cherry picked from commit 5a796629c61221261c1856e19dd829973e6158f0)
While conceptually is_supported_property_index is a cheap index lookup,
it is not currently cheap for an container such as HTMLAllCollection
that is operating on an uncached collection. Instead - just do the
lookup once. It also happens to look a little nicer to not blindly
dereference an optional.
(cherry picked from commit 22969a8e929eae00a45989acae99eb5a97269358)
This uses a faster hashtable lookup in the case of HTMLCollection.
Also port invoke_named_property_setter to FlyString to avoid a
FlyString->String->FlyString conversion that surfaces from this change.
(cherry picked from commit 8a5985b87f618120ce891bfbe87786381654af25)
This removes some ambiguity about what the return value should be if
the index is out of range.
Previously, we would sometimes return a JS null, and other times a JS
undefined.
It will also let us fold together the checks for whether an index is a
supported property index, followed by getting the value just afterwards.
(cherry picked from commit c5c1a8fcc78af986e5dd1a1f0bef1223e458ed37)
We don't need this for any case, so just remove it to simplify handling
in PlatformObject.
(cherry picked from commit 081c92bf3dc66773887243718cf41011289ac55e)
These let you format counters' current values as strings for use in
generated content.
(cherry picked from commit 898e3bd89878ddb87df06e056031673dc770be2b)
This is `counter(name, style?)` or `counters(name, link, style?)`. The
difference being, `counter()` matches only the nearest level (eg, "1"),
and `counters()` combines all the levels in the tree (eg, "3.4.1").
(cherry picked from commit 576a4314084e5c3b839006da00dddb16e58b3503)
These control the state of CSS counters.
Parsing code for `reversed(counter-name)` is implemented, but disabled
for now until we are able to resolve values for those.
(cherry picked from commit 017d6c3314d57d4e351764f328c1d25dbc9d033a)
The new method is Parser::parse_all_as_single_none_value(), which has a
few advantages:
1. There's no need for user code to manually create a StyleValue.
2. It consumes tokens so that doesn't have to be done manually.
3. Whitespace before or after the `none` is consumed correctly.
It does mean we create and then discard a `none` StyleValue in a couple
of places, namely parsing for `grid-*` properties. We may or may not
want to migrate those to returning the IdentifierStyleValue instead.
(cherry picked from commit ca10fb412947f6b6080326573418bfa8a3759c12)
This seems to have been required when pseudo-elements were first
implemented, but has since become unused. It's also awkward because we
don't have access to the DOM Element and its CountersSet at this point.
So, let's remove it.
For reference, Chrome&Firefox both return the computed value for
`content: counter(foo)` as `counter(foo)`, not as the computed string.
So not computing it here seems like the intended behaviour.
(cherry picked from commit 6f2f91d1f50130b6060ccfb1af1faaa890e81618)
This represents each element's set of CSS counters.
https://drafts.csswg.org/css-lists-3/#css-counters-set
Counters are resolved while building the tree. Most elements will not
have any counters to keep track of, so as an optimization, we don't
create a CountersSet object until the element actually needs one.
In order to properly support counters on pseudo-elements, the
CountersSet needs to go somewhere else. However, my experiments with
placing it on the Layout::Node kept hitting a wall. For now, this is
fairly simple at least.
(cherry picked from commit 708f49d906389f8875f006894e2aacf2305834bf)
This code previously only allocated enough space in
m_col_elements_by_index for 1 slot per column, meaning that columns
with a span > 1 would write off the end of it.
(cherry picked from commit 9e32c9329acd89d73eeff3494a5e728077962513)
...for images that don't use a color indexing transform.
For now, write the predictor transform unconditionally, and predict
every pixel as its left neighbor (that is, use predictor 1 everywhere).
This will grow a better heuristic in time, and eventually we might want
to use more than 1 of the 13 different predictor modes. But on average,
doing this unconditionally is better than not doing it unconditionally.
(Also, it's possible to disable this transform using `image`'s
`--webp-allowed-transforms` flag.)
Using the same benchmark as in #24819, this reduces the total size
of the test images further, from 88M to 69M (21.6%). It does increase
runtime for compressing all these images from about 4.4s to 4.7s,
a 6.8% slowdown.
For the usual test image (no effect on the two animations, which use
the color indexing transform):
sunset_retro.png (876K):
1.2M -> 730K, 31.4 ms ± 0.8 ms -> 31.4 ms ± 0.7 ms
From 37% larger than the input to 16% _smaller_ than the input :^)
(A 39% size reduction for this image.)
Compressing sunset_retro.png with zopflipng produces a 820K image,
so we're smaller even than what the best PNG encoder can do with
this image.
It's not a win for all images: For example, the size of
qoi_benchmark_suite/screenshot_web/sublime.png goes from 1.0M to 1.5M,
a fairly dramatic size increase. Hopefully we can get that back in
the future with better heuristics. (The input sublime.png is 1.3M,
and sublime.png encoded using our QOI encoder creates a 1.6M file,
so the 1.5M isn't atrocious, even though it's much bigger than the
size without the predictor transform.)
Our WebP Lossless writer currently now has a similar feature set
to our QOI writer: RLE, color cache, left prediction, and
subtract green is somewhat similar to QOI's luma chunk. The WebP
writer also writes huffman trees, which QOI doesn't do. For most
images, the WebP writer creates smaller files than the QOI writer,
while being about 50% slower. The WebP writer also writes smaller
files than Serenity OS's png writer, while being ~40x as fast
(for sunset_retro, ~30ms instead of ~1.3s; 730K output instead of
999K).
Only doing RLE and using a single predictor for the entire image is
similar to what fpng is doing (...but fpng uses the T predictor always).
We still don't write a meta prefix image to keep the huffman trees
flatter, we still don't do full LZ77 backward matches, and we still
don't write color transforms. But the writer has now enough features
to be in usable shape. It's now Serenity OS's best-compressing lossless
image writer.
The test_webp_color_indexing_transform_single_channel test uses a
linear horizontal gradient, which the predictor transform compresses
so well that encoded_data_without_color_indexing ends up being
smaller than the color indexed file. Just disable the predictor
transform in that test for now.
Removes some noise from the console when browsing bbc.co.uk :^)
(cherry picked from commit 793248aec977d4b15006d6e55a960da2e115a734,
amended to s/UIEvents::KeyCode/KeyCode/ to resolve cherry-pick conflict)
We now ensure that `Node::is_character_data()` returns true for all
nodes of type character data.
Previously, calling `Node::length()` on `CDataSection` or
`ProcessingInstruction` nodes would return an incorrect value.
(cherry picked from commit 3802d9ccc4ea4428b82c6d584c3667c040cb46c7)
We now follow the rules from the spec more closely, along with an
unspecified quirk for when the offsetParent is a non-positioned body
element. (Spec bug linked in a comment.)
This fixes a whole bunch of css-flexbox tests on WPT, which already had
correct layout, but the reported metrics from JS API were wrong.
(cherry picked from commit d49ae5af32044cb83bc14073b92676a1662c3bc1)
This makes https://wpt.fyi/ load today instead of tomorrow, although
there's a lot of room for improvement still.
(cherry picked from commit 4d78c66b3d0092d0e6137a11d55e59a6b8bfc5b1)
We were mistakenly executing the current node's script instead of the
document's pending parsing-blocking script.
This caused ~1000 WPT tests to time out, since we never ended up firing
a load event for XHTML pages that load multiple external scripts.
(cherry picked from commit 007c292af3202a85eb146b121720d988a66ed64b)
Checking that the string parsed for the `font` property is not enough,
the spec also wants to rule out CSS-wide keywords like `inherit`. The
simplest way to do so is to check if it's a ShorthandStyleValue, which
also rules out use of `var()`; this matches other browsers' behaviour.
The newly-added test would previously crash, and now doesn't. :^)
(cherry picked from commit 64d45afd8a650981d4dbab98aa49d47629568f5b)
This PR removes the CRLF characters from the message body data before
passing it to `decode_base64()` so that we can properly display the
message contents.
The :host family of pseudo class selectors select the shadow host
element when matching against a rule from within the element's shadow
tree.
This is a bit convoluted due to the fact that the document-level
StyleComputer keeps track of *all* style rules, and not just the
document-level ones.
In the future, we should refactor style storage so that shadow roots
have their own style scope, and we can simplify a lot of this.
(cherry picked from commit 4c326fc5f6f64797764e7f32a9789b74665f2fec)
This fixes an issue where :host(foo) would parse as if "foo" was the
on the right side of a descendant combinator.
Not testable yet, but will be in the next commit.
(cherry picked from commit 274c46a3c97e1f9969d18b7704ced4c39770e152)
This PR fixes truncation of quoted strings containing escaped quotes,
which were not being handled properly by the parser, resulting in
occasional crashes.
This is the expected behavior per the HTML spec. Fixes an issue where
styling these elements wouldn't have the expected effect unless you also
set the display property.
(cherry picked from commit 3faff34bf6a290e4df1c73f92e8c7d992a78a8e0)
This way, we still perform UTF-8 validation, but don't go through the
slow generic code path that rebuilds the decoded string one code point
at a time.
This was a bottleneck when loading a canned copy of reddit.com, which
ended up being ~120 MiB large.
- Time spent decoding UTF-8 before this change: 1192 ms
- Time spent decoding UTF-8 after this change: 154 ms
That's still a long time, but 7.7x faster is nothing to sneeze at! :^)
Note that if the input fails UTF-8 validation, we still fall back to
the slow path and insert replacement characters per the WHATWG Encoding
spec: https://encoding.spec.whatwg.org/#utf-8-decode
(cherry picked from commit 1a46d8df5fc81eb2c320d5c8a5597285d3d8fb3a)
In `PaintableBox::set_scroll_offset()` the scrollport size was measured
by `content_size()` instead of `absolute_padding_box_rect()`.
Fixes#788
(cherry picked from commit 54066ec5a454f33d8c5e4ea1f8695942b95b1b82)
...except for images that already use a color indexing transform
or are constant-alpha grayscale.
This makes some images larger, but it's on average better than
not doing it: When compressing all images in:
* Base/res/wallpapers
* qoi_benchmark_suite/screenshot_web
* qoi_benchmark_suite/textures_photo
...this reduces the combined output size from 105M to 88M (16%).
See PR for details on reproducing this.
(Runtime for compressing all images increases from a little under
4.4s to a little over 4.4s, so no big per cost either.)
For the images in those directories, it's even always a win.
The size of qoi_benchmark_suite/textures_pk01/pk01_floor01_local.png
increases from 366K to 375K (2.5%), so it's not _always_ a win.
Total size of qoi_benchmark_suite/textures_pk01 increases by 0.6%,
small enough that `du -sh` output is identical for that directory.
sunset_retro.png (876K):
1.4M -> 1.2M, 31.3 ms ± 0.7 ms -> 31.4 ms ± 0.8 ms
From 60% larger than the input file to 37% larger (13.3% smaller),
for a less-than-1% slowdown.
(The size of my two test gifs doesn't change, since those use the
color indexing transform.)
We used to write a color indexing transform for grayscale images.
This stores a palette and then indexes into that palette.
For grayscale images with constant alpha, we don't need to store
the palette image: Using a subtract green transform has the same effect.
(For animations, most frames don't have constant alpha because
AnimationWriter replaces identical pixels with transparent black,
making sure that these frames have a mix of opaque and transparent
pixels. But the first frame of a grayscale animation will use this.)
Only saves a couple of bytes for storing the palette image,
but it's also free in term of performance, and it's conceptually
pleasing.
Reduces the size of 7z7c.webp by 30 bytes, from 8818 to 8788 bytes.
This PR fixes a crash where the parser assumes parenthesized lists of
address structures should be separated by whitespace. Per RFC-9051,
there is no indication of this.
This PR avoids crashing the parser when a group address is encountered,
and keeps the Mail reader happy :^).
Eventually, when we are able to send messages, we may want some kind of
GroupAddress object, but for now this should be ok.
Having resolution of all properties for all paintable types in a single
function was hard to iterate on, so this change separates it into
smaller functions per paintable type.
(cherry picked from commit 7047fcf761ba3cac775befca78e7e6f758dc7c8b)
The Response interface of the Fetch API can now parse form urlencoded
bodies when Content-Type is set to 'application/x-www-form-urlencoded'.
(cherry picked from commit b8fa572c6742c0f1f63da0f63c8b86835a86988d)
This getter returns the concatenation of the data of the contiguous
Text nodes of `this` (being this plus its siblings) in tree order.
(cherry picked from commit 69da6a0ce400d4a675bfba1f1dd1d313ee1f13c0)
This to avoid clashing with the GCC typeof extension, which apparently
confuses clang-format.
(cherry picked from commit 14beda00c9e823dd34da74e7d8fdf46aa57e845c)
The typeof operator has a very small set of possible resulting strings,
so let's make it much faster by caching those strings on the VM.
~8x speed-up on this microbenchmark:
for (let i = 0; i < 10_000_000; ++i) {
typeof i;
}
(cherry picked from commit d0b11af3876a64e6b254b5fc3f474d9bbe552024)
Previously, if a document had any element with a name attribute that
was set to the empty string, then `document.getElementsByName("")` and
`element.getElementsByName("")` would return a collection including
those elements.
(cherry picked from commit e40352b6b59e99a9f3fd922142c2abafd9840e6c)
Previously, `document.getElementsByClassName("")` would return a
collection containing all elements in the given document.
(cherry picked from commit 0fceede029e6af0cab98e86f20367d8835008472)
Previously, we had two implementations of the same function in
`Document` and `Element`, which had inadvertantly diverged.
(cherry picked from commit faf64bfb41393a59e958e21545aa556c9bb9d6a8)
Previously, if a document had an element whose id was the empty string,
then `document.getElementById("")` and `element.getElementById("")`
would return that element.
(cherry picked from commit f666d967d6bac289346cf19f833f81bdc22adbdb)
Before this change, removing a style element from inside a shadow tree
would cause it to be unregistered with the document-level list of sheets
instead of the shadow-root-level list.
This would eventually lead to a verification failure if someone tried to
update the text contents of that style element, since it was still in
the shadow-root-level list, but now with a null owner element.
Fixes a crash on https://www.swedbank.se/
(cherry picked from commit 3b7534b3628641244b0998fd5061c6fa75a61cf5)
This would have saved me an hour of debugging, so putting it here for
the next person. :^)
(cherry picked from commit ebacb921dac6f8fd335d917100e6b04521a3f893)
This avoids a crash that occurred when calling `getBBox()` on an SVG
element that had a transform with no inverse.
Found by Domato.
(cherry picked from commit d417b7568360f20487e4182e52872b82c8fbbf60)
Previously, `SVGSVGBox` would have a natural aspect ratio of 0 if it
had a viewbox with zero width. This led to a division by zero, causing
a crash.
Found by Domato.
(cherry picked from commit 4cdafea36334bcff8c4bbb083076ae55b599177c)
Previously calling `PaintableBox::set_scroll_offset()` with a
PaintableBox whose content size was larger than its scrollble overflow
rect would cause a crash.
Found by Domato.
(cherry picked from commit 604f6040a180ac409cf338045c8709a171d920d5)
GCC 14 emits a warning when an always succeeding `dynamic_cast`'s return
value is compared to NULL inside the `AK::is<T>(U)` template when `T` ==
`U`.
While warning on tautological `is` calls seems useful, it's a bit
awkward when it comes from a function template where the cast may fail
in some instantiation. There is a GCC bug open for it:
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115664
Work around the warning by performing the algorithm on the base type
(`EventTarget`), with a wrapper that casts it to the more specialized
input type.
(cherry picked from commit 31eb0ed938dff11dee7391a4f616f4132aa250c0)
