Skill dekket over kjelleren fra dekket på bakken

Et dekke like under gulvet i første etasje er himlingen over kjelleren, også når det heter
noe med «kjellergulv»; det er et vanlig navn på dekket over kjelleren. Bare navn som sier
«på grunn» eller «on grade» gir dekke mot grunnen, ellers avgjør høyden: nederste dekke
ligger mot grunnen, resten er etasjeskillere inne i bygningen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015GeH3y8fwTaTudaD88P57o

Cargo.lock

@@ -222,7 +222,7 @@ dependencies = [
 
 [[package]]
 name = "enok"
-version = "0.4.1"
+version = "0.4.5"
 dependencies = [
  "anyhow",
  "approx",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "enok"
-version = "0.4.1"
+version = "0.4.5"
 edition = "2021"
 description = "Årlig energiberegning og energirapport for boliger etter NS 3031 (timesmetode, ISO 52016-1)"
 license = "MIT"

README.md

@@ -180,6 +180,16 @@ navn = "Nye vinduer"
 endringer.vindu = [{ navn = "Vinduer sør", u_verdi = 0.80, g_verdi = 0.50 }]
 ```
 
+Rapporten kan følge husets eller firmaets egne dokumenter:
+
+```toml
+[rapport]
+logo = "logo.svg"                 # vises øverst på forsiden
+farge = "#880000"                 # aksentfarge i overskrifter og tabeller
+avsender = "Firma · Adresse · Org.nr. 000 000 000"
+skrift_overskrift = "Futura Now Headline"
+```
+
 Scenarier flettes inn i bygningsbeskrivelsen: tabeller flettes rekursivt, elementer i lister
 matches på `navn` eller `type`, nye elementer legges til, og `slett = true` fjerner et element.
 Et navn med `*` treffer alle elementer det passer på, for eksempel `navn = "Yttervegg*"`.
@@ -310,6 +320,19 @@ Mangler en bygningsdel U-verdi i modellen, sier importen hvilke det gjelder, og
 bruker en typisk verdi for byggeåret. Det gjelder også vinduer og dører, som i de fleste
 eksportene ikke har U-verdi.
 
+Importen tåler noen vanlige feil i eksporten:
+
+- **Deler som ligger dobbelt.** Legger eksporten den samme veggen eller det samme dekket i
+  flere etasjer, telles den én gang. Av kopiene brukes den som hører til den etasjen høyden
+  tilsier, og vinduene i de andre finner fortsatt veggen sin.
+- **Feil etasje.** Hva som er gulv mot grunnen, dekke over kjelleren eller etasjeskiller inne
+  i bygningen, avgjøres av høyden geometrien har, ikke av hvilken etasje delen er lagt i.
+- **Terrengmodell utenfor bakkenivå.** Ligger terrenget over gulvet i første etasje, brukes
+  det ikke, og importen sier fra. Oppgi da `over_terreng` på kjellerveggene.
+
+Importen sier også hvilke deler som ikke er regnet med i klimaskjermen, som innervegger og
+etasjeskillere, slik at det er lett å se om noe mangler.
+
 Med de åtte feltene på plass er importen fra IFC nær nok komplett til at beregningen står på
 modellen alene.
 
@@ -382,7 +405,7 @@ jobs:
             "$GITHUB_SERVER_URL/klingenbergbygg/enok/releases/download/$TAG/enok"
           chmod +x enok
           ./enok import modell.ifc --tillegg prosjekt.toml --ut bygning.toml
-      - uses: https://gitea.com/actions/upload-artifact@v4
+      - uses: https://gitea.com/actions/upload-artifact@v3
         with:
           name: bygningsmodell
           path: |
@@ -396,7 +419,7 @@ jobs:
         shell: fish {0}
     steps:
       - uses: https://gitea.com/actions/checkout@v6
-      - uses: https://gitea.com/actions/download-artifact@v4
+      - uses: https://gitea.com/actions/download-artifact@v3
         with:
           name: bygningsmodell
       - name: Lag rapporten

src/inndata/gbxml.rs

@@ -596,6 +596,7 @@ fn bygg(
         lufting: Lufting::default(),
         drift: Drift::default(),
         scenario: Vec::new(),
+        rapport: Rapport::default(),
     };
     Ok(Importrapport { bygning, merknader })
 }

src/inndata/ifc.rs

@@ -286,6 +286,7 @@ pub fn fra_tekst_med(tekst: &str, standardnavn: &str, valg: &Importvalg) -> Resu
     // Den laveste etasjen over terreng, der etasjeskilleren mot kjelleren ligger.
     let forste_over = etasjer.iter().position(|e| !e.under_terreng);
     // Terrenghøyden på IfcBuilding sier hvor mye av grunnmuren som står over bakken.
+    let terrengmodell = terrengpunkter(&fil, skala);
     let terreng = terrenghoyder(&fil, skala);
     // Ligger terrengmodellen over gulvet i første etasje, er den ikke lagt i bakkenivå, og da
     // sier den ingenting om hvor mye av grunnmuren som er nedgravd.
@@ -308,6 +309,7 @@ pub fn fra_tekst_med(tekst: &str, standardnavn: &str, valg: &Importvalg) -> Resu
     let mut utelatt: Vec<(String, f64, Option<f64>)> = Vec::new();
     let mut uten_uverdi: Vec<String> = Vec::new();
     let mut uten_geometri = 0usize;
+    let mut grunnmurshoyder: Vec<f64> = Vec::new();
     let mut asimut_for_vegg: HashMap<u64, f64> = HashMap::new();
 
     // Laveste etasje og laveste gulvnivå skiller dekke mot grunn fra etasjeskillere.
@@ -359,6 +361,16 @@ pub fn fra_tekst_med(tekst: &str, standardnavn: &str, valg: &Importvalg) -> Resu
         if d.u_verdi.is_none() {
             uten_uverdi.push(d.navn.clone());
         }
+        // Terrengmodellen sier hvor høyt bakken ligger akkurat der denne veggen står, så en
+        // skrånende tomt gir forskjellig høyde over bakken på hver side av huset.
+        let over_bakken = d
+            .plass
+            .and_then(|(x, y, _, _, _)| terreng_ved(&terrengmodell, x, y))
+            .map(|z| (etasjekontekst.forste_over_hoyde.unwrap_or(0.0) - z).clamp(0.0, kjellerdybde))
+            .unwrap_or(kjeller_over_terreng);
+        if i_kjeller && mot == Mot::Grunn {
+            grunnmurshoyder.push(over_bakken);
+        }
         let mal = if i_kjeller {
             &mut kjellerflater
         } else {
@@ -378,8 +390,8 @@ pub fn fra_tekst_med(tekst: &str, standardnavn: &str, valg: &Importvalg) -> Resu
             b_faktor: None,
             absorptans: None,
             omkrets: None,
-            dybde: (i_kjeller && mot == Mot::Grunn).then_some(kjellerdybde - kjeller_over_terreng),
-            over_terreng: (i_kjeller && mot == Mot::Grunn).then_some(kjeller_over_terreng),
+            dybde: (i_kjeller && mot == Mot::Grunn).then_some(kjellerdybde - over_bakken),
+            over_terreng: (i_kjeller && mot == Mot::Grunn).then_some(over_bakken),
             sone,
             kommentar: d
                 .etasje
@@ -693,7 +705,21 @@ pub fn fra_tekst_med(tekst: &str, standardnavn: &str, valg: &Importvalg) -> Resu
                     rom.join(", ")
                 )),
             });
-            let grunnmur = if terreng_over_gulvet {
+            let grunnmur = if !grunnmurshoyder.is_empty() && !terrengmodell.is_empty() {
+                let laveste = grunnmurshoyder
+                    .iter()
+                    .copied()
+                    .fold(f64::INFINITY, f64::min);
+                let hoyeste = grunnmurshoyder
+                    .iter()
+                    .copied()
+                    .fold(f64::NEG_INFINITY, f64::max);
+                let snitt = grunnmurshoyder.iter().sum::<f64>() / grunnmurshoyder.len() as f64;
+                format!(
+                    "Terrengmodellen i filen gir hver kjellervegg sin egen høyde over bakken: \
+                     {laveste:.2}–{hoyeste:.2} m, i snitt {snitt:.2} m. Resten av veggen er regnet nedgravd."
+                )
+            } else if terreng_over_gulvet {
                 format!(
                     "Terrengmodellen ligger over gulvet i første etasje, så den er ikke brukt. \
                      Kjellerveggene er regnet {kjellerdybde:.1} m under terreng uten noe over. Legg \
@@ -833,6 +859,7 @@ pub fn fra_tekst_med(tekst: &str, standardnavn: &str, valg: &Importvalg) -> Resu
         lufting: Lufting::default(),
         drift: Drift::default(),
         scenario: Vec::new(),
+        rapport: Rapport::default(),
     };
     Ok(Importrapport {
         bygning,
@@ -1223,6 +1250,45 @@ fn terrenghoyder(fil: &Fil, skala: f64) -> Option<(f64, f64)> {
     Some((referanse, terreng))
 }
 
+/// Punktene i terrengmodellen, i byggets koordinater, m.
+///
+/// Vectorworks legger terrenget som et `IfcGeographicElement` med typen TERRAIN, eller på
+/// tomta. Punktene brukes til å finne bakkenivået ved hver enkelt kjellervegg.
+fn terrengpunkter(fil: &Fil, skala: f64) -> Vec<[f64; 3]> {
+    let mut ut = Vec::new();
+    for (_, e) in fil
+        .av_type("IFCGEOGRAPHICELEMENT")
+        .chain(fil.av_type("IFCSITE"))
+    {
+        let (px, py, pz) = e
+            .arg(5)
+            .and_then(|a| a.som_ref())
+            .and_then(|p| global_plassering(fil, p, skala))
+            .map(|(x, y, z, _, _)| (x, y, z))
+            .unwrap_or((0.0, 0.0, 0.0));
+        for nett in ifcgeom::netter_for_produkt(fil, e.arg(6).and_then(|a| a.som_ref())) {
+            for p in &nett.punkter {
+                ut.push([p[0] * skala + px, p[1] * skala + py, p[2] * skala + pz]);
+            }
+        }
+    }
+    ut
+}
+
+/// Bakkenivået ved et punkt, som snittet av de nærmeste punktene i terrengmodellen, m.
+fn terreng_ved(punkter: &[[f64; 3]], x: f64, y: f64) -> Option<f64> {
+    if punkter.is_empty() {
+        return None;
+    }
+    let mut avstand: Vec<(f64, f64)> = punkter
+        .iter()
+        .map(|p| ((p[0] - x).powi(2) + (p[1] - y).powi(2), p[2]))
+        .collect();
+    avstand.sort_by(|a, b| a.0.total_cmp(&b.0));
+    let antall = avstand.len().min(8);
+    Some(avstand[..antall].iter().map(|(_, z)| z).sum::<f64>() / antall as f64)
+}
+
 /// Hvor mye av grunnmuren som står over bakken, m.
 ///
 /// Toppen av grunnmuren ligger ved gulvet i første etasje over kjelleren. Den står over
@@ -1438,20 +1504,15 @@ fn klassifiser(
         if d.ytre == Some(true) {
             return Some((FlateType::Gulv, Mot::Ute));
         }
-        // Mot grunnen i det nederste planet, eller når navnet sier det. Høyden av geometrien
-        // avgjør, siden etasjetilknytningen i en eksport kan være feil.
-        let paa_grunnen = [
-            "kjellergulv",
-            "on grade",
-            "på grunn",
-            "paa grunn",
-            "såle",
-            "sale",
-        ];
-        if (d.z - laveste).abs() < 0.5 || paa_grunnen.iter().any(|o| navn.contains(o)) {
+        // Høyden av geometrien avgjør, siden etasjetilknytningen i en eksport kan være feil.
+        // Et dekke som ligger på bakken sier det i navnet. Ellers er et dekke like under
+        // gulvet i første etasje himlingen over kjelleren, og det nederste dekket ligger mot
+        // grunnen. «Kjellergulv» er ikke nok til å si at dekket ligger på bakken: dekket over
+        // kjelleren bærer ofte det samme navnet.
+        let paa_grunnen = ["on grade", "på grunn", "paa grunn", "såle", "sale"];
+        if paa_grunnen.iter().any(|o| navn.contains(o)) {
             return Some((FlateType::Gulv, Mot::Grunn));
         }
-        // Dekket i laveste etasje over en kjeller er grensen mot den uoppvarmede sonen.
         if e.kjeller.is_some() {
             let ved_forste_over = e
                 .forste_over_hoyde
@@ -1461,6 +1522,9 @@ fn klassifiser(
                 return Some((FlateType::Gulv, Mot::Uoppvarmet));
             }
         }
+        if (d.z - laveste).abs() < 0.5 {
+            return Some((FlateType::Gulv, Mot::Grunn));
+        }
         // Dekker lenger opp er etasjeskillere inne i bygningen.
         return None;
     }
@@ -2094,6 +2158,20 @@ mod tester {
         assert!(r.merknader.iter().any(|m| m.contains("standardplassering")));
     }
 
+    #[test]
+    fn terrenget_leses_av_de_naermeste_punktene() {
+        // Et terreng som faller mot øst: bakken er høyere ved vestveggen enn ved østveggen.
+        let punkter: Vec<[f64; 3]> = (0..10)
+            .flat_map(|i| (0..10).map(move |j| [i as f64, j as f64, -1.0 - 0.2 * i as f64]))
+            .collect();
+        let vest = terreng_ved(&punkter, 0.5, 5.0).unwrap();
+        let ost = terreng_ved(&punkter, 8.5, 5.0).unwrap();
+        assert!(vest > ost, "vest {vest}, øst {ost}");
+        assert!((vest + 1.1).abs() < 0.2, "vest {vest}");
+        assert!((ost + 2.7).abs() < 0.2, "øst {ost}");
+        assert_eq!(terreng_ved(&[], 0.0, 0.0), None);
+    }
+
     #[test]
     fn grunnmur_over_terreng_av_hoydene() {
         // ±0 ligger 131,2 moh., terrenget 130,6 moh. og første etasje på ±0: 0,6 m over bakken.

src/inndata/regneark.rs

@@ -215,6 +215,7 @@ pub fn fra_tekst(tekst: &str, standardnavn: &str) -> Result<Importrapport> {
         lufting: Lufting::default(),
         drift: Drift::default(),
         scenario: Vec::new(),
+        rapport: Rapport::default(),
     };
     Ok(Importrapport { bygning, merknader })
 }

src/modell/mod.rs

@@ -82,6 +82,26 @@ pub struct Bygning {
     pub drift: Drift,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub scenario: Vec<Scenario>,
+    #[serde(default)]
+    pub rapport: Rapport,
+}
+
+/// Utseendet på rapporten, slik at den kan følge firmaets øvrige dokumenter.
+#[derive(Deserialize, Serialize, Clone, Debug, Default)]
+#[serde(deny_unknown_fields)]
+pub struct Rapport {
+    /// Logo på forsiden. Filen kopieres til utdatakatalogen ved siden av rapporten.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub logo: Option<PathBuf>,
+    /// Aksentfarge, for eksempel «#880000». Utelatt: enoks egen.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub farge: Option<String>,
+    /// Avsenderlinje nederst på hver side, for eksempel firma og organisasjonsnummer.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub avsender: Option<String>,
+    /// Skrift for overskrifter. Utelatt: enoks egen.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skrift_overskrift: Option<String>,
 }
 
 #[derive(Deserialize, Serialize, Clone, Debug)]

src/rapport/typst_ut.rs

@@ -66,6 +66,12 @@ fn rad(celler: &[String]) -> String {
 pub fn skriv(r: &Resultat, katalog: &Path, scenarier: &[(String, Resultat)]) -> Result<()> {
     std::fs::create_dir_all(katalog)?;
     std::fs::write(katalog.join("stil.typ"), STIL)?;
+    // Logoen følger med, slik at rapporten kan kompileres for seg selv senere. Mangler
+    // filen, lages rapporten uten den.
+    if let (Some(logo), Some(navn)) = (&r.bygning.rapport.logo, logo_navn(r)) {
+        std::fs::copy(logo, katalog.join(navn))
+            .with_context(|| format!("kopierer logoen {}", logo.display()))?;
+    }
     std::fs::write(katalog.join("fig-maaned.svg"), svg::maanedsdiagram(r))?;
     std::fs::write(katalog.join("fig-varighet.svg"), svg::varighetskurve(r))?;
     std::fs::write(katalog.join("fig-karakter.svg"), svg::karakterstige(r))?;
@@ -100,15 +106,32 @@ fn kilde(r: &Resultat, scenarier: &[(String, Resultat)]) -> String {
     let mut s = String::new();
 
     s.push_str("#import \"stil.typ\": *\n\n");
-    s.push_str(&format!(
-        "#show: oppsett.with(tittel: \"{} — energirapport\", bunntekst: \"{}\")\n\n",
-        e(&l.navn),
-        e(&bunntekst(r))
-    ));
+    let rap = &r.bygning.rapport;
+    let mut valg = format!(
+        "tittel: \"{} — energirapport\", bunntekst: \"{}\"",
+        streng(&l.navn),
+        streng(&bunntekst(r))
+    );
+    if let Some(a) = &rap.avsender {
+        valg.push_str(&format!(", avsender: \"{}\"", streng(a)));
+    }
+    if let Some(f) = &rap.farge {
+        valg.push_str(&format!(", farge: rgb(\"{}\")", streng(f)));
+    }
+    if let Some(sk) = &rap.skrift_overskrift {
+        valg.push_str(&format!(", skrift: \"{}\"", streng(sk)));
+    }
+    s.push_str(&format!("#show: oppsett.with({valg})\n\n"));
 
     // ── forside ─────────────────────────────────────────────────────
+    if let Some(navn) = logo_navn(r) {
         s.push_str(&format!(
-        "#v(1.2cm)\n#text(size: 26pt, weight: \"bold\")[Energirapport]\n\n\
+            "#align(right, image(\"{}\", height: 1.7cm))\n\n#v(-0.9cm)\n",
+            streng(&navn)
+        ));
+    }
+    s.push_str(&format!(
+        "#v(1.2cm)\n#forsidetittel[Energirapport]\n\n\
          #v(-0.3em)\n#text(size: 15pt, fill: mid)[{}]\n\n",
         e(&l.navn)
     ));
@@ -473,7 +496,8 @@ fn kilde(r: &Resultat, scenarier: &[(String, Resultat)]) -> String {
     if l.forutsetninger.is_empty() {
         s.push_str("Alle inndata er oppgitt i bygningsbeskrivelsen.\n\n");
     } else {
-        s.push_str("#tabell(\n  kolonner: (auto, auto, 1fr),\n  justering: (left, left, left),\n  overskrift: (\"Felt\", \"Verdi\", \"Kilde\"),\n  rader: (\n");
+        // Faste bredder, ellers spiser de to første kolonnene plassen kilden trenger.
+        s.push_str("#tabell(\n  kolonner: (1.15fr, 0.85fr, 1.6fr),\n  justering: (left, left, left),\n  overskrift: (\"Felt\", \"Verdi\", \"Kilde\"),\n  rader: (\n");
         for f in &l.forutsetninger {
             s.push_str(&format!(
                 "    {}\n",
@@ -539,6 +563,24 @@ fn kilde(r: &Resultat, scenarier: &[(String, Resultat)]) -> String {
     s
 }
 
+/// Tekst i en Typst-strengliteral: bare omvendt skråstrek og anførselstegn skal ut.
+fn streng(s: &str) -> String {
+    s.replace('\\', "\\\\").replace('"', "\\\"")
+}
+
+/// Filnavnet på logoen, når den er oppgitt og finnes.
+fn logo_navn(r: &Resultat) -> Option<String> {
+    let logo = r.bygning.rapport.logo.as_ref()?;
+    if !logo.exists() {
+        eprintln!(
+            "  ! rapport.logo: fant ikke {}; rapporten lages uten logo.",
+            logo.display()
+        );
+        return None;
+    }
+    Some(logo.file_name()?.to_str()?.to_string())
+}
+
 fn bunntekst(r: &Resultat) -> String {
     let b = &r.bygning.bygning;
     let mut deler = Vec::new();

typst/stil.typ

@@ -7,11 +7,32 @@
 #let lys         = rgb("#f4f1ee")
 #let kantlinje   = rgb("#ddd4cc")
 
+// Aksentfarge og overskriftsskrift kan settes av rapporten, slik at den kan følge
+// firmaets øvrige dokumenter. Verdiene under er enoks egne.
+#let aksent-valgt = state("aksent-valgt", aksent)
+#let skrift-valgt = state("skrift-valgt", none)
+
 #let font-heading = ("Libertinus Serif", "DejaVu Serif", "Noto Serif")
 #let font-body    = ("Libertinus Serif", "DejaVu Serif", "Noto Serif")
 #let font-tall    = ("DejaVu Sans Mono", "Liberation Mono")
 
-#let oppsett(tittel: "", undertittel: "", bunntekst: "", doc) = {
+/// Skriften rapporten har bedt om, ellers enoks egen.
+#let overskriftsskrift() = {
+  let valgt = skrift-valgt.get()
+  if valgt == none { font-heading } else { (valgt,) + font-heading }
+}
+
+#let oppsett(
+  tittel: "",
+  undertittel: "",
+  bunntekst: "",
+  avsender: "",
+  farge: none,
+  skrift: none,
+  doc,
+) = {
+  aksent-valgt.update(if farge == none { aksent } else { farge })
+  skrift-valgt.update(skrift)
   set page(
     paper: "a4",
     margin: (top: 2.4cm, bottom: 2.4cm, left: 2.2cm, right: 2.2cm),
@@ -20,32 +41,36 @@
         grid(
           columns: (1fr, auto),
           align: (left + horizon, right + horizon),
-          text(font: font-heading, size: 8pt, fill: mid)[#tittel],
+          text(font: overskriftsskrift(), size: 8pt, fill: mid)[#tittel],
           text(font: font-body, size: 8pt, fill: mid)[#counter(page).display()],
         )
         line(length: 100%, stroke: 0.4pt + kantlinje)
       }
     },
     footer: context {
-      if counter(page).get().first() > 1 and bunntekst != "" {
+      if counter(page).get().first() > 1 and (bunntekst != "" or avsender != "") {
         line(length: 100%, stroke: 0.4pt + kantlinje)
         v(3pt)
+        if avsender != "" {
+          text(font: font-body, size: 7.5pt, fill: mid)[#avsender]
+          linebreak()
+        }
         text(font: font-body, size: 7.5pt, fill: mid)[#bunntekst]
       }
     },
   )
   set text(font: font-body, size: 10pt, fill: moerk, lang: "nb")
   set par(justify: true, leading: 0.62em)
-  show heading: it => {
-    set text(font: font-heading, fill: aksent)
+  show heading: it => context {
+    set text(font: overskriftsskrift(), fill: aksent-valgt.get())
     block(above: 1.2em, below: 0.6em, it)
   }
-  show heading.where(level: 1): it => {
+  show heading.where(level: 1): it => context {
     set text(size: 15pt, weight: "bold")
     block(above: 1.6em, below: 0.7em)[
       #it.body
       #v(-0.45em)
-      #line(length: 100%, stroke: 1pt + aksent)
+      #line(length: 100%, stroke: 1pt + aksent-valgt.get())
     ]
   }
   show heading.where(level: 2): set text(size: 11.5pt, weight: "bold")
@@ -55,7 +80,8 @@
 }
 
 // Tabell med stripete rader og linje under overskriften.
-#let tabell(kolonner: (), overskrift: (), rader: (), justering: none, sum-rader: ()) = {
+#let tabell(kolonner: (), overskrift: (), rader: (), justering: none, sum-rader: ()) = context {
+  let aksent = aksent-valgt.get()
   let j = if justering == none { kolonner.map(_ => right) } else { justering }
   block(breakable: true, table(
     columns: kolonner,
@@ -71,6 +97,16 @@
   ))
 }
 
+// Tittelen på forsiden, i samme skrift og farge som overskriftene.
+#let forsidetittel(tekst) = context {
+  text(
+    font: overskriftsskrift(),
+    size: 26pt,
+    weight: "bold",
+    fill: aksent-valgt.get(),
+  )[#tekst]
+}
+
 // Stor karakterrute på forsiden.
 #let karakterrute(bokstav, verdi, farge) = {
   box(
@@ -99,3 +135,4 @@
   stroke: (left: 2pt + aksent-lys),
   text(size: 9pt)[#innhold],
 )
+