@tensor_1/react 2.18.0 → 2.19.0

package/dist/rich-text.cjs

@@ -0,0 +1,2578 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rich-text.ts
+var rich_text_exports = {};
+__export(rich_text_exports, {
+  DEFAULT_RICH_TEXT_LABELS: () => DEFAULT_RICH_TEXT_LABELS,
+  RichTextEditor: () => RichTextEditor,
+  RichTextEditorFallback: () => RichTextEditorFallback,
+  emojiImageFileName: () => emojiImageFileName,
+  roundTripMarkdown: () => roundTripMarkdown
+});
+module.exports = __toCommonJS(rich_text_exports);
+
+// src/components/RichTextEditor.tsx
+var import_react7 = require("react");
+var import_core2 = require("@tiptap/core");
+var import_react8 = require("@tiptap/react");
+var import_markdown2 = require("@tiptap/markdown");
+var import_extensions = require("@tiptap/extensions");
+var import_extension_image2 = require("@tiptap/extension-image");
+var import_extension_emoji2 = require("@tiptap/extension-emoji");
+var import_suggestion = require("@tiptap/suggestion");
+var import_state = require("@tiptap/pm/state");
+var import_view = require("@tiptap/pm/view");
+
+// src/cx.ts
+function cx(...args) {
+  return args.filter(Boolean).join(" ");
+}
+
+// src/overlay-position.ts
+var OPPOSITE = { top: "bottom", bottom: "top", left: "right", right: "left" };
+function parsePlacement(p) {
+  const [side, align] = p.split("-");
+  return { side, align: align ?? "center" };
+}
+var clamp = (v, min, max) => Math.max(min, Math.min(max, v));
+function spaceOn(side, a, vp, offset) {
+  switch (side) {
+    case "top":
+      return a.y - offset;
+    case "bottom":
+      return vp.height - (a.y + a.height) - offset;
+    case "left":
+      return a.x - offset;
+    case "right":
+      return vp.width - (a.x + a.width) - offset;
+  }
+}
+function fitsOn(side, a, f, vp, offset, padding) {
+  const need = side === "top" || side === "bottom" ? f.height : f.width;
+  return spaceOn(side, a, vp, offset) >= need + padding;
+}
+function computePosition(anchor, floating, viewport, options = {}) {
+  const { placement = "bottom-start", offset = 6, padding = 8, flip = true, shift = true } = options;
+  const { side: preferred, align } = parsePlacement(placement);
+  let side = preferred;
+  if (flip && !fitsOn(side, anchor, floating, viewport, offset, padding)) {
+    const opp = OPPOSITE[side];
+    if (fitsOn(opp, anchor, floating, viewport, offset, padding) || spaceOn(opp, anchor, viewport, offset) > spaceOn(side, anchor, viewport, offset)) {
+      side = opp;
+    }
+  }
+  let x, y;
+  const horizontal = side === "top" || side === "bottom";
+  if (side === "top") y = anchor.y - floating.height - offset;
+  else if (side === "bottom") y = anchor.y + anchor.height + offset;
+  else if (side === "left") x = anchor.x - floating.width - offset;
+  else x = anchor.x + anchor.width + offset;
+  if (horizontal) {
+    const start = anchor.x;
+    const end = anchor.x + anchor.width - floating.width;
+    const center = anchor.x + (anchor.width - floating.width) / 2;
+    x = align === "start" ? start : align === "end" ? end : center;
+    if (shift) x = clamp(x, padding, Math.max(padding, viewport.width - floating.width - padding));
+  } else {
+    const start = anchor.y;
+    const end = anchor.y + anchor.height - floating.height;
+    const center = anchor.y + (anchor.height - floating.height) / 2;
+    y = align === "start" ? start : align === "end" ? end : center;
+    if (shift) y = clamp(y, padding, Math.max(padding, viewport.height - floating.height - padding));
+  }
+  return {
+    x,
+    y,
+    placement: align === "center" ? side : `${side}-${align}`,
+    side,
+    align
+  };
+}
+
+// src/emoji-model.ts
+var COMPONENT_GROUP_KEY = "component";
+var capitalize = (s) => s ? s[0].toLocaleUpperCase() + s.slice(1) : s;
+function buildEmojiData(locale, compact, messages) {
+  const sourceGroups = [...messages.groups].sort((a, b) => a.order - b.order);
+  const groups = [];
+  const groupIndex = /* @__PURE__ */ new Map();
+  for (const g of sourceGroups) {
+    if (g.key === COMPONENT_GROUP_KEY) continue;
+    groupIndex.set(g.order, groups.length);
+    groups.push({ key: g.key, name: capitalize(g.message) });
+  }
+  const emojis2 = [];
+  const names = /* @__PURE__ */ new Map();
+  const sorted = [...compact].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  for (const item of sorted) {
+    if (item.group === void 0) continue;
+    const group = groupIndex.get(item.group);
+    if (group === void 0) continue;
+    const entry = { emoji: item.unicode, name: item.label, tags: item.tags ?? [], group };
+    emojis2.push(entry);
+    names.set(item.unicode, item.label);
+    names.set(item.unicode.replace(/️/g, ""), item.label);
+  }
+  return { locale, groups, emojis: emojis2, names };
+}
+var cache = /* @__PURE__ */ new Map();
+var loadEmojiData = (locale) => {
+  let pending = cache.get(locale);
+  if (!pending) {
+    const files = locale === "de" ? Promise.all([import("emojibase-data/de/compact.json"), import("emojibase-data/de/messages.json")]) : Promise.all([import("emojibase-data/en/compact.json"), import("emojibase-data/en/messages.json")]);
+    pending = files.then(
+      ([compact, messages]) => buildEmojiData(
+        locale,
+        compact.default ?? compact,
+        messages.default ?? messages
+      )
+    );
+    pending.catch(() => cache.delete(locale));
+    cache.set(locale, pending);
+  }
+  return pending;
+};
+var fold = (s) => s.toLocaleLowerCase().normalize("NFD").replace(/\p{M}/gu, "");
+function searchEmoji(data, query, limit = 64) {
+  const q = fold(query.trim());
+  if (!q) return [];
+  const prefix = [];
+  const contains = [];
+  for (const entry of data.emojis) {
+    const name = fold(entry.name);
+    const words = [...name.split(/[\s:,-]+/), ...entry.tags.map(fold)];
+    if (words.some((w) => w.startsWith(q)) || name.startsWith(q)) prefix.push(entry);
+    else if (name.includes(q)) contains.push(entry);
+    if (prefix.length >= limit) break;
+  }
+  return [...prefix, ...contains].slice(0, limit);
+}
+var DEFAULT_RECENT_KEY = "uix-emoji-recent";
+var RECENT_MAX = 16;
+function readRecentEmoji(key = DEFAULT_RECENT_KEY) {
+  try {
+    const raw = globalThis.localStorage?.getItem(key);
+    const list = raw ? JSON.parse(raw) : [];
+    return Array.isArray(list) ? list.filter((e) => typeof e === "string").slice(0, RECENT_MAX) : [];
+  } catch {
+    return [];
+  }
+}
+function pushRecentEmoji(emoji, key = DEFAULT_RECENT_KEY) {
+  const next = [emoji, ...readRecentEmoji(key).filter((e) => e !== emoji)].slice(0, RECENT_MAX);
+  try {
+    globalThis.localStorage?.setItem(key, JSON.stringify(next));
+  } catch {
+  }
+  return next;
+}
+function emojiGridMove(index, key, count, columns) {
+  if (count === 0) return null;
+  switch (key) {
+    case "ArrowRight":
+      return Math.min(index + 1, count - 1);
+    case "ArrowLeft":
+      return Math.max(index - 1, 0);
+    case "ArrowDown":
+      return Math.min(index + columns, count - 1);
+    case "ArrowUp":
+      return index - columns < 0 ? null : index - columns;
+    case "Home":
+      return 0;
+    case "End":
+      return count - 1;
+    default:
+      return null;
+  }
+}
+function formatLabel(template, values) {
+  return template.replace(/\{(\w+)\}/g, (match, name) => name in values ? String(values[name]) : match);
+}
+
+// src/emoji-image.ts
+var warned = /* @__PURE__ */ new Set();
+var devWarn = (message) => {
+  if (warned.has(message) || typeof process === "undefined" || process.env.NODE_ENV === "production") return;
+  warned.add(message);
+  console.warn(message);
+};
+function normalizeEmojiImageBaseUrl(value) {
+  if (value === void 0 || value === "") return void 0;
+  const sameOrigin = /^(?:\/(?![/\\])|\.\/)/.test(value) && !/[\\\s]/.test(value) && !/^[^/?#]*:/.test(value);
+  if (!sameOrigin) {
+    devWarn(`uix: emojiImageBaseUrl "${value}" was ignored \u2014 only same-origin paths starting with "/" or "./" are allowed.`);
+    return void 0;
+  }
+  return value.replace(/\/+$/, "") || "/";
+}
+function emojiImageFileName(emoji) {
+  return `${Array.from(emoji, (ch) => ch.codePointAt(0).toString(16)).join("-")}.png`;
+}
+function emojiImageSrc(base, emoji) {
+  return `${base === "/" ? "" : base}/${emojiImageFileName(emoji)}`;
+}
+var support = /* @__PURE__ */ new Map();
+var context;
+var SIZE = 20;
+function canRenderEmoji(emoji) {
+  const cached = support.get(emoji);
+  if (cached !== void 0) return cached;
+  if (typeof document === "undefined") return true;
+  if (context === void 0) {
+    try {
+      const canvas = document.createElement("canvas");
+      canvas.width = SIZE;
+      canvas.height = SIZE;
+      context = typeof canvas.getContext === "function" ? canvas.getContext("2d", { willReadFrequently: true }) : null;
+    } catch {
+      context = null;
+    }
+  }
+  if (!context) return true;
+  let result = true;
+  try {
+    context.clearRect(0, 0, SIZE, SIZE);
+    context.fillStyle = "#000";
+    context.textBaseline = "top";
+    context.font = `${SIZE - 4}px sans-serif`;
+    context.fillText(emoji, 0, 0);
+    const { data } = context.getImageData(0, 0, SIZE, SIZE);
+    result = false;
+    for (let i = 0; i < data.length; i += 4) {
+      const [r, g, b, a] = [data[i], data[i + 1], data[i + 2], data[i + 3]];
+      if (a > 0 && (Math.abs(r - g) > 12 || Math.abs(g - b) > 12)) {
+        result = true;
+        break;
+      }
+    }
+  } catch {
+    result = true;
+  }
+  support.set(emoji, result);
+  return result;
+}
+function emojiPattern() {
+  try {
+    return new RegExp("\\p{RGI_Emoji}", "gv");
+  } catch {
+    return /\p{Regional_Indicator}{2}|(?:\p{Extended_Pictographic}|[#*0-9]️?⃣)(?:️|\p{Emoji_Modifier})*(?:‍\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})*)*/gu;
+  }
+}
+
+// src/rich-text/emoji-items.ts
+var import_extension_emoji = require("@tiptap/extension-emoji");
+var OFFLINE_EMOJI_ITEMS = Object.freeze(
+  import_extension_emoji.emojis.filter((item) => typeof item.emoji === "string" && item.emoji !== "").map(({ fallbackImage: _remote, ...item }) => item).filter((item) => !/https?:|\/\//i.test(JSON.stringify(item)))
+);
+
+// src/components/EmojiGlyph.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+function useEmojiRenderer(emojiImageBaseUrl) {
+  const base = (0, import_react.useMemo)(() => normalizeEmojiImageBaseUrl(emojiImageBaseUrl), [emojiImageBaseUrl]);
+  const [mounted, setMounted] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    if (base) setMounted(true);
+  }, [base]);
+  return (0, import_react.useCallback)((emoji) => {
+    if (!base || !mounted || canRenderEmoji(emoji)) return emoji;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("img", { className: "uix-emoji-img", src: emojiImageSrc(base, emoji), alt: emoji, draggable: false, decoding: "async" });
+  }, [base, mounted]);
+}
+
+// src/rich-text/pipeline.ts
+var import_core = require("@tiptap/core");
+var import_markdown = require("@tiptap/markdown");
+var import_extension_list = require("@tiptap/extension-list");
+var import_extension_table = require("@tiptap/extension-table");
+var import_extension_image = require("@tiptap/extension-image");
+var import_starter_kit = require("@tiptap/starter-kit");
+var import_marked = require("marked");
+
+// src/url-policy.ts
+var ALLOWED_START = /^(https?:|mailto:|\/|#|\.\/|\.\.\/)/i;
+var CONTROL_OR_BACKSLASH = /[\x00-\x1f\x7f\\]/;
+var PROTOCOL_RELATIVE = /^[/\\]{2}/;
+function defaultIsSafeUrl(url) {
+  const candidate = url.replace(/[\t\n\r]/g, "").trim();
+  if (CONTROL_OR_BACKSLASH.test(candidate) || PROTOCOL_RELATIVE.test(candidate)) return false;
+  return ALLOWED_START.test(candidate);
+}
+
+// src/rich-text/pipeline.ts
+var indentContinuation = (h) => {
+  let first = true;
+  return {
+    ...h,
+    renderChildren: (nodes) => {
+      const out = h.renderChildren(nodes);
+      if (!first) return out;
+      first = false;
+      return out.split("\n").map((line, n) => n > 0 && line ? h.indent(line) : line).join("\n");
+    }
+  };
+};
+var listItemRender = import_extension_list.ListItem.config.renderMarkdown;
+var UixListItem = import_extension_list.ListItem.extend({
+  renderMarkdown: (node, h, ctx) => listItemRender(node, indentContinuation(h), ctx)
+});
+var UixTaskItem = import_extension_list.TaskItem.extend({
+  renderMarkdown: (node, h) => {
+    const prefix = `- [${node.attrs?.checked ? "x" : " "}] `;
+    const [first, ...rest] = node.content ?? [];
+    if (first?.type !== "paragraph" || !(first.content ?? []).some((c) => c.type === "hardBreak")) {
+      return (0, import_core.renderNestedMarkdownContent)(node, h, prefix);
+    }
+    const lines = [[]];
+    for (const child of first.content ?? []) {
+      if (child.type === "hardBreak") lines.push([]);
+      else lines[lines.length - 1].push(child);
+    }
+    const paragraphs = lines.filter((line) => line.length > 0).map((content) => ({ type: "paragraph", content }));
+    return (0, import_core.renderNestedMarkdownContent)({ ...node, content: [...paragraphs, ...rest] }, h, prefix);
+  }
+});
+function createSchemaExtensions(options = {}) {
+  const isSafeUrl = options.isSafeUrl ?? defaultIsSafeUrl;
+  return [
+    import_starter_kit.StarterKit.configure({
+      underline: false,
+      listItem: false,
+      heading: { levels: [...options.headingLevels ?? [1, 2, 3]] },
+      link: {
+        openOnClick: false,
+        autolink: true,
+        linkOnPaste: true,
+        defaultProtocol: "https",
+        // Unsafe links never become marks: pasted or typed, they stay text.
+        isAllowedUri: (url) => isSafeUrl(url),
+        shouldAutoLink: (url) => isSafeUrl(url),
+        HTMLAttributes: { rel: "noopener noreferrer nofollow", target: null }
+      }
+    }),
+    UixListItem,
+    import_extension_list.TaskList,
+    UixTaskItem.configure({ nested: true }),
+    import_extension_table.TableKit.configure({ table: { resizable: false } }),
+    options.image ?? import_extension_image.Image.configure({ inline: true, allowBase64: false })
+  ];
+}
+var ENTITY_AFTER_AMP = /^(?:#\d+;|#x[\da-f]+;|[a-z][a-z\d]*;)/i;
+var TAG_START = /^[a-z/!?]$/i;
+var ASCII_PUNCT = /[!-/:-@[-`{-~]/;
+var LIST_MARKER = /^(?:\d+|[ivxlcdmIVXLCDM]+|[a-zA-Z]{1,2})$/;
+var BACKSLASH = String.fromCharCode(92);
+function encodeText(text, options = {}) {
+  let out = "";
+  const chars = Array.from(text);
+  let lineStart = 0;
+  let inLead = options.lineStart ?? true;
+  for (let i = 0; i < chars.length; i += 1) {
+    const ch = chars[i];
+    const prev = chars[i - 1] ?? "";
+    const next = chars[i + 1] ?? "";
+    if (ch === "\n") {
+      out += ch;
+      lineStart = i + 1;
+      inLead = true;
+      continue;
+    }
+    if (inLead && (ch === " " || ch === "	")) {
+      continue;
+    }
+    const atStart = inLead;
+    inLead = false;
+    const lineRest = chars.slice(i).join("").split("\n")[0];
+    const endOrSpace = next === "" || next === "\n" || /\s/u.test(next);
+    const markerBefore = !atStart && LIST_MARKER.test(out.slice(out.lastIndexOf("\n") + 1));
+    if (
+      // `#` always: marked ends a list item at a line starting with `#`, space or not.
+      atStart && (ch === "#" || /[-+*]/.test(ch) && endOrSpace) || atStart && /[-=*_]/.test(ch) && new RegExp(`^(?:\\${ch}[ \\t]*)+$`).test(lineRest) || markerBefore && /[.)]/.test(ch) && endOrSpace
+    ) {
+      out += BACKSLASH + ch;
+      continue;
+    }
+    if (ch === "#" && options.headingEnd && (prev === "" || /\s/u.test(prev)) && /^#+$/.test(lineRest)) {
+      out += BACKSLASH + ch;
+      continue;
+    }
+    switch (ch) {
+      case BACKSLASH:
+        out += ASCII_PUNCT.test(next) || next === "" ? BACKSLASH + BACKSLASH : BACKSLASH;
+        break;
+      case "`":
+      case "[":
+      case "]":
+      case "~":
+        out += BACKSLASH + ch;
+        break;
+      case "|":
+        out += options.inTable ? BACKSLASH + ch : ch;
+        break;
+      case "&":
+        out += ENTITY_AFTER_AMP.test(chars.slice(i + 1, i + 40).join("")) ? "&amp;" : ch;
+        break;
+      case "<":
+        out += TAG_START.test(next) ? "&lt;" : ch;
+        break;
+      case "!":
+        out += next === "" && options.beforeLink ? BACKSLASH + ch : ch;
+        break;
+      case "*":
+      case "_": {
+        const spaced = (prev === "" || /\s/u.test(prev)) && (next === "" || /\s/u.test(next));
+        const intraword = ch === "_" && /[\p{L}\p{N}]/u.test(prev) && /[\p{L}\p{N}]/u.test(next);
+        out += spaced || intraword ? ch : BACKSLASH + ch;
+        break;
+      }
+      case ">":
+        out += atStart ? BACKSLASH + ch : ch;
+        break;
+      default:
+        out += ch;
+    }
+  }
+  return out;
+}
+function createMarked() {
+  return new import_marked.Marked({
+    gfm: true,
+    tokenizer: {
+      html: () => void 0,
+      // `<br>` is the one tag read: GFM tables have no other way to hold a line break,
+      // and Tiptap writes hard breaks in cells that way.
+      tag: (src) => {
+        const br = /^<br\s*\/?>/i.exec(src);
+        return br ? { type: "br", raw: br[0] } : void 0;
+      }
+    }
+  });
+}
+var hasLink = (node) => (node?.marks ?? []).some((m) => (typeof m === "string" ? m : m.type) === "link");
+function patchManager(manager) {
+  const internals = manager;
+  internals.encodeTextForMarkdown = function encode(text, node, parentNode) {
+    const inCode = parentNode?.type != null && internals.codeTypes.has(parentNode.type) || (node.marks ?? []).some((m) => internals.codeTypes.has(typeof m === "string" ? m : m.type));
+    if (inCode) return text;
+    const siblings = parentNode?.content ?? [];
+    const index = siblings.indexOf(node);
+    const previous = index > 0 ? siblings[index - 1] : void 0;
+    const next = index >= 0 ? siblings[index + 1] : void 0;
+    return encodeText(text, {
+      inTable: !!internals.uixInTable,
+      beforeLink: hasLink(next) && !hasLink(node),
+      // Unknown position (node not found among its siblings): assume a line start, the safe side.
+      lineStart: index <= 0 || previous?.type === "hardBreak",
+      headingEnd: parentNode?.type === "heading" && (index < 0 || index === siblings.length - 1)
+    });
+  };
+  return manager;
+}
+function serializeNode(manager, node) {
+  const internals = manager;
+  internals.uixInTable = node.type === "table";
+  try {
+    return manager.serialize({ type: "doc", content: [node] }).replace(/^\n+|\n+$/g, "");
+  } finally {
+    internals.uixInTable = false;
+  }
+}
+function createManager(extensions) {
+  return patchManager(new import_markdown.MarkdownManager({ marked: createMarked(), extensions }));
+}
+var SEPARATOR_TOKENS = /* @__PURE__ */ new Set(["space", "def"]);
+var nodeKey = (node) => JSON.stringify(node);
+var normalize = (schema, content) => {
+  if (content.length === 0) return [];
+  const blocks = [];
+  for (const node of content) {
+    if (node.type && schema.nodes[node.type]?.isInline) {
+      const last = blocks[blocks.length - 1];
+      if (last?.type === "paragraph" && last.wrapped) last.content.push(node);
+      else blocks.push({ type: "paragraph", content: [node], wrapped: true });
+    } else {
+      blocks.push(node);
+    }
+  }
+  for (const block of blocks) delete block.wrapped;
+  const doc = schema.nodeFromJSON({ type: "doc", content: blocks });
+  doc.check();
+  return doc.toJSON().content ?? [];
+};
+function readMarkdown(source, manager, schema) {
+  const normalized = source.replace(/\r\n?/g, "\n");
+  const lexed = manager.instance.lexer(normalized);
+  const origin = [];
+  for (let i = 0, o = 0; i <= normalized.length; i += 1, o += 1) {
+    origin.push(o);
+    if (source[o] === "\r" && source[o + 1] === "\n") o += 1;
+  }
+  let cursor = 0;
+  const tokens = lexed.map((t) => {
+    const start = origin[cursor];
+    cursor += t.raw.length;
+    return { type: t.type, raw: source.slice(start, origin[cursor]) };
+  });
+  const joined = lexed.map((t) => t.raw).join("") === normalized ? tokens.map((t) => t.raw).join("") : null;
+  const blocks = [];
+  const eol = /\r\n/.test(source) && !/(^|[^\r])\n/.test(source) ? "\r\n" : "\n";
+  let lead = "";
+  let defs = [];
+  const keepInLead = (raw) => {
+    lead += raw;
+    const text = raw.replace(/\s+$/u, "").replace(/^\s+/u, "");
+    if (text) defs.push(text);
+  };
+  const pushBlock = (raw) => {
+    let nodes;
+    try {
+      nodes = normalize(schema, manager.parse(raw).content ?? []);
+    } catch {
+      nodes = normalize(schema, [{ type: "paragraph", content: [{ type: "text", text: raw }] }]);
+    }
+    if (nodes.length === 0) {
+      keepInLead(raw);
+      return;
+    }
+    blocks.push({ raw, lead, nodes, keys: nodes.map(nodeKey), defs });
+    lead = "";
+    defs = [];
+  };
+  if (joined !== source) {
+    const core = source.replace(/\s+$/u, "");
+    lead = source.slice(0, source.length - source.trimStart().length);
+    if (core.trim()) pushBlock(core.trimStart());
+    const tail = source.slice(core.length);
+    return { source, blocks, tail, tailDefs: [], eol, doc: { type: "doc", content: blocks.flatMap((b) => b.nodes) } };
+  }
+  for (const token of tokens) {
+    if (SEPARATOR_TOKENS.has(token.type) || token.raw.trim() === "") {
+      if (token.type === "def") keepInLead(token.raw);
+      else lead += token.raw;
+      continue;
+    }
+    const leading = /^(?:[ \t]*\r?\n)*/.exec(token.raw)[0];
+    lead += leading;
+    const body = token.raw.slice(leading.length);
+    const core = body.replace(/\s+$/u, "");
+    pushBlock(core);
+    lead += body.slice(core.length);
+  }
+  return {
+    source,
+    blocks,
+    tail: lead,
+    tailDefs: defs,
+    eol,
+    doc: { type: "doc", content: blocks.flatMap((b) => b.nodes) }
+  };
+}
+var isEmptyParagraph = (node) => node.type === "paragraph" && !(node.content ?? []).some((c) => c.type !== "text" || (c.text ?? "").trim() !== "");
+var matchesAt = (children, at, block) => block.keys.every((key, k) => children[at + k] === key);
+var LOOKAHEAD = 8;
+function writeMarkdown(doc, origin, manager) {
+  const content = [...doc.content ?? []];
+  while (content.length > 0 && isEmptyParagraph(content[content.length - 1])) content.pop();
+  if (content.length === 0) {
+    return origin.blocks.length === 0 ? origin.source : "";
+  }
+  const keys = content.map(nodeKey);
+  const { blocks, eol } = origin;
+  const pieces = [];
+  let i = 0;
+  let j = 0;
+  while (i < content.length) {
+    if (j < blocks.length && matchesAt(keys, i, blocks[j])) {
+      pieces.push({ text: blocks[j].raw, slot: j, edited: false });
+      i += blocks[j].keys.length;
+      j += 1;
+      continue;
+    }
+    let skip = 0;
+    for (let d = 1; d <= LOOKAHEAD && j + d < blocks.length; d += 1) {
+      if (matchesAt(keys, i, blocks[j + d])) {
+        skip = d;
+        break;
+      }
+    }
+    let insert = 0;
+    if (j < blocks.length) {
+      for (let d = 1; d <= LOOKAHEAD && i + d < content.length; d += 1) {
+        if (matchesAt(keys, i + d, blocks[j])) {
+          insert = d;
+          break;
+        }
+      }
+    }
+    if (skip && (!insert || skip <= insert)) {
+      j += skip;
+      continue;
+    }
+    let text = serializeNode(manager, content[i]);
+    if (eol !== "\n") text = text.replace(/\n/g, eol);
+    const inPlace = !insert && j < blocks.length && blocks[j].keys.length === 1;
+    pieces.push(inPlace ? { text, slot: j, edited: true } : { text, edited: true });
+    i += 1;
+    if (!insert && j < blocks.length) j += 1;
+  }
+  const blank = eol + eol;
+  const emitted = /* @__PURE__ */ new Set();
+  let out = "";
+  pieces.forEach((piece, n) => {
+    const prev = pieces[n - 1];
+    const slot = piece.slot;
+    const lead = slot !== void 0 ? blocks[slot].lead : "";
+    if (n === 0) {
+      if (slot === 0) {
+        out += lead;
+        emitted.add(0);
+      }
+    } else if (slot !== void 0 && prev?.slot === slot - 1 && // Next to a re-serialized block, only a separator with a blank line is safe.
+    (!(piece.edited || prev.edited) || /\n[ \t]*\r?\n/.test(lead))) {
+      out += lead;
+      emitted.add(slot);
+    } else {
+      out += blank;
+    }
+    out += piece.text;
+  });
+  const last = pieces[pieces.length - 1];
+  const tailKept = last.slot === blocks.length - 1;
+  const lost = [
+    ...blocks.flatMap((block, n) => emitted.has(n) ? [] : block.defs),
+    ...tailKept ? [] : origin.tailDefs
+  ];
+  if (lost.length) out += blank + lost.join(eol);
+  if (tailKept) out += origin.tail;
+  else if (/\n$/.test(origin.tail)) out += eol;
+  return out;
+}
+function createPipeline(options = {}) {
+  const extensions = createSchemaExtensions(options);
+  const schema = (0, import_core.getSchema)(extensions);
+  const manager = createManager(extensions);
+  return {
+    extensions,
+    schema,
+    manager,
+    read: (source) => readMarkdown(source, manager, schema),
+    write: (doc, origin) => writeMarkdown(doc, origin, manager)
+  };
+}
+
+// src/components/Composer.tsx
+var import_react2 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function Composer({ children, className, label = "Add a comment", ...props }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: cx("uix-composer", className), ...props, children: import_react2.Children.map(children, (child) => {
+    if (!(0, import_react2.isValidElement)(child) || child.type !== "textarea") return child;
+    const p = child.props;
+    return p["aria-label"] || p["aria-labelledby"] || p.id ? child : (0, import_react2.cloneElement)(child, { "aria-label": label });
+  }) });
+}
+function ComposerBar({ children, className, ...props }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: cx("uix-composer__bar", className), ...props, children });
+}
+
+// src/components/EditorIcons.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var PATHS = {
+  heading1: "M4 12h8M4 18V6M12 18V6M17 12l3-2v8",
+  heading2: "M4 12h8M4 18V6M12 18V6M21 18h-4c0-4 4-3 4-6 0-1.5-2-2.5-4-1",
+  heading3: "M4 12h8M4 18V6M12 18V6M17.5 10.5c1.7-1 3.5 0 3.5 1.5a2 2 0 0 1-2 2M17 17.5c2 1.5 4 .3 4-1.5a2 2 0 0 0-2-2",
+  bold: "M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8",
+  italic: "M19 4h-9M14 20H5M15 4 9 20",
+  strike: "M16 4H9a3 3 0 0 0-2.83 4M14 12a4 4 0 0 1 0 8H6M4 12h16",
+  code: "m16 18 6-6-6-6M8 6l-6 6 6 6",
+  bulletList: "M3 12h.01M3 18h.01M3 6h.01M8 12h13M8 18h13M8 6h13",
+  orderedList: "M10 12h11M10 18h11M10 6h11M4 10h2M4 6h1v4M6 18H4c0-1 2-2 2-3s-1-1.5-2-1",
+  taskList: "m3 17 2 2 4-4M3 7l2 2 4-4M13 6h8M13 12h8M13 18h8",
+  blockquote: "M17 6H3M21 12H8M21 18H8M3 12v6",
+  codeBlock: "m10 9-3 3 3 3M14 15l3-3-3-3M5 3h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2Z",
+  horizontalRule: "M5 12h14",
+  link: "M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71",
+  table: "M12 3v18M5 3h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2ZM3 9h18M3 15h18",
+  tableAddRow: "M4 3h16a1 1 0 0 1 1 1v6a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1ZM12 15v6M9 18h6",
+  tableAddColumn: "M4 3h6a1 1 0 0 1 1 1v16a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1ZM18 9v6M15 12h6",
+  tableDeleteRow: "M4 3h16a1 1 0 0 1 1 1v6a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1ZM9 18h6",
+  tableDeleteColumn: "M4 3h6a1 1 0 0 1 1 1v16a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1ZM15 12h6",
+  trash: "M3 6h18M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2",
+  image: "M5 3h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2ZM9 7a2 2 0 1 0 0 4 2 2 0 0 0 0-4ZM21 15l-3.09-3.09a2 2 0 0 0-2.82 0L6 21",
+  emoji: "M12 2a10 10 0 1 0 0 20 10 10 0 0 0 0-20ZM8 14s1.5 2 4 2 4-2 4-2M9 9h.01M15 9h.01",
+  addReaction: "M22 11v1a10 10 0 1 1-9-10M8 14s1.5 2 4 2 4-2 4-2M9 9h.01M15 9h.01M16 5h6M19 2v6",
+  undo: "M9 14 4 9l5-5M4 9h10.5a5.5 5.5 0 0 1 0 11H11",
+  redo: "m15 14 5-5-5-5M20 9H9.5a5.5 5.5 0 0 0 0 11H13",
+  sourceMode: "M10 12.5 8 15l2 2.5M14 12.5l2 2.5-2 2.5M14 2v4a2 2 0 0 0 2 2h4M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z",
+  richMode: "M14 2v4a2 2 0 0 0 2 2h4M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7ZM8 13h8M8 17h5",
+  clock: "M12 2a10 10 0 1 0 0 20 10 10 0 0 0 0-20ZM12 6v6l4 2"
+};
+function EditorIcon({ name, ...props }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    "svg",
+    {
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: 2,
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      focusable: "false",
+      ...props,
+      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("path", { d: PATHS[name] })
+    }
+  );
+}
+
+// src/components/EmojiPicker.tsx
+var import_react5 = require("react");
+
+// src/components/Popover.tsx
+var import_react4 = require("react");
+
+// src/hooks/useAnchoredPosition.ts
+var import_react3 = require("react");
+var useIsomorphicLayoutEffect = typeof document !== "undefined" ? import_react3.useLayoutEffect : import_react3.useEffect;
+var resolve = (a) => a && typeof a === "object" && "current" in a ? a.current : a ?? null;
+function useAnchoredPosition(anchor, floatingRef, { open, placement = "bottom-start", offset = 6, padding = 8 }) {
+  const opts = (0, import_react3.useRef)({ placement, offset, padding });
+  opts.current = { placement, offset, padding };
+  const reposition = (0, import_react3.useCallback)(() => {
+    const anchorEl = resolve(anchor);
+    const floating = floatingRef.current;
+    if (!anchorEl || !floating) return;
+    const s = floating.style;
+    s.position = "fixed";
+    s.inset = "auto";
+    s.margin = "0";
+    const a = anchorEl.getBoundingClientRect();
+    const { placement: p, offset: o, padding: pad } = opts.current;
+    const pos = computePosition(
+      { x: a.x, y: a.y, width: a.width, height: a.height },
+      { width: floating.offsetWidth, height: floating.offsetHeight },
+      { width: window.innerWidth, height: window.innerHeight },
+      { placement: p, offset: o, padding: pad }
+    );
+    s.left = `${Math.round(pos.x)}px`;
+    s.top = `${Math.round(pos.y)}px`;
+    floating.dataset.placement = pos.placement;
+  }, [anchor, floatingRef]);
+  useIsomorphicLayoutEffect(() => {
+    if (!open) return;
+    reposition();
+    const onScroll = () => reposition();
+    window.addEventListener("scroll", onScroll, { passive: true, capture: true });
+    window.addEventListener("resize", onScroll);
+    return () => {
+      window.removeEventListener("scroll", onScroll, true);
+      window.removeEventListener("resize", onScroll);
+    };
+  }, [open, reposition]);
+  return reposition;
+}
+
+// src/components/Popover.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function Popover({
+  popover = "auto",
+  anchor,
+  placement = "bottom-start",
+  offset = 6,
+  className,
+  children,
+  ...props
+}) {
+  const ref = (0, import_react4.useRef)(null);
+  const [open, setOpen] = (0, import_react4.useState)(false);
+  const popoverAttr = { popover };
+  const reposition = useAnchoredPosition(anchor ?? null, ref, {
+    open: open && !!anchor,
+    placement,
+    offset
+  });
+  (0, import_react4.useEffect)(() => {
+    const el = ref.current;
+    if (!el || !anchor) return;
+    const sync = () => {
+      const isOpen = el.matches(":popover-open");
+      if (isOpen) reposition();
+      setOpen(isOpen);
+    };
+    el.addEventListener("toggle", sync);
+    return () => el.removeEventListener("toggle", sync);
+  }, [anchor, reposition]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { ref, className: cx("uix-popover", className), ...popoverAttr, ...props, children });
+}
+
+// src/components/EmojiPicker.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var DEFAULT_EMOJI_PICKER_LABELS = {
+  dialog: "Choose an emoji",
+  search: "Search emoji",
+  recent: "Recently used",
+  quickPicks: "Frequently used",
+  categories: "Emoji categories",
+  noResults: "No emoji found",
+  loading: "Loading emoji\u2026",
+  loadFailed: "Emoji could not be loaded."
+};
+var EMOJI_GRID_COLUMNS = 8;
+function EmojiPicker({
+  onSelect,
+  trigger,
+  labels: labelOverrides,
+  locale = "en",
+  quickPicks,
+  loadData = loadEmojiData,
+  recentStorageKey = DEFAULT_RECENT_KEY,
+  placement = "bottom-start",
+  onOpenChange,
+  className,
+  emojiImageBaseUrl
+}) {
+  const renderEmoji = useEmojiRenderer(emojiImageBaseUrl);
+  const labels = { ...DEFAULT_EMOJI_PICKER_LABELS, ...labelOverrides };
+  const id = (0, import_react5.useId)();
+  const popoverId = `${id}-picker`;
+  const anchorRef = (0, import_react5.useRef)(null);
+  const searchRef = (0, import_react5.useRef)(null);
+  const gridRef = (0, import_react5.useRef)(null);
+  const pointerWasOpen = (0, import_react5.useRef)(null);
+  const [open, setOpen] = (0, import_react5.useState)(false);
+  const [data, setData] = (0, import_react5.useState)(null);
+  const [failed, setFailed] = (0, import_react5.useState)(false);
+  const [query, setQuery] = (0, import_react5.useState)("");
+  const [recent, setRecent] = (0, import_react5.useState)([]);
+  const [active, setActive] = (0, import_react5.useState)(0);
+  const popoverEl = () => typeof document === "undefined" ? null : document.getElementById(popoverId);
+  const isOpen = (el) => {
+    try {
+      return !!el?.matches(":popover-open");
+    } catch {
+      return false;
+    }
+  };
+  (0, import_react5.useEffect)(() => {
+    const el = popoverEl();
+    if (!el) return;
+    const onToggle = (event) => {
+      const { newState } = event;
+      const nowOpen = newState ? newState === "open" : isOpen(el);
+      setOpen(nowOpen);
+      onOpenChange?.(nowOpen);
+      if (nowOpen) {
+        setRecent(readRecentEmoji(recentStorageKey));
+        setQuery("");
+        setActive(0);
+        requestAnimationFrame(() => searchRef.current?.focus());
+      } else if (el.contains(document.activeElement) || document.activeElement === document.body) {
+        focusTrigger();
+      }
+    };
+    el.addEventListener("toggle", onToggle);
+    return () => el.removeEventListener("toggle", onToggle);
+  }, [popoverId, recentStorageKey, onOpenChange]);
+  (0, import_react5.useEffect)(() => {
+    if (!open || data?.locale === locale) return;
+    let live = true;
+    setFailed(false);
+    loadData(locale).then(
+      (loaded) => {
+        if (live) setData(loaded);
+      },
+      () => {
+        if (live) setFailed(true);
+      }
+    );
+    return () => {
+      live = false;
+    };
+  }, [open, locale, loadData, data?.locale]);
+  const focusTrigger = () => {
+    const el = anchorRef.current?.querySelector("button, [href], [tabindex]");
+    el?.focus();
+  };
+  const hide = () => {
+    const el = popoverEl();
+    if (el && isOpen(el)) el.hidePopover();
+  };
+  const sections = (0, import_react5.useMemo)(() => {
+    if (query.trim()) {
+      return data ? [{ key: "results", title: labels.search, emojis: searchEmoji(data, query).map((e) => e.emoji) }] : [];
+    }
+    const list = [];
+    if (quickPicks?.length) list.push({ key: "quick", title: labels.quickPicks, emojis: [...new Set(quickPicks)] });
+    if (recent.length) list.push({ key: "recent", title: labels.recent, emojis: recent });
+    if (data) {
+      data.groups.forEach((group, index) => {
+        list.push({ key: group.key, title: group.name, emojis: data.emojis.filter((e) => e.group === index).map((e) => e.emoji) });
+      });
+    }
+    return list;
+  }, [query, data, quickPicks, recent, labels.search, labels.quickPicks, labels.recent]);
+  const flat = (0, import_react5.useMemo)(() => sections.flatMap((s) => s.emojis), [sections]);
+  const sectionStart = (0, import_react5.useMemo)(() => {
+    const starts = /* @__PURE__ */ new Map();
+    let at = 0;
+    for (const section of sections) {
+      starts.set(section.key, at);
+      at += section.emojis.length;
+    }
+    return starts;
+  }, [sections]);
+  const activeIndex = Math.min(active, Math.max(flat.length - 1, 0));
+  const choose = (emoji) => {
+    setRecent(pushRecentEmoji(emoji, recentStorageKey));
+    onSelect(emoji);
+    hide();
+  };
+  const focusCell = (0, import_react5.useCallback)((index) => {
+    setActive(index);
+    const find = () => gridRef.current?.querySelector(`[data-emoji-index="${index}"]`);
+    const cell = find();
+    if (cell) cell.focus();
+    else requestAnimationFrame(() => find()?.focus());
+  }, []);
+  const onGridKeyDown = (event) => {
+    const target = event.target;
+    const index = Number(target.dataset.emojiIndex ?? -1);
+    if (index < 0) return;
+    const next = emojiGridMove(index, event.key, flat.length, EMOJI_GRID_COLUMNS);
+    if (event.key === "ArrowUp" && next === null) {
+      event.preventDefault();
+      searchRef.current?.focus();
+      return;
+    }
+    if (next === null) return;
+    event.preventDefault();
+    focusCell(next);
+  };
+  const onSearchKeyDown = (event) => {
+    if (event.key === "Escape") {
+      event.preventDefault();
+      hide();
+    } else if (event.key === "ArrowDown" && flat.length) {
+      event.preventDefault();
+      focusCell(0);
+    } else if (event.key === "Enter" && query.trim() && flat[0]) {
+      event.preventDefault();
+      choose(flat[0]);
+    }
+  };
+  const toggleFromTrigger = (event) => {
+    const el = popoverEl();
+    if (!el || event.defaultPrevented) return;
+    const was = pointerWasOpen.current;
+    pointerWasOpen.current = null;
+    if (was === true) return;
+    if (isOpen(el)) el.hidePopover();
+    else el.showPopover();
+  };
+  const triggerProps = (0, import_react5.isValidElement)(trigger) ? trigger.props : {};
+  const triggerEl = (0, import_react5.isValidElement)(trigger) ? (0, import_react5.cloneElement)(trigger, {
+    "aria-haspopup": "dialog",
+    "aria-expanded": open,
+    "aria-controls": popoverId,
+    onPointerDown: (event) => {
+      pointerWasOpen.current = isOpen(popoverEl());
+      triggerProps.onPointerDown?.(event);
+    },
+    onClick: (event) => {
+      triggerProps.onClick?.(event);
+      toggleFromTrigger(event);
+    }
+  }) : trigger;
+  const names = data?.names;
+  let offset = 0;
+  const status = failed ? labels.loadFailed : !data && open ? labels.loading : query.trim() && data && flat.length === 0 ? labels.noResults : "";
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("span", { ref: anchorRef, className: cx("uix-emoji-picker__anchor", className), children: [
+    triggerEl,
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      Popover,
+      {
+        id: popoverId,
+        anchor: anchorRef,
+        placement,
+        className: "uix-emoji-picker-popover",
+        role: "dialog",
+        "aria-label": labels.dialog,
+        children: open ? /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: "uix-emoji-picker uix-emoji-picker--full", lang: locale, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+            "input",
+            {
+              ref: searchRef,
+              type: "search",
+              className: "uix-input uix-emoji-picker__search",
+              "aria-label": labels.search,
+              placeholder: labels.search,
+              value: query,
+              onChange: (event) => {
+                setQuery(event.target.value);
+                setActive(0);
+              },
+              onKeyDown: onSearchKeyDown,
+              autoComplete: "off",
+              spellCheck: false
+            }
+          ),
+          data && !query.trim() ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "uix-emoji-picker__nav", role: "group", "aria-label": labels.categories, children: sections.map((section) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+            "button",
+            {
+              type: "button",
+              className: "uix-emoji-picker__nav-btn",
+              "aria-label": section.title,
+              title: section.title,
+              onClick: () => {
+                const start = section.emojis.length ? sectionStart.get(section.key) ?? -1 : -1;
+                gridRef.current?.querySelector(`[data-section="${section.key}"]`)?.scrollIntoView({ block: "start" });
+                if (start >= 0) focusCell(start);
+              },
+              children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { "aria-hidden": "true", children: section.emojis[0] ? renderEmoji(section.emojis[0]) : null })
+            },
+            section.key
+          )) }) : null,
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "uix-emoji-picker__grid", ref: gridRef, onKeyDown: onGridKeyDown, children: sections.map((section) => {
+            const start = offset;
+            offset += section.emojis.length;
+            if (!section.emojis.length) return null;
+            const headingId = `${id}-${section.key}`;
+            return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("section", { className: "uix-emoji-picker__section", "data-section": section.key, "aria-labelledby": headingId, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("h3", { id: headingId, className: "uix-emoji-picker__heading", children: section.title }),
+              /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "uix-emoji-picker__cells", role: "group", "aria-labelledby": headingId, children: section.emojis.map((emoji, i) => {
+                const index = start + i;
+                return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+                  "button",
+                  {
+                    type: "button",
+                    className: "uix-emoji-picker__btn",
+                    "data-emoji-index": index,
+                    tabIndex: index === activeIndex ? 0 : -1,
+                    "aria-label": names?.get(emoji) ?? emoji,
+                    title: names?.get(emoji),
+                    onClick: () => choose(emoji),
+                    onFocus: () => setActive(index),
+                    children: renderEmoji(emoji)
+                  },
+                  `${section.key}-${emoji}`
+                );
+              }) })
+            ] }, section.key);
+          }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("p", { className: "uix-emoji-picker__status", role: "status", children: status })
+        ] }) : null
+      }
+    )
+  ] });
+}
+
+// src/markdown-model.ts
+var ASCII_PUNCT2 = /[!-/:-@[-`{-~]/;
+var WORD = /[\p{L}\p{N}]/u;
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0",
+  copy: "\xA9",
+  reg: "\xAE",
+  hellip: "\u2026",
+  mdash: "\u2014",
+  ndash: "\u2013"
+};
+var ENTITY_RE = /^&(?:#(\d{1,7})|#[xX]([\da-fA-F]{1,6})|([a-zA-Z][a-zA-Z\d]{1,31}));/;
+var ENTITY_GLOBAL = /&(?:#\d{1,7}|#[xX][\da-fA-F]{1,6}|[a-zA-Z][a-zA-Z\d]{1,31});/g;
+var BARE_URL_RE = /^https?:\/\/[^\s<>()]+/;
+var BR_RE = /^<br\s*\/?>/i;
+var AUTOLINK_RE = /^<((?:https?:|mailto:)[^\s<>]*)>/i;
+var decodeEntity = (match) => {
+  const [, dec, hex, name] = match;
+  const code = dec ? Number(dec) : hex ? parseInt(hex, 16) : void 0;
+  if (code !== void 0) return code > 0 && code <= 1114111 ? String.fromCodePoint(code) : "\uFFFD";
+  return name && Object.prototype.hasOwnProperty.call(NAMED_ENTITIES, name) ? NAMED_ENTITIES[name] : null;
+};
+var MAX_SCAN = 2e3;
+var MAX_DEPTH = 12;
+var findBracketEnd = (text, open) => {
+  let depth = 0;
+  const stop = Math.min(text.length, open + MAX_SCAN);
+  for (let i = open; i < stop; i += 1) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      const close = text.indexOf("`", i + 1);
+      if (close > 0) {
+        i = close;
+        continue;
+      }
+    }
+    if (ch === "[") depth += 1;
+    else if (ch === "]") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+};
+var readDestination = (text, open) => {
+  if (text[open] !== "(") return null;
+  let depth = 0;
+  let end = -1;
+  const stop = Math.min(text.length, open + MAX_SCAN);
+  for (let i = open; i < stop; i += 1) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 1;
+      continue;
+    }
+    if (ch === "(") depth += 1;
+    else if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end < 0) return null;
+  const inner = text.slice(open + 1, end).trim();
+  const titled = /^(\S+)\s+(?:"([^"]*)"|'([^']*)')$/.exec(inner);
+  const rawUrl = titled ? titled[1] : inner;
+  const url = rawUrl.replace(/^<(.*)>$/, "$1").replace(/\\([!-/:-@[-`{-~])/g, "$1").replace(ENTITY_GLOBAL, (match) => decodeEntity(ENTITY_RE.exec(match)) ?? match);
+  const title = titled ? titled[2] ?? titled[3] : void 0;
+  return title === void 0 ? { url, end } : { url, title, end };
+};
+var backtickRun = (text, at) => {
+  let end = at;
+  while (text[end] === "`") end += 1;
+  return text.slice(at, end);
+};
+var findCloser = (text, from, delim, misses) => {
+  if (from >= (misses.get(delim) ?? Infinity)) return -1;
+  for (let i = from; i < text.length; i += 1) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      const run = backtickRun(text, i);
+      const close = text.indexOf(run, i + run.length);
+      if (close > 0) {
+        i = close + run.length - 1;
+        continue;
+      }
+    }
+    if (text.startsWith(delim, i) && i > from && !/\s/u.test(text[i - 1])) {
+      if (delim[0] === "_" && WORD.test(text[i + delim.length] ?? "")) continue;
+      if (delim.length === 1 && text[i + 1] === delim) {
+        i += 1;
+        continue;
+      }
+      return i;
+    }
+  }
+  misses.set(delim, Math.min(from, misses.get(delim) ?? Infinity));
+  return -1;
+};
+var pushText = (out, value) => {
+  if (!value) return;
+  const last = out[out.length - 1];
+  if (last?.type === "text") last.value += value;
+  else out.push({ type: "text", value });
+};
+function parseInline(text, depth = 0) {
+  const out = [];
+  if (depth > MAX_DEPTH) {
+    pushText(out, text);
+    return out;
+  }
+  const misses = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    const rest = text.slice(i);
+    if (ch === "\\" && ASCII_PUNCT2.test(text[i + 1] ?? "")) {
+      pushText(out, text[i + 1]);
+      i += 2;
+      continue;
+    }
+    if (ch === "\n") {
+      out.push({ type: "br" });
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      const run = backtickRun(text, i);
+      const close = text.indexOf(run, i + run.length);
+      if (close > 0 && text[close + run.length] !== "`") {
+        let value = text.slice(i + run.length, close).replace(/\n/g, " ");
+        if (/^ .* $/.test(value) && value.trim()) value = value.slice(1, -1);
+        out.push({ type: "code", value });
+        i = close + run.length;
+        continue;
+      }
+      pushText(out, run);
+      i += run.length;
+      continue;
+    }
+    if (ch === "!" && text[i + 1] === "[") {
+      const end = findBracketEnd(text, i + 1);
+      const dest = end > 0 ? readDestination(text, end + 1) : null;
+      if (dest) {
+        const alt = plainText(parseInline(text.slice(i + 2, end), depth + 1));
+        out.push(dest.title === void 0 ? { type: "image", src: dest.url, alt } : { type: "image", src: dest.url, alt, title: dest.title });
+        i = dest.end + 1;
+        continue;
+      }
+    }
+    if (ch === "[") {
+      const end = findBracketEnd(text, i);
+      const dest = end > 0 ? readDestination(text, end + 1) : null;
+      if (dest) {
+        const children = parseInline(text.slice(i + 1, end), depth + 1);
+        out.push(dest.title === void 0 ? { type: "link", href: dest.url, children } : { type: "link", href: dest.url, title: dest.title, children });
+        i = dest.end + 1;
+        continue;
+      }
+    }
+    if (ch === "<") {
+      const br = BR_RE.exec(rest);
+      if (br) {
+        out.push({ type: "br" });
+        i += br[0].length;
+        continue;
+      }
+      const auto = AUTOLINK_RE.exec(rest);
+      if (auto) {
+        out.push({ type: "link", href: auto[1], children: [{ type: "text", value: auto[1].replace(/^mailto:/i, "") }], bare: true });
+        i += auto[0].length;
+        continue;
+      }
+    }
+    if (ch === "&") {
+      const entity = ENTITY_RE.exec(rest);
+      const decoded = entity ? decodeEntity(entity) : null;
+      if (entity && decoded !== null) {
+        pushText(out, decoded);
+        i += entity[0].length;
+        continue;
+      }
+    }
+    if (ch === "~" && text[i + 1] === "~" && text[i + 2] && !/\s/u.test(text[i + 2])) {
+      const close = findCloser(text, i + 2, "~~", misses);
+      if (close > 0) {
+        out.push({ type: "del", children: parseInline(text.slice(i + 2, close), depth + 1) });
+        i = close + 2;
+        continue;
+      }
+    }
+    if (ch === "*" || ch === "_") {
+      const leftOk = ch === "*" || !WORD.test(text[i - 1] ?? "");
+      const double = text[i + 1] === ch;
+      const delim = double ? ch + ch : ch;
+      const after = text[i + delim.length];
+      if (leftOk && after && !/\s/u.test(after)) {
+        const close = findCloser(text, i + delim.length, delim, misses);
+        if (close > 0) {
+          const children = parseInline(text.slice(i + delim.length, close), depth + 1);
+          out.push(double ? { type: "strong", children } : { type: "em", children });
+          i = close + delim.length;
+          continue;
+        }
+      }
+      const run = new RegExp(`^\\${ch}+`).exec(rest)[0];
+      pushText(out, run);
+      i += run.length;
+      continue;
+    }
+    if (ch === "h" && !WORD.test(text[i - 1] ?? "")) {
+      const bare = BARE_URL_RE.exec(rest);
+      if (bare) {
+        const url = bare[0].replace(/[.,;:!?'"]+$/, "");
+        out.push({ type: "link", href: url, children: [{ type: "text", value: url }], bare: true });
+        i += url.length;
+        continue;
+      }
+    }
+    pushText(out, ch);
+    i += 1;
+  }
+  return out;
+}
+function plainText(nodes) {
+  return nodes.map((n) => {
+    switch (n.type) {
+      case "text":
+      case "code":
+        return n.value;
+      case "br":
+        return " ";
+      case "image":
+        return n.alt;
+      default:
+        return plainText(n.children);
+    }
+  }).join("");
+}
+var FENCE_RE = /^(`{3,}|~{3,})\s*([^`\s]*)/;
+var HEADING_RE = /^(#{1,6})\s+(.*?)(?:\s+#+)?$/;
+var RULE_RE = /^(?:(?:\*\s*){3,}|(?:-\s*){3,}|(?:_\s*){3,})$/;
+var BULLET_RE = /^(\s*)([-*+])\s+(.*)$/;
+var ORDERED_RE = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
+var TASK_RE = /^\[([ xX])\]\s+(.*)$/;
+var DELIMITER_ROW_RE = /^\s*\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?\s*$/;
+var indentOf = (s) => s.replace(/\t/g, "    ").length;
+function splitTableRow(line) {
+  let row = line.trim();
+  if (row.startsWith("|")) row = row.slice(1);
+  if (row.endsWith("|") && !row.endsWith("\\|")) row = row.slice(0, -1);
+  const cells = [];
+  let cell = "";
+  let inCode = false;
+  for (let i = 0; i < row.length; i += 1) {
+    const ch = row[i];
+    if (ch === "\\" && row[i + 1] === "|") {
+      cell += "|";
+      i += 1;
+      continue;
+    }
+    if (ch === "`") inCode = !inCode;
+    if (ch === "|" && !inCode) {
+      cells.push(cell.trim());
+      cell = "";
+      continue;
+    }
+    cell += ch;
+  }
+  cells.push(cell.trim());
+  return cells;
+}
+var alignOf = (cell) => {
+  const c = cell.trim();
+  const left = c.startsWith(":");
+  const right = c.endsWith(":");
+  return left && right ? "center" : right ? "right" : left ? "left" : null;
+};
+var matchListLine = (line) => {
+  const bullet = BULLET_RE.exec(line);
+  if (bullet && !RULE_RE.test(line.trim())) return { indent: indentOf(bullet[1]), ordered: false, number: 1, text: bullet[3] };
+  const ordered = ORDERED_RE.exec(line);
+  if (ordered) return { indent: indentOf(ordered[1]), ordered: true, number: Number(ordered[2]), text: ordered[3] };
+  return null;
+};
+var toItem = (text) => {
+  const task = TASK_RE.exec(text);
+  return task ? { checked: task[1] !== " ", children: parseInline(task[2]), lists: [] } : { checked: null, children: parseInline(text), lists: [] };
+};
+var buildList = (lines) => {
+  const lists = [];
+  const stack = [];
+  for (const line of lines) {
+    while (stack.length && line.indent < stack[stack.length - 1].indent) stack.pop();
+    let top = stack[stack.length - 1];
+    if (top && line.indent > top.indent) {
+      const parentItem = top.list.items[top.list.items.length - 1];
+      const nested = { type: "list", ordered: line.ordered, start: line.number, items: [] };
+      parentItem.lists.push(nested);
+      stack.push({ list: nested, indent: line.indent });
+      top = stack[stack.length - 1];
+    } else if (!top || top.list.ordered !== line.ordered) {
+      const list = { type: "list", ordered: line.ordered, start: line.number, items: [] };
+      if (stack.length <= 1) {
+        lists.push(list);
+        stack.length = 0;
+      } else {
+        stack.pop();
+        const parent = stack[stack.length - 1].list;
+        parent.items[parent.items.length - 1].lists.push(list);
+      }
+      stack.push({ list, indent: line.indent });
+      top = stack[stack.length - 1];
+    }
+    top.list.items.push(toItem(line.text));
+  }
+  return lists;
+};
+function parseMarkdown(source) {
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+  const blocks = [];
+  let paragraph = [];
+  let i = 0;
+  const flush = () => {
+    if (paragraph.length) {
+      blocks.push({ type: "paragraph", children: parseInline(paragraph.join("\n")) });
+      paragraph = [];
+    }
+  };
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      flush();
+      i += 1;
+      continue;
+    }
+    const fence = FENCE_RE.exec(trimmed);
+    if (fence) {
+      flush();
+      const marker = fence[1];
+      const body = [];
+      i += 1;
+      while (i < lines.length && !lines[i].trim().startsWith(marker)) {
+        body.push(lines[i]);
+        i += 1;
+      }
+      i += 1;
+      blocks.push({ type: "code", lang: fence[2] ?? "", value: body.join("\n") });
+      continue;
+    }
+    const heading = HEADING_RE.exec(trimmed);
+    if (heading) {
+      flush();
+      blocks.push({ type: "heading", level: heading[1].length, children: parseInline(heading[2]) });
+      i += 1;
+      continue;
+    }
+    if (RULE_RE.test(trimmed)) {
+      flush();
+      blocks.push({ type: "rule" });
+      i += 1;
+      continue;
+    }
+    if (trimmed.startsWith(">")) {
+      flush();
+      const quote = [];
+      while (i < lines.length && lines[i].trim().startsWith(">")) {
+        quote.push(lines[i].trim().replace(/^>\s?/, ""));
+        i += 1;
+      }
+      blocks.push({ type: "quote", children: parseInline(quote.join(" ")) });
+      continue;
+    }
+    if (trimmed.includes("|") && i + 1 < lines.length && DELIMITER_ROW_RE.test(lines[i + 1]) && lines[i + 1].includes("-")) {
+      const head = splitTableRow(line);
+      const delimiters = splitTableRow(lines[i + 1]);
+      if (delimiters.length === head.length) {
+        flush();
+        const rows = [];
+        i += 2;
+        while (i < lines.length && lines[i].trim() !== "" && lines[i].includes("|")) {
+          const cells = splitTableRow(lines[i]);
+          rows.push(head.map((_, c) => parseInline(cells[c] ?? "")));
+          i += 1;
+        }
+        blocks.push({ type: "table", align: delimiters.map(alignOf), head: head.map((c) => parseInline(c)), rows });
+        continue;
+      }
+    }
+    const first = matchListLine(line);
+    if (first) {
+      flush();
+      const listLines = [];
+      while (i < lines.length) {
+        const current = lines[i];
+        const item = matchListLine(current);
+        if (item) {
+          if (listLines.length && item.indent <= listLines[0].indent && item.ordered !== listLines[0].ordered) break;
+          listLines.push(item);
+        } else if (current.trim() !== "" && indentOf(current) > listLines[0].indent && listLines.length) {
+          listLines[listLines.length - 1].text += `
+${current.trim()}`;
+        } else {
+          break;
+        }
+        i += 1;
+      }
+      const base = Math.min(...listLines.map((l) => l.indent));
+      blocks.push(...buildList(listLines.map((l) => ({ ...l, indent: l.indent - base }))));
+      continue;
+    }
+    paragraph.push(trimmed);
+    i += 1;
+  }
+  flush();
+  return blocks;
+}
+
+// src/components/Markdown.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var defaultMarkdownIsSafeUrl = defaultIsSafeUrl;
+var isExternal = (href) => /^https?:/i.test(href.trim());
+function renderInlines(nodes, policy) {
+  return nodes.map((node, i) => {
+    switch (node.type) {
+      case "text":
+        return node.value;
+      case "br":
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("br", {}, i);
+      case "code":
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("code", { children: node.value }, i);
+      case "strong":
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("strong", { children: renderInlines(node.children, policy) }, i);
+      case "em":
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("em", { children: renderInlines(node.children, policy) }, i);
+      case "del":
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("del", { children: renderInlines(node.children, policy) }, i);
+      case "link": {
+        const children = renderInlines(node.children, policy);
+        if (!node.href.trim() || !policy.isSafeUrl(node.href)) return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { children }, i);
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          "a",
+          {
+            href: node.href.trim(),
+            title: node.title,
+            ...isExternal(node.href) ? { target: "_blank", rel: "noopener noreferrer" } : {},
+            children
+          },
+          i
+        );
+      }
+      case "image": {
+        const resolved = policy.resolveImageSrc?.(node.src) ?? null;
+        if (resolved) {
+          return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("img", { src: resolved, alt: node.alt, title: node.title, loading: "lazy", decoding: "async" }, i);
+        }
+        const label = node.alt || node.src;
+        if (!node.src.trim() || !policy.isSafeUrl(node.src)) return label;
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("a", { href: node.src.trim(), ...isExternal(node.src) ? { target: "_blank", rel: "noopener noreferrer" } : {}, children: label }, i);
+      }
+    }
+  });
+}
+function renderList(list, policy, key) {
+  const items = list.items.map((item, i) => {
+    const content = renderInlines(item.children, policy);
+    const nested = item.lists.map((sub, n) => renderList(sub, policy, n));
+    if (item.checked === null) {
+      return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("li", { children: [
+        content,
+        nested
+      ] }, i);
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("li", { className: "uix-markdown__task", "data-checked": item.checked || void 0, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("input", { type: "checkbox", defaultChecked: item.checked, disabled: true, "aria-label": plainText(item.children) }),
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { children: content }),
+      nested
+    ] }, i);
+  });
+  const hasTasks = list.items.some((item) => item.checked !== null);
+  const className = hasTasks ? "uix-markdown__tasks" : void 0;
+  return list.ordered ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("ol", { className, start: list.start !== 1 ? list.start : void 0, children: items }, key) : /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("ul", { className, children: items }, key);
+}
+function renderBlock(block, policy, headingOffset, key) {
+  switch (block.type) {
+    case "paragraph":
+      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("p", { children: renderInlines(block.children, policy) }, key);
+    case "heading": {
+      const Tag = `h${Math.min(Math.max(block.level + headingOffset, 1), 6)}`;
+      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Tag, { children: renderInlines(block.children, policy) }, key);
+    }
+    case "code":
+      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("pre", { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("code", { "data-language": block.lang || void 0, children: block.value }) }, key);
+    case "quote":
+      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("blockquote", { children: renderInlines(block.children, policy) }, key);
+    case "rule":
+      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("hr", {}, key);
+    case "list":
+      return renderList(block, policy, key);
+    case "table":
+      return (
+        // A scrollable region must be reachable from the keyboard.
+        /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { className: "uix-markdown__table", tabIndex: 0, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("table", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("tr", { children: block.head.map((cell, c) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("th", { scope: "col", style: block.align[c] ? { textAlign: block.align[c] } : void 0, children: renderInlines(cell, policy) }, c)) }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("tbody", { children: block.rows.map((row, r) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("tr", { children: row.map((cell, c) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("td", { style: block.align[c] ? { textAlign: block.align[c] } : void 0, children: renderInlines(cell, policy) }, c)) }, r)) })
+        ] }) }, key)
+      );
+  }
+}
+function Markdown({ children, className, isSafeUrl = defaultMarkdownIsSafeUrl, resolveImageSrc, headingOffset = 2 }) {
+  const source = typeof children === "string" ? children : "";
+  if (source.trim() === "") return null;
+  const policy = { isSafeUrl, resolveImageSrc };
+  const blocks = parseMarkdown(source);
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { className: cx("uix-prose", "uix-markdown", className), "data-component": "markdown", children: blocks.map((block, i) => renderBlock(block, policy, headingOffset, i)) });
+}
+
+// src/components/Textarea.tsx
+var import_react6 = require("react");
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var Textarea = (0, import_react6.forwardRef)(
+  ({ invalid, className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+    "textarea",
+    {
+      ref,
+      className: cx("uix-textarea", className),
+      "aria-invalid": invalid || void 0,
+      ...props
+    }
+  )
+);
+Textarea.displayName = "Textarea";
+
+// src/components/RichTextEditor.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var DEFAULT_RICH_TEXT_LABELS = {
+  toolbar: "Formatting",
+  heading1: "Heading 1",
+  heading2: "Heading 2",
+  heading3: "Heading 3",
+  bold: "Bold",
+  italic: "Italic",
+  strike: "Strikethrough",
+  code: "Inline code",
+  bulletList: "Bulleted list",
+  orderedList: "Numbered list",
+  taskList: "Checklist",
+  blockquote: "Quote",
+  codeBlock: "Code block",
+  horizontalRule: "Divider",
+  link: "Link",
+  linkUrl: "Link address",
+  linkApply: "Apply",
+  linkRemove: "Remove link",
+  linkInvalid: "Use a web, mail or in-app address.",
+  table: "Table",
+  tableAddRow: "Add row",
+  tableAddColumn: "Add column",
+  tableDeleteRow: "Delete row",
+  tableDeleteColumn: "Delete column",
+  tableDelete: "Delete table",
+  image: "Image",
+  imageUploading: "Uploading image\u2026",
+  imageFailed: "The image could not be added.",
+  emoji: "Emoji",
+  emojiSuggestions: "Emoji suggestions",
+  undo: "Undo",
+  redo: "Redo",
+  sourceMode: "Show markdown",
+  richMode: "Show formatted",
+  characterCount: "{count} of {max} characters"
+};
+var COMMON = ["bold", "italic", "strike", "code", "bulletList", "orderedList", "taskList", "blockquote", "codeBlock", "link", "emoji", "history", "source"];
+var PRESETS = {
+  full: /* @__PURE__ */ new Set([...COMMON, "heading", "horizontalRule", "table", "image"]),
+  comment: new Set(COMMON),
+  template: /* @__PURE__ */ new Set([...COMMON, "heading", "horizontalRule", "table"])
+};
+var emojiSuggestionKey = new import_state.PluginKey("uixEmojiSuggestion");
+var SHORTCODE_RE = /:([a-zA-Z0-9_+-]+):$/;
+var emojiItems = OFFLINE_EMOJI_ITEMS;
+var findShortcode = (name) => emojiItems.find((item) => item.emoji && (item.name === name || item.shortcodes.includes(name)));
+function suggestEmoji(query, limit = 8) {
+  const q = query.toLowerCase();
+  if (q.length < 2) return [];
+  const starts = [];
+  const tagged = [];
+  for (const item of emojiItems) {
+    if (!item.emoji) continue;
+    if (item.shortcodes.some((s) => s.startsWith(q))) starts.push(item);
+    else if (item.tags.some((t) => t.startsWith(q))) tagged.push(item);
+    if (starts.length >= limit) break;
+  }
+  return [...starts, ...tagged].slice(0, limit);
+}
+var htmlAttr = (value) => value === void 0 || value === false || value === "" ? void 0 : String(value);
+var popoverOpen = (el) => {
+  try {
+    return el.matches(":popover-open");
+  } catch {
+    return false;
+  }
+};
+var isMac = () => typeof navigator !== "undefined" && /mac|iphone|ipad/i.test(navigator.platform || navigator.userAgent);
+function RichTextEditorFallback(props) {
+  const {
+    value,
+    onChange,
+    onSubmitShortcut,
+    placeholder,
+    disabled,
+    readOnly,
+    maxLength,
+    id,
+    name,
+    variant = "field",
+    toolbarEnd,
+    minRows,
+    className,
+    onBlur,
+    labels: labelOverrides
+  } = props;
+  const labels = { ...DEFAULT_RICH_TEXT_LABELS, ...labelOverrides };
+  const counterId = (0, import_react7.useId)();
+  const over = maxLength !== void 0 && value.length > maxLength;
+  const counter = maxLength !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { id: counterId, className: "uix-rich-text__counter", "data-over": over || void 0, children: formatLabel(labels.characterCount, { count: value.length, max: maxLength }) }) : null;
+  const textarea = /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    Textarea,
+    {
+      id,
+      name,
+      value,
+      onChange: (event) => onChange(event.target.value),
+      onBlur,
+      onKeyDown: (event) => {
+        if (onSubmitShortcut && (event.metaKey || event.ctrlKey) && event.key === "Enter") {
+          event.preventDefault();
+          onSubmitShortcut();
+        }
+      },
+      placeholder,
+      disabled,
+      readOnly,
+      rows: minRows ?? (variant === "composer" ? 3 : 4),
+      className: "uix-rich-text__source",
+      "aria-label": props["aria-label"],
+      "aria-labelledby": props["aria-labelledby"],
+      "aria-describedby": [props["aria-describedby"], counter ? counterId : void 0].filter(Boolean).join(" ") || void 0,
+      "aria-invalid": props["aria-invalid"] || over || void 0,
+      "aria-required": props["aria-required"] || void 0,
+      "data-editor-fallback": ""
+    }
+  );
+  if (variant === "composer") {
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Composer, { className: cx("uix-rich-text", "uix-rich-text--composer", className), children: [
+      textarea,
+      counter || toolbarEnd ? /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(ComposerBar, { className: "uix-rich-text__bar", children: [
+        counter,
+        toolbarEnd
+      ] }) : null
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: cx("uix-rich-text", "uix-rich-text--fallback", className), "data-disabled": disabled || void 0, children: [
+    textarea,
+    counter ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "uix-rich-text__footer", children: counter }) : null
+  ] });
+}
+function RichTextEditor(props) {
+  const {
+    value,
+    onChange,
+    features = "full",
+    headingLevels = [1, 2, 3],
+    onUploadImage,
+    isSafeUrl = defaultIsSafeUrl,
+    resolveImageSrc,
+    onSubmitShortcut,
+    emoji = true,
+    maxLength,
+    placeholder,
+    disabled = false,
+    readOnly = false,
+    labels: labelOverrides,
+    emojiPickerLabels,
+    emojiLocale,
+    id,
+    name,
+    variant = "field",
+    toolbarEnd,
+    minRows,
+    className,
+    onBlur,
+    emojiImageBaseUrl
+  } = props;
+  const emojiBase = (0, import_react7.useMemo)(() => normalizeEmojiImageBaseUrl(emojiImageBaseUrl), [emojiImageBaseUrl]);
+  const renderEmoji = useEmojiRenderer(emojiImageBaseUrl);
+  const labels = (0, import_react7.useMemo)(() => ({ ...DEFAULT_RICH_TEXT_LABELS, ...labelOverrides }), [labelOverrides]);
+  const uid = (0, import_react7.useId)();
+  const counterId = `${uid}-counter`;
+  const statusId = `${uid}-status`;
+  const suggestId = `${uid}-emoji`;
+  const linkPopoverId = `${uid}-link`;
+  const controls = PRESETS[features];
+  const has = (control) => controls.has(control) && (control !== "emoji" || emoji) && (control !== "image" || !!onUploadImage);
+  const latest = (0, import_react7.useRef)({ onChange, onSubmitShortcut, onBlur, isSafeUrl, resolveImageSrc, onUploadImage, placeholder, imagesOn: false });
+  latest.current = {
+    onChange,
+    onSubmitShortcut,
+    onBlur,
+    isSafeUrl,
+    resolveImageSrc,
+    onUploadImage,
+    placeholder,
+    imagesOn: controls.has("image") && !!onUploadImage
+  };
+  const lastValue = (0, import_react7.useRef)(value);
+  const origin = (0, import_react7.useRef)(null);
+  const [markdown, setMarkdown] = (0, import_react7.useState)(value);
+  const [mode, setMode] = (0, import_react7.useState)("rich");
+  const [status, setStatus] = (0, import_react7.useState)(null);
+  const [suggest, setSuggest] = (0, import_react7.useState)(null);
+  const [suggestIndex, setSuggestIndex] = (0, import_react7.useState)(0);
+  const [linkUrl, setLinkUrl] = (0, import_react7.useState)("");
+  const [linkError, setLinkError] = (0, import_react7.useState)(false);
+  const [rovingIndex, setRovingIndex] = (0, import_react7.useState)(0);
+  const toolbarRef = (0, import_react7.useRef)(null);
+  const linkButtonRef = (0, import_react7.useRef)(null);
+  const linkInputRef = (0, import_react7.useRef)(null);
+  const fileRef = (0, import_react7.useRef)(null);
+  const sourceRef = (0, import_react7.useRef)(null);
+  const openLinkRef = (0, import_react7.useRef)(() => {
+  });
+  const suggestState = (0, import_react7.useRef)({ suggest, suggestIndex });
+  suggestState.current = { suggest, suggestIndex };
+  const bridge = (0, import_react7.useRef)({ update: () => {
+  }, keyDown: () => false });
+  bridge.current = {
+    update: (p) => {
+      if (!p || p.items.length === 0) {
+        setSuggest(null);
+        return;
+      }
+      setSuggest({ query: p.query, items: p.items, command: p.command, rect: p.clientRect?.() ?? null });
+      setSuggestIndex(0);
+    },
+    keyDown: ({ event }) => {
+      const { suggest: open, suggestIndex: index } = suggestState.current;
+      if (!open) return false;
+      if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+        const delta = event.key === "ArrowDown" ? 1 : -1;
+        setSuggestIndex((index + delta + open.items.length) % open.items.length);
+        return true;
+      }
+      if (event.key === "Enter" || event.key === "Tab") {
+        const item = open.items[index];
+        if (item) open.command(item);
+        return true;
+      }
+      if (event.key === "Escape") {
+        setSuggest(null);
+        return true;
+      }
+      return false;
+    }
+  };
+  const headingKey = [...headingLevels].sort().join(",");
+  const extensions = (0, import_react7.useMemo)(() => {
+    const image = import_extension_image2.Image.extend({
+      parseHTML() {
+        return [{
+          tag: "img[src]",
+          // Pasted images are kept only when the consumer allows images and can resolve them.
+          getAttrs: (el) => {
+            const src = el.getAttribute("src") ?? "";
+            return latest.current.imagesOn && latest.current.resolveImageSrc?.(src) ? null : false;
+          }
+        }];
+      },
+      renderHTML({ node, HTMLAttributes }) {
+        const src = String(node.attrs.src ?? "");
+        const resolved = latest.current.resolveImageSrc?.(src) ?? null;
+        if (resolved) return ["img", (0, import_core2.mergeAttributes)(this.options.HTMLAttributes, HTMLAttributes, { src: resolved })];
+        return ["span", { class: "uix-rich-text__image-link", "data-src": src, title: src }, node.attrs.alt || src];
+      }
+    }).configure({ inline: true, allowBase64: false });
+    const unicodeEmoji = import_extension_emoji2.Emoji.extend({
+      addStorage() {
+        return { emojis: this.options.emojis, isSupported: () => true };
+      },
+      // Emoji are inserted as text; the node type exists only because the extension defines it.
+      // Unknown names (e.g. pasted from another editor) keep their shortcode rather than vanish.
+      renderMarkdown: (node) => {
+        const name2 = String(node.attrs?.name ?? "");
+        return findShortcode(name2)?.emoji ?? (name2 ? `:${name2}:` : "");
+      },
+      addInputRules() {
+        return [new import_core2.InputRule({
+          find: SHORTCODE_RE,
+          handler: ({ range, match, chain }) => {
+            const item = findShortcode(match[1] ?? "");
+            if (item?.emoji) chain().insertContentAt(range, item.emoji).run();
+          }
+        })];
+      },
+      addPasteRules() {
+        return [];
+      },
+      addProseMirrorPlugins() {
+        return [(0, import_suggestion.Suggestion)({ editor: this.editor, ...this.options.suggestion })];
+      }
+    }).configure({
+      // Offline list: no CDN fallbackImage, no GitHub image-only emoji (on-prem, CSP img-src 'self').
+      emojis: [...emojiItems],
+      enableEmoticons: false,
+      forceFallbackImages: false,
+      suggestion: {
+        char: ":",
+        pluginKey: emojiSuggestionKey,
+        items: ({ query }) => suggestEmoji(query),
+        command: ({ editor: editor2, range, props: item }) => {
+          if (item.emoji) editor2.chain().focus().insertContentAt(range, item.emoji).run();
+        },
+        allow: ({ state: state2, range }) => !state2.doc.resolve(range.from).parent.type.spec.code,
+        render: () => ({
+          onStart: (p) => bridge.current.update(p),
+          onUpdate: (p) => bridge.current.update(p),
+          onExit: () => bridge.current.update(null),
+          onKeyDown: (p) => bridge.current.keyDown(p)
+        })
+      }
+    });
+    const shortcuts = import_core2.Extension.create({
+      name: "uixRichTextShortcuts",
+      addKeyboardShortcuts() {
+        return {
+          "Mod-Enter": () => {
+            const submit = latest.current.onSubmitShortcut;
+            if (!submit) return false;
+            submit();
+            return true;
+          },
+          "Mod-k": () => {
+            openLinkRef.current();
+            return true;
+          },
+          "Mod-Shift-x": () => this.editor.commands.toggleStrike()
+        };
+      }
+    });
+    const emojiImages = import_core2.Extension.create({
+      name: "uixEmojiImages",
+      addProseMirrorPlugins() {
+        const key = new import_state.PluginKey("uixEmojiImages");
+        const build = (doc) => {
+          if (!emojiBase) return import_view.DecorationSet.empty;
+          const decorations = [];
+          doc.descendants((node, pos) => {
+            if (node.type.spec.code) return false;
+            if (!node.isText || !node.text) return true;
+            for (const match of node.text.matchAll(emojiPattern())) {
+              const glyph = match[0];
+              if (canRenderEmoji(glyph)) continue;
+              const from = pos + (match.index ?? 0);
+              decorations.push(import_view.Decoration.inline(from, from + glyph.length, { class: "uix-rich-text__emoji-text" }));
+              decorations.push(import_view.Decoration.widget(from, () => {
+                const img = document.createElement("img");
+                img.className = "uix-emoji-img";
+                img.alt = glyph;
+                img.draggable = false;
+                img.src = emojiImageSrc(emojiBase, glyph);
+                return img;
+              }, { side: -1, key: `emoji-${glyph}`, ignoreSelection: true }));
+            }
+            return false;
+          });
+          return import_view.DecorationSet.create(doc, decorations);
+        };
+        return [new import_state.Plugin({
+          key,
+          state: {
+            init: (_, state2) => build(state2.doc),
+            apply: (tr, previous) => tr.docChanged ? build(tr.doc) : previous
+          },
+          props: { decorations: (state2) => key.getState(state2) }
+        })];
+      }
+    });
+    return [
+      ...createSchemaExtensions({
+        headingLevels: headingKey.split(",").map(Number),
+        isSafeUrl: (url) => latest.current.isSafeUrl(url),
+        image
+      }),
+      import_markdown2.Markdown.configure({ marked: createMarked() }),
+      import_extensions.Placeholder.configure({ placeholder: () => latest.current.placeholder ?? "" }),
+      shortcuts,
+      ...emoji ? [unicodeEmoji] : [],
+      ...emojiBase ? [emojiImages] : []
+    ];
+  }, [headingKey, emoji, emojiBase]);
+  const managerOf = (ed) => {
+    const manager = ed.markdown ?? ed.storage.markdown.manager;
+    return patchManager(manager);
+  };
+  const load = (0, import_react7.useCallback)((ed, source) => {
+    const read = readMarkdown(source, managerOf(ed), ed.schema);
+    origin.current = read;
+    ed.chain().setMeta("addToHistory", false).setContent(read.doc, { emitUpdate: false }).run();
+  }, []);
+  const emit = (next) => {
+    if (next === lastValue.current) return;
+    lastValue.current = next;
+    setMarkdown(next);
+    latest.current.onChange(next);
+  };
+  const uploadImage = async (ed, file) => {
+    const upload = latest.current.onUploadImage;
+    if (!upload || !file.type.startsWith("image/")) return;
+    setStatus({ kind: "busy", text: labels.imageUploading });
+    try {
+      const { src, alt } = await upload(file);
+      ed.chain().focus().setImage({ src, alt }).run();
+      setStatus(null);
+    } catch (error) {
+      const message = error instanceof Error && error.message ? error.message : "";
+      setStatus({ kind: "error", text: message ? `${labels.imageFailed} ${message}` : labels.imageFailed });
+    }
+  };
+  const editor = (0, import_react8.useEditor)({
+    extensions,
+    immediatelyRender: false,
+    // Styles ship in @tensor_1/tokens (rich-text.css); no runtime <style> injection under CSP.
+    injectCSS: false,
+    shouldRerenderOnTransaction: false,
+    editable: !disabled && !readOnly,
+    editorProps: {
+      handlePaste: (_view, event) => {
+        const files = Array.from(event.clipboardData?.files ?? []).filter((f) => f.type.startsWith("image/"));
+        if (!files.length || !latest.current.imagesOn || !editorRef.current) return false;
+        files.forEach((file) => void uploadImage(editorRef.current, file));
+        return true;
+      },
+      handleDrop: (_view, event) => {
+        const files = Array.from(event.dataTransfer?.files ?? []).filter((f) => f.type.startsWith("image/"));
+        if (!files.length || !latest.current.imagesOn || !editorRef.current) return false;
+        event.preventDefault();
+        files.forEach((file) => void uploadImage(editorRef.current, file));
+        return true;
+      }
+    },
+    onCreate: ({ editor: ed }) => load(ed, lastValue.current),
+    onUpdate: ({ editor: ed }) => {
+      if (!origin.current) return;
+      emit(writeMarkdown(ed.getJSON(), origin.current, managerOf(ed)));
+    },
+    onBlur: () => latest.current.onBlur?.()
+  }, [extensions]);
+  const editorRef = (0, import_react7.useRef)(null);
+  editorRef.current = editor;
+  (0, import_react7.useEffect)(() => {
+    if (value === lastValue.current) return;
+    lastValue.current = value;
+    setMarkdown(value);
+    if (editor && !editor.isDestroyed) load(editor, value);
+  }, [value, editor, load]);
+  (0, import_react7.useEffect)(() => {
+    if (editor && !editor.isDestroyed) editor.setEditable(!disabled && !readOnly, false);
+  }, [editor, disabled, readOnly]);
+  const over = maxLength !== void 0 && markdown.length > maxLength;
+  const invalid = props["aria-invalid"] || over;
+  const describedBy = [props["aria-describedby"], maxLength !== void 0 ? counterId : void 0, status ? statusId : void 0].filter(Boolean).join(" ") || void 0;
+  const suggestOpen = !!suggest && mode === "rich";
+  const rows = minRows ?? (variant === "composer" ? 3 : 4);
+  (0, import_react7.useEffect)(() => {
+    if (!editor || editor.isDestroyed) return;
+    editor.setOptions({
+      editorProps: {
+        ...editor.options.editorProps,
+        attributes: Object.fromEntries(Object.entries({
+          id: mode === "rich" ? id : void 0,
+          role: "textbox",
+          "aria-multiline": "true",
+          "aria-label": props["aria-label"],
+          "aria-labelledby": props["aria-labelledby"],
+          "aria-describedby": describedBy,
+          "aria-invalid": htmlAttr(invalid),
+          "aria-required": htmlAttr(props["aria-required"]),
+          "aria-disabled": htmlAttr(disabled),
+          "aria-readonly": htmlAttr(readOnly),
+          "aria-autocomplete": emoji ? "list" : void 0,
+          "aria-controls": suggestOpen ? suggestId : void 0,
+          "aria-activedescendant": suggestOpen ? `${suggestId}-${suggestIndex}` : void 0,
+          class: "uix-rich-text__content uix-prose",
+          style: `min-height: calc(${rows} * 1lh + 2 * var(--uix-space-3))`
+        }).filter(([, v]) => v !== void 0))
+      }
+    });
+  }, [
+    editor,
+    mode,
+    id,
+    props["aria-label"],
+    props["aria-labelledby"],
+    describedBy,
+    invalid,
+    props["aria-required"],
+    disabled,
+    readOnly,
+    emoji,
+    suggestOpen,
+    suggestId,
+    suggestIndex,
+    rows
+  ]);
+  const state = (0, import_react8.useEditorState)({
+    editor,
+    selector: ({ editor: ed }) => {
+      if (!ed) return null;
+      const can = ed.can();
+      return {
+        bold: ed.isActive("bold"),
+        italic: ed.isActive("italic"),
+        strike: ed.isActive("strike"),
+        code: ed.isActive("code"),
+        h1: ed.isActive("heading", { level: 1 }),
+        h2: ed.isActive("heading", { level: 2 }),
+        h3: ed.isActive("heading", { level: 3 }),
+        bulletList: ed.isActive("bulletList"),
+        orderedList: ed.isActive("orderedList"),
+        taskList: ed.isActive("taskList"),
+        blockquote: ed.isActive("blockquote"),
+        codeBlock: ed.isActive("codeBlock"),
+        link: ed.isActive("link"),
+        inTable: ed.isActive("table"),
+        canUndo: can.undo(),
+        canRedo: can.redo()
+      };
+    }
+  });
+  const openLink = () => {
+    if (!editor || mode !== "rich") return;
+    setLinkUrl(String(editor.getAttributes("link").href ?? ""));
+    setLinkError(false);
+    const pop = document.getElementById(linkPopoverId);
+    if (pop && !popoverOpen(pop)) pop.showPopover();
+    requestAnimationFrame(() => linkInputRef.current?.select());
+  };
+  openLinkRef.current = openLink;
+  const closeLink = () => {
+    const pop = document.getElementById(linkPopoverId);
+    if (pop && popoverOpen(pop)) pop.hidePopover();
+    editor?.commands.focus();
+  };
+  const applyLink = () => {
+    if (!editor) return;
+    const url = linkUrl.trim();
+    if (!url) {
+      editor.chain().focus().extendMarkRange("link").unsetLink().run();
+      closeLink();
+      return;
+    }
+    if (!isSafeUrl(url)) {
+      setLinkError(true);
+      linkInputRef.current?.focus();
+      return;
+    }
+    const chain = editor.chain().focus().extendMarkRange("link");
+    if (editor.state.selection.empty && !editor.isActive("link")) {
+      chain.insertContent({ type: "text", text: url, marks: [{ type: "link", attrs: { href: url } }] }).run();
+    } else {
+      chain.setLink({ href: url }).run();
+    }
+    closeLink();
+  };
+  const toggleMode = () => {
+    if (!editor) return;
+    if (mode === "rich") {
+      setMode("source");
+      requestAnimationFrame(() => sourceRef.current?.focus());
+    } else {
+      load(editor, lastValue.current);
+      setMode("rich");
+      requestAnimationFrame(() => editor.commands.focus());
+    }
+  };
+  const insertEmoji = (glyph) => {
+    if (mode === "source") {
+      const box = sourceRef.current;
+      if (!box) return;
+      const next = `${box.value.slice(0, box.selectionStart)}${glyph}${box.value.slice(box.selectionEnd)}`;
+      const caret = box.selectionStart + glyph.length;
+      emit(next);
+      requestAnimationFrame(() => {
+        box.focus();
+        box.setSelectionRange(caret, caret);
+      });
+      return;
+    }
+    editor?.chain().focus().insertContent(glyph).run();
+  };
+  const run = (fn) => () => {
+    if (editor) fn(editor);
+  };
+  const locked = disabled || !editor;
+  const richOnly = locked || mode === "source";
+  const shortcut = (key) => `${isMac() ? "\u2318" : "Ctrl+"}${key}`;
+  const groups = [];
+  if (has("heading")) {
+    groups.push(headingLevels.map((level) => ({
+      key: `h${level}`,
+      icon: `heading${level}`,
+      label: labels[`heading${level}`],
+      pressed: !!state?.[`h${level}`],
+      disabled: richOnly,
+      onClick: run((ed) => ed.chain().focus().toggleHeading({ level }).run())
+    })));
+  }
+  const marks = [];
+  if (has("bold")) marks.push({ key: "bold", icon: "bold", label: labels.bold, hint: shortcut("B"), pressed: state?.bold, disabled: richOnly, onClick: run((ed) => ed.chain().focus().toggleBold().run()) });
+  if (has("italic")) marks.push({ key: "italic", icon: "italic", label: labels.italic, hint: shortcut("I"), pressed: state?.italic, disabled: richOnly, onClick: run((ed) => ed.chain().focus().toggleItalic().run()) });
+  if (has("strike")) marks.push({ key: "strike", icon: "strike", label: labels.strike, hint: shortcut("Shift+X"), pressed: state?.strike, disabled: richOnly, onClick: run((ed) => ed.chain().focus().toggleStrike().run()) });
+  if (has("code")) marks.push({ key: "code", icon: "code", label: labels.code, hint: shortcut("E"), pressed: state?.code, disabled: richOnly, onClick: run((ed) => ed.chain().focus().toggleCode().run()) });
+  if (has("link")) marks.push({ key: "link", icon: "link", label: labels.link, hint: shortcut("K"), pressed: state?.link, disabled: richOnly, onClick: openLink });
+  if (marks.length) groups.push(marks);
+  const blocks = [];
+  if (has("bulletList")) blocks.push({ key: "bulletList", icon: "bulletList", label: labels.bulletList, pressed: state?.bulletList, disabled: richOnly, onClick: run((ed) => ed.chain().focus().toggleBulletList().run()) });
+  if (has("orderedList")) blocks.push({ key: "orderedList", icon: "orderedList", label: labels.orderedList, pressed: state?.orderedList, disabled: richOnly, onClick: run((ed) => ed.chain().focus().toggleOrderedList().run()) });
+  if (has("taskList")) blocks.push({ key: "taskList", icon: "taskList", label: labels.taskList, pressed: state?.taskList, disabled: richOnly, onClick: run((ed) => ed.chain().focus().toggleTaskList().run()) });
+  if (has("blockquote")) blocks.push({ key: "blockquote", icon: "blockquote", label: labels.blockquote, pressed: state?.blockquote, disabled: richOnly, onClick: run((ed) => ed.chain().focus().toggleBlockquote().run()) });
+  if (has("codeBlock")) blocks.push({ key: "codeBlock", icon: "codeBlock", label: labels.codeBlock, pressed: state?.codeBlock, disabled: richOnly, onClick: run((ed) => ed.chain().focus().toggleCodeBlock().run()) });
+  if (has("horizontalRule")) blocks.push({ key: "horizontalRule", icon: "horizontalRule", label: labels.horizontalRule, disabled: richOnly, onClick: run((ed) => ed.chain().focus().setHorizontalRule().run()) });
+  if (blocks.length) groups.push(blocks);
+  const inserts = [];
+  if (has("table")) inserts.push({ key: "table", icon: "table", label: labels.table, pressed: state?.inTable, disabled: richOnly || state?.inTable, onClick: run((ed) => ed.chain().focus().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run()) });
+  if (has("image")) inserts.push({ key: "image", icon: "image", label: labels.image, disabled: richOnly || status?.kind === "busy", onClick: () => fileRef.current?.click() });
+  if (inserts.length) groups.push(inserts);
+  if (has("table") && state?.inTable && mode === "rich") {
+    groups.push([
+      { key: "tableAddRow", icon: "tableAddRow", label: labels.tableAddRow, disabled: locked, onClick: run((ed) => ed.chain().focus().addRowAfter().run()) },
+      { key: "tableAddColumn", icon: "tableAddColumn", label: labels.tableAddColumn, disabled: locked, onClick: run((ed) => ed.chain().focus().addColumnAfter().run()) },
+      { key: "tableDeleteRow", icon: "tableDeleteRow", label: labels.tableDeleteRow, disabled: locked, onClick: run((ed) => ed.chain().focus().deleteRow().run()) },
+      { key: "tableDeleteColumn", icon: "tableDeleteColumn", label: labels.tableDeleteColumn, disabled: locked, onClick: run((ed) => ed.chain().focus().deleteColumn().run()) },
+      { key: "tableDelete", icon: "trash", label: labels.tableDelete, disabled: locked, onClick: run((ed) => ed.chain().focus().deleteTable().run()) }
+    ]);
+  }
+  const trailing = [];
+  if (has("history")) {
+    trailing.push({ key: "undo", icon: "undo", label: labels.undo, hint: shortcut("Z"), disabled: richOnly || !state?.canUndo, onClick: run((ed) => ed.chain().focus().undo().run()) });
+    trailing.push({ key: "redo", icon: "redo", label: labels.redo, hint: shortcut(isMac() ? "Shift+Z" : "Y"), disabled: richOnly || !state?.canRedo, onClick: run((ed) => ed.chain().focus().redo().run()) });
+  }
+  if (has("source")) {
+    trailing.push({
+      key: "source",
+      icon: mode === "rich" ? "sourceMode" : "richMode",
+      label: mode === "rich" ? labels.sourceMode : labels.richMode,
+      pressed: mode === "source",
+      disabled: locked,
+      onClick: toggleMode
+    });
+  }
+  const tools = () => Array.from(toolbarRef.current?.querySelectorAll("button[data-tool]:not(:disabled)") ?? []);
+  const onToolbarKeyDown = (event) => {
+    const list = tools();
+    const current = list.indexOf(document.activeElement);
+    if (current < 0) return;
+    let next = current;
+    if (event.key === "ArrowRight") next = (current + 1) % list.length;
+    else if (event.key === "ArrowLeft") next = (current - 1 + list.length) % list.length;
+    else if (event.key === "Home") next = 0;
+    else if (event.key === "End") next = list.length - 1;
+    else return;
+    event.preventDefault();
+    list[next].focus();
+    list[next].scrollIntoView?.({ block: "nearest", inline: "nearest" });
+  };
+  const enabledCount = { value: 0 };
+  const renderTool = (tool) => {
+    const index = tool.disabled ? -1 : enabledCount.value++;
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+      "button",
+      {
+        ref: tool.key === "link" ? linkButtonRef : void 0,
+        type: "button",
+        "data-tool": tool.key,
+        className: "uix-rich-text__tool",
+        "aria-label": tool.label,
+        title: tool.hint ? `${tool.label} (${tool.hint})` : tool.label,
+        "aria-pressed": tool.pressed === void 0 ? void 0 : !!tool.pressed,
+        "aria-keyshortcuts": tool.hint ? tool.hint.replace("\u2318", "Meta+") : void 0,
+        disabled: tool.disabled,
+        tabIndex: index === rovingIndex ? 0 : -1,
+        onFocus: () => {
+          if (index >= 0) setRovingIndex(index);
+        },
+        onMouseDown: (event) => {
+          if (tool.key !== "source") event.preventDefault();
+        },
+        onClick: tool.onClick,
+        children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(EditorIcon, { name: tool.icon })
+      },
+      tool.key
+    );
+  };
+  (0, import_react7.useEffect)(() => {
+    const count = tools().length;
+    if (count && rovingIndex >= count) setRovingIndex(0);
+  });
+  const toolbar = readOnly ? null : /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+    "div",
+    {
+      ref: toolbarRef,
+      className: "uix-rich-text__toolbar",
+      role: "toolbar",
+      "aria-label": labels.toolbar,
+      "aria-controls": editor || mode === "source" ? id : void 0,
+      onKeyDown: onToolbarKeyDown,
+      children: [
+        groups.map((group, g) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "uix-rich-text__group", role: "group", children: group.map(renderTool) }, g)),
+        has("emoji") ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "uix-rich-text__group", role: "group", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          EmojiPicker,
+          {
+            labels: emojiPickerLabels,
+            locale: emojiLocale,
+            emojiImageBaseUrl,
+            onSelect: insertEmoji,
+            trigger: (() => {
+              const index = locked ? -1 : enabledCount.value++;
+              return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                "button",
+                {
+                  type: "button",
+                  "data-tool": "emoji",
+                  className: "uix-rich-text__tool",
+                  "aria-label": labels.emoji,
+                  title: labels.emoji,
+                  disabled: locked,
+                  tabIndex: index === rovingIndex ? 0 : -1,
+                  onFocus: () => {
+                    if (index >= 0) setRovingIndex(index);
+                  },
+                  onMouseDown: (event) => event.preventDefault(),
+                  children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(EditorIcon, { name: "emoji" })
+                }
+              );
+            })()
+          }
+        ) }) : null,
+        trailing.length ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "uix-rich-text__group uix-rich-text__group--end", role: "group", children: trailing.map(renderTool) }) : null,
+        has("link") ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Popover, { id: linkPopoverId, anchor: linkButtonRef, className: "uix-rich-text__link", role: "dialog", "aria-label": labels.link, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+          "form",
+          {
+            className: "uix-rich-text__link-form",
+            onSubmit: (event) => {
+              event.preventDefault();
+              applyLink();
+            },
+            onKeyDown: (event) => {
+              if (event.key === "Escape") {
+                event.preventDefault();
+                closeLink();
+              }
+            },
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "uix-field", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("label", { className: "uix-field__label", htmlFor: `${uid}-link-url`, children: labels.linkUrl }),
+                /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                  "input",
+                  {
+                    ref: linkInputRef,
+                    id: `${uid}-link-url`,
+                    className: "uix-input",
+                    type: "text",
+                    inputMode: "url",
+                    autoComplete: "url",
+                    value: linkUrl,
+                    "aria-invalid": linkError || void 0,
+                    "aria-describedby": linkError ? `${uid}-link-error` : void 0,
+                    onChange: (event) => {
+                      setLinkUrl(event.target.value);
+                      setLinkError(false);
+                    }
+                  }
+                ),
+                linkError ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "uix-field__msg", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { id: `${uid}-link-error`, className: "uix-field__error", role: "alert", children: labels.linkInvalid }) }) : null
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "uix-rich-text__link-actions", children: [
+                state?.link ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                  "button",
+                  {
+                    type: "button",
+                    className: "uix-btn uix-btn--ghost uix-btn--sm",
+                    onClick: () => {
+                      editor?.chain().focus().extendMarkRange("link").unsetLink().run();
+                      closeLink();
+                    },
+                    children: labels.linkRemove
+                  }
+                ) : null,
+                /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("button", { type: "submit", className: "uix-btn uix-btn--primary uix-btn--sm", children: labels.linkApply })
+              ] })
+            ]
+          }
+        ) }) : null,
+        has("image") ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          "input",
+          {
+            ref: fileRef,
+            type: "file",
+            accept: "image/*",
+            hidden: true,
+            tabIndex: -1,
+            "aria-hidden": "true",
+            onChange: (event) => {
+              const file = event.target.files?.[0];
+              event.target.value = "";
+              if (file && editor) void uploadImage(editor, file);
+            }
+          }
+        ) : null
+      ]
+    }
+  );
+  const surface = /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "uix-rich-text__surface", children: [
+    mode === "source" ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+      Textarea,
+      {
+        ref: sourceRef,
+        id,
+        value: markdown,
+        onChange: (event) => emit(event.target.value),
+        onBlur,
+        onKeyDown: (event) => {
+          if (onSubmitShortcut && (event.metaKey || event.ctrlKey) && event.key === "Enter") {
+            event.preventDefault();
+            onSubmitShortcut();
+          }
+        },
+        disabled,
+        readOnly,
+        placeholder,
+        rows,
+        spellCheck: false,
+        className: "uix-rich-text__source",
+        "aria-label": props["aria-label"],
+        "aria-labelledby": props["aria-labelledby"],
+        "aria-describedby": describedBy,
+        "aria-invalid": invalid || void 0,
+        "aria-required": props["aria-required"] || void 0
+      }
+    ) : editor ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react8.EditorContent, { editor, className: "uix-rich-text__editor" }) : (
+      // One frame before Tiptap mounts: the same content, read-only, without layout shift.
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "uix-rich-text__content uix-rich-text__content--loading", "aria-busy": "true", style: { minHeight: `calc(${rows} * 1lh + 2 * var(--uix-space-3))` }, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Markdown, { isSafeUrl, resolveImageSrc, children: value }) })
+    ),
+    suggestOpen && suggest ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+      EmojiSuggestions,
+      {
+        id: suggestId,
+        label: labels.emojiSuggestions,
+        items: suggest.items,
+        query: suggest.query,
+        active: suggestIndex,
+        rect: suggest.rect,
+        onPick: (item) => suggest.command(item),
+        renderEmoji
+      }
+    ) : null
+  ] });
+  const counter = maxLength !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { id: counterId, className: "uix-rich-text__counter", "data-over": over || void 0, children: formatLabel(labels.characterCount, { count: markdown.length, max: maxLength }) }) : null;
+  const statusLine = /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { id: statusId, className: "uix-rich-text__status", role: "status", "data-kind": status?.kind, children: status?.text ?? "" });
+  const hidden = name ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("input", { type: "hidden", name, value: markdown }) : null;
+  const stateAttrs = {
+    "data-disabled": disabled || void 0,
+    "data-readonly": readOnly || void 0,
+    "data-invalid": invalid || void 0,
+    "data-mode": mode
+  };
+  if (variant === "composer") {
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Composer, { className: cx("uix-rich-text", "uix-rich-text--composer", className), ...stateAttrs, children: [
+      surface,
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(ComposerBar, { className: "uix-rich-text__bar", children: [
+        toolbar,
+        statusLine,
+        counter,
+        toolbarEnd
+      ] }),
+      hidden
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: cx("uix-rich-text", className), ...stateAttrs, children: [
+    toolbar,
+    surface,
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "uix-rich-text__footer", children: [
+      statusLine,
+      counter,
+      toolbarEnd
+    ] }),
+    hidden
+  ] });
+}
+function EmojiSuggestions({ id, label, items, query, active, rect, onPick, renderEmoji }) {
+  const listRef = (0, import_react7.useRef)(null);
+  const [pos, setPos] = (0, import_react7.useState)(null);
+  (0, import_react7.useEffect)(() => {
+    const el = listRef.current;
+    if (!el || !rect || typeof window === "undefined") return;
+    const box = el.getBoundingClientRect();
+    const result = computePosition(
+      { x: rect.left, y: rect.top, width: rect.width, height: rect.height },
+      { width: box.width, height: box.height },
+      { width: window.innerWidth, height: window.innerHeight },
+      { placement: "bottom-start", offset: 4, padding: 8 }
+    );
+    setPos({ x: result.x, y: result.y });
+  }, [rect, items.length]);
+  (0, import_react7.useEffect)(() => {
+    document.getElementById(`${id}-${active}`)?.scrollIntoView?.({ block: "nearest" });
+  }, [active, id]);
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    "div",
+    {
+      ref: listRef,
+      id,
+      role: "listbox",
+      "aria-label": label,
+      className: "uix-rich-text__suggest",
+      style: { left: pos?.x ?? -9999, top: pos?.y ?? -9999 },
+      children: items.map((item, i) => /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+        "div",
+        {
+          id: `${id}-${i}`,
+          role: "option",
+          "aria-selected": i === active,
+          className: "uix-rich-text__suggest-item",
+          onMouseDown: (event) => {
+            event.preventDefault();
+            onPick(item);
+          },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "uix-rich-text__suggest-emoji", "aria-hidden": "true", children: renderEmoji(item.emoji ?? "") }),
+            /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { className: "uix-rich-text__suggest-name", children: [
+              ":",
+              item.shortcodes.find((s) => s.startsWith(query.toLowerCase())) ?? item.shortcodes[0] ?? item.name,
+              ":"
+            ] })
+          ]
+        },
+        item.name
+      ))
+    }
+  );
+}
+
+// src/rich-text/round-trip.ts
+var shared;
+async function roundTripMarkdown(markdown, options) {
+  const pipeline = options ? createPipeline(options) : shared ?? (shared = createPipeline());
+  const origin = pipeline.read(markdown);
+  const doc = pipeline.schema.nodeFromJSON(origin.doc).toJSON();
+  return pipeline.write(doc, origin);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_RICH_TEXT_LABELS,
+  RichTextEditor,
+  RichTextEditorFallback,
+  emojiImageFileName,
+  roundTripMarkdown
+});