@progress/kendo-editor-common 1.10.3-dev.202309121208 → 1.10.3

package/dist/es/DOMSerializer.js

@@ -0,0 +1,188 @@
+import { setAttribute } from "./utils";
+var DOMSerializer = /** @class */ (function () {
+    /// Create a serializer. `nodes` should map node names to functions
+    /// that take a node and return a description of the corresponding
+    /// DOM. `marks` does the same for mark names, but also gets an
+    /// argument that tells it whether the mark's content is block or
+    /// inline content (for typical use, it'll always be inline). A mark
+    /// serializer may be `null` to indicate that marks of that type
+    /// should not be serialized.
+    function DOMSerializer(
+    /// The node serialization functions.
+    nodes, 
+    /// The mark serialization functions.
+    marks) {
+        this.nodes = nodes;
+        this.marks = marks;
+    }
+    /// Render an [output spec](#model.DOMOutputSpec) to a DOM node. If
+    /// the spec has a hole (zero) in it, `contentDOM` will point at the
+    /// node with the hole.
+    DOMSerializer.renderSpec = function (docum, structure, xmlNS) {
+        if (xmlNS === void 0) { xmlNS = null; }
+        if (typeof structure === "string") {
+            return { dom: docum.createTextNode(structure) };
+        }
+        if (structure.nodeType != null) {
+            return { dom: structure };
+        }
+        if (structure.dom && structure.dom.nodeType != null) {
+            return structure;
+        }
+        var tagName = structure[0], space = tagName.indexOf(" ");
+        if (space > 0) {
+            xmlNS = tagName.slice(0, space);
+            tagName = tagName.slice(space + 1);
+        }
+        var contentDOM;
+        var dom = (xmlNS ? docum.createElementNS(xmlNS, tagName) : docum.createElement(tagName));
+        var attrs = structure[1], start = 1;
+        if (attrs && typeof attrs === "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
+            start = 2;
+            for (var name_1 in attrs) {
+                if (attrs[name_1] != null) {
+                    space = name_1.indexOf(" ");
+                    if (space > 0) {
+                        dom.setAttributeNS(name_1.slice(0, space), name_1.slice(space + 1), attrs[name_1]);
+                    }
+                    else {
+                        setAttribute(dom, name_1, attrs[name_1]);
+                    }
+                }
+            }
+        }
+        for (var i = start; i < structure.length; i++) {
+            var 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: dom, contentDOM: dom };
+            }
+            else {
+                var _a = DOMSerializer.renderSpec(docum, child, xmlNS), inner = _a.dom, innerContent = _a.contentDOM;
+                dom.appendChild(inner);
+                if (innerContent) {
+                    if (contentDOM) {
+                        throw new RangeError("Multiple content holes");
+                    }
+                    contentDOM = innerContent;
+                }
+            }
+        }
+        return { dom: dom, contentDOM: contentDOM };
+    };
+    /// Build a serializer using the [`toDOM`](#model.NodeSpec.toDOM)
+    /// properties in a schema's node and mark specs.
+    DOMSerializer.fromSchema = function (schema) {
+        return schema.cached.domSerializer ||
+            (schema.cached.domSerializer = new DOMSerializer(this.nodesFromSchema(schema), this.marksFromSchema(schema)));
+    };
+    /// Gather the serializers in a schema's node specs into an object.
+    /// This can be useful as a base to build a custom serializer from.
+    DOMSerializer.nodesFromSchema = function (schema) {
+        var result = gatherToDOM(schema.nodes);
+        if (!result.text) {
+            result.text = function (node) { return node.text; };
+        }
+        return result;
+    };
+    /// Gather the serializers in a schema's mark specs into an object.
+    DOMSerializer.marksFromSchema = function (schema) {
+        return gatherToDOM(schema.marks);
+    };
+    /// Serialize the content of this fragment to a DOM fragment. When
+    /// not in the browser, the `document` option, containing a DOM
+    /// document, should be passed so that the serializer can create
+    /// nodes.
+    DOMSerializer.prototype.serializeFragment = function (fragment, options, target) {
+        var _this = this;
+        if (options === void 0) { options = {}; }
+        if (!target) {
+            target = doc(options).createDocumentFragment();
+        }
+        var top = target, active = [];
+        fragment.forEach(function (node) {
+            if (active.length || node.marks.length) {
+                var keep = 0, rendered = 0;
+                while (keep < active.length && rendered < node.marks.length) {
+                    var next = node.marks[rendered];
+                    if (!_this.marks[next.type.name]) {
+                        rendered++;
+                        continue;
+                    }
+                    if (!next.eq(active[keep][0]) || next.type.spec.spanning === false) {
+                        break;
+                    }
+                    keep++;
+                    rendered++;
+                }
+                while (keep < active.length) {
+                    top = active.pop()[1];
+                }
+                while (rendered < node.marks.length) {
+                    var add = node.marks[rendered++];
+                    var markDOM = _this.serializeMark(add, node.isInline, options);
+                    if (markDOM) {
+                        active.push([add, top]);
+                        top.appendChild(markDOM.dom);
+                        top = markDOM.contentDOM || markDOM.dom;
+                    }
+                }
+            }
+            top.appendChild(_this.serializeNodeInner(node, options));
+        });
+        return target;
+    };
+    /// Serialize this node to a DOM node. This can be useful when you
+    /// need to serialize a part of a document, as opposed to the whole
+    /// document. To serialize a whole document, use
+    /// [`serializeFragment`](#model.DOMSerializer.serializeFragment) on
+    /// its [content](#model.Node.content).
+    DOMSerializer.prototype.serializeNode = function (node, options) {
+        if (options === void 0) { options = {}; }
+        var dom = this.serializeNodeInner(node, options);
+        for (var i = node.marks.length - 1; i >= 0; i--) {
+            var wrap = this.serializeMark(node.marks[i], node.isInline, options);
+            if (wrap) {
+                (wrap.contentDOM || wrap.dom).appendChild(dom);
+                dom = wrap.dom;
+            }
+        }
+        return dom;
+    };
+    /// @internal
+    DOMSerializer.prototype.serializeMark = function (mark, inline, options) {
+        if (options === void 0) { options = {}; }
+        var toDOM = this.marks[mark.type.name];
+        return toDOM && DOMSerializer.renderSpec(doc(options), toDOM(mark, inline));
+    };
+    /// @internal
+    DOMSerializer.prototype.serializeNodeInner = function (node, options) {
+        var _a = DOMSerializer.renderSpec(doc(options), this.nodes[node.type.name](node)), dom = _a.dom, contentDOM = _a.contentDOM;
+        if (contentDOM) {
+            if (node.isLeaf) {
+                throw new RangeError("Content hole not allowed in a leaf node spec");
+            }
+            this.serializeFragment(node.content, options, contentDOM);
+        }
+        return dom;
+    };
+    return DOMSerializer;
+}());
+export { DOMSerializer };
+function gatherToDOM(obj) {
+    var result = {};
+    for (var name_2 in obj) {
+        if (obj[name_2]) {
+            var toDOM = obj[name_2].spec.toDOM;
+            if (toDOM) {
+                result[name_2] = toDOM;
+            }
+        }
+    }
+    return result;
+}
+function doc(options) {
+    return options.document || window.document;
+}

package/dist/es/main.js

@@ -21,6 +21,7 @@ export { convertMsLists } from './listConvert';
 export { find, findAt, findAll, replace, replaceAll } from './find-replace';
 export { placeholder } from './plugins/placeholder';
 export { spacesFix } from './plugins/spaces-fix';
+export { cspFix } from './plugins/csp-fix';
 export { textHighlight, textHighlightKey } from './plugins/highlight';
 export { imageResizing, imageResizeKey } from './plugins/image-resize';
 export { caretColor, caretColorKey } from './plugins/caret-color';

package/dist/es/plugins/csp-fix.js

@@ -0,0 +1,51 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import { setAttribute } from "../utils";
+var setAttributes = function (dom, attrs) {
+    for (var attrName in attrs) {
+        if (attrName) {
+            setAttribute(dom, attrName, attrs[attrName]);
+        }
+    }
+};
+var CustomNodeView = /** @class */ (function () {
+    function CustomNodeView(node, view, nodeName, isLeaf) {
+        if (isLeaf === void 0) { isLeaf = false; }
+        this.node = node;
+        this.view = view;
+        this.dom = document.createElement(nodeName);
+        setAttributes(this.dom, node.attrs);
+        this.contentDOM = !isLeaf ? this.dom : undefined;
+    }
+    return CustomNodeView;
+}());
+var StyleView = /** @class */ (function () {
+    function StyleView(mark, view, _inline) {
+        this.mark = mark;
+        this.view = view;
+        this.dom = document.createElement('span');
+        setAttributes(this.dom, mark.attrs);
+        this.contentDOM = this.dom;
+    }
+    return StyleView;
+}());
+export var cspFix = function () {
+    return new Plugin({
+        key: new PluginKey('csp-fix'),
+        props: {
+            nodeViews: {
+                paragraph: function (node, view) { return new CustomNodeView(node, view, 'p'); },
+                div: function (node, view) { return new CustomNodeView(node, view, 'div'); },
+                table_wrapper: function (node, view) { return new CustomNodeView(node, view, 'div'); },
+                table_caption_external: function (node, view) { return new CustomNodeView(node, view, 'div'); },
+                table: function (node, view) { return new CustomNodeView(node, view, 'table'); },
+                table_row: function (node, view) { return new CustomNodeView(node, view, 'tr'); },
+                table_cell: function (node, view) { return new CustomNodeView(node, view, 'td'); },
+                table_header: function (node, view) { return new CustomNodeView(node, view, 'th'); },
+                image: function (node, view) { return new CustomNodeView(node, view, 'img', true); }
+            },
+            markViews: {
+                style: function (mark, view, inline) { return new StyleView(mark, view, inline); }
+            }
+        }
+    });
+};

package/dist/es/plugins/table-resize/column-resize.js

@@ -4,7 +4,8 @@ import { TableMap } from 'prosemirror-tables';
 import { Decoration, DecorationSet } from 'prosemirror-view';
 import { colgroupAttr } from '../../config/constants';
 import { TableView, TableWrapperView } from './table-view';
-import { cellIndexes, domCellAround, otherResizeHandle, otherResizing, edgeCell, parseStyle, setNodeStyle, tableColumnResizeKey as key } from './utils';
+import { parseStyle } from './../../utils';
+import { cellIndexes, domCellAround, otherResizeHandle, otherResizing, edgeCell, setNodeStyle, tableColumnResizeKey as key } from './utils';
 export function columnResizing() {
     var handleWidth = 5, cellMinWidth = 25;
     var plugin = new Plugin({

package/dist/es/plugins/table-resize/row-resize.js

@@ -1,7 +1,8 @@
 import { Plugin } from 'prosemirror-state';
 import { TableMap, tableNodeTypes } from 'prosemirror-tables';
 import { Decoration, DecorationSet } from 'prosemirror-view';
-import { cellIndexes, domCellAround, otherResizeHandle, otherResizing, parseStyle, setNodeStyle, tableRowResizeKey as key, edgeCell } from './utils';
+import { cellIndexes, domCellAround, otherResizeHandle, otherResizing, setNodeStyle, tableRowResizeKey as key, edgeCell } from './utils';
+import { parseStyle } from './../../utils';
 var TableRowView = /** @class */ (function () {
     function TableRowView() {
     }

package/dist/es/plugins/table-resize/table-resize.js

@@ -1,7 +1,8 @@
 import { __assign } from "tslib";
 import { NodeSelection, Plugin } from 'prosemirror-state';
 import { colgroupAttr, dataResizeDirTable, resizableAttr } from '../../config/constants';
-import { getTable, parentNode, parseStyle, setNodeStyle, tableResizeKey as key } from './utils';
+import { getTable, parentNode, setNodeStyle, tableResizeKey as key } from './utils';
+import { parseStyle } from './../../utils';
 import { directions } from './../resize-utils';
 var commonDir = {
     'southeast': true,

package/dist/es/plugins/table-resize/table-view.js

@@ -1,7 +1,7 @@
 import { colgroupAttr, dataResizeDirTable, resizableAttr, resizableWrap, resizeHandle } from '../../config/constants';
 import { parseStrColgroup } from '../../config/schema';
 import { handles } from './../resize-utils';
-import { parseStyle } from './utils';
+import { parseStyle, setAttribute } from './../../utils';
 var TableView = /** @class */ (function () {
     function TableView(node, view) {
         this.node = node;
@@ -72,14 +72,7 @@ var TableView = /** @class */ (function () {
         var skip = [colgroupAttr, resizableAttr];
         for (var attrName in attrs) {
             if (attrName && skip.indexOf(attrName) === -1) {
-                var current = table.getAttribute(attrName);
-                var next = attrs[attrName];
-                if (next && next !== current) {
-                    table.setAttribute(attrName, next);
-                }
-                else if (!next) {
-                    table.removeAttribute(attrName);
-                }
+                setAttribute(table, attrName, attrs[attrName]);
             }
         }
         if (/%$/.test(table.style.width)) {
@@ -119,14 +112,7 @@ var TableWrapperView = /** @class */ (function () {
     TableWrapperView.prototype.setAttributes = function (dom, attrs) {
         for (var attrName in attrs) {
             if (attrName) {
-                var current = dom.getAttribute(attrName);
-                var next = attrs[attrName];
-                if (next && next !== current) {
-                    dom.setAttribute(attrName, next);
-                }
-                else if (!next) {
-                    dom.removeAttribute(attrName);
-                }
+                setAttribute(dom, attrName, attrs[attrName]);
             }
         }
         dom.setAttribute('table', '');

package/dist/es/plugins/table-resize/utils.js

@@ -3,14 +3,6 @@ import { PluginKey } from 'prosemirror-state';
 import { TableMap } from 'prosemirror-tables';
 import { changeStylesString } from '../../utils';
 export var reAnyValue = /^.+$/;
-export var parseStyle = function (styleText) {
-    var styles = (styleText || '').split(/\s*;\s*/).filter(Boolean).map(function (s) {
-        var _a;
-        var nameValue = s.split(/\s*:\s*/);
-        return _a = {}, _a[nameValue[0]] = nameValue[1], _a;
-    }).reduce(function (acc, val) { return (__assign(__assign({}, acc), val)); }, {});
-    return styles;
-};
 export function setNodeStyle(nodeAttrs, styleType, value) {
     var attrs;
     if (new RegExp('[^-]?' + styleType + ':').test(nodeAttrs.style || '')) {

package/dist/es/source.js

@@ -1,6 +1,7 @@
-import { DOMSerializer, DOMParser as ProseMirrorDOMParser } from 'prosemirror-model';
+import { DOMParser as ProseMirrorDOMParser } from 'prosemirror-model';
 import { AllSelection } from 'prosemirror-state';
 import { rowTypeAttr, colgroupAttr } from './config/constants';
+import { DOMSerializer } from './DOMSerializer';
 var blockWrappers = [
     'div', 'ol', 'ul', 'li', 'table', 'tbody', 'thead', 'tfoot', 'caption', 'td', 'th', 'p',
     'tr', 'col', 'colgroup', 'article', 'main', 'nav', 'header', 'footer', 'aside', 'section'
@@ -128,6 +129,29 @@ export var trimWhitespace = function (html, trimAroundTags) {
     return html.replace(new RegExp('\\s*(<(?:' + tags + ')(?:\\s[^>]*?)?>)', 'g'), '$1')
         .replace(new RegExp('(<\\/(?:' + tags + ')(?:\\s[^>]*?)?>)\\s*', 'g'), '$1');
 };
+var styleAttr = 'data-style';
+var styleReplace = ' ' + styleAttr + '=';
+var reTag = /<[^>]+>/gm;
+var reStyle = /\sstyle=/gm;
+var replacer = function (match) {
+    return match.replace(reStyle, styleReplace);
+};
+var replaceStyleAttr = function (html) {
+    return html.replace(reTag, replacer);
+};
+var applyStyle = function (styleString, element) {
+    return styleString.split(';').filter(function (s) { return s !== ''; }).forEach(function (s) {
+        var parts = s.split(':');
+        element.style[parts[0].trim()] = parts[1].trim();
+    });
+};
+var restoreStyleAttr = function (container) {
+    Array.from(container.querySelectorAll('[' + styleAttr + ']')).forEach(function (element) {
+        var styleString = element.getAttribute(styleAttr);
+        element.removeAttribute(styleAttr);
+        applyStyle(styleString, element);
+    });
+};
 /**
  * Creates a DocumentFragment from the given HTML content.
  *
@@ -136,21 +160,9 @@ export var trimWhitespace = function (html, trimAroundTags) {
  */
 export var htmlToFragment = function (html) {
     var template = document.createElement('template');
-    var fragment;
-    if ('content' in template) {
-        template.innerHTML = html;
-        fragment = template.content;
-    }
-    else {
-        // Internet Explorer
-        var parsedDocument = new DOMParser().parseFromString(html, 'text/html');
-        fragment = document.createDocumentFragment();
-        var dom = parsedDocument.body;
-        while (dom && dom.firstChild) {
-            fragment.appendChild(dom.firstChild);
-        }
-    }
-    return fragment;
+    template.innerHTML = replaceStyleAttr(html);
+    restoreStyleAttr(template.content);
+    return template.content;
 };
 /**
  * @hidden
@@ -200,9 +212,7 @@ export var parseContent = function (content, schema, parseOptions) {
  */
 export var getHtml = function (state) {
     var fragment = pmDocToFragment(state.doc);
-    var container = document.createElement('div');
-    container.appendChild(fragment);
-    return container.innerHTML;
+    return fragmentToHtml(fragment);
 };
 /**
  * Replaces the content of the editor with a new one.

package/dist/es/utils.js

@@ -232,3 +232,34 @@ export var expandToWordWrap = function (command, options) {
         return command(options)(cmdState, cmdDispatch);
     };
 };
+export var parseStyle = function (styleText) {
+    var styles = (styleText || '').split(/\s*;\s*/).filter(Boolean).map(function (s) {
+        var _a;
+        var nameValue = s.split(/\s*:\s*/);
+        return _a = {}, _a[nameValue[0]] = nameValue[1], _a;
+    }).reduce(function (acc, val) { return (__assign(__assign({}, acc), val)); }, {});
+    return styles;
+};
+var setStyleAttr = function (element, styleString) {
+    var styles = parseStyle(styleString);
+    for (var style in styles) {
+        if (style && typeof element.style[style] !== 'undefined') {
+            element.style[style] = styles[style];
+        }
+    }
+};
+export var setAttribute = function (node, attrName, value) {
+    var current = node.getAttribute(attrName);
+    if (value !== undefined && value !== current) {
+        if (attrName === 'style') {
+            node.removeAttribute(attrName);
+            setStyleAttr(node, value);
+        }
+        else {
+            node.setAttribute(attrName, value);
+        }
+    }
+    else if (value === undefined) {
+        node.removeAttribute(attrName);
+    }
+};

package/dist/es2015/DOMSerializer.js

@@ -0,0 +1,181 @@
+import { setAttribute } from "./utils";
+export class DOMSerializer {
+    /// Create a serializer. `nodes` should map node names to functions
+    /// that take a node and return a description of the corresponding
+    /// DOM. `marks` does the same for mark names, but also gets an
+    /// argument that tells it whether the mark's content is block or
+    /// inline content (for typical use, it'll always be inline). A mark
+    /// serializer may be `null` to indicate that marks of that type
+    /// should not be serialized.
+    constructor(
+    /// The node serialization functions.
+    nodes, 
+    /// The mark serialization functions.
+    marks) {
+        this.nodes = nodes;
+        this.marks = marks;
+    }
+    /// Render an [output spec](#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(docum, structure, xmlNS = null) {
+        if (typeof structure === "string") {
+            return { dom: docum.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 ? docum.createElementNS(xmlNS, tagName) : docum.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) {
+                    space = name.indexOf(" ");
+                    if (space > 0) {
+                        dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
+                    }
+                    else {
+                        setAttribute(dom, 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(docum, child, xmlNS);
+                dom.appendChild(inner);
+                if (innerContent) {
+                    if (contentDOM) {
+                        throw new RangeError("Multiple content holes");
+                    }
+                    contentDOM = innerContent;
+                }
+            }
+        }
+        return { dom, contentDOM };
+    }
+    /// Build a serializer using the [`toDOM`](#model.NodeSpec.toDOM)
+    /// properties in a schema's node and mark specs.
+    static fromSchema(schema) {
+        return schema.cached.domSerializer ||
+            (schema.cached.domSerializer = new DOMSerializer(this.nodesFromSchema(schema), this.marksFromSchema(schema)));
+    }
+    /// Gather the serializers in a schema's node specs into an object.
+    /// This can be useful as a base to build a custom serializer from.
+    static nodesFromSchema(schema) {
+        let result = gatherToDOM(schema.nodes);
+        if (!result.text) {
+            result.text = node => node.text;
+        }
+        return result;
+    }
+    /// Gather the serializers in a schema's mark specs into an object.
+    static marksFromSchema(schema) {
+        return gatherToDOM(schema.marks);
+    }
+    /// Serialize the content of this fragment to a DOM fragment. When
+    /// not in the browser, the `document` option, containing a DOM
+    /// document, should be passed so that the serializer can create
+    /// nodes.
+    serializeFragment(fragment, options = {}, target) {
+        if (!target) {
+            target = doc(options).createDocumentFragment();
+        }
+        let top = target, active = [];
+        fragment.forEach(node => {
+            if (active.length || node.marks.length) {
+                let keep = 0, rendered = 0;
+                while (keep < active.length && rendered < node.marks.length) {
+                    let next = node.marks[rendered];
+                    if (!this.marks[next.type.name]) {
+                        rendered++;
+                        continue;
+                    }
+                    if (!next.eq(active[keep][0]) || next.type.spec.spanning === false) {
+                        break;
+                    }
+                    keep++;
+                    rendered++;
+                }
+                while (keep < active.length) {
+                    top = active.pop()[1];
+                }
+                while (rendered < node.marks.length) {
+                    let add = node.marks[rendered++];
+                    let markDOM = this.serializeMark(add, node.isInline, options);
+                    if (markDOM) {
+                        active.push([add, top]);
+                        top.appendChild(markDOM.dom);
+                        top = markDOM.contentDOM || markDOM.dom;
+                    }
+                }
+            }
+            top.appendChild(this.serializeNodeInner(node, options));
+        });
+        return target;
+    }
+    /// Serialize this node to a DOM node. This can be useful when you
+    /// need to serialize a part of a document, as opposed to the whole
+    /// document. To serialize a whole document, use
+    /// [`serializeFragment`](#model.DOMSerializer.serializeFragment) on
+    /// its [content](#model.Node.content).
+    serializeNode(node, options = {}) {
+        let dom = this.serializeNodeInner(node, options);
+        for (let i = node.marks.length - 1; i >= 0; i--) {
+            let wrap = this.serializeMark(node.marks[i], node.isInline, options);
+            if (wrap) {
+                (wrap.contentDOM || wrap.dom).appendChild(dom);
+                dom = wrap.dom;
+            }
+        }
+        return dom;
+    }
+    /// @internal
+    serializeMark(mark, inline, options = {}) {
+        let toDOM = this.marks[mark.type.name];
+        return toDOM && DOMSerializer.renderSpec(doc(options), toDOM(mark, inline));
+    }
+    /// @internal
+    serializeNodeInner(node, options) {
+        let { dom, contentDOM } = DOMSerializer.renderSpec(doc(options), this.nodes[node.type.name](node));
+        if (contentDOM) {
+            if (node.isLeaf) {
+                throw new RangeError("Content hole not allowed in a leaf node spec");
+            }
+            this.serializeFragment(node.content, options, contentDOM);
+        }
+        return dom;
+    }
+}
+function gatherToDOM(obj) {
+    let result = {};
+    for (let name in obj) {
+        if (obj[name]) {
+            let toDOM = obj[name].spec.toDOM;
+            if (toDOM) {
+                result[name] = toDOM;
+            }
+        }
+    }
+    return result;
+}
+function doc(options) {
+    return options.document || window.document;
+}

package/dist/es2015/main.js

@@ -21,6 +21,7 @@ export { convertMsLists } from './listConvert';
 export { find, findAt, findAll, replace, replaceAll } from './find-replace';
 export { placeholder } from './plugins/placeholder';
 export { spacesFix } from './plugins/spaces-fix';
+export { cspFix } from './plugins/csp-fix';
 export { textHighlight, textHighlightKey } from './plugins/highlight';
 export { imageResizing, imageResizeKey } from './plugins/image-resize';
 export { caretColor, caretColorKey } from './plugins/caret-color';