## [1.14.1] - 2026-03-06
### Added
#### [Escaped characters in numbering formats](https://quarkdown.com/wiki/numbering)
A backslash (`\`) in a numbering format string now escapes the next character, treating it as a fixed symbol. For example, `\1` produces a literal `1` instead of a decimal counter.
### Fixed
#### Fixed live preview sometimes timing out on Windows
Fixed an IPv6-related issue that caused connections to Quarkdown's server to time out on Windows. _Please also update to the latest version of the VS Code extension to v1.1.2 or later._
#### Fixed block function call incorrectly matching lines with trailing content
Fixed an issue that caused a line like `.sum {1} {2} .sum {3} {4}` to be incorrectly lexed as two block function calls rather than a single paragraph with two inline function calls.
### Changed
#### Improved lexer performance
The lexer no longer restarts its regex search from scratch when a function call advances the scan position, resulting in slightly improved performance, especially for documents with many function calls.
## [1.14.0] - 2026-02-19
This version is the biggest release to date, with a large number of new features and improvements, and a [new official wiki](https://quarkdown.com/wiki), written in Quarkdown, that fully replaces the GitHub wiki for a better experience.
> Going forward, next minor releases will be smaller and more frequent.
### Added
#### [`docs` document type](https://quarkdown.com/wiki/document-types#docs-docs)
`docs` is the fourth document type available in Quarkdown, alongside `plain`, `paged` and `slides`. It is designed for technical documentation, wikis and knowledge bases.
It derives from `plain`, and adds a customizable navigation sidebar, a ToC sidebar, a header, accurate client-side search, and next/previous page navigation buttons.
You can see it in action in the [new official wiki](https://quarkdown.com/wiki)! To get started with a new `docs` document, you can rely on `quarkdown create` as usual.
#### New themes: Galactic (color) and Hyperlegible (layout)
Inspired by Astro, this new theme combination is the one used in the new wiki for improved readability and modern look.
Thanks @OverSamu!
#### [Horizontal/vertical gap customization of `.grid`](https://quarkdown.com/wiki/stacks#parameters)
The `.grid` function now accepts `hgap` and `vgap` parameters to customize the horizontal and vertical gaps between grid items. `gap` still works as a shorthand for both.
Thanks @OverSamu!
#### [`none` is now converted to `null`](https://quarkdown.com/wiki/none#passing-none-to-functions)
When invoking a native function from the stdlib, [`none`](https://quarkdown.com/wiki/none) is now supported by nullable parameters, and converted to `null`.
Before:
```markdown
.function {rectangle}
width height background?:
.if {.background::isnone}
.container width:{.width} height:{.height}
.ifnot {.background::isnone}
.container width:{.width} height:{.height} background:{.background}
```
After:
```markdown
.function {rectangle}
width height background?:
.container width:{.width} height:{.height} background:{.background}
```
#### [Icons](https://quarkdown.com/wiki/icons)
The new `.icon {name}` function relies on [Bootstrap Icons](https://icons.getbootstrap.com/#icons) to display pixel-perfect icons in your documents.
```markdown
Quarkdown is on .icon {github}
```
#### New output target: plain text
Quarkdown can now render to plain text (`.txt`) via `--render plaintext`.
This has no particular use case. It was needed to implement the docs search feature in the first place.
#### Get path to root directory
The new `.pathtoroot {granularity?}` function returns the relative path from the current source file to the parent directory of:
- the root document, if `granularity` is `project` (default)
- the subdocument, if `granularity` is `subdocument`
### Changed
#### `.css` doesn't require `!important` anymore
The `.css` function now applies `!important` automatically at the end of each rule.
#### Revised navigation sidebar
The navigation sidebar, visible in `plain` and `paged` documents on web view, is now easier to navigate, with all entries visible at once, and more accessible for screen readers.
[Unreleased]: https://github.com/iamgio/quarkdown/compare/v1.14.1...HEAD
[1.14.1]: https://github.com/iamgio/quarkdown/compare/v1.14.0...v1.14.1
[1.14.0]: https://github.com/iamgio/quarkdown/compare/36ef163d22c13e51edfca12739b99aa6aa1368b4...v1.14.0
================================================
FILE: CLAUDE.md
================================================
# About Quarkdown
This is the Quarkdown project. Quarkdown is a:
- Turing-complete Markdown flavor, with a `.qd` standard file extension
- Typesetting system, as an alternative to LaTeX, with high-quality typography and layout customization
- Compiler, parser and renderer to:
- HTML
- PDF (via Puppeteer)
- Plain text
- CLI tool
Quarkdown supports different document types, which can be set via the `.doctype {type}` function:
- Plain documents (`plain`), suitable for notes, website, etc. Notion-like.
- Paged documents (`paged`), suitable for books, articles, reports, etc. LaTeX-like.
- Slides (`slides`), suitable for presentations.
- Documentation (`docs`), suitable for technical documentation websites and wikis.
The Quarkdown flavor extends CommonMark and GFM with various features. The most notable one is *functions*:
- Inline function:
```markdown
Lorem ipsum .myfunction {arg1} param:{arg2} dolor sit amet.
```
- Block function:
```markdown
.myfunction {arg1} param:{arg2}
arg3
```
Quarkdown is dynamically typed, although types do live in the native Kotlin implementation of functions.
For a full function call syntax reference, see [here](docs/syntax-of-a-function-call.qd).
For any other information, see the [documentation](docs) and the [README](README.md).
# Making changes
## Guidelines
You are a senior software engineer with high expertise in handling complex codebases, compilers, and typesetting systems.
You care about software quality, maintainability, and readability.
Avoid repetitive code at all costs and strive for elegant solutions, abstracting common patterns into reusable components.
Keep functions and classes small and focused on a single responsibility.
It's possible to over-engineer when necessary to achieve high cohesion, low coupling, to anticipate future changes,
leveraging design patterns, such as strategy and visitor (frequent in this codebase), and best practices.
Write medium-sized documentation comments for all public classes, methods, and properties,
and also non-public ones when the logic is not straightforward. Update existing documentation when making changes to the codebase, both in code and [docs](docs), and make sure to keep it consistent with the style used in the project.
Aim for a test-driven development (TDD) approach when possible. Tests play an important role. See [Testing](#testing) below.
When creating new files, always add them to git via `git add`, and make sure to place them in the correct module and package, following the existing project structure.
## Overview
The project is structured as a multi-module Gradle project.
- To build, always run `./gradlew installDist` or `distZip` from the root folder. Never run `build`.
- To test, run `./gradlew test`, optionally specifying a module, e.g., `:quarkdown-core:test`.
- `./gradlew run` is acceptable.
## Compiler
The main compiler, located in [quarkdown-core](quarkdown-core),
along with rendering extensions, such as [quarkdown-html](quarkdown-html) and [quarkdown-plaintext](quarkdown-plaintext),
the language server, located in [quarkdown-lsp](quarkdown-lsp),
the CLI, located in [quarkdown-cli](quarkdown-cli),
and other modules, is written in Kotlin with the Ktlint code style.
Follow the code style used in the project, and make sure to run `./gradlew ktlintFormat` after making changes to ensure the code is properly formatted.
### Pipeline
The compiler is structured as a sequential pipeline (`pipeline` package).
See `Pipeline-*` files in the [documentation](docs) to understand the different stages (`pipeline/stages` package).
### Context
`Context` is the most important interface in the compiler (`context` package). A context contains information about libraries, functions,
metadata, settings, and other data needed during compilation.
Each function call has a reference to the context it was parsed in.
A context can be forked to create a child context with additional or overridden data.
There are three forking methods, depending on the implementation, which affect the sandbox level:
- `SharedContext`: exchanges information bi-directionally. Changes made in the child context are reflected in the parent context, and vice versa,
allowing for full sharing of variables, functions and other declarations.
- `ScopeContext`: like `SharedContext`, but the child context does not share new declarations (functions and variables) back to the parent context.
This is the behavior used within lambda blocks, such as in `.foreach`.
`SubdocumentContext`: no information is shared back to the main file's context, only inherited from it. This also applies to the document info (metadata, title, etc.),
This is the behavior used for subdocuments (see [Subdocuments](docs/subdocuments.qd)).
### Nodes
Nodes are defined in the `ast/base` or `ast/quarkdown` package, depending on whether they are from CommonMark/GFM or Quarkdown-specific.
Defining a new node involves:
- Implementing `Node` or `NestableNode`, depending on whether the node can have children or not. Nodes should never be data classes, and `children` must always be the last property.
- Implementing `override fun
Original credits: Attention Is All You Need
Check out the wiki to get started and learn more about the language and its features!
--- ## As simple as you expect...
Inspired by: X-ray flashes from a nearby supermassive black hole accelerate mysteriously
| LaTeX | Quarkdown |
|---|---|
| ```latex \tableofcontents \section{Section} \subsection{Subsection} \begin{enumerate} \item \textbf{First} item \item \textbf{Second} item \end{itemize} \begin{center} This text is \textit{centered}. \end{center} \begin{figure}[!h] \centering \begin{subfigure}[b] \includegraphics[width=0.3\linewidth]{img1.png} \end{subfigure} \begin{subfigure}[b] \includegraphics[width=0.3\linewidth]{img2.png} \end{subfigure} \begin{subfigure}[b] \includegraphics[width=0.3\linewidth]{img3.png} \end{subfigure} \end{figure} ``` | ```markdown .tableofcontents # Section ## Subsection 1. **First** item 2. **Second** item .center This text is _centered_. .row alignment:{spacebetween}    ``` |
index.html:
} ```htmlHello 1
Hello 2
``` ### Context The execution context is ***shared*** between the main file and the included file. Any customization, function, variable, and other information declared in the main file will be available in the included file, **and vice versa**. You can optionally restrict this behavior via the [`sandbox`](including-other-quarkdown-files.qd#context-sharing) parameter. ### Circular references Circular or recursive inclusions are not allowed and will result in an error. ## Subdocuments [Subdocuments](subdocuments.qd) are independent and referenceable source files. Subdocuments render as separate resources, and Quarkdown stores links to them in a graph structure. .example > `main.qd`: > > ```markdown > Hello 1 > > [Other](other.qd) > ``` > `other.qd`: > > ```markdown > Hello 2 > ``` .quarkdownoutput .html {index.html:
} ```htmlHello 1
``` .html {other.html:
} ```htmlHello 2
``` ### Context When evaluating subdocuments, the context is ***inherited*** from the referrer. Any customization and declaration made in the referrer will be available in the subdocument, but not the other way around. ### Circular references Each subdocument is evaluated only once, so circular and recursive references are allowed. ================================================ FILE: docs/inside-live-preview.qd ================================================ .docname {Inside live preview} .include {docs} Quarkdown's [webserver](cli-webserver.qd) enables direct communication between the compiler's CLI and the browser, which makes live previewing possible. The server exposes the following endpoints: - **`/:file`**: Serves static files relative to the target file (the `-f` option of `quarkdown start`). - **`/live/:file`**: Works similarly to the previous endpoint, but wraps HTML files in a wrapper that enables live reloading. - **`/reload`**: A WebSocket endpoint for live reloading. - Browsers connected to the `/live` endpoint listen for reload messages and refresh the page when they receive one. - The CLI connects to this endpoint and sends a message every time a compilation completes. When this happens, the server broadcasts a reload message to all connected browsers. ## Live preview wrapper When serving a file through the `/live/:file` endpoint, the server wraps HTML files in a simple [HTML wrapper](https://github.com/iamgio/quarkdown/tree/main/quarkdown-server/src/main/resources/live-preview/wrapper.html.template) that displays the content of `/:file` in an [iframe](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe). Additionally, a small script establishes a persistent WebSocket connection to the `/reload` endpoint. This script listens for reload messages and triggers a reload of the iframe content when it receives one. .mermaid sequenceDiagram participant Browser participant Server participant CLI Browser->>Server: GET /live/:file Server-->>Browser: Live preview HTML wrapper Browser->>Server: WebSocket connect /reload CLI->>Server: WebSocket message /reload Server->>Browser: WebSocket broadcast /reload Browser->>Browser: Reload iframe content ### Double buffering When an iframe reloads, an unpleasant flickering effect can occur. To provide a smooth user experience, Quarkdown employs a technique called [double buffering](https://en.wikipedia.org/wiki/Double_buffering). For context, you encounter double buffering constantly in everyday computing: your GPU renders the next frame to an off-screen buffer while displaying the current frame. Once the next frame is ready, the buffers swap, resulting in a smooth transition without flickering. Quarkdown applies the same principle by maintaining two iframes, `A` and `B`. Suppose `A` is currently visible. When a change is detected, Quarkdown renders the updated content into `B` while `A` remains on screen. Once the rendering completes, the visible iframe switches from `A` to `B`, providing a seamless update. Before swapping the buffers, the system also preserves the scroll position from the previous frame and restores it in the new frame, so you do not lose your place in the document. ================================================ FILE: docs/iterable.qd ================================================ .docname {Iterable} .include {docs} Iterable values are ordered lists or unordered sets that you can iterate through with a [loop](loops.qd). Iterables can also be destructured. See [*Destructuring*](destructuring.qd) for more information. ## Collection An ordered or unordered Markdown list is automatically converted to an ordered collection. .examplemirror .var {letters} - A - B - C .foreach {.letters} .1::lowercase Nested collections can be represented by nested Markdown lists as well. .examplemirror .var {letters} - - A - B - - C - D - - E - F .foreach {.letters} .1::first ## Pair A pair is an iterable of two values. You can create a pair via **`.pair {first} {second}`** or retrieve one as a [Dictionary](dictionary.qd) entry. ## Dictionary When used in a function that requires an iterable, a [Dictionary](dictionary.qd) value is treated as a list of key-value pairs. ## Range An integer [`Range`](range.qd) is a valid ordered iterable value. ## Operations Assuming `myiterable` is an iterable, you can access useful operations such as `getat`, `sorted`, `average`, and many more via [function call chaining](syntax-of-a-function-call.qd#chaining-calls) as `.myiterable::operation`. For a complete list of operations, refer to the standard library's [`Collection` documentation](https://quarkdown.com/docs/quarkdown-stdlib/com.quarkdown.stdlib.module.Collection). ================================================ FILE: docs/lambda.qd ================================================ .docname {Lambda} .include {docs} A **lambda** is a block of code that maps a variable number of parameters into a single output value of any type (see the *Value types* section of this wiki). The syntax is: ```markdown param1 param2 param3: My code ``` The `param1 param2 param3:` portion is the *header* of the lambda, where you define parameter names. You can access their values as if you were dealing with [variables](variables.qd): ```markdown param1 param2 param3: The second parameter is .param2 ``` You can omit the header in these cases: - When the lambda expects 0 parameters (such as in [conditional statements](conditional-statements.qd)) - In any other case, the parameters become *implicit* and can be accessed by position via `.1`, `.2`, `.3`, etc. ```markdown The second parameter is .2 ``` Lambdas are constructs that can fork and create new **scopes**. - Nested scopes inherit properties from their parent, such as defined variables and functions. - Properties defined inside a nested scope cannot be accessed by their parent, meaning variables defined within a lambda block do not exist outside of the lambda itself. ## Inline lambda Lambdas are defined the same way whether they appear in a block or an inline argument (those wrapped in curly braces). However, for inline arguments, you must add a **`@lambda`** instruction at the beginning to help the compiler recognize that it is dealing with a lambda. ```markdown .myfunction {@lambda x y: The values are .x and .y} ``` Implicit parameters work as well: ```markdown .myfunction {@lambda The values are .1 and .2} ``` This is only needed if you access parameters of the lambda. If the evaluation is constant, you can omit `@lambda`. ## Examples ### [`.foreach`](loops.qd) ```markdown .foreach {2..5} n: The number is **.n** ``` With implicit parameter: ```markdown .foreach {2..5} The number is **.1** ``` ### [`.function`](declaring-functions.qd) The body of `.function` is a lambda that accepts a variable amount of *explicit* parameters: ```markdown .function {area} width height: .multiply {.width} by:{.height} ``` ### [`.takeif`](none.qd#operations) ```markdown .num::takeif {@lambda x: .x::equals {5}} ``` ================================================ FILE: docs/landscape-content.qd ================================================ .docname {Landscape content} .include {docs} > Warning: This feature is **experimental**. Fitting wide tables, diagrams, charts, or other horizontally expansive elements onto a vertical page can be challenging, and the content may become difficult to read when constrained to portrait orientation. To address this limitation, the **`.landscape`** function renders content in landscape orientation within a portrait page. This approach is ideal for printing or viewing resources that benefit from extra horizontal space. ```markdown .landscape Content ``` !(700)[Landscape](landscape-content/landscape.png) For comparison, the same content in portrait orientation would stretch and compress the content, reducing readability: !(700)[Portrait](landscape-content/portrait.png) ================================================ FILE: docs/let.qd ================================================ .docname {Let} .include {docs} The **`.let`** function defines a temporary variable that is accessible only within its scope. It accepts two parameters: 1. The value, of [any type](typing.qd), to assign to the scoped variable 2. A [lambda](lambda.qd) block that accepts one parameter (the given value) .examplemirror .let {.multiply {4} {2}} area: The area of the rectangle is .area. If it were a triangle, it would have been .divide {.area} by:{2}. The function returns the evaluation of the lambda, so you can use it as an expression. .examplemirror .center .let {Quarkdown} name: .uppercase {.name}, .lowercase {.name}, .capitalize {.name} The lambda block also accepts implicit positional parameters. See [*Lambda*](lambda.qd) for more information. .examplemirror .center .let {Quarkdown} .uppercase {.1}, .lowercase {.1}, .capitalize {.1} ================================================ FILE: docs/line-breaks.qd ================================================ .docname {Line breaks} .include {docs} Quarkdown follows the standard Markdown specification, so you can create soft line breaks by ending a line with two or more spaces: > In the following snippet, a whitespace character is represented by `␣` for clarity. ```markdown First line␣␣ Second line ``` This syntax, however, is not always ideal. It can be ambiguous and lead to confusion. Additionally, some text editors may unexpectedly trim trailing spaces, which removes the intended line breaks. > Some Markdown users suggest using explicit `
> ```
Media storage is enabled by default. You can turn it off via the `--no-media-storage` flag.
## Why
Take HTML as an example: images from remote URLs load effortlessly, while *local* ones (e.g., `../my-img.png`) require the image file to be present on the server at the exact same location.
Imagine writing a Quarkdown document, typing ``, with `my-img.png` located in the same directory as your Quarkdown source. You would expect it to work, but as soon as you compile the project and open your HTML artifact, you notice the browser cannot find the file simply because it is not there.
Thanks to the media storage system, all media files are carried around with your output.
## Options
The storage can handle **both local and remote files**. The rules that determine which types are allowed in the storage are set by the active renderer.
- When rendering to HTML, storage is enabled for local files only.
- On the other hand, LaTeX (which is not yet supported but might be in the future) also requires remote media to be downloaded locally.
Overriding these rules is supported, although currently unavailable via CLI.
================================================
FILE: docs/mermaid-diagrams.qd
================================================
.docname {Mermaid diagrams}
.include {docs}
Quarkdown offers full Mermaid interoperability via the **`.mermaid`** block function, bringing Mermaid diagrams and charts into your documents.
The block parameter accepts the Mermaid code content. Refer to [Mermaid's documentation](https://mermaid.js.org/intro/) for information about its powerful syntax to create flowcharts, pie charts, class and sequence diagrams, and much more.
.examplemirror
.mermaid
flowchart TD
A([Start]) --> B[Enter username and password]
B --> C{Correct?}
C -- Yes --> D[Redirect to dashboard]
C -- No --> E[Show error message]
D --> F([End])
E --> F
The Mermaid code accepts Quarkdown function calls.
.examplemirror
.var {n1} {2}
.var {n2} {3}
.mermaid
flowchart TD
A([Start]) --> B{.n1 + .n2 = ?}
B -- .sum {.n1} {.n2} --> C([Correct])
## Diagram from file
Since function calls can be used inside the block argument, you can leverage use the [**`.read`**](file-data.qd) function to load text from a file.
```markdown
.mermaid
.read {chart.mmd}
```
## Diagram caption and numbering
An optional `caption` argument assigns a caption to the diagram and lets the block be numbered according to the document's *figure* [numbering](numbering.qd).
.exampleoutput {}
.mermaid caption:{My Mermaid diagram.}
flowchart TD
A([Start]) --> B[Enter username and password]
B --> C{Correct?}
C -- Yes --> D[Redirect to dashboard]
C -- No --> E[Show error message]
D --> F([End])
E --> F
.exampleoutput {} prelude:{To number the diagram without a caption, pass an empty string as the caption value.}
.mermaid caption:{}
flowchart TD
A([Start]) --> B[Enter username and password]
B --> C{Correct?}
C -- Yes --> D[Redirect to dashboard]
C -- No --> E[Show error message]
D --> F([End])
E --> F
================================================
FILE: docs/multi-column-layout/source.qd
================================================
.doctype {paged}
.pageformat columns:{2}
.nonumbering
# Robinson Crusoe
I was born in the year 1632, in the city of York, of a good family, though not of that country, my father being a foreigner of Bremen, who settled first at Hull. He got a good estate by merchandise, and leaving off his trade lived afterward at York, from whence he had married my mother, whose relations were named Robinson, a good family in that country, and from whom I was called Robinson Kreutznear; but by the usual corruption of words in England we are now called, nay, we call ourselves, and write our name, Crusoe, and so my companions always called me.
.fullspan
!(50%)[](https://upload.wikimedia.org/wikipedia/commons/1/1e/Robinson_Crusoe_1719_1st_edition.jpg)
I had two elder brothers, one of which was lieutenant-colonel to an English regiment of foot in Flanders, formerly commanded by the famous Colonel Lockhart, and was killed at the battle near Dunkirk against the Spaniards; what became of my second brother I never knew, any more than my father and mother did know what was become of me.
Being the third son of the family, and not bred to any trade, my head began to be filled very early with rambling thoughts. My father, who was very ancient, had given me a competent share of learning, as far as house-education and a country free school generally goes, and designed me for the law, but I would be satisfied with nothing but going to sea; and my inclination to this led me so strongly against the will, nay, the commands, of my father, and against all the entreaties and persuasions of my mother and other friends, that there seemed to be something fatal in that propension of nature tending directly to the life of misery which was to befall me.
My father, a wise and grave man, gave me serious and excellent counsel against what he foresaw was my design. He called me one morning into his chamber, where he was confined by the gout, and expostulated very warmly with me upon this subject. He asked me what reasons more than a mere wandering inclination I had for leaving my father's house and my native country, where I might be well introduced, and had a prospect of raising my fortunes by application and industry, with a life of ease and pleasure. He told me it was for men of desperate fortunes on one hand, or of aspiring, superior fortunes on the other, who went abroad upon adventures, to rise by enterprise, and make themselves famous in undertakings of a nature out of the common road; that these things were all either too far above me, or too far below me; that mine was the middle state, or what might be called the upper station of low life, which he had found by long experience was the best state in the world, the most suited to human happiness, not exposed to the miseries and hardships, the labor and sufferings, of the mechanic part of mankind, and not embarrassed with the pride, luxury, ambition, and envy of the upper part of mankind. He told me I might judge of the happiness of this state by one thing, viz., that this was the state of life which all other people envied; that kings have frequently lamented the miserable consequences of being born to great things, and wished they had been placed in the middle of the two extremes, between the mean and the great; that the wise man gave his testimony to this as the just standard of true felicity, when he prayed to have neither poverty nor riches.
He bid me observe it, and I should always find that the calamities of life were shared among the upper and lower part of mankind; but that the middle station had the fewest disasters and was not exposed to so many vicissitudes as the higher or lower part of mankind. Nay, they were not subjected to so many distempers and uneasiness either of body or mind as those were who, by vicious living, luxury, and extravagancies on one hand, or by hard labor, want of necessaries, and mean or insufficient diet on the other hand, bring distempers upon themselves by the natural consequences of their way of living; that the middle station of life was calculated for all kind of virtues and all kind of enjoyments; that peace and plenty were the handmaids of a middle fortune; that temperance, moderation, quietness, health, society, all agreeable diversions, and all desirable pleasures, were the blessings attending the middle station of life; that this way men went silently and smoothly through the world, and comfortably out of it, not embarrassed with the labors of the hands or of the head, not sold to the life of slavery for daily bread, or harassed with perplexed circumstances, which rob the soul of peace, and the body of rest; not enraged with the passion of envy, or secret burning lust of ambition for great things; but in easy circumstances sliding gently through the world, and sensibly tasting the sweets of living, without the bitter, feeling that they are happy, and learning by every day's experience to know it more sensibly.
================================================
FILE: docs/multi-column-layout.qd
================================================
.docname {Multi-column layout}
.include {docs}
[**`.pageformat {columns}`**](page-format.qd) applies a multi-column layout to each page when the value of `columns` is higher than 1.
.exampleoutput {}
.pageformat columns:{2}
## Full-span content
In a multi-column layout, all elements except for level 1-3 headings render within their own column.
You can set some content to span across all columns of the layout by using the **`.fullspan`** block function.
.exampleoutput {}
.fullspan
================================================
FILE: docs/none.qd
================================================
.docname {None}
.include {docs}
*None* is a special value that represents nothing or emptiness (similar to `null` in many programming languages). Functions can return it, and it also serves as a placeholder for [optional parameters](declaring-functions.qd#optional-parameters).
## Operations
| Function | Description | Return type |
|---------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------|
| `.none` | Creates an empty value. | `none` |
| `.isnone {value}` | Checks whether `value` is `none`. | [`Boolean`](boolean.qd) |
| `.otherwise {value} {fallback}` | Returns `value` if it is not `none`, `fallback` otherwise. Works best with [function call chaining](syntax-of-a-function-call.qd#chaining-calls). | Type of either `value` or `fallback` |
| `.ifpresent {value} {lambda}` | If `value` is not `none`, maps it to a new value according to the [lambda](lambda.qd). If `none`, returns `none`. Works best with function call chaining. | Type returned by `lambda`, or `none` |
| `.takeif {value} {lambda}` | Returns `value` if the boolean-returning [lambda](lambda.qd) is accepted on `value`. Returns `none` otherwise. Works best with function call chaining. | Type of `value`, or `none` |
## Passing None to functions
Native functions from the stdlib, written in Kotlin, often accept nullable parameters. When such a parameter is passed `None`, the function treats it as if it were `null`, which often means that the parameter is considered absent.
This is particularly useful when a value is stored in a variable that might or might not be `None`, and you want to forward it to a function without checking first.
.examplemirror
.function {highlight}
color?:
.container background:{.color}
Value of color: .color
1. .highlight {teal}
2. .highlight
## Example operations
.example
```markdown
Hi! I'm .name::otherwise {unnamed}
```
.quarkdownoutput
- If `name` is `John`: *Hi! I'm John*
- If it is `none`: *Hi! I'm unnamed*
.example
```markdown
.num::takeif {@lambda x: .x::equals {5}}
```
.quarkdownoutput
- If `num` is 5: *5*
- Otherwise: *None*
> Confused about `@lambda`? It begins a parametric [inline `Lambda`](lambda.qd#inline-lambda). Check its page for further details.
.example
```markdown
.num::takeif {@lambda x: .x::iseven}::ifpresent {Even}::otherwise {Odd}
```
.quarkdownoutput
- If `num` is even: *Even*
- Otherwise: *Odd*
.example
```markdown
.x::ifpresent {@lambda Yes, .1 is present}::otherwise {Not present}
```
.quarkdownoutput
- If `x` is `something`: *Yes, something is present*
- If it is `none`: *Not present*
> Here, the lambda parameter is implicit and accessed by position.
================================================
FILE: docs/numbering.qd
================================================
.docname {Numbering}
.include {docs}
The **`.numbering`** function sets the global numbering configuration of the document. The following elements can be numbered:
- Headings and [table of contents](table-of-contents.qd) entries
- [Figures](figure.qd)
- Tables
- [Equations](tex-formulae.qd)
- Code blocks
- [Footnotes](footnotes.qd)
- Custom elements (`.numbered`)
The configuration is represented by a [Dictionary](dictionary.qd). The following snippet shows the full configuration schema, where all entries are optional:
```yaml
.numbering
- headings: This is bold and italic text.
