research-copilot 0.1.0

package/app/out/renderer/assets/clone-CsnzsYXQ.js

@@ -0,0 +1,8 @@
+import { b as baseClone } from "./graph-DpC13d95.js";
+var CLONE_SYMBOLS_FLAG = 4;
+function clone(value) {
+  return baseClone(value, CLONE_SYMBOLS_FLAG);
+}
+export {
+  clone as c
+};

package/app/out/renderer/assets/cmake-BGaNd9E7.js

@@ -0,0 +1,71 @@
+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();
+  if (ch === "$") {
+    if (stream.match(variable_regex)) {
+      return "variableName.special";
+    }
+    return "variable";
+  }
+  if (state.continueString) {
+    stream.backUp(1);
+    return tokenString(stream, state);
+  }
+  if (stream.match(/(\s+)?\w+\(/) || stream.match(/(\s+)?\w+\ \(/)) {
+    stream.backUp(1);
+    return "def";
+  }
+  if (ch == "#") {
+    stream.skipToEnd();
+    return "comment";
+  }
+  if (ch == "'" || ch == '"') {
+    state.pending = ch;
+    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/app/out/renderer/assets/cobol-4yqQntpt.js

@@ -0,0 +1,120 @@
+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) {
+  if (ch === "0" && stream.eat(/x/i)) {
+    stream.eatWhile(tests.hex);
+    return true;
+  }
+  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()) {
+      state.indentation = 6;
+    }
+    if (stream.eatSpace()) {
+      return null;
+    }
+    var returnType = null;
+    switch (state.mode) {
+      case "string":
+        var next = false;
+        while ((next = stream.next()) != null) {
+          if ((next == '"' || next == "'") && !stream.match(/['"]/, false)) {
+            state.mode = false;
+            break;
+          }
+        }
+        returnType = STRING;
+        break;
+      default:
+        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) {
+          stream.skipToEnd();
+          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) === void 0) {
+                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
+};

package/app/out/renderer/assets/coffeescript-D2dXvhEc.js

@@ -0,0 +1,308 @@
+var ERRORCLASS = "error";
+function wordRegexp(words) {
+  return new RegExp("^((" + words.join(")|(") + "))\\b");
+}
+var operators = /^(?:->|=>|\+[+=]?|-[\-=]?|\*[\*=]?|\/[\/=]?|[=!]=|<[><]?=?|>>?=?|%=?|&=?|\|=?|\^=?|\~|!|\?|(or|and|\|\||&&|\?)=)/;
+var delimiters = /^(?:[()\[\]{},:`=;]|\.\.?\.?)/;
+var identifiers = /^[_A-Za-z$][_A-Za-z$0-9]*/;
+var atProp = /^@[_A-Za-z$][_A-Za-z$0-9]*/;
+var wordOperators = wordRegexp([
+  "and",
+  "or",
+  "not",
+  "is",
+  "isnt",
+  "in",
+  "instanceof",
+  "typeof"
+]);
+var indentKeywords = [
+  "for",
+  "while",
+  "loop",
+  "if",
+  "unless",
+  "else",
+  "switch",
+  "try",
+  "catch",
+  "finally",
+  "class"
+];
+var commonKeywords = [
+  "break",
+  "by",
+  "continue",
+  "debugger",
+  "delete",
+  "do",
+  "in",
+  "of",
+  "new",
+  "return",
+  "then",
+  "this",
+  "@",
+  "throw",
+  "when",
+  "until",
+  "extends"
+];
+var keywords = wordRegexp(indentKeywords.concat(commonKeywords));
+indentKeywords = wordRegexp(indentKeywords);
+var stringPrefixes = /^('{3}|\"{3}|['\"])/;
+var regexPrefixes = /^(\/{3}|\/)/;
+var commonConstants = ["Infinity", "NaN", "undefined", "null", "true", "false", "on", "off", "yes", "no"];
+var constants = wordRegexp(commonConstants);
+function tokenBase(stream, state) {
+  if (stream.sol()) {
+    if (state.scope.align === null) state.scope.align = false;
+    var scopeOffset = state.scope.offset;
+    if (stream.eatSpace()) {
+      var lineOffset = stream.indentation();
+      if (lineOffset > scopeOffset && state.scope.type == "coffee") {
+        return "indent";
+      } else if (lineOffset < scopeOffset) {
+        return "dedent";
+      }
+      return null;
+    } else {
+      if (scopeOffset > 0) {
+        dedent(stream, state);
+      }
+    }
+  }
+  if (stream.eatSpace()) {
+    return null;
+  }
+  var ch = stream.peek();
+  if (stream.match("####")) {
+    stream.skipToEnd();
+    return "comment";
+  }
+  if (stream.match("###")) {
+    state.tokenize = longComment;
+    return state.tokenize(stream, state);
+  }
+  if (ch === "#") {
+    stream.skipToEnd();
+    return "comment";
+  }
+  if (stream.match(/^-?[0-9\.]/, false)) {
+    var floatLiteral = false;
+    if (stream.match(/^-?\d*\.\d+(e[\+\-]?\d+)?/i)) {
+      floatLiteral = true;
+    }
+    if (stream.match(/^-?\d+\.\d*/)) {
+      floatLiteral = true;
+    }
+    if (stream.match(/^-?\.\d+/)) {
+      floatLiteral = true;
+    }
+    if (floatLiteral) {
+      if (stream.peek() == ".") {
+        stream.backUp(1);
+      }
+      return "number";
+    }
+    var intLiteral = false;
+    if (stream.match(/^-?0x[0-9a-f]+/i)) {
+      intLiteral = true;
+    }
+    if (stream.match(/^-?[1-9]\d*(e[\+\-]?\d+)?/)) {
+      intLiteral = true;
+    }
+    if (stream.match(/^-?0(?![\dx])/i)) {
+      intLiteral = true;
+    }
+    if (intLiteral) {
+      return "number";
+    }
+  }
+  if (stream.match(stringPrefixes)) {
+    state.tokenize = tokenFactory(stream.current(), false, "string");
+    return state.tokenize(stream, state);
+  }
+  if (stream.match(regexPrefixes)) {
+    if (stream.current() != "/" || stream.match(/^.*\//, false)) {
+      state.tokenize = tokenFactory(stream.current(), true, "string.special");
+      return state.tokenize(stream, state);
+    } else {
+      stream.backUp(1);
+    }
+  }
+  if (stream.match(operators) || stream.match(wordOperators)) {
+    return "operator";
+  }
+  if (stream.match(delimiters)) {
+    return "punctuation";
+  }
+  if (stream.match(constants)) {
+    return "atom";
+  }
+  if (stream.match(atProp) || state.prop && stream.match(identifiers)) {
+    return "property";
+  }
+  if (stream.match(keywords)) {
+    return "keyword";
+  }
+  if (stream.match(identifiers)) {
+    return "variable";
+  }
+  stream.next();
+  return ERRORCLASS;
+}
+function tokenFactory(delimiter, singleline, outclass) {
+  return function(stream, state) {
+    while (!stream.eol()) {
+      stream.eatWhile(/[^'"\/\\]/);
+      if (stream.eat("\\")) {
+        stream.next();
+        if (singleline && stream.eol()) {
+          return outclass;
+        }
+      } else if (stream.match(delimiter)) {
+        state.tokenize = tokenBase;
+        return outclass;
+      } else {
+        stream.eat(/['"\/]/);
+      }
+    }
+    if (singleline) {
+      state.tokenize = tokenBase;
+    }
+    return outclass;
+  };
+}
+function longComment(stream, state) {
+  while (!stream.eol()) {
+    stream.eatWhile(/[^#]/);
+    if (stream.match("###")) {
+      state.tokenize = tokenBase;
+      break;
+    }
+    stream.eatWhile("#");
+  }
+  return "comment";
+}
+function indent(stream, state, type = "coffee") {
+  var offset = 0, align = false, alignOffset = null;
+  for (var scope = state.scope; scope; scope = scope.prev) {
+    if (scope.type === "coffee" || scope.type == "}") {
+      offset = scope.offset + stream.indentUnit;
+      break;
+    }
+  }
+  if (type !== "coffee") {
+    align = null;
+    alignOffset = stream.column() + stream.current().length;
+  } else if (state.scope.align) {
+    state.scope.align = false;
+  }
+  state.scope = {
+    offset,
+    type,
+    prev: state.scope,
+    align,
+    alignOffset
+  };
+}
+function dedent(stream, state) {
+  if (!state.scope.prev) return;
+  if (state.scope.type === "coffee") {
+    var _indent = stream.indentation();
+    var matched = false;
+    for (var scope = state.scope; scope; scope = scope.prev) {
+      if (_indent === scope.offset) {
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      return true;
+    }
+    while (state.scope.prev && state.scope.offset !== _indent) {
+      state.scope = state.scope.prev;
+    }
+    return false;
+  } else {
+    state.scope = state.scope.prev;
+    return false;
+  }
+}
+function tokenLexer(stream, state) {
+  var style = state.tokenize(stream, state);
+  var current = stream.current();
+  if (current === "return") {
+    state.dedent = true;
+  }
+  if ((current === "->" || current === "=>") && stream.eol() || style === "indent") {
+    indent(stream, state);
+  }
+  var delimiter_index = "[({".indexOf(current);
+  if (delimiter_index !== -1) {
+    indent(stream, state, "])}".slice(delimiter_index, delimiter_index + 1));
+  }
+  if (indentKeywords.exec(current)) {
+    indent(stream, state);
+  }
+  if (current == "then") {
+    dedent(stream, state);
+  }
+  if (style === "dedent") {
+    if (dedent(stream, state)) {
+      return ERRORCLASS;
+    }
+  }
+  delimiter_index = "])}".indexOf(current);
+  if (delimiter_index !== -1) {
+    while (state.scope.type == "coffee" && state.scope.prev)
+      state.scope = state.scope.prev;
+    if (state.scope.type == current)
+      state.scope = state.scope.prev;
+  }
+  if (state.dedent && stream.eol()) {
+    if (state.scope.type == "coffee" && state.scope.prev)
+      state.scope = state.scope.prev;
+    state.dedent = false;
+  }
+  return style == "indent" || style == "dedent" ? null : style;
+}
+const coffeeScript = {
+  name: "coffeescript",
+  startState: function() {
+    return {
+      tokenize: tokenBase,
+      scope: { offset: 0, type: "coffee", prev: null, align: false },
+      prop: false,
+      dedent: 0
+    };
+  },
+  token: function(stream, state) {
+    var fillAlign = state.scope.align === null && state.scope;
+    if (fillAlign && stream.sol()) fillAlign.align = false;
+    var style = tokenLexer(stream, state);
+    if (style && style != "comment") {
+      if (fillAlign) fillAlign.align = true;
+      state.prop = style == "punctuation" && stream.current() == ".";
+    }
+    return style;
+  },
+  indent: function(state, text) {
+    if (state.tokenize != tokenBase) return 0;
+    var scope = state.scope;
+    var closer = text && "])}".indexOf(text.charAt(0)) > -1;
+    if (closer) while (scope.type == "coffee" && scope.prev) scope = scope.prev;
+    var closes = closer && scope.type === text.charAt(0);
+    if (scope.align)
+      return scope.alignOffset - (closes ? 1 : 0);
+    else
+      return (closes ? scope.prev : scope).offset;
+  },
+  languageData: {
+    commentTokens: { line: "#" }
+  }
+};
+export {
+  coffeeScript
+};

package/app/out/renderer/assets/commonlisp-CF_VNHQR.js

@@ -0,0 +1,130 @@
+var specialForm = /^(block|let*|return-from|catch|load-time-value|setq|eval-when|locally|symbol-macrolet|flet|macrolet|tagbody|function|multiple-value-call|the|go|multiple-value-prog1|throw|if|progn|unwind-protect|labels|progv|let|quote)$/;
+var assumeBody = /^with|^def|^do|^prog|case$|^cond$|bind$|when$|unless$/;
+var numLiteral = /^(?:[+\-]?(?:\d+|\d*\.\d+)(?:[efd][+\-]?\d+)?|[+\-]?\d+(?:\/[+\-]?\d+)?|#b[+\-]?[01]+|#o[+\-]?[0-7]+|#x[+\-]?[\da-f]+)/;
+var symbol = /[^\s'`,@()\[\]";]/;
+var type;
+function readSym(stream) {
+  var ch;
+  while (ch = stream.next()) {
+    if (ch == "\\") stream.next();
+    else if (!symbol.test(ch)) {
+      stream.backUp(1);
+      break;
+    }
+  }
+  return stream.current();
+}
+function base(stream, state) {
+  if (stream.eatSpace()) {
+    type = "ws";
+    return null;
+  }
+  if (stream.match(numLiteral)) return "number";
+  var ch = stream.next();
+  if (ch == "\\") ch = stream.next();
+  if (ch == '"') return (state.tokenize = inString)(stream, state);
+  else if (ch == "(") {
+    type = "open";
+    return "bracket";
+  } else if (ch == ")") {
+    type = "close";
+    return "bracket";
+  } else if (ch == ";") {
+    stream.skipToEnd();
+    type = "ws";
+    return "comment";
+  } else if (/['`,@]/.test(ch)) return null;
+  else if (ch == "|") {
+    if (stream.skipTo("|")) {
+      stream.next();
+      return "variableName";
+    } else {
+      stream.skipToEnd();
+      return "error";
+    }
+  } else if (ch == "#") {
+    var ch = stream.next();
+    if (ch == "(") {
+      type = "open";
+      return "bracket";
+    } else if (/[+\-=\.']/.test(ch)) return null;
+    else if (/\d/.test(ch) && stream.match(/^\d*#/)) return null;
+    else if (ch == "|") return (state.tokenize = inComment)(stream, state);
+    else if (ch == ":") {
+      readSym(stream);
+      return "meta";
+    } else if (ch == "\\") {
+      stream.next();
+      readSym(stream);
+      return "string.special";
+    } else return "error";
+  } else {
+    var name = readSym(stream);
+    if (name == ".") return null;
+    type = "symbol";
+    if (name == "nil" || name == "t" || name.charAt(0) == ":") return "atom";
+    if (state.lastType == "open" && (specialForm.test(name) || assumeBody.test(name))) return "keyword";
+    if (name.charAt(0) == "&") return "variableName.special";
+    return "variableName";
+  }
+}
+function inString(stream, state) {
+  var escaped = false, next;
+  while (next = stream.next()) {
+    if (next == '"' && !escaped) {
+      state.tokenize = base;
+      break;
+    }
+    escaped = !escaped && next == "\\";
+  }
+  return "string";
+}
+function inComment(stream, state) {
+  var next, last;
+  while (next = stream.next()) {
+    if (next == "#" && last == "|") {
+      state.tokenize = base;
+      break;
+    }
+    last = next;
+  }
+  type = "ws";
+  return "comment";
+}
+const commonLisp = {
+  name: "commonlisp",
+  startState: function() {
+    return { ctx: { prev: null, start: 0, indentTo: 0 }, lastType: null, tokenize: base };
+  },
+  token: function(stream, state) {
+    if (stream.sol() && typeof state.ctx.indentTo != "number")
+      state.ctx.indentTo = state.ctx.start + 1;
+    type = null;
+    var style = state.tokenize(stream, state);
+    if (type != "ws") {
+      if (state.ctx.indentTo == null) {
+        if (type == "symbol" && assumeBody.test(stream.current()))
+          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.lastType = type;
+    }
+    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: {
+    commentTokens: { line: ";;", block: { open: "#|", close: "|#" } },
+    closeBrackets: { brackets: ["(", "[", "{", '"'] }
+  }
+};
+export {
+  commonLisp
+};