open-wysiwyg-editor 0.1.0

package/dist/chunk-CDPXFV6R.js

@@ -0,0 +1,3361 @@
+import DOMPurify from 'dompurify';
+import { DOMParser, Slice, Schema } from 'prosemirror-model';
+import { liftTarget } from 'prosemirror-transform';
+import { PluginKey, EditorState, Plugin, NodeSelection, AllSelection, TextSelection, Selection } from 'prosemirror-state';
+import { EditorView, DecorationSet, Decoration } from 'prosemirror-view';
+import { keymap } from 'prosemirror-keymap';
+import { baseKeymap, setBlockType, lift, wrapIn, toggleMark, chainCommands, exitCode } from 'prosemirror-commands';
+import { inputRules, InputRule, wrappingInputRule, textblockTypeInputRule } from 'prosemirror-inputrules';
+import { liftListItem, wrapInList, sinkListItem, splitListItem } from 'prosemirror-schema-list';
+import { redo, undo, history } from 'prosemirror-history';
+import { dropCursor } from 'prosemirror-dropcursor';
+import { gapCursor } from 'prosemirror-gapcursor';
+import { columnResizing, tableEditing, goToNextCell, splitCell, mergeCells, deleteTable, deleteColumn, deleteRow, addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, toggleHeader, tableNodes } from 'prosemirror-tables';
+
+/*! open-wysiwyg-editor | MIT License | https://github.com/alhassan73/open-wysiwyg-editor */
+
+// src/core/extension.ts
+function defineExtension(config2, options = config2.defaultOptions ?? {}) {
+  return {
+    name: config2.name,
+    options,
+    config: config2,
+    configure(partial) {
+      return defineExtension(config2, mergeOptions(options, partial));
+    }
+  };
+}
+function mergeOptions(base, partial) {
+  if (!partial) return base;
+  const out = { ...base };
+  for (const [key, value] of Object.entries(partial)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    out[key] = value;
+  }
+  return out;
+}
+function resolveExtensions(list) {
+  const flat = [];
+  const visit = (ext) => {
+    const children = ext.config.extensions?.(ext.options) ?? [];
+    for (const child of children) visit(child);
+    flat.push(ext);
+  };
+  for (const ext of list) visit(ext);
+  const byName = /* @__PURE__ */ new Map();
+  for (const ext of flat) {
+    byName.delete(ext.name);
+    byName.set(ext.name, ext);
+  }
+  return [...byName.values()].map((ext, index) => ({ ext, index })).sort((a, b) => (b.ext.config.priority ?? 100) - (a.ext.config.priority ?? 100) || a.index - b.index).map(({ ext }) => ext);
+}
+
+// src/core/url.ts
+var DEFAULT_PROTOCOLS = ["http", "https", "mailto", "tel"];
+var STRIP = new RegExp("[\0--Ÿ­​-‏\u2028\u2029⁠\uFEFF]", "g");
+var SCHEME = /^([a-z][a-z0-9+.-]*):/i;
+var SAFE_DATA_IMAGE = /^data:image\/(?:png|jpe?g|gif|webp|avif);base64,[a-z0-9+/]+=*$/i;
+function sanitizeUrl(input, policy = {}, kind = "link") {
+  if (typeof input !== "string") return null;
+  const url = input.replace(STRIP, "").trim();
+  if (!url) return null;
+  const scheme = SCHEME.exec(url.replace(/\s+/g, ""));
+  if (!scheme) {
+    if (policy.allowRelative === false) return null;
+    return url;
+  }
+  const name = scheme[1].toLowerCase();
+  if (name === "data") {
+    return kind === "image" && policy.allowDataImages && SAFE_DATA_IMAGE.test(url) ? url : null;
+  }
+  const allowed = kind === "image" ? ["http", "https"] : policy.protocols ?? DEFAULT_PROTOCOLS;
+  return allowed.includes(name) ? url : null;
+}
+
+// src/core/html.ts
+var VOID = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+var NAME = /^[a-zA-Z][a-zA-Z0-9-]*$/;
+var ATTR_NAME = /^[a-zA-Z_:][a-zA-Z0-9_.:-]*$/;
+var FORBIDDEN_OUTPUT = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "base",
+  "meta",
+  "link",
+  "object",
+  "embed",
+  "applet",
+  "frame",
+  "frameset",
+  "template",
+  "noscript",
+  "form"
+]);
+var URL_ATTRS = /* @__PURE__ */ new Set(["href", "src", "cite", "poster", "action", "background"]);
+var DROP_ATTRS = /* @__PURE__ */ new Set(["srcdoc", "srcset", "formaction", "xlink:href", "ping"]);
+var NBSP = new RegExp(String.fromCharCode(160), "g");
+var escapeText = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(NBSP, "&nbsp;");
+var escapeAttr = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function renderAttrs(raw, policy) {
+  let attrs = "";
+  for (const [name, value] of Object.entries(raw)) {
+    if (value === null || value === void 0 || value === false) continue;
+    const lower = name.toLowerCase();
+    if (!ATTR_NAME.test(name) || lower.startsWith("on") || DROP_ATTRS.has(lower)) continue;
+    if (URL_ATTRS.has(lower)) {
+      const safe = sanitizeUrl(String(value), { ...policy, allowDataImages: true }, lower === "src" ? "image" : "link");
+      if (safe !== null) attrs += ` ${name}="${escapeAttr(safe)}"`;
+      continue;
+    }
+    attrs += value === true || value === "" ? ` ${name}=""` : ` ${name}="${escapeAttr(String(value))}"`;
+  }
+  return attrs;
+}
+function renderSpec(spec, hole, policy) {
+  if (typeof spec === "string") return escapeText(spec);
+  if (!Array.isArray(spec)) {
+    throw new Error("[open-wysiwyg-editor] toDOM/toHTML must return an array spec to be serializable.");
+  }
+  const [rawTag, ...rest] = spec;
+  const tag = rawTag.includes(" ") ? rawTag.split(" ")[1] : rawTag;
+  if (!NAME.test(tag)) throw new Error(`[open-wysiwyg-editor] Invalid tag name "${tag}".`);
+  if (FORBIDDEN_OUTPUT.has(tag.toLowerCase())) return "";
+  let attrs = "";
+  let start = 0;
+  const first = rest[0];
+  if (first && typeof first === "object" && !Array.isArray(first)) {
+    start = 1;
+    attrs = renderAttrs(first, policy);
+  }
+  if (VOID.has(tag.toLowerCase())) return `<${tag}${attrs}>`;
+  let inner = "";
+  for (let i = start; i < rest.length; i++) {
+    const child = rest[i];
+    inner += child === 0 ? hole ? hole() : "" : renderSpec(child, hole, policy);
+  }
+  return `<${tag}${attrs}>${inner}</${tag}>`;
+}
+function renderNodeSpec(node) {
+  const spec = node.type.spec;
+  const fn = spec.toHTML ?? spec.toDOM;
+  if (!fn) throw new Error(`[open-wysiwyg-editor] Node "${node.type.name}" has no toDOM/toHTML.`);
+  return fn(node);
+}
+function markParts(mark, inline, policy) {
+  const spec = mark.type.spec;
+  const fn = spec.toHTML ?? spec.toDOM;
+  if (!fn) return ["", ""];
+  const token = `\0${Math.random().toString(36).slice(2)}\0`;
+  const html = renderSpec(fn(mark, inline), () => token, policy);
+  const at = html.indexOf(token);
+  return at === -1 ? [html, ""] : [html.slice(0, at), html.slice(at + token.length)];
+}
+function serializeNode(node, policy = {}) {
+  if (node.isText) return escapeText(node.text ?? "");
+  return renderSpec(renderNodeSpec(node), () => serializeFragment(node.content, policy), policy);
+}
+function serializeFragment(fragment, policy = {}) {
+  let out = "";
+  const active = [];
+  fragment.forEach((node) => {
+    if (active.length || node.marks.length) {
+      let keep = 0;
+      let rendered = 0;
+      while (keep < active.length && rendered < node.marks.length) {
+        const next = node.marks[rendered];
+        if (!next.eq(active[keep].mark) || next.type.spec.spanning === false) break;
+        keep++;
+        rendered++;
+      }
+      while (keep < active.length) out += active.pop().close;
+      while (rendered < node.marks.length) {
+        const mark = node.marks[rendered++];
+        const [open, close] = markParts(mark, node.isInline, policy);
+        out += open;
+        active.push({ mark, close });
+      }
+    }
+    out += serializeNode(node, policy);
+  });
+  while (active.length) out += active.pop().close;
+  return out;
+}
+function docToHTML(doc, policy = {}) {
+  return serializeFragment(doc.content, policy);
+}
+
+// src/core/i18n.ts
+var defaultLabels = {
+  editorLabel: "Rich text editor",
+  toolbar: "Formatting",
+  more: "More",
+  // Marks
+  bold: "Bold",
+  italic: "Italic",
+  underline: "Underline",
+  strike: "Strikethrough",
+  code: "Inline code",
+  subscript: "Subscript",
+  superscript: "Superscript",
+  link: "Link",
+  unlink: "Remove link",
+  removeFormat: "Clear formatting",
+  // Blocks
+  blockType: "Text style",
+  paragraph: "Paragraph",
+  heading: "Heading {level}",
+  blockquote: "Quote",
+  codeBlock: "Code block",
+  horizontalRule: "Horizontal line",
+  hardBreak: "Line break",
+  bulletList: "Bulleted list",
+  orderedList: "Numbered list",
+  taskList: "Checklist",
+  task: "Task",
+  toggleTask: "Mark task as done",
+  indent: "Increase indent",
+  outdent: "Decrease indent",
+  // Alignment & direction
+  align: "Alignment",
+  alignStart: "Align start",
+  alignCenter: "Align center",
+  alignEnd: "Align end",
+  alignJustify: "Justify",
+  direction: "Text direction",
+  dirLtr: "Left to right",
+  dirRtl: "Right to left",
+  dirAuto: "Automatic direction",
+  // History
+  undo: "Undo",
+  redo: "Redo",
+  // Image
+  image: "Image",
+  insertImage: "Insert image",
+  imageUrl: "Image address (URL)",
+  imageUpload: "Upload from device",
+  altText: "Alternative text",
+  altHelp: `Describe the image for people who can't see it. Leave out "image of".`,
+  decorative: "Decorative image (no description needed)",
+  caption: "Caption",
+  imageSize: "Size",
+  sizeSmall: "Small",
+  sizeMedium: "Medium",
+  sizeLarge: "Large",
+  sizeOriginal: "Original",
+  // Table
+  table: "Table",
+  insertTable: "Insert table",
+  rows: "Rows",
+  columns: "Columns",
+  headerRow: "Header row",
+  headerColumn: "Header column",
+  tableCaption: "Table caption",
+  addRowBefore: "Insert row above",
+  addRowAfter: "Insert row below",
+  addColumnBefore: "Insert column before",
+  addColumnAfter: "Insert column after",
+  deleteRow: "Delete row",
+  deleteColumn: "Delete column",
+  deleteTable: "Delete table",
+  mergeCells: "Merge cells",
+  splitCell: "Split cell",
+  tableSize: "{rows} by {cols} table",
+  // Link dialog
+  linkUrl: "Link address (URL)",
+  linkText: "Text to display",
+  linkNewTab: "Open in a new tab",
+  invalidUrl: "This address is not allowed. Use a web address (https://…), email (mailto:) or phone (tel:).",
+  // Dialog
+  insert: "Insert",
+  save: "Save",
+  cancel: "Cancel",
+  close: "Close",
+  apply: "Apply",
+  remove: "Remove",
+  // Find & replace
+  find: "Find",
+  findAndReplace: "Find and replace",
+  replace: "Replace",
+  replaceWith: "Replace with",
+  replaceAll: "Replace all",
+  findNext: "Next match",
+  findPrevious: "Previous match",
+  matchCase: "Match case",
+  wholeWord: "Whole words",
+  matchCount: { zero: "No matches", one: "{current} of {n} match", other: "{current} of {n} matches" },
+  replacedCount: { one: "Replaced {n} match", other: "Replaced {n} matches" },
+  // Status
+  wordCount: { one: "{n} word", other: "{n} words" },
+  charCount: { one: "{n} character", other: "{n} characters" },
+  charLimit: "{n} of {limit} characters",
+  charLimitReached: "Character limit reached",
+  elementPath: "Element path",
+  // Announcements
+  on: "{name} on",
+  off: "{name} off",
+  inserted: "{name} inserted",
+  pasteCleaned: "Pasted content was cleaned up",
+  pasteDropped: "Some pasted content isn't supported and was removed",
+  // Help
+  shortcuts: "Keyboard shortcuts",
+  shortcutsHelp: "Press {shortcut} to move to the toolbar, Escape to return to the text.",
+  // Accessibility checker
+  a11yChecker: "Accessibility checker",
+  a11yIssues: { zero: "No accessibility issues", one: "{n} accessibility issue", other: "{n} accessibility issues" },
+  // Placeholder
+  placeholder: "Start writing…",
+  // Element path & structure
+  listItem: "List item",
+  tableRow: "Row",
+  tableCell: "Cell",
+  tableHeader: "Header cell",
+  selectElement: "Select {name}",
+  // Dialogs & UI
+  editLink: "Edit link",
+  editImage: "Edit image",
+  required: "required",
+  altRequired: "Describe the image, or mark it as decorative.",
+  urlRequired: "Enter an address.",
+  tableOptions: "Table options",
+  tableProperties: "Table properties",
+  closeFind: "Close find and replace",
+  action: "Action",
+  shortcut: "Shortcut",
+  leaveEditor: "Press Escape, then Tab, to leave the editor from inside a list or table.",
+  markdownShortcuts: "Typing shortcuts",
+  navigation: "Navigation",
+  formatting: "Formatting",
+  blocks: "Blocks",
+  focusToolbar: "Move focus to the toolbar",
+  showShortcuts: "Show keyboard shortcuts",
+  openFind: "Find and replace",
+  insertLink: "Insert link",
+  sourceCode: "Source code",
+  sourceCleaned: "Some HTML isn't supported and was removed or simplified",
+  // Colors
+  textColor: "Text color",
+  highlight: "Highlight color",
+  automatic: "Automatic",
+  noHighlight: "No highlight",
+  customColor: "Custom color",
+  color: "Color",
+  hexValue: "Hex value",
+  invalidColor: "Enter a color such as #1a73e8.",
+  contrastText: "Contrast on a white background: {ratio}:1",
+  contrastBg: "Contrast with dark text: {ratio}:1",
+  contrastPass: "Meets WCAG AA for normal text.",
+  contrastFail: "Below the 4.5:1 minimum for normal text (WCAG 1.4.3).",
+  colorBlack: "Black",
+  colorDarkGray: "Dark gray",
+  colorDarkRed: "Dark red",
+  colorDarkOrange: "Dark orange",
+  colorOlive: "Olive",
+  colorDarkGreen: "Dark green",
+  colorTeal: "Teal",
+  colorBlue: "Blue",
+  colorPurple: "Purple",
+  colorMagenta: "Magenta",
+  colorYellow: "Yellow",
+  colorGreen: "Green",
+  colorPink: "Pink",
+  colorOrange: "Orange",
+  colorGray: "Gray"
+};
+var arabicLabels = {
+  editorLabel: "محرر النصوص",
+  toolbar: "التنسيق",
+  more: "المزيد",
+  bold: "عريض",
+  italic: "مائل",
+  underline: "تسطير",
+  strike: "يتوسطه خط",
+  code: "شيفرة سطرية",
+  subscript: "منخفض",
+  superscript: "مرتفع",
+  link: "رابط",
+  unlink: "إزالة الرابط",
+  removeFormat: "مسح التنسيق",
+  blockType: "نمط النص",
+  paragraph: "فقرة",
+  heading: "عنوان {level}",
+  blockquote: "اقتباس",
+  codeBlock: "كتلة شيفرة",
+  horizontalRule: "خط أفقي",
+  hardBreak: "سطر جديد",
+  bulletList: "قائمة نقطية",
+  orderedList: "قائمة مرقّمة",
+  taskList: "قائمة مهام",
+  task: "مهمة",
+  toggleTask: "تعليم المهمة كمنجزة",
+  indent: "زيادة المسافة البادئة",
+  outdent: "إنقاص المسافة البادئة",
+  align: "المحاذاة",
+  alignStart: "محاذاة إلى البداية",
+  alignCenter: "توسيط",
+  alignEnd: "محاذاة إلى النهاية",
+  alignJustify: "ضبط",
+  direction: "اتجاه النص",
+  dirLtr: "من اليسار إلى اليمين",
+  dirRtl: "من اليمين إلى اليسار",
+  dirAuto: "اتجاه تلقائي",
+  undo: "تراجع",
+  redo: "إعادة",
+  image: "صورة",
+  insertImage: "إدراج صورة",
+  imageUrl: "عنوان الصورة (URL)",
+  imageUpload: "رفع من الجهاز",
+  altText: "النص البديل",
+  altHelp: 'صِف الصورة لمن لا يستطيع رؤيتها، دون كتابة "صورة لـ".',
+  decorative: "صورة زخرفية (لا تحتاج إلى وصف)",
+  caption: "تعليق",
+  imageSize: "الحجم",
+  sizeSmall: "صغير",
+  sizeMedium: "متوسط",
+  sizeLarge: "كبير",
+  sizeOriginal: "الحجم الأصلي",
+  table: "جدول",
+  insertTable: "إدراج جدول",
+  rows: "الصفوف",
+  columns: "الأعمدة",
+  headerRow: "صف العناوين",
+  headerColumn: "عمود العناوين",
+  tableCaption: "عنوان الجدول",
+  addRowBefore: "إدراج صف أعلى",
+  addRowAfter: "إدراج صف أسفل",
+  addColumnBefore: "إدراج عمود قبل",
+  addColumnAfter: "إدراج عمود بعد",
+  deleteRow: "حذف الصف",
+  deleteColumn: "حذف العمود",
+  deleteTable: "حذف الجدول",
+  mergeCells: "دمج الخلايا",
+  splitCell: "تقسيم الخلية",
+  tableSize: "جدول {rows} × {cols}",
+  linkUrl: "عنوان الرابط (URL)",
+  linkText: "النص المعروض",
+  linkNewTab: "فتح في علامة تبويب جديدة",
+  invalidUrl: "هذا العنوان غير مسموح. استخدم عنوان ويب (https://…) أو بريدًا (mailto:) أو هاتفًا (tel:).",
+  insert: "إدراج",
+  save: "حفظ",
+  cancel: "إلغاء",
+  close: "إغلاق",
+  apply: "تطبيق",
+  remove: "إزالة",
+  find: "بحث",
+  findAndReplace: "بحث واستبدال",
+  replace: "استبدال",
+  replaceWith: "استبدال بـ",
+  replaceAll: "استبدال الكل",
+  findNext: "التطابق التالي",
+  findPrevious: "التطابق السابق",
+  matchCase: "مطابقة حالة الأحرف",
+  wholeWord: "كلمات كاملة",
+  matchCount: {
+    zero: "لا توجد نتائج",
+    one: "{current} من نتيجة واحدة",
+    two: "{current} من نتيجتين",
+    few: "{current} من {n} نتائج",
+    many: "{current} من {n} نتيجة",
+    other: "{current} من {n} نتيجة"
+  },
+  replacedCount: {
+    zero: "لم يُستبدل شيء",
+    one: "تم استبدال نتيجة واحدة",
+    two: "تم استبدال نتيجتين",
+    few: "تم استبدال {n} نتائج",
+    many: "تم استبدال {n} نتيجة",
+    other: "تم استبدال {n} نتيجة"
+  },
+  wordCount: {
+    zero: "لا كلمات",
+    one: "كلمة واحدة",
+    two: "كلمتان",
+    few: "{n} كلمات",
+    many: "{n} كلمة",
+    other: "{n} كلمة"
+  },
+  charCount: {
+    zero: "لا أحرف",
+    one: "حرف واحد",
+    two: "حرفان",
+    few: "{n} أحرف",
+    many: "{n} حرفًا",
+    other: "{n} حرف"
+  },
+  charLimit: "{n} من {limit} حرف",
+  charLimitReached: "تم الوصول إلى الحد الأقصى للأحرف",
+  elementPath: "مسار العنصر",
+  on: "{name}: مُفعّل",
+  off: "{name}: غير مُفعّل",
+  inserted: "تم إدراج {name}",
+  pasteCleaned: "تم تنظيف المحتوى الملصق",
+  pasteDropped: "بعض المحتوى الملصق غير مدعوم وتمت إزالته",
+  shortcuts: "اختصارات لوحة المفاتيح",
+  shortcutsHelp: "اضغط {shortcut} للانتقال إلى شريط الأدوات، وEscape للعودة إلى النص.",
+  a11yChecker: "مدقق إمكانية الوصول",
+  a11yIssues: {
+    zero: "لا توجد مشكلات في إمكانية الوصول",
+    one: "مشكلة واحدة في إمكانية الوصول",
+    two: "مشكلتان في إمكانية الوصول",
+    few: "{n} مشكلات في إمكانية الوصول",
+    many: "{n} مشكلة في إمكانية الوصول",
+    other: "{n} مشكلة في إمكانية الوصول"
+  },
+  placeholder: "ابدأ الكتابة…",
+  listItem: "عنصر قائمة",
+  tableRow: "صف",
+  tableCell: "خلية",
+  tableHeader: "خلية عنوان",
+  selectElement: "تحديد {name}",
+  editLink: "تعديل الرابط",
+  editImage: "تعديل الصورة",
+  required: "مطلوب",
+  altRequired: "صِف الصورة، أو حدّدها كصورة زخرفية.",
+  urlRequired: "أدخل عنوانًا.",
+  tableOptions: "خيارات الجدول",
+  tableProperties: "خصائص الجدول",
+  closeFind: "إغلاق البحث والاستبدال",
+  action: "الإجراء",
+  shortcut: "الاختصار",
+  leaveEditor: "اضغط Escape ثم Tab لمغادرة المحرر من داخل قائمة أو جدول.",
+  markdownShortcuts: "اختصارات الكتابة",
+  navigation: "التنقل",
+  formatting: "التنسيق",
+  blocks: "الكتل",
+  focusToolbar: "نقل التركيز إلى شريط الأدوات",
+  showShortcuts: "عرض اختصارات لوحة المفاتيح",
+  openFind: "بحث واستبدال",
+  insertLink: "إدراج رابط",
+  sourceCode: "الشيفرة المصدرية",
+  sourceCleaned: "بعض شيفرة HTML غير مدعومة وتمت إزالتها أو تبسيطها",
+  textColor: "لون النص",
+  highlight: "لون التمييز",
+  automatic: "تلقائي",
+  noHighlight: "بدون تمييز",
+  customColor: "لون مخصص",
+  color: "اللون",
+  hexValue: "القيمة السداسية",
+  invalidColor: "أدخل لونًا مثل ‎#1a73e8.",
+  contrastText: "التباين على خلفية بيضاء: ‎{ratio}:1",
+  contrastBg: "التباين مع نص داكن: ‎{ratio}:1",
+  contrastPass: "يستوفي معيار WCAG AA للنص العادي.",
+  contrastFail: "أقل من الحد الأدنى 4.5:1 للنص العادي (WCAG 1.4.3).",
+  colorBlack: "أسود",
+  colorDarkGray: "رمادي داكن",
+  colorDarkRed: "أحمر داكن",
+  colorDarkOrange: "برتقالي داكن",
+  colorOlive: "زيتوني",
+  colorDarkGreen: "أخضر داكن",
+  colorTeal: "أزرق مخضر",
+  colorBlue: "أزرق",
+  colorPurple: "بنفسجي",
+  colorMagenta: "أرجواني",
+  colorYellow: "أصفر",
+  colorGreen: "أخضر",
+  colorPink: "وردي",
+  colorOrange: "برتقالي",
+  colorGray: "رمادي"
+};
+var builtInLanguages = [
+  { code: "en", name: "English", dir: "ltr", labels: {} },
+  { code: "ar", name: "العربية", dir: "rtl", labels: arabicLabels }
+];
+var RTL_LANGS = /^(ar|arc|ckb|dv|fa|he|iw|ks|ps|sd|ug|ur|yi)(-|$)/i;
+function resolveLanguage(code, languages = builtInLanguages) {
+  const wanted = code ?? (typeof document !== "undefined" ? document.documentElement.lang : "") ?? "en";
+  const lower = wanted.toLowerCase();
+  return languages.find((l) => l.code.toLowerCase() === lower) ?? languages.find((l) => lower.split("-")[0] === l.code.toLowerCase().split("-")[0]) ?? languages[0] ?? { code: "en", name: "English", dir: "ltr", labels: {} };
+}
+function createI18n(language, overrides = {}) {
+  const labels = { ...defaultLabels, ...language.labels, ...overrides };
+  let plural = null;
+  try {
+    plural = new Intl.PluralRules(language.code);
+  } catch {
+    plural = null;
+  }
+  const t = (key, vars = {}) => {
+    const label = labels[key] ?? defaultLabels[key];
+    let text;
+    if (label === void 0) text = String(key);
+    else if (typeof label === "string") text = label;
+    else {
+      const n = Number(vars.n ?? 0);
+      const form = n === 0 && label.zero ? "zero" : plural?.select(n) ?? "other";
+      text = label[form] ?? label.other ?? Object.values(label)[0] ?? key;
+    }
+    return text.replace(
+      /\{(\w+)\}/g,
+      (m, name) => name in vars ? formatVar(vars[name], language.code) : m
+    );
+  };
+  return {
+    lang: language.code,
+    dir: language.dir ?? (RTL_LANGS.test(language.code) ? "rtl" : "ltr"),
+    t
+  };
+}
+function formatVar(value, lang) {
+  if (typeof value !== "number") return value;
+  try {
+    return new Intl.NumberFormat(lang).format(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/core/trusted-types.ts
+var TRUSTED_TYPES_POLICY_NAME = "open-wysiwyg-editor";
+var REGISTRY = /* @__PURE__ */ Symbol.for("open-wysiwyg-editor.tt-policy");
+var custom;
+function setTrustedTypesPolicy(policy) {
+  custom = policy;
+}
+function getTrustedTypesPolicy() {
+  if (custom !== void 0) return custom;
+  const store = globalThis;
+  if (store[REGISTRY] !== void 0) return store[REGISTRY] ?? null;
+  const tt = globalThis.trustedTypes;
+  let policy = null;
+  if (tt && typeof tt.createPolicy === "function") {
+    try {
+      policy = tt.createPolicy(TRUSTED_TYPES_POLICY_NAME, {
+        createHTML: (s) => s,
+        // DOMPurify requires this hook; the editor never produces script URLs.
+        createScriptURL: () => ""
+      });
+    } catch {
+      policy = null;
+    }
+  }
+  store[REGISTRY] = policy;
+  return policy;
+}
+var FORBIDDEN_TAGS = [
+  "script",
+  "style",
+  "iframe",
+  "frame",
+  "frameset",
+  "object",
+  "embed",
+  "applet",
+  "form",
+  "input",
+  "button",
+  "select",
+  "textarea",
+  "option",
+  "base",
+  "meta",
+  "link",
+  "template",
+  "noscript",
+  "svg",
+  "math"
+];
+var DROPPED_CONTENTS = [
+  "script",
+  "style",
+  "template",
+  "noscript",
+  "iframe",
+  "frame",
+  "frameset",
+  "object",
+  "embed",
+  "applet",
+  "svg",
+  "math",
+  "select",
+  "option",
+  "textarea",
+  "button",
+  "head",
+  "title"
+];
+var FORBIDDEN_ATTRS = ["srcdoc", "formaction", "xlink:href", "action", "ping"];
+function config(extra) {
+  const policy = getTrustedTypesPolicy();
+  return {
+    FORBID_TAGS: FORBIDDEN_TAGS,
+    FORBID_ATTR: FORBIDDEN_ATTRS,
+    // Drop the *contents* of these too (not just the tags): CSS, scripts, form widgets, etc.
+    ADD_FORBID_CONTENTS: DROPPED_CONTENTS,
+    ALLOW_UNKNOWN_PROTOCOLS: false,
+    // Pasted Office/Google Docs content carries formatting in `style`; the schema parser reads
+    // only the specific properties it understands and never copies raw style into the document.
+    ...policy ? { TRUSTED_TYPES_POLICY: policy } : {},
+    ...extra
+  };
+}
+function stripInertBlocks(html) {
+  return html.replace(/<style\b[^>]*>[\s\S]*?<\/style\s*>/gi, "").replace(/<!--\[if[\s\S]*?<!\[endif\]-->/gi, "").replace(/<xml\b[^>]*>[\s\S]*?<\/xml\s*>/gi, "");
+}
+var STYLE_DATA_ATTR = "data-owe-style";
+var STYLE_ATTR = /(<[a-z][^\s/>]*(?:\s+[^\s/>="']+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*?\s+)style(?=\s*=)/gi;
+function protectStyles(html) {
+  return html.replace(STYLE_ATTR, `$1${STYLE_DATA_ATTR}`);
+}
+function restoreStyles(root) {
+  const scope = root;
+  if (typeof scope.querySelectorAll !== "function") return;
+  for (const el of [...scope.querySelectorAll(`[${STYLE_DATA_ATTR}]`)]) {
+    const css = el.getAttribute(STYLE_DATA_ATTR) ?? "";
+    el.removeAttribute(STYLE_DATA_ATTR);
+    if (el.style) el.style.cssText = css;
+  }
+}
+function sanitizePastedHTML(html) {
+  return DOMPurify.sanitize(stripInertBlocks(html), { ...config(), RETURN_TRUSTED_TYPE: false });
+}
+function sanitizeToFragment(html) {
+  const fragment = DOMPurify.sanitize(`<div data-owe-wrap="">${protectStyles(stripInertBlocks(html))}</div>`, {
+    ...config(),
+    RETURN_DOM_FRAGMENT: true
+  });
+  for (const wrap of [...fragment.children].filter((el) => el.hasAttribute("data-owe-wrap"))) {
+    wrap.replaceWith(...wrap.childNodes);
+  }
+  return fragment;
+}
+function sanitizeHTML(html, options) {
+  const purify = options?.window ? DOMPurify(options.window) : DOMPurify;
+  return purify.sanitize(html, { ...config(options?.config), RETURN_TRUSTED_TYPE: false });
+}
+
+// src/core/paste.ts
+var STYLED = `[${STYLE_DATA_ATTR}]`;
+var WORD = /urn:schemas-microsoft-com:office|class=["']?Mso|mso-[a-z-]+:/i;
+var GDOCS = /id=["']?docs-internal-guid/i;
+var MSO_IGNORE = /mso-list\s*:\s*ignore/i;
+var MSO_LEVEL = /mso-list\s*:[^;"]*level(\d+)/i;
+var BULLETS = /^[•·▪●◦–—o§·•▪●◦\-*]$/;
+var ORDERED = /^\(?([0-9]{1,4}|[a-zA-Z]|[ivxlcdmIVXLCDM]{1,6})[.)]$/;
+var BLOCKS = ":scope > :is(p, h1, h2, h3, h4, h5, h6, div, ul, ol, table, blockquote, pre)";
+function cleanPastedHTML(input, policy = {}) {
+  const fragment = sanitizeToFragment(input);
+  if (!fragment.ownerDocument) return { html: "", dropped: false, cleaned: false };
+  const root = fragment.ownerDocument.createElement("div");
+  root.append(fragment);
+  const isWord = WORD.test(input);
+  const isGDocs = GDOCS.test(input);
+  let cleaned = false;
+  let dropped = false;
+  if (isWord) {
+    convertWordLists(root);
+    for (const el of [...root.querySelectorAll(STYLED)]) {
+      if (MSO_IGNORE.test(el.getAttribute(STYLE_DATA_ATTR) ?? "")) el.remove();
+    }
+    for (const span of [...root.querySelectorAll("span")].reverse()) {
+      if (!span.textContent && !span.querySelector("img, br")) span.remove();
+    }
+    cleaned = true;
+  }
+  if (isGDocs) {
+    for (const el of root.querySelectorAll("[dir]")) el.removeAttribute("dir");
+    cleaned = true;
+  }
+  cleaned = nestLooseLists(root) || cleaned;
+  cleaned = nestAriaLevelLists(root) || cleaned;
+  for (const img of [...root.querySelectorAll("img")]) {
+    if (!sanitizeUrl(img.getAttribute("src"), policy, "image")) {
+      img.remove();
+      dropped = true;
+    }
+  }
+  for (const font of [...root.querySelectorAll("font")]) font.replaceWith(...font.childNodes);
+  return { html: serializeInert(root), dropped, cleaned };
+}
+function serializeInert(container) {
+  return container.innerHTML;
+}
+function isWordListParagraph(el) {
+  return el.tagName === "P" && /mso-list\s*:/i.test(el.getAttribute(STYLE_DATA_ATTR) ?? "") && !MSO_IGNORE.test(el.getAttribute(STYLE_DATA_ATTR) ?? "");
+}
+function markerOf(p) {
+  const ignore = [...p.querySelectorAll(STYLED)].find((el) => MSO_IGNORE.test(el.getAttribute(STYLE_DATA_ATTR) ?? ""));
+  const text = (ignore?.textContent ?? "").trim();
+  ignore?.remove();
+  return text;
+}
+function convertWordLists(root) {
+  const parents = /* @__PURE__ */ new Set();
+  for (const p of root.querySelectorAll("p")) if (isWordListParagraph(p) && p.parentElement) parents.add(p.parentElement);
+  let changed = false;
+  for (const parent of parents) {
+    const children = [...parent.children];
+    for (let i = 0; i < children.length; ) {
+      if (!isWordListParagraph(children[i])) {
+        i++;
+        continue;
+      }
+      const run = [];
+      while (i < children.length && isWordListParagraph(children[i])) run.push(children[i++]);
+      buildNestedList(run, (p) => {
+        const level = Number(MSO_LEVEL.exec(p.getAttribute(STYLE_DATA_ATTR) ?? "")?.[1] ?? 1);
+        const marker = markerOf(p);
+        const ordered = ORDERED.test(marker) && !BULLETS.test(marker);
+        const start = ordered && /^\d+/.test(marker) ? Number.parseInt(marker, 10) : 1;
+        return { level, ordered, start };
+      });
+      changed = true;
+    }
+  }
+  return changed;
+}
+function buildNestedList(run, info) {
+  const doc = run[0].ownerDocument;
+  const stack = [];
+  const anchor = doc.createElement("div");
+  run[0].before(anchor);
+  for (const el of run) {
+    const { level, ordered, start } = info(el);
+    while (stack.length && stack[stack.length - 1].level > level) stack.pop();
+    let top = stack[stack.length - 1];
+    if (!top || top.level < level) {
+      const list = doc.createElement(ordered ? "ol" : "ul");
+      if (ordered && start > 1) list.setAttribute("start", String(start));
+      if (top?.last) top.last.append(list);
+      else if (top) top.list.append(doc.createElement("li"), list);
+      else anchor.append(list);
+      top = { level, list, last: null };
+      stack.push(top);
+    }
+    const li = doc.createElement("li");
+    if (el.querySelector(BLOCKS)) {
+      li.append(...el.childNodes);
+    } else {
+      const p = doc.createElement("p");
+      p.append(...el.childNodes);
+      for (const attr of ["dir", "lang"]) {
+        const v = el.getAttribute(attr);
+        if (v) p.setAttribute(attr, v);
+      }
+      li.append(p);
+    }
+    top.list.append(li);
+    top.last = li;
+    el.remove();
+  }
+  anchor.replaceWith(...anchor.childNodes);
+}
+function nestLooseLists(root) {
+  let changed = false;
+  for (const list of [...root.querySelectorAll("ul > ul, ul > ol, ol > ul, ol > ol")]) {
+    const prev = list.previousElementSibling;
+    if (prev?.tagName === "LI") prev.append(list);
+    else {
+      const li = list.ownerDocument.createElement("li");
+      list.before(li);
+      li.append(list);
+    }
+    changed = true;
+  }
+  return changed;
+}
+function nestAriaLevelLists(root) {
+  let changed = false;
+  for (const list of [...root.querySelectorAll("ul, ol")]) {
+    const items = [...list.children].filter((c) => c.tagName === "LI");
+    const levels = items.map((li) => Number(li.getAttribute("aria-level") ?? 1));
+    if (items.length < 2 || levels.every((l) => l === levels[0])) continue;
+    const ordered = list.tagName === "OL";
+    const wrapper = list.ownerDocument.createElement("div");
+    list.before(wrapper);
+    for (const li of items) {
+      const item = list.ownerDocument.createElement("div");
+      item.append(...li.childNodes);
+      item.setAttribute("data-level", li.getAttribute("aria-level") ?? "1");
+      wrapper.append(item);
+    }
+    list.remove();
+    buildNestedList([...wrapper.children], (el) => ({
+      level: Number(el.getAttribute("data-level")),
+      ordered,
+      start: 1
+    }));
+    wrapper.replaceWith(...wrapper.childNodes);
+    changed = true;
+  }
+  return changed;
+}
+function createCommandManager(factories, host) {
+  const names = Object.keys(factories);
+  const get = (name, args) => factories[name](...args);
+  const commands = {};
+  const can = {};
+  for (const name of names) {
+    commands[name] = (...args) => {
+      const view = host.view();
+      return get(name, args)(view.state, view.dispatch, view);
+    };
+    can[name] = (...args) => {
+      const view = host.view();
+      return get(name, args)(view.state, void 0, view);
+    };
+  }
+  function chain() {
+    const queue = [];
+    const api = {};
+    for (const name of names) {
+      api[name] = (...args) => {
+        queue.push({ name, args });
+        return api;
+      };
+    }
+    api.run = () => {
+      const view = host.view();
+      let state = view.state;
+      const tr = state.tr;
+      let focusTo = null;
+      for (const { name, args } of queue) {
+        if (name === "focus") {
+          focusTo = args[0];
+          continue;
+        }
+        let applied = null;
+        const ok = get(name, args)(state, (t) => applied = t, view);
+        if (!ok) return false;
+        if (applied) state = foldInto(tr, applied, state);
+      }
+      if (tr.docChanged || tr.selectionSet || tr.storedMarksSet) view.dispatch(tr.scrollIntoView());
+      if (focusTo !== null) host.focus(focusTo);
+      return true;
+    };
+    return api;
+  }
+  return { commands, can, chain };
+}
+function foldInto(target, source, before) {
+  for (const step of source.steps) target.step(step);
+  if (source.selectionSet) {
+    target.setSelection(Selection.fromJSON(target.doc, source.selection.toJSON()));
+  }
+  if (source.storedMarksSet) target.setStoredMarks(source.storedMarks);
+  return before.apply(source);
+}
+
+// src/core/dom.ts
+function h(tag, props, ...children) {
+  const el = document.createElement(tag);
+  if (props) {
+    for (const [key, value] of Object.entries(props)) {
+      if (value === void 0 || value === null || value === false) continue;
+      if (key === "className") el.className = String(value);
+      else if (key === "style") {
+        for (const [prop, v] of Object.entries(value)) {
+          if (v != null) el.style.setProperty(prop, v);
+        }
+      } else if (key.startsWith("on") && typeof value === "function") {
+        el.addEventListener(key.slice(2).toLowerCase(), value);
+      } else if (value === true) el.setAttribute(key, "");
+      else el.setAttribute(key, String(value));
+    }
+  }
+  for (const child of children.flat()) {
+    if (child === null || child === void 0 || child === false) continue;
+    el.append(typeof child === "object" ? child : String(child));
+  }
+  return el;
+}
+var counter = 0;
+var uid = (prefix = "owe") => `${prefix}-${(++counter).toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+function svg(paths, className = "owe-icon") {
+  const ns = "http://www.w3.org/2000/svg";
+  const el = document.createElementNS(ns, "svg");
+  el.setAttribute("viewBox", "0 0 24 24");
+  el.setAttribute("aria-hidden", "true");
+  el.setAttribute("focusable", "false");
+  el.setAttribute("class", className);
+  for (const d of paths) {
+    const path = document.createElementNS(ns, "path");
+    path.setAttribute("d", d);
+    el.append(path);
+  }
+  return el;
+}
+
+// src/core/env.ts
+var LIB = "open-wysiwyg-editor";
+var isBrowser = () => typeof window !== "undefined" && typeof document !== "undefined";
+function assertBrowser(what) {
+  if (!isBrowser()) {
+    throw new Error(
+      `[${LIB}] ${what} needs a browser DOM. Call it on the client (e.g. in useEffect / onMounted / afterNextRender), or use "${LIB}/server" helpers for server-side rendering.`
+    );
+  }
+}
+var isMac = () => typeof navigator !== "undefined" && /Mac|iPhone|iPad|iPod/.test(
+  navigator.userAgentData?.platform ?? navigator.platform ?? ""
+);
+function warn(message) {
+  if (typeof console !== "undefined") console.warn(`[${LIB}] ${message}`);
+}
+
+// src/core/events.ts
+function createEmitter() {
+  const listeners = /* @__PURE__ */ new Map();
+  const off = (event, listener) => {
+    listeners.get(event)?.delete(listener);
+  };
+  return {
+    on(event, listener) {
+      let set = listeners.get(event);
+      if (!set) listeners.set(event, set = /* @__PURE__ */ new Set());
+      set.add(listener);
+      return () => off(event, listener);
+    },
+    off,
+    emit(event, ...args) {
+      for (const listener of [...listeners.get(event) ?? []]) {
+        try {
+          listener(...args);
+        } catch (error) {
+          console.error("[open-wysiwyg-editor] listener error", error);
+        }
+      }
+    },
+    clear() {
+      listeners.clear();
+    }
+  };
+}
+function buildSchema(extensions, ctx) {
+  const nodes = {};
+  const marks = {};
+  for (const ext of extensions) {
+    Object.assign(nodes, ext.config.nodes?.(ext.options, ctx));
+    Object.assign(marks, ext.config.marks?.(ext.options, ctx));
+  }
+  if (!nodes.doc || !nodes.text) {
+    throw new Error("[open-wysiwyg-editor] The Document and Text extensions are required.");
+  }
+  for (const ext of extensions) {
+    for (const group of ext.config.globalAttributes?.(ext.options) ?? []) {
+      for (const type of group.types) {
+        if (nodes[type]) nodes[type] = withGlobalAttributes(nodes[type], group.attributes);
+        else if (marks[type]) marks[type] = withGlobalAttributes(marks[type], group.attributes);
+      }
+    }
+  }
+  const ordered = { doc: nodes.doc };
+  if (nodes.paragraph) ordered.paragraph = nodes.paragraph;
+  for (const [name, spec] of Object.entries(nodes)) if (!(name in ordered)) ordered[name] = spec;
+  const schema = new Schema({ nodes: ordered, marks });
+  schema.cached.urlPolicy = ctx.urlPolicy;
+  return schema;
+}
+function withGlobalAttributes(spec, globals) {
+  const entries = Object.entries(globals);
+  const attrs = { ...spec.attrs };
+  for (const [name, g] of entries) attrs[name] = { default: g.default ?? null };
+  const parseDOM = spec.parseDOM?.map((rule) => {
+    if (!("tag" in rule) || !rule.tag) return rule;
+    const tagRule = rule;
+    return {
+      ...tagRule,
+      getAttrs(dom) {
+        const base = tagRule.getAttrs ? tagRule.getAttrs(dom) : tagRule.attrs ?? null;
+        if (base === false) return false;
+        const extra = {};
+        for (const [name, g] of entries) {
+          const value = g.parseHTML ? g.parseHTML(dom) : dom.getAttribute(name);
+          if (value !== null && value !== void 0) extra[name] = value;
+        }
+        return { ...tagRule.attrs, ...base, ...extra };
+      }
+    };
+  });
+  const render = (mode, owner, out) => {
+    let extra = {};
+    for (const [name, g] of entries) {
+      const fn = mode === "dom" ? g.renderDOM ?? g.renderHTML : g.renderHTML;
+      const value = owner.attrs[name];
+      const rendered = fn ? fn(value, owner) : value == null ? null : { [name]: String(value) };
+      if (rendered) extra = mergeAttrs(extra, rendered);
+    }
+    return injectAttrs(out, extra);
+  };
+  const toDOM = spec.toDOM;
+  const toHTML = spec.toHTML ?? toDOM;
+  return {
+    ...spec,
+    attrs,
+    parseDOM,
+    toDOM: toDOM && ((owner, ...rest) => render("dom", owner, toDOM(owner, ...rest))),
+    toHTML: toHTML && ((owner, ...rest) => render("html", owner, toHTML(owner, ...rest)))
+  };
+}
+function mergeAttrs(a, b) {
+  const out = { ...a };
+  for (const [key, value] of Object.entries(b)) {
+    if (key === "class" && out.class) out.class = `${out.class} ${value}`;
+    else if (key === "style" && out.style) out.style = `${out.style.replace(/;?\s*$/, ";")} ${value}`;
+    else out[key] = value;
+  }
+  return out;
+}
+function isAttrs(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(typeof Node !== "undefined" && value instanceof Node);
+}
+function injectAttrs(out, extra) {
+  if (!Array.isArray(out) || Object.keys(extra).length === 0) return out;
+  const [tag, maybeAttrs, ...rest] = out;
+  if (isAttrs(maybeAttrs)) {
+    const clean = Object.fromEntries(
+      Object.entries(maybeAttrs).filter(([, v]) => v !== null && v !== void 0)
+    );
+    return [tag, mergeAttrs(clean, extra), ...rest];
+  }
+  const tail = maybeAttrs === void 0 ? rest : [maybeAttrs, ...rest];
+  return [tag, extra, ...tail];
+}
+
+// src/core/editor.ts
+var placeholderKey = new PluginKey("owe-placeholder");
+function createEditor(options = {}) {
+  assertBrowser("createEditor()");
+  let opts = { ...options };
+  const emitter = createEmitter();
+  const language = resolveLanguage(opts.language, opts.languages);
+  const i18n = createI18n(language, opts.labels);
+  const urlPolicy = opts.urlPolicy ?? {};
+  const extensions = resolveExtensions([CoreExtension, ...opts.extensions ?? []]);
+  const schema = buildSchema(extensions, { t: i18n.t, urlPolicy });
+  const domParser = DOMParser.fromSchema(schema);
+  const parseHTML = (html) => {
+    const fragment = sanitizeToFragment(html);
+    restoreStyles(fragment);
+    return domParser.parse(fragment);
+  };
+  const clipboardParser = Object.create(domParser);
+  clipboardParser.parseSlice = (dom, options2) => {
+    restoreStyles(dom);
+    return domParser.parseSlice(dom, options2);
+  };
+  const target = opts.element ?? null;
+  const textarea = target instanceof HTMLTextAreaElement ? target : null;
+  let initial = opts.content;
+  if (initial === void 0 && target) initial = textarea ? textarea.value : target;
+  const root = h("div", { className: "owe", dir: i18n.dir, lang: i18n.lang });
+  const body = h("div", { className: "owe-body" });
+  const polite = h("div", { className: "owe-sr-only", role: "status", "aria-live": "polite" });
+  const assertive = h("div", { className: "owe-sr-only", role: "alert", "aria-live": "assertive" });
+  root.append(body, polite, assertive);
+  if (textarea) {
+    textarea.hidden = true;
+    textarea.after(root);
+    if (!opts.ariaLabel && !opts.ariaLabelledBy && textarea.labels?.length) {
+      const label = textarea.labels[0];
+      if (!label.id) label.id = uid("owe-label");
+      opts.ariaLabelledBy = label.id;
+      label.addEventListener("click", focusFromLabel);
+    }
+  }
+  let editable = opts.editable !== false;
+  let destroyed = false;
+  let focused = false;
+  const doc = parseContent(initial, true) ?? schema.topNodeType.createAndFill();
+  if (target && !textarea) {
+    target.replaceChildren(root);
+  }
+  const ctxFor = (ext) => ({
+    options: ext.options,
+    schema,
+    editor: editorRef
+  });
+  const plugins = [];
+  const rules = [];
+  const factories = {};
+  const view = new EditorView(body, {
+    state: EditorState.create({ schema, doc }),
+    editable: () => editable,
+    attributes: () => viewAttributes(),
+    dispatchTransaction,
+    // Every paste and drop goes through the same sanitizer as setContent(), plus Office cleanup.
+    clipboardParser,
+    transformPastedHTML: (html) => {
+      const result = cleanPastedHTML(html, urlPolicy);
+      if (result.dropped) announce(i18n.t("pasteDropped"));
+      return result.html;
+    },
+    // Pasting into an *empty* textblock replaces it, so the pasted block keeps its own
+    // attributes (e.g. dir="rtl" from an Arabic document) instead of inheriting the empty one's.
+    transformPasted: (slice, v) => {
+      const { $from, empty } = v.state.selection;
+      if (empty && $from.parent.isTextblock && $from.parent.content.size === 0 && slice.openStart > 0 && slice.content.firstChild?.isBlock) {
+        return new Slice(slice.content, 0, slice.openEnd);
+      }
+      return slice;
+    },
+    handleDOMEvents: {
+      focus: (_v, event) => {
+        focused = true;
+        emitter.emit("focus", event);
+        opts.onFocus?.(editorRef, event);
+        return false;
+      },
+      blur: (_v, event) => {
+        focused = false;
+        emitter.emit("blur", event);
+        opts.onBlur?.(editorRef, event);
+        syncTextarea();
+        return false;
+      }
+    }
+  });
+  function viewAttributes() {
+    const attrs = {
+      class: "owe-content",
+      role: "textbox",
+      "aria-multiline": "true",
+      "aria-readonly": editable ? "false" : "true"
+    };
+    if (opts.ariaLabelledBy) attrs["aria-labelledby"] = opts.ariaLabelledBy;
+    else attrs["aria-label"] = opts.ariaLabel ?? i18n.t("editorLabel");
+    if (opts.ariaDescribedBy) attrs["aria-describedby"] = opts.ariaDescribedBy;
+    const placeholder = placeholderText();
+    if (placeholder) attrs["aria-placeholder"] = placeholder;
+    if (opts.dir) attrs.dir = opts.dir;
+    if (opts.contentLang) attrs.lang = opts.contentLang;
+    return attrs;
+  }
+  function placeholderText() {
+    if (opts.placeholder === false) return null;
+    return opts.placeholder ?? i18n.t("placeholder");
+  }
+  function dispatchTransaction(tr) {
+    if (destroyed) return;
+    const before = view.state;
+    const next = before.apply(tr);
+    view.updateState(next);
+    emitter.emit("transaction", tr);
+    if (!before.selection.eq(next.selection)) {
+      emitter.emit("selectionUpdate");
+      opts.onSelectionUpdate?.(editorRef);
+    }
+    if (tr.docChanged && !tr.getMeta("owe-silent")) {
+      emitter.emit("update");
+      opts.onUpdate?.(editorRef);
+      scheduleTextareaSync();
+    }
+  }
+  let syncTimer;
+  function syncTextarea() {
+    clearTimeout(syncTimer);
+    if (textarea && !destroyed) textarea.value = editorRef.getHTML();
+  }
+  function scheduleTextareaSync() {
+    if (!textarea) return;
+    clearTimeout(syncTimer);
+    syncTimer = setTimeout(syncTextarea, 150);
+  }
+  const form = textarea?.form ?? null;
+  form?.addEventListener("submit", syncTextarea, true);
+  form?.addEventListener("formdata", syncTextarea, true);
+  function focusFromLabel(event) {
+    event.preventDefault();
+    editorRef.focus();
+  }
+  let tabEscape = false;
+  const onKeyDownCapture = (event) => {
+    if (event.key === "Escape" && view.dom.contains(event.target)) tabEscape = true;
+    else if (event.key === "Tab" && tabEscape) {
+      tabEscape = false;
+      event.stopPropagation();
+    } else if (event.key !== "Shift") tabEscape = false;
+  };
+  root.addEventListener("keydown", onKeyDownCapture, true);
+  let announceFrame = 0;
+  function announce(message, politeness = "polite") {
+    const region = politeness === "assertive" ? assertive : polite;
+    region.textContent = "";
+    cancelAnimationFrame(announceFrame);
+    announceFrame = requestAnimationFrame(() => {
+      region.textContent = message;
+    });
+  }
+  function parseContent(content, initialLoad = false) {
+    try {
+      if (content === null || content === void 0 || content === "") {
+        return schema.topNodeType.createAndFill();
+      }
+      if (typeof content === "string") return parseHTML(content);
+      if (typeof HTMLElement !== "undefined" && content instanceof HTMLElement) {
+        return parseHTML(elementHTML(content));
+      }
+      const node = schema.nodeFromJSON(content);
+      node.check();
+      return node;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (initialLoad) warn(`Invalid initial content: ${err.message}`);
+      queueMicrotask(() => {
+        emitter.emit("contentError", err);
+        opts.onContentError?.(err);
+      });
+      return null;
+    }
+  }
+  const editorRef = buildApi();
+  for (const ext of extensions) {
+    const ctx = ctxFor(ext);
+    Object.assign(factories, ext.config.commands?.(ctx));
+    if (opts.inputRules !== false) rules.push(...ext.config.inputRules?.(ctx) ?? []);
+  }
+  if (rules.length) plugins.push(inputRules({ rules }));
+  for (const ext of extensions) {
+    const map = ext.config.keymap?.(ctxFor(ext));
+    if (map && Object.keys(map).length) plugins.push(keymap(map));
+  }
+  for (const ext of extensions) plugins.push(...ext.config.plugins?.(ctxFor(ext)) ?? []);
+  plugins.push(keymap(baseKeymap), placeholderPlugin());
+  view.updateState(view.state.reconfigure({ plugins }));
+  const manager = createCommandManager(factories, {
+    view: () => view,
+    focus: (position) => editorRef.focus(position)
+  });
+  function placeholderPlugin() {
+    return new Plugin({
+      key: placeholderKey,
+      props: {
+        decorations(state) {
+          const text = placeholderText();
+          const first = state.doc.firstChild;
+          if (!text || state.doc.childCount !== 1 || !first?.isTextblock || first.content.size) return null;
+          return DecorationSet.create(state.doc, [
+            Decoration.node(0, first.nodeSize, { class: "owe-placeholder", "data-placeholder": text })
+          ]);
+        }
+      }
+    });
+  }
+  function buildApi() {
+    const api = {
+      get root() {
+        return root;
+      },
+      get view() {
+        return view;
+      },
+      schema,
+      get state() {
+        return view.state;
+      },
+      extensions,
+      i18n,
+      get isDestroyed() {
+        return destroyed;
+      },
+      get isEditable() {
+        return editable;
+      },
+      get isEmpty() {
+        const d = view.state.doc;
+        return d.childCount === 1 && !!d.firstChild?.isTextblock && d.firstChild.content.size === 0;
+      },
+      get isFocused() {
+        return focused;
+      },
+      get commands() {
+        return manager.commands;
+      },
+      can: () => manager.can,
+      chain: () => manager.chain(),
+      getHTML: () => docToHTML(view.state.doc, urlPolicy),
+      getJSON: () => view.state.doc.toJSON(),
+      getText: ({ blockSeparator = "\n\n" } = {}) => view.state.doc.textBetween(0, view.state.doc.content.size, blockSeparator),
+      setContent(content, { emitUpdate = false, addToHistory = false } = {}) {
+        const node = parseContent(content);
+        if (!node) return false;
+        const tr = view.state.tr.replaceWith(0, view.state.doc.content.size, node.content);
+        tr.setSelection(Selection.atStart(tr.doc));
+        if (!addToHistory) tr.setMeta("addToHistory", false);
+        if (!emitUpdate) tr.setMeta("owe-silent", true);
+        view.dispatch(tr);
+        if (!emitUpdate) scheduleTextareaSync();
+        return true;
+      },
+      clearContent(o) {
+        api.setContent(null, o);
+      },
+      setEditable(value) {
+        api.setOptions({ editable: value });
+      },
+      focus(position) {
+        if (destroyed) return;
+        if (position !== void 0) {
+          const { doc: d } = view.state;
+          const sel = position === "start" ? Selection.atStart(d) : position === "end" ? Selection.atEnd(d) : TextSelection.near(d.resolve(Math.max(0, Math.min(position, d.content.size))));
+          view.dispatch(view.state.tr.setSelection(sel).scrollIntoView());
+        }
+        view.focus();
+      },
+      blur() {
+        view.dom.blur();
+      },
+      isActive: (name, attrs) => isActive(view.state, schema, name, attrs),
+      getAttributes: (name) => getAttributes(view.state, schema, name),
+      t: i18n.t,
+      announce,
+      on: (event, listener) => emitter.on(event, listener),
+      off: (event, listener) => emitter.off(event, listener),
+      subscribe(listener) {
+        const offTr = emitter.on("transaction", listener);
+        const offOpts = emitter.on("options", listener);
+        return () => {
+          offTr();
+          offOpts();
+        };
+      },
+      setOptions(partial) {
+        if (destroyed) return;
+        opts = { ...opts, ...partial };
+        if (partial.editable !== void 0) editable = partial.editable;
+        view.setProps({});
+        view.dispatch(view.state.tr.setMeta(placeholderKey, true));
+        emitter.emit("options");
+      },
+      destroy() {
+        if (destroyed) return;
+        syncTextarea();
+        for (const ext of extensions) ext.config.onDestroy?.(ctxFor(ext));
+        destroyed = true;
+        clearTimeout(syncTimer);
+        cancelAnimationFrame(announceFrame);
+        root.removeEventListener("keydown", onKeyDownCapture, true);
+        form?.removeEventListener("submit", syncTextarea, true);
+        form?.removeEventListener("formdata", syncTextarea, true);
+        if (textarea) {
+          textarea.labels?.forEach((l) => l.removeEventListener("click", focusFromLabel));
+          textarea.hidden = false;
+        }
+        view.destroy();
+        root.remove();
+        emitter.emit("destroy");
+        opts.onDestroy?.();
+        emitter.clear();
+      }
+    };
+    return api;
+  }
+  for (const ext of extensions) ext.config.onCreate?.(ctxFor(ext));
+  emitter.emit("create");
+  opts.onCreate?.(editorRef);
+  if (opts.autofocus) {
+    editorRef.focus(opts.autofocus === true ? void 0 : opts.autofocus);
+  }
+  return editorRef;
+}
+function elementHTML(el) {
+  return el.innerHTML;
+}
+function attrsMatch(actual, wanted) {
+  if (!wanted) return true;
+  return Object.entries(wanted).every(([k, v]) => actual[k] === v);
+}
+function isActive(state, schema, name, attrs) {
+  const markType = schema.marks[name];
+  if (markType) {
+    const { from, to, empty, $from: $from2 } = state.selection;
+    if (empty) {
+      return (state.storedMarks ?? $from2.marks()).some(
+        (m) => m.type === markType && attrsMatch(m.attrs, attrs)
+      );
+    }
+    let sawText = false;
+    let all = true;
+    state.doc.nodesBetween(from, to, (node) => {
+      if (!all) return false;
+      if (node.isText) {
+        sawText = true;
+        if (!node.marks.some((m) => m.type === markType && attrsMatch(m.attrs, attrs))) all = false;
+      }
+      return true;
+    });
+    return sawText && all;
+  }
+  const nodeType = schema.nodes[name];
+  if (!nodeType) return false;
+  const sel = state.selection;
+  if (sel instanceof NodeSelection && sel.node.type === nodeType) return attrsMatch(sel.node.attrs, attrs);
+  const $from = sel.$from;
+  for (let d = $from.depth; d >= 0; d--) {
+    const node = $from.node(d);
+    if (node.type === nodeType && attrsMatch(node.attrs, attrs)) return true;
+  }
+  return false;
+}
+function getAttributes(state, schema, name) {
+  const markType = schema.marks[name];
+  if (markType) {
+    const { from, to, empty, $from } = state.selection;
+    let mark;
+    if (empty) mark = (state.storedMarks ?? $from.marks()).find((m) => m.type === markType);
+    else {
+      state.doc.nodesBetween(from, to, (node) => {
+        mark ?? (mark = node.marks.find((m) => m.type === markType));
+        return !mark;
+      });
+    }
+    return mark ? { ...mark.attrs } : {};
+  }
+  const nodeType = schema.nodes[name];
+  const sel = state.selection;
+  if (sel instanceof NodeSelection && sel.node.type === nodeType) return { ...sel.node.attrs };
+  for (let d = sel.$from.depth; d >= 0; d--) {
+    const node = sel.$from.node(d);
+    if (node.type === nodeType) return { ...node.attrs };
+  }
+  return {};
+}
+var unsetAllMarks = (state, dispatch) => {
+  const { from, to, empty } = state.selection;
+  if (empty) {
+    if (dispatch) dispatch(state.tr.setStoredMarks([]));
+    return true;
+  }
+  if (dispatch) dispatch(state.tr.removeMark(from, to, null));
+  return true;
+};
+var clearNodes = (state, dispatch) => {
+  const paragraph = state.schema.nodes.paragraph;
+  if (!paragraph) return false;
+  const { from, to } = state.selection;
+  const tr = state.tr;
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isTextblock) return true;
+    let range = tr.doc.resolve(tr.mapping.map(pos)).blockRange(tr.doc.resolve(tr.mapping.map(pos + node.nodeSize)));
+    let target = range ? liftTarget(range) : null;
+    while (range && target !== null) {
+      tr.lift(range, target);
+      range = tr.doc.resolve(tr.mapping.map(pos)).blockRange(tr.doc.resolve(tr.mapping.map(pos + node.nodeSize)));
+      target = range ? liftTarget(range) : null;
+    }
+    if (node.type !== paragraph) tr.setNodeMarkup(tr.mapping.map(pos), paragraph);
+    return false;
+  });
+  if (!tr.docChanged) return false;
+  if (dispatch) dispatch(tr.scrollIntoView());
+  return true;
+};
+var CoreExtension = defineExtension({
+  name: "core",
+  priority: 1e3,
+  commands: ({ editor }) => ({
+    focus: (position) => () => {
+      editor.focus(position);
+      return true;
+    },
+    blur: () => () => {
+      editor.blur();
+      return true;
+    },
+    selectAll: () => (state, dispatch) => {
+      if (dispatch) dispatch(state.tr.setSelection(new AllSelection(state.doc)));
+      return true;
+    },
+    unsetAllMarks: () => unsetAllMarks,
+    clearNodes: () => clearNodes
+  })
+});
+function markInputRule(regexp, markType, attrs) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    const full = match[1];
+    const text = match[2];
+    if (!full || !text) return null;
+    const fullStart = start + match[0].length - full.length;
+    const textStart = fullStart + full.indexOf(text);
+    const textEnd = textStart + text.length;
+    const $from = state.doc.resolve(fullStart);
+    if (!$from.parent.type.allowsMarkType(markType)) return null;
+    let blocked = false;
+    state.doc.nodesBetween(fullStart, end, (node) => {
+      if (node.marks.some((m) => m.type !== markType && m.type.excludes(markType))) blocked = true;
+    });
+    if (blocked) return null;
+    const tr = state.tr;
+    if (textEnd < end) tr.delete(textEnd, end);
+    if (textStart > fullStart) tr.delete(fullStart, textStart);
+    tr.addMark(fullStart, fullStart + text.length, markType.create(attrs));
+    tr.removeStoredMark(markType);
+    return tr;
+  });
+}
+function sequence(...commands) {
+  return (state, dispatch, view) => {
+    let current = state;
+    const trs = [];
+    for (const command of commands) {
+      const ok = command(current, (tr) => {
+        trs.push(tr);
+        current = current.apply(tr);
+      }, view);
+      if (!ok) return false;
+    }
+    if (dispatch && trs.length) {
+      const tr = state.tr;
+      for (const t of trs) for (const step of t.steps) tr.step(step);
+      const last = trs[trs.length - 1];
+      if (last.selectionSet) {
+        tr.setSelection(last.selection.map(tr.doc, tr.mapping.slice(tr.steps.length)));
+      }
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+function isNodeActive(state, type, attrs) {
+  const { $from, to } = state.selection;
+  for (let d = $from.depth; d >= 0; d--) {
+    const node = $from.node(d);
+    if (node.type !== type) continue;
+    if (!attrs || Object.entries(attrs).every(([k, v]) => node.attrs[k] === v)) {
+      return to <= $from.end(d);
+    }
+  }
+  return false;
+}
+function toggleBlockType(type, fallback, attrs, match = attrs) {
+  return (state, dispatch, view) => isNodeActive(state, type, match) ? setBlockType(fallback)(state, dispatch, view) : setBlockType(type, attrs)(state, dispatch, view);
+}
+function toggleWrap(type) {
+  return (state, dispatch, view) => isNodeActive(state, type) ? lift(state, dispatch, view) : wrapIn(type)(state, dispatch, view);
+}
+function toggleMarkCommand(type, attrs) {
+  return toggleMark(type, attrs, { removeWhenPresent: false, enterInlineAtoms: true });
+}
+function findParent($pos, predicate) {
+  for (let d = $pos.depth; d > 0; d--) {
+    const node = $pos.node(d);
+    if (predicate(node.type)) return { pos: $pos.before(d), depth: d, node };
+  }
+  return null;
+}
+var isListType = (type) => type.spec.group?.split(" ").includes("list") ?? false;
+var liftOutOfLists = (state, dispatch) => {
+  let current = state;
+  const trs = [];
+  for (let guard = 0; guard < 20; guard++) {
+    const list = findParent(current.selection.$from, isListType);
+    if (!list) break;
+    const itemType = list.node.firstChild?.type;
+    if (!itemType) break;
+    const ok = liftListItem(itemType)(current, (tr) => {
+      trs.push(tr);
+      current = current.apply(tr);
+    });
+    if (!ok) break;
+  }
+  if (!trs.length) return false;
+  if (dispatch) {
+    const tr = state.tr;
+    for (const t of trs) for (const step of t.steps) tr.step(step);
+    dispatch(tr);
+  }
+  return true;
+};
+function toggleList(listType, itemType) {
+  return (state, dispatch, view) => {
+    const list = findParent(state.selection.$from, isListType);
+    if (list) {
+      if (list.node.type === listType) return liftListItem(itemType)(state, dispatch, view);
+      if (list.node.firstChild?.type === itemType) {
+        if (dispatch) dispatch(state.tr.setNodeMarkup(list.pos, listType, list.node.attrs));
+        return true;
+      }
+      return sequence(liftOutOfLists, wrapInList(listType))(state, dispatch, view);
+    }
+    return wrapInList(listType)(state, dispatch, view);
+  };
+}
+function markRange($pos, type) {
+  const parent = $pos.parent;
+  const start = parent.childAfter($pos.parentOffset);
+  const child = start.node ?? parent.childBefore($pos.parentOffset).node;
+  const mark = child?.marks.find((m) => m.type === type);
+  if (!mark) return null;
+  let index = $pos.index();
+  if (!parent.maybeChild(index)?.marks.some((m) => m.eq(mark))) index--;
+  if (index < 0) return null;
+  let startIndex = index;
+  let endIndex = index + 1;
+  while (startIndex > 0 && mark.isInSet(parent.child(startIndex - 1).marks)) startIndex--;
+  while (endIndex < parent.childCount && mark.isInSet(parent.child(endIndex).marks)) endIndex++;
+  let from = $pos.start();
+  for (let i = 0; i < startIndex; i++) from += parent.child(i).nodeSize;
+  let to = from;
+  for (let i = startIndex; i < endIndex; i++) to += parent.child(i).nodeSize;
+  return { from, to, mark };
+}
+function setBlockAttrs(types, attrs) {
+  return (state, dispatch) => {
+    const { from, to } = state.selection;
+    const tr = state.tr;
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      if (types.includes(node.type.name) && node.isTextblock) {
+        tr.setNodeMarkup(pos, void 0, { ...node.attrs, ...attrs });
+      }
+      return true;
+    });
+    if (!tr.docChanged) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+// src/extensions/attributes.ts
+var ALIGNMENTS = ["start", "center", "end", "justify"];
+var TextAlign = defineExtension({
+  name: "textAlign",
+  defaultOptions: { types: ["paragraph", "heading"], output: "style" },
+  globalAttributes: ({ types, output }) => [
+    {
+      types,
+      attributes: {
+        textAlign: {
+          default: null,
+          parseHTML: (el) => {
+            const raw = (el.style.textAlign || el.getAttribute("align") || "").toLowerCase();
+            if (raw === "left" || raw === "right") {
+              const rtl = el.closest("[dir]")?.getAttribute("dir") === "rtl";
+              return raw === "left" !== rtl ? null : "end";
+            }
+            return ALIGNMENTS.includes(raw) && raw !== "start" ? raw : null;
+          },
+          renderHTML: (value) => value ? output === "class" ? { class: `owe-align-${value}` } : { style: `text-align: ${value}` } : null,
+          renderDOM: (value) => value ? { class: `owe-align-${String(value)}` } : null
+        }
+      }
+    }
+  ],
+  commands: ({ options }) => ({
+    setTextAlign: (align) => ALIGNMENTS.includes(align) ? setBlockAttrs(options.types, { textAlign: align === "start" ? null : align }) : () => false,
+    unsetTextAlign: () => setBlockAttrs(options.types, { textAlign: null })
+  }),
+  keymap: ({ options }) => ({
+    "Mod-Shift-l": setBlockAttrs(options.types, { textAlign: null }),
+    "Mod-Shift-e": setBlockAttrs(options.types, { textAlign: "center" }),
+    "Mod-Shift-r": setBlockAttrs(options.types, { textAlign: "end" }),
+    "Mod-Shift-j": setBlockAttrs(options.types, { textAlign: "justify" })
+  })
+});
+var TextDirection = defineExtension({
+  name: "textDirection",
+  defaultOptions: {
+    types: ["paragraph", "heading", "blockquote", "bulletList", "orderedList", "taskList", "table"],
+    autoDetect: true
+  },
+  globalAttributes: ({ types, autoDetect }) => {
+    const textblocks = types.filter((t) => t === "paragraph" || t === "heading");
+    const containers = types.filter((t) => !textblocks.includes(t));
+    const attr = (auto) => ({
+      dir: {
+        default: null,
+        parseHTML: (el) => {
+          const dir = el.getAttribute("dir")?.toLowerCase();
+          return dir === "ltr" || dir === "rtl" || dir === "auto" ? dir : null;
+        },
+        // Empty blocks inherit the editor direction so the caret starts on the correct side.
+        renderHTML: (value, node) => value ? { dir: String(value) } : auto && "content" in node && node.content.size > 0 ? { dir: "auto" } : null
+      }
+    });
+    return [
+      { types: textblocks, attributes: attr(autoDetect) },
+      { types: containers, attributes: attr(false) }
+    ];
+  },
+  commands: ({ options }) => ({
+    setTextDirection: (dir) => dir === "ltr" || dir === "rtl" || dir === "auto" ? setBlockAttrs(options.types, { dir }) : () => false,
+    unsetTextDirection: () => setBlockAttrs(options.types, { dir: null })
+  })
+});
+var History = defineExtension({
+  name: "history",
+  defaultOptions: { depth: 200, newGroupDelay: 500 },
+  commands: () => ({ undo: () => undo, redo: () => redo }),
+  keymap: () => ({ "Mod-z": undo, "Shift-Mod-z": redo, "Mod-y": redo }),
+  plugins: ({ options }) => [history(options)]
+});
+var Dropcursor = defineExtension({
+  name: "dropcursor",
+  plugins: () => [dropCursor({ class: "owe-dropcursor", width: 2 })]
+});
+var Gapcursor = defineExtension({
+  name: "gapcursor",
+  plugins: () => [gapCursor()]
+});
+var dimension = (value) => {
+  const n = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(n) && n > 0 && n < 2e4 ? n : null;
+};
+var Image = defineExtension({
+  name: "image",
+  defaultOptions: { upload: null },
+  nodes: (_options, { urlPolicy }) => ({
+    image: {
+      group: "block",
+      atom: true,
+      draggable: true,
+      attrs: {
+        src: { default: null },
+        // null = not provided (the checker flags it); "" = decorative (ATAG B.2.3).
+        alt: { default: null },
+        title: { default: null },
+        caption: { default: null },
+        width: { default: null },
+        height: { default: null }
+      },
+      parseDOM: [
+        {
+          tag: "figure",
+          getAttrs: (el) => {
+            const img = el.querySelector("img");
+            if (!img) return false;
+            const attrs = readImg(img, urlPolicy);
+            if (!attrs) return false;
+            const caption = el.querySelector("figcaption")?.textContent?.trim();
+            return { ...attrs, caption: caption || null };
+          }
+        },
+        { tag: "img[src]", getAttrs: (el) => readImg(el, urlPolicy) ?? false }
+      ],
+      toDOM: (node) => {
+        const a = node.attrs;
+        const img = [
+          "img",
+          {
+            src: sanitizeUrl(a.src, urlPolicy, "image"),
+            alt: a.alt,
+            title: a.title ?? null,
+            width: a.width ? String(a.width) : null,
+            height: a.height ? String(a.height) : null,
+            loading: "lazy",
+            decoding: "async"
+          }
+        ];
+        return a.caption ? ["figure", img, ["figcaption", a.caption]] : img;
+      }
+    }
+  }),
+  commands: ({ schema }) => {
+    const type = schema.nodes.image;
+    const policy = schema.cached.urlPolicy ?? {};
+    const setImage = (attrs) => (state, dispatch) => {
+      const src = sanitizeUrl(attrs.src, policy, "image");
+      if (!src) return false;
+      const node = type.create({ ...normalize(attrs), src });
+      if (dispatch) dispatch(state.tr.replaceSelectionWith(node).scrollIntoView());
+      return true;
+    };
+    const updateImage = (attrs) => (state, dispatch) => {
+      const sel = state.selection;
+      if (!(sel instanceof NodeSelection) || sel.node.type !== type) return false;
+      const next = { ...sel.node.attrs, ...normalize(attrs) };
+      if (attrs.src !== void 0) {
+        const src = sanitizeUrl(attrs.src, policy, "image");
+        if (!src) return false;
+        next.src = src;
+      }
+      if (dispatch) {
+        const tr = state.tr.setNodeMarkup(sel.from, void 0, next);
+        tr.setSelection(NodeSelection.create(tr.doc, sel.from));
+        dispatch(tr);
+      }
+      return true;
+    };
+    return { setImage, updateImage };
+  }
+});
+function readImg(img, policy) {
+  const src = sanitizeUrl(img.getAttribute("src"), policy, "image");
+  if (!src) return null;
+  return {
+    src,
+    alt: img.getAttribute("alt"),
+    title: img.getAttribute("title"),
+    width: dimension(img.getAttribute("width")),
+    height: dimension(img.getAttribute("height"))
+  };
+}
+function normalize(attrs) {
+  const out = {};
+  if (attrs.alt !== void 0) out.alt = attrs.alt === null ? null : attrs.alt.trim();
+  if (attrs.title !== void 0) out.title = attrs.title?.trim() || null;
+  if (attrs.caption !== void 0) out.caption = attrs.caption?.trim() || null;
+  if (attrs.width !== void 0) out.width = attrs.width ? Math.round(attrs.width) : null;
+  if (attrs.height !== void 0) out.height = attrs.height ? Math.round(attrs.height) : null;
+  return out;
+}
+var itemTypes = ["listItem", "taskItem"];
+var forItem = (make) => (state, dispatch, view) => {
+  const item = findParent(state.selection.$from, (t) => itemTypes.includes(t.name));
+  return item ? make(item.node.type)(state, dispatch, view) : false;
+};
+var liftAtStart = (state, dispatch, view) => {
+  const { $from, empty } = state.selection;
+  if (!empty || $from.parentOffset > 0) return false;
+  const item = findParent($from, (t) => itemTypes.includes(t.name));
+  if (!item || $from.index(item.depth) !== 0) return false;
+  return liftListItem(item.node.type)(state, dispatch, view);
+};
+var ListItem = defineExtension({
+  name: "listItem",
+  nodes: () => ({
+    listItem: {
+      content: "paragraph block*",
+      defining: true,
+      parseDOM: [{ tag: "li", priority: 40 }],
+      toDOM: () => ["li", 0]
+    }
+  }),
+  commands: () => ({
+    sinkListItem: () => forItem(sinkListItem),
+    liftListItem: () => forItem(liftListItem)
+  }),
+  keymap: () => ({
+    Enter: forItem(splitListItem),
+    // Tab only acts inside lists and fails at the first item, so focus can always leave the editor.
+    Tab: forItem(sinkListItem),
+    "Shift-Tab": forItem(liftListItem),
+    Backspace: liftAtStart
+  })
+});
+var BulletList = defineExtension({
+  name: "bulletList",
+  extensions: () => [ListItem],
+  nodes: () => ({
+    bulletList: {
+      content: "listItem+",
+      group: "block list",
+      parseDOM: [{ tag: "ul", getAttrs: (el) => el.dataset.type === "taskList" ? false : null }],
+      toDOM: () => ["ul", 0]
+    }
+  }),
+  commands: ({ schema }) => ({
+    toggleBulletList: () => toggleList(schema.nodes.bulletList, schema.nodes.listItem)
+  }),
+  keymap: ({ schema }) => ({ "Mod-Shift-8": toggleList(schema.nodes.bulletList, schema.nodes.listItem) }),
+  inputRules: ({ schema }) => [wrappingInputRule(/^\s*([-+*])\s$/, schema.nodes.bulletList)]
+});
+var OrderedList = defineExtension({
+  name: "orderedList",
+  extensions: () => [ListItem],
+  nodes: () => ({
+    orderedList: {
+      attrs: { start: { default: 1 }, type: { default: null } },
+      content: "listItem+",
+      group: "block list",
+      parseDOM: [
+        {
+          tag: "ol",
+          getAttrs: (el) => {
+            const start = Number.parseInt(el.getAttribute("start") ?? "1", 10);
+            const type = el.getAttribute("type");
+            return {
+              start: Number.isFinite(start) ? start : 1,
+              type: type && /^[1aAiI]$/.test(type) ? type : null
+            };
+          }
+        }
+      ],
+      toDOM: (node) => [
+        "ol",
+        {
+          start: node.attrs.start === 1 ? null : String(node.attrs.start),
+          type: node.attrs.type
+        },
+        0
+      ]
+    }
+  }),
+  commands: ({ schema }) => ({
+    toggleOrderedList: () => toggleList(schema.nodes.orderedList, schema.nodes.listItem)
+  }),
+  keymap: ({ schema }) => ({ "Mod-Shift-7": toggleList(schema.nodes.orderedList, schema.nodes.listItem) }),
+  inputRules: ({ schema }) => [
+    wrappingInputRule(
+      /^(\d+)\.\s$/,
+      schema.nodes.orderedList,
+      (match) => ({ start: Number(match[1]) }),
+      (match, node) => node.childCount + node.attrs.start === Number(match[1])
+    )
+  ]
+});
+var TaskItem = defineExtension({
+  name: "taskItem",
+  nodes: (_o, { t }) => ({
+    taskItem: {
+      attrs: { checked: { default: false } },
+      content: "paragraph block*",
+      defining: true,
+      parseDOM: [
+        {
+          tag: 'li[data-type="taskItem"]',
+          priority: 51,
+          getAttrs: (el) => ({
+            checked: el.getAttribute("data-checked") === "true" || !!el.querySelector(':scope > input[type="checkbox"][checked], :scope > label > input[checked]')
+          })
+        }
+      ],
+      // Output keeps a real, labelled checkbox so readers of the published page get the state.
+      toDOM: (node) => [
+        "li",
+        { "data-type": "taskItem", "data-checked": node.attrs.checked ? "true" : "false" },
+        [
+          "input",
+          {
+            type: "checkbox",
+            disabled: "",
+            checked: node.attrs.checked ? "" : null,
+            "aria-label": t("task")
+          }
+        ],
+        ["div", 0]
+      ]
+    }
+  }),
+  commands: () => ({}),
+  keymap: () => ({
+    // Ctrl/Cmd+Enter toggles the task at the cursor.
+    "Mod-Enter": (state, dispatch) => {
+      const item = findParent(state.selection.$from, (t) => t.name === "taskItem");
+      if (!item) return false;
+      if (dispatch) dispatch(state.tr.setNodeMarkup(item.pos, void 0, { checked: !item.node.attrs.checked }));
+      return true;
+    }
+  }),
+  plugins: ({ editor }) => [
+    new Plugin({
+      props: {
+        nodeViews: {
+          taskItem: (node, view, getPos) => new TaskItemView(node, view, getPos, editor)
+        }
+      }
+    })
+  ]
+});
+var TaskItemView = class {
+  constructor(node, view, getPos, editor) {
+    this.node = node;
+    this.checkbox = h("input", {
+      type: "checkbox",
+      className: "owe-task-checkbox",
+      "aria-label": editor.t("toggleTask")
+    });
+    this.checkbox.checked = node.attrs.checked;
+    this.checkbox.addEventListener("mousedown", (e) => e.preventDefault());
+    this.checkbox.addEventListener("change", () => {
+      const pos = getPos();
+      if (pos === void 0 || !editor.isEditable) {
+        this.checkbox.checked = this.node.attrs.checked;
+        return;
+      }
+      view.dispatch(view.state.tr.setNodeMarkup(pos, void 0, { checked: this.checkbox.checked }));
+    });
+    const label = h("span", { contenteditable: "false", className: "owe-task-control" }, this.checkbox);
+    this.contentDOM = h("div", { className: "owe-task-content" });
+    this.dom = h("li", { "data-type": "taskItem" }, label, this.contentDOM);
+    this.sync();
+  }
+  sync() {
+    this.dom.dataset.checked = String(this.node.attrs.checked);
+    this.checkbox.checked = this.node.attrs.checked;
+  }
+  update(node) {
+    if (node.type !== this.node.type) return false;
+    this.node = node;
+    this.sync();
+    return true;
+  }
+  stopEvent(event) {
+    return event.target === this.checkbox;
+  }
+  ignoreMutation(mutation) {
+    return mutation.type !== "selection" && !this.contentDOM.contains(mutation.target);
+  }
+};
+var TaskList = defineExtension({
+  name: "taskList",
+  extensions: () => [TaskItem],
+  nodes: () => ({
+    taskList: {
+      content: "taskItem+",
+      group: "block list",
+      parseDOM: [{ tag: 'ul[data-type="taskList"]', priority: 51 }],
+      toDOM: () => ["ul", { "data-type": "taskList" }, 0]
+    }
+  }),
+  commands: ({ schema }) => ({
+    toggleTaskList: () => toggleList(schema.nodes.taskList, schema.nodes.taskItem)
+  }),
+  keymap: ({ schema }) => ({ "Mod-Shift-9": toggleList(schema.nodes.taskList, schema.nodes.taskItem) }),
+  inputRules: ({ schema }) => [
+    wrappingInputRule(/^\s*\[( |x|X)?\]\s$/, schema.nodes.taskList)
+  ]
+});
+var notNormal = (value) => value !== "normal" && value !== "400" && value !== "lighter";
+var Bold = defineExtension({
+  name: "bold",
+  marks: () => ({
+    bold: {
+      parseDOM: [
+        { tag: "strong" },
+        // Google Docs wraps whole documents in <b style="font-weight:normal">.
+        { tag: "b", getAttrs: (el) => notNormal(el.style.fontWeight || "bold") && null },
+        { style: "font-weight=400", clearMark: (m) => m.type.name === "bold" },
+        { style: "font-weight", getAttrs: (v) => /^(bold(er)?|[6-9]\d{2})$/.test(v) && null }
+      ],
+      toDOM: () => ["strong", 0]
+    }
+  }),
+  commands: ({ schema }) => ({ toggleBold: () => toggleMarkCommand(schema.marks.bold) }),
+  keymap: ({ schema }) => ({ "Mod-b": toggleMarkCommand(schema.marks.bold) }),
+  inputRules: ({ schema }) => [
+    markInputRule(/(?:^|[^*\w])(\*\*([^*\s](?:[^*]*[^*\s])?)\*\*)$/, schema.marks.bold),
+    markInputRule(/(?:^|[^_\w])(__([^_\s](?:[^_]*[^_\s])?)__)$/, schema.marks.bold)
+  ]
+});
+var Italic = defineExtension({
+  name: "italic",
+  marks: () => ({
+    italic: {
+      parseDOM: [
+        { tag: "em" },
+        { tag: "i", getAttrs: (el) => el.style.fontStyle !== "normal" && null },
+        { style: "font-style=normal", clearMark: (m) => m.type.name === "italic" },
+        { style: "font-style=italic" }
+      ],
+      toDOM: () => ["em", 0]
+    }
+  }),
+  commands: ({ schema }) => ({ toggleItalic: () => toggleMarkCommand(schema.marks.italic) }),
+  keymap: ({ schema }) => ({ "Mod-i": toggleMarkCommand(schema.marks.italic) }),
+  inputRules: ({ schema }) => [
+    markInputRule(/(?:^|[^*\w])(\*([^*\s](?:[^*]*[^*\s])?)\*)$/, schema.marks.italic),
+    markInputRule(/(?:^|[^_\w])(_([^_\s](?:[^_]*[^_\s])?)_)$/, schema.marks.italic)
+  ]
+});
+var Underline = defineExtension({
+  name: "underline",
+  marks: () => ({
+    underline: {
+      parseDOM: [
+        { tag: "u" },
+        { tag: "ins" },
+        { style: "text-decoration", getAttrs: (v) => v.includes("underline") && null },
+        { style: "text-decoration-line", getAttrs: (v) => v.includes("underline") && null }
+      ],
+      toDOM: () => ["u", 0]
+    }
+  }),
+  commands: ({ schema }) => ({ toggleUnderline: () => toggleMarkCommand(schema.marks.underline) }),
+  keymap: ({ schema }) => ({ "Mod-u": toggleMarkCommand(schema.marks.underline) })
+});
+var Strike = defineExtension({
+  name: "strike",
+  marks: () => ({
+    strike: {
+      parseDOM: [
+        { tag: "s" },
+        { tag: "del" },
+        { tag: "strike" },
+        { style: "text-decoration", getAttrs: (v) => v.includes("line-through") && null },
+        { style: "text-decoration-line", getAttrs: (v) => v.includes("line-through") && null }
+      ],
+      toDOM: () => ["s", 0]
+    }
+  }),
+  commands: ({ schema }) => ({ toggleStrike: () => toggleMarkCommand(schema.marks.strike) }),
+  keymap: ({ schema }) => ({ "Mod-Shift-s": toggleMarkCommand(schema.marks.strike) }),
+  inputRules: ({ schema }) => [
+    markInputRule(/(?:^|[^~\w])(~~([^~\s](?:[^~]*[^~\s])?)~~)$/, schema.marks.strike)
+  ]
+});
+var Code = defineExtension({
+  name: "code",
+  marks: () => ({
+    code: {
+      excludes: "_",
+      code: true,
+      parseDOM: [{ tag: "code" }],
+      toDOM: () => ["code", 0]
+    }
+  }),
+  commands: ({ schema }) => ({ toggleCode: () => toggleMarkCommand(schema.marks.code) }),
+  keymap: ({ schema }) => ({ "Mod-e": toggleMarkCommand(schema.marks.code) }),
+  inputRules: ({ schema }) => [markInputRule(/(?:^|[^`])(`([^`]+)`)$/, schema.marks.code)]
+});
+var script = (tag, align, excludes) => ({
+  excludes,
+  parseDOM: [{ tag }, { style: "vertical-align", getAttrs: (v) => v === align && null }],
+  toDOM: () => [tag, 0]
+});
+var Subscript = defineExtension({
+  name: "subscript",
+  marks: () => ({ subscript: script("sub", "sub", "superscript") }),
+  commands: ({ schema }) => ({ toggleSubscript: () => toggleMarkCommand(schema.marks.subscript) }),
+  keymap: ({ schema }) => ({ "Mod-,": toggleMarkCommand(schema.marks.subscript) })
+});
+var Superscript = defineExtension({
+  name: "superscript",
+  marks: () => ({ superscript: script("sup", "super", "subscript") }),
+  commands: ({ schema }) => ({ toggleSuperscript: () => toggleMarkCommand(schema.marks.superscript) }),
+  keymap: ({ schema }) => ({ "Mod-.": toggleMarkCommand(schema.marks.superscript) })
+});
+var Link = defineExtension({
+  name: "link",
+  priority: 1e3,
+  // outermost mark: <a><strong>…</strong></a>
+  defaultOptions: { rel: null, linkOnPaste: true },
+  marks: (options, { urlPolicy }) => ({
+    link: {
+      attrs: {
+        href: { default: null },
+        target: { default: null },
+        title: { default: null }
+      },
+      inclusive: false,
+      parseDOM: [
+        {
+          tag: "a[href]",
+          getAttrs: (el) => {
+            const href = sanitizeUrl(el.getAttribute("href"), urlPolicy);
+            if (!href) return false;
+            return {
+              href,
+              target: el.getAttribute("target") === "_blank" ? "_blank" : null,
+              title: el.getAttribute("title")
+            };
+          }
+        }
+      ],
+      toDOM: (mark) => {
+        const newTab = mark.attrs.target === "_blank";
+        const rel = [newTab ? "noopener noreferrer" : null, options.rel].filter(Boolean).join(" ");
+        return [
+          "a",
+          {
+            href: sanitizeUrl(mark.attrs.href, urlPolicy),
+            target: newTab ? "_blank" : null,
+            rel: rel || null,
+            title: mark.attrs.title
+          },
+          0
+        ];
+      }
+    }
+  }),
+  commands: ({ schema }) => {
+    const type = schema.marks.link;
+    const setLink = (attrs) => (state, dispatch) => {
+      const href = sanitizeUrl(attrs.href, readPolicy(schema));
+      if (!href) return false;
+      const mark = type.create({ href, target: attrs.newTab ? "_blank" : null, title: attrs.title ?? null });
+      const { empty, from, to, $from } = state.selection;
+      const tr = state.tr;
+      if (empty) {
+        const range = markRange($from, type);
+        if (range) {
+          if (attrs.text && attrs.text !== state.doc.textBetween(range.from, range.to)) {
+            const kept = state.doc.resolve(range.from + 1).marks().filter((m) => m.type !== type);
+            tr.replaceWith(range.from, range.to, schema.text(attrs.text, [...kept, mark]));
+          } else {
+            tr.removeMark(range.from, range.to, type).addMark(range.from, range.to, mark);
+          }
+        } else {
+          const text = attrs.text || href;
+          tr.insert(from, schema.text(text, [...$from.marks().filter((m) => m.type !== type), mark]));
+          tr.setSelection(TextSelection.create(tr.doc, from + text.length));
+        }
+      } else if (attrs.text && attrs.text !== state.doc.textBetween(from, to)) {
+        tr.replaceWith(from, to, schema.text(attrs.text, [mark]));
+      } else {
+        tr.removeMark(from, to, type).addMark(from, to, mark);
+      }
+      tr.removeStoredMark(type);
+      if (dispatch) dispatch(tr.scrollIntoView());
+      return true;
+    };
+    const unsetLink = (state, dispatch) => {
+      const { empty, from, to, $from } = state.selection;
+      const range = empty ? markRange($from, type) : { from, to };
+      if (!range) return false;
+      if (dispatch) dispatch(state.tr.removeMark(range.from, range.to, type));
+      return true;
+    };
+    return { setLink, unsetLink: () => unsetLink };
+  },
+  plugins: ({ schema, options }) => options.linkOnPaste ? [
+    new Plugin({
+      props: {
+        handlePaste(view, event) {
+          const { empty, from, to } = view.state.selection;
+          if (empty) return false;
+          const text = event.clipboardData?.getData("text/plain")?.trim() ?? "";
+          if (!/^(https?:\/\/|mailto:)\S+$/i.test(text)) return false;
+          const href = sanitizeUrl(text, readPolicy(schema));
+          if (!href) return false;
+          view.dispatch(view.state.tr.addMark(from, to, schema.marks.link.create({ href })));
+          return true;
+        }
+      }
+    })
+  ] : []
+});
+function readPolicy(schema) {
+  return schema.cached.urlPolicy ?? {};
+}
+var Document = defineExtension({
+  name: "doc",
+  nodes: () => ({ doc: { content: "block+" } })
+});
+var Text = defineExtension({
+  name: "text",
+  nodes: () => ({ text: { group: "inline" } })
+});
+var Paragraph = defineExtension({
+  name: "paragraph",
+  priority: 1e3,
+  nodes: () => ({
+    paragraph: {
+      content: "inline*",
+      group: "block",
+      parseDOM: [{ tag: "p" }],
+      toDOM: () => ["p", 0]
+    }
+  }),
+  commands: ({ schema }) => ({
+    setParagraph: () => setBlockType(schema.nodes.paragraph)
+  }),
+  keymap: ({ schema }) => ({ "Mod-Alt-0": setBlockType(schema.nodes.paragraph) })
+});
+var Heading = defineExtension({
+  name: "heading",
+  defaultOptions: { levels: [1, 2, 3, 4, 5, 6] },
+  nodes: ({ levels }) => ({
+    heading: {
+      attrs: { level: { default: levels[0] ?? 1, validate: "number" } },
+      content: "inline*",
+      group: "block",
+      defining: true,
+      parseDOM: [1, 2, 3, 4, 5, 6].map((n) => ({
+        tag: `h${n}`,
+        // Levels that aren't enabled collapse to the nearest allowed one (structure is kept).
+        attrs: { level: nearest(levels, n) }
+      })),
+      toDOM: (node) => [`h${nearest(levels, node.attrs.level)}`, 0]
+    }
+  }),
+  commands: ({ schema, options }) => {
+    const type = schema.nodes.heading;
+    const valid = (level) => options.levels.includes(level);
+    return {
+      setHeading: (level) => valid(level) ? setBlockType(type, { level }) : () => false,
+      toggleHeading: (level) => valid(level) ? toggleBlockType(type, schema.nodes.paragraph, { level }) : () => false
+    };
+  },
+  keymap: ({ schema, options }) => Object.fromEntries(
+    options.levels.map((level) => [
+      `Mod-Alt-${level}`,
+      toggleBlockType(schema.nodes.heading, schema.nodes.paragraph, { level })
+    ])
+  ),
+  inputRules: ({ schema, options }) => [
+    textblockTypeInputRule(/^(#{1,6})\s$/, schema.nodes.heading, (match) => ({
+      level: nearest(options.levels, match[1].length)
+    }))
+  ]
+});
+function nearest(levels, level) {
+  if (levels.includes(level)) return level;
+  return levels.reduce((best, l) => Math.abs(l - level) < Math.abs(best - level) ? l : best, levels[0] ?? 1);
+}
+var Blockquote = defineExtension({
+  name: "blockquote",
+  nodes: () => ({
+    blockquote: {
+      content: "block+",
+      group: "block",
+      defining: true,
+      parseDOM: [{ tag: "blockquote" }],
+      toDOM: () => ["blockquote", 0]
+    }
+  }),
+  commands: ({ schema }) => ({ toggleBlockquote: () => toggleWrap(schema.nodes.blockquote) }),
+  keymap: ({ schema }) => ({ "Mod-Shift-b": toggleWrap(schema.nodes.blockquote) }),
+  inputRules: ({ schema }) => [wrappingInputRule(/^\s*>\s$/, schema.nodes.blockquote)]
+});
+var insertHardBreak = (state, dispatch) => {
+  const type = state.schema.nodes.hardBreak;
+  if (!type) return false;
+  if (dispatch) dispatch(state.tr.replaceSelectionWith(type.create()).scrollIntoView());
+  return true;
+};
+var HardBreak = defineExtension({
+  name: "hardBreak",
+  nodes: () => ({
+    hardBreak: {
+      inline: true,
+      group: "inline",
+      selectable: false,
+      leafText: () => "\n",
+      parseDOM: [{ tag: "br" }],
+      toDOM: () => ["br"]
+    }
+  }),
+  commands: () => ({ setHardBreak: () => insertHardBreak }),
+  keymap: () => ({
+    "Shift-Enter": chainCommands(exitCode, insertHardBreak),
+    "Mod-Enter": chainCommands(exitCode, insertHardBreak)
+  })
+});
+var insertHorizontalRule = (state, dispatch) => {
+  const { horizontalRule, paragraph } = state.schema.nodes;
+  if (!horizontalRule) return false;
+  if (dispatch) {
+    const tr = state.tr.replaceSelectionWith(horizontalRule.create());
+    const after = tr.selection.$from;
+    if (!after.nodeAfter && paragraph) {
+      tr.insert(after.pos, paragraph.create());
+      tr.setSelection(TextSelection.create(tr.doc, after.pos + 1));
+    }
+    dispatch(tr.scrollIntoView());
+  }
+  return true;
+};
+var HorizontalRule = defineExtension({
+  name: "horizontalRule",
+  nodes: () => ({
+    horizontalRule: {
+      group: "block",
+      parseDOM: [{ tag: "hr" }],
+      toDOM: () => ["hr"]
+    }
+  }),
+  commands: () => ({ setHorizontalRule: () => insertHorizontalRule }),
+  inputRules: ({ schema }) => [
+    new InputRule(/^(?:---|___\s|\*\*\*\s)$/, (state, _match, start, end) => {
+      const type = schema.nodes.horizontalRule;
+      const $start = state.doc.resolve(start);
+      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), type)) return null;
+      const tr = state.tr.delete(start, end);
+      const pos = tr.mapping.map($start.before());
+      tr.insert(pos, type.create());
+      return tr;
+    })
+  ]
+});
+var LANGUAGE = /^[a-zA-Z0-9_+#.-]{1,32}$/;
+var CodeBlock = defineExtension({
+  name: "codeBlock",
+  defaultOptions: { languageClassPrefix: "language-" },
+  nodes: ({ languageClassPrefix }) => ({
+    codeBlock: {
+      attrs: { language: { default: null } },
+      content: "text*",
+      marks: "",
+      group: "block",
+      code: true,
+      defining: true,
+      parseDOM: [
+        {
+          tag: "pre",
+          preserveWhitespace: "full",
+          getAttrs: (dom) => {
+            const cls = (dom.querySelector("code")?.className ?? dom.className) || "";
+            const match = /(?:^|\s)(?:language|lang)-([^\s]+)/.exec(cls);
+            const language = match?.[1] ?? dom.getAttribute("data-language");
+            return { language: language && LANGUAGE.test(language) ? language : null };
+          }
+        }
+      ],
+      toDOM: (node) => {
+        const language = node.attrs.language;
+        const valid = language && LANGUAGE.test(language);
+        return ["pre", ["code", valid ? { class: `${languageClassPrefix}${language}` } : {}, 0]];
+      }
+    }
+  }),
+  commands: ({ schema }) => ({
+    toggleCodeBlock: (attrs = {}) => toggleBlockType(
+      schema.nodes.codeBlock,
+      schema.nodes.paragraph,
+      { language: attrs.language && LANGUAGE.test(attrs.language) ? attrs.language : null },
+      {}
+      // any code block counts as active, whatever its language
+    )
+  }),
+  keymap: ({ schema }) => ({
+    "Mod-Alt-c": toggleBlockType(schema.nodes.codeBlock, schema.nodes.paragraph),
+    // Backspace at the start of an empty code block turns it back into a paragraph.
+    Backspace: (state, dispatch) => {
+      const { $from, empty } = state.selection;
+      if (!empty || $from.parent.type !== schema.nodes.codeBlock || $from.parent.content.size) return false;
+      return setBlockType(schema.nodes.paragraph)(state, dispatch);
+    }
+  }),
+  inputRules: ({ schema }) => [
+    textblockTypeInputRule(/^```([a-zA-Z0-9_+#.-]{1,32})?[\s\n]$/, schema.nodes.codeBlock, (match) => ({
+      language: match[1] ?? null
+    }))
+  ]
+});
+var Table = defineExtension({
+  name: "table",
+  defaultOptions: { resizable: true, maxSize: 100 },
+  nodes: () => {
+    const base = tableNodes({
+      tableGroup: "block",
+      cellContent: "block+",
+      cellAttributes: {
+        scope: {
+          default: null,
+          getFromDOM: (dom) => {
+            const scope = dom.getAttribute("scope");
+            return scope === "col" || scope === "row" ? scope : null;
+          },
+          setDOMAttr: (value, attrs) => {
+            if (value) attrs.scope = value;
+          }
+        }
+      }
+    });
+    const table = {
+      ...base.table,
+      content: "tableRow+",
+      attrs: { caption: { default: null } },
+      parseDOM: [
+        {
+          tag: "table",
+          getAttrs: (el) => ({
+            caption: el.querySelector(":scope > caption")?.textContent?.trim() || null
+          })
+        },
+        // The caption is stored as an attribute (read above); don't parse it as cell content.
+        { tag: "caption", ignore: true }
+      ],
+      toDOM: (node) => node.attrs.caption ? ["table", ["caption", node.attrs.caption], ["tbody", 0]] : ["table", ["tbody", 0]]
+    };
+    return {
+      table,
+      tableRow: { ...base.table_row, content: "(tableCell | tableHeader)*" },
+      tableCell: base.table_cell,
+      tableHeader: base.table_header
+    };
+  },
+  commands: ({ schema, options }) => {
+    const insertTable = ({ rows = 3, cols = 3, withHeaderRow = true, caption = null } = {}) => (state, dispatch) => {
+      const r = clamp(rows, 1, options.maxSize);
+      const c = clamp(cols, 1, options.maxSize);
+      const { table, tableRow, tableCell, tableHeader, paragraph } = schema.nodes;
+      const cell = (header) => (header ? tableHeader : tableCell).createAndFill(header ? { scope: "col" } : null);
+      const rowNodes = Array.from(
+        { length: r },
+        (_, i) => tableRow.create(null, Array.from({ length: c }, () => cell(withHeaderRow && i === 0)))
+      );
+      const node = table.create({ caption: caption?.trim() || null }, rowNodes);
+      if (!dispatch) return true;
+      const tr = state.tr.replaceSelectionWith(node);
+      let tablePos = -1;
+      tr.doc.descendants((n, pos) => {
+        if (n === node) tablePos = pos;
+        return tablePos < 0;
+      });
+      if (tablePos < 0) return false;
+      if (tablePos + node.nodeSize === tr.doc.content.size && paragraph) {
+        tr.insert(tr.doc.content.size, paragraph.create());
+      }
+      tr.setSelection(TextSelection.near(tr.doc.resolve(tablePos + 4)));
+      dispatch(tr.scrollIntoView());
+      return true;
+    };
+    const setTableCaption = (caption) => (state, dispatch) => {
+      const found = findParent(state.selection.$from, (t) => t.name === "table");
+      if (!found) return false;
+      if (dispatch) {
+        dispatch(state.tr.setNodeMarkup(found.pos, void 0, { ...found.node.attrs, caption: caption?.trim() || null }));
+      }
+      return true;
+    };
+    return {
+      insertTable,
+      addRowBefore: () => addRowBefore,
+      addRowAfter: () => addRowAfter,
+      addColumnBefore: () => addColumnBefore,
+      addColumnAfter: () => addColumnAfter,
+      deleteRow: () => deleteRow,
+      deleteColumn: () => deleteColumn,
+      deleteTable: () => deleteTable,
+      mergeCells: () => mergeCells,
+      splitCell: () => splitCell,
+      // The non-deprecated toggle logic (the default exports use the legacy behaviour).
+      toggleHeaderRow: () => toggleHeader("row"),
+      toggleHeaderColumn: () => toggleHeader("column"),
+      setTableCaption,
+      goToNextCell: (direction) => goToNextCell(direction)
+    };
+  },
+  keymap: () => ({
+    // Fails at the last/first cell, so Tab then moves focus out of the editor (no trap).
+    Tab: goToNextCell(1),
+    "Shift-Tab": goToNextCell(-1)
+  }),
+  plugins: ({ options }) => [
+    ...options.resizable ? [columnResizing({ cellMinWidth: 48 })] : [],
+    tableEditing(),
+    headerScopePlugin()
+  ]
+});
+function clamp(n, min, max) {
+  return Math.min(max, Math.max(min, Math.floor(Number.isFinite(n) ? n : min)));
+}
+function headerScopePlugin() {
+  return new Plugin({
+    appendTransaction(trs, _old, state) {
+      if (!trs.some((tr2) => tr2.docChanged)) return null;
+      const tr = state.tr;
+      state.doc.descendants((node, pos) => {
+        if (node.type.name !== "table") return node.isBlock;
+        node.forEach((row, rowOffset, rowIndex) => {
+          row.forEach((cell, cellOffset, cellIndex) => {
+            const want = cell.type.name === "tableHeader" ? rowIndex === 0 ? "col" : cellIndex === 0 ? "row" : "col" : null;
+            if (cell.attrs.scope !== want) {
+              tr.setNodeMarkup(pos + 1 + rowOffset + 1 + cellOffset, void 0, { ...cell.attrs, scope: want });
+            }
+          });
+        });
+        return false;
+      });
+      return tr.docChanged ? tr.setMeta("addToHistory", false) : null;
+    }
+  });
+}
+var searchKey = new PluginKey("owe-search");
+var EMPTY = { query: "", caseSensitive: false, wholeWord: false, matches: [], index: -1 };
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function findMatches(doc, q) {
+  if (!q.query) return [];
+  let source = escapeRegExp(q.query);
+  if (q.wholeWord) source = `(?<![\\p{L}\\p{N}_\\p{M}])${source}(?![\\p{L}\\p{N}_\\p{M}])`;
+  let re;
+  try {
+    re = new RegExp(source, `g${q.caseSensitive ? "" : "i"}u`);
+  } catch {
+    return [];
+  }
+  const matches = [];
+  doc.descendants((node, pos) => {
+    if (!node.isTextblock) return true;
+    let text = "";
+    node.forEach((child) => {
+      text += child.isText ? child.text : "".repeat(child.nodeSize);
+    });
+    for (const m of text.matchAll(re)) {
+      if (!m[0]) continue;
+      const from = pos + 1 + m.index;
+      matches.push({ from, to: from + m[0].length });
+      if (matches.length > 1e4) return false;
+    }
+    return false;
+  });
+  return matches;
+}
+function nearestIndex(matches, pos) {
+  if (!matches.length) return -1;
+  const i = matches.findIndex((m) => m.from >= pos);
+  return i === -1 ? 0 : i;
+}
+function getSearchState(state) {
+  return searchKey.getState(state) ?? EMPTY;
+}
+var select = (direction) => (state, dispatch) => {
+  const s = getSearchState(state);
+  if (!s.matches.length) return false;
+  let index;
+  if (s.index === -1) index = direction === 1 ? nearestIndex(s.matches, state.selection.from) : s.matches.length - 1;
+  else index = (s.index + direction + s.matches.length) % s.matches.length;
+  const m = s.matches[index];
+  if (dispatch) {
+    dispatch(
+      state.tr.setSelection(TextSelection.create(state.doc, m.from, m.to)).setMeta(searchKey, { type: "index", index }).scrollIntoView()
+    );
+  }
+  return true;
+};
+var FindReplace = defineExtension({
+  name: "findReplace",
+  commands: () => ({
+    setSearch: (query) => (state, dispatch) => {
+      if (dispatch) dispatch(state.tr.setMeta(searchKey, { type: "set", query }));
+      return true;
+    },
+    clearSearch: () => (state, dispatch) => {
+      if (dispatch) dispatch(state.tr.setMeta(searchKey, { type: "clear" }));
+      return true;
+    },
+    findNext: () => select(1),
+    findPrevious: () => select(-1),
+    replaceCurrent: (replacement) => (state, dispatch) => {
+      const s = getSearchState(state);
+      const m = s.matches[s.index];
+      if (!m) return false;
+      if (dispatch) {
+        const tr = state.tr;
+        if (replacement) tr.insertText(replacement, m.from, m.to);
+        else tr.delete(m.from, m.to);
+        const next = findMatches(tr.doc, s).findIndex((x) => x.from >= tr.mapping.map(m.to));
+        if (next >= 0) {
+          const nm = findMatches(tr.doc, s)[next];
+          tr.setSelection(TextSelection.create(tr.doc, nm.from, nm.to)).setMeta(searchKey, { type: "index", index: next });
+        }
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    },
+    replaceAll: (replacement) => (state, dispatch) => {
+      const s = getSearchState(state);
+      if (!s.matches.length) return false;
+      if (dispatch) {
+        const tr = state.tr;
+        for (const m of [...s.matches].reverse()) {
+          if (replacement) tr.insertText(replacement, m.from, m.to);
+          else tr.delete(m.from, m.to);
+        }
+        dispatch(tr);
+      }
+      return true;
+    }
+  }),
+  plugins: () => [
+    new Plugin({
+      key: searchKey,
+      state: {
+        init: () => EMPTY,
+        apply(tr, prev) {
+          const meta = tr.getMeta(searchKey);
+          if (meta?.type === "clear") return EMPTY;
+          if (meta?.type === "set") {
+            const q = { query: meta.query.query, caseSensitive: !!meta.query.caseSensitive, wholeWord: !!meta.query.wholeWord };
+            const matches = findMatches(tr.doc, q);
+            return { ...q, matches, index: -1 };
+          }
+          if (meta?.type === "index") return { ...prev, index: meta.index };
+          if (tr.docChanged && prev.query) {
+            const matches = findMatches(tr.doc, prev);
+            return { ...prev, matches, index: Math.min(prev.index, matches.length - 1) };
+          }
+          return prev;
+        }
+      },
+      props: {
+        decorations(state) {
+          const s = getSearchState(state);
+          if (!s.matches.length) return null;
+          return DecorationSet.create(
+            state.doc,
+            s.matches.map(
+              (m, i) => Decoration.inline(m.from, m.to, { class: i === s.index ? "owe-find-match owe-find-current" : "owe-find-match" })
+            )
+          );
+        }
+      }
+    })
+  ]
+});
+
+// src/core/color.ts
+var HEX = /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var RGB_FN = /^rgba?\(\s*(\d{1,3})\s*[, ]\s*(\d{1,3})\s*[, ]\s*(\d{1,3})\s*(?:[,/]\s*(?:0|1|0?\.\d+|\d{1,3}%))?\s*\)$/i;
+var HSL_FN = /^hsla?\(\s*(\d{1,3}(?:\.\d+)?)(?:deg)?\s*[, ]\s*(\d{1,3}(?:\.\d+)?)%\s*[, ]\s*(\d{1,3}(?:\.\d+)?)%\s*(?:[,/]\s*(?:0|1|0?\.\d+|\d{1,3}%))?\s*\)$/i;
+var NAMED = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  yellow: "#ffff00",
+  orange: "#ffa500",
+  purple: "#800080",
+  gray: "#808080",
+  grey: "#808080",
+  silver: "#c0c0c0",
+  maroon: "#800000",
+  navy: "#000080",
+  teal: "#008080",
+  olive: "#808000",
+  lime: "#00ff00",
+  aqua: "#00ffff",
+  cyan: "#00ffff",
+  fuchsia: "#ff00ff",
+  magenta: "#ff00ff",
+  pink: "#ffc0cb",
+  brown: "#a52a2a",
+  darkred: "#8b0000",
+  darkblue: "#00008b",
+  darkgreen: "#006400"
+};
+function hsl2rgb(h2, s, l) {
+  s /= 100;
+  l /= 100;
+  const k = (n) => (n + h2 / 30) % 12;
+  const a = s * Math.min(l, 1 - l);
+  const f = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return [Math.round(f(0) * 255), Math.round(f(8) * 255), Math.round(f(4) * 255)];
+}
+function parseColor(input) {
+  if (typeof input !== "string") return null;
+  const value = input.trim().toLowerCase();
+  const hex = HEX.exec(NAMED[value] ?? value)?.[1];
+  if (hex) {
+    const full = hex.length <= 4 ? [...hex.slice(0, 3)].map((c) => c + c).join("") : hex.slice(0, 6);
+    return [0, 2, 4].map((i) => Number.parseInt(full.slice(i, i + 2), 16));
+  }
+  const rgb = RGB_FN.exec(value);
+  if (rgb) {
+    const parts2 = rgb.slice(1, 4).map(Number);
+    return parts2.every((n) => n <= 255) ? parts2 : null;
+  }
+  const hsl = HSL_FN.exec(value);
+  if (hsl) return hsl2rgb(Number(hsl[1]) % 360, Math.min(100, Number(hsl[2])), Math.min(100, Number(hsl[3])));
+  return null;
+}
+var toHex = ([r, g, b]) => `#${[r, g, b].map((n) => n.toString(16).padStart(2, "0")).join("")}`;
+function normalizeColor(input) {
+  const rgb = parseColor(input);
+  return rgb ? toHex(rgb) : null;
+}
+function luminance([r, g, b]) {
+  const lin = (c) => {
+    const s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+function contrastRatio(a, b) {
+  const ca = parseColor(a);
+  const cb = parseColor(b);
+  if (!ca || !cb) return null;
+  const [hi, lo] = [luminance(ca), luminance(cb)].sort((x, y) => y - x);
+  return (hi + 0.05) / (lo + 0.05);
+}
+var TEXT_PALETTE = [
+  { name: "colorBlack", value: "#1b1f24" },
+  { name: "colorDarkGray", value: "#57606a" },
+  { name: "colorDarkRed", value: "#b3261e" },
+  { name: "colorDarkOrange", value: "#9a4a00" },
+  { name: "colorOlive", value: "#6b5b00" },
+  { name: "colorDarkGreen", value: "#146c2e" },
+  { name: "colorTeal", value: "#006a6a" },
+  { name: "colorBlue", value: "#0b57d0" },
+  { name: "colorPurple", value: "#6f2dbd" },
+  { name: "colorMagenta", value: "#a1185d" }
+];
+var HIGHLIGHT_PALETTE = [
+  { name: "colorYellow", value: "#fff2a8" },
+  { name: "colorGreen", value: "#c9f2d0" },
+  { name: "colorBlue", value: "#d3e3fd" },
+  { name: "colorPink", value: "#ffd8e6" },
+  { name: "colorOrange", value: "#ffe0b8" },
+  { name: "colorPurple", value: "#e8dcff" },
+  { name: "colorGray", value: "#e6e8eb" }
+];
+var NOISE_TEXT = /* @__PURE__ */ new Set(["#000000", "#1b1f24"]);
+var NOISE_TEXT_RAW = /^(inherit|initial|unset|currentcolor|windowtext|auto|black)$/i;
+var NOISE_BG = /^(transparent|inherit|initial|unset|none|window|white|#fff(fff)?)$/i;
+function applyColor(type, color) {
+  return (state, dispatch) => {
+    const value = color === null ? null : normalizeColor(color);
+    if (color !== null && !value) return false;
+    const { from, to, empty } = state.selection;
+    const tr = state.tr;
+    if (empty) {
+      tr.removeStoredMark(type);
+      if (value) tr.addStoredMark(type.create({ color: value }));
+    } else {
+      let applicable = false;
+      state.doc.nodesBetween(from, to, (node, pos, parent) => {
+        if (!node.isInline || !parent?.type.allowsMarkType(type)) return true;
+        applicable = true;
+        const start = Math.max(pos, from);
+        const end = Math.min(pos + node.nodeSize, to);
+        tr.removeMark(start, end, type);
+        if (value) tr.addMark(start, end, type.create({ color: value }));
+        return true;
+      });
+      if (!applicable) return false;
+    }
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+var styledView = (tag, prop) => (mark) => {
+  const dom = document.createElement(tag);
+  const color = normalizeColor(mark.attrs.color);
+  if (color) dom.style.setProperty(prop, color);
+  return { dom };
+};
+var TextColor = defineExtension({
+  name: "textColor",
+  defaultOptions: { palette: TEXT_PALETTE },
+  marks: () => ({
+    textColor: {
+      attrs: { color: { default: null } },
+      parseDOM: [
+        {
+          style: "color",
+          getAttrs: (raw) => {
+            if (NOISE_TEXT_RAW.test(raw.trim())) return false;
+            const color = normalizeColor(raw);
+            return color && !NOISE_TEXT.has(color) ? { color } : false;
+          }
+        },
+        {
+          tag: "font[color]",
+          getAttrs: (el) => {
+            const color = normalizeColor(el.getAttribute("color"));
+            return color && !NOISE_TEXT.has(color) ? { color } : false;
+          }
+        }
+      ],
+      toDOM: (mark) => {
+        const color = normalizeColor(mark.attrs.color);
+        return ["span", color ? { style: `color: ${color}` } : {}, 0];
+      }
+    }
+  }),
+  commands: ({ schema }) => ({
+    setTextColor: (color) => applyColor(schema.marks.textColor, color),
+    unsetTextColor: () => applyColor(schema.marks.textColor, null)
+  }),
+  plugins: () => [new Plugin({ props: { markViews: { textColor: styledView("span", "color") } } })]
+});
+var Highlight = defineExtension({
+  name: "highlight",
+  defaultOptions: { palette: HIGHLIGHT_PALETTE },
+  marks: () => ({
+    highlight: {
+      attrs: { color: { default: null } },
+      parseDOM: [
+        {
+          tag: "mark",
+          getAttrs: (el) => ({
+            color: normalizeColor(el.style.backgroundColor || el.getAttribute("data-color")) ?? null
+          })
+        },
+        ...["background-color", "background"].map((style) => ({
+          style,
+          getAttrs: (raw) => {
+            const value = raw.trim();
+            if (NOISE_BG.test(value)) return false;
+            const color = normalizeColor(value);
+            return color && color !== "#ffffff" ? { color } : false;
+          }
+        }))
+      ],
+      // <mark> is semantic: assistive tech can report "highlighted" text.
+      toDOM: (mark) => {
+        const color = normalizeColor(mark.attrs.color);
+        return ["mark", color ? { style: `background-color: ${color}` } : {}, 0];
+      }
+    }
+  }),
+  commands: ({ schema, options }) => {
+    const type = schema.marks.highlight;
+    return {
+      setHighlight: (color) => applyColor(type, color ?? options.palette[0]?.value ?? "#fff2a8"),
+      unsetHighlight: () => applyColor(type, null),
+      toggleHighlight: (color) => (state, dispatch, view) => {
+        const { from, to, empty, $from } = state.selection;
+        const active = empty ? !!type.isInSet(state.storedMarks ?? $from.marks()) : state.doc.rangeHasMark(from, to, type);
+        return applyColor(type, active ? null : color ?? options.palette[0]?.value ?? "#fff2a8")(state, dispatch);
+      }
+    };
+  },
+  keymap: ({ editor }) => ({
+    "Mod-Shift-h": () => editor.commands.toggleHighlight()
+  }),
+  plugins: () => [new Plugin({ props: { markViews: { highlight: styledView("mark", "background-color") } } })]
+});
+var IntlSegmenter = Intl.Segmenter;
+var cache = /* @__PURE__ */ new Map();
+function segmenter(lang, granularity) {
+  if (!IntlSegmenter) return null;
+  const key = `${lang ?? ""}|${granularity}`;
+  let s = cache.get(key);
+  if (!s) {
+    try {
+      s = new IntlSegmenter(lang, { granularity });
+    } catch {
+      s = new IntlSegmenter(void 0, { granularity });
+    }
+    cache.set(key, s);
+  }
+  return s;
+}
+function countCharacters(text, lang) {
+  const seg = segmenter(lang, "grapheme");
+  if (!seg) return [...text].length;
+  let n = 0;
+  for (const segment of seg.segment(text)) if (segment) n++;
+  return n;
+}
+function countWords(text, lang) {
+  const seg = segmenter(lang, "word");
+  if (!seg) return text.split(/\s+/).filter(Boolean).length;
+  let n = 0;
+  for (const s of seg.segment(text)) if (s.isWordLike) n++;
+  return n;
+}
+var docText = (doc) => doc.textBetween(0, doc.content.size, "\n", "\n");
+var characterCountKey = new PluginKey("owe-character-count");
+var CharacterCount = defineExtension({
+  name: "characterCount",
+  defaultOptions: { limit: null },
+  plugins: ({ options, editor }) => [
+    new Plugin({
+      key: characterCountKey,
+      filterTransaction(tr, state) {
+        const limit = options.limit;
+        if (!limit || !tr.docChanged || tr.getMeta("addToHistory") === false) return true;
+        const before = countCharacters(docText(state.doc));
+        const after = countCharacters(docText(tr.doc));
+        if (after <= limit || after <= before) return true;
+        editor.announce(editor.t("charLimitReached"), "assertive");
+        return false;
+      }
+    })
+  ]
+});
+
+// src/extensions/starter-kit.ts
+var parts = [
+  ["link", Link],
+  ["heading", Heading],
+  ["blockquote", Blockquote],
+  ["codeBlock", CodeBlock],
+  ["hardBreak", HardBreak],
+  ["horizontalRule", HorizontalRule],
+  ["bulletList", BulletList],
+  ["orderedList", OrderedList],
+  ["taskList", TaskList],
+  ["image", Image],
+  ["table", Table],
+  ["bold", Bold],
+  ["italic", Italic],
+  ["underline", Underline],
+  ["strike", Strike],
+  ["code", Code],
+  ["subscript", Subscript],
+  ["superscript", Superscript],
+  ["textColor", TextColor],
+  ["highlight", Highlight],
+  ["textAlign", TextAlign],
+  ["textDirection", TextDirection],
+  ["history", History],
+  ["dropcursor", Dropcursor],
+  ["gapcursor", Gapcursor],
+  ["findReplace", FindReplace],
+  ["characterCount", CharacterCount]
+];
+var StarterKit = defineExtension({
+  name: "starterKit",
+  defaultOptions: {},
+  extensions: (options) => [
+    Document,
+    Text,
+    Paragraph,
+    ...parts.filter(([key]) => options[key] !== false).map(([key, ext]) => {
+      const config2 = options[key];
+      return config2 ? ext.configure(config2) : ext;
+    })
+  ]
+});
+
+// src/extensions/html-support.ts
+var HTML_CONTAINERS = [
+  "div",
+  "section",
+  "article",
+  "aside",
+  "header",
+  "footer",
+  "nav",
+  "main",
+  "address",
+  "hgroup",
+  "details",
+  "dl",
+  "dd",
+  "center",
+  "search"
+];
+var HTML_TEXTBLOCKS = ["summary", "dt"];
+var HTML_INLINE = [
+  "span",
+  "abbr",
+  "cite",
+  "dfn",
+  "kbd",
+  "mark",
+  "q",
+  "small",
+  "time",
+  "var",
+  "samp",
+  "bdi",
+  "bdo",
+  "data",
+  "big",
+  "ruby",
+  "rt",
+  "rp"
+];
+var KNOWN_TYPES = [
+  "paragraph",
+  "heading",
+  "blockquote",
+  "bulletList",
+  "orderedList",
+  "listItem",
+  "taskList",
+  "taskItem",
+  "codeBlock",
+  "horizontalRule",
+  "image",
+  "table",
+  "tableRow",
+  "tableCell",
+  "tableHeader",
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "code",
+  "subscript",
+  "superscript",
+  "link"
+];
+var HTML_SAFE_RULES = [
+  {
+    name: new RegExp(`^(${[...HTML_CONTAINERS, ...HTML_TEXTBLOCKS].join("|")})$`),
+    attributes: ["data-*", "id", "title", "lang", "aria-label", "aria-labelledby", "aria-describedby", "role"],
+    classes: true
+  },
+  {
+    name: new RegExp(`^(${HTML_INLINE.join("|")})$`),
+    attributes: ["data-*", "title", "lang", "dir", "datetime", "value", "cite", "translate"],
+    classes: true
+  },
+  {
+    name: /^(p|h[1-6]|blockquote|ul|ol|li|table|tr|td|th|pre|code|figure|img|a|strong|em|u|s|sub|sup|hr)$/,
+    attributes: ["data-*", "id", "lang", "translate"],
+    classes: true
+  }
+];
+var RESERVED = /* @__PURE__ */ new Set([
+  "src",
+  "srcset",
+  "href",
+  "alt",
+  "width",
+  "height",
+  "start",
+  "type",
+  "dir",
+  "colspan",
+  "rowspan",
+  "colwidth",
+  "scope",
+  "title",
+  "data-type",
+  "data-checked",
+  "data-colwidth",
+  "data-language",
+  "open"
+]);
+var DENIED = /^(on|xmlns|xlink)|^(srcdoc|formaction|action|ping|background|tabindex|accesskey|autofocus|contenteditable|draggable|hidden|inert|popover|popovertarget|is|slot|part|nonce|style|class)$|^data-(pm|owe)-/i;
+var URL_ATTRS2 = /* @__PURE__ */ new Set(["cite", "longdesc"]);
+var ROLES = /* @__PURE__ */ new Set(["note", "region", "group", "figure", "doc-note", "doc-example", "doc-tip", "doc-pullquote", "doc-epigraph", "presentation", "none"]);
+var CLASS = /^-?[A-Za-z_][\w-]{0,63}$/;
+var ID = /^[A-Za-z][\w:.-]{0,63}$/;
+var LANG = /^[A-Za-z]{2,3}(-[A-Za-z0-9]{1,8})*$/;
+var UNSAFE_VALUE = /[\u0000-\u001f]/;
+var UNSAFE_CSS = /url\s*\(|expression\s*\(|javascript:|@import|[<>\\]|behavior\s*:|-moz-binding/i;
+var matchesName = (pattern, name) => typeof pattern === "string" ? pattern.endsWith("*") ? name.startsWith(pattern.slice(0, -1).toLowerCase()) : pattern.toLowerCase() === name : pattern.test(name);
+var allowedBy = (list, name) => list === true || !!list && list.some((p) => matchesName(p, name));
+function createHtmlFilter(options, policy = {}) {
+  const allow = options.allow === "safe" ? HTML_SAFE_RULES : options.allow;
+  const deny = options.disallow;
+  const rulesFor = (tag, rules) => rules.filter((r) => matchesName(r.name, tag));
+  const tagAllowed = (tag) => rulesFor(tag, allow).length > 0 && !rulesFor(tag, deny).some((r) => !r.attributes && !r.classes && !r.styles);
+  function permits(tag, kind, name) {
+    const yes = rulesFor(tag, allow).some((r) => allowedBy(r[kind], name));
+    const no = rulesFor(tag, deny).some((r) => allowedBy(r[kind], name));
+    return yes && !no;
+  }
+  function validValue(name, value) {
+    if (value.length > 2e3 || UNSAFE_VALUE.test(value)) return null;
+    if (URL_ATTRS2.has(name)) return sanitizeUrl(value, policy);
+    if (name === "id") {
+      if (!ID.test(value)) return null;
+      if (typeof window !== "undefined" && (value in window || value in document)) return null;
+    }
+    if (name === "lang" && !LANG.test(value)) return null;
+    if (name === "role" && !ROLES.has(value)) return null;
+    if (name === "dir" && !/^(ltr|rtl|auto)$/.test(value)) return null;
+    return value;
+  }
+  function filter(tag, read, names, reserved) {
+    const out = {};
+    for (const raw of names) {
+      const name = raw.toLowerCase();
+      const value = read(raw);
+      if (value === null) continue;
+      if (name === "class") {
+        const classes = value.split(/\s+/).filter((c) => c && CLASS.test(c) && !/^(owe-|ProseMirror)/.test(c) && permits(tag, "classes", c));
+        if (classes.length) out.class = classes.join(" ");
+        continue;
+      }
+      if (name === "style") {
+        const decls = [];
+        for (const decl of value.split(";")) {
+          const i = decl.indexOf(":");
+          if (i < 1) continue;
+          const prop = decl.slice(0, i).trim().toLowerCase();
+          const val = decl.slice(i + 1).trim();
+          if (!/^-?[a-z][a-z-]*$/.test(prop) || !val || UNSAFE_CSS.test(val) || val.length > 200) continue;
+          if (permits(tag, "styles", prop)) decls.push(`${prop}: ${val}`);
+        }
+        if (decls.length) out.style = decls.join("; ");
+        continue;
+      }
+      if (DENIED.test(name) || reserved && RESERVED.has(name)) continue;
+      if (!permits(tag, "attributes", name)) continue;
+      const valid = validValue(name, value);
+      if (valid !== null) out[name] = valid;
+    }
+    return Object.keys(out).length ? out : null;
+  }
+  const fromElement = (el, reserved) => filter(el.tagName.toLowerCase(), (n) => el.getAttribute(n), el.getAttributeNames(), reserved);
+  const revalidate = (tag, value, reserved) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    const stored = value;
+    const names = Object.keys(stored).filter((k) => Object.prototype.hasOwnProperty.call(stored, k));
+    return filter(tag, (n) => typeof stored[n] === "string" ? stored[n] : null, names, reserved);
+  };
+  return { tagAllowed, fromElement, revalidate };
+}
+var NODE_TAG = {
+  paragraph: "p",
+  blockquote: "blockquote",
+  bulletList: "ul",
+  orderedList: "ol",
+  listItem: "li",
+  taskList: "ul",
+  taskItem: "li",
+  codeBlock: "pre",
+  horizontalRule: "hr",
+  image: "img",
+  table: "table",
+  tableRow: "tr",
+  tableCell: "td",
+  tableHeader: "th",
+  bold: "strong",
+  italic: "em",
+  underline: "u",
+  strike: "s",
+  code: "code",
+  subscript: "sub",
+  superscript: "sup",
+  link: "a"
+};
+var tagOf = (owner) => owner.type.name === "heading" ? `h${owner.attrs.level}` : NODE_TAG[owner.type.name] ?? "div";
+var HtmlSupport = defineExtension({
+  name: "htmlSupport",
+  priority: 90,
+  defaultOptions: { allow: "safe", disallow: [] },
+  nodes: (options, { urlPolicy }) => {
+    const f = createHtmlFilter(options, urlPolicy);
+    const containers = HTML_CONTAINERS.filter(f.tagAllowed);
+    const textblocks = HTML_TEXTBLOCKS.filter(f.tagAllowed);
+    const nodeSpec = (tags, content) => ({
+      attrs: { tag: { default: tags[0] ?? "div" }, attributes: { default: null } },
+      content,
+      group: "block",
+      parseDOM: tags.map((tag) => ({
+        tag,
+        priority: 40,
+        getAttrs: (el) => ({ tag, attributes: f.fromElement(el, false) })
+      })),
+      toDOM: (node) => {
+        const tag = tags.includes(node.attrs.tag) ? node.attrs.tag : "div";
+        const attrs = { ...f.revalidate(tag, node.attrs.attributes, false) ?? {} };
+        if (tag === "details") attrs.open = "";
+        return [tag, attrs, 0];
+      }
+    });
+    return {
+      ...containers.length ? { htmlContainer: nodeSpec(containers, "block+") } : {},
+      ...textblocks.length ? { htmlTextblock: nodeSpec(textblocks, "inline*") } : {}
+    };
+  },
+  marks: (options, { urlPolicy }) => {
+    const f = createHtmlFilter(options, urlPolicy);
+    const tags = HTML_INLINE.filter(f.tagAllowed);
+    if (!tags.length) return {};
+    return {
+      htmlInline: {
+        attrs: { tag: { default: "span" }, attributes: { default: null } },
+        excludes: "",
+        // different wrappers (and nested spans) can coexist
+        parseDOM: tags.map((tag) => ({
+          tag,
+          priority: 40,
+          getAttrs: (el) => {
+            const attributes = f.fromElement(el, false);
+            if (tag === "span" && !attributes) return false;
+            return { tag, attributes };
+          }
+        })),
+        toDOM: (mark) => {
+          const tag = tags.includes(mark.attrs.tag) ? mark.attrs.tag : "span";
+          return [tag, f.revalidate(tag, mark.attrs.attributes, false) ?? {}, 0];
+        }
+      }
+    };
+  },
+  globalAttributes: (options) => {
+    const f = createHtmlFilter(options);
+    return [
+      {
+        types: KNOWN_TYPES,
+        attributes: {
+          htmlAttributes: {
+            default: null,
+            parseHTML: (el) => f.fromElement(el, true),
+            renderHTML: (value, owner) => f.revalidate(tagOf(owner), value, true)
+          }
+        }
+      }
+    ];
+  }
+});
+
+export { Blockquote, Bold, BulletList, CharacterCount, Code, CodeBlock, DEFAULT_PROTOCOLS, Document, Dropcursor, FORBIDDEN_ATTRS, FORBIDDEN_TAGS, FindReplace, Gapcursor, HIGHLIGHT_PALETTE, HTML_CONTAINERS, HTML_INLINE, HTML_SAFE_RULES, HTML_TEXTBLOCKS, HardBreak, Heading, Highlight, History, HorizontalRule, HtmlSupport, Image, Italic, Link, ListItem, OrderedList, Paragraph, StarterKit, Strike, Subscript, Superscript, TEXT_PALETTE, TRUSTED_TYPES_POLICY_NAME, Table, TaskItem, TaskList, Text, TextAlign, TextColor, TextDirection, Underline, arabicLabels, builtInLanguages, cleanPastedHTML, contrastRatio, countCharacters, countWords, createEditor, createHtmlFilter, createI18n, defaultLabels, defineExtension, docText, docToHTML, escapeAttr, escapeText, findMatches, findParent, getAttributes, getSearchState, h, isActive, isMac, luminance, markInputRule, markRange, normalizeColor, parseColor, resolveExtensions, resolveLanguage, sanitizeHTML, sanitizePastedHTML, sanitizeUrl, searchKey, sequence, setBlockAttrs, setTrustedTypesPolicy, stripInertBlocks, svg, toHex, toggleBlockType, toggleList, toggleMarkCommand, toggleWrap, uid };
+//# sourceMappingURL=chunk-CDPXFV6R.js.map
+//# sourceMappingURL=chunk-CDPXFV6R.js.map