@vc-shell/framework 1.1.2 → 1.1.3

package/dist/assets/clojure-C2XPrGCa.js

@@ -1,274 +0,0 @@
-var atoms = ["false", "nil", "true"];
-var specialForms = [".", "catch", "def", "do", "if", "monitor-enter",
-                    "monitor-exit", "new", "quote", "recur", "set!", "throw", "try", "var"];
-var coreSymbols = ["*", "*'", "*1", "*2", "*3", "*agent*",
-                   "*allow-unresolved-vars*", "*assert*", "*clojure-version*",
-                   "*command-line-args*", "*compile-files*", "*compile-path*",
-                   "*compiler-options*", "*data-readers*", "*default-data-reader-fn*", "*e",
-                   "*err*", "*file*", "*flush-on-newline*", "*fn-loader*", "*in*",
-                   "*math-context*", "*ns*", "*out*", "*print-dup*", "*print-length*",
-                   "*print-level*", "*print-meta*", "*print-namespace-maps*",
-                   "*print-readably*", "*read-eval*", "*reader-resolver*", "*source-path*",
-                   "*suppress-read*", "*unchecked-math*", "*use-context-classloader*",
-                   "*verbose-defrecords*", "*warn-on-reflection*", "+", "+'", "-", "-'",
-                   "->", "->>", "->ArrayChunk", "->Eduction", "->Vec", "->VecNode",
-                   "->VecSeq", "-cache-protocol-fn", "-reset-methods", "..", "/", "<", "<=",
-                   "=", "==", ">", ">=", "EMPTY-NODE", "Inst", "StackTraceElement->vec",
-                   "Throwable->map", "accessor", "aclone", "add-classpath", "add-watch",
-                   "agent", "agent-error", "agent-errors", "aget", "alength", "alias",
-                   "all-ns", "alter", "alter-meta!", "alter-var-root", "amap", "ancestors",
-                   "and", "any?", "apply", "areduce", "array-map", "as->", "aset",
-                   "aset-boolean", "aset-byte", "aset-char", "aset-double", "aset-float",
-                   "aset-int", "aset-long", "aset-short", "assert", "assoc", "assoc!",
-                   "assoc-in", "associative?", "atom", "await", "await-for", "await1",
-                   "bases", "bean", "bigdec", "bigint", "biginteger", "binding", "bit-and",
-                   "bit-and-not", "bit-clear", "bit-flip", "bit-not", "bit-or", "bit-set",
-                   "bit-shift-left", "bit-shift-right", "bit-test", "bit-xor", "boolean",
-                   "boolean-array", "boolean?", "booleans", "bound-fn", "bound-fn*",
-                   "bound?", "bounded-count", "butlast", "byte", "byte-array", "bytes",
-                   "bytes?", "case", "cast", "cat", "char", "char-array",
-                   "char-escape-string", "char-name-string", "char?", "chars", "chunk",
-                   "chunk-append", "chunk-buffer", "chunk-cons", "chunk-first", "chunk-next",
-                   "chunk-rest", "chunked-seq?", "class", "class?", "clear-agent-errors",
-                   "clojure-version", "coll?", "comment", "commute", "comp", "comparator",
-                   "compare", "compare-and-set!", "compile", "complement", "completing",
-                   "concat", "cond", "cond->", "cond->>", "condp", "conj", "conj!", "cons",
-                   "constantly", "construct-proxy", "contains?", "count", "counted?",
-                   "create-ns", "create-struct", "cycle", "dec", "dec'", "decimal?",
-                   "declare", "dedupe", "default-data-readers", "definline", "definterface",
-                   "defmacro", "defmethod", "defmulti", "defn", "defn-", "defonce",
-                   "defprotocol", "defrecord", "defstruct", "deftype", "delay", "delay?",
-                   "deliver", "denominator", "deref", "derive", "descendants", "destructure",
-                   "disj", "disj!", "dissoc", "dissoc!", "distinct", "distinct?", "doall",
-                   "dorun", "doseq", "dosync", "dotimes", "doto", "double", "double-array",
-                   "double?", "doubles", "drop", "drop-last", "drop-while", "eduction",
-                   "empty", "empty?", "ensure", "ensure-reduced", "enumeration-seq",
-                   "error-handler", "error-mode", "eval", "even?", "every-pred", "every?",
-                   "ex-data", "ex-info", "extend", "extend-protocol", "extend-type",
-                   "extenders", "extends?", "false?", "ffirst", "file-seq", "filter",
-                   "filterv", "find", "find-keyword", "find-ns", "find-protocol-impl",
-                   "find-protocol-method", "find-var", "first", "flatten", "float",
-                   "float-array", "float?", "floats", "flush", "fn", "fn?", "fnext", "fnil",
-                   "for", "force", "format", "frequencies", "future", "future-call",
-                   "future-cancel", "future-cancelled?", "future-done?", "future?",
-                   "gen-class", "gen-interface", "gensym", "get", "get-in", "get-method",
-                   "get-proxy-class", "get-thread-bindings", "get-validator", "group-by",
-                   "halt-when", "hash", "hash-combine", "hash-map", "hash-ordered-coll",
-                   "hash-set", "hash-unordered-coll", "ident?", "identical?", "identity",
-                   "if-let", "if-not", "if-some", "ifn?", "import", "in-ns", "inc", "inc'",
-                   "indexed?", "init-proxy", "inst-ms", "inst-ms*", "inst?", "instance?",
-                   "int", "int-array", "int?", "integer?", "interleave", "intern",
-                   "interpose", "into", "into-array", "ints", "io!", "isa?", "iterate",
-                   "iterator-seq", "juxt", "keep", "keep-indexed", "key", "keys", "keyword",
-                   "keyword?", "last", "lazy-cat", "lazy-seq", "let", "letfn", "line-seq",
-                   "list", "list*", "list?", "load", "load-file", "load-reader",
-                   "load-string", "loaded-libs", "locking", "long", "long-array", "longs",
-                   "loop", "macroexpand", "macroexpand-1", "make-array", "make-hierarchy",
-                   "map", "map-entry?", "map-indexed", "map?", "mapcat", "mapv", "max",
-                   "max-key", "memfn", "memoize", "merge", "merge-with", "meta",
-                   "method-sig", "methods", "min", "min-key", "mix-collection-hash", "mod",
-                   "munge", "name", "namespace", "namespace-munge", "nat-int?", "neg-int?",
-                   "neg?", "newline", "next", "nfirst", "nil?", "nnext", "not", "not-any?",
-                   "not-empty", "not-every?", "not=", "ns", "ns-aliases", "ns-imports",
-                   "ns-interns", "ns-map", "ns-name", "ns-publics", "ns-refers",
-                   "ns-resolve", "ns-unalias", "ns-unmap", "nth", "nthnext", "nthrest",
-                   "num", "number?", "numerator", "object-array", "odd?", "or", "parents",
-                   "partial", "partition", "partition-all", "partition-by", "pcalls", "peek",
-                   "persistent!", "pmap", "pop", "pop!", "pop-thread-bindings", "pos-int?",
-                   "pos?", "pr", "pr-str", "prefer-method", "prefers",
-                   "primitives-classnames", "print", "print-ctor", "print-dup",
-                   "print-method", "print-simple", "print-str", "printf", "println",
-                   "println-str", "prn", "prn-str", "promise", "proxy",
-                   "proxy-call-with-super", "proxy-mappings", "proxy-name", "proxy-super",
-                   "push-thread-bindings", "pvalues", "qualified-ident?",
-                   "qualified-keyword?", "qualified-symbol?", "quot", "rand", "rand-int",
-                   "rand-nth", "random-sample", "range", "ratio?", "rational?",
-                   "rationalize", "re-find", "re-groups", "re-matcher", "re-matches",
-                   "re-pattern", "re-seq", "read", "read-line", "read-string",
-                   "reader-conditional", "reader-conditional?", "realized?", "record?",
-                   "reduce", "reduce-kv", "reduced", "reduced?", "reductions", "ref",
-                   "ref-history-count", "ref-max-history", "ref-min-history", "ref-set",
-                   "refer", "refer-clojure", "reify", "release-pending-sends", "rem",
-                   "remove", "remove-all-methods", "remove-method", "remove-ns",
-                   "remove-watch", "repeat", "repeatedly", "replace", "replicate", "require",
-                   "reset!", "reset-meta!", "reset-vals!", "resolve", "rest",
-                   "restart-agent", "resultset-seq", "reverse", "reversible?", "rseq",
-                   "rsubseq", "run!", "satisfies?", "second", "select-keys", "send",
-                   "send-off", "send-via", "seq", "seq?", "seqable?", "seque", "sequence",
-                   "sequential?", "set", "set-agent-send-executor!",
-                   "set-agent-send-off-executor!", "set-error-handler!", "set-error-mode!",
-                   "set-validator!", "set?", "short", "short-array", "shorts", "shuffle",
-                   "shutdown-agents", "simple-ident?", "simple-keyword?", "simple-symbol?",
-                   "slurp", "some", "some->", "some->>", "some-fn", "some?", "sort",
-                   "sort-by", "sorted-map", "sorted-map-by", "sorted-set", "sorted-set-by",
-                   "sorted?", "special-symbol?", "spit", "split-at", "split-with", "str",
-                   "string?", "struct", "struct-map", "subs", "subseq", "subvec", "supers",
-                   "swap!", "swap-vals!", "symbol", "symbol?", "sync", "tagged-literal",
-                   "tagged-literal?", "take", "take-last", "take-nth", "take-while", "test",
-                   "the-ns", "thread-bound?", "time", "to-array", "to-array-2d",
-                   "trampoline", "transduce", "transient", "tree-seq", "true?", "type",
-                   "unchecked-add", "unchecked-add-int", "unchecked-byte", "unchecked-char",
-                   "unchecked-dec", "unchecked-dec-int", "unchecked-divide-int",
-                   "unchecked-double", "unchecked-float", "unchecked-inc",
-                   "unchecked-inc-int", "unchecked-int", "unchecked-long",
-                   "unchecked-multiply", "unchecked-multiply-int", "unchecked-negate",
-                   "unchecked-negate-int", "unchecked-remainder-int", "unchecked-short",
-                   "unchecked-subtract", "unchecked-subtract-int", "underive", "unquote",
-                   "unquote-splicing", "unreduced", "unsigned-bit-shift-right", "update",
-                   "update-in", "update-proxy", "uri?", "use", "uuid?", "val", "vals",
-                   "var-get", "var-set", "var?", "vary-meta", "vec", "vector", "vector-of",
-                   "vector?", "volatile!", "volatile?", "vreset!", "vswap!", "when",
-                   "when-first", "when-let", "when-not", "when-some", "while",
-                   "with-bindings", "with-bindings*", "with-in-str", "with-loading-context",
-                   "with-local-vars", "with-meta", "with-open", "with-out-str",
-                   "with-precision", "with-redefs", "with-redefs-fn", "xml-seq", "zero?",
-                   "zipmap"];
-var haveBodyParameter = [
-  "->", "->>", "as->", "binding", "bound-fn", "case", "catch", "comment",
-  "cond", "cond->", "cond->>", "condp", "def", "definterface", "defmethod",
-  "defn", "defmacro", "defprotocol", "defrecord", "defstruct", "deftype",
-  "do", "doseq", "dotimes", "doto", "extend", "extend-protocol",
-  "extend-type", "fn", "for", "future", "if", "if-let", "if-not", "if-some",
-  "let", "letfn", "locking", "loop", "ns", "proxy", "reify", "struct-map",
-  "some->", "some->>", "try", "when", "when-first", "when-let", "when-not",
-  "when-some", "while", "with-bindings", "with-bindings*", "with-in-str",
-  "with-loading-context", "with-local-vars", "with-meta", "with-open",
-  "with-out-str", "with-precision", "with-redefs", "with-redefs-fn"];
-
-var atom = createLookupMap(atoms);
-var specialForm = createLookupMap(specialForms);
-var coreSymbol = createLookupMap(coreSymbols);
-var hasBodyParameter = createLookupMap(haveBodyParameter);
-var delimiter = /^(?:[\\\[\]\s"(),;@^`{}~]|$)/;
-var numberLiteral = /^(?:[+\-]?\d+(?:(?:N|(?:[eE][+\-]?\d+))|(?:\.?\d*(?:M|(?:[eE][+\-]?\d+))?)|\/\d+|[xX][0-9a-fA-F]+|r[0-9a-zA-Z]+)?(?=[\\\[\]\s"#'(),;@^`{}~]|$))/;
-var characterLiteral = /^(?:\\(?:backspace|formfeed|newline|return|space|tab|o[0-7]{3}|u[0-9A-Fa-f]{4}|x[0-9A-Fa-f]{4}|.)?(?=[\\\[\]\s"(),;@^`{}~]|$))/;
-
-// simple-namespace := /^[^\\\/\[\]\d\s"#'(),;@^`{}~.][^\\\[\]\s"(),;@^`{}~.\/]*/
-// simple-symbol    := /^(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)/
-// qualified-symbol := (<simple-namespace>(<.><simple-namespace>)*</>)?<simple-symbol>
-var qualifiedSymbol = /^(?:(?:[^\\\/\[\]\d\s"#'(),;@^`{}~.][^\\\[\]\s"(),;@^`{}~.\/]*(?:\.[^\\\/\[\]\d\s"#'(),;@^`{}~.][^\\\[\]\s"(),;@^`{}~.\/]*)*\/)?(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*(?=[\\\[\]\s"(),;@^`{}~]|$))/;
-
-function base(stream, state) {
-  if (stream.eatSpace() || stream.eat(",")) return ["space", null];
-  if (stream.match(numberLiteral)) return [null, "number"];
-  if (stream.match(characterLiteral)) return [null, "string.special"];
-  if (stream.eat(/^"/)) return (state.tokenize = inString)(stream, state);
-  if (stream.eat(/^[(\[{]/)) return ["open", "bracket"];
-  if (stream.eat(/^[)\]}]/)) return ["close", "bracket"];
-  if (stream.eat(/^;/)) {stream.skipToEnd(); return ["space", "comment"];}
-  if (stream.eat(/^[#'@^`~]/)) return [null, "meta"];
-
-  var matches = stream.match(qualifiedSymbol);
-  var symbol = matches && matches[0];
-
-  if (!symbol) {
-    // advance stream by at least one character so we don't get stuck.
-    stream.next();
-    stream.eatWhile(function (c) {return !is(c, delimiter);});
-    return [null, "error"];
-  }
-
-  if (symbol === "comment" && state.lastToken === "(")
-    return (state.tokenize = inComment)(stream, state);
-  if (is(symbol, atom) || symbol.charAt(0) === ":") return ["symbol", "atom"];
-  if (is(symbol, specialForm) || is(symbol, coreSymbol)) return ["symbol", "keyword"];
-  if (state.lastToken === "(") return ["symbol", "builtin"]; // other operator
-
-  return ["symbol", "variable"];
-}
-
-function inString(stream, state) {
-  var escaped = false, next;
-
-  while (next = stream.next()) {
-    if (next === "\"" && !escaped) {state.tokenize = base; break;}
-    escaped = !escaped && next === "\\";
-  }
-
-  return [null, "string"];
-}
-
-function inComment(stream, state) {
-  var parenthesisCount = 1;
-  var next;
-
-  while (next = stream.next()) {
-    if (next === ")") parenthesisCount--;
-    if (next === "(") parenthesisCount++;
-    if (parenthesisCount === 0) {
-      stream.backUp(1);
-      state.tokenize = base;
-      break;
-    }
-  }
-
-  return ["space", "comment"];
-}
-
-function createLookupMap(words) {
-  var obj = {};
-
-  for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
-
-  return obj;
-}
-
-function is(value, test) {
-  if (test instanceof RegExp) return test.test(value);
-  if (test instanceof Object) return test.propertyIsEnumerable(value);
-}
-
-const clojure = {
-  name: "clojure",
-  startState: function () {
-    return {
-      ctx: {prev: null, start: 0, indentTo: 0},
-      lastToken: null,
-      tokenize: base
-    };
-  },
-
-  token: function (stream, state) {
-    if (stream.sol() && (typeof state.ctx.indentTo !== "number"))
-      state.ctx.indentTo = state.ctx.start + 1;
-
-    var typeStylePair = state.tokenize(stream, state);
-    var type = typeStylePair[0];
-    var style = typeStylePair[1];
-    var current = stream.current();
-
-    if (type !== "space") {
-      if (state.lastToken === "(" && state.ctx.indentTo === null) {
-        if (type === "symbol" && is(current, hasBodyParameter))
-          state.ctx.indentTo = state.ctx.start + stream.indentUnit;
-        else state.ctx.indentTo = "next";
-      } else if (state.ctx.indentTo === "next") {
-        state.ctx.indentTo = stream.column();
-      }
-
-      state.lastToken = current;
-    }
-
-    if (type === "open")
-      state.ctx = {prev: state.ctx, start: stream.column(), indentTo: null};
-    else if (type === "close") state.ctx = state.ctx.prev || state.ctx;
-
-    return style;
-  },
-
-  indent: function (state) {
-    var i = state.ctx.indentTo;
-
-    return (typeof i === "number") ?
-      i :
-      state.ctx.start + 1;
-  },
-
-  languageData: {
-    closeBrackets: {brackets: ["(", "[", "{", '"']},
-    commentTokens: {line: ";;"},
-    autocomplete: [].concat(atoms, specialForms, coreSymbols)
-  }
-};
-
-export { clojure };

package/dist/assets/cmake-BGrEgXCL.js

@@ -1,81 +0,0 @@
-var variable_regex = /({)?[a-zA-Z0-9_]+(})?/;
-
-function tokenString(stream, state) {
-  var current, prev, found_var = false;
-  while (!stream.eol() && (current = stream.next()) != state.pending) {
-    if (current === '$' && prev != '\\' && state.pending == '"') {
-      found_var = true;
-      break;
-    }
-    prev = current;
-  }
-  if (found_var) {
-    stream.backUp(1);
-  }
-  if (current == state.pending) {
-    state.continueString = false;
-  } else {
-    state.continueString = true;
-  }
-  return "string";
-}
-
-function tokenize(stream, state) {
-  var ch = stream.next();
-
-  // Have we found a variable?
-  if (ch === '$') {
-    if (stream.match(variable_regex)) {
-      return 'variableName.special';
-    }
-    return 'variable';
-  }
-  // Should we still be looking for the end of a string?
-  if (state.continueString) {
-    // If so, go through the loop again
-    stream.backUp(1);
-    return tokenString(stream, state);
-  }
-  // Do we just have a function on our hands?
-  // In 'cmake_minimum_required (VERSION 2.8.8)', 'cmake_minimum_required' is matched
-  if (stream.match(/(\s+)?\w+\(/) || stream.match(/(\s+)?\w+\ \(/)) {
-    stream.backUp(1);
-    return 'def';
-  }
-  if (ch == "#") {
-    stream.skipToEnd();
-    return "comment";
-  }
-  // Have we found a string?
-  if (ch == "'" || ch == '"') {
-    // Store the type (single or double)
-    state.pending = ch;
-    // Perform the looping function to find the end
-    return tokenString(stream, state);
-  }
-  if (ch == '(' || ch == ')') {
-    return 'bracket';
-  }
-  if (ch.match(/[0-9]/)) {
-    return 'number';
-  }
-  stream.eatWhile(/[\w-]/);
-  return null;
-}
-const cmake = {
-  name: "cmake",
-  startState: function () {
-    var state = {};
-    state.inDefinition = false;
-    state.inInclude = false;
-    state.continueString = false;
-    state.pending = false;
-    return state;
-  },
-  token: function (stream, state) {
-    if (stream.eatSpace()) return null;
-    return tokenize(stream, state);
-  }
-};
-
-export { cmake };

package/dist/assets/cobol-DShPmpZe.js

@@ -1,234 +0,0 @@
-var BUILTIN = "builtin", COMMENT = "comment", STRING = "string",
-    ATOM = "atom", NUMBER = "number", KEYWORD = "keyword", MODTAG = "header",
-    COBOLLINENUM = "def", PERIOD = "link";
-function makeKeywords(str) {
-  var obj = {}, words = str.split(" ");
-  for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
-  return obj;
-}
-var atoms = makeKeywords("TRUE FALSE ZEROES ZEROS ZERO SPACES SPACE LOW-VALUE LOW-VALUES ");
-var keywords = makeKeywords(
-  "ACCEPT ACCESS ACQUIRE ADD ADDRESS " +
-    "ADVANCING AFTER ALIAS ALL ALPHABET " +
-    "ALPHABETIC ALPHABETIC-LOWER ALPHABETIC-UPPER ALPHANUMERIC ALPHANUMERIC-EDITED " +
-    "ALSO ALTER ALTERNATE AND ANY " +
-    "ARE AREA AREAS ARITHMETIC ASCENDING " +
-    "ASSIGN AT ATTRIBUTE AUTHOR AUTO " +
-    "AUTO-SKIP AUTOMATIC B-AND B-EXOR B-LESS " +
-    "B-NOT B-OR BACKGROUND-COLOR BACKGROUND-COLOUR BEEP " +
-    "BEFORE BELL BINARY BIT BITS " +
-    "BLANK BLINK BLOCK BOOLEAN BOTTOM " +
-    "BY CALL CANCEL CD CF " +
-    "CH CHARACTER CHARACTERS CLASS CLOCK-UNITS " +
-    "CLOSE COBOL CODE CODE-SET COL " +
-    "COLLATING COLUMN COMMA COMMIT COMMITMENT " +
-    "COMMON COMMUNICATION COMP COMP-0 COMP-1 " +
-    "COMP-2 COMP-3 COMP-4 COMP-5 COMP-6 " +
-    "COMP-7 COMP-8 COMP-9 COMPUTATIONAL COMPUTATIONAL-0 " +
-    "COMPUTATIONAL-1 COMPUTATIONAL-2 COMPUTATIONAL-3 COMPUTATIONAL-4 COMPUTATIONAL-5 " +
-    "COMPUTATIONAL-6 COMPUTATIONAL-7 COMPUTATIONAL-8 COMPUTATIONAL-9 COMPUTE " +
-    "CONFIGURATION CONNECT CONSOLE CONTAINED CONTAINS " +
-    "CONTENT CONTINUE CONTROL CONTROL-AREA CONTROLS " +
-    "CONVERTING COPY CORR CORRESPONDING COUNT " +
-    "CRT CRT-UNDER CURRENCY CURRENT CURSOR " +
-    "DATA DATE DATE-COMPILED DATE-WRITTEN DAY " +
-    "DAY-OF-WEEK DB DB-ACCESS-CONTROL-KEY DB-DATA-NAME DB-EXCEPTION " +
-    "DB-FORMAT-NAME DB-RECORD-NAME DB-SET-NAME DB-STATUS DBCS " +
-    "DBCS-EDITED DE DEBUG-CONTENTS DEBUG-ITEM DEBUG-LINE " +
-    "DEBUG-NAME DEBUG-SUB-1 DEBUG-SUB-2 DEBUG-SUB-3 DEBUGGING " +
-    "DECIMAL-POINT DECLARATIVES DEFAULT DELETE DELIMITED " +
-    "DELIMITER DEPENDING DESCENDING DESCRIBED DESTINATION " +
-    "DETAIL DISABLE DISCONNECT DISPLAY DISPLAY-1 " +
-    "DISPLAY-2 DISPLAY-3 DISPLAY-4 DISPLAY-5 DISPLAY-6 " +
-    "DISPLAY-7 DISPLAY-8 DISPLAY-9 DIVIDE DIVISION " +
-    "DOWN DROP DUPLICATE DUPLICATES DYNAMIC " +
-    "EBCDIC EGI EJECT ELSE EMI " +
-    "EMPTY EMPTY-CHECK ENABLE END END. END-ACCEPT END-ACCEPT. " +
-    "END-ADD END-CALL END-COMPUTE END-DELETE END-DISPLAY " +
-    "END-DIVIDE END-EVALUATE END-IF END-INVOKE END-MULTIPLY " +
-    "END-OF-PAGE END-PERFORM END-READ END-RECEIVE END-RETURN " +
-    "END-REWRITE END-SEARCH END-START END-STRING END-SUBTRACT " +
-    "END-UNSTRING END-WRITE END-XML ENTER ENTRY " +
-    "ENVIRONMENT EOP EQUAL EQUALS ERASE " +
-    "ERROR ESI EVALUATE EVERY EXCEEDS " +
-    "EXCEPTION EXCLUSIVE EXIT EXTEND EXTERNAL " +
-    "EXTERNALLY-DESCRIBED-KEY FD FETCH FILE FILE-CONTROL " +
-    "FILE-STREAM FILES FILLER FINAL FIND " +
-    "FINISH FIRST FOOTING FOR FOREGROUND-COLOR " +
-    "FOREGROUND-COLOUR FORMAT FREE FROM FULL " +
-    "FUNCTION GENERATE GET GIVING GLOBAL " +
-    "GO GOBACK GREATER GROUP HEADING " +
-    "HIGH-VALUE HIGH-VALUES HIGHLIGHT I-O I-O-CONTROL " +
-    "ID IDENTIFICATION IF IN INDEX " +
-    "INDEX-1 INDEX-2 INDEX-3 INDEX-4 INDEX-5 " +
-    "INDEX-6 INDEX-7 INDEX-8 INDEX-9 INDEXED " +
-    "INDIC INDICATE INDICATOR INDICATORS INITIAL " +
-    "INITIALIZE INITIATE INPUT INPUT-OUTPUT INSPECT " +
-    "INSTALLATION INTO INVALID INVOKE IS " +
-    "JUST JUSTIFIED KANJI KEEP KEY " +
-    "LABEL LAST LD LEADING LEFT " +
-    "LEFT-JUSTIFY LENGTH LENGTH-CHECK LESS LIBRARY " +
-    "LIKE LIMIT LIMITS LINAGE LINAGE-COUNTER " +
-    "LINE LINE-COUNTER LINES LINKAGE LOCAL-STORAGE " +
-    "LOCALE LOCALLY LOCK " +
-    "MEMBER MEMORY MERGE MESSAGE METACLASS " +
-    "MODE MODIFIED MODIFY MODULES MOVE " +
-    "MULTIPLE MULTIPLY NATIONAL NATIVE NEGATIVE " +
-    "NEXT NO NO-ECHO NONE NOT " +
-    "NULL NULL-KEY-MAP NULL-MAP NULLS NUMBER " +
-    "NUMERIC NUMERIC-EDITED OBJECT OBJECT-COMPUTER OCCURS " +
-    "OF OFF OMITTED ON ONLY " +
-    "OPEN OPTIONAL OR ORDER ORGANIZATION " +
-    "OTHER OUTPUT OVERFLOW OWNER PACKED-DECIMAL " +
-    "PADDING PAGE PAGE-COUNTER PARSE PERFORM " +
-    "PF PH PIC PICTURE PLUS " +
-    "POINTER POSITION POSITIVE PREFIX PRESENT " +
-    "PRINTING PRIOR PROCEDURE PROCEDURE-POINTER PROCEDURES " +
-    "PROCEED PROCESS PROCESSING PROGRAM PROGRAM-ID " +
-    "PROMPT PROTECTED PURGE QUEUE QUOTE " +
-    "QUOTES RANDOM RD READ READY " +
-    "REALM RECEIVE RECONNECT RECORD RECORD-NAME " +
-    "RECORDS RECURSIVE REDEFINES REEL REFERENCE " +
-    "REFERENCE-MONITOR REFERENCES RELATION RELATIVE RELEASE " +
-    "REMAINDER REMOVAL RENAMES REPEATED REPLACE " +
-    "REPLACING REPORT REPORTING REPORTS REPOSITORY " +
-    "REQUIRED RERUN RESERVE RESET RETAINING " +
-    "RETRIEVAL RETURN RETURN-CODE RETURNING REVERSE-VIDEO " +
-    "REVERSED REWIND REWRITE RF RH " +
-    "RIGHT RIGHT-JUSTIFY ROLLBACK ROLLING ROUNDED " +
-    "RUN SAME SCREEN SD SEARCH " +
-    "SECTION SECURE SECURITY SEGMENT SEGMENT-LIMIT " +
-    "SELECT SEND SENTENCE SEPARATE SEQUENCE " +
-    "SEQUENTIAL SET SHARED SIGN SIZE " +
-    "SKIP1 SKIP2 SKIP3 SORT SORT-MERGE " +
-    "SORT-RETURN SOURCE SOURCE-COMPUTER SPACE-FILL " +
-    "SPECIAL-NAMES STANDARD STANDARD-1 STANDARD-2 " +
-    "START STARTING STATUS STOP STORE " +
-    "STRING SUB-QUEUE-1 SUB-QUEUE-2 SUB-QUEUE-3 SUB-SCHEMA " +
-    "SUBFILE SUBSTITUTE SUBTRACT SUM SUPPRESS " +
-    "SYMBOLIC SYNC SYNCHRONIZED SYSIN SYSOUT " +
-    "TABLE TALLYING TAPE TENANT TERMINAL " +
-    "TERMINATE TEST TEXT THAN THEN " +
-    "THROUGH THRU TIME TIMES TITLE " +
-    "TO TOP TRAILING TRAILING-SIGN TRANSACTION " +
-    "TYPE TYPEDEF UNDERLINE UNEQUAL UNIT " +
-    "UNSTRING UNTIL UP UPDATE UPON " +
-    "USAGE USAGE-MODE USE USING VALID " +
-    "VALIDATE VALUE VALUES VARYING VLR " +
-    "WAIT WHEN WHEN-COMPILED WITH WITHIN " +
-    "WORDS WORKING-STORAGE WRITE XML XML-CODE " +
-    "XML-EVENT XML-NTEXT XML-TEXT ZERO ZERO-FILL " );
-
-var builtins = makeKeywords("- * ** / + < <= = > >= ");
-var tests = {
-  digit: /\d/,
-  digit_or_colon: /[\d:]/,
-  hex: /[0-9a-f]/i,
-  sign: /[+-]/,
-  exponent: /e/i,
-  symbol: /[\w*+\-]/
-};
-function isNumber(ch, stream){
-  // hex
-  if ( ch === '0' && stream.eat(/x/i) ) {
-    stream.eatWhile(tests.hex);
-    return true;
-  }
-  // leading sign
-  if ( ( ch == '+' || ch == '-' ) && ( tests.digit.test(stream.peek()) ) ) {
-    stream.eat(tests.sign);
-    ch = stream.next();
-  }
-  if ( tests.digit.test(ch) ) {
-    stream.eat(ch);
-    stream.eatWhile(tests.digit);
-    if ( '.' == stream.peek()) {
-      stream.eat('.');
-      stream.eatWhile(tests.digit);
-    }
-    if ( stream.eat(tests.exponent) ) {
-      stream.eat(tests.sign);
-      stream.eatWhile(tests.digit);
-    }
-    return true;
-  }
-  return false;
-}
-const cobol = {
-  name: "cobol",
-  startState: function () {
-    return {
-      indentStack: null,
-      indentation: 0,
-      mode: false
-    };
-  },
-  token: function (stream, state) {
-    if (state.indentStack == null && stream.sol()) {
-      // update indentation, but only if indentStack is empty
-      state.indentation = 6 ; //stream.indentation();
-    }
-    // skip spaces
-    if (stream.eatSpace()) {
-      return null;
-    }
-    var returnType = null;
-    switch(state.mode){
-    case "string": // multi-line string parsing mode
-      var next = false;
-      while ((next = stream.next()) != null) {
-        if ((next == "\"" || next == "\'") && !stream.match(/['"]/, false)) {
-          state.mode = false;
-          break;
-        }
-      }
-      returnType = STRING; // continue on in string mode
-      break;
-    default: // default parsing mode
-      var ch = stream.next();
-      var col = stream.column();
-      if (col >= 0 && col <= 5) {
-        returnType = COBOLLINENUM;
-      } else if (col >= 72 && col <= 79) {
-        stream.skipToEnd();
-        returnType = MODTAG;
-      } else if (ch == "*" && col == 6) { // comment
-        stream.skipToEnd(); // rest of the line is a comment
-        returnType = COMMENT;
-      } else if (ch == "\"" || ch == "\'") {
-        state.mode = "string";
-        returnType = STRING;
-      } else if (ch == "'" && !( tests.digit_or_colon.test(stream.peek()) )) {
-        returnType = ATOM;
-      } else if (ch == ".") {
-        returnType = PERIOD;
-      } else if (isNumber(ch,stream)){
-        returnType = NUMBER;
-      } else {
-        if (stream.current().match(tests.symbol)) {
-          while (col < 71) {
-            if (stream.eat(tests.symbol) === undefined) {
-              break;
-            } else {
-              col++;
-            }
-          }
-        }
-        if (keywords && keywords.propertyIsEnumerable(stream.current().toUpperCase())) {
-          returnType = KEYWORD;
-        } else if (builtins && builtins.propertyIsEnumerable(stream.current().toUpperCase())) {
-          returnType = BUILTIN;
-        } else if (atoms && atoms.propertyIsEnumerable(stream.current().toUpperCase())) {
-          returnType = ATOM;
-        } else returnType = null;
-      }
-    }
-    return returnType;
-  },
-  indent: function (state) {
-    if (state.indentStack == null) return state.indentation;
-    return state.indentStack.indent;
-  }
-};
-
-export { cobol };