Returns the absolute value of the given number.

abs(-10)

10

Adds two values.

add(1, 2)

3

Returns an array of all interned symbols.

Performs a logical AND operation on two boolean values.

and(true, false)

false

Creates an array from the given values.

array(1, 2, 3)

[1, 2, 3]

Converts ASCII uppercase letters (A-Z) in the given string to lowercase, leaving all other characters unchanged.

ascii_downcase("ABC")

abc

Converts ASCII lowercase letters (a-z) in the given string to uppercase, leaving all other characters unchanged.

ascii_upcase("abc")

ABC

Retrieves the value of the specified attribute from a markdown node.

Computes the bitwise AND of two byte arrays of equal length.

Encodes the given string to base64.

base64("hi")

aGk=

Decodes the given base64 string.

base64d("aGk=")

hi

Encodes the given string to URL-safe base64.

base64url("hi")

aGk

Decodes the given URL-safe base64 string.

base64urld(base64url("hi"))

hi

Returns the final component of a path string (e.g. "file.txt" from "/a/b/file.txt").

basename("/a/b/file.txt")

file.txt

Computes the bitwise NOT (complement) of a byte array.

Computes the bitwise OR of two byte arrays of equal length.

Sets a breakpoint for debugging; execution will pause at this point if a debugger is attached.

Captures named groups from the given string based on the specified regular expression pattern and returns them as a dictionary keyed by group names.

capture("v1.2.3", "(?P<major>[0-9]+)")

{"major": "1"}

Rounds the given number up to the nearest integer.

ceil(3.2)

4

Returns the first non-None value from the two provided arguments.

coalesce(None, 5)

5

Recursively reads every Markdown file in the given directory (including subdirectories and symlinked files/directories) and returns an array of `{path, title, frontmatter, content}` dicts, sorted by path, so they can be filtered, sorted, or aggregated as a single dataset. `content` holds the file's Markdown nodes with frontmatter stripped. Symlink cycles are detected and only visited once. `respect_gitignore` is optional (default `false`); when `true`, dotfiles/dot-directories and any path matched by a `.gitignore` in `dir` or a subdirectory are skipped, with closer `.gitignore` files taking precedence, same as `git`. Requires the --allow-read CLI flag; otherwise returns a runtime error.

Removes None values from the given array.

compact([1, None, 2])

[1, 2]

Converts the input value to the specified format. Supported formats: base64, html, text, uri, heading (#, ##, etc.), blockquote (>), list item (-), or link (URL).

Adds n units to a broken-down time array and returns a new array. Units: "seconds", "minutes", "hours", "days", "weeks", "months", "years". Month/year arithmetic is calendar-aware.

Returns the difference (array2 - array1) in the given unit. Units: "seconds", "minutes", "hours", "days", "weeks".

date_diff(gmtime(0), gmtime(86400), "days")

1

Parses a natural-language relative date expression (e.g. "3 days ago", "yesterday", "tomorrow", "next monday", "in 2 weeks") relative to a base Unix timestamp and returns the resulting Unix timestamp (seconds, UTC).

Deletes the element at the specified index in the array or string.

del([1, 2, 3], 1)

[1, 3]

Creates a new, empty dict.

dict()

{}

Returns the parent directory of a path string (e.g. "/a/b" from "/a/b/file.txt"). Returns "." if the path has no parent.

dirname("/a/b/file.txt")

/a/b

Divides the first value by the second value.

div(6, 2)

3

Converts the given string to lowercase.

downcase("ABC")

abc

Inlines an `.image` node's local file into its `url` as a base64 `data:` URI, resolving the path relative to the given base directory (default ".") and inferring the MIME type from the file extension. URLs that are already `data:` URIs or contain a `://` scheme (e.g. `https://`), and non-image nodes, are left unchanged. Requires the --allow-read CLI flag; otherwise returns a runtime error.

Checks if the given string or byte array ends with the specified suffix.

ends_with("hello", "lo")

true

Returns an array of key-value pairs from the dict as arrays.

Checks if two values are equal.

eq(1, 1)

true

Raises a user-defined error with the specified message.

Returns the exponential (e^x) of the given number.

exp(0)

1

Splits the given string into an array of characters.

explode("ab")

[97, 98]

Returns the extension of a file path including the leading dot (e.g. ".txt" from "file.txt"). Returns an empty string if there is no extension.

extname("file.txt")

.txt

Decodes an `.image` node's base64 `data:` URI and writes the bytes to a file under the given directory, named by the content's MD5 hash with an extension inferred from the MIME type, then replaces `url` with that file's path. Nodes whose `url` is not a base64 `data:` URI, including non-image nodes, are left unchanged. Requires the --allow-write CLI flag; otherwise returns a runtime error.

Checks if a file exists at the given path. Requires the --allow-read CLI flag; otherwise returns a runtime error.

Returns the size, in bytes, of the file at the given path. Requires the --allow-read CLI flag; otherwise returns a runtime error.

Flattens a nested array into a single level array.

flatten([[1, 2], [3]])

[1, 2, 3]

Rounds the given number down to the nearest integer.

floor(3.8)

3

Converts a date string to a timestamp.

from_date("1970-01-01T00:00:00Z")

0

Parses a hex string into raw bytes.

Converts the given HTML string to Markdown.

Retrieves a value from a dict by its key. Returns None if the key is not found.

Returns the source position of a markdown node as a dict with start_line, start_column, end_line, and end_column, or None if the node has no position info.

Returns the title of a markdown node.

Returns the url of a markdown node.

get_url(to_link("https://example.com", "Example", ""))

https://example.com

Retrieves the value of a symbol or variable from the current environment.

Checks whether the given path matches the glob pattern (e.g. "*.md", "docs/**/*.rs"), commonly used to filter file lists.

glob_match("*.md", "readme.md")

true

Converts Unix timestamp (seconds since epoch) to broken-down UTC time array [year, mon (0-11), mday, hour, min, sec, wday (0=Sun), yday (0-365)].

gmtime(0)

[1970, 0, 1, 0, 0, 0, 4, 0]

Replaces all occurrences matching a regular expression pattern with the replacement string.

gsub("a1b2", "[0-9]", "#")

a#b#

Checks if the first value is greater than the second value.

gt(2, 1)

true

Checks if the first value is greater than or equal to the second value.

gte(1, 1)

true

Terminates the program with the given exit code.

Escapes `&`, `<`, `>`, `"`, and `'` in the given string as HTML entities.

html_escape("<a>")

<a>

Decodes named and numeric HTML entities in the given string into their corresponding characters.

html_unescape("<a>")

<a>

Performs an HTTPS request with the given method (a string or symbol, e.g. "post" or :post — get, post, put, delete, patch, head, ... are all supported) and returns the response body as a string. An optional body argument (string) sends a request body regardless of method, and an optional headers argument (a dict of string to string, e.g. {"Content-Type": "application/json"}) is applied to the request. Requires the --allow-net CLI flag; otherwise returns a runtime error. Only https:// URLs are allowed.

Joins an array of characters into a string.

implode(explode("ab"))

ab

Finds the first occurrence of a substring or byte subsequence. Returns -1 if not found.

index("hello", "ll")

2

Returns an infinite number value.

Reads a line from standard input and returns it as a string.

Inserts a value into an array or string at the specified index, or into a dict with the specified key.

insert([1, 2, 3], 1, "x")

[1, "x", 2, 3]

Interns the given string, returning a canonical reference for efficient comparison.

intern("hi")

hi

Checks if the given pattern does not match the string.

is_not_regex_match("abc", "x")

true

Checks if the given pattern matches the string.

is_regex_match("abc", "a.c")

true

Joins the elements of an array into a string with the given separator.

join([1, 2, 3], ",")

1,2,3

Returns an array of keys from the dict.

Returns the length of the given string or array.

len("hello")

5

Returns the natural logarithm (base e) of the given number.

ln(1)

0

Converts Unix timestamp (seconds since epoch) to broken-down local time array [year, mon (0-11), mday, hour, min, sec, wday (0=Sun), yday (0-365)].

Returns the base-10 logarithm of the given number.

log10(100)

2

Checks if the first value is less than the second value.

lt(1, 2)

true

Checks if the first value is less than or equal to the second value.

lte(1, 1)

true

Trims whitespace from the left end of the given string.

ltrim("  hi  ")

hi  

Returns the maximum of two values.

max(1, 2)

2

Computes the MD5 hash of a string or bytes and returns a lowercase hex string.

Returns the minimum of two values.

min(1, 2)

1

Converts broken-down UTC time array [year, mon (0-11), mday, hour, min, sec, wday, yday] to Unix timestamp (seconds since epoch).

mktime(gmtime(0))

0

Calculates the remainder of the division of the first value by the second value.

mod(7, 3)

1

Multiplies two values.

mul(2, 3)

6

Returns a Not-a-Number (NaN) value.

Checks if two values are not equal.

ne(1, 2)

true

Returns the negation of the given number.

negate(5)

-5

Performs a logical NOT operation on a boolean value.

not(true)

false

Returns the current timestamp.

Performs a logical OR operation on two boolean values.

or(true, false)

true

Packs a number into bytes using the given format. Supported formats: u8, i8, u16be/le, i16be/le, u32be/le, i32be/le, u64be/le, i64be/le, f32be/le, f64be/le.

Creates a new function by partially applying the given arguments to the specified function.

Joins a base path with a component path and returns the resulting path string (e.g. path_join("/a/b", "c.txt") → "/a/b/c.txt").

path_join("/a/b", "c.txt")

/a/b/c.txt

Raises the base to the power of the exponent.

pow(2, 10)

1024

Prints a message to standard output and returns the current value.

Generates a pseudo-random number in the range [0, 1). Not cryptographically secure.

Generates a pseudo-random integer uniformly distributed in [min, max] (inclusive). Not cryptographically secure.

Generates a random string of `len` characters, each independently chosen (with replacement) from `charset`. Not cryptographically secure.

Creates an array from start to end with an optional step.

range(0, 5, 1)

[0, 1, 2, 3, 4, 5]

Reads the contents of a file at the given path and returns it as a string. Requires the --allow-read CLI flag; otherwise returns a runtime error.

Reads the contents of a file at the given path and returns it as raw bytes. Requires the --allow-read CLI flag; otherwise returns a runtime error.

Finds all matches of the given pattern in the string.

regex_match("abc123", "[0-9]+")

["123"]

Repeats the given string a specified number of times.

repeat("ab", 3)

ababab

Replaces all occurrences of a substring with another substring.

replace("aXbXc", "X", "-")

a-b-c

Reverses the given string or array.

reverse("abc")

cba

Finds the last occurrence of a substring or byte subsequence. Returns -1 if not found.

rindex("hello", "l")

3

Rounds the given number to the nearest integer.

round(3.5)

4

Trims whitespace from the right end of the given string.

rtrim("  hi  ")

  hi

Returns n elements sampled from the array without replacement, in random order. Errors if n exceeds the array length.

Sanitizes the given HTML string using an allowlist of safe tags and attributes, removing scripts and other XSS vectors.

Finds all matches of a regular expression pattern in the string. For each match, returns the captured groups as an array if the pattern has capture groups, otherwise returns the whole match as a string.

scan("a1b2", "[0-9]")

["1", "2"]

Sets a key-value pair in a dict. If the key exists, its value is updated. Returns the modified map.

Sets the value of the specified attribute on a markdown node.

Creates a markdown list node with the given checked state.

set_check(to_md_list("Item", 0), true)

- [x] Item

Sets the children nodes of a markdown node. Nodes without children (e.g. text, code) are left unchanged.

Sets the language of a markdown code block node.

set_code_block_lang(to_code("x", "python"), "rust")

```rust
x
```

Sets the ordered property of a markdown list node.

set_list_ordered(to_md_list("Item", 0), true)

1. Item

Sets the reference identifier for markdown nodes that support references (e.g., Definition, LinkRef, ImageRef, Footnote, FootnoteRef).

Sets a symbol or variable in the current environment with the given value.

Computes the SHA-256 hash of a string or bytes and returns a lowercase hex string.

Computes the SHA-512 hash of a string or bytes and returns a lowercase hex string.

Performs a left shift operation on the given value: for numbers, this is a bitwise left shift by the specified number of positions; for strings, this removes characters from the start; for Markdown headings, this increases the heading level accordingly.

shift_left(1, 2)

4

Performs a bitwise right shift on numbers, slices characters from the end of strings, and adjusts Markdown heading levels when applied to headings, using the given shift amount.

shift_right(8, 2)

2

Returns a new array containing the same elements as the input, in a uniformly random order.

Extracts a substring from the given string.

slice("hello", 1, 3)

el

Sorts the elements of the given array.

sort([3, 1, 2])

[1, 2, 3]

Splits the given string by the specified separator.

split("a,b,c", ",")

["a", "b", "c"]

Returns the square root of the given number.

sqrt(9)

3

Checks if the given string or byte array starts with the specified prefix.

starts_with("hello", "he")

true

Prints a message to standard error and returns the current value.

Returns the file name without the extension (e.g. "file" from "/a/b/file.txt").

stem("/a/b/file.txt")

file

Formats a Unix timestamp (seconds) as a date string using the given strftime format (e.g. "%Y-%m-%d").

strftime(0, "%Y-%m-%d")

1970-01-01

Removes HTML tags from the given string, keeping the surrounding text content.

strip_tags("<b>hi</b>")

hi

Parses a date string using the given strptime format (e.g. "%Y-%m-%d") and returns a Unix timestamp (seconds, UTC).

strptime("1970-01-01", "%Y-%m-%d")

0

Subtracts the second value from the first value.

sub(5, 2)

3

Converts the given value to an array.

to_array(1)

[1]

Creates a markdown blockquote node with the given value.

to_blockquote("Quote")

> Quote

Converts the given value to a boolean. Booleans are returned unchanged, the strings "true" and "false" are converted to their boolean equivalent, and all other input results in an error.

to_boolean("true")

true

Creates a markdown hard line break node.

to_break()

\

Converts a string (UTF-8), array of numbers, or bytes to raw bytes.

Creates a markdown callout node with the given value, kind, and title.

to_callout("Note text", "note", "")

> [!NOTE]
> Note text

Creates a markdown code block with the given value and language.

to_code("x = 1", "python")

```python
x = 1
```

Creates an inline markdown code node with the given value.

to_code_inline("x")

`x`

Converts a timestamp to a date string with the given format.

to_date(0, "%Y-%m-%d")

1970-01-01

Creates a markdown link reference definition node with the given url, identifier, and title.

to_definition("https://example.com", "ex", "")

[ex]: https://example.com

Creates a markdown delete (strikethrough) node with the given value.

to_delete("Old")

~~Old~~

Creates a markdown emphasis (italic) node with the given value.

to_em("Italic")

*Italic*

Creates a markdown footnote definition node with the given value and identifier.

to_footnote("Footnote text", "1")

[^1]: Footnote text

Creates a markdown footnote reference node with the given identifier.

to_footnote_ref("1")

[^1]

Creates a markdown heading node with the given value and depth.

to_h("Title", 1)

# Title

Encodes raw bytes as a lowercase hex string.

to_hex(from_hex("6869"))

6869

Creates a markdown horizontal rule node.

to_hr()

***

Converts the given markdown string to HTML.

Creates a markdown image node with the given URL, alt text, and title.

to_image("https://example.com/a.png", "Alt", "")

![Alt](https://example.com/a.png "")

Creates a markdown link node with the given url and title.

to_link("https://example.com", "Example", "")

[Example](https://example.com)

Parses a markdown string and returns an array of markdown nodes.

to_markdown("# Hi")

[# Hi]

Converts the given value(s) to a markdown string representation.

Creates a markdown math block with the given value.

to_math("x^2")

$$
x^2
$$

Creates an inline markdown math node with the given value.

to_math_inline("x^2")

$x^2$

Creates a markdown fragment node that groups an array of markdown nodes into a single value.

Creates a raw markdown HTML node with the given value.

to_md_html("<br>")

<br>

Creates a markdown list node with the given value and indent level.

to_md_list("Item", 0)

- Item

Returns the name of the given markdown node.

to_md_name(to_h("t", 1))

h1

Creates a markdown table alignment row node from an array of alignments ("left", "right", "center", "none").

to_md_table_align(["left", "right"])

|:---|---:|

Creates a markdown table cell node with the given value at the specified row and column.

to_md_table_cell("A1", 0, 0)

A1

Creates a markdown table row node with the given values.

Creates a markdown text node with the given value.

to_md_text("hi")

hi

Parses an MDX string and returns an array of MDX nodes.

Converts the given value to a number.

to_number("42")

42

Converts the given value to a string.

to_string(1)

1

Creates a markdown strong (bold) node with the given value.

to_strong("Bold")

**Bold**

Converts the given markdown node to plain text.

to_text(to_strong("hi"))

hi

Reduces an array of Markdown nodes to fit within `budget` LLM tokens, preserving structure as much as possible: paragraphs are cut to their first sentence, then lists/tables/code blocks are collapsed to a summary, and only as a last resort is the remaining text hard-truncated. Uses a lightweight chars-per-token heuristic by default; built with the `tiktoken` Cargo feature, counts exactly via tiktoken-rs instead when `model` (e.g. "gpt-5") is given. `model` is optional; without it, the heuristic estimate is always used.

Estimates how many LLM tokens the given text would consume, for context-window budgeting. Uses a lightweight chars-per-token heuristic by default; built with the `tiktoken` Cargo feature, counts exactly via tiktoken-rs instead when `model` (e.g. "gpt-5") is given. `model` is optional; without it, the heuristic estimate is always used.

token_count("Hello, world!")

4

Trims whitespace from both ends of the given string.

trim("  hi  ")

hi

Truncates the given number to an integer by removing the fractional part.

trunc(3.9)

3

Truncates the given string to the specified display width, appending the ellipsis string when truncated (CJK and other wide characters count as two columns).

truncate("hello world", 5, "...")

he...

Returns the type of the given value.

type(1)

number

Removes duplicate elements from the given array.

uniq([1, 1, 2])

[1, 2]

Unpacks a number from bytes using the given format. Supported formats: u8, i8, u16be/le, i16be/le, u32be/le, i32be/le, u64be/le, i64be/le, f32be/le, f64be/le.

Converts the given string to uppercase.

upcase("abc")

ABC

Update the value with specified value.

URL-decodes the given string.

url_decode("a%20b")

a b

URL-encodes the given string.

url_encode("a b")

a%20b

Decodes bytes as a UTF-8 string, returning an error if the bytes are not valid UTF-8.

utf8(to_bytes("hi"))

hi

Generates a random (version 4, RFC 4122) UUID string.

Generates a random (version 4, RFC 4122) UUID string. Alias of `uuid`.

Generates a time-ordered (version 7, RFC 9562) UUID string: a millisecond Unix timestamp followed by random bits, so values sort by creation time. The timestamp is plaintext, so prefer uuid/uuid_v4 for unguessable IDs.

Returns an array of values from the dict.

Wraps the given string into lines no wider than the specified display width, breaking on word boundaries (CJK and other wide characters count as two columns).

word_wrap("hello world", 5)

hello
world

Writes content (string or bytes) to the file at the given path, creating or truncating it. Requires the --allow-write CLI flag; otherwise returns a runtime error.

Computes the bitwise XOR of two byte arrays of equal length.

Halts execution with error code 5

Checks if input is an array

is_array([1, 2])

true

Checks if input is markdown

is_markdown(to_h("t", 1))

true

Checks if input is a boolean

is_bool(true)

true

Checks if input is a number

is_number(1)

true

Checks if input is a string

is_string("hi")

true

Checks if input is None

is_none(None)

true

Checks if input is a dictionary

is_dict({"a": 1})

true

Checks if input is bytes

is_bytes(to_bytes("hi"))

true

Checks if string contains a substring

contains("hello world", "world")

true

Removes prefix string from input if it exists

ltrimstr("prefix_value", "prefix_")

value

Removes suffix string from input if it exists

rtrimstr("value_suffix", "_suffix")

value

Checks if string, array or dict is empty

is_empty([])

true

Tests if string matches a pattern

test("abc", "a.c")

true

Returns value if condition is true, None otherwise

select(5, true)

5

Returns array if input is array, None otherwise

arrays([1, 2])

[1, 2]

Returns markdown if input is markdown, None otherwise

markdowns(to_h("t", 1))

# t

Returns boolean if input is boolean, None otherwise

booleans(true)

true

Returns number if input is number, None otherwise

numbers(1)

1

Returns string if input is string, None otherwise

strings("hi")

hi

Returns dict if input is dict, None otherwise

dicts({"a": 1})

{"a": 1}

Returns the value if it is None, None otherwise

nones(None)

Returns bytes if input is bytes, None otherwise

bytes(to_bytes("hi"))

6869

Returns the value if it is an array or dict (i.e. a container that can be iterated over), None otherwise

iterables([1, 2])

[1, 2]

Returns the value if it is not an array or dict (i.e. a leaf/scalar value), None otherwise

scalars(1)

1

Formats a date to ISO 8601 format (YYYY-MM-DDTHH:MM:SSZ)

to_date_iso8601(0)

1970-01-01T00:00:00Z

Applies a given function to each element of the provided array and returns a new array with the results.

map([1, 2, 3], fn(x): mul(x, 2);)

[2, 4, 6]

Applies a function to each element and flattens the result into a single array

flat_map([1, 2], fn(x): [x, x];)

[1, 1, 2, 2]

Filters the elements of an array based on a provided callback function.

filter([1, 2, 3, 4], fn(x): x > 2;)

[3, 4]

Executes a provided function once for each element in an array or each key-value pair in a dictionary.

Returns the first element of an array

first([1, 2, 3])

1

Returns the last element of an array

last([1, 2, 3])

3

Returns the second element of an array

second([1, 2, 3])

2

Checks if markdown is h1 heading

is_h1(to_h("t", 1))

true

Checks if markdown is h2 heading

is_h2(to_h("t", 2))

true

Checks if markdown is h3 heading

is_h3(to_h("t", 3))

true

Checks if markdown is h4 heading

is_h4(to_h("t", 4))

true

Checks if markdown is h5 heading

is_h5(to_h("t", 5))

true

Checks if markdown is h6 heading

is_h6(to_h("t", 6))

true

Checks if markdown is heading

is_h(to_h("t", 2))

true

Checks if markdown is a heading of the specified level (1-6)

is_h_level(to_h("t", 2), 2)

true

Checks if markdown is table align

is_table_align(to_md_table_align(["left"]))

true

Checks if markdown is table cell

is_table_cell(to_md_table_cell("A1", 0, 0))

true

Checks if markdown is emphasis

is_em(to_em("hi"))

true

Checks if markdown is html

Checks if markdown is yaml

Checks if markdown is toml

Checks if markdown is code block

is_code(to_code("x", "python"))

true

Checks if markdown is text

is_text(to_md_text("hi"))

true

Checks if markdown is list

is_list(to_md_list("Item", 0))

true

Checks if markdown node's URL matches a specified URL deprecated: use select(.link.url == url) instead

matches_url(to_link("https://example.com", "x", ""), "https://example.com")

true

Checks if markdown is MDX Flow Expression

Checks if markdown is MDX Jsx Flow Element

Checks if markdown is MDX Jsx Text Element

Checks if markdown is MDX Text Expression

Checks if markdown is MDX Js Esm

Checks if markdown is MDX

Checks if markdown is a callout block

is_callout(to_callout("Note", "note", ""))

true

Returns an array of length n filled with the given value.

fill("x", 3)

["x", "x", "x"]

Sorts an array using a key function that extracts a comparable value for each element.

sort_by([3, 1, 2], identity)

[1, 2, 3]

Sorts an array in natural order (numeric-aware), so runs of digits embedded in a string are compared as numbers rather than character-by-character, e.g. "file2" sorts before "file10" (unlike a plain lexicographic `sort`).

sort_natural(["file10", "file2"])

["file2", "file10"]

Returns the count of elements in the array that satisfy the provided function.

count_by([1, 2, 3, 4], fn(x): x > 2;)

2

Skips the first n elements of an array and returns the rest

skip([1, 2, 3, 4], 2)

[3, 4]

Takes the first n elements of an array

take([1, 2, 3, 4], 2)

[1, 2]

Returns the index of the first element in an array that satisfies the provided function.

find_index([1, 2, 3], fn(x): x == 2;)

1

Skips elements from the beginning of an array while the provided function returns true

skip_while([1, 2, 3, 4], fn(x): x < 3;)

[3, 4]

Takes elements from the beginning of an array while the provided function returns true

take_while([1, 2, 3, 4], fn(x): x < 3;)

[1, 2]

Groups elements of an array by the result of applying a function to each element

group_by([1, 2, 3, 4], fn(x): mod(x, 2);)

{"1": [1, 3], "0": [2, 4]}

Counts occurrences of each key extracted from the elements of an array, returning a dict of `{key: count}`.

frequencies_by(["a", "b", "a"], identity)

{"a": 2, "b": 1}

Counts occurrences of each element in an array, returning a dict of `{value: count}`.

tally(["a", "b", "a"])

{"a": 2, "b": 1}

Returns true if any element in the array satisfies the provided function.

any([1, 2, 3], fn(x): x > 2;)

true

Returns true if all element in the array satisfies the provided function.

all([1, 2, 3], fn(x): x > 0;)

true

Returns true if the element is in the array.

in([1, 2, 3], 2)

true

Reduces an array to a single value by applying a function, starting from an initial value.

fold([1, 2, 3], 0, fn(acc, x): acc + x;)

6

Returns a new array with duplicate elements removed, comparing by the result of the provided function.

unique_by([1, 2, 1, 3], identity)

[1, 2, 3]

Returns the input value unchanged.

identity(1)

1

Transposes a 2D array (matrix), swapping rows and columns.

transpose([[1, 2], [3, 4]])

[[1, 3], [2, 4]]

Applies a function to a value and returns the value (useful for debugging or side effects).

tap(1, 2)

1

Extracts values from an array of objects based on a specified selector.

Maps over an array and removes None values from the result.

compact_map([1, 2, 3], fn(x): if (x > 1): x;)

[2, 3]

Filters out elements that match the condition (opposite of filter).

reject([1, 2, 3, 4], fn(x): x > 2;)

[1, 2]

Splits an array into two arrays: [matching, not_matching] based on a condition.

partition([1, 2, 3, 4], fn(x): x > 2;)

[[3, 4], [1, 2]]

Safely gets a value from a dict with a default if the key doesn't exist.

get_or({"a": 1}, "b", 0)

0

Executes an expression n times and returns an array of results. Note: `value` is evaluated once (eagerly) and repeated, not re-evaluated per iteration. Deprecated: use `repeat` instead

times(3, 1)

[1, 1, 1]

Checks if a value is between min and max (inclusive).

between(5, 1, 10)

true

Sums elements of an array after applying a transformation function.

sum_by([1, 2, 3], fn(x): mul(x, 2);)

12

Creates a dictionary indexed by a key extracted from each element.

index_by([1, 2, 3], to_string)

{"1": 1, "2": 2, "3": 3}

Joins two arrays of dict records on `left_key`/`right_key`, similar to a SQL join. Matching records are merged with `+` (right's fields win on collision). `kind` is one of "inner" (default), "left", "right", or "full"; unmatched records in outer joins are filled with `None` for the other side's fields (inferred from that side's full key set). Records with a missing or `None` join key never match, and duplicate keys on either side expand as a cross product.

join_by([{"id": 2, "name": "bob"}], [{"uid": 2, "age": 30}], "id", "uid")

[{"id": 2, "name": "bob", "uid": 2, "age": 30}]

Inspects a value by printing its string representation and returning the value.

Left-pads a string to a specified length using a given padding string.

lpad("7", 3, "0")

007

Right-pads a string to a specified length using a given padding string.

rpad("7", 3, "0")

700

Loads a markdown file from the specified path

Performs an HTTPS GET request, optionally with the given headers (a dict of string to string), and returns the response body as a string

Performs an HTTPS POST request with the given body, optionally with the given headers (a dict of string to string), and returns the response body as a string

Performs an HTTPS PUT request with the given body, optionally with the given headers (a dict of string to string), and returns the response body as a string

Performs an HTTPS PATCH request with the given body, optionally with the given headers (a dict of string to string), and returns the response body as a string

Performs an HTTPS DELETE request, optionally with the given headers (a dict of string to string), and returns the response body as a string

Performs an HTTPS HEAD request, optionally with the given headers (a dict of string to string), and returns the response body as a string

Performs an HTTPS GET request, optionally with the given headers (a dict of string to string), and parses the response body as JSON, returning the resulting data structure

Performs an HTTPS POST request with the given body, optionally with the given headers (a dict of string to string), and parses the response body as JSON, returning the resulting data structure

Performs an HTTPS PUT request with the given body, optionally with the given headers (a dict of string to string), and parses the response body as JSON, returning the resulting data structure

Performs an HTTPS PATCH request with the given body, optionally with the given headers (a dict of string to string), and parses the response body as JSON, returning the resulting data structure

Performs an HTTPS DELETE request, optionally with the given headers (a dict of string to string), and parses the response body as JSON, returning the resulting data structure

Prints the debug information of the given value(s).

Increases the depth (numeric level) of a markdown heading node by one, effectively demoting the heading (e.g. h1 -> h2), up to a maximum of 6.

increase_header_depth(to_h("t", 1))

## t

Decreases the depth (numeric level) of a markdown heading node by one, effectively promoting the heading (e.g. h2 -> h1), down to a minimum of 1.

decrease_header_depth(to_h("t", 2))

# t

Demotes a markdown heading by increasing its depth (numeric level) by one. This is an alias for `increase_header_depth`.

demote_heading(to_h("t", 1))

## t

Promotes a markdown heading by decreasing its depth (numeric level) by one. This is an alias for `decrease_header_depth`.

promote_heading(to_h("t", 2))

# t

Deprecated: use `increase_header_depth` or `demote_heading` instead. Kept for backward compatibility; behavior unchanged.

increase_header_level(to_h("t", 1))

## t

Deprecated: use `decrease_header_depth` or `promote_heading` instead. Kept for backward compatibility; behavior unchanged.

decrease_header_level(to_h("t", 2))

# t

Performs a binary search on a sorted array to find the index of the target value.

bsearch([1, 3, 5, 7, 9], 5)

2

Converts a string into a URL-friendly slug by lowercasing, replacing non-alphanumeric characters with hyphens, and trimming hyphens from the ends.

slugify("Hello, World!")

hello-world

Calculates the p-th percentile of an array of numbers using linear interpolation between closest ranks.

percentile([1, 2, 3, 4, 5], 0.5)

3

Splits an array into chunks of a specified size, returning an array of arrays.

chunks([1, 2, 3, 4, 5], 2)

[[1, 2], [3, 4], [5]]

Splits an array into chunks based on the result of applying a function to each element, grouping consecutive elements with the same key together.

chunk_by([1, 1, 2, 2, 3], identity)

[[1, 1], [2, 2], [3]]

Returns a new function that takes the same arguments as the original function but with the first two arguments flipped.

flip(sub, 2, 10)

8

Returns a new predicate function that negates the result of the given function.

let f = complement(is_none) | f(1)

true

Composes functions into one function, applying them right-to-left. `comp(f, g, h)(x)` is equivalent to `f(g(h(x)))`.

let f = comp(fn(x): x + 1;, fn(x): x * 2;) | f(3)

7

Returns a function that applies each given function to its argument and collects the results into an array. `juxt(f, g, h)(x)` is equivalent to `[f(x), g(x), h(x)]`.

let f = juxt(first, last) | f([1, 2, 3])

[1, 3]

Returns the sum of the elements in an array after applying a transformation function to each element.

sum([1, 2, 3])

6

Returns the average (mean) of an array of numbers, or None if the array is empty.

mean([1, 2, 3])

2

Returns the geometric mean of an array of numbers, or None if the array is empty.

geomean([1, 4])

2

Returns the population variance of an array of numbers, or None if the array is empty.

variance([2, 4, 4, 4, 5, 5, 7, 9])

4

Returns the population standard deviation of an array of numbers, or None if the array is empty.

stddev([2, 4, 4, 4, 5, 5, 7, 9])

2

Returns the mode(s) of an array, i.e. the most frequently occurring value(s). Multiple values are returned if there is a tie for the highest frequency. Returns None if the array is empty.

mode([1, 2, 2, 3])

[2]

Returns a dict of summary statistics for an array of numbers: `{min, max, mean, median, stddev, variance, count}`. Returns None if the array is empty.

describe([1, 2, 3, 4, 5])

{"count": 5, "min": 1, "max": 5, "mean": 3, "variance": 2, "stddev": 1.414214, "median": 3}

Returns the n-grams of an array or string, which are overlapping contiguous subarrays (or substrings) of length n, sliding one element at a time.

ngram("abcd", 2)

["ab", "bc", "cd"]

Combines two arrays into an array of pairs, where each pair contains elements from the same index in both arrays.

zip([1, 2], ["a", "b"])

[[1, "a"], [2, "b"]]

Returns the minimum element in an array based on a provided function that extracts a comparable value from each element.

min_by([3, 1, 2], identity)

1

Returns the maximum element in an array based on a provided function that extracts a comparable value from each element.

max_by([3, 1, 2], identity)

3

Returns the lines of a string as an array by splitting on newline characters.

lines("a\nb\nc")

["a", "b", "c"]

Joins an array of strings into a single string with newline characters between them.

unlines(["a", "b", "c"]) == "a\nb\nc"

true

Returns a new dictionary containing only the specified keys from the original dictionary, if they exist.

pick({"a": 1, "b": 2}, ["a"])

{"a": 1}

Returns a new dictionary excluding the specified keys from the original dictionary.

omit({"a": 1, "b": 2}, ["a"])

{"b": 2}

Checks if a dict has the given key, or an array has an element at the given index.

has({"a": 1}, "a")

true

Retrieves a nested value by following an array of keys/indices, e.g. `get_path(d, ["a", "b", 0])`. Returns None as soon as any intermediate step is missing.

get_path({"a": {"b": 1}}, ["a", "b"])

1

Sets a nested value by following an array of keys/indices, e.g. `set_path(d, ["a", "b", 0], 1)`. Missing intermediate dicts/arrays are created automatically, choosing an array when the corresponding path element is a number and a dict otherwise.

set_path({"a": {"b": 1}}, ["a", "b"], 2)

{"a": {"b": 2}}

Deletes the value at a nested path, following an array of keys/indices, e.g. `del_path(d, ["a", "b", 0])`. An empty path deletes the whole value, mirroring jq's `delpaths([[]])`. A path through a missing intermediate container, or ending in a missing key/out-of-range index, leaves `value` unchanged.

del_path({"a": {"b": 1, "c": 2}}, ["a", "b"])

{"a": {"c": 2}}

Deletes the values at multiple nested paths, e.g. `del_paths(d, [["a"], ["b", 0]])`. Paths are applied deepest-first (via `sort`/`reverse`) so that deleting one array element doesn't shift the indices used by the remaining paths, mirroring jq's `delpaths`.

del_paths({"a": 1, "b": 2, "c": 3}, [["a"], ["c"]])

{"b": 2}

Returns an array of leaf-path arrays for a value, e.g. `paths({"a": {"b": 1}})` returns `[["a", "b"]]`. Each returned path can be passed to `get_path`/`set_path`. Containers with no leaves (e.g. `{}`, `[]`) contribute no paths.

paths({"a": {"b": 1}})

[["a", "b"]]

Builds a dict from an array of [key, value] pairs, as produced by `entries`. If the same key appears more than once, the last occurrence wins.

from_entries([["a", 1], ["b", 2]])

{"a": 1, "b": 2}

Transforms each [key, value] pair of a dict by applying the given function, then rebuilds a dict from the resulting pairs.

with_entries({"a": 1}, fn(e): [e[0], e[1] + 1];)

{"a": 2}

Deep merges two values, recursing into dicts key by key. Neither input is mutated. When both sides provide a leaf/array value for the same key, the conflict is resolved according to `policy`, one of: - `"replace"`: the second value (`b`) wins. - `"append"`: arrays are concatenated; other conflicting values are collected into `[a, b]`. - `"error"`: raises an error describing the conflict.

merge_with({"a": 1, "b": {"x": 1}}, {"b": {"y": 2}, "c": 3}, "replace")

{"a": 1, "b": {"x": 1, "y": 2}, "c": 3}

Deep merges `d` over `defaults`, similar to Jsonnet's object inheritance: values present in `d` win (recursively for nested dicts), while keys missing from `d` fall back to the corresponding value in `defaults`. Arrays and scalar conflicts are resolved by letting `d` replace `defaults`. Neither input is mutated.

merge_defaults({"a": {"x": 1}}, {"a": {"x": 0, "y": 2}, "b": 3})

{"a": {"x": 1, "y": 2}, "b": 3}

Parses frontmatter from a markdown node, supporting both YAML and TOML formats.

Walks through a value (which can be a markdown node, array, or dict) and applies a function to each element, returning a new structure with the results.

walk([1, [2, 3]], fn(x): if (is_number(x)): x * 2 else: x;)

[2, [4, 6]]

Formats a byte count as a human-readable decimal (SI, 1000-based) string, e.g. `human_bytes(1500)` => "1.5KB". Negative numbers keep their sign.

human_bytes(1500)

1.5KB

Formats a byte count as a human-readable binary (IEC, 1024-based) string without the "i" suffix, matching `numfmt --to=iec`, e.g. `human_size(1536)` => "1.5K". Negative numbers keep their sign.

human_size(1536)

1.5K

Parses a base64-encoded CBOR string (or raw bytes) and returns the corresponding data structure.

Module: import "cbor" | cbor::cbor_parse(...)

import "cbor" | cbor::cbor_parse(cbor::cbor_stringify({"a": 1}))

{"a": 1}

Serializes a value to CBOR bytes.

Module: import "cbor" | cbor::cbor_stringify(...)

import "cbor" | cbor::cbor_stringify(1)

f93c00

Checks whether a field's string form needs quoting for the given delimiter (RFC 4180): it contains a quote, newline, carriage return, the delimiter itself, or leading/trailing whitespace.

Module: import "csv" | csv::csv_needs_quote(...)

import "csv" | csv::csv_needs_quote("a,b", ",")

true

Parses CSV content with a specified delimiter and optional header row.

Module: import "csv" | csv::csv_parse_with_delimiter(...)

import "csv" | csv::csv_parse_with_delimiter("a;b\n1;2", ";", true)

[{"a": "1", "b": "2"}]

Parses CSV content using a comma as the delimiter.

Module: import "csv" | csv::csv_parse(...)

import "csv" | csv::csv_parse("name,age\nAlice,30", true)

[{"name": "Alice", "age": "30"}]

Parses TSV (Tab-Separated Values) content.

Module: import "csv" | csv::tsv_parse(...)

import "csv" | csv::tsv_parse("name\tage\nAlice\t30", true)

[{"name": "Alice", "age": "30"}]

Parses PSV (Pipe-Separated Values) content.

Module: import "csv" | csv::psv_parse(...)

import "csv" | csv::psv_parse("name|age\nAlice|30", true)

[{"name": "Alice", "age": "30"}]

Converts data to a CSV string with a specified delimiter.

Module: import "csv" | csv::csv_stringify(...)

import "csv" | csv::csv_stringify([{"name": "Alice", "age": 30}], ",")

name,age
Alice,30

Converts CSV data to a Markdown table format.

Module: import "csv" | csv::csv_to_markdown_table(...)

import "csv" | csv::csv_to_markdown_table([{"name": "Alice", "age": 30}])

| name | age |
| --- | --- |
| Alice | 30 |

Converts CSV data to a JSON string.

Module: import "csv" | csv::csv_to_json(...)

import "csv" | csv::csv_to_json([{"name": "Alice", "age": 30}])

[{"name":"Alice","age":30}]

Calculates the Levenshtein distance between two strings.

Module: import "fuzzy" | fuzzy::levenshtein(...)

import "fuzzy" | fuzzy::levenshtein("kitten", "sitting")

3

Calculates the Jaro distance between two strings (0.0 to 1.0, where 1.0 is exact match).

Module: import "fuzzy" | fuzzy::jaro(...)

import "fuzzy" | fuzzy::jaro("martha", "marhta")

0.944444

Calculates the Jaro-Winkler distance between two strings.

Module: import "fuzzy" | fuzzy::jaro_winkler(...)

import "fuzzy" | fuzzy::jaro_winkler("martha", "marhta")

0.961111

Performs fuzzy matching on an array of strings using Jaro-Winkler distance.

Module: import "fuzzy" | fuzzy::fuzzy_match(...)

import "fuzzy" | fuzzy::fuzzy_match(["apple", "aple", "banana"], "aple")

[{"text": "aple", "score": 1}, {"text": "apple", "score": 0.946667}, {"text": "banana", "score": 0.472222}]

Performs fuzzy matching using Levenshtein distance.

Module: import "fuzzy" | fuzzy::fuzzy_match_levenshtein(...)

import "fuzzy" | fuzzy::fuzzy_match_levenshtein(["apple", "aple", "banana"], "aple")

[{"text": "aple", "score": 0}, {"text": "apple", "score": 1}, {"text": "banana", "score": 5}]

Performs fuzzy matching using Jaro distance.

Module: import "fuzzy" | fuzzy::fuzzy_match_jaro(...)

import "fuzzy" | fuzzy::fuzzy_match_jaro(["apple", "aple", "banana"], "aple")

[{"text": "aple", "score": 1}, {"text": "apple", "score": 0.933333}, {"text": "banana", "score": 0.472222}]

Filters candidates by minimum fuzzy match score using Jaro-Winkler.

Module: import "fuzzy" | fuzzy::fuzzy_filter(...)

import "fuzzy" | fuzzy::fuzzy_filter(["apple", "aple", "banana"], "aple", 0.8)

[{"text": "aple", "score": 1}, {"text": "apple", "score": 0.946667}]

Finds the best fuzzy match from candidates.

Module: import "fuzzy" | fuzzy::fuzzy_best_match(...)

import "fuzzy" | fuzzy::fuzzy_best_match(["apple", "aple", "banana"], "aple")

{"text": "aple", "score": 1}

Parses gron-style `path = value;` assignment statements (as produced by `mq -F gron`) and returns the corresponding data structure.

Module: import "gron" | gron::gron_parse(...)

import "gron" | gron::gron_parse("json.a = 1;\njson.b = 2;")

{"a": 1, "b": 2}

Parses a JSON string and returns the corresponding data structure.

Module: import "json" | json::json_parse(...)

import "json" | json::json_parse("{\"a\": 1}")

{"a": 1}

Serializes a value to a JSON string.

Module: import "json" | json::json_stringify(...)

import "json" | json::json_stringify({"a": 1})

{"a": 1}

Converts a JSON data structure to a Markdown table.

Module: import "json" | json::json_to_markdown_table(...)

import "json" | json::json_to_markdown_table([{"a": 1, "b": 2}])

| a | b |
| --- | --- |
| 1 | 2 |

Wraps `value` in a heading node at the given `depth` (1-6).

Module: import "md" | md::h(...)

import "md" | md::h("Title", 1)

# Title

Wraps `value` in a fenced code block with the given `lang`.

Module: import "md" | md::code(...)

Wraps `value` in an inline code span.

Module: import "md" | md::code_inline(...)

import "md" | md::code_inline("x")

`x`

Creates a plain text node from `value`.

Module: import "md" | md::text(...)

import "md" | md::text("hi")

hi

Wraps `value` in a strong (bold) node.

Module: import "md" | md::strong(...)

import "md" | md::strong("Bold")

**Bold**

Wraps `value` in an emphasis (italic) node.

Module: import "md" | md::em(...)

import "md" | md::em("Italic")

*Italic*

Wraps `value` in a delete (strikethrough) node.

Module: import "md" | md::delete(...)

import "md" | md::delete("Old")

~~Old~~

Wraps `value` in a blockquote node.

Module: import "md" | md::blockquote(...)

import "md" | md::blockquote("Quote")

> Quote

Wraps `value` in a callout node of the given `kind` (e.g. "note", "warning"), with an optional custom `title`.

Module: import "md" | md::callout(...)

import "md" | md::callout("Note text", "note", "")

> [!NOTE]
> Note text

Creates a horizontal rule node.

Module: import "md" | md::hr(...)

import "md" | md::hr()

***

Creates a blank line between the surrounding elements in a `doc()`/`to_md_fragment()` call.

Module: import "md" | md::br(...)

Wraps `value` in a math block node.

Module: import "md" | md::math(...)

import "md" | md::math("x^2")

$$
x^2
$$

Wraps `value` in an inline math node.

Module: import "md" | md::math_inline(...)

import "md" | md::math_inline("x^2")

$x^2$

Creates a link node pointing to `url` with link text `value` and an optional `title`.

Module: import "md" | md::link(...)

import "md" | md::link("https://example.com", "Example", "")

[Example](https://example.com)

Creates an image node pointing to `url` with `alt` text and an optional `title`.

Module: import "md" | md::image(...)

import "md" | md::image("https://example.com/a.png", "Alt", "")

![Alt](https://example.com/a.png "")

Wraps `value` in a footnote definition node identified by `ident`.

Module: import "md" | md::footnote(...)

import "md" | md::footnote("Footnote text", "1")

[^1]: Footnote text

Creates a footnote reference node pointing at `ident`.

Module: import "md" | md::footnote_ref(...)

import "md" | md::footnote_ref("1")

[^1]

Creates a link reference definition node (`[ident]: url "title"`) for `ident`, with an optional `title`.

Module: import "md" | md::definition(...)

import "md" | md::definition("https://example.com", "ex", "")

[ex]: https://example.com

Wraps `value` in a raw HTML node, emitted as-is.

Module: import "md" | md::html(...)

import "md" | md::html("<br>")

<br>

Creates a hard line break node.

Module: import "md" | md::linebreak(...)

Wraps `value` in a list item node at the given `level` (0-indexed nesting), optionally `ordered` (numbered) and/or `checked` (checkbox); pass `checked = None` for a plain item.

Module: import "md" | md::list(...)

import "md" | md::list("Item", 0)

- Item

Creates a table row node from an array of cell values.

Module: import "md" | md::table_row(...)

import "md" | md::table_row(["a", "b"])

|a|b|

Creates a single table cell node at the given `row`/`column`.

Module: import "md" | md::table_cell(...)

import "md" | md::table_cell("A1", 0, 0)

A1

Creates a table alignment (header separator) row node from an array of alignments (e.g. ["left", "right", "center"]).

Module: import "md" | md::table_align(...)

import "md" | md::table_align(["left", "right"])

|:---|---:|

Builds a full table from a `header` array of cell values and a `rows` array of row arrays. `aligns` is an array of alignment strings (e.g. ["left", "right", "center"]) matching `header`'s length; defaults to no alignment. Returns an array of row/align nodes ready to splice into `doc()`.

Module: import "md" | md::table(...)

import "md" | md::doc(md::table(["A", "B"], [["1", "2"], ["3", "4"]]))

|A|B|
|---|---|
|1|2|
|3|4|

Combines markdown nodes into a single markdown value. Accepts either a variable number of arguments (`doc(a, b, c)`) or a single array (`doc([a, b, c])`). Nested arrays (e.g. from `map()`) are flattened automatically, so components can return plain arrays of nodes and be spliced in as children.

Module: import "md" | md::doc(...)

import "md" | md::doc(md::h("T", 1), md::text("hi"))

# T
hi

Returns sections whose title contains the specified pattern. If depth is true, each section spans until the next header at the same or higher level (delegates to section::sections(md_nodes, depth), see its doc for details).

Module: import "section" | section::section(...)

import "section" | len(section::section(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"), "A"))

2

Splits markdown nodes into sections based on headers. If depth is true, each section's body extends to the next heading at the same or higher level as that section's own heading, so nested subheadings' content is included in their parent's body. If depth is false (default), every heading of any level is a boundary, so a heading's body only extends to the very next heading regardless of level.

Module: import "section" | section::sections(...)

import "section" | len(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")))

3

import "section" | len(section::body(first(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"), true))))

3

Filters sections based on a given predicate function.

Module: import "section" | section::filter_sections(...)

import "section" | len(section::filter_sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"), fn(s): true;))

3

Maps sections using a given mapper function.

Module: import "section" | section::map_sections(...)

import "section" | section::map_sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"), fn(header, children): to_text(header);)

["A", "A1", "B"]

Returns an array of sections, each section is an array of markdown nodes between the specified header and the next header of the same level.

Module: import "section" | section::split(...)

import "section" | len(section::split(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"), 1))

2

Filters the given list of sections, returning only those whose title contains the specified text.

Module: import "section" | section::title_contains(...)

import "section" | len(section::title_contains(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")), "A"))

2

Filters sections by a pattern match in the title text.

Module: import "section" | section::title_match(...)

import "section" | len(section::title_match(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")), "^A"))

2

Returns the title text of a section (header text without the # symbols).

Module: import "section" | section::title(...)

import "section" | section::title(first(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"))))

A

Returns the content of a section (all nodes except the header). Deprecated: Use body() instead, as content()

Module: import "section" | section::content(...)

import "section" | len(section::content(first(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")))))

1

Returns the body of a section (all nodes except the header).

Module: import "section" | section::body(...)

import "section" | len(section::body(first(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")))))

1

Returns all nodes of a section, including both the header and content.

Module: import "section" | section::all_nodes(...)

import "section" | len(section::all_nodes(first(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")))))

2

Filters sections by heading level. l can be a number (exact level) or a range array (e.g. 1..2).

Module: import "section" | section::by_level(...)

import "section" | len(section::by_level(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")), 1))

2

Returns the header level (1-6) of a section.

Module: import "section" | section::level(...)

import "section" | section::level(first(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"))))

1

Returns the nth section from an array of sections (0-indexed).

Module: import "section" | section::nth(...)

import "section" | section::title(section::nth(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")), 0))

A

Extracts titles from all sections.

Module: import "section" | section::titles(...)

import "section" | section::titles(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")))

["A", "A1", "B"]

Extracts body from all sections.

Module: import "section" | section::bodies(...)

import "section" | len(section::bodies(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"))))

3

Generates a table of contents from sections.

Module: import "section" | section::toc(...)

import "section" | section::toc(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B")))

["  - A", "    - A1", "  - B"]

Checks if a section has any content beyond the header.

Module: import "section" | section::has_content(...)

import "section" | section::has_content(first(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"))))

true

Flattens sections back to markdown nodes for output. This converts section objects back to their original markdown node arrays.

Module: import "section" | section::collect(...)

import "section" | len(section::collect(section::sections(to_markdown("# A\n\nBody A\n\n## A1\n\nSub A\n\n# B\n\nBody B"))))

6

Parses a SemVer string into a dict with major, minor, patch, pre, and build fields.

Module: import "semver" | semver::semver_parse(...)

import "semver" | semver::semver_to_string(semver::semver_parse("1.2.3-beta.1"))

1.2.3-beta.1

Converts a parsed SemVer dict back to a version string.

Module: import "semver" | semver::semver_to_string(...)

import "semver" | semver::semver_to_string(semver::semver_parse("1.2.3-beta"))

1.2.3-beta

Compares two parsed SemVer dicts. Returns -1 if a < b, 0 if a == b, 1 if a > b.

Module: import "semver" | semver::semver_compare(...)

import "semver" | semver::semver_compare(semver::semver_parse("1.0.0"), semver::semver_parse("2.0.0"))

-1

Returns true if version a is greater than version b.

Module: import "semver" | semver::semver_gt(...)

import "semver" | semver::semver_gt(semver::semver_parse("2.0.0"), semver::semver_parse("1.0.0"))

true

Returns true if version a is less than version b.

Module: import "semver" | semver::semver_lt(...)

import "semver" | semver::semver_lt(semver::semver_parse("1.0.0"), semver::semver_parse("2.0.0"))

true

Returns true if version a equals version b (ignoring build metadata).

Module: import "semver" | semver::semver_eq(...)

import "semver" | semver::semver_eq(semver::semver_parse("1.0.0"), semver::semver_parse("1.0.0"))

true

Returns true if version a is greater than or equal to version b.

Module: import "semver" | semver::semver_gte(...)

import "semver" | semver::semver_gte(semver::semver_parse("1.0.0"), semver::semver_parse("1.0.0"))

true

Returns true if version a is less than or equal to version b.

Module: import "semver" | semver::semver_lte(...)

import "semver" | semver::semver_lte(semver::semver_parse("1.0.0"), semver::semver_parse("1.0.0"))

true

Increments the major version and resets minor, patch, and pre-release.

Module: import "semver" | semver::semver_bump_major(...)

import "semver" | semver::semver_to_string(semver::semver_bump_major(semver::semver_parse("1.2.3")))

2.0.0

Increments the minor version and resets patch and pre-release.

Module: import "semver" | semver::semver_bump_minor(...)

import "semver" | semver::semver_to_string(semver::semver_bump_minor(semver::semver_parse("1.2.3")))

1.3.0

Increments the patch version and clears pre-release.

Module: import "semver" | semver::semver_bump_patch(...)

import "semver" | semver::semver_to_string(semver::semver_bump_patch(semver::semver_parse("1.2.3")))

1.2.4

Sorts an array of parsed SemVer dicts in ascending order.

Module: import "semver" | semver::semver_sort(...)

import "semver" | map(semver::semver_sort([semver::semver_parse("2.0.0"), semver::semver_parse("1.0.0")]), semver::semver_to_string)

["1.0.0", "2.0.0"]

Returns the maximum version from an array of parsed SemVer dicts.

Module: import "semver" | semver::semver_max(...)

import "semver" | semver::semver_to_string(semver::semver_max([semver::semver_parse("1.0.0"), semver::semver_parse("2.0.0")]))

2.0.0

Returns the minimum version from an array of parsed SemVer dicts.

Module: import "semver" | semver::semver_min(...)

import "semver" | semver::semver_to_string(semver::semver_min([semver::semver_parse("1.0.0"), semver::semver_parse("2.0.0")]))

1.0.0

Returns true if the given version string satisfies every comma-separated comparator in `range`. Supported comparators: "=", "==", "!=", ">", ">=", "<", "<=". A bare version (no operator) requires an exact match. Example: semver_satisfies("1.5.0", ">=1.0.0,<2.0.0") == true

Module: import "semver" | semver::semver_satisfies(...)

import "semver" | semver::semver_satisfies("1.5.0", ">=1.0.0,<2.0.0")

true

Extract table structures from a list of markdown nodes.

Module: import "table" | table::tables(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | len(self)

1

Set the alignment for a table.

Module: import "table" | table::set_align(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::set_align(self, ["left", "right"]) | table::to_csv(self)

a,b
1,2
3,4

Add a new row to a table.

Module: import "table" | table::add_row(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::add_row(self, ["5", "6"]) | table::to_csv(self)

a,b
1,2
3,4
5,6

Add a new column to a table.

Module: import "table" | table::add_column(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::add_column(self, ["c", "9", "10"]) | table::to_csv(self)

a,b,c
1,2,9
3,4,10

Remove a row from a table at the specified index.

Module: import "table" | table::remove_row(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::remove_row(self, 0) | table::to_csv(self)

a,b
3,4

Remove a column from a table at the specified index.

Module: import "table" | table::remove_column(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::remove_column(self, 0) | len(self[:rows][0])

1

Map a function over each row in the table.

Module: import "table" | table::map_rows(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::map_rows(self, fn(row): row;) | table::to_csv(self)

a,b
1,2
3,4

Filter tables from markdown nodes based on a predicate function.

Module: import "table" | table::filter_tables(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | table::filter_tables(self, fn(h, r): true;) | len(self)

1

Filter rows in the table based on a predicate function.

Module: import "table" | table::filter_rows(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::filter_rows(self, fn(row): true;) | table::to_csv(self)

a,b
1,2
3,4

Sort rows in the table by a specified column index or default sorting.

Module: import "table" | table::sort_rows(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::sort_rows(self) | table::to_csv(self)

a,b
1,2
3,4

Convert a table structure back into a list of markdown nodes.

Module: import "table" | table::to_markdown(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::to_markdown(self) | len(self)

7

Convert a table structure into a CSV string with the specified delimiter.

Module: import "table" | table::to_csv(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::to_csv(self)

a,b
1,2
3,4

Convert a table structure into an array of dict records keyed by header text. The resulting shape matches `csv::csv_parse`'s output, so it composes with `join_by` and other record-array builtins.

Module: import "table" | table::to_array(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::to_array(self)

[{"a": "1", "b": "2"}, {"a": "3", "b": "4"}]

Reshape a table from wide format to long format (a.k.a. melt/unpivot). `value_columns` is an array of column indices to unpivot; each one becomes a row holding its header name (in the `names_to` column) and its cell value (in the `values_to` column). Columns not listed in `value_columns` are treated as identifier columns and repeated for every unpivoted value.

Module: import "table" | table::pivot_longer(...)

import "table" | table::tables(to_markdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |")) | first(self) | table::pivot_longer(self, [1]) | table::to_csv(self)

a,name,value
1,b,2
3,b,4

Reshape a table from long format to wide format (a.k.a. pivot/cast). `names_from` is the column index whose distinct values become the headers of new columns; `values_from` is the column index supplying the values for those new columns. Columns other than `names_from` and `values_from` are treated as identifier columns and used to group rows together.

Module: import "table" | table::pivot_wider(...)

import "table" | table::tables(to_markdown("| id | name | value |\n| --- | --- | --- |\n| 1 | x | 10 |\n| 1 | y | 20 |")) | first(self) | table::pivot_wider(self, 1, 2) | table::to_csv(self)

id,x,y
1,10,20

Verifies that a condition is true and raises an error if it's false.

Module: import "test" | test::assert(...)

true | include "test" | assert(true)

true

Verifies that two values are equal

Module: import "test" | test::assert_eq(...)

1 | include "test" | assert_eq(1, 1)

1

Verifies that two values are not equal

Module: import "test" | test::assert_ne(...)

1 | include "test" | assert_ne(1, 2)

1

Verifies that a value is true

Module: import "test" | test::assert_true(...)

true | include "test" | assert_true(true)

true

Verifies that a value is false

Module: import "test" | test::assert_false(...)

false | include "test" | assert_false(false)

false

Verifies that a value is None

Module: import "test" | test::assert_none(...)

None | include "test" | assert_none(None)

Verifies that a value is not None

Module: import "test" | test::assert_not_none(...)

1 | include "test" | assert_not_none(1)

1

Verifies that an array contains a specific value

Module: import "test" | test::assert_contains(...)

[1, 2] | include "test" | assert_contains([1, 2], 1)

[1, 2]

Verifies that an array has a specific length

Module: import "test" | test::assert_len(...)

[1, 2] | include "test" | assert_len([1, 2], 2)

[1, 2]

Verifies that an array is empty

Module: import "test" | test::assert_empty(...)

[] | include "test" | assert_empty([])

[]

Verifies that an array is not empty

Module: import "test" | test::assert_not_empty(...)

[1] | include "test" | assert_not_empty([1])

[1]

Verifies that a value has the given type. For markdown nodes this checks the node kind (e.g. "h1", "code", "list"), matching `to_md_name`. For every other value it checks the runtime type returned by `type`. On failure the source range of `value` is included so callers (e.g. content-lint rules) can point at the offending node.

Module: import "test" | test::assert_type(...)

1 | include "test" | assert_type(1, "number")

1

Verifies that a dict has the given field.

Module: import "test" | test::assert_field(...)

{"a": 1} | include "test" | assert_field({"a": 1}, "a")

{"a": 1}

Verifies that a value's string representation matches the given regular expression pattern.

Module: import "test" | test::assert_matches(...)

"abc" | include "test" | assert_matches("abc", "a.c")

abc

Executes multiple test functions. The whole report is built as a single string and printed with one `print` call, so concurrently running test files (the Rust runner may evaluate several files in parallel) can never interleave their output mid-line. Returns `true` if every test passed, so the caller can aggregate pass/fail across files itself instead of this function terminating the process.

Module: import "test" | test::run_tests(...)

Helper function to create a test case

Module: import "test" | test::test_case(...)

include "test" | test_case("my test", fn(): true;)["name"]

my test

Parses a TOML string and returns the parsed data structure.

Module: import "toml" | toml::toml_parse(...)

import "toml" | toml::toml_parse("key = 1")

{"key": 1}

Converts a data structure to a TOML string representation.

Module: import "toml" | toml::toml_stringify(...)

import "toml" | toml::toml_stringify({"key": 1})

key = 1

Converts a data structure to a JSON string representation.

Module: import "toml" | toml::toml_to_json(...)

import "toml" | toml::toml_to_json({"key": 1})

{"key":1}

Converts a TOML data structure to a Markdown table.

Module: import "toml" | toml::toml_to_markdown_table(...)

import "toml" | toml::toml_to_markdown_table([{"a": 1}])

| a |
| --- |
| 1 |

To convert a data structure into a TOON string

Module: import "toon" | toon::toon_stringify(...)

import "toon" | toon::toon_stringify({"a": 1})

a: 1

To parse a TOON string into a data structure

Module: import "toon" | toon::toon_parse(...)

import "toon" | toon::toon_parse(toon::toon_stringify({"a": 1}))

{"a": 1}

Parses an XML string and returns the corresponding data structure.

Module: import "xml" | xml::xml_parse(...)

import "xml" | xml::xml_parse("<a>hi</a>")["tag"]

a

Serializes a value to an XML string.

Module: import "xml" | xml::xml_stringify(...)

import "xml" | xml::xml_stringify({"tag": "a", "attributes": {}, "children": [], "text": "hi"})

<?xml version="1.0" encoding="UTF-8"?>
<a>hi</a>

Converts an XML data structure to a Markdown table.

Module: import "xml" | xml::xml_to_markdown_table(...)

import "xml" | xml::xml_to_markdown_table({"tag": "a", "attributes": {}, "children": [], "text": "hi"})

| Tag | Attributes | Text | Children |
| --- | --- | --- | --- |
| a |  | hi | 0 |

Parses a YAML string and returns the parsed data structure. A single `---`-separated document is returned as-is; if the input contains multiple `---`-separated documents, an array of the parsed documents is returned.

Module: import "yaml" | yaml::yaml_parse(...)

import "yaml" | yaml::yaml_parse("key: 1")

{"key": 1}

Converts a data structure to a YAML string representation.

Module: import "yaml" | yaml::yaml_stringify(...)

import "yaml" | yaml::yaml_stringify({"key": 1})

key: 1

Converts a YAML data structure to a Markdown table.

Module: import "yaml" | yaml::yaml_to_markdown_table(...)

import "yaml" | yaml::yaml_to_markdown_table([{"a": 1}])

| a |
| --- |
| 1 |

Converts a data structure to a JSON string representation.

Module: import "yaml" | yaml::yaml_to_json(...)

import "yaml" | yaml::yaml_to_json({"key": 1})

{"key": 1}

Converts a data structure to a YAML front matter string. deprecated: use to_frontmatter instead

Module: import "yaml" | yaml::to_front_matter(...)

import "yaml" | yaml::to_front_matter({"key": 1})

---
key: 1
---

Converts a data structure to a YAML front matter string.

Module: import "yaml" | yaml::to_frontmatter(...)

import "yaml" | yaml::to_frontmatter({"key": 1})

---
key: 1
---