rust-cssparser VS MSEdgeExplainers

If you were to implement this yourself, i'd look into either swash or cosmic-text for the text rendering stack (this is one of the things you really don't want to write from the ground up). For accessibility, AccessKit has quickly become the standard for communicating with crossplatform accessibility APIs in rust GUI. lightningcss (or its lower level counterpart cssparser) are both decent options for CSS parsing. Taffy handles some of what browsers offer for a layout engine, but is still being worked on.

Libraries for a lot of this stuff exist (albeit in many cases not very mature yet):

- https://github.com/pop-os/cosmic-text does text layout (which Taffy explicitly considers out of scope)

- https://github.com/AccessKit/accesskit does accessibility

- https://github.com/servo/rust-cssparser does value-agnostic CSS parsing (it will parse the general syntax but leaves value parsing up to the user, meaning you can easily add support for whatever properties you what). Libraries like https://github.com/parcel-bundler/lightningcss implement parsing for the standard css properties.

- There are crates like https://github.com/BurntSushi/bstr and https://docs.rs/wtf8/latest/wtf8/ for working with non-unicode text

We are planning to add a C API to Taffy, but tbh I feel like C is not very good for this kind of modularised approach. You really want to be able to expose complex APIs with enforced type safety and this isn't possible with C.

The spec is a W3C CSS working group draft: https://drafts.csswg.org/css-anchor-position-1/

It looks like less of a Chrome thing and more of an Edge thing? The Intent to Prototype [1] links to an Edge explainer [2] with Microsoft authors. It doesn't look like anyone has asked Mozilla for a position yet [3] but I expect if they get positive signals from web developers (us!) that will be soon.

[1] https://groups.google.com/a/chromium.org/g/blink-dev/c/vsPdd...

[2] https://github.com/MicrosoftEdge/MSEdgeExplainers/blob/main/...

[3] https://github.com/mozilla/standards-positions/issues?q=anch...

Read the explainer here

You can learn more about Focus Mode in this Edge explainer document.

For a spec about a browser feature, "getting it" can mean a few different things.

1. Understanding the purpose of the feature ("why/when would I use this?")

2. Understanding how to implement the feature

3. Understanding how to use the feature

4. Understanding the feature's "corner cases" (surprising implications, cases where it doesn't do what you'd expect, etc.)

5. Understanding why the feature works the way it does (instead of some other way)

Most of the web specs really only explain how to implement a feature, and even then, they're not great at that, because they do such a poor job at explaining the purpose of the feature.

Assuming that you, like most of us, aren't working on implementing a browser, that means that web specs are mostly unhelpful to you. It's almost completely beyond the purpose of a spec to teach you how to use a feature, what its corner cases would be (which are often unknown at the time a spec was written), and why the specification says what it says.

This is an area where the web spec community has made some improvements in recent years. Nowadays, it's understood that new proposed specifications shouldn't just provide a specification, but also a separate "explainer" document, whose purpose is to communicate #1 (the purpose of the feature), and also persuade the other browser vendors to implement the feature. ("This will be really cool, and here's why…")

At a minimum, specs nowadays often include a non-normative "Motivation" section, as the CSS Nesting spec does. https://www.w3.org/TR/css-nesting-1/ I you'll find that you can "get" that spec much better than you can the CSS OM spec https://www.w3.org/TR/cssom-1/ which is old enough to buy alcohol and doesn't include a "Motivation" section.

You can often find explainer docs linked off of https://chromestatus.com/ e.g. https://github.com/MicrosoftEdge/MSEdgeExplainers/blob/main/... I think you'll find that explainers are 10000% better for learning features than specs are. (They typically even discuss #3, #4, and #5, as they typically discuss alternative rejected approaches.)

Transparent ads are enabled through ad providers joining the Transparent Ads Provider program. More info on the program and the requirements for providers here - https://github.com/MicrosoftEdge/MSEdgeExplainers/blob/main/TransparentAds/Program-Overview.md

Not necessarily for a Swift project, but your experience makes me wonder about the current web API for highlighting spans of text.

https://github.com/MicrosoftEdge/MSEdgeExplainers/blob/main/...

Complicated...