textlane 0.0.0 → 0.2.0

package/build/generated/md.d.ts

@@ -0,0 +1,367 @@
+import type { Plugin } from "../models/plugin.ts";
+/** `md.parse`: Markdown into mdast. */
+export type ParseOptions = Record<string, unknown>;
+/** `md.directive`: generic directives, `:a`, `::b` and `:::c`, read by `md.parse` and written by `md.stringify`; options named as mdast-util-directive's serializer names them. */
+export interface DirectiveOptions {
+    /** Write an empty attribute as its name alone, `{a}`, rather than `{a=""}`. @default true */
+    collapseEmptyAttributes?: boolean;
+    /** Write `id` and `class` as `#a` and `.b` where they can be. @default true */
+    preferShortcut?: boolean;
+    /** Leave attribute values unquoted where they can be. @default false */
+    preferUnquoted?: boolean;
+    /** The quote of attribute values: `"` or `'`; `md.stringify`'s `quote` when unset. */
+    quote?: string | null;
+    /** Use the other quote when the preferred one occurs more often in a value. @default false */
+    quoteSmart?: boolean;
+}
+/** `md.gfm`: GitHub Flavored Markdown's syntax, read by `md.parse` and written by `md.stringify`; options named as remark-gfm names them. */
+export interface GfmOptions {
+    /** Let one tilde, `~a~`, form strikethrough, as well as two. @default true */
+    singleTilde?: boolean;
+    /** Pad table cells with a space on each side when writing Markdown. @default true */
+    tableCellPadding?: boolean;
+    /** Line up table pipes when writing Markdown. @default true */
+    tablePipeAlign?: boolean;
+    /** Write a footnote definition's first line blank when it holds flow content. @default false */
+    firstLineBlank?: boolean;
+}
+/** `md.math`: math syntax, `$$` blocks and `$` text, read by `md.parse` and written by `md.stringify`; options named as remark-math names them. */
+export interface MathOptions {
+    /** Let one dollar, `$a$`, form math in text, as well as two. @default true */
+    singleDollarTextMath?: boolean;
+}
+/** `md.mdx`: MDX syntax, JSX, expressions and ESM, read by `md.parse` and written by `md.stringify`; it turns off indented code, autolinks and raw HTML; options named as remark-mdx and mdast-util-mdx-jsx's serializer name them. */
+export interface MdxOptions {
+    /** The quote of JSX attribute values: `"` (when unset) or `'`. */
+    quote?: string | null;
+    /** Use the other quote when the preferred one occurs more often in a value. @default false */
+    quoteSmart?: boolean;
+    /** Write self-closing tags without a space before the slash, `<a/>`. @default false */
+    tightSelfClosing?: boolean;
+    /** The width past which a flow element's attributes go on lines of their own. */
+    printWidth?: number | null;
+}
+/** The kinds of matter to recognize, as remark-frontmatter takes them (a preset, a matter, or a list of them; `yaml` when unset), or textlane's options object. */
+export type FrontmatterOptions = "yaml" | "toml" | Matter | ("yaml" | "toml" | Matter)[] | FrontmatterSettings;
+/** One kind of frontmatter: the node `type` it becomes and its fences, a `marker` repeated three times or a whole `fence`. */
+export interface Matter {
+    type: string;
+    marker?: Fence;
+    fence?: Fence;
+    anywhere?: boolean;
+}
+/** Different opening and closing fences. */
+export interface FencePair {
+    open: string;
+    close: string;
+}
+/** A fence, or its opening and closing ones. */
+export type Fence = string | FencePair;
+/** textlane's options: the matters, and what to do with YAML frontmatter. */
+export interface FrontmatterSettings {
+    /** The kinds of matter to recognize, as remark-frontmatter takes them; `yaml` when unset. */
+    matters?: "yaml" | "toml" | Matter | ("yaml" | "toml" | Matter)[];
+    /** Parse the YAML frontmatter a document starts with into `file.data.matter`, `{}` when there is none, as vfile-matter does. */
+    data?: boolean;
+    /** Remove the YAML frontmatter a document starts with from the tree. */
+    strip?: boolean;
+}
+/** `md.component`: directives, GitHub alerts and other nodes into MDX JSX elements, the components an MDX runtime renders, by declarative rules. */
+export interface ComponentOptions {
+    /** Rules for directives; the first that matches a directive converts it. */
+    directives?: DirectiveRule[];
+    /** GitHub alerts, `> [!NOTE]`, into a component. */
+    alerts?: AlertRule | null;
+    /** Node types, such as `defList`, into components keeping their children. @default {} */
+    nodes?: Record<string, string>;
+    /** What becomes of a directive no rule converts. */
+    unknownDirectives?: UnknownDirectives;
+    /** Rules for fenced code; the first that matches a block applies. */
+    codes?: CodeRule[];
+}
+/** How `md.component` turns matching directives into one component. */
+export interface DirectiveRule {
+    /** The directive's name, or several. */
+    name: Names;
+    /** The kind of directive: `text`, `leaf` or `container`; any when left out. */
+    kind?: DirectiveKind | null;
+    /** Attribute values the directive must have. @default {} */
+    where?: Record<string, string>;
+    /** The component: a text element for a text directive, else a flow element. */
+    component: string;
+    /** The attribute that gets the directive's name. */
+    nameAs?: string | null;
+    /** The attribute that gets the label's text: a container's label paragraph or a text or leaf directive's content, which is then dropped. */
+    labelAs?: string | null;
+    /** The label's text when there is none. */
+    labelDefault?: string | null;
+    /** The attributes to keep, in order; every one, as written, when left out. */
+    attributes?: AttributeRule[] | null;
+    /** Attributes without which the directive is left to `unknownDirectives`. @default [] */
+    required?: string[];
+    /** Wrap runs of adjacent siblings this rule converted in another component. */
+    group?: GroupRule | null;
+    /** The attribute that gets the lists of a container directive as a file tree, JSON items `{name, type, comment?, highlighted?, children?}`; the lists leave its content. */
+    treeAs?: string | null;
+}
+/** One name or several. */
+export type Names = string | string[];
+/** A directive's kind, by how many colons open it. */
+export type DirectiveKind = "text" | "leaf" | "container";
+/** An attribute to keep: its name, or its name with what to call it and a default. */
+export type AttributeRule = string | {
+    name: string;
+    rename?: string | null;
+    default?: string | null;
+};
+/** The component wrapping a run of adjacent siblings one rule converted. */
+export interface GroupRule {
+    /** The wrapping component. */
+    component: string;
+    /** The shortest run wrapped; 2 when left out. */
+    min?: number | null;
+    /** Attributes the wrapper copies from the run's first element. @default [] */
+    inherit?: string[];
+}
+/** How `md.component` turns GitHub alerts, a block quote opening with `[!TYPE]`, into a component. */
+export interface AlertRule {
+    /** The component an alert becomes. */
+    component: string;
+    /** The attribute that gets the alert's type. */
+    typeAs: string;
+    /** Each alert type, as written, to the value of `typeAs`; other types stay block quotes. */
+    types: Record<string, string>;
+}
+/** What `md.component` does with a directive no rule converts. */
+export type UnknownDirectives = "keep" | "source";
+/** How `md.component` turns matching code blocks into a component, or groups them. */
+export interface CodeRule {
+    /** The block's language, or several; any when left out. */
+    lang?: Names | null;
+    /** A `key="value"` the block's meta must hold. */
+    meta?: string | null;
+    /** The component the block becomes; left out, the block stays code and only groups. */
+    component?: string | null;
+    /** The attribute that gets the code; left out, the code is the component's text. */
+    valueAs?: string | null;
+    /** Meta `key="value"` pairs to keep as attributes, in order. */
+    attributes?: AttributeRule[];
+    /** Wrap runs of adjacent blocks this rule matched in another component. */
+    group?: CodeGroupRule | null;
+}
+/** The component wrapping a run of adjacent code blocks one rule matched; the meta keys it reads are taken out of each block's meta. */
+export interface CodeGroupRule {
+    /** The wrapping component. */
+    component: string;
+    /** The shortest run wrapped; 2 when left out. */
+    min?: number | null;
+    /** The attribute that gets the run's values of the rule's `meta` key, as a JSON list. */
+    collect?: string | null;
+    /** Meta keys the wrapper copies from the run's first block as attributes. @default [] */
+    inherit?: string[];
+}
+/** `md.packageCommand`: a fenced block of package-manager commands, its language naming the ecosystem (`npm`, `pip`, `cargo`), into one component with the commands converted for each manager, as `@docusaurus/remark-plugin-npm2yarn` does for npm. */
+export interface PackageCommandOptions {
+    /** The component a block becomes; one string attribute per manager. @default "PackageTabs" */
+    component?: string;
+    /** Each ecosystem's managers, in attribute order; an empty list leaves its blocks code. */
+    ecosystems?: Ecosystems;
+}
+/** The managers `md.packageCommand` converts each ecosystem's commands for. */
+export interface Ecosystems {
+    /** Managers for `npm` blocks, converted as npm-to-yarn converts; npm, pnpm, yarn and bun by default. */
+    npm?: NpmManager[];
+    /** Managers for `pip` blocks; pip, uv, poetry and pdm by default. */
+    pip?: PipManager[];
+    /** Managers for `cargo` blocks; cargo and cargo-binstall by default. */
+    cargo?: CargoManager[];
+}
+/** A JavaScript package manager an `npm` command converts to. */
+export type NpmManager = "npm" | "pnpm" | "yarn" | "bun" | "deno" | "nub";
+/** A Python package manager a `pip` command converts to. */
+export type PipManager = "pip" | "uv" | "poetry" | "pdm";
+/** A Rust installer a `cargo` command converts to. */
+export type CargoManager = "cargo" | "cargo-binstall";
+/** `md.headingId`: `{#id}` at the end of a heading, after a space, as its id, as remark-heading-id reads it; headings without one keep none. */
+export interface HeadingIdOptions {
+    /** Read a whole attribute list, `{#id .class key=value key="v w"}`, as directives write theirs: classes become `className` and other keys properties. @default false */
+    attributes?: boolean;
+    /** Literal suffixes, such as `[step]`, stripped from a heading's end for the attributes each names, a value or `true` for a bare one: `{"[step]": {"data-step": true}}`. */
+    markers?: Record<string, Record<string, MarkerValue>>;
+}
+/** An attribute a heading marker sets: its value, or `true` for the bare attribute. */
+export type MarkerValue = boolean | string;
+/** `md.pathRewrite`: the URLs of images, links and definitions as a site serves them: relative ones resolved against the file's path and made root-relative, every root-relative one under `base`, and links to Markdown files turned into page URLs. */
+export interface PathRewriteOptions {
+    /** The directory URLs count from, as the file's path spells it; the path's own starting point when left out. */
+    root?: string | null;
+    /** The URL the site is served at, such as `/docs`, put before every root-relative URL once. */
+    base?: string | null;
+    /** The nodes whose URLs are rewritten; images, links and definitions when left out. */
+    nodes?: UrlNode[] | null;
+    /** Markdown files, relative to `root`, to the URL of their page; a link to one of them takes it, before `markdownLinks` applies. @default {} */
+    pages?: Record<string, string>;
+    /** How a link to a Markdown file no page names becomes a URL. */
+    markdownLinks?: MarkdownLinks;
+}
+/** A node with a URL. */
+export type UrlNode = "image" | "link" | "definition";
+/** How a link to a Markdown file becomes a URL. */
+export type MarkdownLinks = "keep" | "directory" | "html";
+/** `md.strip`: mdast down to its text, as strip-markdown does: code, HTML, tables and the like dropped, headings made paragraphs, formatting unwrapped. */
+export interface StripOptions {
+    /** Node types to leave as they are, such as `inlineCode`. @default [] */
+    keep?: string[];
+    /** Node types to drop, besides those strip-markdown drops. @default [] */
+    remove?: string[];
+}
+/** `md.toc`: a table of contents under the first heading matching `heading`, replacing what sat between it and the next heading as deep or shallower, as remark-toc makes it. */
+export interface TocOptions {
+    /** The heading to put the table under, as JavaScript regular expression source matched against its whole text, case-insensitively; `(table[ -]of[ -])?contents?|toc` when unset. */
+    heading?: string | null;
+    /** The deepest heading rank to list, 1 to 6. */
+    maxDepth?: number | null;
+    /** The shallowest heading rank to list, 1 to 6. */
+    minDepth?: number | null;
+    /** Headings to leave out, as JavaScript regular expression source matched against their whole text, case-insensitively. */
+    skip?: string | null;
+    /** Keep the list compact, without blank lines between items; `true` when unset. */
+    tight?: boolean | null;
+    /** Number the list instead of bulleting it. */
+    ordered?: boolean | null;
+    /** What each link's fragment starts with, such as `user-content-`. */
+    prefix?: string | null;
+    /** The parents whose headings are listed, as a unist-util-is test: a node type, an object of fields a parent must equal, or a list of these; only the root when unset. */
+    parents?: ParentTest | null;
+}
+/** A unist-util-is test of a node, written as JSON: one check, or a list any of which passes. */
+export type ParentTest = ParentCheck | ParentCheck[];
+/** One unist-util-is check: a node type, or fields a node must equal. */
+export type ParentCheck = string | Record<string, unknown>;
+/** `md.stringify`: mdast into Markdown; options named as mdast-util-to-markdown names them. */
+export interface StringifyOptions {
+    /** The marker of unordered list items: `*`, `+` or `-`. */
+    bullet?: string | null;
+    /** The marker of ordered list items: `.` or `)`. */
+    bulletOrdered?: string | null;
+    /** The marker of a list right after a list with `bullet`. */
+    bulletOther?: string | null;
+    /** Close ATX headings with as many `#` as they open with. @default false */
+    closeAtx?: boolean;
+    /** The marker of emphasis: `*` or `_`. */
+    emphasis?: string | null;
+    /** The marker of fenced code: `` ` `` or `~`. */
+    fence?: string | null;
+    /** Fence code; `false` indents it where it can. @default true */
+    fences?: boolean;
+    /** Number ordered list items up from `start`. @default true */
+    incrementListMarker?: boolean;
+    /** How list item content is indented: `one`, `tab` or `mixed`. */
+    listItemIndent?: string | null;
+    /** The marker of titles: `"` or `'`. */
+    quote?: string | null;
+    /** Write links as resources even where an autolink would do. @default false */
+    resourceLink?: boolean;
+    /** The marker of thematic breaks: `*`, `-` or `_`. */
+    rule?: string | null;
+    /** How many markers a thematic break has, 3 or more. */
+    ruleRepetition?: number | null;
+    /** Put spaces between the markers of a thematic break. @default false */
+    ruleSpaces?: boolean;
+    /** Write headings of rank 1 and 2 as setext headings. @default false */
+    setext?: boolean;
+    /** The marker of strong: `*` or `_`. */
+    strong?: string | null;
+    /** Join definitions with no blank line between them. @default false */
+    tightDefinitions?: boolean;
+    /** Extra patterns of characters to escape. */
+    unsafe?: UnsafePattern[];
+}
+/** A character to escape where it would otherwise start or end syntax. */
+export interface UnsafePattern {
+    /** The character, escaped as a regular expression would need it. @default "" */
+    character?: string;
+    /** A regular expression that must match right before the character. */
+    before?: string | null;
+    /** A regular expression that must match right after the character. */
+    after?: string | null;
+    /** Only at the start of a line, after any indent. @default false */
+    atBreak?: boolean;
+    /** Only inside one of these constructs. */
+    inConstruct?: Names | null;
+    /** Never inside one of these constructs. */
+    notInConstruct?: Names | null;
+    /** Only at the start of a node right after one of these node types. */
+    beforeNode?: Names | null;
+    /** Only at the end of a node right before one of these node types. */
+    afterNode?: Names | null;
+    /** Read `before` and `after` with Unicode classes such as `\p{L}`. @default false */
+    unicode?: boolean;
+}
+/** `md.toHtml`: mdast into hast; options named as remark-rehype names them. */
+export interface ToHtmlOptions {
+    /** Keep raw HTML in the tree instead of dropping it. @default false */
+    allowDangerousHtml?: boolean;
+    /** What footnote `id`s start with, so they cannot clobber the page's; `user-content-` when unset. */
+    clobberPrefix?: string | null;
+    /** The text of each footnote's back reference; `↩`, numbered from the second, when unset. */
+    footnoteBackContent?: string | null;
+    /** The `aria-label` of each footnote's back reference; `Back to reference 1` and so on when unset. */
+    footnoteBackLabel?: string | null;
+    /** The heading of the footnotes section; `Footnotes` when unset. */
+    footnoteLabel?: string | null;
+    /** The tag name of the footnotes section's heading; `h2` when unset. */
+    footnoteLabelTagName?: string | null;
+    /** Node types without a handler to copy into hast as they are, their children converted. @default [] */
+    passThrough?: string[];
+    /** An `aria-label` for each task-list checkbox, so screen readers name it; none when left out, as remark-rehype writes none. */
+    taskListLabels?: TaskListLabels | null;
+}
+/** The labels of task-list checkboxes. */
+export interface TaskListLabels {
+    /** The label of a checked box, such as `Completed task`. */
+    checked: string;
+    /** The label of an unchecked box, such as `Task`. */
+    unchecked: string;
+}
+/** `md.toNaturalLanguage`: mdast into nlcst, tokenized by the processor's natural-language parser; options named as remark-retext and mdast-util-to-nlcst name them. */
+export interface ToNaturalLanguageOptions {
+    /** Node types to leave out, besides `table`, `tableRow` and `tableCell`. @default [] */
+    ignore?: string[];
+    /** Node types to keep as one `SourceNode` of their source text, besides `inlineCode`. @default [] */
+    source?: string[];
+}
+/** The `md.parse` plugin. */
+export declare function parse(options?: ParseOptions): Plugin<"md.parse", ParseOptions>;
+/** The `md.directive` plugin. */
+export declare function directive(options?: DirectiveOptions): Plugin<"md.directive", DirectiveOptions>;
+/** The `md.gfm` plugin. */
+export declare function gfm(options?: GfmOptions): Plugin<"md.gfm", GfmOptions>;
+/** The `md.definitionList` plugin. */
+export declare function definitionList(): Plugin<"md.definitionList">;
+/** The `md.math` plugin. */
+export declare function math(options?: MathOptions): Plugin<"md.math", MathOptions>;
+/** The `md.mdx` plugin. */
+export declare function mdx(options?: MdxOptions): Plugin<"md.mdx", MdxOptions>;
+/** The `md.frontmatter` plugin. */
+export declare function frontmatter(options?: FrontmatterOptions): Plugin<"md.frontmatter", FrontmatterOptions>;
+/** The `md.gemoji` plugin. */
+export declare function gemoji(): Plugin<"md.gemoji">;
+/** The `md.component` plugin. */
+export declare function component(options?: ComponentOptions): Plugin<"md.component", ComponentOptions>;
+/** The `md.packageCommand` plugin. */
+export declare function packageCommand(options?: PackageCommandOptions): Plugin<"md.packageCommand", PackageCommandOptions>;
+/** The `md.headingId` plugin. */
+export declare function headingId(options?: HeadingIdOptions): Plugin<"md.headingId", HeadingIdOptions>;
+/** The `md.pathRewrite` plugin. */
+export declare function pathRewrite(options?: PathRewriteOptions): Plugin<"md.pathRewrite", PathRewriteOptions>;
+/** The `md.strip` plugin. */
+export declare function strip(options?: StripOptions): Plugin<"md.strip", StripOptions>;
+/** The `md.toc` plugin. */
+export declare function toc(options?: TocOptions): Plugin<"md.toc", TocOptions>;
+/** The `md.stringify` plugin. */
+export declare function stringify(options?: StringifyOptions): Plugin<"md.stringify", StringifyOptions>;
+/** The `md.toHtml` plugin. */
+export declare function toHtml(options?: ToHtmlOptions): Plugin<"md.toHtml", ToHtmlOptions>;
+/** The `md.toNaturalLanguage` plugin. */
+export declare function toNaturalLanguage(options?: ToNaturalLanguageOptions): Plugin<"md.toNaturalLanguage", ToNaturalLanguageOptions>;

package/build/generated/md.js

@@ -0,0 +1,100 @@
+// Generated by `pnpm generate:bindings` from the crate's plugins; do not edit.
+/** The `md.parse` plugin. */
+export function parse(options) {
+    if (options === undefined)
+        return { name: "md.parse" };
+    return { name: "md.parse", options };
+}
+/** The `md.directive` plugin. */
+export function directive(options) {
+    if (options === undefined)
+        return { name: "md.directive" };
+    return { name: "md.directive", options };
+}
+/** The `md.gfm` plugin. */
+export function gfm(options) {
+    if (options === undefined)
+        return { name: "md.gfm" };
+    return { name: "md.gfm", options };
+}
+/** The `md.definitionList` plugin. */
+export function definitionList() {
+    return { name: "md.definitionList" };
+}
+/** The `md.math` plugin. */
+export function math(options) {
+    if (options === undefined)
+        return { name: "md.math" };
+    return { name: "md.math", options };
+}
+/** The `md.mdx` plugin. */
+export function mdx(options) {
+    if (options === undefined)
+        return { name: "md.mdx" };
+    return { name: "md.mdx", options };
+}
+/** The `md.frontmatter` plugin. */
+export function frontmatter(options) {
+    if (options === undefined)
+        return { name: "md.frontmatter" };
+    return { name: "md.frontmatter", options };
+}
+/** The `md.gemoji` plugin. */
+export function gemoji() {
+    return { name: "md.gemoji" };
+}
+/** The `md.component` plugin. */
+export function component(options) {
+    if (options === undefined)
+        return { name: "md.component" };
+    return { name: "md.component", options };
+}
+/** The `md.packageCommand` plugin. */
+export function packageCommand(options) {
+    if (options === undefined)
+        return { name: "md.packageCommand" };
+    return { name: "md.packageCommand", options };
+}
+/** The `md.headingId` plugin. */
+export function headingId(options) {
+    if (options === undefined)
+        return { name: "md.headingId" };
+    return { name: "md.headingId", options };
+}
+/** The `md.pathRewrite` plugin. */
+export function pathRewrite(options) {
+    if (options === undefined)
+        return { name: "md.pathRewrite" };
+    return { name: "md.pathRewrite", options };
+}
+/** The `md.strip` plugin. */
+export function strip(options) {
+    if (options === undefined)
+        return { name: "md.strip" };
+    return { name: "md.strip", options };
+}
+/** The `md.toc` plugin. */
+export function toc(options) {
+    if (options === undefined)
+        return { name: "md.toc" };
+    return { name: "md.toc", options };
+}
+/** The `md.stringify` plugin. */
+export function stringify(options) {
+    if (options === undefined)
+        return { name: "md.stringify" };
+    return { name: "md.stringify", options };
+}
+/** The `md.toHtml` plugin. */
+export function toHtml(options) {
+    if (options === undefined)
+        return { name: "md.toHtml" };
+    return { name: "md.toHtml", options };
+}
+/** The `md.toNaturalLanguage` plugin. */
+export function toNaturalLanguage(options) {
+    if (options === undefined)
+        return { name: "md.toNaturalLanguage" };
+    return { name: "md.toNaturalLanguage", options };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"md.js","sourceRoot":"","sources":["../../generated/md.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAmX/E,6BAA6B;AAC7B,MAAM,UAAU,KAAK,CAAC,OAAsB;IAC1C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAA;IACtD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,CAAA;AACtC,CAAC;AAED,iCAAiC;AACjC,MAAM,UAAU,SAAS,CAAC,OAA0B;IAClD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAA;IAC1D,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,CAAA;AAC1C,CAAC;AAED,2BAA2B;AAC3B,MAAM,UAAU,GAAG,CAAC,OAAoB;IACtC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;IACpD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;AACpC,CAAC;AAED,sCAAsC;AACtC,MAAM,UAAU,cAAc;IAC5B,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAA;AACtC,CAAC;AAED,4BAA4B;AAC5B,MAAM,UAAU,IAAI,CAAC,OAAqB;IACxC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;IACrD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAA;AACrC,CAAC;AAED,2BAA2B;AAC3B,MAAM,UAAU,GAAG,CAAC,OAAoB;IACtC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;IACpD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;AACpC,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,WAAW,CAAC,OAA4B;IACtD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAA;IAC5D,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,CAAA;AAC5C,CAAC;AAED,8BAA8B;AAC9B,MAAM,UAAU,MAAM;IACpB,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAA;AAC9B,CAAC;AAED,iCAAiC;AACjC,MAAM,UAAU,SAAS,CAAC,OAA0B;IAClD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAA;IAC1D,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,CAAA;AAC1C,CAAC;AAED,sCAAsC;AACtC,MAAM,UAAU,cAAc,CAAC,OAA+B;IAC5D,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAA;IAC/D,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,OAAO,EAAE,CAAA;AAC/C,CAAC;AAED,iCAAiC;AACjC,MAAM,UAAU,SAAS,CAAC,OAA0B;IAClD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAA;IAC1D,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,CAAA;AAC1C,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,WAAW,CAAC,OAA4B;IACtD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAA;IAC5D,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,CAAA;AAC5C,CAAC;AAED,6BAA6B;AAC7B,MAAM,UAAU,KAAK,CAAC,OAAsB;IAC1C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAA;IACtD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,CAAA;AACtC,CAAC;AAED,2BAA2B;AAC3B,MAAM,UAAU,GAAG,CAAC,OAAoB;IACtC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;IACpD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;AACpC,CAAC;AAED,iCAAiC;AACjC,MAAM,UAAU,SAAS,CAAC,OAA0B;IAClD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAA;IAC1D,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,CAAA;AAC1C,CAAC;AAED,8BAA8B;AAC9B,MAAM,UAAU,MAAM,CAAC,OAAuB;IAC5C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAA;IACvD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,CAAA;AACvC,CAAC;AAED,yCAAyC;AACzC,MAAM,UAAU,iBAAiB,CAAC,OAAkC;IAClE,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAA;IAClE,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,CAAA;AAClD,CAAC","sourcesContent":["// Generated by `pnpm generate:bindings` from the crate's plugins; do not edit.\n\nimport type { Plugin } from \"../models/plugin.ts\"\n\n/** `md.parse`: Markdown into mdast. */\nexport type ParseOptions = Record<string, unknown>\n\n/** `md.directive`: generic directives, `:a`, `::b` and `:::c`, read by `md.parse` and written by `md.stringify`; options named as mdast-util-directive's serializer names them. */\nexport interface DirectiveOptions {\n  /** Write an empty attribute as its name alone, `{a}`, rather than `{a=\"\"}`. @default true */\n  collapseEmptyAttributes?: boolean\n  /** Write `id` and `class` as `#a` and `.b` where they can be. @default true */\n  preferShortcut?: boolean\n  /** Leave attribute values unquoted where they can be. @default false */\n  preferUnquoted?: boolean\n  /** The quote of attribute values: `\"` or `'`; `md.stringify`'s `quote` when unset. */\n  quote?: string | null\n  /** Use the other quote when the preferred one occurs more often in a value. @default false */\n  quoteSmart?: boolean\n}\n\n/** `md.gfm`: GitHub Flavored Markdown's syntax, read by `md.parse` and written by `md.stringify`; options named as remark-gfm names them. */\nexport interface GfmOptions {\n  /** Let one tilde, `~a~`, form strikethrough, as well as two. @default true */\n  singleTilde?: boolean\n  /** Pad table cells with a space on each side when writing Markdown. @default true */\n  tableCellPadding?: boolean\n  /** Line up table pipes when writing Markdown. @default true */\n  tablePipeAlign?: boolean\n  /** Write a footnote definition's first line blank when it holds flow content. @default false */\n  firstLineBlank?: boolean\n}\n\n/** `md.math`: math syntax, `$$` blocks and `$` text, read by `md.parse` and written by `md.stringify`; options named as remark-math names them. */\nexport interface MathOptions {\n  /** Let one dollar, `$a$`, form math in text, as well as two. @default true */\n  singleDollarTextMath?: boolean\n}\n\n/** `md.mdx`: MDX syntax, JSX, expressions and ESM, read by `md.parse` and written by `md.stringify`; it turns off indented code, autolinks and raw HTML; options named as remark-mdx and mdast-util-mdx-jsx's serializer name them. */\nexport interface MdxOptions {\n  /** The quote of JSX attribute values: `\"` (when unset) or `'`. */\n  quote?: string | null\n  /** Use the other quote when the preferred one occurs more often in a value. @default false */\n  quoteSmart?: boolean\n  /** Write self-closing tags without a space before the slash, `<a/>`. @default false */\n  tightSelfClosing?: boolean\n  /** The width past which a flow element's attributes go on lines of their own. */\n  printWidth?: number | null\n}\n\n/** The kinds of matter to recognize, as remark-frontmatter takes them (a preset, a matter, or a list of them; `yaml` when unset), or textlane's options object. */\nexport type FrontmatterOptions = \"yaml\" | \"toml\" | Matter | (\"yaml\" | \"toml\" | Matter)[] | FrontmatterSettings\n\n/** One kind of frontmatter: the node `type` it becomes and its fences, a `marker` repeated three times or a whole `fence`. */\nexport interface Matter {\n  type: string\n  marker?: Fence\n  fence?: Fence\n  anywhere?: boolean\n}\n\n/** Different opening and closing fences. */\nexport interface FencePair {\n  open: string\n  close: string\n}\n\n/** A fence, or its opening and closing ones. */\nexport type Fence = string | FencePair\n\n/** textlane's options: the matters, and what to do with YAML frontmatter. */\nexport interface FrontmatterSettings {\n  /** The kinds of matter to recognize, as remark-frontmatter takes them; `yaml` when unset. */\n  matters?: \"yaml\" | \"toml\" | Matter | (\"yaml\" | \"toml\" | Matter)[]\n  /** Parse the YAML frontmatter a document starts with into `file.data.matter`, `{}` when there is none, as vfile-matter does. */\n  data?: boolean\n  /** Remove the YAML frontmatter a document starts with from the tree. */\n  strip?: boolean\n}\n\n/** `md.component`: directives, GitHub alerts and other nodes into MDX JSX elements, the components an MDX runtime renders, by declarative rules. */\nexport interface ComponentOptions {\n  /** Rules for directives; the first that matches a directive converts it. */\n  directives?: DirectiveRule[]\n  /** GitHub alerts, `> [!NOTE]`, into a component. */\n  alerts?: AlertRule | null\n  /** Node types, such as `defList`, into components keeping their children. @default {} */\n  nodes?: Record<string, string>\n  /** What becomes of a directive no rule converts. */\n  unknownDirectives?: UnknownDirectives\n  /** Rules for fenced code; the first that matches a block applies. */\n  codes?: CodeRule[]\n}\n\n/** How `md.component` turns matching directives into one component. */\nexport interface DirectiveRule {\n  /** The directive's name, or several. */\n  name: Names\n  /** The kind of directive: `text`, `leaf` or `container`; any when left out. */\n  kind?: DirectiveKind | null\n  /** Attribute values the directive must have. @default {} */\n  where?: Record<string, string>\n  /** The component: a text element for a text directive, else a flow element. */\n  component: string\n  /** The attribute that gets the directive's name. */\n  nameAs?: string | null\n  /** The attribute that gets the label's text: a container's label paragraph or a text or leaf directive's content, which is then dropped. */\n  labelAs?: string | null\n  /** The label's text when there is none. */\n  labelDefault?: string | null\n  /** The attributes to keep, in order; every one, as written, when left out. */\n  attributes?: AttributeRule[] | null\n  /** Attributes without which the directive is left to `unknownDirectives`. @default [] */\n  required?: string[]\n  /** Wrap runs of adjacent siblings this rule converted in another component. */\n  group?: GroupRule | null\n  /** The attribute that gets the lists of a container directive as a file tree, JSON items `{name, type, comment?, highlighted?, children?}`; the lists leave its content. */\n  treeAs?: string | null\n}\n\n/** One name or several. */\nexport type Names = string | string[]\n\n/** A directive's kind, by how many colons open it. */\nexport type DirectiveKind = \"text\" | \"leaf\" | \"container\"\n\n/** An attribute to keep: its name, or its name with what to call it and a default. */\nexport type AttributeRule = string | { name: string; rename?: string | null; default?: string | null }\n\n/** The component wrapping a run of adjacent siblings one rule converted. */\nexport interface GroupRule {\n  /** The wrapping component. */\n  component: string\n  /** The shortest run wrapped; 2 when left out. */\n  min?: number | null\n  /** Attributes the wrapper copies from the run's first element. @default [] */\n  inherit?: string[]\n}\n\n/** How `md.component` turns GitHub alerts, a block quote opening with `[!TYPE]`, into a component. */\nexport interface AlertRule {\n  /** The component an alert becomes. */\n  component: string\n  /** The attribute that gets the alert's type. */\n  typeAs: string\n  /** Each alert type, as written, to the value of `typeAs`; other types stay block quotes. */\n  types: Record<string, string>\n}\n\n/** What `md.component` does with a directive no rule converts. */\nexport type UnknownDirectives = \"keep\" | \"source\"\n\n/** How `md.component` turns matching code blocks into a component, or groups them. */\nexport interface CodeRule {\n  /** The block's language, or several; any when left out. */\n  lang?: Names | null\n  /** A `key=\"value\"` the block's meta must hold. */\n  meta?: string | null\n  /** The component the block becomes; left out, the block stays code and only groups. */\n  component?: string | null\n  /** The attribute that gets the code; left out, the code is the component's text. */\n  valueAs?: string | null\n  /** Meta `key=\"value\"` pairs to keep as attributes, in order. */\n  attributes?: AttributeRule[]\n  /** Wrap runs of adjacent blocks this rule matched in another component. */\n  group?: CodeGroupRule | null\n}\n\n/** The component wrapping a run of adjacent code blocks one rule matched; the meta keys it reads are taken out of each block's meta. */\nexport interface CodeGroupRule {\n  /** The wrapping component. */\n  component: string\n  /** The shortest run wrapped; 2 when left out. */\n  min?: number | null\n  /** The attribute that gets the run's values of the rule's `meta` key, as a JSON list. */\n  collect?: string | null\n  /** Meta keys the wrapper copies from the run's first block as attributes. @default [] */\n  inherit?: string[]\n}\n\n/** `md.packageCommand`: a fenced block of package-manager commands, its language naming the ecosystem (`npm`, `pip`, `cargo`), into one component with the commands converted for each manager, as `@docusaurus/remark-plugin-npm2yarn` does for npm. */\nexport interface PackageCommandOptions {\n  /** The component a block becomes; one string attribute per manager. @default \"PackageTabs\" */\n  component?: string\n  /** Each ecosystem's managers, in attribute order; an empty list leaves its blocks code. */\n  ecosystems?: Ecosystems\n}\n\n/** The managers `md.packageCommand` converts each ecosystem's commands for. */\nexport interface Ecosystems {\n  /** Managers for `npm` blocks, converted as npm-to-yarn converts; npm, pnpm, yarn and bun by default. */\n  npm?: NpmManager[]\n  /** Managers for `pip` blocks; pip, uv, poetry and pdm by default. */\n  pip?: PipManager[]\n  /** Managers for `cargo` blocks; cargo and cargo-binstall by default. */\n  cargo?: CargoManager[]\n}\n\n/** A JavaScript package manager an `npm` command converts to. */\nexport type NpmManager = \"npm\" | \"pnpm\" | \"yarn\" | \"bun\" | \"deno\" | \"nub\"\n\n/** A Python package manager a `pip` command converts to. */\nexport type PipManager = \"pip\" | \"uv\" | \"poetry\" | \"pdm\"\n\n/** A Rust installer a `cargo` command converts to. */\nexport type CargoManager = \"cargo\" | \"cargo-binstall\"\n\n/** `md.headingId`: `{#id}` at the end of a heading, after a space, as its id, as remark-heading-id reads it; headings without one keep none. */\nexport interface HeadingIdOptions {\n  /** Read a whole attribute list, `{#id .class key=value key=\"v w\"}`, as directives write theirs: classes become `className` and other keys properties. @default false */\n  attributes?: boolean\n  /** Literal suffixes, such as `[step]`, stripped from a heading's end for the attributes each names, a value or `true` for a bare one: `{\"[step]\": {\"data-step\": true}}`. */\n  markers?: Record<string, Record<string, MarkerValue>>\n}\n\n/** An attribute a heading marker sets: its value, or `true` for the bare attribute. */\nexport type MarkerValue = boolean | string\n\n/** `md.pathRewrite`: the URLs of images, links and definitions as a site serves them: relative ones resolved against the file's path and made root-relative, every root-relative one under `base`, and links to Markdown files turned into page URLs. */\nexport interface PathRewriteOptions {\n  /** The directory URLs count from, as the file's path spells it; the path's own starting point when left out. */\n  root?: string | null\n  /** The URL the site is served at, such as `/docs`, put before every root-relative URL once. */\n  base?: string | null\n  /** The nodes whose URLs are rewritten; images, links and definitions when left out. */\n  nodes?: UrlNode[] | null\n  /** Markdown files, relative to `root`, to the URL of their page; a link to one of them takes it, before `markdownLinks` applies. @default {} */\n  pages?: Record<string, string>\n  /** How a link to a Markdown file no page names becomes a URL. */\n  markdownLinks?: MarkdownLinks\n}\n\n/** A node with a URL. */\nexport type UrlNode = \"image\" | \"link\" | \"definition\"\n\n/** How a link to a Markdown file becomes a URL. */\nexport type MarkdownLinks = \"keep\" | \"directory\" | \"html\"\n\n/** `md.strip`: mdast down to its text, as strip-markdown does: code, HTML, tables and the like dropped, headings made paragraphs, formatting unwrapped. */\nexport interface StripOptions {\n  /** Node types to leave as they are, such as `inlineCode`. @default [] */\n  keep?: string[]\n  /** Node types to drop, besides those strip-markdown drops. @default [] */\n  remove?: string[]\n}\n\n/** `md.toc`: a table of contents under the first heading matching `heading`, replacing what sat between it and the next heading as deep or shallower, as remark-toc makes it. */\nexport interface TocOptions {\n  /** The heading to put the table under, as JavaScript regular expression source matched against its whole text, case-insensitively; `(table[ -]of[ -])?contents?|toc` when unset. */\n  heading?: string | null\n  /** The deepest heading rank to list, 1 to 6. */\n  maxDepth?: number | null\n  /** The shallowest heading rank to list, 1 to 6. */\n  minDepth?: number | null\n  /** Headings to leave out, as JavaScript regular expression source matched against their whole text, case-insensitively. */\n  skip?: string | null\n  /** Keep the list compact, without blank lines between items; `true` when unset. */\n  tight?: boolean | null\n  /** Number the list instead of bulleting it. */\n  ordered?: boolean | null\n  /** What each link's fragment starts with, such as `user-content-`. */\n  prefix?: string | null\n  /** The parents whose headings are listed, as a unist-util-is test: a node type, an object of fields a parent must equal, or a list of these; only the root when unset. */\n  parents?: ParentTest | null\n}\n\n/** A unist-util-is test of a node, written as JSON: one check, or a list any of which passes. */\nexport type ParentTest = ParentCheck | ParentCheck[]\n\n/** One unist-util-is check: a node type, or fields a node must equal. */\nexport type ParentCheck = string | Record<string, unknown>\n\n/** `md.stringify`: mdast into Markdown; options named as mdast-util-to-markdown names them. */\nexport interface StringifyOptions {\n  /** The marker of unordered list items: `*`, `+` or `-`. */\n  bullet?: string | null\n  /** The marker of ordered list items: `.` or `)`. */\n  bulletOrdered?: string | null\n  /** The marker of a list right after a list with `bullet`. */\n  bulletOther?: string | null\n  /** Close ATX headings with as many `#` as they open with. @default false */\n  closeAtx?: boolean\n  /** The marker of emphasis: `*` or `_`. */\n  emphasis?: string | null\n  /** The marker of fenced code: `` ` `` or `~`. */\n  fence?: string | null\n  /** Fence code; `false` indents it where it can. @default true */\n  fences?: boolean\n  /** Number ordered list items up from `start`. @default true */\n  incrementListMarker?: boolean\n  /** How list item content is indented: `one`, `tab` or `mixed`. */\n  listItemIndent?: string | null\n  /** The marker of titles: `\"` or `'`. */\n  quote?: string | null\n  /** Write links as resources even where an autolink would do. @default false */\n  resourceLink?: boolean\n  /** The marker of thematic breaks: `*`, `-` or `_`. */\n  rule?: string | null\n  /** How many markers a thematic break has, 3 or more. */\n  ruleRepetition?: number | null\n  /** Put spaces between the markers of a thematic break. @default false */\n  ruleSpaces?: boolean\n  /** Write headings of rank 1 and 2 as setext headings. @default false */\n  setext?: boolean\n  /** The marker of strong: `*` or `_`. */\n  strong?: string | null\n  /** Join definitions with no blank line between them. @default false */\n  tightDefinitions?: boolean\n  /** Extra patterns of characters to escape. */\n  unsafe?: UnsafePattern[]\n}\n\n/** A character to escape where it would otherwise start or end syntax. */\nexport interface UnsafePattern {\n  /** The character, escaped as a regular expression would need it. @default \"\" */\n  character?: string\n  /** A regular expression that must match right before the character. */\n  before?: string | null\n  /** A regular expression that must match right after the character. */\n  after?: string | null\n  /** Only at the start of a line, after any indent. @default false */\n  atBreak?: boolean\n  /** Only inside one of these constructs. */\n  inConstruct?: Names | null\n  /** Never inside one of these constructs. */\n  notInConstruct?: Names | null\n  /** Only at the start of a node right after one of these node types. */\n  beforeNode?: Names | null\n  /** Only at the end of a node right before one of these node types. */\n  afterNode?: Names | null\n  /** Read `before` and `after` with Unicode classes such as `\\p{L}`. @default false */\n  unicode?: boolean\n}\n\n/** `md.toHtml`: mdast into hast; options named as remark-rehype names them. */\nexport interface ToHtmlOptions {\n  /** Keep raw HTML in the tree instead of dropping it. @default false */\n  allowDangerousHtml?: boolean\n  /** What footnote `id`s start with, so they cannot clobber the page's; `user-content-` when unset. */\n  clobberPrefix?: string | null\n  /** The text of each footnote's back reference; `↩`, numbered from the second, when unset. */\n  footnoteBackContent?: string | null\n  /** The `aria-label` of each footnote's back reference; `Back to reference 1` and so on when unset. */\n  footnoteBackLabel?: string | null\n  /** The heading of the footnotes section; `Footnotes` when unset. */\n  footnoteLabel?: string | null\n  /** The tag name of the footnotes section's heading; `h2` when unset. */\n  footnoteLabelTagName?: string | null\n  /** Node types without a handler to copy into hast as they are, their children converted. @default [] */\n  passThrough?: string[]\n  /** An `aria-label` for each task-list checkbox, so screen readers name it; none when left out, as remark-rehype writes none. */\n  taskListLabels?: TaskListLabels | null\n}\n\n/** The labels of task-list checkboxes. */\nexport interface TaskListLabels {\n  /** The label of a checked box, such as `Completed task`. */\n  checked: string\n  /** The label of an unchecked box, such as `Task`. */\n  unchecked: string\n}\n\n/** `md.toNaturalLanguage`: mdast into nlcst, tokenized by the processor's natural-language parser; options named as remark-retext and mdast-util-to-nlcst name them. */\nexport interface ToNaturalLanguageOptions {\n  /** Node types to leave out, besides `table`, `tableRow` and `tableCell`. @default [] */\n  ignore?: string[]\n  /** Node types to keep as one `SourceNode` of their source text, besides `inlineCode`. @default [] */\n  source?: string[]\n}\n\n/** The `md.parse` plugin. */\nexport function parse(options?: ParseOptions): Plugin<\"md.parse\", ParseOptions> {\n  if (options === undefined) return { name: \"md.parse\" }\n  return { name: \"md.parse\", options }\n}\n\n/** The `md.directive` plugin. */\nexport function directive(options?: DirectiveOptions): Plugin<\"md.directive\", DirectiveOptions> {\n  if (options === undefined) return { name: \"md.directive\" }\n  return { name: \"md.directive\", options }\n}\n\n/** The `md.gfm` plugin. */\nexport function gfm(options?: GfmOptions): Plugin<\"md.gfm\", GfmOptions> {\n  if (options === undefined) return { name: \"md.gfm\" }\n  return { name: \"md.gfm\", options }\n}\n\n/** The `md.definitionList` plugin. */\nexport function definitionList(): Plugin<\"md.definitionList\"> {\n  return { name: \"md.definitionList\" }\n}\n\n/** The `md.math` plugin. */\nexport function math(options?: MathOptions): Plugin<\"md.math\", MathOptions> {\n  if (options === undefined) return { name: \"md.math\" }\n  return { name: \"md.math\", options }\n}\n\n/** The `md.mdx` plugin. */\nexport function mdx(options?: MdxOptions): Plugin<\"md.mdx\", MdxOptions> {\n  if (options === undefined) return { name: \"md.mdx\" }\n  return { name: \"md.mdx\", options }\n}\n\n/** The `md.frontmatter` plugin. */\nexport function frontmatter(options?: FrontmatterOptions): Plugin<\"md.frontmatter\", FrontmatterOptions> {\n  if (options === undefined) return { name: \"md.frontmatter\" }\n  return { name: \"md.frontmatter\", options }\n}\n\n/** The `md.gemoji` plugin. */\nexport function gemoji(): Plugin<\"md.gemoji\"> {\n  return { name: \"md.gemoji\" }\n}\n\n/** The `md.component` plugin. */\nexport function component(options?: ComponentOptions): Plugin<\"md.component\", ComponentOptions> {\n  if (options === undefined) return { name: \"md.component\" }\n  return { name: \"md.component\", options }\n}\n\n/** The `md.packageCommand` plugin. */\nexport function packageCommand(options?: PackageCommandOptions): Plugin<\"md.packageCommand\", PackageCommandOptions> {\n  if (options === undefined) return { name: \"md.packageCommand\" }\n  return { name: \"md.packageCommand\", options }\n}\n\n/** The `md.headingId` plugin. */\nexport function headingId(options?: HeadingIdOptions): Plugin<\"md.headingId\", HeadingIdOptions> {\n  if (options === undefined) return { name: \"md.headingId\" }\n  return { name: \"md.headingId\", options }\n}\n\n/** The `md.pathRewrite` plugin. */\nexport function pathRewrite(options?: PathRewriteOptions): Plugin<\"md.pathRewrite\", PathRewriteOptions> {\n  if (options === undefined) return { name: \"md.pathRewrite\" }\n  return { name: \"md.pathRewrite\", options }\n}\n\n/** The `md.strip` plugin. */\nexport function strip(options?: StripOptions): Plugin<\"md.strip\", StripOptions> {\n  if (options === undefined) return { name: \"md.strip\" }\n  return { name: \"md.strip\", options }\n}\n\n/** The `md.toc` plugin. */\nexport function toc(options?: TocOptions): Plugin<\"md.toc\", TocOptions> {\n  if (options === undefined) return { name: \"md.toc\" }\n  return { name: \"md.toc\", options }\n}\n\n/** The `md.stringify` plugin. */\nexport function stringify(options?: StringifyOptions): Plugin<\"md.stringify\", StringifyOptions> {\n  if (options === undefined) return { name: \"md.stringify\" }\n  return { name: \"md.stringify\", options }\n}\n\n/** The `md.toHtml` plugin. */\nexport function toHtml(options?: ToHtmlOptions): Plugin<\"md.toHtml\", ToHtmlOptions> {\n  if (options === undefined) return { name: \"md.toHtml\" }\n  return { name: \"md.toHtml\", options }\n}\n\n/** The `md.toNaturalLanguage` plugin. */\nexport function toNaturalLanguage(options?: ToNaturalLanguageOptions): Plugin<\"md.toNaturalLanguage\", ToNaturalLanguageOptions> {\n  if (options === undefined) return { name: \"md.toNaturalLanguage\" }\n  return { name: \"md.toNaturalLanguage\", options }\n}\n"]}

package/build/generated/mdx.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from "../models/plugin.ts";
+/** `mdx.compile`: hast into a JavaScript module, as @mdx-js/mdx's `compile` makes it; options named as @mdx-js/mdx's `compile` names them. */
+export interface CompileOptions {
+    /** Keep JSX in the output instead of compiling it to function calls. @default false */
+    jsx?: boolean;
+    /** The JSX runtime: `automatic` (default) or `classic`. */
+    jsxRuntime?: string | null;
+    /** Where the automatic runtime imports `jsx` and `jsxs` from (default `react`). */
+    jsxImportSource?: string | null;
+    /** The classic runtime's element function (default `React.createElement`). */
+    pragma?: string | null;
+    /** The classic runtime's fragment (default `React.Fragment`). */
+    pragmaFrag?: string | null;
+    /** Where the classic runtime imports the pragma's first name from (default `react`). */
+    pragmaImportSource?: string | null;
+    /** Where `useMDXComponents` is imported from, to take components from a provider. */
+    providerImportSource?: string | null;
+    /** `program` (default), a module, or `function-body`, the body of a function that gets the runtime as its first argument. */
+    outputFormat?: string | null;
+    /** How attribute names of HTML elements are cased: `react` (default) or `html`. */
+    elementAttributeNameCase?: string | null;
+    /** How style property names are cased: `dom` (default) or `css`. */
+    stylePropertyNameCase?: string | null;
+    /** Turn `align` on table cells into a `textAlign` style (default `true`). */
+    tableCellAlignToStyle?: boolean | null;
+}
+/** The `mdx.compile` plugin. */
+export declare function compile(options?: CompileOptions): Plugin<"mdx.compile", CompileOptions>;

package/build/generated/mdx.js

@@ -0,0 +1,8 @@
+// Generated by `pnpm generate:bindings` from the crate's plugins; do not edit.
+/** The `mdx.compile` plugin. */
+export function compile(options) {
+    if (options === undefined)
+        return { name: "mdx.compile" };
+    return { name: "mdx.compile", options };
+}
+//# sourceMappingURL=data:application/json;base64,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