@gravitee/ui-components 3.24.4-migrate-codemirror-999a116 → 3.24.4-migrate-codemirror-6261802

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravitee/ui-components",
-  "version": "3.24.4-migrate-codemirror-999a116",
+  "version": "3.24.4-migrate-codemirror-6261802",
   "description": "Gravitee.io UI Components library, based on Web Components",
   "repository": {
     "type": "git",
@@ -55,6 +55,7 @@
     "@formatjs/intl-locale": "^2.4.40",
     "@formatjs/intl-relativetimeformat": "^9.3.2",
     "clipboard-copy": "^4.0.0",
+    "codemirror-asciidoc": "^2.0.0",
     "date-fns": "^2.26.0",
     "jdenticon": "^3.1.0",
     "jsonschema": "^1.4.0",
@@ -66,29 +67,29 @@
   },
   "devDependencies": {
     "@asciidoctor/core": "2.2.5",
-    "@babel/core": "7.16.0",
+    "@babel/core": "7.16.5",
     "@babel/plugin-syntax-dynamic-import": "7.8.3",
-    "@babel/preset-env": "7.16.4",
+    "@babel/preset-env": "7.16.5",
     "@commitlint/cli": "15.0.0",
     "@commitlint/config-conventional": "15.0.0",
-    "@highcharts/map-collection": "1.1.3",
+    "@highcharts/map-collection": "1.1.4",
     "@semantic-release/changelog": "6.0.1",
     "@semantic-release/git": "10.0.1",
-    "@storybook/addon-a11y": "6.4.8",
-    "@storybook/addon-essentials": "6.4.8",
-    "@storybook/components": "6.4.8",
-    "@storybook/theming": "6.4.8",
-    "@storybook/web-components": "6.4.8",
+    "@storybook/addon-a11y": "6.4.9",
+    "@storybook/addon-essentials": "6.4.9",
+    "@storybook/components": "6.4.9",
+    "@storybook/theming": "6.4.9",
+    "@storybook/web-components": "6.4.9",
     "asciidoctor": "2.2.5",
     "asciidoctor-highlight.js": "0.4.0",
-    "babel-jest": "27.4.2",
+    "babel-jest": "27.4.5",
     "babel-loader": "8.2.3",
     "babel-plugin-template-html-minifier": "4.1.0",
     "bundle-phobia-cli": "0.14.13",
-    "chromatic": "6.1.0",
+    "chromatic": "6.2.3",
     "danger": "10.7.1",
     "del": "6.0.0",
-    "eslint": "8.4.0",
+    "eslint": "8.5.0",
     "eslint-config-prettier": "8.3.0",
     "eslint-config-standard": "16.0.3",
     "eslint-plugin-import": "2.25.3",
@@ -108,11 +109,11 @@
     "i18n-extract": "0.6.7",
     "ignore-loader": "0.1.2",
     "is-ci": "3.0.1",
-    "jest": "27.4.3",
+    "jest": "27.4.5",
     "license-check-and-add": "4.0.3",
     "lint-staged": "11.2.6",
     "lit-html": "2.0.2",
-    "markdown-it": "12.2.0",
+    "markdown-it": "12.3.0",
     "node-static": "0.7.11",
     "nodemon": "2.0.15",
     "pascal-case": "3.1.2",

package/src/molecules/gv-code.js

@@ -108,10 +108,6 @@ export class GvCode extends GvInput {
     dispatchCustomEvent(this, 'ready', { currentTarget: this });
   }
 
-  _onChange() {
-    dispatchCustomEvent(this, 'input', this.value);
-  }
-
   get hasInputStyle() {
     return this.rows === 1;
   }
@@ -148,6 +144,7 @@ export class GvCode extends GvInput {
       EditorView.updateListener.of((viewUpdate) => {
         if (viewUpdate.docChanged) {
           this.value = this._editorView.state.doc.toString();
+          dispatchCustomEvent(this, 'input', this.value);
         }
       }),
       autocompletion({
@@ -168,19 +165,24 @@ export class GvCode extends GvInput {
 
   firstUpdated() {
     super.firstUpdated();
-
-    const parent = this.getInputElement();
-
     this._editorState = EditorState.create({
       doc: this.value,
       extensions: this._getExtensions(),
     });
+    const parent = this.getInputElement();
     this._editorView = new EditorView({
       root: this.shadowRoot,
       parent,
       state: this._editorState,
+      dispatch: (transaction) => {
+        try {
+          this._editorView.update([transaction]);
+        } catch (e) {
+          // Sometimes the default dispatch fn throws an NS_ERROR_FAILURE at runtime.
+          // It's so strange but with this catch everything is okay
+        }
+      },
     });
-
     parent.appendChild(this._editorView.dom);
   }
 
@@ -227,7 +229,10 @@ export class GvCode extends GvInput {
     if (mode) {
       const modeOnly = mode.split('/').pop();
       if (modeOnly === 'asciidoc') {
-        const [{ asciidoc }, { StreamLanguage }] = await Promise.all([import('../lib/asciidoc-lang'), import('@codemirror/stream-parser')]);
+        const [{ asciidoc }, { StreamLanguage }] = await Promise.all([
+          import('codemirror-asciidoc/lib/asciidoc'),
+          import('@codemirror/stream-parser'),
+        ]);
         return {
           name: 'asciidoc',
           support: {

package/src/molecules/gv-expression-language.js

@@ -67,7 +67,7 @@ export class GvExpressionLanguage extends GvCode {
           view.dispatch(
             view.state.changeByRange((range) => ({
               changes: [{ from: range.from, to: range.to, insert: '{#}' }],
-              range: EditorSelection.range(range.from + 2, range.to + 2),
+              range: EditorSelection.range(range.from + 2, range.from + 2),
             })),
           );
           startCompletion(view);

package/src/lib/asciidoc-lang.js

@@ -1,642 +0,0 @@
-/*
- * Copyright (C) 2021 The Gravitee team (http://gravitee.io)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *         http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// Ace highlight rules function imported below.
-const HighlightRules = function () {
-  const identifierRe = '[a-zA-Z\u00a1-\uffff]+\\b';
-  /* eslint no-useless-escape: "off" */
-  this.$rules = {
-    start: [
-      { token: 'empty', regex: /$/ },
-      { token: 'literal', regex: /^\.{4,}\s*$/, next: 'listingBlock' },
-      { token: 'literal', regex: /^-{4,}\s*$/, next: 'literalBlock' },
-      { token: 'literal', regex: /^\+{4,}\s*$/, next: 'passthroughBlock' },
-      { token: 'keyword', regex: /^={4,}\s*$/ },
-      { token: 'text', regex: /^\s*$/ },
-      // immediately return to the start mode without matching anything
-      { token: 'empty', regex: '', next: 'dissallowDelimitedBlock' },
-    ],
-
-    dissallowDelimitedBlock: [
-      { include: 'paragraphEnd' },
-      { token: 'comment', regex: '^//.+$' },
-      { token: 'keyword', regex: '^(?:NOTE|TIP|IMPORTANT|WARNING|CAUTION):\\s' },
-
-      { include: 'listStart' },
-      { token: 'literal', regex: /^\s+.+$/, next: 'indentedBlock' },
-      { token: 'empty', regex: '', next: 'text' },
-    ],
-
-    paragraphEnd: [
-      { token: 'doc.comment', regex: /^\/{4,}\s*$/, next: 'commentBlock' },
-      { token: 'tableBlock', regex: /^\s*[|!]=+\s*$/, next: 'tableBlock' },
-      // open block, ruler
-      { token: 'keyword', regex: /^(?:--|''')\s*$/, next: 'start' },
-      { token: 'option', regex: /^\[.*\]\s*$/, next: 'start' },
-      { token: 'pageBreak', regex: /^>{3,}$/, next: 'start' },
-      { token: 'literal', regex: /^\.{4,}\s*$/, next: 'listingBlock' },
-      { token: 'titleUnderline', regex: /^(?:={2,}|-{2,}|~{2,}|\^{2,}|\+{2,})\s*$/, next: 'start' },
-      { token: 'singleLineTitle', regex: /^={1,6}\s+\S.*$/, next: 'start' },
-
-      { token: 'otherBlock', regex: /^(?:\*{2,}|_{2,})\s*$/, next: 'start' },
-      // .optional title
-      { token: 'optionalTitle', regex: /^\.[^.\s].+$/, next: 'start' },
-    ],
-
-    listStart: [
-      {
-        token: 'keyword',
-        regex: /^\s*(?:\d+\.|[a-zA-Z]\.|[ixvmIXVM]+\)|\*{1,5}|-|\.{1,5})\s/,
-        next: 'listText',
-      },
-      { token: 'meta.tag', regex: /^.+(?::{2,4}|;;)(?: |$)/, next: 'listText' },
-      // continuation
-      { token: 'keyword', regex: /^\+\s*$/, next: 'start' },
-    ],
-
-    text: [
-      {
-        token: ['link', 'link'],
-        regex: /((?:https?:\/\/|ftp:\/\/|file:\/\/|mailto:|callto:)[^\s\[]+)(\[.*?\])/,
-      },
-      { token: ['link', 'link'], regex: /(?:https?:\/\/|ftp:\/\/|file:\/\/|mailto:|callto:)[^\s\[]+/ },
-      { token: 'link', regex: /\b[\w\.\/\-]+@[\w\.\/\-]+\b/ },
-      { include: 'macros' },
-      { include: 'paragraphEnd' },
-      { token: 'literal', regex: /\+{3,}/, next: 'smallPassthrough' },
-      {
-        token: 'escape',
-        regex: /\((?:C|TM|R)\)|\.{3}|->|<-|=>|<=|&#(?:\d+|x[a-fA-F\d]+);|(?: |^)--(?=\s+\S)/,
-      },
-      { token: 'escape', regex: /\\[_*'`+#]|\\{2}[_*'`+#]{2}/ },
-      { token: 'keyword', regex: /\s\+$/ },
-      // any word
-      { token: 'text', regex: identifierRe },
-      {
-        token: ['keyword', 'string', 'keyword'],
-        regex: /(<<[\w\d\-$]+,)(.*?)(>>|$)/,
-      },
-      { token: 'keyword', regex: /<<[\w\d\-$]+,?|>>/ },
-      { token: 'constant.character', regex: /\({2,3}.*?\){2,3}/ },
-      // List of callouts
-      { token: 'support.function.list.callout', regex: /^(?:<\d+>|\d+>|>) /, next: 'text' },
-      // Anchor
-      { token: 'keyword', regex: /\[\[.+?\]\]/ },
-      // bibliography
-      { token: 'support', regex: /^\[{3}[\w\d =\-]+\]{3}/ },
-
-      { include: 'quotes' },
-      // text block end
-      { token: 'empty', regex: /^\s*$/, next: 'start' },
-    ],
-
-    listText: [{ include: 'listStart' }, { include: 'text' }],
-
-    indentedBlock: [
-      { token: 'literal', regex: /^[\s\w].+$/, next: 'indentedBlock' },
-      { token: 'literal', regex: '', next: 'start' },
-    ],
-
-    listingBlock: [
-      { token: 'literal', regex: /^\.{4,}\s*$/, next: 'dissallowDelimitedBlock' },
-      { token: 'constant.numeric', regex: '<\\d+>' },
-      { token: 'literal', regex: '[^<]+' },
-      { token: 'literal', regex: '<' },
-    ],
-    literalBlock: [
-      { token: 'literal', regex: /^-{4,}\s*$/, next: 'dissallowDelimitedBlock' },
-      { token: 'constant.numeric', regex: '<\\d+>' },
-      { token: 'literal', regex: '[^<]+' },
-      { token: 'literal', regex: '<' },
-    ],
-    passthroughBlock: [
-      { token: 'literal', regex: /^\+{4,}\s*$/, next: 'dissallowDelimitedBlock' },
-      { token: 'literal', regex: identifierRe + '|\\d+' },
-      { include: 'macros' },
-      { token: 'literal', regex: '.' },
-    ],
-
-    smallPassthrough: [
-      { token: 'literal', regex: /[+]{3,}/, next: 'dissallowDelimitedBlock' },
-      { token: 'literal', regex: /^\s*$/, next: 'dissallowDelimitedBlock' },
-      { token: 'literal', regex: identifierRe + '|\\d+' },
-      { include: 'macros' },
-    ],
-
-    commentBlock: [
-      { token: 'doc.comment', regex: /^\/{4,}\s*$/, next: 'dissallowDelimitedBlock' },
-      { token: 'doc.comment', regex: '^.*$' },
-    ],
-    tableBlock: [
-      { token: 'tableBlock', regex: /^\s*\|={3,}\s*$/, next: 'dissallowDelimitedBlock' },
-      { token: 'tableBlock', regex: /^\s*!={3,}\s*$/, next: 'innerTableBlock' },
-      { token: 'tableBlock', regex: /\|/ },
-      { include: 'text', noEscape: true },
-    ],
-    innerTableBlock: [
-      { token: 'tableBlock', regex: /^\s*!={3,}\s*$/, next: 'tableBlock' },
-      { token: 'tableBlock', regex: /^\s*|={3,}\s*$/, next: 'dissallowDelimitedBlock' },
-      { token: 'tableBlock', regex: /\!/ },
-    ],
-    macros: [
-      { token: 'macro', regex: /{[\w\-$]+}/ },
-      {
-        token: ['text', 'string', 'text', 'constant.character', 'text'],
-        regex: /({)([\w\-$]+)(:)?(.+)?(})/,
-      },
-      {
-        token: ['text', 'markup.list.macro', 'keyword', 'string'],
-        regex: /(\w+)(footnote(?:ref)?::?)([^\s\[]+)?(\[.*?\])?/,
-      },
-      {
-        token: ['markup.list.macro', 'keyword', 'string'],
-        regex: /([a-zA-Z\-][\w\.\/\-]*::?)([^\s\[]+)(\[.*?\])?/,
-      },
-      { token: ['markup.list.macro', 'keyword'], regex: /([a-zA-Z\-][\w\.\/\-]+::?)(\[.*?\])/ },
-      { token: 'keyword', regex: /^:.+?:(?= |$)/ },
-    ],
-
-    quotes: [
-      { token: 'string.italic', regex: /__[^_\s].*?__/ },
-      { token: 'string.italic', regex: quoteRule('_') },
-
-      { token: 'keyword.bold', regex: /\*\*[^*\s].*?\*\*/ },
-      { token: 'keyword.bold', regex: quoteRule('\\*') },
-
-      { token: 'literal', regex: /\+\+[^+\s].*?\+\+/ },
-      { token: 'literal', regex: quoteRule('\\+') },
-
-      { token: 'literal', regex: /\$\$.+?\$\$/ },
-      { token: 'literal', regex: quoteRule('\\$') },
-
-      { token: 'literal', regex: /``[^`\s].*?``/ },
-      { token: 'literal', regex: quoteRule('`') },
-
-      { token: 'keyword', regex: /\^[^\^].*?\^/ },
-      { token: 'keyword', regex: quoteRule('\\^') },
-      { token: 'keyword', regex: /~[^~].*?~/ },
-      { token: 'keyword', regex: quoteRule('~') },
-
-      { token: 'keyword', regex: /##?/ },
-      { token: 'keyword', regex: /(?:\B|^)``|\b''/ },
-    ],
-  };
-
-  function quoteRule(ch) {
-    const prefix = /\w/.test(ch) ? '\\b' : '(?:\\B|^)';
-    return prefix + ch + '[^' + ch + '].*?' + ch + '(?![\\w*])';
-  }
-
-  // addQuoteBlock("text")
-
-  const tokenMap = {
-    macro: 'constant.character',
-    tableBlock: 'doc.comment',
-    titleUnderline: 'markup.heading',
-    singleLineTitle: 'markup.heading',
-    pageBreak: 'string',
-    option: 'string.regexp',
-    otherBlock: 'markup.list',
-    literal: 'support.function',
-    optionalTitle: 'constant.numeric',
-    escape: 'constant.language.escape',
-    link: 'markup.underline.list',
-  };
-
-  for (const state in this.$rules) {
-    const stateRules = this.$rules[state];
-    for (let i = stateRules.length; i--; ) {
-      const rule = stateRules[i];
-      if (rule.include || typeof rule === 'string') {
-        let args = [i, 1].concat(this.$rules[rule.include || rule]);
-        if (rule.noEscape) {
-          args = args.filter(function (x) {
-            return !x.next;
-          });
-        }
-        stateRules.splice.apply(stateRules, args);
-      } else if (rule.token in tokenMap) {
-        rule.token = tokenMap[rule.token];
-      }
-    }
-  }
-};
-
-// Ace's Syntax Tokenizer.
-
-// tokenizing lines longer than this makes editor very slow
-let MAX_TOKEN_COUNT = 1000;
-const Tokenizer = function (rules) {
-  this.states = rules;
-
-  this.regExps = {};
-  this.matchMappings = {};
-  for (const key in this.states) {
-    const state = this.states[key];
-    const ruleRegExps = [];
-    let matchTotal = 0;
-    const mapping = (this.matchMappings[key] = { defaultToken: 'text' });
-    let flag = 'g';
-
-    const splitterRurles = [];
-    for (let i = 0; i < state.length; i++) {
-      const rule = state[i];
-      if (rule.defaultToken) mapping.defaultToken = rule.defaultToken;
-      if (rule.caseInsensitive) flag = 'gi';
-      if (rule.regex == null) continue;
-
-      if (rule.regex instanceof RegExp) rule.regex = rule.regex.toString().slice(1, -1);
-
-      // Count number of matching groups. 2 extra groups from the full match
-      // And the catch-all on the end (used to force a match);
-      let adjustedregex = rule.regex;
-      let matchcount = new RegExp('(?:(' + adjustedregex + ')|(.))').exec('a').length - 2;
-      if (Array.isArray(rule.token)) {
-        if (rule.token.length === 1 || matchcount === 1) {
-          rule.token = rule.token[0];
-        } else if (matchcount - 1 !== rule.token.length) {
-          throw new Error(
-            "number of classes and regexp groups in '" +
-              rule.token +
-              "'\n'" +
-              rule.regex +
-              "' doesn't match\n" +
-              (matchcount - 1) +
-              '!=' +
-              rule.token.length,
-          );
-        } else {
-          rule.tokenArray = rule.token;
-          rule.token = null;
-          rule.onMatch = this.$arrayTokens;
-        }
-      } else if (typeof rule.token === 'function' && !rule.onMatch) {
-        if (matchcount > 1) rule.onMatch = this.$applyToken;
-        else rule.onMatch = rule.token;
-      }
-
-      if (matchcount > 1) {
-        if (/\\\d/.test(rule.regex)) {
-          // Replace any backreferences and offset appropriately.
-          adjustedregex = rule.regex.replace(/\\([0-9]+)/g, function (match, digit) {
-            return '\\' + (parseInt(digit, 10) + matchTotal + 1);
-          });
-        } else {
-          matchcount = 1;
-          adjustedregex = this.removeCapturingGroups(rule.regex);
-        }
-        if (!rule.splitRegex && typeof rule.token !== 'string')
-          // flag will be known only at the very end
-          splitterRurles.push(rule);
-      }
-
-      mapping[matchTotal] = i;
-      matchTotal += matchcount;
-
-      ruleRegExps.push(adjustedregex);
-
-      // makes property access faster
-      if (!rule.onMatch) rule.onMatch = null;
-    }
-
-    splitterRurles.forEach(function (rule) {
-      rule.splitRegex = this.createSplitterRegexp(rule.regex, flag);
-    }, this);
-
-    this.regExps[key] = new RegExp('(' + ruleRegExps.join(')|(') + ')|($)', flag);
-  }
-};
-
-(function () {
-  this.$setMaxTokenCount = function (m) {
-    MAX_TOKEN_COUNT = m | 0;
-  };
-
-  this.$applyToken = function (str) {
-    const values = this.splitRegex.exec(str).slice(1);
-    const types = this.token.apply(this, values);
-
-    // required for compatibility with old modes
-    if (typeof types === 'string') return [{ type: types, value: str }];
-
-    const tokens = [];
-    for (let i = 0, l = types.length; i < l; i++) {
-      if (values[i])
-        tokens[tokens.length] = {
-          type: types[i],
-          value: values[i],
-        };
-    }
-    return tokens;
-  };
-
-  this.$arrayTokens = function (str) {
-    if (!str) return [];
-    const values = this.splitRegex.exec(str);
-    if (!values) return 'text';
-    const tokens = [];
-    const types = this.tokenArray;
-    for (let i = 0, l = types.length; i < l; i++) {
-      if (values[i + 1])
-        tokens[tokens.length] = {
-          type: types[i],
-          value: values[i + 1],
-        };
-    }
-    return tokens;
-  };
-
-  this.removeCapturingGroups = function (src) {
-    const r = src.replace(/\[(?:\\.|[^\]])*?\]|\\.|\(\?[:=!]|(\()/g, function (x, y) {
-      return y ? '(?:' : x;
-    });
-    return r;
-  };
-
-  this.createSplitterRegexp = function (src, flag) {
-    if (src.indexOf('(?=') !== -1) {
-      let stack = 0;
-      let inChClass = false;
-      const lastCapture = {};
-      src.replace(/(\\.)|(\((?:\?[=!])?)|(\))|([\[\]])/g, function (m, esc, parenOpen, parenClose, square, index) {
-        if (inChClass) {
-          inChClass = square !== ']';
-        } else if (square) {
-          inChClass = true;
-        } else if (parenClose) {
-          if (stack === lastCapture.stack) {
-            lastCapture.end = index + 1;
-            lastCapture.stack = -1;
-          }
-          stack--;
-        } else if (parenOpen) {
-          stack++;
-          if (parenOpen.length !== 1) {
-            lastCapture.stack = stack;
-            lastCapture.start = index;
-          }
-        }
-        return m;
-      });
-
-      if (lastCapture.end != null && /^\)*$/.test(src.substr(lastCapture.end)))
-        src = src.substring(0, lastCapture.start) + src.substr(lastCapture.end);
-    }
-    return new RegExp(src, (flag || '').replace('g', ''));
-  };
-
-  /**
-   * Returns an object containing two properties: `tokens`, which contains all the tokens; and `state`, the current state.
-   * @returns {Object}
-   **/
-  this.getLineTokens = function (line, startState) {
-    let stack = [];
-    if (startState && typeof startState !== 'string') {
-      stack = startState.slice(0);
-      startState = stack[0];
-    }
-
-    let currentState = startState || 'start';
-    let state = this.states[currentState];
-    if (!state) {
-      currentState = 'start';
-      state = this.states[currentState];
-    }
-    let mapping = this.matchMappings[currentState];
-    let re = this.regExps[currentState];
-    re.lastIndex = 0;
-
-    let match;
-    const tokens = [];
-    let lastIndex = 0;
-
-    let token = { type: null, value: '' };
-
-    /* eslint no-cond-assign: "off" */
-    while ((match = re.exec(line))) {
-      let type = mapping.defaultToken;
-      let rule = null;
-      const value = match[0];
-      const index = re.lastIndex;
-
-      if (index - value.length > lastIndex) {
-        const skipped = line.substring(lastIndex, index - value.length);
-        if (token.type === type) {
-          token.value += skipped;
-        } else {
-          if (token.type) tokens.push(token);
-          token = { type: type, value: skipped };
-        }
-      }
-
-      for (let i = 0; i < match.length - 2; i++) {
-        if (match[i + 1] === undefined) continue;
-
-        rule = state[mapping[i]];
-
-        if (rule.onMatch) type = rule.onMatch(value, currentState, stack);
-        else type = rule.token;
-
-        if (rule.next) {
-          if (typeof rule.next === 'string') currentState = rule.next;
-          else currentState = rule.next(currentState, stack);
-
-          state = this.states[currentState];
-          if (!state) {
-            window.console && console.error && console.error(currentState, "doesn't exist");
-            currentState = 'start';
-            state = this.states[currentState];
-          }
-          mapping = this.matchMappings[currentState];
-          lastIndex = index;
-          re = this.regExps[currentState];
-          re.lastIndex = index;
-        }
-        break;
-      }
-
-      if (value) {
-        if (typeof type === 'string') {
-          if ((!rule || rule.merge !== false) && token.type === type) {
-            token.value += value;
-          } else {
-            if (token.type) tokens.push(token);
-            token = { type: type, value: value };
-          }
-        } else if (type) {
-          if (token.type) tokens.push(token);
-          token = { type: null, value: '' };
-          for (let i = 0; i < type.length; i++) tokens.push(type[i]);
-        }
-      }
-
-      if (lastIndex === line.length) break;
-
-      lastIndex = index;
-
-      if (tokens.length > MAX_TOKEN_COUNT) {
-        // chrome doens't show contents of text nodes with very long text
-        while (lastIndex < line.length) {
-          if (token.type) tokens.push(token);
-          token = {
-            value: line.substring(lastIndex, (lastIndex += 2000)),
-            type: 'overflow',
-          };
-        }
-        currentState = 'start';
-        stack = [];
-        break;
-      }
-    }
-
-    if (token.type) tokens.push(token);
-
-    if (stack.length > 1) {
-      if (stack[0] !== currentState) stack.unshift(currentState);
-    }
-    return {
-      tokens: tokens,
-      state: stack.length ? stack : currentState,
-    };
-  };
-}.call(Tokenizer.prototype));
-
-// Token conversion.
-// See <https://github.com/ajaxorg/ace/wiki/Creating-or-Extending-an-Edit-Mode#common-tokens>
-// This is not an exact match nor the best match that can be made.
-const tokenFromAceToken = {
-  empty: null,
-  text: null,
-
-  // Keyword
-  keyword: 'keyword',
-  control: 'keyword',
-  operator: 'operator',
-
-  // Constants
-  constant: 'atom',
-  numeric: 'number',
-  character: 'atom',
-  escape: 'atom',
-
-  // Variables
-  variable: 'variable',
-  parameter: 'variable-3',
-  // Python's `self` uses that.
-  language: 'variable-2',
-
-  // Comments
-  comment: 'comment',
-  line: 'comment',
-  'double-slash': 'comment',
-  'double-dash': 'comment',
-  'number-sign': 'comment',
-  percentage: 'comment',
-  block: 'comment',
-  doc: 'comment',
-
-  // String
-  string: 'string',
-  quoted: 'string',
-  single: 'string',
-  double: 'string',
-  triple: 'string',
-  unquoted: 'string',
-  interpolated: 'string',
-  regexp: 'string-2',
-
-  meta: 'keyword',
-  literal: 'qualifier',
-  support: 'builtin',
-
-  // Markup
-  markup: 'tag',
-  underline: 'link',
-  link: 'link',
-  strong: 'strong',
-  heading: 'header',
-  em: 'em',
-  list: 'variable-2',
-  numbered: 'variable-2',
-  unnumbered: 'variable-2',
-  quote: 'quote',
-  // Markdown's raw block uses that.
-  raw: 'variable-2',
-
-  // Invalid
-  invalid: 'error',
-  illegal: 'invalidchar',
-  deprecated: 'error',
-};
-
-// Takes a list of Ace tokens, returns a (string) CodeMirror token.
-const cmTokenFromAceTokens = function (tokens) {
-  let token = null;
-  for (let i = 0; i < tokens.length; i++) {
-    // Find the most specific token.
-    if (tokenFromAceToken[tokens[i]] !== undefined) {
-      token = tokenFromAceToken[tokens[i]];
-    }
-  }
-  return token;
-};
-
-// Consume a token from plannedTokens.
-const consumeToken = function (stream, state) {
-  const plannedToken = state.plannedTokens.shift();
-  if (plannedToken === undefined) {
-    return null;
-  }
-  stream.match(plannedToken.value);
-  const tokens = plannedToken.type.split('.');
-  return cmTokenFromAceTokens(tokens);
-};
-
-const matchToken = function (stream, state) {
-  // Anormal start: we already have planned tokens to consume.
-  if (state.plannedTokens.length > 0) {
-    return consumeToken(stream, state);
-  }
-
-  // Normal start.
-  const currentState = state.current;
-  const currentLine = stream.match(/.*$/, false)[0];
-  const tokenized = tokenizer.getLineTokens(currentLine, currentState);
-  // We got a {tokens, state} object.
-  // Each token is a {value, type} object.
-  state.plannedTokens = tokenized.tokens;
-  state.current = tokenized.state;
-
-  // Consume a token.
-  return consumeToken(stream, state);
-};
-
-// Initialize all state.
-const aceHighlightRules = new HighlightRules();
-const tokenizer = new Tokenizer(aceHighlightRules.$rules);
-
-export const asciidoc = {
-  startState: function () {
-    return {
-      current: 'start',
-      // List of {value, type}, with type being an Ace token string.
-      plannedTokens: [],
-    };
-  },
-  blankLine: function (state) {
-    matchToken('', state);
-  },
-  token: matchToken,
-};