textlane 0.2.1 → 0.5.0

package/build/actions/addon/resolve.d.ts

@@ -2,6 +2,7 @@
 export declare function resolveAddon(props: {
     platform: string;
     arch: string;
+    libc: string | undefined;
     env: Record<string, string | undefined>;
     resolvePackage: (specifier: string) => string;
 }): string;

package/build/actions/addon/resolve.js

@@ -4,7 +4,8 @@ export function resolveAddon(props) {
     const override = props.env[ADDON_ENV];
     if (override)
         return override;
-    const key = `${props.platform}-${props.arch}`;
+    const suffix = props.libc === "musl" ? "-musl" : "";
+    const key = `${props.platform}-${props.arch}${suffix}`;
     const platform = PLATFORMS[key];
     if (!platform) {
         const supported = Object.keys(PLATFORMS).join(", ");
@@ -19,4 +20,4 @@ export function resolveAddon(props) {
             `--no-optional / --omit=optional so the addon for ${key} comes along.`);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/libc/detect.d.ts

@@ -0,0 +1,5 @@
+/** The C library Node runs on under Linux: glibc when its report names a glibc, else musl. */
+export declare function detectLibc(props: {
+    platform: string;
+    report: () => object;
+}): "glibc" | "musl" | undefined;

package/build/actions/libc/detect.js

@@ -0,0 +1,11 @@
+/** The C library Node runs on under Linux: glibc when its report names a glibc, else musl. */
+export function detectLibc(props) {
+    if (props.platform !== "linux")
+        return undefined;
+    const report = props.report();
+    const header = "header" in report ? report.header : undefined;
+    if (typeof header !== "object" || header === null)
+        return "glibc";
+    return "glibcVersionRuntime" in header && header.glibcVersionRuntime ? "glibc" : "musl";
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGV0ZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vYWN0aW9ucy9saWJjL2RldGVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw4RkFBOEY7QUFDOUYsTUFBTSxVQUFVLFVBQVUsQ0FBQyxLQUFpRDtJQUMxRSxJQUFJLEtBQUssQ0FBQyxRQUFRLEtBQUssT0FBTztRQUFFLE9BQU8sU0FBUyxDQUFBO0lBQ2hELE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQTtJQUM3QixNQUFNLE1BQU0sR0FBRyxRQUFRLElBQUksTUFBTSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUE7SUFDN0QsSUFBSSxPQUFPLE1BQU0sS0FBSyxRQUFRLElBQUksTUFBTSxLQUFLLElBQUk7UUFBRSxPQUFPLE9BQU8sQ0FBQTtJQUNqRSxPQUFPLHFCQUFxQixJQUFJLE1BQU0sSUFBSSxNQUFNLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFBO0FBQ3pGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogVGhlIEMgbGlicmFyeSBOb2RlIHJ1bnMgb24gdW5kZXIgTGludXg6IGdsaWJjIHdoZW4gaXRzIHJlcG9ydCBuYW1lcyBhIGdsaWJjLCBlbHNlIG11c2wuICovXG5leHBvcnQgZnVuY3Rpb24gZGV0ZWN0TGliYyhwcm9wczogeyBwbGF0Zm9ybTogc3RyaW5nOyByZXBvcnQ6ICgpID0+IG9iamVjdCB9KSB7XG4gIGlmIChwcm9wcy5wbGF0Zm9ybSAhPT0gXCJsaW51eFwiKSByZXR1cm4gdW5kZWZpbmVkXG4gIGNvbnN0IHJlcG9ydCA9IHByb3BzLnJlcG9ydCgpXG4gIGNvbnN0IGhlYWRlciA9IFwiaGVhZGVyXCIgaW4gcmVwb3J0ID8gcmVwb3J0LmhlYWRlciA6IHVuZGVmaW5lZFxuICBpZiAodHlwZW9mIGhlYWRlciAhPT0gXCJvYmplY3RcIiB8fCBoZWFkZXIgPT09IG51bGwpIHJldHVybiBcImdsaWJjXCJcbiAgcmV0dXJuIFwiZ2xpYmNWZXJzaW9uUnVudGltZVwiIGluIGhlYWRlciAmJiBoZWFkZXIuZ2xpYmNWZXJzaW9uUnVudGltZSA/IFwiZ2xpYmNcIiA6IFwibXVzbFwiXG59XG4iXX0=

package/build/actions/run/finish.d.ts

@@ -4,7 +4,7 @@ import type { Host } from "../../models/host.ts";
 /** Run the host plugins a native run pauses at until it finishes; under `sync`, a plugin
  * finishing later fails with `async-in-sync`, as an asynchronous native stage does. */
 export declare function finishRun(props: {
-    run: NativeRun<unknown>;
+    run: NativeRun;
     hosts: Map<number, Host>;
     file: HostFile;
     sync: boolean;

package/build/actions/run/finish.js

@@ -6,7 +6,7 @@ export function finishRun(props) {
     let sent = props.file.messages.length;
     while (props.run.hosts().length > 0) {
         mirrorMessages();
-        const tree = runHosts(props, props.run.hosts(), props.run.tree());
+        const tree = runHosts(props, props.run.hosts(), readTree(props.run.tree()));
         if (isThenable(tree)) {
             if (props.sync)
                 throw asyncError(props.call);
@@ -26,7 +26,7 @@ export function finishRun(props) {
         sent = props.file.messages.length;
     }
     function resume(tree) {
-        props.run.resume(tree, props.file.messages.slice(sent).map(message => message.toJSON()));
+        props.run.resume(JSON.stringify(tree), props.file.messages.slice(sent).map(message => message.toJSON()));
         sent = props.file.messages.length;
     }
 }
@@ -45,8 +45,12 @@ function runHosts(props, ids, tree) {
     }
     return tree;
 }
+function readTree(text) {
+    const tree = JSON.parse(text);
+    return tree;
+}
 function asyncError(call) {
     const message = `\`${call}Sync\` finished async. Use \`${call}\` instead`;
     return Object.assign(new Error(message), { code: "async-in-sync" });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/generated/html.d.ts

@@ -1,4 +1,5 @@
-import type { Plugin } from "../models/plugin.ts";
+import type { Root } from "hast";
+import type { Parser, Plugin } from "../models/plugin.ts";
 /** `html.parse`: HTML into hast; options named as rehype-parse names them. */
 export interface ParseOptions {
     /** Parse a fragment, as in a `template`, rather than a whole document. @default false */
@@ -23,9 +24,18 @@ export interface FormatOptions {
     indent?: Indent | null;
     /** Indent the first level, usually `<html>`'s `head` and `body`; `true` when left out. */
     indentInitial?: boolean | null;
+    /** Only collapse whitespace, as rehype-minify-whitespace does, adding no line endings or indentation; `{ newlines: true }` collapses a run holding a line ending to it. */
+    minify?: Minify | null;
 }
 /** One level of indentation. */
 export type Indent = number | string;
+/** `html.format`'s `minify`: on, or on with rehype-minify-whitespace's options. */
+export type Minify = boolean | MinifyOptions;
+/** rehype-minify-whitespace's options. */
+export interface MinifyOptions {
+    /** Collapse a run of whitespace holding a line ending to a line ending, not a space. @default false */
+    newlines?: boolean;
+}
 /** `html.sanitize`: keep only what a schema allows; options: hast-util-sanitize's schema, where a field left out keeps the default schema's, which is GitHub's. */
 export interface SanitizeOptions {
     /** Keep comments. */
@@ -57,7 +67,30 @@ export type Primitive = boolean | number | string;
 export interface SlugOptions {
     /** Put before each id. @default "" */
     prefix?: string;
+    /** Link each heading with an `id` to itself, as rehype-autolink-headings does: `true`, or its options. */
+    autolink?: Autolink | null;
+}
+/** `html.slug`'s `autolink`: on, or on with rehype-autolink-headings' options. */
+export type Autolink = boolean | AutolinkOptions;
+/** rehype-autolink-headings' options, JSON values only. */
+export interface AutolinkOptions {
+    /** Where the link goes: in the heading first or last, around its content, or before or after it. */
+    behavior?: AutolinkBehavior;
+    /** The link's properties, as hast names them; `ariaHidden` and `tabIndex: -1` for `prepend` and `append` when left out. */
+    properties?: Record<string, unknown> | null;
+    /** hast content of the link, one node or a list; `<span class="icon icon-link">` when left out, except for `wrap`, which appends it to the heading's content. */
+    content?: unknown;
+    /** A hast element wrapping the heading and its link, for `before` and `after`. */
+    group?: unknown;
+    /** Properties set on each linked heading. */
+    headingProperties?: Record<string, unknown> | null;
+    /** The tag names of the headings to link; every heading when left out. */
+    test?: TagNames | null;
 }
+/** Where `autolink` puts each heading's link. */
+export type AutolinkBehavior = "prepend" | "append" | "wrap" | "before" | "after";
+/** One tag name or several. */
+export type TagNames = string | string[];
 /** `html.externalLinks`: `rel`, `target` and more on links to other sites, as rehype-external-links adds them; options named as it names them, JSON values only. */
 export interface ExternalLinksOptions {
     /** The `target` of each external link, such as `_blank`. */
@@ -233,7 +266,7 @@ export interface StringifyOptions {
     voids?: string[] | null;
 }
 /** The `html.parse` plugin. */
-export declare function parse(options?: ParseOptions): Plugin<"html.parse", ParseOptions>;
+export declare function parse(options?: ParseOptions): Plugin<"html.parse", ParseOptions> & Parser<Root>;
 /** The `html.raw` plugin. */
 export declare function raw(options?: RawOptions): Plugin<"html.raw", RawOptions>;
 /** The `html.format` plugin. */

package/build/generated/html.js

@@ -73,4 +73,4 @@ export function stringify(options) {
         return { name: "html.stringify" };
     return { name: "html.stringify", options };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"html.js","sourceRoot":"","sources":["../../generated/html.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/** `html.parse`: HTML into hast; options named as rehype-parse names them. */\nexport interface ParseOptions {\n  /** Parse a fragment, as in a `template`, rather than a whole document. @default false */\n  fragment?: boolean\n  /** Report parse errors as messages on the file. @default false */\n  emitParseErrors?: boolean\n  /** Add the positions of opening and closing tags and attributes to elements. @default false */\n  verbose?: boolean\n}\n\n/** `html.raw`: reparse raw HTML and fix nesting through the HTML parser; options named as hast-util-raw names them. */\nexport interface RawOptions {\n  /** Node types, unknown to hast, to copy through as they are; their children are reparsed on their own. @default [] */\n  passThrough?: string[]\n  /** Escape the opening `<` of the tags GFM's tagfilter disallows in raw nodes. @default false */\n  tagfilter?: boolean\n}\n\n/** `html.format`: indent and collapse whitespace for readable HTML; options named as hast-util-format names them. */\nexport interface FormatOptions {\n  /** Tag names of elements to put a blank line between, when both are one. @default [] */\n  blanks?: string[]\n  /** One level of indentation: a number of spaces or the text itself; two spaces when left out. */\n  indent?: Indent | null\n  /** Indent the first level, usually `<html>`'s `head` and `body`; `true` when left out. */\n  indentInitial?: boolean | null\n}\n\n/** One level of indentation. */\nexport type Indent = number | string\n\n/** `html.sanitize`: keep only what a schema allows; options: hast-util-sanitize's schema, where a field left out keeps the default schema's, which is GitHub's. */\nexport interface SanitizeOptions {\n  /** Keep comments. */\n  allowComments?: boolean | null\n  /** Keep doctypes. */\n  allowDoctypes?: boolean | null\n  /** Elements allowed only inside one of these ancestors, by tag name. */\n  ancestors?: Record<string, string[]> | null\n  /** Properties allowed per tag name, `*` for every element; a list names a property and the values it may have. */\n  attributes?: Record<string, AttributeDefinition[]> | null\n  /** Properties whose values get `clobber_prefix`, so they cannot clobber globals. */\n  clobber?: string[] | null\n  /** The prefix of clobbered values. */\n  clobberPrefix?: string | null\n  /** URL properties and the protocols they may use. */\n  protocols?: Record<string, string[]> | null\n  /** Properties set on elements whatever they had, by tag name. */\n  required?: Record<string, Record<string, Primitive>> | null\n  /** Elements dropped with their content rather than unwrapped. */\n  strip?: string[] | null\n  /** The elements kept. */\n  tagNames?: string[] | null\n}\n\n/** A property a sanitize schema allows: by name, or a name and its allowed values. */\nexport type AttributeDefinition = string | Primitive[]\n\n/** A primitive property value. */\nexport type Primitive = boolean | number | string\n\n/** `html.slug`: ids on headings, from their text; options named as rehype-slug names them. */\nexport interface SlugOptions {\n  /** Put before each id. @default \"\" */\n  prefix?: string\n}\n\n/** `html.externalLinks`: `rel`, `target` and more on links to other sites, as rehype-external-links adds them; options named as it names them, JSON values only. */\nexport interface ExternalLinksOptions {\n  /** The `target` of each external link, such as `_blank`. */\n  target?: string | null\n  /** The `rel` of each external link: a list, or tokens separated by white space; `nofollow` when left out or empty, none for an empty list. */\n  rel?: Tokens | null\n  /** The protocols of absolute URLs that count as external; `http` and `https` when left out. A protocol-relative `//…` URL always counts. */\n  protocols?: string[] | null\n  /** More properties for each external link, as hast names them. */\n  properties?: Record<string, unknown> | null\n  /** hast content appended to each external link in a `<span>`: one node or a list. */\n  content?: unknown\n  /** The properties of that `<span>`. */\n  contentProperties?: Record<string, unknown> | null\n}\n\n/** Tokens: a list, or one string of them separated by white space. */\nexport type Tokens = string | string[]\n\n/** `html.extractToc`: the headings, nested by rank, as the file's `data.toc`, as @stefanprobst/rehype-extract-toc stores them. */\nexport interface ExtractTocOptions {\n  /** Attributes, such as `data-toc-hidden`, that keep a heading out of the table of contents; what would nest under it nests under the heading before. @default [] */\n  skip?: string[]\n}\n\n/** `html.highlight`: code blocks colored as Shiki colors them, natively by giallo; options named as @shikijs/rehype names them. */\nexport interface HighlightOptions {\n  /** The theme of each color mode, `light` first, as `{\"light\": …, \"dark\": …}`. */\n  themes?: Record<string, unknown> | null\n  /** The one theme, when `themes` is not given. */\n  theme?: string | null\n  /** The language of a block that names none; such a block is left alone without it. */\n  defaultLanguage?: string | null\n  /** The language of a block naming one Shiki does not know; left alone without it. */\n  fallbackLanguage?: string | null\n  /** Colors to replace, by their lowercase spelling: a color for every theme, or a theme's name to a map of its own. */\n  colorReplacements?: Record<string, ColorReplacement>\n  /** Add `language-<name>` to each highlighted `<code>`. @default false */\n  addLanguageClass?: boolean\n  /** Highlight inline code too, by how it names its language: `tailing-curly-colon` reads `` `a(){:js}` ``. */\n  inline?: InlineCode | null\n  /** The `<pre>` property that gets a block's meta, the text after its language; the JSON stand-in for `parseMetaString: meta => ({ [name]: meta })`. */\n  metaProperty?: string | null\n  /** The transformers of @shikijs/transformers to run, in order, by name or with options. */\n  transformers?: HighlightTransformer[]\n  /** Lines at least this long, in UTF-16 units, are left one plain token as Shiki's own option leaves them; 2,000 when left out, where Shiki has no limit, since a grammar's time grows with the square of a line's length. `0` lifts it. */\n  tokenizeMaxLineLength?: number | null\n}\n\n/** A replacement color, or a theme's own replacements. */\nexport type ColorReplacement = string | Record<string, string>\n\n/** How inline code names its language. */\nexport type InlineCode = \"tailing-curly-colon\"\n\n/** A transformer of @shikijs/transformers: its name alone, or its name and options. */\nexport type HighlightTransformer = TransformerName | ConfiguredTransformer\n\n/** The transformers `html.highlight` runs natively. */\nexport type TransformerName = \"notationDiff\" | \"notationFocus\" | \"notationHighlight\" | \"notationErrorLevel\" | \"metaHighlight\" | \"metaWordHighlight\" | \"renderLineNumber\"\n\n/** A transformer with its options, as @shikijs/transformers names them. */\nexport type ConfiguredTransformer = { name: \"notationDiff\"; classLineAdd?: Classes | null; classLineRemove?: Classes | null; classActivePre?: Classes | null; classActiveCode?: Classes | null } | { name: \"notationFocus\"; classActiveLine?: Classes | null; classActivePre?: Classes | null; classActiveCode?: Classes | null } | { name: \"notationHighlight\"; classActiveLine?: Classes | null; classActivePre?: Classes | null; classActiveCode?: Classes | null } | { name: \"notationErrorLevel\"; classMap?: Record<string, Classes> | null; classActivePre?: Classes | null; classActiveCode?: Classes | null } | { name: \"metaHighlight\"; className?: Classes | null; zeroIndexed?: boolean } | { name: \"metaWordHighlight\"; className?: Classes | null } | { name: \"renderLineNumber\"; classLineNumber?: Classes | null; start?: number | null }\n\n/** Class names: a list, or one string of them separated by white space. */\nexport type Classes = string | string[]\n\n/** `html.katex`: math rendered as rehype-katex renders it, natively by katex-rs; options named as KaTeX names them. */\nexport interface KatexOptions {\n  /** The markup to write, both HTML and MathML by default. */\n  output?: KatexOutput | null\n  /** Put equation numbers on the left. @default false */\n  leqno?: boolean\n  /** Align display math to the left instead of centering it. @default false */\n  fleqn?: boolean\n  /** The color of math that fails to render, `#cc0000` by default. */\n  errorColor?: string | null\n  /** Macros by name, each to the TeX it expands to, as `{\"\\\\RR\": \"\\\\mathbb{R}\"}`. @default {} */\n  macros?: Record<string, string>\n  /** The thinnest a rule, such as a fraction line, is drawn, in ems. */\n  minRuleThickness?: number | null\n  /** Let `\\color` color the text after it, as LaTeX does. @default false */\n  colorIsTextColor?: boolean\n  /** What to do with input LaTeX would reject: `true` or `\"error\"` fails it, `\"warn\"` prints a warning, `false` or `\"ignore\"` (the default) accepts it. */\n  strict?: KatexStrict | null\n  /** Allow commands that can run untrusted input, such as `\\href` and `\\includegraphics`. @default false */\n  trust?: boolean\n  /** The largest a user-given size may be, in ems. */\n  maxSize?: number | null\n  /** How many macro expansions one formula may take, 1000 by default. */\n  maxExpand?: number | null\n  /** Let definitions such as `\\def` last past the formula they are in. @default false */\n  globalGroup?: boolean\n}\n\n/** The markup KaTeX writes. */\nexport type KatexOutput = \"html\" | \"mathml\" | \"htmlAndMathml\"\n\n/** How strictly KaTeX holds input to LaTeX. */\nexport type KatexStrict = boolean | KatexStrictMode\n\n/** One level of KaTeX's strictness. */\nexport type KatexStrictMode = \"ignore\" | \"warn\" | \"error\"\n\n/** `html.toMarkdown`: hast into mdast; options named as hast-util-to-mdast names them. */\nexport interface ToMarkdownOptions {\n  /** Wrap all phrasing content of the root in paragraphs, as for a whole document. @default false */\n  document?: boolean\n  /** Collapse whitespace holding a line ending to that line ending instead of a space. @default false */\n  newlines?: boolean\n  /** The text of a checked checkbox or radio, `[x]` by default. */\n  checked?: string | null\n  /** The text of an unchecked checkbox or radio, `[ ]` by default. */\n  unchecked?: string | null\n  /** The quotes `<q>` uses, an opening and closing character each, alternating by how deep it nests; `\"` by default. */\n  quotes?: string[] | null\n}\n\n/** `html.stringify`: hast into HTML; options named as hast-util-to-html names them. */\nexport interface StringifyOptions {\n  /** Write raw nodes as they are instead of escaping them. @default false */\n  allowDangerousHtml?: boolean\n  /** Leave characters that are only dangerous in some contexts, such as `` ` ``, as they are. @default false */\n  allowDangerousCharacters?: boolean\n  /** Leave characters as they are where browsers accept them though the spec does not. @default false */\n  allowParseErrors?: boolean\n  /** Write comments as bogus comments, `<?a>`. @default false */\n  bogusComments?: boolean\n  /** Close empty foreign elements, `<a />`. @default false */\n  closeEmptyElements?: boolean\n  /** Close void elements, `<br />`. @default false */\n  closeSelfClosing?: boolean\n  /** Write empty attributes as bare names, `a` rather than `a=\"\"`. @default false */\n  collapseEmptyAttributes?: boolean\n  /** Leave out tags the HTML spec lets a parser imply. @default false */\n  omitOptionalTags?: boolean\n  /** Leave attribute values unquoted where that is safe. @default false */\n  preferUnquoted?: boolean\n  /** The quote attribute values are wrapped in: `\"` or `'`. */\n  quote?: string | null\n  /** Use the other quote when the value holds more of the preferred one. @default false */\n  quoteSmart?: boolean\n  /** The space the tree is in: `html` or `svg`. */\n  space?: string | null\n  /** Leave out the space between quoted attributes. @default false */\n  tightAttributes?: boolean\n  /** Join comma-separated values with `,` rather than `, `. @default false */\n  tightCommaSeparatedLists?: boolean\n  /** Write `<!doctypehtml>`. @default false */\n  tightDoctype?: boolean\n  /** Leave out the space before `/>` when the attributes allow. @default false */\n  tightSelfClosing?: boolean\n  /** Write `<!DOCTYPE html>`. @default false */\n  upperDoctype?: boolean\n  /** The tag names of void elements, which have no closing tag. */\n  voids?: string[] | null\n}\n\n/** The `html.parse` plugin. */\nexport function parse(options?: ParseOptions): Plugin<\"html.parse\", ParseOptions> {\n  if (options === undefined) return { name: \"html.parse\" }\n  return { name: \"html.parse\", options }\n}\n\n/** The `html.raw` plugin. */\nexport function raw(options?: RawOptions): Plugin<\"html.raw\", RawOptions> {\n  if (options === undefined) return { name: \"html.raw\" }\n  return { name: \"html.raw\", options }\n}\n\n/** The `html.format` plugin. */\nexport function format(options?: FormatOptions): Plugin<\"html.format\", FormatOptions> {\n  if (options === undefined) return { name: \"html.format\" }\n  return { name: \"html.format\", options }\n}\n\n/** The `html.sanitize` plugin. */\nexport function sanitize(options?: SanitizeOptions): Plugin<\"html.sanitize\", SanitizeOptions> {\n  if (options === undefined) return { name: \"html.sanitize\" }\n  return { name: \"html.sanitize\", options }\n}\n\n/** The `html.slug` plugin. */\nexport function slug(options?: SlugOptions): Plugin<\"html.slug\", SlugOptions> {\n  if (options === undefined) return { name: \"html.slug\" }\n  return { name: \"html.slug\", options }\n}\n\n/** The `html.externalLinks` plugin. */\nexport function externalLinks(options?: ExternalLinksOptions): Plugin<\"html.externalLinks\", ExternalLinksOptions> {\n  if (options === undefined) return { name: \"html.externalLinks\" }\n  return { name: \"html.externalLinks\", options }\n}\n\n/** The `html.unwrapImages` plugin. */\nexport function unwrapImages(): Plugin<\"html.unwrapImages\"> {\n  return { name: \"html.unwrapImages\" }\n}\n\n/** The `html.extractToc` plugin. */\nexport function extractToc(options?: ExtractTocOptions): Plugin<\"html.extractToc\", ExtractTocOptions> {\n  if (options === undefined) return { name: \"html.extractToc\" }\n  return { name: \"html.extractToc\", options }\n}\n\n/** The `html.highlight` plugin. */\nexport function highlight(options?: HighlightOptions): Plugin<\"html.highlight\", HighlightOptions> {\n  if (options === undefined) return { name: \"html.highlight\" }\n  return { name: \"html.highlight\", options }\n}\n\n/** The `html.katex` plugin. */\nexport function katex(options?: KatexOptions): Plugin<\"html.katex\", KatexOptions> {\n  if (options === undefined) return { name: \"html.katex\" }\n  return { name: \"html.katex\", options }\n}\n\n/** The `html.toMarkdown` plugin. */\nexport function toMarkdown(options?: ToMarkdownOptions): Plugin<\"html.toMarkdown\", ToMarkdownOptions> {\n  if (options === undefined) return { name: \"html.toMarkdown\" }\n  return { name: \"html.toMarkdown\", options }\n}\n\n/** The `html.toNaturalLanguage` plugin. */\nexport function toNaturalLanguage(): Plugin<\"html.toNaturalLanguage\"> {\n  return { name: \"html.toNaturalLanguage\" }\n}\n\n/** The `html.stringify` plugin. */\nexport function stringify(options?: StringifyOptions): Plugin<\"html.stringify\", StringifyOptions> {\n  if (options === undefined) return { name: \"html.stringify\" }\n  return { name: \"html.stringify\", options }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"html.js","sourceRoot":"","sources":["../../generated/html.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 \"hast\"\nimport type { Parser, Plugin } from \"../models/plugin.ts\"\n\n/** `html.parse`: HTML into hast; options named as rehype-parse names them. */\nexport interface ParseOptions {\n  /** Parse a fragment, as in a `template`, rather than a whole document. @default false */\n  fragment?: boolean\n  /** Report parse errors as messages on the file. @default false */\n  emitParseErrors?: boolean\n  /** Add the positions of opening and closing tags and attributes to elements. @default false */\n  verbose?: boolean\n}\n\n/** `html.raw`: reparse raw HTML and fix nesting through the HTML parser; options named as hast-util-raw names them. */\nexport interface RawOptions {\n  /** Node types, unknown to hast, to copy through as they are; their children are reparsed on their own. @default [] */\n  passThrough?: string[]\n  /** Escape the opening `<` of the tags GFM's tagfilter disallows in raw nodes. @default false */\n  tagfilter?: boolean\n}\n\n/** `html.format`: indent and collapse whitespace for readable HTML; options named as hast-util-format names them. */\nexport interface FormatOptions {\n  /** Tag names of elements to put a blank line between, when both are one. @default [] */\n  blanks?: string[]\n  /** One level of indentation: a number of spaces or the text itself; two spaces when left out. */\n  indent?: Indent | null\n  /** Indent the first level, usually `<html>`'s `head` and `body`; `true` when left out. */\n  indentInitial?: boolean | null\n  /** Only collapse whitespace, as rehype-minify-whitespace does, adding no line endings or indentation; `{ newlines: true }` collapses a run holding a line ending to it. */\n  minify?: Minify | null\n}\n\n/** One level of indentation. */\nexport type Indent = number | string\n\n/** `html.format`'s `minify`: on, or on with rehype-minify-whitespace's options. */\nexport type Minify = boolean | MinifyOptions\n\n/** rehype-minify-whitespace's options. */\nexport interface MinifyOptions {\n  /** Collapse a run of whitespace holding a line ending to a line ending, not a space. @default false */\n  newlines?: boolean\n}\n\n/** `html.sanitize`: keep only what a schema allows; options: hast-util-sanitize's schema, where a field left out keeps the default schema's, which is GitHub's. */\nexport interface SanitizeOptions {\n  /** Keep comments. */\n  allowComments?: boolean | null\n  /** Keep doctypes. */\n  allowDoctypes?: boolean | null\n  /** Elements allowed only inside one of these ancestors, by tag name. */\n  ancestors?: Record<string, string[]> | null\n  /** Properties allowed per tag name, `*` for every element; a list names a property and the values it may have. */\n  attributes?: Record<string, AttributeDefinition[]> | null\n  /** Properties whose values get `clobber_prefix`, so they cannot clobber globals. */\n  clobber?: string[] | null\n  /** The prefix of clobbered values. */\n  clobberPrefix?: string | null\n  /** URL properties and the protocols they may use. */\n  protocols?: Record<string, string[]> | null\n  /** Properties set on elements whatever they had, by tag name. */\n  required?: Record<string, Record<string, Primitive>> | null\n  /** Elements dropped with their content rather than unwrapped. */\n  strip?: string[] | null\n  /** The elements kept. */\n  tagNames?: string[] | null\n}\n\n/** A property a sanitize schema allows: by name, or a name and its allowed values. */\nexport type AttributeDefinition = string | Primitive[]\n\n/** A primitive property value. */\nexport type Primitive = boolean | number | string\n\n/** `html.slug`: ids on headings, from their text; options named as rehype-slug names them. */\nexport interface SlugOptions {\n  /** Put before each id. @default \"\" */\n  prefix?: string\n  /** Link each heading with an `id` to itself, as rehype-autolink-headings does: `true`, or its options. */\n  autolink?: Autolink | null\n}\n\n/** `html.slug`'s `autolink`: on, or on with rehype-autolink-headings' options. */\nexport type Autolink = boolean | AutolinkOptions\n\n/** rehype-autolink-headings' options, JSON values only. */\nexport interface AutolinkOptions {\n  /** Where the link goes: in the heading first or last, around its content, or before or after it. */\n  behavior?: AutolinkBehavior\n  /** The link's properties, as hast names them; `ariaHidden` and `tabIndex: -1` for `prepend` and `append` when left out. */\n  properties?: Record<string, unknown> | null\n  /** hast content of the link, one node or a list; `<span class=\"icon icon-link\">` when left out, except for `wrap`, which appends it to the heading's content. */\n  content?: unknown\n  /** A hast element wrapping the heading and its link, for `before` and `after`. */\n  group?: unknown\n  /** Properties set on each linked heading. */\n  headingProperties?: Record<string, unknown> | null\n  /** The tag names of the headings to link; every heading when left out. */\n  test?: TagNames | null\n}\n\n/** Where `autolink` puts each heading's link. */\nexport type AutolinkBehavior = \"prepend\" | \"append\" | \"wrap\" | \"before\" | \"after\"\n\n/** One tag name or several. */\nexport type TagNames = string | string[]\n\n/** `html.externalLinks`: `rel`, `target` and more on links to other sites, as rehype-external-links adds them; options named as it names them, JSON values only. */\nexport interface ExternalLinksOptions {\n  /** The `target` of each external link, such as `_blank`. */\n  target?: string | null\n  /** The `rel` of each external link: a list, or tokens separated by white space; `nofollow` when left out or empty, none for an empty list. */\n  rel?: Tokens | null\n  /** The protocols of absolute URLs that count as external; `http` and `https` when left out. A protocol-relative `//…` URL always counts. */\n  protocols?: string[] | null\n  /** More properties for each external link, as hast names them. */\n  properties?: Record<string, unknown> | null\n  /** hast content appended to each external link in a `<span>`: one node or a list. */\n  content?: unknown\n  /** The properties of that `<span>`. */\n  contentProperties?: Record<string, unknown> | null\n}\n\n/** Tokens: a list, or one string of them separated by white space. */\nexport type Tokens = string | string[]\n\n/** `html.extractToc`: the headings, nested by rank, as the file's `data.toc`, as @stefanprobst/rehype-extract-toc stores them. */\nexport interface ExtractTocOptions {\n  /** Attributes, such as `data-toc-hidden`, that keep a heading out of the table of contents; what would nest under it nests under the heading before. @default [] */\n  skip?: string[]\n}\n\n/** `html.highlight`: code blocks colored as Shiki colors them, natively by giallo; options named as @shikijs/rehype names them. */\nexport interface HighlightOptions {\n  /** The theme of each color mode, `light` first, as `{\"light\": …, \"dark\": …}`. */\n  themes?: Record<string, unknown> | null\n  /** The one theme, when `themes` is not given. */\n  theme?: string | null\n  /** The language of a block that names none; such a block is left alone without it. */\n  defaultLanguage?: string | null\n  /** The language of a block naming one Shiki does not know; left alone without it. */\n  fallbackLanguage?: string | null\n  /** Colors to replace, by their lowercase spelling: a color for every theme, or a theme's name to a map of its own. */\n  colorReplacements?: Record<string, ColorReplacement>\n  /** Add `language-<name>` to each highlighted `<code>`. @default false */\n  addLanguageClass?: boolean\n  /** Highlight inline code too, by how it names its language: `tailing-curly-colon` reads `` `a(){:js}` ``. */\n  inline?: InlineCode | null\n  /** The `<pre>` property that gets a block's meta, the text after its language; the JSON stand-in for `parseMetaString: meta => ({ [name]: meta })`. */\n  metaProperty?: string | null\n  /** The transformers of @shikijs/transformers to run, in order, by name or with options. */\n  transformers?: HighlightTransformer[]\n  /** Lines at least this long, in UTF-16 units, are left one plain token as Shiki's own option leaves them; 2,000 when left out, where Shiki has no limit, since a grammar's time grows with the square of a line's length. `0` lifts it. */\n  tokenizeMaxLineLength?: number | null\n}\n\n/** A replacement color, or a theme's own replacements. */\nexport type ColorReplacement = string | Record<string, string>\n\n/** How inline code names its language. */\nexport type InlineCode = \"tailing-curly-colon\"\n\n/** A transformer of @shikijs/transformers: its name alone, or its name and options. */\nexport type HighlightTransformer = TransformerName | ConfiguredTransformer\n\n/** The transformers `html.highlight` runs natively. */\nexport type TransformerName = \"notationDiff\" | \"notationFocus\" | \"notationHighlight\" | \"notationErrorLevel\" | \"metaHighlight\" | \"metaWordHighlight\" | \"renderLineNumber\"\n\n/** A transformer with its options, as @shikijs/transformers names them. */\nexport type ConfiguredTransformer = { name: \"notationDiff\"; classLineAdd?: Classes | null; classLineRemove?: Classes | null; classActivePre?: Classes | null; classActiveCode?: Classes | null } | { name: \"notationFocus\"; classActiveLine?: Classes | null; classActivePre?: Classes | null; classActiveCode?: Classes | null } | { name: \"notationHighlight\"; classActiveLine?: Classes | null; classActivePre?: Classes | null; classActiveCode?: Classes | null } | { name: \"notationErrorLevel\"; classMap?: Record<string, Classes> | null; classActivePre?: Classes | null; classActiveCode?: Classes | null } | { name: \"metaHighlight\"; className?: Classes | null; zeroIndexed?: boolean } | { name: \"metaWordHighlight\"; className?: Classes | null } | { name: \"renderLineNumber\"; classLineNumber?: Classes | null; start?: number | null }\n\n/** Class names: a list, or one string of them separated by white space. */\nexport type Classes = string | string[]\n\n/** `html.katex`: math rendered as rehype-katex renders it, natively by katex-rs; options named as KaTeX names them. */\nexport interface KatexOptions {\n  /** The markup to write, both HTML and MathML by default. */\n  output?: KatexOutput | null\n  /** Put equation numbers on the left. @default false */\n  leqno?: boolean\n  /** Align display math to the left instead of centering it. @default false */\n  fleqn?: boolean\n  /** The color of math that fails to render, `#cc0000` by default. */\n  errorColor?: string | null\n  /** Macros by name, each to the TeX it expands to, as `{\"\\\\RR\": \"\\\\mathbb{R}\"}`. @default {} */\n  macros?: Record<string, string>\n  /** The thinnest a rule, such as a fraction line, is drawn, in ems. */\n  minRuleThickness?: number | null\n  /** Let `\\color` color the text after it, as LaTeX does. @default false */\n  colorIsTextColor?: boolean\n  /** What to do with input LaTeX would reject: `true` or `\"error\"` fails it, `\"warn\"` prints a warning, `false` or `\"ignore\"` (the default) accepts it. */\n  strict?: KatexStrict | null\n  /** Allow commands that can run untrusted input, such as `\\href` and `\\includegraphics`. @default false */\n  trust?: boolean\n  /** The largest a user-given size may be, in ems. */\n  maxSize?: number | null\n  /** How many macro expansions one formula may take, 1000 by default. */\n  maxExpand?: number | null\n  /** Let definitions such as `\\def` last past the formula they are in. @default false */\n  globalGroup?: boolean\n}\n\n/** The markup KaTeX writes. */\nexport type KatexOutput = \"html\" | \"mathml\" | \"htmlAndMathml\"\n\n/** How strictly KaTeX holds input to LaTeX. */\nexport type KatexStrict = boolean | KatexStrictMode\n\n/** One level of KaTeX's strictness. */\nexport type KatexStrictMode = \"ignore\" | \"warn\" | \"error\"\n\n/** `html.toMarkdown`: hast into mdast; options named as hast-util-to-mdast names them. */\nexport interface ToMarkdownOptions {\n  /** Wrap all phrasing content of the root in paragraphs, as for a whole document. @default false */\n  document?: boolean\n  /** Collapse whitespace holding a line ending to that line ending instead of a space. @default false */\n  newlines?: boolean\n  /** The text of a checked checkbox or radio, `[x]` by default. */\n  checked?: string | null\n  /** The text of an unchecked checkbox or radio, `[ ]` by default. */\n  unchecked?: string | null\n  /** The quotes `<q>` uses, an opening and closing character each, alternating by how deep it nests; `\"` by default. */\n  quotes?: string[] | null\n}\n\n/** `html.stringify`: hast into HTML; options named as hast-util-to-html names them. */\nexport interface StringifyOptions {\n  /** Write raw nodes as they are instead of escaping them. @default false */\n  allowDangerousHtml?: boolean\n  /** Leave characters that are only dangerous in some contexts, such as `` ` ``, as they are. @default false */\n  allowDangerousCharacters?: boolean\n  /** Leave characters as they are where browsers accept them though the spec does not. @default false */\n  allowParseErrors?: boolean\n  /** Write comments as bogus comments, `<?a>`. @default false */\n  bogusComments?: boolean\n  /** Close empty foreign elements, `<a />`. @default false */\n  closeEmptyElements?: boolean\n  /** Close void elements, `<br />`. @default false */\n  closeSelfClosing?: boolean\n  /** Write empty attributes as bare names, `a` rather than `a=\"\"`. @default false */\n  collapseEmptyAttributes?: boolean\n  /** Leave out tags the HTML spec lets a parser imply. @default false */\n  omitOptionalTags?: boolean\n  /** Leave attribute values unquoted where that is safe. @default false */\n  preferUnquoted?: boolean\n  /** The quote attribute values are wrapped in: `\"` or `'`. */\n  quote?: string | null\n  /** Use the other quote when the value holds more of the preferred one. @default false */\n  quoteSmart?: boolean\n  /** The space the tree is in: `html` or `svg`. */\n  space?: string | null\n  /** Leave out the space between quoted attributes. @default false */\n  tightAttributes?: boolean\n  /** Join comma-separated values with `,` rather than `, `. @default false */\n  tightCommaSeparatedLists?: boolean\n  /** Write `<!doctypehtml>`. @default false */\n  tightDoctype?: boolean\n  /** Leave out the space before `/>` when the attributes allow. @default false */\n  tightSelfClosing?: boolean\n  /** Write `<!DOCTYPE html>`. @default false */\n  upperDoctype?: boolean\n  /** The tag names of void elements, which have no closing tag. */\n  voids?: string[] | null\n}\n\n/** The `html.parse` plugin. */\nexport function parse(options?: ParseOptions): Plugin<\"html.parse\", ParseOptions> & Parser<Root> {\n  if (options === undefined) return { name: \"html.parse\" }\n  return { name: \"html.parse\", options }\n}\n\n/** The `html.raw` plugin. */\nexport function raw(options?: RawOptions): Plugin<\"html.raw\", RawOptions> {\n  if (options === undefined) return { name: \"html.raw\" }\n  return { name: \"html.raw\", options }\n}\n\n/** The `html.format` plugin. */\nexport function format(options?: FormatOptions): Plugin<\"html.format\", FormatOptions> {\n  if (options === undefined) return { name: \"html.format\" }\n  return { name: \"html.format\", options }\n}\n\n/** The `html.sanitize` plugin. */\nexport function sanitize(options?: SanitizeOptions): Plugin<\"html.sanitize\", SanitizeOptions> {\n  if (options === undefined) return { name: \"html.sanitize\" }\n  return { name: \"html.sanitize\", options }\n}\n\n/** The `html.slug` plugin. */\nexport function slug(options?: SlugOptions): Plugin<\"html.slug\", SlugOptions> {\n  if (options === undefined) return { name: \"html.slug\" }\n  return { name: \"html.slug\", options }\n}\n\n/** The `html.externalLinks` plugin. */\nexport function externalLinks(options?: ExternalLinksOptions): Plugin<\"html.externalLinks\", ExternalLinksOptions> {\n  if (options === undefined) return { name: \"html.externalLinks\" }\n  return { name: \"html.externalLinks\", options }\n}\n\n/** The `html.unwrapImages` plugin. */\nexport function unwrapImages(): Plugin<\"html.unwrapImages\"> {\n  return { name: \"html.unwrapImages\" }\n}\n\n/** The `html.extractToc` plugin. */\nexport function extractToc(options?: ExtractTocOptions): Plugin<\"html.extractToc\", ExtractTocOptions> {\n  if (options === undefined) return { name: \"html.extractToc\" }\n  return { name: \"html.extractToc\", options }\n}\n\n/** The `html.highlight` plugin. */\nexport function highlight(options?: HighlightOptions): Plugin<\"html.highlight\", HighlightOptions> {\n  if (options === undefined) return { name: \"html.highlight\" }\n  return { name: \"html.highlight\", options }\n}\n\n/** The `html.katex` plugin. */\nexport function katex(options?: KatexOptions): Plugin<\"html.katex\", KatexOptions> {\n  if (options === undefined) return { name: \"html.katex\" }\n  return { name: \"html.katex\", options }\n}\n\n/** The `html.toMarkdown` plugin. */\nexport function toMarkdown(options?: ToMarkdownOptions): Plugin<\"html.toMarkdown\", ToMarkdownOptions> {\n  if (options === undefined) return { name: \"html.toMarkdown\" }\n  return { name: \"html.toMarkdown\", options }\n}\n\n/** The `html.toNaturalLanguage` plugin. */\nexport function toNaturalLanguage(): Plugin<\"html.toNaturalLanguage\"> {\n  return { name: \"html.toNaturalLanguage\" }\n}\n\n/** The `html.stringify` plugin. */\nexport function stringify(options?: StringifyOptions): Plugin<\"html.stringify\", StringifyOptions> {\n  if (options === undefined) return { name: \"html.stringify\" }\n  return { name: \"html.stringify\", options }\n}\n"]}

package/build/generated/md.d.ts

@@ -1,4 +1,5 @@
-import type { Plugin } from "../models/plugin.ts";
+import type { Root } from "mdast";
+import type { Parser, 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. */
@@ -24,6 +25,19 @@ export interface GfmOptions {
     tablePipeAlign?: boolean;
     /** Write a footnote definition's first line blank when it holds flow content. @default false */
     firstLineBlank?: boolean;
+    /** Render GitHub alerts, a block quote opening with `[!NOTE]`, as GitHub does, as remark-github-blockquote-alert does: `true`, or its options. */
+    alerts?: Alerts | null;
+}
+/** `md.gfm`'s `alerts`: on, or on with remark-github-blockquote-alert's options. */
+export type Alerts = boolean | AlertsOptions;
+/** remark-github-blockquote-alert's options. */
+export interface AlertsOptions {
+    /** Read a title after the type, `[!NOTE/Read this]`, in place of the type's name. @default false */
+    legacyTitle?: boolean;
+    /** The tag name of the alert's element. @default "div" */
+    tagName?: string;
+    /** More classes for the alert's element, separated by spaces. @default "" */
+    classNames?: string;
 }
 /** `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 {
@@ -66,6 +80,38 @@ export interface FrontmatterSettings {
     /** Remove the YAML frontmatter a document starts with from the tree. */
     strip?: boolean;
 }
+/** `md.gemoji`: gemoji shortcodes, `:smile:`, into emoji, as remark-gemoji does; its options are remark-emoji's. */
+export interface GemojiOptions {
+    /** Also turn emoticons such as `:)` and `:-(` into emoji, as remark-emoji does. @default false */
+    emoticon?: boolean;
+    /** Wrap each emoji in `<span role="img" aria-label="…">`, labelled with its name. @default false */
+    accessible?: boolean;
+    /** Put a space after each emoji. @default false */
+    padSpaceAfter?: boolean;
+}
+/** `md.smartypants`: straight quotes, dashes, dots and backticks in Markdown text into typographic ones, as remark-smartypants does; options as retext-smartypants takes them. */
+export interface SmartypantsOptions {
+    /** Turn double backticks and double straight single quotes into double quotes; `all` turns single ones into single quotes too. */
+    backticks?: Backticks;
+    /** The closing quotes to use: `”` and `’` by default. */
+    closingQuotes?: QuoteCharacters | null;
+    /** Turn two dashes into an em dash; `oldschool` and `inverted` treat three too. */
+    dashes?: Dashes;
+    /** Turn three dots into an ellipsis, with spaces between them or without. */
+    ellipses?: Ellipses;
+    /** The opening quotes to use: `“` and `‘` by default. */
+    openingQuotes?: QuoteCharacters | null;
+    /** Turn straight quotes into smart ones. @default true */
+    quotes?: boolean | null;
+}
+export type Backticks = boolean | "all";
+/** The quote characters to use for double and single quotes. */
+export interface QuoteCharacters {
+    double: string;
+    single: string;
+}
+export type Dashes = boolean | "oldschool" | "inverted";
+export type Ellipses = boolean | "spaced" | "unspaced";
 /** `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. */
@@ -208,6 +254,13 @@ export interface PathRewriteOptions {
 export type UrlNode = "image" | "link" | "definition";
 /** How a link to a Markdown file becomes a URL. */
 export type MarkdownLinks = "keep" | "directory" | "html";
+/** `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. */
+export interface ShiftHeadingOptions {
+    /** The levels added to each heading's depth: `-1` makes an h2 an h1, `1` an h1 an h2. @default 0 */
+    shift?: number;
+    /** Drop the document's first node when it is an h1, looking past frontmatter and ESM. @default false */
+    dropTitle?: boolean;
+}
 /** `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 [] */
@@ -302,6 +355,8 @@ export interface UnsafePattern {
 export interface ToHtmlOptions {
     /** Keep raw HTML in the tree instead of dropping it. @default false */
     allowDangerousHtml?: boolean;
+    /** Turn each line ending in text into a `<br>`, as remark-breaks does. @default false */
+    breaks?: 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. */
@@ -332,7 +387,7 @@ export interface ToNaturalLanguageOptions {
     source?: string[];
 }
 /** The `md.parse` plugin. */
-export declare function parse(options?: ParseOptions): Plugin<"md.parse", ParseOptions>;
+export declare function parse(options?: ParseOptions): Plugin<"md.parse", ParseOptions> & Parser<Root>;
 /** The `md.directive` plugin. */
 export declare function directive(options?: DirectiveOptions): Plugin<"md.directive", DirectiveOptions>;
 /** The `md.gfm` plugin. */
@@ -345,8 +400,12 @@ export declare function math(options?: MathOptions): Plugin<"md.math", MathOptio
 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.cjkFriendly` plugin. */
+export declare function cjkFriendly(): Plugin<"md.cjkFriendly">;
 /** The `md.gemoji` plugin. */
-export declare function gemoji(): Plugin<"md.gemoji">;
+export declare function gemoji(options?: GemojiOptions): Plugin<"md.gemoji", GemojiOptions>;
+/** The `md.smartypants` plugin. */
+export declare function smartypants(options?: SmartypantsOptions): Plugin<"md.smartypants", SmartypantsOptions>;
 /** The `md.component` plugin. */
 export declare function component(options?: ComponentOptions): Plugin<"md.component", ComponentOptions>;
 /** The `md.packageCommand` plugin. */
@@ -355,6 +414,8 @@ export declare function packageCommand(options?: PackageCommandOptions): 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.shiftHeading` plugin. */
+export declare function shiftHeading(options?: ShiftHeadingOptions): Plugin<"md.shiftHeading", ShiftHeadingOptions>;
 /** The `md.strip` plugin. */
 export declare function strip(options?: StripOptions): Plugin<"md.strip", StripOptions>;
 /** The `md.toc` plugin. */