textlane 0.2.1 → 0.5.0

package/build/generated/md.js

@@ -39,9 +39,21 @@ export function frontmatter(options) {
         return { name: "md.frontmatter" };
     return { name: "md.frontmatter", options };
 }
+/** The `md.cjkFriendly` plugin. */
+export function cjkFriendly() {
+    return { name: "md.cjkFriendly" };
+}
 /** The `md.gemoji` plugin. */
-export function gemoji() {
-    return { name: "md.gemoji" };
+export function gemoji(options) {
+    if (options === undefined)
+        return { name: "md.gemoji" };
+    return { name: "md.gemoji", options };
+}
+/** The `md.smartypants` plugin. */
+export function smartypants(options) {
+    if (options === undefined)
+        return { name: "md.smartypants" };
+    return { name: "md.smartypants", options };
 }
 /** The `md.component` plugin. */
 export function component(options) {
@@ -67,6 +79,12 @@ export function pathRewrite(options) {
         return { name: "md.pathRewrite" };
     return { name: "md.pathRewrite", options };
 }
+/** The `md.shiftHeading` plugin. */
+export function shiftHeading(options) {
+    if (options === undefined)
+        return { name: "md.shiftHeading" };
+    return { name: "md.shiftHeading", options };
+}
 /** The `md.strip` plugin. */
 export function strip(options) {
     if (options === undefined)
@@ -97,4 +115,4 @@ export function toNaturalLanguage(options) {
         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":"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","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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"md.js","sourceRoot":"","sources":["../../generated/md.ts"],"names":[],"mappings":"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","sourcesContent":["// Generated by `pnpm generate:bindings` from the crate's plugins; do not edit.\n\nimport type { Root } from \"mdast\"\nimport type { Parser, 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  /** Render GitHub alerts, a block quote opening with `[!NOTE]`, as GitHub does, as remark-github-blockquote-alert does: `true`, or its options. */\n  alerts?: Alerts | null\n}\n\n/** `md.gfm`'s `alerts`: on, or on with remark-github-blockquote-alert's options. */\nexport type Alerts = boolean | AlertsOptions\n\n/** remark-github-blockquote-alert's options. */\nexport interface AlertsOptions {\n  /** Read a title after the type, `[!NOTE/Read this]`, in place of the type's name. @default false */\n  legacyTitle?: boolean\n  /** The tag name of the alert's element. @default \"div\" */\n  tagName?: string\n  /** More classes for the alert's element, separated by spaces. @default \"\" */\n  classNames?: string\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.gemoji`: gemoji shortcodes, `:smile:`, into emoji, as remark-gemoji does; its options are remark-emoji's. */\nexport interface GemojiOptions {\n  /** Also turn emoticons such as `:)` and `:-(` into emoji, as remark-emoji does. @default false */\n  emoticon?: boolean\n  /** Wrap each emoji in `<span role=\"img\" aria-label=\"…\">`, labelled with its name. @default false */\n  accessible?: boolean\n  /** Put a space after each emoji. @default false */\n  padSpaceAfter?: boolean\n}\n\n/** `md.smartypants`: straight quotes, dashes, dots and backticks in Markdown text into typographic ones, as remark-smartypants does; options as retext-smartypants takes them. */\nexport interface SmartypantsOptions {\n  /** Turn double backticks and double straight single quotes into double quotes; `all` turns single ones into single quotes too. */\n  backticks?: Backticks\n  /** The closing quotes to use: `”` and `’` by default. */\n  closingQuotes?: QuoteCharacters | null\n  /** Turn two dashes into an em dash; `oldschool` and `inverted` treat three too. */\n  dashes?: Dashes\n  /** Turn three dots into an ellipsis, with spaces between them or without. */\n  ellipses?: Ellipses\n  /** The opening quotes to use: `“` and `‘` by default. */\n  openingQuotes?: QuoteCharacters | null\n  /** Turn straight quotes into smart ones. @default true */\n  quotes?: boolean | null\n}\n\nexport type Backticks = boolean | \"all\"\n\n/** The quote characters to use for double and single quotes. */\nexport interface QuoteCharacters {\n  double: string\n  single: string\n}\n\nexport type Dashes = boolean | \"oldschool\" | \"inverted\"\n\nexport type Ellipses = boolean | \"spaced\" | \"unspaced\"\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.shiftHeading`: every heading's depth moved by `shift` and kept within 1 to 6, as rehype-shift-heading moves hast's, after the document's title is dropped when asked. */\nexport interface ShiftHeadingOptions {\n  /** The levels added to each heading's depth: `-1` makes an h2 an h1, `1` an h1 an h2. @default 0 */\n  shift?: number\n  /** Drop the document's first node when it is an h1, looking past frontmatter and ESM. @default false */\n  dropTitle?: boolean\n}\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  /** Turn each line ending in text into a `<br>`, as remark-breaks does. @default false */\n  breaks?: 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> & Parser<Root> {\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.cjkFriendly` plugin. */\nexport function cjkFriendly(): Plugin<\"md.cjkFriendly\"> {\n  return { name: \"md.cjkFriendly\" }\n}\n\n/** The `md.gemoji` plugin. */\nexport function gemoji(options?: GemojiOptions): Plugin<\"md.gemoji\", GemojiOptions> {\n  if (options === undefined) return { name: \"md.gemoji\" }\n  return { name: \"md.gemoji\", options }\n}\n\n/** The `md.smartypants` plugin. */\nexport function smartypants(options?: SmartypantsOptions): Plugin<\"md.smartypants\", SmartypantsOptions> {\n  if (options === undefined) return { name: \"md.smartypants\" }\n  return { name: \"md.smartypants\", options }\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.shiftHeading` plugin. */\nexport function shiftHeading(options?: ShiftHeadingOptions): Plugin<\"md.shiftHeading\", ShiftHeadingOptions> {\n  if (options === undefined) return { name: \"md.shiftHeading\" }\n  return { name: \"md.shiftHeading\", 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/nl.d.ts

@@ -1,4 +1,5 @@
-import type { Plugin } from "../models/plugin.ts";
+import type { Root } from "nlcst";
+import type { Parser, Plugin } from "../models/plugin.ts";
 /** `nl.parse`: natural language into nlcst. */
 export interface ParseOptions {
     /** The rules sentences and words are found by. */
@@ -76,7 +77,7 @@ export interface ContractionsOptions {
     straight?: boolean | null;
 }
 /** The `nl.parse` plugin. */
-export declare function parse(options?: ParseOptions): Plugin<"nl.parse", ParseOptions>;
+export declare function parse(options?: ParseOptions): Plugin<"nl.parse", ParseOptions> & Parser<Root>;
 /** The `nl.equality` plugin. */
 export declare function equality(options?: EqualityOptions): Plugin<"nl.equality", EqualityOptions>;
 /** The `nl.passive` plugin. */

package/build/generated/nl.js

@@ -59,4 +59,4 @@ export function contractions(options) {
 export function indefiniteArticle() {
     return { name: "nl.indefiniteArticle" };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nl.js","sourceRoot":"","sources":["../../generated/nl.ts"],"names":[],"mappings":"AAAA,+EAA+E;AA+F/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,gCAAgC;AAChC,MAAM,UAAU,QAAQ,CAAC,OAAyB;IAChD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAA;IACzD,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAA;AACzC,CAAC;AAED,+BAA+B;AAC/B,MAAM,UAAU,OAAO,CAAC,OAAwB;IAC9C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,CAAA;IACxD,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,CAAA;AACxC,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,qCAAqC;AACrC,MAAM,UAAU,aAAa;IAC3B,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAA;AACrC,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,eAAe,CAAC,OAAgC;IAC9D,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAA;IAChE,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,CAAA;AAChD,CAAC;AAED,iCAAiC;AACjC,MAAM,UAAU,SAAS;IACvB,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAA;AACjC,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,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,oCAAoC;AACpC,MAAM,UAAU,YAAY,CAAC,OAA6B;IACxD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAA;IAC7D,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAA;AAC7C,CAAC;AAED,yCAAyC;AACzC,MAAM,UAAU,iBAAiB;IAC/B,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAA;AACzC,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/** `nl.parse`: natural language into nlcst. */\nexport interface ParseOptions {\n  /** The rules sentences and words are found by. */\n  language?: Language\n}\n\n/** The language `nl.parse` reads: parse-latin's rules, or parse-english's on top of them. */\nexport type Language = \"latin\" | \"english\"\n\n/** `nl.equality`: warnings about insensitive, inconsiderate wording, as retext-equality; options are retext-equality's. */\nexport interface EqualityOptions {\n  /** Phrases not to warn about. */\n  ignore?: string[] | null\n  /** Whether a phrase used next to its counterpart (`he or she`) is fine. */\n  binary?: boolean | null\n}\n\n/** `nl.passive`: warnings about the passive voice, as retext-passive; options are retext-passive's. */\nexport interface PassiveOptions {\n  /** Participles not to warn about. */\n  ignore?: string[] | null\n}\n\n/** `nl.readability`: warnings about sentences too hard to read, as retext-readability; options are retext-readability's. */\nexport interface ReadabilityOptions {\n  /** The age of the target audience: 16 by default. */\n  age?: number | null\n  /** The share of algorithms that must find a sentence too hard: 4/7 by default. */\n  threshold?: number | null\n  /** The fewest words a sentence needs to be checked: 5 by default. */\n  minWords?: number | null\n}\n\n/** `nl.sentenceSpacing`: warnings about the spaces between sentences, as retext-sentence-spacing; options are retext-sentence-spacing's. */\nexport interface SentenceSpacingOptions {\n  /** The spacing expected between sentences: `1` or `\"space\"` (the default), `2` or `\"double-space\"`, `0` or `\"newline\"`. */\n  preferred?: Spacing | null\n}\n\n/** A spacing between sentences, as a count of spaces or by name. */\nexport type Spacing = number | string\n\n/** `nl.smartypants`: straight quotes, dashes, dots and backticks into typographic ones; options as retext-smartypants takes them. */\nexport interface SmartypantsOptions {\n  /** Turn double backticks and double straight single quotes into double quotes; `all` turns single ones into single quotes too, and needs `quotes: false`. */\n  backticks?: Backticks\n  /** The closing quotes to use: `”` and `’` by default. */\n  closingQuotes?: QuoteCharacters | null\n  /** Turn two dashes into an em dash; `oldschool` and `inverted` treat three too. */\n  dashes?: Dashes\n  /** Turn three dots into an ellipsis, with spaces between them or without. */\n  ellipses?: Ellipses\n  /** The opening quotes to use: `“` and `‘` by default. */\n  openingQuotes?: QuoteCharacters | null\n  /** Turn straight quotes into smart ones. @default true */\n  quotes?: boolean | null\n}\n\nexport type Backticks = boolean | \"all\"\n\n/** The quote characters to use for double and single quotes. */\nexport interface QuoteCharacters {\n  double: string\n  single: string\n}\n\nexport type Dashes = boolean | \"oldschool\" | \"inverted\"\n\nexport type Ellipses = boolean | \"spaced\" | \"unspaced\"\n\n/** `nl.quotes`: check that quotes and apostrophes are straight or smart, as preferred, at each level of nesting; options as retext-quotes takes them. */\nexport interface QuotesOptions {\n  /** The style of quotes and apostrophes to prefer: `smart` by default. */\n  preferred?: QuoteStyle | null\n  /** Smart quotes by nesting level, each one character or an opening and closing pair: `[\"“”\", \"‘’\"]` by default. */\n  smart?: string[] | null\n  /** Straight quotes by nesting level: `[\"\\\"\", \"'\"]` by default. */\n  straight?: string[] | null\n}\n\n/** A style of quotes: straight (`\"`) or smart (`“”`). */\nexport type QuoteStyle = \"smart\" | \"straight\"\n\n/** `nl.contractions`: check apostrophes in contractions, such as `don’t`; options as retext-contractions takes them. */\nexport interface ContractionsOptions {\n  /** Also check contractions written as literals, such as `“hasnt”`. @default false */\n  allowLiterals?: boolean | null\n  /** Expect straight apostrophes (`'`) instead of smart ones (`’`). @default false */\n  straight?: boolean | null\n}\n\n/** The `nl.parse` plugin. */\nexport function parse(options?: ParseOptions): Plugin<\"nl.parse\", ParseOptions> {\n  if (options === undefined) return { name: \"nl.parse\" }\n  return { name: \"nl.parse\", options }\n}\n\n/** The `nl.equality` plugin. */\nexport function equality(options?: EqualityOptions): Plugin<\"nl.equality\", EqualityOptions> {\n  if (options === undefined) return { name: \"nl.equality\" }\n  return { name: \"nl.equality\", options }\n}\n\n/** The `nl.passive` plugin. */\nexport function passive(options?: PassiveOptions): Plugin<\"nl.passive\", PassiveOptions> {\n  if (options === undefined) return { name: \"nl.passive\" }\n  return { name: \"nl.passive\", options }\n}\n\n/** The `nl.readability` plugin. */\nexport function readability(options?: ReadabilityOptions): Plugin<\"nl.readability\", ReadabilityOptions> {\n  if (options === undefined) return { name: \"nl.readability\" }\n  return { name: \"nl.readability\", options }\n}\n\n/** The `nl.repeatedWords` plugin. */\nexport function repeatedWords(): Plugin<\"nl.repeatedWords\"> {\n  return { name: \"nl.repeatedWords\" }\n}\n\n/** The `nl.sentenceSpacing` plugin. */\nexport function sentenceSpacing(options?: SentenceSpacingOptions): Plugin<\"nl.sentenceSpacing\", SentenceSpacingOptions> {\n  if (options === undefined) return { name: \"nl.sentenceSpacing\" }\n  return { name: \"nl.sentenceSpacing\", options }\n}\n\n/** The `nl.stringify` plugin. */\nexport function stringify(): Plugin<\"nl.stringify\"> {\n  return { name: \"nl.stringify\" }\n}\n\n/** The `nl.smartypants` plugin. */\nexport function smartypants(options?: SmartypantsOptions): Plugin<\"nl.smartypants\", SmartypantsOptions> {\n  if (options === undefined) return { name: \"nl.smartypants\" }\n  return { name: \"nl.smartypants\", options }\n}\n\n/** The `nl.quotes` plugin. */\nexport function quotes(options?: QuotesOptions): Plugin<\"nl.quotes\", QuotesOptions> {\n  if (options === undefined) return { name: \"nl.quotes\" }\n  return { name: \"nl.quotes\", options }\n}\n\n/** The `nl.contractions` plugin. */\nexport function contractions(options?: ContractionsOptions): Plugin<\"nl.contractions\", ContractionsOptions> {\n  if (options === undefined) return { name: \"nl.contractions\" }\n  return { name: \"nl.contractions\", options }\n}\n\n/** The `nl.indefiniteArticle` plugin. */\nexport function indefiniteArticle(): Plugin<\"nl.indefiniteArticle\"> {\n  return { name: \"nl.indefiniteArticle\" }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nl.js","sourceRoot":"","sources":["../../generated/nl.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAgG/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,gCAAgC;AAChC,MAAM,UAAU,QAAQ,CAAC,OAAyB;IAChD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAA;IACzD,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAA;AACzC,CAAC;AAED,+BAA+B;AAC/B,MAAM,UAAU,OAAO,CAAC,OAAwB;IAC9C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,CAAA;IACxD,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,CAAA;AACxC,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,qCAAqC;AACrC,MAAM,UAAU,aAAa;IAC3B,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAA;AACrC,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,eAAe,CAAC,OAAgC;IAC9D,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAA;IAChE,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,CAAA;AAChD,CAAC;AAED,iCAAiC;AACjC,MAAM,UAAU,SAAS;IACvB,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAA;AACjC,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,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,oCAAoC;AACpC,MAAM,UAAU,YAAY,CAAC,OAA6B;IACxD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAA;IAC7D,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAA;AAC7C,CAAC;AAED,yCAAyC;AACzC,MAAM,UAAU,iBAAiB;IAC/B,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAA;AACzC,CAAC","sourcesContent":["// Generated by `pnpm generate:bindings` from the crate's plugins; do not edit.\n\nimport type { Root } from \"nlcst\"\nimport type { Parser, Plugin } from \"../models/plugin.ts\"\n\n/** `nl.parse`: natural language into nlcst. */\nexport interface ParseOptions {\n  /** The rules sentences and words are found by. */\n  language?: Language\n}\n\n/** The language `nl.parse` reads: parse-latin's rules, or parse-english's on top of them. */\nexport type Language = \"latin\" | \"english\"\n\n/** `nl.equality`: warnings about insensitive, inconsiderate wording, as retext-equality; options are retext-equality's. */\nexport interface EqualityOptions {\n  /** Phrases not to warn about. */\n  ignore?: string[] | null\n  /** Whether a phrase used next to its counterpart (`he or she`) is fine. */\n  binary?: boolean | null\n}\n\n/** `nl.passive`: warnings about the passive voice, as retext-passive; options are retext-passive's. */\nexport interface PassiveOptions {\n  /** Participles not to warn about. */\n  ignore?: string[] | null\n}\n\n/** `nl.readability`: warnings about sentences too hard to read, as retext-readability; options are retext-readability's. */\nexport interface ReadabilityOptions {\n  /** The age of the target audience: 16 by default. */\n  age?: number | null\n  /** The share of algorithms that must find a sentence too hard: 4/7 by default. */\n  threshold?: number | null\n  /** The fewest words a sentence needs to be checked: 5 by default. */\n  minWords?: number | null\n}\n\n/** `nl.sentenceSpacing`: warnings about the spaces between sentences, as retext-sentence-spacing; options are retext-sentence-spacing's. */\nexport interface SentenceSpacingOptions {\n  /** The spacing expected between sentences: `1` or `\"space\"` (the default), `2` or `\"double-space\"`, `0` or `\"newline\"`. */\n  preferred?: Spacing | null\n}\n\n/** A spacing between sentences, as a count of spaces or by name. */\nexport type Spacing = number | string\n\n/** `nl.smartypants`: straight quotes, dashes, dots and backticks into typographic ones; options as retext-smartypants takes them. */\nexport interface SmartypantsOptions {\n  /** Turn double backticks and double straight single quotes into double quotes; `all` turns single ones into single quotes too, and needs `quotes: false`. */\n  backticks?: Backticks\n  /** The closing quotes to use: `”` and `’` by default. */\n  closingQuotes?: QuoteCharacters | null\n  /** Turn two dashes into an em dash; `oldschool` and `inverted` treat three too. */\n  dashes?: Dashes\n  /** Turn three dots into an ellipsis, with spaces between them or without. */\n  ellipses?: Ellipses\n  /** The opening quotes to use: `“` and `‘` by default. */\n  openingQuotes?: QuoteCharacters | null\n  /** Turn straight quotes into smart ones. @default true */\n  quotes?: boolean | null\n}\n\nexport type Backticks = boolean | \"all\"\n\n/** The quote characters to use for double and single quotes. */\nexport interface QuoteCharacters {\n  double: string\n  single: string\n}\n\nexport type Dashes = boolean | \"oldschool\" | \"inverted\"\n\nexport type Ellipses = boolean | \"spaced\" | \"unspaced\"\n\n/** `nl.quotes`: check that quotes and apostrophes are straight or smart, as preferred, at each level of nesting; options as retext-quotes takes them. */\nexport interface QuotesOptions {\n  /** The style of quotes and apostrophes to prefer: `smart` by default. */\n  preferred?: QuoteStyle | null\n  /** Smart quotes by nesting level, each one character or an opening and closing pair: `[\"“”\", \"‘’\"]` by default. */\n  smart?: string[] | null\n  /** Straight quotes by nesting level: `[\"\\\"\", \"'\"]` by default. */\n  straight?: string[] | null\n}\n\n/** A style of quotes: straight (`\"`) or smart (`“”`). */\nexport type QuoteStyle = \"smart\" | \"straight\"\n\n/** `nl.contractions`: check apostrophes in contractions, such as `don’t`; options as retext-contractions takes them. */\nexport interface ContractionsOptions {\n  /** Also check contractions written as literals, such as `“hasnt”`. @default false */\n  allowLiterals?: boolean | null\n  /** Expect straight apostrophes (`'`) instead of smart ones (`’`). @default false */\n  straight?: boolean | null\n}\n\n/** The `nl.parse` plugin. */\nexport function parse(options?: ParseOptions): Plugin<\"nl.parse\", ParseOptions> & Parser<Root> {\n  if (options === undefined) return { name: \"nl.parse\" }\n  return { name: \"nl.parse\", options }\n}\n\n/** The `nl.equality` plugin. */\nexport function equality(options?: EqualityOptions): Plugin<\"nl.equality\", EqualityOptions> {\n  if (options === undefined) return { name: \"nl.equality\" }\n  return { name: \"nl.equality\", options }\n}\n\n/** The `nl.passive` plugin. */\nexport function passive(options?: PassiveOptions): Plugin<\"nl.passive\", PassiveOptions> {\n  if (options === undefined) return { name: \"nl.passive\" }\n  return { name: \"nl.passive\", options }\n}\n\n/** The `nl.readability` plugin. */\nexport function readability(options?: ReadabilityOptions): Plugin<\"nl.readability\", ReadabilityOptions> {\n  if (options === undefined) return { name: \"nl.readability\" }\n  return { name: \"nl.readability\", options }\n}\n\n/** The `nl.repeatedWords` plugin. */\nexport function repeatedWords(): Plugin<\"nl.repeatedWords\"> {\n  return { name: \"nl.repeatedWords\" }\n}\n\n/** The `nl.sentenceSpacing` plugin. */\nexport function sentenceSpacing(options?: SentenceSpacingOptions): Plugin<\"nl.sentenceSpacing\", SentenceSpacingOptions> {\n  if (options === undefined) return { name: \"nl.sentenceSpacing\" }\n  return { name: \"nl.sentenceSpacing\", options }\n}\n\n/** The `nl.stringify` plugin. */\nexport function stringify(): Plugin<\"nl.stringify\"> {\n  return { name: \"nl.stringify\" }\n}\n\n/** The `nl.smartypants` plugin. */\nexport function smartypants(options?: SmartypantsOptions): Plugin<\"nl.smartypants\", SmartypantsOptions> {\n  if (options === undefined) return { name: \"nl.smartypants\" }\n  return { name: \"nl.smartypants\", options }\n}\n\n/** The `nl.quotes` plugin. */\nexport function quotes(options?: QuotesOptions): Plugin<\"nl.quotes\", QuotesOptions> {\n  if (options === undefined) return { name: \"nl.quotes\" }\n  return { name: \"nl.quotes\", options }\n}\n\n/** The `nl.contractions` plugin. */\nexport function contractions(options?: ContractionsOptions): Plugin<\"nl.contractions\", ContractionsOptions> {\n  if (options === undefined) return { name: \"nl.contractions\" }\n  return { name: \"nl.contractions\", options }\n}\n\n/** The `nl.indefiniteArticle` plugin. */\nexport function indefiniteArticle(): Plugin<\"nl.indefiniteArticle\"> {\n  return { name: \"nl.indefiniteArticle\" }\n}\n"]}

package/build/index.d.ts

@@ -1,10 +1,10 @@
 import { Processor } from "./models/processor.ts";
 export type { Compatible, Message, MessageOptions, Node, Place, Point, VFile, } from "./models/file.ts";
-export type { Attacher, Pluggable, PluggableList, Plugin, Preset, Transformer, } from "./models/plugin.ts";
+export type { Attacher, Pluggable, PluggableList, Parser, Plugin, Preset, Transformer, } from "./models/plugin.ts";
 export type { HostFile, HostMessage } from "./models/vfile.ts";
 export { Processor } from "./models/processor.ts";
 /** A new processor: add plugins with `use`, then `process` text. */
-export declare function textlane(): Processor;
+export declare function textlane(): Processor<import("./models/file.ts").Node>;
 /** The package version, as the native crate reports it. */
 export declare const version: () => string;
 /** The name of every native plugin, as a pipeline names it. */

package/build/index.js

@@ -1,11 +1,16 @@
 import { createRequire } from "node:module";
 import { resolveAddon } from "./actions/addon/resolve.js";
+import { detectLibc } from "./actions/libc/detect.js";
 import { Processor } from "./models/processor.js";
 export { Processor } from "./models/processor.js";
 const require = createRequire(import.meta.url);
 const addon = require(resolveAddon({
     platform: process.platform,
     arch: process.arch,
+    libc: detectLibc({
+        platform: process.platform,
+        report: () => process.report.getReport(),
+    }),
     env: process.env,
     resolvePackage: specifier => require.resolve(specifier),
 }));
@@ -24,4 +29,4 @@ export const retainedMemory = addon.retainedMemory;
  * default is 256 MB.
  */
 export const setRetainedMemory = addon.setRetainedMemory;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/models/addon.d.ts

@@ -1,29 +1,44 @@
-import type { Message, Node, VFile } from "./file.ts";
-/** The crate's pipeline as the addon exposes it: values cross as JSON. */
+import type { Message } from "./file.ts";
+/** The crate's pipeline as the addon exposes it: values cross as JSON, trees as JSON text. */
 export interface NativePipeline {
     use(value: unknown, options?: unknown): void;
     data(key?: string): unknown;
     setData(key: string, value: unknown): void;
     replaceData(data: Record<string, unknown>): void;
     freeze(): void;
-    parse(text: string): Node;
-    run(tree: Node, value?: string): Node;
-    runSync(tree: Node, value?: string): Node;
-    stringify(tree: Node): string;
-    process(text: string, path?: string): VFile;
-    processSync(text: string, path?: string): VFile;
+    parse(text: string): string;
+    run(tree: string, value?: string): string;
+    runSync(tree: string, value?: string): string;
+    stringify(tree: string): string;
+    process(text: string, path?: string): Promise<ProcessOutcome>;
+    processSync(text: string, path?: string): NativeFile;
     hosts(): number[];
-    startRun(tree: Node, value: string | undefined, sync: boolean): NativeRun<Node>;
-    startProcess(text: string, sync: boolean, path?: string): NativeRun<VFile>;
+    startRun(tree: string, value: string | undefined, sync: boolean): NativeRun;
+    startProcess(text: string, sync: boolean, path?: string): NativeRun;
 }
-/** A run paused before host plugins until `resume`, then finished with `result`. */
-export interface NativeRun<Result> {
+/** What an async `process` settles with: the file, or the error the crate raised. */
+export interface ProcessOutcome {
+    file?: NativeFile;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/** The file a native `process` gives back, its messages as the crate holds them. */
+export interface NativeFile {
+    value: string;
+    messages: Message[];
+    data: Record<string, unknown>;
+}
+/** A run paused before host plugins until `resume`, then finished with `result`, as JSON
+ * text: the tree for a run, the file for a process. */
+export interface NativeRun {
     hosts(): number[];
-    tree(): Node;
+    tree(): string;
     value(): string | null;
     messages(): Message[];
-    resume(tree: Node, messages: Message[]): void;
-    result(): Result;
+    resume(tree: string, messages: Message[]): void;
+    result(): string;
 }
 /** What the napi addon exports. */
 export interface Addon {

package/build/models/addon.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRkb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9tb2RlbHMvYWRkb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTWVzc2FnZSwgTm9kZSwgVkZpbGUgfSBmcm9tIFwiLi9maWxlLnRzXCJcblxuLyoqIFRoZSBjcmF0ZSdzIHBpcGVsaW5lIGFzIHRoZSBhZGRvbiBleHBvc2VzIGl0OiB2YWx1ZXMgY3Jvc3MgYXMgSlNPTi4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTmF0aXZlUGlwZWxpbmUge1xuICB1c2UodmFsdWU6IHVua25vd24sIG9wdGlvbnM/OiB1bmtub3duKTogdm9pZFxuICBkYXRhKGtleT86IHN0cmluZyk6IHVua25vd25cbiAgc2V0RGF0YShrZXk6IHN0cmluZywgdmFsdWU6IHVua25vd24pOiB2b2lkXG4gIHJlcGxhY2VEYXRhKGRhdGE6IFJlY29yZDxzdHJpbmcsIHVua25vd24+KTogdm9pZFxuICBmcmVlemUoKTogdm9pZFxuICBwYXJzZSh0ZXh0OiBzdHJpbmcpOiBOb2RlXG4gIHJ1bih0cmVlOiBOb2RlLCB2YWx1ZT86IHN0cmluZyk6IE5vZGVcbiAgcnVuU3luYyh0cmVlOiBOb2RlLCB2YWx1ZT86IHN0cmluZyk6IE5vZGVcbiAgc3RyaW5naWZ5KHRyZWU6IE5vZGUpOiBzdHJpbmdcbiAgcHJvY2Vzcyh0ZXh0OiBzdHJpbmcsIHBhdGg/OiBzdHJpbmcpOiBWRmlsZVxuICBwcm9jZXNzU3luYyh0ZXh0OiBzdHJpbmcsIHBhdGg/OiBzdHJpbmcpOiBWRmlsZVxuICBob3N0cygpOiBudW1iZXJbXVxuICBzdGFydFJ1bih0cmVlOiBOb2RlLCB2YWx1ZTogc3RyaW5nIHwgdW5kZWZpbmVkLCBzeW5jOiBib29sZWFuKTogTmF0aXZlUnVuPE5vZGU+XG4gIHN0YXJ0UHJvY2Vzcyh0ZXh0OiBzdHJpbmcsIHN5bmM6IGJvb2xlYW4sIHBhdGg/OiBzdHJpbmcpOiBOYXRpdmVSdW48VkZpbGU+XG59XG5cbi8qKiBBIHJ1biBwYXVzZWQgYmVmb3JlIGhvc3QgcGx1Z2lucyB1bnRpbCBgcmVzdW1lYCwgdGhlbiBmaW5pc2hlZCB3aXRoIGByZXN1bHRgLiAqL1xuZXhwb3J0IGludGVyZmFjZSBOYXRpdmVSdW48UmVzdWx0PiB7XG4gIGhvc3RzKCk6IG51bWJlcltdXG4gIHRyZWUoKTogTm9kZVxuICB2YWx1ZSgpOiBzdHJpbmcgfCBudWxsXG4gIG1lc3NhZ2VzKCk6IE1lc3NhZ2VbXVxuICByZXN1bWUodHJlZTogTm9kZSwgbWVzc2FnZXM6IE1lc3NhZ2VbXSk6IHZvaWRcbiAgcmVzdWx0KCk6IFJlc3VsdFxufVxuXG4vKiogV2hhdCB0aGUgbmFwaSBhZGRvbiBleHBvcnRzLiAqL1xuZXhwb3J0IGludGVyZmFjZSBBZGRvbiB7XG4gIHZlcnNpb24oKTogc3RyaW5nXG4gIHBsdWdpbk5hbWVzKCk6IHN0cmluZ1tdXG4gIHJldGFpbmVkTWVtb3J5KCk6IG51bWJlclxuICBzZXRSZXRhaW5lZE1lbW9yeShieXRlczogbnVtYmVyKTogdm9pZFxuICBQaXBlbGluZTogbmV3ICgpID0+IE5hdGl2ZVBpcGVsaW5lXG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/build/models/file.d.ts

@@ -1,3 +1,4 @@
+import type { HostMessage } from "./vfile.ts";
 /** A unist node as JSON: what `parse` returns and `run` and `stringify` take. */
 export interface Node {
     type: string;
@@ -9,7 +10,7 @@ export interface Point {
     column: number;
     offset: number | null;
 }
-/** A diagnostic a plugin reported, as vfile-message has it. */
+/** A diagnostic as it crosses the addon: what a `HostMessage` is read from. */
 export interface Message {
     reason: string;
     ruleId: string | null;
@@ -22,7 +23,7 @@ export interface Message {
 /** What `process` gives back, as a vfile: the output, the messages and the file's data. */
 export interface VFile {
     value: string;
-    messages: Message[];
+    messages: HostMessage[];
     data: Record<string, unknown>;
     path?: string;
 }

package/build/models/file.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL21vZGVscy9maWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQSB1bmlzdCBub2RlIGFzIEpTT046IHdoYXQgYHBhcnNlYCByZXR1cm5zIGFuZCBgcnVuYCBhbmQgYHN0cmluZ2lmeWAgdGFrZS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTm9kZSB7XG4gIHR5cGU6IHN0cmluZ1xuICBba2V5OiBzdHJpbmddOiB1bmtub3duXG59XG5cbi8qKiBPbmUgcGxhY2UgaW4gYSBmaWxlOiBhIDEtaW5kZXhlZCBsaW5lIGFuZCBjb2x1bW4gYW5kIGEgMC1pbmRleGVkIG9mZnNldCwgd2hlbiBrbm93bi4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUG9pbnQge1xuICBsaW5lOiBudW1iZXJcbiAgY29sdW1uOiBudW1iZXJcbiAgb2Zmc2V0OiBudW1iZXIgfCBudWxsXG59XG5cbi8qKiBBIGRpYWdub3N0aWMgYSBwbHVnaW4gcmVwb3J0ZWQsIGFzIHZmaWxlLW1lc3NhZ2UgaGFzIGl0LiAqL1xuZXhwb3J0IGludGVyZmFjZSBNZXNzYWdlIHtcbiAgcmVhc29uOiBzdHJpbmdcbiAgcnVsZUlkOiBzdHJpbmcgfCBudWxsXG4gIHNvdXJjZTogc3RyaW5nIHwgbnVsbFxuICBwbGFjZTogeyBzdGFydDogUG9pbnQ7IGVuZDogUG9pbnQgfSB8IG51bGxcbn1cblxuLyoqIFdoYXQgYHByb2Nlc3NgIGdpdmVzIGJhY2ssIGFzIGEgdmZpbGU6IHRoZSBvdXRwdXQsIHRoZSBtZXNzYWdlcyBhbmQgdGhlIGZpbGUncyBkYXRhLiAqL1xuZXhwb3J0IGludGVyZmFjZSBWRmlsZSB7XG4gIHZhbHVlOiBzdHJpbmdcbiAgbWVzc2FnZXM6IE1lc3NhZ2VbXVxuICBkYXRhOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPlxuICBwYXRoPzogc3RyaW5nXG59XG5cbi8qKiBBIGRvY3VtZW50OiBpdHMgdGV4dCwgb3IgYSBmaWxlIGhvbGRpbmcgaXQgYXMgYHZhbHVlYCwgd2l0aCBpdHMgcGF0aCB3aGVuIGtub3duLiAqL1xuZXhwb3J0IHR5cGUgQ29tcGF0aWJsZSA9IHN0cmluZyB8IHsgdmFsdWU6IHN0cmluZzsgcGF0aD86IHN0cmluZyB9XG5cbi8qKiBXaGVyZSBhIG1lc3NhZ2UgaXM6IGEgcG9pbnQsIGEgcG9zaXRpb24sIG9yIGEgbm9kZSBob2xkaW5nIG9uZS4gKi9cbmV4cG9ydCB0eXBlIFBsYWNlID1cbiAgfCB7IGxpbmU6IG51bWJlcjsgY29sdW1uOiBudW1iZXI7IG9mZnNldD86IG51bWJlciB8IG51bGwgfVxuICB8IHsgc3RhcnQ6IFBvaW50OyBlbmQ6IFBvaW50IH1cbiAgfCB7IHBvc2l0aW9uPzogdW5rbm93biB9XG5cbi8qKiBXaGF0IGBtZXNzYWdlYCB0YWtlcyBiZXNpZGVzIHRoZSByZWFzb24sIGFzIHZmaWxlLW1lc3NhZ2UgbmFtZXMgaXQuICovXG5leHBvcnQgaW50ZXJmYWNlIE1lc3NhZ2VPcHRpb25zIHtcbiAgYW5jZXN0b3JzPzogdW5rbm93bltdXG4gIGNhdXNlPzogdW5rbm93blxuICBwbGFjZT86IFBsYWNlXG4gIHJ1bGVJZD86IHN0cmluZ1xuICBzb3VyY2U/OiBzdHJpbmdcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL21vZGVscy9maWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEhvc3RNZXNzYWdlIH0gZnJvbSBcIi4vdmZpbGUudHNcIlxuXG4vKiogQSB1bmlzdCBub2RlIGFzIEpTT046IHdoYXQgYHBhcnNlYCByZXR1cm5zIGFuZCBgcnVuYCBhbmQgYHN0cmluZ2lmeWAgdGFrZS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTm9kZSB7XG4gIHR5cGU6IHN0cmluZ1xuICBba2V5OiBzdHJpbmddOiB1bmtub3duXG59XG5cbi8qKiBPbmUgcGxhY2UgaW4gYSBmaWxlOiBhIDEtaW5kZXhlZCBsaW5lIGFuZCBjb2x1bW4gYW5kIGEgMC1pbmRleGVkIG9mZnNldCwgd2hlbiBrbm93bi4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUG9pbnQge1xuICBsaW5lOiBudW1iZXJcbiAgY29sdW1uOiBudW1iZXJcbiAgb2Zmc2V0OiBudW1iZXIgfCBudWxsXG59XG5cbi8qKiBBIGRpYWdub3N0aWMgYXMgaXQgY3Jvc3NlcyB0aGUgYWRkb246IHdoYXQgYSBgSG9zdE1lc3NhZ2VgIGlzIHJlYWQgZnJvbS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTWVzc2FnZSB7XG4gIHJlYXNvbjogc3RyaW5nXG4gIHJ1bGVJZDogc3RyaW5nIHwgbnVsbFxuICBzb3VyY2U6IHN0cmluZyB8IG51bGxcbiAgcGxhY2U6IHsgc3RhcnQ6IFBvaW50OyBlbmQ6IFBvaW50IH0gfCBudWxsXG59XG5cbi8qKiBXaGF0IGBwcm9jZXNzYCBnaXZlcyBiYWNrLCBhcyBhIHZmaWxlOiB0aGUgb3V0cHV0LCB0aGUgbWVzc2FnZXMgYW5kIHRoZSBmaWxlJ3MgZGF0YS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVkZpbGUge1xuICB2YWx1ZTogc3RyaW5nXG4gIG1lc3NhZ2VzOiBIb3N0TWVzc2FnZVtdXG4gIGRhdGE6IFJlY29yZDxzdHJpbmcsIHVua25vd24+XG4gIHBhdGg/OiBzdHJpbmdcbn1cblxuLyoqIEEgZG9jdW1lbnQ6IGl0cyB0ZXh0LCBvciBhIGZpbGUgaG9sZGluZyBpdCBhcyBgdmFsdWVgLCB3aXRoIGl0cyBwYXRoIHdoZW4ga25vd24uICovXG5leHBvcnQgdHlwZSBDb21wYXRpYmxlID0gc3RyaW5nIHwgeyB2YWx1ZTogc3RyaW5nOyBwYXRoPzogc3RyaW5nIH1cblxuLyoqIFdoZXJlIGEgbWVzc2FnZSBpczogYSBwb2ludCwgYSBwb3NpdGlvbiwgb3IgYSBub2RlIGhvbGRpbmcgb25lLiAqL1xuZXhwb3J0IHR5cGUgUGxhY2UgPVxuICB8IHsgbGluZTogbnVtYmVyOyBjb2x1bW46IG51bWJlcjsgb2Zmc2V0PzogbnVtYmVyIHwgbnVsbCB9XG4gIHwgeyBzdGFydDogUG9pbnQ7IGVuZDogUG9pbnQgfVxuICB8IHsgcG9zaXRpb24/OiB1bmtub3duIH1cblxuLyoqIFdoYXQgYG1lc3NhZ2VgIHRha2VzIGJlc2lkZXMgdGhlIHJlYXNvbiwgYXMgdmZpbGUtbWVzc2FnZSBuYW1lcyBpdC4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTWVzc2FnZU9wdGlvbnMge1xuICBhbmNlc3RvcnM/OiB1bmtub3duW11cbiAgY2F1c2U/OiB1bmtub3duXG4gIHBsYWNlPzogUGxhY2VcbiAgcnVsZUlkPzogc3RyaW5nXG4gIHNvdXJjZT86IHN0cmluZ1xufVxuIl19

package/build/models/plugin.d.ts

@@ -1,3 +1,4 @@
+import type { Node as UnistNode } from "unist";
 import type { Node } from "./file.ts";
 import type { HostFile } from "./vfile.ts";
 /** A native plugin as a pipeline names it, with its options when given. */
@@ -5,6 +6,11 @@ export interface Plugin<Name extends string = string, Options = unknown> {
     name: Name;
     options?: Options;
 }
+declare const parsed: unique symbol;
+/** A parser plugin, carrying the tree `parse` returns once it is used; nothing at runtime. */
+export interface Parser<Tree extends UnistNode = UnistNode> {
+    readonly [parsed]?: Tree;
+}
 /** Plugins and the settings they share, as unified's presets. */
 export interface Preset {
     plugins?: PluggableList;
@@ -24,3 +30,4 @@ export type Transformer = (tree: Node, file: HostFile, next: (error?: unknown, t
 export type Pluggable = Plugin | string | Attacher | [Plugin | string | Attacher, unknown?] | Preset;
 /** Several pluggables, used in order. */
 export type PluggableList = Pluggable[];
+export {};

package/build/models/plugin.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vbW9kZWxzL3BsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBOb2RlIH0gZnJvbSBcIi4vZmlsZS50c1wiXG5pbXBvcnQgdHlwZSB7IEhvc3RGaWxlIH0gZnJvbSBcIi4vdmZpbGUudHNcIlxuXG4vKiogQSBuYXRpdmUgcGx1Z2luIGFzIGEgcGlwZWxpbmUgbmFtZXMgaXQsIHdpdGggaXRzIG9wdGlvbnMgd2hlbiBnaXZlbi4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUGx1Z2luPE5hbWUgZXh0ZW5kcyBzdHJpbmcgPSBzdHJpbmcsIE9wdGlvbnMgPSB1bmtub3duPiB7XG4gIG5hbWU6IE5hbWVcbiAgb3B0aW9ucz86IE9wdGlvbnNcbn1cblxuLyoqIFBsdWdpbnMgYW5kIHRoZSBzZXR0aW5ncyB0aGV5IHNoYXJlLCBhcyB1bmlmaWVkJ3MgcHJlc2V0cy4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUHJlc2V0IHtcbiAgcGx1Z2lucz86IFBsdWdnYWJsZUxpc3RcbiAgc2V0dGluZ3M/OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPlxufVxuXG4vKipcbiAqIEEgSmF2YVNjcmlwdCBwbHVnaW4sIGFzIHVuaWZpZWQncyBhdHRhY2hlcnM6IGNhbGxlZCB3aXRoIHRoZSBwcm9jZXNzb3IgYXMgYHRoaXNgIGFuZCBpdHNcbiAqIG9wdGlvbnMgd2hlbiB0aGUgcHJvY2Vzc29yIGZyZWV6ZXMsIGl0IHJldHVybnMgdGhlIHRyYW5zZm9ybWVyIHRoZSBwaXBlbGluZSBydW5zLlxuICovXG5leHBvcnQgdHlwZSBBdHRhY2hlciA9ICh0aGlzOiBuZXZlciwgLi4ucGFyYW1ldGVyczogbmV2ZXJbXSkgPT4gdW5rbm93blxuXG4vKipcbiAqIFdoYXQgYW4gYXR0YWNoZXIgcmV0dXJuczogaXQgY2hhbmdlcyB0aGUgdHJlZSBpbiBwbGFjZSBvciByZXR1cm5zIGEgbmV3IG9uZSwgZGlyZWN0bHksXG4gKiB0aHJvdWdoIGEgcHJvbWlzZSBvciB0aHJvdWdoIGBuZXh0YC5cbiAqL1xuZXhwb3J0IHR5cGUgVHJhbnNmb3JtZXIgPSAoXG4gIHRyZWU6IE5vZGUsXG4gIGZpbGU6IEhvc3RGaWxlLFxuICBuZXh0OiAoZXJyb3I/OiB1bmtub3duLCB0cmVlPzogTm9kZSkgPT4gdm9pZCxcbikgPT4gdW5rbm93blxuXG4vKiogQSBwbHVnaW4sIGJ5IGRlc2NyaXB0b3IsIG5hbWUgb3IgYXR0YWNoZXIsIHdpdGggb3B0aW9ucywgb3IgYSBwcmVzZXQuICovXG5leHBvcnQgdHlwZSBQbHVnZ2FibGUgPVxuICB8IFBsdWdpblxuICB8IHN0cmluZ1xuICB8IEF0dGFjaGVyXG4gIHwgW1BsdWdpbiB8IHN0cmluZyB8IEF0dGFjaGVyLCB1bmtub3duP11cbiAgfCBQcmVzZXRcblxuLyoqIFNldmVyYWwgcGx1Z2dhYmxlcywgdXNlZCBpbiBvcmRlci4gKi9cbmV4cG9ydCB0eXBlIFBsdWdnYWJsZUxpc3QgPSBQbHVnZ2FibGVbXVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/build/models/processor.d.ts

@@ -1,18 +1,20 @@
+import type { Node as UnistNode } from "unist";
 import type { NativePipeline } from "./addon.ts";
 import type { Compatible, Node, VFile } from "./file.ts";
-import type { Pluggable, PluggableList, Preset } from "./plugin.ts";
+import type { Parser, Pluggable, PluggableList, Preset } from "./plugin.ts";
 /**
  * unified's processor over the native pipeline; every call is the crate's, except that
  * JavaScript plugins run here when a run pauses before them.
  */
-export declare class Processor {
+export declare class Processor<Tree extends UnistNode = Node> {
     #private;
     constructor(native: NativePipeline);
     /**
      * Add a plugin, a list of them or a preset; a plugin used again is reconfigured. A
      * JavaScript plugin is an attacher, called with the processor and its options at freeze.
+     * A parser, such as `md.parse()`, types the tree `parse` returns.
      */
-    use(value: Pluggable | PluggableList | Preset | null | undefined, ...options: unknown[]): this;
+    use<Value extends Pluggable | PluggableList | Preset | null | undefined>(value: Value, ...options: unknown[]): Processor<ParsedTree<Value, Tree>>;
     /** All data, or the value under `key`. */
     data(): Record<string, unknown>;
     data(key: string): unknown;
@@ -22,18 +24,20 @@ export declare class Processor {
     /** Attach every plugin; later `use` and `data` setters fail. */
     freeze(): this;
     /** Parse a document into a tree. */
-    parse(document: Compatible): Node;
+    parse(document: Compatible): Tree;
     /**
      * Run the transforms, finishing asynchronous stages; `file`, the text `tree` was parsed
      * from, lets bridges read it and keeps positions in the result.
      */
-    run(tree: Node, file?: Compatible): Promise<Node>;
+    run(tree: UnistNode, file?: Compatible): Promise<Node>;
     /** Run the transforms; fails with `async-in-sync` on an asynchronous stage. */
-    runSync(tree: Node, file?: Compatible): Node;
+    runSync(tree: UnistNode, file?: Compatible): Node;
     /** Compile a tree, running no transform. */
-    stringify(tree: Node): string;
+    stringify(tree: UnistNode): string;
     /** Parse, run and compile a document, finishing asynchronous stages. */
     process(document: Compatible): Promise<VFile>;
     /** Parse, run and compile a document; fails with `async-in-sync` on an asynchronous stage. */
     processSync(document: Compatible): VFile;
 }
+type ParsedTree<Value, Current> = Value extends Parser<infer Parsed> ? Parsed extends UnistNode ? Parsed : Current : Current;
+export {};