@progress/kendo-editor-common 1.11.9-dev.202412020819 → 1.11.9-develop.2

package/dist/es/mark.js

@@ -1,13 +1,14 @@
 import { RemoveMarkStep } from 'prosemirror-transform';
 import { MarkType } from 'prosemirror-model';
-import { parseStyle } from './utils';
-export var markApplies = function (doc, ranges, type) {
-    var loop = function (i) {
-        var ref = ranges[i];
-        var $from = ref.$from;
-        var $to = ref.$to;
-        var can = $from.depth === 0 ? doc.type.allowsMarkType(type) : false;
-        doc.nodesBetween($from.pos, $to.pos, function (node) {
+import { parseStyle } from './utils.js';
+
+const markApplies = (doc, ranges, type) => {
+    const loop = i => {
+        const ref = ranges[i];
+        const $from = ref.$from;
+        const $to = ref.$to;
+        let can = $from.depth === 0 ? doc.type.allowsMarkType(type) : false;
+        doc.nodesBetween($from.pos, $to.pos, node => {
             if (can) {
                 return false;
             }
@@ -17,16 +18,16 @@ export var markApplies = function (doc, ranges, type) {
             return { v: true };
         }
     };
-    for (var i = 0; i < ranges.length; i++) {
-        var returned = loop(i);
+    for (let i = 0; i < ranges.length; i++) {
+        const returned = loop(i);
         if (returned) {
             return returned.v;
         }
     }
     return false;
 };
-export var toggleMark = function (markType, attrs, tr) { return function (state, dispatch) {
-    var _a = state.selection, empty = _a.empty, $cursor = _a.$cursor, ranges = _a.ranges;
+const toggleMark = (markType, attrs, tr) => (state, dispatch) => {
+    const { empty, $cursor, ranges } = state.selection;
     if ((empty && !$cursor) || !markApplies(state.doc, ranges, markType)) {
         return false;
     }
@@ -40,13 +41,13 @@ export var toggleMark = function (markType, attrs, tr) { return function (state,
             }
         }
         else {
-            var has = false;
-            for (var i = 0; !has && i < ranges.length; i++) {
-                var _b = ranges[i], $from = _b.$from, $to = _b.$to;
+            let has = false;
+            for (let i = 0; !has && i < ranges.length; i++) {
+                const { $from, $to } = ranges[i];
                 has = state.doc.rangeHasMark($from.pos, $to.pos, markType);
             }
-            for (var i = 0; i < ranges.length; i++) {
-                var _c = ranges[i], $from = _c.$from, $to = _c.$to;
+            for (let i = 0; i < ranges.length; i++) {
+                const { $from, $to } = ranges[i];
                 if (has) {
                     tr.removeMark($from.pos, $to.pos, markType);
                 }
@@ -58,20 +59,20 @@ export var toggleMark = function (markType, attrs, tr) { return function (state,
         }
     }
     return true;
-}; };
-export var removeMark = function (tr, from, to, mark) {
+};
+const removeMark = (tr, from, to, mark) => {
     if (mark === void 0) {
         mark = null;
     }
-    var matched = [], step = 0;
-    tr.doc.nodesBetween(from, to, function (node, pos) {
+    let matched = [], step = 0;
+    tr.doc.nodesBetween(from, to, (node, pos) => {
         if (!node.isInline) {
             return;
         }
         step++;
-        var toRemove = null;
+        let toRemove = null;
         if (mark instanceof MarkType) {
-            var found = mark.isInSet(node.marks);
+            const found = mark.isInSet(node.marks);
             if (found) {
                 toRemove = [found];
             }
@@ -85,11 +86,11 @@ export var removeMark = function (tr, from, to, mark) {
             toRemove = node.marks;
         }
         if (toRemove && toRemove.length) {
-            var end = Math.min(pos + node.nodeSize, to);
-            for (var i = 0; i < toRemove.length; i++) {
-                var style = toRemove[i], found$1 = (void 0);
-                for (var j = 0; j < matched.length; j++) {
-                    var m = matched[j];
+            const end = Math.min(pos + node.nodeSize, to);
+            for (let i = 0; i < toRemove.length; i++) {
+                let style = toRemove[i], found$1 = (void 0);
+                for (let j = 0; j < matched.length; j++) {
+                    const m = matched[j];
                     if (m.step === step - 1 && style.eq(m.style)) {
                         found$1 = m;
                     }
@@ -104,43 +105,37 @@ export var removeMark = function (tr, from, to, mark) {
             }
         }
     });
-    matched.forEach(function (m) { return tr.step(new RemoveMarkStep(m.from, m.to, m.style)); });
+    matched.forEach((m) => { return tr.step(new RemoveMarkStep(m.from, m.to, m.style)); });
     return tr;
 };
-export var removeMarks = function (marks, state, dispatch, tr) {
-    var _a = state.selection, $cursor = _a.$cursor, ranges = _a.ranges;
+const removeMarks = (marks, state, dispatch, tr) => {
+    const { $cursor, ranges } = state.selection;
     tr = tr || state.tr;
     if ($cursor) {
-        marks.forEach(function (m) {
+        marks.forEach(m => {
             if (m.isInSet(state.storedMarks || $cursor.marks())) {
                 dispatch(tr.removeStoredMark(m));
             }
         });
     }
     else {
-        var _loop_1 = function (i) {
-            var _b = ranges[i], $from = _b.$from, $to = _b.$to;
-            marks.forEach(function (m) {
+        for (let i = 0; i < ranges.length; i++) {
+            const { $from, $to } = ranges[i];
+            marks.forEach(m => {
                 removeMark(tr, $from.pos, $to.pos, m);
             });
-        };
-        for (var i = 0; i < ranges.length; i++) {
-            _loop_1(i);
         }
         dispatch(tr.scrollIntoView());
     }
     return true;
 };
-var toArray = function (x) { return x instanceof Array ? x : [x]; };
-export var removeAllMarks = function (_a) {
-    var _b = _a === void 0 ? {} : _a, _c = _b.except, except = _c === void 0 ? [] : _c;
-    return function (state, dispatch) {
-        var tr = state.tr;
-        cleanMarks(tr, { except: toArray(except) });
-        if (tr.docChanged) {
-            dispatch(tr);
-        }
-    };
+const toArray = (x) => x instanceof Array ? x : [x];
+const removeAllMarks = ({ except = [] } = {}) => (state, dispatch) => {
+    const tr = state.tr;
+    cleanMarks(tr, { except: toArray(except) });
+    if (tr.docChanged) {
+        dispatch(tr);
+    }
 };
 /**
  * Removes the marks from the selection base on the passed parameter.
@@ -149,19 +144,17 @@ export var removeAllMarks = function (_a) {
  * @example
  * See `removeAllMarks` or `cleanFormatting` function.
  */
-export var cleanMarks = function (tr, _a) {
-    var except = _a.except;
-    var doc = tr.doc, selection = tr.selection;
-    var schema = doc.type.schema;
-    var empty = selection.empty, ranges = selection.ranges;
-    var excludedMarkTypes = (except || []).map(function (mt) { return mt.name; });
+const cleanMarks = (tr, { except }) => {
+    const { doc, selection } = tr;
+    const schema = doc.type.schema;
+    const { empty, ranges } = selection;
+    const excludedMarkTypes = (except || []).map(mt => mt.name);
     if (!empty) {
-        var marks_1 = Object.keys(schema.marks)
-            .map(function (m) { return schema.marks[m]; })
-            .filter(function (mt) { return excludedMarkTypes.indexOf(mt.name) === -1; });
-        ranges.forEach(function (_a) {
-            var $from = _a.$from, $to = _a.$to;
-            marks_1.forEach(function (mark) { return tr.removeMark($from.pos, $to.pos, mark); });
+        const marks = Object.keys(schema.marks)
+            .map(m => schema.marks[m])
+            .filter(mt => excludedMarkTypes.indexOf(mt.name) === -1);
+        ranges.forEach(({ $from, $to }) => {
+            marks.forEach(mark => tr.removeMark($from.pos, $to.pos, mark));
         });
     }
 };
@@ -169,36 +162,36 @@ export var cleanMarks = function (tr, _a) {
  * Checks if a mark exists in the selection.
  * Used for checking the state of bold, italic, ... and unlink tools.
  */
-export var hasMark = function (state, options) {
-    var marks = state.schema.marks;
-    var altMarks = (options.altMarks || []).filter(function (m) { return marks[m]; });
-    var altStyle = options.altStyle;
-    var _a = state.selection, from = _a.from, $from = _a.$from, to = _a.to, empty = _a.empty;
-    var type = marks[options.mark];
-    var doc = state.doc;
-    var result = false;
-    var currMarks;
+const hasMark = (state, options) => {
+    const marks = state.schema.marks;
+    const altMarks = (options.altMarks || []).filter(m => marks[m]);
+    const altStyle = options.altStyle;
+    const { from, $from, to, empty } = state.selection;
+    const type = marks[options.mark];
+    const doc = state.doc;
+    let result = false;
+    let currMarks;
     if (empty) {
         currMarks = state.storedMarks || $from.marks();
-        result = (type && type.isInSet(currMarks)) || altMarks.some(function (m) { return marks[m].isInSet(currMarks); });
+        result = (type && type.isInSet(currMarks)) || altMarks.some(m => marks[m].isInSet(currMarks));
     }
     else {
-        result = (type && doc.rangeHasMark(from, to, type)) || altMarks.some(function (m) { return doc.rangeHasMark(from, to, marks[m]); });
+        result = (type && doc.rangeHasMark(from, to, type)) || altMarks.some(m => doc.rangeHasMark(from, to, marks[m]));
     }
     if (!result && altStyle && marks.style) {
         return selectionMarks(state, marks.style)
-            .some(function (mark) { return styleValue(mark, altStyle) !== null; });
+            .some(mark => styleValue(mark, altStyle) !== null);
     }
     return Boolean(result);
 };
-export var styleValue = function (mark, style) {
-    var styleText = (mark && mark.attrs.style) || '';
-    var styles = parseStyle(styleText);
-    var styleNames = Object.keys(styles);
-    for (var i = 0; i < styleNames.length; i++) {
-        var name_1 = styleNames[i];
-        if (name_1.toLowerCase() === style.name && style.value.test(styles[name_1])) {
-            return styles[name_1];
+const styleValue = (mark, style) => {
+    const styleText = (mark && mark.attrs.style) || '';
+    const styles = parseStyle(styleText);
+    const styleNames = Object.keys(styles);
+    for (let i = 0; i < styleNames.length; i++) {
+        const name = styleNames[i];
+        if (name.toLowerCase() === style.name && style.value.test(styles[name])) {
+            return styles[name];
         }
     }
     return null;
@@ -206,14 +199,14 @@ export var styleValue = function (mark, style) {
 /**
  * Returns the marks of a specific type for every inline node in the selection.
  */
-export var selectionMarks = function (state, markType) {
-    var _a = state.selection, from = _a.from, $from = _a.$from, to = _a.to, empty = _a.empty;
-    var marks = [];
+const selectionMarks = (state, markType) => {
+    const { from, $from, to, empty } = state.selection;
+    const marks = [];
     if (empty) {
         marks.push(markType.isInSet(state.storedMarks || $from.marks()));
     }
     else {
-        state.doc.nodesBetween(from, to, function (node) {
+        state.doc.nodesBetween(from, to, node => {
             if (node.isInline) {
                 marks.push(markType.isInSet(node.marks));
             }
@@ -225,20 +218,22 @@ export var selectionMarks = function (state, markType) {
  * Returns the specified mark which wraps the selection.
  * Used by link tools.
  */
-export var getMark = function (state, markType) {
-    var marks = selectionMarks(state, markType);
-    var filtered = marks.filter(function (m) { return Boolean(m); });
+const getMark = (state, markType) => {
+    const marks = selectionMarks(state, markType);
+    const filtered = marks.filter(m => Boolean(m));
     return marks.length === filtered.length ? marks[0] : undefined;
 };
 /**
  * **Deprecated.** Use `selectionMarks` function instead.
  */
-export var getActiveMarks = function (state, markType) {
-    var marks = selectionMarks(state, markType);
-    var filtered = marks.filter(function (m) { return Boolean(m); });
-    var hasNodesWithoutMarks = marks.length !== filtered.length;
+const getActiveMarks = (state, markType) => {
+    const marks = selectionMarks(state, markType);
+    const filtered = marks.filter(m => Boolean(m));
+    const hasNodesWithoutMarks = marks.length !== filtered.length;
     return {
-        hasNodesWithoutMarks: hasNodesWithoutMarks,
+        hasNodesWithoutMarks,
         marks: filtered
     };
 };
+
+export { cleanMarks, getActiveMarks, getMark, hasMark, markApplies, removeAllMarks, removeMark, removeMarks, selectionMarks, styleValue, toggleMark };

package/dist/es/paste.js

@@ -1,10 +1,11 @@
-import { convertMsLists } from './listConvert';
-import { fragmentToHtml, htmlToFragment } from './source';
-import { parseStyle } from './utils';
+import { convertMsLists } from './listConvert.js';
+import { htmlToFragment, fragmentToHtml } from './source.js';
+import { parseStyle } from './utils.js';
+
 /**
  * Removes the invalid HTML. Use it as a first step for cleaning the HTML.
  */
-export var sanitize = function (html) {
+const sanitize = (html) => {
     html = html.replace(/^[\s\S]+?<!--StartFragment-->\s*([\s\S]*?)\s*<!--EndFragment-->[\s\S]+$/, '$1');
     html = html.replace(/<\/?[ovw]:[^>]*?>/gi, ''); // MS elements, e.g. <o:p>, <w:sdtPr>, <v:
     html = html.replace(/<\\?\??xml[^>]*>/gi, ''); // XML namespaces
@@ -20,19 +21,19 @@ export var sanitize = function (html) {
 /**
  * Removes comments in HTML.
  */
-export var removeComments = function (html) {
+const removeComments = (html) => {
     return html.replace(/<!--[\s\S]+?-->/g, '');
 };
 /**
  * Removes the specified tag(s).
  */
-export var removeTag = function (html, tagPattern) {
+const removeTag = (html, tagPattern) => {
     return html.replace(new RegExp('<\\/?(' + tagPattern + ')(?:\\s[^>]*?)?>', 'gi'), '');
 };
 /**
  * Removes the passed attribute.
  */
-export var removeAttribute = function (attr) {
+const removeAttribute = (attr) => {
     if (attr.ownerElement) {
         attr.ownerElement.removeAttribute(attr.name);
     }
@@ -40,7 +41,7 @@ export var removeAttribute = function (attr) {
 /**
  * Remove the attribute if its value matches /^Mso/ regex.
  */
-export var sanitizeClassAttr = function (attr) {
+const sanitizeClassAttr = (attr) => {
     if (/^Mso/.test(attr.value)) {
         removeAttribute(attr);
     }
@@ -48,14 +49,14 @@ export var sanitizeClassAttr = function (attr) {
 /**
  * Removes invalid HTML styles.
  */
-export var sanitizeStyleAttr = function (attr) {
-    var styles = parseStyle(attr.value);
-    var element = attr.ownerElement;
-    var supportedStyles = element.style;
-    var result = '';
-    Object.keys(styles).forEach(function (name) {
+const sanitizeStyleAttr = (attr) => {
+    const styles = parseStyle(attr.value);
+    const element = attr.ownerElement;
+    const supportedStyles = element.style;
+    let result = '';
+    Object.keys(styles).forEach(name => {
         if (supportedStyles[name] !== undefined) {
-            result += "".concat(name, ": ").concat(styles[name], "; ");
+            result += `${name}: ${styles[name]}; `;
         }
     });
     result = result.trim();
@@ -66,8 +67,8 @@ export var sanitizeStyleAttr = function (attr) {
         removeAttribute(attr);
     }
 };
-var removeNode = function (node) {
-    var parentNode = node.parentNode;
+const removeNode = (node) => {
+    const parentNode = node.parentNode;
     if (parentNode) {
         while (node.firstChild) {
             parentNode.insertBefore(node.firstChild, node);
@@ -75,10 +76,10 @@ var removeNode = function (node) {
         parentNode.removeChild(node);
     }
 };
-var sanitizeNode = function (node, attributes) {
+const sanitizeNode = (node, attributes) => {
     if (node.nodeType === Node.ELEMENT_NODE) {
-        for (var i = node.attributes.length - 1; i >= 0; i--) {
-            var attr = node.attributes[i];
+        for (let i = node.attributes.length - 1; i >= 0; i--) {
+            const attr = node.attributes[i];
             if (attributes[attr.name]) {
                 attributes[attr.name](attr);
             }
@@ -95,8 +96,8 @@ var sanitizeNode = function (node, attributes) {
  * Cleans the HTML based on passed settings.
  * Before using it, clean the HTML with the `sanitize` function.
  */
-export var pasteCleanup = function (html, settings) {
-    var result = html;
+const pasteCleanup = (html, settings) => {
+    let result = html;
     if (settings.convertMsLists) {
         result = convertMsLists(result);
     }
@@ -104,27 +105,27 @@ export var pasteCleanup = function (html, settings) {
         result = removeTag(result, settings.stripTags);
     }
     if (settings.attributes) {
-        var fragment = htmlToFragment(result);
-        Array.from(fragment.querySelectorAll('*')).forEach(function (node) { return sanitizeNode(node, settings.attributes); });
+        const fragment = htmlToFragment(result);
+        Array.from(fragment.querySelectorAll('*')).forEach(node => sanitizeNode(node, settings.attributes));
         result = fragmentToHtml(fragment);
     }
     return result;
 };
 function convertHexToBase64(hex) {
-    var length = hex.length;
-    var data = new Array(length / 2);
-    for (var i = 0; i < length; i += 2) {
+    const length = hex.length;
+    const data = new Array(length / 2);
+    for (let i = 0; i < length; i += 2) {
         data[i] = String.fromCharCode(parseInt(hex.substring(i, i + 2), 16));
     }
     return btoa(data.join(''));
 }
-var reHtmlImg = /<img\s[^>]*?src=(?:'|")file:\/[^'"]+(?:'|")[^>]*>/gi;
-var reRtfImgHeader = /{\\pict[\s\S]+?\\bliptag-?\d+(\\blipupi-?\d+)?({\\\*\\blipuid\s?[\da-fA-F]+)?[\s}]*?/;
-var reRtfImg = new RegExp('(?:(' + reRtfImgHeader.source + '))([\\da-fA-F\\s]+)\\}', 'g');
-var reNonHex = /[^\da-fA-F]/g;
-var reLocalFile = /file:\/[^'"]+\.(jpg|png|gif)/i;
-var reExtension = /\\(png|jpeg)blip\\/;
-var textRtfType = 'text/rtf';
+const reHtmlImg = /<img\s[^>]*?src=(?:'|")file:\/[^'"]+(?:'|")[^>]*>/gi;
+const reRtfImgHeader = /{\\pict[\s\S]+?\\bliptag-?\d+(\\blipupi-?\d+)?({\\\*\\blipuid\s?[\da-fA-F]+)?[\s}]*?/;
+const reRtfImg = new RegExp('(?:(' + reRtfImgHeader.source + '))([\\da-fA-F\\s]+)\\}', 'g');
+const reNonHex = /[^\da-fA-F]/g;
+const reLocalFile = /file:\/[^'"]+\.(jpg|png|gif)/i;
+const reExtension = /\\(png|jpeg)blip\\/;
+const textRtfType = 'text/rtf';
 /**
  * If the input HTML contains images with 'src' pointing to local file system (it happens when pasting images and text from MS Word),
  * the function will extract the image sources form the RTF and replace the image 'src' with extracted base64 format data in `html` string.
@@ -133,30 +134,31 @@ var textRtfType = 'text/rtf';
  * @param clipboardData - The paste event clipboardData object (event.clipboardData).
  * @returns - The html with the replaced images sources.
  */
-export var replaceImageSourcesFromRtf = function (html, clipboardData) {
-    var htmlImages = html.match(reHtmlImg);
+const replaceImageSourcesFromRtf = (html, clipboardData) => {
+    const htmlImages = html.match(reHtmlImg);
     if (!htmlImages || clipboardData.types.indexOf(textRtfType) === -1) {
         return html;
     }
-    var rtf = clipboardData.getData(textRtfType);
-    var base64Sources = [];
-    var rtfImages = rtf.match(reRtfImg);
+    const rtf = clipboardData.getData(textRtfType);
+    const base64Sources = [];
+    const rtfImages = rtf.match(reRtfImg);
     if (!rtf || !rtfImages) {
         return html;
     }
-    for (var _i = 0, rtfImages_1 = rtfImages; _i < rtfImages_1.length; _i++) {
-        var image = rtfImages_1[_i];
-        var extension = reExtension.exec(image);
+    for (const image of rtfImages) {
+        const extension = reExtension.exec(image);
         if (extension) {
-            var hex = image.replace(reRtfImgHeader, '').replace(reNonHex, '');
-            base64Sources.push("data:image/".concat(extension[1], ";base64,").concat(convertHexToBase64(hex)));
+            const hex = image.replace(reRtfImgHeader, '').replace(reNonHex, '');
+            base64Sources.push(`data:image/${extension[1]};base64,${convertHexToBase64(hex)}`);
         }
     }
     if (htmlImages.length !== base64Sources.length) {
         return html;
     }
-    return html.replace(reHtmlImg, function (img) {
-        var src = base64Sources.shift() || '';
+    return html.replace(reHtmlImg, img => {
+        const src = base64Sources.shift() || '';
         return img.replace(reLocalFile, src);
     });
 };
+
+export { pasteCleanup, removeAttribute, removeComments, removeTag, replaceImageSourcesFromRtf, sanitize, sanitizeClassAttr, sanitizeStyleAttr };

package/dist/es/plugins/caret-color.js

@@ -1,23 +1,24 @@
-import { Plugin, PluginKey } from 'prosemirror-state';
-import { Decoration, DecorationSet } from 'prosemirror-view';
-import { styleValue } from './../mark';
-export var caretColorKey = new PluginKey('caret-color');
-export function caretColor() {
+import { PluginKey, Plugin } from 'prosemirror-state';
+import { DecorationSet, Decoration } from 'prosemirror-view';
+import { styleValue } from '../mark.js';
+
+const caretColorKey = new PluginKey('caret-color');
+function caretColor() {
     return new Plugin({
         key: caretColorKey,
         props: {
-            decorations: function (state) {
-                var doc = state.doc, selection = state.selection, storedMarks = state.storedMarks;
+            decorations: (state) => {
+                const { doc, selection, storedMarks } = state;
                 if (!selection.empty || !storedMarks) {
                     return DecorationSet.empty;
                 }
-                var color = styleValue((storedMarks || []).find(function (m) { return m.type.name === 'style'; }), { name: 'color', value: /^.+$/ });
+                const color = styleValue((storedMarks || []).find((m) => m.type.name === 'style'), { name: 'color', value: /^.+$/ });
                 if (!color) {
                     return DecorationSet.empty;
                 }
-                var parentNode = selection.$anchor.parent;
-                var decorations = [];
-                doc.descendants(function (node, pos) {
+                const parentNode = selection.$anchor.parent;
+                const decorations = [];
+                doc.descendants((node, pos) => {
                     if (node.eq(parentNode)) {
                         decorations.push(Decoration.node(pos, pos + node.nodeSize, {
                             style: 'caret-color: ' + color
@@ -29,3 +30,5 @@ export function caretColor() {
         }
     });
 }
+
+export { caretColor, caretColorKey };

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

@@ -1,51 +1,51 @@
 import { Plugin, PluginKey } from 'prosemirror-state';
-import { setAttribute } from '../utils';
-var setAttributes = function (dom, attrs) {
-    for (var attrName in attrs) {
+import { setAttribute } from '../utils.js';
+
+const setAttributes = (dom, attrs) => {
+    for (const 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; }
+class CustomNodeView {
+    constructor(node, view, nodeName, 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) {
+}
+class StyleView {
+    constructor(mark, view) {
         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 () {
+}
+const cspFix = () => {
     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); }
+                paragraph: (node, view) => new CustomNodeView(node, view, 'p'),
+                div: (node, view) => new CustomNodeView(node, view, 'div'),
+                table_wrapper: (node, view) => new CustomNodeView(node, view, 'div'),
+                table_caption_external: (node, view) => new CustomNodeView(node, view, 'div'),
+                table: (node, view) => new CustomNodeView(node, view, 'table'),
+                table_row: (node, view) => new CustomNodeView(node, view, 'tr'),
+                table_cell: (node, view) => new CustomNodeView(node, view, 'td'),
+                table_header: (node, view) => new CustomNodeView(node, view, 'th'),
+                image: (node, view) => new CustomNodeView(node, view, 'img', true)
             },
             markViews: {
-                style: function (mark, view) { return new StyleView(mark, view); }
+                style: (mark, view) => new StyleView(mark, view)
             }
         }
     });
 };
+
+export { cspFix };

package/dist/es/plugins/highlight.js

@@ -1,21 +1,23 @@
-import { Plugin, PluginKey } from 'prosemirror-state';
+import { PluginKey, Plugin } from 'prosemirror-state';
 import { Decoration, DecorationSet } from 'prosemirror-view';
+
 // https://discuss.prosemirror.net/t/passing-data-between-plugins/1843
-export var textHighlightKey = new PluginKey('highlight');
-export function textHighlight(key) {
-    if (key === void 0) { key = textHighlightKey; }
+const textHighlightKey = new PluginKey('highlight');
+function textHighlight(key = textHighlightKey) {
     return new Plugin({
-        key: key,
+        key,
         state: {
-            init: function () { return null; },
-            apply: function (tr) { return tr.getMeta(this.spec.key); }
+            init() { return null; },
+            apply(tr) { return tr.getMeta(this.spec.key); }
         },
         props: {
-            decorations: function (state) {
-                var decorations = (this.spec.key.getState(state) || [])
-                    .map(function (d) { return Decoration.inline(d.from, d.to, d.attrs); });
+            decorations(state) {
+                const decorations = (this.spec.key.getState(state) || [])
+                    .map((d) => Decoration.inline(d.from, d.to, d.attrs));
                 return DecorationSet.create(state.doc, decorations);
             }
         }
     });
 }
+
+export { textHighlight, textHighlightKey };