[idoubtit]

> That is because CSS is a different Chomsky Grammar than HTML and EMCA - intentionally not Turing complete

CSS has been Turing complete for many years.

You can simulate Turing machines with pure HTML+CSS, e.g. https://github.com/yrd/tm2css

"Rule 110" which implies Turing-completeness has also been implemented in CSS, e.g. http://eli.fox-epste.in/rule110/

[Jerrrrrrry]

CSS has been very, very, very close.

I would had had, had - "has" not been had, expected sooner, but atlas.

But the aforementioned ":has": : The :has() pseudo-class cannot be nested within another :has(). This is because many pseudo-elements exist conditionally based on the styling of their ancestors and allowing these to be queried by :has() can introduce cyclic querying.

  Pseudo-elements are also not valid selectors within :has() and pseudo-elements are not valid anchors for :has().

Note the two limits, "cyclic querying" and self-referential parameters.

The former is required for a basic computational model, the latter for one that supports recursive-ness and thus some optimizations .

  "Rule 110"

This is just lambada calculus and has no tape movement - requires checkin boxes, still, and thinking about whether or not to halt - which actually kinda is its own asterisk (not the usual 'infinite tape' kind). Turing Machines would halt on some input; your calculator goes until the actual computer, you, halts, or stops actually checking(computing) the state for a HALT/desired state.

You'd think someone woulda parasol'd the checkboxes and at least attempted to use :onHover with grid to require minimal mouse movement to trigger input instead.

Or, a bounding box input state driven hack - like when your cursor is "in between" elements, changing every frame.

  pure HTML+CSS, e.g. https://github.com/yrd/tm2css

seems cool, actually. SASS repeats CSS exhaustively through HTML-encoded steps until a valid one is painted - that valid one being the HALT/output. You do have to specify the number of steps, though. You would have to know whether or not it halts, the answer, and how many steps it took to compute to functionally (heavy-lifting in this context) use it - or else it would have to reference itself....which would make it a higher grammar.

But it can't: https://www.w3.org/TR/css-variables/#cycles

  This can create cyclic dependencies where a custom property uses a var() referring to itself, or two or more custom properties each attempt to refer to each other....If there is a cycle in the dependency graph, all the custom properties in the cycle are invalid at computed-value time.

Very close. But you must beg the question (ie. know the answer) in both step count and thus the answer, else you'd have an infinite HTML page. Which is fine in math (HTML is a Type 2, can be infinite, no self-reference, no self-children, nor orphans), but not really much of a simulation/emulation though - if it can only produce valid machines at (essentially) compile time.