@progress/kendo-editor-common 1.11.1 → 1.11.2-dev.202402200937

package/dist/es2015/DOMSerializer.js

@@ -1,25 +1,10 @@
-import { setAttribute } from "./utils";
+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") {
+        if (typeof structure === 'string') {
             return { dom: docum.createTextNode(structure) };
         }
         if (structure.nodeType != null) {
@@ -28,19 +13,19 @@ export class DOMSerializer {
         if (structure.dom && structure.dom.nodeType != null) {
             return structure;
         }
-        let tagName = structure[0], space = tagName.indexOf(" ");
+        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));
+        const 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)) {
+        if (attrs && typeof attrs === 'object' && attrs.nodeType == null && !Array.isArray(attrs)) {
             start = 2;
-            for (let name in attrs) {
+            for (const name in attrs) {
                 if (attrs[name] != null) {
-                    space = name.indexOf(" ");
+                    space = name.indexOf(' ');
                     if (space > 0) {
                         dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
                     }
@@ -51,19 +36,19 @@ export class DOMSerializer {
             }
         }
         for (let i = start; i < structure.length; i++) {
-            let child = structure[i];
+            const 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");
+                    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);
+                const { dom: inner, contentDOM: innerContent } = DOMSerializer.renderSpec(docum, child, xmlNS);
                 dom.appendChild(inner);
                 if (innerContent) {
                     if (contentDOM) {
-                        throw new RangeError("Multiple content holes");
+                        throw new RangeError('Multiple content holes');
                     }
                     contentDOM = innerContent;
                 }
@@ -80,7 +65,7 @@ export class DOMSerializer {
     /// 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);
+        const result = gatherToDOM(schema.nodes);
         if (!result.text) {
             result.text = node => node.text;
         }
@@ -90,6 +75,21 @@ export class DOMSerializer {
     static marksFromSchema(schema) {
         return gatherToDOM(schema.marks);
     }
+    /// 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;
+    }
     /// 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
@@ -103,7 +103,7 @@ export class DOMSerializer {
             if (active.length || node.marks.length) {
                 let keep = 0, rendered = 0;
                 while (keep < active.length && rendered < node.marks.length) {
-                    let next = node.marks[rendered];
+                    const next = node.marks[rendered];
                     if (!this.marks[next.type.name]) {
                         rendered++;
                         continue;
@@ -118,8 +118,8 @@ export class DOMSerializer {
                     top = active.pop()[1];
                 }
                 while (rendered < node.marks.length) {
-                    let add = node.marks[rendered++];
-                    let markDOM = this.serializeMark(add, node.isInline, options);
+                    const add = node.marks[rendered++];
+                    const markDOM = this.serializeMark(add, node.isInline, options);
                     if (markDOM) {
                         active.push([add, top]);
                         top.appendChild(markDOM.dom);
@@ -139,7 +139,7 @@ export class DOMSerializer {
     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);
+            const wrap = this.serializeMark(node.marks[i], node.isInline, options);
             if (wrap) {
                 (wrap.contentDOM || wrap.dom).appendChild(dom);
                 dom = wrap.dom;
@@ -149,15 +149,15 @@ export class DOMSerializer {
     }
     /// @internal
     serializeMark(mark, inline, options = {}) {
-        let toDOM = this.marks[mark.type.name];
+        const 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));
+        const { 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");
+                throw new RangeError('Content hole not allowed in a leaf node spec');
             }
             this.serializeFragment(node.content, options, contentDOM);
         }
@@ -165,10 +165,10 @@ export class DOMSerializer {
     }
 }
 function gatherToDOM(obj) {
-    let result = {};
-    for (let name in obj) {
+    const result = {};
+    for (const name in obj) {
         if (obj[name]) {
-            let toDOM = obj[name].spec.toDOM;
+            const toDOM = obj[name].spec.toDOM;
             if (toDOM) {
                 result[name] = toDOM;
             }

package/dist/es2015/blockNode.js

@@ -7,7 +7,7 @@ import { NodeSelection } from 'prosemirror-state';
  * @hidden
  */
 const canChangeType = (stateDoc, pos, type) => {
-    let $pos = stateDoc.resolve(pos), index = $pos.index();
+    const $pos = stateDoc.resolve(pos), index = $pos.index();
     return $pos.parent.canReplaceWith(index, index + 1, type);
 };
 /**
@@ -32,9 +32,9 @@ export const changeTextBlock = (tr, node, nodeType, attrs) => {
                 canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), nodeType)) {
                 // Ensure all markup that isn't allowed in the new node type is cleared
                 tr.clearIncompatible(tr.mapping.slice(mapFrom).map(pos, 1), nodeType);
-                let mapping = tr.mapping.slice(mapFrom);
-                let startM = mapping.map(pos, 1), endM = mapping.map(pos + currNode.nodeSize, 1);
-                let slice = new Slice(Fragment.from(nodeType.create(attrs, null, currNode.marks)), 0, 0);
+                const mapping = tr.mapping.slice(mapFrom);
+                const startM = mapping.map(pos, 1), endM = mapping.map(pos + currNode.nodeSize, 1);
+                const slice = new Slice(Fragment.from(nodeType.create(attrs, null, currNode.marks)), 0, 0);
                 tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, slice, 1, true));
                 return false; // this will skip the node children
             }
@@ -49,7 +49,7 @@ export const changeTextBlock = (tr, node, nodeType, attrs) => {
  */
 export const blockNodes = (state, options = { blocksInSelection: false }) => {
     const { doc, selection } = state;
-    let { $from, ranges } = selection;
+    const { $from, ranges } = selection;
     const { blocksInSelection } = options;
     const result = [];
     const selNode = selection instanceof NodeSelection ? selection.node : undefined;
@@ -70,7 +70,7 @@ export const blockNodes = (state, options = { blocksInSelection: false }) => {
         ranges.forEach(range => {
             const from = range.$from.pos;
             const to = range.$to.pos;
-            doc.nodesBetween(from, to, (node, pos, _parent, _index) => {
+            doc.nodesBetween(from, to, (node, pos) => {
                 if (node.isBlock && (!blocksInSelection || (pos >= from && pos + node.content.size + 2 <= to))) {
                     result.push(node);
                 }
@@ -88,16 +88,14 @@ export const formatBlockElements = (value, commandName) => (state, dispatch) =>
     blocks.forEach(node => {
         if (node.type.isTextblock) {
             if (value === 'p') {
-                const _a = node.attrs, { level } = _a, attrs = __rest(_a, ["level"]);
-                changeTextBlock(tr, node, nodes.paragraph, attrs);
+                changeTextBlock(tr, node, nodes.paragraph, node.attrs);
             }
             else if (/^h[1-6]$/i.test(value)) {
                 const level = parseInt(value.substr(1), 10);
                 changeTextBlock(tr, node, nodes.heading, Object.assign(Object.assign({}, node.attrs), { level }));
             }
             else if (value === 'blockquote') {
-                const _b = node.attrs, { level } = _b, attrs = __rest(_b, ["level"]);
-                changeTextBlock(tr, node, nodes.blockquote, attrs);
+                changeTextBlock(tr, node, nodes.blockquote, node.attrs);
             }
         }
     });
@@ -159,7 +157,7 @@ export const addStyles = (node, stylesToApply) => {
     return Object.assign({}, node.attrs, { style: currentStyles || null });
 };
 export const hasNode = (state, nodeType) => {
-    let { from, to } = state.selection;
+    const { from, to } = state.selection;
     let result = false;
     state.doc.nodesBetween(from, to, node => {
         result = result || node.type === nodeType;

package/dist/es2015/blockquote.js

@@ -9,7 +9,7 @@ export const liftBlockquote = (state, dispatch) => {
     let target = -1;
     const range = $from.blockRange($to);
     if (range) {
-        doc.nodesBetween(range.start, range.end, (node, pos, _parent, _index) => {
+        doc.nodesBetween(range.start, range.end, (node, pos) => {
             if (node.type === nodeType) {
                 target = pos;
             }

package/dist/es2015/config/keymap.js

@@ -13,9 +13,9 @@ export const buildKeymap = (schema, options) => {
     keys['Mod-z'] = undo;
     keys['Shift-Mod-z'] = redo;
     // tslint:disable-next-line:no-string-literal
-    keys['Backspace'] = chainCommands(undoInputRule, deleteSelection, joinBackward, selectNodeBackward);
+    keys.Backspace = chainCommands(undoInputRule, deleteSelection, joinBackward, selectNodeBackward);
     // tslint:disable-next-line:no-string-literal
-    keys['Enter'] = chainCommands(newlineInCode, createParagraphNear, liftEmptyBlock, splitBlockKeepMarks);
+    keys.Enter = chainCommands(newlineInCode, createParagraphNear, liftEmptyBlock, splitBlockKeepMarks);
     if (!mac) {
         keys['Mod-y'] = redo;
     }
@@ -42,7 +42,7 @@ export const buildListKeymap = (schema) => {
     const keys = {};
     if (schema.nodes.list_item) {
         // tslint:disable-next-line:no-string-literal
-        keys['Enter'] = splitListItemKeepMarks(schema.nodes.list_item);
+        keys.Enter = splitListItemKeepMarks(schema.nodes.list_item);
     }
     return keys;
 };

package/dist/es2015/config/schema.js

@@ -7,7 +7,8 @@ const blockquoteDOM = ['blockquote', hole], hrDOM = ['hr'], preDOM = ['pre', ['c
 const olDOM = ['ol', 0], ulDOM = ['ul', 0], liDOM = ['li', 0];
 const domAttributes = (dom) => {
     const result = {};
-    let attributes = dom.attributes, attr;
+    const attributes = dom.attributes;
+    let attr;
     for (let i = 0; i < attributes.length; i++) {
         attr = attributes[i];
         result[attr.name] = attr.value;
@@ -23,7 +24,7 @@ const defaultAttrs = (attrs) => {
 };
 const commonAttributes = () => defaultAttrs(['style', 'class', 'id']);
 const hasAttrs = (attrs, exclude) => {
-    for (let attr in attrs) {
+    for (const attr in attrs) {
         if (attr && attrs[attr] !== null && attr !== exclude) {
             return true;
         }
@@ -32,7 +33,7 @@ const hasAttrs = (attrs, exclude) => {
 };
 const pmAttributes = (attrs, exclude = []) => {
     const result = {};
-    for (let attr in attrs) {
+    for (const attr in attrs) {
         if (attr && attrs[attr] !== null && !exclude.find(e => e === attr)) {
             result[attr] = attrs[attr];
         }

package/dist/es2015/find-replace.js

@@ -14,7 +14,7 @@ export const findAt = (doc, searchOptions, start, end, exit) => {
     }
     const flags = matchCase ? 'g' : 'gi';
     const regExp = useRegExp ? new RegExp(searchText, flags) : createRegExp(searchText, flags);
-    doc.nodesBetween(start, end, (node, pos, _parent) => {
+    doc.nodesBetween(start, end, (node, pos) => {
         if (exit(result)) {
             return false;
         }

package/dist/es2015/inline-style.js

@@ -14,9 +14,9 @@ const changeStyleMark = (tr, from, to, attrs, markType) => {
         if (!node.isInline) {
             return;
         }
-        let marks = node.marks;
+        const marks = node.marks;
         if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
-            let start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
+            const start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
             const newStyle = changeStyleFromMark(marks, attrs);
             if (newStyle.changed || attrs.newValue) {
                 const style = newStyle.changed ?
@@ -24,7 +24,7 @@ const changeStyleMark = (tr, from, to, attrs, markType) => {
                 const currentMark = markType.isInSet(marks) ? marks.find(m => m.type.name === 'style') : null;
                 const newMarkAttrs = currentMark ? Object.assign(Object.assign({}, currentMark.attrs), style) : style;
                 const newStyleMark = markType.create(newMarkAttrs);
-                let newSet = newStyleMark.addToSet(marks);
+                const newSet = newStyleMark.addToSet(marks);
                 for (let i = 0; i < marks.length; i++) {
                     if (!marks[i].isInSet(newSet)) {
                         if (removing && removing.to === start && removing.mark.eq(marks[i])) {
@@ -88,7 +88,7 @@ const changeStyle = (markType, attrs) => {
             }
             else {
                 for (let i = 0; i < ranges.length; i++) {
-                    let { $from, $to } = ranges[i];
+                    const { $from, $to } = ranges[i];
                     result = changeStyleMark(transaction, $from.pos, $to.pos, attrs, markType) || result;
                 }
                 if (result) {
@@ -143,7 +143,7 @@ export const applyInlineStyle = (options, command) => (state, dispatch) => {
         tr.setMeta('commandName', command);
     }
     tr.setMeta('args', options);
-    let { empty, $cursor, ranges } = state.selection;
+    const { empty, $cursor, ranges } = state.selection;
     if ((empty && !$cursor) || !markType || !markApplies(state.doc, ranges, markType)) {
         return false;
     }

package/dist/es2015/listConvert.js

@@ -1,4 +1,4 @@
-import { fragmentToHtml, htmlToFragment } from "./source";
+import { fragmentToHtml, htmlToFragment } from './source';
 const msoListRegExp = /style=['"]?[^'"]*?mso-list:\s*[a-zA-Z]+(\d+)\s[a-zA-Z]+(\d+)\s(\w+)/gi;
 const extractListLevels = (html) => {
     html = html.replace(msoListRegExp, (match, list, level) => {
@@ -45,7 +45,7 @@ const mapListsCandidates = (nodes, groups) => {
         if (node.nodeType !== Node.ELEMENT_NODE) {
             return;
         }
-        let element = node;
+        const element = node;
         if (element.getAttribute('datalist')) {
             group.push(node);
             groups.add(group);
@@ -68,7 +68,7 @@ const mapListsCandidates = (nodes, groups) => {
 };
 const listTypes = (p) => {
     let html = p.innerHTML;
-    let trimStartText = (t) => {
+    const trimStartText = (t) => {
         return t.replace(/^(?: |[\u00a0\n\r\s])+/, '');
     };
     html = html.replace(/<\/?\w+[^>]*>/g, '').replace(/&nbsp;/g, '\u00a0');
@@ -125,8 +125,8 @@ const toList = (blockNodes) => {
             datalist: p.getAttribute('datalist'),
             datalevel: p.getAttribute('datalevel')
         };
-        let listIndex = listData.datalist;
-        let listType = listTypes(p);
+        const listIndex = listData.datalist;
+        const listType = listTypes(p);
         type = listType && listType.tag;
         if (!type) {
             if (li && (!isLastRootLi || isPartOfListItem(p))) {
@@ -145,7 +145,7 @@ const toList = (blockNodes) => {
         if (!listData.datalevel && !p.style.marginLeft) {
             continue;
         }
-        let levelType = type + listIndex;
+        const levelType = type + listIndex;
         if (!levels[margin]) {
             levels[margin] = {};
         }

package/dist/es2015/lists.js

@@ -94,13 +94,13 @@ function toggleListCommand(options) {
 }
 function liftListItem(state, selection, tr, nodeType) {
     const listItemNodeType = nodeType || state.schema.nodes.listItem;
-    let { $from, $to } = selection;
+    const { $from, $to } = selection;
     let range = $from.blockRange($to, node => node.childCount && node.firstChild.type === listItemNodeType);
     if (!range || range.depth < 2 || $from.node(range.depth - 1).type !== listItemNodeType) {
         return tr;
     }
-    let end = range.end;
-    let endOfList = $to.end(range.depth);
+    const end = range.end;
+    const endOfList = $to.end(range.depth);
     if (end < endOfList) {
         tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new Slice(Fragment.from(listItemNodeType.create(undefined, range.parent.copy())), 1, 0), 1, true));
         range = new NodeRange(tr.doc.resolve($from.pos), tr.doc.resolve(endOfList), range.depth);
@@ -135,7 +135,7 @@ function isRangeOfType(doc, $from, $to, nodeType) {
 }
 function getAncestorNodesBetween(doc, $from, $to) {
     // Returns all top-level ancestor-nodes between $from and $to
-    const nodes = Array();
+    const nodes = [];
     const maxDepth = findAncestorPosition(doc, $from).depth;
     let current = doc.resolve($from.start(maxDepth));
     while (current.pos <= $to.start($to.depth)) {
@@ -212,6 +212,7 @@ function wrapInList(nodeType, attrs = {}) {
 const reListStyle = /list\-style\-type:\s?([\w-]+)/;
 /**
  * Extracts list-style-type style from node's attributes.
+ *
  * @param attrs - The attributes of the list node
  * @returns The extracted list-style-type.
  */
@@ -253,7 +254,7 @@ export function toggleOrderedList(state, dispatch, view) {
 export const splitListItemKeepMarks = (itemType) => (state, dispatch) => {
     // see https://github.com/ProseMirror/prosemirror-commands/blob/master/src/commands.js#L321-L327
     return splitListItem(itemType)(state, tr => {
-        let marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
+        const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
         if (marks) {
             tr.ensureMarks(marks);
         }

package/dist/es2015/mark.js

@@ -1,10 +1,10 @@
 import { RemoveMarkStep } from 'prosemirror-transform';
 import { MarkType } from 'prosemirror-model';
 export const markApplies = (doc, ranges, type) => {
-    let loop = i => {
-        let ref = ranges[i];
-        let $from = ref.$from;
-        let $to = ref.$to;
+    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) {
@@ -17,7 +17,7 @@ export const markApplies = (doc, ranges, type) => {
         }
     };
     for (let i = 0; i < ranges.length; i++) {
-        let returned = loop(i);
+        const returned = loop(i);
         if (returned) {
             return returned.v;
         }
@@ -25,7 +25,7 @@ export const markApplies = (doc, ranges, type) => {
     return false;
 };
 export const toggleMark = (markType, attrs, tr) => (state, dispatch) => {
-    let { empty, $cursor, ranges } = state.selection;
+    const { empty, $cursor, ranges } = state.selection;
     if ((empty && !$cursor) || !markApplies(state.doc, ranges, markType)) {
         return false;
     }
@@ -41,11 +41,11 @@ export const toggleMark = (markType, attrs, tr) => (state, dispatch) => {
         else {
             let has = false;
             for (let i = 0; !has && i < ranges.length; i++) {
-                let { $from, $to } = ranges[i];
+                const { $from, $to } = ranges[i];
                 has = state.doc.rangeHasMark($from.pos, $to.pos, markType);
             }
             for (let i = 0; i < ranges.length; i++) {
-                let { $from, $to } = ranges[i];
+                const { $from, $to } = ranges[i];
                 if (has) {
                     tr.removeMark($from.pos, $to.pos, markType);
                 }
@@ -70,7 +70,7 @@ export const removeMark = (tr, from, to, mark) => {
         step++;
         let toRemove = null;
         if (mark instanceof MarkType) {
-            let found = mark.isInSet(node.marks);
+            const found = mark.isInSet(node.marks);
             if (found) {
                 toRemove = [found];
             }
@@ -84,11 +84,11 @@ export const removeMark = (tr, from, to, mark) => {
             toRemove = node.marks;
         }
         if (toRemove && toRemove.length) {
-            let end = Math.min(pos + node.nodeSize, to);
+            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++) {
-                    let m = matched[j];
+                    const m = matched[j];
                     if (m.step === step - 1 && style.eq(m.style)) {
                         found$1 = m;
                     }
@@ -107,7 +107,7 @@ export const removeMark = (tr, from, to, mark) => {
     return tr;
 };
 export const removeMarks = (marks, state, dispatch, tr) => {
-    let { $cursor, ranges } = state.selection;
+    const { $cursor, ranges } = state.selection;
     tr = tr || state.tr;
     if ($cursor) {
         marks.forEach(m => {
@@ -118,7 +118,7 @@ export const removeMarks = (marks, state, dispatch, tr) => {
     }
     else {
         for (let i = 0; i < ranges.length; i++) {
-            let { $from, $to } = ranges[i];
+            const { $from, $to } = ranges[i];
             marks.forEach(m => {
                 removeMark(tr, $from.pos, $to.pos, m);
             });
@@ -164,7 +164,7 @@ export const hasMark = (state, options) => {
     const marks = state.schema.marks;
     const altMarks = (options.altMarks || []).filter(m => marks[m]);
     const altStyle = options.altStyle;
-    let { from, $from, to, empty } = state.selection;
+    const { from, $from, to, empty } = state.selection;
     const type = marks[options.mark];
     const doc = state.doc;
     let result = false;
@@ -197,8 +197,8 @@ export const styleValue = (mark, style) => {
  * Returns the marks of a specific type for every inline node in the selection.
  */
 export const selectionMarks = (state, markType) => {
-    let { from, $from, to, empty } = state.selection;
-    let marks = [];
+    const { from, $from, to, empty } = state.selection;
+    const marks = [];
     if (empty) {
         marks.push(markType.isInSet(state.storedMarks || $from.marks()));
     }
@@ -226,7 +226,7 @@ export const getMark = (state, markType) => {
 export const getActiveMarks = (state, markType) => {
     const marks = selectionMarks(state, markType);
     const filtered = marks.filter(m => Boolean(m));
-    let hasNodesWithoutMarks = marks.length !== filtered.length;
+    const hasNodesWithoutMarks = marks.length !== filtered.length;
     return {
         hasNodesWithoutMarks,
         marks: filtered

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

@@ -1,5 +1,5 @@
 import { Plugin, PluginKey } from 'prosemirror-state';
-import { Decoration, DecorationSet } from "prosemirror-view";
+import { Decoration, DecorationSet } from 'prosemirror-view';
 import { styleValue } from './../mark';
 export const caretColorKey = new PluginKey('caret-color');
 export function caretColor() {

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

@@ -1,7 +1,7 @@
-import { Plugin, PluginKey } from "prosemirror-state";
-import { setAttribute } from "../utils";
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { setAttribute } from '../utils';
 const setAttributes = (dom, attrs) => {
-    for (let attrName in attrs) {
+    for (const attrName in attrs) {
         if (attrName) {
             setAttribute(dom, attrName, attrs[attrName]);
         }
@@ -17,7 +17,7 @@ class CustomNodeView {
     }
 }
 class StyleView {
-    constructor(mark, view, _inline) {
+    constructor(mark, view) {
         this.mark = mark;
         this.view = view;
         this.dom = document.createElement('span');
@@ -41,7 +41,7 @@ export const cspFix = () => {
                 image: (node, view) => new CustomNodeView(node, view, 'img', true)
             },
             markViews: {
-                style: (mark, view, inline) => new StyleView(mark, view, inline)
+                style: (mark, view) => new StyleView(mark, view)
             }
         }
     });

package/dist/es2015/plugins/highlight.js

@@ -1,5 +1,5 @@
 import { Plugin, PluginKey } from 'prosemirror-state';
-import { Decoration, DecorationSet } from "prosemirror-view";
+import { Decoration, DecorationSet } from 'prosemirror-view';
 // https://discuss.prosemirror.net/t/passing-data-between-plugins/1843
 export const textHighlightKey = new PluginKey('highlight');
 export function textHighlight(key = textHighlightKey) {

package/dist/es2015/plugins/image-resize.js

@@ -1,7 +1,7 @@
-import { NodeSelection, Plugin, PluginKey } from "prosemirror-state";
-import { Decoration, DecorationSet } from "prosemirror-view";
-import { dataResizeDirImage, resizeHandle } from "../config/constants";
-import { changeStylesString } from "../utils";
+import { NodeSelection, Plugin, PluginKey } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { dataResizeDirImage, resizeHandle } from '../config/constants';
+import { changeStylesString } from '../utils';
 import { directions, handles } from './resize-utils';
 export const imageResizeKey = new PluginKey('image-resize');
 const setSize = (domNode, sizeType, value) => {
@@ -17,11 +17,11 @@ class ResizeState {
         this.nodePosition = nodePosition;
     }
     apply(tr) {
-        let state = this, next = tr.getMeta(imageResizeKey);
+        const next = tr.getMeta(imageResizeKey);
         if (next) {
             return new ResizeState(next.activeHandle, next.setDragging, next.rect, next.nodePosition);
         }
-        return state;
+        return this;
     }
 }
 const handleMouseMove = (view, event, options) => {
@@ -37,9 +37,9 @@ const handleMouseMove = (view, event, options) => {
     let width = dir.x ? diffX + img.width : rect.width;
     let height = dir.y ? diffY + img.height : rect.height;
     if (options.lockRatio && dir.x && dir.y) {
-        let ratio = Math.min(width / img.width, height / img.height);
-        let lockWidth = img.width * ratio;
-        let lockHeight = img.height * ratio;
+        const ratio = Math.min(width / img.width, height / img.height);
+        const lockWidth = img.width * ratio;
+        const lockHeight = img.height * ratio;
         dragging.startX = event.clientX - (width - lockWidth) * dir.x;
         dragging.startY = event.clientY - (height - lockHeight) * dir.y;
         width = lockWidth;
@@ -208,7 +208,7 @@ export const imageResizing = (options = { node: 'image', lockRatio: true }) => {
                     wrapper.style.top = rect.top + 'px';
                     wrapper.style.left = rect.left + 'px';
                     for (let i = 0; i < handles.length; i++) {
-                        let dom = document.createElement('div');
+                        const dom = document.createElement('div');
                         dom.className = resizeHandle + ' ' + handles[i];
                         dom.setAttribute(dataResizeDirImage, handles[i]);
                         wrapper.appendChild(dom);

package/dist/es2015/plugins/list-markers-styles.js

@@ -35,7 +35,7 @@ const applyToListItems = (tr, state, options) => {
 const cleanListItems = (tr, state, options) => {
     const stylesToClean = Object.keys(options.resetValues);
     const { tr: transaction, doc, selection: { from, to } } = state;
-    doc.nodesBetween(from, to, (node, pos, _parent) => {
+    doc.nodesBetween(from, to, (node, pos) => {
         if (node.type.name === options.listItem && inSelection(from, to, pos, node, doc)) {
             let attrs = node.attrs;
             const nodeStyles = parseStyle(node.attrs.style);
@@ -53,7 +53,7 @@ const cleanListItems = (tr, state, options) => {
         if (step instanceof RemoveMarkStep) {
             const mark = step.mark;
             if (mark.type.name === 'style' && mark.attrs.style) {
-                const [name, _value] = mark.attrs.style.split(/\s*:\s*/);
+                const [name] = mark.attrs.style.split(/\s*:\s*/);
                 const $pos = transaction.doc.resolve(step.from);
                 const li = parentNode($pos, n => n.type.name === options.listItem);
                 if (li) {