@dooherceg/tiptap-controlled-editor-with-table 0.0.1

package/dist/components/tiptap-ui/color-highlight-button/color-highlight-button.js

@@ -0,0 +1,89 @@
+import { jsx as o, jsxs as S, Fragment as k } from "react/jsx-runtime";
+import { forwardRef as x, useCallback as I, useMemo as K } from "react";
+import { parseShortcutKeys as N } from "../../../lib/tiptap-utils.js";
+import { useTiptapEditor as O } from "../../../hooks/use-tiptap-editor.js";
+import { useColorHighlight as R, COLOR_HIGHLIGHT_SHORTCUT_KEY as _ } from "./use-color-highlight.js";
+import { Button as j } from "../../tiptap-ui-primitive/button/button.js";
+import { Badge as v } from "../../tiptap-ui-primitive/badge/badge.js";
+import '../../../assets/color-highlight-button.css';function E({
+  shortcutKeys: e = _
+}) {
+  return /* @__PURE__ */ o(v, { children: N({ shortcutKeys: e }) });
+}
+const G = x(
+  ({
+    editor: e,
+    highlightColor: t,
+    text: r,
+    hideWhenUnavailable: h = !1,
+    mode: u = "mark",
+    onApplied: p,
+    showShortcut: m = !1,
+    onClick: i,
+    children: g,
+    style: a,
+    ...f
+  }, b) => {
+    const { editor: H } = O(e), {
+      isVisible: y,
+      canColorHighlight: l,
+      isActive: s,
+      handleColorHighlight: n,
+      label: d,
+      shortcutKeys: C
+    } = R({
+      editor: H,
+      highlightColor: t,
+      label: r || `Toggle highlight (${t})`,
+      hideWhenUnavailable: h,
+      mode: u,
+      onApplied: p
+    }), B = I(
+      (c) => {
+        i?.(c), !c.defaultPrevented && n();
+      },
+      [n, i]
+    ), T = K(
+      () => ({
+        ...a,
+        "--highlight-color": t
+      }),
+      [t, a]
+    );
+    return y ? /* @__PURE__ */ o(
+      j,
+      {
+        type: "button",
+        "data-style": "ghost",
+        "data-active-state": s ? "on" : "off",
+        role: "button",
+        tabIndex: -1,
+        disabled: !l,
+        "data-disabled": !l,
+        "aria-label": d,
+        "aria-pressed": s,
+        tooltip: d,
+        onClick: B,
+        style: T,
+        ...f,
+        ref: b,
+        children: g ?? /* @__PURE__ */ S(k, { children: [
+          /* @__PURE__ */ o(
+            "span",
+            {
+              className: "tiptap-button-highlight",
+              style: { "--highlight-color": t }
+            }
+          ),
+          r && /* @__PURE__ */ o("span", { className: "tiptap-button-text", children: r }),
+          m && /* @__PURE__ */ o(E, { shortcutKeys: C })
+        ] })
+      }
+    ) : null;
+  }
+);
+G.displayName = "ColorHighlightButton";
+export {
+  G as ColorHighlightButton,
+  E as ColorHighlightShortcutBadge
+};

package/dist/components/tiptap-ui/color-highlight-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from './color-highlight-button';
+export * from './use-color-highlight';

package/dist/components/tiptap-ui/color-highlight-button/index.js

@@ -0,0 +1,14 @@
+import { ColorHighlightButton as i, ColorHighlightShortcutBadge as t } from "./color-highlight-button.js";
+import { COLOR_HIGHLIGHT_SHORTCUT_KEY as l, HIGHLIGHT_COLORS as H, canColorHighlight as r, isColorHighlightActive as C, pickHighlightColorsByValue as e, removeHighlight as u, shouldShowButton as O, useColorHighlight as c } from "./use-color-highlight.js";
+export {
+  l as COLOR_HIGHLIGHT_SHORTCUT_KEY,
+  i as ColorHighlightButton,
+  t as ColorHighlightShortcutBadge,
+  H as HIGHLIGHT_COLORS,
+  r as canColorHighlight,
+  C as isColorHighlightActive,
+  e as pickHighlightColorsByValue,
+  u as removeHighlight,
+  O as shouldShowButton,
+  c as useColorHighlight
+};

package/dist/components/tiptap-ui/color-highlight-button/use-color-highlight.d.ts

@@ -0,0 +1,82 @@
+import { Editor } from '@tiptap/react';
+export declare const COLOR_HIGHLIGHT_SHORTCUT_KEY = "mod+shift+h";
+export declare const HIGHLIGHT_COLORS: {
+    label: string;
+    value: string;
+    border: string;
+}[];
+export type HighlightColor = (typeof HIGHLIGHT_COLORS)[number];
+export type HighlightMode = "mark" | "node";
+/**
+ * Configuration for the color highlight functionality
+ */
+export interface UseColorHighlightConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The color to apply when toggling the highlight.
+     */
+    highlightColor?: string;
+    /**
+     * Optional label to display alongside the icon.
+     */
+    label?: string;
+    /**
+     * Whether the button should hide when the mark is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * The highlighting mode to use.
+     * - "mark": Uses the highlight mark extension (default)
+     * - "node": Uses the node background extension
+     * @default "mark"
+     */
+    mode?: HighlightMode;
+    /**
+     * Called when the highlight is applied.
+     */
+    onApplied?: ({ color, label, mode, }: {
+        color: string;
+        label: string;
+        mode: HighlightMode;
+    }) => void;
+}
+export declare function pickHighlightColorsByValue(values: string[]): {
+    label: string;
+    value: string;
+    border: string;
+}[];
+/**
+ * Checks if highlight can be applied based on the mode and current editor state
+ */
+export declare function canColorHighlight(editor: Editor | null, mode?: HighlightMode): boolean;
+/**
+ * Checks if highlight is currently active
+ */
+export declare function isColorHighlightActive(editor: Editor | null, highlightColor?: string, mode?: HighlightMode): boolean;
+/**
+ * Removes highlight based on the mode
+ */
+export declare function removeHighlight(editor: Editor | null, mode?: HighlightMode): boolean;
+/**
+ * Determines if the highlight button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    mode: HighlightMode;
+}): boolean;
+export declare function useColorHighlight(config: UseColorHighlightConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleColorHighlight: () => any;
+    handleRemoveHighlight: () => boolean;
+    canColorHighlight: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import('react').MemoExoticComponent<({ className, ...props }: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element>;
+    mode: HighlightMode;
+};

package/dist/components/tiptap-ui/color-highlight-button/use-color-highlight.js

@@ -0,0 +1,176 @@
+import "@tiptap/react";
+import { useState as C, useEffect as y, useCallback as f } from "react";
+import { f as M } from "../../../index-Bqw9S4qP.js";
+import { useIsMobile as E } from "../../../hooks/use-mobile.js";
+import { useTiptapEditor as w } from "../../../hooks/use-tiptap-editor.js";
+import { isMarkInSchema as d, isNodeTypeSelected as B, isExtensionAvailable as v } from "../../../lib/tiptap-utils.js";
+import { HighlighterIcon as I } from "../../tiptap-icons/highlighter-icon.js";
+const b = "mod+shift+h", S = [
+  {
+    label: "Default background",
+    value: "var(--tt-bg-color)",
+    border: "var(--tt-bg-color-contrast)"
+  },
+  {
+    label: "Gray background",
+    value: "var(--tt-color-highlight-gray)",
+    border: "var(--tt-color-highlight-gray-contrast)"
+  },
+  {
+    label: "Brown background",
+    value: "var(--tt-color-highlight-brown)",
+    border: "var(--tt-color-highlight-brown-contrast)"
+  },
+  {
+    label: "Orange background",
+    value: "var(--tt-color-highlight-orange)",
+    border: "var(--tt-color-highlight-orange-contrast)"
+  },
+  {
+    label: "Yellow background",
+    value: "var(--tt-color-highlight-yellow)",
+    border: "var(--tt-color-highlight-yellow-contrast)"
+  },
+  {
+    label: "Green background",
+    value: "var(--tt-color-highlight-green)",
+    border: "var(--tt-color-highlight-green-contrast)"
+  },
+  {
+    label: "Blue background",
+    value: "var(--tt-color-highlight-blue)",
+    border: "var(--tt-color-highlight-blue-contrast)"
+  },
+  {
+    label: "Purple background",
+    value: "var(--tt-color-highlight-purple)",
+    border: "var(--tt-color-highlight-purple-contrast)"
+  },
+  {
+    label: "Pink background",
+    value: "var(--tt-color-highlight-pink)",
+    border: "var(--tt-color-highlight-pink-contrast)"
+  },
+  {
+    label: "Red background",
+    value: "var(--tt-color-highlight-red)",
+    border: "var(--tt-color-highlight-red-contrast)"
+  }
+];
+function x(t) {
+  const r = new Map(
+    S.map((l) => [l.value, l])
+  );
+  return t.map((l) => r.get(l)).filter((l) => !!l);
+}
+function s(t, r = "mark") {
+  if (!t || !t.isEditable) return !1;
+  if (r === "mark")
+    return !d("highlight", t) || B(t, ["image"]) ? !1 : t.can().setMark("highlight");
+  if (!v(t, ["nodeBackground"])) return !1;
+  try {
+    return t.can().toggleNodeBackgroundColor("test");
+  } catch {
+    return !1;
+  }
+}
+function T(t, r, l = "mark") {
+  if (!t || !t.isEditable) return !1;
+  if (l === "mark")
+    return r ? t.isActive("highlight", { color: r }) : t.isActive("highlight");
+  if (!r) return !1;
+  try {
+    const { state: i } = t, { selection: h } = i, a = h.$anchor;
+    for (let n = a.depth; n >= 0; n--) {
+      const e = a.node(n);
+      if (e && e.attrs?.backgroundColor === r)
+        return !0;
+    }
+    return !1;
+  } catch {
+    return !1;
+  }
+}
+function O(t, r = "mark") {
+  return !t || !t.isEditable || !s(t, r) ? !1 : r === "mark" ? t.chain().focus().unsetMark("highlight").run() : t.chain().focus().unsetNodeBackgroundColor().run();
+}
+function A(t) {
+  const { editor: r, hideWhenUnavailable: l, mode: i } = t;
+  if (!r || !r.isEditable) return !1;
+  if (i === "mark") {
+    if (!d("highlight", r)) return !1;
+  } else if (!v(r, ["nodeBackground"])) return !1;
+  return l && !r.isActive("code") ? s(r, i) : !0;
+}
+function D(t) {
+  const {
+    editor: r,
+    label: l,
+    highlightColor: i,
+    hideWhenUnavailable: h = !1,
+    mode: a = "mark",
+    onApplied: n
+  } = t, { editor: e } = w(r), k = E(), [g, m] = C(!0), c = s(e, a), p = T(e, i, a);
+  y(() => {
+    if (!e) return;
+    const o = () => {
+      m(A({ editor: e, hideWhenUnavailable: h, mode: a }));
+    };
+    return o(), e.on("selectionUpdate", o), () => {
+      e.off("selectionUpdate", o);
+    };
+  }, [e, h, a]);
+  const u = f(() => {
+    if (!e || !c || !i || !l)
+      return !1;
+    if (a === "mark") {
+      if (e.state.storedMarks) {
+        const o = e.schema.marks.highlight;
+        o && e.view.dispatch(
+          e.state.tr.removeStoredMark(o)
+        );
+      }
+      return setTimeout(() => {
+        const o = e.chain().focus().toggleMark("highlight", { color: i }).run();
+        return o && n?.({ color: i, label: l, mode: a }), o;
+      }, 0), !0;
+    } else {
+      const o = e.chain().focus().toggleNodeBackgroundColor(i).run();
+      return o && n?.({ color: i, label: l, mode: a }), o;
+    }
+  }, [c, i, e, l, n, a]), H = f(() => {
+    const o = O(e, a);
+    return o && n?.({ color: "", label: "Remove highlight", mode: a }), o;
+  }, [e, n, a]);
+  return M(
+    b,
+    (o) => {
+      o.preventDefault(), u();
+    },
+    {
+      enabled: g && c,
+      enableOnContentEditable: !k,
+      enableOnFormTags: !0
+    }
+  ), {
+    isVisible: g,
+    isActive: p,
+    handleColorHighlight: u,
+    handleRemoveHighlight: H,
+    canColorHighlight: c,
+    label: l || "Highlight",
+    shortcutKeys: b,
+    Icon: I,
+    mode: a
+  };
+}
+export {
+  b as COLOR_HIGHLIGHT_SHORTCUT_KEY,
+  S as HIGHLIGHT_COLORS,
+  s as canColorHighlight,
+  T as isColorHighlightActive,
+  x as pickHighlightColorsByValue,
+  O as removeHighlight,
+  A as shouldShowButton,
+  D as useColorHighlight
+};

package/dist/components/tiptap-ui/color-highlight-popover/color-highlight-popover.d.ts

@@ -0,0 +1,25 @@
+import { Editor } from '@tiptap/react';
+import { ButtonProps } from '../../tiptap-ui-primitive/button';
+import { HighlightColor, UseColorHighlightConfig } from '../color-highlight-button';
+export interface ColorHighlightPopoverContentProps {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Optional colors to use in the highlight popover.
+     * If not provided, defaults to a predefined set of colors.
+     */
+    colors?: HighlightColor[];
+}
+export interface ColorHighlightPopoverProps extends Omit<ButtonProps, "type">, Pick<UseColorHighlightConfig, "editor" | "hideWhenUnavailable" | "onApplied"> {
+    /**
+     * Optional colors to use in the highlight popover.
+     * If not provided, defaults to a predefined set of colors.
+     */
+    colors?: HighlightColor[];
+}
+export declare const ColorHighlightPopoverButton: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
+export declare function ColorHighlightPopoverContent({ editor, colors, }: ColorHighlightPopoverContentProps): import("react/jsx-runtime").JSX.Element;
+export declare function ColorHighlightPopover({ editor: providedEditor, colors, hideWhenUnavailable, onApplied, ...props }: ColorHighlightPopoverProps): import("react/jsx-runtime").JSX.Element | null;
+export default ColorHighlightPopover;

package/dist/components/tiptap-ui/color-highlight-popover/color-highlight-popover.js

@@ -0,0 +1,136 @@
+import { jsx as t, jsxs as u } from "react/jsx-runtime";
+import { forwardRef as H, useRef as I, useMemo as y, useState as x } from "react";
+import "@tiptap/react";
+import { useMenuNavigation as B } from "../../../hooks/use-menu-navigation.js";
+import { useIsMobile as P } from "../../../hooks/use-mobile.js";
+import { useTiptapEditor as R } from "../../../hooks/use-tiptap-editor.js";
+import { BanIcon as S } from "../../tiptap-icons/ban-icon.js";
+import { HighlighterIcon as N } from "../../tiptap-icons/highlighter-icon.js";
+import { useColorHighlight as m, pickHighlightColorsByValue as f } from "../color-highlight-button/use-color-highlight.js";
+import { Card as w, CardBody as M, CardItemGroup as k } from "../../tiptap-ui-primitive/card/card.js";
+import { Button as b, ButtonGroup as d } from "../../tiptap-ui-primitive/button/button.js";
+import { ColorHighlightButton as z } from "../color-highlight-button/color-highlight-button.js";
+import { Popover as O, PopoverTrigger as j, PopoverContent as E } from "../../tiptap-ui-primitive/popover/popover.js";
+import { Separator as G } from "../../tiptap-ui-primitive/separator/separator.js";
+const v = H(({ className: l, children: o, ...r }, a) => /* @__PURE__ */ t(
+  b,
+  {
+    type: "button",
+    className: l,
+    "data-style": "ghost",
+    "data-appearance": "default",
+    role: "button",
+    tabIndex: -1,
+    "aria-label": "Highlight text",
+    tooltip: "Highlight",
+    ref: a,
+    ...r,
+    children: o ?? /* @__PURE__ */ t(N, { className: "tiptap-button-icon" })
+  }
+));
+v.displayName = "ColorHighlightPopoverButton";
+function T({
+  editor: l,
+  colors: o = f([
+    "var(--tt-color-highlight-green)",
+    "var(--tt-color-highlight-blue)",
+    "var(--tt-color-highlight-red)",
+    "var(--tt-color-highlight-purple)",
+    "var(--tt-color-highlight-yellow)"
+  ])
+}) {
+  const { handleRemoveHighlight: r } = m({ editor: l }), a = P(), h = I(null), g = y(
+    () => [...o, { label: "Remove highlight", value: "none" }],
+    [o]
+  ), { selectedIndex: n } = B({
+    containerRef: h,
+    items: g,
+    orientation: "both",
+    onSelect: (e) => {
+      if (!h.current) return !1;
+      const i = h.current.querySelector(
+        '[data-highlighted="true"]'
+      );
+      return i && i.click(), e.value === "none" && r(), !0;
+    },
+    autoSelectFirstItem: !1
+  });
+  return /* @__PURE__ */ t(
+    w,
+    {
+      ref: h,
+      tabIndex: 0,
+      style: a ? { boxShadow: "none", border: 0 } : {},
+      children: /* @__PURE__ */ t(M, { style: a ? { padding: 0 } : {}, children: /* @__PURE__ */ u(k, { orientation: "horizontal", children: [
+        /* @__PURE__ */ t(d, { orientation: "horizontal", children: o.map((e, i) => /* @__PURE__ */ t(
+          z,
+          {
+            editor: l,
+            highlightColor: e.value,
+            tooltip: e.label,
+            "aria-label": `${e.label} highlight color`,
+            tabIndex: i === n ? 0 : -1,
+            "data-highlighted": n === i
+          },
+          e.value
+        )) }),
+        /* @__PURE__ */ t(G, {}),
+        /* @__PURE__ */ t(d, { orientation: "horizontal", children: /* @__PURE__ */ t(
+          b,
+          {
+            onClick: r,
+            "aria-label": "Remove highlight",
+            tooltip: "Remove highlight",
+            tabIndex: n === o.length ? 0 : -1,
+            type: "button",
+            role: "menuitem",
+            "data-style": "ghost",
+            "data-highlighted": n === o.length,
+            children: /* @__PURE__ */ t(S, { className: "tiptap-button-icon" })
+          }
+        ) })
+      ] }) })
+    }
+  );
+}
+function Z({
+  editor: l,
+  colors: o = f([
+    "var(--tt-color-highlight-green)",
+    "var(--tt-color-highlight-blue)",
+    "var(--tt-color-highlight-red)",
+    "var(--tt-color-highlight-purple)",
+    "var(--tt-color-highlight-yellow)"
+  ]),
+  hideWhenUnavailable: r = !1,
+  onApplied: a,
+  ...h
+}) {
+  const { editor: g } = R(l), [n, e] = x(!1), { isVisible: i, canColorHighlight: p, isActive: s, label: c, Icon: C } = m({
+    editor: g,
+    hideWhenUnavailable: r,
+    onApplied: a
+  });
+  return i ? /* @__PURE__ */ u(O, { open: n, onOpenChange: e, children: [
+    /* @__PURE__ */ t(j, { asChild: !0, children: /* @__PURE__ */ t(
+      v,
+      {
+        disabled: !p,
+        "data-active-state": s ? "on" : "off",
+        "data-disabled": !p,
+        "aria-pressed": s,
+        "aria-label": c,
+        tooltip: c,
+        ...h,
+        children: /* @__PURE__ */ t(C, { className: "tiptap-button-icon" })
+      }
+    ) }),
+    /* @__PURE__ */ t(E, { "aria-label": "Highlight colors", children: /* @__PURE__ */ t(T, { editor: g, colors: o }) })
+  ] }) : null;
+}
+export {
+  Z as ColorHighlightPopover,
+  v as ColorHighlightPopoverButton,
+  T as ColorHighlightPopoverContent,
+  Z as default
+};

package/dist/components/tiptap-ui/color-highlight-popover/index.d.ts

@@ -0,0 +1 @@
+export * from './color-highlight-popover';

package/dist/components/tiptap-ui/color-highlight-popover/index.js

@@ -0,0 +1,6 @@
+import { ColorHighlightPopover as t, ColorHighlightPopoverButton as g, ColorHighlightPopoverContent as h } from "./color-highlight-popover.js";
+export {
+  t as ColorHighlightPopover,
+  g as ColorHighlightPopoverButton,
+  h as ColorHighlightPopoverContent
+};

package/dist/components/tiptap-ui/heading-button/heading-button.d.ts

@@ -0,0 +1,23 @@
+import { Level, UseHeadingConfig } from '.';
+import { ButtonProps } from '../../tiptap-ui-primitive/button';
+export interface HeadingButtonProps extends Omit<ButtonProps, "type">, UseHeadingConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function HeadingShortcutBadge({ level, shortcutKeys, }: {
+    level: Level;
+    shortcutKeys?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Button component for toggling heading in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useHeading` hook instead.
+ */
+export declare const HeadingButton: import('react').ForwardRefExoticComponent<HeadingButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/heading-button/heading-button.js

@@ -0,0 +1,74 @@
+import { jsx as t, jsxs as T, Fragment as x } from "react/jsx-runtime";
+import { forwardRef as N, useCallback as S } from "react";
+import { parseShortcutKeys as C } from "../../../lib/tiptap-utils.js";
+import { useTiptapEditor as E } from "../../../hooks/use-tiptap-editor.js";
+import { useHeading as I, HEADING_SHORTCUT_KEYS as K } from "./use-heading.js";
+import { Button as j } from "../../tiptap-ui-primitive/button/button.js";
+import { Badge as k } from "../../tiptap-ui-primitive/badge/badge.js";
+function A({
+  level: a,
+  shortcutKeys: e = K[a]
+}) {
+  return /* @__PURE__ */ t(k, { children: C({ shortcutKeys: e }) });
+}
+const R = N(
+  ({
+    editor: a,
+    level: e,
+    text: o,
+    hideWhenUnavailable: c = !1,
+    onToggled: p,
+    showShortcut: u = !1,
+    onClick: r,
+    children: m,
+    ...f
+  }, g) => {
+    const { editor: b } = E(a), {
+      isVisible: h,
+      canToggle: i,
+      isActive: n,
+      handleToggle: s,
+      label: d,
+      Icon: H,
+      shortcutKeys: y
+    } = I({
+      editor: b,
+      level: e,
+      hideWhenUnavailable: c,
+      onToggled: p
+    }), B = S(
+      (l) => {
+        r?.(l), !l.defaultPrevented && s();
+      },
+      [s, r]
+    );
+    return h ? /* @__PURE__ */ t(
+      j,
+      {
+        type: "button",
+        "data-style": "ghost",
+        "data-active-state": n ? "on" : "off",
+        role: "button",
+        tabIndex: -1,
+        disabled: !i,
+        "data-disabled": !i,
+        "aria-label": d,
+        "aria-pressed": n,
+        tooltip: d,
+        onClick: B,
+        ...f,
+        ref: g,
+        children: m ?? /* @__PURE__ */ T(x, { children: [
+          /* @__PURE__ */ t(H, { className: "tiptap-button-icon" }),
+          o && /* @__PURE__ */ t("span", { className: "tiptap-button-text", children: o }),
+          u && /* @__PURE__ */ t(A, { level: e, shortcutKeys: y })
+        ] })
+      }
+    ) : null;
+  }
+);
+R.displayName = "HeadingButton";
+export {
+  R as HeadingButton,
+  A as HeadingShortcutBadge
+};

package/dist/components/tiptap-ui/heading-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from './heading-button';
+export * from './use-heading';

package/dist/components/tiptap-ui/heading-button/index.js

@@ -0,0 +1,13 @@
+import { HeadingButton as g, HeadingShortcutBadge as n } from "./heading-button.js";
+import { HEADING_SHORTCUT_KEYS as a, canToggle as d, headingIcons as i, isHeadingActive as H, shouldShowButton as r, toggleHeading as u, useHeading as c } from "./use-heading.js";
+export {
+  a as HEADING_SHORTCUT_KEYS,
+  g as HeadingButton,
+  n as HeadingShortcutBadge,
+  d as canToggle,
+  i as headingIcons,
+  H as isHeadingActive,
+  r as shouldShowButton,
+  u as toggleHeading,
+  c as useHeading
+};