avo 3.20.3 → 3.21.0

data/app/assets/builds/avo.base.js

@@ -138486,14 +138486,8 @@
       this.content = content || Fragment.empty;
     }
     /**
-    The array of this node's child nodes.
-    */
-    get children() {
-      return this.content.content;
-    }
-    /**
     The size of this node, as defined by the integer-based [indexing
-    scheme](https://prosemirror.net/docs/guide/#doc.indexing). For text nodes, this is the
+    scheme](/docs/guide/#doc.indexing). For text nodes, this is the
     amount of characters. For other leaf nodes, it is one. For
     non-leaf nodes, it is the size of the content plus two (the
     start and end token).
@@ -139178,7 +139172,7 @@
     let result = [];
     for (let typeName in types) {
       let type2 = types[typeName];
-      if (type2.isInGroup(name))
+      if (type2.groups.indexOf(name) > -1)
         result.push(type2);
     }
     if (result.length == 0)
@@ -139416,13 +139410,6 @@
       return this.isLeaf || !!this.spec.atom;
     }
     /**
-    Return true when this node type is part of the given
-    [group](https://prosemirror.net/docs/ref/#model.NodeSpec.group).
-    */
-    isInGroup(group) {
-      return this.groups.indexOf(group) > -1;
-    }
-    /**
     The node type's [whitespace](https://prosemirror.net/docs/ref/#model.NodeSpec.whitespace) option.
     */
     get whitespace() {
@@ -139810,7 +139797,7 @@
     */
     parse(dom, options = {}) {
       let context = new ParseContext(this, options, false);
-      context.addAll(dom, Mark.none, options.from, options.to);
+      context.addAll(dom, options.from, options.to);
       return context.finish();
     }
     /**
@@ -139823,7 +139810,7 @@
     */
     parseSlice(dom, options = {}) {
       let context = new ParseContext(this, options, true);
-      context.addAll(dom, Mark.none, options.from, options.to);
+      context.addAll(dom, options.from, options.to);
       return Slice.maxOpen(context.finish());
     }
     /**
@@ -139958,14 +139945,16 @@
     return type && type.whitespace == "pre" ? OPT_PRESERVE_WS | OPT_PRESERVE_WS_FULL : base2 & ~OPT_OPEN_LEFT;
   }
   var NodeContext = class {
-    constructor(type, attrs, marks, solid, match3, options) {
+    constructor(type, attrs, marks, pendingMarks, solid, match3, options) {
       this.type = type;
       this.attrs = attrs;
       this.marks = marks;
+      this.pendingMarks = pendingMarks;
       this.solid = solid;
       this.options = options;
       this.content = [];
       this.activeMarks = Mark.none;
+      this.stashMarks = [];
       this.match = match3 || (options & OPT_OPEN_LEFT ? null : type.contentMatch);
     }
     findWrapping(node) {
@@ -140003,6 +139992,20 @@
         content = content.append(this.match.fillBefore(Fragment.empty, true));
       return this.type ? this.type.create(this.attrs, content, this.marks) : content;
     }
+    popFromStashMark(mark) {
+      for (let i5 = this.stashMarks.length - 1; i5 >= 0; i5--)
+        if (mark.eq(this.stashMarks[i5]))
+          return this.stashMarks.splice(i5, 1)[0];
+    }
+    applyPending(nextType) {
+      for (let i5 = 0, pending = this.pendingMarks; i5 < pending.length; i5++) {
+        let mark = pending[i5];
+        if ((this.type ? this.type.allowsMarkType(mark.type) : markMayApply(mark.type, nextType)) && !mark.isInSet(this.activeMarks)) {
+          this.activeMarks = mark.addToSet(this.activeMarks);
+          this.pendingMarks = mark.removeFromSet(this.pendingMarks);
+        }
+      }
+    }
     inlineContext(node) {
       if (this.type)
         return this.type.inlineContent;
@@ -140017,15 +140020,14 @@
       this.options = options;
       this.isOpen = isOpen;
       this.open = 0;
-      this.localPreserveWS = false;
       let topNode = options.topNode, topContext;
       let topOptions = wsOptionsFor(null, options.preserveWhitespace, 0) | (isOpen ? OPT_OPEN_LEFT : 0);
       if (topNode)
-        topContext = new NodeContext(topNode.type, topNode.attrs, Mark.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
+        topContext = new NodeContext(topNode.type, topNode.attrs, Mark.none, Mark.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
       else if (isOpen)
-        topContext = new NodeContext(null, null, Mark.none, true, null, topOptions);
+        topContext = new NodeContext(null, null, Mark.none, Mark.none, true, null, topOptions);
       else
-        topContext = new NodeContext(parser.schema.topNodeType, null, Mark.none, true, null, topOptions);
+        topContext = new NodeContext(parser.schema.topNodeType, null, Mark.none, Mark.none, true, null, topOptions);
       this.nodes = [topContext];
       this.find = options.findPositions;
       this.needsBlock = false;
@@ -140036,17 +140038,35 @@
     // Add a DOM node to the content. Text is inserted as text node,
     // otherwise, the node is passed to `addElement` or, if it has a
     // `style` attribute, `addElementWithStyles`.
-    addDOM(dom, marks) {
+    addDOM(dom) {
       if (dom.nodeType == 3)
-        this.addTextNode(dom, marks);
+        this.addTextNode(dom);
       else if (dom.nodeType == 1)
-        this.addElement(dom, marks);
-    }
-    addTextNode(dom, marks) {
+        this.addElement(dom);
+    }
+    withStyleRules(dom, f4) {
+      let style2 = dom.style;
+      if (!style2 || !style2.length)
+        return f4();
+      let marks = this.readStyles(dom.style);
+      if (!marks)
+        return;
+      let [addMarks, removeMarks] = marks, top2 = this.top;
+      for (let i5 = 0; i5 < removeMarks.length; i5++)
+        this.removePendingMark(removeMarks[i5], top2);
+      for (let i5 = 0; i5 < addMarks.length; i5++)
+        this.addPendingMark(addMarks[i5]);
+      f4();
+      for (let i5 = 0; i5 < addMarks.length; i5++)
+        this.removePendingMark(addMarks[i5], top2);
+      for (let i5 = 0; i5 < removeMarks.length; i5++)
+        this.addPendingMark(removeMarks[i5]);
+    }
+    addTextNode(dom) {
       let value = dom.nodeValue;
-      let top2 = this.top, preserveWS = top2.options & OPT_PRESERVE_WS_FULL ? "full" : this.localPreserveWS || (top2.options & OPT_PRESERVE_WS) > 0;
-      if (preserveWS === "full" || top2.inlineContext(dom) || /[^ \t\r\n\u000c]/.test(value)) {
-        if (!preserveWS) {
+      let top2 = this.top;
+      if (top2.options & OPT_PRESERVE_WS_FULL || top2.inlineContext(dom) || /[^ \t\r\n\u000c]/.test(value)) {
+        if (!(top2.options & OPT_PRESERVE_WS)) {
           value = value.replace(/[ \t\r\n\u000c]+/g, " ");
           if (/^[ \t\r\n\u000c]/.test(value) && this.open == this.nodes.length - 1) {
             let nodeBefore = top2.content[top2.content.length - 1];
@@ -140054,13 +140074,13 @@
             if (!nodeBefore || domNodeBefore && domNodeBefore.nodeName == "BR" || nodeBefore.isText && /[ \t\r\n\u000c]$/.test(nodeBefore.text))
               value = value.slice(1);
           }
-        } else if (preserveWS !== "full") {
+        } else if (!(top2.options & OPT_PRESERVE_WS_FULL)) {
           value = value.replace(/\r?\n|\r/g, " ");
         } else {
           value = value.replace(/\r\n?/g, "\n");
         }
         if (value)
-          this.insertNode(this.parser.schema.text(value), marks);
+          this.insertNode(this.parser.schema.text(value));
         this.findInText(dom);
       } else {
         this.findInside(dom);
@@ -140068,23 +140088,20 @@
     }
     // Try to find a handler for the given tag and use that to parse. If
     // none is found, the element's content nodes are added directly.
-    addElement(dom, marks, matchAfter) {
-      let outerWS = this.localPreserveWS, top2 = this.top;
-      if (dom.tagName == "PRE" || /pre/.test(dom.style && dom.style.whiteSpace))
-        this.localPreserveWS = true;
+    addElement(dom, matchAfter) {
       let name = dom.nodeName.toLowerCase(), ruleID;
       if (listTags.hasOwnProperty(name) && this.parser.normalizeLists)
         normalizeList(dom);
       let rule = this.options.ruleFromNode && this.options.ruleFromNode(dom) || (ruleID = this.parser.matchTag(dom, this, matchAfter));
-      out: if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
+      if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
         this.findInside(dom);
-        this.ignoreFallback(dom, marks);
+        this.ignoreFallback(dom);
       } else if (!rule || rule.skip || rule.closeParent) {
         if (rule && rule.closeParent)
           this.open = Math.max(0, this.open - 1);
         else if (rule && rule.skip.nodeType)
           dom = rule.skip;
-        let sync, oldNeedsBlock = this.needsBlock;
+        let sync, top2 = this.top, oldNeedsBlock = this.needsBlock;
         if (blockTags.hasOwnProperty(name)) {
           if (top2.content.length && top2.content[0].isInline && this.open) {
             this.open--;
@@ -140094,38 +140111,38 @@
           if (!top2.type)
             this.needsBlock = true;
         } else if (!dom.firstChild) {
-          this.leafFallback(dom, marks);
-          break out;
+          this.leafFallback(dom);
+          return;
         }
-        let innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
-        if (innerMarks)
-          this.addAll(dom, innerMarks);
+        if (rule && rule.skip)
+          this.addAll(dom);
+        else
+          this.withStyleRules(dom, () => this.addAll(dom));
         if (sync)
           this.sync(top2);
         this.needsBlock = oldNeedsBlock;
       } else {
-        let innerMarks = this.readStyles(dom, marks);
-        if (innerMarks)
-          this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID : void 0);
+        this.withStyleRules(dom, () => {
+          this.addElementByRule(dom, rule, rule.consuming === false ? ruleID : void 0);
+        });
       }
-      this.localPreserveWS = outerWS;
     }
     // Called for leaf DOM nodes that would otherwise be ignored
-    leafFallback(dom, marks) {
+    leafFallback(dom) {
       if (dom.nodeName == "BR" && this.top.type && this.top.type.inlineContent)
-        this.addTextNode(dom.ownerDocument.createTextNode("\n"), marks);
+        this.addTextNode(dom.ownerDocument.createTextNode("\n"));
     }
     // Called for ignored nodes
-    ignoreFallback(dom, marks) {
+    ignoreFallback(dom) {
       if (dom.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent))
-        this.findPlace(this.parser.schema.text("-"), marks);
+        this.findPlace(this.parser.schema.text("-"));
     }
     // Run any style parser associated with the node's styles. Either
-    // return an updated array of marks, or null to indicate some of the
-    // styles had a rule with `ignore` set.
-    readStyles(dom, marks) {
-      let styles = dom.style;
-      if (styles && styles.length)
+    // return an array of marks, or null to indicate some of the styles
+    // had a rule with `ignore` set.
+    readStyles(styles) {
+      let add2 = Mark.none, remove = Mark.none;
+      if (styles.length)
         for (let i5 = 0; i5 < this.parser.matchedStyles.length; i5++) {
           let name = this.parser.matchedStyles[i5], value = styles.getPropertyValue(name);
           if (value)
@@ -140135,46 +140152,47 @@
                 break;
               if (rule.ignore)
                 return null;
-              if (rule.clearMark)
-                marks = marks.filter((m4) => !rule.clearMark(m4));
-              else
-                marks = marks.concat(this.parser.schema.marks[rule.mark].create(rule.attrs));
+              if (rule.clearMark) {
+                this.top.pendingMarks.concat(this.top.activeMarks).forEach((m4) => {
+                  if (rule.clearMark(m4))
+                    remove = m4.addToSet(remove);
+                });
+              } else {
+                add2 = this.parser.schema.marks[rule.mark].create(rule.attrs).addToSet(add2);
+              }
               if (rule.consuming === false)
                 after = rule;
               else
                 break;
             }
         }
-      return marks;
+      return [add2, remove];
     }
     // Look up a handler for the given node. If none are found, return
     // false. Otherwise, apply it, use its return value to drive the way
     // the node's content is wrapped, and return true.
-    addElementByRule(dom, rule, marks, continueAfter) {
-      let sync, nodeType;
+    addElementByRule(dom, rule, continueAfter) {
+      let sync, nodeType, mark;
       if (rule.node) {
         nodeType = this.parser.schema.nodes[rule.node];
         if (!nodeType.isLeaf) {
-          let inner = this.enter(nodeType, rule.attrs || null, marks, rule.preserveWhitespace);
-          if (inner) {
-            sync = true;
-            marks = inner;
-          }
-        } else if (!this.insertNode(nodeType.create(rule.attrs), marks)) {
-          this.leafFallback(dom, marks);
+          sync = this.enter(nodeType, rule.attrs || null, rule.preserveWhitespace);
+        } else if (!this.insertNode(nodeType.create(rule.attrs))) {
+          this.leafFallback(dom);
         }
       } else {
         let markType = this.parser.schema.marks[rule.mark];
-        marks = marks.concat(markType.create(rule.attrs));
+        mark = markType.create(rule.attrs);
+        this.addPendingMark(mark);
       }
       let startIn = this.top;
       if (nodeType && nodeType.isLeaf) {
         this.findInside(dom);
       } else if (continueAfter) {
-        this.addElement(dom, marks, continueAfter);
+        this.addElement(dom, continueAfter);
       } else if (rule.getContent) {
         this.findInside(dom);
-        rule.getContent(dom, this.parser.schema).forEach((node) => this.insertNode(node, marks));
+        rule.getContent(dom, this.parser.schema).forEach((node) => this.insertNode(node));
       } else {
         let contentDOM = dom;
         if (typeof rule.contentElement == "string")
@@ -140184,27 +140202,28 @@
         else if (rule.contentElement)
           contentDOM = rule.contentElement;
         this.findAround(dom, contentDOM, true);
-        this.addAll(contentDOM, marks);
-        this.findAround(dom, contentDOM, false);
+        this.addAll(contentDOM);
       }
       if (sync && this.sync(startIn))
         this.open--;
+      if (mark)
+        this.removePendingMark(mark, startIn);
     }
     // Add all child nodes between `startIndex` and `endIndex` (or the
     // whole node, if not given). If `sync` is passed, use it to
     // synchronize after every block element.
-    addAll(parent, marks, startIndex, endIndex) {
+    addAll(parent, startIndex, endIndex) {
       let index3 = startIndex || 0;
       for (let dom = startIndex ? parent.childNodes[startIndex] : parent.firstChild, end2 = endIndex == null ? null : parent.childNodes[endIndex]; dom != end2; dom = dom.nextSibling, ++index3) {
         this.findAtPoint(parent, index3);
-        this.addDOM(dom, marks);
+        this.addDOM(dom);
       }
       this.findAtPoint(parent, index3);
     }
     // Try to find a way to fit the given node type into the current
     // context. May add intermediate wrappers and/or leave non-solid
     // nodes that we're in.
-    findPlace(node, marks) {
+    findPlace(node) {
       let route, sync;
       for (let depth = this.open; depth >= 0; depth--) {
         let cx = this.nodes[depth];
@@ -140219,61 +140238,53 @@
           break;
       }
       if (!route)
-        return null;
+        return false;
       this.sync(sync);
       for (let i5 = 0; i5 < route.length; i5++)
-        marks = this.enterInner(route[i5], null, marks, false);
-      return marks;
+        this.enterInner(route[i5], null, false);
+      return true;
     }
     // Try to insert the given node, adjusting the context when needed.
-    insertNode(node, marks) {
+    insertNode(node) {
       if (node.isInline && this.needsBlock && !this.top.type) {
         let block = this.textblockFromContext();
         if (block)
-          marks = this.enterInner(block, null, marks);
+          this.enterInner(block);
       }
-      let innerMarks = this.findPlace(node, marks);
-      if (innerMarks) {
+      if (this.findPlace(node)) {
         this.closeExtra();
         let top2 = this.top;
+        top2.applyPending(node.type);
         if (top2.match)
           top2.match = top2.match.matchType(node.type);
-        let nodeMarks = Mark.none;
-        for (let m4 of innerMarks.concat(node.marks))
-          if (top2.type ? top2.type.allowsMarkType(m4.type) : markMayApply(m4.type, node.type))
-            nodeMarks = m4.addToSet(nodeMarks);
-        top2.content.push(node.mark(nodeMarks));
+        let marks = top2.activeMarks;
+        for (let i5 = 0; i5 < node.marks.length; i5++)
+          if (!top2.type || top2.type.allowsMarkType(node.marks[i5].type))
+            marks = node.marks[i5].addToSet(marks);
+        top2.content.push(node.mark(marks));
         return true;
       }
       return false;
     }
     // Try to start a node of the given type, adjusting the context when
     // necessary.
-    enter(type, attrs, marks, preserveWS) {
-      let innerMarks = this.findPlace(type.create(attrs), marks);
-      if (innerMarks)
-        innerMarks = this.enterInner(type, attrs, marks, true, preserveWS);
-      return innerMarks;
+    enter(type, attrs, preserveWS) {
+      let ok = this.findPlace(type.create(attrs));
+      if (ok)
+        this.enterInner(type, attrs, true, preserveWS);
+      return ok;
     }
     // Open a node of the given type
-    enterInner(type, attrs, marks, solid = false, preserveWS) {
+    enterInner(type, attrs = null, solid = false, preserveWS) {
       this.closeExtra();
       let top2 = this.top;
+      top2.applyPending(type);
       top2.match = top2.match && top2.match.matchType(type);
       let options = wsOptionsFor(type, preserveWS, top2.options);
       if (top2.options & OPT_OPEN_LEFT && top2.content.length == 0)
         options |= OPT_OPEN_LEFT;
-      let applyMarks = Mark.none;
-      marks = marks.filter((m4) => {
-        if (top2.type ? top2.type.allowsMarkType(m4.type) : markMayApply(m4.type, type)) {
-          applyMarks = m4.addToSet(applyMarks);
-          return false;
-        }
-        return true;
-      });
-      this.nodes.push(new NodeContext(type, attrs, applyMarks, solid, null, options));
+      this.nodes.push(new NodeContext(type, attrs, top2.activeMarks, top2.pendingMarks, solid, null, options));
       this.open++;
-      return marks;
     }
     // Make sure all nodes above this.open are finished and added to
     // their parents
@@ -140288,17 +140299,14 @@
     finish() {
       this.open = 0;
       this.closeExtra(this.isOpen);
-      return this.nodes[0].finish(!!(this.isOpen || this.options.topOpen));
+      return this.nodes[0].finish(this.isOpen || this.options.topOpen);
     }
     sync(to2) {
-      for (let i5 = this.open; i5 >= 0; i5--) {
+      for (let i5 = this.open; i5 >= 0; i5--)
         if (this.nodes[i5] == to2) {
           this.open = i5;
           return true;
-        } else if (this.localPreserveWS) {
-          this.nodes[i5].options |= OPT_PRESERVE_WS;
         }
-      }
       return false;
     }
     get currentPos() {
@@ -140364,7 +140372,7 @@
             return false;
           } else {
             let next = depth > 0 || depth == 0 && useRoot ? this.nodes[depth].type : option2 && depth >= minDepth ? option2.node(depth - minDepth).type : null;
-            if (!next || next.name != part && !next.isInGroup(part))
+            if (!next || next.name != part && next.groups.indexOf(part) == -1)
               return false;
             depth--;
           }
@@ -140387,6 +140395,28 @@
           return type;
       }
     }
+    addPendingMark(mark) {
+      let found2 = findSameMarkInSet(mark, this.top.pendingMarks);
+      if (found2)
+        this.top.stashMarks.push(found2);
+      this.top.pendingMarks = mark.addToSet(this.top.pendingMarks);
+    }
+    removePendingMark(mark, upto) {
+      for (let depth = this.open; depth >= 0; depth--) {
+        let level = this.nodes[depth];
+        let found2 = level.pendingMarks.lastIndexOf(mark);
+        if (found2 > -1) {
+          level.pendingMarks = mark.removeFromSet(level.pendingMarks);
+        } else {
+          level.activeMarks = mark.removeFromSet(level.activeMarks);
+          let stashMark = level.popFromStashMark(mark);
+          if (stashMark && level.type && level.type.allowsMarkType(stashMark.type))
+            level.activeMarks = stashMark.addToSet(level.activeMarks);
+        }
+        if (level == upto)
+          break;
+      }
+    }
   };
   function normalizeList(dom) {
     for (let child = dom.firstChild, prevItem = null; child; child = child.nextSibling) {
@@ -140430,6 +140460,12 @@
         return true;
     }
   }
+  function findSameMarkInSet(mark, set2) {
+    for (let i5 = 0; i5 < set2.length; i5++) {
+      if (mark.eq(set2[i5]))
+        return set2[i5];
+    }
+  }
   var DOMSerializer = class _DOMSerializer {
     /**
     Create a serializer. `nodes` should map node names to functions