superdoc 0.35.3 → 0.36.1

package/dist/super-editor/chunks/{editor-CyldDVIe.js → editor-DOp2dsXA.js}

@@ -9,11 +9,11 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _Attribute_static, getGlobalAttributes_fn, getNodeAndMarksAttributes_fn, _Schema_static, createNodesSchema_fn, createMarksSchema_fn, _events, _ExtensionService_instances, setupExtensions_fn, attachEditorEvents_fn, _editor, _stateValidators, _xmlValidators, _requiredNodeTypes, _requiredMarkTypes, _SuperValidator_instances, initializeValidators_fn, collectValidatorRequirements_fn, analyzeDocument_fn, _commandService, _Editor_instances, initContainerElement_fn, init_fn, initRichText_fn, onFocus_fn, checkHeadless_fn, registerCopyHandler_fn, insertNewFileData_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, initFonts_fn, checkFonts_fn, determineUnsupportedFonts_fn, createSchema_fn, generatePmData_fn, createView_fn, onCollaborationReady_fn, initComments_fn, initPagination_fn, dispatchTransaction_fn, handleNodeSelection_fn, prepareDocumentForImport_fn, prepareDocumentForExport_fn, endCollaboration_fn, validateDocumentInit_fn, validateDocumentExport_fn, initDevTools_fn, _DocumentSectionView_instances, init_fn2, addToolTip_fn, _ListItemNodeView_instances, init_fn3, applyIndentStyling_fn, _FieldAnnotationView_instances, createAnnotation_fn, _AutoPageNumberNodeView_instances, renderDom_fn, scheduleUpdateNodeStyle_fn;
+var _a, _Attribute_static, getGlobalAttributes_fn, getNodeAndMarksAttributes_fn, _Schema_static, createNodesSchema_fn, createMarksSchema_fn, _events, _ExtensionService_instances, setupExtensions_fn, attachEditorEvents_fn, _editor, _stateValidators, _xmlValidators, _requiredNodeTypes, _requiredMarkTypes, _SuperValidator_instances, initializeValidators_fn, collectValidatorRequirements_fn, analyzeDocument_fn, _commandService, _Editor_instances, initContainerElement_fn, init_fn, initRichText_fn, onFocus_fn, checkHeadless_fn, validateLayoutMargins_fn, isResponsiveMode_fn, registerCopyHandler_fn, insertNewFileData_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, initFonts_fn, checkFonts_fn, determineUnsupportedFonts_fn, createSchema_fn, generatePmData_fn, createView_fn, onCollaborationReady_fn, initComments_fn, initPagination_fn, dispatchTransaction_fn, handleNodeSelection_fn, prepareDocumentForImport_fn, prepareDocumentForExport_fn, endCollaboration_fn, validateDocumentInit_fn, validateDocumentExport_fn, initDevTools_fn, _DocumentSectionView_instances, init_fn2, addToolTip_fn, _ListItemNodeView_instances, init_fn3, applyIndentStyling_fn, _FieldAnnotationView_instances, createAnnotation_fn, _AutoPageNumberNodeView_instances, renderDom_fn, scheduleUpdateNodeStyle_fn;
 import * as Y from "yjs";
 import { UndoManager, Item as Item$1, ContentType, Text as Text$1, XmlElement, encodeStateAsUpdate } from "yjs";
-import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, B as Buffer2, f as callOrGet, g as getExtensionConfigField, h as getMarkType, i as getMarksFromSelection, j as getNodeType, k as getSchemaTypeNameByName, l as Schema$1, m as cleanSchemaItem, n as canSplit, o as defaultBlockAt$1, q as liftTarget, r as canJoin, s as joinPoint, t as replaceStep$1, R as ReplaceAroundStep$1, u as isTextSelection, v as getMarkRange, w as isMarkActive, x as isNodeActive, y as deleteProps, z as processContent, C as ReplaceStep, E as NodeRange, G as findWrapping, L as ListHelpers, H as findParentNode, I as isMacOS, J as isIOS, K as getSchemaTypeByName, O as inputRulesPlugin, Q as TrackDeleteMarkName, U as TrackInsertMarkName, V as v4, W as TrackFormatMarkName, X as comments_module_events, Y as findMark, Z as objectIncludes, _ as AddMarkStep, $ as RemoveMarkStep, a0 as twipsToLines, a1 as pixelsToTwips, a2 as helpers, a3 as posToDOMRect, a4 as CommandService, a5 as SuperConverter, a6 as createDocument, a7 as createDocFromMarkdown, a8 as createDocFromHTML, a9 as EditorState, aa as hasSomeParentWithClass, ab as isActive, ac as unflattenListsInHtml, ad as parseSizeUnit, ae as minMax, af as getLineHeightValueString, ag as updateDOMAttributes, ah as findChildren$5, ai as htmlHandler, aj as generateRandomSigned32BitIntStrId, ak as InputRule, al as kebabCase, am as findParentNodeClosestToPos, an as getListItemStyleDefinitions, ao as docxNumberingHelpers, ap as parseIndentElement, aq as combineIndents, ar as twipsToPixels, as as PIXELS_PER_INCH, at as SelectionRange, au as Transform, av as isInTable$1, aw as generateDocxRandomId, ax as insertNewRelationship, ay as inchesToPixels } from "./converter-DCcuo33v.js";
-import { D as DocxZipper } from "./docx-zipper-BmJ2rJSz.js";
+import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, B as Buffer2, f as callOrGet, g as getExtensionConfigField, h as getMarkType, i as getMarksFromSelection, j as getNodeType, k as getSchemaTypeNameByName, l as Schema$2, m as cleanSchemaItem, n as canSplit, o as defaultBlockAt$1, q as liftTarget, r as canJoin, s as joinPoint, t as replaceStep$1, R as ReplaceAroundStep$1, u as isTextSelection, v as getMarkRange, w as isMarkActive, x as isNodeActive, y as deleteProps, z as processContent, C as ReplaceStep, E as NodeRange, G as findWrapping, L as ListHelpers, H as findParentNode, I as isMacOS, J as isIOS, K as getSchemaTypeByName, O as inputRulesPlugin, Q as TrackDeleteMarkName, U as TrackInsertMarkName, V as v4, W as TrackFormatMarkName, X as comments_module_events, Y as findMark, Z as objectIncludes, _ as AddMarkStep, $ as RemoveMarkStep, a0 as twipsToLines, a1 as pixelsToTwips, a2 as helpers, a3 as posToDOMRect, a4 as CommandService, a5 as SuperConverter, a6 as createDocument, a7 as createDocFromMarkdown, a8 as createDocFromHTML, a9 as EditorState, aa as hasSomeParentWithClass, ab as isActive, ac as unflattenListsInHtml, ad as parseSizeUnit, ae as minMax, af as getLineHeightValueString, ag as updateDOMAttributes, ah as findChildren$5, ai as htmlHandler, aj as generateRandomSigned32BitIntStrId, ak as InputRule, al as kebabCase, am as findParentNodeClosestToPos, an as getListItemStyleDefinitions, ao as docxNumberingHelpers, ap as parseIndentElement, aq as combineIndents, ar as twipsToPixels, as as PIXELS_PER_INCH$1, at as SelectionRange, au as Transform, av as isInTable$1, aw as generateDocxRandomId, ax as insertNewRelationship, ay as inchesToPixels } from "./converter-C_m22GDt.js";
+import { D as DocxZipper } from "./docx-zipper-BMFQCW01.js";
 import { ref, computed, createElementBlock, openBlock, withModifiers, Fragment as Fragment$1, renderList, normalizeClass, createCommentVNode, toDisplayString, createElementVNode, createApp } from "vue";
 var GOOD_LEAF_SIZE = 200;
 var RopeSequence = function RopeSequence2() {
@@ -577,7 +577,7 @@ const isEquivalentPosition = function(node, off, targetNode, targetOff) {
 };
 const atomElements = /^(img|br|input|textarea|hr)$/i;
 function scanFor(node, off, targetNode, targetOff, dir) {
-  var _a;
+  var _a2;
   for (; ; ) {
     if (node == targetNode && off == targetOff)
       return true;
@@ -590,7 +590,7 @@ function scanFor(node, off, targetNode, targetOff, dir) {
     } else if (node.nodeType == 1) {
       let child = node.childNodes[off + (dir < 0 ? -1 : 0)];
       if (child.nodeType == 1 && child.contentEditable == "false") {
-        if ((_a = child.pmViewDesc) === null || _a === void 0 ? void 0 : _a.ignoreForSelection)
+        if ((_a2 = child.pmViewDesc) === null || _a2 === void 0 ? void 0 : _a2.ignoreForSelection)
           off += dir;
         else
           return false;
@@ -887,17 +887,20 @@ function findOffsetInNode(node, coords) {
 }
 function findOffsetInText(node, coords) {
   let len = node.nodeValue.length;
-  let range = document.createRange();
+  let range = document.createRange(), result;
   for (let i = 0; i < len; i++) {
     range.setEnd(node, i + 1);
     range.setStart(node, i);
     let rect = singleRect(range, 1);
     if (rect.top == rect.bottom)
       continue;
-    if (inRect(coords, rect))
-      return { node, offset: i + (coords.left >= (rect.left + rect.right) / 2 ? 1 : 0) };
+    if (inRect(coords, rect)) {
+      result = { node, offset: i + (coords.left >= (rect.left + rect.right) / 2 ? 1 : 0) };
+      break;
+    }
   }
-  return { node, offset: 0 };
+  range.detach();
+  return result || { node, offset: 0 };
 }
 function inRect(coords, rect) {
   return coords.left >= rect.left - 1 && coords.left <= rect.right + 1 && coords.top >= rect.top - 1 && coords.top <= rect.bottom + 1;
@@ -1214,10 +1217,10 @@ class ViewDesc {
   }
   // The size of the content represented by this desc.
   get size() {
-    let size = 0;
+    let size2 = 0;
     for (let i = 0; i < this.children.length; i++)
-      size += this.children[i].size;
-    return size;
+      size2 += this.children[i].size;
+    return size2;
   }
   // For block nodes, this represents the space taken up by their
   // start/end tokens.
@@ -1669,9 +1672,9 @@ class MarkViewDesc extends ViewDesc {
   }
   slice(from2, to, view) {
     let copy = MarkViewDesc.create(this.parent, this.mark, true, view);
-    let nodes = this.children, size = this.size;
-    if (to < size)
-      nodes = replaceNodes(nodes, to, size, view);
+    let nodes = this.children, size2 = this.size;
+    if (to < size2)
+      nodes = replaceNodes(nodes, to, size2, view);
     if (from2 > 0)
       nodes = replaceNodes(nodes, 0, from2, view);
     for (let i = 0; i < nodes.length; i++)
@@ -3144,12 +3147,12 @@ function normalizeSiblings(fragment, $context) {
     return fragment;
   for (let d2 = $context.depth; d2 >= 0; d2--) {
     let parent = $context.node(d2);
-    let match = parent.contentMatchAt($context.index(d2));
+    let match2 = parent.contentMatchAt($context.index(d2));
     let lastWrap, result = [];
     fragment.forEach((node) => {
       if (!result)
         return;
-      let wrap = match.findWrapping(node.type), inLast;
+      let wrap = match2.findWrapping(node.type), inLast;
       if (!wrap)
         return result = null;
       if (inLast = result.length && lastWrap.length && addToSibling(wrap, lastWrap, node, result[result.length - 1], 0)) {
@@ -3159,7 +3162,7 @@ function normalizeSiblings(fragment, $context) {
           result[result.length - 1] = closeRight(result[result.length - 1], lastWrap.length);
         let wrapped = withWrappers(node, wrap);
         result.push(wrapped);
-        match = match.matchType(wrapped.type);
+        match2 = match2.matchType(wrapped.type);
         lastWrap = wrap;
       }
     });
@@ -3178,8 +3181,8 @@ function addToSibling(wrap, lastWrap, node, sibling, depth) {
     let inner = addToSibling(wrap, lastWrap, node, sibling.lastChild, depth + 1);
     if (inner)
       return sibling.copy(sibling.content.replaceChild(sibling.childCount - 1, inner));
-    let match = sibling.contentMatchAt(sibling.childCount);
-    if (match.matchType(depth == wrap.length - 1 ? node.type : wrap[depth + 1]))
+    let match2 = sibling.contentMatchAt(sibling.childCount);
+    if (match2.matchType(depth == wrap.length - 1 ? node.type : wrap[depth + 1]))
       return sibling.copy(sibling.content.append(Fragment.from(withWrappers(node, wrap, depth + 1))));
   }
 }
@@ -3644,7 +3647,7 @@ editHandlers.compositionstart = editHandlers.compositionupdate = (view) => {
   if (!view.composing) {
     view.domObserver.flush();
     let { state } = view, $pos = state.selection.$to;
-    if (state.selection instanceof TextSelection && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m) => m.type.spec.inclusive === false))) {
+    if (state.selection instanceof TextSelection && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m) => m.type.spec.inclusive === false) || chrome && windows$1 && selectionBeforeUneditable(view))) {
       view.markCursor = view.state.storedMarks || $pos.marks();
       endComposition(view, true);
       view.markCursor = null;
@@ -3672,6 +3675,13 @@ editHandlers.compositionstart = editHandlers.compositionupdate = (view) => {
   }
   scheduleComposeEnd(view, timeoutComposition);
 };
+function selectionBeforeUneditable(view) {
+  let { focusNode, focusOffset } = view.domSelectionRange();
+  if (!focusNode || focusNode.nodeType != 1 || focusOffset >= focusNode.childNodes.length)
+    return false;
+  let next = focusNode.childNodes[focusOffset];
+  return next.nodeType == 1 && next.contentEditable == "false";
+}
 editHandlers.compositionend = (view, event) => {
   if (view.composing) {
     view.input.composing = false;
@@ -3875,10 +3885,14 @@ handlers.dragend = (view) => {
   }, 50);
 };
 editHandlers.dragover = editHandlers.dragenter = (_, e) => e.preventDefault();
-editHandlers.drop = (view, _event) => {
-  let event = _event;
-  let dragging = view.dragging;
-  view.dragging = null;
+editHandlers.drop = (view, event) => {
+  try {
+    handleDrop(view, event, view.dragging);
+  } finally {
+    view.dragging = null;
+  }
+};
+function handleDrop(view, event, dragging) {
   if (!event.dataTransfer)
     return;
   let eventPos = view.posAtCoords(eventCoords(event));
@@ -3931,7 +3945,7 @@ editHandlers.drop = (view, _event) => {
   }
   view.focus();
   view.dispatch(tr.setMeta("uiEvent", "drop"));
-};
+}
 handlers.focus = (view) => {
   view.input.lastFocus = Date.now();
   if (!view.focused) {
@@ -4781,6 +4795,13 @@ class DOMObserver {
             br.remove();
         }
       }
+    } else if ((chrome || safari) && added.some((n) => n.nodeName == "BR") && (view.input.lastKeyCode == 8 || view.input.lastKeyCode == 46)) {
+      for (let node of added)
+        if (node.nodeName == "BR" && node.parentNode) {
+          let after = node.nextSibling;
+          if (after && after.nodeType == 1 && after.contentEditable == "false")
+            node.parentNode.removeChild(node);
+        }
     }
     let readSel = null;
     if (from2 < 0 && newSel && view.input.lastFocus > Date.now() - 200 && Math.max(view.input.lastTouch, view.input.lastClick.time) < Date.now() - 300 && selectionCollapsed(sel) && (readSel = selectionFromDOM(view)) && readSel.eq(Selection.near(view.state.doc.resolve(0), 1))) {
@@ -5298,7 +5319,7 @@ class EditorView {
     this.updateStateInner(state, this._props);
   }
   updateStateInner(state, prevProps) {
-    var _a;
+    var _a2;
     let prev = this.state, redraw = false, updateSel = false;
     if (state.storedMarks && this.composing) {
       clearComposition(this);
@@ -5348,7 +5369,7 @@ class EditorView {
       this.domObserver.start();
     }
     this.updatePluginViews(prev);
-    if (((_a = this.dragging) === null || _a === void 0 ? void 0 : _a.node) && !prev.doc.eq(state.doc))
+    if (((_a2 = this.dragging) === null || _a2 === void 0 ? void 0 : _a2.node) && !prev.doc.eq(state.doc))
       this.updateDraggedNode(this.dragging, prev);
     if (scroll == "reset") {
       this.dom.scrollTop = 0;
@@ -5718,15 +5739,40 @@ const BIT30 = 1 << 29;
 const BITS6 = 63;
 const BITS7 = 127;
 const BITS31 = 2147483647;
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
 const isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor$1(num) === num);
 const create$2 = () => /* @__PURE__ */ new Set();
+const every$1 = (arr, f2) => {
+  for (let i = 0; i < arr.length; i++) {
+    if (!f2(arr[i], i, arr)) {
+      return false;
+    }
+  }
+  return true;
+};
+const some = (arr, f2) => {
+  for (let i = 0; i < arr.length; i++) {
+    if (f2(arr[i], i, arr)) {
+      return true;
+    }
+  }
+  return false;
+};
+const unfold = (len, f2) => {
+  const array = new Array(len);
+  for (let i = 0; i < len; i++) {
+    array[i] = f2(i, array);
+  }
+  return array;
+};
 const isArray = Array.isArray;
 const fromCharCode = String.fromCharCode;
 const toLowerCase = (s2) => s2.toLowerCase();
 const trimLeftRegex = /^\s*/g;
 const trimLeft = (s2) => s2.replace(trimLeftRegex, "");
 const fromCamelCaseRegex = /([A-Z])/g;
-const fromCamelCase = (s2, separator) => trimLeft(s2.replace(fromCamelCaseRegex, (match) => `${separator}${toLowerCase(match)}`));
+const fromCamelCase = (s2, separator) => trimLeft(s2.replace(fromCamelCaseRegex, (match2) => `${separator}${toLowerCase(match2)}`));
 const _encodeUtf8Polyfill = (str) => {
   const encodedString = unescape(encodeURIComponent(str));
   const len = encodedString.length;
@@ -5747,6 +5793,7 @@ let utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecode
 if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
   utf8TextDecoder = null;
 }
+const repeat = (source, n) => unfold(n, () => source).join("");
 class Encoder {
   constructor() {
     this.cpos = 0;
@@ -5943,7 +5990,11 @@ const setIfUndefined = (map2, key2, createT) => {
   }
   return set;
 };
+const EqualityTraitSymbol = Symbol("Equality");
+const equals = (a, b) => a === b || a[EqualityTraitSymbol]?.(b) || false;
+const isObject$1 = (o) => typeof o === "object";
 const keys = Object.keys;
+const size = (obj) => keys(obj).length;
 const every = (obj, f2) => {
   for (const key2 in obj) {
     if (!f2(obj[key2], key2)) {
@@ -5952,6 +6003,81 @@ const every = (obj, f2) => {
   }
   return true;
 };
+const hasProperty = (obj, key2) => Object.prototype.hasOwnProperty.call(obj, key2);
+const equalityDeep = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null || a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object)) {
+    return false;
+  }
+  if (a[EqualityTraitSymbol] != null) {
+    return a[EqualityTraitSymbol](b);
+  }
+  switch (a.constructor) {
+    case ArrayBuffer:
+      a = new Uint8Array(a);
+      b = new Uint8Array(b);
+    // eslint-disable-next-line no-fallthrough
+    case Uint8Array: {
+      if (a.byteLength !== b.byteLength) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+          return false;
+        }
+      }
+      break;
+    }
+    case Set: {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const value of a) {
+        if (!b.has(value)) {
+          return false;
+        }
+      }
+      break;
+    }
+    case Map: {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const key2 of a.keys()) {
+        if (!b.has(key2) || !equalityDeep(a.get(key2), b.get(key2))) {
+          return false;
+        }
+      }
+      break;
+    }
+    case void 0:
+    case Object:
+      if (size(a) !== size(b)) {
+        return false;
+      }
+      for (const key2 in a) {
+        if (!hasProperty(a, key2) || !equalityDeep(a[key2], b[key2])) {
+          return false;
+        }
+      }
+      break;
+    case Array:
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!equalityDeep(a[i], b[i])) {
+          return false;
+        }
+      }
+      break;
+    default:
+      return false;
+  }
+  return true;
+};
 const isOneOf = (value, options) => options.includes(value);
 const createMutex = () => {
   let token = true;
@@ -5992,7 +6118,7 @@ const ySyncPluginKey = new PluginKey("y-sync");
 const yUndoPluginKey = new PluginKey("y-undo");
 const yCursorPluginKey = new PluginKey("yjs-cursor");
 const rand = Math.random;
-const oneOf = (arr) => arr[floor$1(rand() * arr.length)];
+const oneOf$1 = (arr) => arr[floor$1(rand() * arr.length)];
 const undefinedToNull = (v) => v === void 0 ? null : v;
 class VarStoragePolyfill {
   constructor() {
@@ -6066,15 +6192,771 @@ const computeParams = () => {
 const hasParam = (name) => computeParams().has(name);
 const getVariable = (name) => isNode$1 ? undefinedToNull(process$1.env[name.toUpperCase().replaceAll("-", "_")]) : undefinedToNull(varStorage.getItem(name));
 const hasConf = (name) => hasParam("--" + name) || getVariable(name) !== null;
-hasConf("production");
+const production = hasConf("production");
 const forceColor = isNode$1 && isOneOf(process$1.env.FORCE_COLOR, ["true", "1", "2"]);
 forceColor || !hasParam("--no-colors") && // @todo deprecate --no-colors
 !hasConf("no-color") && (!isNode$1 || process$1.stdout.isTTY) && (!isNode$1 || hasParam("--color") || getVariable("COLORTERM") !== null || (getVariable("TERM") || "").includes("color"));
+const toBase64Browser = (bytes) => {
+  let s2 = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    s2 += fromCharCode(bytes[i]);
+  }
+  return btoa(s2);
+};
+const toBase64Node = (bytes) => Buffer2.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+const toBase64 = isBrowser$1 ? toBase64Browser : toBase64Node;
+const encodeAny = (data) => encode((encoder) => writeAny(encoder, data));
+const bool = (gen) => gen.next() >= 0.5;
+const int53 = (gen, min2, max2) => floor$1(gen.next() * (max2 + 1 - min2) + min2);
+const int32 = (gen, min2, max2) => floor$1(gen.next() * (max2 + 1 - min2) + min2);
+const int31 = (gen, min2, max2) => int32(gen, min2, max2);
+const letter = (gen) => fromCharCode(int31(gen, 97, 122));
+const word = (gen, minLen = 0, maxLen = 20) => {
+  const len = int31(gen, minLen, maxLen);
+  let str = "";
+  for (let i = 0; i < len; i++) {
+    str += letter(gen);
+  }
+  return str;
+};
+const oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
+const schemaSymbol = Symbol("0schema");
+class ValidationError {
+  constructor() {
+    this._rerrs = [];
+  }
+  /**
+   * @param {string?} path
+   * @param {string} expected
+   * @param {string} has
+   * @param {string?} message
+   */
+  extend(path, expected, has, message = null) {
+    this._rerrs.push({ path, expected, has, message });
+  }
+  toString() {
+    const s2 = [];
+    for (let i = this._rerrs.length - 1; i > 0; i--) {
+      const r2 = this._rerrs[i];
+      s2.push(repeat(" ", (this._rerrs.length - i) * 2) + `${r2.path != null ? `[${r2.path}] ` : ""}${r2.has} doesn't match ${r2.expected}. ${r2.message}`);
+    }
+    return s2.join("\n");
+  }
+}
+const shapeExtends = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null || a.constructor !== b.constructor) return false;
+  if (a[EqualityTraitSymbol]) return equals(a, b);
+  if (isArray(a)) {
+    return every$1(
+      a,
+      (aitem) => some(b, (bitem) => shapeExtends(aitem, bitem))
+    );
+  } else if (isObject$1(a)) {
+    return every(
+      a,
+      (aitem, akey) => shapeExtends(aitem, b[akey])
+    );
+  }
+  return false;
+};
+let Schema$1 = (_a = class {
+  /**
+   * @param {Schema<any>} other
+   */
+  extends(other) {
+    let [a, b] = [
+      /** @type {any} */
+      this.shape,
+      /** @type {any} */
+      other.shape
+    ];
+    if (
+      /** @type {typeof Schema<any>} */
+      this.constructor._dilutes
+    ) [b, a] = [a, b];
+    return shapeExtends(a, b);
+  }
+  /**
+   * Overwrite this when necessary. By default, we only check the `shape` property which every shape
+   * should have.
+   * @param {Schema<any>} other
+   */
+  equals(other) {
+    return this.constructor === other.constructor && equalityDeep(this.shape, other.shape);
+  }
+  [schemaSymbol]() {
+    return true;
+  }
+  /**
+   * @param {object} other
+   */
+  [EqualityTraitSymbol](other) {
+    return this.equals(
+      /** @type {any} */
+      other
+    );
+  }
+  /**
+   * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
+   * Schema. Validate will check the structure of the parameter and return true iff the instance
+   * really is an instance of Schema.
+   *
+   * @param {T} o
+   * @return {boolean}
+   */
+  validate(o) {
+    return this.check(o);
+  }
+  /* c8 ignore start */
+  /**
+   * Similar to validate, but this method accepts untyped parameters.
+   *
+   * @param {any} _o
+   * @param {ValidationError} [_err]
+   * @return {_o is T}
+   */
+  check(_o, _err) {
+    methodUnimplemented();
+  }
+  /* c8 ignore stop */
+  /**
+   * @type {Schema<T?>}
+   */
+  get nullable() {
+    return $union(this, $null);
+  }
+  /**
+   * @type {$Optional<Schema<T>>}
+   */
+  get optional() {
+    return new $Optional(
+      /** @type {Schema<T>} */
+      this
+    );
+  }
+  /**
+   * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
+   * Use this if you know that the type is of a specific type and you just want to convince the type
+   * system.
+   *
+   * **Do not rely on these error messages!**
+   * Performs an assertion check only if not in a production environment.
+   *
+   * @template OO
+   * @param {OO} o
+   * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
+   */
+  cast(o) {
+    assert(o, this);
+    return (
+      /** @type {any} */
+      o
+    );
+  }
+  /**
+   * EXPECTO PATRONUM!! 🪄
+   * This function protects against type errors. Though it may not work in the real world.
+   *
+   * "After all this time?"
+   * "Always." - Snape, talking about type safety
+   *
+   * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
+   * Use this if you know that the type is of a specific type and you just want to convince the type
+   * system.
+   *
+   * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
+   *
+   * **Do not rely on these error messages!**
+   * Performs an assertion check if not in a production environment.
+   *
+   * @param {T} o
+   * @return {o extends T ? T : never}
+   */
+  expect(o) {
+    assert(o, this);
+    return o;
+  }
+}, // this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
+/**
+ * If true, the more things are added to the shape the more objects this schema will accept (e.g.
+ * union). By default, the more objects are added, the the fewer objects this schema will accept.
+ * @protected
+ */
+__publicField(_a, "_dilutes", false), _a);
+class $ConstructedBy extends Schema$1 {
+  /**
+   * @param {C} c
+   * @param {((o:Instance<C>)=>boolean)|null} check
+   */
+  constructor(c, check) {
+    super();
+    this.shape = c;
+    this._c = check;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
+   */
+  check(o, err = void 0) {
+    const c = o?.constructor === this.shape && (this._c == null || this._c(o));
+    !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? "Constructor match failed" : "Check failed");
+    return c;
+  }
+}
+const $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
+$constructedBy($ConstructedBy);
+class $Custom extends Schema$1 {
+  /**
+   * @param {(o:any) => boolean} check
+   */
+  constructor(check) {
+    super();
+    this.shape = check;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is any}
+   */
+  check(o, err) {
+    const c = this.shape(o);
+    !c && err?.extend(null, "custom prop", o?.constructor.name, "failed to check custom prop");
+    return c;
+  }
+}
+const $custom = (check) => new $Custom(check);
+$constructedBy($Custom);
+class $Literal extends Schema$1 {
+  /**
+   * @param {Array<T>} literals
+   */
+  constructor(literals) {
+    super();
+    this.shape = literals;
+  }
+  /**
+   *
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is T}
+   */
+  check(o, err) {
+    const c = this.shape.some((a) => a === o);
+    !c && err?.extend(null, this.shape.join(" | "), o.toString());
+    return c;
+  }
+}
+const $literal = (...literals) => new $Literal(literals);
+const $$literal = $constructedBy($Literal);
+const _regexEscape = (
+  /** @type {any} */
+  RegExp.escape || /** @type {(str:string) => string} */
+  ((str) => str.replace(/[().|&,$^[\]]/g, (s2) => "\\" + s2))
+);
+const _schemaStringTemplateToRegex = (s2) => {
+  if ($string.check(s2)) {
+    return [_regexEscape(s2)];
+  }
+  if ($$literal.check(s2)) {
+    return (
+      /** @type {Array<string|number>} */
+      s2.shape.map((v) => v + "")
+    );
+  }
+  if ($$number.check(s2)) {
+    return ["[+-]?\\d+.?\\d*"];
+  }
+  if ($$string.check(s2)) {
+    return [".*"];
+  }
+  if ($$union.check(s2)) {
+    return s2.shape.map(_schemaStringTemplateToRegex).flat(1);
+  }
+  unexpectedCase();
+};
+class $StringTemplate extends Schema$1 {
+  /**
+   * @param {T} shape
+   */
+  constructor(shape) {
+    super();
+    this.shape = shape;
+    this._r = new RegExp("^" + shape.map(_schemaStringTemplateToRegex).map((opts) => `(${opts.join("|")})`).join("") + "$");
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is CastStringTemplateArgsToTemplate<T>}
+   */
+  check(o, err) {
+    const c = this._r.exec(o) != null;
+    !c && err?.extend(null, this._r.toString(), o.toString(), "String doesn't match string template.");
+    return c;
+  }
+}
+$constructedBy($StringTemplate);
+const isOptionalSymbol = Symbol("optional");
+class $Optional extends Schema$1 {
+  /**
+   * @param {S} shape
+   */
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is (Unwrap<S>|undefined)}
+   */
+  check(o, err) {
+    const c = o === void 0 || this.shape.check(o);
+    !c && err?.extend(null, "undefined (optional)", "()");
+    return c;
+  }
+  get [isOptionalSymbol]() {
+    return true;
+  }
+}
+const $$optional = $constructedBy($Optional);
+class $Never extends Schema$1 {
+  /**
+   * @param {any} _o
+   * @param {ValidationError} [err]
+   * @return {_o is never}
+   */
+  check(_o, err) {
+    err?.extend(null, "never", typeof _o);
+    return false;
+  }
+}
+$constructedBy($Never);
+const _$Object = class _$Object extends Schema$1 {
+  /**
+   * @param {S} shape
+   * @param {boolean} partial
+   */
+  constructor(shape, partial = false) {
+    super();
+    this.shape = shape;
+    this._isPartial = partial;
+  }
+  /**
+   * @type {Schema<Partial<$ObjectToType<S>>>}
+   */
+  get partial() {
+    return new _$Object(this.shape, true);
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is $ObjectToType<S>}
+   */
+  check(o, err) {
+    if (o == null) {
+      err?.extend(null, "object", "null");
+      return false;
+    }
+    return every(this.shape, (vv, vk) => {
+      const c = this._isPartial && !hasProperty(o, vk) || vv.check(o[vk], err);
+      !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], "Object property does not match");
+      return c;
+    });
+  }
+};
+__publicField(_$Object, "_dilutes", true);
+let $Object = _$Object;
+const $object = (def) => (
+  /** @type {any} */
+  new $Object(def)
+);
+const $$object = $constructedBy($Object);
+const $objectAny = $custom((o) => o != null && (o.constructor === Object || o.constructor == null));
+class $Record extends Schema$1 {
+  /**
+   * @param {Keys} keys
+   * @param {Values} values
+   */
+  constructor(keys2, values) {
+    super();
+    this.shape = {
+      keys: keys2,
+      values
+    };
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
+   */
+  check(o, err) {
+    return o != null && every(o, (vv, vk) => {
+      const ck = this.shape.keys.check(vk, err);
+      !ck && err?.extend(vk + "", "Record", typeof o, ck ? "Key doesn't match schema" : "Value doesn't match value");
+      return ck && this.shape.values.check(vv, err);
+    });
+  }
+}
+const $record = (keys2, values) => new $Record(keys2, values);
+const $$record = $constructedBy($Record);
+class $Tuple extends Schema$1 {
+  /**
+   * @param {S} shape
+   */
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
+   */
+  check(o, err) {
+    return o != null && every(this.shape, (vv, vk) => {
+      const c = (
+        /** @type {Schema<any>} */
+        vv.check(o[vk], err)
+      );
+      !c && err?.extend(vk.toString(), "Tuple", typeof vv);
+      return c;
+    });
+  }
+}
+const $tuple = (...def) => new $Tuple(def);
+$constructedBy($Tuple);
+class $Array extends Schema$1 {
+  /**
+   * @param {Array<S>} v
+   */
+  constructor(v) {
+    super();
+    this.shape = v.length === 1 ? v[0] : new $Union(v);
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is Array<S extends Schema<infer T> ? T : never>} o
+   */
+  check(o, err) {
+    const c = isArray(o) && every$1(o, (oi) => this.shape.check(oi));
+    !c && err?.extend(null, "Array", "");
+    return c;
+  }
+}
+const $array = (...def) => new $Array(def);
+const $$array = $constructedBy($Array);
+const $arrayAny = $custom((o) => isArray(o));
+class $InstanceOf extends Schema$1 {
+  /**
+   * @param {new (...args:any) => T} constructor
+   * @param {((o:T) => boolean)|null} check
+   */
+  constructor(constructor, check) {
+    super();
+    this.shape = constructor;
+    this._c = check;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is T}
+   */
+  check(o, err) {
+    const c = o instanceof this.shape && (this._c == null || this._c(o));
+    !c && err?.extend(null, this.shape.name, o?.constructor.name);
+    return c;
+  }
+}
+const $instanceOf = (c, check = null) => new $InstanceOf(c, check);
+$constructedBy($InstanceOf);
+const $$schema = $instanceOf(Schema$1);
+class $Lambda extends Schema$1 {
+  /**
+   * @param {Args} args
+   */
+  constructor(args) {
+    super();
+    this.len = args.length - 1;
+    this.args = $tuple(...args.slice(-1));
+    this.res = args[this.len];
+  }
+  /**
+   * @param {any} f
+   * @param {ValidationError} err
+   * @return {f is _LArgsToLambdaDef<Args>}
+   */
+  check(f2, err) {
+    const c = f2.constructor === Function && f2.length <= this.len;
+    !c && err?.extend(null, "function", typeof f2);
+    return c;
+  }
+}
+const $$lambda = $constructedBy($Lambda);
+const $function = $custom((o) => typeof o === "function");
+class $Intersection extends Schema$1 {
+  /**
+   * @param {T} v
+   */
+  constructor(v) {
+    super();
+    this.shape = v;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is Intersect<UnwrapArray<T>>}
+   */
+  check(o, err) {
+    const c = every$1(this.shape, (check) => check.check(o, err));
+    !c && err?.extend(null, "Intersectinon", typeof o);
+    return c;
+  }
+}
+$constructedBy($Intersection, (o) => o.shape.length > 0);
+class $Union extends Schema$1 {
+  /**
+   * @param {Array<Schema<S>>} v
+   */
+  constructor(v) {
+    super();
+    this.shape = v;
+  }
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is S}
+   */
+  check(o, err) {
+    const c = some(this.shape, (vv) => vv.check(o, err));
+    err?.extend(null, "Union", typeof o);
+    return c;
+  }
+}
+__publicField($Union, "_dilutes", true);
+const $union = (...schemas) => schemas.findIndex(($s) => $$union.check($s)) >= 0 ? $union(...schemas.map(($s) => $($s)).map(($s) => $$union.check($s) ? $s.shape : [$s]).flat(1)) : schemas.length === 1 ? schemas[0] : new $Union(schemas);
+const $$union = (
+  /** @type {Schema<$Union<any>>} */
+  $constructedBy($Union)
+);
+const _t = () => true;
+const $any = $custom(_t);
+const $$any = (
+  /** @type {Schema<Schema<any>>} */
+  $constructedBy($Custom, (o) => o.shape === _t)
+);
+const $bigint = $custom((o) => typeof o === "bigint");
+const $$bigint = (
+  /** @type {Schema<Schema<BigInt>>} */
+  $custom((o) => o === $bigint)
+);
+const $symbol = $custom((o) => typeof o === "symbol");
+$custom((o) => o === $symbol);
+const $number = $custom((o) => typeof o === "number");
+const $$number = (
+  /** @type {Schema<Schema<number>>} */
+  $custom((o) => o === $number)
+);
+const $string = $custom((o) => typeof o === "string");
+const $$string = (
+  /** @type {Schema<Schema<string>>} */
+  $custom((o) => o === $string)
+);
+const $boolean = $custom((o) => typeof o === "boolean");
+const $$boolean = (
+  /** @type {Schema<Schema<Boolean>>} */
+  $custom((o) => o === $boolean)
+);
+const $undefined = $literal(void 0);
+$constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === void 0);
+$literal(void 0);
+const $null = $literal(null);
+const $$null = (
+  /** @type {Schema<Schema<null>>} */
+  $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === null)
+);
+$constructedBy(Uint8Array);
+$constructedBy($ConstructedBy, (o) => o.shape === Uint8Array);
+const $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
+(() => {
+  const $jsonArr = (
+    /** @type {$Array<$any>} */
+    $array($any)
+  );
+  const $jsonRecord = (
+    /** @type {$Record<$string,$any>} */
+    $record($string, $any)
+  );
+  const $json = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
+  $jsonArr.shape = $json;
+  $jsonRecord.shape.values = $json;
+  return $json;
+})();
+const $ = (o) => {
+  if ($$schema.check(o)) {
+    return (
+      /** @type {any} */
+      o
+    );
+  } else if ($objectAny.check(o)) {
+    const o2 = {};
+    for (const k2 in o) {
+      o2[k2] = $(o[k2]);
+    }
+    return (
+      /** @type {any} */
+      $object(o2)
+    );
+  } else if ($arrayAny.check(o)) {
+    return (
+      /** @type {any} */
+      $union(...o.map($))
+    );
+  } else if ($primitive.check(o)) {
+    return (
+      /** @type {any} */
+      $literal(o)
+    );
+  } else if ($function.check(o)) {
+    return (
+      /** @type {any} */
+      $constructedBy(
+        /** @type {any} */
+        o
+      )
+    );
+  }
+  unexpectedCase();
+};
+const assert = production ? () => {
+} : (o, schema) => {
+  const err = new ValidationError();
+  if (!schema.check(o, err)) {
+    throw create$1(`Expected value to be of type ${schema.constructor.name}.
+${err.toString()}`);
+  }
+};
+class PatternMatcher {
+  /**
+   * @param {Schema<State>} [$state]
+   */
+  constructor($state) {
+    this.patterns = [];
+    this.$state = $state;
+  }
+  /**
+   * @template P
+   * @template R
+   * @param {P} pattern
+   * @param {(o:NoInfer<Unwrap<ReadSchema<P>>>,s:State)=>R} handler
+   * @return {PatternMatcher<State,Patterns|Pattern<Unwrap<ReadSchema<P>>,R>>}
+   */
+  if(pattern, handler) {
+    this.patterns.push({ if: $(pattern), h: handler });
+    return this;
+  }
+  /**
+   * @template R
+   * @param {(o:any,s:State)=>R} h
+   */
+  else(h) {
+    return this.if($any, h);
+  }
+  /**
+   * @return {State extends undefined
+   *   ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
+   *   : <In extends Unwrap<Patterns['if']>>(o:In,state:State)=>PatternMatchResult<Patterns,In>}
+   */
+  done() {
+    return (
+      /** @type {any} */
+      (o, s2) => {
+        for (let i = 0; i < this.patterns.length; i++) {
+          const p = this.patterns[i];
+          if (p.if.check(o)) {
+            return p.h(o, s2);
+          }
+        }
+        throw create$1("Unhandled pattern");
+      }
+    );
+  }
+}
+const match = (state) => new PatternMatcher(
+  /** @type {any} */
+  state
+);
+const _random = (
+  /** @type {any} */
+  match(
+    /** @type {Schema<prng.PRNG>} */
+    $any
+  ).if($$number, (_o, gen) => int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER)).if($$string, (_o, gen) => word(gen)).if($$boolean, (_o, gen) => bool(gen)).if($$bigint, (_o, gen) => BigInt(int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER))).if($$union, (o, gen) => random(gen, oneOf(gen, o.shape))).if($$object, (o, gen) => {
+    const res = {};
+    for (const k2 in o.shape) {
+      let prop = o.shape[k2];
+      if ($$optional.check(prop)) {
+        if (bool(gen)) {
+          continue;
+        }
+        prop = prop.shape;
+      }
+      res[k2] = _random(prop, gen);
+    }
+    return res;
+  }).if($$array, (o, gen) => {
+    const arr = [];
+    const n = int32(gen, 0, 42);
+    for (let i = 0; i < n; i++) {
+      arr.push(random(gen, o.shape));
+    }
+    return arr;
+  }).if($$literal, (o, gen) => {
+    return oneOf(gen, o.shape);
+  }).if($$null, (o, gen) => {
+    return null;
+  }).if($$lambda, (o, gen) => {
+    const res = random(gen, o.res);
+    return () => res;
+  }).if($$any, (o, gen) => random(gen, oneOf(gen, [
+    $number,
+    $string,
+    $null,
+    $undefined,
+    $bigint,
+    $boolean,
+    $array($number),
+    $record($union("a", "b", "c"), $number)
+  ]))).if($$record, (o, gen) => {
+    const res = {};
+    const keysN = int53(gen, 0, 3);
+    for (let i = 0; i < keysN; i++) {
+      const key2 = random(gen, o.shape.keys);
+      const val = random(gen, o.shape.values);
+      res[key2] = val;
+    }
+    return res;
+  }).done()
+);
+const random = (gen, schema) => (
+  /** @type {any} */
+  _random($(schema), gen)
+);
 const doc = (
   /** @type {Document} */
   typeof document !== "undefined" ? document : {}
 );
+$custom((el) => el.nodeType === DOCUMENT_FRAGMENT_NODE);
 typeof DOMParser !== "undefined" ? new DOMParser() : null;
+$custom((el) => el.nodeType === ELEMENT_NODE);
+$custom((el) => el.nodeType === TEXT_NODE);
+const ELEMENT_NODE = doc.ELEMENT_NODE;
+const TEXT_NODE = doc.TEXT_NODE;
+const DOCUMENT_NODE = doc.DOCUMENT_NODE;
+const DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE;
+$custom((el) => el.nodeType === DOCUMENT_NODE);
 const createTimeoutClass = (clearFunction) => class TT {
   /**
    * @param {number} timeoutId
@@ -6257,16 +7139,6 @@ class Hasher {
   }
 }
 const digest = (data) => new Hasher().digest(data);
-const toBase64Browser = (bytes) => {
-  let s2 = "";
-  for (let i = 0; i < bytes.byteLength; i++) {
-    s2 += fromCharCode(bytes[i]);
-  }
-  return btoa(s2);
-};
-const toBase64Node = (bytes) => Buffer2.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
-const toBase64 = isBrowser$1 ? toBase64Browser : toBase64Node;
-const encodeAny = (data) => encode((encoder) => writeAny(encoder, data));
 const _convolute = (digest2) => {
   const N = 6;
   for (let i = N; i < digest2.length; i++) {
@@ -6289,7 +7161,7 @@ const getUserColor = (colorMapping, colors, user) => {
       colorMapping.forEach((color) => usedColors.add(color));
       colors = colors.filter((color) => !usedColors.has(color));
     }
-    colorMapping.set(user, oneOf(colors));
+    colorMapping.set(user, oneOf$1(colors));
   }
   return (
     /** @type {ColorDef} */
@@ -8077,14 +8949,14 @@ const _Schema = class _Schema {
    * @returns PM schema
    */
   static createSchemaByExtensions(extensions, editor) {
-    var _a, _b;
+    var _a2, _b;
     const nodeExtensions = extensions.filter((e) => e.type === "node");
     const markExtensions = extensions.filter((e) => e.type === "mark");
     const topNode = nodeExtensions.find((e) => getExtensionConfigField(e, "topNode"))?.name;
     const attributes = Attribute.getAttributesFromExtensions(extensions);
-    const nodes = __privateMethod(_a = _Schema, _Schema_static, createNodesSchema_fn).call(_a, nodeExtensions, attributes, editor);
+    const nodes = __privateMethod(_a2 = _Schema, _Schema_static, createNodesSchema_fn).call(_a2, nodeExtensions, attributes, editor);
     const marks = __privateMethod(_b = _Schema, _Schema_static, createMarksSchema_fn).call(_b, markExtensions, attributes, editor);
-    return new Schema$1({ topNode, nodes, marks });
+    return new Schema$2({ topNode, nodes, marks });
   }
 };
 _Schema_static = new WeakSet();
@@ -8481,9 +9353,9 @@ const newlineInCode$1 = (state, dispatch) => {
     dispatch(state.tr.insertText("\n").scrollIntoView());
   return true;
 };
-function defaultBlockAt(match) {
-  for (let i = 0; i < match.edgeCount; i++) {
-    let { type } = match.edge(i);
+function defaultBlockAt(match2) {
+  for (let i = 0; i < match2.edgeCount; i++) {
+    let { type } = match2.edge(i);
     if (type.isTextblock && !type.hasRequiredAttrs())
       return type;
   }
@@ -8610,12 +9482,12 @@ function joinMaybeClear(state, $pos, dispatch) {
   return true;
 }
 function deleteBarrier(state, $cut, dispatch, dir) {
-  let before = $cut.nodeBefore, after = $cut.nodeAfter, conn, match;
+  let before = $cut.nodeBefore, after = $cut.nodeAfter, conn, match2;
   let isolated = before.type.spec.isolating || after.type.spec.isolating;
   if (!isolated && joinMaybeClear(state, $cut, dispatch))
     return true;
   let canDelAfter = !isolated && $cut.parent.canReplace($cut.index(), $cut.index() + 1);
-  if (canDelAfter && (conn = (match = before.contentMatchAt(before.childCount)).findWrapping(after.type)) && match.matchType(conn[0] || after.type).validEnd) {
+  if (canDelAfter && (conn = (match2 = before.contentMatchAt(before.childCount)).findWrapping(after.type)) && match2.matchType(conn[0] || after.type).validEnd) {
     if (dispatch) {
       let end2 = $cut.pos + after.nodeSize, wrap = Fragment.empty;
       for (let i = conn.length - 1; i >= 0; i--)
@@ -9192,7 +10064,7 @@ function createNodeFromContent(content, schema, options) {
     if (options.errorOnInvalidContent) {
       let hasInvalidContent = false;
       let invalidContent = "";
-      const contentCheckSchema = new Schema$1({
+      const contentCheckSchema = new Schema$2({
         topNode: schema.spec.topNode,
         marks: schema.spec.marks,
         // Prosemirror's schemas are executed such that: the last to execute, matches last
@@ -9826,8 +10698,8 @@ const collectTargetListItemPositions = (state, fallbackPos) => {
   const { from: from2, to } = state.selection;
   doc2.nodesBetween(from2, to, (node, pos) => {
     if (node.type === listItemType) {
-      const size = typeof node.nodeSize === "number" ? node.nodeSize : 0;
-      candidates.push({ node, pos, end: pos + size });
+      const size2 = typeof node.nodeSize === "number" ? node.nodeSize : 0;
+      candidates.push({ node, pos, end: pos + size2 });
     }
   });
   if (!candidates.length && typeof fallbackPos === "number") {
@@ -10093,8 +10965,8 @@ const deleteListItem = () => (props) => {
       }
     });
     if (fullySelectedBlocks.length) {
-      fullySelectedBlocks.sort((a, b) => b.pos - a.pos).forEach(({ pos, size }) => {
-        tr.delete(pos, pos + size);
+      fullySelectedBlocks.sort((a, b) => b.pos - a.pos).forEach(({ pos, size: size2 }) => {
+        tr.delete(pos, pos + size2);
       });
       const $new = tr.doc.resolve(from2);
       tr.setSelection(TextSelection.near($new));
@@ -13352,9 +14224,9 @@ const findWordBounds = (doc2, pos) => {
 };
 const setWordSelection = (view, pos) => {
   const { state, dispatch } = view;
-  const word = findWordBounds(state.doc, pos);
-  if (!word) return;
-  const tr = state.tr.setSelection(TextSelection.create(state.doc, word.from, word.to));
+  const word2 = findWordBounds(state.doc, pos);
+  if (!word2) return;
+  const tr = state.tr.setSelection(TextSelection.create(state.doc, word2.from, word2.to));
   dispatch(tr);
 };
 const setImageNodeSelection = (view, pos) => {
@@ -14494,6 +15366,9 @@ function buildSchemaSummary(schema, schemaVersion) {
     marks
   };
 }
+const PIXELS_PER_INCH = 96;
+const MAX_HEIGHT_BUFFER_PX = 50;
+const MAX_WIDTH_BUFFER_PX = 20;
 const _Editor = class _Editor extends EventEmitter {
   /**
    * Create a new Editor instance
@@ -14575,6 +15450,8 @@ const _Editor = class _Editor extends EventEmitter {
       lastSelection: null,
       suppressDefaultDocxStyles: false,
       jsonOverride: null,
+      layoutMode: "paginated",
+      layoutMargins: null,
       onBeforeCreate: () => null,
       onCreate: () => null,
       onUpdate: () => null,
@@ -14613,6 +15490,7 @@ const _Editor = class _Editor extends EventEmitter {
     });
     __privateMethod(this, _Editor_instances, initContainerElement_fn).call(this, options);
     __privateMethod(this, _Editor_instances, checkHeadless_fn).call(this, options);
+    __privateMethod(this, _Editor_instances, validateLayoutMargins_fn).call(this, options);
     this.setOptions(options);
     let modes = {
       docx: () => __privateMethod(this, _Editor_instances, init_fn).call(this),
@@ -14991,17 +15869,28 @@ const _Editor = class _Editor extends EventEmitter {
     });
   }
   /**
-   * Get the maximum content size
-   * @returns {Object} Size object with width and height
+   * Get the maximum content size based on page dimensions and margins
+   * @returns {{width: number, height: number} | {}} Size object with width and height in pixels, or empty object if no page size
    */
   getMaxContentSize() {
     if (!this.converter) return {};
     const { pageSize = {}, pageMargins = {} } = this.converter.pageStyles ?? {};
+    const { layoutMargins } = this.options;
     const { width, height } = pageSize;
-    const { top: top2 = 0, bottom: bottom2 = 0, left: left2 = 0, right: right2 = 0 } = pageMargins;
+    const isResponsive = __privateMethod(this, _Editor_instances, isResponsiveMode_fn).call(this);
+    const getMarginPx = (side) => {
+      if (isResponsive) {
+        return layoutMargins?.[side] ?? PIXELS_PER_INCH;
+      }
+      return (pageMargins?.[side] ?? 0) * PIXELS_PER_INCH;
+    };
+    const topPx = getMarginPx("top");
+    const bottomPx = getMarginPx("bottom");
+    const leftPx = getMarginPx("left");
+    const rightPx = getMarginPx("right");
     if (!width || !height) return {};
-    const maxHeight = height * 96 - top2 * 96 - bottom2 * 96 - 50;
-    const maxWidth = width * 96 - left2 * 96 - right2 * 96 - 20;
+    const maxHeight = height * PIXELS_PER_INCH - topPx - bottomPx - MAX_HEIGHT_BUFFER_PX;
+    const maxWidth = width * PIXELS_PER_INCH - leftPx - rightPx - MAX_WIDTH_BUFFER_PX;
     return {
       width: maxWidth,
       height: maxHeight
@@ -15009,9 +15898,15 @@ const _Editor = class _Editor extends EventEmitter {
   }
   /**
    * Attach styles and attributes to the editor element
+   * @param {HTMLElement} element - The editor container element
+   * @param {HTMLElement} proseMirror - The ProseMirror element
+   * @param {boolean} [hasPaginationEnabled=true] - Whether pagination is enabled
+   * @returns {void}
    */
   updateEditorStyles(element, proseMirror, hasPaginationEnabled = true) {
     const { pageSize, pageMargins } = this.converter.pageStyles ?? {};
+    const { layoutMargins, pagination } = this.options;
+    const isResponsive = __privateMethod(this, _Editor_instances, isResponsiveMode_fn).call(this);
     if (!proseMirror || !element) {
       return;
     }
@@ -15020,12 +15915,17 @@ const _Editor = class _Editor extends EventEmitter {
     proseMirror.setAttribute("aria-label", "Main content area, start typing to enter text.");
     proseMirror.setAttribute("aria-description", "");
     proseMirror.classList.remove("view-mode");
-    if (pageSize) {
-      element.style.width = pageSize.width + "in";
-      element.style.minWidth = pageSize.width + "in";
-      element.style.minHeight = pageSize.height + "in";
+    if (pageSize?.width != null) {
+      element.style.width = isResponsive ? "100%" : `${pageSize.width}in`;
+      element.style.minWidth = isResponsive ? "" : `${pageSize.width}in`;
     }
-    if (pageMargins) {
+    if (pageSize?.height != null) {
+      element.style.minHeight = isResponsive ? "" : `${pageSize.height}in`;
+    }
+    if (isResponsive) {
+      element.style.paddingLeft = (layoutMargins?.left ?? PIXELS_PER_INCH) + "px";
+      element.style.paddingRight = (layoutMargins?.right ?? PIXELS_PER_INCH) + "px";
+    } else if (pageMargins) {
       element.style.paddingLeft = pageMargins.left + "in";
       element.style.paddingRight = pageMargins.right + "in";
     }
@@ -15048,7 +15948,10 @@ const _Editor = class _Editor extends EventEmitter {
     element.style.webkitOverflowScrolling = "touch";
     const defaultLineHeight = 1.2;
     proseMirror.style.lineHeight = defaultLineHeight;
-    if (!hasPaginationEnabled) {
+    if (isResponsive) {
+      proseMirror.style.paddingTop = (layoutMargins?.top ?? PIXELS_PER_INCH) + "px";
+      proseMirror.style.paddingBottom = (layoutMargins?.bottom ?? PIXELS_PER_INCH) + "px";
+    } else if (!pagination) {
       proseMirror.style.paddingTop = "1in";
       proseMirror.style.paddingBottom = "1in";
     } else {
@@ -15073,6 +15976,7 @@ const _Editor = class _Editor extends EventEmitter {
   /**
    * Initializes responsive styles for mobile devices.
    * Sets up scaling based on viewport width and handles orientation changes.
+   * Note: Scaling is skipped in responsive layout mode since content reflows naturally.
    *
    * @param {HTMLElement|void} element - The DOM element to apply mobile styles to
    * @returns {void}
@@ -15081,6 +15985,9 @@ const _Editor = class _Editor extends EventEmitter {
     if (!element) {
       return;
     }
+    if (__privateMethod(this, _Editor_instances, isResponsiveMode_fn).call(this)) {
+      return;
+    }
     const initialWidth = element.offsetWidth;
     const updateScale = () => {
       const minPageSideMargin = 10;
@@ -15229,7 +16136,7 @@ const _Editor = class _Editor extends EventEmitter {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-CUb1VdVb.js"),
+      import("./index-CzkLnJsZ.js"),
       import("./index-DRCvimau.js"),
       import("./index-C_x_N6Uh.js"),
       import("./index-D_sWOSiG.js"),
@@ -15447,7 +16354,7 @@ const _Editor = class _Editor extends EventEmitter {
    * @returns {Object | void} Migration results
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.35.3");
+    console.debug("[checkVersionMigrations] Current editor version", "0.36.1");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -15761,6 +16668,39 @@ checkHeadless_fn = function(options) {
     global.window = options.mockWindow;
   }
 };
+/**
+ * Validate layoutMargins option values
+ * @param {EditorOptions} options - Editor options
+ * @returns {void}
+ */
+validateLayoutMargins_fn = function(options) {
+  if (!options.layoutMargins) return;
+  const margins = options.layoutMargins;
+  const validatedMargins = {};
+  let hasValidValues = false;
+  for (const key2 of ["top", "bottom", "left", "right"]) {
+    if (margins[key2] !== void 0 && margins[key2] !== null) {
+      const value = margins[key2];
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+        validatedMargins[key2] = value;
+        hasValidValues = true;
+      } else {
+        console.warn(
+          `[SuperDoc] Invalid layoutMargins.${key2}: ${value}. Value must be a positive finite number. Ignoring this property.`
+        );
+      }
+    }
+  }
+  options.layoutMargins = hasValidValues ? validatedMargins : null;
+};
+/**
+ * Check if responsive layout mode is enabled
+ * @returns {boolean} True if layoutMode is 'responsive'
+ * @private
+ */
+isResponsiveMode_fn = function() {
+  return this.options.layoutMode === "responsive";
+};
 registerCopyHandler_fn = function() {
   this.view.dom.addEventListener("copy", (event) => {
     const clipboardData = event.clipboardData;
@@ -16043,6 +16983,9 @@ initPagination_fn = async function() {
   if (this.options.isHeadless || !this.extensionService || this.options.isHeaderOrFooter) {
     return;
   }
+  if (__privateMethod(this, _Editor_instances, isResponsiveMode_fn).call(this)) {
+    return;
+  }
   const pagination = this.options.extensions.find((e) => e.name === "pagination");
   if (pagination && this.options.pagination) {
     const sectionData = await initPaginationData(this);
@@ -16766,12 +17709,12 @@ function dropCursor(options = {}) {
 }
 class DropCursorView {
   constructor(editorView, options) {
-    var _a;
+    var _a2;
     this.editorView = editorView;
     this.cursorPos = null;
     this.element = null;
     this.timeout = -1;
-    this.width = (_a = options.width) !== null && _a !== void 0 ? _a : 1;
+    this.width = (_a2 = options.width) !== null && _a2 !== void 0 ? _a2 : 1;
     this.color = options.color === false ? void 0 : options.color || "black";
     this.class = options.class;
     this.handlers = ["dragover", "dragend", "drop", "dragleave"].map((name) => {
@@ -18919,7 +19862,7 @@ const Document = Node$1.create({
        */
       getDocumentStats: () => ({ editor }) => {
         const text = editor.getText();
-        const words = text.split(/\s+/).filter((word) => word.length > 0).length;
+        const words = text.split(/\s+/).filter((word2) => word2.length > 0).length;
         const characters = text.length;
         const paragraphs = editor.state.doc.content.childCount;
         return {
@@ -19326,9 +20269,9 @@ const ordinalFormatter = (level) => {
 };
 const generateFromCustom = (path, lvlText, customFormat) => {
   if (customFormat !== "001, 002, 003, ...") return generateNumbering(path, lvlText, String);
-  const match = customFormat.match(/(\d+)/);
-  if (!match) throw new Error("Invalid format string: no numeric pattern found");
-  const sample = match[1];
+  const match2 = customFormat.match(/(\d+)/);
+  if (!match2) throw new Error("Invalid format string: no numeric pattern found");
+  const sample = match2[1];
   const digitCount = sample.length;
   const index2 = path.pop();
   return String(index2).padStart(digitCount, "0");
@@ -21697,9 +22640,9 @@ function calculateIndentFallback(indentAttrs = {}) {
   } else if (hanging) {
     textIndent = -hanging;
   } else if (typeof indentAttrs.textIndent === "string") {
-    const match = indentAttrs.textIndent.match(/(-?\d*\.?\d+)in$/);
-    if (match) {
-      textIndent = Number(match[1]) * 96;
+    const match2 = indentAttrs.textIndent.match(/(-?\d*\.?\d+)in$/);
+    if (match2) {
+      textIndent = Number(match2[1]) * 96;
     }
   }
   if (textIndent) return left2 + textIndent;
@@ -22057,7 +23000,7 @@ function updateColumns(node, colgroup, table, cellMinWidth, overrideCol, overrid
     const pageWidth = toNumber(pageStyles.pageSize.width);
     const marginLeft = toNumber(pageStyles.pageMargins?.left);
     const marginRight = toNumber(pageStyles.pageMargins?.right);
-    const pageAvailableWidthPx = Math.max((pageWidth - marginLeft - marginRight) * PIXELS_PER_INCH, 0);
+    const pageAvailableWidthPx = Math.max((pageWidth - marginLeft - marginRight) * PIXELS_PER_INCH$1, 0);
     if (pageAvailableWidthPx > 0) {
       availableWidth = availableWidth ? Math.min(availableWidth, pageAvailableWidthPx) : pageAvailableWidthPx;
     }
@@ -22176,14 +23119,14 @@ const createCell = (cellType, cellContent = null) => {
   }
   return cellType.createAndFill();
 };
-const createTableBorders = ({ size = 0.66665, color = "#000000" } = {}) => {
+const createTableBorders = ({ size: size2 = 0.66665, color = "#000000" } = {}) => {
   return {
-    top: { size, color },
-    left: { size, color },
-    bottom: { size, color },
-    right: { size, color },
-    insideH: { size, color },
-    insideV: { size, color }
+    top: { size: size2, color },
+    left: { size: size2, color },
+    bottom: { size: size2, color },
+    right: { size: size2, color },
+    insideH: { size: size2, color },
+    insideV: { size: size2, color }
   };
 };
 const createTable = (schema, rowsCount, colsCount, withHeaderRow, cellContent = null) => {
@@ -22281,8 +23224,8 @@ const createColGroup = (node, cellMinWidth, overrideCol, overrideValue) => {
     colgroupValues
   };
 };
-var readFromCache;
-var addToCache;
+let readFromCache;
+let addToCache;
 if (typeof WeakMap != "undefined") {
   let cache = /* @__PURE__ */ new WeakMap();
   readFromCache = (key2) => cache.get(key2);
@@ -22295,8 +23238,7 @@ if (typeof WeakMap != "undefined") {
   const cacheSize = 10;
   let cachePos = 0;
   readFromCache = (key2) => {
-    for (let i = 0; i < cache.length; i += 2)
-      if (cache[i] == key2) return cache[i + 1];
+    for (let i = 0; i < cache.length; i += 2) if (cache[i] == key2) return cache[i + 1];
   };
   addToCache = (key2, value) => {
     if (cachePos == cacheSize) cachePos = 0;
@@ -22311,7 +23253,6 @@ var TableMap = class {
     this.map = map2;
     this.problems = problems;
   }
-  // Find the dimensions of the cell at the given position.
   findCell(pos) {
     for (let i = 0; i < this.map.length; i++) {
       const curPos = this.map[i];
@@ -22320,27 +23261,21 @@ var TableMap = class {
       const top2 = i / this.width | 0;
       let right2 = left2 + 1;
       let bottom2 = top2 + 1;
-      for (let j = 1; right2 < this.width && this.map[i + j] == curPos; j++) {
-        right2++;
-      }
-      for (let j = 1; bottom2 < this.height && this.map[i + this.width * j] == curPos; j++) {
-        bottom2++;
-      }
-      return { left: left2, top: top2, right: right2, bottom: bottom2 };
+      for (let j = 1; right2 < this.width && this.map[i + j] == curPos; j++) right2++;
+      for (let j = 1; bottom2 < this.height && this.map[i + this.width * j] == curPos; j++) bottom2++;
+      return {
+        left: left2,
+        top: top2,
+        right: right2,
+        bottom: bottom2
+      };
     }
     throw new RangeError(`No cell with offset ${pos} found`);
   }
-  // Find the left side of the cell at the given position.
   colCount(pos) {
-    for (let i = 0; i < this.map.length; i++) {
-      if (this.map[i] == pos) {
-        return i % this.width;
-      }
-    }
+    for (let i = 0; i < this.map.length; i++) if (this.map[i] == pos) return i % this.width;
     throw new RangeError(`No cell with offset ${pos} found`);
   }
-  // Find the next cell in the given direction, starting from the cell
-  // at `pos`, if any.
   nextCell(pos, axis, dir) {
     const { left: left2, right: right2, top: top2, bottom: bottom2 } = this.findCell(pos);
     if (axis == "horiz") {
@@ -22351,20 +23286,9 @@ var TableMap = class {
       return this.map[left2 + this.width * (dir < 0 ? top2 - 1 : bottom2)];
     }
   }
-  // Get the rectangle spanning the two given cells.
   rectBetween(a, b) {
-    const {
-      left: leftA,
-      right: rightA,
-      top: topA,
-      bottom: bottomA
-    } = this.findCell(a);
-    const {
-      left: leftB,
-      right: rightB,
-      top: topB,
-      bottom: bottomB
-    } = this.findCell(b);
+    const { left: leftA, right: rightA, top: topA, bottom: bottomA } = this.findCell(a);
+    const { left: leftB, right: rightB, top: topB, bottom: bottomB } = this.findCell(b);
     return {
       left: Math.min(leftA, leftB),
       top: Math.min(topA, topB),
@@ -22372,27 +23296,19 @@ var TableMap = class {
       bottom: Math.max(bottomA, bottomB)
     };
   }
-  // Return the position of all cells that have the top left corner in
-  // the given rectangle.
   cellsInRect(rect) {
     const result = [];
     const seen = {};
-    for (let row = rect.top; row < rect.bottom; row++) {
-      for (let col = rect.left; col < rect.right; col++) {
-        const index2 = row * this.width + col;
-        const pos = this.map[index2];
-        if (seen[pos]) continue;
-        seen[pos] = true;
-        if (col == rect.left && col && this.map[index2 - 1] == pos || row == rect.top && row && this.map[index2 - this.width] == pos) {
-          continue;
-        }
-        result.push(pos);
-      }
+    for (let row = rect.top; row < rect.bottom; row++) for (let col = rect.left; col < rect.right; col++) {
+      const index2 = row * this.width + col;
+      const pos = this.map[index2];
+      if (seen[pos]) continue;
+      seen[pos] = true;
+      if (col == rect.left && col && this.map[index2 - 1] == pos || row == rect.top && row && this.map[index2 - this.width] == pos) continue;
+      result.push(pos);
     }
     return result;
   }
-  // Return the position at which the cell at the given row and column
-  // starts, or would start, if a cell started there.
   positionAt(row, col, table) {
     for (let i = 0, rowStart = 0; ; i++) {
       const rowEnd = rowStart + table.child(i).nodeSize;
@@ -22405,14 +23321,12 @@ var TableMap = class {
       rowStart = rowEnd;
     }
   }
-  // Find the table map for the given table node.
   static get(table) {
     return readFromCache(table) || addToCache(table, computeMap(table));
   }
 };
 function computeMap(table) {
-  if (table.type.spec.tableRole != "table")
-    throw new RangeError("Not a table node: " + table.type.name);
+  if (table.type.spec.tableRole != "table") throw new RangeError("Not a table node: " + table.type.name);
   const width = findWidth(table), height = table.childCount;
   const map2 = [];
   let mapPos = 0;
@@ -22439,22 +23353,19 @@ function computeMap(table) {
         const start2 = mapPos + h * width;
         for (let w = 0; w < colspan; w++) {
           if (map2[start2 + w] == 0) map2[start2 + w] = pos;
-          else
-            (problems || (problems = [])).push({
-              type: "collision",
-              row,
-              pos,
-              n: colspan - w
-            });
+          else (problems || (problems = [])).push({
+            type: "collision",
+            row,
+            pos,
+            n: colspan - w
+          });
           const colW = colwidth && colwidth[w];
           if (colW) {
             const widthIndex = (start2 + w) % width * 2, prev = colWidths[widthIndex];
             if (prev == null || prev != colW && colWidths[widthIndex + 1] == 1) {
               colWidths[widthIndex] = colW;
               colWidths[widthIndex + 1] = 1;
-            } else if (prev == colW) {
-              colWidths[widthIndex + 1]++;
-            }
+            } else if (prev == colW) colWidths[widthIndex + 1]++;
           }
         }
       }
@@ -22464,16 +23375,17 @@ function computeMap(table) {
     const expectedPos = (row + 1) * width;
     let missing = 0;
     while (mapPos < expectedPos) if (map2[mapPos++] == 0) missing++;
-    if (missing)
-      (problems || (problems = [])).push({ type: "missing", row, n: missing });
+    if (missing) (problems || (problems = [])).push({
+      type: "missing",
+      row,
+      n: missing
+    });
     pos++;
   }
-  if (width === 0 || height === 0)
-    (problems || (problems = [])).push({ type: "zero_sized" });
+  if (width === 0 || height === 0) (problems || (problems = [])).push({ type: "zero_sized" });
   const tableMap = new TableMap(width, height, map2, problems);
   let badWidths = false;
-  for (let i = 0; !badWidths && i < colWidths.length; i += 2)
-    if (colWidths[i] != null && colWidths[i + 1] < height) badWidths = true;
+  for (let i = 0; !badWidths && i < colWidths.length; i += 2) if (colWidths[i] != null && colWidths[i + 1] < height) badWidths = true;
   if (badWidths) findBadColWidths(tableMap, colWidths, table);
   return tableMap;
 }
@@ -22483,14 +23395,13 @@ function findWidth(table) {
   for (let row = 0; row < table.childCount; row++) {
     const rowNode = table.child(row);
     let rowWidth = 0;
-    if (hasRowSpan)
-      for (let j = 0; j < row; j++) {
-        const prevRow = table.child(j);
-        for (let i = 0; i < prevRow.childCount; i++) {
-          const cell = prevRow.child(i);
-          if (j + cell.attrs.rowspan > row) rowWidth += cell.attrs.colspan;
-        }
+    if (hasRowSpan) for (let j = 0; j < row; j++) {
+      const prevRow = table.child(j);
+      for (let i = 0; i < prevRow.childCount; i++) {
+        const cell = prevRow.child(i);
+        if (j + cell.attrs.rowspan > row) rowWidth += cell.attrs.colspan;
       }
+    }
     for (let i = 0; i < rowNode.childCount; i++) {
       const cell = rowNode.child(i);
       rowWidth += cell.attrs.colspan;
@@ -22509,23 +23420,18 @@ function findBadColWidths(map2, colWidths, table) {
     if (seen[pos]) continue;
     seen[pos] = true;
     const node = table.nodeAt(pos);
-    if (!node) {
-      throw new RangeError(`No cell with offset ${pos} found`);
-    }
+    if (!node) throw new RangeError(`No cell with offset ${pos} found`);
     let updated = null;
     const attrs = node.attrs;
     for (let j = 0; j < attrs.colspan; j++) {
-      const col = (i + j) % map2.width;
-      const colWidth = colWidths[col * 2];
-      if (colWidth != null && (!attrs.colwidth || attrs.colwidth[j] != colWidth))
-        (updated || (updated = freshColWidth(attrs)))[j] = colWidth;
-    }
-    if (updated)
-      map2.problems.unshift({
-        type: "colwidth mismatch",
-        pos,
-        colwidth: updated
-      });
+      const colWidth = colWidths[(i + j) % map2.width * 2];
+      if (colWidth != null && (!attrs.colwidth || attrs.colwidth[j] != colWidth)) (updated || (updated = freshColWidth(attrs)))[j] = colWidth;
+    }
+    if (updated) map2.problems.unshift({
+      type: "colwidth mismatch",
+      pos,
+      colwidth: updated
+    });
   }
 }
 function freshColWidth(attrs) {
@@ -22545,11 +23451,9 @@ function tableNodeTypes(schema) {
   }
   return result;
 }
-var tableEditingKey = new PluginKey("selectingCells");
+const tableEditingKey = new PluginKey("selectingCells");
 function cellAround$1($pos) {
-  for (let d2 = $pos.depth - 1; d2 > 0; d2--)
-    if ($pos.node(d2).type.spec.tableRole == "row")
-      return $pos.node(0).resolve($pos.before(d2 + 1));
+  for (let d2 = $pos.depth - 1; d2 > 0; d2--) if ($pos.node(d2).type.spec.tableRole == "row") return $pos.node(0).resolve($pos.before(d2 + 1));
   return null;
 }
 function cellWrapping$1($pos) {
@@ -22561,21 +23465,15 @@ function cellWrapping$1($pos) {
 }
 function isInTable(state) {
   const $head = state.selection.$head;
-  for (let d2 = $head.depth; d2 > 0; d2--)
-    if ($head.node(d2).type.spec.tableRole == "row") return true;
+  for (let d2 = $head.depth; d2 > 0; d2--) if ($head.node(d2).type.spec.tableRole == "row") return true;
   return false;
 }
 function selectionCell(state) {
   const sel = state.selection;
-  if ("$anchorCell" in sel && sel.$anchorCell) {
-    return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;
-  } else if ("node" in sel && sel.node && sel.node.type.spec.tableRole == "cell") {
-    return sel.$anchor;
-  }
+  if ("$anchorCell" in sel && sel.$anchorCell) return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;
+  else if ("node" in sel && sel.node && sel.node.type.spec.tableRole == "cell") return sel.$anchor;
   const $cell = cellAround$1(sel.$head) || cellNear(sel.$head);
-  if ($cell) {
-    return $cell;
-  }
+  if ($cell) return $cell;
   throw new RangeError(`No cell found around position ${sel.head}`);
 }
 function cellNear($pos) {
@@ -22585,8 +23483,7 @@ function cellNear($pos) {
   }
   for (let before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {
     const role = before.type.spec.tableRole;
-    if (role == "cell" || role == "header_cell")
-      return $pos.doc.resolve(pos - before.nodeSize);
+    if (role == "cell" || role == "header_cell") return $pos.doc.resolve(pos - before.nodeSize);
   }
 }
 function pointsAtCell($pos) {
@@ -22606,7 +23503,10 @@ function nextCell($pos, axis, dir) {
   return moved == null ? null : $pos.node(0).resolve(tableStart + moved);
 }
 function removeColSpan(attrs, pos, n = 1) {
-  const result = { ...attrs, colspan: attrs.colspan - n };
+  const result = {
+    ...attrs,
+    colspan: attrs.colspan - n
+  };
   if (result.colwidth) {
     result.colwidth = result.colwidth.slice();
     result.colwidth.splice(pos, n);
@@ -22615,7 +23515,10 @@ function removeColSpan(attrs, pos, n = 1) {
   return result;
 }
 function addColSpan(attrs, pos, n = 1) {
-  const result = { ...attrs, colspan: attrs.colspan + n };
+  const result = {
+    ...attrs,
+    colspan: attrs.colspan + n
+  };
   if (result.colwidth) {
     result.colwidth = result.colwidth.slice();
     for (let i = 0; i < n; i++) result.colwidth.splice(pos, 0, 0);
@@ -22624,37 +23527,23 @@ function addColSpan(attrs, pos, n = 1) {
 }
 function columnIsHeader(map2, table, col) {
   const headerCell = tableNodeTypes(table.type.schema).header_cell;
-  for (let row = 0; row < map2.height; row++)
-    if (table.nodeAt(map2.map[col + row * map2.width]).type != headerCell)
-      return false;
+  for (let row = 0; row < map2.height; row++) if (table.nodeAt(map2.map[col + row * map2.width]).type != headerCell) return false;
   return true;
 }
-var CellSelection = class _CellSelection extends Selection {
-  // A table selection is identified by its anchor and head cells. The
-  // positions given to this constructor should point _before_ two
-  // cells in the same table. They may be the same, to select a single
-  // cell.
+var CellSelection = class CellSelection2 extends Selection {
   constructor($anchorCell, $headCell = $anchorCell) {
     const table = $anchorCell.node(-1);
     const map2 = TableMap.get(table);
     const tableStart = $anchorCell.start(-1);
-    const rect = map2.rectBetween(
-      $anchorCell.pos - tableStart,
-      $headCell.pos - tableStart
-    );
+    const rect = map2.rectBetween($anchorCell.pos - tableStart, $headCell.pos - tableStart);
     const doc2 = $anchorCell.node(0);
     const cells = map2.cellsInRect(rect).filter((p) => p != $headCell.pos - tableStart);
     cells.unshift($headCell.pos - tableStart);
     const ranges = cells.map((pos) => {
       const cell = table.nodeAt(pos);
-      if (!cell) {
-        throw RangeError(`No cell with offset ${pos} found`);
-      }
+      if (!cell) throw new RangeError(`No cell with offset ${pos} found`);
       const from2 = tableStart + pos + 1;
-      return new SelectionRange(
-        doc2.resolve(from2),
-        doc2.resolve(from2 + cell.content.size)
-      );
+      return new SelectionRange(doc2.resolve(from2), doc2.resolve(from2 + cell.content.size));
     });
     super(ranges[0].$from, ranges[0].$to, ranges);
     this.$anchorCell = $anchorCell;
@@ -22665,24 +23554,17 @@ var CellSelection = class _CellSelection extends Selection {
     const $headCell = doc2.resolve(mapping.map(this.$headCell.pos));
     if (pointsAtCell($anchorCell) && pointsAtCell($headCell) && inSameTable($anchorCell, $headCell)) {
       const tableChanged = this.$anchorCell.node(-1) != $anchorCell.node(-1);
-      if (tableChanged && this.isRowSelection())
-        return _CellSelection.rowSelection($anchorCell, $headCell);
-      else if (tableChanged && this.isColSelection())
-        return _CellSelection.colSelection($anchorCell, $headCell);
-      else return new _CellSelection($anchorCell, $headCell);
+      if (tableChanged && this.isRowSelection()) return CellSelection2.rowSelection($anchorCell, $headCell);
+      else if (tableChanged && this.isColSelection()) return CellSelection2.colSelection($anchorCell, $headCell);
+      else return new CellSelection2($anchorCell, $headCell);
     }
     return TextSelection.between($anchorCell, $headCell);
   }
-  // Returns a rectangular slice of table rows containing the selected
-  // cells.
   content() {
     const table = this.$anchorCell.node(-1);
     const map2 = TableMap.get(table);
     const tableStart = this.$anchorCell.start(-1);
-    const rect = map2.rectBetween(
-      this.$anchorCell.pos - tableStart,
-      this.$headCell.pos - tableStart
-    );
+    const rect = map2.rectBetween(this.$anchorCell.pos - tableStart, this.$headCell.pos - tableStart);
     const seen = {};
     const rows = [];
     for (let row = rect.top; row < rect.bottom; row++) {
@@ -22693,44 +23575,25 @@ var CellSelection = class _CellSelection extends Selection {
         seen[pos] = true;
         const cellRect = map2.findCell(pos);
         let cell = table.nodeAt(pos);
-        if (!cell) {
-          throw RangeError(`No cell with offset ${pos} found`);
-        }
+        if (!cell) throw new RangeError(`No cell with offset ${pos} found`);
         const extraLeft = rect.left - cellRect.left;
         const extraRight = cellRect.right - rect.right;
         if (extraLeft > 0 || extraRight > 0) {
           let attrs = cell.attrs;
-          if (extraLeft > 0) {
-            attrs = removeColSpan(attrs, 0, extraLeft);
-          }
-          if (extraRight > 0) {
-            attrs = removeColSpan(
-              attrs,
-              attrs.colspan - extraRight,
-              extraRight
-            );
-          }
+          if (extraLeft > 0) attrs = removeColSpan(attrs, 0, extraLeft);
+          if (extraRight > 0) attrs = removeColSpan(attrs, attrs.colspan - extraRight, extraRight);
           if (cellRect.left < rect.left) {
             cell = cell.type.createAndFill(attrs);
-            if (!cell) {
-              throw RangeError(
-                `Could not create cell with attrs ${JSON.stringify(attrs)}`
-              );
-            }
-          } else {
-            cell = cell.type.create(attrs, cell.content);
-          }
+            if (!cell) throw new RangeError(`Could not create cell with attrs ${JSON.stringify(attrs)}`);
+          } else cell = cell.type.create(attrs, cell.content);
         }
         if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
           const attrs = {
             ...cell.attrs,
             rowspan: Math.min(cellRect.bottom, rect.bottom) - Math.max(cellRect.top, rect.top)
           };
-          if (cellRect.top < rect.top) {
-            cell = cell.type.createAndFill(attrs);
-          } else {
-            cell = cell.type.create(attrs, cell.content);
-          }
+          if (cellRect.top < rect.top) cell = cell.type.createAndFill(attrs);
+          else cell = cell.type.create(attrs, cell.content);
         }
         rowContent.push(cell);
       }
@@ -22743,16 +23606,9 @@ var CellSelection = class _CellSelection extends Selection {
     const mapFrom = tr.steps.length, ranges = this.ranges;
     for (let i = 0; i < ranges.length; i++) {
       const { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
-      tr.replace(
-        mapping.map($from.pos),
-        mapping.map($to.pos),
-        i ? Slice.empty : content
-      );
+      tr.replace(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
     }
-    const sel = Selection.findFrom(
-      tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)),
-      -1
-    );
+    const sel = Selection.findFrom(tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)), -1);
     if (sel) tr.setSelection(sel);
   }
   replaceWith(tr, node) {
@@ -22762,18 +23618,9 @@ var CellSelection = class _CellSelection extends Selection {
     const table = this.$anchorCell.node(-1);
     const map2 = TableMap.get(table);
     const tableStart = this.$anchorCell.start(-1);
-    const cells = map2.cellsInRect(
-      map2.rectBetween(
-        this.$anchorCell.pos - tableStart,
-        this.$headCell.pos - tableStart
-      )
-    );
-    for (let i = 0; i < cells.length; i++) {
-      f2(table.nodeAt(cells[i]), tableStart + cells[i]);
-    }
+    const cells = map2.cellsInRect(map2.rectBetween(this.$anchorCell.pos - tableStart, this.$headCell.pos - tableStart));
+    for (let i = 0; i < cells.length; i++) f2(table.nodeAt(cells[i]), tableStart + cells[i]);
   }
-  // True if this selection goes all the way from the top to the
-  // bottom of the table.
   isColSelection() {
     const anchorTop = this.$anchorCell.index(-1);
     const headTop = this.$headCell.index(-1);
@@ -22782,8 +23629,6 @@ var CellSelection = class _CellSelection extends Selection {
     const headBottom = headTop + this.$headCell.nodeAfter.attrs.rowspan;
     return Math.max(anchorBottom, headBottom) == this.$headCell.node(-1).childCount;
   }
-  // Returns the smallest column selection that covers the given anchor
-  // and head cell.
   static colSelection($anchorCell, $headCell = $anchorCell) {
     const table = $anchorCell.node(-1);
     const map2 = TableMap.get(table);
@@ -22792,24 +23637,14 @@ var CellSelection = class _CellSelection extends Selection {
     const headRect = map2.findCell($headCell.pos - tableStart);
     const doc2 = $anchorCell.node(0);
     if (anchorRect.top <= headRect.top) {
-      if (anchorRect.top > 0)
-        $anchorCell = doc2.resolve(tableStart + map2.map[anchorRect.left]);
-      if (headRect.bottom < map2.height)
-        $headCell = doc2.resolve(
-          tableStart + map2.map[map2.width * (map2.height - 1) + headRect.right - 1]
-        );
+      if (anchorRect.top > 0) $anchorCell = doc2.resolve(tableStart + map2.map[anchorRect.left]);
+      if (headRect.bottom < map2.height) $headCell = doc2.resolve(tableStart + map2.map[map2.width * (map2.height - 1) + headRect.right - 1]);
     } else {
-      if (headRect.top > 0)
-        $headCell = doc2.resolve(tableStart + map2.map[headRect.left]);
-      if (anchorRect.bottom < map2.height)
-        $anchorCell = doc2.resolve(
-          tableStart + map2.map[map2.width * (map2.height - 1) + anchorRect.right - 1]
-        );
+      if (headRect.top > 0) $headCell = doc2.resolve(tableStart + map2.map[headRect.left]);
+      if (anchorRect.bottom < map2.height) $anchorCell = doc2.resolve(tableStart + map2.map[map2.width * (map2.height - 1) + anchorRect.right - 1]);
     }
-    return new _CellSelection($anchorCell, $headCell);
+    return new CellSelection2($anchorCell, $headCell);
   }
-  // True if this selection goes all the way from the left to the
-  // right of the table.
   isRowSelection() {
     const table = this.$anchorCell.node(-1);
     const map2 = TableMap.get(table);
@@ -22822,10 +23657,8 @@ var CellSelection = class _CellSelection extends Selection {
     return Math.max(anchorRight, headRight) == map2.width;
   }
   eq(other) {
-    return other instanceof _CellSelection && other.$anchorCell.pos == this.$anchorCell.pos && other.$headCell.pos == this.$headCell.pos;
+    return other instanceof CellSelection2 && other.$anchorCell.pos == this.$anchorCell.pos && other.$headCell.pos == this.$headCell.pos;
   }
-  // Returns the smallest row selection that covers the given anchor
-  // and head cell.
   static rowSelection($anchorCell, $headCell = $anchorCell) {
     const table = $anchorCell.node(-1);
     const map2 = TableMap.get(table);
@@ -22834,23 +23667,13 @@ var CellSelection = class _CellSelection extends Selection {
     const headRect = map2.findCell($headCell.pos - tableStart);
     const doc2 = $anchorCell.node(0);
     if (anchorRect.left <= headRect.left) {
-      if (anchorRect.left > 0)
-        $anchorCell = doc2.resolve(
-          tableStart + map2.map[anchorRect.top * map2.width]
-        );
-      if (headRect.right < map2.width)
-        $headCell = doc2.resolve(
-          tableStart + map2.map[map2.width * (headRect.top + 1) - 1]
-        );
+      if (anchorRect.left > 0) $anchorCell = doc2.resolve(tableStart + map2.map[anchorRect.top * map2.width]);
+      if (headRect.right < map2.width) $headCell = doc2.resolve(tableStart + map2.map[map2.width * (headRect.top + 1) - 1]);
     } else {
-      if (headRect.left > 0)
-        $headCell = doc2.resolve(tableStart + map2.map[headRect.top * map2.width]);
-      if (anchorRect.right < map2.width)
-        $anchorCell = doc2.resolve(
-          tableStart + map2.map[map2.width * (anchorRect.top + 1) - 1]
-        );
+      if (headRect.left > 0) $headCell = doc2.resolve(tableStart + map2.map[headRect.top * map2.width]);
+      if (anchorRect.right < map2.width) $anchorCell = doc2.resolve(tableStart + map2.map[map2.width * (anchorRect.top + 1) - 1]);
     }
-    return new _CellSelection($anchorCell, $headCell);
+    return new CellSelection2($anchorCell, $headCell);
   }
   toJSON() {
     return {
@@ -22860,10 +23683,10 @@ var CellSelection = class _CellSelection extends Selection {
     };
   }
   static fromJSON(doc2, json) {
-    return new _CellSelection(doc2.resolve(json.anchor), doc2.resolve(json.head));
+    return new CellSelection2(doc2.resolve(json.anchor), doc2.resolve(json.head));
   }
   static create(doc2, anchorCell, headCell = anchorCell) {
-    return new _CellSelection(doc2.resolve(anchorCell), doc2.resolve(headCell));
+    return new CellSelection2(doc2.resolve(anchorCell), doc2.resolve(headCell));
   }
   getBookmark() {
     return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
@@ -22871,18 +23694,17 @@ var CellSelection = class _CellSelection extends Selection {
 };
 CellSelection.prototype.visible = false;
 Selection.jsonID("cell", CellSelection);
-var CellBookmark = class _CellBookmark {
+var CellBookmark = class CellBookmark2 {
   constructor(anchor, head) {
     this.anchor = anchor;
     this.head = head;
   }
   map(mapping) {
-    return new _CellBookmark(mapping.map(this.anchor), mapping.map(this.head));
+    return new CellBookmark2(mapping.map(this.anchor), mapping.map(this.head));
   }
   resolve(doc2) {
     const $anchorCell = doc2.resolve(this.anchor), $headCell = doc2.resolve(this.head);
-    if ($anchorCell.parent.type.spec.tableRole == "row" && $headCell.parent.type.spec.tableRole == "row" && $anchorCell.index() < $anchorCell.parent.childCount && $headCell.index() < $headCell.parent.childCount && inSameTable($anchorCell, $headCell))
-      return new CellSelection($anchorCell, $headCell);
+    if ($anchorCell.parent.type.spec.tableRole == "row" && $headCell.parent.type.spec.tableRole == "row" && $anchorCell.index() < $anchorCell.parent.childCount && $headCell.index() < $headCell.parent.childCount && inSameTable($anchorCell, $headCell)) return new CellSelection($anchorCell, $headCell);
     else return Selection.near($headCell, 1);
   }
 };
@@ -22890,9 +23712,7 @@ function drawCellSelection(state) {
   if (!(state.selection instanceof CellSelection)) return null;
   const cells = [];
   state.selection.forEachCell((node, pos) => {
-    cells.push(
-      Decoration.node(pos, pos + node.nodeSize, { class: "selectedCell" })
-    );
+    cells.push(Decoration.node(pos, pos + node.nodeSize, { class: "selectedCell" }));
   });
   return DecorationSet.create(state.doc, cells);
 }
@@ -22901,10 +23721,8 @@ function isCellBoundarySelection({ $from, $to }) {
   let afterFrom = $from.pos;
   let beforeTo = $to.pos;
   let depth = $from.depth;
-  for (; depth >= 0; depth--, afterFrom++)
-    if ($from.after(depth + 1) < $from.end(depth)) break;
-  for (let d2 = $to.depth; d2 >= 0; d2--, beforeTo--)
-    if ($to.before(d2 + 1) > $to.start(d2)) break;
+  for (; depth >= 0; depth--, afterFrom++) if ($from.after(depth + 1) < $from.end(depth)) break;
+  for (let d2 = $to.depth; d2 >= 0; d2--, beforeTo--) if ($to.before(d2 + 1) > $to.start(d2)) break;
   return afterFrom == beforeTo && /row|table/.test($from.node(depth).type.spec.tableRole);
 }
 function isTextSelectionAcrossCells({ $from, $to }) {
@@ -22932,9 +23750,8 @@ function normalizeSelection(state, tr, allowTableNodeSelection) {
   let normalize2;
   let role;
   if (sel instanceof NodeSelection && (role = sel.node.type.spec.tableRole)) {
-    if (role == "cell" || role == "header_cell") {
-      normalize2 = CellSelection.create(doc2, sel.from);
-    } else if (role == "row") {
+    if (role == "cell" || role == "header_cell") normalize2 = CellSelection.create(doc2, sel.from);
+    else if (role == "row") {
       const $cell = doc2.resolve(sel.from + 1);
       normalize2 = CellSelection.rowSelection($cell, $cell);
     } else if (!allowTableNodeSelection) {
@@ -22943,29 +23760,23 @@ function normalizeSelection(state, tr, allowTableNodeSelection) {
       const lastCell = start2 + map2.map[map2.width * map2.height - 1];
       normalize2 = CellSelection.create(doc2, start2 + 1, lastCell);
     }
-  } else if (sel instanceof TextSelection && isCellBoundarySelection(sel)) {
-    normalize2 = TextSelection.create(doc2, sel.from);
-  } else if (sel instanceof TextSelection && isTextSelectionAcrossCells(sel)) {
-    normalize2 = TextSelection.create(doc2, sel.$from.start(), sel.$from.end());
-  }
+  } else if (sel instanceof TextSelection && isCellBoundarySelection(sel)) normalize2 = TextSelection.create(doc2, sel.from);
+  else if (sel instanceof TextSelection && isTextSelectionAcrossCells(sel)) normalize2 = TextSelection.create(doc2, sel.$from.start(), sel.$from.end());
   if (normalize2) (tr || (tr = state.tr)).setSelection(normalize2);
   return tr;
 }
-var fixTablesKey = new PluginKey("fix-tables");
+const fixTablesKey = new PluginKey("fix-tables");
 function changedDescendants(old, cur, offset2, f2) {
   const oldSize = old.childCount, curSize = cur.childCount;
   outer: for (let i = 0, j = 0; i < curSize; i++) {
     const child = cur.child(i);
-    for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {
-      if (old.child(scan) == child) {
-        j = scan + 1;
-        offset2 += child.nodeSize;
-        continue outer;
-      }
+    for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) if (old.child(scan) == child) {
+      j = scan + 1;
+      offset2 += child.nodeSize;
+      continue outer;
     }
     f2(child, offset2);
-    if (j < oldSize && old.child(j).sameMarkup(child))
-      changedDescendants(old.child(j), child, offset2 + 1, f2);
+    if (j < oldSize && old.child(j).sameMarkup(child)) changedDescendants(old.child(j), child, offset2 + 1, f2);
     else child.nodesBetween(0, child.content.size, f2, offset2 + 1);
     offset2 += child.nodeSize;
   }
@@ -22973,12 +23784,10 @@ function changedDescendants(old, cur, offset2, f2) {
 function fixTables(state, oldState) {
   let tr;
   const check = (node, pos) => {
-    if (node.type.spec.tableRole == "table")
-      tr = fixTable(state, node, pos, tr);
+    if (node.type.spec.tableRole == "table") tr = fixTable(state, node, pos, tr);
   };
   if (!oldState) state.doc.descendants(check);
-  else if (oldState.doc != state.doc)
-    changedDescendants(oldState.doc, state.doc, 0, check);
+  else if (oldState.doc != state.doc) changedDescendants(oldState.doc, state.doc, 0, check);
   return tr;
 }
 function fixTable(state, table, tablePos, tr) {
@@ -22994,14 +23803,9 @@ function fixTable(state, table, tablePos, tr) {
       if (!cell) continue;
       const attrs = cell.attrs;
       for (let j = 0; j < attrs.rowspan; j++) mustAdd[prob.row + j] += prob.n;
-      tr.setNodeMarkup(
-        tr.mapping.map(tablePos + 1 + prob.pos),
-        null,
-        removeColSpan(attrs, attrs.colspan - prob.n, prob.n)
-      );
-    } else if (prob.type == "missing") {
-      mustAdd[prob.row] += prob.n;
-    } else if (prob.type == "overlong_rowspan") {
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, removeColSpan(attrs, attrs.colspan - prob.n, prob.n));
+    } else if (prob.type == "missing") mustAdd[prob.row] += prob.n;
+    else if (prob.type == "overlong_rowspan") {
       const cell = table.nodeAt(prob.pos);
       if (!cell) continue;
       tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, {
@@ -23021,20 +23825,17 @@ function fixTable(state, table, tablePos, tr) {
     }
   }
   let first2, last;
-  for (let i = 0; i < mustAdd.length; i++)
-    if (mustAdd[i]) {
-      if (first2 == null) first2 = i;
-      last = i;
-    }
+  for (let i = 0; i < mustAdd.length; i++) if (mustAdd[i]) {
+    if (first2 == null) first2 = i;
+    last = i;
+  }
   for (let i = 0, pos = tablePos + 1; i < map2.height; i++) {
     const row = table.child(i);
     const end2 = pos + row.nodeSize;
     const add = mustAdd[i];
     if (add > 0) {
       let role = "cell";
-      if (row.firstChild) {
-        role = row.firstChild.type.spec.tableRole;
-      }
+      if (row.firstChild) role = row.firstChild.type.spec.tableRole;
       const nodes = [];
       for (let j = 0; j < add; j++) {
         const node = tableNodeTypes(state.schema)[role].createAndFill();
@@ -23053,27 +23854,22 @@ function selectedRect(state) {
   const table = $pos.node(-1);
   const tableStart = $pos.start(-1);
   const map2 = TableMap.get(table);
-  const rect = sel instanceof CellSelection ? map2.rectBetween(
-    sel.$anchorCell.pos - tableStart,
-    sel.$headCell.pos - tableStart
-  ) : map2.findCell($pos.pos - tableStart);
-  return { ...rect, tableStart, map: map2, table };
+  return {
+    ...sel instanceof CellSelection ? map2.rectBetween(sel.$anchorCell.pos - tableStart, sel.$headCell.pos - tableStart) : map2.findCell($pos.pos - tableStart),
+    tableStart,
+    map: map2,
+    table
+  };
 }
 function addColumn(tr, { map: map2, tableStart, table }, col) {
   let refColumn = col > 0 ? -1 : 0;
-  if (columnIsHeader(map2, table, col + refColumn)) {
-    refColumn = col == 0 || col == map2.width ? null : 0;
-  }
+  if (columnIsHeader(map2, table, col + refColumn)) refColumn = col == 0 || col == map2.width ? null : 0;
   for (let row = 0; row < map2.height; row++) {
     const index2 = row * map2.width + col;
     if (col > 0 && col < map2.width && map2.map[index2 - 1] == map2.map[index2]) {
       const pos = map2.map[index2];
       const cell = table.nodeAt(pos);
-      tr.setNodeMarkup(
-        tr.mapping.map(tableStart + pos),
-        null,
-        addColSpan(cell.attrs, col - map2.colCount(pos))
-      );
+      tr.setNodeMarkup(tr.mapping.map(tableStart + pos), null, addColSpan(cell.attrs, col - map2.colCount(pos)));
       row += cell.attrs.rowspan - 1;
     } else {
       const type = refColumn == null ? tableNodeTypes(table.type.schema).cell : table.nodeAt(map2.map[index2 + refColumn]).type;
@@ -23106,13 +23902,8 @@ function removeColumn(tr, { map: map2, table, tableStart }, col) {
     const pos = map2.map[index2];
     const cell = table.nodeAt(pos);
     const attrs = cell.attrs;
-    if (col > 0 && map2.map[index2 - 1] == pos || col < map2.width - 1 && map2.map[index2 + 1] == pos) {
-      tr.setNodeMarkup(
-        tr.mapping.slice(mapStart).map(tableStart + pos),
-        null,
-        removeColSpan(attrs, col - map2.colCount(pos))
-      );
-    } else {
+    if (col > 0 && map2.map[index2 - 1] == pos || col < map2.width - 1 && map2.map[index2 + 1] == pos) tr.setNodeMarkup(tr.mapping.slice(mapStart).map(tableStart + pos), null, removeColSpan(attrs, col - map2.colCount(pos)));
+    else {
       const start2 = tr.mapping.slice(mapStart).map(tableStart + pos);
       tr.delete(start2, start2 + cell.nodeSize);
     }
@@ -23129,9 +23920,7 @@ function deleteColumn(state, dispatch) {
       removeColumn(tr, rect, i);
       if (i == rect.left) break;
       const table = rect.tableStart ? tr.doc.nodeAt(rect.tableStart - 1) : tr.doc;
-      if (!table) {
-        throw RangeError("No table found");
-      }
+      if (!table) throw new RangeError("No table found");
       rect.table = table;
       rect.map = TableMap.get(table);
     }
@@ -23140,35 +23929,30 @@ function deleteColumn(state, dispatch) {
   return true;
 }
 function rowIsHeader(map2, table, row) {
-  var _a;
+  var _table$nodeAt;
   const headerCell = tableNodeTypes(table.type.schema).header_cell;
-  for (let col = 0; col < map2.width; col++)
-    if (((_a = table.nodeAt(map2.map[col + row * map2.width])) == null ? void 0 : _a.type) != headerCell)
-      return false;
+  for (let col = 0; col < map2.width; col++) if (((_table$nodeAt = table.nodeAt(map2.map[col + row * map2.width])) === null || _table$nodeAt === void 0 ? void 0 : _table$nodeAt.type) != headerCell) return false;
   return true;
 }
 function addRow(tr, { map: map2, tableStart, table }, row) {
-  var _a;
   let rowPos = tableStart;
   for (let i = 0; i < row; i++) rowPos += table.child(i).nodeSize;
   const cells = [];
   let refRow = row > 0 ? -1 : 0;
-  if (rowIsHeader(map2, table, row + refRow))
-    refRow = row == 0 || row == map2.height ? null : 0;
-  for (let col = 0, index2 = map2.width * row; col < map2.width; col++, index2++) {
-    if (row > 0 && row < map2.height && map2.map[index2] == map2.map[index2 - map2.width]) {
-      const pos = map2.map[index2];
-      const attrs = table.nodeAt(pos).attrs;
-      tr.setNodeMarkup(tableStart + pos, null, {
-        ...attrs,
-        rowspan: attrs.rowspan + 1
-      });
-      col += attrs.colspan - 1;
-    } else {
-      const type = refRow == null ? tableNodeTypes(table.type.schema).cell : (_a = table.nodeAt(map2.map[index2 + refRow * map2.width])) == null ? void 0 : _a.type;
-      const node = type == null ? void 0 : type.createAndFill();
-      if (node) cells.push(node);
-    }
+  if (rowIsHeader(map2, table, row + refRow)) refRow = row == 0 || row == map2.height ? null : 0;
+  for (let col = 0, index2 = map2.width * row; col < map2.width; col++, index2++) if (row > 0 && row < map2.height && map2.map[index2] == map2.map[index2 - map2.width]) {
+    const pos = map2.map[index2];
+    const attrs = table.nodeAt(pos).attrs;
+    tr.setNodeMarkup(tableStart + pos, null, {
+      ...attrs,
+      rowspan: attrs.rowspan + 1
+    });
+    col += attrs.colspan - 1;
+  } else {
+    var _table$nodeAt2;
+    const type = refRow == null ? tableNodeTypes(table.type.schema).cell : (_table$nodeAt2 = table.nodeAt(map2.map[index2 + refRow * map2.width])) === null || _table$nodeAt2 === void 0 ? void 0 : _table$nodeAt2.type;
+    const node = type === null || type === void 0 ? void 0 : type.createAndFill();
+    if (node) cells.push(node);
   }
   tr.insert(rowPos, tableNodeTypes(table.type.schema).row.create(null, cells));
   return tr;
@@ -23210,10 +23994,10 @@ function removeRow(tr, { map: map2, table, tableStart }, row) {
     } else if (row < map2.height && pos == map2.map[index2 + map2.width]) {
       const cell = table.nodeAt(pos);
       const attrs = cell.attrs;
-      const copy = cell.type.create(
-        { ...attrs, rowspan: cell.attrs.rowspan - 1 },
-        cell.content
-      );
+      const copy = cell.type.create({
+        ...attrs,
+        rowspan: cell.attrs.rowspan - 1
+      }, cell.content);
       const newPos = map2.positionAt(row + 1, col, table);
       tr.insert(tr.mapping.slice(mapFrom).map(tableStart + newPos), copy);
       col += attrs.colspan - 1;
@@ -23229,9 +24013,7 @@ function deleteRow(state, dispatch) {
       removeRow(tr, rect, i);
       if (i == rect.top) break;
       const table = rect.tableStart ? tr.doc.nodeAt(rect.tableStart - 1) : tr.doc;
-      if (!table) {
-        throw RangeError("No table found");
-      }
+      if (!table) throw new RangeError("No table found");
       rect.table = table;
       rect.map = TableMap.get(rect.table);
     }
@@ -23247,14 +24029,12 @@ function cellsOverlapRectangle({ width, height, map: map2 }, rect) {
   let indexTop = rect.top * width + rect.left, indexLeft = indexTop;
   let indexBottom = (rect.bottom - 1) * width + rect.left, indexRight = indexTop + (rect.right - rect.left - 1);
   for (let i = rect.top; i < rect.bottom; i++) {
-    if (rect.left > 0 && map2[indexLeft] == map2[indexLeft - 1] || rect.right < width && map2[indexRight] == map2[indexRight + 1])
-      return true;
+    if (rect.left > 0 && map2[indexLeft] == map2[indexLeft - 1] || rect.right < width && map2[indexRight] == map2[indexRight + 1]) return true;
     indexLeft += width;
     indexRight += width;
   }
   for (let i = rect.left; i < rect.right; i++) {
-    if (rect.top > 0 && map2[indexTop] == map2[indexTop - width] || rect.bottom < height && map2[indexBottom] == map2[indexBottom + width])
-      return true;
+    if (rect.top > 0 && map2[indexTop] == map2[indexTop - width] || rect.bottom < height && map2[indexBottom] == map2[indexBottom + width]) return true;
     indexTop++;
     indexBottom++;
   }
@@ -23262,8 +24042,7 @@ function cellsOverlapRectangle({ width, height, map: map2 }, rect) {
 }
 function mergeCells(state, dispatch) {
   const sel = state.selection;
-  if (!(sel instanceof CellSelection) || sel.$anchorCell.pos == sel.$headCell.pos)
-    return false;
+  if (!(sel instanceof CellSelection) || sel.$anchorCell.pos == sel.$headCell.pos) return false;
   const rect = selectedRect(state), { map: map2 } = rect;
   if (cellsOverlapRectangle(map2, rect)) return false;
   if (dispatch) {
@@ -23272,41 +24051,31 @@ function mergeCells(state, dispatch) {
     let content = Fragment.empty;
     let mergedPos;
     let mergedCell;
-    for (let row = rect.top; row < rect.bottom; row++) {
-      for (let col = rect.left; col < rect.right; col++) {
-        const cellPos = map2.map[row * map2.width + col];
-        const cell = rect.table.nodeAt(cellPos);
-        if (seen[cellPos] || !cell) continue;
-        seen[cellPos] = true;
-        if (mergedPos == null) {
-          mergedPos = cellPos;
-          mergedCell = cell;
-        } else {
-          if (!isEmpty(cell)) content = content.append(cell.content);
-          const mapped = tr.mapping.map(cellPos + rect.tableStart);
-          tr.delete(mapped, mapped + cell.nodeSize);
-        }
+    for (let row = rect.top; row < rect.bottom; row++) for (let col = rect.left; col < rect.right; col++) {
+      const cellPos = map2.map[row * map2.width + col];
+      const cell = rect.table.nodeAt(cellPos);
+      if (seen[cellPos] || !cell) continue;
+      seen[cellPos] = true;
+      if (mergedPos == null) {
+        mergedPos = cellPos;
+        mergedCell = cell;
+      } else {
+        if (!isEmpty(cell)) content = content.append(cell.content);
+        const mapped = tr.mapping.map(cellPos + rect.tableStart);
+        tr.delete(mapped, mapped + cell.nodeSize);
       }
     }
-    if (mergedPos == null || mergedCell == null) {
-      return true;
-    }
+    if (mergedPos == null || mergedCell == null) return true;
     tr.setNodeMarkup(mergedPos + rect.tableStart, null, {
-      ...addColSpan(
-        mergedCell.attrs,
-        mergedCell.attrs.colspan,
-        rect.right - rect.left - mergedCell.attrs.colspan
-      ),
+      ...addColSpan(mergedCell.attrs, mergedCell.attrs.colspan, rect.right - rect.left - mergedCell.attrs.colspan),
       rowspan: rect.bottom - rect.top
     });
-    if (content.size) {
+    if (content.size > 0) {
       const end2 = mergedPos + 1 + mergedCell.content.size;
       const start2 = isEmpty(mergedCell) ? mergedPos + 1 : end2;
       tr.replaceWith(start2 + rect.tableStart, end2 + rect.tableStart, content);
     }
-    tr.setSelection(
-      new CellSelection(tr.doc.resolve(mergedPos + rect.tableStart))
-    );
+    tr.setSelection(new CellSelection(tr.doc.resolve(mergedPos + rect.tableStart)));
     dispatch(tr);
   }
   return true;
@@ -23319,63 +24088,57 @@ function splitCell(state, dispatch) {
 }
 function splitCellWithType(getCellType2) {
   return (state, dispatch) => {
-    var _a;
     const sel = state.selection;
     let cellNode;
     let cellPos;
     if (!(sel instanceof CellSelection)) {
+      var _cellAround;
       cellNode = cellWrapping$1(sel.$from);
       if (!cellNode) return false;
-      cellPos = (_a = cellAround$1(sel.$from)) == null ? void 0 : _a.pos;
+      cellPos = (_cellAround = cellAround$1(sel.$from)) === null || _cellAround === void 0 ? void 0 : _cellAround.pos;
     } else {
       if (sel.$anchorCell.pos != sel.$headCell.pos) return false;
       cellNode = sel.$anchorCell.nodeAfter;
       cellPos = sel.$anchorCell.pos;
     }
-    if (cellNode == null || cellPos == null) {
-      return false;
-    }
-    if (cellNode.attrs.colspan == 1 && cellNode.attrs.rowspan == 1) {
-      return false;
-    }
+    if (cellNode == null || cellPos == null) return false;
+    if (cellNode.attrs.colspan == 1 && cellNode.attrs.rowspan == 1) return false;
     if (dispatch) {
       let baseAttrs = cellNode.attrs;
       const attrs = [];
       const colwidth = baseAttrs.colwidth;
-      if (baseAttrs.rowspan > 1) baseAttrs = { ...baseAttrs, rowspan: 1 };
-      if (baseAttrs.colspan > 1) baseAttrs = { ...baseAttrs, colspan: 1 };
+      if (baseAttrs.rowspan > 1) baseAttrs = {
+        ...baseAttrs,
+        rowspan: 1
+      };
+      if (baseAttrs.colspan > 1) baseAttrs = {
+        ...baseAttrs,
+        colspan: 1
+      };
       const rect = selectedRect(state), tr = state.tr;
-      for (let i = 0; i < rect.right - rect.left; i++)
-        attrs.push(
-          colwidth ? {
-            ...baseAttrs,
-            colwidth: colwidth && colwidth[i] ? [colwidth[i]] : null
-          } : baseAttrs
-        );
+      for (let i = 0; i < rect.right - rect.left; i++) attrs.push(colwidth ? {
+        ...baseAttrs,
+        colwidth: colwidth && colwidth[i] ? [colwidth[i]] : null
+      } : baseAttrs);
       let lastCell;
       for (let row = rect.top; row < rect.bottom; row++) {
         let pos = rect.map.positionAt(row, rect.left, rect.table);
         if (row == rect.top) pos += cellNode.nodeSize;
         for (let col = rect.left, i = 0; col < rect.right; col++, i++) {
           if (col == rect.left && row == rect.top) continue;
-          tr.insert(
-            lastCell = tr.mapping.map(pos + rect.tableStart, 1),
-            getCellType2({ node: cellNode, row, col }).createAndFill(attrs[i])
-          );
-        }
-      }
-      tr.setNodeMarkup(
-        cellPos,
-        getCellType2({ node: cellNode, row: rect.top, col: rect.left }),
-        attrs[0]
-      );
-      if (sel instanceof CellSelection)
-        tr.setSelection(
-          new CellSelection(
-            tr.doc.resolve(sel.$anchorCell.pos),
-            lastCell ? tr.doc.resolve(lastCell) : void 0
-          )
-        );
+          tr.insert(lastCell = tr.mapping.map(pos + rect.tableStart, 1), getCellType2({
+            node: cellNode,
+            row,
+            col
+          }).createAndFill(attrs[i]));
+        }
+      }
+      tr.setNodeMarkup(cellPos, getCellType2({
+        node: cellNode,
+        row: rect.top,
+        col: rect.left
+      }), attrs[0]);
+      if (sel instanceof CellSelection) tr.setSelection(new CellSelection(tr.doc.resolve(sel.$anchorCell.pos), lastCell ? tr.doc.resolve(lastCell) : void 0));
       dispatch(tr);
     }
     return true;
@@ -23388,19 +24151,16 @@ function setCellAttr(name, value) {
     if ($cell.nodeAfter.attrs[name] === value) return false;
     if (dispatch) {
       const tr = state.tr;
-      if (state.selection instanceof CellSelection)
-        state.selection.forEachCell((node, pos) => {
-          if (node.attrs[name] !== value)
-            tr.setNodeMarkup(pos, null, {
-              ...node.attrs,
-              [name]: value
-            });
-        });
-      else
-        tr.setNodeMarkup($cell.pos, null, {
-          ...$cell.nodeAfter.attrs,
+      if (state.selection instanceof CellSelection) state.selection.forEachCell((node, pos) => {
+        if (node.attrs[name] !== value) tr.setNodeMarkup(pos, null, {
+          ...node.attrs,
           [name]: value
         });
+      });
+      else tr.setNodeMarkup($cell.pos, null, {
+        ...$cell.nodeAfter.attrs,
+        [name]: value
+      });
       dispatch(tr);
     }
     return true;
@@ -23412,34 +24172,20 @@ function deprecated_toggleHeader(type) {
     if (dispatch) {
       const types = tableNodeTypes(state.schema);
       const rect = selectedRect(state), tr = state.tr;
-      const cells = rect.map.cellsInRect(
-        type == "column" ? {
-          left: rect.left,
-          top: 0,
-          right: rect.right,
-          bottom: rect.map.height
-        } : type == "row" ? {
-          left: 0,
-          top: rect.top,
-          right: rect.map.width,
-          bottom: rect.bottom
-        } : rect
-      );
+      const cells = rect.map.cellsInRect(type == "column" ? {
+        left: rect.left,
+        top: 0,
+        right: rect.right,
+        bottom: rect.map.height
+      } : type == "row" ? {
+        left: 0,
+        top: rect.top,
+        right: rect.map.width,
+        bottom: rect.bottom
+      } : rect);
       const nodes = cells.map((pos) => rect.table.nodeAt(pos));
-      for (let i = 0; i < cells.length; i++)
-        if (nodes[i].type == types.header_cell)
-          tr.setNodeMarkup(
-            rect.tableStart + cells[i],
-            types.cell,
-            nodes[i].attrs
-          );
-      if (tr.steps.length == 0)
-        for (let i = 0; i < cells.length; i++)
-          tr.setNodeMarkup(
-            rect.tableStart + cells[i],
-            types.header_cell,
-            nodes[i].attrs
-          );
+      for (let i = 0; i < cells.length; i++) if (nodes[i].type == types.header_cell) tr.setNodeMarkup(rect.tableStart + cells[i], types.cell, nodes[i].attrs);
+      if (tr.steps.length === 0) for (let i = 0; i < cells.length; i++) tr.setNodeMarkup(rect.tableStart + cells[i], types.header_cell, nodes[i].attrs);
       dispatch(tr);
     }
     return true;
@@ -23454,9 +24200,7 @@ function isHeaderEnabledByType(type, rect, types) {
   });
   for (let i = 0; i < cellPositions.length; i++) {
     const cell = rect.table.nodeAt(cellPositions[i]);
-    if (cell && cell.type !== types.header_cell) {
-      return false;
-    }
+    if (cell && cell.type !== types.header_cell) return false;
   }
   return true;
 }
@@ -23469,13 +24213,8 @@ function toggleHeader(type, options) {
       const types = tableNodeTypes(state.schema);
       const rect = selectedRect(state), tr = state.tr;
       const isHeaderRowEnabled = isHeaderEnabledByType("row", rect, types);
-      const isHeaderColumnEnabled = isHeaderEnabledByType(
-        "column",
-        rect,
-        types
-      );
-      const isHeaderEnabled = type === "column" ? isHeaderRowEnabled : type === "row" ? isHeaderColumnEnabled : false;
-      const selectionStartsAt = isHeaderEnabled ? 1 : 0;
+      const isHeaderColumnEnabled = isHeaderEnabledByType("column", rect, types);
+      const selectionStartsAt = (type === "column" ? isHeaderRowEnabled : type === "row" ? isHeaderColumnEnabled : false) ? 1 : 0;
       const cellsRect = type == "column" ? {
         left: 0,
         top: selectionStartsAt,
@@ -23491,24 +24230,16 @@ function toggleHeader(type, options) {
       rect.map.cellsInRect(cellsRect).forEach((relativeCellPos) => {
         const cellPos = relativeCellPos + rect.tableStart;
         const cell = tr.doc.nodeAt(cellPos);
-        if (cell) {
-          tr.setNodeMarkup(cellPos, newType, cell.attrs);
-        }
+        if (cell) tr.setNodeMarkup(cellPos, newType, cell.attrs);
       });
       dispatch(tr);
     }
     return true;
   };
 }
-toggleHeader("row", {
-  useDeprecatedLogic: true
-});
-toggleHeader("column", {
-  useDeprecatedLogic: true
-});
-var toggleHeaderCell = toggleHeader("cell", {
-  useDeprecatedLogic: true
-});
+toggleHeader("row", { useDeprecatedLogic: true });
+toggleHeader("column", { useDeprecatedLogic: true });
+const toggleHeaderCell = toggleHeader("cell", { useDeprecatedLogic: true });
 function findNextCell($cell, dir) {
   if (dir < 0) {
     const before = $cell.nodeBefore;
@@ -23516,15 +24247,11 @@ function findNextCell($cell, dir) {
     for (let row = $cell.index(-1) - 1, rowEnd = $cell.before(); row >= 0; row--) {
       const rowNode = $cell.node(-1).child(row);
       const lastChild = rowNode.lastChild;
-      if (lastChild) {
-        return rowEnd - 1 - lastChild.nodeSize;
-      }
+      if (lastChild) return rowEnd - 1 - lastChild.nodeSize;
       rowEnd -= rowNode.nodeSize;
     }
   } else {
-    if ($cell.index() < $cell.parent.childCount - 1) {
-      return $cell.pos + $cell.nodeAfter.nodeSize;
-    }
+    if ($cell.index() < $cell.parent.childCount - 1) return $cell.pos + $cell.nodeAfter.nodeSize;
     const table = $cell.node(-1);
     for (let row = $cell.indexAfter(-1), rowStart = $cell.after(); row < table.childCount; row++) {
       const rowNode = table.child(row);
@@ -23541,24 +24268,16 @@ function goToNextCell(direction) {
     if (cell == null) return false;
     if (dispatch) {
       const $cell = state.doc.resolve(cell);
-      dispatch(
-        state.tr.setSelection(TextSelection.between($cell, moveCellForward($cell))).scrollIntoView()
-      );
+      dispatch(state.tr.setSelection(TextSelection.between($cell, moveCellForward($cell))).scrollIntoView());
     }
     return true;
   };
 }
 function deleteTable(state, dispatch) {
   const $pos = state.selection.$anchor;
-  for (let d2 = $pos.depth; d2 > 0; d2--) {
-    const node = $pos.node(d2);
-    if (node.type.spec.tableRole == "table") {
-      if (dispatch)
-        dispatch(
-          state.tr.delete($pos.before(d2), $pos.after(d2)).scrollIntoView()
-        );
-      return true;
-    }
+  for (let d2 = $pos.depth; d2 > 0; d2--) if ($pos.node(d2).type.spec.tableRole == "table") {
+    if (dispatch) dispatch(state.tr.delete($pos.before(d2), $pos.after(d2)).scrollIntoView());
+    return true;
   }
   return false;
 }
@@ -23569,19 +24288,14 @@ function deleteCellSelection(state, dispatch) {
     const tr = state.tr;
     const baseContent = tableNodeTypes(state.schema).cell.createAndFill().content;
     sel.forEachCell((cell, pos) => {
-      if (!cell.content.eq(baseContent))
-        tr.replace(
-          tr.mapping.map(pos + 1),
-          tr.mapping.map(pos + cell.nodeSize - 1),
-          new Slice(baseContent, 0, 0)
-        );
+      if (!cell.content.eq(baseContent)) tr.replace(tr.mapping.map(pos + 1), tr.mapping.map(pos + cell.nodeSize - 1), new Slice(baseContent, 0, 0));
     });
     if (tr.docChanged) dispatch(tr);
   }
   return true;
 }
 function pastedCells(slice2) {
-  if (!slice2.size) return null;
+  if (slice2.size === 0) return null;
   let { content, openStart, openEnd } = slice2;
   while (content.childCount == 1 && (openStart > 0 && openEnd > 0 || content.child(0).type.spec.tableRole == "table")) {
     openStart--;
@@ -23591,28 +24305,15 @@ function pastedCells(slice2) {
   const first2 = content.child(0);
   const role = first2.type.spec.tableRole;
   const schema = first2.type.schema, rows = [];
-  if (role == "row") {
-    for (let i = 0; i < content.childCount; i++) {
-      let cells = content.child(i).content;
-      const left2 = i ? 0 : Math.max(0, openStart - 1);
-      const right2 = i < content.childCount - 1 ? 0 : Math.max(0, openEnd - 1);
-      if (left2 || right2)
-        cells = fitSlice(
-          tableNodeTypes(schema).row,
-          new Slice(cells, left2, right2)
-        ).content;
-      rows.push(cells);
-    }
-  } else if (role == "cell" || role == "header_cell") {
-    rows.push(
-      openStart || openEnd ? fitSlice(
-        tableNodeTypes(schema).row,
-        new Slice(content, openStart, openEnd)
-      ).content : content
-    );
-  } else {
-    return null;
-  }
+  if (role == "row") for (let i = 0; i < content.childCount; i++) {
+    let cells = content.child(i).content;
+    const left2 = i ? 0 : Math.max(0, openStart - 1);
+    const right2 = i < content.childCount - 1 ? 0 : Math.max(0, openEnd - 1);
+    if (left2 || right2) cells = fitSlice(tableNodeTypes(schema).row, new Slice(cells, left2, right2)).content;
+    rows.push(cells);
+  }
+  else if (role == "cell" || role == "header_cell") rows.push(openStart || openEnd ? fitSlice(tableNodeTypes(schema).row, new Slice(content, openStart, openEnd)).content : content);
+  else return null;
   return ensureRectangular(schema, rows);
 }
 function ensureRectangular(schema, rows) {
@@ -23621,8 +24322,7 @@ function ensureRectangular(schema, rows) {
     const row = rows[i];
     for (let j = row.childCount - 1; j >= 0; j--) {
       const { rowspan, colspan } = row.child(j).attrs;
-      for (let r2 = i; r2 < i + rowspan; r2++)
-        widths[r2] = (widths[r2] || 0) + colspan;
+      for (let r2 = i; r2 < i + rowspan; r2++) widths[r2] = (widths[r2] || 0) + colspan;
     }
   }
   let width = 0;
@@ -23632,18 +24332,19 @@ function ensureRectangular(schema, rows) {
     if (widths[r2] < width) {
       const empty2 = tableNodeTypes(schema).cell.createAndFill();
       const cells = [];
-      for (let i = widths[r2]; i < width; i++) {
-        cells.push(empty2);
-      }
+      for (let i = widths[r2]; i < width; i++) cells.push(empty2);
       rows[r2] = rows[r2].append(Fragment.from(cells));
     }
   }
-  return { height: rows.length, width, rows };
+  return {
+    height: rows.length,
+    width,
+    rows
+  };
 }
 function fitSlice(nodeType, slice2) {
   const node = nodeType.createAndFill();
-  const tr = new Transform(node).replace(0, node.content.size, slice2);
-  return tr.doc;
+  return new Transform(node).replace(0, node.content.size, slice2).doc;
 }
 function clipCells({ width, height, rows }, newWidth, newHeight) {
   if (width != newWidth) {
@@ -23653,19 +24354,10 @@ function clipCells({ width, height, rows }, newWidth, newHeight) {
       const frag = rows[row], cells = [];
       for (let col = added[row] || 0, i = 0; col < newWidth; i++) {
         let cell = frag.child(i % frag.childCount);
-        if (col + cell.attrs.colspan > newWidth)
-          cell = cell.type.createChecked(
-            removeColSpan(
-              cell.attrs,
-              cell.attrs.colspan,
-              col + cell.attrs.colspan - newWidth
-            ),
-            cell.content
-          );
+        if (col + cell.attrs.colspan > newWidth) cell = cell.type.createChecked(removeColSpan(cell.attrs, cell.attrs.colspan, col + cell.attrs.colspan - newWidth), cell.content);
         cells.push(cell);
         col += cell.attrs.colspan;
-        for (let j = 1; j < cell.attrs.rowspan; j++)
-          added[row + j] = (added[row + j] || 0) + cell.attrs.colspan;
+        for (let j = 1; j < cell.attrs.rowspan; j++) added[row + j] = (added[row + j] || 0) + cell.attrs.colspan;
       }
       newRows.push(Fragment.from(cells));
     }
@@ -23678,14 +24370,10 @@ function clipCells({ width, height, rows }, newWidth, newHeight) {
       const cells = [], source = rows[i % height];
       for (let j = 0; j < source.childCount; j++) {
         let cell = source.child(j);
-        if (row + cell.attrs.rowspan > newHeight)
-          cell = cell.type.create(
-            {
-              ...cell.attrs,
-              rowspan: Math.max(1, newHeight - cell.attrs.rowspan)
-            },
-            cell.content
-          );
+        if (row + cell.attrs.rowspan > newHeight) cell = cell.type.create({
+          ...cell.attrs,
+          rowspan: Math.max(1, newHeight - cell.attrs.rowspan)
+        }, cell.content);
         cells.push(cell);
       }
       newRows.push(Fragment.from(cells));
@@ -23693,33 +24381,32 @@ function clipCells({ width, height, rows }, newWidth, newHeight) {
     rows = newRows;
     height = newHeight;
   }
-  return { width, height, rows };
+  return {
+    width,
+    height,
+    rows
+  };
 }
 function growTable(tr, map2, table, start2, width, height, mapFrom) {
   const schema = tr.doc.type.schema;
   const types = tableNodeTypes(schema);
   let empty2;
   let emptyHead;
-  if (width > map2.width) {
-    for (let row = 0, rowEnd = 0; row < map2.height; row++) {
-      const rowNode = table.child(row);
-      rowEnd += rowNode.nodeSize;
-      const cells = [];
-      let add;
-      if (rowNode.lastChild == null || rowNode.lastChild.type == types.cell)
-        add = empty2 || (empty2 = types.cell.createAndFill());
-      else add = emptyHead || (emptyHead = types.header_cell.createAndFill());
-      for (let i = map2.width; i < width; i++) cells.push(add);
-      tr.insert(tr.mapping.slice(mapFrom).map(rowEnd - 1 + start2), cells);
-    }
+  if (width > map2.width) for (let row = 0, rowEnd = 0; row < map2.height; row++) {
+    const rowNode = table.child(row);
+    rowEnd += rowNode.nodeSize;
+    const cells = [];
+    let add;
+    if (rowNode.lastChild == null || rowNode.lastChild.type == types.cell) add = empty2 || (empty2 = types.cell.createAndFill());
+    else add = emptyHead || (emptyHead = types.header_cell.createAndFill());
+    for (let i = map2.width; i < width; i++) cells.push(add);
+    tr.insert(tr.mapping.slice(mapFrom).map(rowEnd - 1 + start2), cells);
   }
   if (height > map2.height) {
     const cells = [];
-    for (let i = 0, start22 = (map2.height - 1) * map2.width; i < Math.max(map2.width, width); i++) {
-      const header = i >= map2.width ? false : table.nodeAt(map2.map[start22 + i]).type == types.header_cell;
-      cells.push(
-        header ? emptyHead || (emptyHead = types.header_cell.createAndFill()) : empty2 || (empty2 = types.cell.createAndFill())
-      );
+    for (let i = 0, start$1 = (map2.height - 1) * map2.width; i < Math.max(map2.width, width); i++) {
+      const header = i >= map2.width ? false : table.nodeAt(map2.map[start$1 + i]).type == types.header_cell;
+      cells.push(header ? emptyHead || (emptyHead = types.header_cell.createAndFill()) : empty2 || (empty2 = types.cell.createAndFill()));
     }
     const emptyRow = types.row.create(null, Fragment.from(cells)), rows = [];
     for (let i = map2.height; i < height; i++) rows.push(emptyRow);
@@ -23740,13 +24427,10 @@ function isolateHorizontal(tr, map2, table, start2, left2, right2, top2, mapFrom
         ...cell.attrs,
         rowspan: top2 - cellTop
       });
-      tr.insert(
-        tr.mapping.slice(mapFrom).map(map2.positionAt(top2, cellLeft, table)),
-        cell.type.createAndFill({
-          ...cell.attrs,
-          rowspan: cellTop + cell.attrs.rowspan - top2
-        })
-      );
+      tr.insert(tr.mapping.slice(mapFrom).map(map2.positionAt(top2, cellLeft, table)), cell.type.createAndFill({
+        ...cell.attrs,
+        rowspan: cellTop + cell.attrs.rowspan - top2
+      }));
       col += cell.attrs.colspan - 1;
     }
   }
@@ -23762,21 +24446,8 @@ function isolateVertical(tr, map2, table, start2, top2, bottom2, left2, mapFrom)
       const cell = table.nodeAt(pos);
       const cellLeft = map2.colCount(pos);
       const updatePos = tr.mapping.slice(mapFrom).map(pos + start2);
-      tr.setNodeMarkup(
-        updatePos,
-        null,
-        removeColSpan(
-          cell.attrs,
-          left2 - cellLeft,
-          cell.attrs.colspan - (left2 - cellLeft)
-        )
-      );
-      tr.insert(
-        updatePos + cell.nodeSize,
-        cell.type.createAndFill(
-          removeColSpan(cell.attrs, 0, left2 - cellLeft)
-        )
-      );
+      tr.setNodeMarkup(updatePos, null, removeColSpan(cell.attrs, left2 - cellLeft, cell.attrs.colspan - (left2 - cellLeft)));
+      tr.insert(updatePos + cell.nodeSize, cell.type.createAndFill(removeColSpan(cell.attrs, 0, left2 - cellLeft)));
       row += cell.attrs.rowspan - 1;
     }
   }
@@ -23784,9 +24455,7 @@ function isolateVertical(tr, map2, table, start2, top2, bottom2, left2, mapFrom)
 }
 function insertCells(state, dispatch, tableStart, rect, cells) {
   let table = tableStart ? state.doc.nodeAt(tableStart - 1) : state.doc;
-  if (!table) {
-    throw new Error("No table found");
-  }
+  if (!table) throw new Error("No table found");
   let map2 = TableMap.get(table);
   const { top: top2, left: left2 } = rect;
   const right2 = left2 + cells.width, bottom2 = top2 + cells.height;
@@ -23794,39 +24463,24 @@ function insertCells(state, dispatch, tableStart, rect, cells) {
   let mapFrom = 0;
   function recomp() {
     table = tableStart ? tr.doc.nodeAt(tableStart - 1) : tr.doc;
-    if (!table) {
-      throw new Error("No table found");
-    }
+    if (!table) throw new Error("No table found");
     map2 = TableMap.get(table);
     mapFrom = tr.mapping.maps.length;
   }
   if (growTable(tr, map2, table, tableStart, right2, bottom2, mapFrom)) recomp();
-  if (isolateHorizontal(tr, map2, table, tableStart, left2, right2, top2, mapFrom))
-    recomp();
-  if (isolateHorizontal(tr, map2, table, tableStart, left2, right2, bottom2, mapFrom))
-    recomp();
-  if (isolateVertical(tr, map2, table, tableStart, top2, bottom2, left2, mapFrom))
-    recomp();
-  if (isolateVertical(tr, map2, table, tableStart, top2, bottom2, right2, mapFrom))
-    recomp();
+  if (isolateHorizontal(tr, map2, table, tableStart, left2, right2, top2, mapFrom)) recomp();
+  if (isolateHorizontal(tr, map2, table, tableStart, left2, right2, bottom2, mapFrom)) recomp();
+  if (isolateVertical(tr, map2, table, tableStart, top2, bottom2, left2, mapFrom)) recomp();
+  if (isolateVertical(tr, map2, table, tableStart, top2, bottom2, right2, mapFrom)) recomp();
   for (let row = top2; row < bottom2; row++) {
     const from2 = map2.positionAt(row, left2, table), to = map2.positionAt(row, right2, table);
-    tr.replace(
-      tr.mapping.slice(mapFrom).map(from2 + tableStart),
-      tr.mapping.slice(mapFrom).map(to + tableStart),
-      new Slice(cells.rows[row - top2], 0, 0)
-    );
+    tr.replace(tr.mapping.slice(mapFrom).map(from2 + tableStart), tr.mapping.slice(mapFrom).map(to + tableStart), new Slice(cells.rows[row - top2], 0, 0));
   }
   recomp();
-  tr.setSelection(
-    new CellSelection(
-      tr.doc.resolve(tableStart + map2.positionAt(top2, left2, table)),
-      tr.doc.resolve(tableStart + map2.positionAt(bottom2 - 1, right2 - 1, table))
-    )
-  );
+  tr.setSelection(new CellSelection(tr.doc.resolve(tableStart + map2.positionAt(top2, left2, table)), tr.doc.resolve(tableStart + map2.positionAt(bottom2 - 1, right2 - 1, table))));
   dispatch(tr);
 }
-var handleKeyDown = keydownHandler({
+const handleKeyDown = keydownHandler({
   ArrowLeft: arrow$2("horiz", -1),
   ArrowRight: arrow$2("horiz", 1),
   ArrowUp: arrow$2("vert", -1),
@@ -23849,29 +24503,17 @@ function arrow$2(axis, dir) {
   return (state, dispatch, view) => {
     if (!view) return false;
     const sel = state.selection;
-    if (sel instanceof CellSelection) {
-      return maybeSetSelection(
-        state,
-        dispatch,
-        Selection.near(sel.$headCell, dir)
-      );
-    }
+    if (sel instanceof CellSelection) return maybeSetSelection(state, dispatch, Selection.near(sel.$headCell, dir));
     if (axis != "horiz" && !sel.empty) return false;
     const end2 = atEndOfCell(view, axis, dir);
     if (end2 == null) return false;
-    if (axis == "horiz") {
-      return maybeSetSelection(
-        state,
-        dispatch,
-        Selection.near(state.doc.resolve(sel.head + dir), dir)
-      );
-    } else {
+    if (axis == "horiz") return maybeSetSelection(state, dispatch, Selection.near(state.doc.resolve(sel.head + dir), dir));
+    else {
       const $cell = state.doc.resolve(end2);
       const $next = nextCell($cell, axis, dir);
       let newSel;
       if ($next) newSel = Selection.near($next, 1);
-      else if (dir < 0)
-        newSel = Selection.near(state.doc.resolve($cell.before(-1)), -1);
+      else if (dir < 0) newSel = Selection.near(state.doc.resolve($cell.before(-1)), -1);
       else newSel = Selection.near(state.doc.resolve($cell.after(-1)), 1);
       return maybeSetSelection(state, dispatch, newSel);
     }
@@ -23882,20 +24524,15 @@ function shiftArrow(axis, dir) {
     if (!view) return false;
     const sel = state.selection;
     let cellSel;
-    if (sel instanceof CellSelection) {
-      cellSel = sel;
-    } else {
+    if (sel instanceof CellSelection) cellSel = sel;
+    else {
       const end2 = atEndOfCell(view, axis, dir);
       if (end2 == null) return false;
       cellSel = new CellSelection(state.doc.resolve(end2));
     }
     const $head = nextCell(cellSel.$headCell, axis, dir);
     if (!$head) return false;
-    return maybeSetSelection(
-      state,
-      dispatch,
-      new CellSelection(cellSel.$anchorCell, $head)
-    );
+    return maybeSetSelection(state, dispatch, new CellSelection(cellSel.$anchorCell, $head));
   };
 }
 function handleTripleClick(view, pos) {
@@ -23909,65 +24546,45 @@ function handlePaste(view, _, slice2) {
   let cells = pastedCells(slice2);
   const sel = view.state.selection;
   if (sel instanceof CellSelection) {
-    if (!cells)
-      cells = {
-        width: 1,
-        height: 1,
-        rows: [
-          Fragment.from(
-            fitSlice(tableNodeTypes(view.state.schema).cell, slice2)
-          )
-        ]
-      };
+    if (!cells) cells = {
+      width: 1,
+      height: 1,
+      rows: [Fragment.from(fitSlice(tableNodeTypes(view.state.schema).cell, slice2))]
+    };
     const table = sel.$anchorCell.node(-1);
     const start2 = sel.$anchorCell.start(-1);
-    const rect = TableMap.get(table).rectBetween(
-      sel.$anchorCell.pos - start2,
-      sel.$headCell.pos - start2
-    );
+    const rect = TableMap.get(table).rectBetween(sel.$anchorCell.pos - start2, sel.$headCell.pos - start2);
     cells = clipCells(cells, rect.right - rect.left, rect.bottom - rect.top);
     insertCells(view.state, view.dispatch, start2, rect, cells);
     return true;
   } else if (cells) {
     const $cell = selectionCell(view.state);
     const start2 = $cell.start(-1);
-    insertCells(
-      view.state,
-      view.dispatch,
-      start2,
-      TableMap.get($cell.node(-1)).findCell($cell.pos - start2),
-      cells
-    );
+    insertCells(view.state, view.dispatch, start2, TableMap.get($cell.node(-1)).findCell($cell.pos - start2), cells);
     return true;
-  } else {
-    return false;
-  }
+  } else return false;
 }
 function handleMouseDown(view, startEvent) {
-  var _a;
+  var _cellUnderMouse;
   if (startEvent.ctrlKey || startEvent.metaKey) return;
   const startDOMCell = domInCell(view, startEvent.target);
   let $anchor;
   if (startEvent.shiftKey && view.state.selection instanceof CellSelection) {
     setCellSelection(view.state.selection.$anchorCell, startEvent);
     startEvent.preventDefault();
-  } else if (startEvent.shiftKey && startDOMCell && ($anchor = cellAround$1(view.state.selection.$anchor)) != null && ((_a = cellUnderMouse(view, startEvent)) == null ? void 0 : _a.pos) != $anchor.pos) {
+  } else if (startEvent.shiftKey && startDOMCell && ($anchor = cellAround$1(view.state.selection.$anchor)) != null && ((_cellUnderMouse = cellUnderMouse(view, startEvent)) === null || _cellUnderMouse === void 0 ? void 0 : _cellUnderMouse.pos) != $anchor.pos) {
     setCellSelection($anchor, startEvent);
     startEvent.preventDefault();
-  } else if (!startDOMCell) {
-    return;
-  }
-  function setCellSelection($anchor2, event) {
+  } else if (!startDOMCell) return;
+  function setCellSelection($anchor$1, event) {
     let $head = cellUnderMouse(view, event);
     const starting = tableEditingKey.getState(view.state) == null;
-    if (!$head || !inSameTable($anchor2, $head)) {
-      if (starting) $head = $anchor2;
-      else return;
-    }
-    const selection = new CellSelection($anchor2, $head);
+    if (!$head || !inSameTable($anchor$1, $head)) if (starting) $head = $anchor$1;
+    else return;
+    const selection = new CellSelection($anchor$1, $head);
     if (starting || !view.state.selection.eq(selection)) {
       const tr = view.state.tr.setSelection(selection);
-      if (starting) tr.setMeta(tableEditingKey, $anchor2.pos);
+      if (starting) tr.setMeta(tableEditingKey, $anchor$1.pos);
       view.dispatch(tr);
     }
   }
@@ -23975,20 +24592,18 @@ function handleMouseDown(view, startEvent) {
     view.root.removeEventListener("mouseup", stop);
     view.root.removeEventListener("dragstart", stop);
     view.root.removeEventListener("mousemove", move);
-    if (tableEditingKey.getState(view.state) != null)
-      view.dispatch(view.state.tr.setMeta(tableEditingKey, -1));
+    if (tableEditingKey.getState(view.state) != null) view.dispatch(view.state.tr.setMeta(tableEditingKey, -1));
   }
   function move(_event) {
     const event = _event;
     const anchor = tableEditingKey.getState(view.state);
-    let $anchor2;
-    if (anchor != null) {
-      $anchor2 = view.state.doc.resolve(anchor);
-    } else if (domInCell(view, event.target) != startDOMCell) {
-      $anchor2 = cellUnderMouse(view, startEvent);
-      if (!$anchor2) return stop();
+    let $anchor$1;
+    if (anchor != null) $anchor$1 = view.state.doc.resolve(anchor);
+    else if (domInCell(view, event.target) != startDOMCell) {
+      $anchor$1 = cellUnderMouse(view, startEvent);
+      if (!$anchor$1) return stop();
     }
-    if ($anchor2) setCellSelection($anchor2, event);
+    if ($anchor$1) setCellSelection($anchor$1, event);
   }
   view.root.addEventListener("mouseup", stop);
   view.root.addEventListener("dragstart", stop);
@@ -23998,8 +24613,8 @@ function atEndOfCell(view, axis, dir) {
   if (!(view.state.selection instanceof TextSelection)) return null;
   const { $head } = view.state.selection;
   for (let d2 = $head.depth - 1; d2 >= 0; d2--) {
-    const parent = $head.node(d2), index2 = dir < 0 ? $head.index(d2) : $head.indexAfter(d2);
-    if (index2 != (dir < 0 ? 0 : parent.childCount)) return null;
+    const parent = $head.node(d2);
+    if ((dir < 0 ? $head.index(d2) : $head.indexAfter(d2)) != (dir < 0 ? 0 : parent.childCount)) return null;
     if (parent.type.spec.tableRole == "cell" || parent.type.spec.tableRole == "header_cell") {
       const cellPos = $head.before(d2);
       const dirStr = axis == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
@@ -24009,11 +24624,7 @@ function atEndOfCell(view, axis, dir) {
   return null;
 }
 function domInCell(view, dom) {
-  for (; dom && dom != view.dom; dom = dom.parentNode) {
-    if (dom.nodeName == "TD" || dom.nodeName == "TH") {
-      return dom;
-    }
-  }
+  for (; dom && dom != view.dom; dom = dom.parentNode) if (dom.nodeName == "TD" || dom.nodeName == "TH") return dom;
   return null;
 }
 function cellUnderMouse(view, event) {
@@ -24022,7 +24633,8 @@ function cellUnderMouse(view, event) {
     top: event.clientY
   });
   if (!mousePos) return null;
-  return mousePos ? cellAround$1(view.state.doc.resolve(mousePos.pos)) : null;
+  const pos = mousePos.inside >= 0 ? mousePos.inside : mousePos.pos;
+  return cellAround$1(view.state.doc.resolve(pos));
 }
 var TableView = class {
   constructor(node, defaultCellMinWidth) {
@@ -24031,10 +24643,7 @@ var TableView = class {
     this.dom = document.createElement("div");
     this.dom.className = "tableWrapper";
     this.table = this.dom.appendChild(document.createElement("table"));
-    this.table.style.setProperty(
-      "--default-cell-min-width",
-      `${defaultCellMinWidth}px`
-    );
+    this.table.style.setProperty("--default-cell-min-width", `${defaultCellMinWidth}px`);
     this.colgroup = this.table.appendChild(document.createElement("colgroup"));
     updateColumnsOnResize(node, this.colgroup, this.table, defaultCellMinWidth);
     this.contentDOM = this.table.appendChild(document.createElement("tbody"));
@@ -24042,12 +24651,7 @@ var TableView = class {
   update(node) {
     if (node.type != this.node.type) return false;
     this.node = node;
-    updateColumnsOnResize(
-      node,
-      this.colgroup,
-      this.table,
-      this.defaultCellMinWidth
-    );
+    updateColumnsOnResize(node, this.colgroup, this.table, this.defaultCellMinWidth);
     return true;
   }
   ignoreMutation(record) {
@@ -24055,7 +24659,6 @@ var TableView = class {
   }
 };
 function updateColumnsOnResize(node, colgroup, table, defaultCellMinWidth, overrideCol, overrideValue) {
-  var _a;
   let totalWidth = 0;
   let fixedWidth = true;
   let nextDOM = colgroup.firstChild;
@@ -24069,20 +24672,19 @@ function updateColumnsOnResize(node, colgroup, table, defaultCellMinWidth, overr
       totalWidth += hasWidth || defaultCellMinWidth;
       if (!hasWidth) fixedWidth = false;
       if (!nextDOM) {
-        const col2 = document.createElement("col");
-        col2.style.width = cssWidth;
-        colgroup.appendChild(col2);
+        const col$1 = document.createElement("col");
+        col$1.style.width = cssWidth;
+        colgroup.appendChild(col$1);
       } else {
-        if (nextDOM.style.width != cssWidth) {
-          nextDOM.style.width = cssWidth;
-        }
+        if (nextDOM.style.width != cssWidth) nextDOM.style.width = cssWidth;
         nextDOM = nextDOM.nextSibling;
       }
     }
   }
   while (nextDOM) {
+    var _nextDOM$parentNode;
     const after = nextDOM.nextSibling;
-    (_a = nextDOM.parentNode) == null ? void 0 : _a.removeChild(nextDOM);
+    (_nextDOM$parentNode = nextDOM.parentNode) === null || _nextDOM$parentNode === void 0 || _nextDOM$parentNode.removeChild(nextDOM);
     nextDOM = after;
   }
   if (fixedWidth) {
@@ -24093,28 +24695,18 @@ function updateColumnsOnResize(node, colgroup, table, defaultCellMinWidth, overr
     table.style.minWidth = totalWidth + "px";
   }
 }
-var columnResizingPluginKey = new PluginKey(
-  "tableColumnResizing"
-);
-function columnResizing({
-  handleWidth = 5,
-  cellMinWidth = 25,
-  defaultCellMinWidth = 100,
-  View = TableView,
-  lastColumnResizable = true
-} = {}) {
+const columnResizingPluginKey = new PluginKey("tableColumnResizing");
+function columnResizing({ handleWidth = 5, cellMinWidth = 25, defaultCellMinWidth = 100, View = TableView, lastColumnResizable = true } = {}) {
   const plugin = new Plugin({
     key: columnResizingPluginKey,
     state: {
       init(_, state) {
-        var _a, _b;
-        const nodeViews = (_b = (_a = plugin.spec) == null ? void 0 : _a.props) == null ? void 0 : _b.nodeViews;
+        var _plugin$spec;
+        const nodeViews = (_plugin$spec = plugin.spec) === null || _plugin$spec === void 0 || (_plugin$spec = _plugin$spec.props) === null || _plugin$spec === void 0 ? void 0 : _plugin$spec.nodeViews;
         const tableName = tableNodeTypes(state.schema).table.name;
-        if (View && nodeViews) {
-          nodeViews[tableName] = (node, view) => {
-            return new View(node, defaultCellMinWidth, view);
-          };
-        }
+        if (View && nodeViews) nodeViews[tableName] = (node, view) => {
+          return new View(node, defaultCellMinWidth, view);
+        };
         return new ResizeState(-1, false);
       },
       apply(tr, prev) {
@@ -24134,21 +24726,19 @@ function columnResizing({
           handleMouseLeave(view);
         },
         mousedown: (view, event) => {
-          handleMouseDown2(view, event, cellMinWidth, defaultCellMinWidth);
+          handleMouseDown$1(view, event, cellMinWidth, defaultCellMinWidth);
         }
       },
       decorations: (state) => {
         const pluginState = columnResizingPluginKey.getState(state);
-        if (pluginState && pluginState.activeHandle > -1) {
-          return handleDecorations(state, pluginState.activeHandle);
-        }
+        if (pluginState && pluginState.activeHandle > -1) return handleDecorations(state, pluginState.activeHandle);
       },
       nodeViews: {}
     }
   });
   return plugin;
 }
-var ResizeState = class _ResizeState {
+var ResizeState = class ResizeState2 {
   constructor(activeHandle, dragging) {
     this.activeHandle = activeHandle;
     this.dragging = dragging;
@@ -24156,16 +24746,12 @@ var ResizeState = class _ResizeState {
   apply(tr) {
     const state = this;
     const action = tr.getMeta(columnResizingPluginKey);
-    if (action && action.setHandle != null)
-      return new _ResizeState(action.setHandle, false);
-    if (action && action.setDragging !== void 0)
-      return new _ResizeState(state.activeHandle, action.setDragging);
+    if (action && action.setHandle != null) return new ResizeState2(action.setHandle, false);
+    if (action && action.setDragging !== void 0) return new ResizeState2(state.activeHandle, action.setDragging);
     if (state.activeHandle > -1 && tr.docChanged) {
       let handle = tr.mapping.map(state.activeHandle, -1);
-      if (!pointsAtCell(tr.doc.resolve(handle))) {
-        handle = -1;
-      }
-      return new _ResizeState(handle, state.dragging);
+      if (!pointsAtCell(tr.doc.resolve(handle))) handle = -1;
+      return new ResizeState2(handle, state.dragging);
     }
     return state;
   }
@@ -24179,10 +24765,8 @@ function handleMouseMove(view, event, handleWidth, lastColumnResizable) {
     let cell = -1;
     if (target) {
       const { left: left2, right: right2 } = target.getBoundingClientRect();
-      if (event.clientX - left2 <= handleWidth)
-        cell = edgeCell(view, event, "left", handleWidth);
-      else if (right2 - event.clientX <= handleWidth)
-        cell = edgeCell(view, event, "right", handleWidth);
+      if (event.clientX - left2 <= handleWidth) cell = edgeCell(view, event, "left", handleWidth);
+      else if (right2 - event.clientX <= handleWidth) cell = edgeCell(view, event, "right", handleWidth);
     }
     if (cell != pluginState.activeHandle) {
       if (!lastColumnResizable && cell !== -1) {
@@ -24190,10 +24774,7 @@ function handleMouseMove(view, event, handleWidth, lastColumnResizable) {
         const table = $cell.node(-1);
         const map2 = TableMap.get(table);
         const tableStart = $cell.start(-1);
-        const col = map2.colCount($cell.pos - tableStart) + $cell.nodeAfter.attrs.colspan - 1;
-        if (col == map2.width - 1) {
-          return;
-        }
+        if (map2.colCount($cell.pos - tableStart) + $cell.nodeAfter.attrs.colspan - 1 == map2.width - 1) return;
       }
       updateHandle(view, cell);
     }
@@ -24202,58 +24783,39 @@ function handleMouseMove(view, event, handleWidth, lastColumnResizable) {
 function handleMouseLeave(view) {
   if (!view.editable) return;
   const pluginState = columnResizingPluginKey.getState(view.state);
-  if (pluginState && pluginState.activeHandle > -1 && !pluginState.dragging)
-    updateHandle(view, -1);
+  if (pluginState && pluginState.activeHandle > -1 && !pluginState.dragging) updateHandle(view, -1);
 }
-function handleMouseDown2(view, event, cellMinWidth, defaultCellMinWidth) {
-  var _a;
+function handleMouseDown$1(view, event, cellMinWidth, defaultCellMinWidth) {
+  var _view$dom$ownerDocume;
   if (!view.editable) return false;
-  const win = (_a = view.dom.ownerDocument.defaultView) != null ? _a : window;
+  const win = (_view$dom$ownerDocume = view.dom.ownerDocument.defaultView) !== null && _view$dom$ownerDocume !== void 0 ? _view$dom$ownerDocume : window;
   const pluginState = columnResizingPluginKey.getState(view.state);
-  if (!pluginState || pluginState.activeHandle == -1 || pluginState.dragging)
-    return false;
+  if (!pluginState || pluginState.activeHandle == -1 || pluginState.dragging) return false;
   const cell = view.state.doc.nodeAt(pluginState.activeHandle);
   const width = currentColWidth(view, pluginState.activeHandle, cell.attrs);
-  view.dispatch(
-    view.state.tr.setMeta(columnResizingPluginKey, {
-      setDragging: { startX: event.clientX, startWidth: width }
-    })
-  );
-  function finish(event2) {
+  view.dispatch(view.state.tr.setMeta(columnResizingPluginKey, { setDragging: {
+    startX: event.clientX,
+    startWidth: width
+  } }));
+  function finish(event$1) {
     win.removeEventListener("mouseup", finish);
     win.removeEventListener("mousemove", move);
-    const pluginState2 = columnResizingPluginKey.getState(view.state);
-    if (pluginState2 == null ? void 0 : pluginState2.dragging) {
-      updateColumnWidth(
-        view,
-        pluginState2.activeHandle,
-        draggedWidth(pluginState2.dragging, event2, cellMinWidth)
-      );
-      view.dispatch(
-        view.state.tr.setMeta(columnResizingPluginKey, { setDragging: null })
-      );
+    const pluginState$1 = columnResizingPluginKey.getState(view.state);
+    if (pluginState$1 === null || pluginState$1 === void 0 ? void 0 : pluginState$1.dragging) {
+      updateColumnWidth(view, pluginState$1.activeHandle, draggedWidth(pluginState$1.dragging, event$1, cellMinWidth));
+      view.dispatch(view.state.tr.setMeta(columnResizingPluginKey, { setDragging: null }));
     }
   }
-  function move(event2) {
-    if (!event2.which) return finish(event2);
-    const pluginState2 = columnResizingPluginKey.getState(view.state);
-    if (!pluginState2) return;
-    if (pluginState2.dragging) {
-      const dragged = draggedWidth(pluginState2.dragging, event2, cellMinWidth);
-      displayColumnWidth(
-        view,
-        pluginState2.activeHandle,
-        dragged,
-        defaultCellMinWidth
-      );
+  function move(event$1) {
+    if (!event$1.which) return finish(event$1);
+    const pluginState$1 = columnResizingPluginKey.getState(view.state);
+    if (!pluginState$1) return;
+    if (pluginState$1.dragging) {
+      const dragged = draggedWidth(pluginState$1.dragging, event$1, cellMinWidth);
+      displayColumnWidth(view, pluginState$1.activeHandle, dragged, defaultCellMinWidth);
     }
   }
-  displayColumnWidth(
-    view,
-    pluginState.activeHandle,
-    width,
-    defaultCellMinWidth
-  );
+  displayColumnWidth(view, pluginState.activeHandle, width, defaultCellMinWidth);
   win.addEventListener("mouseup", finish);
   win.addEventListener("mousemove", move);
   event.preventDefault();
@@ -24263,20 +24825,17 @@ function currentColWidth(view, cellPos, { colspan, colwidth }) {
   const width = colwidth && colwidth[colwidth.length - 1];
   if (width) return width;
   const dom = view.domAtPos(cellPos);
-  const node = dom.node.childNodes[dom.offset];
-  let domWidth = node.offsetWidth, parts = colspan;
+  let domWidth = dom.node.childNodes[dom.offset].offsetWidth, parts = colspan;
   if (colwidth) {
-    for (let i = 0; i < colspan; i++)
-      if (colwidth[i]) {
-        domWidth -= colwidth[i];
-        parts--;
-      }
+    for (let i = 0; i < colspan; i++) if (colwidth[i]) {
+      domWidth -= colwidth[i];
+      parts--;
+    }
   }
   return domWidth / parts;
 }
 function domCellAround(target) {
-  while (target && target.nodeName != "TD" && target.nodeName != "TH")
-    target = target.classList && target.classList.contains("ProseMirror") ? null : target.parentNode;
+  while (target && target.nodeName != "TD" && target.nodeName != "TH") target = target.classList && target.classList.contains("ProseMirror") ? null : target.parentNode;
   return target;
 }
 function edgeCell(view, event, side, handleWidth) {
@@ -24299,9 +24858,7 @@ function draggedWidth(dragging, event, resizeMinWidth) {
   return Math.max(resizeMinWidth, dragging.startWidth + offset2);
 }
 function updateHandle(view, value) {
-  view.dispatch(
-    view.state.tr.setMeta(columnResizingPluginKey, { setHandle: value })
-  );
+  view.dispatch(view.state.tr.setMeta(columnResizingPluginKey, { setHandle: value }));
 }
 function updateColumnWidth(view, cell, width) {
   const $cell = view.state.doc.resolve(cell);
@@ -24317,7 +24874,10 @@ function updateColumnWidth(view, cell, width) {
     if (attrs.colwidth && attrs.colwidth[index2] == width) continue;
     const colwidth = attrs.colwidth ? attrs.colwidth.slice() : zeroes(attrs.colspan);
     colwidth[index2] = width;
-    tr.setNodeMarkup(start2 + pos, null, { ...attrs, colwidth });
+    tr.setNodeMarkup(start2 + pos, null, {
+      ...attrs,
+      colwidth
+    });
   }
   if (tr.docChanged) view.dispatch(tr);
 }
@@ -24326,64 +24886,38 @@ function displayColumnWidth(view, cell, width, defaultCellMinWidth) {
   const table = $cell.node(-1), start2 = $cell.start(-1);
   const col = TableMap.get(table).colCount($cell.pos - start2) + $cell.nodeAfter.attrs.colspan - 1;
   let dom = view.domAtPos($cell.start(-1)).node;
-  while (dom && dom.nodeName != "TABLE") {
-    dom = dom.parentNode;
-  }
+  while (dom && dom.nodeName != "TABLE") dom = dom.parentNode;
   if (!dom) return;
-  updateColumnsOnResize(
-    table,
-    dom.firstChild,
-    dom,
-    defaultCellMinWidth,
-    col,
-    width
-  );
+  updateColumnsOnResize(table, dom.firstChild, dom, defaultCellMinWidth, col, width);
 }
 function zeroes(n) {
   return Array(n).fill(0);
 }
 function handleDecorations(state, cell) {
-  var _a;
   const decorations = [];
   const $cell = state.doc.resolve(cell);
   const table = $cell.node(-1);
-  if (!table) {
-    return DecorationSet.empty;
-  }
+  if (!table) return DecorationSet.empty;
   const map2 = TableMap.get(table);
   const start2 = $cell.start(-1);
   const col = map2.colCount($cell.pos - start2) + $cell.nodeAfter.attrs.colspan - 1;
   for (let row = 0; row < map2.height; row++) {
     const index2 = col + row * map2.width;
     if ((col == map2.width - 1 || map2.map[index2] != map2.map[index2 + 1]) && (row == 0 || map2.map[index2] != map2.map[index2 - map2.width])) {
+      var _columnResizingPlugin;
       const cellPos = map2.map[index2];
       const pos = start2 + cellPos + table.nodeAt(cellPos).nodeSize - 1;
       const dom = document.createElement("div");
       dom.className = "column-resize-handle";
-      if ((_a = columnResizingPluginKey.getState(state)) == null ? void 0 : _a.dragging) {
-        decorations.push(
-          Decoration.node(
-            start2 + cellPos,
-            start2 + cellPos + table.nodeAt(cellPos).nodeSize,
-            {
-              class: "column-resize-dragging"
-            }
-          )
-        );
-      }
+      if ((_columnResizingPlugin = columnResizingPluginKey.getState(state)) === null || _columnResizingPlugin === void 0 ? void 0 : _columnResizingPlugin.dragging) decorations.push(Decoration.node(start2 + cellPos, start2 + cellPos + table.nodeAt(cellPos).nodeSize, { class: "column-resize-dragging" }));
       decorations.push(Decoration.widget(pos, dom));
     }
   }
   return DecorationSet.create(state.doc, decorations);
 }
-function tableEditing({
-  allowTableNodeSelection = false
-} = {}) {
+function tableEditing({ allowTableNodeSelection = false } = {}) {
   return new Plugin({
     key: tableEditingKey,
-    // This piece of state is used to remember when a mouse-drag
-    // cell-selection is happening, so that it can continue even as
-    // transactions (which might move its anchor cell) come in.
     state: {
       init() {
         return null;
@@ -24398,9 +24932,7 @@ function tableEditing({
     },
     props: {
       decorations: drawCellSelection,
-      handleDOMEvents: {
-        mousedown: handleMouseDown
-      },
+      handleDOMEvents: { mousedown: handleMouseDown },
       createSelectionBetween(view) {
         return tableEditingKey.getState(view.state) != null ? view.state.selection : null;
       },
@@ -24409,11 +24941,7 @@ function tableEditing({
       handlePaste
     },
     appendTransaction(_, oldState, state) {
-      return normalizeSelection(
-        state,
-        fixTables(state, oldState),
-        allowTableNodeSelection
-      );
+      return normalizeSelection(state, fixTables(state, oldState), allowTableNodeSelection);
     }
   });
 }
@@ -24438,12 +24966,12 @@ const deleteTableWhenSelected = ({ editor }) => {
   editor.commands.deleteTable();
   return true;
 };
-const createCellBorders = ({ size = 0.66665, color = "#000000" } = {}) => {
+const createCellBorders = ({ size: size2 = 0.66665, color = "#000000" } = {}) => {
   return {
-    top: { size, color },
-    left: { size, color },
-    bottom: { size, color },
-    right: { size, color }
+    top: { size: size2, color },
+    left: { size: size2, color },
+    bottom: { size: size2, color },
+    right: { size: size2, color }
   };
 };
 function cellAround($pos) {
@@ -24624,8 +25152,8 @@ const Table = Node$1.create({
         default: {},
         renderDOM({ borders }) {
           if (!borders) return {};
-          const style = Object.entries(borders).reduce((acc, [key2, { size, color }]) => {
-            return `${acc}border-${key2}: ${Math.ceil(size)}px solid ${color || "black"};`;
+          const style = Object.entries(borders).reduce((acc, [key2, { size: size2, color }]) => {
+            return `${acc}border-${key2}: ${Math.ceil(size2)}px solid ${color || "black"};`;
           }, "");
           return {
             style
@@ -24747,8 +25275,8 @@ const Table = Node$1.create({
           let resolvedTablePos = tablePos;
           if (typeof resolvedTablePos !== "number" && workingTable) {
             const tables = editor.getNodesOfType("table");
-            const match = workingTable ? tables.find((t) => t.node.eq(workingTable)) : tables[0];
-            resolvedTablePos = match?.pos ?? null;
+            const match2 = workingTable ? tables.find((t) => t.node.eq(workingTable)) : tables[0];
+            resolvedTablePos = match2?.pos ?? null;
           }
           if (typeof resolvedTablePos !== "number") {
             return false;
@@ -26404,9 +26932,9 @@ const FieldAnnotation = Node$1.create({
       },
       size: {
         default: null,
-        renderDOM: ({ size }) => {
-          if (!size || !size.width) return {};
-          const style = `width: ${size.width}px; height: ${size.height}px; overflow: hidden;`;
+        renderDOM: ({ size: size2 }) => {
+          if (!size2 || !size2.width) return {};
+          const style = `width: ${size2.width}px; height: ${size2.height}px; overflow: hidden;`;
           return { style };
         }
       },
@@ -27526,7 +28054,7 @@ const generateUniqueDocPrId = (editor) => {
   } while (!candidate || existingIds.has(candidate));
   return candidate;
 };
-async function uploadAndInsertImage({ editor, view, file, size, id }) {
+async function uploadAndInsertImage({ editor, view, file, size: size2, id }) {
   const imageUploadHandler = typeof editor.options.handleImageUpload === "function" ? editor.options.handleImageUpload : handleImageUpload;
   const placeholderId = id;
   try {
@@ -27551,7 +28079,7 @@ async function uploadAndInsertImage({ editor, view, file, size, id }) {
     }
     let imageNode = view.state.schema.nodes.image.create({
       src: mediaPath,
-      size,
+      size: size2,
       id: docPrId,
       rId
     });
@@ -27842,7 +28370,7 @@ const getImagePositionDecorations = (state, view) => {
       let style = "";
       let className = "";
       const { vRelativeFrom, alignH } = node.attrs.anchorData;
-      const { size, padding } = node.attrs;
+      const { size: size2, padding } = node.attrs;
       const pageBreak = findPreviousDomNodeWithClass(view, pos, "pagination-break-wrapper");
       if (pageBreak && vRelativeFrom === "margin" && alignH) {
         let pageBreakPos = pageBreakPositionCache.get(pageBreak);
@@ -27862,7 +28390,7 @@ const getImagePositionDecorations = (state, view) => {
           const $pos = view.state.doc.resolve(pos);
           decorations.push(
             Decoration.node(pos - 1, pos + $pos.parent.nodeSize - 1, {
-              style: `height: ${size.height + parseInt(padding.top) + parseInt(padding.bottom)}px`
+              style: `height: ${size2.height + parseInt(padding.top) + parseInt(padding.bottom)}px`
             })
           );
         }
@@ -27875,8 +28403,8 @@ const getImagePositionDecorations = (state, view) => {
         } else {
           paddingHorizontal = parseInt(padding[alignH]) || 0;
         }
-        imageBlock.style.width = size.width + paddingHorizontal + "px";
-        imageBlock.style.height = size.height + parseInt(padding.top) + parseInt(padding.bottom) + "px";
+        imageBlock.style.width = size2.width + paddingHorizontal + "px";
+        imageBlock.style.height = size2.height + parseInt(padding.top) + parseInt(padding.bottom) + "px";
         decorations.push(Decoration.widget(nextPos, imageBlock, { key: "stable-key" }));
         decorations.push(Decoration.inline(pos, pos + node.nodeSize, { style, class: className }));
       }
@@ -28080,9 +28608,9 @@ const Image = Node$1.create({
       extension: { rendered: false },
       size: {
         default: {},
-        renderDOM: ({ size, extension }) => {
+        renderDOM: ({ size: size2, extension }) => {
           let style = "";
-          let { width, height } = size ?? {};
+          let { width, height } = size2 ?? {};
           if (width) style += `width: ${width}px;`;
           if (height && ["emf", "wmf"].includes(extension))
             style += `height: ${height}px; border: 1px solid black; position: absolute;`;
@@ -28119,7 +28647,7 @@ const Image = Node$1.create({
   },
   renderDOM({ node, htmlAttributes }) {
     const { wrap, marginOffset } = getNormalizedImageAttrs(node.attrs);
-    const { anchorData, padding, transformData = {}, size = { width: 0, height: 0 } } = node.attrs;
+    const { anchorData, padding, transformData = {}, size: size2 = { width: 0, height: 0 } } = node.attrs;
     const margin = {
       left: 0,
       right: 0,
@@ -28137,7 +28665,7 @@ const Image = Node$1.create({
       if (padding.bottom) margin.bottom += padding.bottom;
     }
     const { rotation } = transformData;
-    const { height, width } = size;
+    const { height, width } = size2;
     if (rotation && height && width) {
       const { horizontal, vertical } = getRotationMargins(width, height, rotation);
       margin.left += horizontal;
@@ -28167,7 +28695,7 @@ const Image = Node$1.create({
             const pageStylesData = getDataFromPageStyles({
               editor: this.editor,
               marginOffset,
-              size,
+              size: size2,
               attrs
             });
             style += pageStylesData.style;
@@ -28185,7 +28713,7 @@ const Image = Node$1.create({
           const pageStylesData = getDataFromPageStyles({
             editor: this.editor,
             marginOffset,
-            size,
+            size: size2,
             attrs
           });
           style += pageStylesData.style;
@@ -28210,8 +28738,8 @@ const Image = Node$1.create({
             });
             const originalWidth = maxX - minX;
             const originalHeight = maxY - minY;
-            const scaleWidth = Math.min(1, size.width / originalWidth);
-            const scaleHeight = Math.min(1, size.height / originalHeight);
+            const scaleWidth = Math.min(1, size2.width / originalWidth);
+            const scaleHeight = Math.min(1, size2.height / originalHeight);
             const verticalOffset = Math.max(0, marginOffset.top);
             const points = attrs.polygon.map(([x, y]) => `${horizontalOffset + x * scaleWidth}px ${verticalOffset + y * scaleHeight}px`).join(", ");
             style += `shape-outside: polygon(${points});`;
@@ -28267,7 +28795,7 @@ const Image = Node$1.create({
       let rotationHorizontal = 0;
       let rotationTop = 0;
       const { rotation: rotation2 } = transformData ?? {};
-      const { height: height2, width: width2 } = size ?? {};
+      const { height: height2, width: width2 } = size2 ?? {};
       if (rotation2 && height2 && width2) {
         const { horizontal: horizontal2, vertical } = getRotationMargins(width2, height2, rotation2);
         rotationHorizontal = horizontal2;
@@ -28408,17 +28936,17 @@ const Image = Node$1.create({
     return [ImageRegistrationPlugin({ editor: this.editor }), ImagePositionPlugin({ editor: this.editor })];
   }
 });
-const getDataFromPageStyles = ({ editor, marginOffset, size, attrs }) => {
+const getDataFromPageStyles = ({ editor, marginOffset, size: size2, attrs }) => {
   let style = "";
   let floatRight = false;
   let baseHorizontal = marginOffset?.horizontal || 0;
   const pageStyles = editor?.converter?.pageStyles || editor?.options.parentEditor?.converter?.pageStyles;
-  if (pageStyles?.pageSize && pageStyles?.pageMargins && size.width) {
+  if (pageStyles?.pageSize && pageStyles?.pageMargins && size2.width) {
     const pageWidth = inchesToPixels(pageStyles.pageSize.width);
     const leftMargin = inchesToPixels(pageStyles.pageMargins.left);
     const rightMargin = inchesToPixels(pageStyles.pageMargins.right);
     const contentWidth = pageWidth - leftMargin - rightMargin;
-    const imageWidth = size.width + (attrs.distLeft || 0) + (attrs.distRight || 0);
+    const imageWidth = size2.width + (attrs.distLeft || 0) + (attrs.distRight || 0);
     const leftSpace = marginOffset.horizontal;
     const rightSpace = contentWidth - leftSpace - imageWidth;
     if (rightSpace < 0) {
@@ -29112,14 +29640,14 @@ const ContentBlock = Node$1.create({
       },
       size: {
         default: null,
-        renderDOM: ({ size }) => {
-          if (!size) return {};
+        renderDOM: ({ size: size2 }) => {
+          if (!size2) return {};
           let style = "";
-          if (size.top) style += `top: ${size.top}px; `;
-          if (size.left) style += `left: ${size.left}px; `;
-          if (size.width) style += `width: ${size.width.toString().endsWith("%") ? size.width : `${size.width}px`}; `;
-          if (size.height)
-            style += `height: ${size.height.toString().endsWith("%") ? size.height : `${size.height}px`}; `;
+          if (size2.top) style += `top: ${size2.top}px; `;
+          if (size2.left) style += `left: ${size2.left}px; `;
+          if (size2.width) style += `width: ${size2.width.toString().endsWith("%") ? size2.width : `${size2.width}px`}; `;
+          if (size2.height)
+            style += `height: ${size2.height.toString().endsWith("%") ? size2.height : `${size2.height}px`}; `;
           return { style };
         }
       },
@@ -31834,12 +32362,12 @@ class ShapeGroupView {
   }
   createElement() {
     const attrs = this.node.attrs;
-    const { groupTransform, shapes, size } = attrs;
+    const { groupTransform, shapes, size: size2 } = attrs;
     const container = document.createElement("div");
     container.classList.add("sd-shape-group");
     container.setAttribute("data-shape-group", "");
-    const width = size?.width || groupTransform?.width || 300;
-    const height = size?.height || groupTransform?.height || 200;
+    const width = size2?.width || groupTransform?.width || 300;
+    const height = size2?.height || groupTransform?.height || 200;
     container.style.width = `${width}px`;
     container.style.height = `${height}px`;
     container.style.position = "relative";
@@ -36303,8 +36831,8 @@ class Popover {
     if (from2 < 1) return false;
     const textBefore = this.getMentionText(from2);
     const mentionPattern = /(?:^|\s)@[\w]*$/;
-    const match = textBefore.match(mentionPattern);
-    return match && this.state.selection.empty;
+    const match2 = textBefore.match(mentionPattern);
+    return match2 && this.state.selection.empty;
   }
   destroy() {
     this.tippyInstance.destroy();
@@ -36812,10 +37340,10 @@ function getScale(element) {
   const {
     width,
     height,
-    $
+    $: $2
   } = getCssDimensions(domElement);
-  let x = ($ ? round(rect.width) : rect.width) / width;
-  let y = ($ ? round(rect.height) : rect.height) / height;
+  let x = ($2 ? round(rect.width) : rect.width) / width;
+  let y = ($2 ? round(rect.height) : rect.height) / height;
   if (!x || !Number.isFinite(x)) {
     x = 1;
   }
@@ -38156,8 +38684,8 @@ class SearchQuery {
     let $from = state.doc.resolve(result.from);
     let marks = $from.marksAcross(state.doc.resolve(result.to));
     let ranges = [];
-    let frag = Fragment.empty, pos = result.from, { match } = result;
-    let groups = match ? getGroupIndices(match) : [[0, result.to - result.from]];
+    let frag = Fragment.empty, pos = result.from, { match: match2 } = result;
+    let groups = match2 ? getGroupIndices(match2) : [[0, result.to - result.from]];
     let replParts = parseReplacement(this.unquote(this.replace));
     for (let part of replParts) {
       if (typeof part == "string") {
@@ -38235,39 +38763,39 @@ class RegExpQuery {
     return scanTextblocks(state.doc, from2, to, (node, start2) => {
       let content = textContent(node).slice(0, Math.min(node.content.size, to - start2));
       this.regexp.lastIndex = from2 - start2;
-      let match = this.regexp.exec(content);
-      if (!match) return null;
-      const absoluteIndex = match.index;
+      let match2 = this.regexp.exec(content);
+      if (!match2) return null;
+      const absoluteIndex = match2.index;
       const fromPos = mapIndexToDocPos(node, start2, absoluteIndex);
-      const toPos = mapIndexToDocPos(node, start2, absoluteIndex + match[0].length);
-      return { from: fromPos, to: toPos, match, matchStart: start2 };
+      const toPos = mapIndexToDocPos(node, start2, absoluteIndex + match2[0].length);
+      return { from: fromPos, to: toPos, match: match2, matchStart: start2 };
     });
   }
   findPrev(state, from2, to) {
     return scanTextblocks(state.doc, from2, to, (node, start2) => {
       let content = textContent(node).slice(0, Math.min(node.content.size, from2 - start2));
-      let match;
+      let match2;
       for (let off = 0; ; ) {
         this.regexp.lastIndex = off;
         let next = this.regexp.exec(content);
         if (!next) break;
-        match = next;
+        match2 = next;
         off = next.index + 1;
       }
-      if (!match) return null;
-      const absoluteIndex = match.index;
+      if (!match2) return null;
+      const absoluteIndex = match2.index;
       const fromPos = mapIndexToDocPos(node, start2, absoluteIndex);
-      const toPos = mapIndexToDocPos(node, start2, absoluteIndex + match[0].length);
-      return { from: fromPos, to: toPos, match, matchStart: start2 };
+      const toPos = mapIndexToDocPos(node, start2, absoluteIndex + match2[0].length);
+      return { from: fromPos, to: toPos, match: match2, matchStart: start2 };
     });
   }
 }
-function getGroupIndices(match) {
-  if (match.indices) return match.indices;
-  let result = [[0, match[0].length]];
-  for (let i = 1, pos = 0; i < match.length; i++) {
-    let found = match[i] ? match[0].indexOf(match[i], pos) : -1;
-    result.push(found < 0 ? void 0 : [found, pos = found + match[i].length]);
+function getGroupIndices(match2) {
+  if (match2.indices) return match2.indices;
+  let result = [[0, match2[0].length]];
+  for (let i = 1, pos = 0; i < match2.length; i++) {
+    let found = match2[i] ? match2[0].indexOf(match2[i], pos) : -1;
+    result.push(found < 0 ? void 0 : [found, pos = found + match2[i].length]);
   }
   return result;
 }
@@ -38508,8 +39036,8 @@ const Search = Extension.create({
           const matches = storage?.searchResults;
           if (!matches?.length) return null;
           const decorations = matches.map(
-            (match) => Decoration.inline(match.from, match.to, {
-              id: `search-match-${match.id}`
+            (match2) => Decoration.inline(match2.from, match2.to, {
+              id: `search-match-${match2.id}`
             })
           );
           return DecorationSet.create(state.doc, decorations);
@@ -38613,10 +39141,10 @@ const Search = Extension.create({
        * editor.commands.goToSearchResult(searchResults[3])
        * @note Scrolls to match and selects it
        */
-      goToSearchResult: (match) => (
+      goToSearchResult: (match2) => (
         /** @returns {boolean} */
         ({ state, dispatch, editor }) => {
-          const { from: from2, to } = match;
+          const { from: from2, to } = match2;
           editor.view.focus();
           const tr = state.tr.setSelection(TextSelection.create(state.doc, from2, to)).scrollIntoView();
           dispatch(tr);