Skip locatables

crates/typst-html/src/rules.rs

@@ -14,8 +14,8 @@ use typst_library::model::{
     RefElem, StrongElem, TableCell, TableElem, TermsElem,
 };
 use typst_library::text::{
-    HighlightElem, LinebreakElem, OverlineElem, RawElem, RawLine, SpaceElem, StrikeElem,
+    HighlightElem, LinebreakElem, OverlineElem, RawElem, RawLine, SmallcapsElem,
-    SubElem, SuperElem, UnderlineElem,
+    SpaceElem, StrikeElem, SubElem, SuperElem, UnderlineElem,
 };
 use typst_library::visualize::ImageElem;
 
@@ -47,6 +47,7 @@ pub fn register(rules: &mut NativeRuleMap) {
     rules.register(Html, OVERLINE_RULE);
     rules.register(Html, STRIKE_RULE);
     rules.register(Html, HIGHLIGHT_RULE);
+    rules.register(Html, SMALLCAPS_RULE);
     rules.register(Html, RAW_RULE);
     rules.register(Html, RAW_LINE_RULE);
 
@@ -390,6 +391,20 @@ const STRIKE_RULE: ShowFn<StrikeElem> =
 const HIGHLIGHT_RULE: ShowFn<HighlightElem> =
     |elem, _, _| Ok(HtmlElem::new(tag::mark).with_body(Some(elem.body.clone())).pack());
 
+const SMALLCAPS_RULE: ShowFn<SmallcapsElem> = |elem, _, styles| {
+    Ok(HtmlElem::new(tag::span)
+        .with_attr(
+            attr::style,
+            if elem.all.get(styles) {
+                "font-variant-caps: all-small-caps"
+            } else {
+                "font-variant-caps: small-caps"
+            },
+        )
+        .with_body(Some(elem.body.clone()))
+        .pack())
+};
+
 const RAW_RULE: ShowFn<RawElem> = |elem, _, styles| {
     let lines = elem.lines.as_deref().unwrap_or_default();
 

crates/typst-library/src/foundations/selector.rs

@@ -37,13 +37,12 @@ pub use crate::__select_where as select_where;
 
 /// A filter for selecting elements within the document.
 ///
-/// You can construct a selector in the following ways:
+/// To construct a selector you can:
-/// - you can use an element [function]
+/// - use an element [function]
-/// - you can filter for an element function with
+/// - filter for an element function with [specific fields]($function.where)
-///   [specific fields]($function.where)
+/// - use a [string]($str) or [regular expression]($regex)
-/// - you can use a [string]($str) or [regular expression]($regex)
+/// - use a [`{<label>}`]($label)
-/// - you can use a [`{<label>}`]($label)
+/// - use a [`location`]
-/// - you can use a [`location`]
 /// - call the [`selector`] constructor to convert any of the above types into a
 ///   selector value and use the methods below to refine it
 ///
@@ -148,7 +147,9 @@ impl Selector {
 impl Selector {
     /// Turns a value into a selector. The following values are accepted:
     /// - An element function like a `heading` or `figure`.
+    /// - A [string]($str) or [regular expression]($regex).
     /// - A `{<label>}`.
+    /// - A [`location`].
     /// - A more complex selector like `{heading.where(level: 1)}`.
     #[func(constructor)]
     pub fn construct(

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

@@ -10,7 +10,7 @@ use typst_utils::NonZeroExt;
 
 use crate::diag::{bail, StrResult};
 use crate::foundations::{Content, Label, Repr, Selector};
-use crate::introspection::{Location, Tag};
+use crate::introspection::{Locatable, Location, Tag};
 use crate::layout::{Frame, FrameItem, Point, Position, Transform};
 use crate::model::Numbering;
 
@@ -422,9 +422,11 @@ impl IntrospectorBuilder {
     ) {
         match tag {
             Tag::Start(elem) => {
-                let loc = elem.location().unwrap();
+                if elem.can::<dyn Locatable>() {
-                if self.seen.insert(loc) {
+                    let loc = elem.location().unwrap();
-                    sink.push((elem.clone(), position));
+                    if self.seen.insert(loc) {
+                        sink.push((elem.clone(), position));
+                    }
                 }
             }
             Tag::End(loc, key) => {

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

@@ -108,6 +108,9 @@ impl Repr for Location {
 /// Makes this element as locatable through the introspector.
 pub trait Locatable {}
 
+/// Makes this element as not locatable through the introspector.
+pub trait Unlocatable {}
+
 /// Marks this element as not being queryable even though it is locatable for
 /// internal reasons.
 pub trait Unqueriable {}

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

@@ -50,6 +50,7 @@ use crate::foundations::{
     NativeElement, Never, NoneValue, Packed, PlainText, Regex, Repr, Resolve, Scope, Set,
     Smart, StyleChain,
 };
+use crate::introspection::Unlocatable;
 use crate::layout::{Abs, Axis, Dir, Em, Length, Ratio, Rel};
 use crate::math::{EquationElem, MathSize};
 use crate::visualize::{Color, Paint, RelativeTo, Stroke};
@@ -90,7 +91,7 @@ pub(super) fn define(global: &mut Scope) {
 ///   With a function call.
 /// ])
 /// ```
-#[elem(Debug, Construct, PlainText, Repr)]
+#[elem(Debug, Construct, PlainText, Repr, Unlocatable)]
 pub struct TextElem {
     /// A font family descriptor or priority list of font family descriptors.
     ///
@@ -792,6 +793,8 @@ impl PlainText for Packed<TextElem> {
     }
 }
 
+impl Unlocatable for Packed<TextElem> {}
+
 /// A lowercased font family like "arial".
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub struct FontFamily {

crates/typst-library/src/text/smartquote.rs

@@ -7,9 +7,12 @@ use crate::foundations::{
     array, cast, dict, elem, Array, Dict, FromValue, Packed, PlainText, Smart, Str,
     StyleChain,
 };
+use crate::introspection::Unlocatable;
 use crate::layout::Dir;
 use crate::text::{Lang, Region, TextElem};
 
+impl Unlocatable for Packed<SmartQuoteElem> {}
+
 /// A language-aware quote that reacts to its context.
 ///
 /// Automatically turns into an appropriate opening or closing quote based on
@@ -29,7 +32,7 @@ use crate::text::{Lang, Region, TextElem};
 /// # Syntax
 /// This function also has dedicated syntax: The normal quote characters
 /// (`'` and `"`). Typst automatically makes your quotes smart.
-#[elem(name = "smartquote", PlainText)]
+#[elem(name = "smartquote", PlainText, Unlocatable)]
 pub struct SmartQuoteElem {
     /// Whether this should be a double quote.
     #[default(true)]

crates/typst-library/src/text/space.rs

@@ -4,9 +4,10 @@ use typst_utils::singleton;
 use crate::foundations::{
     elem, Content, NativeElement, Packed, PlainText, Repr, Unlabellable,
 };
+use crate::introspection::Unlocatable;
 
 /// A text space.
-#[elem(Unlabellable, PlainText, Repr)]
+#[elem(Unlabellable, PlainText, Repr, Unlocatable)]
 pub struct SpaceElem {}
 
 impl SpaceElem {
@@ -24,6 +25,8 @@ impl Repr for SpaceElem {
 
 impl Unlabellable for Packed<SpaceElem> {}
 
+impl Unlocatable for Packed<SpaceElem> {}
+
 impl PlainText for Packed<SpaceElem> {
     fn plain_text(&self, text: &mut EcoString) {
         text.push(' ');

crates/typst-realize/src/lib.rs

@@ -18,7 +18,7 @@ use typst_library::foundations::{
     RecipeIndex, Selector, SequenceElem, ShowSet, Style, StyleChain, StyledElem, Styles,
     SymbolElem, Synthesize, TargetElem, Transformation,
 };
-use typst_library::introspection::{Locatable, SplitLocator, Tag, TagElem};
+use typst_library::introspection::{Locatable, SplitLocator, Tag, TagElem, Unlocatable};
 use typst_library::layout::{
     AlignElem, BoxElem, HElem, InlineElem, PageElem, PagebreakElem, VElem,
 };
@@ -506,7 +506,7 @@ fn verdict<'a>(
             elem.label().is_none()
                 && elem.location().is_none()
                 && !elem.can::<dyn ShowSet>()
-                && !elem.can::<dyn Locatable>()
+                && !locatable(elem)
                 && !elem.can::<dyn Synthesize>()
         })
     {
@@ -516,6 +516,10 @@ fn verdict<'a>(
     Some(Verdict { prepared, map, step })
 }
 
+fn locatable(elem: &Content) -> bool {
+    !elem.can::<dyn Unlocatable>()
+}
+
 /// This is only executed the first time an element is visited.
 fn prepare(
     engine: &mut Engine,
@@ -531,9 +535,7 @@ fn prepare(
     // The element could already have a location even if it is not prepared
     // when it stems from a query.
     let key = typst_utils::hash128(&elem);
-    if elem.location().is_none()
+    if elem.location().is_none() && (locatable(elem) || elem.label().is_some()) {
-        && (elem.can::<dyn Locatable>() || elem.label().is_some())
-    {
         let loc = locator.next_location(engine.introspector, key);
         elem.set_location(loc);
     }

tests/ref/html/smallcaps-all.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <p><span style="font-variant-caps: small-caps">Test 012</span><br><span style="font-variant-caps: all-small-caps">Test 012</span></p>
+  </body>
+</html>

tests/suite/text/smallcaps.typ

@@ -11,6 +11,6 @@
 #show smallcaps: set text(fill: red)
 #smallcaps[Smallcaps]
 
---- smallcaps-all ---
+--- smallcaps-all render html ---
 #smallcaps(all: false)[Test 012] \
 #smallcaps(all: true)[Test 012]