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

/***/ 875:
/***/ (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), __webpack_require__(865));else if (true) // AMD
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(266), __webpack_require__(865)], __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("sass", function (config) {
    var cssMode = CodeMirror.mimeModes["text/css"];
    var propertyKeywords = cssMode.propertyKeywords || {},
        colorKeywords = cssMode.colorKeywords || {},
        valueKeywords = cssMode.valueKeywords || {},
        fontProperties = cssMode.fontProperties || {};

    function tokenRegexp(words) {
      return new RegExp("^" + words.join("|"));
    }

    var keywords = ["true", "false", "null", "auto"];
    var keywordsRegexp = new RegExp("^" + keywords.join("|"));
    var operators = ["\\(", "\\)", "=", ">", "<", "==", ">=", "<=", "\\+", "-", "\\!=", "/", "\\*", "%", "and", "or", "not", ";", "\\{", "\\}", ":"];
    var opRegexp = tokenRegexp(operators);
    var pseudoElementsRegexp = /^::?[a-zA-Z_][\w\-]*/;
    var word;

    function isEndLine(stream) {
      return !stream.peek() || stream.match(/\s+$/, false);
    }

    function urlTokens(stream, state) {
      var ch = stream.peek();

      if (ch === ")") {
        stream.next();
        state.tokenizer = tokenBase;
        return "operator";
      } else if (ch === "(") {
        stream.next();
        stream.eatSpace();
        return "operator";
      } else if (ch === "'" || ch === '"') {
        state.tokenizer = buildStringTokenizer(stream.next());
        return "string";
      } else {
        state.tokenizer = buildStringTokenizer(")", false);
        return "string";
      }
    }

    function comment(indentation, multiLine) {
      return function (stream, state) {
        if (stream.sol() && stream.indentation() <= indentation) {
          state.tokenizer = tokenBase;
          return tokenBase(stream, state);
        }

        if (multiLine && stream.skipTo("*/")) {
          stream.next();
          stream.next();
          state.tokenizer = tokenBase;
        } else {
          stream.skipToEnd();
        }

        return "comment";
      };
    }

    function buildStringTokenizer(quote, greedy) {
      if (greedy == null) {
        greedy = true;
      }

      function stringTokenizer(stream, state) {
        var nextChar = stream.next();
        var peekChar = stream.peek();
        var previousChar = stream.string.charAt(stream.pos - 2);
        var endingString = nextChar !== "\\" && peekChar === quote || nextChar === quote && previousChar !== "\\";

        if (endingString) {
          if (nextChar !== quote && greedy) {
            stream.next();
          }

          if (isEndLine(stream)) {
            state.cursorHalf = 0;
          }

          state.tokenizer = tokenBase;
          return "string";
        } else if (nextChar === "#" && peekChar === "{") {
          state.tokenizer = buildInterpolationTokenizer(stringTokenizer);
          stream.next();
          return "operator";
        } else {
          return "string";
        }
      }

      return stringTokenizer;
    }

    function buildInterpolationTokenizer(currentTokenizer) {
      return function (stream, state) {
        if (stream.peek() === "}") {
          stream.next();
          state.tokenizer = currentTokenizer;
          return "operator";
        } else {
          return tokenBase(stream, state);
        }
      };
    }

    function indent(state) {
      if (state.indentCount == 0) {
        state.indentCount++;
        var lastScopeOffset = state.scopes[0].offset;
        var currentOffset = lastScopeOffset + config.indentUnit;
        state.scopes.unshift({
          offset: currentOffset
        });
      }
    }

    function dedent(state) {
      if (state.scopes.length == 1) return;
      state.scopes.shift();
    }

    function tokenBase(stream, state) {
      var ch = stream.peek(); // Comment

      if (stream.match("/*")) {
        state.tokenizer = comment(stream.indentation(), true);
        return state.tokenizer(stream, state);
      }

      if (stream.match("//")) {
        state.tokenizer = comment(stream.indentation(), false);
        return state.tokenizer(stream, state);
      } // Interpolation


      if (stream.match("#{")) {
        state.tokenizer = buildInterpolationTokenizer(tokenBase);
        return "operator";
      } // Strings


      if (ch === '"' || ch === "'") {
        stream.next();
        state.tokenizer = buildStringTokenizer(ch);
        return "string";
      }

      if (!state.cursorHalf) {
        // state.cursorHalf === 0
        // first half i.e. before : for key-value pairs
        // including selectors
        if (ch === "-") {
          if (stream.match(/^-\w+-/)) {
            return "meta";
          }
        }

        if (ch === ".") {
          stream.next();

          if (stream.match(/^[\w-]+/)) {
            indent(state);
            return "qualifier";
          } else if (stream.peek() === "#") {
            indent(state);
            return "tag";
          }
        }

        if (ch === "#") {
          stream.next(); // ID selectors

          if (stream.match(/^[\w-]+/)) {
            indent(state);
            return "builtin";
          }

          if (stream.peek() === "#") {
            indent(state);
            return "tag";
          }
        } // Variables


        if (ch === "$") {
          stream.next();
          stream.eatWhile(/[\w-]/);
          return "variable-2";
        } // Numbers


        if (stream.match(/^-?[0-9\.]+/)) return "number"; // Units

        if (stream.match(/^(px|em|in)\b/)) return "unit";
        if (stream.match(keywordsRegexp)) return "keyword";

        if (stream.match(/^url/) && stream.peek() === "(") {
          state.tokenizer = urlTokens;
          return "atom";
        }

        if (ch === "=") {
          // Match shortcut mixin definition
          if (stream.match(/^=[\w-]+/)) {
            indent(state);
            return "meta";
          }
        }

        if (ch === "+") {
          // Match shortcut mixin definition
          if (stream.match(/^\+[\w-]+/)) {
            return "variable-3";
          }
        }

        if (ch === "@") {
          if (stream.match(/@extend/)) {
            if (!stream.match(/\s*[\w]/)) dedent(state);
          }
        } // Indent Directives


        if (stream.match(/^@(else if|if|media|else|for|each|while|mixin|function)/)) {
          indent(state);
          return "def";
        } // Other Directives


        if (ch === "@") {
          stream.next();
          stream.eatWhile(/[\w-]/);
          return "def";
        }

        if (stream.eatWhile(/[\w-]/)) {
          if (stream.match(/ *: *[\w-\+\$#!\("']/, false)) {
            word = stream.current().toLowerCase();
            var prop = state.prevProp + "-" + word;

            if (propertyKeywords.hasOwnProperty(prop)) {
              return "property";
            } else if (propertyKeywords.hasOwnProperty(word)) {
              state.prevProp = word;
              return "property";
            } else if (fontProperties.hasOwnProperty(word)) {
              return "property";
            }

            return "tag";
          } else if (stream.match(/ *:/, false)) {
            indent(state);
            state.cursorHalf = 1;
            state.prevProp = stream.current().toLowerCase();
            return "property";
          } else if (stream.match(/ *,/, false)) {
            return "tag";
          } else {
            indent(state);
            return "tag";
          }
        }

        if (ch === ":") {
          if (stream.match(pseudoElementsRegexp)) {
            // could be a pseudo-element
            return "variable-3";
          }

          stream.next();
          state.cursorHalf = 1;
          return "operator";
        }
      } // cursorHalf===0 ends here
      else {
          if (ch === "#") {
            stream.next(); // Hex numbers

            if (stream.match(/[0-9a-fA-F]{6}|[0-9a-fA-F]{3}/)) {
              if (isEndLine(stream)) {
                state.cursorHalf = 0;
              }

              return "number";
            }
          } // Numbers


          if (stream.match(/^-?[0-9\.]+/)) {
            if (isEndLine(stream)) {
              state.cursorHalf = 0;
            }

            return "number";
          } // Units


          if (stream.match(/^(px|em|in)\b/)) {
            if (isEndLine(stream)) {
              state.cursorHalf = 0;
            }

            return "unit";
          }

          if (stream.match(keywordsRegexp)) {
            if (isEndLine(stream)) {
              state.cursorHalf = 0;
            }

            return "keyword";
          }

          if (stream.match(/^url/) && stream.peek() === "(") {
            state.tokenizer = urlTokens;

            if (isEndLine(stream)) {
              state.cursorHalf = 0;
            }

            return "atom";
          } // Variables


          if (ch === "$") {
            stream.next();
            stream.eatWhile(/[\w-]/);

            if (isEndLine(stream)) {
              state.cursorHalf = 0;
            }

            return "variable-2";
          } // bang character for !important, !default, etc.


          if (ch === "!") {
            stream.next();
            state.cursorHalf = 0;
            return stream.match(/^[\w]+/) ? "keyword" : "operator";
          }

          if (stream.match(opRegexp)) {
            if (isEndLine(stream)) {
              state.cursorHalf = 0;
            }

            return "operator";
          } // attributes


          if (stream.eatWhile(/[\w-]/)) {
            if (isEndLine(stream)) {
              state.cursorHalf = 0;
            }

            word = stream.current().toLowerCase();

            if (valueKeywords.hasOwnProperty(word)) {
              return "atom";
            } else if (colorKeywords.hasOwnProperty(word)) {
              return "keyword";
            } else if (propertyKeywords.hasOwnProperty(word)) {
              state.prevProp = stream.current().toLowerCase();
              return "property";
            } else {
              return "tag";
            }
          } //stream.eatSpace();


          if (isEndLine(stream)) {
            state.cursorHalf = 0;
            return null;
          }
        } // else ends here


      if (stream.match(opRegexp)) return "operator"; // If we haven't returned by now, we move 1 character
      // and return an error

      stream.next();
      return null;
    }

    function tokenLexer(stream, state) {
      if (stream.sol()) state.indentCount = 0;
      var style = state.tokenizer(stream, state);
      var current = stream.current();

      if (current === "@return" || current === "}") {
        dedent(state);
      }

      if (style !== null) {
        var startOfToken = stream.pos - current.length;
        var withCurrentIndent = startOfToken + config.indentUnit * state.indentCount;
        var newScopes = [];

        for (var i = 0; i < state.scopes.length; i++) {
          var scope = state.scopes[i];
          if (scope.offset <= withCurrentIndent) newScopes.push(scope);
        }

        state.scopes = newScopes;
      }

      return style;
    }

    return {
      startState: function startState() {
        return {
          tokenizer: tokenBase,
          scopes: [{
            offset: 0,
            type: "sass"
          }],
          indentCount: 0,
          cursorHalf: 0,
          // cursor half tells us if cursor lies after (1)
          // or before (0) colon (well... more or less)
          definedVars: [],
          definedMixins: []
        };
      },
      token: function token(stream, state) {
        var style = tokenLexer(stream, state);
        state.lastToken = {
          style: style,
          content: stream.current()
        };
        return style;
      },
      indent: function indent(state) {
        return state.scopes[0].offset;
      }
    };
  }, "css");
  CodeMirror.defineMIME("text/x-sass", "sass");
});
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(102)(module)))

/***/ })

}]);