diff --git a/packages/preview/owl-lst-thesis/0.1.0/LICENSE b/packages/preview/owl-lst-thesis/0.1.0/LICENSE new file mode 100644 index 0000000000..30c629513b --- /dev/null +++ b/packages/preview/owl-lst-thesis/0.1.0/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/preview/owl-lst-thesis/0.1.0/README.md b/packages/preview/owl-lst-thesis/0.1.0/README.md new file mode 100644 index 0000000000..ac35476df8 --- /dev/null +++ b/packages/preview/owl-lst-thesis/0.1.0/README.md @@ -0,0 +1,268 @@ +# Typst style for LST theses + +This is a Typst thesis style +for the [Department of Language Science and Technology](https://www.lst.uni-saarland.de/) +at [Saarland University](https://www.uni-saarland.de/). +You can use this for your Bachelor's or Master's Thesis or any other document you like. +The template is maintained by [Alexander Koller](https://www.coli.uni-saarland.de/~koller/). + +The template sets up the title page, declaration, abstract, acknowledgments, +table of contents, chapter styling, headers, page numbers, figure captions, and bibliography +formatting for an LST thesis. +The default `screen` mode uses equal left and right margins. The `print` mode is intended for +double-sided printing and binding, with a wider inner margin. + + +## Quick start in the Typst web app + +1. Open the Typst web app. +2. Create a new project from the `owl-lst-thesis` template. +3. Edit the metadata in the `#show` block. +4. Add BibTeX entries and import your BibTeX file with `add-bib-resource`. + +You can write the thesis below the `#show: lst` block and export the PDF from the web app. + + +## Minimal thesis file + +This is the smallest useful shape of a thesis file: + +```typst +#import "@preview/owl-lst-thesis:0.1.0": * +#import "@preview/pergamon:0.8.0": * + +#set text(lang: "en") + +#show: lst.with( + title: "My Thesis Title", + author: "Jane Student", + matriculation-number: "1234567", + degree-program: "coli", + supervisors: ( + ("Supervisors", "Prof. Dr. First Supervisor", "Prof. Dr. Second Supervisor"), + ("Additional advisor", "Dr. Helpful Advisor"), + ), + date: "31.12.2026", + + abstract: [ + Write a short summary of the thesis here. + ], + + acknowledgments: [ + Optional acknowledgments go here. + ]) + +#add-bib-resource(read("custom.bib")) + += Introduction + +Start writing here. Cite papers with Pergamon like this #cite("bender-koller-2020-climbing"). + +#print-lst-bibliography() +``` + + +## Template arguments + +The main function is `lst`. Use it in a `#show` rule around your document content. + +- `title`: Thesis title shown on the title page and stored in the PDF metadata. Can be any content. +- `author`: Your name, stored in the PDF metadata. Must be a string. +- `matriculation-number`: Your matriculation number. Must be a string. +- `degree-program`: Required degree program printed on the title page. Use one of the built-in + abbreviations below, or pass free-form text for custom cases together with `thesis-type`. +- `supervisors`: A tuple of supervisor groups. Each group starts with a role label, followed by + one or more names. Use strings for all labels and names. +- `date`: Submission date printed on the title page and declaration. Must be a string. +- `thesis-type`: Optional string. By default, the template chooses the localized bachelor's or + master's thesis label from a built-in degree program. Set this by hand for custom cases such as + `"Seminar paper"`; this manual value is not localized. +- `city`: Optional string. Defaults to `Saarbrücken` and is printed above the signature line in the + declaration. +- `mode`: Optional string. Defaults to `"screen"`, which makes the left and right margin equal size. Use `"print"` for a wider inner margin for binding. +- `abstract`: Optional content. If present, the template creates an abstract page. +- `acknowledgments`: Optional content. If present, the template creates an acknowledgments page. + +Built-in degree programs: + +| Abbreviation | Degree program | English thesis type | German thesis type | +| --- | --- | --- | --- | +| `"langsci"` | `BA Language Science` | `Bachelor's Thesis` | `Bachelorarbeit` | +| `"coli"` | `BSc Computerlinguistik` | `Bachelor's Thesis` | `Bachelorarbeit` | +| `"lst"` | `MSc Language Science and Technology` | `Master's Thesis` | `Masterarbeit` | +| `"lct"` | `MSc Language and Communication Technologies` | `Master's Thesis` | `Masterarbeit` | +| `"tst"` | `MA Translation Science and Technology` | `Master's Thesis` | `Masterarbeit` | + +For these built-in abbreviations, the degree program name is printed exactly as shown above. The +thesis type is selected from the document language: `#set text(lang: "en")` prints the English +label, and `#set text(lang: "de")` prints the German label. + +The template automatically creates: + +- title page with LST and Saarland University logos; +- declaration page; +- PDF metadata with the thesis title, author, and template preparation string; +- abstract and acknowledgments pages when provided; +- table of contents to section depth; +- main-matter page numbering; +- odd-page chapter starts with blank pages where needed; +- running headers with chapter and section information; +- chapter-based numbering for figures, tables, raw figures, and equations; +- LST-styled captions, links, references, and bibliography heading. + + +## Language + +The template localizes its built-in labels from Typst's document language. It defaults to +English. Use German with: + +```typst +#set text(lang: "de") +``` + +This translates template chrome such as chapter labels, front-matter headings, title-page +fields, and the declaration. User-provided thesis text and supervisor role labels are not +translated automatically, so write those labels yourself: + +```typst +supervisors: ( + ("Gutachter", "Prof. Dr. First Supervisor", "Prof. Dr. External Reviewer"), + ("Betreuerin", "Dr. Helpful Advisor"), +) +``` + + +## Writing structure + +Use normal Typst headings: + +```typst += Chapter +== Section +=== Subsection +==== Paragraph-style heading +``` + +The table of contents includes chapters and sections. Subsections and lower heading levels are +not shown in the table of contents. + +Use labels for cross-references: + +```typst += Introduction + +As discussed in @sec:introduction, this chapter introduces the topic. +``` + +Use figures and tables with labels: + +```typst +#figure(caption: [Example figure.])[ + #image("figure.pdf", width: 80%) +] + +See @fig:example. +``` + + + +## Citations and bibliography with Pergamon + +This template uses [Pergamon](https://typst.app/universe/package/pergamon) for author-year citations and bibliography formatting. Keep these +three pieces in your thesis file: + +```typst +#import "@preview/pergamon:0.8.0": * + +#add-bib-resource(read("custom.bib")) + +#print-lst-bibliography() +``` + +Add references to `custom.bib` in normal BibTeX format. Of course you can also use Bibtex files with different names. + +Cite a source in parentheses with `#cite` and as a noun phrase with `#citet`. +Pass the BibTeX key as a string (not as a label like in the default Typst `cite` command): + +```typst +#citet("bender-koller-2020-climbing") argued that meaning cannot be learned from form alone. +``` + +Finally, print the bibliography at the end of the document: + +```typst +#print-lst-bibliography() +``` + +`print-lst-bibliography` is provided by this template. It creates the LST-styled bibliography +heading and then asks Pergamon to print the bibliography. + + +## Fonts + +The template uses Libertinus Serif for the main text and Open Sans for headings, captions, headers, and title-page elements. Install +[Open Sans](https://fonts.google.com/specimen/Open+Sans) locally when compiling offline. + +In the Typst web app, Libertinus Serif and Open Sans should be available without extra setup. + + +## Common metadata patterns + +To select another degree program, set `degree-program`: + +```typst +#show: lst.with( + degree-program: "lst", + title: "My Thesis Title", + // add the remaining arguments as in the minimal example +) +``` + +To override the thesis type that is chosen from the degree program, set `thesis-type`: + +```typst +#show: lst.with( + degree-program: "langsci", + thesis-type: "Seminar paper", + title: "My Seminar Paper", + // add the remaining arguments as in the minimal example +) +``` + +Free-form degree programs are also possible, but then `thesis-type` is required: + +```typst +#show: lst.with( + degree-program: "Certificate Program in Example Studies", + thesis-type: "Project report", + title: "My Report", + // add the remaining arguments as in the minimal example +) +``` + +If `degree-program` is omitted, the template stops with an error message. If `degree-program` is +free-form and `thesis-type` is omitted, it also stops with an error message. In these free-form +cases, neither the degree program nor the manually supplied thesis type is localized by the +template. + +To omit acknowledgments, remove the `acknowledgments` argument. To omit the abstract, remove +the `abstract` argument. + +To use German labels throughout the template, set the document language before the `#show` +rule: + +```typst +#set text(lang: "de") +``` + + +## Licenses + +The Typst source files are released under an MIT-0 license. + +The [Open Sans](https://fonts.google.com/specimen/Open+Sans) font is Copyright 2020 by The +Open Sans Project Authors and distributed under the +[SIL Open Font License 11](https://fonts.google.com/specimen/Open+Sans/license). + +The Saarland University and LST logos in `logos/` are trademarks of their respective owners, +used with permission, and are not covered by the package license. diff --git a/packages/preview/owl-lst-thesis/0.1.0/lib.typ b/packages/preview/owl-lst-thesis/0.1.0/lib.typ new file mode 100644 index 0000000000..26459736b3 --- /dev/null +++ b/packages/preview/owl-lst-thesis/0.1.0/lib.typ @@ -0,0 +1,542 @@ +#import "@preview/pergamon:0.8.0": * + +#let lst-template-version = "0.1.0" +#let prepared-string = "Prepared with the owl-lst-thesis Typst template, version " + lst-template-version + "." + +#let titlepage-bottom-fontsize = 10pt + +#let uds-blue-screen = rgb(0, 72, 118) +#let uds-blue = uds-blue-screen +#let text-gray = luma(95) + +#let lst-mode-settings(mode) = { + if mode == "screen" { + ( + blue: uds-blue-screen, + lst_logo: "logos/rgb/lst-logo.svg", + uds_logo: "logos/rgb/uds-logo.svg", + page_margin: (bottom: 3cm, top: 3cm, inside: 2.75cm, outside: 2.75cm), + ) + } else if mode == "print" { + ( + blue: uds-blue-screen, + lst_logo: "logos/rgb/lst-logo.svg", + uds_logo: "logos/rgb/uds-logo.svg", + page_margin: (bottom: 3cm, top: 3cm, inside: 3cm, outside: 2.5cm), + ) + } else { + panic("unknown LST template mode: " + repr(mode)) + } +} + +// Built-in strings for the parts of the thesis that the template creates. +// The selected language comes from `#set text(lang: "...")`; unsupported +// languages fall back to English. +#let lst-translations = ( + en: ( + bibliography: "Bibliography", + declaration: "Declaration", + declaration-text: [ + I hereby confirm that the thesis presented here is my own work, with all assistance + acknowledged. I assure that the electronic version is identical in content to the printed + version of the thesis. + ], + contents: "Contents", + abstract: "Abstract", + acknowledgments: "Acknowledgments", + chapter: "Chapter", + matriculation-number: "Matriculation Number", + submission-date: "Submission Date", + department: "Department of Language Science and Technology", + university: "Saarland University", + bib-in: "In", + ), + de: ( + bibliography: "Literaturverzeichnis", + declaration: "Erklärung", + declaration-text: [ + Hiermit bestätige ich, dass die vorliegende Arbeit von mir selbstständig verfasst wurde + und alle verwendeten Hilfsmittel angegeben sind. Ich versichere, dass die elektronische + Version inhaltlich mit der gedruckten Version der Arbeit übereinstimmt. + ], + contents: "Inhaltsverzeichnis", + abstract: "Zusammenfassung", + acknowledgments: "Danksagung", + chapter: "Kapitel", + matriculation-number: "Matrikelnummer", + submission-date: "Abgabedatum", + department: "FR Sprachwissenschaft und Sprachtechnologie", + university: "Universität des Saarlandes", + bib-in: "In", + ), +) + +#let lst-current-translations() = { + let lang = text.lang + if lst-translations.keys().contains(lang) { + lst-translations.at(lang) + } else { + lst-translations.en + } +} + +#let degree-programs = ( + langsci: ( + name: "BA Language Science", + thesis-type: ( + en: "Bachelor's Thesis", + de: "Bachelorarbeit", + ), + ), + coli: ( + name: "BSc Computerlinguistik", + thesis-type: ( + en: "Bachelor's Thesis", + de: "Bachelorarbeit", + ), + ), + lst: ( + name: "MSc Language Science and Technology", + thesis-type: ( + en: "Master's Thesis", + de: "Masterarbeit", + ), + ), + lct: ( + name: "MSc Language and Communication Technologies", + thesis-type: ( + en: "Master's Thesis", + de: "Masterarbeit", + ), + ), + tst: ( + name: "MA Translation Science and Technology", + thesis-type: ( + en: "Master's Thesis", + de: "Masterarbeit", + ), + ), +) + +#let localized-thesis-type(thesis-type) = { + let lang = text.lang + if thesis-type.keys().contains(lang) { + thesis-type.at(lang) + } else { + thesis-type.en + } +} + +#let lst-text(key) = context { + lst-current-translations().at(key) +} + +// Public helper for the end of the thesis. It keeps the bibliography heading +// consistent with the front matter and delegates the actual entries to Pergamon. +#let print-lst-bibliography() = { + heading(level: 100)[#lst-text("bibliography")] + v(-2em) + print-bibliography( + title: none + ) +} + +// Render grouped supervisor/advisor entries. Each group is expected to have the +// role label first and one or more names afterwards. +#let advisors(supervisors) = { + set text(size: titlepage-bottom-fontsize) + for (j, sup) in supervisors.enumerate() { + let role = sup.at(0) + let names = sup.slice(1) + + strong(role) + for (i, name) in names.enumerate() { + linebreak() + name + } + + if j < supervisors.len() - 1 { + linebreak() + linebreak() + } + } +} + +// The title page is separated from `lst` so the main wrapper can focus on page +// setup and document flow. Localized strings are passed in explicitly because +// the title page is built inside a context block. +#let title-page(mode-settings, strings, thesis-type, degree-program, title, author, matriculation-number, supervisors, date) = { + set text(font: "Open Sans") + + stack(dir: ltr, + box( + text(size: 12pt, fill: mode-settings.blue)[ + *#thesis-type*\ + #degree-program\ + #strings.university + ] + ), + h(1fr), + + stack(dir: ltr, + move(dy: -0.08cm, image(mode-settings.lst_logo, width: 1.9cm)), + h(0.6cm), + image(mode-settings.uds_logo, width: 1.6cm) + ) + ) + + v(4.3cm) + + text(size: 18pt, author) + v(0em) + text(size: 24pt, weight: "bold", fill: mode-settings.blue, title) + + v(1fr) + + + advisors(supervisors) + + place(bottom + right)[ + #set text(size: titlepage-bottom-fontsize) + *#strings.matriculation-number*\ + #matriculation-number\ + \ + *#strings.submission-date*\ + #date + ] +} + + + + +// Main thesis wrapper. Use it through `#show: lst.with(...)` so the +// student's document body becomes `content` after the template has inserted the +// title page, declaration, optional front matter, and table of contents. +#let lst(thesis-type: none, + degree-program: none, + title: none, + author: none, + matriculation-number: none, + supervisors: none, + date: none, + city: "Saarbrücken", + mode: "screen", + abstract: none, + acknowledgments: none, + content) = [ + #let mode-settings = lst-mode-settings(mode) + #let uds-blue = mode-settings.blue + + #if title != none and author != none { + set document(title: title, author: author, description: prepared-string, keywords: (prepared-string,)) + } else if title != none { + set document(title: title, description: prepared-string, keywords: (prepared-string,)) + } else if author != none { + set document(author: author, description: prepared-string, keywords: (prepared-string,)) + } else { + set document(description: prepared-string, keywords: (prepared-string,)) + } + + #set page( + paper: "a4", margin: mode-settings.page_margin, + numbering: none, + number-align: center, + ) + + #set text(size: 11pt) + #let leading-space = 0.7em + #let paragraph-space = 2 * leading-space + #set par(leading: leading-space, spacing: paragraph-space) + + + + // Level 100 is reserved for generated front-matter headings. It lets the + // template reuse the chapter-opening layout without putting these pages into + // the normal chapter numbering. + #show heading: it => { + if it.level == 1 or it.level == 100 { + // The content switch marks inserted blank pages so headers and footers can + // stay empty on pages created only to force odd-page chapter starts. + state("content.switch").update(false) + pagebreak(weak: true, to: "odd") + state("content.switch").update(true) + + v(2cm) + set text(font: ("Open Sans", "Libertinus Serif"), weight: "bold", size: 24pt, fill: uds-blue) + + if it.level == 1 and it.numbering != none { + text(font: "Open Sans", size: 12pt, fill: text-gray)[#lst-text("chapter") #context(counter(heading).display())] + v(-0.6em) + text(fill: uds-blue, it.body) + + // Figure-like counters are chapter-local, matching labels such as 2.1. + for kind in (image, table, raw) { + counter(figure.where(kind: kind)).update(0) + counter(math.equation).update(0) + } + } else { + it.body + } + v(2em, weak: true) + } else if it.level == 2 { + // Sections + v(paragraph-space) + text(font: "Open Sans", size: 15pt, weight: "bold", it) + v(1.5em, weak: true) + } else if it.level == 3 { + // Subsections + v(0.3em) + text(font: "Open Sans", size: 12.5pt, weight: "bold", it) + v(1em, weak: true) + } else if it.level == 4 { + // v(0.7em) + text(weight: "bold", it.body) + [. ] + } else { + v(0em) + it + v(1em, weak: true) + } + } + + // Figure/table/equation numbering uses the current chapter number as prefix. + #set figure( + placement: top, + numbering: n => { + let h1 = counter(heading).get().first() + numbering("1.1", h1, n) + } + ) + + #show figure: set place(clearance: 2em) + + #show figure.caption: it => { + set text(font: "Open Sans", size: 9pt) + v(0.5em) + text(fill: uds-blue, weight: "semibold", it.supplement) + h(0.35em) + text(fill: uds-blue, weight: "semibold", it.counter.display()) + text(fill: text-gray)[:] + h(0.35em) + text(fill: text-gray, it.body) + } + + // Links and references use the house blue so cross-references are visible but + // not visually louder than the surrounding thesis text. + #show link: set text(fill: uds-blue) + // #show cite: set text(fill: uds-blue) + #show ref: set text(fill: uds-blue) + + // Show page numbers only on pages that the header has marked as containing + // real content. This avoids numbering intentionally inserted blank pages. + // The state-based approach follows the pattern discussed in: + // https://github.com/typst/typst/discussions/3122 + #let page-footer = context { + let has-content = state("content.pages", (0,)).get().contains(here().page()) + + if has-content { + let page-here = here().page() + align( + if calc.odd(page-here) { right } else { left }, + text(font: "Open Sans", size: 9pt, fill: uds-blue, weight: "semibold", counter(page).display()) + ) + } else { + [ ] // empty page + } + } + + #let heading-number-at(it) = { + let nums = counter(heading).at(it.location()) + numbering("1.1", ..nums) + } + + // Build even-page running heads of the form "Chapter 3 / Experiments". + #let header-for-chapter() = context { + let page-number = here().page() + let chapters = heading.where(level: 1) + if query(chapters).any(it => it.location().page() == page-number) { + return [] + } + + // Find the chapter of the section we are currently in + let chapters-before = query(chapters.before(here())) + if chapters-before.len() > 0 { + let current-chapter = chapters-before.last() + + // no header in un-numbered chapters + if current-chapter.numbering == none { + return [] + } + + let chapter-title = current-chapter.body + let chapter-number = str(counter(heading.where(level: 1)).get().first()) + + text(fill: uds-blue, weight: "semibold")[#lst-text("chapter") #chapter-number] + h(0.35em) + text(fill: text-gray)[/] + h(0.35em) + text(fill: text-gray, chapter-title) + } + } + + // Build odd-page running heads of the form "2.3 / Previous Work". If the + // current chapter has no section yet, fall back to the chapter header. + #let header-for-section() = context { + let page-number = here().page() + let sections = heading.where(level: 2) + let sections-on-page = query(sections).filter(it => it.location().page() == page-number) + + if sections-on-page.len() > 0 { + let current-section = sections-on-page.first() + let section-title = current-section.body + text(fill: uds-blue, weight: "semibold")[#heading-number-at(current-section)] + h(0.35em) + text(fill: text-gray)[/] + h(0.35em) + text(fill: text-gray, section-title) + } else { + let sections-before = query(sections.before(here())) + if sections-before.len() > 0 { + let current-section = sections-before.last() + let section-title = current-section.body + text(fill: uds-blue, weight: "semibold")[#heading-number-at(current-section)] + h(0.35em) + text(fill: text-gray)[/] + h(0.35em) + text(fill: text-gray, section-title) + } else { + header-for-chapter() + } + } + } + + // Page headers are also responsible for recording which pages are nonblank; + // the footer reads that state when deciding whether to print a page number. + #let page-header = context { + let page-here = here().page() + // Chapter starts include real chapters and generated front-matter pages. + let is-start-chapter = query(heading.where(level: 1) .or(heading.where(level: 100)) ).any(it => it.location().page() == page-here) + + if not state("content.switch", false).get() and not is-start-chapter { + [ ] // empty page + return + } + + // Suppress running heads on chapter-opening pages. + if not is-start-chapter { + let header-content = if calc.odd(page-here) { + header-for-section() + } else { + header-for-chapter() + } + + align(if calc.odd(page-here) { right } else { left }, + text(font: "Open Sans", size: 9pt)[ + #header-content + ]) + } + + // update the list of pages on which the footer displays page numbers + state("content.pages").update(it => return it + (page-here,)) + } + + #set page(footer: page-footer, header: page-header) + + + // Generated front matter. Page numbering starts in roman numerals after the + // unnumbered title page, then restarts in arabic numerals for the thesis body. + #context { + let strings = lst-current-translations() + if degree-program == none { + panic("Missing degree program. Set `degree-program` to one of \"langsci\", \"coli\", \"lst\", \"lct\", or \"tst\", or pass a free-form degree-program together with `thesis-type`.") + } + + let is-known-degree-program = type(degree-program) == str and degree-programs.keys().contains(degree-program) + let resolved-degree-program = if is-known-degree-program { + degree-programs.at(degree-program) + } else { + (name: degree-program, thesis-type: none) + } + + if not is-known-degree-program and thesis-type == none { + panic("Free-form degree programs need an explicit `thesis-type`, for example `thesis-type: \"Seminar paper\"`.") + } + + let displayed-thesis-type = if thesis-type != none { + thesis-type + } else { + localized-thesis-type(resolved-degree-program.thesis-type) + } + + // title page + title-page(mode-settings, strings, displayed-thesis-type, resolved-degree-program.name, title, author, matriculation-number, supervisors, date) + + // declaration page + set page(numbering: "i") + counter(page).update(0) + heading(level: 100, strings.declaration) + v(-2em) + strings.declaration-text + v(2em) + + city + [, ] + date + + v(5em) + line(length: 50%) + v(-0.5em) + [(#author)] + + v(1fr) + text(size: 8pt, prepared-string) + } + + // Optional front-matter sections are omitted entirely when the corresponding + // argument is `none`. + #set par(justify: true) + #if abstract != none [ + #heading(level: 100)[#lst-text("abstract")] + #v(-2em) + #abstract + ] + + // acknowledgments + #if acknowledgments != none [ + #heading(level: 100)[#lst-text("acknowledgments")] + #v(-2em) + #acknowledgments + ] + + // The table of contents is intentionally shallow: chapters and sections only. + #show outline.entry.where(level: 1): it => { + v(11pt, weak: true) + it + } + + #outline(title: lst-text("contents"), depth: 2) // show sections, but not subsections + + // Main matter starts the visible chapter/section numbering and wraps the body + // in Pergamon's author-year citation style. + #set page(numbering: "1") + #counter(page).update(0) + #set heading(numbering: "1.1") + + #context { + let strings = lst-current-translations() + refsection(style: authoryear-style( + reference: ( + name-format: "{given} {family}", + format-quotes: it => it, + print-date-after-authors: true, + suppress-fields: ( + "*": ("month", "day",), + "inproceedings": ("editor", "publisher", "pages", "location") + ), + eval-scope: ("todo": x => text(fill: red, x)), + bibstring: ("in": strings.bib-in), + bibstring-style: "long", + ) + ), content) + } +] diff --git a/packages/preview/owl-lst-thesis/0.1.0/logos/rgb/lst-logo.svg b/packages/preview/owl-lst-thesis/0.1.0/logos/rgb/lst-logo.svg new file mode 100644 index 0000000000..5cddeef6c0 --- /dev/null +++ b/packages/preview/owl-lst-thesis/0.1.0/logos/rgb/lst-logo.svg @@ -0,0 +1,29 @@ + + + + + + + + + diff --git a/packages/preview/owl-lst-thesis/0.1.0/logos/rgb/uds-logo.svg b/packages/preview/owl-lst-thesis/0.1.0/logos/rgb/uds-logo.svg new file mode 100644 index 0000000000..3d76ca45c3 --- /dev/null +++ b/packages/preview/owl-lst-thesis/0.1.0/logos/rgb/uds-logo.svg @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/preview/owl-lst-thesis/0.1.0/template/custom.bib b/packages/preview/owl-lst-thesis/0.1.0/template/custom.bib new file mode 100644 index 0000000000..a9f34cda60 --- /dev/null +++ b/packages/preview/owl-lst-thesis/0.1.0/template/custom.bib @@ -0,0 +1,56 @@ +@inproceedings{bender-koller-2020-climbing, + title = "Climbing towards {NLU}: {On} Meaning, Form, and Understanding in the Age of Data", + author = "Bender, Emily M. and + Koller, Alexander", + editor = "Jurafsky, Dan and + Chai, Joyce and + Schluter, Natalie and + Tetreault, Joel", + booktitle = "Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics", + month = jul, + year = "2020", + address = "Online", + publisher = "Association for Computational Linguistics", + url = "https://aclanthology.org/2020.acl-main.463", + doi = "10.18653/v1/2020.acl-main.463", + pages = "5185--5198", + abstract = "The success of the large neural language models on many NLP tasks is exciting. However, we find that these successes sometimes lead to hype in which these models are being described as {``}understanding{''} language or capturing {``}meaning{''}. In this position paper, we argue that a system trained only on form has a priori no way to learn meaning. In keeping with the ACL 2020 theme of {``}Taking Stock of Where We{'}ve Been and Where We{'}re Going{''}, we argue that a clear understanding of the distinction between form and meaning will help guide the field towards better science around natural language understanding.", +} + +@article{kuhlmann-etal-2015-lexicalization, + title = "Lexicalization and Generative Power in {CCG}", + author = "Kuhlmann, Marco and + Koller, Alexander and + Satta, Giorgio", + journal = "Computational Linguistics", + volume = "41", + number = "2", + month = jun, + year = "2015", + address = "Cambridge, MA", + publisher = "MIT Press", + doi = "10.1162/COLI_a_00219", + pages = "187--219", + keywords = "workshop" +} + +@book{GareyJohnsonBook, +author = {Garey, Michael R. and Johnson, David S.}, +title = {{Computers and Intractability: A Guide to the Theory of NP-Completeness}}, +year = {1990}, +isbn = {0716710455}, +publisher = {W. H. Freeman \& Co.}, +url = {https://dl.acm.org/doi/10.5555/574848}, +address = {USA} +} + +@misc{yao2023predictinggeneralizationperformancecorrectness, + title={Predicting generalization performance with correctness discriminators}, + author={Yuekun Yao and Alexander Koller}, + year={2023}, + eprint={2311.09422}, + archivePrefix={arXiv}, + primaryClass={cs.CL}, + howpublished={ArXiv paper 2311.09422}, + url={https://arxiv.org/abs/2311.09422}, +} diff --git a/packages/preview/owl-lst-thesis/0.1.0/template/main.typ b/packages/preview/owl-lst-thesis/0.1.0/template/main.typ new file mode 100644 index 0000000000..c86fe785ef --- /dev/null +++ b/packages/preview/owl-lst-thesis/0.1.0/template/main.typ @@ -0,0 +1,49 @@ +#import "@preview/owl-lst-thesis:0.1.0": * +#import "@preview/pergamon:0.8.0": * + +// Use "de" for German template labels. +#set text(lang: "en") + +#show: lst.with( + title: "Thesis Title", + author: "Your Name", + matriculation-number: "Your Matriculation Number", + + degree-program: "coli", + // one of "coli", "lst", "lct", "langsci", "tst" + + supervisors: ( + ("Supervisors", "First Supervisor", "Second Supervisor"), + ("Additional advisor", "Additional Advisor"), + ), + + date: "Submission Date", + + // mode: "print", // uncomment to obtain printing-friendly page margins + + abstract: [ + Write your abstract here. + ], + + acknowledgments: [ + Write optional acknowledgments here, or remove this argument. + ] +) + +#add-bib-resource(read("custom.bib")) + += Introduction + +Start writing your thesis here. + += Background + +Many interesting combinatorial problems are NP-complete #cite("GareyJohnsonBook"). + +#citet("bender-koller-2020-climbing") argued that meaning cannot be learned from form alone. + += My Contribution + += Conclusion + +#print-lst-bibliography() diff --git a/packages/preview/owl-lst-thesis/0.1.0/thumbnail.png b/packages/preview/owl-lst-thesis/0.1.0/thumbnail.png new file mode 100644 index 0000000000..7d319fd7d1 Binary files /dev/null and b/packages/preview/owl-lst-thesis/0.1.0/thumbnail.png differ diff --git a/packages/preview/owl-lst-thesis/0.1.0/typst.toml b/packages/preview/owl-lst-thesis/0.1.0/typst.toml new file mode 100644 index 0000000000..f57b2f3599 --- /dev/null +++ b/packages/preview/owl-lst-thesis/0.1.0/typst.toml @@ -0,0 +1,29 @@ +[package] +name = "owl-lst-thesis" +version = "0.1.0" +entrypoint = "lib.typ" +authors = ["Alexander Koller "] +license = "MIT-0" +description = "Thesis in the LST department at Saarland University." +repository = "https://github.com/coli-saar/typst-lst-template" +keywords = [ + "Saarland University", + "Language Science and Technology", + "LST", + "thesis", +] +categories = ["thesis"] +disciplines = ["computer-science", "linguistics"] +compiler = "0.15.0" +exclude = [ + "/tmp/", + "/custom.bib", + "/main.typ", + "/main.pdf", + ".DS_Store", +] + +[template] +path = "template" +entrypoint = "main.typ" +thumbnail = "thumbnail.png"