Merge 73340f70a6f36bc46514a81b220373112fc7399e into 9a6268050fb769e18c4889fa5f59d4150e8878d6

crates/typst-html/src/convert.rs

@@ -109,10 +109,7 @@ fn handle(
             styles.chain(&style),
             Region::new(Size::splat(Abs::inf()), Axes::splat(false)),
         )?;
-        output.push(HtmlNode::Frame(HtmlFrame {
-            inner: frame,
-            text_size: styles.resolve(TextElem::size),
-        }));
+        output.push(HtmlNode::Frame(HtmlFrame::new(frame, styles)));
     } else {
         engine.sink.warn(warning!(
             child.span(),

crates/typst-html/src/dom.rs

@@ -2,10 +2,11 @@ use std::fmt::{self, Debug, Display, Formatter};
 
 use ecow::{EcoString, EcoVec};
 use typst_library::diag::{bail, HintedStrResult, StrResult};
-use typst_library::foundations::{cast, Dict, Repr, Str};
+use typst_library::foundations::{cast, Dict, Repr, Str, StyleChain};
 use typst_library::introspection::{Introspector, Tag};
 use typst_library::layout::{Abs, Frame};
 use typst_library::model::DocumentInfo;
+use typst_library::text::TextElem;
 use typst_syntax::Span;
 use typst_utils::{PicoStr, ResolvedPicoStr};
 
@@ -279,3 +280,10 @@ pub struct HtmlFrame {
     /// consistently.
     pub text_size: Abs,
 }
+
+impl HtmlFrame {
+    /// Wraps a laid-out frame.
+    pub fn new(inner: Frame, styles: StyleChain) -> Self {
+        Self { inner, text_size: styles.resolve(TextElem::size) }
+    }
+}

crates/typst-html/src/encode.rs

@@ -121,6 +121,7 @@ fn write_children(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
     let pretty_inside = allows_pretty_inside(element.tag)
         && element.children.iter().any(|node| match node {
             HtmlNode::Element(child) => wants_pretty_around(child.tag),
+            HtmlNode::Frame(_) => true,
             _ => false,
         });
 
@@ -305,14 +306,6 @@ fn write_escape(w: &mut Writer, c: char) -> StrResult<()> {
 
 /// Encode a laid out frame into the writer.
 fn write_frame(w: &mut Writer, frame: &HtmlFrame) {
-    // FIXME: This string replacement is obviously a hack.
-    let svg = typst_svg::svg_frame(&frame.inner).replace(
-        "<svg class",
-        &format!(
-            "<svg style=\"overflow: visible; width: {}em; height: {}em;\" class",
-            frame.inner.width() / frame.text_size,
-            frame.inner.height() / frame.text_size,
-        ),
-    );
+    let svg = typst_svg::svg_html_frame(&frame.inner, frame.text_size);
     w.buf.push_str(&svg);
 }

crates/typst-library/src/introspection/count.rs

@@ -0,0 +1,92 @@
+use comemo::Tracked;
+
+use crate::diag::HintedStrResult;
+use crate::engine::Engine;
+use crate::foundations::{func, Array, Context, IntoValue, LocatableSelector, Selector};
+
+/// Counts element in the document.
+///
+/// The `count` function lets you count elements in your document of a
+/// particular type or with a particular label. It also allows to count them
+/// in a hierachical way. To use it, you first need to ensure that [context]
+/// is available.
+///
+/// Always returns an array of integers, even if called with just a single
+/// target.
+
+/// # Counting elements - simple
+///
+/// To just count elements of a single type/label up to the current location,
+/// pass the selector you want to count:
+/// ```example
+/// = Heading
+///
+/// = Another Heading
+///
+/// #context count(heading)
+///
+/// = Third Heading
+/// ```
+///
+/// Note that it will not return an integer, but an array with a single integer
+/// entry.
+
+/// # Counting elements - hierarchical
+///
+/// If you pass multiple targets, then it starts by counting the first target.
+/// Then the second target is counted _starting only from the last counted
+/// element of the first target_.
+///
+/// ```example
+/// = Some Heading
+///
+/// == Some Subheading
+///
+/// = Another Heading
+///
+/// == Some Subheading
+///
+/// #context count(heading.where(level: 1), heading.where(level: 2))
+///
+/// == Another Subheading
+/// ```
+#[func(contextual)]
+pub fn count(
+    /// The engine.
+    engine: &mut Engine,
+    /// The callsite context.
+    context: Tracked<Context>,
+    /// Each target can be
+    /// - an element function like a `heading` or `figure`,
+    /// - a `{<label>}`,
+    /// - a more complex selector like `{heading.where(level: 1)}`,
+    /// - or `{selector(heading).before(here())}`.
+    ///
+    /// Only [locatable]($location/#locatable) element functions are supported.
+    #[variadic]
+    targets: Vec<LocatableSelector>,
+    /// When passing this argument, it will count everything only from a
+    /// certain location on.
+    /// The selector must match exactly one element in the document. The most
+    /// useful kinds of selectors for this are [labels]($label) and
+    /// [locations]($location).
+    // TODO remove Option as soon as there is a special `start` location
+    #[named]
+    after: Option<LocatableSelector>,
+) -> HintedStrResult<Array> {
+    // NOTE this could be made more efficient
+    // one could directly get a slice &[Selector] from Vec<LocatableSelector>
+    // by using #[repr(transparent)] on LocatableSelector
+    let selectors: Vec<Selector> = targets.into_iter().map(|sel| sel.0).collect();
+    // TODO add argument "at" with default value "here"
+    // and compute `before` accordingly
+    let before = Some(context.location()?);
+    let after = match after {
+        Some(selector) => Some(selector.resolve_unique(engine.introspector, context)?),
+        None => None,
+    };
+
+    let nums = engine.introspector.count(&selectors, after, before);
+
+    Ok(nums.into_iter().map(IntoValue::into_value).collect())
+}

crates/typst-library/src/introspection/introspector.rs

@@ -238,6 +238,60 @@ impl Introspector {
         }
     }
 
+    /// Count hierarchically.
+    pub fn count(
+        &self,
+        selectors: &[Selector],
+        // TODO remove Option as soon as there is a special `start` location
+        after: Option<Location>,
+        // TODO remove Option as soon as there is a special `end` location
+        before: Option<Location>,
+    ) -> SmallVec<[usize; 3]> {
+        let mut nums = SmallVec::with_capacity(selectors.len());
+
+        // can't write `mut` directly into function parameters because not supported by comemo
+        let mut after = after;
+
+        for selector in selectors.iter() {
+            let list = self.query(selector);
+
+            // count how many elements in `list` are between after and end
+            let index_start = if let Some(after) = after {
+                if let Some(after) = self.get_by_loc(&after) {
+                    match self.binary_search(&list, after) {
+                        Ok(i) => i, // TODO if after is exclusive then must add 1 here
+                        Err(i) => i,
+                    }
+                } else {
+                    0
+                }
+            } else {
+                0
+            };
+            let index_end = if let Some(before) = before {
+                if let Some(before) = self.get_by_loc(&before) {
+                    match self.binary_search(&list, before) {
+                        Ok(i) => i + 1,
+                        Err(i) => i,
+                    }
+                } else {
+                    list.len()
+                }
+            } else {
+                list.len()
+            };
+            nums.push(index_end - index_start);
+
+            // the next level should be counted only from
+            // the last element of the previous level on
+            if index_end != 0 {
+                after = Some(list[index_end - 1].location().unwrap());
+            }
+        }
+
+        nums
+    }
+
     /// The total number pages.
     pub fn pages(&self) -> NonZeroUsize {
         NonZeroUsize::new(self.pages).unwrap_or(NonZeroUsize::ONE)

crates/typst-library/src/introspection/mod.rs

@@ -1,5 +1,7 @@
 //! Interaction between document parts.
 
+#[path = "count.rs"]
+mod count_;
 mod counter;
 #[path = "here.rs"]
 mod here_;
@@ -14,6 +16,7 @@ mod query_;
 mod state;
 mod tag;
 
+pub use self::count_::*;
 pub use self::counter::*;
 pub use self::here_::*;
 pub use self::introspector::*;
@@ -36,6 +39,7 @@ pub fn define(global: &mut Scope) {
     global.define_elem::<MetadataElem>();
     global.define_func::<here>();
     global.define_func::<query>();
+    global.define_func::<count>();
     global.define_func::<locate>();
     global.reset_category();
 }

crates/typst-svg/src/lib.rs

@@ -45,6 +45,30 @@ pub fn svg_frame(frame: &Frame) -> String {
     renderer.finalize()
 }
 
+/// Export a frame into an SVG suitable for embedding into HTML.
+#[typst_macros::time(name = "svg html frame")]
+pub fn svg_html_frame(frame: &Frame, text_size: Abs) -> String {
+    let mut renderer = SVGRenderer::with_options(xmlwriter::Options {
+        indent: xmlwriter::Indent::None,
+        ..Default::default()
+    });
+    renderer.write_header_with_custom_attrs(frame.size(), |xml| {
+        xml.write_attribute("class", "typst-frame");
+        xml.write_attribute_fmt(
+            "style",
+            format_args!(
+                "overflow: visible; width: {}em; height: {}em;",
+                frame.width() / text_size,
+                frame.height() / text_size,
+            ),
+        );
+    });
+
+    let state = State::new(frame.size(), Transform::identity());
+    renderer.render_frame(state, Transform::identity(), frame);
+    renderer.finalize()
+}
+
 /// Export a document with potentially multiple pages into a single SVG file.
 ///
 /// The padding will be added around and between the individual frames.
@@ -158,8 +182,13 @@ impl State {
 impl SVGRenderer {
     /// Create a new SVG renderer with empty glyph and clip path.
     fn new() -> Self {
+        Self::with_options(Default::default())
+    }
+
+    /// Create a new SVG renderer with the given configuration.
+    fn with_options(options: xmlwriter::Options) -> Self {
         SVGRenderer {
-            xml: XmlWriter::new(xmlwriter::Options::default()),
+            xml: XmlWriter::new(options),
             glyphs: Deduplicator::new('g'),
             clip_paths: Deduplicator::new('c'),
             gradient_refs: Deduplicator::new('g'),
@@ -170,11 +199,22 @@ impl SVGRenderer {
         }
     }
 
-    /// Write the SVG header, including the `viewBox` and `width` and `height`
-    /// attributes.
+    /// Write the default SVG header, including a `typst-doc` class, the
+    /// `viewBox` and `width` and `height` attributes.
     fn write_header(&mut self, size: Size) {
+        self.write_header_with_custom_attrs(size, |xml| {
+            xml.write_attribute("class", "typst-doc");
+        });
+    }
+
+    /// Write the SVG header with additional attributes and standard attributes.
+    fn write_header_with_custom_attrs(
+        &mut self,
+        size: Size,
+        write_custom_attrs: impl FnOnce(&mut XmlWriter),
+    ) {
         self.xml.start_element("svg");
-        self.xml.write_attribute("class", "typst-doc");
+        write_custom_attrs(&mut self.xml);
         self.xml.write_attribute_fmt(
             "viewBox",
             format_args!("0 0 {} {}", size.x.to_pt(), size.y.to_pt()),

tests/ref/html/html-frame.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <p>A rectangle:</p>
+    <svg class="typst-frame" style="overflow: visible; width: 4.5em; height: 3em;" viewBox="0 0 45 30" width="45pt" height="30pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h5="http://www.w3.org/1999/xhtml"><g><g transform="translate(-0 -0)"><path class="typst-shape" fill="none" stroke="#000000" stroke-width="1" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" d="M 0 0 L 0 30 L 45 30 L 45 0 Z "/></g></g></svg>
+  </body>
+</html>

tests/suite/html/frame.typ

@@ -1,5 +1,6 @@
-// No proper HTML tests here yet because we don't want to test SVG export just
-// yet. We'll definitely add tests at some point.
+--- html-frame html ---
+A rectangle:
+#html.frame(rect())
 
 --- html-frame-in-layout ---
 // Ensure that HTML frames are transparent in layout. This is less important for