@limetech/lime-elements 37.56.0 → 37.56.1

package/dist/cjs/limel-prosemirror-adapter.cjs.entry.js

@@ -1029,7 +1029,7 @@ class Fragment {
     /**
     Find the index and inner offset corresponding to a given relative
     position in this fragment. The result object will be reused
-    (overwritten) the next time the function is called. (Not public.)
+    (overwritten) the next time the function is called. @internal
     */
     findIndex(pos, round = -1) {
         if (pos == 0)
@@ -1262,7 +1262,9 @@ class Mark {
         let type = schema.marks[json.type];
         if (!type)
             throw new RangeError(`There is no mark type ${json.type} in this schema`);
-        return type.create(json.attrs);
+        let mark = type.create(json.attrs);
+        type.checkAttrs(mark.attrs);
+        return mark;
     }
     /**
     Test whether two sets of marks are identical.
@@ -1820,17 +1822,29 @@ class ResolvedPos {
     @internal
     */
     static resolveCached(doc, pos) {
-        for (let i = 0; i < resolveCache.length; i++) {
-            let cached = resolveCache[i];
-            if (cached.pos == pos && cached.doc == doc)
-                return cached;
+        let cache = resolveCache.get(doc);
+        if (cache) {
+            for (let i = 0; i < cache.elts.length; i++) {
+                let elt = cache.elts[i];
+                if (elt.pos == pos)
+                    return elt;
+            }
+        }
+        else {
+            resolveCache.set(doc, cache = new ResolveCache);
         }
-        let result = resolveCache[resolveCachePos] = ResolvedPos.resolve(doc, pos);
-        resolveCachePos = (resolveCachePos + 1) % resolveCacheSize;
+        let result = cache.elts[cache.i] = ResolvedPos.resolve(doc, pos);
+        cache.i = (cache.i + 1) % resolveCacheSize;
         return result;
     }
 }
-let resolveCache = [], resolveCachePos = 0, resolveCacheSize = 12;
+class ResolveCache {
+    constructor() {
+        this.elts = [];
+        this.i = 0;
+    }
+}
+const resolveCacheSize = 12, resolveCache = new WeakMap();
 /**
 Represents a flat range of content, i.e. one that starts and
 ends in the same node.
@@ -2230,13 +2244,17 @@ class Node$1 {
     }
     /**
     Check whether this node and its descendants conform to the
-    schema, and raise error when they do not.
+    schema, and raise an exception when they do not.
     */
     check() {
         this.type.checkContent(this.content);
+        this.type.checkAttrs(this.attrs);
         let copy = Mark.none;
-        for (let i = 0; i < this.marks.length; i++)
-            copy = this.marks[i].addToSet(copy);
+        for (let i = 0; i < this.marks.length; i++) {
+            let mark = this.marks[i];
+            mark.type.checkAttrs(mark.attrs);
+            copy = mark.addToSet(copy);
+        }
         if (!Mark.sameSet(copy, this.marks))
             throw new RangeError(`Invalid collection of marks for node ${this.type.name}: ${this.marks.map(m => m.type.name)}`);
         this.content.forEach(node => node.check());
@@ -2262,7 +2280,7 @@ class Node$1 {
     static fromJSON(schema, json) {
         if (!json)
             throw new RangeError("Invalid input for Node.fromJSON");
-        let marks = null;
+        let marks = undefined;
         if (json.marks) {
             if (!Array.isArray(json.marks))
                 throw new RangeError("Invalid mark data for Node.fromJSON");
@@ -2274,7 +2292,9 @@ class Node$1 {
             return schema.text(json.text, marks);
         }
         let content = Fragment.fromJSON(schema, json.content);
-        return schema.nodeType(json.type).create(json.attrs, content, marks);
+        let node = schema.nodeType(json.type).create(json.attrs, content, marks);
+        node.type.checkAttrs(node.attrs);
+        return node;
     }
 }
 Node$1.prototype.text = undefined;
@@ -2791,11 +2811,21 @@ function computeAttrs(attrs, value) {
     }
     return built;
 }
-function initAttrs(attrs) {
+function checkAttrs(attrs, values, type, name) {
+    for (let name in values)
+        if (!(name in attrs))
+            throw new RangeError(`Unsupported attribute ${name} for ${type} of type ${name}`);
+    for (let name in attrs) {
+        let attr = attrs[name];
+        if (attr.validate)
+            attr.validate(values[name]);
+    }
+}
+function initAttrs(typeName, attrs) {
     let result = Object.create(null);
     if (attrs)
         for (let name in attrs)
-            result[name] = new Attribute(attrs[name]);
+            result[name] = new Attribute(typeName, name, attrs[name]);
     return result;
 }
 /**
@@ -2830,7 +2860,7 @@ class NodeType$1 {
         */
         this.markSet = null;
         this.groups = spec.group ? spec.group.split(" ") : [];
-        this.attrs = initAttrs(spec.attrs);
+        this.attrs = initAttrs(name, spec.attrs);
         this.defaultAttrs = defaultAttrs(this.attrs);
         this.contentMatch = null;
         this.inlineContent = null;
@@ -2934,7 +2964,7 @@ class NodeType$1 {
     }
     /**
     Returns true if the given fragment is valid content for this node
-    type with the given attributes.
+    type.
     */
     validContent(content) {
         let result = this.contentMatch.matchFragment(content);
@@ -2955,6 +2985,12 @@ class NodeType$1 {
             throw new RangeError(`Invalid content for node ${this.name}: ${content.toString().slice(0, 50)}`);
     }
     /**
+    @internal
+    */
+    checkAttrs(attrs) {
+        checkAttrs(this.attrs, attrs, "node");
+    }
+    /**
     Check whether the given mark type is allowed in this node.
     */
     allowsMarkType(markType) {
@@ -3005,11 +3041,20 @@ class NodeType$1 {
         return result;
     }
 }
+function validateType(typeName, attrName, type) {
+    let types = type.split("|");
+    return (value) => {
+        let name = value === null ? "null" : typeof value;
+        if (types.indexOf(name) < 0)
+            throw new RangeError(`Expected value of type ${types} for attribute ${attrName} on type ${typeName}, got ${name}`);
+    };
+}
 // Attribute descriptors
 class Attribute {
-    constructor(options) {
+    constructor(typeName, attrName, options) {
         this.hasDefault = Object.prototype.hasOwnProperty.call(options, "default");
         this.default = options.default;
+        this.validate = typeof options.validate == "string" ? validateType(typeName, attrName, options.validate) : options.validate;
     }
     get isRequired() {
         return !this.hasDefault;
@@ -3047,7 +3092,7 @@ class MarkType {
         this.rank = rank;
         this.schema = schema;
         this.spec = spec;
-        this.attrs = initAttrs(spec.attrs);
+        this.attrs = initAttrs(name, spec.attrs);
         this.excluded = null;
         let defaults = defaultAttrs(this.attrs);
         this.instance = defaults ? new Mark(this, defaults) : null;
@@ -3091,6 +3136,12 @@ class MarkType {
                 return set[i];
     }
     /**
+    @internal
+    */
+    checkAttrs(attrs) {
+        checkAttrs(this.attrs, attrs, "mark");
+    }
+    /**
     Queries whether a given mark type is
     [excluded](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) by this one.
     */
@@ -3112,6 +3163,12 @@ class Schema {
     Construct a schema from a schema [specification](https://prosemirror.net/docs/ref/#model.SchemaSpec).
     */
     constructor(spec) {
+        /**
+        The [linebreak
+        replacement](https://prosemirror.net/docs/ref/#model.NodeSpec.linebreakReplacement) node defined
+        in this schema, if any.
+        */
+        this.linebreakReplacement = null;
         /**
         An object for storing whatever values modules may want to
         compute and cache per schema. (If you want to store something
@@ -3133,6 +3190,13 @@ class Schema {
             type.contentMatch = contentExprCache[contentExpr] ||
                 (contentExprCache[contentExpr] = ContentMatch.parse(contentExpr, this.nodes));
             type.inlineContent = type.contentMatch.inlineContent;
+            if (type.spec.linebreakReplacement) {
+                if (this.linebreakReplacement)
+                    throw new RangeError("Multiple linebreak nodes defined");
+                if (!type.isInline || !type.isLeaf)
+                    throw new RangeError("Linebreak replacement nodes must be inline leaf nodes");
+                this.linebreakReplacement = type;
+            }
             type.markSet = markExpr == "_" ? null :
                 markExpr ? gatherMarks(this, markExpr.split(" ")) :
                     markExpr == "" || !type.inlineContent ? [] : null;
@@ -3221,6 +3285,8 @@ function gatherMarks(schema, marks) {
     return found;
 }
 
+function isTagRule(rule) { return rule.tag != null; }
+function isStyleRule(rule) { return rule.style != null; }
 /**
 A DOM parser represents a strategy for parsing DOM content into a
 ProseMirror document conforming to a given schema. Its behavior is
@@ -3251,11 +3317,17 @@ class DOMParser {
         @internal
         */
         this.styles = [];
+        let matchedStyles = this.matchedStyles = [];
         rules.forEach(rule => {
-            if (rule.tag)
+            if (isTagRule(rule)) {
                 this.tags.push(rule);
-            else if (rule.style)
+            }
+            else if (isStyleRule(rule)) {
+                let prop = /[^=]*/.exec(rule.style)[0];
+                if (matchedStyles.indexOf(prop) < 0)
+                    matchedStyles.push(prop);
                 this.styles.push(rule);
+            }
         });
         // Only normalize list elements when lists in the schema can't directly contain themselves
         this.normalizeLists = !this.tags.some(r => {
@@ -3270,7 +3342,7 @@ class DOMParser {
     */
     parse(dom, options = {}) {
         let context = new ParseContext(this, options, false);
-        context.addAll(dom, options.from, options.to);
+        context.addAll(dom, Mark.none, options.from, options.to);
         return context.finish();
     }
     /**
@@ -3283,7 +3355,7 @@ class DOMParser {
     */
     parseSlice(dom, options = {}) {
         let context = new ParseContext(this, options, true);
-        context.addAll(dom, options.from, options.to);
+        context.addAll(dom, Mark.none, options.from, options.to);
         return Slice.maxOpen(context.finish());
     }
     /**
@@ -3392,22 +3464,15 @@ function wsOptionsFor(type, preserveWhitespace, base) {
     return type && type.whitespace == "pre" ? OPT_PRESERVE_WS | OPT_PRESERVE_WS_FULL : base & ~OPT_OPEN_LEFT;
 }
 class NodeContext {
-    constructor(type, attrs, 
-    // Marks applied to this node itself
-    marks, 
-    // Marks that can't apply here, but will be used in children if possible
-    pendingMarks, solid, match, options) {
+    constructor(type, attrs, marks, solid, match, options) {
         this.type = type;
         this.attrs = attrs;
         this.marks = marks;
-        this.pendingMarks = pendingMarks;
         this.solid = solid;
         this.options = options;
         this.content = [];
         // Marks applied to the node's children
         this.activeMarks = Mark.none;
-        // Nested Marks with same type
-        this.stashMarks = [];
         this.match = match || (options & OPT_OPEN_LEFT ? null : type.contentMatch);
     }
     findWrapping(node) {
@@ -3447,21 +3512,6 @@ class NodeContext {
             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 i = this.stashMarks.length - 1; i >= 0; i--)
-            if (mark.eq(this.stashMarks[i]))
-                return this.stashMarks.splice(i, 1)[0];
-    }
-    applyPending(nextType) {
-        for (let i = 0, pending = this.pendingMarks; i < pending.length; i++) {
-            let mark = pending[i];
-            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;
@@ -3483,11 +3533,11 @@ class ParseContext {
         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, Mark.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
+            topContext = new NodeContext(topNode.type, topNode.attrs, Mark.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
         else if (isOpen)
-            topContext = new NodeContext(null, null, Mark.none, Mark.none, true, null, topOptions);
+            topContext = new NodeContext(null, null, Mark.none, true, null, topOptions);
         else
-            topContext = new NodeContext(parser.schema.topNodeType, null, Mark.none, Mark.none, true, null, topOptions);
+            topContext = new NodeContext(parser.schema.topNodeType, null, Mark.none, true, null, topOptions);
         this.nodes = [topContext];
         this.find = options.findPositions;
         this.needsBlock = false;
@@ -3498,31 +3548,13 @@ class ParseContext {
     // 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) {
+    addDOM(dom, marks) {
         if (dom.nodeType == 3)
-            this.addTextNode(dom);
+            this.addTextNode(dom, marks);
         else if (dom.nodeType == 1)
-            this.addElement(dom);
-    }
-    withStyleRules(dom, f) {
-        let style = dom.getAttribute("style");
-        if (!style)
-            return f();
-        let marks = this.readStyles(parseStyles(style));
-        if (!marks)
-            return; // A style with ignore: true
-        let [addMarks, removeMarks] = marks, top = this.top;
-        for (let i = 0; i < removeMarks.length; i++)
-            this.removePendingMark(removeMarks[i], top);
-        for (let i = 0; i < addMarks.length; i++)
-            this.addPendingMark(addMarks[i]);
-        f();
-        for (let i = 0; i < addMarks.length; i++)
-            this.removePendingMark(addMarks[i], top);
-        for (let i = 0; i < removeMarks.length; i++)
-            this.addPendingMark(removeMarks[i]);
+            this.addElement(dom, marks);
     }
-    addTextNode(dom) {
+    addTextNode(dom, marks) {
         let value = dom.nodeValue;
         let top = this.top;
         if (top.options & OPT_PRESERVE_WS_FULL ||
@@ -3549,7 +3581,7 @@ class ParseContext {
                 value = value.replace(/\r\n?/g, "\n");
             }
             if (value)
-                this.insertNode(this.parser.schema.text(value));
+                this.insertNode(this.parser.schema.text(value), marks);
             this.findInText(dom);
         }
         else {
@@ -3558,7 +3590,7 @@ class ParseContext {
     }
     // 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, matchAfter) {
+    addElement(dom, marks, matchAfter) {
         let name = dom.nodeName.toLowerCase(), ruleID;
         if (listTags.hasOwnProperty(name) && this.parser.normalizeLists)
             normalizeList(dom);
@@ -3566,7 +3598,7 @@ class ParseContext {
             (ruleID = this.parser.matchTag(dom, this, matchAfter));
         if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
             this.findInside(dom);
-            this.ignoreFallback(dom);
+            this.ignoreFallback(dom, marks);
         }
         else if (!rule || rule.skip || rule.closeParent) {
             if (rule && rule.closeParent)
@@ -3584,92 +3616,97 @@ class ParseContext {
                     this.needsBlock = true;
             }
             else if (!dom.firstChild) {
-                this.leafFallback(dom);
+                this.leafFallback(dom, marks);
                 return;
             }
-            if (rule && rule.skip)
-                this.addAll(dom);
-            else
-                this.withStyleRules(dom, () => this.addAll(dom));
+            let innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
+            if (innerMarks)
+                this.addAll(dom, innerMarks);
             if (sync)
                 this.sync(top);
             this.needsBlock = oldNeedsBlock;
         }
         else {
-            this.withStyleRules(dom, () => {
-                this.addElementByRule(dom, rule, rule.consuming === false ? ruleID : undefined);
-            });
+            let innerMarks = this.readStyles(dom, marks);
+            if (innerMarks)
+                this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID : undefined);
         }
     }
     // Called for leaf DOM nodes that would otherwise be ignored
-    leafFallback(dom) {
+    leafFallback(dom, marks) {
         if (dom.nodeName == "BR" && this.top.type && this.top.type.inlineContent)
-            this.addTextNode(dom.ownerDocument.createTextNode("\n"));
+            this.addTextNode(dom.ownerDocument.createTextNode("\n"), marks);
     }
     // Called for ignored nodes
-    ignoreFallback(dom) {
+    ignoreFallback(dom, marks) {
         // Ignored BR nodes should at least create an inline context
         if (dom.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent))
-            this.findPlace(this.parser.schema.text("-"));
+            this.findPlace(this.parser.schema.text("-"), marks);
     }
     // Run any style parser associated with the node's styles. Either
-    // return an array of marks, or null to indicate some of the styles
-    // had a rule with `ignore` set.
-    readStyles(styles) {
-        let add = Mark.none, remove = Mark.none;
-        for (let i = 0; i < styles.length; i += 2) {
-            for (let after = undefined;;) {
-                let rule = this.parser.matchStyle(styles[i], styles[i + 1], this, after);
-                if (!rule)
-                    break;
-                if (rule.ignore)
-                    return null;
-                if (rule.clearMark) {
-                    this.top.pendingMarks.concat(this.top.activeMarks).forEach(m => {
-                        if (rule.clearMark(m))
-                            remove = m.addToSet(remove);
-                    });
-                }
-                else {
-                    add = this.parser.schema.marks[rule.mark].create(rule.attrs).addToSet(add);
-                }
-                if (rule.consuming === false)
-                    after = rule;
-                else
-                    break;
+    // 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;
+        // Because many properties will only show up in 'normalized' form
+        // in `style.item` (i.e. text-decoration becomes
+        // text-decoration-line, text-decoration-color, etc), we directly
+        // query the styles mentioned in our rules instead of iterating
+        // over the items.
+        if (styles && styles.length)
+            for (let i = 0; i < this.parser.matchedStyles.length; i++) {
+                let name = this.parser.matchedStyles[i], value = styles.getPropertyValue(name);
+                if (value)
+                    for (let after = undefined;;) {
+                        let rule = this.parser.matchStyle(name, value, this, after);
+                        if (!rule)
+                            break;
+                        if (rule.ignore)
+                            return null;
+                        if (rule.clearMark)
+                            marks = marks.filter(m => !rule.clearMark(m));
+                        else
+                            marks = marks.concat(this.parser.schema.marks[rule.mark].create(rule.attrs));
+                        if (rule.consuming === false)
+                            after = rule;
+                        else
+                            break;
+                    }
             }
-        }
-        return [add, remove];
+        return marks;
     }
     // 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, continueAfter) {
-        let sync, nodeType, mark;
+    addElementByRule(dom, rule, marks, continueAfter) {
+        let sync, nodeType;
         if (rule.node) {
             nodeType = this.parser.schema.nodes[rule.node];
             if (!nodeType.isLeaf) {
-                sync = this.enter(nodeType, rule.attrs || null, rule.preserveWhitespace);
+                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))) {
-                this.leafFallback(dom);
+            else if (!this.insertNode(nodeType.create(rule.attrs), marks)) {
+                this.leafFallback(dom, marks);
             }
         }
         else {
             let markType = this.parser.schema.marks[rule.mark];
-            mark = markType.create(rule.attrs);
-            this.addPendingMark(mark);
+            marks = marks.concat(markType.create(rule.attrs));
         }
         let startIn = this.top;
         if (nodeType && nodeType.isLeaf) {
             this.findInside(dom);
         }
         else if (continueAfter) {
-            this.addElement(dom, continueAfter);
+            this.addElement(dom, marks, continueAfter);
         }
         else if (rule.getContent) {
             this.findInside(dom);
-            rule.getContent(dom, this.parser.schema).forEach(node => this.insertNode(node));
+            rule.getContent(dom, this.parser.schema).forEach(node => this.insertNode(node, marks));
         }
         else {
             let contentDOM = dom;
@@ -3680,28 +3717,26 @@ class ParseContext {
             else if (rule.contentElement)
                 contentDOM = rule.contentElement;
             this.findAround(dom, contentDOM, true);
-            this.addAll(contentDOM);
+            this.addAll(contentDOM, marks);
         }
         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, startIndex, endIndex) {
+    addAll(parent, marks, startIndex, endIndex) {
         let index = startIndex || 0;
         for (let dom = startIndex ? parent.childNodes[startIndex] : parent.firstChild, end = endIndex == null ? null : parent.childNodes[endIndex]; dom != end; dom = dom.nextSibling, ++index) {
             this.findAtPoint(parent, index);
-            this.addDOM(dom);
+            this.addDOM(dom, marks);
         }
         this.findAtPoint(parent, index);
     }
     // 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) {
+    findPlace(node, marks) {
         let route, sync;
         for (let depth = this.open; depth >= 0; depth--) {
             let cx = this.nodes[depth];
@@ -3716,53 +3751,61 @@ class ParseContext {
                 break;
         }
         if (!route)
-            return false;
+            return null;
         this.sync(sync);
         for (let i = 0; i < route.length; i++)
-            this.enterInner(route[i], null, false);
-        return true;
+            marks = this.enterInner(route[i], null, marks, false);
+        return marks;
     }
     // Try to insert the given node, adjusting the context when needed.
-    insertNode(node) {
+    insertNode(node, marks) {
         if (node.isInline && this.needsBlock && !this.top.type) {
             let block = this.textblockFromContext();
             if (block)
-                this.enterInner(block);
+                marks = this.enterInner(block, null, marks);
         }
-        if (this.findPlace(node)) {
+        let innerMarks = this.findPlace(node, marks);
+        if (innerMarks) {
             this.closeExtra();
             let top = this.top;
-            top.applyPending(node.type);
             if (top.match)
                 top.match = top.match.matchType(node.type);
-            let marks = top.activeMarks;
-            for (let i = 0; i < node.marks.length; i++)
-                if (!top.type || top.type.allowsMarkType(node.marks[i].type))
-                    marks = node.marks[i].addToSet(marks);
-            top.content.push(node.mark(marks));
+            let nodeMarks = Mark.none;
+            for (let m of innerMarks.concat(node.marks))
+                if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, node.type))
+                    nodeMarks = m.addToSet(nodeMarks);
+            top.content.push(node.mark(nodeMarks));
             return true;
         }
         return false;
     }
     // Try to start a node of the given type, adjusting the context when
     // necessary.
-    enter(type, attrs, preserveWS) {
-        let ok = this.findPlace(type.create(attrs));
-        if (ok)
-            this.enterInner(type, attrs, true, preserveWS);
-        return ok;
+    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;
     }
     // Open a node of the given type
-    enterInner(type, attrs = null, solid = false, preserveWS) {
+    enterInner(type, attrs, marks, solid = false, preserveWS) {
         this.closeExtra();
         let top = this.top;
-        top.applyPending(type);
         top.match = top.match && top.match.matchType(type);
         let options = wsOptionsFor(type, preserveWS, top.options);
         if ((top.options & OPT_OPEN_LEFT) && top.content.length == 0)
             options |= OPT_OPEN_LEFT;
-        this.nodes.push(new NodeContext(type, attrs, top.activeMarks, top.pendingMarks, solid, null, options));
+        let applyMarks = Mark.none;
+        marks = marks.filter(m => {
+            if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, type)) {
+                applyMarks = m.addToSet(applyMarks);
+                return false;
+            }
+            return true;
+        });
+        this.nodes.push(new NodeContext(type, attrs, applyMarks, solid, null, options));
         this.open++;
+        return marks;
     }
     // Make sure all nodes above this.open are finished and added to
     // their parents
@@ -3876,29 +3919,6 @@ class ParseContext {
                 return type;
         }
     }
-    addPendingMark(mark) {
-        let found = findSameMarkInSet(mark, this.top.pendingMarks);
-        if (found)
-            this.top.stashMarks.push(found);
-        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 found = level.pendingMarks.lastIndexOf(mark);
-            if (found > -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;
-        }
-    }
 }
 // Kludge to work around directly nested list nodes produced by some
 // tools and allowed by browsers to mean that the nested list is
@@ -3922,13 +3942,6 @@ function normalizeList(dom) {
 function matches(dom, selector) {
     return (dom.matches || dom.msMatchesSelector || dom.webkitMatchesSelector || dom.mozMatchesSelector).call(dom, selector);
 }
-// Tokenize a style attribute into property/value pairs.
-function parseStyles(style) {
-    let re = /\s*([\w-]+)\s*:\s*([^;]+)/g, m, result = [];
-    while (m = re.exec(style))
-        result.push(m[1], m[2].trim());
-    return result;
-}
 function copy(obj) {
     let copy = {};
     for (let prop in obj)
@@ -3958,12 +3971,6 @@ function markMayApply(markType, nodeType) {
             return true;
     }
 }
-function findSameMarkInSet(mark, set) {
-    for (let i = 0; i < set.length; i++) {
-        if (mark.eq(set[i]))
-            return set[i];
-    }
-}
 
 /**
 A DOM serializer knows how to convert ProseMirror nodes and
@@ -4035,7 +4042,7 @@ class DOMSerializer {
     @internal
     */
     serializeNodeInner(node, options) {
-        let { dom, contentDOM } = DOMSerializer.renderSpec(doc$1(options), this.nodes[node.type.name](node));
+        let { dom, contentDOM } = renderSpec(doc$1(options), this.nodes[node.type.name](node), null, node.attrs);
         if (contentDOM) {
             if (node.isLeaf)
                 throw new RangeError("Content hole not allowed in a leaf node spec");
@@ -4066,57 +4073,10 @@ class DOMSerializer {
     */
     serializeMark(mark, inline, options = {}) {
         let toDOM = this.marks[mark.type.name];
-        return toDOM && DOMSerializer.renderSpec(doc$1(options), toDOM(mark, inline));
-    }
-    /**
-    Render an [output spec](https://prosemirror.net/docs/ref/#model.DOMOutputSpec) to a DOM node. If
-    the spec has a hole (zero) in it, `contentDOM` will point at the
-    node with the hole.
-    */
-    static renderSpec(doc, structure, xmlNS = null) {
-        if (typeof structure == "string")
-            return { dom: doc.createTextNode(structure) };
-        if (structure.nodeType != null)
-            return { dom: structure };
-        if (structure.dom && structure.dom.nodeType != null)
-            return structure;
-        let tagName = structure[0], space = tagName.indexOf(" ");
-        if (space > 0) {
-            xmlNS = tagName.slice(0, space);
-            tagName = tagName.slice(space + 1);
-        }
-        let contentDOM;
-        let dom = (xmlNS ? doc.createElementNS(xmlNS, tagName) : doc.createElement(tagName));
-        let attrs = structure[1], start = 1;
-        if (attrs && typeof attrs == "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
-            start = 2;
-            for (let name in attrs)
-                if (attrs[name] != null) {
-                    let space = name.indexOf(" ");
-                    if (space > 0)
-                        dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
-                    else
-                        dom.setAttribute(name, attrs[name]);
-                }
-        }
-        for (let i = start; i < structure.length; i++) {
-            let child = structure[i];
-            if (child === 0) {
-                if (i < structure.length - 1 || i > start)
-                    throw new RangeError("Content hole must be the only child of its parent node");
-                return { dom, contentDOM: dom };
-            }
-            else {
-                let { dom: inner, contentDOM: innerContent } = DOMSerializer.renderSpec(doc, child, xmlNS);
-                dom.appendChild(inner);
-                if (innerContent) {
-                    if (contentDOM)
-                        throw new RangeError("Multiple content holes");
-                    contentDOM = innerContent;
-                }
-            }
-        }
-        return { dom, contentDOM };
+        return toDOM && renderSpec(doc$1(options), toDOM(mark, inline), null, mark.attrs);
+    }
+    static renderSpec(doc, structure, xmlNS = null, blockArraysIn) {
+        return renderSpec(doc, structure, xmlNS, blockArraysIn);
     }
     /**
     Build a serializer using the [`toDOM`](https://prosemirror.net/docs/ref/#model.NodeSpec.toDOM)
@@ -4155,6 +4115,88 @@ function gatherToDOM(obj) {
 function doc$1(options) {
     return options.document || window.document;
 }
+const suspiciousAttributeCache = new WeakMap();
+function suspiciousAttributes(attrs) {
+    let value = suspiciousAttributeCache.get(attrs);
+    if (value === undefined)
+        suspiciousAttributeCache.set(attrs, value = suspiciousAttributesInner(attrs));
+    return value;
+}
+function suspiciousAttributesInner(attrs) {
+    let result = null;
+    function scan(value) {
+        if (value && typeof value == "object") {
+            if (Array.isArray(value)) {
+                if (typeof value[0] == "string") {
+                    if (!result)
+                        result = [];
+                    result.push(value);
+                }
+                else {
+                    for (let i = 0; i < value.length; i++)
+                        scan(value[i]);
+                }
+            }
+            else {
+                for (let prop in value)
+                    scan(value[prop]);
+            }
+        }
+    }
+    scan(attrs);
+    return result;
+}
+function renderSpec(doc, structure, xmlNS, blockArraysIn) {
+    if (typeof structure == "string")
+        return { dom: doc.createTextNode(structure) };
+    if (structure.nodeType != null)
+        return { dom: structure };
+    if (structure.dom && structure.dom.nodeType != null)
+        return structure;
+    let tagName = structure[0], suspicious;
+    if (typeof tagName != "string")
+        throw new RangeError("Invalid array passed to renderSpec");
+    if (blockArraysIn && (suspicious = suspiciousAttributes(blockArraysIn)) &&
+        suspicious.indexOf(structure) > -1)
+        throw new RangeError("Using an array from an attribute object as a DOM spec. This may be an attempted cross site scripting attack.");
+    let space = tagName.indexOf(" ");
+    if (space > 0) {
+        xmlNS = tagName.slice(0, space);
+        tagName = tagName.slice(space + 1);
+    }
+    let contentDOM;
+    let dom = (xmlNS ? doc.createElementNS(xmlNS, tagName) : doc.createElement(tagName));
+    let attrs = structure[1], start = 1;
+    if (attrs && typeof attrs == "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
+        start = 2;
+        for (let name in attrs)
+            if (attrs[name] != null) {
+                let space = name.indexOf(" ");
+                if (space > 0)
+                    dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
+                else
+                    dom.setAttribute(name, attrs[name]);
+            }
+    }
+    for (let i = start; i < structure.length; i++) {
+        let child = structure[i];
+        if (child === 0) {
+            if (i < structure.length - 1 || i > start)
+                throw new RangeError("Content hole must be the only child of its parent node");
+            return { dom, contentDOM: dom };
+        }
+        else {
+            let { dom: inner, contentDOM: innerContent } = renderSpec(doc, child, xmlNS, blockArraysIn);
+            dom.appendChild(inner);
+            if (innerContent) {
+                if (contentDOM)
+                    throw new RangeError("Multiple content holes");
+                contentDOM = innerContent;
+            }
+        }
+    }
+    return { dom, contentDOM };
+}
 
 // Recovery values encode a range index and an offset. They are
 // represented as numbers, because tons of them will be created when
@@ -24875,9 +24917,9 @@ const schema = new Schema({
         strong: {
             parseDOM: [
                 { tag: "strong" },
-                { tag: "b", getAttrs: (node) => node.style.fontWeight != "normal" && null },
+                { tag: "b", getAttrs: node => node.style.fontWeight != "normal" && null },
                 { style: "font-weight=400", clearMark: m => m.type.name == "strong" },
-                { style: "font-weight", getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null }
+                { style: "font-weight", getAttrs: value => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null }
             ],
             toDOM() { return ["strong"]; }
         },
@@ -25131,6 +25173,7 @@ new MarkdownParser(schema, MarkdownIt("commonmark", { html: false }), {
     code_inline: { mark: "code", noCloseToken: true }
 });
 
+const blankMark = { open: "", close: "", mixable: true };
 /**
 A specification for serializing a ProseMirror document as
 Markdown/CommonMark text.
@@ -25338,6 +25381,18 @@ class MarkdownSerializerState {
         }
     }
     /**
+    @internal
+    */
+    getMark(name) {
+        let info = this.marks[name];
+        if (!info) {
+            if (this.options.strict !== false)
+                throw new Error(`Mark type \`${name}\` not supported by Markdown renderer`);
+            info = blankMark;
+        }
+        return info;
+    }
+    /**
     Render a block, prefixing each line with `delim`, and the first
     line in `firstDelim`. `node` should be the node that is closed at
     the end of the block, and `f` is a function that renders the
@@ -25402,9 +25457,22 @@ class MarkdownSerializerState {
     Render the given node as a block.
     */
     render(node, parent, index) {
-        if (!this.nodes[node.type.name])
-            throw new Error("Token type `" + node.type.name + "` not supported by Markdown renderer");
-        this.nodes[node.type.name](this, node, parent, index);
+        if (this.nodes[node.type.name]) {
+            this.nodes[node.type.name](this, node, parent, index);
+        }
+        else {
+            if (this.options.strict !== false) {
+                throw new Error("Token type `" + node.type.name + "` not supported by Markdown renderer");
+            }
+            else if (!node.type.isLeaf) {
+                if (node.type.inlineContent)
+                    this.renderInline(node);
+                else
+                    this.renderContent(node);
+                if (node.isBlock)
+                    this.closeBlock(node);
+            }
+        }
     }
     /**
     Render the contents of `parent` as block nodes.
@@ -25435,7 +25503,7 @@ class MarkdownSerializerState {
             // If whitespace has to be expelled from the node, adjust
             // leading and trailing accordingly.
             if (node && node.isText && marks.some(mark => {
-                let info = this.marks[mark.type.name];
+                let info = this.getMark(mark.type.name);
                 return info && info.expelEnclosingWhitespace && !mark.isInSet(active);
             })) {
                 let [_, lead, rest] = /^(\s*)(.*)$/m.exec(node.text);
@@ -25447,7 +25515,7 @@ class MarkdownSerializerState {
                 }
             }
             if (node && node.isText && marks.some(mark => {
-                let info = this.marks[mark.type.name];
+                let info = this.getMark(mark.type.name);
                 return info && info.expelEnclosingWhitespace &&
                     (index == parent.childCount - 1 || !mark.isInSet(parent.child(index + 1).marks));
             })) {
@@ -25460,7 +25528,7 @@ class MarkdownSerializerState {
                 }
             }
             let inner = marks.length ? marks[marks.length - 1] : null;
-            let noEsc = inner && this.marks[inner.type.name].escape === false;
+            let noEsc = inner && this.getMark(inner.type.name).escape === false;
             let len = marks.length - (noEsc ? 1 : 0);
             // Try to reorder 'mixable' marks, such as em and strong, which
             // in Markdown may be opened and closed in different order, so
@@ -25468,11 +25536,11 @@ class MarkdownSerializerState {
             // active.
             outer: for (let i = 0; i < len; i++) {
                 let mark = marks[i];
-                if (!this.marks[mark.type.name].mixable)
+                if (!this.getMark(mark.type.name).mixable)
                     break;
                 for (let j = 0; j < active.length; j++) {
                     let other = active[j];
-                    if (!this.marks[other.type.name].mixable)
+                    if (!this.getMark(other.type.name).mixable)
                         break;
                     if (mark.eq(other)) {
                         if (i > j)
@@ -25578,7 +25646,7 @@ class MarkdownSerializerState {
     Get the markdown string for a given opening or closing mark.
     */
     markString(mark, open, parent, index) {
-        let info = this.marks[mark.type.name];
+        let info = this.getMark(mark.type.name);
         let value = open ? info.open : info.close;
         return typeof value == "string" ? value : value(this, mark, parent, index);
     }