blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/gecko/pseudo_element_definition.mako.rs

@@ -0,0 +1,298 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use crate::derives::*;
+
+type AtomThinVec = thin_vec::ThinVec<Atom>;
+
+/// Gecko's pseudo-element definition.
+///
+/// We intentionally double-box legacy ::-moz-tree pseudo-elements to keep the
+/// size of PseudoElement (and thus selector components) small.
+#[derive(Clone, Debug, Eq, Hash, MallocSizeOf, PartialEq, ToShmem)]
+#[repr(u8)]
+pub enum PseudoElement {
+    % for pseudo in PSEUDOS:
+    /// ${pseudo.name}
+    % if pseudo.argument:
+    ${pseudo.capitalized}(${pseudo.argument}),
+    % else:
+    ${pseudo.capitalized},
+    % endif
+    % endfor
+    /// ::-webkit-* that we don't recognize
+    /// https://github.com/whatwg/compat/issues/103
+    UnknownWebkit(Atom),
+}
+
+<% EAGER_PSEUDOS = list(filter(lambda p: getattr(p, 'is_eager', False), PSEUDOS)) %>
+
+/// The number of eager pseudo-elements.
+pub const EAGER_PSEUDO_COUNT: usize = ${len(EAGER_PSEUDOS)};
+
+/// The number of all pseudo-elements.
+pub const PSEUDO_COUNT: usize = ${len(PSEUDOS)};
+
+/// The list of eager pseudos.
+pub const EAGER_PSEUDOS: [PseudoElement; EAGER_PSEUDO_COUNT] = [
+    % for eager_pseudo in EAGER_PSEUDOS:
+    PseudoElement::${eager_pseudo.capitalized},
+    % endfor
+];
+
+<%def name="pseudo_element_variant(pseudo, arg='..')">\
+PseudoElement::${pseudo.capitalized}${"({})".format(arg) if pseudo.argument else ""}\
+</%def>
+
+impl PseudoElement {
+    /// Whether this pseudo-element is tree pseudo-element.
+    #[inline]
+    pub fn is_tree_pseudo_element(&self) -> bool {
+        matches!(
+            *self,
+            ${" | ".join(capture(pseudo_element_variant, pseudo) for pseudo in PSEUDOS if pseudo.name.startswith("-moz-tree-"))}
+        )
+    }
+
+    #[inline]
+    fn flags_for_index(i: usize) -> PseudoStyleTypeFlags {
+        static FLAGS: [PseudoStyleTypeFlags; PSEUDO_COUNT + 1] = [
+        % for pseudo in PSEUDOS:
+        PseudoStyleTypeFlags::from_bits_truncate(${' | '.join(f"PseudoStyleTypeFlags::{flag}.bits()" for flag in pseudo.flags())}), // ${pseudo.name}
+        % endfor
+        // Unknown ::-webkit-* pseudos allow user-action state pseudo-classes.
+        PseudoStyleTypeFlags::from_bits_truncate(
+            PseudoStyleTypeFlags::IS_PSEUDO_ELEMENT.bits() |
+            PseudoStyleTypeFlags::SUPPORTS_USER_ACTION_STATE.bits()
+        ),
+        ];
+        FLAGS[i]
+    }
+
+    /// Gets the flags associated to this pseudo-element or anon box.
+    #[inline]
+    pub fn flags(&self) -> PseudoStyleTypeFlags {
+        Self::flags_for_index(self.index())
+    }
+
+    /// If this pseudo is pref-gated, returns the pref value, otherwise false.
+    pub fn type_enabled_in_content(ty: PseudoStyleType) -> bool {
+        let flags = Self::flags_for_index(ty as usize);
+        // Common path, not enabled explicitly in UA sheets (note that chrome implies UA), and not
+        // pref-gated.
+        if !flags.intersects(PseudoStyleTypeFlags::ENABLED_IN_UA | PseudoStyleTypeFlags::ENABLED_BY_PREF) {
+            return true;
+        }
+        if !flags.intersects(PseudoStyleTypeFlags::ENABLED_BY_PREF) {
+            return false;
+        }
+        match ty {
+        % for pseudo in PSEUDOS:
+        % if pseudo.pref:
+            PseudoStyleType::${pseudo.capitalized} => pref!("${pseudo.pref}"),
+        % endif
+        % endfor
+            _ => false,
+        }
+    }
+
+    /// Returns the current value of the `enabled_domains_pref` pref for this
+    /// pseudo, if it has one. The value is a list of the only domains for
+    /// which this pseudo should be enabled, or "*" for "every domain" (see
+    /// `nsContentUtils::IsURIInList` for the format).
+    pub fn enabled_domains(&self) -> Option<nsstring::nsCString> {
+        match *self {
+        % for pseudo in PSEUDOS:
+        % if pseudo.is_pseudo_element() and pseudo.enabled_domains_pref:
+            ${pseudo_element_variant(pseudo)} => Some(pref!("${pseudo.enabled_domains_pref}")),
+        % endif
+        % endfor
+            _ => None,
+        }
+    }
+
+    /// Construct a pseudo-element from a `PseudoStyleType`.
+    #[inline]
+    pub fn from_pseudo_type(type_: PseudoStyleType, functional_pseudo_parameter: Option<AtomIdent>) -> Option<Self> {
+        match type_ {
+            % for pseudo in PSEUDOS:
+            % if not pseudo.argument:
+            PseudoStyleType::${pseudo.capitalized} => {
+                debug_assert!(functional_pseudo_parameter.is_none());
+                Some(${pseudo_element_variant(pseudo)})
+            },
+            % elif pseudo.argument == "AtomThinVec":
+            PseudoStyleType::${pseudo.capitalized} => {
+                debug_assert!(functional_pseudo_parameter.is_none());
+                Some(${pseudo_element_variant(pseudo, "Default::default()")})
+            },
+            % elif pseudo.argument == "PtNameAndClassSelector":
+            PseudoStyleType::${pseudo.capitalized} => functional_pseudo_parameter.map(|p| {
+                PseudoElement::${pseudo.capitalized}(PtNameAndClassSelector::from_name(p.0))
+            }),
+            % else:
+            <% assert pseudo.argument == "AtomIdent", f"Unhandled argument type {pseudo.argument}" %>
+            PseudoStyleType::${pseudo.capitalized} => {
+                functional_pseudo_parameter.map(PseudoElement::${pseudo.capitalized})
+            },
+            % endif
+            % endfor
+            _ => None,
+        }
+    }
+
+    /// Construct a `PseudoStyleType`.
+    #[inline]
+    pub fn pseudo_type(&self) -> PseudoStyleType {
+        // SAFETY: PseudoStyleType has the same variants as PseudoElement
+        unsafe { std::mem::transmute::<u8, PseudoStyleType>(self.discriminant()) }
+    }
+
+    /// Returns the relevant PseudoStyleType, and an atom as an argument, if any.
+    /// FIXME: we probably have to return the arguments of -moz-tree. However, they are multiple
+    /// names, so we skip them for now (until we really need them).
+    #[inline]
+    pub fn pseudo_type_and_argument(&self) -> (PseudoStyleType, Option<&Atom>) {
+        let ty = self.pseudo_type();
+        let arg = match *self {
+            % for pseudo in PSEUDOS:
+            % if pseudo.argument == "PtNameAndClassSelector":
+            PseudoElement::${pseudo.capitalized}(ref val) => Some(val.name()),
+            % elif pseudo.argument == "AtomIdent":
+            PseudoElement::${pseudo.capitalized}(ref val) => Some(&val.0),
+            % endif
+            % endfor
+            _ => None,
+        };
+        (ty, arg)
+    }
+
+    /// Get the argument list of a tree pseudo-element.
+    #[inline]
+    pub fn tree_pseudo_args(&self) -> &[Atom] {
+        match *self {
+            % for pseudo in PSEUDOS:
+            % if pseudo.name.startswith("-moz-tree-"):
+            PseudoElement::${pseudo.capitalized}(ref args) => args,
+            % endif
+            % endfor
+            _ => &[],
+        }
+    }
+
+    /// Constructs a pseudo-element from a string of text.
+    ///
+    /// Returns `None` if the pseudo-element is not recognised.
+    #[inline]
+    pub fn from_slice(name: &str) -> Option<Self> {
+        // We don't need to support tree pseudos because functional
+        // pseudo-elements needs arguments, and thus should be created
+        // via other methods.
+        cssparser::ascii_case_insensitive_phf_map! {
+            pseudo -> PseudoElement = {
+                % for pseudo in PSEUDOS:
+                % if not pseudo.argument:
+                "${pseudo.name}" => ${pseudo_element_variant(pseudo)},
+                % endif
+                % endfor
+                // Alias some legacy prefixed pseudos to their standardized name at parse time:
+                "-moz-selection" => PseudoElement::Selection,
+                "-moz-placeholder" => PseudoElement::Placeholder,
+                "-moz-list-bullet" => PseudoElement::Marker,
+                "-moz-list-number" => PseudoElement::Marker,
+            }
+        }
+        if let Some(p) = pseudo::get(name) {
+            return Some(p.clone());
+        }
+        if starts_with_ignore_ascii_case(name, "-moz-tree-") {
+            return PseudoElement::tree_pseudo_element(name, Default::default())
+        }
+        None
+    }
+
+    /// Produces an `UnknownWebkit` pseudo-element for any `-webkit-*` name.
+    #[inline]
+    pub fn unknown_webkit_from_name(name: &str) -> Option<Self> {
+        const WEBKIT_PREFIX: &str = "-webkit-";
+        if !starts_with_ignore_ascii_case(name, WEBKIT_PREFIX) {
+            return None;
+        }
+        let part = string_as_ascii_lowercase(&name[WEBKIT_PREFIX.len()..]);
+        Some(PseudoElement::UnknownWebkit(part.into()))
+    }
+
+    /// Constructs a tree pseudo-element from the given name and arguments.
+    /// "name" must start with "-moz-tree-".
+    ///
+    /// Returns `None` if the pseudo-element is not recognized.
+    #[inline]
+    pub fn tree_pseudo_element(name: &str, args: thin_vec::ThinVec<Atom>) -> Option<Self> {
+        debug_assert!(starts_with_ignore_ascii_case(name, "-moz-tree-"));
+        let tree_part = &name[10..];
+        % for pseudo in PSEUDOS:
+        % if pseudo.name.startswith("-moz-tree-"):
+        if tree_part.eq_ignore_ascii_case("${pseudo.name[10:]}") {
+            return Some(${pseudo_element_variant(pseudo, "args")});
+        }
+        % endif
+        % endfor
+        None
+    }
+
+    /// Returns true if this pseudo-element matches the given selector.
+    pub fn matches(
+        &self,
+        pseudo_selector: &PseudoElement,
+        element: &super::wrapper::GeckoElement,
+    ) -> bool {
+        if *self == *pseudo_selector {
+            return true;
+        }
+
+        if std::mem::discriminant(self) != std::mem::discriminant(pseudo_selector) {
+            return false;
+        }
+
+        // Check named view transition pseudo-elements.
+        self.matches_named_view_transition_pseudo_element(pseudo_selector, element)
+    }
+}
+
+impl ToCss for PseudoElement {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
+        match *self {
+            % for pseudo in PSEUDOS:
+            % if pseudo.argument == "AtomThinVec":
+            ${pseudo_element_variant(pseudo, "ref args")} => {
+                dest.write_str("::${pseudo.name}")?;
+                let mut iter = args.iter();
+                if let Some(first) = iter.next() {
+                    dest.write_char('(')?;
+                    serialize_atom_identifier(first, dest)?;
+                    for item in iter {
+                        dest.write_str(", ")?;
+                        serialize_atom_identifier(item, dest)?;
+                    }
+                    dest.write_char(')')?;
+                }
+                Ok(())
+            },
+            % elif pseudo.argument:
+                PseudoElement::${pseudo.capitalized}(ref arg) => {
+                    dest.write_str("::${pseudo.name}(")?;
+                    arg.to_css(dest)?;
+                    dest.write_char(')')
+                }
+            % else:
+                ${pseudo_element_variant(pseudo)} => dest.write_str("::${pseudo.name}"),
+            % endif
+            % endfor
+            PseudoElement::UnknownWebkit(ref atom) => {
+                dest.write_str("::-webkit-")?;
+                serialize_atom_identifier(atom, dest)
+            },
+        }
+    }
+}

package/vendor/stylo/gecko/pseudo_elements.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import os
+import sys
+
+import toml
+
+THIS_DIR = os.path.dirname(__file__)
+sys.path.insert(0, os.path.join(os.path.dirname(THIS_DIR), "properties"))
+
+import data
+
+
+class Pseudo(object):
+    def __init__(self, name, argument, enabled_in, pref):
+        self.name = name
+        self.camel = data.to_camel_case(name)
+        self.capitalized = self.camel[0].upper() + self.camel[1:]
+        self.argument = argument
+        self.enabled_in = enabled_in
+        self.pref = pref
+
+    def is_pseudo_element(self):
+        return isinstance(self, PseudoElement)
+
+    def is_anon_box(self):
+        return isinstance(self, AnonBox)
+
+    def is_non_inheriting_anon_box(self):
+        return isinstance(self, AnonBox) and not self.inherits
+
+    def is_inheriting_anon_box(self):
+        return isinstance(self, AnonBox) and self.inherits
+
+    def flags(self):
+        flags = []
+        if self.enabled_in == "ua":
+            flags.append("ENABLED_IN_UA")
+        elif self.enabled_in == "chrome":
+            flags.append("ENABLED_IN_UA")
+            flags.append("ENABLED_IN_CHROME")
+        if self.pref:
+            flags.append("ENABLED_BY_PREF")
+        if self.argument:
+            flags.append("HAS_ARGUMENT")
+        if isinstance(self, PseudoElement):
+            flags.append("IS_PSEUDO_ELEMENT")
+            if self.is_css2:
+                flags.append("IS_CSS2")
+            if self.is_eager:
+                flags.append("IS_EAGER")
+            if self.is_js_created_nac:
+                flags.append("IS_JS_CREATED_NAC")
+            if self.is_flex_or_grid_item:
+                flags.append("IS_FLEX_OR_GRID_ITEM")
+            if self.is_element_backed:
+                flags.append("IS_ELEMENT_BACKED")
+            if self.is_tree_abiding:
+                flags.append("IS_TREE_ABIDING")
+            if self.parses_as_element_backed:
+                flags.append("PARSES_AS_ELEMENT_BACKED")
+            if self.supports_user_action_state:
+                flags.append("SUPPORTS_USER_ACTION_STATE")
+        if isinstance(self, AnonBox):
+            if self.inherits:
+                flags.append("IS_INHERITING_ANON_BOX")
+            else:
+                flags.append("IS_NON_INHERITING_ANON_BOX")
+            if self.wrapper:
+                flags.append("IS_WRAPPER_ANON_BOX")
+        return flags
+
+
+class AnonBox(Pseudo):
+    def __init__(self, name, wrapper=False, inherits=True):
+        super().__init__(name, argument=None, enabled_in="ua", pref=None)
+        self.wrapper = wrapper
+        self.inherits = inherits
+
+
+class PseudoElement(Pseudo):
+    def __init__(
+        self,
+        name,
+        enabled_in="content",
+        is_css2=False,
+        is_eager=False,
+        is_js_created_nac=False,
+        is_flex_or_grid_item=False,
+        is_element_backed=False,
+        is_tree_abiding=False,
+        parses_as_element_backed=None,
+        supports_user_action_state=False,
+        enabled_domains_pref=None,
+        pref=None,
+        argument=None,
+    ):
+        super().__init__(name, argument=argument, enabled_in=enabled_in, pref=pref)
+        self.is_css2 = is_css2
+        self.is_eager = is_eager
+        self.is_js_created_nac = is_js_created_nac
+        self.is_flex_or_grid_item = is_flex_or_grid_item
+        self.is_element_backed = is_element_backed
+        self.is_tree_abiding = is_element_backed or is_tree_abiding
+        self.parses_as_element_backed = (
+            parses_as_element_backed
+            if parses_as_element_backed is not None
+            else is_element_backed
+        )
+        self.supports_user_action_state = supports_user_action_state
+        self.enabled_domains_pref = enabled_domains_pref
+
+
+class PseudoElementData:
+    def __init__(self):
+        this_dir = os.path.dirname(__file__)
+        pseudo_elements_toml = os.path.join(this_dir, "pseudo_elements.toml")
+        anon_boxes_toml = os.path.join(this_dir, "anon_boxes.toml")
+        self.anon_boxes = sorted(
+            (
+                AnonBox(name, **val)
+                for name, val in toml.loads(open(anon_boxes_toml).read()).items()
+            ),
+            key=lambda n: n.inherits,
+        )
+        self.pseudo_elements = [
+            PseudoElement(name, **val)
+            for name, val in toml.loads(open(pseudo_elements_toml).read()).items()
+        ]
+        self.path_dependencies = [pseudo_elements_toml, anon_boxes_toml]
+
+    def all_pseudos(self):
+        return self.anon_boxes + self.pseudo_elements

package/vendor/stylo/gecko/pseudo_elements.toml

@@ -0,0 +1,197 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# This file contains the list of support CSS pseudo-elements and some flags.
+#
+# Each pseudo element has its own section, with the following keys:
+#
+#   enabled_in - Same semantics as longhands.toml
+#   is_css2 - Default false, whether this is a css2 pseudo-element, and can be
+#             parsed only with one colon.
+#   is_eager - Whether the pseudo-element is eagerly cascaded by the style
+#              system during traversal. This should generally only be used for
+#              pseudo-elements that apply to most elements.
+#   is_js_created_nac - True if this pseudo-element can be created by JS.
+#   is_flex_or_grid_item - True if display item fixup for flex / grid should
+#                          happen for this pseudo
+#   is_element_backed - whether this is an element-backed pseudo-element
+#                       https://drafts.csswg.org/css-pseudo-4/#element-like
+#   supports_user_action_state - true if this pseudo supports :hover etc.
+#   enabled_domains_pref - name of a pref (`DataMutexString`,
+#                          `mirror: always`, `rust: true`) listing the only
+#                          domains for which this pseudo-element should be
+#                          enabled. An empty value means no domain, "*" means
+#                          every domain.
+#                          See `nsContentUtils::IsURIInList` for the value
+#                          format.
+#   argument - If provided, the argument this functional pseudo takes.
+#   pref - Same semantics as gecko_pref in longhands.toml
+#
+# When adding a pseudo-element, you also need to add the relevant atom to
+# StaticAtoms.py, with the camel-case name of the pseudo-element.
+[after]
+is_css2 = true
+is_eager = true
+is_flex_or_grid_item = true
+is_tree_abiding = true
+[before]
+is_css2 = true
+is_eager = true
+is_flex_or_grid_item = true
+is_tree_abiding = true
+[marker]
+is_tree_abiding = true
+[backdrop]
+[cue]
+is_js_created_nac = true
+[first-letter]
+is_css2 = true
+is_eager = true
+[first-line]
+is_css2 = true
+is_eager = true
+[highlight]
+argument = "AtomIdent"
+[selection]
+[target-text]
+[view-transition]
+[view-transition-group]
+argument = "PtNameAndClassSelector"
+is_element_backed = true
+[view-transition-image-pair]
+is_element_backed = true
+argument = "PtNameAndClassSelector"
+[view-transition-old]
+is_element_backed = true
+argument = "PtNameAndClassSelector"
+[view-transition-new]
+is_element_backed = true
+argument = "PtNameAndClassSelector"
+# The internal implementation usage for View transition to create the snapshot
+# containing block concept.
+[-moz-snapshot-containing-block]
+enabled_in = "ua"
+[picker]
+enabled_in = "ua"
+pref = "dom.select.customizable_select.enabled"
+argument = "AtomIdent"
+is_element_backed = true
+[checkmark]
+pref = "dom.select.customizable_select.enabled"
+is_tree_abiding = true
+
+# HTML5 Forms pseudo elements
+[-moz-number-spin-box]
+supports_user_action_state = true
+enabled_in = "chrome"
+[-moz-number-spin-down]
+supports_user_action_state = true
+enabled_in = "chrome"
+[-moz-number-spin-up]
+supports_user_action_state = true
+enabled_in = "chrome"
+[-moz-search-clear-button]
+supports_user_action_state = true
+enabled_in = "chrome"
+# The selected label of a <select>
+[-moz-select-content]
+enabled_in = "chrome"
+is_element_backed = true
+# The menulist button of a <select>
+[picker-icon]
+enabled_in = "chrome"
+pref = "dom.select.customizable_select.enabled"
+is_tree_abiding = true
+[-moz-progress-bar]
+supports_user_action_state = true
+[-moz-range-track]
+supports_user_action_state = true
+[-moz-range-progress]
+supports_user_action_state = true
+[-moz-range-thumb]
+supports_user_action_state = true
+[-moz-meter-bar]
+supports_user_action_state = true
+[placeholder]
+supports_user_action_state = true
+is_element_backed = true
+parses_as_element_backed = false
+[-moz-color-swatch]
+supports_user_action_state = true
+# The root of the text value anonymous content inside an <input> or <textarea>.
+[-moz-text-control-editing-root]
+enabled_in = "ua"
+is_element_backed = true
+# The element that shows the autofill value.
+[-moz-text-control-preview]
+enabled_in = "ua"
+is_element_backed = true
+# The Reveal Password button for <input type=password>.
+[-moz-reveal]
+supports_user_action_state = true
+enabled_in = "ua"
+# The button in an <input type=file>
+[file-selector-button]
+supports_user_action_state = true
+is_tree_abiding = true
+# The cropped label in a file input.
+[-moz-file-content]
+enabled_in = "chrome"
+# Standard progress/meter/range pseudo-elements.
+[slider-track]
+supports_user_action_state = true
+enabled_in = "chrome"
+pref = "layout.css.modern-range-pseudos.enabled"
+[slider-thumb]
+supports_user_action_state = true
+enabled_in = "chrome"
+pref = "layout.css.modern-range-pseudos.enabled"
+[slider-fill]
+supports_user_action_state = true
+enabled_in = "chrome"
+pref = "layout.css.modern-range-pseudos.enabled"
+# The content in a <details> element that is shown when the element is open.
+[details-content]
+supports_user_action_state = true
+enabled_in = "chrome"
+pref = "layout.css.details-content.enabled"
+is_element_backed = true
+[-webkit-scrollbar]
+pref = "layout.css.fake-webkit-scrollbar.enabled"
+enabled_domains_pref = "layout.css.fake-webkit-scrollbar.enabled-domains"
+
+# Tree pseudo-elements
+[-moz-tree-column]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-row]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-separator]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-cell]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-indentation]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-line]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-twisty]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-image]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-cell-text]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-checkbox]
+enabled_in = "chrome"
+argument = "AtomThinVec"
+[-moz-tree-drop-feedback]
+enabled_in = "chrome"
+argument = "AtomThinVec"

package/vendor/stylo/gecko/regen_pseudo_elements.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import os
+import sys
+
+from pseudo_elements import PseudoElementData
+
+import build
+
+
+def generate_pseudo_elements(out):
+    data = PseudoElementData()
+    pseudo_definition_template = os.path.join(
+        os.path.dirname(__file__), "pseudo_element_definition.mako.rs"
+    )
+
+    print(f"cargo:rerun-if-changed={pseudo_definition_template}")
+    for f in data.path_dependencies:
+        print(f"cargo:rerun-if-changed={f}")
+
+    target = os.path.join(out, "pseudo_element_definition.rs")
+    build.write(out, "pseudo_element_definition.rs", build.render(pseudo_definition_template, PSEUDOS=data.all_pseudos()))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: {} out".format(sys.argv[0]))
+        exit(2)
+    generate_pseudo_elements(sys.argv[1])