@limetech/lime-elements 40.5.2 → 40.5.4

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

@@ -1,18 +1,18 @@
 import { r as registerInstance, c as createEvent, h, H as Host, a as getElement } from './index-Bnc9lzk2.js';
 import { L as LevelMapping, E as EditorMenuTypes, i as isInlineImageTag, M as MouseButtons, e as editorMenuTypesArray } from './types-C_Yu8dOg.js';
 import { g as getLinkAttributes, m as markdownToHTML, s as sanitizeHTML } from './markdown-parser-DrxxGLF5.js';
-import { h as cloneDeep } from './cloneDeep-CL7UD3mR.js';
+import { c as cloneDeep } from './cloneDeep-DAbOtbs8.js';
 import { t as translate } from './translations-DMtX4tTX.js';
 import { c as decodeHTML, e as decodeHTMLStrict } from './index-CbciMfiU.js';
 import { c as createRandomString } from './random-string-JbKhhoXs.js';
 import { i as isItem } from './is-item-CrvUOVvg.js';
 import { c as createFileInfo } from './files-DnkFEKoB.js';
-import { i as isEqual } from './isEqual-4tbMaaf_.js';
+import { i as isEqual } from './isEqual-CE83yS8T.js';
 import { d as debounce } from './debounce-B67JMchz.js';
 import './_commonjsHelpers-B85MJLTf.js';
-import './_baseIsEqual-B6bIeexY.js';
+import './_baseIsEqual-CyF4P8uM.js';
 import './eq-CZ30nDJE.js';
-import './_getTag-CMJL-6hk.js';
+import './_getTag-BiAaLWvH.js';
 import './isObject-BJQylLSL.js';
 import './isObjectLike-oiMYqRQ0.js';
 import './isArrayLike-CyVGB489.js';
@@ -22,7 +22,7 @@ import './isArray-B8VKuhvH.js';
 import './_isIndex-B--C3qwe.js';
 import './_assignValue-CEFvyZxO.js';
 import './_defineProperty-C69Btzid.js';
-import './_getAllKeysIn-kT3KizYN.js';
+import './_getPrototype-B0kMNv1F.js';
 import './language-C3hECvXE.js';
 import './file-metadata-BHzkIH4g.js';
 import './icons-Bu_YRgCL.js';
@@ -680,7 +680,6 @@ class Mark {
         if (!type)
             throw new RangeError(`There is no mark type ${json.type} in this schema`);
         let mark = type.create(json.attrs);
-        type.checkAttrs(mark.attrs);
         return mark;
     }
     /**
@@ -1660,11 +1659,11 @@ class Node {
     */
     check() {
         this.type.checkContent(this.content);
-        this.type.checkAttrs(this.attrs);
+        checkAttrs(this.type.attrs, this.attrs, "node", this.type.name);
         let copy = Mark.none;
         for (let i = 0; i < this.marks.length; i++) {
             let mark = this.marks[i];
-            mark.type.checkAttrs(mark.attrs);
+            checkAttrs(mark.type.attrs, mark.attrs, "mark", mark.type.name);
             copy = mark.addToSet(copy);
         }
         if (!Mark.sameSet(copy, this.marks))
@@ -1705,7 +1704,6 @@ class Node {
         }
         let content = Fragment.fromJSON(schema, json.content);
         let node = schema.nodeType(json.type).create(json.attrs, content, marks);
-        node.type.checkAttrs(node.attrs);
         return node;
     }
 }
@@ -1755,6 +1753,15 @@ function wrapMarks(marks, str) {
         str = marks[i].type.name + "(" + str + ")";
     return str;
 }
+function checkAttrs(attrs, values, type, name) {
+    for (let attr in values)
+        if (!(attr in attrs))
+            throw new RangeError(`Unsupported attribute ${attr} for ${type} of type ${name}`);
+    for (let attr in attrs) {
+        if (attrs[attr].validate)
+            attrs[attr].validate(values[attr]);
+    }
+}
 
 /**
 Instances of this class represent a match state of a node type's
@@ -2209,27 +2216,21 @@ function defaultAttrs(attrs) {
 function computeAttrs(attrs, value) {
     let built = Object.create(null);
     for (let name in attrs) {
+        let attr = attrs[name];
         let given = value && value[name];
         if (given === undefined) {
-            let attr = attrs[name];
             if (attr.hasDefault)
                 given = attr.default;
             else
                 throw new RangeError("No value supplied for attribute " + name);
         }
+        else if (attr.validate) {
+            attr.validate(given);
+        }
         built[name] = given;
     }
     return built;
 }
-function checkAttrs(attrs, values, type, name) {
-    for (let attr in values)
-        if (!(attr in attrs))
-            throw new RangeError(`Unsupported attribute ${attr} for ${type} of type ${name}`);
-    for (let attr in attrs) {
-        if (attrs[attr].validate)
-            attrs[attr].validate(values[attr]);
-    }
-}
 function initAttrs(typeName, attrs) {
     let result = Object.create(null);
     if (attrs)
@@ -2401,11 +2402,9 @@ let NodeType$1 = class NodeType {
             throw new RangeError(`Invalid content for node ${this.name}: ${content.toString().slice(0, 50)}`);
     }
     /**
-    @internal
+    @internal no longer useful, but called by old prosemirror-view versions
     */
-    checkAttrs(attrs) {
-        checkAttrs(this.attrs, attrs, "node", this.name);
-    }
+    checkAttrs(attrs) { }
     /**
     Check whether the given mark type is allowed in this node.
     */
@@ -2552,12 +2551,6 @@ class MarkType {
                 return set[i];
     }
     /**
-    @internal
-    */
-    checkAttrs(attrs) {
-        checkAttrs(this.attrs, attrs, "mark", this.name);
-    }
-    /**
     Queries whether a given mark type is
     [excluded](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) by this one.
     */
@@ -15273,7 +15266,6 @@ function arrayReplaceAt (src, pos, newElements) {
 }
 
 function isValidEntityCode (c) {
-  /* eslint no-bitwise:0 */
   // broken sequence
   if (c >= 0xD800 && c <= 0xDFFF) { return false }
   // never used
@@ -15301,8 +15293,8 @@ function fromCodePoint (c) {
   return String.fromCharCode(c)
 }
 
-const UNESCAPE_MD_RE  = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
-const ENTITY_RE       = /&([a-z#][a-z0-9]{1,31});/gi;
+const UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
+const ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
 const UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');
 
 const DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i;
@@ -15328,12 +15320,6 @@ function replaceEntityPattern (match, name) {
   return match
 }
 
-/* function replaceEntities(str) {
-  if (str.indexOf('&') < 0) { return str; }
-
-  return str.replace(ENTITY_RE, replaceEntityPattern);
-} */
-
 function unescapeMd (str) {
   if (str.indexOf('\\') < 0) { return str }
   return str.replace(UNESCAPE_MD_RE, '$1')
@@ -15403,8 +15389,6 @@ function isWhiteSpace (code) {
   return false
 }
 
-/* eslint-disable max-len */
-
 // Currently without astral characters support.
 function isPunctChar (ch) {
   return P.test(ch) || regex.test(ch)
@@ -15664,7 +15648,7 @@ function parseLinkDestination (str, start, max) {
     if (code < 0x20 || code === 0x7F) { break }
 
     if (code === 0x5C /* \ */ && pos + 1 < max) {
-      if (str.charCodeAt(pos + 1) === 0x20) { break }
+      if (str.charCodeAt(pos + 1) === 0x20) { pos++; continue }
       pos += 2;
       continue
     }
@@ -15780,7 +15764,7 @@ const default_rules = {};
 default_rules.code_inline = function (tokens, idx, options, env, slf) {
   const token = tokens[idx];
 
-  return  '<code' + slf.renderAttrs(token) + '>' +
+  return '<code' + slf.renderAttrs(token) + '>' +
           escapeHtml(token.content) +
           '</code>'
 };
@@ -15788,7 +15772,7 @@ default_rules.code_inline = function (tokens, idx, options, env, slf) {
 default_rules.code_block = function (tokens, idx, options, env, slf) {
   const token = tokens[idx];
 
-  return  '<pre' + slf.renderAttrs(token) + '><code>' +
+  return '<pre' + slf.renderAttrs(token) + '><code>' +
           escapeHtml(tokens[idx].content) +
           '</code></pre>\n'
 };
@@ -16441,28 +16425,28 @@ function Token (type, tag, nesting) {
    *
    * Type of the token (string, e.g. "paragraph_open")
    **/
-  this.type     = type;
+  this.type = type;
 
   /**
    * Token#tag -> String
    *
    * html tag name, e.g. "p"
    **/
-  this.tag      = tag;
+  this.tag = tag;
 
   /**
    * Token#attrs -> Array
    *
    * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
    **/
-  this.attrs    = null;
+  this.attrs = null;
 
   /**
    * Token#map -> Array
    *
    * Source map info. Format: `[ line_begin, line_end ]`
    **/
-  this.map      = null;
+  this.map = null;
 
   /**
    * Token#nesting -> Number
@@ -16473,14 +16457,14 @@ function Token (type, tag, nesting) {
    * -  `0` means the tag is self-closing
    * - `-1` means the tag is closing
    **/
-  this.nesting  = nesting;
+  this.nesting = nesting;
 
   /**
    * Token#level -> Number
    *
    * nesting level, the same as `state.level`
    **/
-  this.level    = 0;
+  this.level = 0;
 
   /**
    * Token#children -> Array
@@ -16495,14 +16479,14 @@ function Token (type, tag, nesting) {
    * In a case of self-closing tag (code, html, fence, etc.),
    * it has contents of this tag.
    **/
-  this.content  = '';
+  this.content = '';
 
   /**
    * Token#markup -> String
    *
    * '*' or '_' for emphasis, fence string for fence, etc.
    **/
-  this.markup   = '';
+  this.markup = '';
 
   /**
    * Token#info -> String
@@ -16513,14 +16497,14 @@ function Token (type, tag, nesting) {
    * - The value "auto" for autolink "link_open" and "link_close" tokens
    * - The string value of the item marker for ordered-list "list_item_open" tokens
    **/
-  this.info     = '';
+  this.info = '';
 
   /**
    * Token#meta -> Object
    *
    * A place for plugins to store an arbitrary data
    **/
-  this.meta     = null;
+  this.meta = null;
 
   /**
    * Token#block -> Boolean
@@ -16528,7 +16512,7 @@ function Token (type, tag, nesting) {
    * True for block-level tokens, false for inline tokens.
    * Used in renderer to calculate line breaks
    **/
-  this.block    = false;
+  this.block = false;
 
   /**
    * Token#hidden -> Boolean
@@ -16536,7 +16520,7 @@ function Token (type, tag, nesting) {
    * If it's true, ignore this element when rendering. Used for tight lists
    * to hide paragraphs.
    **/
-  this.hidden   = false;
+  this.hidden = false;
 }
 
 /**
@@ -16632,8 +16616,8 @@ StateCore.prototype.Token = Token;
 // Normalize input string
 
 // https://spec.commonmark.org/0.29/#line-ending
-const NEWLINES_RE  = /\r\n?|\n/g;
-const NULL_RE      = /\0/g;
+const NEWLINES_RE = /\r\n?|\n/g;
+const NULL_RE = /\0/g;
 
 function normalize$1 (state) {
   let str;
@@ -16651,9 +16635,9 @@ function block (state) {
   let token;
 
   if (state.inlineMode) {
-    token          = new state.Token('inline', '', 0);
-    token.content  = state.src;
-    token.map      = [0, 1];
+    token = new state.Token('inline', '', 0);
+    token.content = state.src;
+    token.map = [0, 1];
     token.children = [];
     state.tokens.push(token);
   } else {
@@ -16678,7 +16662,6 @@ function inline (state) {
 // Currently restricted by `md.validateLink()` to http/https/ftp
 //
 
-
 function isLinkOpen$1 (str) {
   return /^<a[>\s]/i.test(str)
 }
@@ -16697,7 +16680,8 @@ function linkify$1 (state) {
       continue
     }
 
-    let tokens = blockTokens[j].children;
+    const tokens = blockTokens[j].children;
+    const replacements = [];
 
     let htmlLinkLevel = 0;
 
@@ -16767,43 +16751,70 @@ function linkify$1 (state) {
           const pos = links[ln].index;
 
           if (pos > lastPos) {
-            const token   = new state.Token('text', '', 0);
+            const token = new state.Token('text', '', 0);
             token.content = text.slice(lastPos, pos);
-            token.level   = level;
+            token.level = level;
             nodes.push(token);
           }
 
-          const token_o   = new state.Token('link_open', 'a', 1);
-          token_o.attrs   = [['href', fullUrl]];
-          token_o.level   = level++;
-          token_o.markup  = 'linkify';
-          token_o.info    = 'auto';
+          const token_o = new state.Token('link_open', 'a', 1);
+          token_o.attrs = [['href', fullUrl]];
+          token_o.level = level++;
+          token_o.markup = 'linkify';
+          token_o.info = 'auto';
           nodes.push(token_o);
 
-          const token_t   = new state.Token('text', '', 0);
+          const token_t = new state.Token('text', '', 0);
           token_t.content = urlText;
-          token_t.level   = level;
+          token_t.level = level;
           nodes.push(token_t);
 
-          const token_c   = new state.Token('link_close', 'a', -1);
-          token_c.level   = --level;
-          token_c.markup  = 'linkify';
-          token_c.info    = 'auto';
+          const token_c = new state.Token('link_close', 'a', -1);
+          token_c.level = --level;
+          token_c.markup = 'linkify';
+          token_c.info = 'auto';
           nodes.push(token_c);
 
           lastPos = links[ln].lastIndex;
         }
         if (lastPos < text.length) {
-          const token   = new state.Token('text', '', 0);
+          const token = new state.Token('text', '', 0);
           token.content = text.slice(lastPos);
-          token.level   = level;
+          token.level = level;
           nodes.push(token);
         }
 
-        // replace current node
-        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
+        replacements.push({ index: i, nodes });
       }
     }
+
+    if (replacements.length > 0) {
+      let newTokensLength = tokens.length;
+      for (const replacement of replacements) {
+        newTokensLength += replacement.nodes.length - 1;
+      }
+
+      const newTokens = new Array(newTokensLength);
+      let replacementIndex = 0;
+      let newTokenIndex = 0;
+
+      replacements.reverse();
+
+      for (let i = 0; i < tokens.length; i++) {
+        const replacement = replacements[replacementIndex];
+
+        if (replacement?.index === i) {
+          for (const node of replacement.nodes) {
+            newTokens[newTokenIndex++] = node;
+          }
+          replacementIndex++;
+        } else {
+          newTokens[newTokenIndex++] = tokens[i];
+        }
+      }
+
+      blockTokens[j].children = newTokens;
+    }
   }
 }
 
@@ -16916,6 +16927,19 @@ function replace (state) {
 const QUOTE_TEST_RE = /['"]/;
 const QUOTE_RE = /['"]/g;
 const APOSTROPHE = '\u2019'; /* ’ */
+// Caps memory on malicious input
+const MAX_OPENERS = 1000;
+
+function truncateStack (stack, heads, length) {
+  while (stack.length > length) {
+    const item = stack.pop();
+    if (item.isSingleQuote) {
+      heads.single = item.prevSameQuoteIdx;
+    } else {
+      heads.double = item.prevSameQuoteIdx;
+    }
+  }
+}
 
 function addReplacement (replacements, tokenIdx, pos, ch) {
   if (!replacements[tokenIdx]) {
@@ -16945,6 +16969,8 @@ function process_inlines (tokens, state) {
   let j;
 
   const stack = [];
+  // stack indexes of topmost openers of each type (-1 if none)
+  const heads = { single: -1, double: -1 };
   // token index -> list of replacements in the original token content
   const replacements = {};
 
@@ -16956,7 +16982,7 @@ function process_inlines (tokens, state) {
     for (j = stack.length - 1; j >= 0; j--) {
       if (stack[j].level <= thisLevel) { break }
     }
-    stack.length = j + 1;
+    truncateStack(stack, heads, j + 1);
 
     if (token.type !== 'text') { continue }
 
@@ -17060,39 +17086,45 @@ function process_inlines (tokens, state) {
       }
 
       if (canClose) {
-        // this could be a closing quote, rewind the stack to get a match
-        for (j = stack.length - 1; j >= 0; j--) {
-          let item = stack[j];
-          if (stack[j].level < thisLevel) { break }
-          if (item.single === isSingle && stack[j].level === thisLevel) {
-            item = stack[j];
-
-            let openQuote;
-            let closeQuote;
-            if (isSingle) {
-              openQuote = state.md.options.quotes[2];
-              closeQuote = state.md.options.quotes[3];
-            } else {
-              openQuote = state.md.options.quotes[0];
-              closeQuote = state.md.options.quotes[1];
-            }
+        // Stack levels never decrease, so an opener of this type below
+        // the current level means there is no match
+        j = isSingle ? heads.single : heads.double;
+        if (j >= 0 && stack[j].level === thisLevel) {
+          const item = stack[j];
+
+          let openQuote;
+          let closeQuote;
+          if (isSingle) {
+            openQuote = state.md.options.quotes[2];
+            closeQuote = state.md.options.quotes[3];
+          } else {
+            openQuote = state.md.options.quotes[0];
+            closeQuote = state.md.options.quotes[1];
+          }
 
-            addReplacement(replacements, i, t.index, closeQuote);
-            addReplacement(replacements, item.token, item.pos, openQuote);
+          addReplacement(replacements, i, t.index, closeQuote);
+          addReplacement(replacements, item.tokenIdx, item.contentPos, openQuote);
 
-            stack.length = j;
-            continue OUTER
-          }
+          truncateStack(stack, heads, j);
+          continue OUTER
         }
       }
 
       if (canOpen) {
+        if (stack.length >= MAX_OPENERS) { return }
         stack.push({
-          token: i,
-          pos: t.index,
-          single: isSingle,
-          level: thisLevel
+          tokenIdx: i,
+          contentPos: t.index,
+          isSingleQuote: isSingle,
+          level: thisLevel,
+          // stack index of the previous opener of the same quote type, -1 if none
+          prevSameQuoteIdx: isSingle ? heads.single : heads.double
         });
+        if (isSingle) {
+          heads.single = stack.length - 1;
+        } else {
+          heads.double = stack.length - 1;
+        }
       } else if (canClose && isSingle) {
         addReplacement(replacements, i, t.index, APOSTROPHE);
       }
@@ -17171,15 +17203,15 @@ function text_join (state) {
 
 
 const _rules$2 = [
-  ['normalize',      normalize$1],
-  ['block',          block],
-  ['inline',         inline],
-  ['linkify',        linkify$1],
-  ['replacements',   replace],
-  ['smartquotes',    smartquotes],
+  ['normalize', normalize$1],
+  ['block', block],
+  ['inline', inline],
+  ['linkify', linkify$1],
+  ['replacements', replace],
+  ['smartquotes', smartquotes],
   // `text_join` finds `text_special` tokens (for escape sequences)
   // and joins them with the rest of the text
-  ['text_join',      text_join]
+  ['text_join', text_join]
 ];
 
 /**
@@ -17220,7 +17252,7 @@ function StateBlock (src, md, env, tokens) {
   this.src = src;
 
   // link to parser instance
-  this.md     = md;
+  this.md = md;
 
   this.env = env;
 
@@ -17251,11 +17283,11 @@ function StateBlock (src, md, env, tokens) {
 
   // required block content indent (for example, if we are
   // inside a list, it would be positioned after list marker)
-  this.blkIndent  = 0;
-  this.line       = 0; // line index in src
-  this.lineMax    = 0; // lines count
-  this.tight      = false;  // loose/tight mode for lists
-  this.ddIndent   = -1; // indent of the current dd block (-1 if there isn't any)
+  this.blkIndent = 0;
+  this.line = 0; // line index in src
+  this.lineMax = 0; // lines count
+  this.tight = false;  // loose/tight mode for lists
+  this.ddIndent = -1; // indent of the current dd block (-1 if there isn't any)
   this.listIndent = -1; // indent of the current list block (-1 if there isn't any)
 
   // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
@@ -17582,11 +17614,11 @@ function table (state, startLine, endLine, silent) {
   for (let i = 0; i < columns.length; i++) {
     const token_ho = state.push('th_open', 'th', 1);
     if (aligns[i]) {
-      token_ho.attrs  = [['style', 'text-align:' + aligns[i]]];
+      token_ho.attrs = [['style', 'text-align:' + aligns[i]]];
     }
 
     const token_il = state.push('inline', '', 0);
-    token_il.content  = columns[i].trim();
+    token_il.content = columns[i].trim();
     token_il.children = [];
 
     state.push('th_close', 'th', -1);
@@ -17633,11 +17665,11 @@ function table (state, startLine, endLine, silent) {
     for (let i = 0; i < columnCount; i++) {
       const token_tdo = state.push('td_open', 'td', 1);
       if (aligns[i]) {
-        token_tdo.attrs  = [['style', 'text-align:' + aligns[i]]];
+        token_tdo.attrs = [['style', 'text-align:' + aligns[i]]];
       }
 
       const token_il = state.push('inline', '', 0);
-      token_il.content  = columns[i] ? columns[i].trim() : '';
+      token_il.content = columns[i] ? columns[i].trim() : '';
       token_il.children = [];
 
       state.push('td_close', 'td', -1);
@@ -17682,9 +17714,9 @@ function code$1 (state, startLine, endLine/*, silent */) {
 
   state.line = last;
 
-  const token   = state.push('code_block', 'code', 0);
+  const token = state.push('code_block', 'code', 0);
   token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + '\n';
-  token.map     = [startLine, state.line];
+  token.map = [startLine, state.line];
 
   return true
 }
@@ -17775,11 +17807,11 @@ function fence (state, startLine, endLine, silent) {
 
   state.line = nextLine + (haveEndMarker ? 1 : 0);
 
-  const token   = state.push('fence', 'code', 0);
-  token.info    = params;
+  const token = state.push('fence', 'code', 0);
+  token.info = params;
   token.content = state.getLines(startLine + 1, nextLine, len, true);
-  token.markup  = markup;
-  token.map     = [startLine, state.line];
+  token.markup = markup;
+  token.map = [startLine, state.line];
 
   return true
 }
@@ -17803,10 +17835,10 @@ function blockquote (state, startLine, endLine, silent) {
   // so no point trying to find the end of it in silent mode
   if (silent) { return true }
 
-  const oldBMarks  = [];
+  const oldBMarks = [];
   const oldBSCount = [];
-  const oldSCount  = [];
-  const oldTShift  = [];
+  const oldSCount = [];
+  const oldTShift = [];
 
   const terminatorRules = state.md.block.ruler.getRules('blockquote');
 
@@ -17966,14 +17998,14 @@ function blockquote (state, startLine, endLine, silent) {
   const oldIndent = state.blkIndent;
   state.blkIndent = 0;
 
-  const token_o  = state.push('blockquote_open', 'blockquote', 1);
+  const token_o = state.push('blockquote_open', 'blockquote', 1);
   token_o.markup = '>';
   const lines = [startLine, 0];
-  token_o.map    = lines;
+  token_o.map = lines;
 
   state.md.block.tokenize(state, startLine, nextLine);
 
-  const token_c  = state.push('blockquote_close', 'blockquote', -1);
+  const token_c = state.push('blockquote_close', 'blockquote', -1);
   token_c.markup = '>';
 
   state.lineMax = oldLineMax;
@@ -18026,8 +18058,8 @@ function hr (state, startLine, endLine, silent) {
 
   state.line = startLine + 1;
 
-  const token  = state.push('hr', 'hr', 0);
-  token.map    = [startLine, state.line];
+  const token = state.push('hr', 'hr', 0);
+  token.map = [startLine, state.line];
   token.markup = Array(cnt + 1).join(String.fromCharCode(marker));
 
   return true
@@ -18190,16 +18222,16 @@ function list (state, startLine, endLine, silent) {
   const listTokIdx = state.tokens.length;
 
   if (isOrdered) {
-    token       = state.push('ordered_list_open', 'ol', 1);
+    token = state.push('ordered_list_open', 'ol', 1);
     if (markerValue !== 1) {
       token.attrs = [['start', markerValue]];
     }
   } else {
-    token       = state.push('bullet_list_open', 'ul', 1);
+    token = state.push('bullet_list_open', 'ul', 1);
   }
 
   const listLines = [nextLine, 0];
-  token.map    = listLines;
+  token.map = listLines;
   token.markup = String.fromCharCode(markerCharCode);
 
   //
@@ -18252,10 +18284,10 @@ function list (state, startLine, endLine, silent) {
     const indent = initial + indentAfterMarker;
 
     // Run subparser & write tokens
-    token        = state.push('list_item_open', 'li', 1);
+    token = state.push('list_item_open', 'li', 1);
     token.markup = String.fromCharCode(markerCharCode);
     const itemLines = [nextLine, 0];
-    token.map    = itemLines;
+    token.map = itemLines;
     if (isOrdered) {
       token.info = state.src.slice(start, posAfterMarker - 1);
     }
@@ -18304,7 +18336,7 @@ function list (state, startLine, endLine, silent) {
     state.sCount[nextLine] = oldSCount;
     state.tight = oldTight;
 
-    token        = state.push('list_item_close', 'li', -1);
+    token = state.push('list_item_close', 'li', -1);
     token.markup = String.fromCharCode(markerCharCode);
 
     nextLine = state.line;
@@ -18641,23 +18673,23 @@ var block_names = [
 
 // Regexps to match html elements
 
-const attr_name     = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
+const attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
 
-const unquoted      = '[^"\'=<>`\\x00-\\x20]+';
+const unquoted = '[^"\'=<>`\\x00-\\x20]+';
 const single_quoted = "'[^']*'";
 const double_quoted = '"[^"]*"';
 
-const attr_value  = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';
+const attr_value = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';
 
-const attribute   = '(?:\\s+' + attr_name + '(?:\\s*=\\s*' + attr_value + ')?)';
+const attribute = '(?:\\s+' + attr_name + '(?:\\s*=\\s*' + attr_value + ')?)';
 
-const open_tag    = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>';
+const open_tag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>';
 
-const close_tag   = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
-const comment     = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->';
-const processing  = '<[?][\\s\\S]*?[?]>';
+const close_tag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
+const comment = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->';
+const processing = '<[?][\\s\\S]*?[?]>';
 const declaration = '<![A-Za-z][^>]*>';
-const cdata       = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
+const cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
 
 const HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +
                         '|' + processing + '|' + declaration + '|' + cdata + ')');
@@ -18671,12 +18703,12 @@ const HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag +
 //
 const HTML_SEQUENCES = [
   [/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true],
-  [/^<!--/,        /-->/,   true],
-  [/^<\?/,         /\?>/,   true],
-  [/^<![A-Z]/,     />/,     true],
+  [/^<!--/, /-->/, true],
+  [/^<\?/, /\?>/, true],
+  [/^<![A-Za-z]/, />/, true],
   [/^<!\[CDATA\[/, /\]\]>/, true],
   [new RegExp('^</?(' + block_names.join('|') + ')(?=(\\s|/?>|$))', 'i'), /^$/, true],
-  [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\s*$'),  /^$/, false]
+  [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\s*$'), /^$/, false]
 ];
 
 function html_block (state, startLine, endLine, silent) {
@@ -18735,8 +18767,8 @@ function html_block (state, startLine, endLine, silent) {
 
   state.line = nextLine;
 
-  const token   = state.push('html_block', '', 0);
-  token.map     = [startLine, nextLine];
+  const token = state.push('html_block', '', 0);
+  token.map = [startLine, nextLine];
   token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
 
   return true
@@ -18752,7 +18784,7 @@ function heading (state, startLine, endLine, silent) {
   // if it's indented more than 3 spaces, it should be a code block
   if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
 
-  let ch  = state.src.charCodeAt(pos);
+  let ch = state.src.charCodeAt(pos);
 
   if (ch !== 0x23/* # */ || pos >= max) { return false }
 
@@ -18778,16 +18810,16 @@ function heading (state, startLine, endLine, silent) {
 
   state.line = startLine + 1;
 
-  const token_o  = state.push('heading_open', 'h' + String(level), 1);
+  const token_o = state.push('heading_open', 'h' + String(level), 1);
   token_o.markup = '########'.slice(0, level);
-  token_o.map    = [startLine, state.line];
+  token_o.map = [startLine, state.line];
 
-  const token_i    = state.push('inline', '', 0);
-  token_i.content  = asciiTrim(state.src.slice(pos, max));
-  token_i.map      = [startLine, state.line];
+  const token_i = state.push('inline', '', 0);
+  token_i.content = asciiTrim(state.src.slice(pos, max));
+  token_i.map = [startLine, state.line];
   token_i.children = [];
 
-  const token_c  = state.push('heading_close', 'h' + String(level), -1);
+  const token_c = state.push('heading_close', 'h' + String(level), -1);
   token_c.markup = '########'.slice(0, level);
 
   return true
@@ -18861,17 +18893,17 @@ function lheading (state, startLine, endLine/*, silent */) {
 
   state.line = nextLine + 1;
 
-  const token_o    = state.push('heading_open', 'h' + String(level), 1);
-  token_o.markup   = String.fromCharCode(marker);
-  token_o.map      = [startLine, state.line];
+  const token_o = state.push('heading_open', 'h' + String(level), 1);
+  token_o.markup = String.fromCharCode(marker);
+  token_o.map = [startLine, state.line];
 
-  const token_i    = state.push('inline', '', 0);
-  token_i.content  = content;
-  token_i.map      = [startLine, state.line - 1];
+  const token_i = state.push('inline', '', 0);
+  token_i.content = content;
+  token_i.map = [startLine, state.line - 1];
   token_i.children = [];
 
-  const token_c    = state.push('heading_close', 'h' + String(level), -1);
-  token_c.markup   = String.fromCharCode(marker);
+  const token_c = state.push('heading_close', 'h' + String(level), -1);
+  token_c.markup = String.fromCharCode(marker);
 
   state.parentType = oldParentType;
 
@@ -18911,12 +18943,12 @@ function paragraph (state, startLine, endLine) {
 
   state.line = nextLine;
 
-  const token_o    = state.push('paragraph_open', 'p', 1);
-  token_o.map      = [startLine, state.line];
+  const token_o = state.push('paragraph_open', 'p', 1);
+  token_o.map = [startLine, state.line];
 
-  const token_i    = state.push('inline', '', 0);
-  token_i.content  = content;
-  token_i.map      = [startLine, state.line];
+  const token_i = state.push('inline', '', 0);
+  token_i.content = content;
+  token_i.map = [startLine, state.line];
   token_i.children = [];
 
   state.push('paragraph_close', 'p', -1);
@@ -18936,17 +18968,17 @@ function paragraph (state, startLine, endLine) {
 const _rules$1 = [
   // First 2 params - rule name & source. Secondary array - list of rules,
   // which can be terminated by this one.
-  ['table',      table,      ['paragraph', 'reference']],
-  ['code',       code$1],
-  ['fence',      fence,      ['paragraph', 'reference', 'blockquote', 'list']],
+  ['table', table, ['paragraph', 'reference']],
+  ['code', code$1],
+  ['fence', fence, ['paragraph', 'reference', 'blockquote', 'list']],
   ['blockquote', blockquote, ['paragraph', 'reference', 'blockquote', 'list']],
-  ['hr',         hr,         ['paragraph', 'reference', 'blockquote', 'list']],
-  ['list',       list,       ['paragraph', 'reference', 'blockquote']],
-  ['reference',  reference],
+  ['hr', hr, ['paragraph', 'reference', 'blockquote', 'list']],
+  ['list', list, ['paragraph', 'reference', 'blockquote']],
+  ['reference', reference],
   ['html_block', html_block, ['paragraph', 'reference', 'blockquote']],
-  ['heading',    heading,    ['paragraph', 'reference', 'blockquote']],
-  ['lheading',   lheading],
-  ['paragraph',  paragraph]
+  ['heading', heading, ['paragraph', 'reference', 'blockquote']],
+  ['lheading', lheading],
+  ['paragraph', paragraph]
 ];
 
 /**
@@ -19187,8 +19219,8 @@ StateInline.prototype.scanDelims = function (start, canSplitWord) {
   const right_flanking =
     !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);
 
-  const can_open  = left_flanking  && (canSplitWord || !right_flanking || isLastPunctChar);
-  const can_close = right_flanking && (canSplitWord || !left_flanking  || isNextPunctChar);
+  const can_open = left_flanking && (canSplitWord || !right_flanking || isLastPunctChar);
+  const can_close = right_flanking && (canSplitWord || !left_flanking || isNextPunctChar);
 
   return { can_open, can_close, length: count }
 };
@@ -19283,10 +19315,20 @@ module.exports = function text(state, silent) {
   return true;
 }; */
 
-// Process links like https://example.org/
+// Early process links like https://example.org/ to have priority
+// over emphasis, etc.
 
 // RFC3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
-const SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;
+function isAsciiAlpha (code) {
+  return (code >= 0x41 && code <= 0x5A) || (code >= 0x61 && code <= 0x7A)
+}
+
+function isSchemeChar (code) {
+  return (code >= 0x41 && code <= 0x5A) ||
+    (code >= 0x61 && code <= 0x7A) ||
+    (code >= 0x30 && code <= 0x39) ||
+    code === 0x2B || code === 0x2D || code === 0x2E
+}
 
 function linkify (state, silent) {
   if (!state.md.options.linkify) return false
@@ -19300,19 +19342,27 @@ function linkify (state, silent) {
   if (state.src.charCodeAt(pos + 1) !== 0x2F/* / */) return false
   if (state.src.charCodeAt(pos + 2) !== 0x2F/* / */) return false
 
-  const match = state.pending.match(SCHEME_RE);
-  if (!match) return false
+  // Search backwards for the scheme, but no more than 10 characters, the length
+  // of the pending string, or the length of the source prefix.
+  // Use state.src instead of state.pending because it is faster to access.
+  const protoMin = pos - Math.min(10, state.pending.length, pos);
+  let protoStart = pos;
+  while (protoStart > protoMin && isSchemeChar(state.src.charCodeAt(protoStart - 1))) {
+    protoStart--;
+  }
 
-  const proto = match[1];
+  if (protoStart === pos || !isAsciiAlpha(state.src.charCodeAt(protoStart))) return false
 
-  const link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));
+  const protoLength = pos - protoStart;
+
+  const link = state.md.linkify.matchAtStart(state.src.slice(protoStart));
   if (!link) return false
 
   let url = link.url;
 
   // invalid link, but still detected by linkify somehow;
   // need to check to prevent infinite loop below
-  if (url.length <= proto.length) return false
+  if (url.length <= protoLength) return false
 
   // disallow '*' at the end of the link (conflicts with emphasis)
   // do manual backsearch to avoid perf issues with regex /\*+$/ on "****...****a".
@@ -19328,7 +19378,7 @@ function linkify (state, silent) {
   if (!state.md.validateLink(fullUrl)) return false
 
   if (!silent) {
-    state.pending = state.pending.slice(0, -proto.length);
+    state.pending = state.pending.slice(0, -protoLength);
 
     const token_o = state.push('link_open', 'a', 1);
     token_o.attrs = [['href', fullUrl]];
@@ -19343,7 +19393,7 @@ function linkify (state, silent) {
     token_c.info = 'auto';
   }
 
-  state.pos += url.length - proto.length;
+  state.pos += url.length - protoLength;
   return true
 }
 
@@ -19428,6 +19478,20 @@ function escape (state, silent) {
     return true
   }
 
+  // '\' before a space is a literal backslash. Don't consume the space, so a
+  // trailing two-space hard line break is still detected by the newline rule.
+  if (ch1 === 0x20) {
+    if (!silent) {
+      const token = state.push('text_special', '', 0);
+      token.content = '\\';
+      token.markup = '\\';
+      token.info = 'escape';
+    }
+
+    state.pos = pos;
+    return true
+  }
+
   let escapedStr = state.src[pos];
 
   if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {
@@ -19451,7 +19515,7 @@ function escape (state, silent) {
     }
 
     token.markup = origStr;
-    token.info   = 'escape';
+    token.info = 'escape';
   }
 
   state.pos = pos + 1;
@@ -19541,13 +19605,13 @@ function strikethrough_tokenize (state, silent) {
   let token;
 
   if (len % 2) {
-    token         = state.push('text', '', 0);
+    token = state.push('text', '', 0);
     token.content = ch;
     len--;
   }
 
   for (let i = 0; i < len; i += 2) {
-    token         = state.push('text', '', 0);
+    token = state.push('text', '', 0);
     token.content = ch + ch;
 
     state.delimiters.push({
@@ -19583,18 +19647,18 @@ function postProcess$1 (state, delimiters) {
 
     const endDelim = delimiters[startDelim.end];
 
-    token         = state.tokens[startDelim.token];
-    token.type    = 's_open';
-    token.tag     = 's';
+    token = state.tokens[startDelim.token];
+    token.type = 's_open';
+    token.tag = 's';
     token.nesting = 1;
-    token.markup  = '~~';
+    token.markup = '~~';
     token.content = '';
 
-    token         = state.tokens[endDelim.token];
-    token.type    = 's_close';
-    token.tag     = 's';
+    token = state.tokens[endDelim.token];
+    token.type = 's_close';
+    token.tag = 's';
     token.nesting = -1;
-    token.markup  = '~~';
+    token.markup = '~~';
     token.content = '';
 
     if (state.tokens[endDelim.token - 1].type === 'text' &&
@@ -19729,18 +19793,18 @@ function postProcess (state, delimiters) {
 
     const ch = String.fromCharCode(startDelim.marker);
 
-    const token_o   = state.tokens[startDelim.token];
-    token_o.type    = isStrong ? 'strong_open' : 'em_open';
-    token_o.tag     = isStrong ? 'strong' : 'em';
+    const token_o = state.tokens[startDelim.token];
+    token_o.type = isStrong ? 'strong_open' : 'em_open';
+    token_o.tag = isStrong ? 'strong' : 'em';
     token_o.nesting = 1;
-    token_o.markup  = isStrong ? ch + ch : ch;
+    token_o.markup = isStrong ? ch + ch : ch;
     token_o.content = '';
 
-    const token_c   = state.tokens[endDelim.token];
-    token_c.type    = isStrong ? 'strong_close' : 'em_close';
-    token_c.tag     = isStrong ? 'strong' : 'em';
+    const token_c = state.tokens[endDelim.token];
+    token_c.type = isStrong ? 'strong_close' : 'em_close';
+    token_c.tag = isStrong ? 'strong' : 'em';
     token_c.nesting = -1;
-    token_c.markup  = isStrong ? ch + ch : ch;
+    token_c.markup = isStrong ? ch + ch : ch;
     token_c.content = '';
 
     if (isStrong) {
@@ -19893,7 +19957,7 @@ function link (state, silent) {
 
     const token_o = state.push('link_open', 'a', 1);
     const attrs = [['href', href]];
-    token_o.attrs  = attrs;
+    token_o.attrs = attrs;
     if (title) {
       attrs.push(['title', title]);
     }
@@ -20051,7 +20115,7 @@ function image (state, silent) {
 // Process autolinks '<protocol:...>'
 
 /* eslint max-len:0 */
-const EMAIL_RE    = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
+const EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
 /* eslint-disable-next-line no-control-regex */
 const AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/;
 
@@ -20079,17 +20143,17 @@ function autolink (state, silent) {
     if (!state.md.validateLink(fullUrl)) { return false }
 
     if (!silent) {
-      const token_o   = state.push('link_open', 'a', 1);
-      token_o.attrs   = [['href', fullUrl]];
-      token_o.markup  = 'autolink';
-      token_o.info    = 'auto';
+      const token_o = state.push('link_open', 'a', 1);
+      token_o.attrs = [['href', fullUrl]];
+      token_o.markup = 'autolink';
+      token_o.info = 'auto';
 
-      const token_t   = state.push('text', '', 0);
+      const token_t = state.push('text', '', 0);
       token_t.content = state.md.normalizeLinkText(url);
 
-      const token_c   = state.push('link_close', 'a', -1);
-      token_c.markup  = 'autolink';
-      token_c.info    = 'auto';
+      const token_c = state.push('link_close', 'a', -1);
+      token_c.markup = 'autolink';
+      token_c.info = 'auto';
     }
 
     state.pos += url.length + 2;
@@ -20101,17 +20165,17 @@ function autolink (state, silent) {
     if (!state.md.validateLink(fullUrl)) { return false }
 
     if (!silent) {
-      const token_o   = state.push('link_open', 'a', 1);
-      token_o.attrs   = [['href', fullUrl]];
-      token_o.markup  = 'autolink';
-      token_o.info    = 'auto';
+      const token_o = state.push('link_open', 'a', 1);
+      token_o.attrs = [['href', fullUrl]];
+      token_o.markup = 'autolink';
+      token_o.info = 'auto';
 
-      const token_t   = state.push('text', '', 0);
+      const token_t = state.push('text', '', 0);
       token_t.content = state.md.normalizeLinkText(url);
 
-      const token_c   = state.push('link_close', 'a', -1);
-      token_c.markup  = 'autolink';
-      token_c.info    = 'auto';
+      const token_c = state.push('link_close', 'a', -1);
+      token_c.markup = 'autolink';
+      token_c.info = 'auto';
     }
 
     state.pos += url.length + 2;
@@ -20164,7 +20228,7 @@ function html_inline (state, silent) {
     const token = state.push('html_inline', '', 0);
     token.content = match[0];
 
-    if (isLinkOpen(token.content))  state.linkLevel++;
+    if (isLinkOpen(token.content)) state.linkLevel++;
     if (isLinkClose(token.content)) state.linkLevel--;
   }
   state.pos += match[0].length;
@@ -20175,7 +20239,7 @@ function html_inline (state, silent) {
 
 
 const DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
-const NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i;
+const NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;
 
 function entity (state, silent) {
   const pos = state.pos;
@@ -20193,10 +20257,10 @@ function entity (state, silent) {
       if (!silent) {
         const code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);
 
-        const token   = state.push('text_special', '', 0);
+        const token = state.push('text_special', '', 0);
         token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);
-        token.markup  = match[0];
-        token.info    = 'entity';
+        token.markup = match[0];
+        token.info = 'entity';
       }
       state.pos += match[0].length;
       return true
@@ -20207,10 +20271,10 @@ function entity (state, silent) {
       const decoded = decodeHTMLStrict(match[0]);
       if (decoded !== match[0]) {
         if (!silent) {
-          const token   = state.push('text_special', '', 0);
+          const token = state.push('text_special', '', 0);
           token.content = decoded;
-          token.markup  = match[0];
-          token.info    = 'entity';
+          token.markup = match[0];
+          token.info = 'entity';
         }
         state.pos += match[0].length;
         return true
@@ -20308,8 +20372,8 @@ function processDelimiters (delimiters) {
           jumps[closerIdx] = closerIdx - openerIdx + lastJump;
           jumps[openerIdx] = lastJump;
 
-          closer.open  = false;
-          opener.end   = closerIdx;
+          closer.open = false;
+          opener.end = closerIdx;
           opener.close = false;
           newMinOpenerIdx = -1;
           // treat next token as start of run,
@@ -20395,18 +20459,18 @@ function fragments_join (state) {
 // Parser rules
 
 const _rules = [
-  ['text',            text],
-  ['linkify',         linkify],
-  ['newline',         newline],
-  ['escape',          escape],
-  ['backticks',       backtick],
-  ['strikethrough',   r_strikethrough.tokenize],
-  ['emphasis',        r_emphasis.tokenize],
-  ['link',            link],
-  ['image',           image],
-  ['autolink',        autolink],
-  ['html_inline',     html_inline],
-  ['entity',          entity]
+  ['text', text],
+  ['linkify', linkify],
+  ['newline', newline],
+  ['escape', escape],
+  ['backticks', backtick],
+  ['strikethrough', r_strikethrough.tokenize],
+  ['emphasis', r_emphasis.tokenize],
+  ['link', link],
+  ['image', image],
+  ['autolink', autolink],
+  ['html_inline', html_inline],
+  ['entity', entity]
 ];
 
 // `rule2` ruleset was created specifically for emphasis/strikethrough
@@ -20415,12 +20479,12 @@ const _rules = [
 // Don't use this for anything except pairs (plugins working with `balance_pairs`).
 //
 const _rules2 = [
-  ['balance_pairs',   link_pairs],
-  ['strikethrough',   r_strikethrough.postProcess],
-  ['emphasis',        r_emphasis.postProcess],
+  ['balance_pairs', link_pairs],
+  ['strikethrough', r_strikethrough.postProcess],
+  ['emphasis', r_emphasis.postProcess],
   // rules for pairs separate '**' into its own text tokens, which may be left unused,
   // rule below merges unused segments back with the rest of the text
-  ['fragments_join',  fragments_join]
+  ['fragments_join', fragments_join]
 ];
 
 /**
@@ -22623,7 +22687,7 @@ const schema$1 = new Schema({
             toDOM() { return ["div", ["hr"]]; }
         },
         heading: {
-            attrs: { level: { default: 1 } },
+            attrs: { level: { default: 1, validate: "number" } },
             content: "(text | image)*",
             group: "block",
             defining: true,
@@ -22633,7 +22697,7 @@ const schema$1 = new Schema({
                 { tag: "h4", attrs: { level: 4 } },
                 { tag: "h5", attrs: { level: 5 } },
                 { tag: "h6", attrs: { level: 6 } }],
-            toDOM(node) { return ["h" + node.attrs.level, 0]; }
+            toDOM(node) { return ["h" + +node.attrs.level, 0]; }
         },
         code_block: {
             content: "text*",
@@ -23624,7 +23688,7 @@ const nodes = {
             { tag: "h4", attrs: { level: 4 } },
             { tag: "h5", attrs: { level: 5 } },
             { tag: "h6", attrs: { level: 6 } }],
-        toDOM(node) { return ["h" + node.attrs.level, 0]; }
+        toDOM(node) { return ["h" + +node.attrs.level, 0]; }
     },
     /**
     A code listing. Disallows marks or non-text inline