How to add 100 to the weight of the results of a regex show rule?

Questions
1

My use case is to make strings of caps, like abbreviations, 10% smaller and 100 pts heavier. So every time, for example, ACRONYM appears, its size is decreased to 0.9em and weight increased by 100 pts. The first part’s easy (below) but how to do the second part when I don’t already know what weight the text found by the show rule is?
BTW the desired effect admittedly looks weird on screen but it looks nice in print.

image

I suppose that my question could generalized as: How to return the properties of text shown with regex?

… I must be missing something obvious …

#show regex("[A-Z&]{2,}"): set text(size: 1em*.9)
This ACRONYM should be\ heavier, like this #text(weight: 500)[ACRONYM].
2

You can apply strong with a delta arugment to the text captured by the regex:

#show regex("[A-Z&]{2,}"): it => {
  set text(size: 1em*.9)
  strong(delta: 100, it)
}
1 Like
3

To get the current text weight as an integer, you can use this (text.weight):

#let get-text-weight() = {
  let weight = text.weight
  if type(weight) == int { return weight }
  let index = (
    "thin",
    "extralight",
    "light",
    "regular",
    "medium",
    "semibold",
    "bold",
    "extrabold",
    "black",
  ).position(x => x == weight)
  (index + 1) * 100
}

#context get-text-weight() // 400

The @gezepi’s solution I would write like this:

#let acronym-selector = regex("[A-Z&]{2,}")
#show acronym-selector: set text(size: 0.9em)
#show acronym-selector: strong.with(delta: 300)

It’s always better to avoid show rule closures, as they make any further potential styling changes less flexible.

1 Like
4

That worked great! In my case I do a lot of professional reports with acronyms. Other people might find this more useful as a way to fake petite caps. Say they’re using Libertinus Serif, which doesn’t have them. Just shrinking the font 50% looks too skinny. The petite X is overwhelmed by the period.
image
This fixes the problem.

#let acronym-selector = regex("[A-Z&]{2,}")
#show acronym-selector: set text(size: 0.5em, tracking: 0.025em)

X#(sym.zws)X#smallcaps[xx]XX.
#show acronym-selector: strong.with(delta: 200)

X#(sym.zws)X#smallcaps[xx]XX.```
5

Are you actually using ZWS in your document, or just showcasing?

Also, to have correct syntax highlighting, you should use the typ language marker:

```typ
```
6

I was just showcasing.

Thank you for your help!

I tried to improve your solution, but failed. The idea was that instead of applying delta to the weight, it would switch to a different optical size (obviously not Libertinus Serif, but for example Literata).

Because a document might have multiple font families, the function would first have to detect which font is currently in the found text. Then it’d determine size which it’s decreasing it to. Then it’d reference the correct precompiled dictionary (e.g., if the font were Literata then the dictionary would contain an array of pairs (e.g., (9.5, “Literata 7pt”), (15, “Literata 12pt”), etc). Then it would switch the font to the correct optical weight (if the new size were >9.5 and <15 then the font’d become Literata 12pt.

I didn’t get very far. I could return the value of .font but I couldn’t then use that value in an if then statement.

I searched the Forum and Universe, as it seemed likely that if it were possible then someone else would have already used this approach as a general solution to the optical size issue.

7

The typ thing only applies to block code and not inline.

You can use context if text.font or text.size { this } else { that }.