Update to move custom CodeMirror codebase to our own repo and update webpack build config

3 files changed, 0 insertions, 839 deletions

diff --git a/public/vendor/codemirror/mode/dylan/dylan.js b/public/vendor/codemirror/mode/dylan/dylan.js
deleted file mode 100644
index 1b46bc82..00000000
--- a/public/vendor/codemirror/mode/dylan/dylan.js
+++ /dev/null
@@ -1,344 +0,0 @@
-// 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("dylan", function(_config) {
-  // Words
-  var words = {
-    // Words that introduce unnamed definitions like "define interface"
-    unnamedDefinition: ["interface"],
-
-    // Words that introduce simple named definitions like "define library"
-    namedDefinition: ["module", "library", "macro",
-                      "C-struct", "C-union",
-                      "C-function", "C-callable-wrapper"
-                     ],
-
-    // Words that introduce type definitions like "define class".
-    // These are also parameterized like "define method" and are
-    // appended to otherParameterizedDefinitionWords
-    typeParameterizedDefinition: ["class", "C-subtype", "C-mapped-subtype"],
-
-    // Words that introduce trickier definitions like "define method".
-    // These require special definitions to be added to startExpressions
-    otherParameterizedDefinition: ["method", "function",
-                                   "C-variable", "C-address"
-                                  ],
-
-    // Words that introduce module constant definitions.
-    // These must also be simple definitions and are
-    // appended to otherSimpleDefinitionWords
-    constantSimpleDefinition: ["constant"],
-
-    // Words that introduce module variable definitions.
-    // These must also be simple definitions and are
-    // appended to otherSimpleDefinitionWords
-    variableSimpleDefinition: ["variable"],
-
-    // Other words that introduce simple definitions
-    // (without implicit bodies).
-    otherSimpleDefinition: ["generic", "domain",
-                            "C-pointer-type",
-                            "table"
-                           ],
-
-    // Words that begin statements with implicit bodies.
-    statement: ["if", "block", "begin", "method", "case",
-                "for", "select", "when", "unless", "until",
-                "while", "iterate", "profiling", "dynamic-bind"
-               ],
-
-    // Patterns that act as separators in compound statements.
-    // This may include any general pattern that must be indented
-    // specially.
-    separator: ["finally", "exception", "cleanup", "else",
-                "elseif", "afterwards"
-               ],
-
-    // Keywords that do not require special indentation handling,
-    // but which should be highlighted
-    other: ["above", "below", "by", "from", "handler", "in",
-            "instance", "let", "local", "otherwise", "slot",
-            "subclass", "then", "to", "keyed-by", "virtual"
-           ],
-
-    // Condition signaling function calls
-    signalingCalls: ["signal", "error", "cerror",
-                     "break", "check-type", "abort"
-                    ]
-  };
-
-  words["otherDefinition"] =
-    words["unnamedDefinition"]
-    .concat(words["namedDefinition"])
-    .concat(words["otherParameterizedDefinition"]);
-
-  words["definition"] =
-    words["typeParameterizedDefinition"]
-    .concat(words["otherDefinition"]);
-
-  words["parameterizedDefinition"] =
-    words["typeParameterizedDefinition"]
-    .concat(words["otherParameterizedDefinition"]);
-
-  words["simpleDefinition"] =
-    words["constantSimpleDefinition"]
-    .concat(words["variableSimpleDefinition"])
-    .concat(words["otherSimpleDefinition"]);
-
-  words["keyword"] =
-    words["statement"]
-    .concat(words["separator"])
-    .concat(words["other"]);
-
-  // Patterns
-  var symbolPattern = "[-_a-zA-Z?!*@<>$%]+";
-  var symbol = new RegExp("^" + symbolPattern);
-  var patterns = {
-    // Symbols with special syntax
-    symbolKeyword: symbolPattern + ":",
-    symbolClass: "<" + symbolPattern + ">",
-    symbolGlobal: "\\*" + symbolPattern + "\\*",
-    symbolConstant: "\\$" + symbolPattern
-  };
-  var patternStyles = {
-    symbolKeyword: "atom",
-    symbolClass: "tag",
-    symbolGlobal: "variable-2",
-    symbolConstant: "variable-3"
-  };
-
-  // Compile all patterns to regular expressions
-  for (var patternName in patterns)
-    if (patterns.hasOwnProperty(patternName))
-      patterns[patternName] = new RegExp("^" + patterns[patternName]);
-
-  // Names beginning "with-" and "without-" are commonly
-  // used as statement macro
-  patterns["keyword"] = [/^with(?:out)?-[-_a-zA-Z?!*@<>$%]+/];
-
-  var styles = {};
-  styles["keyword"] = "keyword";
-  styles["definition"] = "def";
-  styles["simpleDefinition"] = "def";
-  styles["signalingCalls"] = "builtin";
-
-  // protected words lookup table
-  var wordLookup = {};
-  var styleLookup = {};
-
-  [
-    "keyword",
-    "definition",
-    "simpleDefinition",
-    "signalingCalls"
-  ].forEach(function(type) {
-    words[type].forEach(function(word) {
-      wordLookup[word] = type;
-      styleLookup[word] = styles[type];
-    });
-  });
-
-
-  function chain(stream, state, f) {
-    state.tokenize = f;
-    return f(stream, state);
-  }
-
-  function tokenBase(stream, state) {
-    // String
-    var ch = stream.peek();
-    if (ch == "'" || ch == '"') {
-      stream.next();
-      return chain(stream, state, tokenString(ch, "string"));
-    }
-    // Comment
-    else if (ch == "/") {
-      stream.next();
-      if (stream.eat("*")) {
-        return chain(stream, state, tokenComment);
-      } else if (stream.eat("/")) {
-        stream.skipToEnd();
-        return "comment";
-      }
-      stream.backUp(1);
-    }
-    // Decimal
-    else if (/[+\-\d\.]/.test(ch)) {
-      if (stream.match(/^[+-]?[0-9]*\.[0-9]*([esdx][+-]?[0-9]+)?/i) ||
-          stream.match(/^[+-]?[0-9]+([esdx][+-]?[0-9]+)/i) ||
-          stream.match(/^[+-]?\d+/)) {
-        return "number";
-      }
-    }
-    // Hash
-    else if (ch == "#") {
-      stream.next();
-      // Symbol with string syntax
-      ch = stream.peek();
-      if (ch == '"') {
-        stream.next();
-        return chain(stream, state, tokenString('"', "string"));
-      }
-      // Binary number
-      else if (ch == "b") {
-        stream.next();
-        stream.eatWhile(/[01]/);
-        return "number";
-      }
-      // Hex number
-      else if (ch == "x") {
-        stream.next();
-        stream.eatWhile(/[\da-f]/i);
-        return "number";
-      }
-      // Octal number
-      else if (ch == "o") {
-        stream.next();
-        stream.eatWhile(/[0-7]/);
-        return "number";
-      }
-      // Token concatenation in macros
-      else if (ch == '#') {
-        stream.next();
-        return "punctuation";
-      }
-      // Sequence literals
-      else if ((ch == '[') || (ch == '(')) {
-        stream.next();
-        return "bracket";
-      // Hash symbol
-      } else if (stream.match(/f|t|all-keys|include|key|next|rest/i)) {
-        return "atom";
-      } else {
-        stream.eatWhile(/[-a-zA-Z]/);
-        return "error";
-      }
-    } else if (ch == "~") {
-      stream.next();
-      ch = stream.peek();
-      if (ch == "=") {
-        stream.next();
-        ch = stream.peek();
-        if (ch == "=") {
-          stream.next();
-          return "operator";
-        }
-        return "operator";
-      }
-      return "operator";
-    } else if (ch == ":") {
-      stream.next();
-      ch = stream.peek();
-      if (ch == "=") {
-        stream.next();
-        return "operator";
-      } else if (ch == ":") {
-        stream.next();
-        return "punctuation";
-      }
-    } else if ("[](){}".indexOf(ch) != -1) {
-      stream.next();
-      return "bracket";
-    } else if (".,".indexOf(ch) != -1) {
-      stream.next();
-      return "punctuation";
-    } else if (stream.match("end")) {
-      return "keyword";
-    }
-    for (var name in patterns) {
-      if (patterns.hasOwnProperty(name)) {
-        var pattern = patterns[name];
-        if ((pattern instanceof Array && pattern.some(function(p) {
-          return stream.match(p);
-        })) || stream.match(pattern))
-          return patternStyles[name];
-      }
-    }
-    if (/[+\-*\/^=<>&|]/.test(ch)) {
-      stream.next();
-      return "operator";
-    }
-    if (stream.match("define")) {
-      return "def";
-    } else {
-      stream.eatWhile(/[\w\-]/);
-      // Keyword
-      if (wordLookup[stream.current()]) {
-        return styleLookup[stream.current()];
-      } else if (stream.current().match(symbol)) {
-        return "variable";
-      } else {
-        stream.next();
-        return "variable-2";
-      }
-    }
-  }
-
-  function tokenComment(stream, state) {
-    var maybeEnd = false, maybeNested = false, nestedCount = 0, ch;
-    while ((ch = stream.next())) {
-      if (ch == "/" && maybeEnd) {
-        if (nestedCount > 0) {
-          nestedCount--;
-        } else {
-          state.tokenize = tokenBase;
-          break;
-        }
-      } else if (ch == "*" && maybeNested) {
-        nestedCount++;
-      }
-      maybeEnd = (ch == "*");
-      maybeNested = (ch == "/");
-    }
-    return "comment";
-  }
-
-  function tokenString(quote, style) {
-    return function(stream, state) {
-      var escaped = false, next, end = false;
-      while ((next = stream.next()) != null) {
-        if (next == quote && !escaped) {
-          end = true;
-          break;
-        }
-        escaped = !escaped && next == "\\";
-      }
-      if (end || !escaped) {
-        state.tokenize = tokenBase;
-      }
-      return style;
-    };
-  }
-
-  // Interface
-  return {
-    startState: function() {
-      return {
-        tokenize: tokenBase,
-        currentIndent: 0
-      };
-    },
-    token: function(stream, state) {
-      if (stream.eatSpace())
-        return null;
-      var style = state.tokenize(stream, state);
-      return style;
-    },
-    blockCommentStart: "/*",
-    blockCommentEnd: "*/"
-  };
-});
-
-CodeMirror.defineMIME("text/x-dylan", "dylan");
-
-});
diff --git a/public/vendor/codemirror/mode/dylan/index.html b/public/vendor/codemirror/mode/dylan/index.html
deleted file mode 100644
index ddf5ad06..00000000
--- a/public/vendor/codemirror/mode/dylan/index.html
+++ /dev/null
@@ -1,407 +0,0 @@
-<!doctype html>
-
-<title>CodeMirror: Dylan mode</title>
-<meta charset="utf-8"/>
-<link rel=stylesheet href="../../doc/docs.css">
-
-<link rel="stylesheet" href="../../lib/codemirror.css">
-<script src="../../lib/codemirror.js"></script>
-<script src="../../addon/edit/matchbrackets.js"></script>
-<script src="../../addon/comment/continuecomment.js"></script>
-<script src="../../addon/comment/comment.js"></script>
-<script src="dylan.js"></script>
-<style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
-<div id=nav>
-  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
-
-  <ul>
-    <li><a href="../../index.html">Home</a>
-    <li><a href="../../doc/manual.html">Manual</a>
-    <li><a href="https://github.com/codemirror/codemirror">Code</a>
-  </ul>
-  <ul>
-    <li><a href="../index.html">Language modes</a>
-    <li><a class=active href="#">Dylan</a>
-  </ul>
-</div>
-
-<article>
-<h2>Dylan mode</h2>
-
-
-<div><textarea id="code" name="code">
-Module:       locators-internals
-Synopsis:     Abstract modeling of locations
-Author:       Andy Armstrong
-Copyright:    Original Code is Copyright (c) 1995-2004 Functional Objects, Inc.
-              All rights reserved.
-License:      See License.txt in this distribution for details.
-Warranty:     Distributed WITHOUT WARRANTY OF ANY KIND
-
-define open generic locator-server
-    (locator :: <locator>) => (server :: false-or(<server-locator>));
-define open generic locator-host
-    (locator :: <locator>) => (host :: false-or(<string>));
-define open generic locator-volume
-    (locator :: <locator>) => (volume :: false-or(<string>));
-define open generic locator-directory
-    (locator :: <locator>) => (directory :: false-or(<directory-locator>));
-define open generic locator-relative?
-    (locator :: <locator>) => (relative? :: <boolean>);
-define open generic locator-path
-    (locator :: <locator>) => (path :: <sequence>);
-define open generic locator-base
-    (locator :: <locator>) => (base :: false-or(<string>));
-define open generic locator-extension
-    (locator :: <locator>) => (extension :: false-or(<string>));
-
-/// Locator classes
-
-define open abstract class <directory-locator> (<physical-locator>)
-end class <directory-locator>;
-
-define open abstract class <file-locator> (<physical-locator>)
-end class <file-locator>;
-
-define method as
-    (class == <directory-locator>, string :: <string>)
- => (locator :: <directory-locator>)
-  as(<native-directory-locator>, string)
-end method as;
-
-define method make
-    (class == <directory-locator>,
-     #key server :: false-or(<server-locator>) = #f,
-          path :: <sequence> = #[],
-          relative? :: <boolean> = #f,
-          name :: false-or(<string>) = #f)
- => (locator :: <directory-locator>)
-  make(<native-directory-locator>,
-       server:    server,
-       path:      path,
-       relative?: relative?,
-       name:      name)
-end method make;
-
-define method as
-    (class == <file-locator>, string :: <string>)
- => (locator :: <file-locator>)
-  as(<native-file-locator>, string)
-end method as;
-
-define method make
-    (class == <file-locator>,
-     #key directory :: false-or(<directory-locator>) = #f,
-          base :: false-or(<string>) = #f,
-          extension :: false-or(<string>) = #f,
-          name :: false-or(<string>) = #f)
- => (locator :: <file-locator>)
-  make(<native-file-locator>,
-       directory: directory,
-       base:      base,
-       extension: extension,
-       name:      name)
-end method make;
-
-/// Locator coercion
-
-//---*** andrewa: This caching scheme doesn't work yet, so disable it.
-define constant $cache-locators?        = #f;
-define constant $cache-locator-strings? = #f;
-
-define constant $locator-to-string-cache = make(<object-table>, weak: #"key");
-define constant $string-to-locator-cache = make(<string-table>, weak: #"value");
-
-define open generic locator-as-string
-    (class :: subclass(<string>), locator :: <locator>)
- => (string :: <string>);
-
-define open generic string-as-locator
-    (class :: subclass(<locator>), string :: <string>)
- => (locator :: <locator>);
-
-define sealed sideways method as
-    (class :: subclass(<string>), locator :: <locator>)
- => (string :: <string>)
-  let string = element($locator-to-string-cache, locator, default: #f);
-  if (string)
-    as(class, string)
-  else
-    let string = locator-as-string(class, locator);
-    if ($cache-locator-strings?)
-      element($locator-to-string-cache, locator) := string;
-    else
-      string
-    end
-  end
-end method as;
-
-define sealed sideways method as
-    (class :: subclass(<locator>), string :: <string>)
- => (locator :: <locator>)
-  let locator = element($string-to-locator-cache, string, default: #f);
-  if (instance?(locator, class))
-    locator
-  else
-    let locator = string-as-locator(class, string);
-    if ($cache-locators?)
-      element($string-to-locator-cache, string) := locator;
-    else
-      locator
-    end
-  end
-end method as;
-
-/// Locator conditions
-
-define class <locator-error> (<format-string-condition>, <error>)
-end class <locator-error>;
-
-define function locator-error
-    (format-string :: <string>, #rest format-arguments)
-  error(make(<locator-error>, 
-             format-string:    format-string,
-             format-arguments: format-arguments))
-end function locator-error;
-
-/// Useful locator protocols
-
-define open generic locator-test
-    (locator :: <directory-locator>) => (test :: <function>);
-
-define method locator-test
-    (locator :: <directory-locator>) => (test :: <function>)
-  \=
-end method locator-test;
-
-define open generic locator-might-have-links?
-    (locator :: <directory-locator>) => (links? :: <boolean>);
-
-define method locator-might-have-links?
-    (locator :: <directory-locator>) => (links? :: singleton(#f))
-  #f
-end method locator-might-have-links?;
-
-define method locator-relative?
-    (locator :: <file-locator>) => (relative? :: <boolean>)
-  let directory = locator.locator-directory;
-  ~directory | directory.locator-relative?
-end method locator-relative?;
-
-define method current-directory-locator?
-    (locator :: <directory-locator>) => (current-directory? :: <boolean>)
-  locator.locator-relative?
-    & locator.locator-path = #[#"self"]
-end method current-directory-locator?;
-
-define method locator-directory
-    (locator :: <directory-locator>) => (parent :: false-or(<directory-locator>))
-  let path = locator.locator-path;
-  unless (empty?(path))
-    make(object-class(locator),
-         server:    locator.locator-server,
-         path:      copy-sequence(path, end: path.size - 1),
-         relative?: locator.locator-relative?)
-  end
-end method locator-directory;
-
-/// Simplify locator
-
-define open generic simplify-locator
-    (locator :: <physical-locator>)
- => (simplified-locator :: <physical-locator>);
-
-define method simplify-locator
-    (locator :: <directory-locator>)
- => (simplified-locator :: <directory-locator>)
-  let path = locator.locator-path;
-  let relative? = locator.locator-relative?;
-  let resolve-parent? = ~locator.locator-might-have-links?;
-  let simplified-path
-    = simplify-path(path, 
-                    resolve-parent?: resolve-parent?,
-                    relative?: relative?);
-  if (path ~= simplified-path)
-    make(object-class(locator),
-         server:    locator.locator-server,
-         path:      simplified-path,
-         relative?: locator.locator-relative?)
-  else
-    locator
-  end
-end method simplify-locator;
-
-define method simplify-locator
-    (locator :: <file-locator>) => (simplified-locator :: <file-locator>)
-  let directory = locator.locator-directory;
-  let simplified-directory = directory & simplify-locator(directory);
-  if (directory ~= simplified-directory)
-    make(object-class(locator),
-         directory: simplified-directory,
-         base:      locator.locator-base,
-         extension: locator.locator-extension)
-  else
-    locator
-  end
-end method simplify-locator;
-
-/// Subdirectory locator
-
-define open generic subdirectory-locator
-    (locator :: <directory-locator>, #rest sub-path)
- => (subdirectory :: <directory-locator>);
-
-define method subdirectory-locator
-    (locator :: <directory-locator>, #rest sub-path)
- => (subdirectory :: <directory-locator>)
-  let old-path = locator.locator-path;
-  let new-path = concatenate-as(<simple-object-vector>, old-path, sub-path);
-  make(object-class(locator),
-       server:    locator.locator-server,
-       path:      new-path,
-       relative?: locator.locator-relative?)
-end method subdirectory-locator;
-
-/// Relative locator
-
-define open generic relative-locator
-    (locator :: <physical-locator>, from-locator :: <physical-locator>)
- => (relative-locator :: <physical-locator>);
-
-define method relative-locator
-    (locator :: <directory-locator>, from-locator :: <directory-locator>)
- => (relative-locator :: <directory-locator>)
-  let path = locator.locator-path;
-  let from-path = from-locator.locator-path;
-  case
-    ~locator.locator-relative? & from-locator.locator-relative? =>
-      locator-error
-        ("Cannot find relative path of absolute locator %= from relative locator %=",
-         locator, from-locator);
-    locator.locator-server ~= from-locator.locator-server =>
-      locator;
-    path = from-path =>
-      make(object-class(locator),
-           path: vector(#"self"),
-           relative?: #t);
-    otherwise =>
-      make(object-class(locator),
-           path: relative-path(path, from-path, test: locator.locator-test),
-           relative?: #t);
-  end
-end method relative-locator;
-
-define method relative-locator
-    (locator :: <file-locator>, from-directory :: <directory-locator>)
- => (relative-locator :: <file-locator>)
-  let directory = locator.locator-directory;
-  let relative-directory = directory & relative-locator(directory, from-directory);
-  if (relative-directory ~= directory)
-    simplify-locator
-      (make(object-class(locator),
-            directory: relative-directory,
-            base:      locator.locator-base,
-            extension: locator.locator-extension))
-  else
-    locator
-  end
-end method relative-locator;
-
-define method relative-locator
-    (locator :: <physical-locator>, from-locator :: <file-locator>)
- => (relative-locator :: <physical-locator>)
-  let from-directory = from-locator.locator-directory;
-  case
-    from-directory =>
-      relative-locator(locator, from-directory);
-    ~locator.locator-relative? =>
-      locator-error
-        ("Cannot find relative path of absolute locator %= from relative locator %=",
-         locator, from-locator);
-    otherwise =>
-      locator;
-  end
-end method relative-locator;
-
-/// Merge locators
-
-define open generic merge-locators
-    (locator :: <physical-locator>, from-locator :: <physical-locator>)
- => (merged-locator :: <physical-locator>);
-
-/// Merge locators
-
-define method merge-locators
-    (locator :: <directory-locator>, from-locator :: <directory-locator>)
- => (merged-locator :: <directory-locator>)
-  if (locator.locator-relative?)
-    let path = concatenate(from-locator.locator-path, locator.locator-path);
-    simplify-locator
-      (make(object-class(locator),
-            server:    from-locator.locator-server,
-            path:      path,
-            relative?: from-locator.locator-relative?))
-  else
-    locator
-  end
-end method merge-locators;
-
-define method merge-locators
-    (locator :: <file-locator>, from-locator :: <directory-locator>)
- => (merged-locator :: <file-locator>)
-  let directory = locator.locator-directory;
-  let merged-directory 
-    = if (directory)
-        merge-locators(directory, from-locator)
-      else
-        simplify-locator(from-locator)
-      end;
-  if (merged-directory ~= directory)
-    make(object-class(locator),
-         directory: merged-directory,
-         base:      locator.locator-base,
-         extension: locator.locator-extension)
-  else
-    locator
-  end
-end method merge-locators;
-
-define method merge-locators
-    (locator :: <physical-locator>, from-locator :: <file-locator>)
- => (merged-locator :: <physical-locator>)
-  let from-directory = from-locator.locator-directory;
-  if (from-directory)
-    merge-locators(locator, from-directory)
-  else
-    locator
-  end
-end method merge-locators;
-
-/// Locator protocols
-
-define sideways method supports-open-locator?
-    (locator :: <file-locator>) => (openable? :: <boolean>)
-  ~locator.locator-relative?
-end method supports-open-locator?;
-
-define sideways method open-locator
-    (locator :: <file-locator>, #rest keywords, #key, #all-keys)
- => (stream :: <stream>)
-  apply(open-file-stream, locator, keywords)
-end method open-locator;
-</textarea></div>
-
-    <script>
-      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
-        mode: "text/x-dylan",
-        lineNumbers: true,
-        matchBrackets: true,
-        continueComments: "Enter",
-        extraKeys: {"Ctrl-Q": "toggleComment"},
-        tabMode: "indent",
-        indentUnit: 2
-      });
-    </script>
-
-    <p><strong>MIME types defined:</strong> <code>text/x-dylan</code>.</p>
-</article>
diff --git a/public/vendor/codemirror/mode/dylan/test.js b/public/vendor/codemirror/mode/dylan/test.js
deleted file mode 100644
index bf25be27..00000000
--- a/public/vendor/codemirror/mode/dylan/test.js
+++ /dev/null
@@ -1,88 +0,0 @@
-// CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-(function() {
-  var mode = CodeMirror.getMode({indentUnit: 2}, "dylan");
-  function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); }
-
-  MT('comments',
-     '[comment // This is a line comment]',
-     '[comment /* This is a block comment */]',
-     '[comment /* This is a multi]',
-     '[comment line comment]',
-     '[comment */]',
-     '[comment /* And this is a /*]',
-     '[comment /* nested */ comment */]');
-
-  MT('unary_operators',
-     '[operator -][variable a]',
-     '[operator -] [variable a]',
-     '[operator ~][variable a]',
-     '[operator ~] [variable a]');
-
-  MT('binary_operators',
-     '[variable a] [operator +] [variable b]',
-     '[variable a] [operator -] [variable b]',
-     '[variable a] [operator *] [variable b]',
-     '[variable a] [operator /] [variable b]',
-     '[variable a] [operator ^] [variable b]',
-     '[variable a] [operator =] [variable b]',
-     '[variable a] [operator ==] [variable b]',
-     '[variable a] [operator ~=] [variable b]',
-     '[variable a] [operator ~==] [variable b]',
-     '[variable a] [operator <] [variable b]',
-     '[variable a] [operator <=] [variable b]',
-     '[variable a] [operator >] [variable b]',
-     '[variable a] [operator >=] [variable b]',
-     '[variable a] [operator &] [variable b]',
-     '[variable a] [operator |] [variable b]',
-     '[variable a] [operator :=] [variable b]');
-
-  MT('integers',
-     '[number 1]',
-     '[number 123]',
-     '[number -123]',
-     '[number +456]',
-     '[number #b010]',
-     '[number #o073]',
-     '[number #xabcDEF123]');
-
-  MT('floats',
-     '[number .3]',
-     '[number -1.]',
-     '[number -2.335]',
-     '[number +3.78d1]',
-     '[number 3.78s-1]',
-     '[number -3.32e+5]');
-
-  MT('characters_and_strings',
-     "[string 'a']",
-     "[string '\\\\'']",
-     '[string ""]',
-     '[string "a"]',
-     '[string "abc def"]',
-     '[string "More escaped characters: \\\\\\\\ \\\\a \\\\b \\\\e \\\\f \\\\n \\\\r \\\\t \\\\0 ..."]');
-
-  MT('brackets',
-     '[bracket #[[]]]',
-     '[bracket #()]',
-     '[bracket #(][number 1][bracket )]',
-     '[bracket [[][number 1][punctuation ,] [number 3][bracket ]]]',
-     '[bracket ()]',
-     '[bracket {}]',
-     '[keyword if] [bracket (][variable foo][bracket )]',
-     '[bracket (][number 1][bracket )]',
-     '[bracket [[][number 1][bracket ]]]');
-
-  MT('hash_words',
-     '[punctuation ##]',
-     '[atom #f]', '[atom #F]',
-     '[atom #t]', '[atom #T]',
-     '[atom #all-keys]',
-     '[atom #include]',
-     '[atom #key]',
-     '[atom #next]',
-     '[atom #rest]',
-     '[string #"foo"]',
-     '[error #invalid]');
-})();