codemirror-rails 4.8 → 4.9

data/vendor/assets/javascripts/codemirror/modes/spreadsheet.js

@@ -0,0 +1,109 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://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";
+
+  CodeMirror.defineMode("spreadsheet", function () {
+    return {
+      startState: function () {
+        return {
+          stringType: null,
+          stack: []
+        };
+      },
+      token: function (stream, state) {
+        if (!stream) return;
+
+        //check for state changes
+        if (state.stack.length === 0) {
+          //strings
+          if ((stream.peek() == '"') || (stream.peek() == "'")) {
+            state.stringType = stream.peek();
+            stream.next(); // Skip quote
+            state.stack.unshift("string");
+          }
+        }
+
+        //return state
+        //stack has
+        switch (state.stack[0]) {
+        case "string":
+          while (state.stack[0] === "string" && !stream.eol()) {
+            if (stream.peek() === state.stringType) {
+              stream.next(); // Skip quote
+              state.stack.shift(); // Clear flag
+            } else if (stream.peek() === "\\") {
+              stream.next();
+              stream.next();
+            } else {
+              stream.match(/^.[^\\\"\']*/);
+            }
+          }
+          return "string";
+
+        case "characterClass":
+          while (state.stack[0] === "characterClass" && !stream.eol()) {
+            if (!(stream.match(/^[^\]\\]+/) || stream.match(/^\\./)))
+              state.stack.shift();
+          }
+          return "operator";
+        }
+
+        var peek = stream.peek();
+
+        //no stack
+        switch (peek) {
+        case "[":
+          stream.next();
+          state.stack.unshift("characterClass");
+          return "bracket";
+        case ":":
+          stream.next();
+          return "operator";
+        case "\\":
+          if (stream.match(/\\[a-z]+/)) return "string-2";
+          else return null;
+        case ".":
+        case ",":
+        case ";":
+        case "*":
+        case "-":
+        case "+":
+        case "^":
+        case "<":
+        case "/":
+        case "=":
+          stream.next();
+          return "atom";
+        case "$":
+          stream.next();
+          return "builtin";
+        }
+
+        if (stream.match(/\d+/)) {
+          if (stream.match(/^\w+/)) return "error";
+          return "number";
+        } else if (stream.match(/^[a-zA-Z_]\w*/)) {
+          if (stream.match(/(?=[\(.])/, false)) return "keyword";
+          return "variable-2";
+        } else if (["[", "]", "(", ")", "{", "}"].indexOf(peek) != -1) {
+          stream.next();
+          return "bracket";
+        } else if (!stream.eatSpace()) {
+          stream.next();
+        }
+        return null;
+      }
+    };
+  });
+
+  CodeMirror.defineMIME("text/x-spreadsheet", "spreadsheet");
+});

data/vendor/assets/javascripts/codemirror/modes/stex.js

@@ -130,8 +130,7 @@
       if (ch == "%") {
         source.skipToEnd();
         return "comment";
-      }
-      else if (ch == '}' || ch == ']') {
+      } else if (ch == '}' || ch == ']') {
         plug = peekCommand(state);
         if (plug) {
           plug.closeBracket(ch);
@@ -145,12 +144,10 @@
         plug = new plug();
         pushCommand(state, plug);
         return "bracket";
-      }
-      else if (/\d/.test(ch)) {
+      } else if (/\d/.test(ch)) {
         source.eatWhile(/[\w.%]/);
         return "atom";
-      }
-      else {
+      } else {
         source.eatWhile(/[\w\-_]/);
         plug = getMostPowerful(state);
         if (plug.name == 'begin') {
@@ -242,6 +239,7 @@
       },
       blankLine: function(state) {
         state.f = normal;
+        state.cmdState.length = 0;
       },
       lineComment: "%"
     };

data/vendor/assets/javascripts/codemirror/modes/textile.js

@@ -2,552 +2,468 @@
 // Distributed under an MIT license: http://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);
+  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 Parser(regExpFactory, state, stream) {
-  this.regExpFactory = regExpFactory;
-  this.state = state;
-  this.stream = stream;
-  this.styles = TOKEN_STYLES;
-
-  this.state.specialChar = null;
-}
-
-Parser.prototype.eat = function(name) {
-  return this.stream.match(this.regExpFactory.pattern(name), true);
-};
-
-Parser.prototype.check = function(name) {
-  return this.stream.match(this.regExpFactory.pattern(name), false);
-};
-
-Parser.prototype.setModeForNextToken = function(mode) {
-  return this.state.mode = mode;
-};
-
-Parser.prototype.execMode = function(newMode) {
-  return this.setModeForNextToken(newMode).call(this);
-};
-
-Parser.prototype.startNewLine = function() {
-  this.setModeForNextToken(Modes.newLayout);
-  this.state.tableHeading = false;
-
-  if (this.state.layoutType === 'definitionList' && this.state.spanningLayout) {
-    if (this.check('definitionListEnd')) {
-      this.state.spanningLayout = false;
-    }
-  }
-};
+  "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"
+  };
 
-Parser.prototype.nextToken = function() {
-  return this.state.mode.call(this);
-};
+  function startNewLine(stream, state) {
+    state.mode = Modes.newLayout;
+    state.tableHeading = false;
 
-Parser.prototype.styleFor = function(token) {
-  if (this.styles.hasOwnProperty(token)) {
-    return this.styles[token];
+    if (state.layoutType === "definitionList" && state.spanningLayout &&
+        stream.match(RE("definitionListEnd"), false))
+      state.spanningLayout = false;
   }
-  throw 'unknown token';
-};
 
-Parser.prototype.handlePhraseModifier = function(ch) {
-  if (ch === '_') {
-    if (this.stream.eat('_')) {
-      return this.togglePhraseModifier('italic', /^.*__/);
+  function handlePhraseModifier(stream, state, ch) {
+    if (ch === "_") {
+      if (stream.eat("_"))
+        return togglePhraseModifier(stream, state, "italic", /__/, 2);
+      else
+        return togglePhraseModifier(stream, state, "em", /_/, 1);
     }
-    return this.togglePhraseModifier('em', /^.*_/);
-  }
 
-  if (ch === '*') {
-    if (this.stream.eat('*')) {
-      return this.togglePhraseModifier('bold', /^.*\*\*/);
+    if (ch === "*") {
+      if (stream.eat("*")) {
+        return togglePhraseModifier(stream, state, "bold", /\*\*/, 2);
+      }
+      return togglePhraseModifier(stream, state, "strong", /\*/, 1);
     }
-    return this.togglePhraseModifier('strong', /^.*\*/);
-  }
 
-  if (ch === '[') {
-    if (this.stream.match(/\d+\]/)) {
-      this.state.footCite = true;
+    if (ch === "[") {
+      if (stream.match(/\d+\]/)) state.footCite = true;
+      return tokenStyles(state);
     }
-    return this.tokenStyles();
-  }
 
-  if (ch === '(') {
-    if (this.stream.match('r)')) {
-      this.state.specialChar = 'r';
-    } else if (this.stream.match('tm)')) {
-      this.state.specialChar = 'tm';
-    } else if (this.stream.match('c)')) {
-      this.state.specialChar = 'c';
+    if (ch === "(") {
+      var spec = stream.match(/^(r|tm|c)\)/);
+      if (spec)
+        return tokenStylesWith(state, TOKEN_STYLES.specialChar);
     }
-    return this.tokenStyles();
-  }
 
-  if (ch === '<') {
-    if (this.stream.match(/(\w+)[^>]+>[^<]+<\/\1>/)) {
-      return this.tokenStylesWith(this.styleFor('html'));
-    }
-  }
+    if (ch === "<" && stream.match(/(\w+)[^>]+>[^<]+<\/\1>/))
+      return tokenStylesWith(state, TOKEN_STYLES.html);
 
-  if (ch === '?' && this.stream.eat('?')) {
-    return this.togglePhraseModifier('cite', /^.*\?\?/);
-  }
-  if (ch === '=' && this.stream.eat('=')) {
-    return this.togglePhraseModifier('notextile', /^.*==/);
-  }
-  if (ch === '-') {
-    return this.togglePhraseModifier('deletion', /^.*-/);
-  }
-  if (ch === '+') {
-    return this.togglePhraseModifier('addition', /^.*\+/);
-  }
-  if (ch === '~') {
-    return this.togglePhraseModifier('sub', /^.*~/);
-  }
-  if (ch === '^') {
-    return this.togglePhraseModifier('sup', /^.*\^/);
-  }
-  if (ch === '%') {
-    return this.togglePhraseModifier('span', /^.*%/);
-  }
-  if (ch === '@') {
-    return this.togglePhraseModifier('code', /^.*@/);
-  }
-  if (ch === '!') {
-    var type = this.togglePhraseModifier('image', /^.*(?:\([^\)]+\))?!/);
-    this.stream.match(/^:\S+/); // optional Url portion
-    return type;
-  }
-  return this.tokenStyles();
-};
-
-Parser.prototype.togglePhraseModifier = function(phraseModifier, closeRE) {
-  if (this.state[phraseModifier]) { // remove phrase modifier
-    var type = this.tokenStyles();
-    this.state[phraseModifier] = false;
-    return type;
-  }
-  if (this.stream.match(closeRE, false)) { // add phrase modifier
-    this.state[phraseModifier] = true;
-    this.setModeForNextToken(Modes.attributes);
-  }
-  return this.tokenStyles();
-};
+    if (ch === "?" && stream.eat("?"))
+      return togglePhraseModifier(stream, state, "cite", /\?\?/, 2);
 
-Parser.prototype.tokenStyles = function() {
-  var disabled = this.textileDisabled(),
-      styles = [];
+    if (ch === "=" && stream.eat("="))
+      return togglePhraseModifier(stream, state, "notextile", /==/, 2);
 
-  if (disabled) return disabled;
+    if (ch === "-" && !stream.eat("-"))
+      return togglePhraseModifier(stream, state, "deletion", /-/, 1);
 
-  if (this.state.layoutType) {
-    styles.push(this.styleFor(this.state.layoutType));
-  }
+    if (ch === "+")
+      return togglePhraseModifier(stream, state, "addition", /\+/, 1);
 
-  styles = styles.concat(this.activeStyles('addition', 'bold', 'cite', 'code',
-      'deletion', 'em', 'footCite', 'image', 'italic', 'link', 'span', 'specialChar', 'strong',
-      'sub', 'sup', 'table', 'tableHeading'));
+    if (ch === "~")
+      return togglePhraseModifier(stream, state, "sub", /~/, 1);
 
-  if (this.state.layoutType === 'header') {
-    styles.push(this.styleFor('header') + '-' + this.state.header);
-  }
-  return styles.length ? styles.join(' ') : null;
-};
+    if (ch === "^")
+      return togglePhraseModifier(stream, state, "sup", /\^/, 1);
 
-Parser.prototype.textileDisabled = function() {
-  var type = this.state.layoutType;
+    if (ch === "%")
+      return togglePhraseModifier(stream, state, "span", /%/, 1);
 
-  switch(type) {
-    case 'notextile':
-    case 'code':
-    case 'pre':
-      return this.styleFor(type);
-    default:
-      if (this.state.notextile) {
-        return this.styleFor('notextile') + (type ? (' ' + this.styleFor(type)) : '');
-      }
+    if (ch === "@")
+      return togglePhraseModifier(stream, state, "code", /@/, 1);
 
-      return null;
+    if (ch === "!") {
+      var type = togglePhraseModifier(stream, state, "image", /(?:\([^\)]+\))?!/, 1);
+      stream.match(/^:\S+/); // optional Url portion
+      return type;
+    }
+    return tokenStyles(state);
   }
-};
 
-Parser.prototype.tokenStylesWith = function(extraStyles) {
-  var disabled = this.textileDisabled(),
-      type;
+  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);
+  };
 
-  if (disabled) return disabled;
+  function tokenStyles(state) {
+    var disabled = textileDisabled(state);
+    if (disabled) return disabled;
 
-  type = this.tokenStyles();
-  if(extraStyles) {
-    return type ? (type + ' ' + extraStyles) : extraStyles;
-  }
-  return type;
-};
-
-Parser.prototype.activeStyles = function() {
-  var styles = [],
-      i;
-  for (i = 0; i < arguments.length; ++i) {
-    if (this.state[arguments[i]]) {
-      styles.push(this.styleFor(arguments[i]));
-    }
-  }
-  return styles;
-};
+    var styles = [];
+    if (state.layoutType) styles.push(TOKEN_STYLES[state.layoutType]);
 
-Parser.prototype.blankLine = function() {
-  var spanningLayout = this.state.spanningLayout,
-      type = this.state.layoutType,
-      key;
+    styles = styles.concat(activeStyles(
+      state, "addition", "bold", "cite", "code", "deletion", "em", "footCite",
+      "image", "italic", "link", "span", "strong", "sub", "sup", "table", "tableHeading"));
 
-  for (key in this.state) {
-    if (this.state.hasOwnProperty(key)) {
-      delete this.state[key];
-    }
-  }
+    if (state.layoutType === "header")
+      styles.push(TOKEN_STYLES.header + "-" + state.header);
 
-  this.setModeForNextToken(Modes.newLayout);
-  if (spanningLayout) {
-    this.state.layoutType = type;
-    this.state.spanningLayout = true;
+    return styles.length ? styles.join(" ") : null;
   }
-};
-
-
-function RegExpFactory() {
-  this.cache = {};
-  this.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: /[^!"_=\*\[\(<\?\+~\^%@-]+/
-  };
-  this.attributes = {
-    align: /(?:<>|<|>|=)/,
-    selector: /\([^\(][^\)]+\)/,
-    lang: /\[[^\[\]]+\]/,
-    pad: /(?:\(+|\)+){1,2}/,
-    css: /\{[^\}]+\}/
-  };
-}
-
-RegExpFactory.prototype.pattern = function(name) {
-  return (this.cache[name] || this.createRe(name));
-};
-
-RegExpFactory.prototype.createRe = function(name) {
-  switch (name) {
-    case 'drawTable':
-      return this.makeRe('^', this.single.drawTable, '$');
-    case 'html':
-      return this.makeRe('^', this.single.html, '(?:', this.single.html, ')*', '$');
-    case 'linkDefinition':
-      return this.makeRe('^', this.single.linkDefinition, '$');
-    case 'listLayout':
-      return this.makeRe('^', this.single.list, this.pattern('allAttributes'), '*\\s+');
-    case 'tableCellAttributes':
-      return this.makeRe('^', this.choiceRe(this.single.tableCellAttributes,
-          this.pattern('allAttributes')), '+\\.');
-    case 'type':
-      return this.makeRe('^', this.pattern('allTypes'));
-    case 'typeLayout':
-      return this.makeRe('^', this.pattern('allTypes'), this.pattern('allAttributes'),
-          '*\\.\\.?', '(\\s+|$)');
-    case 'attributes':
-      return this.makeRe('^', this.pattern('allAttributes'), '+');
-
-    case 'allTypes':
-      return this.choiceRe(this.single.div, this.single.foot,
-          this.single.header, this.single.bc, this.single.bq,
-          this.single.notextile, this.single.pre, this.single.table,
-          this.single.para);
-
-    case 'allAttributes':
-      return this.choiceRe(this.attributes.selector, this.attributes.css,
-          this.attributes.lang, this.attributes.align, this.attributes.pad);
 
+  function textileDisabled(state) {
+    var type = state.layoutType;
+
+    switch(type) {
+    case "notextile":
+    case "code":
+    case "pre":
+      return TOKEN_STYLES[type];
     default:
-      return this.makeRe('^', this.single[name]);
+      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;
 
-RegExpFactory.prototype.makeRe = function() {
-  var pattern = '',
-      i,
-      arg;
-
-  for (i = 0; i < arguments.length; ++i) {
-    arg = arguments[i];
-    pattern += (typeof arg === 'string') ? arg : arg.source;
+    var type = tokenStyles(state);
+    if (extraStyles)
+      return type ? (type + " " + extraStyles) : extraStyles;
+    else
+      return type;
   }
-  return new RegExp(pattern);
-};
-
-RegExpFactory.prototype.choiceRe = function() {
-  var parts = [arguments[0]],
-      i;
 
-  for (i = 1; i < arguments.length; ++i) {
-    parts[i * 2 - 1] = '|';
-    parts[i * 2] = arguments[i];
+  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;
   }
 
-  parts.unshift('(?:');
-  parts.push(')');
-  return this.makeRe.apply(this, parts);
-};
+  function blankLine(state) {
+    var spanningLayout = state.spanningLayout, type = state.layoutType;
 
+    for (var key in state) if (state.hasOwnProperty(key))
+      delete state[key];
 
-var Modes = {
-  newLayout: function() {
-    if (this.check('typeLayout')) {
-      this.state.spanningLayout = false;
-      return this.execMode(Modes.blockType);
+    state.mode = Modes.newLayout;
+    if (spanningLayout) {
+      state.layoutType = type;
+      state.spanningLayout = true;
     }
-    if (!this.textileDisabled()) {
-      if (this.check('listLayout')) {
-        return this.execMode(Modes.list);
-      } else if (this.check('drawTable')) {
-        return this.execMode(Modes.table);
-      } else if (this.check('linkDefinition')) {
-        return this.execMode(Modes.linkDefinition);
-      } else if (this.check('definitionList')) {
-        return this.execMode(Modes.definitionList);
-      } else if (this.check('html')) {
-        return this.execMode(Modes.html);
+  }
+
+  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];
       }
-    }
-    return this.execMode(Modes.text);
-  },
-
-  blockType: function() {
-    var match,
-        type;
-    this.state.layoutType = null;
-
-    if (match = this.eat('type')) {
-      type = match[0];
-    } else {
-      return this.execMode(Modes.text);
-    }
 
-    if(match = type.match(this.regExpFactory.pattern('header'))) {
-      this.state.layoutType = 'header';
-      this.state.header = parseInt(match[0][1]);
-    } else if (type.match(this.regExpFactory.pattern('bq'))) {
-      this.state.layoutType = 'quote';
-    } else if (type.match(this.regExpFactory.pattern('bc'))) {
-      this.state.layoutType = 'code';
-    } else if (type.match(this.regExpFactory.pattern('foot'))) {
-      this.state.layoutType = 'footnote';
-    } else if (type.match(this.regExpFactory.pattern('notextile'))) {
-      this.state.layoutType = 'notextile';
-    } else if (type.match(this.regExpFactory.pattern('pre'))) {
-      this.state.layoutType = 'pre';
-    } else if (type.match(this.regExpFactory.pattern('div'))) {
-      this.state.layoutType = 'div';
-    } else if (type.match(this.regExpFactory.pattern('table'))) {
-      this.state.layoutType = 'table';
+      parts.unshift("(?:");
+      parts.push(")");
+      return REs.makeRe.apply(null, parts);
     }
+  };
 
-    this.setModeForNextToken(Modes.attributes);
-    return this.tokenStyles();
-  },
+  function RE(name) {
+    return (REs.cache[name] || (REs.cache[name] = REs.createRe(name)));
+  }
 
-  text: function() {
-    if (this.eat('text')) {
-      return this.tokenStyles();
-    }
+  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);
+    },
 
-    var ch = this.stream.next();
+    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";
+      }
 
-    if (ch === '"') {
-      return this.execMode(Modes.link);
-    }
-    return this.handlePhraseModifier(ch);
-  },
+      state.mode = Modes.attributes;
+      return tokenStyles(state);
+    },
 
-  attributes: function() {
-    this.setModeForNextToken(Modes.layoutLength);
+    text: function(stream, state) {
+      if (stream.match(RE("text"))) return tokenStyles(state);
 
-    if (this.eat('attributes')) {
-      return this.tokenStylesWith(this.styleFor('attributes'));
-    }
-    return this.tokenStyles();
-  },
+      var ch = stream.next();
+      if (ch === '"')
+        return (state.mode = Modes.link)(stream, state);
+      return handlePhraseModifier(stream, state, ch);
+    },
 
-  layoutLength: function() {
-    if (this.stream.eat('.') && this.stream.eat('.')) {
-      this.state.spanningLayout = true;
-    }
+    attributes: function(stream, state) {
+      state.mode = Modes.layoutLength;
 
-    this.setModeForNextToken(Modes.text);
-    return this.tokenStyles();
-  },
-
-  list: function() {
-    var match = this.eat('list'),
-        listMod;
-    this.state.listDepth = match[0].length;
-    listMod = (this.state.listDepth - 1) % 3;
-    if (!listMod) {
-      this.state.layoutType = 'list1';
-    } else if (listMod === 1) {
-      this.state.layoutType = 'list2';
-    } else {
-      this.state.layoutType = 'list3';
-    }
-    this.setModeForNextToken(Modes.attributes);
-    return this.tokenStyles();
-  },
-
-  link: function() {
-    this.setModeForNextToken(Modes.text);
-    if (this.eat('link')) {
-      this.stream.match(/\S+/);
-      return this.tokenStylesWith(this.styleFor('link'));
-    }
-    return this.tokenStyles();
-  },
+      if (stream.match(RE("attributes")))
+        return tokenStylesWith(state, TOKEN_STYLES.attributes);
+      else
+        return tokenStyles(state);
+    },
 
-  linkDefinition: function() {
-    this.stream.skipToEnd();
-    return this.tokenStylesWith(this.styleFor('linkDefinition'));
-  },
+    layoutLength: function(stream, state) {
+      if (stream.eat(".") && stream.eat("."))
+        state.spanningLayout = true;
 
-  definitionList: function() {
-    this.eat('definitionList');
+      state.mode = Modes.text;
+      return tokenStyles(state);
+    },
 
-    this.state.layoutType = 'definitionList';
+    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);
+    },
 
-    if (this.stream.match(/\s*$/)) {
-      this.state.spanningLayout = true;
-    } else {
-      this.setModeForNextToken(Modes.attributes);
-    }
-    return this.tokenStyles();
-  },
-
-  html: function() {
-    this.stream.skipToEnd();
-    return this.tokenStylesWith(this.styleFor('html'));
-  },
-
-  table: function() {
-    this.state.layoutType = 'table';
-    return this.execMode(Modes.tableCell);
-  },
-
-  tableCell: function() {
-    if (this.eat('tableHeading')) {
-      this.state.tableHeading = true;
-    } else {
-      this.stream.eat('|');
-    }
-    this.setModeForNextToken(Modes.tableCellAttributes);
-    return this.tokenStyles();
-  },
+    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);
+    },
 
-  tableCellAttributes: function() {
-    this.setModeForNextToken(Modes.tableText);
+    linkDefinition: function(stream, state) {
+      stream.skipToEnd();
+      return tokenStylesWith(state, TOKEN_STYLES.linkDefinition);
+    },
 
-    if (this.eat('tableCellAttributes')) {
-      return this.tokenStylesWith(this.styleFor('attributes'));
-    }
-    return this.tokenStyles();
-  },
+    definitionList: function(stream, state) {
+      stream.match(RE("definitionList"));
 
-  tableText: function() {
-    if (this.eat('tableText')) {
-      return this.tokenStyles();
-    }
+      state.layoutType = "definitionList";
 
-    if (this.stream.peek() === '|') { // end of cell
-      this.setModeForNextToken(Modes.tableCell);
-      return this.tokenStyles();
-    }
-    return this.handlePhraseModifier(this.stream.next());
-  }
-};
+      if (stream.match(/\s*$/))
+        state.spanningLayout = true;
+      else
+        state.mode = Modes.attributes;
 
+      return tokenStyles(state);
+    },
 
-CodeMirror.defineMode('textile', function() {
-  var regExpFactory = new RegExpFactory();
+    html: function(stream, state) {
+      stream.skipToEnd();
+      return tokenStylesWith(state, TOKEN_STYLES.html);
+    },
 
-  return {
-    startState: function() {
-      return { mode: Modes.newLayout };
+    table: function(stream, state) {
+      state.layoutType = "table";
+      return (state.mode = Modes.tableCell)(stream, state);
     },
-    token: function(stream, state) {
-      var parser = new Parser(regExpFactory, state, stream);
-      if (stream.sol()) { parser.startNewLine(); }
-      return parser.nextToken();
+
+    tableCell: function(stream, state) {
+      if (stream.match(RE("tableHeading")))
+        state.tableHeading = true;
+      else
+        stream.eat("|");
+
+      state.mode = Modes.tableCellAttributes;
+      return tokenStyles(state);
     },
-    blankLine: function(state) {
-      new Parser(regExpFactory, state).blankLine();
+
+    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.defineMIME('text/x-textile', 'textile');
+  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");
 });