@bafif/foja 0.0.0-stage → 0.1.0

package/dist/template/fonts/GUST-FONT-LICENSE.txt

@@ -0,0 +1,29 @@
+% This is version 1.0, dated 22 June 2009, of the GUST Font License.
+% (GUST is the Polish TeX Users Group, https://www.gust.org.pl)
+%
+% For the most recent version of this license see
+% https://www.gust.org.pl/fonts/licenses/GUST-FONT-LICENSE.txt
+% or
+% https://tug.org/fonts/licenses/GUST-FONT-LICENSE.txt
+%
+% This work may be distributed and/or modified under the conditions
+% of the LaTeX Project Public License, either version 1.3c of this
+% license or (at your option) any later version.
+% 
+% Please also observe the following clause:
+% 1) it is requested, but not legally required, that derived works be
+%    distributed only after changing the names of the fonts comprising this
+%    work and given in an accompanying "manifest", and that the
+%    files comprising the Work, as listed in the manifest, also be given
+%    new names. Any exceptions to this request are also given in the
+%    manifest.
+%    
+%    We recommend the manifest be given in a separate file named
+%    MANIFEST-<fontid>.txt, where <fontid> is some unique identification
+%    of the font family. If a separate "readme" file accompanies the Work, 
+%    we recommend a name of the form README-<fontid>.txt.
+%
+% The latest version of the LaTeX Project Public License is in
+% https://www.latex-project.org/lppl.txt and version 1.3c or later
+% is part of all distributions of LaTeX version 2006/05/20 or later.
+

package/dist/template/fonts/NotoSans-LICENSE.txt

@@ -0,0 +1,94 @@
+Noto Sans: Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-greek-cyrillic).
+Subset to Latin (and unhinted) for Foja.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/template/fonts/XCharter-LICENSE.txt

@@ -0,0 +1,14 @@
+Original Bitstream Free font license:
+
+  (c) Copyright 1989-1992, Bitstream Inc., Cambridge, MA.
+
+  You are hereby granted permission under all Bitstream propriety rights
+  to use, copy, modify, sublicense, sell, and redistribute the 4
+  Bitstream Charter (r) Type 1 outline fonts for any purpose and without
+  restriction; provided, that this notice is left intact on all copies
+  of such fonts and that Bitstream's trademark is acknowledged as shown
+  below on all unmodified copies of the 4 Charter Type 1 fonts.
+
+    BITSTREAM CHARTER is a registered trademark of Bitstream Inc.
+
+Portions of the font modifications are Copyright (c) 2009--2012, Andrey Panov; Copyright (c) 2013--2024, Michael Sharpe.

package/dist/template/labels.json

@@ -0,0 +1,86 @@
+{
+  "es": {
+    "profile": "Perfil",
+    "contact": "Contacto",
+    "skills": "Habilidades",
+    "present": "actualidad",
+    "months": [
+      "ene",
+      "feb",
+      "mar",
+      "abr",
+      "may",
+      "jun",
+      "jul",
+      "ago",
+      "sep",
+      "oct",
+      "nov",
+      "dic"
+    ],
+    "contacts": {
+      "phone": "Teléfono",
+      "email": "Correo",
+      "website": "Web",
+      "github": "GitHub",
+      "linkedin": "LinkedIn",
+      "location": "Ubicación"
+    }
+  },
+  "en": {
+    "profile": "Profile",
+    "contact": "Contact",
+    "skills": "Skills",
+    "present": "present",
+    "months": [
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec"
+    ],
+    "contacts": {
+      "phone": "Phone",
+      "email": "Email",
+      "website": "Website",
+      "github": "GitHub",
+      "linkedin": "LinkedIn",
+      "location": "Location"
+    }
+  },
+  "pt": {
+    "profile": "Perfil",
+    "contact": "Contato",
+    "skills": "Competências",
+    "present": "atual",
+    "months": [
+      "jan",
+      "fev",
+      "mar",
+      "abr",
+      "mai",
+      "jun",
+      "jul",
+      "ago",
+      "set",
+      "out",
+      "nov",
+      "dez"
+    ],
+    "contacts": {
+      "phone": "Telefone",
+      "email": "E-mail",
+      "website": "Site",
+      "github": "GitHub",
+      "linkedin": "LinkedIn",
+      "location": "Localização"
+    }
+  }
+}

package/dist/template/lib.typ

@@ -0,0 +1,233 @@
+// Foja's template library. Every CV style, the built-in ones and those people write themselves,
+// is a Typst file that starts with
+//
+//     #import "/lib.typ": *
+//
+// and lays out `cv`, the profile being built, already resolved: entries looked up, dates
+// formatted, labels in the CV's language, contacts with their links. The marks (`anchored`) and
+// the column geometry (`geometry`) are what the editor uses for click-to-edit and the page-fit
+// badge; a style works without them, those two features just do not.
+//
+// Inputs (`sys.inputs`): `project`, path of the project JSON (default `/project.json`), and
+// `profile`, the id of the profile to lay out (default: the first one). The photo is a file under
+// `/assets/`.
+
+#let project = json(sys.inputs.at("project", default: "/project.json"))
+#let profile-id = sys.inputs.at("profile", default: project.profiles.keys().first())
+#let profile = project.profiles.at(profile-id)
+#let layout = profile.at("layout", default: (:))
+
+/// A layout option of the profile, or `default` when it is not set.
+#let opt(key, default) = layout.at(key, default: default)
+
+#let all-labels = json("/labels.json")
+#let lang = project.language.split("-").first()
+/// Fixed words in the CV's language: `labels.profile`, `labels.contact`, `labels.skills`,
+/// `labels.present`, `labels.months`, `labels.contacts.<kind>`.
+#let labels = all-labels.at(opt("labels", lang), default: all-labels.en)
+
+// ---------------------------------------------------------------- text and dates
+
+/// A plain string where `**bold**` spans become strong.
+#let inline(s) = s.split("**").enumerate().map(((i, part)) => if calc.odd(i) { strong(part) } else { part }).join()
+
+/// `2026-05` in the profile's date format: `05/2026`, `may 2026` or `2026`.
+#let month(value) = {
+  // An incomplete date (the editor may store one while it is being typed) shows as is.
+  if type(value) != str or value.split("-").len() != 2 { return if type(value) == str { value } else { "" } }
+  let (year, m) = value.split("-")
+  let format = opt("dateFormat", "MM/YYYY")
+  if format == "YYYY" { year } else if format == "MMM YYYY" { labels.months.at(int(m) - 1) + " " + year } else {
+    m + "/" + year
+  }
+}
+
+/// The period of an entry: `start` alone is a single date, `end: none` means ongoing.
+#let period(e) = {
+  if "start" not in e { return "" }
+  if "end" not in e { return month(e.start) }
+  let start = month(e.start)
+  let end = if e.end == none { labels.present } else { month(e.end) }
+  if start == end { start } else { start + " – " + end }
+}
+
+/// The text of an item, with its heading in bold.
+#let item-body(it) = {
+  if it.at("heading", default: none) != none { strong(it.heading + ".") + " " }
+  inline(it.text)
+}
+
+// ---------------------------------------------------------------- options
+
+/// The accent colour: the profile's, or the style's `default`.
+#let accent(default) = if "accent" in layout { rgb(layout.accent) } else { default }
+/// Body size in points (`fontSize`, default 10).
+#let base-size = opt("fontSize", 10) * 1pt
+/// Spacing factor of the `density` option: 0.7, 1 or 1.3.
+#let density = (compact: 0.7, normal: 1, relaxed: 1.3).at(opt("density", "normal"))
+/// Page size of the `paper` option.
+#let paper = if opt("paper", "a4") == "a4" { (width: 210mm, height: 297mm) } else { (width: 215.9mm, height: 279.4mm) }
+/// The margins: the profile's (in mm), each falling back to the style's `default` (also in mm).
+#let margins(default) = {
+  let m = layout.at("margins", default: (:))
+  (
+    top: m.at("top", default: default.top) * 1mm,
+    bottom: m.at("bottom", default: default.bottom) * 1mm,
+    left: m.at("left", default: default.left) * 1mm,
+    right: m.at("right", default: default.right) * 1mm,
+  )
+}
+
+// ---------------------------------------------------------------- marks for the editor
+
+/// An invisible marker; `anchored` puts one at each end of a part.
+#let mark(path, kind, column) = context [#metadata((
+  path: path,
+  kind: kind,
+  column: column,
+  page: here().page(),
+  x: here().position().x.pt(),
+  y: here().position().y.pt(),
+))<foja>]
+
+/// `body`, marked as the part at `path` (e.g. `cv.sections.at(0).path`) in `column` ("main" or
+/// "side"), so that a click on it in the editor opens that part.
+#let anchored(path, body, column: "main") = {
+  mark(path, "start", column)
+  body
+  mark(path, "end", column)
+}
+
+/// Declares where the columns are on the page (from the left edge), for the editor to know the
+/// width of a marked part: `geometry(main: (x: 200pt, width: 360pt), side: (x: 34pt, width: 150pt))`.
+#let geometry(main: none, side: none) = {
+  let pt(c) = if c == none { none } else { (x: c.x.pt(), width: c.width.pt()) }
+  [#metadata((main: pt(main), side: pt(side)))<foja-geometry>]
+}
+
+// ---------------------------------------------------------------- what of the bank goes in
+
+// The same rules as packages/core/src/select.ts, which the other exports use: keep both in step.
+// Each entry, item and skill has a priority (`essential`, `normal`, `extra`); the profile's length
+// says which go in, and its overrides make the exceptions.
+
+#let length = opt("length", "normal")
+#let shown-priorities = (short: ("essential",), normal: ("essential", "normal"), full: ("essential", "normal", "extra")).at(
+  length,
+  default: ("essential", "normal"),
+)
+#let overrides = profile.at("overrides", default: (:))
+
+/// Whether the thing of the bank at `key` (`entries/<id>`, `entries/<id>/items/<id>` or
+/// `skills/<group>/<id>`) goes in the profile: its override, or the length rule.
+#let shown(key, thing) = {
+  let override = overrides.at(key, default: none)
+  if type(override) == bool { override } else { thing.at("priority", default: "normal") in shown-priorities }
+}
+#let block-shown(b) = b.type != "entry" or shown("entries/" + b.entry, project.entries.at(b.entry))
+#let summary-short = profile.at("summaryShort", default: "")
+#let uses-short-summary = (
+  opt("summaryLength", if length == "short" { "short" } else { "long" }) == "short" and summary-short.trim() != ""
+)
+
+// ---------------------------------------------------------------- the CV, resolved
+
+#let link-for(kind, value) = {
+  if kind == "email" { "mailto:" + value } else if kind in ("website", "github", "linkedin") {
+    if value.starts-with("http") { value } else { "https://" + value }
+  } else { none }
+}
+
+/// Everything a style lays out:
+/// - `name`, `given`, `family`, `subtitle`, `summary` (may be ""), `highlight` (`(title, text)` or none);
+/// - `photo` (a path for `image`, or none) and `photo-shape` ("square", "rounded", "circle");
+/// - `contacts`: array of `(kind, label, value, link)` (`link` is none for phone and location);
+/// - `skills`: rows of groups `(title, items)`; a row with several groups goes side by side;
+/// - `sections`: array of `(index, path, id, title, side, compact, blocks)`; `side` is true for
+///   sections meant for a sidebar; each block is either
+///   `(type: "entry", path, id, title, place, period, note, items)` or
+///   `(type: "item" | "paragraph", path, heading, text)`.
+#let cv = {
+  let person = project.person
+  let photo-name = person.at("photo", default: none)
+  (
+    name: (person.givenNames + person.familyNames).join(" "),
+    given: person.givenNames.join(" "),
+    family: person.familyNames.join(" "),
+    subtitle: profile.subtitle,
+    summary: if uses-short-summary { summary-short } else { profile.summary },
+    highlight: profile.at("highlight", default: none),
+    photo: if photo-name == none or opt("photo", "square") == "none" { none } else { "/assets/" + photo-name },
+    photo-shape: opt("photo", "square"),
+    contacts: profile
+      .contacts
+      .filter(k => k in project.contacts)
+      .map(k => (kind: k, label: labels.contacts.at(k), value: project.contacts.at(k), link: link-for(k, project.contacts.at(k)))),
+    skills: profile
+      .skills
+      .map(row => row
+        .filter(id => id in project.skills)
+        .map(id => (id: id, group: project.skills.at(id)))
+        // A group the selection emptied goes away; one that was empty stays.
+        .filter(((id, group)) => group.items.len() == 0 or group.items.any(s => shown("skills/" + id + "/" + s.id, s)))
+        .map(((id, group)) => (
+          title: group.title,
+          items: group.items.filter(s => shown("skills/" + id + "/" + s.id, s)).map(s => s.text),
+        )))
+      .filter(row => row.len() > 0),
+    sections: profile
+      .sections
+      .enumerate()
+      // A section the selection emptied goes away; one that was empty stays. `index` and `path`
+      // keep the section's place in the profile, as the blocks' paths keep theirs.
+      .filter(((i, s)) => s.blocks.len() == 0 or s.blocks.any(block-shown))
+      .map(((i, s)) => (
+        index: i,
+        path: "sections." + str(i),
+        id: s.id,
+        title: s.title,
+        side: s.at("column", default: "main") == "side",
+        compact: s.at("compact", default: false),
+        blocks: s
+          .blocks
+          .enumerate()
+          .filter(((j, b)) => block-shown(b))
+          .map(((j, b)) => {
+            let path = "sections." + str(i) + ".blocks." + str(j)
+            if b.type == "entry" {
+              let e = project.entries.at(b.entry)
+              (
+                type: "entry",
+                path: path,
+                id: b.entry,
+                title: e.title,
+                place: e.at("place", default: ""),
+                period: period(e),
+                note: e.at("note", default: none),
+                items: e.at("items", default: ()).filter(it => shown("entries/" + b.entry + "/items/" + it.at("id", default: ""), it)),
+              )
+            } else {
+              (type: b.type, path: path, heading: b.at("heading", default: none), text: b.text)
+            }
+          }),
+      )),
+  )
+}
+
+/// The photo at `width`, in the profile's shape; none when there is no photo.
+#let photo(width, shape: cv.photo-shape) = {
+  if cv.photo == none { return none }
+  if shape == "circle" {
+    box(clip: true, radius: 50%, width: width, height: width, image(cv.photo, width: width, height: width, fit: "cover"))
+  } else if shape == "rounded" {
+    box(clip: true, radius: width * 0.08, image(cv.photo, width: width))
+  } else {
+    image(cv.photo, width: width)
+  }
+}
+
+/// A contact value as text, linked when it has a link.
+#let contact-text(c) = if c.link == none { c.value } else { link(c.link, c.value) }
+
+/// The document metadata every style should set.
+#let document-info = (title: cv.name + " — " + cv.subtitle, author: cv.name)

package/dist/template/styles/arco.typ

@@ -0,0 +1,177 @@
+// Arco: made for a CV with little in it, so that it looks full and kind. A tinted panel down the
+// left with the photo in an arch at its top (the initials, when there is no photo), the name large
+// in a bold serif, the subtitle and the summary on a soft card, and titles over a fine line that
+// ends in a diamond. Two columns: the panel holds the contacts, the skills and the side sections.
+
+#import "/lib.typ": *
+
+#let ink = rgb("#2b2427")
+#let muted = ink.lighten(38%)
+#let accent-color = accent(rgb("#b06a5b"))
+#let deep = accent-color.darken(30%)
+#let tint = accent-color.lighten(88%)
+#let soft = accent-color.lighten(76%)
+#let m = margins((top: 14, bottom: 12, left: 13, right: 14))
+#let text-width = paper.width - m.left - m.right
+#let side-width = text-width * 0.33
+#let gutter = 10mm
+#let main-width = text-width - side-width - gutter
+#let main-x = m.left + side-width + gutter
+#let pad = 5mm
+#let small = base-size * 0.9
+#let serif = "XCharter"
+#let shows-picture = opt("photo", "square") != "none"
+#let pic-width = side-width * 0.8
+#let pic-height = pic-width * 1.2
+// On the first page the panel starts halfway down the photo, which stands out of it.
+#let panel-top = if shows-picture { m.top + pic-height * 0.55 } else { m.top - pad }
+
+#set document(..document-info)
+#set page(width: paper.width, height: paper.height, margin: m, background: context {
+  let first = counter(page).get().first() == 1
+  let y0 = if first { panel-top } else { 0pt }
+  place(top + left, dx: m.left - pad, dy: y0, rect(
+    width: side-width + 2 * pad,
+    height: paper.height - y0,
+    fill: tint,
+    radius: if first { (top-left: 6mm, top-right: 6mm) } else { 0pt },
+  ))
+})
+#set text(font: opt("font", "Noto Sans"), size: base-size, fill: ink, lang: lang)
+#set par(leading: 0.62em, spacing: 0.62em * density, justify: false)
+#set list(marker: text(fill: accent-color, sym.bullet), indent: 0.1em, body-indent: 0.5em, spacing: 0.45em * density)
+#show link: set text(hyphenate: false)
+
+#geometry(main: (x: main-x, width: main-width), side: (x: m.left, width: side-width))
+
+// ---------------------------------------------------------------- ornaments
+
+#let diamond(size: 4.4pt) = box(width: size, height: size, align(center + horizon, rotate(45deg, square(size: size * 0.68, fill: accent-color))))
+
+/// A four-pointed star of radius `r`.
+#let star(r) = {
+  let w = r * 0.28
+  polygon(fill: accent-color.lighten(25%), (r, 0pt), (r + w, r - w), (2 * r, r), (r + w, r + w), (r, 2 * r), (r - w, r + w), (0pt, r), (r - w, r - w))
+}
+
+#let title-line(title, size: base-size * 1.2) = block(above: 1.35em * density, below: 0.7em * density, sticky: true, {
+  text(font: serif, size: size, weight: "bold", fill: ink, title)
+  h(0.5em)
+  box(width: 1fr, baseline: -0.3em, line(length: 100%, stroke: 0.6pt + accent-color.lighten(30%)))
+  box(baseline: -(0.3em - 2.2pt), diamond())
+})
+
+// ---------------------------------------------------------------- the panel
+
+#let first-letter(s) = if s.len() > 0 { upper(s.clusters().first()) } else { "" }
+#let arch(w) = (top-left: w / 2, top-right: w / 2)
+#let picture = if not shows-picture { none } else {
+  let inner = if cv.photo != none {
+    box(clip: true, radius: arch(pic-width), width: pic-width, height: pic-height, image(cv.photo, width: pic-width, height: pic-height, fit: "cover"))
+  } else {
+    box(radius: arch(pic-width), width: pic-width, height: pic-height, fill: soft, align(center + horizon, text(
+      font: serif,
+      size: pic-width * 0.3,
+      weight: "bold",
+      fill: white,
+      first-letter(cv.given) + first-letter(cv.family),
+    )))
+  }
+  box(stroke: 0.8pt + accent-color, radius: arch(pic-width + 9pt), inset: 4.5pt, inner)
+}
+
+#let dots(items) = block(above: 0.2em, stroke: (left: 0.7pt + accent-color.lighten(35%)), inset: (left: 10pt, y: 1pt), for (i, it) in items.enumerate() {
+  block(above: if i == 0 { 0pt } else { 0.62em * density }, below: 0pt, {
+    place(left, dx: -10pt - 2.6pt, dy: 0.12em, circle(radius: 2.3pt, fill: tint, stroke: 0.8pt + accent-color))
+    it
+  })
+})
+
+#let contact-line(c) = block(above: 0.6em * density, below: 0pt, grid(
+  columns: (auto, 1fr),
+  column-gutter: 0.55em,
+  move(dy: 0.12em, circle(radius: 2.6pt, stroke: 0.9pt + accent-color)),
+  contact-text(c),
+))
+
+#let side-section(s) = {
+  title-line(s.title, size: base-size * 1.1)
+  for b in s.blocks {
+    anchored(b.path, column: "side", block(above: 0.65em * density, below: 0pt, if b.type == "entry" {
+      text(weight: "bold", b.title)
+      if b.place != "" { linebreak() + text(fill: deep, b.place) }
+      if b.period != "" { linebreak() + text(fill: muted, b.period) }
+    } else { item-body(b) }))
+  }
+}
+
+#let sidebar = {
+  set text(size: small)
+  if picture != none {
+    place(top + left, dx: -1mm, dy: 5mm, star(3.2pt))
+    place(top + left, dx: 2.6mm, dy: 11mm, star(1.9pt))
+    place(top + left, dx: -0.4mm, dy: 15.5mm, star(1.4pt))
+    anchored("photo", column: "side", align(center, picture))
+    v(3mm)
+  }
+  if cv.contacts.len() > 0 {
+    anchored("contacts", column: "side", {
+      title-line(labels.contact, size: base-size * 1.1)
+      for c in cv.contacts { contact-line(c) }
+    })
+  }
+  for (i, row) in cv.skills.enumerate() {
+    anchored("skills." + str(i), column: "side", for g in row {
+      title-line(g.title, size: base-size * 1.1)
+      dots(g.items)
+    })
+  }
+  for s in cv.sections.filter(s => s.side) { anchored(s.path, column: "side", side-section(s)) }
+}
+
+// ---------------------------------------------------------------- the main column
+
+#let entry(b, compact) = anchored(b.path, block(above: 1em * density, below: 0pt, {
+  text(weight: "bold", b.title)
+  if b.place != "" or b.period != "" {
+    linebreak()
+    text(size: small, {
+      if b.place != "" { text(fill: deep, weight: "medium", b.place) }
+      if b.place != "" and b.period != "" { h(0.45em) + text(fill: accent-color, "|") + h(0.45em) }
+      text(fill: muted, b.period)
+    })
+  }
+  if b.note != none { par(text(size: small, fill: muted, b.note)) }
+  if not compact and b.items.len() > 0 { block(above: 0.5em * density, list(..b.items.map(item-body))) }
+}))
+
+#let main-section(s) = anchored(s.path, {
+  title-line(s.title)
+  for b in s.blocks {
+    if b.type == "entry" { entry(b, s.compact) } else if b.type == "item" {
+      anchored(b.path, block(above: 0.5em * density, below: 0pt, list(item-body(b))))
+    } else { anchored(b.path, block(above: 0.5em * density, below: 0pt, par(justify: true, inline(b.text)))) }
+  }
+})
+
+#let main = {
+  anchored("name", par(leading: 0.32em, text(font: serif, size: base-size * 3.1, weight: "bold", fill: ink, {
+    cv.given
+    linebreak()
+    cv.family
+  })))
+  block(above: 1em, fill: soft.lighten(30%), radius: 5pt, inset: (x: 11pt, y: 10pt), width: 100%, {
+    anchored("subtitle", text(size: base-size * 1.12, weight: "bold", fill: deep, cv.subtitle))
+    if cv.highlight != none {
+      v(0.3em)
+      anchored("highlight", text(size: small)[#text(weight: "bold", fill: deep, cv.highlight.title): #cv.highlight.text])
+    }
+    if cv.summary != "" {
+      v(0.45em)
+      anchored("summary", par(justify: true, inline(cv.summary)))
+    }
+  })
+  for s in cv.sections.filter(s => not s.side) { main-section(s) }
+}
+
+#grid(columns: (side-width, main-width), column-gutter: gutter, sidebar, main)