Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

feat(open-knowledge): footnote bubble-menu trigger (#1645)

Abraham5a4c08de4891
diff --git a/packages/app/src/editor/bubble-menu/BubbleMenuBar.tsx b/packages/app/src/editor/bubble-menu/BubbleMenuBar.tsx
index 68e967c96..c5a9d3334 100644
--- a/packages/app/src/editor/bubble-menu/BubbleMenuBar.tsx
+++ b/packages/app/src/editor/bubble-menu/BubbleMenuBar.tsx
@@ -9,6 +9,7 @@ import { getFindReplaceState } from '../find-replace/tiptap-find-replace-extensi
import { BlockTypeSelector } from './BlockTypeSelector';
import { EditWithAiBubbleButton } from './EditWithAiBubbleButton';
import { FileBubbleButtons, isFileNodeSelected } from './FileBubbleButtons';
+import { FootnoteBubbleButton } from './FootnoteBubbleButton';
import { ImageAlignButtons, isImageNodeSelected } from './ImageAlignButtons';
import { InlineFormatButtons } from './InlineFormatButtons';
import { LinkEditPopover } from './LinkEditPopover';
@@ -106,6 +107,7 @@ export function BubbleMenuBar({
<InlineFormatButtons key={tooltipKey} editor={editor} />
<Separator orientation="vertical" className="mx-0.5 h-5 data-vertical:self-center" />
<LinkEditPopover key={`${tooltipKey}-link`} editor={editor} />
+ <FootnoteBubbleButton key={`${tooltipKey}-footnote`} editor={editor} />
<EditWithAiBubbleButton
key={`${tooltipKey}-edit-ai`}
editor={editor}
diff --git a/packages/app/src/editor/bubble-menu/FootnoteBubbleButton.dom.test.tsx b/packages/app/src/editor/bubble-menu/FootnoteBubbleButton.dom.test.tsx
new file mode 100644
index 000000000..300f419d9
--- /dev/null
+++ b/packages/app/src/editor/bubble-menu/FootnoteBubbleButton.dom.test.tsx
@@ -0,0 +1,105 @@
+import { describe, expect, test } from 'bun:test';
+import { cleanup, render } from '@testing-library/react';
+import type { Editor } from '@tiptap/react';
+import { TooltipProvider } from '@/components/ui/tooltip';
+import { FootnoteBubbleButton } from './FootnoteBubbleButton';
+
+interface FakeEditorOpts {
+ hasSchema?: boolean;
+ emptySelection?: boolean;
+ selectionContainsRef?: boolean;
+ selectionCrossesBlocks?: boolean;
+}
+
+function makeEditor(opts: FakeEditorOpts = {}): Editor {
+ const {
+ hasSchema = true,
+ emptySelection = false,
+ selectionContainsRef = false,
+ selectionCrossesBlocks = false,
+ } = opts;
+
+ const nodes: Record<string, unknown> = {};
+ if (hasSchema) {
+ nodes.footnoteReference = {};
+ nodes.footnoteDefinition = {};
+ }
+
+ const parentA = { someParentToken: 'A' };
+ const parentB = { someParentToken: 'B' };
+
+ const selection = {
+ empty: emptySelection,
+ from: 5,
+ to: 10,
+ $from: { sameParent: (other: { someParentToken: string }) => other === parentA },
+ $to: selectionCrossesBlocks ? parentB : parentA,
+ };
+
+ const doc = {
+ nodesBetween: (
+ _from: number,
+ _to: number,
+ cb: (node: { type: { name: string } }) => boolean | undefined,
+ ) => {
+ if (selectionContainsRef) {
+ cb({ type: { name: 'footnoteReference' } });
+ } else {
+ cb({ type: { name: 'text' } });
+ }
+ },
+ };
+
+ return {
+ schema: { nodes },
+ state: { selection, doc },
+ on: () => {},
+ off: () => {},
+ } as unknown as Editor;
+}
+
+function renderWithProvider(editor: Editor) {
+ return render(
+ <TooltipProvider>
+ <FootnoteBubbleButton editor={editor} />
+ </TooltipProvider>,
+ );
+}
+
+function findButton(container: HTMLElement): HTMLButtonElement {
+ const btn = container.querySelector<HTMLButtonElement>('[data-testid="footnote-bubble-button"]');
+ if (!btn) throw new Error('button not rendered');
+ return btn;
+}
+
+describe('FootnoteBubbleButton — disabled gating', () => {
+ test('disabled when schema lacks footnoteReference / footnoteDefinition', () => {
+ const { container } = renderWithProvider(makeEditor({ hasSchema: false }));
+ expect(findButton(container).disabled).toBe(true);
+ cleanup();
+ });
+
+ test('disabled when selection is empty', () => {
+ const { container } = renderWithProvider(makeEditor({ emptySelection: true }));
+ expect(findButton(container).disabled).toBe(true);
+ cleanup();
+ });
+
+ test('disabled when selection spans an existing footnoteReference atom', () => {
+ const { container } = renderWithProvider(makeEditor({ selectionContainsRef: true }));
+ expect(findButton(container).disabled).toBe(true);
+ cleanup();
+ });
+
+ test('disabled when selection crosses textblock boundaries', () => {
+ const { container } = renderWithProvider(makeEditor({ selectionCrossesBlocks: true }));
+ expect(findButton(container).disabled).toBe(true);
+ cleanup();
+ });
+
+ test('enabled when schema present + non-empty single-block selection without refs', () => {
+ const { container } = renderWithProvider(makeEditor());
+ expect(findButton(container).disabled).toBe(false);
+ cleanup();
+ });
+});
diff --git a/packages/app/src/editor/bubble-menu/FootnoteBubbleButton.tsx b/packages/app/src/editor/bubble-menu/FootnoteBubbleButton.tsx
new file mode 100644
index 000000000..7b350047d
--- /dev/null
+++ b/packages/app/src/editor/bubble-menu/FootnoteBubbleButton.tsx
@@ -0,0 +1,107 @@
+import {
+ collectFootnoteIdentifiers,
+ findFootnoteDefinitionInsertPos,
+ nextFootnoteIdentifier,
+} from '@inkeep/open-knowledge-core';
+import { useLingui } from '@lingui/react/macro';
+import type { Editor } from '@tiptap/react';
+import { useEditorState } from '@tiptap/react';
+import { Superscript } from 'lucide-react';
+import type { ReactNode } from 'react';
+import { Button } from '@/components/ui/button';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
+
+function hasFootnoteSchema(editor: Editor): boolean {
+ const nodes = editor.schema.nodes;
+ return Boolean(nodes.footnoteReference && nodes.footnoteDefinition);
+}
+
+function selectionContainsFootnoteRef(editor: Editor): boolean {
+ const { from, to } = editor.state.selection;
+ let found = false;
+ editor.state.doc.nodesBetween(from, to, (node) => {
+ if (node.type.name === 'footnoteReference') {
+ found = true;
+ return false;
+ }
+ return true;
+ });
+ return found;
+}
+
+function selectionCrossesBlocks(editor: Editor): boolean {
+ const { $from, $to } = editor.state.selection;
+ return !$from.sameParent($to);
+}
+
+export function FootnoteBubbleButton({ editor }: { editor: Editor }): ReactNode {
+ const { t } = useLingui();
+
+ const disabled = useEditorState({
+ editor,
+ selector: (ctx) => {
+ const ed = ctx.editor;
+ if (!hasFootnoteSchema(ed)) return true;
+ if (ed.state.selection.empty) return true;
+ if (selectionCrossesBlocks(ed)) return true;
+ if (selectionContainsFootnoteRef(ed)) return true;
+ return false;
+ },
+ });
+
+ const wrapSelection = (): void => {
+ if (disabled) return;
+
+ if (!hasFootnoteSchema(editor)) return;
+ if (editor.state.selection.empty) return;
+ if (selectionCrossesBlocks(editor)) return;
+ if (selectionContainsFootnoteRef(editor)) return;
+
+ const { from, to } = editor.state.selection;
+ const selectedText = editor.state.doc.textBetween(from, to, ' ');
+ if (!selectedText.trim()) return;
+
+ const id = nextFootnoteIdentifier(collectFootnoteIdentifiers(editor.state.doc));
+
+ const preChainInsertPos = findFootnoteDefinitionInsertPos(editor.state.doc);
+ const insertAt = preChainInsertPos + 1 - (to - from);
+
+ editor
+ .chain()
+ .focus()
+ .deleteSelection()
+ .insertFootnoteReference(id)
+ .insertContentAt(insertAt, {
+ type: 'footnoteDefinition',
+ attrs: { identifier: id, label: id },
+ content: [{ type: 'paragraph', content: [{ type: 'text', text: selectedText }] }],
+ })
+ .run();
+ };
+
+ return (
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <Button
+ type="button"
+ variant="ghost"
+ size="icon-xs"
+ data-testid="footnote-bubble-button"
+ className="text-accent-foreground/80"
+ aria-label={t`Convert selection to footnote`}
+ onMouseDown={(e) => {
+ e.preventDefault();
+ wrapSelection();
+ }}
+ disabled={disabled}
+ >
+ <Superscript className="size-3.5" aria-hidden="true" />
+ </Button>
+ </TooltipTrigger>
+ <TooltipContent
+ side="bottom"
+ sideOffset={8}
+ >{t`Convert selection to footnote`}</TooltipContent>
+ </Tooltip>
+ );
+}
diff --git a/packages/app/src/editor/slash-command/items.tsx b/packages/app/src/editor/slash-command/items.tsx
index 60f2066d6..4e8887167 100644
--- a/packages/app/src/editor/slash-command/items.tsx
+++ b/packages/app/src/editor/slash-command/items.tsx
@@ -1,3 +1,8 @@
+import {
+ collectFootnoteIdentifiers,
+ findFootnoteDefinitionInsertPos,
+ nextFootnoteIdentifier,
+} from '@inkeep/open-knowledge-core';
import { t } from '@lingui/core/macro';
import { Trans } from '@lingui/react/macro';
import type { Editor } from '@tiptap/react';
@@ -254,22 +259,13 @@ export function getSlashCommandItems(): SlashCommandItem[] {
icon: Superscript,
category: 'insert',
command: (editor) => {
- let maxId = 0;
- editor.state.doc.descendants((node) => {
- if (node.type.name === 'footnoteDefinition') {
- const id = String(node.attrs.identifier ?? '');
- const n = Number.parseInt(id, 10);
- if (!Number.isNaN(n) && n > maxId) maxId = n;
- }
- return true;
- });
- const next = String(maxId + 1);
- const docEnd = editor.state.doc.content.size;
+ const next = nextFootnoteIdentifier(collectFootnoteIdentifiers(editor.state.doc));
+ const insertAt = findFootnoteDefinitionInsertPos(editor.state.doc) + 1;
editor
.chain()
.focus()
.insertFootnoteReference(next)
- .insertContentAt(docEnd + 1, {
+ .insertContentAt(insertAt, {
type: 'footnoteDefinition',
attrs: { identifier: next, label: next },
content: [{ type: 'paragraph' }],
diff --git a/packages/app/src/globals.css b/packages/app/src/globals.css
index 21f6b4efe..1d477d6f1 100644
--- a/packages/app/src/globals.css
+++ b/packages/app/src/globals.css
@@ -3029,17 +3029,29 @@ html.electron-mode [data-slot="sidebar-inner"] {
}
/* Visual divider above the first footnote in the document — separates
- * the footnote list from the prose body. The selector targets any
- * `.footnote-def` that is NOT preceded by another `.footnote-def` (i.e.
- * the first footnote-def regardless of intervening siblings). Class-
- * keyed rather than `:first-of-type` because `commentBlock` also renders
- * as `<aside>` (see `core/src/extensions/comment-block.ts`) — a comment
- * block before the first footnote would otherwise hide the divider. */
-.footnote-def:not(.footnote-def + .footnote-def) {
+ * the footnote list from the prose body. CSS has no native "first-of-
+ * class" selector, so we apply the divider to ALL `.footnote-def` and
+ * then UN-apply it on any `.footnote-def` that has a prior
+ * `.footnote-def` SIBLING anywhere earlier in the parent. The general-
+ * sibling combinator (`~`) matches across intervening non-footnote
+ * elements — PM inserts `<p class="ok-chunk-wrapper">` chunks between
+ * every block-level node, so the adjacent-sibling combinator (`+`)
+ * would never see a `.footnote-def + .footnote-def` match in practice.
+ *
+ * Class-keyed rather than `:first-of-type` because `commentBlock` also
+ * renders as `<aside>` (see `core/src/extensions/comment-block.ts`) —
+ * a comment block before the first footnote would otherwise hide the
+ * divider. */
+.footnote-def {
margin-top: 1.5rem;
padding-top: 1rem;
border-top: 1px solid var(--border);
}
+.footnote-def ~ .footnote-def {
+ margin-top: 0.25rem;
+ padding-top: 0;
+ border-top: none;
+}
.footnote-def .footnote-body {
flex: 1;
diff --git a/packages/app/src/locales/en/messages.json b/packages/app/src/locales/en/messages.json
index 5919a9923..ac2ba3c88 100644
--- a/packages/app/src/locales/en/messages.json
+++ b/packages/app/src/locales/en/messages.json
@@ -1704,6 +1704,7 @@
". You can still create a blank note."
],
"sER-bs": ["Files"],
+ "sIGbBZ": ["Convert selection to footnote"],
"sIxSSP": ["Resolve conflict in your terminal"],
"sJK6pq": ["Permission denied"],
"sJWhgo": ["Unknown component: ", ["unregisteredComponentName"]],
diff --git a/packages/app/src/locales/en/messages.po b/packages/app/src/locales/en/messages.po
index c52d1bfdb..327d68904 100644
--- a/packages/app/src/locales/en/messages.po
+++ b/packages/app/src/locales/en/messages.po
@@ -1319,6 +1319,10 @@ msgstr "Content directory"
msgid "Content directory must be inside the project"
msgstr "Content directory must be inside the project"
+#: src/editor/bubble-menu/FootnoteBubbleButton.tsx
+msgid "Convert selection to footnote"
+msgstr "Convert selection to footnote"
+
#: src/lib/keyboard-shortcuts.ts
msgid "Convert the current block to a paragraph."
msgstr "Convert the current block to a paragraph."
diff --git a/packages/app/src/locales/pseudo/messages.json b/packages/app/src/locales/pseudo/messages.json
index 029368954..0951b25f8 100644
--- a/packages/app/src/locales/pseudo/messages.json
+++ b/packages/app/src/locales/pseudo/messages.json
@@ -1704,6 +1704,7 @@
". Ŷōũ ćàń śţĩĺĺ ćŕēàţē à ƀĺàńķ ńōţē."
],
"sER-bs": ["Ƒĩĺēś"],
+ "sIGbBZ": ["Ćōńvēŕţ śēĺēćţĩōń ţō ƒōōţńōţē"],
"sIxSSP": ["Ŕēśōĺvē ćōńƒĺĩćţ ĩń ŷōũŕ ţēŕḿĩńàĺ"],
"sJK6pq": ["Ƥēŕḿĩśśĩōń ďēńĩēď"],
"sJWhgo": ["Ũńķńōŵń ćōḿƥōńēńţ: ", ["unregisteredComponentName"]],
diff --git a/packages/app/src/locales/pseudo/messages.po b/packages/app/src/locales/pseudo/messages.po
index 98ef89634..a4398063f 100644
--- a/packages/app/src/locales/pseudo/messages.po
+++ b/packages/app/src/locales/pseudo/messages.po
@@ -1314,6 +1314,10 @@ msgstr ""
msgid "Content directory must be inside the project"
msgstr ""
+#: src/editor/bubble-menu/FootnoteBubbleButton.tsx
+msgid "Convert selection to footnote"
+msgstr ""
+
#: src/lib/keyboard-shortcuts.ts
msgid "Convert the current block to a paragraph."
msgstr ""
diff --git a/packages/core/src/extensions/footnote-reference.test.ts b/packages/core/src/extensions/footnote-reference.test.ts
new file mode 100644
index 000000000..269b5f8ff
--- /dev/null
+++ b/packages/core/src/extensions/footnote-reference.test.ts
@@ -0,0 +1,166 @@
+import { describe, expect, test } from 'bun:test';
+import {
+ collectFootnoteIdentifiers,
+ type FootnoteDescendableDoc,
+ type FootnoteWalkableDoc,
+ findFootnoteDefinitionInsertPos,
+ nextFootnoteIdentifier,
+} from './footnote-reference.ts';
+
+function fakeDoc(blocks: Array<{ type: string; size: number }>): FootnoteWalkableDoc {
+ return {
+ content: { size: blocks.reduce((s, b) => s + b.size, 0) },
+ forEach(cb) {
+ let offset = 0;
+ blocks.forEach((b, i) => {
+ cb({ type: { name: b.type }, nodeSize: b.size }, offset, i);
+ offset += b.size;
+ });
+ },
+ };
+}
+
+describe('nextFootnoteIdentifier', () => {
+ test('empty list → "1"', () => {
+ expect(nextFootnoteIdentifier([])).toBe('1');
+ });
+
+ test('contiguous integers → max + 1', () => {
+ expect(nextFootnoteIdentifier(['1', '2', '3'])).toBe('4');
+ });
+
+ test('non-contiguous integers → max + 1 (no gap-filling)', () => {
+ expect(nextFootnoteIdentifier(['1', '3', '5'])).toBe('6');
+ });
+
+ test('non-numeric identifiers are ignored', () => {
+ expect(nextFootnoteIdentifier(['note', 'aside', 'footnote-x'])).toBe('1');
+ });
+
+ test('mixed numeric + non-numeric → max numeric + 1', () => {
+ expect(nextFootnoteIdentifier(['1', 'note', '4', 'aside'])).toBe('5');
+ });
+
+ test('empty string / whitespace-only ids treated as non-numeric', () => {
+ expect(nextFootnoteIdentifier(['', ' ', '2'])).toBe('3');
+ });
+
+ test('negative integers do not lower the floor', () => {
+ expect(nextFootnoteIdentifier(['-3', '-1'])).toBe('1');
+ });
+
+ test('numeric-with-suffix ("3a") parses to integer prefix and counts', () => {
+ expect(nextFootnoteIdentifier(['3a', '5b'])).toBe('6');
+ });
+});
+
+describe('findFootnoteDefinitionInsertPos', () => {
+ test('empty doc → 0 (insert at very start)', () => {
+ const doc = fakeDoc([]);
+ expect(findFootnoteDefinitionInsertPos(doc)).toBe(0);
+ });
+
+ test('no footnote — returns doc end', () => {
+ const doc = fakeDoc([
+ { type: 'heading', size: 10 },
+ { type: 'paragraph', size: 20 },
+ ]);
+ expect(findFootnoteDefinitionInsertPos(doc)).toBe(30);
+ });
+
+ test('one footnote at end — returns position right after it', () => {
+ const doc = fakeDoc([
+ { type: 'heading', size: 10 },
+ { type: 'paragraph', size: 20 },
+ { type: 'footnoteDefinition', size: 15 },
+ ]);
+ expect(findFootnoteDefinitionInsertPos(doc)).toBe(45);
+ });
+
+ test('multiple consecutive footnotes — returns end of LAST', () => {
+ const doc = fakeDoc([
+ { type: 'paragraph', size: 10 },
+ { type: 'footnoteDefinition', size: 5 },
+ { type: 'footnoteDefinition', size: 7 },
+ { type: 'footnoteDefinition', size: 4 },
+ ]);
+ expect(findFootnoteDefinitionInsertPos(doc)).toBe(26);
+ });
+
+ test('footnote followed by non-footnote — returns end of footnote (NOT doc end)', () => {
+ const doc = fakeDoc([
+ { type: 'heading', size: 10 },
+ { type: 'footnoteDefinition', size: 12 },
+ { type: 'paragraph', size: 2 }, // trailing empty p
+ ]);
+ expect(findFootnoteDefinitionInsertPos(doc)).toBe(22);
+ });
+
+ test('footnote mid-doc with trailing content — uses end of LAST footnote', () => {
+ const doc = fakeDoc([
+ { type: 'paragraph', size: 5 },
+ { type: 'footnoteDefinition', size: 3 },
+ { type: 'paragraph', size: 4 },
+ { type: 'footnoteDefinition', size: 6 },
+ { type: 'paragraph', size: 2 }, // trailing empty p
+ ]);
+ expect(findFootnoteDefinitionInsertPos(doc)).toBe(18);
+ });
+});
+
+describe('collectFootnoteIdentifiers', () => {
+ function fakeDescendable(
+ nodes: Array<{ type: string; identifier?: unknown }>,
+ ): FootnoteDescendableDoc {
+ return {
+ descendants(cb) {
+ let pos = 0;
+ for (const n of nodes) {
+ cb({ type: { name: n.type }, attrs: { identifier: n.identifier } }, pos);
+ pos += 1;
+ }
+ },
+ };
+ }
+
+ test('empty doc → empty array', () => {
+ expect(collectFootnoteIdentifiers(fakeDescendable([]))).toEqual([]);
+ });
+
+ test('skips non-footnoteDefinition nodes', () => {
+ const doc = fakeDescendable([
+ { type: 'paragraph' },
+ { type: 'heading' },
+ { type: 'footnoteDefinition', identifier: '1' },
+ { type: 'paragraph' },
+ ]);
+ expect(collectFootnoteIdentifiers(doc)).toEqual(['1']);
+ });
+
+ test('preserves doc order across multiple footnotes', () => {
+ const doc = fakeDescendable([
+ { type: 'footnoteDefinition', identifier: '3' },
+ { type: 'footnoteDefinition', identifier: '1' },
+ { type: 'footnoteDefinition', identifier: 'note' },
+ ]);
+ expect(collectFootnoteIdentifiers(doc)).toEqual(['3', '1', 'note']);
+ });
+
+ test('coerces null / missing identifier to empty string', () => {
+ const doc = fakeDescendable([
+ { type: 'footnoteDefinition', identifier: null },
+ { type: 'footnoteDefinition' },
+ { type: 'footnoteDefinition', identifier: '2' },
+ ]);
+ expect(collectFootnoteIdentifiers(doc)).toEqual(['', '', '2']);
+ });
+
+ test('round-trips into nextFootnoteIdentifier', () => {
+ const doc = fakeDescendable([
+ { type: 'paragraph' },
+ { type: 'footnoteDefinition', identifier: '1' },
+ { type: 'footnoteDefinition', identifier: '2' },
+ ]);
+ expect(nextFootnoteIdentifier(collectFootnoteIdentifiers(doc))).toBe('3');
+ });
+});
diff --git a/packages/core/src/extensions/footnote-reference.ts b/packages/core/src/extensions/footnote-reference.ts
index b225f8536..dd522b730 100644
--- a/packages/core/src/extensions/footnote-reference.ts
+++ b/packages/core/src/extensions/footnote-reference.ts
@@ -8,6 +8,52 @@ declare module '@tiptap/core' {
}
}
+export function nextFootnoteIdentifier(existingIdentifiers: readonly string[]): string {
+ let maxId = 0;
+ for (const id of existingIdentifiers) {
+ const n = Number.parseInt(id, 10);
+ if (!Number.isNaN(n) && n > maxId) maxId = n;
+ }
+ return String(maxId + 1);
+}
+
+export interface FootnoteWalkableDoc {
+ forEach(
+ f: (node: { type: { name: string }; nodeSize: number }, offset: number, index: number) => void,
+ ): void;
+ content: { size: number };
+}
+
+export interface FootnoteDescendableDoc {
+ descendants(
+ f: (
+ node: { type: { name: string }; attrs: { identifier?: unknown } },
+ pos: number,
+ ) => boolean | undefined,
+ ): void;
+}
+
+export function collectFootnoteIdentifiers(doc: FootnoteDescendableDoc): string[] {
+ const ids: string[] = [];
+ doc.descendants((node) => {
+ if (node.type.name === 'footnoteDefinition') {
+ ids.push(String(node.attrs.identifier ?? ''));
+ }
+ return true;
+ });
+ return ids;
+}
+
+export function findFootnoteDefinitionInsertPos(doc: FootnoteWalkableDoc): number {
+ let pos: number | null = null;
+ doc.forEach((node, offset) => {
+ if (node.type.name === 'footnoteDefinition') {
+ pos = offset + node.nodeSize;
+ }
+ });
+ return pos ?? doc.content.size;
+}
+
export const FootnoteReference = Node.create({
name: 'footnoteReference',
group: 'inline',
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index ce580297e..8532d869d 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -227,6 +227,13 @@ export {
export { CodeBlockFidelity } from './extensions/code-block-fidelity.ts';
export { EmphasisFidelity, StrongFidelity } from './extensions/emphasis-fidelity.ts';
export { EscapeMark } from './extensions/escape-mark.ts';
+export { FootnoteDefinition } from './extensions/footnote-definition.ts';
+export {
+ collectFootnoteIdentifiers,
+ FootnoteReference,
+ findFootnoteDefinitionInsertPos,
+ nextFootnoteIdentifier,
+} from './extensions/footnote-reference.ts';
export {
FRONTMATTER_RE,
prependFrontmatter,