diff --git a/packages/preview/cmarker/0.1.10/LICENSE b/packages/preview/cmarker/0.1.10/LICENSE
new file mode 100644
index 0000000000..6be1b0d13c
--- /dev/null
+++ b/packages/preview/cmarker/0.1.10/LICENSE
@@ -0,0 +1,7 @@
+Copyright 2023 Sabrina Jewson
+
+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, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+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/cmarker/0.1.10/README.md b/packages/preview/cmarker/0.1.10/README.md
new file mode 100644
index 0000000000..698ada4dac
--- /dev/null
+++ b/packages/preview/cmarker/0.1.10/README.md
@@ -0,0 +1,900 @@
+# cmarker.typ
+
+<!--raw-typst #align(center)[https://github.com/SabrinaJewson/cmarker.typ] -->
+
+This package enables you to write CommonMark Markdown,
+and import it directly into Typst.
+
+<table>
+<tr>
+<th><code>simple.typ</code></th>
+<th><code>simple.md</code></th>
+</tr>
+<tr>
+<td>
+
+```typ
+#import "@preview/cmarker:0.1.10"
+
+#cmarker.render(read("simple.md"))
+```
+</td>
+<td>
+
+```markdown
+# We can write Markdown!
+
+*Using* __lots__ ~of~ `fancy` [features](https://example.org/).
+```
+</td>
+</tr>
+</table>
+<table>
+<tr><th><code>simple.pdf</code></th></tr>
+<tr><td><img src="./examples/simple.png" alt="`simple.md` rendered as a PDF"></td></tr>
+</table>
+
+This document is available
+in [Markdown](https://github.com/SabrinaJewson/cmarker.typ/tree/release#cmarker)
+and [rendered PDF](https://github.com/SabrinaJewson/cmarker.typ/blob/release/README.pdf)
+formats.
+
+## Contents
+
+2. [API](#api)
+2. [References, labels, figures and citations](#references-labels-figures-and-citations)
+2. [Supported Markdown syntax](#supported-markdown-syntax)
+2. [Interleaving Markdown and Typst](#interleaving-markdown-and-typst)
+2. [FAQ](#faq)
+2. [Development](#development)
+
+## API
+
+We offer two functions:
+1. [render](#render)
+2. [render-with-metadata](#render-with-metadata)
+
+### render
+```typc
+render(
+  markdown,
+  smart-punctuation: true,
+  math: none,
+  task-list-marker: none,
+  h1-level: 1,
+  set-document-title: true,
+  raw-typst: true,
+  html: (:),
+  label-prefix: "",
+  prefix-label-uses: true,
+  heading-labels: "github",
+  scope: (:),
+  show-source: false,
+  blockquote: none,
+) -> content
+```
+
+The `render` function renders the given Markdown and returns content.
+
+#### `markdown`
+
+The [CommonMark](https://spec.commonmark.org/0.30/) Markdown string to be processed.
+Parsed with the [pulldown-cmark](https://docs.rs/pulldown-cmark) Rust library.
+You can set this to `read("somefile.md")` to import an external markdown file;
+see the
+[documentation for the read function](https://typst.app/docs/reference/data-loading/read/).
+- Accepted values: Strings and raw text code blocks.
+- Required.
+
+#### `smart-punctuation`
+
+Whether to automatically convert ASCII punctuation to Unicode equivalents:
+- nondirectional quotations (" and ') become directional (“” and ‘’);
+- three consecutive full stops (...) become ellipses (…);
+- two and three consecutive hypen-minus signs (-- and ---)
+	become en and em dashes (– and —).
+
+Note that although Typst also offers this functionality,
+this conversion is done through the Markdown parser rather than Typst.
+- Accepted values: Booleans.
+- Default value: `true`.
+
+#### `math`
+
+A callback to be used when equations are encountered in the Markdown,
+or `none` if it should be treated as normal text.
+Because Typst does not support LaTeX equations natively,
+the user must configure this.
+- Accepted values:
+	Functions that take a boolean argument named `block` and a positional string argument
+	(often, the `mitex` function from
+	[the mitex package](https://typst.app/universe/package/mitex)),
+	or `none`.
+- Default value: `none`.
+
+For example, to render math equation as a Typst math block,
+one can use:
+```typ
+#import "@preview/mitex:0.2.7": mitex
+#cmarker.render(`$\int_1^2 x \mathrm{d} x$`, math: mitex)
+```
+<!--raw-typst
+which renders as: $integral_1^2 x dif x$
+-->
+
+#### `task-list-marker`
+
+A callback which can be used to render Markdown task lists,
+or `none` if task lists are not supported.
+The callback will be called with `true` if the checkbox is to be checked (`- [x]`),
+and `false` if it is unchecked (`- [ ]`).
+
+- Accepted values:
+	Functions from booleans to content, or `none`.
+- Default value: `none`.
+
+You may want to use [`cheq`](https://typst.app/universe/package/cheq) to provide the checkboxes:
+
+````typ
+#import "@preview/cheq:0.3.1"
+
+#cmarker.render(
+  ```md
+  - [ ] Not checked
+  - [x] Checked
+  ```,
+  task-list-marker: checked => if checked { cheq.checked-sym() } else { cheq.unchecked-sym() },
+)
+````
+
+#### `h1-level`
+
+The level that top-level headings in Markdown should get in Typst.
+When set to zero,
+top-level headings are treated as titles,
+`##` headings become `=` headings,
+`###` headings become `==` headings,
+et cetera;
+when set to `2`,
+`#` headings become `==` headings,
+`##` headings become `===` headings,
+et cetera.
+- Accepted values: Integers in the range [-128, 127].
+- Default value: 1.
+
+#### `set-document-title`
+
+Whether to emit a `#set document(title: […])` line
+for `#title()`s.
+
+If you encounter a “document set rules are not allowed inside of containers” error,
+you should set this to `false`,
+and potentially add a `#set document(title: […])` line manually.
+
+This has effect when [`h1-level`](#h1-level) is zero
+and you have a top-level (i.e. `#`) heading.
+
+- Accepted values: Booleans.
+- Default value: `true`.
+
+#### `raw-typst`
+
+Whether to allow raw Typst code to be injected into the document via HTML comments.
+If disabled, the comments will act as regular HTML comments.
+- Accepted values: Booleans.
+- Default value: `true`.
+
+For example, when this is enabled, `<!--raw-typst #circle(radius: 10pt) -->`
+will result in a circle in the document
+(but only when rendered through Typst).
+See also
+[`<!--typst-begin-exclude-->` and `<!--typst-end-exclude-->`](#interleaving-markdown-and-typst),
+which is the inverse of this.
+
+#### `html`
+
+The dictionary of HTML elements that cmarker will support.
+- Accepted values:
+	Dictionaries whose keys are the tag name (without the surrounding `<>`)
+	and whose values can be:
+	- `("normal", (attrs, body) => [/* … */])`:
+		Defines a normal element,
+		where `attrs` is a dictionary of strings, `body` is content,
+		and the function returns content.
+	- `("void", (attrs) => [/* … */])`:
+		Defines a void element (e.g. `<br>`, `<img>`, `<hr>`).
+	- `("raw-text", (attrs, body) => [/* … */])`:
+		Defines a raw text element (e.g. `<script>`, `<style>`),
+		where `body` is a string.
+	- `("escapable-raw-text", (attrs, body) => [/* … */])`:
+		Defines an escapable raw text element (e.g. `<textarea>`),
+		where `body` is a string.
+	- `(attrs, body) => [/* … */]`: Shorthand for
+		`("normal", (attrs, body) => [/* … */])`.
+- Default value: `(:)`.
+- Overridable keys:
+	The following HTML elements are provided by default,
+	but you are free to override them:
+	`<sub>`,
+	`<sup>`,
+	`<mark>`,
+	`<h1>`–`<h6>`,
+	`<ul>`,
+	`<ol>`,
+	`<li>`,
+	`<dl>`,
+	`<dt>`,
+	`<dd>`,
+	`<table>`,
+	`<thead>`,
+	`<tfoot>`,
+	`<tr>`,
+	`<th>`,
+	`<td>`,
+	`<hr>`,
+	`<a>`,
+	`<em>`,
+	`<strong>`,
+	`<s>`,
+	`<code>`,
+	`<br>`,
+	`<blockquote>`,
+	`<figure>`,
+	`<figcaption>`,
+	`<svg>`,
+	`<img>`.
+
+For example, the following code
+would allow you to write `<circle radius="25">` to render a 25pt circle:
+
+```typ
+#cmarker.render(read("example.md"), html: (
+  circle: ("void", attrs => circle(radius: int(attrs.radius) * 1pt))
+))
+```
+
+#### `label-prefix`
+
+If present, any labels autogenerated by footnotes and headings will be prefixed by this string.
+This is useful to avoid collisions.
+- Accepted values: A valid label or the empty string.
+- Default value: The empty string.
+
+#### `prefix-label-uses`
+
+Whether references to labels such as `[@label]` and `[link](#label)`
+should be prefixed by `label-prefix`.
+- Accepted values: Booleans.
+- Default value: `true`.
+
+#### `heading-labels`
+
+How the cases of labels autogenerated by headings should be transformed.
+The label prefix (given in `label-prefix`) will **not** be transformed.
+- Accepted values:
+	- `"github"`:
+		Match [GitHub’s slugification algorithm](https://github.com/Flet/github-slugger):
+		strip out invalid characters, lowercase everything, convert ASCII spaces to hyphens,
+		and number duplicate headings to avoid collisions.
+		For example, `# My heading!` will become `<my-heading>`.
+	- `"jupyter"`:
+		Match [Jupyter’s slugification algorithm](https://github.com/jupyterlab/jupyterlab/blob/b3094f1156ad67e23f91f0cc8cc676123c8eb448/packages/rendermime/src/renderers.ts#L400):
+		just convert ASCII spaces to hyphens.
+		For example, `# My heading!` will become `<My-heading!>`.
+		Unlike the real Jupyter, we also number duplicate headings,
+		but this shouldn’t have any difference in practice since
+		Jupyter doesn’t allow referring to duplicate headings anyway.
+	- `none`: Don’t add automatic labels to headings.
+- Default value: `"github"`.
+
+#### `scope`
+
+A dictionary providing the context in which the evaluated Typst code runs.
+It is useful to pass values in to code inside `<!--raw-typst-->` blocks,
+but can also be used to override element functions generated by cmarker itself.
+- Accepted values: Any dictionary.
+- Default value: `(:)`.
+- Overridable keys:
+	- All built-in Typst functions.
+	- `rule`:
+		Deprecated!
+		This used to be a function returning content
+		to be used when [thematic breaks](#thematic-breaks) (`---` in Markdown) are encountered.
+		Since Typst 0.15, this is just [`divider`](https://typst.app/docs/reference/model/divider/).
+
+#### `show-source`
+
+A debugging tool.
+When set to `true`, the Typst code that would otherwise have been displayed
+will be instead rendered in a code block.
+- Accepted values: Booleans.
+- Default value: `false`.
+
+#### `blockquote`
+Deprecated!
+This used to control how blockquotes were rendered,
+but we now default to `quote(block: true)`.
+If you want to override how blockquotes look,
+either use `#show quote.where(block: true)`
+or use `scope: (quote: …)`.
+- Accepted values: Functions accepting content and returning content, or `none`.
+- Default value: `none`.
+
+### render-with-metadata
+
+```typc
+render-with-metadata(
+  markdown,
+  smart-punctuation: true,
+  math: none,
+  task-list-marker: none,
+  h1-level: 1,
+  set-document-title: true,
+  raw-typst: true,
+  html: (:),
+  label-prefix: "",
+  prefix-label-uses: true,
+  heading-labels: "github",
+  scope: (:),
+  show-source: false,
+  blockquote: none,
+  metadata-block: none,
+) -> (metadata, content)
+```
+
+The `render-with-metadata` functions works the same as `render` with two exceptions:
+1. This function returns `(meta, body)`. This allows the user to freely manipulate the metadata.
+	```typ
+	#let (meta, body) = cmarker.render-with-metadata(read("example.md"))
+	// `body` will be the same as:
+	#let body = cmarker.render(read("example.md"))
+	```
+2. This function has an extra argument: `metadata-block`. The other arguments are the same as `render`.
+
+#### `metadata-block`
+
+How to parse the metadata block.
+Only a single metadata block at the beginning of the document is supported;
+metadata blocks not at the start will be ignored.
+If `none`, the metadata block will not be parsed.
+The behaviour is the same as using `render`.
+- Accepted values:
+	- `"frontmatter-raw"`:
+		Parse the metadata block and return it as a string.
+	- `"frontmatter-yaml"`:
+		Parsed the metadata block as YAML and return it as a dictionary.
+	- `none`.
+- Default value: `none`.
+
+## References, labels, figures and citations
+
+`cmarker.typ` integrates well with Typst’s native references and labels.
+Where in Typst you would write `@foo`, in Markdown you write `[@foo]`;
+where in Typst you would write `@foo[Chapter]`, in Markdown you’d write `[Chapter][@foo]`.
+You can also write `[some text](#foo)` to have “some text” be a link that points at `foo`.
+
+Headings are automatically given references according to their name,
+but lowercased and with spaces replaced by hyphens
+(although this can be controlled with the [`heading-labels`](#heading-labels) option):
+
+```md
+# My nice heading
+
+We can make a link to [this section](#my-nice-heading).
+We can refer you to [@my-nice-heading]. <!-- generates “We can refer you to Section 1.” -->
+Or to [Chapter][@my-nice-heading]. <!-- generates “We can refer you to Chapter 1.” -->
+```
+
+If you have two headings with the same title,
+they’ll be numbered sequentially in the fashion of GitHub Markdown:
+`heading`, `heading-1`, `heading-2`, etc.
+
+If you want to cite something from a bibliography,
+you can do it much the same way: `[@citation]`.
+
+If you want to customize the label of a heading from the default,
+you can use `id=` in HTML, or use `raw-typst` blocks
+(note that these **must** be preceded by a newline):
+
+```md
+<h1 id="my-nice-section">My nice heading</h1>
+
+# My other nice heading
+<!--raw-typst <my-other-nice-section> -->
+
+See [@my-nice-section] and [@my-other-nice-section].
+<!-- generates “See Section 1 and Section 2.” -->
+```
+
+This can also be used with figures, which is very powerful:
+
+```md
+Please refer to [@my-graph]. <!-- generates “Please refer to Figure 1.” -->
+
+<figure id="my-graph">
+
+![a graph](graph.png)</figure>
+```
+
+If you encounter collision errors across multiple Markdown files,
+you can set [the `label-prefix` option](#label-prefix).
+For example, setting
+`label-prefix: "file-a-"` will convert the label of
+`# My Heading` into `file-a-my-heading`.
+By default, references within the file will expect the unprefixed name;
+this can be changed by setting [`prefix-label-uses: false`](#prefix-label-uses).
+
+## Supported Markdown syntax
+
+We support CommonMark with a couple extensions.
+
+### Line breaks
+
+A single newline becomes a space;
+two consecutive newlines (i.e. one blank line) give a paragraph break;
+two spaces before a newline gives a hard line break
+(used for example in poetry) –
+you can also write `<br>` to the same effect.
+
+### Formatting
+
+- *Emphasis*: `*emphasis*` or `_emphasis_`
+- **Strong**: `**strong**` or `__strong__`
+- ~Strikethrough~: `~strikethrough~`
+- <sub>Subscript</sub>: `<sub>subscript</sub>`
+- <sup>Superscript</sup>: `<sup>superscript</sup>`
+- <mark>Highlighting</mark>: `<mark>highlighted</mark>`
+- Inline code blocks: `` `code here` ``
+- Out-of-line code blocks:
+	````
+	```
+	code here
+	```
+	````
+	Syntax highlighting can be achieved by specifying a language after the opening backticks:
+	````
+	```rust
+	let x = 5;
+	```
+	````
+- Blockquotes:
+	```md
+	> Whereas recognition of the inherent dignity and of
+	> the equal and inalienable rights of all members of
+	> the human family is the foundation of freedom,
+	> justice and peace in the world,
+	```
+
+### Links
+
+You can link to a URL directly: `[link](https://example.org)`
+
+Or you can reuse URLs by defining them out-of-line:
+
+```md
+[This link] and [that link][This link] go to the same place.
+
+[This link]: https://example.org
+```
+
+See [the section on labels](#references-labels-figures-and-citations)
+for using links with Typst labels and citations.
+
+### Images
+
+```md
+![alt text here](path/to/image.png)
+```
+
+Due to the way Typst resolves paths,
+in order for this to work you will need to override the `image` function in the [`scope`](#scope):
+
+```typ
+#cmarker.render(
+  read("example.md"),
+  scope: (image: (source, ..args) => image(source, ..args))
+)
+```
+
+You can use the HTML `<img>` tag, which allows you to specify the width and height of the
+image, either as a `%` or as an absolute value.
+The below image will span 50% of the page and be 20pt tall:
+
+```md
+<img src="path/to/image.png" alt="alt text here" width="50%" height="20">
+```
+
+#### Spaces in image paths
+
+Be aware that image paths that contain spaces must be wrapped in `<>`:
+
+```md
+<!-- Incorrect: Will render as text -->
+![alt text](image path.png)
+
+<!-- Correct: Will give an image -->
+![alt text](<image path.png>)
+```
+
+#### External images
+
+Since Typst compilation has no network access,
+you won’t be able to include images from external URLs.
+For example, the below will fail:
+
+```md
+<!-- Bad -->
+![the Typst logo](https://upload.wikimedia.org/wikipedia/commons/f/f8/Typst.svg)
+```
+
+You instead need to download the image
+and reference the local path.
+
+```md
+<!-- Good -->
+![the Typst logo](Typst.svg)
+```
+
+#### Alt text and captions
+
+Alt text – which is specified between the `[]` –
+is used by screen readers and other assistive technologies,
+and won’t be visible in the document by default.
+It should provide a description of the image
+that makes the document readable to anyone who can’t see the image.
+
+If you want to add a caption to the image
+that will be visible to all readers,
+you should set a `<figcaption>` explicitly.
+For example:
+
+```md
+<figure>
+
+![alt text](image.png)
+<figcaption>caption text</figcaption>
+</figure>
+```
+
+You can alternatively transform all alt text into captions automatically:
+
+```typ
+#cmarker.render(
+  read("example.md"),
+  scope: (
+    image: (source, alt: none, ..args) => {
+      figure(image(source, alt: alt, ..args), caption: alt)
+    },
+  ),
+)
+```
+
+However, this has disadvantage that
+you can’t use markup in the caption,
+because alt text is just a plain string and not content.
+(In theory, Markdown supports markup in image alt text,
+but our Markdown parser stringifies it anyway
+because Typst only supports strings in alt text.
+It’s possible we could add extra functionality for this use case.)
+
+### Headings
+
+Headings are denoted with hashes at the start of the line:
+
+```md
+# Title of the document
+## Sub-heading
+### Sub-sub-heading
+```
+
+The [h1-level](#h1-level) option controls how Markdown heading levels become Typst heading levels.
+
+Headings will have Typst labels automatically generated from their content –
+the `heading-labels` option controls this.
+If you want to to specify a label explicitly, see
+[the section on labels](#references-labels-figures-and-citations).
+
+### Thematic breaks
+
+Add a thematic break (horizontal rule) with `---`.
+This corresponds to the Typst code [`#divider()`](https://typst.app/docs/reference/model/divider/):
+
+---
+
+### Lists
+
+Unordered (bullet-point) lists are denoted with `-`, `+` or `*`:
+```md
+- Foo
+- Bar
+```
+
+Ordered (numbered) lists are denoted with `1.` or `1)`:
+```md
+1. Foo
+1. Bar
+```
+
+The numbers will be generated automatically.
+
+### Math equations
+
+Math formulae are denoted with dollars: `$x + y$` or `$$x + y$$`.
+This requires the [`math`](#math) parameter to be set,
+and the syntax of the equations is determined by that parameter.
+
+### Tables
+
+```md
+| Column 1 | Column 2 |
+| -------- | -------- |
+| Row 1 Cell 1 | Row 1 Cell 2 |
+| Row 2 Cell 1 | Row 2 Cell 2 |
+```
+
+You can also use HTML tables,
+which has greater flexibility for elements inside tables:
+
+```md
+<table>
+	<thead><tr><th>Column 1</th><th>Column 2</th></tr></thead>
+	<tr><td>Row 1 Cell 1</td><td>Row 1 Cell 2</td></tr>
+	<tr><td>Row 2 Cell 1</td><td>Row 2 Cell 2</td></tr>
+</table>
+```
+
+### Footnotes
+
+```md
+Some text[^footnote]
+
+[^footnote]: content
+```
+
+### Term/description lists
+
+Term/description lists:
+```md
+<dl>
+	<dt>Ligature</dt>
+	<dd>A merged glyph.</dd>
+	<dt>Kerning</dt>
+	<dd>A spacing adjustment between two adjacent letters.</dd>
+</dl>
+```
+
+### Figures
+
+```md
+<figure><figcaption>My lovely figure</figcaption>
+
+![a graph](graph.png)
+</figure>
+```
+
+### Inline SVG
+
+```md
+<svg version="1.1" width="100" height="100" xmlns="http://www.w3.org/2000/svg">
+	<circle cx="50" cy="50" r="50" fill="blue" />
+</svg>
+```
+
+### Task lists
+
+If you set the [`task-list-marker`](#task-list-marker) parameter,
+`cmarker.typ`s supports task lists:
+
+```md
+- [ ] Not checked
+- [x] Checked
+```
+
+## Interleaving Markdown and Typst
+
+Sometimes,
+you might want to render a certain section of the document
+only when viewed as Markdown,
+or only when viewed through Typst.
+To achieve the former,
+you can simply wrap the section in
+`<!--typst-begin-exclude-->` and `<!--typst-end-exclude-->`:
+
+```md
+<!--typst-begin-exclude-->
+Hello from not Typst!
+<!--typst-end-exclude-->
+```
+
+Most Markdown parsers support HTML comments,
+so from their perspective this is no different
+to just writing out the Markdown directly;
+but `cmarker.typ` knows to search for those comments
+and avoid rendering the content in between.
+
+Note that when the opening comment is followed by the end of an element,
+`cmarker.typ` will close the block for you.
+For example:
+
+```md
+> <!--typst-begin-exclude-->
+> One
+
+Two
+```
+
+In this code,
+“Two” will be given no matter where the document is rendered.
+This is done to prevent us from generating invalid Typst code.
+
+Conversely, one can put Typst code inside
+a HTML comment of the form
+`<!--raw-typst […]-->`
+to have it evaluated directly as Typst code
+(but only if [the `raw-typst` option](#raw-typst) is set to `true` –
+which it is by default –
+otherwise it will just be seen as a regular comment and removed):
+
+```md
+<!--raw-typst Hello from #text(fill:blue)[Typst]!-->
+```
+
+## FAQ
+
+### How do I include multiple Markdown files in one project?
+
+See [the multi-file example](https://github.com/SabrinaJewson/cmarker.typ/blob/release/examples/multi-file.typ).
+
+Note that this example uses a _single_ call to `render` with concatenated Markdown,
+i.e. `cmarker.render(read("file-a.md") + read("file-b.md"))`.
+If you instead wish to use
+`cmarker.render(read("file-a.md"))` followed by `cmarker.render(read("file-b.md"))`,
+you may encounter collision issues if two headings have the same name.
+This can be resolved in two ways:
+- Giving the headings an explicit ID:
+	`<h1 id="my-id">My Heading</h1>` instead of `# My Heading`.
+- Setting a [label prefix](#label-prefix), e.g. `label-prefix: "my-file-"`.
+
+### My Markdown after an open HTML tag is getting rendered as text!
+
+This is a Markdown quirk –
+in code like `<p>hello _world_</p>`
+or `<!-- -->hello _world_`,
+italics will not be generated.
+
+There are two fixes:
+either insert some empty inline-level HTML at the start,
+e.g. `<span></span><p>hello _world_</p>`,
+or insert two newlines after the opening tag:
+
+```
+<p>
+
+hello _world_</p>
+```
+
+### How to I save the resulting Typst file?
+
+`cmarker.typ` is not intended for one-time conversions from Markdown to Typst;
+it is intended for when you want to keep the Markdown file
+and continue to edit it,
+but have it be rendered with Typst.
+For one-time conversions,
+I’d recommend using [Pandoc](https://pandoc.org/) instead.
+
+If you still want to use it for this purpose,
+you can pass in [`show-source: true`](#show-source)
+and render to HTML using
+`typst compile --features html --format html your-file.typ`.
+Then, open `your-file.html` in a web browser and copy the code block.
+
+Alternatively, you can attach it to the PDF as follows:
+
+```typ
+#let typst-code = cmarker.render(read("example.md"), show-source: true)
+#pdf.attach("yourtypstcode.typ", bytes(typst-code.text))
+```
+
+And then extract the attachment from the generated PDF
+using your preferred PDF viewer.
+
+Since `cmarker.typ` does not attempt to make generated code readable,
+you may want to use
+a code formatter like [typstyle](https://github.com/typstyle-rs/typstyle)
+on the result.
+
+### How do I have headings start on a new page?
+
+[Show rules](https://typst.app/docs/reference/styling/#show-rules) are the best way:
+
+```typ
+#show heading.where(level: 1): it => {
+  pagebreak(weak: true)
+  it
+}
+#cmarker.render(read("example.md"))
+```
+
+For example, in the below document a pagebreak will occur before the second heading:
+
+```md
+# first heading
+some content
+
+## sub-heading
+
+<!-- a pagebreak will be inserted here -->
+
+# second heading
+more content
+```
+
+### How do I centre tables? How do I have them span the page width?
+
+This can be achieved via [show rules](https://typst.app/docs/reference/styling/#show-rules).
+For example, centring:
+
+```typ
+#show table: t => align(center, t)
+#cmarker.render("
+  | a | b |
+  | - | - |
+  | c | d |
+")
+```
+
+And having them span the page width:
+
+```typ
+#show table: t => {
+  if t.columns.all(c => c == auto) {
+    table(columns: (1fr,) * t.columns.len(), align: t.align, ..t.children)
+  } else {
+    t
+  }
+}
+```
+
+
+## Development
+
+File structure is as follows:
+
+<table>
+<tr><td><code>lib.typ</code></td><td>
+	The entrypoint of the library,
+	defining its public API.
+	This file only handles the Typst parts;
+	the computation itself is done by the Rust plugin at <code>plugin/</code>.
+</td></tr>
+<tr><td><code>plugin/</code></td><td>
+	The Rust plugin that is compiled to WebAssembly.
+	This is mostly serialization/deserialization scaffolding
+	around the real logic, which lives in <code>lib/</code>.
+</td></tr>
+<tr><td><code>lib/</code></td><td>
+	The <code>cmarker-typst</code> pure Rust library,
+	which does the grunt work of the translation itself.
+</td></tr>
+<tr><td><code>tests/</code></td><td>
+	The test suite.
+	Each Markdown or Typst file here
+	is rendered and compared with the expected HTML output.
+	Run all the tests with <code>cargo test --workspace</code>.
+</td></tr>
+<tr><td><code>test-runner/</code></td><td>
+	A helper crate that runs our test suite.
+	Consult <code>test-runner/main.rs</code> for a guide on writing tests.
+</td></tr>
+<tr><td><code>fuzz/</code></td><td>
+	Fuzzing for the library.
+	Run fuzzing with <code>cargo +nightly fuzz run fuzz</code>.
+</td></tr>
+<tr><td><code>examples/</code></td><td>
+	A few examples.
+	Compile them with <code>typst compile examples/{name}.typ</code>.
+</td></tr>
+<tr><td><code>prepare-release.sh</code></td><td>
+	A small shell script that can be used to cut a release of <code>cmarker.typ</code>.
+</td></tr>
+</table>
diff --git a/packages/preview/cmarker/0.1.10/examples/hexagons.png b/packages/preview/cmarker/0.1.10/examples/hexagons.png
new file mode 100644
index 0000000000..0cf792328d
Binary files /dev/null and b/packages/preview/cmarker/0.1.10/examples/hexagons.png differ
diff --git a/packages/preview/cmarker/0.1.10/examples/simple.png b/packages/preview/cmarker/0.1.10/examples/simple.png
new file mode 100644
index 0000000000..01b8c649a8
Binary files /dev/null and b/packages/preview/cmarker/0.1.10/examples/simple.png differ
diff --git a/packages/preview/cmarker/0.1.10/lib.typ b/packages/preview/cmarker/0.1.10/lib.typ
new file mode 100644
index 0000000000..09f29f4663
--- /dev/null
+++ b/packages/preview/cmarker/0.1.10/lib.typ
@@ -0,0 +1,462 @@
+#let _p = plugin("./plugin.wasm")
+#let render-with-metadata(
+  markdown,
+  smart-punctuation: true,
+  math: none,
+  task-list-marker: none,
+  h1-level: 1,
+  set-document-title: true,
+  raw-typst: true,
+  html: (:),
+  label-prefix: "",
+  prefix-label-uses: true,
+  heading-labels: "github",
+  scope: (:),
+  show-source: false,
+  blockquote: none,
+  metadata-block: none,
+) = {
+  // A simple system for tagging content with invisible metadata.
+  // Used to implement various HTML tags that need some amount of structure.
+  let tag-content(content, tag, data: none) = [#metadata((tag, data))#content]
+  let is-tagged(content, tag) = (
+    content.func() == [].func()
+      and content.children.len() == 2
+      and content.children.at(0).func() == metadata
+      and content.children.at(0).value.len() == 2
+      and content.children.at(0).value.at(0) == tag
+  )
+  let untag-content(content) = (..content.children.at(0).value, content.children.at(1))
+  let take-tagged-children(content, tag) = {
+    if type(tag) != array {
+      tag = (tag,)
+    }
+    let tagged = ()
+    let rest = ()
+    if tag.any(t => is-tagged(content, t)) {
+      tagged.push(untag-content(content))
+    } else if content.func() == [].func() {
+      for child in content.children {
+        if tag.any(t => is-tagged(child, t)) {
+          tagged.push(untag-content(child))
+        } else {
+          rest.push(child)
+        }
+      }
+    } else {
+      rest.push(content)
+    }
+    (tagged: tagged, rest: for r in rest { r })
+  }
+  let untag-children(content, tag) = take-tagged-children(content, tag).tagged
+
+  if type(markdown) == content and markdown.has("text") {
+    markdown = markdown.text
+  }
+  assert(type(markdown) == str, message: "Markdown must be a string")
+
+  // Backward compatibility
+  if blockquote != none {
+    assert(type(blockquote) == function, message: "blockquote must be a function")
+    scope += (
+      quote: (block: false, ..rest) => if block { blockquote(..rest) } else { quote(..rest) },
+    )
+  }
+  // Backward compatibility
+  if "rule" in scope {
+    scope += (divider: scope.rule)
+  }
+
+  let labelify(content, attrs) = {
+    if "id" in attrs {
+      [#content #label(label-prefix + attrs.id)]
+    } else {
+      content
+    }
+  }
+
+  assert(type(label-prefix) == str, message: "label-prefix must be a string")
+  let label-use-prefix = if prefix-label-uses { label-prefix } else { "" }
+
+  let heading-fn(level) = (attrs, body) => {
+    let level = h1-level + level
+    if level < 0 {
+      body
+    } else if level == 0 {
+      if set-document-title {
+        set document(title: body)
+        title()
+      } else {
+        title(body)
+      }
+    } else {
+      labelify(scope.at("heading", default: heading)(level: level, body), attrs)
+    }
+  }
+
+  html = (
+    sub: (attrs, body) => scope.at("sub", default: sub)(body),
+    sup: (attrs, body) => scope.at("sup", default: super)(body),
+    mark: (attrs, body) => scope.at("highlight", default: highlight)(body),
+    h1: heading-fn(0),
+    h2: heading-fn(1),
+    h3: heading-fn(2),
+    h4: heading-fn(3),
+    h5: heading-fn(4),
+    h6: heading-fn(5),
+
+    li: (attrs, body) => tag-content(body, "<li>"),
+    ul: (attrs, body) => {
+      scope.at("list", default: list)(..untag-children(body, "<li>").map(((_, _, c)) => c))
+    },
+    ol: (attrs, body) => {
+      scope.at("enum", default: enum)(..untag-children(body, "<li>").map(((_, _, c)) => c))
+    },
+
+    dt: (attrs, body) => tag-content(body, "<dt>"),
+    dd: (attrs, body) => tag-content(body, "<dd>"),
+    dl: (attrs, body) => scope.at("terms", default: terms)(..(
+      untag-children(body, ("<dt>", "<dd>"))
+        .map(((_, _, c)) => c)
+        .chunks(2, exact: true)
+    )),
+
+    tr: (attrs, body) => tag-content(body, "<tr>"),
+    thead: (attrs, body) => tag-content(body, "<thead>"),
+    tfoot: (attrs, body) => tag-content(body, "<tfoot>"),
+    th: (attrs, body) => tag-content(body, "<td>", data: attrs),
+    td: (attrs, body) => tag-content(body, "<td>", data: attrs),
+    table: (attrs, body) => {
+      let rows = (header: (), body: (), footer: ())
+      for (tag, _, child) in untag-children(body, ("<tr>", "<thead>", "<tfoot>")) {
+        if tag == "<thead>" {
+          for (_, _, row) in untag-children(child, "<tr>") {
+            rows.header.push(untag-children(row, "<td>"))
+          }
+        } else if tag == "<tfoot>" {
+          for (_, _, row) in untag-children(child, "<tr>") {
+            rows.footer.push(untag-children(row, "<td>"))
+          }
+        } else if tag == "<tr>" {
+          rows.body.push(untag-children(child, "<td>"))
+        }
+      }
+      if rows.header.len() == 0 and rows.body.len() == 0 and rows.footer.len() == 0 {
+        return table()
+      }
+      // FIXME: This is likely buggy for exotic uses of rowspan and colspan.
+      let columns = calc.max(
+        ..rows.header.map(r => r.len()),
+        ..rows.body.map(r => r.len()),
+        ..rows.footer.map(r => r.len()),
+      )
+      let start-i = 0
+      for (k, section) in rows {
+        rows.insert(k, section.enumerate().map(((i, row)) => {
+          row = row.map(((_, attrs, td)) => {
+            let rowspan = int(attrs.at("rowspan", default: "1"))
+            let colspan = int(attrs.at("colspan", default: "1"))
+            table.cell(rowspan: rowspan, colspan: colspan, y: start-i + i, td)
+          })
+          row
+        }))
+        start-i += section.len()
+      }
+      let args = ()
+      if rows.header.len() != 0 {
+        args.push(table.header(..rows.header.flatten()))
+      }
+      args += rows.body.flatten()
+      if rows.footer.len() != 0 {
+        args.push(table.footer(..rows.footer.flatten()))
+      }
+      scope.at("table", default: table)(columns: columns, ..args)
+    },
+
+    figcaption: (attrs, body) => tag-content(body, "<figcaption>"),
+    figure: (attrs, body) => {
+      let (tagged: captions, rest) = take-tagged-children(body, "<figcaption>")
+      let caption = if captions.len() >= 1 { captions.at(0).at(2) } else { none }
+      labelify(figure(caption: caption, rest), attrs)
+    },
+
+    hr: ("void", (attrs) => (scope.at("divider", default: divider))()),
+    a: (attrs, body) => scope.at("link", default: link)(
+      if attrs.href.starts-with("#") {
+        label(label-use-prefix + attrs.href.slice(1))
+      } else {
+        attrs.href
+      },
+      body,
+    ),
+    em: (attrs, body) => scope.at("emph", default: emph)(body),
+    strong: (attrs, body) => scope.at("strong", default: strong)(body),
+    s: (attrs, body) => scope.at("strike", default: strike)(body),
+    // Although we stringify the body, <code> cannot be a raw text element because raw text elements
+    // - have their content ignored by heading ID generation and
+    // - include nested HTML in the string,
+    // both of which are undesirable for <code>.
+    code: (attrs, body) => {
+      // https://github.com/typst/typst/issues/2196#issuecomment-1728135476
+      let to-string(it) = {
+        if type(it) == str {
+          it
+        } else if type(it) != content {
+          str(it)
+        } else if it.has("text") {
+          it.text
+        } else if it.has("children") {
+          it.children.map(to-string).join()
+        } else if it.has("body") {
+          to-string(it.body)
+        } else if it == [ ] {
+          " "
+        }
+      }
+      scope.at("raw", default: raw)(to-string(body))
+    },
+    br: ("void", (attrs) => scope.at("linebreak", default: linebreak)()),
+    img: ("void", (attrs) => {
+      let args = (:)
+
+      let parse-dim(dim) = {
+        if dim.ends-with("%") {
+          int(dim.slice(0, -1)) * 1%
+        } else {
+          // When exporting as PDF, the inherent size of the image is converted into `pt` for its
+          // default size. HTML uses `px` instead, meaning this gives wrong results:
+          // https://github.com/typst/typst/issues/8136
+          int(dim) * 1pt
+        }
+      }
+
+      let width = attrs.at("width", default: none)
+      if width != none {
+        args += (width: parse-dim(width))
+      }
+      let height = attrs.at("height", default: none)
+      if height != none {
+        args += (height: parse-dim(height))
+      }
+
+      scope.at("image", default: image)(attrs.src, alt: attrs.at("alt", default: none), ..args)
+    }),
+    blockquote: (attrs, body) => scope.at("quote", default: quote)(block: true, body),
+
+    svg: ("raw-text", (attrs, body) => {
+      let escape(s) = {
+        for c in s {
+          if c == "\"" {
+            "&quot;"
+          } else if c == "&" {
+            "&amp;"
+          } else {
+            c
+          }
+        }
+      }
+
+      let attrs = attrs.pairs().map(((k, v)) => k + "=\"" + escape(v) + "\"").join(" ")
+      let svg = "<svg " + attrs + ">" + body + "</svg>"
+      scope.at("image", default: image)(bytes(svg), format: "svg")
+    }),
+
+    ..html,
+  )
+
+  let flags = 0
+  if smart-punctuation {
+    flags += 0b00000001
+  }
+  if raw-typst {
+    flags += 0b00000010
+  }
+  if math != none {
+    assert(type(math) == function, message: "math must be a function")
+    flags += 0b00000100
+    scope += (math: math)
+  }
+  if set-document-title {
+    flags += 0b00001000
+  }
+  if task-list-marker != none {
+    assert(type(task-list-marker) == function, message: "task-list-marker must be a function")
+    flags += 0b00010000
+
+    // We use manual counters even for `enum`s, even though they could use numberings. This is
+    // because in certain edge cases, numberings are not unique: a reversed list may have several
+    // items numbered at zero.
+    let list-counter = counter("cmarker-list")
+    let enum-counter = counter("cmarker-enum")
+
+    scope += (
+      list-helper: data => depth => {
+        list-counter.step(level: depth + 1)
+        context {
+          let i = list-counter.get().last()
+          let v = data.at(i - 1)
+          if v > 0 {
+            task-list-marker(v == 2)
+          } else if type(list.marker) == content {
+            list.marker
+          } else if type(list.marker) == array {
+            list.marker.at(calc.rem(depth, list.marker.len()))
+          } else {
+            (list.marker)(depth)
+          }
+        }
+        list-counter.update((..c, i) => if i < data.len() { (..c.pos(), i) } else { c.pos() })
+      },
+      enum-helper: data => (..numbers) => {
+        enum-counter.step(level: numbers.len())
+        context {
+          let i = enum-counter.get().last()
+          let v = data.at(i - 1)
+          if v > 0 {
+            task-list-marker(v == 2)
+          } else if enum.full {
+            numbering(enum.numbering, ..numbers)
+          } else {
+            numbering(enum.numbering, numbers.pos().last())
+          }
+        }
+        enum-counter.update((..c, i) => if i < data.len() { (..c.pos(), i) } else { c.pos() })
+      },
+    )
+  }
+
+  let heading-labels = {
+    if heading-labels == none { 0 }
+    else if heading-labels == "github" { 1 }
+    else if heading-labels == "jupyter" { 2 }
+    else { assert(false, message: "invalid heading-labels") }
+  }
+
+  assert(type(h1-level) == int, message: "h1-level must be an integer")
+  assert(-128 <= h1-level and h1-level <= 127, message: "h1-level must be in the range [-128, 127]")
+  // Reinterpret 8-bit 2’s complement (i8) as a u8
+  h1-level = if h1-level < 0 { 256 + h1-level } else { h1-level }
+
+  let options-bytes = (flags, h1-level, heading-labels)
+
+  options-bytes += array(bytes(label-prefix)) + (0xFF,)
+  options-bytes += array(bytes(label-use-prefix)) + (0xFF,)
+
+  scope.html = (:)
+  for (tag-name, value) in html {
+    let (kind, callback) = if type(value) == function { ("normal", value) } else { value }
+    assert(type(callback) == function, message: "HTML callback must be a function")
+    scope.html.insert(tag-name, callback)
+    options-bytes += array(bytes(tag-name))
+    options-bytes.push(if kind == "void" {
+      0xFC
+    } else if kind == "raw-text" {
+      0xFD
+    } else if kind == "escapable-raw-text" {
+      0xFE
+    } else if kind == "normal" {
+      0xFF
+    } else {
+      assert(false, message: "invalid HTML tag kind for <" + tag-name + "> (expected void, raw-text, escapable-raw-text or normal)")
+    })
+  }
+
+  // Transforms the following:
+  // ```md
+  // ---
+  // frontmatter
+  // ---
+  // content
+  // ```
+  // into the tuple (frontmatter, content) of type (str, str).
+  //
+  // The frontmatter is left as a string to let the user
+  // decide the metadata format i.e. yaml, toml, etc.
+  //
+  // A YAML metadata block is a valid YAML object,
+  // [1] delimited by a line of three hyphens (---) at the top
+  // [2] and a line of three hyphens (---) or three dots (...) at the bottom.
+  // [3] The initial line --- must not be followed by a blank line.
+  //
+  // Reference: https://pandoc.org/demo/example33/8.10-metadata-blocks.html
+  let extract-frontmatter(s) = {
+    let original = s
+
+    let start-match = s.match(regex("^---[ \t\r]*\n"))
+    if start-match == none {
+      return ("", original)
+    }
+    s = s.slice(start-match.end)
+
+    if s.starts-with(regex("[ \t\r]*\n")) {
+      return ("", original)
+    }
+
+    let end-match = s.match(regex("\n(---|\.\.\.)[ \t\r]*(\n|$)"))
+    if end-match == none {
+      return ("", original)
+    }
+
+    return (s.slice(0, end-match.start), s.slice(end-match.end))
+  }
+
+  let (markdown-frontmatter, markdown) = if metadata-block != none {
+     extract-frontmatter(markdown)
+  } else {
+    (none, markdown)
+  }
+  let rendered = str(_p.render(bytes(markdown), bytes(options-bytes)))
+
+  let body = if show-source {
+    raw(rendered, block: true, lang: "typ")
+  } else {
+    eval(rendered, mode: "markup", scope: scope)
+  }
+
+  let metadata-block-content = if metadata-block == "frontmatter-raw" {
+    markdown-frontmatter
+  } else if metadata-block == "frontmatter-yaml" {
+    yaml(bytes(markdown-frontmatter))
+  } else if metadata-block != none {
+    let message = "invalid metadata-block value `" + metadata-block + "` (expected `frontmatter-raw` or `frontmatter-yaml`)"
+    assert(false, message: message)
+  }
+
+  (metadata-block-content, body)
+}
+
+#let render(
+  markdown,
+  smart-punctuation: true,
+  math: none,
+  task-list-marker: none,
+  h1-level: 1,
+  set-document-title: true,
+  raw-typst: true,
+  html: (:),
+  label-prefix: "",
+  prefix-label-uses: true,
+  heading-labels: "github",
+  scope: (:),
+  show-source: false,
+  blockquote: none,
+) = {
+  let (meta, body) = render-with-metadata(
+    markdown,
+    smart-punctuation: smart-punctuation,
+    math: math,
+    task-list-marker: task-list-marker,
+    h1-level: h1-level,
+    set-document-title: set-document-title,
+    raw-typst: raw-typst,
+    html: html,
+    label-prefix: label-prefix,
+    prefix-label-uses: prefix-label-uses,
+    heading-labels: heading-labels,
+    scope: scope,
+    show-source: show-source,
+    blockquote: blockquote,
+    metadata-block: none,
+  )
+  body
+}
diff --git a/packages/preview/cmarker/0.1.10/plugin.wasm b/packages/preview/cmarker/0.1.10/plugin.wasm
new file mode 100755
index 0000000000..ef3b102412
Binary files /dev/null and b/packages/preview/cmarker/0.1.10/plugin.wasm differ
diff --git a/packages/preview/cmarker/0.1.10/typst.toml b/packages/preview/cmarker/0.1.10/typst.toml
new file mode 100644
index 0000000000..b5e41a42b0
--- /dev/null
+++ b/packages/preview/cmarker/0.1.10/typst.toml
@@ -0,0 +1,11 @@
+[package]
+name = "cmarker"
+version = "0.1.10"
+entrypoint = "lib.typ"
+authors = ["Sabrina Jewson"]
+license = "MIT"
+description = "Transpile CommonMark Markdown to Typst, from within Typst!"
+repository = "https://github.com/SabrinaJewson/cmarker.typ"
+keywords = ["Markdown", "CommonMark"]
+compiler = "0.15.0"
+exclude = ["examples", "README.pdf"]