@ones-editor/editor 0.0.7-beta.26 → 0.0.7-beta.28

package/dist/index.js

@@ -2365,7 +2365,6 @@ div[data-type=editor-block].table-block div[data-type=table-content] > .error {
 }
 div[data-type=editor-block].table-block div[data-type=table-content] > table {
   border-collapse: collapse;
-  width: max-content;
   border-spacing: 0;
 }
 div[data-type=editor-block].table-block div[data-type=table-content] > table colgroup col {
@@ -3761,7 +3760,7 @@ div.editor-root.readonly div.editor-content div[data-type=editor-block] > [data-
   justify-content: center;
 }
 .comment-editor-root:not(.comment-editor-readonly) .editor-root .editor-content [data-type=editor-block]:not([data-block-type=text]) {
-  width: 248px;
+  width: 224px;
 }
 .comment-editor-editing {
   border: 1px solid #0064ff;
@@ -3850,6 +3849,7 @@ div.editor-root.readonly div.editor-content div[data-type=editor-block] > [data-
 }
 .comment-item-root .item-actions .editor-button {
   padding: 4px 10px;
+  line-height: 1;
 }
 .comment-item-root .item-actions.hidden {
   display: none;
@@ -3908,10 +3908,6 @@ div.editor-root.readonly div.editor-content div[data-type=editor-block] > [data-
   transform: matrix(0.71, 0.61, 0.82, -0.71, 0, 0) translateX(-50%);
   z-index: -1;
 }.comment-quick-reply .quick-reply-button {
-  position: absolute;
-  left: 8px;
-  bottom: 10px;
-  z-index: 2;
   color: #575859;
   font-size: 12px;
 }
@@ -3934,6 +3930,7 @@ div.editor-root.readonly div.editor-content div[data-type=editor-block] > [data-
 }
 .comment-quick-reply .quick-reply-editor .reply-editor-actions .editor-button {
   padding: 4px 10px;
+  line-height: 1;
 }
 .comment-quick-reply.hidden {
   display: none;
@@ -4029,7 +4026,7 @@ div.editor-root.readonly div.editor-content div[data-type=editor-block] > [data-
   border-radius: 2px;
   border-color: var(--editor-comment-layer-active-border-color);
   box-shadow: var(--editor-box-shadow);
-  padding-bottom: 35px;
+  padding-bottom: 10px;
 }
 .editor-web-comment-root .comment-groups-container .comment-group-item-root:not(.no-animation) {
   transition: top 0.2s ease-in, opacity 0.35s ease-in;
@@ -6767,44 +6764,6 @@ var __publicField = (obj, key, value) => {
     }
   }
   const lockers = new Lockers();
-  /**
-   * @name string-character-is-astral-surrogate
-   * @fileoverview Tells, is given character a part of astral character, specifically, a high and low surrogate
-   * @version 2.1.6
-   * @author Roy Revelt, Codsen Ltd
-   * @license MIT
-   * {@link https://codsen.com/os/string-character-is-astral-surrogate/}
-   */
-  function t$7(r) {
-    if (typeof r == "string")
-      return r.length === 0 ? false : r.charCodeAt(0) >= 55296 && r.charCodeAt(0) <= 56319;
-    if (r === void 0)
-      return false;
-    throw new TypeError(`string-character-is-astral-surrogate/isHighSurrogate(): the input is not string but ${typeof r}`);
-  }
-  function e(r) {
-    if (typeof r == "string")
-      return r.length === 0 ? false : r.charCodeAt(0) >= 56320 && r.charCodeAt(0) <= 57343;
-    if (r === void 0)
-      return false;
-    throw new TypeError(`string-character-is-astral-surrogate/isLowSurrogate(): the input is not string but ${typeof r}`);
-  }
-  const ZERO_WIDTH_SPACE_CHAR = "\u200B";
-  function unicodeLength(str) {
-    const s = str;
-    return [...s].length;
-  }
-  function unicodeSubstr(str, start, count) {
-    const s = str;
-    const arr = [...s];
-    let end;
-    if (count === void 0) {
-      end = arr.length;
-    } else {
-      end = start + count;
-    }
-    return arr.slice(start, end).join("");
-  }
   const logger$46 = getLogger("dom-utils");
   function addClass(dom, ...className) {
     if (dom && dom.nodeType === Node.ELEMENT_NODE) {
@@ -6888,28 +6847,31 @@ var __publicField = (obj, key, value) => {
     const dist = (x1 - x) ** 2 + (y1 - y) ** 2;
     return dist;
   }
-  function textNodeOffsetFromPoint(node, x, y) {
-    const text2 = node.data;
-    assert(logger$46, text2, "invalid text node, no data");
-    let minDist = Number.MAX_SAFE_INTEGER;
-    let offset = 0;
-    const range = document.createRange();
-    for (let i = 0; i <= text2.length; i++) {
-      if (i < text2.length && e(text2[i])) {
-        continue;
+  function getOffsetFromPoint(x, y) {
+    let range;
+    let textNode = null;
+    let offset = -1;
+    if (document.caretPositionFromPoint) {
+      range = document.caretPositionFromPoint(x, y);
+      if (range) {
+        textNode = range.offsetNode;
+        offset = range.offset;
       }
-      range.setStart(node, i);
-      const rects = range.getClientRects();
-      for (let r = 0; r < rects.length; r++) {
-        const rect = rects[r];
-        const dist = getDistanceSquare(rect, x, y);
-        if (dist < minDist) {
-          minDist = dist;
-          offset = i;
-        }
+    } else if (document.caretRangeFromPoint) {
+      range = document.caretRangeFromPoint(x, y);
+      if (range) {
+        textNode = range.startContainer;
+        offset = range.startOffset;
       }
     }
-    return offset;
+    return { textNode, offset };
+  }
+  function textNodeOffsetFromPoint(node, x, y) {
+    const offsetInfo = getOffsetFromPoint(x, y);
+    if (offsetInfo.textNode === node) {
+      return offsetInfo.offset;
+    }
+    return 0;
   }
   function compareElement(elem1, elem2) {
     if (elem1 === elem2) {
@@ -7331,6 +7293,44 @@ var __publicField = (obj, key, value) => {
   function pointInRect(rect, x, y) {
     return rect.left <= x && x <= rect.right && rect.top <= y && y <= rect.bottom;
   }
+  /**
+   * @name string-character-is-astral-surrogate
+   * @fileoverview Tells, is given character a part of astral character, specifically, a high and low surrogate
+   * @version 2.1.6
+   * @author Roy Revelt, Codsen Ltd
+   * @license MIT
+   * {@link https://codsen.com/os/string-character-is-astral-surrogate/}
+   */
+  function t$7(r) {
+    if (typeof r == "string")
+      return r.length === 0 ? false : r.charCodeAt(0) >= 55296 && r.charCodeAt(0) <= 56319;
+    if (r === void 0)
+      return false;
+    throw new TypeError(`string-character-is-astral-surrogate/isHighSurrogate(): the input is not string but ${typeof r}`);
+  }
+  function e(r) {
+    if (typeof r == "string")
+      return r.length === 0 ? false : r.charCodeAt(0) >= 56320 && r.charCodeAt(0) <= 57343;
+    if (r === void 0)
+      return false;
+    throw new TypeError(`string-character-is-astral-surrogate/isLowSurrogate(): the input is not string but ${typeof r}`);
+  }
+  const ZERO_WIDTH_SPACE_CHAR = "\u200B";
+  function unicodeLength(str) {
+    const s = str;
+    return [...s].length;
+  }
+  function unicodeSubstr(str, start, count) {
+    const s = str;
+    const arr = [...s];
+    let end;
+    if (count === void 0) {
+      end = arr.length;
+    } else {
+      end = start + count;
+    }
+    return arr.slice(start, end).join("");
+  }
   function escapeSpace(text2) {
     const nbsp = "\xA0";
     if (!text2)
@@ -10260,8 +10260,21 @@ var __publicField = (obj, key, value) => {
     }
     return null;
   }
-  function getBlockRangeFromPoint(editor, x, y) {
+  function getBlockRangeFromPoint(editor, pointX, pointY) {
     const yOffsets = [0, -8, 8];
+    let x = pointX;
+    const y = pointY;
+    let target = document.elementsFromPoint(x, y)[0];
+    if (target === editor.contentElement) {
+      const contentRect = editor.contentElement.getBoundingClientRect();
+      const editorCenterX = contentRect.left + contentRect.width / 2;
+      target = document.elementsFromPoint(editorCenterX, y)[0];
+      const targetBlock = getParentBlock(target);
+      if (targetBlock) {
+        const blockRect = targetBlock.getBoundingClientRect();
+        x = pointX > editorCenterX ? blockRect.right - 5 : blockRect.left;
+      }
+    }
     for (let i = 0; i < yOffsets.length; i++) {
       const elem = document.elementsFromPoint(x, y + yOffsets[i])[0];
       if (!elem) {
@@ -11210,6 +11223,191 @@ var __publicField = (obj, key, value) => {
       background.remove();
     });
   }
+  const logger$3w = getLogger("line-breaker");
+  function getRects(textNode) {
+    const range = document.createRange();
+    range.setStart(textNode, 0);
+    range.setEnd(textNode, textNode.data.length);
+    return range.getClientRects();
+  }
+  function getLineBreaks(block) {
+    const isWrappedChild = (child) => {
+      const first = getFirstClientRect(child);
+      const last = getLastClientRect(child);
+      return last.top > first.top + first.height / 2;
+    };
+    const nextChildStartsNewLine = (child, nextChild) => {
+      const currRect = getLastClientRect(child);
+      const nextRect = getFirstClientRect(nextChild);
+      const ret = Math.floor(nextRect.left) < Math.floor(currRect.right);
+      return ret;
+    };
+    const endAtNewLine = (prev, box) => {
+      const currRect = getLastClientRect(prev);
+      const endRect = getLastClientRect(box);
+      return endRect.top + endRect.height / 2 > currRect.bottom;
+    };
+    const lineBreaks = [];
+    let offset = 0;
+    const children = getTextBlockContentChildren(block);
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (isTextBlockContentInsertionChild(child)) {
+        const insertion = child;
+        const nextChild = children[i + 1];
+        if (!nextChild) {
+          break;
+        }
+        const prevChild = children[i - 1];
+        if (prevChild) {
+          if (endAtNewLine(prevChild, insertion)) {
+            lineBreaks.push({
+              offset,
+              type: "betweenChild",
+              childInfo: {
+                prevChild,
+                nextChild: insertion,
+                wrap: "nextWrapped",
+                prevWrapped: isWrappedChild(prevChild),
+                nextWrapped: isWrappedChild(insertion)
+              }
+            });
+          }
+        }
+        if (nextChildStartsNewLine(insertion, nextChild)) {
+          lineBreaks.push({
+            offset,
+            type: "betweenChild",
+            childInfo: {
+              prevChild,
+              nextChild: insertion,
+              wrap: "nowrap",
+              prevWrapped: isWrappedChild(prevChild),
+              nextWrapped: isWrappedChild(insertion)
+            }
+          });
+          continue;
+        }
+        continue;
+      }
+      if (isTextBlockContentBoxChild(child)) {
+        const boxChild = child;
+        const nextChild = children[i + 1];
+        if (!nextChild) {
+          break;
+        }
+        const prevChild = children[i - 1];
+        if (prevChild) {
+          if (endAtNewLine(prevChild, boxChild)) {
+            lineBreaks.push({
+              offset,
+              type: "betweenChild",
+              childInfo: {
+                prevChild,
+                nextChild: boxChild,
+                wrap: "nextWrapped",
+                prevWrapped: isWrappedChild(prevChild),
+                nextWrapped: isWrappedChild(boxChild)
+              }
+            });
+          }
+        }
+        if (nextChildStartsNewLine(boxChild, nextChild)) {
+          offset += 1;
+          lineBreaks.push({
+            offset,
+            type: "betweenChild",
+            childInfo: {
+              prevChild,
+              nextChild: child,
+              wrap: "nowrap",
+              prevWrapped: isWrappedChild(prevChild),
+              nextWrapped: isWrappedChild(child)
+            }
+          });
+          continue;
+        }
+        offset += 1;
+        continue;
+      }
+      const textChild = child;
+      const rects = textChild.getClientRects();
+      assert(logger$3w, rects.length > 0, "invalid text child dom");
+      if (rects.length === 1) {
+        const nextChild = children[i + 1];
+        if (!nextChild) {
+          break;
+        }
+        if (nextChildStartsNewLine(textChild, nextChild)) {
+          offset += getTextBlockContentChildTextLength(textChild);
+          lineBreaks.push({
+            offset,
+            type: "betweenChild",
+            childInfo: {
+              prevChild: textChild,
+              nextChild,
+              wrap: "nowrap",
+              prevWrapped: isWrappedChild(textChild),
+              nextWrapped: isWrappedChild(nextChild)
+            }
+          });
+          continue;
+        }
+        offset += getTextBlockContentChildTextLength(textChild);
+        continue;
+      }
+      const textNode = textChild.firstChild;
+      assert(logger$3w, textNode, "invalid text child, no text node");
+      assert(logger$3w, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
+      const textChildLength = getTextBlockContentChildTextLength(textChild);
+      assert(logger$3w, textNode.data.length === textChildLength, "text node data length not equal child text length");
+      const textRects = getRects(textNode);
+      for (let rIndex = 0; rIndex < textRects.length - 1; rIndex++) {
+        const rect = textRects[rIndex];
+        const offsetInfo = getOffsetFromPoint(rect.right, rect.top);
+        if (offsetInfo.offset > -1 && offsetInfo.textNode === textNode) {
+          lineBreaks.push({
+            offset: offset + offsetInfo.offset,
+            type: "textBreakWord",
+            childInfo: {
+              prevChild: child,
+              nextChild: child,
+              wrap: "nowrap",
+              prevWrapped: isWrappedChild(child),
+              nextWrapped: isWrappedChild(child)
+            }
+          });
+        }
+      }
+      offset += textChildLength;
+    }
+    return lineBreaks;
+  }
+  function getLineIndex(block, position) {
+    const lineBreaks = getLineBreaks(block);
+    for (let i = 0; i < lineBreaks.length; i++) {
+      const { offset } = lineBreaks[i];
+      if (position.offset < offset) {
+        return {
+          lineIndex: i,
+          lineBreaks
+        };
+      }
+      if (position.offset === offset) {
+        if (position.type === "end") {
+          return {
+            lineIndex: i,
+            lineBreaks
+          };
+        }
+      }
+    }
+    assert(logger$3w, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
+    return {
+      lineIndex: lineBreaks.length,
+      lineBreaks
+    };
+  }
   var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
   var lib$1 = {};
   var Graphemer$1 = {};
@@ -19977,7 +20175,7 @@ var __publicField = (obj, key, value) => {
   const Graphemer_1 = __importDefault(Graphemer$1);
   var _default = lib$1.default = Graphemer_1.default;
   const splitter = new _default();
-  const logger$3w = getLogger("text-offset");
+  const logger$3v = getLogger("text-offset");
   function getChildOffset(block, child) {
     const children = getTextBlockContentChildren(block);
     let start = 0;
@@ -19993,26 +20191,26 @@ var __publicField = (obj, key, value) => {
       }
       start += testLength;
     }
-    assert(logger$3w, false, "can not find child in children");
+    assert(logger$3v, false, "can not find child in children");
   }
   function isValidOffset(block, blockOffset) {
-    assert(logger$3w, blockOffset >= 0, `invalid offset: ${blockOffset}`);
+    assert(logger$3v, blockOffset >= 0, `invalid offset: ${blockOffset}`);
     const childInfo = getTextBlockChild(block, blockOffset);
     const { prev, next, offset } = childInfo;
     if (!prev && !next) {
-      assert(logger$3w, false, "invalid offset, no prev & next child at offset");
+      assert(logger$3v, false, "invalid offset, no prev & next child at offset");
     }
     if (prev !== next) {
       return true;
     }
     const child = prev;
-    assert(logger$3w, child, "no child");
+    assert(logger$3v, child, "no child");
     if (isTextBlockContentBoxChild(child)) {
-      assert(logger$3w, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
+      assert(logger$3v, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
       return true;
     }
     const text2 = child.textContent;
-    assert(logger$3w, text2, "no content for text child");
+    assert(logger$3v, text2, "no content for text child");
     const chars = splitter.splitGraphemes(text2);
     const validOffsets = /* @__PURE__ */ new Set();
     let start = 0;
@@ -20042,7 +20240,7 @@ var __publicField = (obj, key, value) => {
   }
   function getNextValidOffset(block, blockOffset) {
     const length = getTextBlockLength(block);
-    assert(logger$3w, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
+    assert(logger$3v, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
     if (blockOffset === length) {
       return length;
     }
@@ -20056,229 +20254,6 @@ var __publicField = (obj, key, value) => {
     }
     return ret;
   }
-  const logger$3v = getLogger("line-breaker");
-  function getLineBreaks(block) {
-    const isWrappedChild = (child) => {
-      const first = getFirstClientRect(child);
-      const last = getLastClientRect(child);
-      return last.top > first.top + first.height / 2;
-    };
-    const nextChildStartsNewLine = (child, nextChild) => {
-      const currRect = getLastClientRect(child);
-      const nextRect = getFirstClientRect(nextChild);
-      const ret = Math.floor(nextRect.left) < Math.floor(currRect.right);
-      return ret;
-    };
-    const endAtNewLine = (prev, box) => {
-      const currRect = getLastClientRect(prev);
-      const endRect = getLastClientRect(box);
-      return endRect.top + endRect.height / 2 > currRect.bottom;
-    };
-    const isBreakWordRects = (rects) => {
-      if (rects.length === 0) {
-        return false;
-      }
-      if (rects.length === 1) {
-        return false;
-      }
-      const first = rects[0];
-      const last = rects[rects.length - 1];
-      return Math.floor(first.right) - Math.floor(last.left) > 10;
-    };
-    const lineBreaks = [];
-    let offset = 0;
-    const children = getTextBlockContentChildren(block);
-    for (let i = 0; i < children.length; i++) {
-      const child = children[i];
-      if (isTextBlockContentInsertionChild(child)) {
-        const insertion = child;
-        const nextChild = children[i + 1];
-        if (!nextChild) {
-          break;
-        }
-        const prevChild = children[i - 1];
-        if (prevChild) {
-          if (endAtNewLine(prevChild, insertion)) {
-            lineBreaks.push({
-              offset,
-              type: "betweenChild",
-              childInfo: {
-                prevChild,
-                nextChild: insertion,
-                wrap: "nextWrapped",
-                prevWrapped: isWrappedChild(prevChild),
-                nextWrapped: isWrappedChild(insertion)
-              }
-            });
-          }
-        }
-        if (nextChildStartsNewLine(insertion, nextChild)) {
-          lineBreaks.push({
-            offset,
-            type: "betweenChild",
-            childInfo: {
-              prevChild,
-              nextChild: insertion,
-              wrap: "nowrap",
-              prevWrapped: isWrappedChild(prevChild),
-              nextWrapped: isWrappedChild(insertion)
-            }
-          });
-          continue;
-        }
-        continue;
-      }
-      if (isTextBlockContentBoxChild(child)) {
-        const boxChild = child;
-        const nextChild = children[i + 1];
-        if (!nextChild) {
-          break;
-        }
-        const prevChild = children[i - 1];
-        if (prevChild) {
-          if (endAtNewLine(prevChild, boxChild)) {
-            lineBreaks.push({
-              offset,
-              type: "betweenChild",
-              childInfo: {
-                prevChild,
-                nextChild: boxChild,
-                wrap: "nextWrapped",
-                prevWrapped: isWrappedChild(prevChild),
-                nextWrapped: isWrappedChild(boxChild)
-              }
-            });
-          }
-        }
-        if (nextChildStartsNewLine(boxChild, nextChild)) {
-          offset += 1;
-          lineBreaks.push({
-            offset,
-            type: "betweenChild",
-            childInfo: {
-              prevChild,
-              nextChild: child,
-              wrap: "nowrap",
-              prevWrapped: isWrappedChild(prevChild),
-              nextWrapped: isWrappedChild(child)
-            }
-          });
-          continue;
-        }
-        offset += 1;
-        continue;
-      }
-      const textChild = child;
-      const rects = textChild.getClientRects();
-      assert(logger$3v, rects.length > 0, "invalid text child dom");
-      if (rects.length === 1) {
-        const nextChild = children[i + 1];
-        if (!nextChild) {
-          break;
-        }
-        if (nextChildStartsNewLine(textChild, nextChild)) {
-          offset += getTextBlockContentChildTextLength(textChild);
-          lineBreaks.push({
-            offset,
-            type: "betweenChild",
-            childInfo: {
-              prevChild: textChild,
-              nextChild,
-              wrap: "nowrap",
-              prevWrapped: isWrappedChild(textChild),
-              nextWrapped: isWrappedChild(nextChild)
-            }
-          });
-          continue;
-        }
-        offset += getTextBlockContentChildTextLength(textChild);
-        continue;
-      }
-      const textNode = textChild.firstChild;
-      assert(logger$3v, textNode, "invalid text child, no text node");
-      assert(logger$3v, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
-      const range = document.createRange();
-      const rangeNext = document.createRange();
-      const textChildLength = getTextBlockContentChildTextLength(textChild);
-      assert(logger$3v, textNode.data.length === textChildLength, "text node data length not equal child text length");
-      for (let subOffset = 0; subOffset < textNode.data.length; subOffset++) {
-        if (!isValidOffset(block, offset + subOffset)) {
-          continue;
-        }
-        range.setStart(textNode, subOffset);
-        const currRects = range.getClientRects();
-        assert(logger$3v, currRects.length >= 1, "invalid text node, no client rects");
-        if (isBreakWordRects(currRects)) {
-          const newOffset = offset + subOffset;
-          lineBreaks.push({
-            offset: newOffset,
-            type: "textBreakWord",
-            childInfo: {
-              prevChild: child,
-              nextChild: child,
-              wrap: "nowrap",
-              prevWrapped: isWrappedChild(child),
-              nextWrapped: isWrappedChild(child)
-            }
-          });
-          continue;
-        }
-        let nextSubOffset = subOffset + 1;
-        if (!isValidOffset(block, offset + nextSubOffset)) {
-          nextSubOffset = subOffset + 2;
-        }
-        rangeNext.setStart(textNode, nextSubOffset);
-        const nextRects = rangeNext.getClientRects();
-        const currRect = currRects[0];
-        const nextRect = nextRects[0];
-        if (Math.floor(nextRect.left) < Math.floor(currRect.right)) {
-          if (isFirefox() || isSafari()) {
-            lineBreaks.push({
-              offset: isSafari() ? offset + nextSubOffset : offset + subOffset,
-              type: "textBreakWord",
-              childInfo: {
-                prevChild: child,
-                nextChild: child,
-                wrap: "nowrap",
-                prevWrapped: isWrappedChild(child),
-                nextWrapped: isWrappedChild(child)
-              }
-            });
-            continue;
-          } else {
-            assert(logger$3v, false, "span pre-wrap should not has a line-wrap by white space");
-          }
-        }
-      }
-      offset += textChildLength;
-    }
-    return lineBreaks;
-  }
-  function getLineIndex(block, position) {
-    const lineBreaks = getLineBreaks(block);
-    for (let i = 0; i < lineBreaks.length; i++) {
-      const { offset, type } = lineBreaks[i];
-      if (position.offset < offset) {
-        return {
-          lineIndex: i,
-          lineBreaks
-        };
-      }
-      if (position.offset === offset) {
-        if (position.type === "end") {
-          return {
-            lineIndex: i,
-            lineBreaks
-          };
-        }
-      }
-    }
-    assert(logger$3v, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
-    return {
-      lineIndex: lineBreaks.length,
-      lineBreaks
-    };
-  }
   const logger$3u = getLogger("line-offset");
   function getLineOffsets(block) {
     const lineBreaks = getLineBreaks(block);
@@ -39653,6 +39628,10 @@ var __publicField = (obj, key, value) => {
       const leftWidths = widths.slice(0, colIndex).reduce((a, b) => a + b, 0);
       const colWidth = totalWidth - leftWidths;
       setColumnWidth(table, colIndex, colWidth);
+      if (colWidth) {
+        const tableWidth = parseFloat(table.style.minWidth);
+        table.style.minWidth = `${tableWidth + (colWidth - widths[colIndex])}px`;
+      }
       updateResizeGripper(this.editor, block, draggingRefCell);
       this.editor.selection.caret.update();
     }
@@ -46176,6 +46155,7 @@ $$${mathData.mathjaxText}$$
       }
     }
     assert(logger$1k, containerIndex === tableData.children.length, "container count mismatch");
+    table.style.minWidth = `${colsWidth.reduce((pre, cur) => cur + pre, 0)}px`;
     if (tableData.noBorder) {
       addClass(table, "no-border");
     }
@@ -48174,8 +48154,8 @@ ${codeText}
 \`\`\`
  ${captionText}`;
     }
-    return `<p><pre><code>${codeText}</code></pre></p>
-<p>${captionText}</p>`;
+    return `<p><pre><code>${escapeHtmlText(codeText)}</code></pre></p>
+<p>${escapeHtmlText(captionText)}</p>`;
   }
   const CodeBlock = {
     blockType: "code",
@@ -60781,9 +60761,16 @@ ${codeText}
     assert(logger$l, data.text, `no text for text box data: ${JSON.stringify(boxData)}`);
     assert(logger$l, typeof data.text === "string", `invalid text type for text box data: ${JSON.stringify(boxData)}`);
     const oldBoxData = data.oldAttr;
-    const boxClass = editor.editorBoxes.getBoxClass(oldBoxData.type);
-    if (boxClass) {
-      boxClass.updateBoxContent(editor, boxElement, boxContent, oldBoxData);
+    if (oldBoxData && oldBoxData.box) {
+      const childBoxElement = createBoxElement(oldBoxData);
+      const childBoxContent = createBoxContentElement(childBoxElement);
+      const boxClass = editor.editorBoxes.getBoxClass(oldBoxData.type);
+      if (boxClass) {
+        boxClass.updateBoxContent(editor, childBoxElement, childBoxContent, oldBoxData);
+      }
+      boxContent.appendChild(childBoxElement);
+    } else {
+      createElement("span", [], boxContent, data.text);
     }
     addClass(boxContent, "history-deleted-box");
     const user = data.user;
@@ -72993,6 +72980,7 @@ ${data.flowchartText}
   exports2.getNextBlock = getNextBlock;
   exports2.getNextValidOffset = getNextValidOffset;
   exports2.getNextVisibleBlock = getNextVisibleBlock;
+  exports2.getOffsetFromPoint = getOffsetFromPoint;
   exports2.getOffsetInfoAfter = getOffsetInfoAfter;
   exports2.getOffsetInfoBefore = getOffsetInfoBefore;
   exports2.getOpAt = getOpAt;