@tiptap/extension-code-block-lowlight 2.0.0-beta.54 → 2.0.0-beta.55

package/dist/tiptap-extension-code-block-lowlight.umd.js

@@ -0,0 +1,3009 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@tiptap/extension-code-block'), require('prosemirror-state'), require('prosemirror-view'), require('@tiptap/core')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@tiptap/extension-code-block', 'prosemirror-state', 'prosemirror-view', '@tiptap/core'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@tiptap/extension-code-block-lowlight"] = {}, global.CodeBlock, global.prosemirrorState, global.prosemirrorView, global.core$2));
+})(this, (function (exports, CodeBlock, prosemirrorState, prosemirrorView, core$2) { 'use strict';
+
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+  var CodeBlock__default = /*#__PURE__*/_interopDefaultLegacy(CodeBlock);
+
+  var core$1 = {};
+
+  function deepFreeze(obj) {
+      if (obj instanceof Map) {
+          obj.clear = obj.delete = obj.set = function () {
+              throw new Error('map is read-only');
+          };
+      } else if (obj instanceof Set) {
+          obj.add = obj.clear = obj.delete = function () {
+              throw new Error('set is read-only');
+          };
+      }
+
+      // Freeze self
+      Object.freeze(obj);
+
+      Object.getOwnPropertyNames(obj).forEach(function (name) {
+          var prop = obj[name];
+
+          // Freeze prop if it is an object
+          if (typeof prop == 'object' && !Object.isFrozen(prop)) {
+              deepFreeze(prop);
+          }
+      });
+
+      return obj;
+  }
+
+  var deepFreezeEs6 = deepFreeze;
+  var _default = deepFreeze;
+  deepFreezeEs6.default = _default;
+
+  /** @implements CallbackResponse */
+  class Response {
+    /**
+     * @param {CompiledMode} mode
+     */
+    constructor(mode) {
+      // eslint-disable-next-line no-undefined
+      if (mode.data === undefined) mode.data = {};
+
+      this.data = mode.data;
+      this.isMatchIgnored = false;
+    }
+
+    ignoreMatch() {
+      this.isMatchIgnored = true;
+    }
+  }
+
+  /**
+   * @param {string} value
+   * @returns {string}
+   */
+  function escapeHTML(value) {
+    return value
+      .replace(/&/g, '&')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#x27;');
+  }
+
+  /**
+   * performs a shallow merge of multiple objects into one
+   *
+   * @template T
+   * @param {T} original
+   * @param {Record<string,any>[]} objects
+   * @returns {T} a single new object
+   */
+  function inherit(original, ...objects) {
+    /** @type Record<string,any> */
+    const result = Object.create(null);
+
+    for (const key in original) {
+      result[key] = original[key];
+    }
+    objects.forEach(function(obj) {
+      for (const key in obj) {
+        result[key] = obj[key];
+      }
+    });
+    return /** @type {T} */ (result);
+  }
+
+  /**
+   * @typedef {object} Renderer
+   * @property {(text: string) => void} addText
+   * @property {(node: Node) => void} openNode
+   * @property {(node: Node) => void} closeNode
+   * @property {() => string} value
+   */
+
+  /** @typedef {{kind?: string, sublanguage?: boolean}} Node */
+  /** @typedef {{walk: (r: Renderer) => void}} Tree */
+  /** */
+
+  const SPAN_CLOSE = '</span>';
+
+  /**
+   * Determines if a node needs to be wrapped in <span>
+   *
+   * @param {Node} node */
+  const emitsWrappingTags = (node) => {
+    return !!node.kind;
+  };
+
+  /** @type {Renderer} */
+  class HTMLRenderer {
+    /**
+     * Creates a new HTMLRenderer
+     *
+     * @param {Tree} parseTree - the parse tree (must support `walk` API)
+     * @param {{classPrefix: string}} options
+     */
+    constructor(parseTree, options) {
+      this.buffer = "";
+      this.classPrefix = options.classPrefix;
+      parseTree.walk(this);
+    }
+
+    /**
+     * Adds texts to the output stream
+     *
+     * @param {string} text */
+    addText(text) {
+      this.buffer += escapeHTML(text);
+    }
+
+    /**
+     * Adds a node open to the output stream (if needed)
+     *
+     * @param {Node} node */
+    openNode(node) {
+      if (!emitsWrappingTags(node)) return;
+
+      let className = node.kind;
+      if (!node.sublanguage) {
+        className = `${this.classPrefix}${className}`;
+      }
+      this.span(className);
+    }
+
+    /**
+     * Adds a node close to the output stream (if needed)
+     *
+     * @param {Node} node */
+    closeNode(node) {
+      if (!emitsWrappingTags(node)) return;
+
+      this.buffer += SPAN_CLOSE;
+    }
+
+    /**
+     * returns the accumulated buffer
+    */
+    value() {
+      return this.buffer;
+    }
+
+    // helpers
+
+    /**
+     * Builds a span element
+     *
+     * @param {string} className */
+    span(className) {
+      this.buffer += `<span class="${className}">`;
+    }
+  }
+
+  /** @typedef {{kind?: string, sublanguage?: boolean, children: Node[]} | string} Node */
+  /** @typedef {{kind?: string, sublanguage?: boolean, children: Node[]} } DataNode */
+  /**  */
+
+  class TokenTree {
+    constructor() {
+      /** @type DataNode */
+      this.rootNode = { children: [] };
+      this.stack = [this.rootNode];
+    }
+
+    get top() {
+      return this.stack[this.stack.length - 1];
+    }
+
+    get root() { return this.rootNode; }
+
+    /** @param {Node} node */
+    add(node) {
+      this.top.children.push(node);
+    }
+
+    /** @param {string} kind */
+    openNode(kind) {
+      /** @type Node */
+      const node = { kind, children: [] };
+      this.add(node);
+      this.stack.push(node);
+    }
+
+    closeNode() {
+      if (this.stack.length > 1) {
+        return this.stack.pop();
+      }
+      // eslint-disable-next-line no-undefined
+      return undefined;
+    }
+
+    closeAllNodes() {
+      while (this.closeNode());
+    }
+
+    toJSON() {
+      return JSON.stringify(this.rootNode, null, 4);
+    }
+
+    /**
+     * @typedef { import("./html_renderer").Renderer } Renderer
+     * @param {Renderer} builder
+     */
+    walk(builder) {
+      // this does not
+      return this.constructor._walk(builder, this.rootNode);
+      // this works
+      // return TokenTree._walk(builder, this.rootNode);
+    }
+
+    /**
+     * @param {Renderer} builder
+     * @param {Node} node
+     */
+    static _walk(builder, node) {
+      if (typeof node === "string") {
+        builder.addText(node);
+      } else if (node.children) {
+        builder.openNode(node);
+        node.children.forEach((child) => this._walk(builder, child));
+        builder.closeNode(node);
+      }
+      return builder;
+    }
+
+    /**
+     * @param {Node} node
+     */
+    static _collapse(node) {
+      if (typeof node === "string") return;
+      if (!node.children) return;
+
+      if (node.children.every(el => typeof el === "string")) {
+        // node.text = node.children.join("");
+        // delete node.children;
+        node.children = [node.children.join("")];
+      } else {
+        node.children.forEach((child) => {
+          TokenTree._collapse(child);
+        });
+      }
+    }
+  }
+
+  /**
+    Currently this is all private API, but this is the minimal API necessary
+    that an Emitter must implement to fully support the parser.
+
+    Minimal interface:
+
+    - addKeyword(text, kind)
+    - addText(text)
+    - addSublanguage(emitter, subLanguageName)
+    - finalize()
+    - openNode(kind)
+    - closeNode()
+    - closeAllNodes()
+    - toHTML()
+
+  */
+
+  /**
+   * @implements {Emitter}
+   */
+  class TokenTreeEmitter extends TokenTree {
+    /**
+     * @param {*} options
+     */
+    constructor(options) {
+      super();
+      this.options = options;
+    }
+
+    /**
+     * @param {string} text
+     * @param {string} kind
+     */
+    addKeyword(text, kind) {
+      if (text === "") { return; }
+
+      this.openNode(kind);
+      this.addText(text);
+      this.closeNode();
+    }
+
+    /**
+     * @param {string} text
+     */
+    addText(text) {
+      if (text === "") { return; }
+
+      this.add(text);
+    }
+
+    /**
+     * @param {Emitter & {root: DataNode}} emitter
+     * @param {string} name
+     */
+    addSublanguage(emitter, name) {
+      /** @type DataNode */
+      const node = emitter.root;
+      node.kind = name;
+      node.sublanguage = true;
+      this.add(node);
+    }
+
+    toHTML() {
+      const renderer = new HTMLRenderer(this, this.options);
+      return renderer.value();
+    }
+
+    finalize() {
+      return true;
+    }
+  }
+
+  /**
+   * @param {string} value
+   * @returns {RegExp}
+   * */
+  function escape(value) {
+    return new RegExp(value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&'), 'm');
+  }
+
+  /**
+   * @param {RegExp | string } re
+   * @returns {string}
+   */
+  function source(re) {
+    if (!re) return null;
+    if (typeof re === "string") return re;
+
+    return re.source;
+  }
+
+  /**
+   * @param {...(RegExp | string) } args
+   * @returns {string}
+   */
+  function concat(...args) {
+    const joined = args.map((x) => source(x)).join("");
+    return joined;
+  }
+
+  /**
+   * Any of the passed expresssions may match
+   *
+   * Creates a huge this | this | that | that match
+   * @param {(RegExp | string)[] } args
+   * @returns {string}
+   */
+  function either(...args) {
+    const joined = '(' + args.map((x) => source(x)).join("|") + ")";
+    return joined;
+  }
+
+  /**
+   * @param {RegExp} re
+   * @returns {number}
+   */
+  function countMatchGroups(re) {
+    return (new RegExp(re.toString() + '|')).exec('').length - 1;
+  }
+
+  /**
+   * Does lexeme start with a regular expression match at the beginning
+   * @param {RegExp} re
+   * @param {string} lexeme
+   */
+  function startsWith(re, lexeme) {
+    const match = re && re.exec(lexeme);
+    return match && match.index === 0;
+  }
+
+  // BACKREF_RE matches an open parenthesis or backreference. To avoid
+  // an incorrect parse, it additionally matches the following:
+  // - [...] elements, where the meaning of parentheses and escapes change
+  // - other escape sequences, so we do not misparse escape sequences as
+  //   interesting elements
+  // - non-matching or lookahead parentheses, which do not capture. These
+  //   follow the '(' with a '?'.
+  const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+
+  // 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
+  // match group, keeping track of the sequencing of those match groups
+  // is currently an exercise for the caller. :-)
+  /**
+   * @param {(string | RegExp)[]} regexps
+   * @param {string} separator
+   * @returns {string}
+   */
+  function join(regexps, separator = "|") {
+    let numCaptures = 0;
+
+    return regexps.map((regex) => {
+      numCaptures += 1;
+      const offset = numCaptures;
+      let re = source(regex);
+      let out = '';
+
+      while (re.length > 0) {
+        const match = BACKREF_RE.exec(re);
+        if (!match) {
+          out += re;
+          break;
+        }
+        out += re.substring(0, match.index);
+        re = re.substring(match.index + match[0].length);
+        if (match[0][0] === '\\' && match[1]) {
+          // Adjust the backreference.
+          out += '\\' + String(Number(match[1]) + offset);
+        } else {
+          out += match[0];
+          if (match[0] === '(') {
+            numCaptures++;
+          }
+        }
+      }
+      return out;
+    }).map(re => `(${re})`).join(separator);
+  }
+
+  // Common regexps
+  const MATCH_NOTHING_RE = /\b\B/;
+  const IDENT_RE = '[a-zA-Z]\\w*';
+  const UNDERSCORE_IDENT_RE = '[a-zA-Z_]\\w*';
+  const NUMBER_RE = '\\b\\d+(\\.\\d+)?';
+  const C_NUMBER_RE = '(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)'; // 0x..., 0..., decimal, float
+  const BINARY_NUMBER_RE = '\\b(0b[01]+)'; // 0b...
+  const RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~';
+
+  /**
+  * @param { Partial<Mode> & {binary?: string | RegExp} } opts
+  */
+  const SHEBANG = (opts = {}) => {
+    const beginShebang = /^#![ ]*\//;
+    if (opts.binary) {
+      opts.begin = concat(
+        beginShebang,
+        /.*\b/,
+        opts.binary,
+        /\b.*/);
+    }
+    return inherit({
+      className: 'meta',
+      begin: beginShebang,
+      end: /$/,
+      relevance: 0,
+      /** @type {ModeCallback} */
+      "on:begin": (m, resp) => {
+        if (m.index !== 0) resp.ignoreMatch();
+      }
+    }, opts);
+  };
+
+  // Common modes
+  const BACKSLASH_ESCAPE = {
+    begin: '\\\\[\\s\\S]', relevance: 0
+  };
+  const APOS_STRING_MODE = {
+    className: 'string',
+    begin: '\'',
+    end: '\'',
+    illegal: '\\n',
+    contains: [BACKSLASH_ESCAPE]
+  };
+  const QUOTE_STRING_MODE = {
+    className: 'string',
+    begin: '"',
+    end: '"',
+    illegal: '\\n',
+    contains: [BACKSLASH_ESCAPE]
+  };
+  const PHRASAL_WORDS_MODE = {
+    begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+  };
+  /**
+   * Creates a comment mode
+   *
+   * @param {string | RegExp} begin
+   * @param {string | RegExp} end
+   * @param {Mode | {}} [modeOptions]
+   * @returns {Partial<Mode>}
+   */
+  const COMMENT = function(begin, end, modeOptions = {}) {
+    const mode = inherit(
+      {
+        className: 'comment',
+        begin,
+        end,
+        contains: []
+      },
+      modeOptions
+    );
+    mode.contains.push(PHRASAL_WORDS_MODE);
+    mode.contains.push({
+      className: 'doctag',
+      begin: '(?:TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):',
+      relevance: 0
+    });
+    return mode;
+  };
+  const C_LINE_COMMENT_MODE = COMMENT('//', '$');
+  const C_BLOCK_COMMENT_MODE = COMMENT('/\\*', '\\*/');
+  const HASH_COMMENT_MODE = COMMENT('#', '$');
+  const NUMBER_MODE = {
+    className: 'number',
+    begin: NUMBER_RE,
+    relevance: 0
+  };
+  const C_NUMBER_MODE = {
+    className: 'number',
+    begin: C_NUMBER_RE,
+    relevance: 0
+  };
+  const BINARY_NUMBER_MODE = {
+    className: '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:
+    //
+    //     3 / something
+    //
+    // (which will then blow up when regex's `illegal` sees the newline)
+    begin: /(?=\/[^/\n]*\/)/,
+    contains: [{
+      className: 'regexp',
+      begin: /\//,
+      end: /\/[gimuy]*/,
+      illegal: /\n/,
+      contains: [
+        BACKSLASH_ESCAPE,
+        {
+          begin: /\[/,
+          end: /\]/,
+          relevance: 0,
+          contains: [BACKSLASH_ESCAPE]
+        }
+      ]
+    }]
+  };
+  const TITLE_MODE = {
+    className: 'title',
+    begin: IDENT_RE,
+    relevance: 0
+  };
+  const UNDERSCORE_TITLE_MODE = {
+    className: 'title',
+    begin: UNDERSCORE_IDENT_RE,
+    relevance: 0
+  };
+  const METHOD_GUARD = {
+    // excludes method names from keyword processing
+    begin: '\\.\\s*' + UNDERSCORE_IDENT_RE,
+    relevance: 0
+  };
+
+  /**
+   * Adds end same as begin mechanics to a mode
+   *
+   * Your mode must include at least a single () match group as that first match
+   * group is what is used for comparison
+   * @param {Partial<Mode>} mode
+   */
+  const END_SAME_AS_BEGIN = function(mode) {
+    return Object.assign(mode,
+      {
+        /** @type {ModeCallback} */
+        'on:begin': (m, resp) => { resp.data._beginMatch = m[1]; },
+        /** @type {ModeCallback} */
+        'on:end': (m, resp) => { if (resp.data._beginMatch !== m[1]) resp.ignoreMatch(); }
+      });
+  };
+
+  var MODES = /*#__PURE__*/Object.freeze({
+      __proto__: null,
+      MATCH_NOTHING_RE: MATCH_NOTHING_RE,
+      IDENT_RE: IDENT_RE,
+      UNDERSCORE_IDENT_RE: UNDERSCORE_IDENT_RE,
+      NUMBER_RE: NUMBER_RE,
+      C_NUMBER_RE: C_NUMBER_RE,
+      BINARY_NUMBER_RE: BINARY_NUMBER_RE,
+      RE_STARTERS_RE: RE_STARTERS_RE,
+      SHEBANG: SHEBANG,
+      BACKSLASH_ESCAPE: BACKSLASH_ESCAPE,
+      APOS_STRING_MODE: APOS_STRING_MODE,
+      QUOTE_STRING_MODE: QUOTE_STRING_MODE,
+      PHRASAL_WORDS_MODE: PHRASAL_WORDS_MODE,
+      COMMENT: COMMENT,
+      C_LINE_COMMENT_MODE: C_LINE_COMMENT_MODE,
+      C_BLOCK_COMMENT_MODE: C_BLOCK_COMMENT_MODE,
+      HASH_COMMENT_MODE: HASH_COMMENT_MODE,
+      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,
+      METHOD_GUARD: METHOD_GUARD,
+      END_SAME_AS_BEGIN: END_SAME_AS_BEGIN
+  });
+
+  // Grammar extensions / plugins
+  // See: https://github.com/highlightjs/highlight.js/issues/2833
+
+  // Grammar extensions allow "syntactic sugar" to be added to the grammar modes
+  // without requiring any underlying changes to the compiler internals.
+
+  // `compileMatch` being the perfect small example of now allowing a grammar
+  // author to write `match` when they desire to match a single expression rather
+  // than being forced to use `begin`.  The extension then just moves `match` into
+  // `begin` when it runs.  Ie, no features have been added, but we've just made
+  // the experience of writing (and reading grammars) a little bit nicer.
+
+  // ------
+
+  // TODO: We need negative look-behind support to do this properly
+  /**
+   * Skip a match if it has a preceding dot
+   *
+   * This is used for `beginKeywords` to prevent matching expressions such as
+   * `bob.keyword.do()`. The mode compiler automatically wires this up as a
+   * special _internal_ 'on:begin' callback for modes with `beginKeywords`
+   * @param {RegExpMatchArray} match
+   * @param {CallbackResponse} response
+   */
+  function skipIfhasPrecedingDot(match, response) {
+    const before = match.input[match.index - 1];
+    if (before === ".") {
+      response.ignoreMatch();
+    }
+  }
+
+
+  /**
+   * `beginKeywords` syntactic sugar
+   * @type {CompilerExt}
+   */
+  function beginKeywords(mode, parent) {
+    if (!parent) return;
+    if (!mode.beginKeywords) return;
+
+    // for languages with keywords that include non-word characters checking for
+    // a word boundary is not sufficient, so instead we check for a word boundary
+    // or whitespace - this does no harm in any case since our keyword engine
+    // 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.keywords = mode.keywords || mode.beginKeywords;
+    delete mode.beginKeywords;
+
+    // prevents double relevance, the keywords themselves provide
+    // relevance, the mode doesn't need to double it
+    // eslint-disable-next-line no-undefined
+    if (mode.relevance === undefined) mode.relevance = 0;
+  }
+
+  /**
+   * Allow `illegal` to contain an array of illegal values
+   * @type {CompilerExt}
+   */
+  function compileIllegal(mode, _parent) {
+    if (!Array.isArray(mode.illegal)) return;
+
+    mode.illegal = either(...mode.illegal);
+  }
+
+  /**
+   * `match` to match a single expression for readability
+   * @type {CompilerExt}
+   */
+  function compileMatch(mode, _parent) {
+    if (!mode.match) return;
+    if (mode.begin || mode.end) throw new Error("begin & end are not supported with match");
+
+    mode.begin = mode.match;
+    delete mode.match;
+  }
+
+  /**
+   * provides the default 1 relevance to all modes
+   * @type {CompilerExt}
+   */
+  function compileRelevance(mode, _parent) {
+    // eslint-disable-next-line no-undefined
+    if (mode.relevance === undefined) mode.relevance = 1;
+  }
+
+  // keywords that should have no default relevance value
+  const COMMON_KEYWORDS = [
+    'of',
+    'and',
+    'for',
+    'in',
+    'not',
+    'or',
+    'if',
+    'then',
+    'parent', // common variable name
+    'list', // common variable name
+    'value' // common variable name
+  ];
+
+  const DEFAULT_KEYWORD_CLASSNAME = "keyword";
+
+  /**
+   * Given raw keywords from a language definition, compile them.
+   *
+   * @param {string | Record<string,string|string[]> | Array<string>} rawKeywords
+   * @param {boolean} caseInsensitive
+   */
+  function compileKeywords(rawKeywords, caseInsensitive, className = DEFAULT_KEYWORD_CLASSNAME) {
+    /** @type KeywordDict */
+    const compiledKeywords = {};
+
+    // 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)
+    if (typeof rawKeywords === 'string') {
+      compileList(className, rawKeywords.split(" "));
+    } else if (Array.isArray(rawKeywords)) {
+      compileList(className, rawKeywords);
+    } else {
+      Object.keys(rawKeywords).forEach(function(className) {
+        // collapse all our objects back into the parent object
+        Object.assign(
+          compiledKeywords,
+          compileKeywords(rawKeywords[className], caseInsensitive, className)
+        );
+      });
+    }
+    return compiledKeywords;
+
+    // ---
+
+    /**
+     * Compiles an individual list of keywords
+     *
+     * Ex: "for if when while|5"
+     *
+     * @param {string} className
+     * @param {Array<string>} keywordList
+     */
+    function compileList(className, 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])];
+      });
+    }
+  }
+
+  /**
+   * Returns the proper score for a given keyword
+   *
+   * Also takes into account comment keywords, which will be scored 0 UNLESS
+   * another score has been manually assigned.
+   * @param {string} keyword
+   * @param {string} [providedScore]
+   */
+  function scoreForKeyword(keyword, providedScore) {
+    // manual scores always win over common keywords
+    // so you can force a score of 1 if you really insist
+    if (providedScore) {
+      return Number(providedScore);
+    }
+
+    return commonKeyword(keyword) ? 0 : 1;
+  }
+
+  /**
+   * Determines if a given keyword is common or not
+   *
+   * @param {string} keyword */
+  function commonKeyword(keyword) {
+    return COMMON_KEYWORDS.includes(keyword.toLowerCase());
+  }
+
+  // compilation
+
+  /**
+   * Compiles a language definition result
+   *
+   * 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 }) {
+    /**
+     * Builds a regex with the case sensativility of the current language
+     *
+     * @param {RegExp | string} value
+     * @param {boolean} [global]
+     */
+    function langRe(value, global) {
+      return new RegExp(
+        source(value),
+        'm' + (language.case_insensitive ? 'i' : '') + (global ? 'g' : '')
+      );
+    }
+
+    /**
+      Stores multiple regular expressions and allows you to quickly search for
+      them all in a string simultaneously - returning the first match.  It does
+      this by creating a huge (a|b|c) regex - each individual item wrapped with ()
+      and joined by `|` - using match groups to track position.  When a match is
+      found checking which position in the array has content allows us to figure
+      out which of the original regexes / match groups triggered the match.
+
+      The match object itself (the result of `Regex.exec`) is returned but also
+      enhanced by merging in any meta-data that was registered with the regex.
+      This is how we keep track of which mode matched, and what type of rule
+      (`illegal`, `begin`, end, etc).
+    */
+    class MultiRegex {
+      constructor() {
+        this.matchIndexes = {};
+        // @ts-ignore
+        this.regexes = [];
+        this.matchAt = 1;
+        this.position = 0;
+      }
+
+      // @ts-ignore
+      addRule(re, opts) {
+        opts.position = this.position++;
+        // @ts-ignore
+        this.matchIndexes[this.matchAt] = opts;
+        this.regexes.push([opts, re]);
+        this.matchAt += countMatchGroups(re) + 1;
+      }
+
+      compile() {
+        if (this.regexes.length === 0) {
+          // avoids the need to check length every time exec is called
+          // @ts-ignore
+          this.exec = () => null;
+        }
+        const terminators = this.regexes.map(el => el[1]);
+        this.matcherRe = langRe(join(terminators), true);
+        this.lastIndex = 0;
+      }
+
+      /** @param {string} s */
+      exec(s) {
+        this.matcherRe.lastIndex = this.lastIndex;
+        const match = this.matcherRe.exec(s);
+        if (!match) { return null; }
+
+        // eslint-disable-next-line no-undefined
+        const i = match.findIndex((el, i) => i > 0 && el !== undefined);
+        // @ts-ignore
+        const matchData = this.matchIndexes[i];
+        // trim off any earlier non-relevant match groups (ie, the other regex
+        // match groups that make up the multi-matcher)
+        match.splice(0, i);
+
+        return Object.assign(match, matchData);
+      }
+    }
+
+    /*
+      Created to solve the key deficiently with MultiRegex - there is no way to
+      test for multiple matches at a single location.  Why would we need to do
+      that?  In the future a more dynamic engine will allow certain matches to be
+      ignored.  An example: if we matched say the 3rd regex in a large group but
+      decided to ignore it - we'd need to started testing again at the 4th
+      regex... but MultiRegex itself gives us no real way to do that.
+
+      So what this class creates MultiRegexs on the fly for whatever search
+      position they are needed.
+
+      NOTE: These additional MultiRegex objects are created dynamically.  For most
+      grammars most of the time we will never actually need anything more than the
+      first MultiRegex - so this shouldn't have too much overhead.
+
+      Say this is our search group, and we match regex3, but wish to ignore it.
+
+        regex1 | regex2 | regex3 | regex4 | regex5    ' ie, startAt = 0
+
+      What we need is a new MultiRegex that only includes the remaining
+      possibilities:
+
+        regex4 | regex5                               ' ie, startAt = 3
+
+      This class wraps all that complexity up in a simple API... `startAt` decides
+      where in the array of expressions to start doing the matching. It
+      auto-increments, so if a match is found at position 2, then startAt will be
+      set to 3.  If the end is reached startAt will return to 0.
+
+      MOST of the time the parser will be setting startAt manually to 0.
+    */
+    class ResumableMultiRegex {
+      constructor() {
+        // @ts-ignore
+        this.rules = [];
+        // @ts-ignore
+        this.multiRegexes = [];
+        this.count = 0;
+
+        this.lastIndex = 0;
+        this.regexIndex = 0;
+      }
+
+      // @ts-ignore
+      getMatcher(index) {
+        if (this.multiRegexes[index]) return this.multiRegexes[index];
+
+        const matcher = new MultiRegex();
+        this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
+        matcher.compile();
+        this.multiRegexes[index] = matcher;
+        return matcher;
+      }
+
+      resumingScanAtSamePosition() {
+        return this.regexIndex !== 0;
+      }
+
+      considerAll() {
+        this.regexIndex = 0;
+      }
+
+      // @ts-ignore
+      addRule(re, opts) {
+        this.rules.push([re, opts]);
+        if (opts.type === "begin") this.count++;
+      }
+
+      /** @param {string} s */
+      exec(s) {
+        const m = this.getMatcher(this.regexIndex);
+        m.lastIndex = this.lastIndex;
+        let result = m.exec(s);
+
+        // The following is because we have no easy way to say "resume scanning at the
+        // existing position but also skip the current rule ONLY". What happens is
+        // all prior rules are also skipped which can result in matching the wrong
+        // thing. Example of matching "booger":
+
+        // our matcher is [string, "booger", number]
+        //
+        // ....booger....
+
+        // if "booger" is ignored then we'd really need a regex to scan from the
+        // SAME position for only: [string, number] but ignoring "booger" (if it
+        // was the first match), a simple resume would scan ahead who knows how
+        // far looking only for "number", ignoring potential string matches (or
+        // future "booger" matches that might be valid.)
+
+        // So what we do: We execute two matchers, one resuming at the same
+        // position, but the second full matcher starting at the position after:
+
+        //     /--- resume first regex match here (for [number])
+        //     |/---- full match here for [string, "booger", number]
+        //     vv
+        // ....booger....
+
+        // Which ever results in a match first is then used. So this 3-4 step
+        // process essentially allows us to say "match at this position, excluding
+        // a prior rule that was ignored".
+        //
+        // 1. Match "booger" first, ignore. Also proves that [string] does non match.
+        // 2. Resume matching for [number]
+        // 3. Match at index + 1 for [string, "booger", number]
+        // 4. If #2 and #3 result in matches, which came first?
+        if (this.resumingScanAtSamePosition()) {
+          if (result && result.index === this.lastIndex) ; else { // use the second matcher result
+            const m2 = this.getMatcher(0);
+            m2.lastIndex = this.lastIndex + 1;
+            result = m2.exec(s);
+          }
+        }
+
+        if (result) {
+          this.regexIndex += result.position + 1;
+          if (this.regexIndex === this.count) {
+            // wrap-around to considering all matches again
+            this.considerAll();
+          }
+        }
+
+        return result;
+      }
+    }
+
+    /**
+     * Given a mode, builds a huge ResumableMultiRegex that can be used to walk
+     * the content and find matches.
+     *
+     * @param {CompiledMode} mode
+     * @returns {ResumableMultiRegex}
+     */
+    function buildModeRegex(mode) {
+      const mm = new ResumableMultiRegex();
+
+      mode.contains.forEach(term => mm.addRule(term.begin, { rule: term, type: "begin" }));
+
+      if (mode.terminatorEnd) {
+        mm.addRule(mode.terminatorEnd, { type: "end" });
+      }
+      if (mode.illegal) {
+        mm.addRule(mode.illegal, { type: "illegal" });
+      }
+
+      return mm;
+    }
+
+    /** skip vs abort vs ignore
+     *
+     * @skip   - The mode is still entered and exited normally (and contains rules apply),
+     *           but all content is held and added to the parent buffer rather than being
+     *           output when the mode ends.  Mostly used with `sublanguage` to build up
+     *           a single large buffer than can be parsed by sublanguage.
+     *
+     *             - The mode begin ands ends normally.
+     *             - Content matched is added to the parent mode buffer.
+     *             - The parser cursor is moved forward normally.
+     *
+     * @abort  - A hack placeholder until we have ignore.  Aborts the mode (as if it
+     *           never matched) but DOES NOT continue to match subsequent `contains`
+     *           modes.  Abort is bad/suboptimal because it can result in modes
+     *           farther down not getting applied because an earlier rule eats the
+     *           content but then aborts.
+     *
+     *             - The mode does not begin.
+     *             - Content matched by `begin` is added to the mode buffer.
+     *             - The parser cursor is moved forward accordingly.
+     *
+     * @ignore - Ignores the mode (as if it never matched) and continues to match any
+     *           subsequent `contains` modes.  Ignore isn't technically possible with
+     *           the current parser implementation.
+     *
+     *             - The mode does not begin.
+     *             - Content matched by `begin` is ignored.
+     *             - The parser cursor is not moved forward.
+     */
+
+    /**
+     * Compiles an individual mode
+     *
+     * This can raise an error if the mode contains certain detectable known logic
+     * issues.
+     * @param {Mode} mode
+     * @param {CompiledMode | null} [parent]
+     * @returns {CompiledMode | never}
+     */
+    function compileMode(mode, parent) {
+      const cmode = /** @type CompiledMode */ (mode);
+      if (mode.isCompiled) return cmode;
+
+      [
+        // do this early so compiler extensions generally don't have to worry about
+        // the distinction between match/begin
+        compileMatch
+      ].forEach(ext => ext(mode, parent));
+
+      language.compilerExtensions.forEach(ext => ext(mode, parent));
+
+      // __beforeBegin is considered private API, internal use only
+      mode.__beforeBegin = null;
+
+      [
+        beginKeywords,
+        // do this later so compiler extensions that come earlier have access to the
+        // raw array if they wanted to perhaps manipulate it, etc.
+        compileIllegal,
+        // default to 1 relevance if not specified
+        compileRelevance
+      ].forEach(ext => ext(mode, parent));
+
+      mode.isCompiled = true;
+
+      let keywordPattern = null;
+      if (typeof mode.keywords === "object") {
+        keywordPattern = mode.keywords.$pattern;
+        delete mode.keywords.$pattern;
+      }
+
+      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;
+        if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
+        if (mode.end) cmode.endRe = langRe(mode.end);
+        cmode.terminatorEnd = source(mode.end) || '';
+        if (mode.endsWithParent && parent.terminatorEnd) {
+          cmode.terminatorEnd += (mode.end ? '|' : '') + parent.terminatorEnd;
+        }
+      }
+      if (mode.illegal) cmode.illegalRe = langRe(/** @type {RegExp | string} */ (mode.illegal));
+      if (!mode.contains) mode.contains = [];
+
+      mode.contains = [].concat(...mode.contains.map(function(c) {
+        return expandOrCloneMode(c === 'self' ? mode : c);
+      }));
+      mode.contains.forEach(function(c) { compileMode(/** @type Mode */ (c), cmode); });
+
+      if (mode.starts) {
+        compileMode(mode.starts, parent);
+      }
+
+      cmode.matcher = buildModeRegex(cmode);
+      return cmode;
+    }
+
+    if (!language.compilerExtensions) language.compilerExtensions = [];
+
+    // self is not valid at the top-level
+    if (language.contains && language.contains.includes('self')) {
+      throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");
+    }
+
+    // we need a null object, which inherit will guarantee
+    language.classNameAliases = inherit(language.classNameAliases || {});
+
+    return compileMode(/** @type Mode */ (language));
+  }
+
+  /**
+   * Determines if a mode has a dependency on it's parent or not
+   *
+   * If a mode does have a parent dependency then often we need to clone it if
+   * it's used in multiple places so that each copy points to the correct parent,
+   * where-as modes without a parent can often safely be re-used at the bottom of
+   * a mode chain.
+   *
+   * @param {Mode | null} mode
+   * @returns {boolean} - is there a dependency on the parent?
+   * */
+  function dependencyOnParent(mode) {
+    if (!mode) return false;
+
+    return mode.endsWithParent || dependencyOnParent(mode.starts);
+  }
+
+  /**
+   * Expands a mode or clones it if necessary
+   *
+   * This is necessary for modes with parental dependenceis (see notes on
+   * `dependencyOnParent`) and for nodes that have `variants` - which must then be
+   * exploded into their own individual modes at compile time.
+   *
+   * @param {Mode} mode
+   * @returns {Mode | Mode[]}
+   * */
+  function expandOrCloneMode(mode) {
+    if (mode.variants && !mode.cachedVariants) {
+      mode.cachedVariants = mode.variants.map(function(variant) {
+        return inherit(mode, { variants: null }, variant);
+      });
+    }
+
+    // EXPAND
+    // if we have variants then essentially "replace" the mode with the variants
+    // this happens in compileMode, where this function is called from
+    if (mode.cachedVariants) {
+      return mode.cachedVariants;
+    }
+
+    // CLONE
+    // if we have dependencies on parents then we need a unique
+    // 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 });
+    }
+
+    if (Object.isFrozen(mode)) {
+      return inherit(mode);
+    }
+
+    // no special dependency issues, just return ourselves
+    return mode;
+  }
+
+  var version = "10.7.3";
+
+  // @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);
+      }
+    };
+
+    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;
+    }
+
+    /**
+     * @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
+
+  */
+
+  /**
+   * @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/
+  */
+
+  const escape$1 = escapeHTML;
+  const inherit$1 = inherit;
+  const NO_MATCH = Symbol("nomatch");
+
+  /**
+   * @param {any} hljs - object that is extended (legacy)
+   * @returns {HLJSApi}
+   */
+  const HLJS = function(hljs) {
+    // Global internal variables used within the highlight.js library.
+    /** @type {Record<string, Language>} */
+    const languages = Object.create(null);
+    /** @type {Record<string, string>} */
+    const aliases = Object.create(null);
+    /** @type {HLJSPlugin[]} */
+    const plugins = [];
+
+    // 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: [] };
+
+    // Global options used when within external APIs. This is modified when
+    // calling the `hljs.configure` function.
+    /** @type HLJSOptions */
+    let options = {
+      noHighlightRe: /^(no-?highlight)$/i,
+      languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+      classPrefix: 'hljs-',
+      tabReplace: null,
+      useBR: false,
+      languages: null,
+      // beta configuration options, subject to change, welcome to discuss
+      // https://github.com/highlightjs/highlight.js/issues/1086
+      __emitter: TokenTreeEmitter
+    };
+
+    /* Utility functions */
+
+    /**
+     * Tests a language name to see if highlighting should be skipped
+     * @param {string} languageName
+     */
+    function shouldNotHighlight(languageName) {
+      return options.noHighlightRe.test(languageName);
+    }
+
+    /**
+     * @param {HighlightedHTMLElement} block - the HTML element to determine language for
+     */
+    function blockLanguage(block) {
+      let classes = block.className + ' ';
+
+      classes += block.parentNode ? block.parentNode.className : '';
+
+      // language-* takes precedence over non-prefixed class names.
+      const match = options.languageDetectRe.exec(classes);
+      if (match) {
+        const language = getLanguage(match[1]);
+        if (!language) {
+          warn(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
+          warn("Falling back to no-highlight mode for this block.", block);
+        }
+        return language ? match[1] : 'no-highlight';
+      }
+
+      return classes
+        .split(/\s+/)
+        .find((_class) => shouldNotHighlight(_class) || getLanguage(_class));
+    }
+
+    /**
+     * Core highlighting function.
+     *
+     * OLD API
+     * highlight(lang, code, ignoreIllegals, continuation)
+     *
+     * NEW API
+     * highlight(code, {lang, ignoreIllegals})
+     *
+     * @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
+     * @property {number} relevance - the relevance score
+     * @property {string} value - the highlighted HTML code
+     * @property {string} code - the original raw code
+     * @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) {
+      let code = "";
+      let languageName = "";
+      if (typeof optionsOrCode === "object") {
+        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;
+        code = optionsOrCode;
+      }
+
+      /** @type {BeforeHighlightContext} */
+      const context = {
+        code,
+        language: languageName
+      };
+      // the plugin can change the desired language or the code to be highlighted
+      // just be changing the object it was passed
+      fire("before:highlight", context);
+
+      // a before plugin can usurp the result completely by providing it's own
+      // in which case we don't even need to call highlight
+      const result = context.result
+        ? context.result
+        : _highlight(context.language, context.code, ignoreIllegals, continuation);
+
+      result.code = context.code;
+      // the plugin can change anything in result to suite it
+      fire("after:highlight", result);
+
+      return result;
+    }
+
+    /**
+     * private highlight that's used internally and does not fire callbacks
+     *
+     * @param {string} languageName - the language to use for highlighting
+     * @param {string} codeToHighlight - 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 of the highlight operation
+    */
+    function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
+      /**
+       * Return keyword data if a match is a keyword
+       * @param {CompiledMode} mode - current mode
+       * @param {RegExpMatchArray} match - regexp match data
+       * @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 processKeywords() {
+        if (!top.keywords) {
+          emitter.addText(modeBuffer);
+          return;
+        }
+
+        let lastIndex = 0;
+        top.keywordPatternRe.lastIndex = 0;
+        let match = top.keywordPatternRe.exec(modeBuffer);
+        let buf = "";
+
+        while (match) {
+          buf += modeBuffer.substring(lastIndex, match.index);
+          const data = keywordData(top, match);
+          if (data) {
+            const [kind, keywordRelevance] = data;
+            emitter.addText(buf);
+            buf = "";
+
+            relevance += keywordRelevance;
+            if (kind.startsWith("_")) {
+              // _ implied for relevance only, do not highlight
+              // by applying a class name
+              buf += match[0];
+            } else {
+              const cssClass = language.classNameAliases[kind] || kind;
+              emitter.addKeyword(match[0], cssClass);
+            }
+          } else {
+            buf += match[0];
+          }
+          lastIndex = top.keywordPatternRe.lastIndex;
+          match = top.keywordPatternRe.exec(modeBuffer);
+        }
+        buf += modeBuffer.substr(lastIndex);
+        emitter.addText(buf);
+      }
+
+      function processSubLanguage() {
+        if (modeBuffer === "") return;
+        /** @type HighlightResult */
+        let result = null;
+
+        if (typeof top.subLanguage === 'string') {
+          if (!languages[top.subLanguage]) {
+            emitter.addText(modeBuffer);
+            return;
+          }
+          result = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
+          continuations[top.subLanguage] = /** @type {CompiledMode} */ (result.top);
+        } else {
+          result = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
+        }
+
+        // Counting embedded language score towards the host language may be disabled
+        // with zeroing the containing mode relevance. Use case in point is Markdown that
+        // allows XML everywhere and makes every XML snippet to have a much larger Markdown
+        // score.
+        if (top.relevance > 0) {
+          relevance += result.relevance;
+        }
+        emitter.addSublanguage(result.emitter, result.language);
+      }
+
+      function processBuffer() {
+        if (top.subLanguage != null) {
+          processSubLanguage();
+        } else {
+          processKeywords();
+        }
+        modeBuffer = '';
+      }
+
+      /**
+       * @param {Mode} mode - new mode to start
+       */
+      function startNewMode(mode) {
+        if (mode.className) {
+          emitter.openNode(language.classNameAliases[mode.className] || mode.className);
+        }
+        top = Object.create(mode, { parent: { value: top } });
+        return top;
+      }
+
+      /**
+       * @param {CompiledMode } mode - the mode to potentially end
+       * @param {RegExpMatchArray} match - the latest match
+       * @param {string} matchPlusRemainder - match plus remainder of content
+       * @returns {CompiledMode | void} - the next mode, or if void continue on in current mode
+       */
+      function endOfMode(mode, match, matchPlusRemainder) {
+        let matched = startsWith(mode.endRe, matchPlusRemainder);
+
+        if (matched) {
+          if (mode["on:end"]) {
+            const resp = new Response(mode);
+            mode["on:end"](match, resp);
+            if (resp.isMatchIgnored) matched = false;
+          }
+
+          if (matched) {
+            while (mode.endsParent && mode.parent) {
+              mode = mode.parent;
+            }
+            return mode;
+          }
+        }
+        // even if on:end fires an `ignore` it's still possible
+        // that we might trigger the end node because of a parent mode
+        if (mode.endsWithParent) {
+          return endOfMode(mode.parent, match, matchPlusRemainder);
+        }
+      }
+
+      /**
+       * Handle matching but then ignoring a sequence of text
+       *
+       * @param {string} lexeme - string containing full match text
+       */
+      function doIgnore(lexeme) {
+        if (top.matcher.regexIndex === 0) {
+          // no more regexs to potentially match here, so we move the cursor forward one
+          // space
+          modeBuffer += lexeme[0];
+          return 1;
+        } else {
+          // no need to move the cursor, we still have additional regexes to try and
+          // match at this very spot
+          resumeScanAtSamePosition = true;
+          return 0;
+        }
+      }
+
+      /**
+       * Handle the start of a new potential mode match
+       *
+       * @param {EnhancedMatch} match - the current match
+       * @returns {number} how far to advance the parse cursor
+       */
+      function doBeginMatch(match) {
+        const lexeme = match[0];
+        const newMode = match.rule;
+
+        const resp = new Response(newMode);
+        // first internal before callbacks, then the public ones
+        const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]];
+        for (const cb of beforeCallbacks) {
+          if (!cb) continue;
+          cb(match, resp);
+          if (resp.isMatchIgnored) return doIgnore(lexeme);
+        }
+
+        if (newMode && newMode.endSameAsBegin) {
+          newMode.endRe = escape(lexeme);
+        }
+
+        if (newMode.skip) {
+          modeBuffer += lexeme;
+        } else {
+          if (newMode.excludeBegin) {
+            modeBuffer += lexeme;
+          }
+          processBuffer();
+          if (!newMode.returnBegin && !newMode.excludeBegin) {
+            modeBuffer = lexeme;
+          }
+        }
+        startNewMode(newMode);
+        // if (mode["after:begin"]) {
+        //   let resp = new Response(mode);
+        //   mode["after:begin"](match, resp);
+        // }
+        return newMode.returnBegin ? 0 : lexeme.length;
+      }
+
+      /**
+       * Handle the potential end of mode
+       *
+       * @param {RegExpMatchArray} match - the current match
+       */
+      function doEndMatch(match) {
+        const lexeme = match[0];
+        const matchPlusRemainder = codeToHighlight.substr(match.index);
+
+        const endMode = endOfMode(top, match, matchPlusRemainder);
+        if (!endMode) { return NO_MATCH; }
+
+        const origin = top;
+        if (origin.skip) {
+          modeBuffer += lexeme;
+        } else {
+          if (!(origin.returnEnd || origin.excludeEnd)) {
+            modeBuffer += lexeme;
+          }
+          processBuffer();
+          if (origin.excludeEnd) {
+            modeBuffer = lexeme;
+          }
+        }
+        do {
+          if (top.className) {
+            emitter.closeNode();
+          }
+          if (!top.skip && !top.subLanguage) {
+            relevance += top.relevance;
+          }
+          top = top.parent;
+        } while (top !== endMode.parent);
+        if (endMode.starts) {
+          if (endMode.endSameAsBegin) {
+            endMode.starts.endRe = endMode.endRe;
+          }
+          startNewMode(endMode.starts);
+        }
+        return origin.returnEnd ? 0 : lexeme.length;
+      }
+
+      function processContinuations() {
+        const list = [];
+        for (let current = top; current !== language; current = current.parent) {
+          if (current.className) {
+            list.unshift(current.className);
+          }
+        }
+        list.forEach(item => emitter.openNode(item));
+      }
+
+      /** @type {{type?: MatchType, index?: number, rule?: Mode}}} */
+      let lastMatch = {};
+
+      /**
+       *  Process an individual match
+       *
+       * @param {string} textBeforeMatch - text preceeding the match (since the last match)
+       * @param {EnhancedMatch} [match] - the match itself
+       */
+      function processLexeme(textBeforeMatch, match) {
+        const lexeme = match && match[0];
+
+        // add non-matched text to the current mode buffer
+        modeBuffer += textBeforeMatch;
+
+        if (lexeme == null) {
+          processBuffer();
+          return 0;
+        }
+
+        // we've found a 0 width match and we're stuck, so we need to advance
+        // this happens when we have badly behaved rules that have optional matchers to the degree that
+        // sometimes they can end up matching nothing at all
+        // Ref: https://github.com/highlightjs/highlight.js/issues/2140
+        if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") {
+          // spit the "skipped" character that our regex choked on back into the output sequence
+          modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
+          if (!SAFE_MODE) {
+            /** @type {AnnotatedError} */
+            const err = new Error('0 width match regex');
+            err.languageName = languageName;
+            err.badRule = lastMatch.rule;
+            throw err;
+          }
+          return 1;
+        }
+        lastMatch = match;
+
+        if (match.type === "begin") {
+          return doBeginMatch(match);
+        } 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>') + '"');
+          err.mode = top;
+          throw err;
+        } else if (match.type === "end") {
+          const processed = doEndMatch(match);
+          if (processed !== NO_MATCH) {
+            return processed;
+          }
+        }
+
+        // edge case for when illegal matches $ (end of line) which is technically
+        // a 0 width match but not a begin/end match so it's not caught by the
+        // first handler (when ignoreIllegals is true)
+        if (match.type === "illegal" && lexeme === "") {
+          // advance so we aren't stuck in an infinite loop
+          return 1;
+        }
+
+        // infinite loops are BAD, this is a last ditch catch all. if we have a
+        // decent number of iterations yet our index (cursor position in our
+        // parsing) still 3x behind our index then something is very wrong
+        // so we bail
+        if (iterations > 100000 && iterations > match.index * 3) {
+          const err = new Error('potential infinite loop, way more iterations than matches');
+          throw err;
+        }
+
+        /*
+        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.
+
+        This causes no real harm other than stopping a few times too many.
+        */
+
+        modeBuffer += lexeme;
+        return lexeme.length;
+      }
+
+      const language = getLanguage(languageName);
+      if (!language) {
+        error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
+        throw new Error('Unknown language: "' + languageName + '"');
+      }
+
+      const md = compileLanguage(language, { plugins });
+      let result = '';
+      /** @type {CompiledMode} */
+      let top = continuation || md;
+      /** @type Record<string,CompiledMode> */
+      const continuations = {}; // keep continuations for sub-languages
+      const emitter = new options.__emitter(options);
+      processContinuations();
+      let modeBuffer = '';
+      let relevance = 0;
+      let index = 0;
+      let iterations = 0;
+      let resumeScanAtSamePosition = false;
+
+      try {
+        top.matcher.considerAll();
+
+        for (;;) {
+          iterations++;
+          if (resumeScanAtSamePosition) {
+            // only regexes not matched previously will now be
+            // considered for a potential match
+            resumeScanAtSamePosition = false;
+          } else {
+            top.matcher.considerAll();
+          }
+          top.matcher.lastIndex = index;
+
+          const match = top.matcher.exec(codeToHighlight);
+          // console.log("match", match[0], match.rule && match.rule.begin)
+
+          if (!match) break;
+
+          const beforeMatch = codeToHighlight.substring(index, match.index);
+          const processedCount = processLexeme(beforeMatch, match);
+          index = match.index + processedCount;
+        }
+        processLexeme(codeToHighlight.substr(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,
+          illegal: false,
+          emitter: emitter,
+          top: top
+        };
+      } catch (err) {
+        if (err.message && err.message.includes('Illegal')) {
+          return {
+            illegal: true,
+            illegalBy: {
+              msg: err.message,
+              context: codeToHighlight.slice(index - 100, index + 100),
+              mode: err.mode
+            },
+            sofar: result,
+            relevance: 0,
+            value: escape$1(codeToHighlight),
+            emitter: emitter
+          };
+        } else if (SAFE_MODE) {
+          return {
+            illegal: false,
+            relevance: 0,
+            value: escape$1(codeToHighlight),
+            emitter: emitter,
+            language: languageName,
+            top: top,
+            errorRaised: err
+          };
+        } else {
+          throw err;
+        }
+      }
+    }
+
+    /**
+     * returns a valid highlight result, without actually doing any actual work,
+     * auto highlight starts with this and it's possible for small snippets that
+     * auto-detection may not find a better match
+     * @param {string} code
+     * @returns {HighlightResult}
+     */
+    function justTextHighlightResult(code) {
+      const result = {
+        relevance: 0,
+        emitter: new options.__emitter(options),
+        value: escape$1(code),
+        illegal: false,
+        top: PLAINTEXT_LANGUAGE
+      };
+      result.emitter.addText(code);
+      return result;
+    }
+
+    /**
+    Highlighting with language detection. Accepts a string with the code to
+    highlight. Returns an object with the following properties:
+
+    - language (detected language)
+    - relevance (int)
+    - value (an HTML string with highlighting markup)
+    - second_best (object with the same structure for second-best heuristically
+      detected language, may be absent)
+
+      @param {string} code
+      @param {Array<string>} [languageSubset]
+      @returns {AutoHighlightResult}
+    */
+    function highlightAuto(code, languageSubset) {
+      languageSubset = languageSubset || options.languages || Object.keys(languages);
+      const plaintext = justTextHighlightResult(code);
+
+      const results = languageSubset.filter(getLanguage).filter(autoDetection).map(name =>
+        _highlight(name, code, false)
+      );
+      results.unshift(plaintext); // plaintext is always an option
+
+      const sorted = results.sort((a, b) => {
+        // sort base on relevance
+        if (a.relevance !== b.relevance) return b.relevance - a.relevance;
+
+        // always award the tie to the base language
+        // ie if C++ and Arduino are tied, it's more likely to be C++
+        if (a.language && b.language) {
+          if (getLanguage(a.language).supersetOf === b.language) {
+            return 1;
+          } else if (getLanguage(b.language).supersetOf === a.language) {
+            return -1;
+          }
+        }
+
+        // otherwise say they are equal, which has the effect of sorting on
+        // relevance while preserving the original ordering - which is how ties
+        // have historically been settled, ie the language that comes first always
+        // wins in the case of a tie
+        return 0;
+      });
+
+      const [best, secondBest] = sorted;
+
+      /** @type {AutoHighlightResult} */
+      const result = best;
+      result.second_best = 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
+     *
+     * @param {HTMLElement} element
+     * @param {string} [currentLang]
+     * @param {string} [resultLang]
+     */
+    function updateClassName(element, currentLang, resultLang) {
+      const language = currentLang ? aliases[currentLang] : resultLang;
+
+      element.classList.add("hljs");
+      if (language) element.classList.add(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.
+     *
+     * @param {HighlightedHTMLElement} element - the HTML element to highlight
+    */
+    function highlightElement(element) {
+      /** @type HTMLElement */
+      let node = null;
+      const language = blockLanguage(element);
+
+      if (shouldNotHighlight(language)) return;
+
+      // support for v10 API
+      fire("before:highlightElement",
+        { el: element, language: language });
+
+      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
+      };
+      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
+        };
+      }
+    }
+
+    /**
+     * Updates highlight.js global options with the passed options
+     *
+     * @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);
+    }
+
+    /**
+     * 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);
+    };
+
+    // Higlights all when DOMContentLoaded fires
+    // TODO: remove v12, deprecated
+    function initHighlightingOnLoad() {
+      deprecated("10.6.0", "initHighlightingOnLoad() is deprecated.  Use highlightAll() instead.");
+      wantsHighlight = true;
+    }
+
+    let wantsHighlight = false;
+
+    /**
+     * auto-highlights all pre>code elements on the page
+     */
+    function highlightAll() {
+      // if we are called too early in the loading process
+      if (document.readyState === "loading") {
+        wantsHighlight = true;
+        return;
+      }
+
+      const blocks = document.querySelectorAll('pre code');
+      blocks.forEach(highlightElement);
+    }
+
+    function boot() {
+      // if a highlight was requested before DOM was loaded, do now
+      if (wantsHighlight) highlightAll();
+    }
+
+    // make sure we are in the browser environment
+    if (typeof window !== 'undefined' && window.addEventListener) {
+      window.addEventListener('DOMContentLoaded', boot, false);
+    }
+
+    /**
+     * Register a language grammar module
+     *
+     * @param {string} languageName
+     * @param {LanguageFn} languageDefinition
+     */
+    function registerLanguage(languageName, languageDefinition) {
+      let lang = null;
+      try {
+        lang = languageDefinition(hljs);
+      } catch (error$1) {
+        error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+        // hard or soft error
+        if (!SAFE_MODE) { throw error$1; } else { error(error$1); }
+        // languages that have serious errors are replaced with essentially a
+        // "plaintext" stand-in so that the code blocks will still get normal
+        // css classes applied to them - and one bad language won't break the
+        // entire highlighter
+        lang = PLAINTEXT_LANGUAGE;
+      }
+      // give it a temporary name if it doesn't have one in the meta-data
+      if (!lang.name) lang.name = languageName;
+      languages[languageName] = lang;
+      lang.rawDefinition = languageDefinition.bind(null, hljs);
+
+      if (lang.aliases) {
+        registerAliases(lang.aliases, { languageName });
+      }
+    }
+
+    /**
+     * Remove a language grammar module
+     *
+     * @param {string} languageName
+     */
+    function unregisterLanguage(languageName) {
+      delete languages[languageName];
+      for (const alias of Object.keys(aliases)) {
+        if (aliases[alias] === languageName) {
+          delete aliases[alias];
+        }
+      }
+    }
+
+    /**
+     * @returns {string[]} List of language internal names
+     */
+    function listLanguages() {
+      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}
+     */
+    function getLanguage(name) {
+      name = (name || '').toLowerCase();
+      return languages[name] || languages[aliases[name]];
+    }
+
+    /**
+     *
+     * @param {string|string[]} aliasList - single alias or list of aliases
+     * @param {{languageName: string}} opts
+     */
+    function registerAliases(aliasList, { languageName }) {
+      if (typeof aliasList === 'string') {
+        aliasList = [aliasList];
+      }
+      aliasList.forEach(alias => { aliases[alias.toLowerCase()] = languageName; });
+    }
+
+    /**
+     * Determines if a given language has auto-detection enabled
+     * @param {string} name - name of the language
+     */
+    function autoDetection(name) {
+      const lang = getLanguage(name);
+      return lang && !lang.disableAutodetect;
+    }
+
+    /**
+     * Upgrades the old highlightBlock plugins to the new
+     * highlightElement API
+     * @param {HLJSPlugin} plugin
+     */
+    function upgradePluginAPI(plugin) {
+      // TODO: remove with v12
+      if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) {
+        plugin["before:highlightElement"] = (data) => {
+          plugin["before:highlightBlock"](
+            Object.assign({ block: data.el }, data)
+          );
+        };
+      }
+      if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) {
+        plugin["after:highlightElement"] = (data) => {
+          plugin["after:highlightBlock"](
+            Object.assign({ block: data.el }, data)
+          );
+        };
+      }
+    }
+
+    /**
+     * @param {HLJSPlugin} plugin
+     */
+    function addPlugin(plugin) {
+      upgradePluginAPI(plugin);
+      plugins.push(plugin);
+    }
+
+    /**
+     *
+     * @param {PluginEvent} event
+     * @param {any} args
+     */
+    function fire(event, args) {
+      const cb = event;
+      plugins.forEach(function(plugin) {
+        if (plugin[cb]) {
+          plugin[cb](args);
+        }
+      });
+    }
+
+    /**
+    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);
+    }
+
+    /**
+     *
+     * @param {HighlightedHTMLElement} el
+     */
+    function deprecateHighlightBlock(el) {
+      deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
+      deprecated("10.7.0", "Please use highlightElement now.");
+
+      return highlightElement(el);
+    }
+
+    /* Interface definition */
+    Object.assign(hljs, {
+      highlight,
+      highlightAuto,
+      highlightAll,
+      fixMarkup: deprecateFixMarkup,
+      highlightElement,
+      // TODO: Remove with v12 API
+      highlightBlock: deprecateHighlightBlock,
+      configure,
+      initHighlighting,
+      initHighlightingOnLoad,
+      registerLanguage,
+      unregisterLanguage,
+      listLanguages,
+      getLanguage,
+      registerAliases,
+      requireLanguage,
+      autoDetection,
+      inherit: inherit$1,
+      addPlugin,
+      // plugins for frameworks
+      vuePlugin: BuildVuePlugin(hljs).VuePlugin
+    });
+
+    hljs.debugMode = function() { SAFE_MODE = false; };
+    hljs.safeMode = function() { SAFE_MODE = true; };
+    hljs.versionString = version;
+
+    for (const key in MODES) {
+      // @ts-ignore
+      if (typeof MODES[key] === "object") {
+        // @ts-ignore
+        deepFreezeEs6(MODES[key]);
+      }
+    }
+
+    // merge all the modes/regexs 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 = highlight$1;
+
+  var format = {exports: {}};
+
+  (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;
+    }
+
+  }());
+  }(format));
+
+  var formatter = format.exports;
+
+  var fault$1 = create(Error);
+
+  var fault_1 = fault$1;
+
+  fault$1.eval = create(EvalError);
+  fault$1.range = create(RangeError);
+  fault$1.reference = create(ReferenceError);
+  fault$1.syntax = create(SyntaxError);
+  fault$1.type = create(TypeError);
+  fault$1.uri = create(URIError);
+
+  fault$1.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) {
+      if (format) {
+        format = formatter.apply(null, arguments);
+      }
+
+      return new EConstructor(format)
+    }
+  }
+
+  var high = core;
+  var fault = fault_1;
+
+  core$1.highlight = highlight;
+  core$1.highlightAuto = highlightAuto;
+  core$1.registerLanguage = registerLanguage;
+  core$1.listLanguages = listLanguages;
+  core$1.registerAlias = 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 = high.configure({});
+    var settings = options || {};
+    var prefix = settings.prefix;
+    var result;
+
+    if (typeof name !== 'string') {
+      throw fault('Expected `string` for name, got `%s`', name)
+    }
+
+    if (!high.getLanguage(name)) {
+      throw fault('Unknown language: `%s` is not registered', name)
+    }
+
+    if (typeof value !== 'string') {
+      throw fault('Expected `string` for value, got `%s`', value)
+    }
+
+    if (prefix === null || prefix === undefined) {
+      prefix = defaultPrefix;
+    }
+
+    high.configure({__emitter: Emitter, classPrefix: prefix});
+
+    result = high.highlight(value, {language: name, ignoreIllegals: true});
+
+    high.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 || high.listLanguages();
+    settings.prefix;
+    var length = subset.length;
+    var index = -1;
+    var result;
+    var secondBest;
+    var current;
+    var name;
+
+    if (typeof value !== 'string') {
+      throw fault('Expected `string` for value, got `%s`', value)
+    }
+
+    secondBest = {relevance: 0, language: null, value: []};
+    result = {relevance: 0, language: null, value: []};
+
+    while (++index < length) {
+      name = subset[index];
+
+      if (!high.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) {
+    high.registerLanguage(name, syntax);
+  }
+
+  // Get a list of all registered languages.
+  function listLanguages() {
+    return high.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) {
+      high.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() {}
+
+  function parseNodes(nodes, className = []) {
+      return nodes
+          .map(node => {
+          const classes = [
+              ...className,
+              ...node.properties
+                  ? node.properties.className
+                  : [],
+          ];
+          if (node.children) {
+              return parseNodes(node.children, classes);
+          }
+          return {
+              text: node.value,
+              classes,
+          };
+      })
+          .flat();
+  }
+  function getHighlightNodes(result) {
+      // `.value` for lowlight v1, `.children` for lowlight v2
+      return result.value || result.children || [];
+  }
+  function getDecorations({ doc, name, lowlight, defaultLanguage, }) {
+      const decorations = [];
+      core$2.findChildren(doc, node => node.type.name === name)
+          .forEach(block => {
+          let from = block.pos + 1;
+          const language = block.node.attrs.language || defaultLanguage;
+          console.log({ language, defaultLanguage });
+          const languages = lowlight.listLanguages();
+          const nodes = language && languages.includes(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, {
+                      class: node.classes.join(' '),
+                  });
+                  decorations.push(decoration);
+              }
+              from = to;
+          });
+      });
+      return prosemirrorView.DecorationSet.create(doc, decorations);
+  }
+  function LowlightPlugin({ name, lowlight, defaultLanguage }) {
+      return new prosemirrorState.Plugin({
+          key: new prosemirrorState.PluginKey('lowlight'),
+          state: {
+              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);
+                  if (transaction.docChanged
+                      // Apply decorations if:
+                      && (
+                      // selection includes named node,
+                      [oldNodeName, newNodeName].includes(name)
+                          // OR transaction adds/removes named node,
+                          || newNodes.length !== oldNodes.length
+                          // OR transaction has changes that completely encapsulte a node
+                          // (for example, a transaction that affects the entire document).
+                          // Such transactions can happen during collab syncing via y-prosemirror, for example.
+                          || transaction.steps.some(step => {
+                              // @ts-ignore
+                              return step.from !== undefined
+                                  // @ts-ignore
+                                  && step.to !== undefined
+                                  && oldNodes.some(node => {
+                                      // @ts-ignore
+                                      return node.pos >= step.from
+                                          // @ts-ignore
+                                          && node.pos + node.node.nodeSize <= step.to;
+                                  });
+                          }))) {
+                      return getDecorations({
+                          doc: transaction.doc,
+                          name,
+                          lowlight,
+                          defaultLanguage,
+                      });
+                  }
+                  return decorationSet.map(transaction.mapping, transaction.doc);
+              },
+          },
+          props: {
+              decorations(state) {
+                  return this.getState(state);
+              },
+          },
+      });
+  }
+
+  const CodeBlockLowlight = CodeBlock__default["default"].extend({
+      addOptions() {
+          var _a;
+          return {
+              ...(_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this),
+              lowlight: core$1,
+              defaultLanguage: null,
+          };
+      },
+      addProseMirrorPlugins() {
+          var _a;
+          return [
+              ...((_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this)) || [],
+              LowlightPlugin({
+                  name: this.name,
+                  lowlight: this.options.lowlight,
+                  defaultLanguage: this.options.defaultLanguage,
+              }),
+          ];
+      },
+  });
+
+  exports.CodeBlockLowlight = CodeBlockLowlight;
+  exports["default"] = CodeBlockLowlight;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=tiptap-extension-code-block-lowlight.umd.js.map