text: // CodeMirror, copyright (c) by Marijn Haverbeke and others
  // Distributed under an MIT license: https://codemirror.net/LICENSE
  
  (function(mod) {
    if (typeof exports == "object" && typeof module == "object") { // CommonJS
      mod(require("../../lib/codemirror"));
    } else if (typeof define == "function" && define.amd) { // AMD
      define(["../../lib/codemirror"], mod);
    } else { // Plain browser env
      mod(CodeMirror);
    }
  })(function(CodeMirror) {
    "use strict";
  
    var TOKEN_STYLES = {
      addition: "positive",
      attributes: "attribute",
      bold: "strong",
      cite: "keyword",
      code: "atom",
      definitionList: "number",
      deletion: "negative",
      div: "punctuation",
      em: "em",
      footnote: "variable",
      footCite: "qualifier",
      header: "header",
      html: "comment",
      image: "string",
      italic: "em",
      link: "link",
      linkDefinition: "link",
      list1: "variable-2",
      list2: "variable-3",
      list3: "keyword",
      notextile: "string-2",
      pre: "operator",
      p: "property",
      quote: "bracket",
      span: "quote",
      specialChar: "tag",
      strong: "strong",
      sub: "builtin",
      sup: "builtin",
      table: "variable-3",
      tableHeading: "operator"
    };
  
    function startNewLine(stream, state) {
      state.mode = Modes.newLayout;
      state.tableHeading = false;
  
      if (state.layoutType === "definitionList" && state.spanningLayout &&
          stream.match(RE("definitionListEnd"), false))
        state.spanningLayout = false;
    }
  
    function handlePhraseModifier(stream, state, ch) {
      if (ch === "_") {
        if (stream.eat("_"))
          return togglePhraseModifier(stream, state, "italic", /__/, 2);
        else
          return togglePhraseModifier(stream, state, "em", /_/, 1);
      }
  
      if (ch === "*") {
        if (stream.eat("*")) {
          return togglePhraseModifier(stream, state, "bold", /\*\*/, 2);
        }
        return togglePhraseModifier(stream, state, "strong", /\*/, 1);
      }
  
      if (ch === "[") {
        if (stream.match(/\d+\]/)) state.footCite = true;
        return tokenStyles(state);
      }
  
      if (ch === "(") {
        var spec = stream.match(/^(r|tm|c)\)/);
        if (spec)
          return tokenStylesWith(state, TOKEN_STYLES.specialChar);
      }
  
      if (ch === "<" && stream.match(/(\w+)[^>]+>[^<]+<\/\1>/))
        return tokenStylesWith(state, TOKEN_STYLES.html);
  
      if (ch === "?" && stream.eat("?"))
        return togglePhraseModifier(stream, state, "cite", /\?\?/, 2);
  
      if (ch === "=" && stream.eat("="))
        return togglePhraseModifier(stream, state, "notextile", /==/, 2);
  
      if (ch === "-" && !stream.eat("-"))
        return togglePhraseModifier(stream, state, "deletion", /-/, 1);
  
      if (ch === "+")
        return togglePhraseModifier(stream, state, "addition", /\+/, 1);
  
      if (ch === "~")
        return togglePhraseModifier(stream, state, "sub", /~/, 1);
  
      if (ch === "^")
        return togglePhraseModifier(stream, state, "sup", /\^/, 1);
  
      if (ch === "%")
        return togglePhraseModifier(stream, state, "span", /%/, 1);
  
      if (ch === "@")
        return togglePhraseModifier(stream, state, "code", /@/, 1);
  
      if (ch === "!") {
        var type = togglePhraseModifier(stream, state, "image", /(?:\([^\)]+\))?!/, 1);
        stream.match(/^:\S+/); // optional Url portion
        return type;
      }
      return tokenStyles(state);
    }
  
    function togglePhraseModifier(stream, state, phraseModifier, closeRE, openSize) {
      var charBefore = stream.pos > openSize ? stream.string.charAt(stream.pos - openSize - 1) : null;
      var charAfter = stream.peek();
      if (state[phraseModifier]) {
        if ((!charAfter || /\W/.test(charAfter)) && charBefore && /\S/.test(charBefore)) {
          var type = tokenStyles(state);
          state[phraseModifier] = false;
          return type;
        }
      } else if ((!charBefore || /\W/.test(charBefore)) && charAfter && /\S/.test(charAfter) &&
                 stream.match(new RegExp("^.*\\S" + closeRE.source + "(?:\\W|$)"), false)) {
        state[phraseModifier] = true;
        state.mode = Modes.attributes;
      }
      return tokenStyles(state);
    };
  
    function tokenStyles(state) {
      var disabled = textileDisabled(state);
      if (disabled) return disabled;
  
      var styles = [];
      if (state.layoutType) styles.push(TOKEN_STYLES[state.layoutType]);
  
      styles = styles.concat(activeStyles(
        state, "addition", "bold", "cite", "code", "deletion", "em", "footCite",
        "image", "italic", "link", "span", "strong", "sub", "sup", "table", "tableHeading"));
  
      if (state.layoutType === "header")
        styles.push(TOKEN_STYLES.header + "-" + state.header);
  
      return styles.length ? styles.join(" ") : null;
    }
  
    function textileDisabled(state) {
      var type = state.layoutType;
  
      switch(type) {
      case "notextile":
      case "code":
      case "pre":
        return TOKEN_STYLES[type];
      default:
        if (state.notextile)
          return TOKEN_STYLES.notextile + (type ? (" " + TOKEN_STYLES[type]) : "");
        return null;
      }
    }
  
    function tokenStylesWith(state, extraStyles) {
      var disabled = textileDisabled(state);
      if (disabled) return disabled;
  
      var type = tokenStyles(state);
      if (extraStyles)
        return type ? (type + " " + extraStyles) : extraStyles;
      else
        return type;
    }
  
    function activeStyles(state) {
      var styles = [];
      for (var i = 1; i < arguments.length; ++i) {
        if (state[arguments[i]])
          styles.push(TOKEN_STYLES[arguments[i]]);
      }
      return styles;
    }
  
    function blankLine(state) {
      var spanningLayout = state.spanningLayout, type = state.layoutType;
  
      for (var key in state) if (state.hasOwnProperty(key))
        delete state[key];
  
      state.mode = Modes.newLayout;
      if (spanningLayout) {
        state.layoutType = type;
        state.spanningLayout = true;
      }
    }
  
    var REs = {
      cache: {},
      single: {
        bc: "bc",
        bq: "bq",
        definitionList: /- .*?:=+/,
        definitionListEnd: /.*=:\s*$/,
        div: "div",
        drawTable: /\|.*\|/,
        foot: /fn\d+/,
        header: /h[1-6]/,
        html: /\s*<(?:\/)?(\w+)(?:[^>]+)?>(?:[^<]+<\/\1>)?/,
        link: /[^"]+":\S/,
        linkDefinition: /\[[^\s\]]+\]\S+/,
        list: /(?:#+|\*+)/,
        notextile: "notextile",
        para: "p",
        pre: "pre",
        table: "table",
        tableCellAttributes: /[\/\\]\d+/,
        tableHeading: /\|_\./,
        tableText: /[^"_\*\[\(\?\+~\^%@|-]+/,
        text: /[^!"_=\*\[\(<\?\+~\^%@-]+/
      },
      attributes: {
        align: /(?:<>|<|>|=)/,
        selector: /\([^\(][^\)]+\)/,
        lang: /\[[^\[\]]+\]/,
        pad: /(?:\(+|\)+){1,2}/,
        css: /\{[^\}]+\}/
      },
      createRe: function(name) {
        switch (name) {
        case "drawTable":
          return REs.makeRe("^", REs.single.drawTable, "$");
        case "html":
          return REs.makeRe("^", REs.single.html, "(?:", REs.single.html, ")*", "$");
        case "linkDefinition":
          return REs.makeRe("^", REs.single.linkDefinition, "$");
        case "listLayout":
          return REs.makeRe("^", REs.single.list, RE("allAttributes"), "*\\s+");
        case "tableCellAttributes":
          return REs.makeRe("^", REs.choiceRe(REs.single.tableCellAttributes,
                                              RE("allAttributes")), "+\\.");
        case "type":
          return REs.makeRe("^", RE("allTypes"));
        case "typeLayout":
          return REs.makeRe("^", RE("allTypes"), RE("allAttributes"),
                            "*\\.\\.?", "(\\s+|$)");
        case "attributes":
          return REs.makeRe("^", RE("allAttributes"), "+");
  
        case "allTypes":
          return REs.choiceRe(REs.single.div, REs.single.foot,
                              REs.single.header, REs.single.bc, REs.single.bq,
                              REs.single.notextile, REs.single.pre, REs.single.table,
                              REs.single.para);
  
        case "allAttributes":
          return REs.choiceRe(REs.attributes.selector, REs.attributes.css,
                              REs.attributes.lang, REs.attributes.align, REs.attributes.pad);
  
        default:
          return REs.makeRe("^", REs.single[name]);
        }
      },
      makeRe: function() {
        var pattern = "";
        for (var i = 0; i < arguments.length; ++i) {
          var arg = arguments[i];
          pattern += (typeof arg === "string") ? arg : arg.source;
        }
        return new RegExp(pattern);
      },
      choiceRe: function() {
        var parts = [arguments[0]];
        for (var i = 1; i < arguments.length; ++i) {
          parts[i * 2 - 1] = "|";
          parts[i * 2] = arguments[i];
        }
  
        parts.unshift("(?:");
        parts.push(")");
        return REs.makeRe.apply(null, parts);
      }
    };
  
    function RE(name) {
      return (REs.cache[name] || (REs.cache[name] = REs.createRe(name)));
    }
  
    var Modes = {
      newLayout: function(stream, state) {
        if (stream.match(RE("typeLayout"), false)) {
          state.spanningLayout = false;
          return (state.mode = Modes.blockType)(stream, state);
        }
        var newMode;
        if (!textileDisabled(state)) {
          if (stream.match(RE("listLayout"), false))
            newMode = Modes.list;
          else if (stream.match(RE("drawTable"), false))
            newMode = Modes.table;
          else if (stream.match(RE("linkDefinition"), false))
            newMode = Modes.linkDefinition;
          else if (stream.match(RE("definitionList")))
            newMode = Modes.definitionList;
          else if (stream.match(RE("html"), false))
            newMode = Modes.html;
        }
        return (state.mode = (newMode || Modes.text))(stream, state);
      },
  
      blockType: function(stream, state) {
        var match, type;
        state.layoutType = null;
  
        if (match = stream.match(RE("type")))
          type = match[0];
        else
          return (state.mode = Modes.text)(stream, state);
  
        if (match = type.match(RE("header"))) {
          state.layoutType = "header";
          state.header = parseInt(match[0][1]);
        } else if (type.match(RE("bq"))) {
          state.layoutType = "quote";
        } else if (type.match(RE("bc"))) {
          state.layoutType = "code";
        } else if (type.match(RE("foot"))) {
          state.layoutType = "footnote";
        } else if (type.match(RE("notextile"))) {
          state.layoutType = "notextile";
        } else if (type.match(RE("pre"))) {
          state.layoutType = "pre";
        } else if (type.match(RE("div"))) {
          state.layoutType = "div";
        } else if (type.match(RE("table"))) {
          state.layoutType = "table";
        }
  
        state.mode = Modes.attributes;
        return tokenStyles(state);
      },
  
      text: function(stream, state) {
        if (stream.match(RE("text"))) return tokenStyles(state);
  
        var ch = stream.next();
        if (ch === '"')
          return (state.mode = Modes.link)(stream, state);
        return handlePhraseModifier(stream, state, ch);
      },
  
      attributes: function(stream, state) {
        state.mode = Modes.layoutLength;
  
        if (stream.match(RE("attributes")))
          return tokenStylesWith(state, TOKEN_STYLES.attributes);
        else
          return tokenStyles(state);
      },
  
      layoutLength: function(stream, state) {
        if (stream.eat(".") && stream.eat("."))
          state.spanningLayout = true;
  
        state.mode = Modes.text;
        return tokenStyles(state);
      },
  
      list: function(stream, state) {
        var match = stream.match(RE("list"));
        state.listDepth = match[0].length;
        var listMod = (state.listDepth - 1) % 3;
        if (!listMod)
          state.layoutType = "list1";
        else if (listMod === 1)
          state.layoutType = "list2";
        else
          state.layoutType = "list3";
  
        state.mode = Modes.attributes;
        return tokenStyles(state);
      },
  
      link: function(stream, state) {
        state.mode = Modes.text;
        if (stream.match(RE("link"))) {
          stream.match(/\S+/);
          return tokenStylesWith(state, TOKEN_STYLES.link);
        }
        return tokenStyles(state);
      },
  
      linkDefinition: function(stream, state) {
        stream.skipToEnd();
        return tokenStylesWith(state, TOKEN_STYLES.linkDefinition);
      },
  
      definitionList: function(stream, state) {
        stream.match(RE("definitionList"));
  
        state.layoutType = "definitionList";
  
        if (stream.match(/\s*$/))
          state.spanningLayout = true;
        else
          state.mode = Modes.attributes;
  
        return tokenStyles(state);
      },
  
      html: function(stream, state) {
        stream.skipToEnd();
        return tokenStylesWith(state, TOKEN_STYLES.html);
      },
  
      table: function(stream, state) {
        state.layoutType = "table";
        return (state.mode = Modes.tableCell)(stream, state);
      },
  
      tableCell: function(stream, state) {
        if (stream.match(RE("tableHeading")))
          state.tableHeading = true;
        else
          stream.eat("|");
  
        state.mode = Modes.tableCellAttributes;
        return tokenStyles(state);
      },
  
      tableCellAttributes: function(stream, state) {
        state.mode = Modes.tableText;
  
        if (stream.match(RE("tableCellAttributes")))
          return tokenStylesWith(state, TOKEN_STYLES.attributes);
        else
          return tokenStyles(state);
      },
  
      tableText: function(stream, state) {
        if (stream.match(RE("tableText")))
          return tokenStyles(state);
  
        if (stream.peek() === "|") { // end of cell
          state.mode = Modes.tableCell;
          return tokenStyles(state);
        }
        return handlePhraseModifier(stream, state, stream.next());
      }
    };
  
    CodeMirror.defineMode("textile", function() {
      return {
        startState: function() {
          return { mode: Modes.newLayout };
        },
        token: function(stream, state) {
          if (stream.sol()) startNewLine(stream, state);
          return state.mode(stream, state);
        },
        blankLine: blankLine
      };
    });
  
    CodeMirror.defineMIME("text/x-textile", "textile");
  });
  