removed em-dashes from most of the comments and texts

Ok, so this is currently the sad state of AI usage in projects. We/I
feel that AI is a very robust tool to help us with defining problems,
laying out solutions, and implement them. All under our guidance and
inspection.

It works faster and results often in better code than I could personally
write myself. Not because I have no clue what i'm doing (i hope i have
by now), but mostly because I literally didn't think of solving some
problems in a way that an LLM came up with. And sometimes, it finds ways
that are too ridiculous and with some rewrites we got it back working.
Most of the time, I feel like it uses the same solution i would do
myself, only it's 10 times faster in producing it.

Anyhow, there are many different ways on how to use AI, and I think is
very dangerous that the current mindset by too many people is that when
you use AI, it must be slop. It just screams insecurity in my opinion.

So the first thing that people will check on ANY repo: is there even a
miniscule trace of AI that I can detect in this repo? If so, i will not
be looking any further and will scream AI-slop at the nearest forum i
can find.

This is why i'm removing the em-dashes, the number one telltale on AI
generated content/comments. Not because I don't approve the comments
itself (i think most of them are fine, but it's a big project, and there
are bound to be some spillage here and there that we should
change/update), but I don't approve of the way people will NOT read the
comments, but rather fall over the em-dash being present.

Without them, it might make people actually read the comments, the code,
and decide for themselves if something is AI slop or not.

I don't like that this is the way we have to work at this point in time,
but it is the way it is.

Author: jaytaph

bin/gosub-screenshot/main.rs

@@ -1,7 +1,7 @@
 //! Headless screenshot tool: loads a URL through the full gosub render pipeline and
 //! saves the result as a PNG without opening a window.
 //!
-//! Uses the Skia backend for **CPU** rasterization — no GPU, no wgpu adapter, and no
+//! Uses the Skia backend for **CPU** rasterization - no GPU, no wgpu adapter, and no
 //! system libraries (skia-safe is statically linked). The page is rasterized into small
 //! cached tiles (`ExternalHandle::TileCache`) which we composite here, so there is no
 //! GPU texture-size limit and pages of any height can be captured.
@@ -104,7 +104,7 @@ fn main() {
 
     let url = Url::parse(&url_str).expect("invalid URL");
 
-    // ── Engine setup (CPU backend — no GPU) ───────────────────────────────────
+    // ── Engine setup (CPU backend - no GPU) ───────────────────────────────────
     #[cfg(all(feature = "backend_skia", not(feature = "backend_cairo")))]
     let backend = SkiaBackend::new();
     #[cfg(feature = "backend_cairo")]
@@ -320,7 +320,7 @@ fn main() {
                 // Premultiplied source-over the *existing* buffer (initialised to white), not a
                 // fixed white background: result = src_rgb + (255 - src_a)/255 * dst_rgb. Blending
                 // over the buffer (rather than overwriting) lets an upper layer's transparent
-                // regions reveal content from layers already composited beneath it — e.g. a
+                // regions reveal content from layers already composited beneath it - e.g. a
                 // promoted `position: fixed` navbar tile must not erase the rows behind it.
                 let inv_a = 255u32 - a;
                 let (d0, d1, d2) = (

crates/gosub_config/src/lib.rs

@@ -64,7 +64,7 @@ struct Subscription {
 
 /// A shareable handle to a configuration store. Cloning is cheap (an `Arc` bump); all clones refer
 /// to the same underlying store, so subscriptions and writes made through one clone are visible to
-/// the others. This is the per-engine entry point to configuration — construct one and hand clones
+/// the others. This is the per-engine entry point to configuration - construct one and hand clones
 /// to whichever components need it.
 #[derive(Clone)]
 pub struct Config(Arc<RwLock<ConfigStore>>);
@@ -73,7 +73,7 @@ impl Config {
     /// Creates a config from the given settings schema, backed by a volatile in-memory store.
     ///
     /// `gosub_config` is agnostic of which settings exist: the caller (e.g. the engine) supplies
-    /// the schema — the set of known keys with their defaults and constraints. Only keys present
+    /// the schema - the set of known keys with their defaults and constraints. Only keys present
     /// in the schema can be read or written.
     #[must_use]
     pub fn new(schema: impl IntoIterator<Item = SettingInfo>) -> Self {
@@ -106,7 +106,7 @@ impl Config {
     /// `set`. Returns the number of settings actually merged.
     pub fn merge(&self, other: &Config, namespace: &str) -> usize {
         // Snapshot `other` first (its read guard is released at the end of this statement) so that
-        // acquiring our own write lock can never overlap with it — safe even if `other` is a clone
+        // acquiring our own write lock can never overlap with it - safe even if `other` is a clone
         // of `self`.
         let entries = other.0.read().snapshot();
         self.0.write().absorb(entries, namespace)

crates/gosub_css3/examples/css_corpus_match.rs

@@ -5,7 +5,7 @@
 //! Real-world validation harness for the CSS value-syntax matcher.
 //!
 //! Runs a directory of `.css` files through the property-definition matcher and reports
-//! how much real-world CSS it accepts, plus a ranked breakdown of what it rejects — the
+//! how much real-world CSS it accepts, plus a ranked breakdown of what it rejects - the
 //! rejections are the interesting output, since they point at the next matcher gaps.
 //!
 //! Note: normal parsing does NOT run the matcher (`ParserConfig::match_values` is inert),

crates/gosub_css3/src/colors.rs

@@ -68,7 +68,7 @@ impl From<&str> for RgbColor {
             return RgbColor::new(rgb.get_red(), rgb.get_green(), rgb.get_blue(), 255.0);
         }
         if value.starts_with("rgba(") {
-            // Rgba function — alpha from colors_transform is in 0..1 range; scale to 0..255
+            // Rgba function - alpha from colors_transform is in 0..1 range; scale to 0..255
             let Ok(rgb) = Rgb::from_str(value) else {
                 return RgbColor::default();
             };
@@ -82,7 +82,7 @@ impl From<&str> for RgbColor {
             return RgbColor::new(rgb.get_red(), rgb.get_green(), rgb.get_blue(), 255.0);
         }
         if value.starts_with("hsla(") {
-            // hsla() — alpha from colors_transform is in 0..1 range; scale to 0..255
+            // hsla() - alpha from colors_transform is in 0..1 range; scale to 0..255
             let Ok(hsl) = Hsl::from_str(value) else {
                 return RgbColor::default();
             };

crates/gosub_css3/src/functions/math.rs

@@ -9,8 +9,8 @@ use crate::stylesheet::CssValue;
 /// returned as a `Unit(_, "px")`.
 ///
 /// Returns `None` (leaving the function unresolved) when any operand is not a plain
-/// length we can compare — e.g. a percentage (no containing block here) or a nested
-/// function — so callers can fall back to the original token.
+/// length we can compare - e.g. a percentage (no containing block here) or a nested
+/// function - so callers can fall back to the original token.
 pub fn resolve_math(func: &str, values: &[CssValue]) -> Option<CssValue> {
     // Drop the comma separators that the parser keeps between arguments.
     let operands: Option<Vec<f32>> = values

crates/gosub_css3/src/functions/var.rs

@@ -10,7 +10,7 @@ pub fn resolve_var(values: &[CssValue], custom_props: &HashMap<String, CssValue>
         return vec![value.clone()];
     }
 
-    // Variable not found — use the fallback if provided
+    // Variable not found - use the fallback if provided
     if let Some(fallback) = values.get(1).cloned() {
         return vec![fallback];
     }

crates/gosub_css3/src/matcher/property_definitions.rs

@@ -316,7 +316,7 @@ impl CssDefinitions {
             } => {
                 // A quoted reference (`<'name'>`) denotes a PROPERTY per the CSS value
                 // definition syntax, so resolve it from the property grammar before
-                // anything else — a same-named value type (e.g. the `<top>` used by
+                // anything else - a same-named value type (e.g. the `<top>` used by
                 // `<shape>`) must not shadow the property reference in `inset: <'top'>{1,4}`.
                 if *quoted && datatype != prop_name {
                     if let Some(resolved) = self.resolve_property_reference(datatype, multipliers) {
@@ -904,7 +904,7 @@ mod tests {
                 ],
             ),
             (
-                // `<'margin-top'>{1,4}` — the 1-to-4 value box shorthand (ranged multiplier).
+                // `<'margin-top'>{1,4}` - the 1-to-4 value box shorthand (ranged multiplier).
                 "margin",
                 &[
                     ("10px", true),
@@ -924,7 +924,7 @@ mod tests {
                 &[("10px", true), ("1px 2px 3px 4px", true), ("auto", false)],
             ),
             (
-                // `none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]` — a `||`
+                // `none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]` - a `||`
                 // any-order group with an embedded optional operand.
                 "flex",
                 &[
@@ -954,7 +954,7 @@ mod tests {
             ),
             (
                 // `[ ... <'font-size'> [ / <'line-height'> ]? <'font-family'># ] | ...`
-                // — exercises the `/` line-height separator inside a shorthand.
+                // - exercises the `/` line-height separator inside a shorthand.
                 "font",
                 &[
                     ("12px serif", true),
@@ -977,7 +977,7 @@ mod tests {
                 ],
             ),
             (
-                // `[ <bg-layer> , ]* <final-bg-layer>` — a single layer needs no comma, and
+                // `[ <bg-layer> , ]* <final-bg-layer>` - a single layer needs no comma, and
                 // additional layers are comma-separated. The generator rewrites the
                 // linearized `<bg-layer>#? , <final-bg-layer>` idiom into this spec form.
                 "background",
@@ -1016,7 +1016,7 @@ mod tests {
     }
 
     /// Coverage for the multipliers not exercised by the combinator regression test
-    /// (`*` zero-or-more, `!` at-least-one-in-group, and the ranged `{min,max}` form —
+    /// (`*` zero-or-more, `!` at-least-one-in-group, and the ranged `{min,max}` form -
     /// as opposed to the fixed `{2}` count tested elsewhere).
     #[test]
     fn test_multiplier_coverage() {
@@ -1025,19 +1025,19 @@ mod tests {
         }
         let (a, b) = (|| str!("a"), || str!("b"));
 
-        // `*` — zero or more, so the empty input is valid.
+        // `*` - zero or more, so the empty input is valid.
         assert!(m("a*", &[]));
         assert!(m("a*", &[a()]));
         assert!(m("a*", &[a(), a(), a()]));
 
-        // `!` — the group must produce at least one value even though every operand
+        // `!` - the group must produce at least one value even though every operand
         // inside it is individually optional.
         assert!(!m("[ a? b? ]!", &[]));
         assert!(m("[ a? b? ]!", &[a()]));
         assert!(m("[ a? b? ]!", &[b()]));
         assert!(m("[ a? b? ]!", &[a(), b()]));
 
-        // `{min,max}` — a genuine range (not the fixed `{2}` count): 1..=3 here.
+        // `{min,max}` - a genuine range (not the fixed `{2}` count): 1..=3 here.
         assert!(!m("a{1,3}", &[]));
         assert!(m("a{1,3}", &[a()]));
         assert!(m("a{1,3}", &[a(), a(), a()]));
@@ -1134,7 +1134,7 @@ mod tests {
     }
 
     /// The `/` separating two `<grid-line>`s (and font-size/line-height etc.) is a
-    /// structural delimiter. The `<custom-ident>` catch-all used to consume it — the
+    /// structural delimiter. The `<custom-ident>` catch-all used to consume it - the
     /// optional ident tail in `[ <integer> && <custom-ident>? ]` ate the slash, so any
     /// `grid-column` with a numeric or span left side and a second grid-line failed.
     /// calc() bodies are preserved as raw text (the old stream-slice approach returned
@@ -1146,10 +1146,10 @@ mod tests {
     /// the easing before the property name), and vendor-prefixed math functions.
     /// Micro-gaps surfaced by the 66k-file external corpus: `background-clip: text`
     /// (webref's <visual-box> misses it; use MDN's <bg-clip>), case-insensitive color
-    /// keywords, and percentage scale() — the bare legacy `scale()` value def shadowed
+    /// keywords, and percentage scale() - the bare legacy `scale()` value def shadowed
     /// the modern bracketed `<scale()>` under one loader key (Definition-typed entries
     /// now win). The corpus's `margin-top: 0 \9` rejections are the IE hack, whose whole
-    /// point is that modern parsers reject it — correct behavior, not a gap.
+    /// point is that modern parsers reject it - correct behavior, not a gap.
     #[test]
     fn test_external_corpus_micro_gaps() {
         let defs = get_css_definitions();
@@ -1259,7 +1259,7 @@ mod tests {
         assert!(ok("clip", "auto"));
         assert!(!ok("clip", "banana"));
         // <'top'> property references keep resolving to the property grammar, which
-        // accepts percentages — the <top> value type (`<length> | auto`) does not.
+        // accepts percentages - the <top> value type (`<length> | auto`) does not.
         assert!(ok("inset", "10% 20%"));
         assert!(ok("inset", "auto"));
     }
@@ -1354,7 +1354,7 @@ mod tests {
 
     /// `<alpha()>` in `<color-function>` denotes a function named `alpha`, not a bare
     /// numeric. When its builtin arm matched Zero/Number/Percentage, any bare `0` matched
-    /// `<color>` — so box-shadow's `&&` group let a leading `0` offset claim the
+    /// `<color>` - so box-shadow's `&&` group let a leading `0` offset claim the
     /// shadow-color slot, rejecting every zero-offset shadow.
     #[test]
     fn test_zero_offset_shadows_and_alpha_function() {
@@ -1435,7 +1435,7 @@ mod tests {
     }
 
     /// A value containing a `var()`/`env()` substitution is valid at parse time for any
-    /// property, wherever the substitution appears — its grammar cannot be checked until
+    /// property, wherever the substitution appears - its grammar cannot be checked until
     /// substitution happens (CSS Variables L1 §3).
     #[test]
     fn test_var_substitution() {

crates/gosub_css3/src/matcher/shorthands.rs

@@ -556,8 +556,8 @@ impl CssDefinitions {
                 }
             }
 
-            // `border-radius` is `<lp>{1,4} [ / <lp>{1,4} ]?`, so — unlike margin/padding
-            // whose `{1,4}` sits on the top-level component — the top-level component is a
+            // `border-radius` is `<lp>{1,4} [ / <lp>{1,4} ]?`, so - unlike margin/padding
+            // whose `{1,4}` sits on the top-level component - the top-level component is a
             // Juxtaposition group whose FIRST child carries the `{1,4}` multiplier (the second
             // child is the optional `/ <vertical-radii>` part). Detect that shape and drive the
             // same {1,4}-value box expansion.
@@ -578,7 +578,7 @@ impl CssDefinitions {
                     });
 
                     if nested_quad {
-                        // [BR, BL, TR, TL] — see comment above.
+                        // [BR, BL, TR, TL] - see comment above.
                         for i in [2usize, 3, 1, 0] {
                             shorthands.push(Shorthand {
                                 name: computed[i].clone(),

crates/gosub_css3/src/matcher/styling.rs

@@ -18,9 +18,9 @@ use crate::system::Css3System;
 // Matches a complete selector (all parts) against the given node(id).
 //
 // `pseudo` selects what we are matching against:
-//   * `None`           — match the element itself. Any selector containing a `::pseudo-element`
+//   * `None`           - match the element itself. Any selector containing a `::pseudo-element`
 //                        part never matches (pseudo-elements are not the element).
-//   * `Some("before")` — match the `::before` pseudo-element of `node_id`. Only selectors that
+//   * `Some("before")` - match the `::before` pseudo-element of `node_id`. Only selectors that
 //                        explicitly carry the matching `::before` part match; the rest of the
 //                        compound is matched against the originating element as usual.
 pub(crate) fn match_selector<C: HasDocument>(
@@ -512,7 +512,7 @@ impl CssProperty {
         // Bare numbers and percentages are ratios/multipliers and must keep their fractional
         // value: rounding `opacity: 0.15` to 0 makes an element vanish, `line-height: 1.7`
         // to 2.0 inflates every paragraph, `flex-grow: 0.5` to 1 doubles an item's share.
-        // Relative units (em, rem, vw, vh) must not be rounded either — 1.5em rounded to
+        // Relative units (em, rem, vw, vh) must not be rounded either - 1.5em rounded to
         // 2.0em would make h2 render at h1 size. Only absolute lengths (px, pt, in, cm, mm)
         // are snapped to whole values here.
         match &self.used {

crates/gosub_css3/src/matcher/syntax.rs

@@ -870,7 +870,7 @@ fn parse_component(input: &str) -> IResult<&str, SyntaxComponent> {
     // Only apply an explicit multiplier suffix (one that actually consumed input).
     // `parse_multipliers` returns a default `[Once]` when no suffix is present; applying
     // that would clobber a component's own multipliers. This matters for single-element
-    // groups such as `[ b{2} ]`, which unwrap to their inner component (`b{2}`) — that
+    // groups such as `[ b{2} ]`, which unwrap to their inner component (`b{2}`) - that
     // inner multiplier must survive.
     if rest.len() != input.len() {
         component.update_multipliers(multipliers.clone());