textlane 0.0.0 → 0.1.0

package/build/generated/html.d.ts

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

package/build/generated/html.js

@@ -0,0 +1,74 @@
+// Generated by `pnpm generate:bindings` from the crate's plugins; do not edit.
+/** The `html.parse` plugin. */
+export function parse(options) {
+    if (options === undefined)
+        return { name: "html.parse" };
+    return { name: "html.parse", options };
+}
+/** The `html.raw` plugin. */
+export function raw(options) {
+    if (options === undefined)
+        return { name: "html.raw" };
+    return { name: "html.raw", options };
+}
+/** The `html.format` plugin. */
+export function format(options) {
+    if (options === undefined)
+        return { name: "html.format" };
+    return { name: "html.format", options };
+}
+/** The `html.sanitize` plugin. */
+export function sanitize(options) {
+    if (options === undefined)
+        return { name: "html.sanitize" };
+    return { name: "html.sanitize", options };
+}
+/** The `html.slug` plugin. */
+export function slug(options) {
+    if (options === undefined)
+        return { name: "html.slug" };
+    return { name: "html.slug", options };
+}
+/** The `html.externalLinks` plugin. */
+export function externalLinks(options) {
+    if (options === undefined)
+        return { name: "html.externalLinks" };
+    return { name: "html.externalLinks", options };
+}
+/** The `html.unwrapImages` plugin. */
+export function unwrapImages() {
+    return { name: "html.unwrapImages" };
+}
+/** The `html.extractToc` plugin. */
+export function extractToc() {
+    return { name: "html.extractToc" };
+}
+/** The `html.highlight` plugin. */
+export function highlight(options) {
+    if (options === undefined)
+        return { name: "html.highlight" };
+    return { name: "html.highlight", options };
+}
+/** The `html.katex` plugin. */
+export function katex(options) {
+    if (options === undefined)
+        return { name: "html.katex" };
+    return { name: "html.katex", options };
+}
+/** The `html.toMarkdown` plugin. */
+export function toMarkdown(options) {
+    if (options === undefined)
+        return { name: "html.toMarkdown" };
+    return { name: "html.toMarkdown", options };
+}
+/** The `html.toNaturalLanguage` plugin. */
+export function toNaturalLanguage() {
+    return { name: "html.toNaturalLanguage" };
+}
+/** The `html.stringify` plugin. */
+export function stringify(options) {
+    if (options === undefined)
+        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.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}\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\" | \"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: \"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(): Plugin<\"html.extractToc\"> {\n  return { name: \"html.extractToc\" }\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"]}