@tiptap/extension-code-block-lowlight 2.0.0-beta.9 → 2.0.0-rc.2

package/dist/{tiptap-extension-code-block-lowlight.cjs.js → index.cjs}

@@ -3,14 +3,16 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var CodeBlock = require('@tiptap/extension-code-block');
-var prosemirrorState = require('prosemirror-state');
-var prosemirrorView = require('prosemirror-view');
-var core$2 = require('@tiptap/core');
+var core$1 = require('@tiptap/core');
+var state = require('@tiptap/pm/state');
+var view = require('@tiptap/pm/view');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var CodeBlock__default = /*#__PURE__*/_interopDefaultLegacy(CodeBlock);
 
+var deepFreezeEs6 = {exports: {}};
+
 function deepFreeze(obj) {
     if (obj instanceof Map) {
         obj.clear = obj.delete = obj.set = function () {
@@ -37,11 +39,13 @@ function deepFreeze(obj) {
     return obj;
 }
 
-var deepFreezeEs6 = deepFreeze;
-var _default = deepFreeze;
-deepFreezeEs6.default = _default;
+deepFreezeEs6.exports = deepFreeze;
+deepFreezeEs6.exports.default = deepFreeze;
 
+/** @typedef {import('highlight.js').CallbackResponse} CallbackResponse */
+/** @typedef {import('highlight.js').CompiledMode} CompiledMode */
 /** @implements CallbackResponse */
+
 class Response {
   /**
    * @param {CompiledMode} mode
@@ -80,7 +84,7 @@ function escapeHTML(value) {
  * @param {Record<string,any>[]} objects
  * @returns {T} a single new object
  */
-function inherit(original, ...objects) {
+function inherit$1(original, ...objects) {
   /** @type Record<string,any> */
   const result = Object.create(null);
 
@@ -103,7 +107,7 @@ function inherit(original, ...objects) {
  * @property {() => string} value
  */
 
-/** @typedef {{kind?: string, sublanguage?: boolean}} Node */
+/** @typedef {{scope?: string, language?: string, sublanguage?: boolean}} Node */
 /** @typedef {{walk: (r: Renderer) => void}} Tree */
 /** */
 
@@ -114,7 +118,25 @@ const SPAN_CLOSE = '</span>';
  *
  * @param {Node} node */
 const emitsWrappingTags = (node) => {
-  return !!node.kind;
+  // rarely we can have a sublanguage where language is undefined
+  // TODO: track down why
+  return !!node.scope || (node.sublanguage && node.language);
+};
+
+/**
+ *
+ * @param {string} name
+ * @param {{prefix:string}} options
+ */
+const scopeToCSSClass = (name, { prefix }) => {
+  if (name.includes(".")) {
+    const pieces = name.split(".");
+    return [
+      `${prefix}${pieces.shift()}`,
+      ...(pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`))
+    ].join(" ");
+  }
+  return `${prefix}${name}`;
 };
 
 /** @type {Renderer} */
@@ -146,9 +168,11 @@ class HTMLRenderer {
   openNode(node) {
     if (!emitsWrappingTags(node)) return;
 
-    let className = node.kind;
-    if (!node.sublanguage) {
-      className = `${this.classPrefix}${className}`;
+    let className = "";
+    if (node.sublanguage) {
+      className = `language-${node.language}`;
+    } else {
+      className = scopeToCSSClass(node.scope, { prefix: this.classPrefix });
     }
     this.span(className);
   }
@@ -181,14 +205,23 @@ class HTMLRenderer {
   }
 }
 
-/** @typedef {{kind?: string, sublanguage?: boolean, children: Node[]} | string} Node */
-/** @typedef {{kind?: string, sublanguage?: boolean, children: Node[]} } DataNode */
+/** @typedef {{scope?: string, language?: string, sublanguage?: boolean, children: Node[]} | string} Node */
+/** @typedef {{scope?: string, language?: string, sublanguage?: boolean, children: Node[]} } DataNode */
+/** @typedef {import('highlight.js').Emitter} Emitter */
 /**  */
 
+/** @returns {DataNode} */
+const newNode = (opts = {}) => {
+  /** @type DataNode */
+  const result = { children: [] };
+  Object.assign(result, opts);
+  return result;
+};
+
 class TokenTree {
   constructor() {
     /** @type DataNode */
-    this.rootNode = { children: [] };
+    this.rootNode = newNode();
     this.stack = [this.rootNode];
   }
 
@@ -203,10 +236,10 @@ class TokenTree {
     this.top.children.push(node);
   }
 
-  /** @param {string} kind */
-  openNode(kind) {
+  /** @param {string} scope */
+  openNode(scope) {
     /** @type Node */
-    const node = { kind, children: [] };
+    const node = newNode({ scope });
     this.add(node);
     this.stack.push(node);
   }
@@ -278,11 +311,11 @@ class TokenTree {
 
   Minimal interface:
 
-  - addKeyword(text, kind)
+  - addKeyword(text, scope)
   - addText(text)
   - addSublanguage(emitter, subLanguageName)
   - finalize()
-  - openNode(kind)
+  - openNode(scope)
   - closeNode()
   - closeAllNodes()
   - toHTML()
@@ -303,12 +336,12 @@ class TokenTreeEmitter extends TokenTree {
 
   /**
    * @param {string} text
-   * @param {string} kind
+   * @param {string} scope
    */
-  addKeyword(text, kind) {
+  addKeyword(text, scope) {
     if (text === "") { return; }
 
-    this.openNode(kind);
+    this.openNode(scope);
     this.addText(text);
     this.closeNode();
   }
@@ -329,8 +362,8 @@ class TokenTreeEmitter extends TokenTree {
   addSublanguage(emitter, name) {
     /** @type DataNode */
     const node = emitter.root;
-    node.kind = name;
     node.sublanguage = true;
+    node.language = name;
     this.add(node);
   }
 
@@ -348,9 +381,6 @@ class TokenTreeEmitter extends TokenTree {
  * @param {string} value
  * @returns {RegExp}
  * */
-function escape(value) {
-  return new RegExp(value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&'), 'm');
-}
 
 /**
  * @param {RegExp | string } re
@@ -363,6 +393,30 @@ function source(re) {
   return re.source;
 }
 
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function lookahead(re) {
+  return concat('(?=', re, ')');
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function anyNumberOfTimes(re) {
+  return concat('(?:', re, ')*');
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function optional(re) {
+  return concat('(?:', re, ')?');
+}
+
 /**
  * @param {...(RegExp | string) } args
  * @returns {string}
@@ -372,20 +426,41 @@ function concat(...args) {
   return joined;
 }
 
+/**
+ * @param { Array<string | RegExp | Object> } args
+ * @returns {object}
+ */
+function stripOptionsFromArgs(args) {
+  const opts = args[args.length - 1];
+
+  if (typeof opts === 'object' && opts.constructor === Object) {
+    args.splice(args.length - 1, 1);
+    return opts;
+  } else {
+    return {};
+  }
+}
+
+/** @typedef { {capture?: boolean} } RegexEitherOptions */
+
 /**
  * Any of the passed expresssions may match
  *
  * Creates a huge this | this | that | that match
- * @param {(RegExp | string)[] } args
+ * @param {(RegExp | string)[] | [...(RegExp | string)[], RegexEitherOptions]} args
  * @returns {string}
  */
 function either(...args) {
-  const joined = '(' + args.map((x) => source(x)).join("|") + ")";
+  /** @type { object & {capture?: boolean} }  */
+  const opts = stripOptionsFromArgs(args);
+  const joined = '('
+    + (opts.capture ? "" : "?:")
+    + args.map((x) => source(x)).join("|") + ")";
   return joined;
 }
 
 /**
- * @param {RegExp} re
+ * @param {RegExp | string} re
  * @returns {number}
  */
 function countMatchGroups(re) {
@@ -411,6 +486,7 @@ function startsWith(re, lexeme) {
 //   follow the '(' with a '?'.
 const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
 
+// **INTERNAL** Not intended for outside usage
 // join logically computes regexps.join(separator), but fixes the
 // backreferences so they continue to match.
 // it also places each individual regular expression into it's own
@@ -418,10 +494,10 @@ const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
 // is currently an exercise for the caller. :-)
 /**
  * @param {(string | RegExp)[]} regexps
- * @param {string} separator
+ * @param {{joinWith: string}} opts
  * @returns {string}
  */
-function join(regexps, separator = "|") {
+function _rewriteBackreferences(regexps, { joinWith }) {
   let numCaptures = 0;
 
   return regexps.map((regex) => {
@@ -449,9 +525,12 @@ function join(regexps, separator = "|") {
       }
     }
     return out;
-  }).map(re => `(${re})`).join(separator);
+  }).map(re => `(${re})`).join(joinWith);
 }
 
+/** @typedef {import('highlight.js').Mode} Mode */
+/** @typedef {import('highlight.js').ModeCallback} ModeCallback */
+
 // Common regexps
 const MATCH_NOTHING_RE = /\b\B/;
 const IDENT_RE = '[a-zA-Z]\\w*';
@@ -473,8 +552,8 @@ const SHEBANG = (opts = {}) => {
       opts.binary,
       /\b.*/);
   }
-  return inherit({
-    className: 'meta',
+  return inherit$1({
+    scope: 'meta',
     begin: beginShebang,
     end: /$/,
     relevance: 0,
@@ -490,14 +569,14 @@ const BACKSLASH_ESCAPE = {
   begin: '\\\\[\\s\\S]', relevance: 0
 };
 const APOS_STRING_MODE = {
-  className: 'string',
+  scope: 'string',
   begin: '\'',
   end: '\'',
   illegal: '\\n',
   contains: [BACKSLASH_ESCAPE]
 };
 const QUOTE_STRING_MODE = {
-  className: 'string',
+  scope: 'string',
   begin: '"',
   end: '"',
   illegal: '\\n',
@@ -515,54 +594,88 @@ const PHRASAL_WORDS_MODE = {
  * @returns {Partial<Mode>}
  */
 const COMMENT = function(begin, end, modeOptions = {}) {
-  const mode = inherit(
+  const mode = inherit$1(
     {
-      className: 'comment',
+      scope: 'comment',
       begin,
       end,
       contains: []
     },
     modeOptions
   );
-  mode.contains.push(PHRASAL_WORDS_MODE);
   mode.contains.push({
-    className: 'doctag',
-    begin: '(?:TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):',
+    scope: 'doctag',
+    // hack to avoid the space from being included. the space is necessary to
+    // match here to prevent the plain text rule below from gobbling up doctags
+    begin: '[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)',
+    end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
+    excludeBegin: true,
     relevance: 0
   });
+  const ENGLISH_WORD = either(
+    // list of common 1 and 2 letter words in English
+    "I",
+    "a",
+    "is",
+    "so",
+    "us",
+    "to",
+    "at",
+    "if",
+    "in",
+    "it",
+    "on",
+    // note: this is not an exhaustive list of contractions, just popular ones
+    /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, // contractions - can't we'd they're let's, etc
+    /[A-Za-z]+[-][a-z]+/, // `no-way`, etc.
+    /[A-Za-z][a-z]{2,}/ // allow capitalized words at beginning of sentences
+  );
+  // looking like plain text, more likely to be a comment
+  mode.contains.push(
+    {
+      // TODO: how to include ", (, ) without breaking grammars that use these for
+      // comment delimiters?
+      // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
+      // ---
+
+      // this tries to find sequences of 3 english words in a row (without any
+      // "programming" type syntax) this gives us a strong signal that we've
+      // TRULY found a comment - vs perhaps scanning with the wrong language.
+      // It's possible to find something that LOOKS like the start of the
+      // comment - but then if there is no readable text - good chance it is a
+      // false match and not a comment.
+      //
+      // for a visual example please see:
+      // https://github.com/highlightjs/highlight.js/issues/2827
+
+      begin: concat(
+        /[ ]+/, // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+        '(',
+        ENGLISH_WORD,
+        /[.]?[:]?([.][ ]|[ ])/,
+        '){3}') // look for 3 words in a row
+    }
+  );
   return mode;
 };
 const C_LINE_COMMENT_MODE = COMMENT('//', '$');
 const C_BLOCK_COMMENT_MODE = COMMENT('/\\*', '\\*/');
 const HASH_COMMENT_MODE = COMMENT('#', '$');
 const NUMBER_MODE = {
-  className: 'number',
+  scope: 'number',
   begin: NUMBER_RE,
   relevance: 0
 };
 const C_NUMBER_MODE = {
-  className: 'number',
+  scope: 'number',
   begin: C_NUMBER_RE,
   relevance: 0
 };
 const BINARY_NUMBER_MODE = {
-  className: 'number',
+  scope: 'number',
   begin: BINARY_NUMBER_RE,
   relevance: 0
 };
-const CSS_NUMBER_MODE = {
-  className: 'number',
-  begin: NUMBER_RE + '(' +
-    '%|em|ex|ch|rem' +
-    '|vw|vh|vmin|vmax' +
-    '|cm|mm|in|pt|pc|px' +
-    '|deg|grad|rad|turn' +
-    '|s|ms' +
-    '|Hz|kHz' +
-    '|dpi|dpcm|dppx' +
-    ')?',
-  relevance: 0
-};
 const REGEXP_MODE = {
   // this outer rule makes sure we actually have a WHOLE regex and not simply
   // an expression such as:
@@ -572,7 +685,7 @@ const REGEXP_MODE = {
   // (which will then blow up when regex's `illegal` sees the newline)
   begin: /(?=\/[^/\n]*\/)/,
   contains: [{
-    className: 'regexp',
+    scope: 'regexp',
     begin: /\//,
     end: /\/[gimuy]*/,
     illegal: /\n/,
@@ -588,12 +701,12 @@ const REGEXP_MODE = {
   }]
 };
 const TITLE_MODE = {
-  className: 'title',
+  scope: 'title',
   begin: IDENT_RE,
   relevance: 0
 };
 const UNDERSCORE_TITLE_MODE = {
-  className: 'title',
+  scope: 'title',
   begin: UNDERSCORE_IDENT_RE,
   relevance: 0
 };
@@ -641,7 +754,6 @@ var MODES = /*#__PURE__*/Object.freeze({
     NUMBER_MODE: NUMBER_MODE,
     C_NUMBER_MODE: C_NUMBER_MODE,
     BINARY_NUMBER_MODE: BINARY_NUMBER_MODE,
-    CSS_NUMBER_MODE: CSS_NUMBER_MODE,
     REGEXP_MODE: REGEXP_MODE,
     TITLE_MODE: TITLE_MODE,
     UNDERSCORE_TITLE_MODE: UNDERSCORE_TITLE_MODE,
@@ -649,6 +761,11 @@ var MODES = /*#__PURE__*/Object.freeze({
     END_SAME_AS_BEGIN: END_SAME_AS_BEGIN
 });
 
+/**
+@typedef {import('highlight.js').CallbackResponse} CallbackResponse
+@typedef {import('highlight.js').CompilerExt} CompilerExt
+*/
+
 // Grammar extensions / plugins
 // See: https://github.com/highlightjs/highlight.js/issues/2833
 
@@ -673,13 +790,24 @@ var MODES = /*#__PURE__*/Object.freeze({
  * @param {RegExpMatchArray} match
  * @param {CallbackResponse} response
  */
-function skipIfhasPrecedingDot(match, response) {
+function skipIfHasPrecedingDot(match, response) {
   const before = match.input[match.index - 1];
   if (before === ".") {
     response.ignoreMatch();
   }
 }
 
+/**
+ *
+ * @type {CompilerExt}
+ */
+function scopeClassName(mode, _parent) {
+  // eslint-disable-next-line no-undefined
+  if (mode.className !== undefined) {
+    mode.scope = mode.className;
+    delete mode.className;
+  }
+}
 
 /**
  * `beginKeywords` syntactic sugar
@@ -695,7 +823,7 @@ function beginKeywords(mode, parent) {
   // doesn't allow spaces in keywords anyways and we still check for the boundary
   // first
   mode.begin = '\\b(' + mode.beginKeywords.split(' ').join('|') + ')(?!\\.)(?=\\b|\\s)';
-  mode.__beforeBegin = skipIfhasPrecedingDot;
+  mode.__beforeBegin = skipIfHasPrecedingDot;
   mode.keywords = mode.keywords || mode.beginKeywords;
   delete mode.beginKeywords;
 
@@ -736,6 +864,30 @@ function compileRelevance(mode, _parent) {
   if (mode.relevance === undefined) mode.relevance = 1;
 }
 
+// allow beforeMatch to act as a "qualifier" for the match
+// the full match begin must be [beforeMatch][begin]
+const beforeMatchExt = (mode, parent) => {
+  if (!mode.beforeMatch) return;
+  // starts conflicts with endsParent which we need to make sure the child
+  // rule is not matched multiple times
+  if (mode.starts) throw new Error("beforeMatch cannot be used with starts");
+
+  const originalMode = Object.assign({}, mode);
+  Object.keys(mode).forEach((key) => { delete mode[key]; });
+
+  mode.keywords = originalMode.keywords;
+  mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
+  mode.starts = {
+    relevance: 0,
+    contains: [
+      Object.assign(originalMode, { endsParent: true })
+    ]
+  };
+  mode.relevance = 0;
+
+  delete originalMode.beforeMatch;
+};
+
 // keywords that should have no default relevance value
 const COMMON_KEYWORDS = [
   'of',
@@ -751,7 +903,7 @@ const COMMON_KEYWORDS = [
   'value' // common variable name
 ];
 
-const DEFAULT_KEYWORD_CLASSNAME = "keyword";
+const DEFAULT_KEYWORD_SCOPE = "keyword";
 
 /**
  * Given raw keywords from a language definition, compile them.
@@ -759,22 +911,22 @@ const DEFAULT_KEYWORD_CLASSNAME = "keyword";
  * @param {string | Record<string,string|string[]> | Array<string>} rawKeywords
  * @param {boolean} caseInsensitive
  */
-function compileKeywords(rawKeywords, caseInsensitive, className = DEFAULT_KEYWORD_CLASSNAME) {
+function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
   /** @type KeywordDict */
-  const compiledKeywords = {};
+  const compiledKeywords = Object.create(null);
 
   // input can be a string of keywords, an array of keywords, or a object with
-  // named keys representing className (which can then point to a string or array)
+  // named keys representing scopeName (which can then point to a string or array)
   if (typeof rawKeywords === 'string') {
-    compileList(className, rawKeywords.split(" "));
+    compileList(scopeName, rawKeywords.split(" "));
   } else if (Array.isArray(rawKeywords)) {
-    compileList(className, rawKeywords);
+    compileList(scopeName, rawKeywords);
   } else {
-    Object.keys(rawKeywords).forEach(function(className) {
+    Object.keys(rawKeywords).forEach(function(scopeName) {
       // collapse all our objects back into the parent object
       Object.assign(
         compiledKeywords,
-        compileKeywords(rawKeywords[className], caseInsensitive, className)
+        compileKeywords(rawKeywords[scopeName], caseInsensitive, scopeName)
       );
     });
   }
@@ -787,16 +939,16 @@ function compileKeywords(rawKeywords, caseInsensitive, className = DEFAULT_KEYWO
    *
    * Ex: "for if when while|5"
    *
-   * @param {string} className
+   * @param {string} scopeName
    * @param {Array<string>} keywordList
    */
-  function compileList(className, keywordList) {
+  function compileList(scopeName, keywordList) {
     if (caseInsensitive) {
       keywordList = keywordList.map(x => x.toLowerCase());
     }
     keywordList.forEach(function(keyword) {
       const pair = keyword.split('|');
-      compiledKeywords[pair[0]] = [className, scoreForKeyword(pair[0], pair[1])];
+      compiledKeywords[pair[0]] = [scopeName, scoreForKeyword(pair[0], pair[1])];
     });
   }
 }
@@ -827,6 +979,183 @@ function commonKeyword(keyword) {
   return COMMON_KEYWORDS.includes(keyword.toLowerCase());
 }
 
+/*
+
+For the reasoning behind this please see:
+https://github.com/highlightjs/highlight.js/issues/2880#issuecomment-747275419
+
+*/
+
+/**
+ * @type {Record<string, boolean>}
+ */
+const seenDeprecations = {};
+
+/**
+ * @param {string} message
+ */
+const error = (message) => {
+  console.error(message);
+};
+
+/**
+ * @param {string} message
+ * @param {any} args
+ */
+const warn = (message, ...args) => {
+  console.log(`WARN: ${message}`, ...args);
+};
+
+/**
+ * @param {string} version
+ * @param {string} message
+ */
+const deprecated = (version, message) => {
+  if (seenDeprecations[`${version}/${message}`]) return;
+
+  console.log(`Deprecated as of ${version}. ${message}`);
+  seenDeprecations[`${version}/${message}`] = true;
+};
+
+/* eslint-disable no-throw-literal */
+
+/**
+@typedef {import('highlight.js').CompiledMode} CompiledMode
+*/
+
+const MultiClassError = new Error();
+
+/**
+ * Renumbers labeled scope names to account for additional inner match
+ * groups that otherwise would break everything.
+ *
+ * Lets say we 3 match scopes:
+ *
+ *   { 1 => ..., 2 => ..., 3 => ... }
+ *
+ * So what we need is a clean match like this:
+ *
+ *   (a)(b)(c) => [ "a", "b", "c" ]
+ *
+ * But this falls apart with inner match groups:
+ *
+ * (a)(((b)))(c) => ["a", "b", "b", "b", "c" ]
+ *
+ * Our scopes are now "out of alignment" and we're repeating `b` 3 times.
+ * What needs to happen is the numbers are remapped:
+ *
+ *   { 1 => ..., 2 => ..., 5 => ... }
+ *
+ * We also need to know that the ONLY groups that should be output
+ * are 1, 2, and 5.  This function handles this behavior.
+ *
+ * @param {CompiledMode} mode
+ * @param {Array<RegExp | string>} regexes
+ * @param {{key: "beginScope"|"endScope"}} opts
+ */
+function remapScopeNames(mode, regexes, { key }) {
+  let offset = 0;
+  const scopeNames = mode[key];
+  /** @type Record<number,boolean> */
+  const emit = {};
+  /** @type Record<number,string> */
+  const positions = {};
+
+  for (let i = 1; i <= regexes.length; i++) {
+    positions[i + offset] = scopeNames[i];
+    emit[i + offset] = true;
+    offset += countMatchGroups(regexes[i - 1]);
+  }
+  // we use _emit to keep track of which match groups are "top-level" to avoid double
+  // output from inside match groups
+  mode[key] = positions;
+  mode[key]._emit = emit;
+  mode[key]._multi = true;
+}
+
+/**
+ * @param {CompiledMode} mode
+ */
+function beginMultiClass(mode) {
+  if (!Array.isArray(mode.begin)) return;
+
+  if (mode.skip || mode.excludeBegin || mode.returnBegin) {
+    error("skip, excludeBegin, returnBegin not compatible with beginScope: {}");
+    throw MultiClassError;
+  }
+
+  if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
+    error("beginScope must be object");
+    throw MultiClassError;
+  }
+
+  remapScopeNames(mode, mode.begin, { key: "beginScope" });
+  mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" });
+}
+
+/**
+ * @param {CompiledMode} mode
+ */
+function endMultiClass(mode) {
+  if (!Array.isArray(mode.end)) return;
+
+  if (mode.skip || mode.excludeEnd || mode.returnEnd) {
+    error("skip, excludeEnd, returnEnd not compatible with endScope: {}");
+    throw MultiClassError;
+  }
+
+  if (typeof mode.endScope !== "object" || mode.endScope === null) {
+    error("endScope must be object");
+    throw MultiClassError;
+  }
+
+  remapScopeNames(mode, mode.end, { key: "endScope" });
+  mode.end = _rewriteBackreferences(mode.end, { joinWith: "" });
+}
+
+/**
+ * this exists only to allow `scope: {}` to be used beside `match:`
+ * Otherwise `beginScope` would necessary and that would look weird
+
+  {
+    match: [ /def/, /\w+/ ]
+    scope: { 1: "keyword" , 2: "title" }
+  }
+
+ * @param {CompiledMode} mode
+ */
+function scopeSugar(mode) {
+  if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
+    mode.beginScope = mode.scope;
+    delete mode.scope;
+  }
+}
+
+/**
+ * @param {CompiledMode} mode
+ */
+function MultiClass(mode) {
+  scopeSugar(mode);
+
+  if (typeof mode.beginScope === "string") {
+    mode.beginScope = { _wrap: mode.beginScope };
+  }
+  if (typeof mode.endScope === "string") {
+    mode.endScope = { _wrap: mode.endScope };
+  }
+
+  beginMultiClass(mode);
+  endMultiClass(mode);
+}
+
+/**
+@typedef {import('highlight.js').Mode} Mode
+@typedef {import('highlight.js').CompiledMode} CompiledMode
+@typedef {import('highlight.js').Language} Language
+@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+@typedef {import('highlight.js').CompiledLanguage} CompiledLanguage
+*/
+
 // compilation
 
 /**
@@ -835,12 +1164,11 @@ function commonKeyword(keyword) {
  * Given the raw result of a language definition (Language), compiles this so
  * that it is ready for highlighting code.
  * @param {Language} language
- * @param {{plugins: HLJSPlugin[]}} opts
  * @returns {CompiledLanguage}
  */
-function compileLanguage(language, { plugins }) {
+function compileLanguage(language) {
   /**
-   * Builds a regex with the case sensativility of the current language
+   * Builds a regex with the case sensitivity of the current language
    *
    * @param {RegExp | string} value
    * @param {boolean} [global]
@@ -848,7 +1176,10 @@ function compileLanguage(language, { plugins }) {
   function langRe(value, global) {
     return new RegExp(
       source(value),
-      'm' + (language.case_insensitive ? 'i' : '') + (global ? 'g' : '')
+      'm'
+      + (language.case_insensitive ? 'i' : '')
+      + (language.unicodeRegex ? 'u' : '')
+      + (global ? 'g' : '')
     );
   }
 
@@ -890,7 +1221,7 @@ function compileLanguage(language, { plugins }) {
         this.exec = () => null;
       }
       const terminators = this.regexes.map(el => el[1]);
-      this.matcherRe = langRe(join(terminators), true);
+      this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: '|' }), true);
       this.lastIndex = 0;
     }
 
@@ -1103,9 +1434,12 @@ function compileLanguage(language, { plugins }) {
     if (mode.isCompiled) return cmode;
 
     [
+      scopeClassName,
       // do this early so compiler extensions generally don't have to worry about
       // the distinction between match/begin
-      compileMatch
+      compileMatch,
+      MultiClass,
+      beforeMatchExt
     ].forEach(ext => ext(mode, parent));
 
     language.compilerExtensions.forEach(ext => ext(mode, parent));
@@ -1125,32 +1459,28 @@ function compileLanguage(language, { plugins }) {
     mode.isCompiled = true;
 
     let keywordPattern = null;
-    if (typeof mode.keywords === "object") {
+    if (typeof mode.keywords === "object" && mode.keywords.$pattern) {
+      // we need a copy because keywords might be compiled multiple times
+      // so we can't go deleting $pattern from the original on the first
+      // pass
+      mode.keywords = Object.assign({}, mode.keywords);
       keywordPattern = mode.keywords.$pattern;
       delete mode.keywords.$pattern;
     }
+    keywordPattern = keywordPattern || /\w+/;
 
     if (mode.keywords) {
       mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
     }
 
-    // both are not allowed
-    if (mode.lexemes && keywordPattern) {
-      throw new Error("ERR: Prefer `keywords.$pattern` to `mode.lexemes`, BOTH are not allowed. (see mode reference) ");
-    }
-
-    // `mode.lexemes` was the old standard before we added and now recommend
-    // using `keywords.$pattern` to pass the keyword pattern
-    keywordPattern = keywordPattern || mode.lexemes || /\w+/;
     cmode.keywordPatternRe = langRe(keywordPattern, true);
 
     if (parent) {
       if (!mode.begin) mode.begin = /\B|\b/;
-      cmode.beginRe = langRe(mode.begin);
-      if (mode.endSameAsBegin) mode.end = mode.begin;
+      cmode.beginRe = langRe(cmode.begin);
       if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
-      if (mode.end) cmode.endRe = langRe(mode.end);
-      cmode.terminatorEnd = source(mode.end) || '';
+      if (mode.end) cmode.endRe = langRe(cmode.end);
+      cmode.terminatorEnd = source(cmode.end) || '';
       if (mode.endsWithParent && parent.terminatorEnd) {
         cmode.terminatorEnd += (mode.end ? '|' : '') + parent.terminatorEnd;
       }
@@ -1179,7 +1509,7 @@ function compileLanguage(language, { plugins }) {
   }
 
   // we need a null object, which inherit will guarantee
-  language.classNameAliases = inherit(language.classNameAliases || {});
+  language.classNameAliases = inherit$1(language.classNameAliases || {});
 
   return compileMode(/** @type Mode */ (language));
 }
@@ -1214,7 +1544,7 @@ function dependencyOnParent(mode) {
 function expandOrCloneMode(mode) {
   if (mode.variants && !mode.cachedVariants) {
     mode.cachedVariants = mode.variants.map(function(variant) {
-      return inherit(mode, { variants: null }, variant);
+      return inherit$1(mode, { variants: null }, variant);
     });
   }
 
@@ -1230,288 +1560,58 @@ function expandOrCloneMode(mode) {
   // instance of ourselves, so we can be reused with many
   // different parents without issue
   if (dependencyOnParent(mode)) {
-    return inherit(mode, { starts: mode.starts ? inherit(mode.starts) : null });
+    return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null });
   }
 
   if (Object.isFrozen(mode)) {
-    return inherit(mode);
+    return inherit$1(mode);
   }
 
   // no special dependency issues, just return ourselves
   return mode;
 }
 
-var version = "10.7.2";
-
-// @ts-nocheck
-
-function hasValueOrEmptyAttribute(value) {
-  return Boolean(value || value === "");
-}
-
-function BuildVuePlugin(hljs) {
-  const Component = {
-    props: ["language", "code", "autodetect"],
-    data: function() {
-      return {
-        detectedLanguage: "",
-        unknownLanguage: false
-      };
-    },
-    computed: {
-      className() {
-        if (this.unknownLanguage) return "";
-
-        return "hljs " + this.detectedLanguage;
-      },
-      highlighted() {
-        // no idea what language to use, return raw code
-        if (!this.autoDetect && !hljs.getLanguage(this.language)) {
-          console.warn(`The language "${this.language}" you specified could not be found.`);
-          this.unknownLanguage = true;
-          return escapeHTML(this.code);
-        }
-
-        let result = {};
-        if (this.autoDetect) {
-          result = hljs.highlightAuto(this.code);
-          this.detectedLanguage = result.language;
-        } else {
-          result = hljs.highlight(this.language, this.code, this.ignoreIllegals);
-          this.detectedLanguage = this.language;
-        }
-        return result.value;
-      },
-      autoDetect() {
-        return !this.language || hasValueOrEmptyAttribute(this.autodetect);
-      },
-      ignoreIllegals() {
-        return true;
-      }
-    },
-    // this avoids needing to use a whole Vue compilation pipeline just
-    // to build Highlight.js
-    render(createElement) {
-      return createElement("pre", {}, [
-        createElement("code", {
-          class: this.className,
-          domProps: { innerHTML: this.highlighted }
-        })
-      ]);
-    }
-    // template: `<pre><code :class="className" v-html="highlighted"></code></pre>`
-  };
-
-  const VuePlugin = {
-    install(Vue) {
-      Vue.component('highlightjs', Component);
-    }
-  };
+var version = "11.6.0";
 
-  return { Component, VuePlugin };
-}
-
-/* plugin itself */
-
-/** @type {HLJSPlugin} */
-const mergeHTMLPlugin = {
-  "after:highlightElement": ({ el, result, text }) => {
-    const originalStream = nodeStream(el);
-    if (!originalStream.length) return;
-
-    const resultNode = document.createElement('div');
-    resultNode.innerHTML = result.value;
-    result.value = mergeStreams(originalStream, nodeStream(resultNode), text);
-  }
-};
-
-/* Stream merging support functions */
-
-/**
- * @typedef Event
- * @property {'start'|'stop'} event
- * @property {number} offset
- * @property {Node} node
- */
-
-/**
- * @param {Node} node
- */
-function tag(node) {
-  return node.nodeName.toLowerCase();
-}
-
-/**
- * @param {Node} node
- */
-function nodeStream(node) {
-  /** @type Event[] */
-  const result = [];
-  (function _nodeStream(node, offset) {
-    for (let child = node.firstChild; child; child = child.nextSibling) {
-      if (child.nodeType === 3) {
-        offset += child.nodeValue.length;
-      } else if (child.nodeType === 1) {
-        result.push({
-          event: 'start',
-          offset: offset,
-          node: child
-        });
-        offset = _nodeStream(child, offset);
-        // Prevent void elements from having an end tag that would actually
-        // double them in the output. There are more void elements in HTML
-        // but we list only those realistically expected in code display.
-        if (!tag(child).match(/br|hr|img|input/)) {
-          result.push({
-            event: 'stop',
-            offset: offset,
-            node: child
-          });
-        }
-      }
-    }
-    return offset;
-  })(node, 0);
-  return result;
-}
-
-/**
- * @param {any} original - the original stream
- * @param {any} highlighted - stream of the highlighted source
- * @param {string} value - the original source itself
- */
-function mergeStreams(original, highlighted, value) {
-  let processed = 0;
-  let result = '';
-  const nodeStack = [];
-
-  function selectStream() {
-    if (!original.length || !highlighted.length) {
-      return original.length ? original : highlighted;
-    }
-    if (original[0].offset !== highlighted[0].offset) {
-      return (original[0].offset < highlighted[0].offset) ? original : highlighted;
-    }
-
-    /*
-    To avoid starting the stream just before it should stop the order is
-    ensured that original always starts first and closes last:
-
-    if (event1 == 'start' && event2 == 'start')
-      return original;
-    if (event1 == 'start' && event2 == 'stop')
-      return highlighted;
-    if (event1 == 'stop' && event2 == 'start')
-      return original;
-    if (event1 == 'stop' && event2 == 'stop')
-      return highlighted;
-
-    ... which is collapsed to:
-    */
-    return highlighted[0].event === 'start' ? original : highlighted;
+class HTMLInjectionError extends Error {
+  constructor(reason, html) {
+    super(reason);
+    this.name = "HTMLInjectionError";
+    this.html = html;
   }
-
-  /**
-   * @param {Node} node
-   */
-  function open(node) {
-    /** @param {Attr} attr */
-    function attributeString(attr) {
-      return ' ' + attr.nodeName + '="' + escapeHTML(attr.value) + '"';
-    }
-    // @ts-ignore
-    result += '<' + tag(node) + [].map.call(node.attributes, attributeString).join('') + '>';
-  }
-
-  /**
-   * @param {Node} node
-   */
-  function close(node) {
-    result += '</' + tag(node) + '>';
-  }
-
-  /**
-   * @param {Event} event
-   */
-  function render(event) {
-    (event.event === 'start' ? open : close)(event.node);
-  }
-
-  while (original.length || highlighted.length) {
-    let stream = selectStream();
-    result += escapeHTML(value.substring(processed, stream[0].offset));
-    processed = stream[0].offset;
-    if (stream === original) {
-      /*
-      On any opening or closing tag of the original markup we first close
-      the entire highlighted node stack, then render the original tag along
-      with all the following original tags at the same offset and then
-      reopen all the tags on the highlighted stack.
-      */
-      nodeStack.reverse().forEach(close);
-      do {
-        render(stream.splice(0, 1)[0]);
-        stream = selectStream();
-      } while (stream === original && stream.length && stream[0].offset === processed);
-      nodeStack.reverse().forEach(open);
-    } else {
-      if (stream[0].event === 'start') {
-        nodeStack.push(stream[0].node);
-      } else {
-        nodeStack.pop();
-      }
-      render(stream.splice(0, 1)[0]);
-    }
-  }
-  return result + escapeHTML(value.substr(processed));
 }
 
 /*
-
-For the reasoning behind this please see:
-https://github.com/highlightjs/highlight.js/issues/2880#issuecomment-747275419
-
+Syntax highlighting with language autodetection.
+https://highlightjs.org/
 */
 
 /**
- * @type {Record<string, boolean>}
- */
-const seenDeprecations = {};
-
-/**
- * @param {string} message
- */
-const error = (message) => {
-  console.error(message);
-};
-
-/**
- * @param {string} message
- * @param {any} args
- */
-const warn = (message, ...args) => {
-  console.log(`WARN: ${message}`, ...args);
-};
-
-/**
- * @param {string} version
- * @param {string} message
- */
-const deprecated = (version, message) => {
-  if (seenDeprecations[`${version}/${message}`]) return;
-
-  console.log(`Deprecated as of ${version}. ${message}`);
-  seenDeprecations[`${version}/${message}`] = true;
-};
-
-/*
-Syntax highlighting with language autodetection.
-https://highlightjs.org/
+@typedef {import('highlight.js').Mode} Mode
+@typedef {import('highlight.js').CompiledMode} CompiledMode
+@typedef {import('highlight.js').CompiledScope} CompiledScope
+@typedef {import('highlight.js').Language} Language
+@typedef {import('highlight.js').HLJSApi} HLJSApi
+@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+@typedef {import('highlight.js').PluginEvent} PluginEvent
+@typedef {import('highlight.js').HLJSOptions} HLJSOptions
+@typedef {import('highlight.js').LanguageFn} LanguageFn
+@typedef {import('highlight.js').HighlightedHTMLElement} HighlightedHTMLElement
+@typedef {import('highlight.js').BeforeHighlightContext} BeforeHighlightContext
+@typedef {import('highlight.js/private').MatchType} MatchType
+@typedef {import('highlight.js/private').KeywordData} KeywordData
+@typedef {import('highlight.js/private').EnhancedMatch} EnhancedMatch
+@typedef {import('highlight.js/private').AnnotatedError} AnnotatedError
+@typedef {import('highlight.js').AutoHighlightResult} AutoHighlightResult
+@typedef {import('highlight.js').HighlightOptions} HighlightOptions
+@typedef {import('highlight.js').HighlightResult} HighlightResult
 */
 
-const escape$1 = escapeHTML;
-const inherit$1 = inherit;
+
+const escape = escapeHTML;
+const inherit = inherit$1;
 const NO_MATCH = Symbol("nomatch");
+const MAX_KEYWORD_HITS = 7;
 
 /**
  * @param {any} hljs - object that is extended (legacy)
@@ -1529,7 +1629,6 @@ const HLJS = function(hljs) {
   // safe/production mode - swallows more errors, tries to keep running
   // even if a single syntax or parse hits a fatal error
   let SAFE_MODE = true;
-  const fixMarkupRe = /(^(<[^>]+>|\t|)+|\n)/gm;
   const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";
   /** @type {Language} */
   const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: 'Plain text', contains: [] };
@@ -1538,11 +1637,12 @@ const HLJS = function(hljs) {
   // calling the `hljs.configure` function.
   /** @type HLJSOptions */
   let options = {
+    ignoreUnescapedHTML: false,
+    throwUnescapedHTML: false,
     noHighlightRe: /^(no-?highlight)$/i,
     languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
     classPrefix: 'hljs-',
-    tabReplace: null,
-    useBR: false,
+    cssSelector: 'pre code',
     languages: null,
     // beta configuration options, subject to change, welcome to discuss
     // https://github.com/highlightjs/highlight.js/issues/1086
@@ -1592,10 +1692,9 @@ const HLJS = function(hljs) {
    * NEW API
    * highlight(code, {lang, ignoreIllegals})
    *
-   * @param {string} codeOrlanguageName - the language to use for highlighting
+   * @param {string} codeOrLanguageName - the language to use for highlighting
    * @param {string | HighlightOptions} optionsOrCode - the code to highlight
    * @param {boolean} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
-   * @param {CompiledMode} [continuation] - current continuation mode, if any
    *
    * @returns {HighlightResult} Result - an object that represents the result
    * @property {string} language - the language name
@@ -1605,24 +1704,25 @@ const HLJS = function(hljs) {
    * @property {CompiledMode} top - top of the current mode stack
    * @property {boolean} illegal - indicates whether any illegal matches were found
   */
-  function highlight(codeOrlanguageName, optionsOrCode, ignoreIllegals, continuation) {
+  function highlight(codeOrLanguageName, optionsOrCode, ignoreIllegals) {
     let code = "";
     let languageName = "";
     if (typeof optionsOrCode === "object") {
-      code = codeOrlanguageName;
+      code = codeOrLanguageName;
       ignoreIllegals = optionsOrCode.ignoreIllegals;
       languageName = optionsOrCode.language;
-      // continuation not supported at all via the new API
-      // eslint-disable-next-line no-undefined
-      continuation = undefined;
     } else {
       // old API
       deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated.");
       deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
-      languageName = codeOrlanguageName;
+      languageName = codeOrLanguageName;
       code = optionsOrCode;
     }
 
+    // https://github.com/highlightjs/highlight.js/issues/3149
+    // eslint-disable-next-line no-undefined
+    if (ignoreIllegals === undefined) { ignoreIllegals = true; }
+
     /** @type {BeforeHighlightContext} */
     const context = {
       code,
@@ -1636,7 +1736,7 @@ const HLJS = function(hljs) {
     // in which case we don't even need to call highlight
     const result = context.result
       ? context.result
-      : _highlight(context.language, context.code, ignoreIllegals, continuation);
+      : _highlight(context.language, context.code, ignoreIllegals);
 
     result.code = context.code;
     // the plugin can change anything in result to suite it
@@ -1655,15 +1755,16 @@ const HLJS = function(hljs) {
    * @returns {HighlightResult} - result of the highlight operation
   */
   function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
+    const keywordHits = Object.create(null);
+
     /**
      * Return keyword data if a match is a keyword
      * @param {CompiledMode} mode - current mode
-     * @param {RegExpMatchArray} match - regexp match data
+     * @param {string} matchText - the textual match
      * @returns {KeywordData | false}
      */
-    function keywordData(mode, match) {
-      const matchText = language.case_insensitive ? match[0].toLowerCase() : match[0];
-      return Object.prototype.hasOwnProperty.call(mode.keywords, matchText) && mode.keywords[matchText];
+    function keywordData(mode, matchText) {
+      return mode.keywords[matchText];
     }
 
     function processKeywords() {
@@ -1679,13 +1780,15 @@ const HLJS = function(hljs) {
 
       while (match) {
         buf += modeBuffer.substring(lastIndex, match.index);
-        const data = keywordData(top, match);
+        const word = language.case_insensitive ? match[0].toLowerCase() : match[0];
+        const data = keywordData(top, word);
         if (data) {
           const [kind, keywordRelevance] = data;
           emitter.addText(buf);
           buf = "";
 
-          relevance += keywordRelevance;
+          keywordHits[word] = (keywordHits[word] || 0) + 1;
+          if (keywordHits[word] <= MAX_KEYWORD_HITS) relevance += keywordRelevance;
           if (kind.startsWith("_")) {
             // _ implied for relevance only, do not highlight
             // by applying a class name
@@ -1700,7 +1803,7 @@ const HLJS = function(hljs) {
         lastIndex = top.keywordPatternRe.lastIndex;
         match = top.keywordPatternRe.exec(modeBuffer);
       }
-      buf += modeBuffer.substr(lastIndex);
+      buf += modeBuffer.substring(lastIndex);
       emitter.addText(buf);
     }
 
@@ -1715,7 +1818,7 @@ const HLJS = function(hljs) {
           return;
         }
         result = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
-        continuations[top.subLanguage] = /** @type {CompiledMode} */ (result.top);
+        continuations[top.subLanguage] = /** @type {CompiledMode} */ (result._top);
       } else {
         result = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
       }
@@ -1727,7 +1830,7 @@ const HLJS = function(hljs) {
       if (top.relevance > 0) {
         relevance += result.relevance;
       }
-      emitter.addSublanguage(result.emitter, result.language);
+      emitter.addSublanguage(result._emitter, result.language);
     }
 
     function processBuffer() {
@@ -1740,12 +1843,47 @@ const HLJS = function(hljs) {
     }
 
     /**
-     * @param {Mode} mode - new mode to start
+     * @param {CompiledScope} scope
+     * @param {RegExpMatchArray} match
+     */
+    function emitMultiClass(scope, match) {
+      let i = 1;
+      const max = match.length - 1;
+      while (i <= max) {
+        if (!scope._emit[i]) { i++; continue; }
+        const klass = language.classNameAliases[scope[i]] || scope[i];
+        const text = match[i];
+        if (klass) {
+          emitter.addKeyword(text, klass);
+        } else {
+          modeBuffer = text;
+          processKeywords();
+          modeBuffer = "";
+        }
+        i++;
+      }
+    }
+
+    /**
+     * @param {CompiledMode} mode - new mode to start
+     * @param {RegExpMatchArray} match
      */
-    function startNewMode(mode) {
-      if (mode.className) {
-        emitter.openNode(language.classNameAliases[mode.className] || mode.className);
+    function startNewMode(mode, match) {
+      if (mode.scope && typeof mode.scope === "string") {
+        emitter.openNode(language.classNameAliases[mode.scope] || mode.scope);
       }
+      if (mode.beginScope) {
+        // beginScope just wraps the begin match itself in a scope
+        if (mode.beginScope._wrap) {
+          emitter.addKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap);
+          modeBuffer = "";
+        } else if (mode.beginScope._multi) {
+          // at this point modeBuffer should just be the match
+          emitMultiClass(mode.beginScope, match);
+          modeBuffer = "";
+        }
+      }
+
       top = Object.create(mode, { parent: { value: top } });
       return top;
     }
@@ -1787,7 +1925,7 @@ const HLJS = function(hljs) {
      */
     function doIgnore(lexeme) {
       if (top.matcher.regexIndex === 0) {
-        // no more regexs to potentially match here, so we move the cursor forward one
+        // no more regexes to potentially match here, so we move the cursor forward one
         // space
         modeBuffer += lexeme[0];
         return 1;
@@ -1818,10 +1956,6 @@ const HLJS = function(hljs) {
         if (resp.isMatchIgnored) return doIgnore(lexeme);
       }
 
-      if (newMode && newMode.endSameAsBegin) {
-        newMode.endRe = escape(lexeme);
-      }
-
       if (newMode.skip) {
         modeBuffer += lexeme;
       } else {
@@ -1833,11 +1967,7 @@ const HLJS = function(hljs) {
           modeBuffer = lexeme;
         }
       }
-      startNewMode(newMode);
-      // if (mode["after:begin"]) {
-      //   let resp = new Response(mode);
-      //   mode["after:begin"](match, resp);
-      // }
+      startNewMode(newMode, match);
       return newMode.returnBegin ? 0 : lexeme.length;
     }
 
@@ -1848,13 +1978,19 @@ const HLJS = function(hljs) {
      */
     function doEndMatch(match) {
       const lexeme = match[0];
-      const matchPlusRemainder = codeToHighlight.substr(match.index);
+      const matchPlusRemainder = codeToHighlight.substring(match.index);
 
       const endMode = endOfMode(top, match, matchPlusRemainder);
       if (!endMode) { return NO_MATCH; }
 
       const origin = top;
-      if (origin.skip) {
+      if (top.endScope && top.endScope._wrap) {
+        processBuffer();
+        emitter.addKeyword(lexeme, top.endScope._wrap);
+      } else if (top.endScope && top.endScope._multi) {
+        processBuffer();
+        emitMultiClass(top.endScope, match);
+      } else if (origin.skip) {
         modeBuffer += lexeme;
       } else {
         if (!(origin.returnEnd || origin.excludeEnd)) {
@@ -1866,7 +2002,7 @@ const HLJS = function(hljs) {
         }
       }
       do {
-        if (top.className) {
+        if (top.scope) {
           emitter.closeNode();
         }
         if (!top.skip && !top.subLanguage) {
@@ -1875,10 +2011,7 @@ const HLJS = function(hljs) {
         top = top.parent;
       } while (top !== endMode.parent);
       if (endMode.starts) {
-        if (endMode.endSameAsBegin) {
-          endMode.starts.endRe = endMode.endRe;
-        }
-        startNewMode(endMode.starts);
+        startNewMode(endMode.starts, match);
       }
       return origin.returnEnd ? 0 : lexeme.length;
     }
@@ -1886,8 +2019,8 @@ const HLJS = function(hljs) {
     function processContinuations() {
       const list = [];
       for (let current = top; current !== language; current = current.parent) {
-        if (current.className) {
-          list.unshift(current.className);
+        if (current.scope) {
+          list.unshift(current.scope);
         }
       }
       list.forEach(item => emitter.openNode(item));
@@ -1899,7 +2032,7 @@ const HLJS = function(hljs) {
     /**
      *  Process an individual match
      *
-     * @param {string} textBeforeMatch - text preceeding the match (since the last match)
+     * @param {string} textBeforeMatch - text preceding the match (since the last match)
      * @param {EnhancedMatch} [match] - the match itself
      */
     function processLexeme(textBeforeMatch, match) {
@@ -1922,7 +2055,7 @@ const HLJS = function(hljs) {
         modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
         if (!SAFE_MODE) {
           /** @type {AnnotatedError} */
-          const err = new Error('0 width match regex');
+          const err = new Error(`0 width match regex (${languageName})`);
           err.languageName = languageName;
           err.badRule = lastMatch.rule;
           throw err;
@@ -1936,7 +2069,7 @@ const HLJS = function(hljs) {
       } else if (match.type === "illegal" && !ignoreIllegals) {
         // illegal match, we do not continue processing
         /** @type {AnnotatedError} */
-        const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.className || '<unnamed>') + '"');
+        const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || '<unnamed>') + '"');
         err.mode = top;
         throw err;
       } else if (match.type === "end") {
@@ -1964,13 +2097,9 @@ const HLJS = function(hljs) {
       }
 
       /*
-      Why might be find ourselves here?  Only one occasion now.  An end match that was
-      triggered but could not be completed.  When might this happen?  When an `endSameasBegin`
-      rule sets the end rule to a specific match.  Since the overall mode termination rule that's
-      being used to scan the text isn't recompiled that means that any match that LOOKS like
-      the end (but is not, because it is not an exact match to the beginning) will
-      end up here.  A definite end match, but when `doEndMatch` tries to "reapply"
-      the end rule and fails to match, we wind up here, and just silently ignore the end.
+      Why might be find ourselves here?  An potential end match that was
+      triggered but could not be completed.  IE, `doEndMatch` returned NO_MATCH.
+      (this could be because a callback requests the match be ignored, etc)
 
       This causes no real harm other than stopping a few times too many.
       */
@@ -1985,7 +2114,7 @@ const HLJS = function(hljs) {
       throw new Error('Unknown language: "' + languageName + '"');
     }
 
-    const md = compileLanguage(language, { plugins });
+    const md = compileLanguage(language);
     let result = '';
     /** @type {CompiledMode} */
     let top = continuation || md;
@@ -2022,44 +2151,44 @@ const HLJS = function(hljs) {
         const processedCount = processLexeme(beforeMatch, match);
         index = match.index + processedCount;
       }
-      processLexeme(codeToHighlight.substr(index));
+      processLexeme(codeToHighlight.substring(index));
       emitter.closeAllNodes();
       emitter.finalize();
       result = emitter.toHTML();
 
       return {
-        // avoid possible breakage with v10 clients expecting
-        // this to always be an integer
-        relevance: Math.floor(relevance),
-        value: result,
         language: languageName,
+        value: result,
+        relevance: relevance,
         illegal: false,
-        emitter: emitter,
-        top: top
+        _emitter: emitter,
+        _top: top
       };
     } catch (err) {
       if (err.message && err.message.includes('Illegal')) {
         return {
+          language: languageName,
+          value: escape(codeToHighlight),
           illegal: true,
-          illegalBy: {
-            msg: err.message,
+          relevance: 0,
+          _illegalBy: {
+            message: err.message,
+            index: index,
             context: codeToHighlight.slice(index - 100, index + 100),
-            mode: err.mode
+            mode: err.mode,
+            resultSoFar: result
           },
-          sofar: result,
-          relevance: 0,
-          value: escape$1(codeToHighlight),
-          emitter: emitter
+          _emitter: emitter
         };
       } else if (SAFE_MODE) {
         return {
+          language: languageName,
+          value: escape(codeToHighlight),
           illegal: false,
           relevance: 0,
-          value: escape$1(codeToHighlight),
-          emitter: emitter,
-          language: languageName,
-          top: top,
-          errorRaised: err
+          errorRaised: err,
+          _emitter: emitter,
+          _top: top
         };
       } else {
         throw err;
@@ -2076,13 +2205,13 @@ const HLJS = function(hljs) {
    */
   function justTextHighlightResult(code) {
     const result = {
-      relevance: 0,
-      emitter: new options.__emitter(options),
-      value: escape$1(code),
+      value: escape(code),
       illegal: false,
-      top: PLAINTEXT_LANGUAGE
+      relevance: 0,
+      _top: PLAINTEXT_LANGUAGE,
+      _emitter: new options.__emitter(options)
     };
-    result.emitter.addText(code);
+    result._emitter.addText(code);
     return result;
   }
 
@@ -2093,7 +2222,7 @@ const HLJS = function(hljs) {
   - language (detected language)
   - relevance (int)
   - value (an HTML string with highlighting markup)
-  - second_best (object with the same structure for second-best heuristically
+  - secondBest (object with the same structure for second-best heuristically
     detected language, may be absent)
 
     @param {string} code
@@ -2134,35 +2263,11 @@ const HLJS = function(hljs) {
 
     /** @type {AutoHighlightResult} */
     const result = best;
-    result.second_best = secondBest;
+    result.secondBest = secondBest;
 
     return result;
   }
 
-  /**
-  Post-processing of the highlighted markup:
-
-  - replace TABs with something more useful
-  - replace real line-breaks with '<br>' for non-pre containers
-
-    @param {string} html
-    @returns {string}
-  */
-  function fixMarkup(html) {
-    if (!(options.tabReplace || options.useBR)) {
-      return html;
-    }
-
-    return html.replace(fixMarkupRe, match => {
-      if (match === '\n') {
-        return options.useBR ? '<br>' : match;
-      } else if (options.tabReplace) {
-        return match.replace(/\t/g, options.tabReplace);
-      }
-      return match;
-    });
-  }
-
   /**
    * Builds new class name for block given the language name
    *
@@ -2171,41 +2276,14 @@ const HLJS = function(hljs) {
    * @param {string} [resultLang]
    */
   function updateClassName(element, currentLang, resultLang) {
-    const language = currentLang ? aliases[currentLang] : resultLang;
+    const language = (currentLang && aliases[currentLang]) || resultLang;
 
     element.classList.add("hljs");
-    if (language) element.classList.add(language);
+    element.classList.add(`language-${language}`);
   }
 
-  /** @type {HLJSPlugin} */
-  const brPlugin = {
-    "before:highlightElement": ({ el }) => {
-      if (options.useBR) {
-        el.innerHTML = el.innerHTML.replace(/\n/g, '').replace(/<br[ /]*>/g, '\n');
-      }
-    },
-    "after:highlightElement": ({ result }) => {
-      if (options.useBR) {
-        result.value = result.value.replace(/\n/g, "<br>");
-      }
-    }
-  };
-
-  const TAB_REPLACE_RE = /^(<[^>]+>|\t)+/gm;
-  /** @type {HLJSPlugin} */
-  const tabReplacePlugin = {
-    "after:highlightElement": ({ result }) => {
-      if (options.tabReplace) {
-        result.value = result.value.replace(TAB_REPLACE_RE, (m) =>
-          m.replace(/\t/g, options.tabReplace)
-        );
-      }
-    }
-  };
-
   /**
-   * Applies highlighting to a DOM node containing code. Accepts a DOM node and
-   * two optional parameters for fixMarkup.
+   * Applies highlighting to a DOM node containing code.
    *
    * @param {HighlightedHTMLElement} element - the HTML element to highlight
   */
@@ -2216,33 +2294,50 @@ const HLJS = function(hljs) {
 
     if (shouldNotHighlight(language)) return;
 
-    // support for v10 API
     fire("before:highlightElement",
       { el: element, language: language });
 
+    // we should be all text, no child nodes (unescaped HTML) - this is possibly
+    // an HTML injection attack - it's likely too late if this is already in
+    // production (the code has likely already done its damage by the time
+    // we're seeing it)... but we yell loudly about this so that hopefully it's
+    // more likely to be caught in development before making it to production
+    if (element.children.length > 0) {
+      if (!options.ignoreUnescapedHTML) {
+        console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk.");
+        console.warn("https://github.com/highlightjs/highlight.js/wiki/security");
+        console.warn("The element with unescaped HTML:");
+        console.warn(element);
+      }
+      if (options.throwUnescapedHTML) {
+        const err = new HTMLInjectionError(
+          "One of your code blocks includes unescaped HTML.",
+          element.innerHTML
+        );
+        throw err;
+      }
+    }
+
     node = element;
     const text = node.textContent;
     const result = language ? highlight(text, { language, ignoreIllegals: true }) : highlightAuto(text);
 
-    // support for v10 API
-    fire("after:highlightElement", { el: element, result, text });
-
     element.innerHTML = result.value;
     updateClassName(element, language, result.language);
     element.result = {
       language: result.language,
       // TODO: remove with version 11.0
       re: result.relevance,
-      relavance: result.relevance
+      relevance: result.relevance
     };
-    if (result.second_best) {
-      element.second_best = {
-        language: result.second_best.language,
-        // TODO: remove with version 11.0
-        re: result.second_best.relevance,
-        relavance: result.second_best.relevance
+    if (result.secondBest) {
+      element.secondBest = {
+        language: result.secondBest.language,
+        relevance: result.secondBest.relevance
       };
     }
+
+    fire("after:highlightElement", { el: element, result, text });
   }
 
   /**
@@ -2251,34 +2346,19 @@ const HLJS = function(hljs) {
    * @param {Partial<HLJSOptions>} userOptions
    */
   function configure(userOptions) {
-    if (userOptions.useBR) {
-      deprecated("10.3.0", "'useBR' will be removed entirely in v11.0");
-      deprecated("10.3.0", "Please see https://github.com/highlightjs/highlight.js/issues/2559");
-    }
-    options = inherit$1(options, userOptions);
+    options = inherit(options, userOptions);
   }
 
-  /**
-   * Highlights to all <pre><code> blocks on a page
-   *
-   * @type {Function & {called?: boolean}}
-   */
   // TODO: remove v12, deprecated
   const initHighlighting = () => {
-    if (initHighlighting.called) return;
-    initHighlighting.called = true;
-
-    deprecated("10.6.0", "initHighlighting() is deprecated.  Use highlightAll() instead.");
-
-    const blocks = document.querySelectorAll('pre code');
-    blocks.forEach(highlightElement);
+    highlightAll();
+    deprecated("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
   };
 
-  // Higlights all when DOMContentLoaded fires
   // TODO: remove v12, deprecated
   function initHighlightingOnLoad() {
-    deprecated("10.6.0", "initHighlightingOnLoad() is deprecated.  Use highlightAll() instead.");
-    wantsHighlight = true;
+    highlightAll();
+    deprecated("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
   }
 
   let wantsHighlight = false;
@@ -2293,7 +2373,7 @@ const HLJS = function(hljs) {
       return;
     }
 
-    const blocks = document.querySelectorAll('pre code');
+    const blocks = document.querySelectorAll(options.cssSelector);
     blocks.forEach(highlightElement);
   }
 
@@ -2358,26 +2438,6 @@ const HLJS = function(hljs) {
     return Object.keys(languages);
   }
 
-  /**
-    intended usage: When one language truly requires another
-
-    Unlike `getLanguage`, this will throw when the requested language
-    is not available.
-
-    @param {string} name - name of the language to fetch/require
-    @returns {Language | never}
-  */
-  function requireLanguage(name) {
-    deprecated("10.4.0", "requireLanguage will be removed entirely in v11.");
-    deprecated("10.4.0", "Please see https://github.com/highlightjs/highlight.js/pull/2844");
-
-    const lang = getLanguage(name);
-    if (lang) { return lang; }
-
-    const err = new Error('The \'{}\' language is required, but not loaded.'.replace('{}', name));
-    throw err;
-  }
-
   /**
    * @param {string} name - name of the language to retrieve
    * @returns {Language | undefined}
@@ -2454,20 +2514,7 @@ const HLJS = function(hljs) {
   }
 
   /**
-  Note: fixMarkup is deprecated and will be removed entirely in v11
-
-  @param {string} arg
-  @returns {string}
-  */
-  function deprecateFixMarkup(arg) {
-    deprecated("10.2.0", "fixMarkup will be removed entirely in v11.0");
-    deprecated("10.2.0", "Please see https://github.com/highlightjs/highlight.js/issues/2534");
-
-    return fixMarkup(arg);
-  }
-
-  /**
-   *
+   * DEPRECATED
    * @param {HighlightedHTMLElement} el
    */
   function deprecateHighlightBlock(el) {
@@ -2482,7 +2529,6 @@ const HLJS = function(hljs) {
     highlight,
     highlightAuto,
     highlightAll,
-    fixMarkup: deprecateFixMarkup,
     highlightElement,
     // TODO: Remove with v12 API
     highlightBlock: deprecateHighlightBlock,
@@ -2494,404 +2540,50 @@ const HLJS = function(hljs) {
     listLanguages,
     getLanguage,
     registerAliases,
-    requireLanguage,
     autoDetection,
-    inherit: inherit$1,
-    addPlugin,
-    // plugins for frameworks
-    vuePlugin: BuildVuePlugin(hljs).VuePlugin
+    inherit,
+    addPlugin
   });
 
   hljs.debugMode = function() { SAFE_MODE = false; };
   hljs.safeMode = function() { SAFE_MODE = true; };
   hljs.versionString = version;
 
+  hljs.regex = {
+    concat: concat,
+    lookahead: lookahead,
+    either: either,
+    optional: optional,
+    anyNumberOfTimes: anyNumberOfTimes
+  };
+
   for (const key in MODES) {
     // @ts-ignore
     if (typeof MODES[key] === "object") {
       // @ts-ignore
-      deepFreezeEs6(MODES[key]);
+      deepFreezeEs6.exports(MODES[key]);
     }
   }
 
-  // merge all the modes/regexs into our main object
+  // merge all the modes/regexes into our main object
   Object.assign(hljs, MODES);
 
-  // built-in plugins, likely to be moved out of core in the future
-  hljs.addPlugin(brPlugin); // slated to be removed in v11
-  hljs.addPlugin(mergeHTMLPlugin);
-  hljs.addPlugin(tabReplacePlugin);
   return hljs;
 };
 
 // export an "instance" of the highlighter
-var highlight$1 = HLJS({});
-
-var core$1 = highlight$1;
+var highlight = HLJS({});
 
-function createCommonjsModule(fn) {
-  var module = { exports: {} };
-	return fn(module, module.exports), module.exports;
-}
-
-var format = createCommonjsModule(function (module) {
-(function() {
-
-  //// Export the API
-  var namespace;
-
-  // CommonJS / Node module
-  {
-    namespace = module.exports = format;
-  }
-
-  namespace.format = format;
-  namespace.vsprintf = vsprintf;
-
-  if (typeof console !== 'undefined' && typeof console.log === 'function') {
-    namespace.printf = printf;
-  }
-
-  function printf(/* ... */) {
-    console.log(format.apply(null, arguments));
-  }
-
-  function vsprintf(fmt, replacements) {
-    return format.apply(null, [fmt].concat(replacements));
-  }
-
-  function format(fmt) {
-    var argIndex = 1 // skip initial format argument
-      , args = [].slice.call(arguments)
-      , i = 0
-      , n = fmt.length
-      , result = ''
-      , c
-      , escaped = false
-      , arg
-      , tmp
-      , leadingZero = false
-      , precision
-      , nextArg = function() { return args[argIndex++]; }
-      , slurpNumber = function() {
-          var digits = '';
-          while (/\d/.test(fmt[i])) {
-            digits += fmt[i++];
-            c = fmt[i];
-          }
-          return digits.length > 0 ? parseInt(digits) : null;
-        }
-      ;
-    for (; i < n; ++i) {
-      c = fmt[i];
-      if (escaped) {
-        escaped = false;
-        if (c == '.') {
-          leadingZero = false;
-          c = fmt[++i];
-        }
-        else if (c == '0' && fmt[i + 1] == '.') {
-          leadingZero = true;
-          i += 2;
-          c = fmt[i];
-        }
-        else {
-          leadingZero = true;
-        }
-        precision = slurpNumber();
-        switch (c) {
-        case 'b': // number in binary
-          result += parseInt(nextArg(), 10).toString(2);
-          break;
-        case 'c': // character
-          arg = nextArg();
-          if (typeof arg === 'string' || arg instanceof String)
-            result += arg;
-          else
-            result += String.fromCharCode(parseInt(arg, 10));
-          break;
-        case 'd': // number in decimal
-          result += parseInt(nextArg(), 10);
-          break;
-        case 'f': // floating point number
-          tmp = String(parseFloat(nextArg()).toFixed(precision || 6));
-          result += leadingZero ? tmp : tmp.replace(/^0/, '');
-          break;
-        case 'j': // JSON
-          result += JSON.stringify(nextArg());
-          break;
-        case 'o': // number in octal
-          result += '0' + parseInt(nextArg(), 10).toString(8);
-          break;
-        case 's': // string
-          result += nextArg();
-          break;
-        case 'x': // lowercase hexadecimal
-          result += '0x' + parseInt(nextArg(), 10).toString(16);
-          break;
-        case 'X': // uppercase hexadecimal
-          result += '0x' + parseInt(nextArg(), 10).toString(16).toUpperCase();
-          break;
-        default:
-          result += c;
-          break;
-        }
-      } else if (c === '%') {
-        escaped = true;
-      } else {
-        result += c;
-      }
-    }
-    return result;
-  }
-
-}());
-});
-
-var fault = create(Error);
-
-var fault_1 = fault;
-
-fault.eval = create(EvalError);
-fault.range = create(RangeError);
-fault.reference = create(ReferenceError);
-fault.syntax = create(SyntaxError);
-fault.type = create(TypeError);
-fault.uri = create(URIError);
-
-fault.create = create;
-
-// Create a new `EConstructor`, with the formatted `format` as a first argument.
-function create(EConstructor) {
-  FormattedError.displayName = EConstructor.displayName || EConstructor.name;
-
-  return FormattedError
-
-  function FormattedError(format$1) {
-    if (format$1) {
-      format$1 = format.apply(null, arguments);
-    }
-
-    return new EConstructor(format$1)
-  }
-}
-
-var highlight_1 = highlight;
-var highlightAuto_1 = highlightAuto;
-var registerLanguage_1 = registerLanguage;
-var listLanguages_1 = listLanguages;
-var registerAlias_1 = registerAlias;
-
-Emitter.prototype.addText = text;
-Emitter.prototype.addKeyword = addKeyword;
-Emitter.prototype.addSublanguage = addSublanguage;
-Emitter.prototype.openNode = open;
-Emitter.prototype.closeNode = close;
-Emitter.prototype.closeAllNodes = noop;
-Emitter.prototype.finalize = noop;
-Emitter.prototype.toHTML = toHtmlNoop;
-
-var defaultPrefix = 'hljs-';
-
-// Highlighting `value` in the language `name`.
-function highlight(name, value, options) {
-  var before = core$1.configure({});
-  var settings = options || {};
-  var prefix = settings.prefix;
-  var result;
-
-  if (typeof name !== 'string') {
-    throw fault_1('Expected `string` for name, got `%s`', name)
-  }
-
-  if (!core$1.getLanguage(name)) {
-    throw fault_1('Unknown language: `%s` is not registered', name)
-  }
-
-  if (typeof value !== 'string') {
-    throw fault_1('Expected `string` for value, got `%s`', value)
-  }
-
-  if (prefix === null || prefix === undefined) {
-    prefix = defaultPrefix;
-  }
-
-  core$1.configure({__emitter: Emitter, classPrefix: prefix});
-
-  result = core$1.highlight(value, {language: name, ignoreIllegals: true});
-
-  core$1.configure(before || {});
-
-  /* istanbul ignore if - Highlight.js seems to use this (currently) for broken
-   * grammars, so let’s keep it in there just to be sure. */
-  if (result.errorRaised) {
-    throw result.errorRaised
-  }
-
-  return {
-    relevance: result.relevance,
-    language: result.language,
-    value: result.emitter.rootNode.children
-  }
-}
-
-function highlightAuto(value, options) {
-  var settings = options || {};
-  var subset = settings.subset || core$1.listLanguages();
-  settings.prefix;
-  var length = subset.length;
-  var index = -1;
-  var result;
-  var secondBest;
-  var current;
-  var name;
-
-  if (typeof value !== 'string') {
-    throw fault_1('Expected `string` for value, got `%s`', value)
-  }
+var core = highlight;
+highlight.HighlightJS = highlight;
+highlight.default = highlight;
 
-  secondBest = {relevance: 0, language: null, value: []};
-  result = {relevance: 0, language: null, value: []};
-
-  while (++index < length) {
-    name = subset[index];
-
-    if (!core$1.getLanguage(name)) {
-      continue
-    }
-
-    current = highlight(name, value, options);
-    current.language = name;
-
-    if (current.relevance > secondBest.relevance) {
-      secondBest = current;
-    }
-
-    if (current.relevance > result.relevance) {
-      secondBest = result;
-      result = current;
-    }
-  }
-
-  if (secondBest.language) {
-    result.secondBest = secondBest;
-  }
-
-  return result
-}
-
-// Register a language.
-function registerLanguage(name, syntax) {
-  core$1.registerLanguage(name, syntax);
-}
-
-// Get a list of all registered languages.
-function listLanguages() {
-  return core$1.listLanguages()
-}
-
-// Register more aliases for an already registered language.
-function registerAlias(name, alias) {
-  var map = name;
-  var key;
-
-  if (alias) {
-    map = {};
-    map[name] = alias;
-  }
-
-  for (key in map) {
-    core$1.registerAliases(map[key], {languageName: key});
-  }
-}
-
-function Emitter(options) {
-  this.options = options;
-  this.rootNode = {children: []};
-  this.stack = [this.rootNode];
-}
-
-function addKeyword(value, name) {
-  this.openNode(name);
-  this.addText(value);
-  this.closeNode();
-}
-
-function addSublanguage(other, name) {
-  var stack = this.stack;
-  var current = stack[stack.length - 1];
-  var results = other.rootNode.children;
-  var node = name
-    ? {
-        type: 'element',
-        tagName: 'span',
-        properties: {className: [name]},
-        children: results
-      }
-    : results;
-
-  current.children = current.children.concat(node);
-}
-
-function text(value) {
-  var stack = this.stack;
-  var current;
-  var tail;
-
-  if (value === '') return
-
-  current = stack[stack.length - 1];
-  tail = current.children[current.children.length - 1];
-
-  if (tail && tail.type === 'text') {
-    tail.value += value;
-  } else {
-    current.children.push({type: 'text', value: value});
-  }
-}
-
-function open(name) {
-  var stack = this.stack;
-  var className = this.options.classPrefix + name;
-  var current = stack[stack.length - 1];
-  var child = {
-    type: 'element',
-    tagName: 'span',
-    properties: {className: [className]},
-    children: []
-  };
-
-  current.children.push(child);
-  stack.push(child);
-}
-
-function close() {
-  this.stack.pop();
-}
-
-function toHtmlNoop() {
-  return ''
-}
-
-function noop() {}
-
-var core = {
-	highlight: highlight_1,
-	highlightAuto: highlightAuto_1,
-	registerLanguage: registerLanguage_1,
-	listLanguages: listLanguages_1,
-	registerAlias: registerAlias_1
-};
+var HighlightJS = core;
 
 function parseNodes(nodes, className = []) {
     return nodes
         .map(node => {
-        const classes = [
-            ...className,
-            ...node.properties
-                ? node.properties.className
-                : [],
-        ];
+        const classes = [...className, ...(node.properties ? node.properties.className : [])];
         if (node.children) {
             return parseNodes(node.children, classes);
         }
@@ -2902,22 +2594,26 @@ function parseNodes(nodes, className = []) {
     })
         .flat();
 }
-function getDecorations({ doc, name, lowlight }) {
+function getHighlightNodes(result) {
+    // `.value` for lowlight v1, `.children` for lowlight v2
+    return result.value || result.children || [];
+}
+function registered(aliasOrLanguage) {
+    return Boolean(HighlightJS.getLanguage(aliasOrLanguage));
+}
+function getDecorations({ doc, name, lowlight, defaultLanguage, }) {
     const decorations = [];
-    core$2.findChildren(doc, node => node.type.name === name)
-        .forEach(block => {
+    core$1.findChildren(doc, node => node.type.name === name).forEach(block => {
         let from = block.pos + 1;
-        const { language } = block.node.attrs;
-        // TODO: add missing type for `listLanguages`
-        // @ts-ignore
+        const language = block.node.attrs.language || defaultLanguage;
         const languages = lowlight.listLanguages();
-        const nodes = language && languages.includes(language)
-            ? lowlight.highlight(language, block.node.textContent).value
-            : lowlight.highlightAuto(block.node.textContent).value;
+        const nodes = language && (languages.includes(language) || registered(language))
+            ? getHighlightNodes(lowlight.highlight(language, block.node.textContent))
+            : getHighlightNodes(lowlight.highlightAuto(block.node.textContent));
         parseNodes(nodes).forEach(node => {
             const to = from + node.text.length;
             if (node.classes.length) {
-                const decoration = prosemirrorView.Decoration.inline(from, to, {
+                const decoration = view.Decoration.inline(from, to, {
                     class: node.classes.join(' '),
                 });
                 decorations.push(decoration);
@@ -2925,23 +2621,33 @@ function getDecorations({ doc, name, lowlight }) {
             from = to;
         });
     });
-    return prosemirrorView.DecorationSet.create(doc, decorations);
+    return view.DecorationSet.create(doc, decorations);
 }
-function LowlightPlugin({ name, lowlight }) {
-    return new prosemirrorState.Plugin({
-        key: new prosemirrorState.PluginKey('lowlight'),
+function isFunction(param) {
+    return typeof param === 'function';
+}
+function LowlightPlugin({ name, lowlight, defaultLanguage, }) {
+    if (!['highlight', 'highlightAuto', 'listLanguages'].every(api => isFunction(lowlight[api]))) {
+        throw Error('You should provide an instance of lowlight to use the code-block-lowlight extension');
+    }
+    const lowlightPlugin = new state.Plugin({
+        key: new state.PluginKey('lowlight'),
         state: {
-            init: (_, { doc }) => getDecorations({ doc, name, lowlight }),
+            init: (_, { doc }) => getDecorations({
+                doc,
+                name,
+                lowlight,
+                defaultLanguage,
+            }),
             apply: (transaction, decorationSet, oldState, newState) => {
                 const oldNodeName = oldState.selection.$head.parent.type.name;
                 const newNodeName = newState.selection.$head.parent.type.name;
-                const oldNodes = core$2.findChildren(oldState.doc, node => node.type.name === name);
-                const newNodes = core$2.findChildren(newState.doc, node => node.type.name === name);
+                const oldNodes = core$1.findChildren(oldState.doc, node => node.type.name === name);
+                const newNodes = core$1.findChildren(newState.doc, node => node.type.name === name);
                 if (transaction.docChanged
                     // Apply decorations if:
-                    && (
                     // selection includes named node,
-                    [oldNodeName, newNodeName].includes(name)
+                    && ([oldNodeName, newNodeName].includes(name)
                         // OR transaction adds/removes named node,
                         || newNodes.length !== oldNodes.length
                         // OR transaction has changes that completely encapsulte a node
@@ -2949,46 +2655,61 @@ function LowlightPlugin({ name, lowlight }) {
                         // Such transactions can happen during collab syncing via y-prosemirror, for example.
                         || transaction.steps.some(step => {
                             // @ts-ignore
-                            return step.from !== undefined
+                            return (
+                            // @ts-ignore
+                            step.from !== undefined
                                 // @ts-ignore
                                 && step.to !== undefined
                                 && oldNodes.some(node => {
                                     // @ts-ignore
-                                    return node.pos >= step.from
+                                    return (
+                                    // @ts-ignore
+                                    node.pos >= step.from
                                         // @ts-ignore
-                                        && node.pos + node.node.nodeSize <= step.to;
-                                });
+                                        && node.pos + node.node.nodeSize <= step.to);
+                                }));
                         }))) {
-                    return getDecorations({ doc: transaction.doc, name, lowlight });
+                    return getDecorations({
+                        doc: transaction.doc,
+                        name,
+                        lowlight,
+                        defaultLanguage,
+                    });
                 }
                 return decorationSet.map(transaction.mapping, transaction.doc);
             },
         },
         props: {
             decorations(state) {
-                return this.getState(state);
+                return lowlightPlugin.getState(state);
             },
         },
     });
+    return lowlightPlugin;
 }
 
-const CodeBlockLowlight = CodeBlock__default['default'].extend({
-    defaultOptions: {
-        ...CodeBlock__default['default'].options,
-        lowlight: core,
+const CodeBlockLowlight = CodeBlock__default["default"].extend({
+    addOptions() {
+        var _a;
+        return {
+            ...(_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this),
+            lowlight: {},
+            defaultLanguage: null,
+        };
     },
     addProseMirrorPlugins() {
         var _a;
         return [
             ...((_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this)) || [],
             LowlightPlugin({
-                name: 'codeBlock',
+                name: this.name,
                 lowlight: this.options.lowlight,
+                defaultLanguage: this.options.defaultLanguage,
             }),
         ];
     },
 });
 
 exports.CodeBlockLowlight = CodeBlockLowlight;
-exports.default = CodeBlockLowlight;
-//# sourceMappingURL=tiptap-extension-code-block-lowlight.cjs.js.map
+exports["default"] = CodeBlockLowlight;
+//# sourceMappingURL=index.cjs.map