mirror of
https://github.com/typst/typst
synced 2025-08-19 17:38:32 +08:00
Compare commits
25 Commits
1660f63946
...
263cd4d1d9
| Author | SHA1 | Date | |
|---|---|---|---|
|
263cd4d1d9 | ||
|
|
9ae94b2f64 | ||
|
|
6094516a63 | ||
|
d1deb80bb8 | ||
|
88e451b3dc | ||
|
cc3a68ecb1 | ||
|
22a57fcf5c | ||
|
09c831d3b3 | ||
|
30ddc4a7ca | ||
|
|
d978f8c33a | ||
|
c99f3ffc7d | ||
|
|
880f56c90d | ||
|
|
a6cf0247b2 | ||
|
|
c4bcfb18c1 | ||
|
|
e8f9877fc5 | ||
|
|
74b1b10986 | ||
|
584dd5fec6 | ||
|
|
b9f3a95e03 | ||
|
e8ce894ee7 | ||
|
|
9311f6f08e | ||
|
|
7420ec972f | ||
|
5dd5771df0 | ||
|
|
04fd0acaca | ||
|
|
6a1d6c08e2 | ||
|
|
35809387f8 |
4
Cargo.lock
generated
4
Cargo.lock
generated
@ -413,7 +413,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "codex"
|
||||
version = "0.1.1"
|
||||
source = "git+https://github.com/typst/codex?rev=56eb217#56eb2172fc0670f4c1c8b79a63d11f9354e5babe"
|
||||
source = "git+https://github.com/typst/codex?rev=a5428cb#a5428cb9c81a41354d44b44dbd5a16a710bbd928"
|
||||
|
||||
[[package]]
|
||||
name = "color-print"
|
||||
@ -2911,7 +2911,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "typst-dev-assets"
|
||||
version = "0.13.1"
|
||||
source = "git+https://github.com/typst/typst-dev-assets?rev=fddbf8b#fddbf8b99506bc370ac0edcd4959add603a7fc92"
|
||||
source = "git+https://github.com/typst/typst-dev-assets?rev=bfa947f#bfa947f3433d7d13a995168c40ae788a2ebfe648"
|
||||
|
||||
[[package]]
|
||||
name = "typst-docs"
|
||||
|
||||
@ -33,7 +33,7 @@ typst-syntax = { path = "crates/typst-syntax", version = "0.13.1" }
|
||||
typst-timing = { path = "crates/typst-timing", version = "0.13.1" }
|
||||
typst-utils = { path = "crates/typst-utils", version = "0.13.1" }
|
||||
typst-assets = { git = "https://github.com/typst/typst-assets", rev = "c1089b4" }
|
||||
typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "fddbf8b" }
|
||||
typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "bfa947f" }
|
||||
arrayvec = "0.7.4"
|
||||
az = "1.2"
|
||||
base64 = "0.22"
|
||||
@ -47,7 +47,7 @@ clap = { version = "4.4", features = ["derive", "env", "wrap_help"] }
|
||||
clap_complete = "4.2.1"
|
||||
clap_mangen = "0.2.10"
|
||||
codespan-reporting = "0.11"
|
||||
codex = { git = "https://github.com/typst/codex", rev = "56eb217" }
|
||||
codex = { git = "https://github.com/typst/codex", rev = "a5428cb" }
|
||||
color-print = "0.3.6"
|
||||
comemo = "0.4"
|
||||
csv = "1"
|
||||
|
||||
21
README.md
21
README.md
@ -240,6 +240,26 @@ instant preview. To achieve these goals, we follow three core design principles:
|
||||
Luckily we have [`comemo`], a system for incremental compilation which does
|
||||
most of the hard work in the background.
|
||||
|
||||
## Acknowledgements
|
||||
|
||||
We'd like to thank everyone who is supporting Typst's development, be it via
|
||||
[GitHub sponsors] or elsewhere. In particular, special thanks[^1] go to:
|
||||
|
||||
- [Posit](https://posit.co/blog/posit-and-typst/) for financing a full-time
|
||||
compiler engineer
|
||||
- [NLnet](https://nlnet.nl/) for supporting work on Typst via multiple grants
|
||||
through the [NGI Zero Core](https://nlnet.nl/core) fund:
|
||||
- Work on [HTML export](https://nlnet.nl/project/Typst-HTML/)
|
||||
- Work on [PDF accessibility](https://nlnet.nl/project/Typst-Accessibility/)
|
||||
- [Science & Startups](https://www.science-startups.berlin/) for having financed
|
||||
Typst development from January through June 2023 via the Berlin Startup
|
||||
Scholarship
|
||||
- [Zerodha](https://zerodha.tech/blog/1-5-million-pdfs-in-25-minutes/) for their
|
||||
generous one-time sponsorship
|
||||
|
||||
[^1]: This list only includes contributions for our open-source work that exceed
|
||||
or are expected to exceed €10K.
|
||||
|
||||
[docs]: https://typst.app/docs/
|
||||
[app]: https://typst.app/
|
||||
[discord]: https://discord.gg/2uDybryKPe
|
||||
@ -259,3 +279,4 @@ instant preview. To achieve these goals, we follow three core design principles:
|
||||
[packages]: https://github.com/typst/packages/
|
||||
[`comemo`]: https://github.com/typst/comemo/
|
||||
[snap]: https://snapcraft.io/typst
|
||||
[GitHub sponsors]: https://github.com/sponsors/typst/
|
||||
|
||||
@ -491,7 +491,7 @@ pub enum PdfStandard {
|
||||
/// PDF/A-2u.
|
||||
#[value(name = "a-2u")]
|
||||
A_2u,
|
||||
/// PDF/A-3u.
|
||||
/// PDF/A-3b.
|
||||
#[value(name = "a-3b")]
|
||||
A_3b,
|
||||
/// PDF/A-3u.
|
||||
|
||||
@ -205,7 +205,9 @@ impl Eval for ast::Label<'_> {
|
||||
type Output = Value;
|
||||
|
||||
fn eval(self, _: &mut Vm) -> SourceResult<Self::Output> {
|
||||
Ok(Value::Label(Label::new(PicoStr::intern(self.get()))))
|
||||
Ok(Value::Label(
|
||||
Label::new(PicoStr::intern(self.get())).expect("unexpected empty label"),
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
@ -213,7 +215,8 @@ impl Eval for ast::Ref<'_> {
|
||||
type Output = Content;
|
||||
|
||||
fn eval(self, vm: &mut Vm) -> SourceResult<Self::Output> {
|
||||
let target = Label::new(PicoStr::intern(self.target()));
|
||||
let target = Label::new(PicoStr::intern(self.target()))
|
||||
.expect("unexpected empty reference");
|
||||
let mut elem = RefElem::new(target);
|
||||
if let Some(supplement) = self.supplement() {
|
||||
elem.push_supplement(Smart::Custom(Some(Supplement::Content(
|
||||
|
||||
@ -3,9 +3,8 @@ use std::fmt::Write;
|
||||
use typst_library::diag::{bail, At, SourceResult, StrResult};
|
||||
use typst_library::foundations::Repr;
|
||||
use typst_library::html::{
|
||||
attr, charsets, tag, HtmlDocument, HtmlElement, HtmlNode, HtmlTag,
|
||||
attr, charsets, tag, HtmlDocument, HtmlElement, HtmlFrame, HtmlNode, HtmlTag,
|
||||
};
|
||||
use typst_library::layout::Frame;
|
||||
use typst_syntax::Span;
|
||||
|
||||
/// Encodes an HTML document into a string.
|
||||
@ -304,9 +303,15 @@ fn write_escape(w: &mut Writer, c: char) -> StrResult<()> {
|
||||
}
|
||||
|
||||
/// Encode a laid out frame into the writer.
|
||||
fn write_frame(w: &mut Writer, frame: &Frame) {
|
||||
fn write_frame(w: &mut Writer, frame: &HtmlFrame) {
|
||||
// FIXME: This string replacement is obviously a hack.
|
||||
let svg = typst_svg::svg_frame(frame)
|
||||
.replace("<svg class", "<svg style=\"overflow: visible;\" class");
|
||||
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,
|
||||
),
|
||||
);
|
||||
w.buf.push_str(&svg);
|
||||
}
|
||||
|
||||
@ -9,7 +9,7 @@ use typst_library::diag::{bail, warning, At, SourceResult};
|
||||
use typst_library::engine::{Engine, Route, Sink, Traced};
|
||||
use typst_library::foundations::{Content, StyleChain, Target, TargetElem};
|
||||
use typst_library::html::{
|
||||
attr, tag, FrameElem, HtmlDocument, HtmlElem, HtmlElement, HtmlNode,
|
||||
attr, tag, FrameElem, HtmlDocument, HtmlElem, HtmlElement, HtmlFrame, HtmlNode,
|
||||
};
|
||||
use typst_library::introspection::{
|
||||
Introspector, Locator, LocatorLink, SplitLocator, TagElem,
|
||||
@ -246,7 +246,10 @@ fn handle(
|
||||
styles.chain(&style),
|
||||
Region::new(Size::splat(Abs::inf()), Axes::splat(false)),
|
||||
)?;
|
||||
output.push(HtmlNode::Frame(frame));
|
||||
output.push(HtmlNode::Frame(HtmlFrame {
|
||||
inner: frame,
|
||||
text_size: TextElem::size_in(styles),
|
||||
}));
|
||||
} else {
|
||||
engine.sink.warn(warning!(
|
||||
child.span(),
|
||||
|
||||
@ -448,7 +448,7 @@ fn field_access_completions(
|
||||
match value {
|
||||
Value::Symbol(symbol) => {
|
||||
for modifier in symbol.modifiers() {
|
||||
if let Ok(modified) = symbol.clone().modified(modifier) {
|
||||
if let Ok(modified) = symbol.clone().modified((), modifier) {
|
||||
ctx.completions.push(Completion {
|
||||
kind: CompletionKind::Symbol(modified.get()),
|
||||
label: modifier.into(),
|
||||
|
||||
@ -72,7 +72,8 @@ pub fn definition(
|
||||
|
||||
// Try to jump to the referenced content.
|
||||
DerefTarget::Ref(node) => {
|
||||
let label = Label::new(PicoStr::intern(node.cast::<ast::Ref>()?.target()));
|
||||
let label = Label::new(PicoStr::intern(node.cast::<ast::Ref>()?.target()))
|
||||
.expect("unexpected empty reference");
|
||||
let selector = Selector::Label(label);
|
||||
let elem = document?.introspector.query_first(&selector)?;
|
||||
return Some(Definition::Span(elem.span()));
|
||||
|
||||
@ -199,7 +199,7 @@ impl PackageStorage {
|
||||
// The place at which the specific package version will live in the end.
|
||||
let package_dir = base_dir.join(format!("{}", spec.version));
|
||||
|
||||
// To prevent multiple Typst instances from interferring, we download
|
||||
// To prevent multiple Typst instances from interfering, we download
|
||||
// into a temporary directory first and then move this directory to
|
||||
// its final destination.
|
||||
//
|
||||
|
||||
@ -206,7 +206,7 @@ pub fn collect<'a>(
|
||||
}
|
||||
InlineItem::Frame(mut frame) => {
|
||||
frame.modify(&FrameModifiers::get_in(styles));
|
||||
apply_baseline_shift(&mut frame, styles);
|
||||
apply_shift(&engine.world, &mut frame, styles);
|
||||
collector.push_item(Item::Frame(frame));
|
||||
}
|
||||
}
|
||||
@ -221,7 +221,7 @@ pub fn collect<'a>(
|
||||
let mut frame = layout_and_modify(styles, |styles| {
|
||||
layout_box(elem, engine, loc, styles, region)
|
||||
})?;
|
||||
apply_baseline_shift(&mut frame, styles);
|
||||
apply_shift(&engine.world, &mut frame, styles);
|
||||
collector.push_item(Item::Frame(frame));
|
||||
}
|
||||
} else if let Some(elem) = child.to_packed::<TagElem>() {
|
||||
|
||||
@ -5,7 +5,7 @@ use typst_library::engine::Engine;
|
||||
use typst_library::introspection::{SplitLocator, Tag};
|
||||
use typst_library::layout::{Abs, Dir, Em, Fr, Frame, FrameItem, Point};
|
||||
use typst_library::model::ParLineMarker;
|
||||
use typst_library::text::{Lang, TextElem};
|
||||
use typst_library::text::{variant, Lang, TextElem};
|
||||
use typst_utils::Numeric;
|
||||
|
||||
use super::*;
|
||||
@ -219,7 +219,7 @@ fn collect_items<'a>(
|
||||
// Add fallback text to expand the line height, if necessary.
|
||||
if !items.iter().any(|item| matches!(item, Item::Text(_))) {
|
||||
if let Some(fallback) = fallback {
|
||||
items.push(fallback);
|
||||
items.push(fallback, usize::MAX);
|
||||
}
|
||||
}
|
||||
|
||||
@ -270,10 +270,10 @@ fn collect_range<'a>(
|
||||
items: &mut Items<'a>,
|
||||
fallback: &mut Option<ItemEntry<'a>>,
|
||||
) {
|
||||
for (subrange, item) in p.slice(range.clone()) {
|
||||
for (idx, (subrange, item)) in p.slice(range.clone()).enumerate() {
|
||||
// All non-text items are just kept, they can't be split.
|
||||
let Item::Text(shaped) = item else {
|
||||
items.push(item);
|
||||
items.push(item, idx);
|
||||
continue;
|
||||
};
|
||||
|
||||
@ -293,10 +293,10 @@ fn collect_range<'a>(
|
||||
} else if split {
|
||||
// When the item is split in half, reshape it.
|
||||
let reshaped = shaped.reshape(engine, sliced);
|
||||
items.push(Item::Text(reshaped));
|
||||
items.push(Item::Text(reshaped), idx);
|
||||
} else {
|
||||
// When the item is fully contained, just keep it.
|
||||
items.push(item);
|
||||
items.push(item, idx);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -330,7 +330,7 @@ fn adjust_cj_at_line_start(p: &Preparation, items: &mut Items) {
|
||||
let glyph = shaped.glyphs.to_mut().first_mut().unwrap();
|
||||
let shrink = glyph.shrinkability().0;
|
||||
glyph.shrink_left(shrink);
|
||||
shaped.width -= shrink.at(shaped.size);
|
||||
shaped.width -= shrink.at(glyph.size);
|
||||
} else if p.config.cjk_latin_spacing
|
||||
&& glyph.is_cj_script()
|
||||
&& glyph.x_offset > Em::zero()
|
||||
@ -342,7 +342,7 @@ fn adjust_cj_at_line_start(p: &Preparation, items: &mut Items) {
|
||||
glyph.x_advance -= shrink;
|
||||
glyph.x_offset = Em::zero();
|
||||
glyph.adjustability.shrinkability.0 = Em::zero();
|
||||
shaped.width -= shrink.at(shaped.size);
|
||||
shaped.width -= shrink.at(glyph.size);
|
||||
}
|
||||
}
|
||||
|
||||
@ -360,7 +360,7 @@ fn adjust_cj_at_line_end(p: &Preparation, items: &mut Items) {
|
||||
let shrink = glyph.shrinkability().1;
|
||||
let punct = shaped.glyphs.to_mut().last_mut().unwrap();
|
||||
punct.shrink_right(shrink);
|
||||
shaped.width -= shrink.at(shaped.size);
|
||||
shaped.width -= shrink.at(punct.size);
|
||||
} else if p.config.cjk_latin_spacing
|
||||
&& glyph.is_cj_script()
|
||||
&& (glyph.x_advance - glyph.x_offset) > Em::one()
|
||||
@ -371,7 +371,7 @@ fn adjust_cj_at_line_end(p: &Preparation, items: &mut Items) {
|
||||
let glyph = shaped.glyphs.to_mut().last_mut().unwrap();
|
||||
glyph.x_advance -= shrink;
|
||||
glyph.adjustability.shrinkability.1 = Em::zero();
|
||||
shaped.width -= shrink.at(shaped.size);
|
||||
shaped.width -= shrink.at(glyph.size);
|
||||
}
|
||||
}
|
||||
|
||||
@ -412,9 +412,30 @@ fn should_repeat_hyphen(pred_line: &Line, text: &str) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply the current baseline shift to a frame.
|
||||
pub fn apply_baseline_shift(frame: &mut Frame, styles: StyleChain) {
|
||||
frame.translate(Point::with_y(TextElem::baseline_in(styles)));
|
||||
/// Apply the current baseline shift and italic compensation to a frame.
|
||||
pub fn apply_shift<'a>(
|
||||
world: &Tracked<'a, dyn World + 'a>,
|
||||
frame: &mut Frame,
|
||||
styles: StyleChain,
|
||||
) {
|
||||
let mut baseline = TextElem::baseline_in(styles);
|
||||
let mut compensation = Abs::zero();
|
||||
if let Some(scripts) = TextElem::shift_settings_in(styles) {
|
||||
let font_metrics = TextElem::font_in(styles)
|
||||
.into_iter()
|
||||
.find_map(|family| {
|
||||
world
|
||||
.book()
|
||||
.select(family.as_str(), variant(styles))
|
||||
.and_then(|id| world.font(id))
|
||||
})
|
||||
.map_or(*scripts.kind.default_metrics(), |f| {
|
||||
*scripts.kind.read_metrics(f.metrics())
|
||||
});
|
||||
baseline -= scripts.shift.unwrap_or(font_metrics.vertical_offset).resolve(styles);
|
||||
compensation += font_metrics.horizontal_offset.resolve(styles);
|
||||
}
|
||||
frame.translate(Point::new(compensation, baseline));
|
||||
}
|
||||
|
||||
/// Commit to a line and build its frame.
|
||||
@ -444,7 +465,7 @@ pub fn commit(
|
||||
&& TextElem::overhang_in(text.styles)
|
||||
&& (line.items.len() > 1 || text.glyphs.len() > 1)
|
||||
{
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
|
||||
offset -= amount;
|
||||
remaining += amount;
|
||||
}
|
||||
@ -458,7 +479,7 @@ pub fn commit(
|
||||
&& TextElem::overhang_in(text.styles)
|
||||
&& (line.items.len() > 1 || text.glyphs.len() > 1)
|
||||
{
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
|
||||
remaining += amount;
|
||||
}
|
||||
}
|
||||
@ -499,16 +520,16 @@ pub fn commit(
|
||||
|
||||
// Build the frames and determine the height and baseline.
|
||||
let mut frames = vec![];
|
||||
for item in line.items.iter() {
|
||||
let mut push = |offset: &mut Abs, frame: Frame| {
|
||||
for &(idx, ref item) in line.items.indexed_iter() {
|
||||
let mut push = |offset: &mut Abs, frame: Frame, idx: usize| {
|
||||
let width = frame.width();
|
||||
top.set_max(frame.baseline());
|
||||
bottom.set_max(frame.size().y - frame.baseline());
|
||||
frames.push((*offset, frame));
|
||||
frames.push((*offset, frame, idx));
|
||||
*offset += width;
|
||||
};
|
||||
|
||||
match item {
|
||||
match &**item {
|
||||
Item::Absolute(v, _) => {
|
||||
offset += *v;
|
||||
}
|
||||
@ -519,8 +540,8 @@ pub fn commit(
|
||||
let mut frame = layout_and_modify(*styles, |styles| {
|
||||
layout_box(elem, engine, loc.relayout(), styles, region)
|
||||
})?;
|
||||
apply_baseline_shift(&mut frame, *styles);
|
||||
push(&mut offset, frame);
|
||||
apply_shift(&engine.world, &mut frame, *styles);
|
||||
push(&mut offset, frame, idx);
|
||||
} else {
|
||||
offset += amount;
|
||||
}
|
||||
@ -532,15 +553,15 @@ pub fn commit(
|
||||
justification_ratio,
|
||||
extra_justification,
|
||||
);
|
||||
push(&mut offset, frame);
|
||||
push(&mut offset, frame, idx);
|
||||
}
|
||||
Item::Frame(frame) => {
|
||||
push(&mut offset, frame.clone());
|
||||
push(&mut offset, frame.clone(), idx);
|
||||
}
|
||||
Item::Tag(tag) => {
|
||||
let mut frame = Frame::soft(Size::zero());
|
||||
frame.push(Point::zero(), FrameItem::Tag((*tag).clone()));
|
||||
frames.push((offset, frame));
|
||||
frames.push((offset, frame, idx));
|
||||
}
|
||||
Item::Skip(_) => {}
|
||||
}
|
||||
@ -559,8 +580,13 @@ pub fn commit(
|
||||
add_par_line_marker(&mut output, marker, engine, locator, top);
|
||||
}
|
||||
|
||||
// Ensure that the final frame's items are in logical order rather than in
|
||||
// visual order. This is important because it affects the order of elements
|
||||
// during introspection and thus things like counters.
|
||||
frames.sort_unstable_by_key(|(_, _, idx)| *idx);
|
||||
|
||||
// Construct the line's frame.
|
||||
for (offset, frame) in frames {
|
||||
for (offset, frame, _) in frames {
|
||||
let x = offset + p.config.align.position(remaining);
|
||||
let y = top - frame.baseline();
|
||||
output.push_frame(Point::new(x, y), frame);
|
||||
@ -627,7 +653,7 @@ fn overhang(c: char) -> f64 {
|
||||
}
|
||||
|
||||
/// A collection of owned or borrowed inline items.
|
||||
pub struct Items<'a>(Vec<ItemEntry<'a>>);
|
||||
pub struct Items<'a>(Vec<(usize, ItemEntry<'a>)>);
|
||||
|
||||
impl<'a> Items<'a> {
|
||||
/// Create empty items.
|
||||
@ -636,33 +662,38 @@ impl<'a> Items<'a> {
|
||||
}
|
||||
|
||||
/// Push a new item.
|
||||
pub fn push(&mut self, entry: impl Into<ItemEntry<'a>>) {
|
||||
self.0.push(entry.into());
|
||||
pub fn push(&mut self, entry: impl Into<ItemEntry<'a>>, idx: usize) {
|
||||
self.0.push((idx, entry.into()));
|
||||
}
|
||||
|
||||
/// Iterate over the items.
|
||||
pub fn iter(&self) -> impl Iterator<Item = &Item<'a>> {
|
||||
self.0.iter().map(|item| &**item)
|
||||
self.0.iter().map(|(_, item)| &**item)
|
||||
}
|
||||
|
||||
/// Iterate over the items with indices
|
||||
pub fn indexed_iter(&self) -> impl Iterator<Item = &(usize, ItemEntry<'a>)> {
|
||||
self.0.iter()
|
||||
}
|
||||
|
||||
/// Access the first item.
|
||||
pub fn first(&self) -> Option<&Item<'a>> {
|
||||
self.0.first().map(|item| &**item)
|
||||
self.0.first().map(|(_, item)| &**item)
|
||||
}
|
||||
|
||||
/// Access the last item.
|
||||
pub fn last(&self) -> Option<&Item<'a>> {
|
||||
self.0.last().map(|item| &**item)
|
||||
self.0.last().map(|(_, item)| &**item)
|
||||
}
|
||||
|
||||
/// Access the first item mutably, if it is text.
|
||||
pub fn first_text_mut(&mut self) -> Option<&mut ShapedText<'a>> {
|
||||
self.0.first_mut()?.text_mut()
|
||||
self.0.first_mut()?.1.text_mut()
|
||||
}
|
||||
|
||||
/// Access the last item mutably, if it is text.
|
||||
pub fn last_text_mut(&mut self) -> Option<&mut ShapedText<'a>> {
|
||||
self.0.last_mut()?.text_mut()
|
||||
self.0.last_mut()?.1.text_mut()
|
||||
}
|
||||
|
||||
/// Reorder the items starting at the given index to RTL.
|
||||
@ -673,12 +704,12 @@ impl<'a> Items<'a> {
|
||||
|
||||
impl<'a> FromIterator<ItemEntry<'a>> for Items<'a> {
|
||||
fn from_iter<I: IntoIterator<Item = ItemEntry<'a>>>(iter: I) -> Self {
|
||||
Self(iter.into_iter().collect())
|
||||
Self(iter.into_iter().enumerate().collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Deref for Items<'a> {
|
||||
type Target = Vec<ItemEntry<'a>>;
|
||||
type Target = Vec<(usize, ItemEntry<'a>)>;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
|
||||
@ -927,9 +927,9 @@ impl Estimates {
|
||||
let byte_len = g.range.len();
|
||||
let stretch = g.stretchability().0 + g.stretchability().1;
|
||||
let shrink = g.shrinkability().0 + g.shrinkability().1;
|
||||
widths.push(byte_len, g.x_advance.at(shaped.size));
|
||||
stretchability.push(byte_len, stretch.at(shaped.size));
|
||||
shrinkability.push(byte_len, shrink.at(shaped.size));
|
||||
widths.push(byte_len, g.x_advance.at(g.size));
|
||||
stretchability.push(byte_len, stretch.at(g.size));
|
||||
shrinkability.push(byte_len, shrink.at(g.size));
|
||||
justifiables.push(byte_len, g.is_justifiable() as usize);
|
||||
}
|
||||
} else {
|
||||
|
||||
@ -29,7 +29,7 @@ use typst_utils::{Numeric, SliceExt};
|
||||
use self::collect::{collect, Item, Segment, SpanMapper};
|
||||
use self::deco::decorate;
|
||||
use self::finalize::finalize;
|
||||
use self::line::{apply_baseline_shift, commit, line, Line};
|
||||
use self::line::{apply_shift, commit, line, Line};
|
||||
use self::linebreak::{linebreak, Breakpoint};
|
||||
use self::prepare::{prepare, Preparation};
|
||||
use self::shaping::{
|
||||
|
||||
@ -144,7 +144,7 @@ fn add_cjk_latin_spacing(items: &mut [(Range, Item)]) {
|
||||
// The spacing is default to 1/4 em, and can be shrunk to 1/8 em.
|
||||
glyph.x_advance += Em::new(0.25);
|
||||
glyph.adjustability.shrinkability.1 += Em::new(0.125);
|
||||
text.width += Em::new(0.25).at(text.size);
|
||||
text.width += Em::new(0.25).at(glyph.size);
|
||||
}
|
||||
|
||||
// Case 2: Latin followed by a CJ character
|
||||
@ -152,7 +152,7 @@ fn add_cjk_latin_spacing(items: &mut [(Range, Item)]) {
|
||||
glyph.x_advance += Em::new(0.25);
|
||||
glyph.x_offset += Em::new(0.25);
|
||||
glyph.adjustability.shrinkability.0 += Em::new(0.125);
|
||||
text.width += Em::new(0.25).at(text.size);
|
||||
text.width += Em::new(0.25).at(glyph.size);
|
||||
}
|
||||
|
||||
prev = Some(glyph);
|
||||
|
||||
@ -3,14 +3,15 @@ use std::fmt::{self, Debug, Formatter};
|
||||
use std::sync::Arc;
|
||||
|
||||
use az::SaturatingAs;
|
||||
use rustybuzz::{BufferFlags, ShapePlan, UnicodeBuffer};
|
||||
use rustybuzz::{BufferFlags, Feature, ShapePlan, UnicodeBuffer};
|
||||
use ttf_parser::gsub::SubstitutionSubtable;
|
||||
use ttf_parser::Tag;
|
||||
use typst_library::engine::Engine;
|
||||
use typst_library::foundations::{Smart, StyleChain};
|
||||
use typst_library::layout::{Abs, Dir, Em, Frame, FrameItem, Point, Size};
|
||||
use typst_library::text::{
|
||||
families, features, is_default_ignorable, language, variant, Font, FontFamily,
|
||||
FontVariant, Glyph, Lang, Region, TextEdgeBounds, TextElem, TextItem,
|
||||
FontVariant, Glyph, Lang, Region, ShiftSettings, TextEdgeBounds, TextElem, TextItem,
|
||||
};
|
||||
use typst_library::World;
|
||||
use typst_utils::SliceExt;
|
||||
@ -41,8 +42,6 @@ pub struct ShapedText<'a> {
|
||||
pub styles: StyleChain<'a>,
|
||||
/// The font variant.
|
||||
pub variant: FontVariant,
|
||||
/// The font size.
|
||||
pub size: Abs,
|
||||
/// The width of the text's bounding box.
|
||||
pub width: Abs,
|
||||
/// The shaped glyphs.
|
||||
@ -62,6 +61,8 @@ pub struct ShapedGlyph {
|
||||
pub x_offset: Em,
|
||||
/// The vertical offset of the glyph.
|
||||
pub y_offset: Em,
|
||||
/// The font size for the glyph.
|
||||
pub size: Abs,
|
||||
/// The adjustability of the glyph.
|
||||
pub adjustability: Adjustability,
|
||||
/// The byte range of this glyph's cluster in the full inline layout. A
|
||||
@ -222,14 +223,17 @@ impl<'a> ShapedText<'a> {
|
||||
let mut frame = Frame::soft(size);
|
||||
frame.set_baseline(top);
|
||||
|
||||
let size = TextElem::size_in(self.styles);
|
||||
let shift = TextElem::baseline_in(self.styles);
|
||||
let decos = TextElem::deco_in(self.styles);
|
||||
let fill = TextElem::fill_in(self.styles);
|
||||
let stroke = TextElem::stroke_in(self.styles);
|
||||
let span_offset = TextElem::span_offset_in(self.styles);
|
||||
|
||||
for ((font, y_offset), group) in
|
||||
self.glyphs.as_ref().group_by_key(|g| (g.font.clone(), g.y_offset))
|
||||
for ((font, y_offset, glyph_size), group) in self
|
||||
.glyphs
|
||||
.as_ref()
|
||||
.group_by_key(|g| (g.font.clone(), g.y_offset, g.size))
|
||||
{
|
||||
let mut range = group[0].range.clone();
|
||||
for glyph in group {
|
||||
@ -237,7 +241,7 @@ impl<'a> ShapedText<'a> {
|
||||
range.end = range.end.max(glyph.range.end);
|
||||
}
|
||||
|
||||
let pos = Point::new(offset, top + shift - y_offset.at(self.size));
|
||||
let pos = Point::new(offset, top + shift - y_offset.at(size));
|
||||
let glyphs: Vec<Glyph> = group
|
||||
.iter()
|
||||
.map(|shaped: &ShapedGlyph| {
|
||||
@ -257,11 +261,11 @@ impl<'a> ShapedText<'a> {
|
||||
adjustability_right * justification_ratio;
|
||||
if shaped.is_justifiable() {
|
||||
justification_right +=
|
||||
Em::from_length(extra_justification, self.size)
|
||||
Em::from_abs(extra_justification, glyph_size)
|
||||
}
|
||||
|
||||
frame.size_mut().x += justification_left.at(self.size)
|
||||
+ justification_right.at(self.size);
|
||||
frame.size_mut().x += justification_left.at(glyph_size)
|
||||
+ justification_right.at(glyph_size);
|
||||
|
||||
// We may not be able to reach the offset completely if
|
||||
// it exceeds u16, but better to have a roughly correct
|
||||
@ -304,7 +308,7 @@ impl<'a> ShapedText<'a> {
|
||||
|
||||
let item = TextItem {
|
||||
font,
|
||||
size: self.size,
|
||||
size: glyph_size,
|
||||
lang: self.lang,
|
||||
region: self.region,
|
||||
fill: fill.clone(),
|
||||
@ -336,12 +340,13 @@ impl<'a> ShapedText<'a> {
|
||||
let mut top = Abs::zero();
|
||||
let mut bottom = Abs::zero();
|
||||
|
||||
let size = TextElem::size_in(self.styles);
|
||||
let top_edge = TextElem::top_edge_in(self.styles);
|
||||
let bottom_edge = TextElem::bottom_edge_in(self.styles);
|
||||
|
||||
// Expand top and bottom by reading the font's vertical metrics.
|
||||
let mut expand = |font: &Font, bounds: TextEdgeBounds| {
|
||||
let (t, b) = font.edges(top_edge, bottom_edge, self.size, bounds);
|
||||
let (t, b) = font.edges(top_edge, bottom_edge, size, bounds);
|
||||
top.set_max(t);
|
||||
bottom.set_max(b);
|
||||
};
|
||||
@ -388,18 +393,16 @@ impl<'a> ShapedText<'a> {
|
||||
pub fn stretchability(&self) -> Abs {
|
||||
self.glyphs
|
||||
.iter()
|
||||
.map(|g| g.stretchability().0 + g.stretchability().1)
|
||||
.sum::<Em>()
|
||||
.at(self.size)
|
||||
.map(|g| (g.stretchability().0 + g.stretchability().1).at(g.size))
|
||||
.sum()
|
||||
}
|
||||
|
||||
/// The shrinkability of the text
|
||||
pub fn shrinkability(&self) -> Abs {
|
||||
self.glyphs
|
||||
.iter()
|
||||
.map(|g| g.shrinkability().0 + g.shrinkability().1)
|
||||
.sum::<Em>()
|
||||
.at(self.size)
|
||||
.map(|g| (g.shrinkability().0 + g.shrinkability().1).at(g.size))
|
||||
.sum()
|
||||
}
|
||||
|
||||
/// Reshape a range of the shaped text, reusing information from this
|
||||
@ -418,9 +421,8 @@ impl<'a> ShapedText<'a> {
|
||||
lang: self.lang,
|
||||
region: self.region,
|
||||
styles: self.styles,
|
||||
size: self.size,
|
||||
variant: self.variant,
|
||||
width: glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(self.size),
|
||||
width: glyphs_width(glyphs),
|
||||
glyphs: Cow::Borrowed(glyphs),
|
||||
}
|
||||
} else {
|
||||
@ -484,13 +486,15 @@ impl<'a> ShapedText<'a> {
|
||||
// that subtracting either of the endpoints by self.base doesn't
|
||||
// underflow. See <https://github.com/typst/typst/issues/2283>.
|
||||
.unwrap_or_else(|| self.base..self.base);
|
||||
self.width += x_advance.at(self.size);
|
||||
let size = TextElem::size_in(self.styles);
|
||||
self.width += x_advance.at(size);
|
||||
let glyph = ShapedGlyph {
|
||||
font,
|
||||
glyph_id: glyph_id.0,
|
||||
x_advance,
|
||||
x_offset: Em::zero(),
|
||||
y_offset: Em::zero(),
|
||||
size,
|
||||
adjustability: Adjustability::default(),
|
||||
range,
|
||||
safe_to_break: true,
|
||||
@ -666,6 +670,7 @@ fn shape<'a>(
|
||||
region: Option<Region>,
|
||||
) -> ShapedText<'a> {
|
||||
let size = TextElem::size_in(styles);
|
||||
let shift_settings = TextElem::shift_settings_in(styles);
|
||||
let mut ctx = ShapingContext {
|
||||
engine,
|
||||
size,
|
||||
@ -676,6 +681,7 @@ fn shape<'a>(
|
||||
features: features(styles),
|
||||
fallback: TextElem::fallback_in(styles),
|
||||
dir,
|
||||
shift_settings,
|
||||
};
|
||||
|
||||
if !text.is_empty() {
|
||||
@ -698,12 +704,17 @@ fn shape<'a>(
|
||||
region,
|
||||
styles,
|
||||
variant: ctx.variant,
|
||||
size,
|
||||
width: ctx.glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(size),
|
||||
width: glyphs_width(&ctx.glyphs),
|
||||
glyphs: Cow::Owned(ctx.glyphs),
|
||||
}
|
||||
}
|
||||
|
||||
/// Computes the width of a run of glyphs relative to the font size, accounting
|
||||
/// for their individual scaling factors and other font metrics.
|
||||
fn glyphs_width(glyphs: &[ShapedGlyph]) -> Abs {
|
||||
glyphs.iter().map(|g| g.x_advance.at(g.size)).sum()
|
||||
}
|
||||
|
||||
/// Holds shaping results and metadata common to all shaped segments.
|
||||
struct ShapingContext<'a, 'v> {
|
||||
engine: &'a Engine<'v>,
|
||||
@ -715,6 +726,7 @@ struct ShapingContext<'a, 'v> {
|
||||
features: Vec<rustybuzz::Feature>,
|
||||
fallback: bool,
|
||||
dir: Dir,
|
||||
shift_settings: Option<ShiftSettings>,
|
||||
}
|
||||
|
||||
/// Shape text with font fallback using the `families` iterator.
|
||||
@ -789,6 +801,18 @@ fn shape_segment<'a>(
|
||||
// text extraction.
|
||||
buffer.set_flags(BufferFlags::REMOVE_DEFAULT_IGNORABLES);
|
||||
|
||||
let (script_shift, script_compensation, scale, shift_feature) = ctx
|
||||
.shift_settings
|
||||
.map_or((Em::zero(), Em::zero(), Em::one(), None), |settings| {
|
||||
determine_shift(text, &font, settings)
|
||||
});
|
||||
|
||||
let has_shift_feature = shift_feature.is_some();
|
||||
if let Some(feat) = shift_feature {
|
||||
// Temporarily push the feature.
|
||||
ctx.features.push(feat)
|
||||
}
|
||||
|
||||
// Prepare the shape plan. This plan depends on direction, script, language,
|
||||
// and features, but is independent from the text and can thus be memoized.
|
||||
let plan = create_shape_plan(
|
||||
@ -799,6 +823,10 @@ fn shape_segment<'a>(
|
||||
&ctx.features,
|
||||
);
|
||||
|
||||
if has_shift_feature {
|
||||
ctx.features.pop();
|
||||
}
|
||||
|
||||
// Shape!
|
||||
let buffer = rustybuzz::shape_with_plan(font.rusty(), &plan, buffer);
|
||||
let infos = buffer.glyph_infos();
|
||||
@ -869,8 +897,9 @@ fn shape_segment<'a>(
|
||||
glyph_id: info.glyph_id as u16,
|
||||
// TODO: Don't ignore y_advance.
|
||||
x_advance,
|
||||
x_offset: font.to_em(pos[i].x_offset),
|
||||
y_offset: font.to_em(pos[i].y_offset),
|
||||
x_offset: font.to_em(pos[i].x_offset) + script_compensation,
|
||||
y_offset: font.to_em(pos[i].y_offset) + script_shift,
|
||||
size: scale.at(ctx.size),
|
||||
adjustability: Adjustability::default(),
|
||||
range: start..end,
|
||||
safe_to_break: !info.unsafe_to_break(),
|
||||
@ -932,6 +961,64 @@ fn shape_segment<'a>(
|
||||
ctx.used.pop();
|
||||
}
|
||||
|
||||
/// Returns a `(script_shift, script_compensation, scale, feature)` quadruplet
|
||||
/// describing how to produce scripts.
|
||||
///
|
||||
/// Those values determine how the rendered text should be transformed to
|
||||
/// display sub-/super-scripts. If the OpenType feature can be used, the
|
||||
/// rendered text should not be transformed in any way, and so those values are
|
||||
/// neutral (`(0, 0, 1, None)`). If scripts should be synthesized, those values
|
||||
/// determine how to transform the rendered text to display scripts as expected.
|
||||
fn determine_shift(
|
||||
text: &str,
|
||||
font: &Font,
|
||||
settings: ShiftSettings,
|
||||
) -> (Em, Em, Em, Option<Feature>) {
|
||||
settings
|
||||
.typographic
|
||||
.then(|| {
|
||||
// If typographic scripts are enabled (i.e., we want to use the
|
||||
// OpenType feature instead of synthesizing if possible), we add
|
||||
// "subs"/"sups" to the feature list if supported by the font.
|
||||
// In case of a problem, we just early exit
|
||||
let gsub = font.rusty().tables().gsub?;
|
||||
let subtable_index =
|
||||
gsub.features.find(settings.kind.feature())?.lookup_indices.get(0)?;
|
||||
let coverage = gsub
|
||||
.lookups
|
||||
.get(subtable_index)?
|
||||
.subtables
|
||||
.get::<SubstitutionSubtable>(0)?
|
||||
.coverage();
|
||||
text.chars()
|
||||
.all(|c| {
|
||||
font.rusty().glyph_index(c).is_some_and(|i| coverage.contains(i))
|
||||
})
|
||||
.then(|| {
|
||||
// If we can use the OpenType feature, we can keep the text
|
||||
// as is.
|
||||
(
|
||||
Em::zero(),
|
||||
Em::zero(),
|
||||
Em::one(),
|
||||
Some(Feature::new(settings.kind.feature(), 1, ..)),
|
||||
)
|
||||
})
|
||||
})
|
||||
// Reunite the cases where `typographic` is `false` or where using the
|
||||
// OpenType feature would not work.
|
||||
.flatten()
|
||||
.unwrap_or_else(|| {
|
||||
let script_metrics = settings.kind.read_metrics(font.metrics());
|
||||
(
|
||||
settings.shift.unwrap_or(script_metrics.vertical_offset),
|
||||
script_metrics.horizontal_offset,
|
||||
settings.size.unwrap_or(script_metrics.height),
|
||||
None,
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Create a shape plan.
|
||||
#[comemo::memoize]
|
||||
pub fn create_shape_plan(
|
||||
@ -963,6 +1050,7 @@ fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) {
|
||||
x_advance,
|
||||
x_offset: Em::zero(),
|
||||
y_offset: Em::zero(),
|
||||
size: ctx.size,
|
||||
adjustability: Adjustability::default(),
|
||||
range: start..end,
|
||||
safe_to_break: true,
|
||||
@ -985,9 +1073,8 @@ fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) {
|
||||
|
||||
/// Apply tracking and spacing to the shaped glyphs.
|
||||
fn track_and_space(ctx: &mut ShapingContext) {
|
||||
let tracking = Em::from_length(TextElem::tracking_in(ctx.styles), ctx.size);
|
||||
let spacing =
|
||||
TextElem::spacing_in(ctx.styles).map(|abs| Em::from_length(abs, ctx.size));
|
||||
let tracking = Em::from_abs(TextElem::tracking_in(ctx.styles), ctx.size);
|
||||
let spacing = TextElem::spacing_in(ctx.styles).map(|abs| Em::from_abs(abs, ctx.size));
|
||||
|
||||
let mut glyphs = ctx.glyphs.iter_mut().peekable();
|
||||
while let Some(glyph) = glyphs.next() {
|
||||
|
||||
@ -215,7 +215,7 @@ impl MathFragment {
|
||||
&glyph.item.font,
|
||||
GlyphId(glyph.item.glyphs[glyph_index].id),
|
||||
corner,
|
||||
Em::from_length(height, glyph.item.size),
|
||||
Em::from_abs(height, glyph.item.size),
|
||||
)
|
||||
.unwrap_or_default()
|
||||
.at(glyph.item.size)
|
||||
@ -767,8 +767,8 @@ fn assemble(
|
||||
advance += ratio * (max_overlap - min_overlap);
|
||||
}
|
||||
let (x, y) = match axis {
|
||||
Axis::X => (Em::from_length(advance, base.item.size), Em::zero()),
|
||||
Axis::Y => (Em::zero(), Em::from_length(advance, base.item.size)),
|
||||
Axis::X => (Em::from_abs(advance, base.item.size), Em::zero()),
|
||||
Axis::Y => (Em::zero(), Em::from_abs(advance, base.item.size)),
|
||||
};
|
||||
glyphs.push(Glyph {
|
||||
id: part.glyph_id.0,
|
||||
|
||||
@ -15,6 +15,7 @@ pub fn finalize(
|
||||
LayoutedPage {
|
||||
inner,
|
||||
mut margin,
|
||||
bleed,
|
||||
binding,
|
||||
two_sided,
|
||||
header,
|
||||
@ -34,33 +35,36 @@ pub fn finalize(
|
||||
}
|
||||
|
||||
// Create a frame for the full page.
|
||||
let mut frame = Frame::hard(inner.size() + margin.sum_by_axis());
|
||||
let mut frame =
|
||||
Frame::hard(inner.size() + margin.sum_by_axis() + bleed.sum_by_axis());
|
||||
|
||||
// Add tags.
|
||||
for tag in tags.drain(..) {
|
||||
frame.push(Point::zero(), FrameItem::Tag(tag));
|
||||
}
|
||||
|
||||
let content_origin = Point::new(bleed.left, bleed.top);
|
||||
|
||||
// Add the "before" marginals. The order in which we push things here is
|
||||
// important as it affects the relative ordering of introspectable elements
|
||||
// and thus how counters resolve.
|
||||
if let Some(background) = background {
|
||||
frame.push_frame(Point::zero(), background);
|
||||
frame.push_frame(content_origin, background);
|
||||
}
|
||||
if let Some(header) = header {
|
||||
frame.push_frame(Point::with_x(margin.left), header);
|
||||
frame.push_frame(content_origin + Point::with_x(margin.left), header);
|
||||
}
|
||||
|
||||
// Add the inner contents.
|
||||
frame.push_frame(Point::new(margin.left, margin.top), inner);
|
||||
frame.push_frame(content_origin + Point::new(margin.left, margin.top), inner);
|
||||
|
||||
// Add the "after" marginals.
|
||||
if let Some(footer) = footer {
|
||||
let y = frame.height() - footer.height();
|
||||
frame.push_frame(Point::new(margin.left, y), footer);
|
||||
let y = frame.height() - footer.height() - bleed.bottom;
|
||||
frame.push_frame(Point::new(margin.left + bleed.left, y), footer);
|
||||
}
|
||||
if let Some(foreground) = foreground {
|
||||
frame.push_frame(Point::zero(), foreground);
|
||||
frame.push_frame(content_origin + Point::zero(), foreground);
|
||||
}
|
||||
|
||||
// Apply counter updates from within the page to the manual page counter.
|
||||
@ -70,5 +74,5 @@ pub fn finalize(
|
||||
let number = counter.logical();
|
||||
counter.step();
|
||||
|
||||
Ok(Page { frame, fill, numbering, supplement, number })
|
||||
Ok(Page { frame, bleed, fill, numbering, supplement, number })
|
||||
}
|
||||
|
||||
@ -28,6 +28,7 @@ use crate::flow::{layout_flow, FlowMode};
|
||||
pub struct LayoutedPage {
|
||||
pub inner: Frame,
|
||||
pub margin: Sides<Abs>,
|
||||
pub bleed: Sides<Abs>,
|
||||
pub binding: Binding,
|
||||
pub two_sided: bool,
|
||||
pub header: Option<Frame>,
|
||||
@ -123,6 +124,12 @@ fn layout_page_run_impl(
|
||||
.resolve(styles)
|
||||
.relative_to(size);
|
||||
|
||||
let bleed = PageElem::bleed_in(styles)
|
||||
.sides
|
||||
.map(|side| side.and_then(Smart::custom).unwrap_or(Rel::zero()))
|
||||
.resolve(styles)
|
||||
.relative_to(size);
|
||||
|
||||
let fill = PageElem::fill_in(styles);
|
||||
let foreground = PageElem::foreground_in(styles);
|
||||
let background = PageElem::background_in(styles);
|
||||
@ -215,6 +222,7 @@ fn layout_page_run_impl(
|
||||
background: layout_marginal(background, full_size, mid)?,
|
||||
foreground: layout_marginal(foreground, full_size, mid)?,
|
||||
margin,
|
||||
bleed,
|
||||
binding,
|
||||
two_sided,
|
||||
});
|
||||
|
||||
@ -94,7 +94,7 @@ impl Array {
|
||||
}
|
||||
|
||||
/// Iterate over references to the contained values.
|
||||
pub fn iter(&self) -> std::slice::Iter<Value> {
|
||||
pub fn iter(&self) -> std::slice::Iter<'_, Value> {
|
||||
self.0.iter()
|
||||
}
|
||||
|
||||
@ -604,7 +604,7 @@ impl Array {
|
||||
Ok(acc)
|
||||
}
|
||||
|
||||
/// Calculates the product all items (works for all types that can be
|
||||
/// Calculates the product of all items (works for all types that can be
|
||||
/// multiplied).
|
||||
#[func]
|
||||
pub fn product(
|
||||
|
||||
@ -207,9 +207,9 @@ pub fn sqrt(
|
||||
/// ```
|
||||
#[func]
|
||||
pub fn root(
|
||||
/// The expression to take the root of
|
||||
/// The expression to take the root of.
|
||||
radicand: f64,
|
||||
/// Which root of the radicand to take
|
||||
/// Which root of the radicand to take.
|
||||
index: Spanned<i64>,
|
||||
) -> SourceResult<f64> {
|
||||
if index.v == 0 {
|
||||
@ -317,7 +317,7 @@ pub fn asin(
|
||||
/// ```
|
||||
#[func(title = "Arccosine")]
|
||||
pub fn acos(
|
||||
/// The number whose arcsine to calculate. Must be between -1 and 1.
|
||||
/// The number whose arccosine to calculate. Must be between -1 and 1.
|
||||
value: Spanned<Num>,
|
||||
) -> SourceResult<Angle> {
|
||||
let val = value.v.float();
|
||||
@ -387,7 +387,7 @@ pub fn cosh(
|
||||
value.cosh()
|
||||
}
|
||||
|
||||
/// Calculates the hyperbolic tangent of an hyperbolic angle.
|
||||
/// Calculates the hyperbolic tangent of a hyperbolic angle.
|
||||
///
|
||||
/// ```example
|
||||
/// #calc.tanh(0) \
|
||||
|
||||
@ -114,7 +114,7 @@ impl Dict {
|
||||
}
|
||||
|
||||
/// Iterate over pairs of references to the contained keys and values.
|
||||
pub fn iter(&self) -> indexmap::map::Iter<Str, Value> {
|
||||
pub fn iter(&self) -> indexmap::map::Iter<'_, Str, Value> {
|
||||
self.0.iter()
|
||||
}
|
||||
|
||||
|
||||
@ -1,7 +1,8 @@
|
||||
use ecow::{eco_format, EcoString};
|
||||
use typst_utils::{PicoStr, ResolvedPicoStr};
|
||||
|
||||
use crate::foundations::{func, scope, ty, Repr, Str};
|
||||
use crate::diag::StrResult;
|
||||
use crate::foundations::{bail, func, scope, ty, Repr, Str};
|
||||
|
||||
/// A label for an element.
|
||||
///
|
||||
@ -27,7 +28,8 @@ use crate::foundations::{func, scope, ty, Repr, Str};
|
||||
/// # Syntax
|
||||
/// This function also has dedicated syntax: You can create a label by enclosing
|
||||
/// its name in angle brackets. This works both in markup and code. A label's
|
||||
/// name can contain letters, numbers, `_`, `-`, `:`, and `.`.
|
||||
/// name can contain letters, numbers, `_`, `-`, `:`, and `.`. A label cannot
|
||||
/// be empty.
|
||||
///
|
||||
/// Note that there is a syntactical difference when using the dedicated syntax
|
||||
/// for this function. In the code below, the `[<a>]` terminates the heading and
|
||||
@ -50,8 +52,11 @@ pub struct Label(PicoStr);
|
||||
|
||||
impl Label {
|
||||
/// Creates a label from an interned string.
|
||||
pub fn new(name: PicoStr) -> Self {
|
||||
Self(name)
|
||||
///
|
||||
/// Returns `None` if the given string is empty.
|
||||
pub fn new(name: PicoStr) -> Option<Self> {
|
||||
const EMPTY: PicoStr = PicoStr::constant("");
|
||||
(name != EMPTY).then_some(Self(name))
|
||||
}
|
||||
|
||||
/// Resolves the label to a string.
|
||||
@ -70,10 +75,14 @@ impl Label {
|
||||
/// Creates a label from a string.
|
||||
#[func(constructor)]
|
||||
pub fn construct(
|
||||
/// The name of the label.
|
||||
/// The name of the label. Must not be empty.
|
||||
name: Str,
|
||||
) -> Label {
|
||||
Self(PicoStr::intern(name.as_str()))
|
||||
) -> StrResult<Label> {
|
||||
if name.is_empty() {
|
||||
bail!("label name must not be empty");
|
||||
}
|
||||
|
||||
Ok(Self(PicoStr::intern(name.as_str())))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -19,11 +19,8 @@ use crate::foundations::{repr, ty, Content, Scope, Value};
|
||||
///
|
||||
/// You can access definitions from the module using [field access
|
||||
/// notation]($scripting/#fields) and interact with it using the [import and
|
||||
/// include syntaxes]($scripting/#modules). Alternatively, it is possible to
|
||||
/// convert a module to a dictionary, and therefore access its contents
|
||||
/// dynamically, using the [dictionary constructor]($dictionary/#constructor).
|
||||
/// include syntaxes]($scripting/#modules).
|
||||
///
|
||||
/// # Example
|
||||
/// ```example
|
||||
/// <<< #import "utils.typ"
|
||||
/// <<< #utils.add(2, 5)
|
||||
@ -34,6 +31,20 @@ use crate::foundations::{repr, ty, Content, Scope, Value};
|
||||
/// >>>
|
||||
/// >>> #(-3)
|
||||
/// ```
|
||||
///
|
||||
/// You can check whether a definition is present in a module using the `{in}`
|
||||
/// operator, with a string on the left-hand side. This can be useful to
|
||||
/// [conditionally access]($category/foundations/std/#conditional-access)
|
||||
/// definitions in a module.
|
||||
///
|
||||
/// ```example
|
||||
/// #("table" in std) \
|
||||
/// #("nope" in std)
|
||||
/// ```
|
||||
///
|
||||
/// Alternatively, it is possible to convert a module to a dictionary, and
|
||||
/// therefore access its contents dynamically, using the [dictionary
|
||||
/// constructor]($dictionary/#constructor).
|
||||
#[ty(cast)]
|
||||
#[derive(Clone, Hash)]
|
||||
#[allow(clippy::derived_hash_with_manual_eq)]
|
||||
|
||||
@ -558,6 +558,7 @@ pub fn contains(lhs: &Value, rhs: &Value) -> Option<bool> {
|
||||
(Str(a), Str(b)) => Some(b.as_str().contains(a.as_str())),
|
||||
(Dyn(a), Str(b)) => a.downcast::<Regex>().map(|regex| regex.is_match(b)),
|
||||
(Str(a), Dict(b)) => Some(b.contains(a)),
|
||||
(Str(a), Module(b)) => Some(b.scope().get(a).is_some()),
|
||||
(a, Array(b)) => Some(b.contains(a.clone())),
|
||||
|
||||
_ => Option::None,
|
||||
|
||||
@ -8,7 +8,7 @@ use serde::{Serialize, Serializer};
|
||||
use typst_syntax::{is_ident, Span, Spanned};
|
||||
use typst_utils::hash128;
|
||||
|
||||
use crate::diag::{bail, SourceResult, StrResult};
|
||||
use crate::diag::{bail, DeprecationSink, SourceResult, StrResult};
|
||||
use crate::foundations::{
|
||||
cast, elem, func, scope, ty, Array, Content, Func, NativeElement, NativeFunc, Packed,
|
||||
PlainText, Repr as _,
|
||||
@ -54,18 +54,22 @@ enum Repr {
|
||||
/// A native symbol that has no named variant.
|
||||
Single(char),
|
||||
/// A native symbol with multiple named variants.
|
||||
Complex(&'static [(ModifierSet<&'static str>, char)]),
|
||||
Complex(&'static [Variant<&'static str>]),
|
||||
/// A symbol with multiple named variants, where some modifiers may have
|
||||
/// been applied. Also used for symbols defined at runtime by the user with
|
||||
/// no modifier applied.
|
||||
Modified(Arc<(List, ModifierSet<EcoString>)>),
|
||||
}
|
||||
|
||||
/// A symbol variant, consisting of a set of modifiers, a character, and an
|
||||
/// optional deprecation message.
|
||||
type Variant<S> = (ModifierSet<S>, char, Option<S>);
|
||||
|
||||
/// A collection of symbols.
|
||||
#[derive(Clone, Eq, PartialEq, Hash)]
|
||||
enum List {
|
||||
Static(&'static [(ModifierSet<&'static str>, char)]),
|
||||
Runtime(Box<[(ModifierSet<EcoString>, char)]>),
|
||||
Static(&'static [Variant<&'static str>]),
|
||||
Runtime(Box<[Variant<EcoString>]>),
|
||||
}
|
||||
|
||||
impl Symbol {
|
||||
@ -76,14 +80,14 @@ impl Symbol {
|
||||
|
||||
/// Create a symbol with a static variant list.
|
||||
#[track_caller]
|
||||
pub const fn list(list: &'static [(ModifierSet<&'static str>, char)]) -> Self {
|
||||
pub const fn list(list: &'static [Variant<&'static str>]) -> Self {
|
||||
debug_assert!(!list.is_empty());
|
||||
Self(Repr::Complex(list))
|
||||
}
|
||||
|
||||
/// Create a symbol with a runtime variant list.
|
||||
#[track_caller]
|
||||
pub fn runtime(list: Box<[(ModifierSet<EcoString>, char)]>) -> Self {
|
||||
pub fn runtime(list: Box<[Variant<EcoString>]>) -> Self {
|
||||
debug_assert!(!list.is_empty());
|
||||
Self(Repr::Modified(Arc::new((List::Runtime(list), ModifierSet::default()))))
|
||||
}
|
||||
@ -93,9 +97,11 @@ impl Symbol {
|
||||
match &self.0 {
|
||||
Repr::Single(c) => *c,
|
||||
Repr::Complex(_) => ModifierSet::<&'static str>::default()
|
||||
.best_match_in(self.variants())
|
||||
.best_match_in(self.variants().map(|(m, c, _)| (m, c)))
|
||||
.unwrap(),
|
||||
Repr::Modified(arc) => arc.1.best_match_in(self.variants()).unwrap(),
|
||||
Repr::Modified(arc) => {
|
||||
arc.1.best_match_in(self.variants().map(|(m, c, _)| (m, c))).unwrap()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -128,7 +134,11 @@ impl Symbol {
|
||||
}
|
||||
|
||||
/// Apply a modifier to the symbol.
|
||||
pub fn modified(mut self, modifier: &str) -> StrResult<Self> {
|
||||
pub fn modified(
|
||||
mut self,
|
||||
sink: impl DeprecationSink,
|
||||
modifier: &str,
|
||||
) -> StrResult<Self> {
|
||||
if let Repr::Complex(list) = self.0 {
|
||||
self.0 =
|
||||
Repr::Modified(Arc::new((List::Static(list), ModifierSet::default())));
|
||||
@ -137,7 +147,12 @@ impl Symbol {
|
||||
if let Repr::Modified(arc) = &mut self.0 {
|
||||
let (list, modifiers) = Arc::make_mut(arc);
|
||||
modifiers.insert_raw(modifier);
|
||||
if modifiers.best_match_in(list.variants()).is_some() {
|
||||
if let Some(deprecation) =
|
||||
modifiers.best_match_in(list.variants().map(|(m, _, d)| (m, d)))
|
||||
{
|
||||
if let Some(message) = deprecation {
|
||||
sink.emit(message)
|
||||
}
|
||||
return Ok(self);
|
||||
}
|
||||
}
|
||||
@ -146,7 +161,7 @@ impl Symbol {
|
||||
}
|
||||
|
||||
/// The characters that are covered by this symbol.
|
||||
pub fn variants(&self) -> impl Iterator<Item = (ModifierSet<&str>, char)> {
|
||||
pub fn variants(&self) -> impl Iterator<Item = Variant<&str>> {
|
||||
match &self.0 {
|
||||
Repr::Single(c) => Variants::Single(Some(*c).into_iter()),
|
||||
Repr::Complex(list) => Variants::Static(list.iter()),
|
||||
@ -161,7 +176,7 @@ impl Symbol {
|
||||
_ => ModifierSet::default(),
|
||||
};
|
||||
self.variants()
|
||||
.flat_map(|(m, _)| m)
|
||||
.flat_map(|(m, _, _)| m)
|
||||
.filter(|modifier| !modifier.is_empty() && !modifiers.contains(modifier))
|
||||
.collect::<BTreeSet<_>>()
|
||||
.into_iter()
|
||||
@ -256,7 +271,7 @@ impl Symbol {
|
||||
|
||||
let list = variants
|
||||
.into_iter()
|
||||
.map(|s| (ModifierSet::from_raw_dotted(s.v.0), s.v.1))
|
||||
.map(|s| (ModifierSet::from_raw_dotted(s.v.0), s.v.1, None))
|
||||
.collect();
|
||||
Ok(Symbol::runtime(list))
|
||||
}
|
||||
@ -316,17 +331,17 @@ impl crate::foundations::Repr for Symbol {
|
||||
}
|
||||
|
||||
fn repr_variants<'a>(
|
||||
variants: impl Iterator<Item = (ModifierSet<&'a str>, char)>,
|
||||
variants: impl Iterator<Item = Variant<&'a str>>,
|
||||
applied_modifiers: ModifierSet<&str>,
|
||||
) -> String {
|
||||
crate::foundations::repr::pretty_array_like(
|
||||
&variants
|
||||
.filter(|(modifiers, _)| {
|
||||
.filter(|(modifiers, _, _)| {
|
||||
// Only keep variants that can still be accessed, i.e., variants
|
||||
// that contain all applied modifiers.
|
||||
applied_modifiers.iter().all(|am| modifiers.contains(am))
|
||||
})
|
||||
.map(|(modifiers, c)| {
|
||||
.map(|(modifiers, c, _)| {
|
||||
let trimmed_modifiers =
|
||||
modifiers.into_iter().filter(|&m| !applied_modifiers.contains(m));
|
||||
if trimmed_modifiers.clone().all(|m| m.is_empty()) {
|
||||
@ -379,18 +394,20 @@ cast! {
|
||||
/// Iterator over variants.
|
||||
enum Variants<'a> {
|
||||
Single(std::option::IntoIter<char>),
|
||||
Static(std::slice::Iter<'static, (ModifierSet<&'static str>, char)>),
|
||||
Runtime(std::slice::Iter<'a, (ModifierSet<EcoString>, char)>),
|
||||
Static(std::slice::Iter<'static, Variant<&'static str>>),
|
||||
Runtime(std::slice::Iter<'a, Variant<EcoString>>),
|
||||
}
|
||||
|
||||
impl<'a> Iterator for Variants<'a> {
|
||||
type Item = (ModifierSet<&'a str>, char);
|
||||
type Item = Variant<&'a str>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
match self {
|
||||
Self::Single(iter) => Some((ModifierSet::default(), iter.next()?)),
|
||||
Self::Single(iter) => Some((ModifierSet::default(), iter.next()?, None)),
|
||||
Self::Static(list) => list.next().copied(),
|
||||
Self::Runtime(list) => list.next().map(|(m, c)| (m.as_deref(), *c)),
|
||||
Self::Runtime(list) => {
|
||||
list.next().map(|(m, c, d)| (m.as_deref(), *c, d.as_deref()))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -157,7 +157,9 @@ impl Value {
|
||||
/// Try to access a field on the value.
|
||||
pub fn field(&self, field: &str, sink: impl DeprecationSink) -> StrResult<Value> {
|
||||
match self {
|
||||
Self::Symbol(symbol) => symbol.clone().modified(field).map(Self::Symbol),
|
||||
Self::Symbol(symbol) => {
|
||||
symbol.clone().modified(sink, field).map(Self::Symbol)
|
||||
}
|
||||
Self::Version(version) => version.component(field).map(Self::Int),
|
||||
Self::Dict(dict) => dict.get(field).cloned(),
|
||||
Self::Content(content) => content.field_by_name(field),
|
||||
|
||||
@ -7,7 +7,7 @@ use typst_utils::{PicoStr, ResolvedPicoStr};
|
||||
use crate::diag::{bail, HintedStrResult, StrResult};
|
||||
use crate::foundations::{cast, Dict, Repr, Str};
|
||||
use crate::introspection::{Introspector, Tag};
|
||||
use crate::layout::Frame;
|
||||
use crate::layout::{Abs, Frame};
|
||||
use crate::model::DocumentInfo;
|
||||
|
||||
/// An HTML document.
|
||||
@ -30,8 +30,8 @@ pub enum HtmlNode {
|
||||
Text(EcoString, Span),
|
||||
/// Another element.
|
||||
Element(HtmlElement),
|
||||
/// A frame that will be displayed as an embedded SVG.
|
||||
Frame(Frame),
|
||||
/// Layouted content that will be embedded into HTML as an SVG.
|
||||
Frame(HtmlFrame),
|
||||
}
|
||||
|
||||
impl HtmlNode {
|
||||
@ -263,6 +263,17 @@ cast! {
|
||||
v: Str => Self::intern(&v)?,
|
||||
}
|
||||
|
||||
/// Layouted content that will be embedded into HTML as an SVG.
|
||||
#[derive(Debug, Clone, Hash)]
|
||||
pub struct HtmlFrame {
|
||||
/// The frame that will be displayed as an SVG.
|
||||
pub inner: Frame,
|
||||
/// The text size where the frame was defined. This is used to size the
|
||||
/// frame with em units to make text in and outside of the frame sized
|
||||
/// consistently.
|
||||
pub text_size: Abs,
|
||||
}
|
||||
|
||||
/// Defines syntactical properties of HTML tags, attributes, and text.
|
||||
pub mod charsets {
|
||||
/// Check whether a character is in a tag name.
|
||||
|
||||
@ -446,7 +446,7 @@ impl IntrospectorBuilder {
|
||||
HtmlNode::Element(elem) => self.discover_in_html(sink, &elem.children),
|
||||
HtmlNode::Frame(frame) => self.discover_in_frame(
|
||||
sink,
|
||||
frame,
|
||||
&frame.inner,
|
||||
NonZeroUsize::ONE,
|
||||
Transform::identity(),
|
||||
),
|
||||
|
||||
@ -497,7 +497,8 @@ mod callbacks {
|
||||
|
||||
macro_rules! callback {
|
||||
($name:ident = ($($param:ident: $param_ty:ty),* $(,)?) -> $ret:ty) => {
|
||||
#[derive(Debug, Clone, PartialEq, Hash)]
|
||||
#[derive(Debug, Clone, Hash)]
|
||||
#[allow(clippy::derived_hash_with_manual_eq)]
|
||||
pub struct $name {
|
||||
captured: Content,
|
||||
f: fn(&Content, $($param_ty),*) -> $ret,
|
||||
@ -535,6 +536,19 @@ mod callbacks {
|
||||
(self.f)(&self.captured, $($param),*)
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for $name {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
// Comparing function pointers is problematic. Since for
|
||||
// each type of content, there is typically just one
|
||||
// callback, we skip it. It barely matters anyway since
|
||||
// getting into a comparison codepath for inline & block
|
||||
// elements containing callback bodies is close to
|
||||
// impossible (as these are generally generated in show
|
||||
// rules).
|
||||
self.captured.eq(&other.captured)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@ use ecow::EcoString;
|
||||
use typst_utils::{Numeric, Scalar};
|
||||
|
||||
use crate::foundations::{cast, repr, Repr, Resolve, StyleChain, Value};
|
||||
use crate::layout::Abs;
|
||||
use crate::layout::{Abs, Length};
|
||||
use crate::text::TextElem;
|
||||
|
||||
/// A length that is relative to the font size.
|
||||
@ -26,18 +26,18 @@ impl Em {
|
||||
Self(Scalar::ONE)
|
||||
}
|
||||
|
||||
/// Create a font-relative length.
|
||||
/// Creates a font-relative length.
|
||||
pub const fn new(em: f64) -> Self {
|
||||
Self(Scalar::new(em))
|
||||
}
|
||||
|
||||
/// Create an em length from font units at the given units per em.
|
||||
/// Creates an em length from font units at the given units per em.
|
||||
pub fn from_units(units: impl Into<f64>, units_per_em: f64) -> Self {
|
||||
Self(Scalar::new(units.into() / units_per_em))
|
||||
}
|
||||
|
||||
/// Create an em length from a length at the given font size.
|
||||
pub fn from_length(length: Abs, font_size: Abs) -> Self {
|
||||
/// Creates an em length from an absolute length at the given font size.
|
||||
pub fn from_abs(length: Abs, font_size: Abs) -> Self {
|
||||
let result = length / font_size;
|
||||
if result.is_finite() {
|
||||
Self(Scalar::new(result))
|
||||
@ -46,6 +46,11 @@ impl Em {
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates an em length from a length at the given font size.
|
||||
pub fn from_length(length: Length, font_size: Abs) -> Em {
|
||||
length.em + Self::from_abs(length.abs, font_size)
|
||||
}
|
||||
|
||||
/// The number of em units.
|
||||
pub const fn get(self) -> f64 {
|
||||
(self.0).get()
|
||||
@ -56,7 +61,7 @@ impl Em {
|
||||
Self::new(self.get().abs())
|
||||
}
|
||||
|
||||
/// Convert to an absolute length at the given font size.
|
||||
/// Converts to an absolute length at the given font size.
|
||||
pub fn at(self, font_size: Abs) -> Abs {
|
||||
let resolved = font_size * self.get();
|
||||
if resolved.is_finite() {
|
||||
|
||||
@ -47,12 +47,12 @@ impl Fragment {
|
||||
}
|
||||
|
||||
/// Iterate over the contained frames.
|
||||
pub fn iter(&self) -> std::slice::Iter<Frame> {
|
||||
pub fn iter(&self) -> std::slice::Iter<'_, Frame> {
|
||||
self.0.iter()
|
||||
}
|
||||
|
||||
/// Iterate over the contained frames.
|
||||
pub fn iter_mut(&mut self) -> std::slice::IterMut<Frame> {
|
||||
pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, Frame> {
|
||||
self.0.iter_mut()
|
||||
}
|
||||
}
|
||||
|
||||
@ -148,6 +148,47 @@ pub struct PageElem {
|
||||
#[ghost]
|
||||
pub margin: Margin,
|
||||
|
||||
/// The page's bleed margin.
|
||||
///
|
||||
/// The bleed is the area of content that extends beyond the final trimmed
|
||||
/// size of the page. It ensures that no unprinted edges appear in the final
|
||||
/// product, even if minor trimming misalignments occur.
|
||||
///
|
||||
/// Accepted values:
|
||||
///
|
||||
/// - `{auto}`: Sets the bleed to `0mm` on all sides.
|
||||
/// - A single length: Applies the same bleed to all sides.
|
||||
/// - A dictionary: Allows setting bleed values individually. The dictionary
|
||||
/// may include the following keys, listed in order of precedence:
|
||||
/// - `top`: Bleed at the top of the page.
|
||||
/// - `right`: Bleed at the right side.
|
||||
/// - `bottom`: Bleed at the bottom.
|
||||
/// - `left`: Bleed at the left side.
|
||||
/// - `inside`: Bleed on the inner side of the page (next to
|
||||
/// [binding]($page.binding)).
|
||||
/// - `outside`: Bleed on the outer side of the page (opposite the
|
||||
/// [binding]($page.binding)).
|
||||
/// - `x`: Horizontal bleed (applies to both left/right or inside/outside).
|
||||
/// - `y`: Vertical bleed (applies to both top and bottom).
|
||||
/// - `rest`: Default bleed for any sides not explicitly set.
|
||||
///
|
||||
/// Note: The keys `left` and `right` are mutually exclusive with `inside` and
|
||||
/// `outside`.
|
||||
///
|
||||
/// On PDF output, if the bleed is non-zero, a `TrimBox` and a `BleedBox` are
|
||||
/// defined for the page.
|
||||
///
|
||||
/// ```example
|
||||
/// #set page(
|
||||
/// width: 3cm,
|
||||
/// height: 4cm,
|
||||
/// bleed: 5mm,
|
||||
/// background: rect(width: 100%, height: 100%, fill: aqua),
|
||||
/// )
|
||||
/// ```
|
||||
#[ghost]
|
||||
pub bleed: Margin,
|
||||
|
||||
/// On which side the pages will be bound.
|
||||
///
|
||||
/// - `{auto}`: Equivalent to `left` if the [text direction]($text.dir)
|
||||
@ -467,6 +508,8 @@ pub struct PagedDocument {
|
||||
pub struct Page {
|
||||
/// The frame that defines the page.
|
||||
pub frame: Frame,
|
||||
/// The bleed amount to be added on each side of the page.
|
||||
pub bleed: Sides<Abs>,
|
||||
/// How the page is filled.
|
||||
///
|
||||
/// - When `None`, the background is transparent.
|
||||
|
||||
@ -321,7 +321,11 @@ impl Bibliography {
|
||||
for d in data.iter() {
|
||||
let library = decode_library(d)?;
|
||||
for entry in library {
|
||||
match map.entry(Label::new(PicoStr::intern(entry.key()))) {
|
||||
let label = Label::new(PicoStr::intern(entry.key()))
|
||||
.ok_or("bibliography contains entry with empty key")
|
||||
.at(d.source.span)?;
|
||||
|
||||
match map.entry(label) {
|
||||
indexmap::map::Entry::Vacant(vacant) => {
|
||||
vacant.insert(entry);
|
||||
}
|
||||
|
||||
@ -2,7 +2,10 @@ use smallvec::smallvec;
|
||||
|
||||
use crate::diag::SourceResult;
|
||||
use crate::engine::Engine;
|
||||
use crate::foundations::{elem, Content, Packed, Show, Smart, StyleChain};
|
||||
use crate::foundations::{
|
||||
elem, Content, NativeElement, Packed, Show, Smart, StyleChain, TargetElem,
|
||||
};
|
||||
use crate::html::{attr, tag, HtmlElem};
|
||||
use crate::layout::{Abs, Corners, Length, Rel, Sides};
|
||||
use crate::text::{BottomEdge, BottomEdgeMetric, TextElem, TopEdge, TopEdgeMetric};
|
||||
use crate::visualize::{Color, FixedStroke, Paint, Stroke};
|
||||
@ -81,6 +84,16 @@ pub struct UnderlineElem {
|
||||
impl Show for Packed<UnderlineElem> {
|
||||
#[typst_macros::time(name = "underline", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
// Note: In modern HTML, `<u>` is not the underline element, but
|
||||
// rather an "Unarticulated Annotation" element (see HTML spec
|
||||
// 4.5.22). Using `text-decoration` instead is recommended by MDN.
|
||||
return Ok(HtmlElem::new(tag::span)
|
||||
.with_attr(attr::style, "text-decoration: underline")
|
||||
.with_body(Some(self.body.clone()))
|
||||
.pack());
|
||||
}
|
||||
|
||||
Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
|
||||
line: DecoLine::Underline {
|
||||
stroke: self.stroke(styles).unwrap_or_default(),
|
||||
@ -173,6 +186,13 @@ pub struct OverlineElem {
|
||||
impl Show for Packed<OverlineElem> {
|
||||
#[typst_macros::time(name = "overline", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
return Ok(HtmlElem::new(tag::span)
|
||||
.with_attr(attr::style, "text-decoration: overline")
|
||||
.with_body(Some(self.body.clone()))
|
||||
.pack());
|
||||
}
|
||||
|
||||
Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
|
||||
line: DecoLine::Overline {
|
||||
stroke: self.stroke(styles).unwrap_or_default(),
|
||||
@ -250,6 +270,10 @@ pub struct StrikeElem {
|
||||
impl Show for Packed<StrikeElem> {
|
||||
#[typst_macros::time(name = "strike", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
return Ok(HtmlElem::new(tag::s).with_body(Some(self.body.clone())).pack());
|
||||
}
|
||||
|
||||
Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
|
||||
// Note that we do not support evade option for strikethrough.
|
||||
line: DecoLine::Strikethrough {
|
||||
@ -345,6 +369,12 @@ pub struct HighlightElem {
|
||||
impl Show for Packed<HighlightElem> {
|
||||
#[typst_macros::time(name = "highlight", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
return Ok(HtmlElem::new(tag::mark)
|
||||
.with_body(Some(self.body.clone()))
|
||||
.pack());
|
||||
}
|
||||
|
||||
Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
|
||||
line: DecoLine::Highlight {
|
||||
fill: self.fill(styles),
|
||||
|
||||
@ -228,6 +228,10 @@ pub struct FontMetrics {
|
||||
pub underline: LineMetrics,
|
||||
/// Recommended metrics for an overline.
|
||||
pub overline: LineMetrics,
|
||||
/// Metrics for subscripts, if provided by the font.
|
||||
pub subscript: Option<ScriptMetrics>,
|
||||
/// Metrics for superscripts, if provided by the font.
|
||||
pub superscript: Option<ScriptMetrics>,
|
||||
}
|
||||
|
||||
impl FontMetrics {
|
||||
@ -240,6 +244,7 @@ impl FontMetrics {
|
||||
let cap_height = ttf.capital_height().filter(|&h| h > 0).map_or(ascender, to_em);
|
||||
let x_height = ttf.x_height().filter(|&h| h > 0).map_or(ascender, to_em);
|
||||
let descender = to_em(ttf.typographic_descender().unwrap_or(ttf.descender()));
|
||||
|
||||
let strikeout = ttf.strikeout_metrics();
|
||||
let underline = ttf.underline_metrics();
|
||||
|
||||
@ -262,6 +267,20 @@ impl FontMetrics {
|
||||
thickness: underline.thickness,
|
||||
};
|
||||
|
||||
let subscript = ttf.subscript_metrics().map(|metrics| ScriptMetrics {
|
||||
width: to_em(metrics.x_size),
|
||||
height: to_em(metrics.y_size),
|
||||
horizontal_offset: to_em(metrics.x_offset),
|
||||
vertical_offset: -to_em(metrics.y_offset),
|
||||
});
|
||||
|
||||
let superscript = ttf.superscript_metrics().map(|metrics| ScriptMetrics {
|
||||
width: to_em(metrics.x_size),
|
||||
height: to_em(metrics.y_size),
|
||||
horizontal_offset: to_em(metrics.x_offset),
|
||||
vertical_offset: to_em(metrics.y_offset),
|
||||
});
|
||||
|
||||
Self {
|
||||
units_per_em,
|
||||
ascender,
|
||||
@ -271,6 +290,8 @@ impl FontMetrics {
|
||||
strikethrough,
|
||||
underline,
|
||||
overline,
|
||||
superscript,
|
||||
subscript,
|
||||
}
|
||||
}
|
||||
|
||||
@ -296,6 +317,24 @@ pub struct LineMetrics {
|
||||
pub thickness: Em,
|
||||
}
|
||||
|
||||
/// Metrics for subscripts or superscripts.
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct ScriptMetrics {
|
||||
/// The width of those scripts, relative to the outer font size.
|
||||
pub width: Em,
|
||||
/// The height of those scripts, relative to the outer font size.
|
||||
pub height: Em,
|
||||
/// The horizontal (to the right) offset of those scripts, relative to the
|
||||
/// outer font size.
|
||||
///
|
||||
/// This is used for italic correction.
|
||||
pub horizontal_offset: Em,
|
||||
/// The vertical (to the top) offset of those scripts, relative to the outer font size.
|
||||
///
|
||||
/// For superscripts, this is positive. For subscripts, this is negative.
|
||||
pub vertical_offset: Em,
|
||||
}
|
||||
|
||||
/// Identifies a vertical metric of a font.
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)]
|
||||
pub enum VerticalFontMetric {
|
||||
|
||||
@ -755,6 +755,12 @@ pub struct TextElem {
|
||||
#[internal]
|
||||
#[ghost]
|
||||
pub smallcaps: Option<Smallcaps>,
|
||||
|
||||
/// The configuration for superscripts or subscripts, if one of them is
|
||||
/// enabled.
|
||||
#[internal]
|
||||
#[ghost]
|
||||
pub shift_settings: Option<ShiftSettings>,
|
||||
}
|
||||
|
||||
impl TextElem {
|
||||
@ -930,7 +936,7 @@ cast! {
|
||||
}
|
||||
|
||||
/// Resolve a prioritized iterator over the font families.
|
||||
pub fn families(styles: StyleChain) -> impl Iterator<Item = &FontFamily> + Clone {
|
||||
pub fn families(styles: StyleChain<'_>) -> impl Iterator<Item = &'_ FontFamily> + Clone {
|
||||
let fallbacks = singleton!(Vec<FontFamily>, {
|
||||
[
|
||||
"libertinus serif",
|
||||
|
||||
@ -1,14 +1,13 @@
|
||||
use ecow::EcoString;
|
||||
|
||||
use crate::diag::SourceResult;
|
||||
use crate::engine::Engine;
|
||||
use crate::foundations::{
|
||||
elem, Content, NativeElement, Packed, SequenceElem, Show, StyleChain, TargetElem,
|
||||
elem, Content, NativeElement, Packed, Show, Smart, StyleChain, TargetElem,
|
||||
};
|
||||
use crate::html::{tag, HtmlElem};
|
||||
use crate::layout::{Em, Length};
|
||||
use crate::text::{variant, SpaceElem, TextElem, TextSize};
|
||||
use crate::World;
|
||||
use crate::text::{FontMetrics, TextElem, TextSize};
|
||||
use ttf_parser::Tag;
|
||||
use typst_library::text::ScriptMetrics;
|
||||
|
||||
/// Renders text in subscript.
|
||||
///
|
||||
@ -20,11 +19,16 @@ use crate::World;
|
||||
/// ```
|
||||
#[elem(title = "Subscript", Show)]
|
||||
pub struct SubElem {
|
||||
/// Whether to prefer the dedicated subscript characters of the font.
|
||||
/// Whether to create artificial subscripts by lowering and scaling down
|
||||
/// regular glyphs.
|
||||
///
|
||||
/// If this is enabled, Typst first tries to transform the text to subscript
|
||||
/// codepoints. If that fails, it falls back to rendering lowered and shrunk
|
||||
/// normal letters.
|
||||
/// Ideally, subscripts glyphs are provided by the font (using the `subs`
|
||||
/// OpenType feature). Otherwise, Typst is able to synthesize subscripts.
|
||||
///
|
||||
/// When this is set to `{false}`, synthesized glyphs will be used
|
||||
/// regardless of whether the font provides dedicated subscript glyphs. When
|
||||
/// `{true}`, synthesized glyphs may still be used in case the font does not
|
||||
/// provide the necessary subscript glyphs.
|
||||
///
|
||||
/// ```example
|
||||
/// N#sub(typographic: true)[1]
|
||||
@ -33,17 +37,27 @@ pub struct SubElem {
|
||||
#[default(true)]
|
||||
pub typographic: bool,
|
||||
|
||||
/// The baseline shift for synthetic subscripts. Does not apply if
|
||||
/// `typographic` is true and the font has subscript codepoints for the
|
||||
/// given `body`.
|
||||
#[default(Em::new(0.2).into())]
|
||||
pub baseline: Length,
|
||||
/// The downward baseline shift for synthesized subscripts.
|
||||
///
|
||||
/// This only applies to synthesized subscripts. In other words, this has no
|
||||
/// effect if `typographic` is `{true}` and the font provides the necessary
|
||||
/// subscript glyphs.
|
||||
///
|
||||
/// If set to `{auto}`, the baseline is shifted according to the metrics
|
||||
/// provided by the font, with a fallback to `{0.2em}` in case the font does
|
||||
/// not define the necessary metrics.
|
||||
pub baseline: Smart<Length>,
|
||||
|
||||
/// The font size for synthetic subscripts. Does not apply if
|
||||
/// `typographic` is true and the font has subscript codepoints for the
|
||||
/// given `body`.
|
||||
#[default(TextSize(Em::new(0.6).into()))]
|
||||
pub size: TextSize,
|
||||
/// The font size for synthesized subscripts.
|
||||
///
|
||||
/// This only applies to synthesized subscripts. In other words, this has no
|
||||
/// effect if `typographic` is `{true}` and the font provides the necessary
|
||||
/// subscript glyphs.
|
||||
///
|
||||
/// If set to `{auto}`, the size is scaled according to the metrics provided
|
||||
/// by the font, with a fallback to `{0.6em}` in case the font does not
|
||||
/// define the necessary metrics.
|
||||
pub size: Smart<TextSize>,
|
||||
|
||||
/// The text to display in subscript.
|
||||
#[required]
|
||||
@ -52,7 +66,7 @@ pub struct SubElem {
|
||||
|
||||
impl Show for Packed<SubElem> {
|
||||
#[typst_macros::time(name = "sub", span = self.span())]
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let body = self.body.clone();
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
@ -62,17 +76,14 @@ impl Show for Packed<SubElem> {
|
||||
.spanned(self.span()));
|
||||
}
|
||||
|
||||
if self.typographic(styles) {
|
||||
if let Some(text) = convert_script(&body, true) {
|
||||
if is_shapable(engine, &text, styles) {
|
||||
return Ok(TextElem::packed(text));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Ok(body
|
||||
.styled(TextElem::set_baseline(self.baseline(styles)))
|
||||
.styled(TextElem::set_size(self.size(styles))))
|
||||
show_script(
|
||||
styles,
|
||||
body,
|
||||
self.typographic(styles),
|
||||
self.baseline(styles),
|
||||
self.size(styles),
|
||||
ScriptKind::Sub,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@ -86,11 +97,16 @@ impl Show for Packed<SubElem> {
|
||||
/// ```
|
||||
#[elem(title = "Superscript", Show)]
|
||||
pub struct SuperElem {
|
||||
/// Whether to prefer the dedicated superscript characters of the font.
|
||||
/// Whether to create artificial superscripts by raising and scaling down
|
||||
/// regular glyphs.
|
||||
///
|
||||
/// If this is enabled, Typst first tries to transform the text to
|
||||
/// superscript codepoints. If that fails, it falls back to rendering
|
||||
/// raised and shrunk normal letters.
|
||||
/// Ideally, superscripts glyphs are provided by the font (using the `sups`
|
||||
/// OpenType feature). Otherwise, Typst is able to synthesize superscripts.
|
||||
///
|
||||
/// When this is set to `{false}`, synthesized glyphs will be used
|
||||
/// regardless of whether the font provides dedicated superscript glyphs.
|
||||
/// When `{true}`, synthesized glyphs may still be used in case the font
|
||||
/// does not provide the necessary superscript glyphs.
|
||||
///
|
||||
/// ```example
|
||||
/// N#super(typographic: true)[1]
|
||||
@ -99,17 +115,31 @@ pub struct SuperElem {
|
||||
#[default(true)]
|
||||
pub typographic: bool,
|
||||
|
||||
/// The baseline shift for synthetic superscripts. Does not apply if
|
||||
/// `typographic` is true and the font has superscript codepoints for the
|
||||
/// given `body`.
|
||||
#[default(Em::new(-0.5).into())]
|
||||
pub baseline: Length,
|
||||
/// The downward baseline shift for synthesized superscripts.
|
||||
///
|
||||
/// This only applies to synthesized superscripts. In other words, this has
|
||||
/// no effect if `typographic` is `{true}` and the font provides the
|
||||
/// necessary superscript glyphs.
|
||||
///
|
||||
/// If set to `{auto}`, the baseline is shifted according to the metrics
|
||||
/// provided by the font, with a fallback to `{-0.5em}` in case the font
|
||||
/// does not define the necessary metrics.
|
||||
///
|
||||
/// Note that, since the baseline shift is applied downward, you will need
|
||||
/// to provide a negative value for the content to appear as raised above
|
||||
/// the normal baseline.
|
||||
pub baseline: Smart<Length>,
|
||||
|
||||
/// The font size for synthetic superscripts. Does not apply if
|
||||
/// `typographic` is true and the font has superscript codepoints for the
|
||||
/// given `body`.
|
||||
#[default(TextSize(Em::new(0.6).into()))]
|
||||
pub size: TextSize,
|
||||
/// The font size for synthesized superscripts.
|
||||
///
|
||||
/// This only applies to synthesized superscripts. In other words, this has
|
||||
/// no effect if `typographic` is `{true}` and the font provides the
|
||||
/// necessary superscript glyphs.
|
||||
///
|
||||
/// If set to `{auto}`, the size is scaled according to the metrics provided
|
||||
/// by the font, with a fallback to `{0.6em}` in case the font does not
|
||||
/// define the necessary metrics.
|
||||
pub size: Smart<TextSize>,
|
||||
|
||||
/// The text to display in superscript.
|
||||
#[required]
|
||||
@ -118,7 +148,7 @@ pub struct SuperElem {
|
||||
|
||||
impl Show for Packed<SuperElem> {
|
||||
#[typst_macros::time(name = "super", span = self.span())]
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let body = self.body.clone();
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
@ -128,104 +158,102 @@ impl Show for Packed<SuperElem> {
|
||||
.spanned(self.span()));
|
||||
}
|
||||
|
||||
if self.typographic(styles) {
|
||||
if let Some(text) = convert_script(&body, false) {
|
||||
if is_shapable(engine, &text, styles) {
|
||||
return Ok(TextElem::packed(text));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Ok(body
|
||||
.styled(TextElem::set_baseline(self.baseline(styles)))
|
||||
.styled(TextElem::set_size(self.size(styles))))
|
||||
show_script(
|
||||
styles,
|
||||
body,
|
||||
self.typographic(styles),
|
||||
self.baseline(styles),
|
||||
self.size(styles),
|
||||
ScriptKind::Super,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Find and transform the text contained in `content` to the given script kind
|
||||
/// if and only if it only consists of `Text`, `Space`, and `Empty` leaves.
|
||||
fn convert_script(content: &Content, sub: bool) -> Option<EcoString> {
|
||||
if content.is::<SpaceElem>() {
|
||||
Some(' '.into())
|
||||
} else if let Some(elem) = content.to_packed::<TextElem>() {
|
||||
if sub {
|
||||
elem.text.chars().map(to_subscript_codepoint).collect()
|
||||
} else {
|
||||
elem.text.chars().map(to_superscript_codepoint).collect()
|
||||
}
|
||||
} else if let Some(sequence) = content.to_packed::<SequenceElem>() {
|
||||
sequence
|
||||
.children
|
||||
.iter()
|
||||
.map(|item| convert_script(item, sub))
|
||||
.collect()
|
||||
} else {
|
||||
None
|
||||
}
|
||||
fn show_script(
|
||||
styles: StyleChain,
|
||||
body: Content,
|
||||
typographic: bool,
|
||||
baseline: Smart<Length>,
|
||||
size: Smart<TextSize>,
|
||||
kind: ScriptKind,
|
||||
) -> SourceResult<Content> {
|
||||
let font_size = TextElem::size_in(styles);
|
||||
Ok(body.styled(TextElem::set_shift_settings(Some(ShiftSettings {
|
||||
typographic,
|
||||
shift: baseline.map(|l| -Em::from_length(l, font_size)),
|
||||
size: size.map(|t| Em::from_length(t.0, font_size)),
|
||||
kind,
|
||||
}))))
|
||||
}
|
||||
|
||||
/// Checks whether the first retrievable family contains all code points of the
|
||||
/// given string.
|
||||
fn is_shapable(engine: &Engine, text: &str, styles: StyleChain) -> bool {
|
||||
let world = engine.world;
|
||||
for family in TextElem::font_in(styles) {
|
||||
if let Some(font) = world
|
||||
.book()
|
||||
.select(family.as_str(), variant(styles))
|
||||
.and_then(|id| world.font(id))
|
||||
{
|
||||
let covers = family.covers();
|
||||
return text.chars().all(|c| {
|
||||
covers.is_none_or(|cov| cov.is_match(c.encode_utf8(&mut [0; 4])))
|
||||
&& font.ttf().glyph_index(c).is_some()
|
||||
});
|
||||
/// Configuration values for sub- or superscript text.
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
|
||||
pub struct ShiftSettings {
|
||||
/// Whether the OpenType feature should be used if possible.
|
||||
pub typographic: bool,
|
||||
/// The baseline shift of the script, relative to the outer text size.
|
||||
///
|
||||
/// For superscripts, this is positive. For subscripts, this is negative. A
|
||||
/// value of [`Smart::Auto`] indicates that the value should be obtained
|
||||
/// from font metrics.
|
||||
pub shift: Smart<Em>,
|
||||
/// The size of the script, relative to the outer text size.
|
||||
///
|
||||
/// A value of [`Smart::Auto`] indicates that the value should be obtained
|
||||
/// from font metrics.
|
||||
pub size: Smart<Em>,
|
||||
/// The kind of script (either a subscript, or a superscript).
|
||||
///
|
||||
/// This is used to know which OpenType table to use to resolve
|
||||
/// [`Smart::Auto`] values.
|
||||
pub kind: ScriptKind,
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
|
||||
pub enum ScriptKind {
|
||||
Sub,
|
||||
Super,
|
||||
}
|
||||
|
||||
impl ScriptKind {
|
||||
/// Returns the default metrics for this script kind.
|
||||
///
|
||||
/// This can be used as a last resort if neither the user nor the font
|
||||
/// provided those metrics.
|
||||
pub fn default_metrics(self) -> &'static ScriptMetrics {
|
||||
match self {
|
||||
Self::Sub => &DEFAULT_SUBSCRIPT_METRICS,
|
||||
Self::Super => &DEFAULT_SUPERSCRIPT_METRICS,
|
||||
}
|
||||
}
|
||||
|
||||
false
|
||||
}
|
||||
/// Reads the script metrics from the font table for to this script kind.
|
||||
pub fn read_metrics(self, font_metrics: &FontMetrics) -> &ScriptMetrics {
|
||||
match self {
|
||||
Self::Sub => font_metrics.subscript.as_ref(),
|
||||
Self::Super => font_metrics.superscript.as_ref(),
|
||||
}
|
||||
.unwrap_or(self.default_metrics())
|
||||
}
|
||||
|
||||
/// Convert a character to its corresponding Unicode superscript.
|
||||
fn to_superscript_codepoint(c: char) -> Option<char> {
|
||||
match c {
|
||||
'1' => Some('¹'),
|
||||
'2' => Some('²'),
|
||||
'3' => Some('³'),
|
||||
'0' | '4'..='9' => char::from_u32(c as u32 - '0' as u32 + '⁰' as u32),
|
||||
'+' => Some('⁺'),
|
||||
'−' => Some('⁻'),
|
||||
'=' => Some('⁼'),
|
||||
'(' => Some('⁽'),
|
||||
')' => Some('⁾'),
|
||||
'n' => Some('ⁿ'),
|
||||
'i' => Some('ⁱ'),
|
||||
' ' => Some(' '),
|
||||
_ => None,
|
||||
/// The corresponding OpenType feature.
|
||||
pub const fn feature(self) -> Tag {
|
||||
match self {
|
||||
Self::Sub => Tag::from_bytes(b"subs"),
|
||||
Self::Super => Tag::from_bytes(b"sups"),
|
||||
}
|
||||
}
|
||||
}
|
||||
static DEFAULT_SUBSCRIPT_METRICS: ScriptMetrics = ScriptMetrics {
|
||||
width: Em::new(0.6),
|
||||
height: Em::new(0.6),
|
||||
horizontal_offset: Em::zero(),
|
||||
vertical_offset: Em::new(-0.2),
|
||||
};
|
||||
|
||||
/// Convert a character to its corresponding Unicode subscript.
|
||||
fn to_subscript_codepoint(c: char) -> Option<char> {
|
||||
match c {
|
||||
'0'..='9' => char::from_u32(c as u32 - '0' as u32 + '₀' as u32),
|
||||
'+' => Some('₊'),
|
||||
'−' => Some('₋'),
|
||||
'=' => Some('₌'),
|
||||
'(' => Some('₍'),
|
||||
')' => Some('₎'),
|
||||
'a' => Some('ₐ'),
|
||||
'e' => Some('ₑ'),
|
||||
'o' => Some('ₒ'),
|
||||
'x' => Some('ₓ'),
|
||||
'h' => Some('ₕ'),
|
||||
'k' => Some('ₖ'),
|
||||
'l' => Some('ₗ'),
|
||||
'm' => Some('ₘ'),
|
||||
'n' => Some('ₙ'),
|
||||
'p' => Some('ₚ'),
|
||||
's' => Some('ₛ'),
|
||||
't' => Some('ₜ'),
|
||||
' ' => Some(' '),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
static DEFAULT_SUPERSCRIPT_METRICS: ScriptMetrics = ScriptMetrics {
|
||||
width: Em::new(0.6),
|
||||
height: Em::new(0.6),
|
||||
horizontal_offset: Em::zero(),
|
||||
vertical_offset: Em::new(0.5),
|
||||
};
|
||||
|
||||
@ -1285,24 +1285,17 @@ fn process_stops(stops: &[Spanned<GradientStop>]) -> SourceResult<Vec<(Color, Ra
|
||||
/// Sample the stops at a given position.
|
||||
fn sample_stops(stops: &[(Color, Ratio)], mixing_space: ColorSpace, t: f64) -> Color {
|
||||
let t = t.clamp(0.0, 1.0);
|
||||
let mut low = 0;
|
||||
let mut high = stops.len();
|
||||
let mut j = stops.partition_point(|(_, ratio)| ratio.get() < t);
|
||||
|
||||
while low < high {
|
||||
let mid = (low + high) / 2;
|
||||
if stops[mid].1.get() < t {
|
||||
low = mid + 1;
|
||||
} else {
|
||||
high = mid;
|
||||
if j == 0 {
|
||||
while stops.get(j + 1).is_some_and(|(_, r)| r.is_zero()) {
|
||||
j += 1;
|
||||
}
|
||||
return stops[j].0;
|
||||
}
|
||||
|
||||
if low == 0 {
|
||||
low = 1;
|
||||
}
|
||||
|
||||
let (col_0, pos_0) = stops[low - 1];
|
||||
let (col_1, pos_1) = stops[low];
|
||||
let (col_0, pos_0) = stops[j - 1];
|
||||
let (col_1, pos_1) = stops[j];
|
||||
let t = (t - pos_0.get()) / (pos_1.get() - pos_0.get());
|
||||
|
||||
Color::mix_iter(
|
||||
|
||||
@ -7,7 +7,7 @@ use krilla::configure::{Configuration, ValidationError, Validator};
|
||||
use krilla::destination::{NamedDestination, XyzDestination};
|
||||
use krilla::embed::EmbedError;
|
||||
use krilla::error::KrillaError;
|
||||
use krilla::geom::PathBuilder;
|
||||
use krilla::geom::{PathBuilder, Rect};
|
||||
use krilla::page::{PageLabel, PageSettings};
|
||||
use krilla::surface::Surface;
|
||||
use krilla::{Document, SerializeSettings};
|
||||
@ -16,7 +16,7 @@ use typst_library::diag::{bail, error, SourceDiagnostic, SourceResult};
|
||||
use typst_library::foundations::{NativeElement, Repr};
|
||||
use typst_library::introspection::Location;
|
||||
use typst_library::layout::{
|
||||
Abs, Frame, FrameItem, GroupItem, PagedDocument, Size, Transform,
|
||||
Abs, Frame, FrameItem, GroupItem, PagedDocument, Sides, Size, Transform,
|
||||
};
|
||||
use typst_library::model::HeadingElem;
|
||||
use typst_library::text::{Font, Lang};
|
||||
@ -81,6 +81,22 @@ fn convert_pages(gc: &mut GlobalContext, document: &mut Document) -> SourceResul
|
||||
typst_page.frame.height().to_f32(),
|
||||
);
|
||||
|
||||
if typst_page.bleed != Sides::splat(Abs::zero()) {
|
||||
settings = settings
|
||||
.with_bleed_box(Rect::from_xywh(
|
||||
0.0,
|
||||
0.0,
|
||||
typst_page.frame.width().to_f32(),
|
||||
typst_page.frame.height().to_f32(),
|
||||
))
|
||||
.with_trim_box(Rect::from_ltrb(
|
||||
typst_page.bleed.left.to_f32(),
|
||||
typst_page.bleed.top.to_f32(),
|
||||
(typst_page.frame.width() - typst_page.bleed.right).to_f32(),
|
||||
(typst_page.frame.height() - typst_page.bleed.bottom).to_f32(),
|
||||
));
|
||||
}
|
||||
|
||||
if let Some(label) = typst_page
|
||||
.numbering
|
||||
.as_ref()
|
||||
|
||||
@ -172,7 +172,7 @@ pub enum PdfStandard {
|
||||
/// PDF/A-2u.
|
||||
#[serde(rename = "a-2u")]
|
||||
A_2u,
|
||||
/// PDF/A-3u.
|
||||
/// PDF/A-3b.
|
||||
#[serde(rename = "a-3b")]
|
||||
A_3b,
|
||||
/// PDF/A-3u.
|
||||
|
||||
@ -22,8 +22,6 @@ pub(crate) fn build_metadata(gc: &GlobalContext) -> Metadata {
|
||||
.keywords(gc.document.info.keywords.iter().map(EcoString::to_string).collect())
|
||||
.authors(gc.document.info.author.iter().map(EcoString::to_string).collect());
|
||||
|
||||
let lang = gc.languages.iter().max_by_key(|(_, &count)| count).map(|(&l, _)| l);
|
||||
|
||||
if let Some(lang) = lang {
|
||||
metadata = metadata.language(lang.as_str().to_string());
|
||||
}
|
||||
|
||||
@ -18,7 +18,7 @@ use typst_library::foundations::{
|
||||
SequenceElem, Show, ShowSet, Style, StyleChain, StyledElem, Styles, SymbolElem,
|
||||
Synthesize, Transformation,
|
||||
};
|
||||
use typst_library::html::{tag, HtmlElem};
|
||||
use typst_library::html::{tag, FrameElem, HtmlElem};
|
||||
use typst_library::introspection::{Locatable, SplitLocator, Tag, TagElem};
|
||||
use typst_library::layout::{
|
||||
AlignElem, BoxElem, HElem, InlineElem, PageElem, PagebreakElem, VElem,
|
||||
@ -237,9 +237,9 @@ fn visit<'a>(
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Transformations for math content based on the realization kind. Needs
|
||||
// Transformations for content based on the realization kind. Needs
|
||||
// to happen before show rules.
|
||||
if visit_math_rules(s, content, styles)? {
|
||||
if visit_kind_rules(s, content, styles)? {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@ -280,9 +280,8 @@ fn visit<'a>(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Handles special cases for math in normal content and nested equations in
|
||||
// math.
|
||||
fn visit_math_rules<'a>(
|
||||
// Handles transformations based on the realization kind.
|
||||
fn visit_kind_rules<'a>(
|
||||
s: &mut State<'a, '_, '_, '_>,
|
||||
content: &'a Content,
|
||||
styles: StyleChain<'a>,
|
||||
@ -335,6 +334,13 @@ fn visit_math_rules<'a>(
|
||||
}
|
||||
}
|
||||
|
||||
if !s.kind.is_html() {
|
||||
if let Some(elem) = content.to_packed::<FrameElem>() {
|
||||
visit(s, &elem.body, styles)?;
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
|
||||
@ -724,6 +724,8 @@ node! {
|
||||
|
||||
impl<'a> Ref<'a> {
|
||||
/// Get the target.
|
||||
///
|
||||
/// Will not be empty.
|
||||
pub fn target(self) -> &'a str {
|
||||
self.0
|
||||
.children()
|
||||
|
||||
@ -185,7 +185,7 @@ impl Lexer<'_> {
|
||||
'h' if self.s.eat_if("ttp://") => self.link(),
|
||||
'h' if self.s.eat_if("ttps://") => self.link(),
|
||||
'<' if self.s.at(is_id_continue) => self.label(),
|
||||
'@' => self.ref_marker(),
|
||||
'@' if self.s.at(is_id_continue) => self.ref_marker(),
|
||||
|
||||
'.' if self.s.eat_if("..") => SyntaxKind::Shorthand,
|
||||
'-' if self.s.eat_if("--") => SyntaxKind::Shorthand,
|
||||
|
||||
@ -395,6 +395,10 @@ pub fn default_math_class(c: char) -> Option<MathClass> {
|
||||
// https://github.com/typst/typst/issues/5764
|
||||
'⟇' => Some(MathClass::Binary),
|
||||
|
||||
// Arabic comma.
|
||||
// https://github.com/latex3/unicode-math/pull/633#issuecomment-2028936135
|
||||
'،' => Some(MathClass::Punctuation),
|
||||
|
||||
c => unicode_math_class::class(c),
|
||||
}
|
||||
}
|
||||
|
||||
@ -256,8 +256,8 @@ In Typst, the same function can be used both to affect the appearance for the
|
||||
remainder of the document, a block (or scope), or just its arguments. For
|
||||
example, `[#text(weight: "bold")[bold text]]` will only embolden its argument,
|
||||
while `[#set text(weight: "bold")]` will embolden any text until the end of the
|
||||
current block, or, if there is none, document. The effects of a function are
|
||||
immediately obvious based on whether it is used in a call or a
|
||||
current block, or the end of the document, if there is none. The effects of a
|
||||
function are immediately obvious based on whether it is used in a call or a
|
||||
[set rule.]($styling/#set-rules)
|
||||
|
||||
```example
|
||||
|
||||
@ -181,11 +181,7 @@
|
||||
[`sys.version`]($category/foundations/sys) can also be very useful.
|
||||
|
||||
```typ
|
||||
#let tiling = if "tiling" in dictionary(std) {
|
||||
tiling
|
||||
} else {
|
||||
pattern
|
||||
}
|
||||
#let tiling = if "tiling" in std { tiling } else { pattern }
|
||||
|
||||
...
|
||||
```
|
||||
|
||||
@ -720,18 +720,12 @@ fn symbols_model(resolver: &dyn Resolver, group: &GroupData) -> SymbolsModel {
|
||||
}
|
||||
};
|
||||
|
||||
for (variant, c) in symbol.variants() {
|
||||
for (variant, c, deprecation) in symbol.variants() {
|
||||
let shorthand = |list: &[(&'static str, char)]| {
|
||||
list.iter().copied().find(|&(_, x)| x == c).map(|(s, _)| s)
|
||||
};
|
||||
|
||||
let name = complete(variant);
|
||||
let deprecation = match name.as_str() {
|
||||
"integral.sect" => {
|
||||
Some("`integral.sect` is deprecated, use `integral.inter` instead")
|
||||
}
|
||||
_ => binding.deprecation(),
|
||||
};
|
||||
|
||||
list.push(SymbolModel {
|
||||
name,
|
||||
@ -742,10 +736,10 @@ fn symbols_model(resolver: &dyn Resolver, group: &GroupData) -> SymbolsModel {
|
||||
accent: typst::math::Accent::combine(c).is_some(),
|
||||
alternates: symbol
|
||||
.variants()
|
||||
.filter(|(other, _)| other != &variant)
|
||||
.map(|(other, _)| complete(other))
|
||||
.filter(|(other, _, _)| other != &variant)
|
||||
.map(|(other, _, _)| complete(other))
|
||||
.collect(),
|
||||
deprecation,
|
||||
deprecation: deprecation.or_else(|| binding.deprecation()),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@ -79,7 +79,7 @@ the right.
|
||||
|
||||
Last but not least is the `numbering` argument. Here, we can provide a
|
||||
[numbering pattern]($numbering) that defines how to number the pages. By
|
||||
setting into to `{"1"}`, Typst only displays the bare page number. Setting it to
|
||||
setting it to `{"1"}`, Typst only displays the bare page number. Setting it to
|
||||
`{"(1/1)"}` would have displayed the current page and total number of pages
|
||||
surrounded by parentheses. And we could even have provided a completely custom
|
||||
function here to format things to our liking.
|
||||
|
||||
BIN
tests/ref/html-frame-in-layout.png
Normal file
BIN
tests/ref/html-frame-in-layout.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 146 B |
11
tests/ref/html/html-deco.html
Normal file
11
tests/ref/html/html-deco.html
Normal file
@ -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><s>Struck</s> <mark>Highlighted</mark> <span style="text-decoration: underline">Underlined</span> <span style="text-decoration: overline">Overlined</span></p>
|
||||
<p><span style="text-decoration: overline"><span style="text-decoration: underline"><mark><s>Mixed</s></mark></span></span></p>
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 841 B After Width: | Height: | Size: 903 B |
BIN
tests/ref/issue-5775-cite-order-rtl.png
Normal file
BIN
tests/ref/issue-5775-cite-order-rtl.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 14 KiB |
BIN
tests/ref/issue-6162-coincident-gradient-stops-export-png.png
Normal file
BIN
tests/ref/issue-6162-coincident-gradient-stops-export-png.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 522 B |
BIN
tests/ref/long-scripts.png
Normal file
BIN
tests/ref/long-scripts.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 956 B |
BIN
tests/ref/page-bleed-content-bleeding.png
Normal file
BIN
tests/ref/page-bleed-content-bleeding.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 93 B |
BIN
tests/ref/page-bleed.png
Normal file
BIN
tests/ref/page-bleed.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 111 B |
BIN
tests/ref/ref-to-empty-label-not-possible.png
Normal file
BIN
tests/ref/ref-to-empty-label-not-possible.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 182 B |
BIN
tests/ref/script-metrics-bundeled-fonts.png
Normal file
BIN
tests/ref/script-metrics-bundeled-fonts.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.0 KiB |
BIN
tests/ref/sub-super-italic-compensation.png
Normal file
BIN
tests/ref/sub-super-italic-compensation.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.3 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 311 B After Width: | Height: | Size: 318 B |
BIN
tests/ref/sub-super-typographic.png
Normal file
BIN
tests/ref/sub-super-typographic.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.3 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.2 KiB |
BIN
tests/ref/super-highlight.png
Normal file
BIN
tests/ref/super-highlight.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.3 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.8 KiB After Width: | Height: | Size: 835 B |
@ -92,3 +92,7 @@ _Visible_
|
||||
--- label-non-existent-error ---
|
||||
// Error: 5-10 sequence does not have field "label"
|
||||
#[].label
|
||||
|
||||
--- label-empty ---
|
||||
// Error: 23-32 label name must not be empty
|
||||
= Something to label #label("")
|
||||
|
||||
8
tests/suite/html/frame.typ
Normal file
8
tests/suite/html/frame.typ
Normal file
@ -0,0 +1,8 @@
|
||||
// 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-in-layout ---
|
||||
// Ensure that HTML frames are transparent in layout. This is less important for
|
||||
// actual paged export than for _nested_ HTML frames, which take the same code
|
||||
// path.
|
||||
#html.frame[A]
|
||||
@ -34,7 +34,7 @@ To the right! Where the sunlight peeks behind the mountain.
|
||||
#align(start)[Start]
|
||||
#align(end)[Ende]
|
||||
|
||||
#set text(lang: "ar")
|
||||
#set text(lang: "ar", font: "Noto Sans Arabic")
|
||||
#align(start)[يبدأ]
|
||||
#align(end)[نهاية]
|
||||
|
||||
|
||||
@ -45,6 +45,7 @@ Lריווח #h(1cm) R
|
||||
|
||||
--- bidi-whitespace-reset ---
|
||||
// Test whether L1 whitespace resetting destroys stuff.
|
||||
#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
|
||||
الغالب #h(70pt) ن#" "ة
|
||||
|
||||
--- bidi-explicit-dir ---
|
||||
@ -87,7 +88,7 @@ Lריווח #h(1cm) R
|
||||
columns: (1fr, 1fr),
|
||||
lines(6),
|
||||
[
|
||||
#text(lang: "ar")[مجرد نص مؤقت لأغراض العرض التوضيحي. ]
|
||||
#text(lang: "ar", font: ("Libertinus Serif", "Noto Sans Arabic"))[مجرد نص مؤقت لأغراض العرض التوضيحي. ]
|
||||
#text(lang: "ar")[سلام]
|
||||
],
|
||||
)
|
||||
|
||||
@ -29,6 +29,7 @@ ABCअपार्टमेंट
|
||||
\ ט
|
||||
|
||||
--- shaping-font-fallback ---
|
||||
#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
|
||||
// Font fallback for emoji.
|
||||
A😀B
|
||||
|
||||
|
||||
@ -80,7 +80,7 @@ I'm in#text(tracking: 0.15em + 1.5pt)[ spaace]!
|
||||
|
||||
--- text-tracking-arabic ---
|
||||
// Test tracking in arabic text (makes no sense whatsoever)
|
||||
#set text(tracking: 0.3em)
|
||||
#set text(tracking: 0.3em, font: "Noto Sans Arabic")
|
||||
النص
|
||||
|
||||
--- text-spacing ---
|
||||
|
||||
@ -348,6 +348,26 @@ A
|
||||
A
|
||||
]
|
||||
|
||||
--- page-bleed ---
|
||||
#set page(
|
||||
bleed: 20pt,
|
||||
margin: 20pt,
|
||||
height: 80pt,
|
||||
width: 80pt,
|
||||
background: rect(width: 100%, height: 100%, fill: gray),
|
||||
)
|
||||
#rect(width: 100%, height: 100%, fill: black)
|
||||
|
||||
--- page-bleed-content-bleeding ---
|
||||
#set page(
|
||||
bleed: 20pt,
|
||||
margin: 20pt,
|
||||
height: 80pt,
|
||||
width: 80pt,
|
||||
)
|
||||
#set align(center + horizon)
|
||||
#rect(width: 100pt, height: 100pt, fill: black)
|
||||
|
||||
--- issue-2631-page-header-ordering ---
|
||||
#set text(6pt)
|
||||
#show heading: set text(6pt, weight: "regular")
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
|
||||
--- repeat-dots-rtl ---
|
||||
// Test dots with RTL.
|
||||
#set text(lang: "ar")
|
||||
#set text(lang: "ar", font: ("Libertinus Serif", "Noto Sans Arabic"))
|
||||
مقدمة #box(width: 1fr, repeat[.]) 15
|
||||
|
||||
--- repeat-empty ---
|
||||
@ -35,7 +35,7 @@ A#box(width: 1fr, repeat(rect(width: 6em, height: 0.7em)))B
|
||||
#set align(center)
|
||||
A#box(width: 1fr, repeat(rect(width: 6em, height: 0.7em)))B
|
||||
|
||||
#set text(dir: rtl)
|
||||
#set text(dir: rtl, font: "Noto Sans Arabic")
|
||||
ريجين#box(width: 1fr, repeat(rect(width: 4em, height: 0.7em)))سون
|
||||
|
||||
--- repeat-unrestricted ---
|
||||
|
||||
@ -121,8 +121,8 @@ $a scripts(=)^"def" b quad a scripts(lt.eq)_"really" b quad a scripts(arrow.r.lo
|
||||
|
||||
--- math-attach-integral ---
|
||||
// Test default of scripts attachments on integrals at display size.
|
||||
$ integral.sect_a^b quad \u{2a1b}_a^b quad limits(\u{2a1b})_a^b $
|
||||
$integral.sect_a^b quad \u{2a1b}_a^b quad limits(\u{2a1b})_a^b$
|
||||
$ integral.inter_a^b quad \u{2a1b}_a^b quad limits(\u{2a1b})_a^b $
|
||||
$integral.inter_a^b quad \u{2a1b}_a^b quad limits(\u{2a1b})_a^b$
|
||||
|
||||
--- math-attach-large-operator ---
|
||||
// Test default of limit attachments on large operators at display size only.
|
||||
|
||||
@ -75,6 +75,14 @@ Now we have multiple bibliographies containing @glacier-melt @keshav2007read
|
||||
// Error: 2-62 CSL style "Alphanumeric" is not suitable for bibliographies
|
||||
#bibliography("/assets/bib/works.bib", style: "alphanumeric")
|
||||
|
||||
--- bibliography-empty-key ---
|
||||
#let src = ```yaml
|
||||
"":
|
||||
type: Book
|
||||
```
|
||||
// Error: 15-30 bibliography contains entry with empty key
|
||||
#bibliography(bytes(src.text))
|
||||
|
||||
--- issue-4618-bibliography-set-heading-level ---
|
||||
// Test that the bibliography block's heading is set to 2 by the show rule,
|
||||
// and therefore should be rendered like a level-2 heading. Notably, this
|
||||
|
||||
@ -147,3 +147,16 @@ B #cite(<netwok>) #cite(<arrgh>).
|
||||
// Error: 7-17 expected label, found string
|
||||
// Hint: 7-17 use `label("%@&#*!\\")` to create a label
|
||||
#cite("%@&#*!\\")
|
||||
|
||||
--- issue-5775-cite-order-rtl ---
|
||||
// Test citation order in RTL text.
|
||||
#set page(width: 300pt)
|
||||
#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
|
||||
@netwok
|
||||
aaa
|
||||
این است
|
||||
@tolkien54
|
||||
و این یکی هست
|
||||
@arrgh
|
||||
|
||||
#bibliography("/assets/bib/works.bib")
|
||||
|
||||
@ -231,7 +231,7 @@ Welcome \ here. Does this work well?
|
||||
|
||||
--- par-hanging-indent-rtl ---
|
||||
#set par(hanging-indent: 2em)
|
||||
#set text(dir: rtl)
|
||||
#set text(dir: rtl, font: ("Libertinus Serif", "Noto Sans Arabic"))
|
||||
لآن وقد أظلم الليل وبدأت النجوم
|
||||
تنضخ وجه الطبيعة التي أعْيَتْ من طول ما انبعثت في النهار
|
||||
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
|
||||
--- quote-dir-author-pos ---
|
||||
// Text direction affects author positioning
|
||||
#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
|
||||
And I quote: #quote(attribution: [René Descartes])[cogito, ergo sum].
|
||||
|
||||
#set text(lang: "ar")
|
||||
@ -9,6 +10,7 @@ And I quote: #quote(attribution: [René Descartes])[cogito, ergo sum].
|
||||
|
||||
--- quote-dir-align ---
|
||||
// Text direction affects block alignment
|
||||
#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
|
||||
#set quote(block: true)
|
||||
#quote(attribution: [René Descartes])[cogito, ergo sum]
|
||||
|
||||
|
||||
@ -86,3 +86,14 @@ Text seen on #ref(<text>, form: "page", supplement: "Page").
|
||||
// Test reference with non-whitespace before it.
|
||||
#figure[] <1>
|
||||
#test([(#ref(<1>))], [(@1)])
|
||||
|
||||
--- ref-to-empty-label-not-possible ---
|
||||
// @ without any following label should just produce the symbol in the output
|
||||
// and not produce a reference to a label with an empty name.
|
||||
@
|
||||
|
||||
--- ref-function-empty-label ---
|
||||
// using ref() should also not be possible
|
||||
// Error: 6-7 unexpected less-than operator
|
||||
// Error: 7-8 unexpected greater-than operator
|
||||
#ref(<>)
|
||||
|
||||
@ -264,6 +264,8 @@
|
||||
#test("Hey" not in "abheyCd", true)
|
||||
#test("a" not
|
||||
/* fun comment? */ in "abc", false)
|
||||
#test("sys" in std, true)
|
||||
#test("system" in std, false)
|
||||
|
||||
--- ops-not-trailing ---
|
||||
// Error: 10 expected keyword `in`
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
|
||||
--- numbers ---
|
||||
// Test numbers in text mode.
|
||||
#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
|
||||
12 \
|
||||
12.0 \
|
||||
3.14 \
|
||||
|
||||
@ -83,3 +83,11 @@ We can also specify a customized value
|
||||
#highlight(stroke: 2pt + blue)[abc]
|
||||
#highlight(stroke: (top: blue, left: red, bottom: green, right: orange))[abc]
|
||||
#highlight(stroke: 1pt, radius: 3pt)[#lorem(5)]
|
||||
|
||||
--- html-deco html ---
|
||||
#strike[Struck]
|
||||
#highlight[Highlighted]
|
||||
#underline[Underlined]
|
||||
#overline[Overlined]
|
||||
|
||||
#(strike, highlight, underline, overline).fold([Mixed], (it, f) => f(it))
|
||||
|
||||
@ -1,22 +1,89 @@
|
||||
// Test sub- and superscript shifts.
|
||||
|
||||
--- sub-super ---
|
||||
#let sq = box(square(size: 4pt))
|
||||
#table(
|
||||
columns: 3,
|
||||
[Typo.], [Fallb.], [Synth],
|
||||
[x#super[1]], [x#super[5n]], [x#super[2 #box(square(size: 6pt))]],
|
||||
[x#sub[1]], [x#sub[5n]], [x#sub[2 #box(square(size: 6pt))]],
|
||||
[Typo.], [Fallb.], [Synth.],
|
||||
[x#super[1#sq]], [x#super[5: #sq]], [x#super(typographic: false)[2 #sq]],
|
||||
[x#sub[1#sq]], [x#sub[5: #sq]], [x#sub(typographic: false)[2 #sq]],
|
||||
)
|
||||
|
||||
--- sub-super-typographic ---
|
||||
#set text(size: 20pt)
|
||||
// Libertinus Serif supports "subs" and "sups" for `typo` and `sq`, but not for
|
||||
// `synth`.
|
||||
#let synth = [1,2,3]
|
||||
#let typo = [123]
|
||||
#let sq = [1#box(square(size: 4pt))2]
|
||||
x#super(synth) x#super(typo) x#super(sq) \
|
||||
x#sub(synth) x#sub(typo) x#sub(sq)
|
||||
|
||||
--- sub-super-italic-compensation ---
|
||||
#set text(size: 20pt, style: "italic")
|
||||
// Libertinus Serif supports "subs" and "sups" for `typo`, but not for `synth`.
|
||||
#let synth = [1,2,3]
|
||||
#let typo = [123]
|
||||
#let sq = [1#box(square(size: 4pt))2]
|
||||
x#super(synth) x#super(typo) x#super(sq) \
|
||||
x#sub(synth) x#sub(typo) x#sub(sq)
|
||||
|
||||
--- sub-super-non-typographic ---
|
||||
#set super(typographic: false, baseline: -0.25em, size: 0.7em)
|
||||
n#super[1], n#sub[2], ... n#super[N]
|
||||
|
||||
--- super-underline ---
|
||||
#set underline(stroke: 0.5pt, offset: 0.15em)
|
||||
#underline[The claim#super[\[4\]]] has been disputed. \
|
||||
The claim#super[#underline[\[4\]]] has been disputed. \
|
||||
It really has been#super(box(text(baseline: 0pt, underline[\[4\]]))) \
|
||||
#set super(typographic: false)
|
||||
#underline[A#super[4]] B \
|
||||
A#super[#underline[4]] B \
|
||||
A #underline(super[4]) B \
|
||||
#set super(typographic: true)
|
||||
#underline[A#super[4]] B \
|
||||
A#super[#underline[4]] B \
|
||||
A #underline(super[4]) B
|
||||
|
||||
--- super-highlight ---
|
||||
#set super(typographic: false)
|
||||
#highlight[A#super[4]] B \
|
||||
A#super[#highlight[4]] B \
|
||||
A#super(highlight[4]) \
|
||||
#set super(typographic: true)
|
||||
#highlight[A#super[4]] B \
|
||||
A#super[#highlight[4]] B \
|
||||
A#super(highlight[4])
|
||||
|
||||
--- super-1em ---
|
||||
#set text(size: 10pt)
|
||||
#super(context test(1em.to-absolute(), 10pt))
|
||||
|
||||
--- long-scripts ---
|
||||
|longscript| \
|
||||
|#super(typographic: true)[longscript]| \
|
||||
|#super(typographic: false)[longscript]| \
|
||||
|#sub(typographic: true)[longscript]| \
|
||||
|#sub(typographic: false)[longscript]|
|
||||
|
||||
--- script-metrics-bundeled-fonts ---
|
||||
// Tests whether the script metrics are used properly by synthesizing
|
||||
// superscripts and subscripts for all bundled fonts.
|
||||
|
||||
#set super(typographic: false)
|
||||
#set sub(typographic: false)
|
||||
|
||||
#let test(font, weights, styles) = {
|
||||
for weight in weights {
|
||||
for style in styles {
|
||||
text(font: font, weight: weight, style: style)[Xx#super[Xx]#sub[Xx]]
|
||||
linebreak()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#test("DejaVu Sans Mono", ("regular", "bold"), ("normal", "oblique"))
|
||||
#test("Libertinus Serif", ("regular", "semibold", "bold"), ("normal", "italic"))
|
||||
#test("New Computer Modern", ("regular", "bold"), ("normal", "italic"))
|
||||
#test("New Computer Modern Math", (400, 450, "bold"), ("normal",))
|
||||
|
||||
--- basic-sup-sub html ---
|
||||
1#super[st], 2#super[nd], 3#super[rd].
|
||||
|
||||
@ -666,3 +666,29 @@ $ A = mat(
|
||||
#let _ = gradient.linear(..my-gradient.stops())
|
||||
#let my-gradient2 = gradient.linear(red, blue).repeat(5, mirror: true)
|
||||
#let _ = gradient.linear(..my-gradient2.stops())
|
||||
|
||||
--- issue-6162-coincident-gradient-stops-export-png ---
|
||||
// Ensure that multiple gradient stops with the same position
|
||||
// don't cause a panic.
|
||||
#rect(
|
||||
fill: gradient.linear(
|
||||
(red, 0%),
|
||||
(green, 0%),
|
||||
(blue, 100%),
|
||||
)
|
||||
)
|
||||
#rect(
|
||||
fill: gradient.linear(
|
||||
(red, 0%),
|
||||
(green, 100%),
|
||||
(blue, 100%),
|
||||
)
|
||||
)
|
||||
#rect(
|
||||
fill: gradient.linear(
|
||||
(white, 0%),
|
||||
(red, 50%),
|
||||
(green, 50%),
|
||||
(blue, 100%),
|
||||
)
|
||||
)
|
||||
|
||||
@ -94,9 +94,12 @@
|
||||
"watch": "tsc -watch -p ./"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "18.x",
|
||||
"@types/vscode": "^1.88.0",
|
||||
"typescript": "^5.3.3"
|
||||
"@types/node": "^24.0.4",
|
||||
"@types/vscode": "^1.101.0",
|
||||
"typescript": "^5.8.3"
|
||||
},
|
||||
"dependencies": {
|
||||
"shiki": "^3.7.0"
|
||||
},
|
||||
"engines": {
|
||||
"vscode": "^1.88.0"
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
import * as vscode from "vscode";
|
||||
import * as cp from "child_process";
|
||||
import { clearInterval } from "timers";
|
||||
const shiki = import("shiki"); // Normal import causes TypeScript problems.
|
||||
|
||||
// Called when an activation event is triggered. Our activation event is the
|
||||
// presence of "tests/suite/playground.typ".
|
||||
@ -17,6 +18,8 @@ class TestHelper {
|
||||
opened?: {
|
||||
// The tests's name.
|
||||
name: string;
|
||||
// The test's attributes.
|
||||
attrs: string[];
|
||||
// The WebView panel that displays the test images and output.
|
||||
panel: vscode.WebviewPanel;
|
||||
};
|
||||
@ -44,18 +47,18 @@ class TestHelper {
|
||||
);
|
||||
|
||||
// Triggered when clicking "View" in the lens.
|
||||
this.registerCommand("typst-test-helper.viewFromLens", (name) =>
|
||||
this.viewFromLens(name)
|
||||
this.registerCommand("typst-test-helper.viewFromLens", (name, attrs) =>
|
||||
this.viewFromLens(name, attrs)
|
||||
);
|
||||
|
||||
// Triggered when clicking "Run" in the lens.
|
||||
this.registerCommand("typst-test-helper.runFromLens", (name) =>
|
||||
this.runFromLens(name)
|
||||
this.registerCommand("typst-test-helper.runFromLens", (name, attrs) =>
|
||||
this.runFromLens(name, attrs)
|
||||
);
|
||||
|
||||
// Triggered when clicking "Save" in the lens.
|
||||
this.registerCommand("typst-test-helper.saveFromLens", (name) =>
|
||||
this.saveFromLens(name)
|
||||
this.registerCommand("typst-test-helper.saveFromLens", (name, attrs) =>
|
||||
this.saveFromLens(name, attrs)
|
||||
);
|
||||
|
||||
// Triggered when clicking "Terminal" in the lens.
|
||||
@ -121,31 +124,32 @@ class TestHelper {
|
||||
const lenses = [];
|
||||
for (let nr = 0; nr < document.lineCount; nr++) {
|
||||
const line = document.lineAt(nr);
|
||||
const re = /^--- ([\d\w-]+)( [\d\w-]+)* ---$/;
|
||||
const re = /^--- ([\d\w-]+)(( [\d\w-]+)*) ---$/;
|
||||
const m = line.text.match(re);
|
||||
if (!m) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const name = m[1];
|
||||
const attrs = m[2].trim().split(" ");
|
||||
lenses.push(
|
||||
new vscode.CodeLens(line.range, {
|
||||
title: "View",
|
||||
tooltip: "View the test output and reference in a new tab",
|
||||
command: "typst-test-helper.viewFromLens",
|
||||
arguments: [name],
|
||||
arguments: [name, attrs],
|
||||
}),
|
||||
new vscode.CodeLens(line.range, {
|
||||
title: "Run",
|
||||
tooltip: "Run the test and view the results in a new tab",
|
||||
command: "typst-test-helper.runFromLens",
|
||||
arguments: [name],
|
||||
arguments: [name, attrs],
|
||||
}),
|
||||
new vscode.CodeLens(line.range, {
|
||||
title: "Save",
|
||||
tooltip: "Run and view the test and save the reference output",
|
||||
command: "typst-test-helper.saveFromLens",
|
||||
arguments: [name],
|
||||
arguments: [name, attrs],
|
||||
}),
|
||||
new vscode.CodeLens(line.range, {
|
||||
title: "Terminal",
|
||||
@ -159,40 +163,49 @@ class TestHelper {
|
||||
}
|
||||
|
||||
// Triggered when clicking "View" in the lens.
|
||||
private viewFromLens(name: string) {
|
||||
if (this.opened?.name == name) {
|
||||
private viewFromLens(name: string, attrs: string[]) {
|
||||
if (
|
||||
this.opened?.name == name &&
|
||||
this.opened.attrs.join(" ") == attrs.join(" ")
|
||||
) {
|
||||
this.opened.panel.reveal();
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.opened) {
|
||||
this.opened.name = name;
|
||||
this.opened.attrs = attrs;
|
||||
this.opened.panel.title = name;
|
||||
} else {
|
||||
const panel = vscode.window.createWebviewPanel(
|
||||
"typst-test-helper.preview",
|
||||
name,
|
||||
vscode.ViewColumn.Beside,
|
||||
{ enableFindWidget: true }
|
||||
{ enableFindWidget: true, enableScripts: true }
|
||||
);
|
||||
|
||||
panel.onDidDispose(() => (this.opened = undefined));
|
||||
panel.webview.onDidReceiveMessage((message) => {
|
||||
if (message.command === "openFile") {
|
||||
vscode.env.openExternal(vscode.Uri.parse(message.uri));
|
||||
}
|
||||
});
|
||||
|
||||
this.opened = { name, panel };
|
||||
this.opened = { name, attrs, panel };
|
||||
}
|
||||
|
||||
this.refreshWebView();
|
||||
}
|
||||
|
||||
// Triggered when clicking "Run" in the lens.
|
||||
private runFromLens(name: string) {
|
||||
this.viewFromLens(name);
|
||||
private runFromLens(name: string, attrs: string[]) {
|
||||
this.viewFromLens(name, attrs);
|
||||
this.runFromPreview();
|
||||
}
|
||||
|
||||
// Triggered when clicking "Run" in the lens.
|
||||
private saveFromLens(name: string) {
|
||||
this.viewFromLens(name);
|
||||
private saveFromLens(name: string, attrs: string[]) {
|
||||
this.viewFromLens(name, attrs);
|
||||
this.saveFromPreview();
|
||||
}
|
||||
|
||||
@ -288,41 +301,37 @@ class TestHelper {
|
||||
private copyImageFilePathFromPreviewContext(webviewSection: string) {
|
||||
if (!this.opened) return;
|
||||
const { name } = this.opened;
|
||||
const { png, ref } = getImageUris(name);
|
||||
switch (webviewSection) {
|
||||
case "png":
|
||||
vscode.env.clipboard.writeText(png.fsPath);
|
||||
break;
|
||||
case "ref":
|
||||
vscode.env.clipboard.writeText(ref.fsPath);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
const [bucket, format] = webviewSection.split("/");
|
||||
vscode.env.clipboard.writeText(
|
||||
getUri(name, bucket as Bucket, format as Format).fsPath
|
||||
);
|
||||
}
|
||||
|
||||
// Reloads the web view.
|
||||
private refreshWebView(output?: { stdout: string; stderr: string }) {
|
||||
if (!this.opened) return;
|
||||
|
||||
const { name, panel } = this.opened;
|
||||
const { png, ref } = getImageUris(name);
|
||||
const { name, attrs, panel } = this.opened;
|
||||
|
||||
if (panel) {
|
||||
console.log(
|
||||
`Refreshing WebView for ${name}` + (panel.visible ? " in background" : ""));
|
||||
const webViewSrcs = {
|
||||
png: panel.webview.asWebviewUri(png),
|
||||
ref: panel.webview.asWebviewUri(ref),
|
||||
};
|
||||
`Refreshing WebView for ${name}` +
|
||||
(panel.visible ? " in background" : "")
|
||||
);
|
||||
|
||||
panel.webview.html = "";
|
||||
|
||||
// Make refresh notable.
|
||||
setTimeout(() => {
|
||||
setTimeout(async () => {
|
||||
if (!panel) {
|
||||
throw new Error("panel to refresh is falsy after waiting");
|
||||
}
|
||||
panel.webview.html = getWebviewContent(webViewSrcs, output);
|
||||
panel.webview.html = await getWebviewContent(
|
||||
panel,
|
||||
name,
|
||||
attrs,
|
||||
output
|
||||
);
|
||||
}, 50);
|
||||
}
|
||||
}
|
||||
@ -386,30 +395,43 @@ function getWorkspaceRoot() {
|
||||
return vscode.workspace.workspaceFolders![0].uri;
|
||||
}
|
||||
|
||||
// Returns the URIs for a test's images.
|
||||
function getImageUris(name: string) {
|
||||
const root = getWorkspaceRoot();
|
||||
const png = vscode.Uri.joinPath(root, `tests/store/render/${name}.png`);
|
||||
const ref = vscode.Uri.joinPath(root, `tests/ref/${name}.png`);
|
||||
return { png, ref };
|
||||
const EXTENSION = { html: "html", render: "png" };
|
||||
|
||||
type Bucket = "store" | "ref";
|
||||
type Format = "html" | "render";
|
||||
|
||||
function getUri(name: string, bucket: Bucket, format: Format) {
|
||||
let path;
|
||||
if (bucket === "ref" && format === "render") {
|
||||
path = `tests/ref/${name}.png`;
|
||||
} else {
|
||||
path = `tests/${bucket}/${format}/${name}.${EXTENSION[format]}`;
|
||||
}
|
||||
return vscode.Uri.joinPath(getWorkspaceRoot(), path);
|
||||
}
|
||||
|
||||
// Produces the content of the WebView.
|
||||
function getWebviewContent(
|
||||
webViewSrcs: { png: vscode.Uri; ref: vscode.Uri },
|
||||
async function getWebviewContent(
|
||||
panel: vscode.WebviewPanel,
|
||||
name: string,
|
||||
attrs: string[],
|
||||
output?: {
|
||||
stdout: string;
|
||||
stderr: string;
|
||||
}
|
||||
): string {
|
||||
const escape = (text: string) =>
|
||||
text.replace(/</g, "<").replace(/>/g, ">");
|
||||
): Promise<string> {
|
||||
const showHtml = attrs.includes("html");
|
||||
const showRender = !showHtml || attrs.includes("render");
|
||||
|
||||
const stdoutHtml = output?.stdout
|
||||
? `<h1>Standard output</h1><pre>${escape(output.stdout)}</pre>`
|
||||
const stdout = output?.stdout
|
||||
? `<h2>Standard output</h2><pre class="output">${escape(
|
||||
output.stdout
|
||||
)}</pre>`
|
||||
: "";
|
||||
const stderrHtml = output?.stderr
|
||||
? `<h1>Standard error</h1><pre>${escape(output.stderr)}</pre>`
|
||||
const stderr = output?.stderr
|
||||
? `<h2>Standard error</h2><pre class="output">${escape(
|
||||
output.stderr
|
||||
)}</pre>`
|
||||
: "";
|
||||
|
||||
return `
|
||||
@ -449,46 +471,169 @@ function getWebviewContent(
|
||||
color: #bebebe;
|
||||
content: "Not present";
|
||||
}
|
||||
pre {
|
||||
display: inline-block;
|
||||
font-family: var(--vscode-editor-font-family);
|
||||
text-align: left;
|
||||
width: 80%;
|
||||
h2 {
|
||||
margin-bottom: 12px;
|
||||
}
|
||||
h2 a {
|
||||
color: var(--vscode-editor-foreground);
|
||||
text-decoration: underline;
|
||||
}
|
||||
h2 a:hover {
|
||||
cursor: pointer;
|
||||
}
|
||||
.flex {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
justify-content: center;
|
||||
}
|
||||
.vertical {
|
||||
flex-direction: column;
|
||||
}
|
||||
.top-bottom {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
padding-inline: 32px;
|
||||
width: calc(100vw - 64px);
|
||||
}
|
||||
pre {
|
||||
font-family: var(--vscode-editor-font-family);
|
||||
text-align: left;
|
||||
white-space: pre-wrap;
|
||||
}
|
||||
pre.output {
|
||||
display: inline-block;
|
||||
width: 80%;
|
||||
margin-block-start: 0;
|
||||
}
|
||||
pre.shiki {
|
||||
background-color: transparent !important;
|
||||
padding: 12px;
|
||||
margin-block-start: 0;
|
||||
}
|
||||
pre.shiki code {
|
||||
--vscode-textPreformat-background: transparent;
|
||||
}
|
||||
iframe, pre.shiki {
|
||||
border: 1px solid rgb(189, 191, 204);
|
||||
border-radius: 6px;
|
||||
}
|
||||
iframe {
|
||||
background: white;
|
||||
}
|
||||
.vscode-dark iframe {
|
||||
filter: invert(1) hue-rotate(180deg);
|
||||
}
|
||||
</style>
|
||||
<script>
|
||||
const api = acquireVsCodeApi()
|
||||
function openFile(uri) {
|
||||
api.postMessage({ command: 'openFile', uri });
|
||||
}
|
||||
function sizeIframe(obj){
|
||||
obj.style.height = 0;
|
||||
obj.style.height = obj.contentWindow.document.body.scrollHeight + 'px';
|
||||
}
|
||||
</script>
|
||||
</head>
|
||||
<body>
|
||||
<div
|
||||
class="flex"
|
||||
data-vscode-context='{"preventDefaultContextMenuItems": true}'
|
||||
>
|
||||
<div>
|
||||
<h1>Output</h1>
|
||||
<img
|
||||
class="output"
|
||||
data-vscode-context='{"webviewSection":"png"}'
|
||||
src="${webViewSrcs.png}"
|
||||
alt="Placeholder"
|
||||
>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<h1>Reference</h1>
|
||||
<img
|
||||
class="ref"
|
||||
data-vscode-context='{"webviewSection":"ref"}'
|
||||
src="${webViewSrcs.ref}"
|
||||
alt="Placeholder"
|
||||
>
|
||||
</div>
|
||||
</div>
|
||||
${stdoutHtml}
|
||||
${stderrHtml}
|
||||
${showRender ? renderSection(panel, name) : ""}
|
||||
${showHtml ? await htmlSection(name) : ""}
|
||||
${stdout}
|
||||
${stderr}
|
||||
</body>
|
||||
</html>`;
|
||||
}
|
||||
|
||||
function renderSection(panel: vscode.WebviewPanel, name: string) {
|
||||
const outputUri = getUri(name, "store", "render");
|
||||
const refUri = getUri(name, "ref", "render");
|
||||
return `<div
|
||||
class="flex"
|
||||
data-vscode-context='{"preventDefaultContextMenuItems": true}'
|
||||
>
|
||||
<div>
|
||||
${linkedTitle("Output", outputUri)}
|
||||
<img
|
||||
class="output"
|
||||
data-vscode-context='{"bucket":"store", format: "render"}'
|
||||
src="${panel.webview.asWebviewUri(outputUri)}"
|
||||
alt="Placeholder"
|
||||
>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
${linkedTitle("Reference", refUri)}
|
||||
<img
|
||||
class="ref"
|
||||
data-vscode-context='{"bucket":"ref", format: "render"}'
|
||||
src="${panel.webview.asWebviewUri(refUri)}"
|
||||
alt="Placeholder"
|
||||
>
|
||||
</div>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
async function htmlSection(name: string) {
|
||||
const storeHtml = await htmlSnippet(
|
||||
"HTML Output",
|
||||
getUri(name, "store", "html")
|
||||
);
|
||||
const refHtml = await htmlSnippet(
|
||||
"HTML Reference",
|
||||
getUri(name, "ref", "html")
|
||||
);
|
||||
return `<div
|
||||
class="flex vertical"
|
||||
data-vscode-context='{"preventDefaultContextMenuItems": true}'
|
||||
>
|
||||
${storeHtml}
|
||||
${refHtml}
|
||||
</div>`;
|
||||
}
|
||||
|
||||
async function htmlSnippet(title: string, uri: vscode.Uri): Promise<string> {
|
||||
try {
|
||||
const data = await vscode.workspace.fs.readFile(uri);
|
||||
const code = new TextDecoder("utf-8").decode(data);
|
||||
return `<div>
|
||||
${linkedTitle(title, uri)}
|
||||
<div class="top-bottom">
|
||||
${await highlight(code)}
|
||||
<iframe srcdoc="${escape(code)}"></iframe>
|
||||
</div>
|
||||
</div>`;
|
||||
} catch {
|
||||
return `<div><h2>${title}</h2>Not present</div>`;
|
||||
}
|
||||
}
|
||||
|
||||
function linkedTitle(title: string, uri: vscode.Uri) {
|
||||
return `<h2><a onclick="openFile('${uri.toString()}')">${title}</a></h2>`;
|
||||
}
|
||||
|
||||
async function highlight(code: string): Promise<string> {
|
||||
return (await shiki).codeToHtml(code, {
|
||||
lang: "html",
|
||||
theme: selectTheme(),
|
||||
});
|
||||
}
|
||||
|
||||
function selectTheme() {
|
||||
switch (vscode.window.activeColorTheme.kind) {
|
||||
case vscode.ColorThemeKind.Light:
|
||||
case vscode.ColorThemeKind.HighContrastLight:
|
||||
return "github-light";
|
||||
case vscode.ColorThemeKind.Dark:
|
||||
case vscode.ColorThemeKind.HighContrast:
|
||||
return "github-dark";
|
||||
}
|
||||
}
|
||||
|
||||
function escape(text: string) {
|
||||
return text
|
||||
.replace(/&/g, "&")
|
||||
.replace(/</g, "<")
|
||||
.replace(/>/g, ">")
|
||||
.replace(/"/g, """)
|
||||
.replace(/'/g, "'");
|
||||
}
|
||||
|
||||
@ -1,9 +1,10 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"module": "Node16",
|
||||
"module": "nodenext",
|
||||
"lib": ["ES2022", "DOM"],
|
||||
"target": "ES2022",
|
||||
"moduleResolution": "nodenext",
|
||||
"outDir": "dist",
|
||||
"lib": ["ES2022"],
|
||||
"sourceMap": true,
|
||||
"rootDir": "src",
|
||||
"strict": true
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user