@riebeckite/plugin-sidenotes 0.0.5

package/dist/index.js

@@ -0,0 +1,504 @@
+// index.ts
+import {
+  createClientEntry,
+  createStyleAsset,
+  definePlugin
+} from "@riebeckite/core";
+
+// src/options.ts
+var DEFAULT_SIDENOTES_ARIA_LABEL = "Sidenote";
+var DEFAULT_SIDENOTES_OPEN_LABEL = "Footnote";
+var DEFAULT_SIDENOTES_CLOSE_LABEL = "Close sidenote";
+var DEFAULT_SIDENOTES_POPOVER_ALIGNMENT = "bottom";
+function resolveSidenotesOptions(options = {}) {
+  return {
+    className: normalizeNonEmpty(options.className, ""),
+    ariaLabel: normalizeNonEmpty(
+      options.ariaLabel,
+      DEFAULT_SIDENOTES_ARIA_LABEL
+    ),
+    openLabel: normalizeNonEmpty(
+      options.openLabel,
+      DEFAULT_SIDENOTES_OPEN_LABEL
+    ),
+    closeLabel: normalizeNonEmpty(
+      options.closeLabel,
+      DEFAULT_SIDENOTES_CLOSE_LABEL
+    ),
+    popoverAlignment: normalizePopoverAlignment(
+      options.popoverAlignment,
+      DEFAULT_SIDENOTES_POPOVER_ALIGNMENT
+    )
+  };
+}
+function normalizeNonEmpty(value, fallback) {
+  if (typeof value !== "string") return fallback;
+  const trimmed = value.trim();
+  return trimmed === "" ? fallback : trimmed;
+}
+function normalizePopoverAlignment(value, fallback) {
+  return value === "end" ? "end" : value === "bottom" ? "bottom" : fallback;
+}
+
+// src/render.ts
+import { escapeHtml, escapeHtmlAttribute } from "@riebeckite/core";
+var SIDENOTES_TOGGLE_CLASS = "rr-sidenotes__toggle";
+var SIDENOTES_NOTE_CLASS = "rr-sidenotes__note";
+var SIDENOTES_POPOVER_PREFIX = "rr-sidenotes__note--popover-";
+var SIDENOTES_INDEX_CLASS = "rr-sidenotes__index";
+var SIDENOTES_BODY_CLASS = "rr-sidenotes__body";
+var SIDENOTES_FOOTNOTES_CLASS = "rr-sidenotes__footnotes";
+var SIDENOTES_NOTE_ID_PREFIX = "rr-sidenotes-";
+var FOOTNOTE_HREF_PREFIX = "#user-content-fn-";
+function sidenotesKey(href) {
+  if (href.startsWith(FOOTNOTE_HREF_PREFIX)) {
+    return href.slice(FOOTNOTE_HREF_PREFIX.length);
+  }
+  const marker = href.lastIndexOf("-fn-");
+  return marker === -1 ? null : href.slice(marker + "-fn-".length);
+}
+function sidenotesNoteId(key) {
+  return `${SIDENOTES_NOTE_ID_PREFIX}${key}`;
+}
+function renderSidenotesReference(input) {
+  const { href, id, index, options } = input;
+  const key = sidenotesKey(href) ?? "";
+  const label = `${options.openLabel} ${index}`.trim();
+  return `<a href="${escapeHtmlAttribute(href)}" id="${escapeHtmlAttribute(id)}" class="${SIDENOTES_TOGGLE_CLASS}" data-rr-sidenotes-ref aria-expanded="false" aria-controls="${escapeHtmlAttribute(sidenotesNoteId(key))}" aria-label="${escapeHtmlAttribute(label)}">${escapeHtml(index)}</a>`;
+}
+function renderSidenotesNote(input) {
+  const { key, index, bodyHtml, options } = input;
+  const className = [
+    SIDENOTES_NOTE_CLASS,
+    `${SIDENOTES_POPOVER_PREFIX}${options.popoverAlignment}`,
+    ...options.className === "" ? [] : [options.className]
+  ].join(" ");
+  const label = `${options.ariaLabel} ${index}`.trim();
+  return `<aside class="${escapeHtmlAttribute(className)}" id="${escapeHtmlAttribute(sidenotesNoteId(key))}" data-rr-sidenotes-note aria-label="${escapeHtmlAttribute(label)}" tabindex="-1"><span class="${SIDENOTES_INDEX_CLASS}" aria-hidden="true">${escapeHtml(index)}</span><div class="${SIDENOTES_BODY_CLASS}">${bodyHtml}</div></aside>`;
+}
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function renderHastChildren(children) {
+  return children.map(renderHastNode).join("");
+}
+function renderHastNode(node) {
+  if (node.type === "text" && typeof node.value === "string") {
+    return escapeHtml(node.value);
+  }
+  if (node.type === "raw" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "comment" && typeof node.value === "string") {
+    return `<!--${node.value}-->`;
+  }
+  if (node.type !== "element") return "";
+  const { tagName, properties, children = [] } = node;
+  const attributes = renderHastAttributes(properties);
+  const content = renderHastChildren(children);
+  if (VOID_ELEMENTS.has(tagName)) return `<${tagName}${attributes}>`;
+  return `<${tagName}${attributes}>${content}</${tagName}>`;
+}
+function renderHastAttributes(properties) {
+  if (!properties) return "";
+  let result = "";
+  for (const [name, value] of Object.entries(properties)) {
+    if (value === null || value === void 0) continue;
+    const attributeName = name === "className" ? "class" : hyphenateAttribute(name);
+    result += ` ${attributeName}`;
+    if (value === false) continue;
+    if (value === true) {
+      result += '=""';
+      continue;
+    }
+    const stringValue = Array.isArray(value) ? value.filter((entry) => entry !== null && entry !== void 0).join(" ") : String(value);
+    result += `="${escapeHtmlAttribute(stringValue)}"`;
+  }
+  return result;
+}
+function hyphenateAttribute(name) {
+  return name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+
+// src/rehype.ts
+var FOOTNOTE_REFERENCE_ATTRIBUTE = "dataFootnoteRef";
+var FOOTNOTES_SECTION_ATTRIBUTE = "dataFootnotes";
+var FOOTNOTE_ID_PREFIX_PATTERN = /^(?:user-content-)?fn-(.+)$/;
+var BLOCK_TAG_NAMES = /* @__PURE__ */ new Set([
+  "article",
+  "aside",
+  "blockquote",
+  "dd",
+  "div",
+  "dl",
+  "dt",
+  "figcaption",
+  "figure",
+  "footer",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "li",
+  "main",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "ul"
+]);
+var SIDENOTES_REF_CLASS = "rr-sidenotes__ref";
+function rehypeSidenotes(options = {}) {
+  const resolved = resolveSidenotesOptions(options);
+  return (tree) => {
+    transformSidenotes(tree, resolved);
+  };
+}
+function transformSidenotes(tree, options) {
+  const section = findFootnoteSection(tree);
+  if (!section) return;
+  const notes = collectFootnoteNotes(section);
+  if (notes.size === 0) return;
+  addClassName(section, SIDENOTES_FOOTNOTES_CLASS);
+  const insertions = [];
+  walkElements(tree, [], (ref, parent, index, ancestors) => {
+    if (!isFootnoteReference(ref)) return;
+    const href = getStringProperty(ref, "href");
+    if (!href) return;
+    const key = sidenotesKey(href);
+    if (!key) return;
+    const note = notes.get(key);
+    if (!note) return;
+    const noteIndex = getTextContent(ref);
+    const toggleHtml = renderSidenotesReference({
+      href,
+      id: getStringProperty(ref, "id") ?? "",
+      index: noteIndex,
+      options
+    });
+    if (parent.tagName === "sup") {
+      addClassName(parent, SIDENOTES_REF_CLASS);
+      (parent.children ?? []).splice(index, 1, rawNode(toggleHtml));
+    } else {
+      (parent.children ?? []).splice(
+        index,
+        1,
+        rawNode(`<sup class="${SIDENOTES_REF_CLASS}">${toggleHtml}</sup>`)
+      );
+    }
+    if (note.used) return;
+    const { container, parent: containerParent } = findBlockContainer(
+      parent,
+      ancestors
+    );
+    if (!containerParent) return;
+    note.used = true;
+    note.index = noteIndex;
+    const noteHtml = renderSidenotesNote({
+      key,
+      index: noteIndex,
+      bodyHtml: note.bodyHtml,
+      options
+    });
+    let insertion = insertions.find((entry) => entry.container === container);
+    if (!insertion) {
+      insertion = { parent: containerParent, container, htmls: [] };
+      insertions.push(insertion);
+    }
+    insertion.htmls.push(noteHtml);
+  });
+  applyInsertions(insertions);
+}
+function findFootnoteSection(node) {
+  if (node.type === "element" && node.tagName === "section" && hasProperty(node, FOOTNOTES_SECTION_ATTRIBUTE)) {
+    return node;
+  }
+  for (const child of getChildren(node)) {
+    if (child.type !== "element") continue;
+    const found = findFootnoteSection(child);
+    if (found) return found;
+  }
+  return null;
+}
+function collectFootnoteNotes(section) {
+  const notes = /* @__PURE__ */ new Map();
+  const list = (section.children ?? []).find(
+    (child) => child.type === "element" && child.tagName === "ol"
+  );
+  if (!list) return notes;
+  for (const child of list.children ?? []) {
+    if (child.type !== "element" || child.tagName !== "li") continue;
+    const id = getStringProperty(child, "id") ?? "";
+    const match = FOOTNOTE_ID_PREFIX_PATTERN.exec(id);
+    if (!match) continue;
+    const key = match[1];
+    notes.set(key, {
+      key,
+      bodyHtml: renderHastChildren(
+        stripDefinitionContent(child.children ?? [])
+      ),
+      index: "",
+      used: false
+    });
+  }
+  return notes;
+}
+function stripDefinitionContent(children) {
+  const result = [];
+  for (const child of children) {
+    const stripped = stripDefinitionNode(child);
+    if (stripped) result.push(stripped);
+  }
+  const last = result[result.length - 1];
+  if (last?.type === "text") {
+    result[result.length - 1] = { type: "text", value: last.value.trimEnd() };
+  }
+  return result;
+}
+function stripDefinitionNode(node) {
+  if (node.type === "text") {
+    return node.value.trim() === "" ? null : node;
+  }
+  if (node.type !== "element") return node;
+  if (hasProperty(node, "dataFootnoteBackref")) return null;
+  return {
+    ...node,
+    children: stripDefinitionContent(node.children ?? [])
+  };
+}
+function walkElements(node, ancestors, onReference) {
+  if (node.type !== "element" && node.type !== "root") return;
+  const parent = node;
+  const children = parent.children ?? [];
+  for (let index = 0; index < children.length; index += 1) {
+    const child = children[index];
+    if (child.type !== "element") continue;
+    if (isFootnoteReference(child)) {
+      onReference(child, parent, index, ancestors);
+      continue;
+    }
+    walkElements(child, [parent, ...ancestors], onReference);
+  }
+}
+function findBlockContainer(parent, ancestors) {
+  const chain = [parent, ...ancestors];
+  for (let index = 0; index < chain.length; index += 1) {
+    if (BLOCK_TAG_NAMES.has(chain[index].tagName)) {
+      return {
+        container: chain[index],
+        parent: chain[index + 1] ?? null
+      };
+    }
+  }
+  return { container: chain[chain.length - 1], parent: null };
+}
+function applyInsertions(insertions) {
+  for (const insertion of insertions) {
+    const siblings = insertion.parent.children ?? [];
+    const index = siblings.indexOf(insertion.container);
+    if (index === -1) continue;
+    siblings.splice(index + 1, 0, ...insertion.htmls.map(rawNode));
+  }
+}
+function isFootnoteReference(node) {
+  return node.tagName === "a" && hasProperty(node, FOOTNOTE_REFERENCE_ATTRIBUTE);
+}
+function rawNode(value) {
+  return { type: "raw", value };
+}
+function addClassName(node, className) {
+  node.properties = {
+    ...node.properties,
+    className: mergeClassName(node.properties?.className, className)
+  };
+}
+function mergeClassName(current, next) {
+  const currentClass = Array.isArray(current) ? current.join(" ") : typeof current === "string" ? current : "";
+  return currentClass === "" ? next : `${currentClass} ${next}`;
+}
+function getStringProperty(node, key) {
+  const value = getProperty(node, key);
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.join(" ");
+  return null;
+}
+function hasProperty(node, key) {
+  return getProperty(node, key) !== void 0;
+}
+function getProperty(node, key) {
+  const value = node.properties?.[key];
+  if (value !== void 0) return value;
+  const hyphenated = key.replace(
+    /[A-Z]/g,
+    (letter) => `-${letter.toLowerCase()}`
+  );
+  if (hyphenated !== key) return node.properties?.[hyphenated];
+  return void 0;
+}
+function getTextContent(node) {
+  if (node.type === "text" && typeof node.value === "string") {
+    return node.value;
+  }
+  return getChildren(node).map(getTextContent).join("");
+}
+function getChildren(node) {
+  const children = node.children;
+  return Array.isArray(children) ? children : [];
+}
+
+// src/client.ts
+var DEFAULT_SELECTOR = "[data-rr-sidenotes-ref]";
+var NOTE_OPEN_CLASS = "rr-sidenotes__note--open";
+var DESKTOP_QUERY = "(min-width: 48rem)";
+var DEFAULT_OPEN_LABEL = "Footnote";
+var DEFAULT_CLOSE_LABEL = "Close sidenote";
+function initSidenotes(options = {}) {
+  const desktopQuery = window.matchMedia(DESKTOP_QUERY);
+  if (desktopQuery.matches) return;
+  const toggles = Array.from(
+    document.querySelectorAll(
+      options.selector ?? DEFAULT_SELECTOR
+    )
+  );
+  if (toggles.length === 0) return;
+  const openLabel = options.openLabel ?? DEFAULT_OPEN_LABEL;
+  const closeLabel = options.closeLabel ?? DEFAULT_CLOSE_LABEL;
+  const noteFor = (toggle) => {
+    const controls = toggle.getAttribute("aria-controls");
+    if (!controls) return null;
+    const note = document.getElementById(controls);
+    return note instanceof HTMLElement ? note : null;
+  };
+  const isInsideSidenotes = (target) => {
+    if (!target) return false;
+    for (const toggle of toggles) {
+      const note = noteFor(toggle);
+      if (toggle.contains(target) || note?.contains(target)) return true;
+    }
+    return false;
+  };
+  const setOpen = (toggle, note, open) => {
+    const index = toggle.textContent?.trim() ?? "";
+    const label = open ? `${closeLabel} ${index}`.trim() : `${openLabel} ${index}`.trim();
+    toggle.setAttribute("aria-expanded", String(open));
+    toggle.setAttribute("aria-label", label);
+    note.classList.toggle(NOTE_OPEN_CLASS, open);
+    if (open) note.focus({ preventScroll: true });
+  };
+  const closeAll = () => {
+    for (const toggle of toggles) {
+      const note = noteFor(toggle);
+      if (note?.classList.contains(NOTE_OPEN_CLASS)) {
+        setOpen(toggle, note, false);
+      }
+    }
+  };
+  for (const toggle of toggles) {
+    toggle.addEventListener("click", (event) => {
+      event.preventDefault();
+      const note = noteFor(toggle);
+      if (!note) return;
+      const isOpen = note.classList.contains(NOTE_OPEN_CLASS);
+      if (!isOpen) closeAll();
+      setOpen(toggle, note, !isOpen);
+    });
+  }
+  const onKeydown = (event) => {
+    if (event.key !== "Escape") return;
+    closeAll();
+  };
+  const onClickOutside = (event) => {
+    if (isInsideSidenotes(event.target instanceof Node ? event.target : null)) {
+      return;
+    }
+    closeAll();
+  };
+  document.addEventListener("keydown", onKeydown);
+  document.addEventListener("click", onClickOutside);
+  const onViewportChange = (event) => {
+    if (!event.matches) return;
+    closeAll();
+    document.removeEventListener("keydown", onKeydown);
+    document.removeEventListener("click", onClickOutside);
+    desktopQuery.removeEventListener("change", onViewportChange);
+  };
+  desktopQuery.addEventListener("change", onViewportChange);
+}
+
+// index.ts
+var SIDENOTES_PLUGIN_NAME = "sidenotes";
+function sidenotes(options = {}) {
+  const resolved = resolveSidenotesOptions(options);
+  return definePlugin({
+    name: SIDENOTES_PLUGIN_NAME,
+    options,
+    validateOptions: validateSidenotesOptions,
+    rehypePlugins: [() => rehypeSidenotes(resolved)],
+    assets: [createStyleAsset(SIDENOTES_PLUGIN_NAME)],
+    clientEntries: [
+      createClientEntry(SIDENOTES_PLUGIN_NAME, "initSidenotes", {
+        openLabel: resolved.openLabel,
+        closeLabel: resolved.closeLabel
+      })
+    ]
+  });
+}
+var sidenotesPlugin = sidenotes;
+function validateSidenotesOptions(options) {
+  if (!options) return [];
+  const issues = [];
+  for (const key of [
+    "className",
+    "ariaLabel",
+    "openLabel",
+    "closeLabel"
+  ]) {
+    const value = options[key];
+    if (value !== void 0 && (typeof value !== "string" || value.trim() === "")) {
+      issues.push({ path: key, message: "Expected a non-empty string." });
+    }
+  }
+  if (options.popoverAlignment !== void 0 && options.popoverAlignment !== "bottom" && options.popoverAlignment !== "end") {
+    issues.push({
+      path: "popoverAlignment",
+      message: 'Expected "bottom" or "end".'
+    });
+  }
+  return issues;
+}
+export {
+  SIDENOTES_PLUGIN_NAME,
+  initSidenotes,
+  rehypeSidenotes,
+  renderHastChildren,
+  renderSidenotesNote,
+  renderSidenotesReference,
+  resolveSidenotesOptions,
+  sidenotes,
+  sidenotesKey,
+  sidenotesNoteId,
+  sidenotesPlugin
+};

package/dist/src/client.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Mobile popover behavior for `@riebeckite/plugin-sidenotes`.
+ *
+ * Desktop margin notes are static and need no JavaScript: this entry ignores
+ * the page whenever `(min-width: 48rem)` matches and disconnects itself when
+ * the viewport crosses into the desktop layout.
+ */
+/** Public options exposed to the browser through the plugin's client entry. */
+export type SidenotesClientOptions = {
+    /** Selector for reference links. Defaults to `[data-rr-sidenotes-ref]`. */
+    selector?: string;
+    /** Accessible label prefix for a reference link while its popover is closed. */
+    openLabel?: string;
+    /** Accessible label prefix for a reference link while its popover is open. */
+    closeLabel?: string;
+};
+export declare function initSidenotes(options?: SidenotesClientOptions): void;

package/dist/src/options.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedSidenotesOptions, SidenotesOptions } from "./types.js";
+export declare const DEFAULT_SIDENOTES_ARIA_LABEL = "Sidenote";
+export declare const DEFAULT_SIDENOTES_OPEN_LABEL = "Footnote";
+export declare const DEFAULT_SIDENOTES_CLOSE_LABEL = "Close sidenote";
+export declare const DEFAULT_SIDENOTES_POPOVER_ALIGNMENT = "bottom";
+/**
+ * Applies defaults to `SidenotesOptions`. Pure and deterministic so the
+ * plugin can resolve options once and reuse them for every processed tree.
+ */
+export declare function resolveSidenotesOptions(options?: SidenotesOptions): ResolvedSidenotesOptions;

package/dist/src/rehype.d.ts

@@ -0,0 +1,2 @@
+import type { HastNode, SidenotesOptions } from "./types.js";
+export declare function rehypeSidenotes(options?: SidenotesOptions): (tree: HastNode) => void;

package/dist/src/render.d.ts

@@ -0,0 +1,49 @@
+import type { HastNode, ResolvedSidenotesOptions } from "./types.js";
+/** Feature hooks follow the `rr-sidenotes` convention from the CSS hooks doc. */
+export declare const SIDENOTES_REF_CLASS = "rr-sidenotes__ref";
+export declare const SIDENOTES_TOGGLE_CLASS = "rr-sidenotes__toggle";
+export declare const SIDENOTES_NOTE_CLASS = "rr-sidenotes__note";
+export declare const SIDENOTES_NOTE_OPEN_MODIFIER = "rr-sidenotes__note--open";
+export declare const SIDENOTES_POPOVER_PREFIX = "rr-sidenotes__note--popover-";
+export declare const SIDENOTES_INDEX_CLASS = "rr-sidenotes__index";
+export declare const SIDENOTES_BODY_CLASS = "rr-sidenotes__body";
+export declare const SIDENOTES_FOOTNOTES_CLASS = "rr-sidenotes__footnotes";
+export declare const SIDENOTES_NOTE_ID_PREFIX = "rr-sidenotes-";
+/** Extracts the footnote key from a reference href. Returns `null` when the
+ * href does not look like a footnote target. */
+export declare function sidenotesKey(href: string): string | null;
+/** Stable id shared by a sidenote and its toggles' `aria-controls`. */
+export declare function sidenotesNoteId(key: string): string;
+export type SidenotesReferenceInput = {
+    /** Existing `href` of the GFM footnote reference, kept for reachability. */
+    href: string;
+    /** Existing `id` of the GFM footnote reference, kept for back-links. */
+    id: string;
+    /** Display number already chosen by the footnote pipeline. */
+    index: string;
+    options: ResolvedSidenotesOptions;
+};
+/**
+ * Renders the inline reference link that replaces a GFM footnote reference.
+ * The surrounding `sup` is managed by the rehype transformer so it can reuse
+ * the existing wrapper when one is already present.
+ */
+export declare function renderSidenotesReference(input: SidenotesReferenceInput): string;
+export type SidenotesNoteInput = {
+    key: string;
+    index: string;
+    /** Serialized definition content (back-links stripped). */
+    bodyHtml: string;
+    options: ResolvedSidenotesOptions;
+};
+/**
+ * Renders the sidenote: a static margin note on desktop and the popover
+ * source on mobile.
+ */
+export declare function renderSidenotesNote(input: SidenotesNoteInput): string;
+/**
+ * Serializes existing hast children into the HTML embedded in a sidenote
+ * body. The output is inserted as a `raw` node and serialized verbatim, so
+ * every text value and attribute is escaped here.
+ */
+export declare function renderHastChildren(children: readonly HastNode[]): string;

package/dist/src/types.d.ts

@@ -0,0 +1,68 @@
+/** Options accepted by `sidenotes()`. */
+export type SidenotesOptions = {
+    /**
+     * Extra CSS class appended to each sidenote root, on top of
+     * `rr-sidenotes__note` and the popover modifier. Defaults to none.
+     */
+    className?: string;
+    /**
+     * Accessible name prefix for each sidenote. The rendered label is
+     * `"${ariaLabel} ${index}"`. Defaults to `"Sidenote"`.
+     */
+    ariaLabel?: string;
+    /**
+     * Accessible label prefix for a reference link while its mobile popover is
+     * closed. The rendered label is `"${openLabel} ${index}"`. Defaults to
+     * `"Footnote"`.
+     */
+    openLabel?: string;
+    /**
+     * Accessible label prefix for a reference link while its mobile popover is
+     * open. The rendered label is `"${closeLabel} ${index}"`. Defaults to
+     * `"Close sidenote"`.
+     */
+    closeLabel?: string;
+    /**
+     * Where the mobile popover is anchored. Defaults to `"bottom"` (a bottom
+     * sheet); `"end"` is a right-edge panel.
+     */
+    popoverAlignment?: "bottom" | "end";
+};
+/** `SidenotesOptions` with every default applied. */
+export type ResolvedSidenotesOptions = {
+    className: string;
+    ariaLabel: string;
+    openLabel: string;
+    closeLabel: string;
+    popoverAlignment: "bottom" | "end";
+};
+/** Minimal hast element shape the sidenotes transformer reads and emits. */
+export type HastElementNode = {
+    type: "element";
+    tagName: string;
+    properties?: Record<string, unknown>;
+    children?: HastNode[];
+};
+export type HastTextNode = {
+    type: "text";
+    value: string;
+};
+/** A raw HTML fragment emitted by the plugin and serialized verbatim. */
+export type HastRawNode = {
+    type: "raw";
+    value: string;
+};
+export type HastCommentNode = {
+    type: "comment";
+    value: string;
+};
+export type HastDoctypeNode = {
+    type: "doctype";
+    name?: string;
+};
+export type HastRootNode = {
+    type: "root";
+    children?: HastNode[];
+};
+/** Any node the sidenotes transformer may encounter in a hast tree. */
+export type HastNode = HastElementNode | HastTextNode | HastRawNode | HastCommentNode | HastDoctypeNode | HastRootNode;