(this["webpackJsonpPlugin"] = this["webpackJsonpPlugin"] || []).push([[76],{

/***/ 934:
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE
(function (mod) {
  if (( false ? undefined : _typeof(exports)) == "object" && ( false ? undefined : _typeof(module)) == "object") // CommonJS
    mod(__webpack_require__(266));else if (true) // AMD
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(266)], __WEBPACK_AMD_DEFINE_FACTORY__ = (mod),
				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));else // Plain browser env
    {}
})(function (CodeMirror) {
  "use strict";

  CodeMirror.defineMode("oz", function (conf) {
    function wordRegexp(words) {
      return new RegExp("^((" + words.join(")|(") + "))\\b");
    }

    var singleOperators = /[\^@!\|<>#~\.\*\-\+\\/,=]/;
    var doubleOperators = /(<-)|(:=)|(=<)|(>=)|(<=)|(<:)|(>:)|(=:)|(\\=)|(\\=:)|(!!)|(==)|(::)/;
    var tripleOperators = /(:::)|(\.\.\.)|(=<:)|(>=:)/;
    var middle = ["in", "then", "else", "of", "elseof", "elsecase", "elseif", "catch", "finally", "with", "require", "prepare", "import", "export", "define", "do"];
    var end = ["end"];
    var atoms = wordRegexp(["true", "false", "nil", "unit"]);
    var commonKeywords = wordRegexp(["andthen", "at", "attr", "declare", "feat", "from", "lex", "mod", "div", "mode", "orelse", "parser", "prod", "prop", "scanner", "self", "syn", "token"]);
    var openingKeywords = wordRegexp(["local", "proc", "fun", "case", "class", "if", "cond", "or", "dis", "choice", "not", "thread", "try", "raise", "lock", "for", "suchthat", "meth", "functor"]);
    var middleKeywords = wordRegexp(middle);
    var endKeywords = wordRegexp(end); // Tokenizers

    function tokenBase(stream, state) {
      if (stream.eatSpace()) {
        return null;
      } // Brackets


      if (stream.match(/[{}]/)) {
        return "bracket";
      } // Special [] keyword


      if (stream.match(/(\[])/)) {
        return "keyword";
      } // Operators


      if (stream.match(tripleOperators) || stream.match(doubleOperators)) {
        return "operator";
      } // Atoms


      if (stream.match(atoms)) {
        return 'atom';
      } // Opening keywords


      var matched = stream.match(openingKeywords);

      if (matched) {
        if (!state.doInCurrentLine) state.currentIndent++;else state.doInCurrentLine = false; // Special matching for signatures

        if (matched[0] == "proc" || matched[0] == "fun") state.tokenize = tokenFunProc;else if (matched[0] == "class") state.tokenize = tokenClass;else if (matched[0] == "meth") state.tokenize = tokenMeth;
        return 'keyword';
      } // Middle and other keywords


      if (stream.match(middleKeywords) || stream.match(commonKeywords)) {
        return "keyword";
      } // End keywords


      if (stream.match(endKeywords)) {
        state.currentIndent--;
        return 'keyword';
      } // Eat the next char for next comparisons


      var ch = stream.next(); // Strings

      if (ch == '"' || ch == "'") {
        state.tokenize = tokenString(ch);
        return state.tokenize(stream, state);
      } // Numbers


      if (/[~\d]/.test(ch)) {
        if (ch == "~") {
          if (!/^[0-9]/.test(stream.peek())) return null;else if (stream.next() == "0" && stream.match(/^[xX][0-9a-fA-F]+/) || stream.match(/^[0-9]*(\.[0-9]+)?([eE][~+]?[0-9]+)?/)) return "number";
        }

        if (ch == "0" && stream.match(/^[xX][0-9a-fA-F]+/) || stream.match(/^[0-9]*(\.[0-9]+)?([eE][~+]?[0-9]+)?/)) return "number";
        return null;
      } // Comments


      if (ch == "%") {
        stream.skipToEnd();
        return 'comment';
      } else if (ch == "/") {
        if (stream.eat("*")) {
          state.tokenize = tokenComment;
          return tokenComment(stream, state);
        }
      } // Single operators


      if (singleOperators.test(ch)) {
        return "operator";
      } // If nothing match, we skip the entire alphanumerical block


      stream.eatWhile(/\w/);
      return "variable";
    }

    function tokenClass(stream, state) {
      if (stream.eatSpace()) {
        return null;
      }

      stream.match(/([A-Z][A-Za-z0-9_]*)|(`.+`)/);
      state.tokenize = tokenBase;
      return "variable-3";
    }

    function tokenMeth(stream, state) {
      if (stream.eatSpace()) {
        return null;
      }

      stream.match(/([a-zA-Z][A-Za-z0-9_]*)|(`.+`)/);
      state.tokenize = tokenBase;
      return "def";
    }

    function tokenFunProc(stream, state) {
      if (stream.eatSpace()) {
        return null;
      }

      if (!state.hasPassedFirstStage && stream.eat("{")) {
        state.hasPassedFirstStage = true;
        return "bracket";
      } else if (state.hasPassedFirstStage) {
        stream.match(/([A-Z][A-Za-z0-9_]*)|(`.+`)|\$/);
        state.hasPassedFirstStage = false;
        state.tokenize = tokenBase;
        return "def";
      } else {
        state.tokenize = tokenBase;
        return null;
      }
    }

    function tokenComment(stream, state) {
      var maybeEnd = false,
          ch;

      while (ch = stream.next()) {
        if (ch == "/" && maybeEnd) {
          state.tokenize = tokenBase;
          break;
        }

        maybeEnd = ch == "*";
      }

      return "comment";
    }

    function tokenString(quote) {
      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 "string";
      };
    }

    function buildElectricInputRegEx() {
      // Reindentation should occur on [] or on a match of any of
      // the block closing keywords, at the end of a line.
      var allClosings = middle.concat(end);
      return new RegExp("[\\[\\]]|(" + allClosings.join("|") + ")$");
    }

    return {
      startState: function startState() {
        return {
          tokenize: tokenBase,
          currentIndent: 0,
          doInCurrentLine: false,
          hasPassedFirstStage: false
        };
      },
      token: function token(stream, state) {
        if (stream.sol()) state.doInCurrentLine = 0;
        return state.tokenize(stream, state);
      },
      indent: function indent(state, textAfter) {
        var trueText = textAfter.replace(/^\s+|\s+$/g, '');
        if (trueText.match(endKeywords) || trueText.match(middleKeywords) || trueText.match(/(\[])/)) return conf.indentUnit * (state.currentIndent - 1);
        if (state.currentIndent < 0) return 0;
        return state.currentIndent * conf.indentUnit;
      },
      fold: "indent",
      electricInput: buildElectricInputRegEx(),
      lineComment: "%",
      blockCommentStart: "/*",
      blockCommentEnd: "*/"
    };
  });
  CodeMirror.defineMIME("text/x-oz", "oz");
});
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(102)(module)))

/***/ })

}]);