🥮 mooncakes.io
    Sign in

    mizchi/crater-renderer/renderer does not have a README file

    ImageIntrinsicSizeProvider

    source
    pub struct ImageIntrinsicSizeProvider {
      func : (String) -> (Double, Double)?
    }

    Image intrinsic-size provider hook for integrating external image metadata resolvers.

    ImageIntrinsicSizeProvider::new

    source
    fn ImageIntrinsicSizeProvider::new(func : (String) -> (Double, Double)?) -> ImageIntrinsicSizeProvider

    PreparedExternalCss

    source
    pub struct PreparedExternalCss {
      stylesheets : Array[
    Stylesheet    ]
      indexed_stylesheets : Array[
    IndexedStylesheet    ]
      before_rules : Array[PseudoRule]
      after_rules : Array[PseudoRule]
      before_index : PseudoRuleIndex
      after_index : PseudoRuleIndex
      total_rules : Int
    }

    PreparedRenderDocument

    source
    pub struct PreparedRenderDocument {
      stylesheets : Array[
    Stylesheet    ]
      indexed_stylesheets : Array[
    IndexedStylesheet    ]
      css_vars : Map[String, String]
      doc_root_selector : 
    Element
      doc_root_style : 
    Style
      render_root : 
    Element
      render_root_tag : String
      body_uses_document_root_style : Bool
      suppress_quirks_body_ua_top_margin : Bool
      before_index : PseudoRuleIndex
      after_index : PseudoRuleIndex
    }

    PseudoRule

    source
    pub struct PseudoRule {
      base_selector : 
    ComplexSelector    ?
      base_selector_text : String
      declarations : Array[
    Declaration    ]
      media_query : 
    MediaQueryList    ?
    }

    PseudoRuleIndex

    source
    pub struct PseudoRuleIndex {
      rules : Array[PseudoRule]
      by_id : Map[String, Array[Int]]
      by_class : Map[String, Array[Int]]
      by_tag : Map[String, Array[Int]]
      universal : Array[Int]
    }

    Indexed pseudo rules for fast lookup (same strategy as SelectorIndex)

    RecordedImage

    source
    pub(all) struct RecordedImage {
      src : String
      has_size : Bool
      width : Double
      height : Double
    }

    A single recorded image intrinsic size lookup: the source and its result (has_size = false records a provider that returned "no intrinsic size").

    RecordedMetric

    source
    pub(all) struct RecordedMetric {
      key : String
      min_width : Double
      max_width : Double
      min_height : Double
      max_height : Double
    }

    A single recorded measurement: the encoded measurement key and its result.

    RenderContext

    source
    pub(all) struct RenderContext {
      viewport_width : Double
      viewport_height : Double
      root_font_size : Double
      color_scheme : 
    ColorScheme
    }

    Render context with viewport dimensions

    RenderContext::default

    source
    fn RenderContext::default() -> RenderContext

    TextMetricsProvider

    source
    pub struct TextMetricsProvider {
      func : (String, Double, Double, 
    WhiteSpace    , 
    WritingMode    , Double, String) -> 
    MeasureFunc
    }

    Text metrics provider hook for integrating external font engines.

    TextMetricsProvider::new

    source

    apply_css_property_debug

    source
    fn apply_css_property_debug(style : 
    Style    , property : String, value : String) -> 
    Style

    Apply a CSS property value to a style (public for testing)

    build_render_root_node

    source

    cascade_reuse_begin

    source
    fn cascade_reuse_begin(prior_styles : Map[String, 
    Style    ], prior_sigs : Map[String, String], uses_sibling? : Bool, uses_child_structure? : Bool) -> Unit

    Start a cascade-reuse pass. prior_styles / prior_sigs are keyed by owner_id from the previous render (pass empty maps to record-only, i.e. no reuse). The build records the new styles + signatures; retrieve them with cascade_reuse_end to seed the next reflow. Only call around a build_render_root_node when the stylesheet is unchanged and reuse-safe.

    cascade_reuse_end

    source
    fn cascade_reuse_end() -> (Map[String, 
    Style    ], Map[String, String], Int)

    End the pass: returns (new styles by owner_id, new signatures by owner_id, reused count) and clears the active context. The maps become the next reflow's prior maps.

    clear_builtin_text_advance_ratio_override_for_test

    source
    fn clear_builtin_text_advance_ratio_override_for_test() -> Unit

    Clear the deterministic built-in text measurement hook.

    clear_image_intrinsic_record_replay

    source
    fn clear_image_intrinsic_record_replay() -> Unit

    clear_image_intrinsic_size_provider

    source
    fn clear_image_intrinsic_size_provider() -> Unit

    clear_text_metrics_provider

    source
    fn clear_text_metrics_provider() -> Unit

    clear_text_metrics_record_replay

    source
    fn clear_text_metrics_record_replay() -> Unit

    Disable both recording and replay.

    compute_composed_shadow_styles

    source
    fn compute_composed_shadow_styles(tree : 
    DomTree    , ctx : RenderContext) -> Map[Int, 
    Style    ]

    Composed shadow-scoped styling for a whole DomTree (#285, PR 6).

    Walks the light DOM from the document root and folds together every shadow host's contribution into one NodeId::to_int-keyed style map:

    • each host plus its shadow-subtree elements via compute_shadow_tree_styles (PR 3), threading inheritance across the boundary;
    • the host's slotted light children's ::slotted(...) contribution via compute_slotted_styles (PR 5);
    • nested shadow roots: a host living inside another host's shadow tree (or slotted into one) is composed too, inheriting from its own computed style.

    The returned map covers shadow hosts, shadow-subtree elements, and slotted light nodes. Plain light nodes that are neither hosts nor slotted are absent: the DomTree has no document-scope cascade, so this is the shadow-scoped composition only. It is the capstone over the PR 1-5 building blocks.

    compute_layout_from_render_root

    source
    fn compute_layout_from_render_root(root : 
    Node    , prepared : PreparedRenderDocument, ctx : RenderContext) -> 
    Layout

    compute_shadow_element_style

    source

    Shadow-tree static styling (#285, PR 3).

    Compute a concrete @style.Style for a node that lives inside a shadow tree (the host, a slotted light node, or an inner shadow node) by running that shadow root's <style> rules through DomTree::shadow_cascaded_values (PR 1, shadow-scoped matching) and folding the result through the renderer's shared post-cascade pipeline apply_cascaded_to_style (PR 2).

    rules is the shadow root's parsed stylesheet, obtained once via DomTree::shadow_stylesheet_rules, so a caller styling many nodes does not re-parse <style> per node. parent_style carries inherited context across the shadow boundary (the host's style for top-level shadow nodes).

    This is a building block; the composed-tree render entry (PR 4) walks the DomTree and calls it for shadow-scoped nodes.

    compute_shadow_tree_styles

    source

    Compute @style.Style for the shadow host and every element in its shadow tree, keyed by node id (NodeId::to_int). The host is styled by its :host rules and inherits from host_parent_style (its light-DOM context); each shadow node inherits from its parent's computed style, threading inheritance across the shadow boundary (host -> top-level shadow nodes -> descendants).

    <style> elements and non-element nodes are skipped. Returns an empty map when host has no shadow root. Slotted light nodes are styled from the light tree, not here.

    compute_slotted_styles

    source

    Compute the shadow-scoped @style.Style contribution for the host's slotted light children, keyed by node id. A light child assigned to a slot in the host's shadow tree is matched against that shadow's ::slotted(...) rules (via compute_shadow_element_style, PR 3) and inherits from host_style (its light-DOM parent context).

    Only element light children that are actually assigned to a slot are included; non-slotted children and non-elements are skipped. This is the shadow-side contribution only — a slotted node's document/light styles come from the light tree and are merged by the (deferred) composed-tree walk. Returns an empty map when host has no shadow root.

    crater_dom_id_attr

    source
    let crater_dom_id_attr : String

    Internal attribute the dynamic-rendering path stamps onto a render @html.Element to carry its originating @dom.DomTree node id through to the render @node.Node (see attach_dom_id). It lives only on the derived render document, never on the DomTree, so it is not serialized into html_content; the cascade ignores it (html_to_selector_element filters it out).

    css_allows_cascade_reuse

    source
    fn css_allows_cascade_reuse(texts : Array[String]) -> Bool

    Whether the given raw CSS texts are safe for scoped cascade reuse: they must use no selector whose match can flip without a change in an element's own inputs or its ancestors' inputs. Conservative and cheap: a substring scan for the disqualifying selector features. A false positive (e.g. + inside a calc() value) only disables the optimization — never a correctness risk.

    css_uses_child_structure

    source
    fn css_uses_child_structure(texts : Array[String]) -> Bool

    Whether any CSS text uses a selector whose match depends on child structure: :empty/:blank (own child/text presence) or positional-from-end / only / of-type (:last-child, :only-child, :nth-last-*, *-of-type — read the parent's child list). When true, each element's reuse signature includes a summary of its direct children. Conservative substring scan; a false positive only tightens reuse.

    css_uses_sibling_combinator

    source
    fn css_uses_sibling_combinator(texts : Array[String]) -> Bool

    Whether any CSS text uses a sibling combinator (+ or ~). Conservative: a substring match (so calc(a + b) or [attr~=v] also counts) — a false positive only tightens the preceding-sibling gate, never a correctness risk. When true, cascade reuse requires every preceding sibling to be clean.

    deserialize_image_intrinsic_recording

    source
    fn deserialize_image_intrinsic_recording(data : String) -> Array[RecordedImage]

    deserialize_text_metrics_recording

    source
    fn deserialize_text_metrics_recording(data : String) -> Array[RecordedMetric]

    Parse a recording produced by serialize_text_metrics_recording.

    element_to_node

    source

    Convert HTML Element to Node tree for layout computation

    get_content_height

    source
    fn get_content_height(html : String, width : Int, height : Int) -> Int

    Get content height from HTML

    get_content_height_with_css

    source
    fn get_content_height_with_css(html : String, width : Int, height : Int, external_css : Array[String]) -> Int

    Get content height with external CSS

    get_content_height_with_document

    source
    fn get_content_height_with_document(doc : 
    Document    , width : Int, height : Int, external_css : Array[String]) -> Int

    Get content height from a parsed Document with external CSS

    get_force_monospace_metrics

    source
    fn get_force_monospace_metrics() -> Bool

    install_image_intrinsic_replay

    source
    fn install_image_intrinsic_replay(images : Array[RecordedImage]) -> Unit

    install_text_metrics_replay

    source
    fn install_text_metrics_replay(metrics : Array[RecordedMetric]) -> Unit

    Serve text measurements from metrics (replay mode); a measurement not in the recording falls back to the live measure func. Clears any active recording.

    layout_to_json

    source
    fn layout_to_json(layout : 
    Layout    ) -> String

    Convert layout to JSON string (with Box Model)

    perf_child_loop_us

    source
    let perf_child_loop_us : 
    Ref    [Int64]

    perf_clock_us

    source
    fn perf_clock_us() -> Int64

    perf_node_build_us

    source
    let perf_node_build_us : 
    Ref    [Int64]

    perf_pre_checks_us

    source
    let perf_pre_checks_us : 
    Ref    [Int64]

    perf_pseudo_us

    source
    let perf_pseudo_us : 
    Ref    [Int64]

    perf_selector_build_us

    source
    let perf_selector_build_us : 
    Ref    [Int64]

    prepare_external_css

    source
    fn prepare_external_css(external_css : Array[String]) -> PreparedExternalCss

    prepare_render_document

    source
    fn prepare_render_document(doc : 
    Document    , ctx : RenderContext, external_css : Array[String]) -> PreparedRenderDocument

    prepare_render_document_with_prepared_external_css

    source
    fn prepare_render_document_with_prepared_external_css(doc : 
    Document    , ctx : RenderContext, external_css : PreparedExternalCss) -> PreparedRenderDocument

    fn print_layout_tree(layout : 
    Layout    , indent : Int) -> Unit

    Print layout tree for debugging
    fn print_layout_tree_with_options(layout : 
    Layout    , indent : Int, show_box_model : Bool) -> Unit

    Print layout tree with optional detailed box model info

    render

    source
    fn render(html : String, ctx : RenderContext) -> 
    Layout

    Render HTML string to Layout

    render_document_with_external_css

    source
    fn render_document_with_external_css(doc : 
    Document    , ctx : RenderContext, external_css : Array[String]) -> 
    Layout

    Render a parsed HTML Document to Layout with external CSS This is useful when you need to pre-process the document (e.g., add synthetic IDs)

    render_document_with_prepared_external_css

    source
    fn render_document_with_prepared_external_css(doc : 
    Document    , ctx : RenderContext, external_css : PreparedExternalCss) -> 
    Layout

    Render a parsed HTML Document to Layout with a prepared external CSS handle.

    render_to_node

    source
    fn render_to_node(html : String, ctx : RenderContext) -> 
    Node

    Render HTML to Node tree (for testing/debugging)

    render_to_node_and_layout

    source
    fn render_to_node_and_layout(html : String, ctx : RenderContext) -> (
    Node    , 
    Layout    )

    Render HTML to Node tree and Layout in a shared pass.

    render_to_node_and_layout_full_document

    source
    fn render_to_node_and_layout_full_document(html : String, ctx : RenderContext) -> (
    Node    , 
    Layout    )

    Render the whole document without viewport skeleton culling.

    render_to_node_and_layout_with_document

    source
    fn render_to_node_and_layout_with_document(doc : 
    Document    , ctx : RenderContext, external_css : Array[String]) -> (
    Node    , 
    Layout    )

    Render a parsed HTML Document to Node tree and Layout with external CSS while sharing HTML/CSS preparation and node construction.

    render_to_node_and_layout_with_external_css

    source
    fn render_to_node_and_layout_with_external_css(html : String, ctx : RenderContext, external_css : Array[String]) -> (
    Node    , 
    Layout    )

    Render HTML to Node tree and Layout with external CSS in a shared pass.

    render_to_node_and_layout_with_prepared_external_css

    source
    fn render_to_node_and_layout_with_prepared_external_css(doc : 
    Document    , ctx : RenderContext, external_css : PreparedExternalCss) -> (
    Node    , 
    Layout    )

    Render a parsed HTML Document to Node tree and Layout with a prepared external CSS handle.

    render_to_node_with_document

    source
    fn render_to_node_with_document(doc : 
    Document    , ctx : RenderContext, external_css : Array[String]) -> 
    Node

    Render a parsed HTML Document to Node tree with external CSS This is useful when you need to use a pre-parsed document (e.g., from streaming parser)

    render_to_node_with_external_css

    source
    fn render_to_node_with_external_css(html : String, ctx : RenderContext, external_css : Array[String]) -> 
    Node

    Render HTML to Node tree with external CSS

    render_to_node_with_prepared_external_css

    source
    fn render_to_node_with_prepared_external_css(doc : 
    Document    , ctx : RenderContext, external_css : PreparedExternalCss) -> 
    Node

    Render a parsed HTML Document to Node tree with a prepared external CSS handle.

    render_with_external_css

    source
    fn render_with_external_css(html : String, ctx : RenderContext, external_css : Array[String]) -> 
    Layout

    Render HTML string to Layout with external CSS

    serialize_image_intrinsic_recording

    source
    fn serialize_image_intrinsic_recording(images : Array[RecordedImage]) -> String

    Serialize image recordings (length-prefixed src, so any URL round-trips).

    serialize_text_metrics_recording

    source
    fn serialize_text_metrics_recording(metrics : Array[RecordedMetric]) -> String

    Serialize a recording to a self-delimiting string (length-prefixed keys, so arbitrary text/newlines in keys round-trip safely).

    set_builtin_text_advance_ratio_override_for_test

    source
    fn set_builtin_text_advance_ratio_override_for_test(ratio : Double) -> Unit

    Test-only hook for deterministic built-in text measurement.

    set_force_monospace_metrics

    source
    fn set_force_monospace_metrics(enabled : Bool) -> Unit

    set_image_intrinsic_size_provider

    source
    fn set_image_intrinsic_size_provider(provider : ImageIntrinsicSizeProvider) -> Unit

    set_text_metrics_provider

    source
    fn set_text_metrics_provider(provider : TextMetricsProvider) -> Unit

    start_image_intrinsic_recording

    source
    fn start_image_intrinsic_recording() -> Unit

    Begin recording image intrinsic sizes. Clears any active image replay.

    start_text_metrics_recording

    source
    fn start_text_metrics_recording() -> Unit

    Begin recording text measurements. Clears any active replay.

    take_image_intrinsic_recording

    source
    fn take_image_intrinsic_recording() -> Array[RecordedImage]

    take_text_metrics_recording

    source
    fn take_text_metrics_recording() -> Array[RecordedMetric]

    Stop recording and return everything captured since start.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io