/*! markdown-render (as markdownRender; ==UserScript==) 0.0.231 https://github.com/rivy/js-user.markdown-render#readme @license MIT */
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["markdownRender"] = factory();
	else
		root["markdownRender"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 106);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Attributes_js_1 = __webpack_require__(26);

var Node_js_1 = __webpack_require__(233);

exports.TEXCLASS = {
  ORD: 0,
  OP: 1,
  BIN: 2,
  REL: 3,
  OPEN: 4,
  CLOSE: 5,
  PUNCT: 6,
  INNER: 7,
  VCENTER: 8,
  NONE: -1
};
exports.TEXCLASSNAMES = ['ORD', 'OP', 'BIN', 'REL', 'OPEN', 'CLOSE', 'PUNCT', 'INNER', 'VCENTER'];
var TEXSPACELENGTH = ['', 'thinmathspace', 'mediummathspace', 'thickmathspace'];
var TEXSPACE = [[0, -1, 2, 3, 0, 0, 0, 1], [-1, -1, 0, 3, 0, 0, 0, 1], [2, 2, 0, 0, 2, 0, 0, 2], [3, 3, 0, 0, 3, 0, 0, 3], [0, 0, 0, 0, 0, 0, 0, 0], [0, -1, 2, 3, 0, 0, 0, 1], [1, 1, 0, 1, 1, 1, 1, 1], [1, -1, 2, 3, 1, 0, 1, 1]];
exports.indentAttributes = ['indentalign', 'indentalignfirst', 'indentshift', 'indentshiftfirst'];

var AbstractMmlNode = function (_super) {
  __extends(AbstractMmlNode, _super);

  function AbstractMmlNode(factory, attributes, children) {
    if (attributes === void 0) {
      attributes = {};
    }

    if (children === void 0) {
      children = [];
    }

    var _this = _super.call(this, factory) || this;

    _this.texClass = null;
    _this.prevClass = null;
    _this.prevLevel = null;

    if (_this.arity < 0) {
      _this.childNodes = [factory.create('inferredMrow')];
      _this.childNodes[0].parent = _this;
    }

    _this.setChildren(children);

    _this.attributes = new Attributes_js_1.Attributes(factory.getNodeClass(_this.kind).defaults, factory.getNodeClass('math').defaults);

    _this.attributes.setList(attributes);

    return _this;
  }

  Object.defineProperty(AbstractMmlNode.prototype, "isToken", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlNode.prototype, "isEmbellished", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlNode.prototype, "isSpacelike", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlNode.prototype, "linebreakContainer", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlNode.prototype, "hasNewLine", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlNode.prototype, "arity", {
    get: function () {
      return Infinity;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlNode.prototype, "isInferred", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlNode.prototype, "Parent", {
    get: function () {
      var parent = this.parent;

      while (parent && parent.notParent) {
        parent = parent.Parent;
      }

      return parent;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlNode.prototype, "notParent", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });

  AbstractMmlNode.prototype.setChildren = function (children) {
    if (this.arity < 0) {
      return this.childNodes[0].setChildren(children);
    }

    return _super.prototype.setChildren.call(this, children);
  };

  AbstractMmlNode.prototype.appendChild = function (child) {
    if (this.arity < 0) {
      this.childNodes[0].appendChild(child);
      return child;
    }

    return _super.prototype.appendChild.call(this, child);
  };

  AbstractMmlNode.prototype.replaceChild = function (newChild, oldChild) {
    if (this.arity < 0) {
      this.childNodes[0].replaceChild(newChild, oldChild);
      return newChild;
    }

    return _super.prototype.replaceChild.call(this, newChild, oldChild);
  };

  AbstractMmlNode.prototype.core = function () {
    return this;
  };

  AbstractMmlNode.prototype.coreMO = function () {
    return this;
  };

  AbstractMmlNode.prototype.coreIndex = function () {
    return 0;
  };

  AbstractMmlNode.prototype.childPosition = function () {
    var child = this;
    var parent = child.parent;

    while (parent && parent.notParent) {
      child = parent;
      parent = parent.parent;
    }

    if (parent) {
      var i = 0;

      try {
        for (var _a = __values(parent.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var node = _b.value;

          if (node === child) {
            return i;
          }

          i++;
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }
    }

    return null;

    var e_1, _c;
  };

  AbstractMmlNode.prototype.setTeXclass = function (prev) {
    this.getPrevClass(prev);
    return this.texClass != null ? this : prev;
  };

  AbstractMmlNode.prototype.updateTeXclass = function (core) {
    if (core) {
      this.prevClass = core.prevClass;
      this.prevLevel = core.prevLevel;
      core.prevClass = core.prevLevel = null;
      this.texClass = core.texClass;
    }
  };

  AbstractMmlNode.prototype.getPrevClass = function (prev) {
    if (prev) {
      this.prevClass = prev.texClass;
      this.prevLevel = prev.attributes.get('scriptlevel');
    }
  };

  AbstractMmlNode.prototype.texSpacing = function () {
    var prevClass = this.prevClass != null ? this.prevClass : exports.TEXCLASS.NONE;
    var texClass = this.texClass || exports.TEXCLASS.ORD;

    if (prevClass === exports.TEXCLASS.NONE || texClass === exports.TEXCLASS.NONE) {
      return '';
    }

    if (prevClass === exports.TEXCLASS.VCENTER) {
      prevClass = exports.TEXCLASS.ORD;
    }

    if (texClass === exports.TEXCLASS.VCENTER) {
      texClass = exports.TEXCLASS.ORD;
    }

    var space = TEXSPACE[prevClass][texClass];

    if (this.prevLevel > 0 && this.attributes.get('scriptlevel') > 0 && space >= 0) {
      return '';
    }

    return TEXSPACELENGTH[Math.abs(space)];
  };

  AbstractMmlNode.prototype.hasSpacingAttributes = function () {
    return this.isEmbellished && this.coreMO().hasSpacingAttributes();
  };

  AbstractMmlNode.prototype.setInheritedAttributes = function (attributes, display, level, prime) {
    if (attributes === void 0) {
      attributes = {};
    }

    if (display === void 0) {
      display = false;
    }

    if (level === void 0) {
      level = 0;
    }

    if (prime === void 0) {
      prime = false;
    }

    var defaults = this.attributes.getAllDefaults();

    try {
      for (var _a = __values(Object.keys(attributes)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var key = _b.value;

        if (defaults.hasOwnProperty(key)) {
          var _c = __read(attributes[key], 2),
              node = _c[0],
              value = _c[1];

          var noinherit = (AbstractMmlNode.noInherit[node] || {})[this.kind] || {};

          if (!noinherit[key]) {
            this.attributes.setInherited(key, value);
          }
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var displaystyle = this.attributes.getExplicit('displaystyle');

    if (displaystyle === undefined) {
      this.attributes.setInherited('displaystyle', display);
    }

    var scriptlevel = this.attributes.getExplicit('scriptlevel');

    if (scriptlevel === undefined) {
      this.attributes.setInherited('scriptlevel', level);
    }

    if (prime) {
      this.setProperty('texprimestyle', prime);
    }

    var arity = this.arity;

    if (arity >= 0 && arity !== Infinity && (arity === 1 && this.childNodes.length === 0 || arity !== 1 && this.childNodes.length !== arity)) {
      if (arity < this.childNodes.length) {
        this.childNodes = this.childNodes.slice(0, arity);
      } else {
        while (this.childNodes.length < arity) {
          this.appendChild(this.factory.create('mrow'));
        }
      }
    }

    this.setChildInheritedAttributes(attributes, display, level, prime);

    var e_2, _d;
  };

  AbstractMmlNode.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        child.setInheritedAttributes(attributes, display, level, prime);
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    var e_3, _c;
  };

  AbstractMmlNode.prototype.addInheritedAttributes = function (current, attributes) {
    var updated = __assign({}, current);

    try {
      for (var _a = __values(Object.keys(attributes)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var name_1 = _b.value;

        if (name_1 !== 'displaystyle' && name_1 !== 'scriptlevel' && name_1 !== 'style') {
          updated[name_1] = [this.kind, attributes[name_1]];
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    return updated;

    var e_4, _c;
  };

  AbstractMmlNode.prototype.inheritAttributesFrom = function (node) {
    var attributes = node.attributes;
    var display = attributes.get('displaystyle');
    var scriptlevel = attributes.get('scriptlevel');
    var defaults = !attributes.isSet('mathsize') ? {} : {
      mathsize: ['math', attributes.get('mathsize')]
    };
    var prime = node.getProperty('texprimestyle') || false;
    this.setInheritedAttributes(defaults, display, scriptlevel, prime);
  };

  AbstractMmlNode.prototype.verifyTree = function (options) {
    if (options === void 0) {
      options = null;
    }

    if (options === null) {
      return;
    }

    this.verifyAttributes(options);
    var arity = this.arity;

    if (options['checkArity']) {
      if (arity >= 0 && arity !== Infinity && (arity === 1 && this.childNodes.length === 0 || arity !== 1 && this.childNodes.length !== arity)) {
        this.mError('Wrong number of children for "' + this.kind + '" node', options, true);
      }
    }

    this.verifyChildren(options);
  };

  AbstractMmlNode.prototype.verifyAttributes = function (options) {
    if (options['checkAttributes']) {
      var attributes = this.attributes;
      var bad = [];

      try {
        for (var _a = __values(attributes.getExplicitNames()), _b = _a.next(); !_b.done; _b = _a.next()) {
          var name_2 = _b.value;

          if (name_2.substr(0, 5) !== 'data-' && attributes.getDefault(name_2) === undefined && !name_2.match(/^(?:class|style|id|(?:xlink:)?href)$/)) {
            bad.push(name_2);
          }
        }
      } catch (e_5_1) {
        e_5 = {
          error: e_5_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_5) throw e_5.error;
        }
      }

      if (bad.length) {
        this.mError('Unknown attributes for ' + this.kind + ' node: ' + bad.join(', '), options);
      }
    }

    var e_5, _c;
  };

  AbstractMmlNode.prototype.verifyChildren = function (options) {
    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        child.verifyTree(options);
      }
    } catch (e_6_1) {
      e_6 = {
        error: e_6_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_6) throw e_6.error;
      }
    }

    var e_6, _c;
  };

  AbstractMmlNode.prototype.mError = function (message, options, short) {
    if (short === void 0) {
      short = false;
    }

    if (this.parent && this.parent.isKind('merror')) {
      return;
    }

    var merror = this.factory.create('merror');

    if (options['fullErrors'] || short) {
      var mtext = this.factory.create('mtext');
      var text = this.factory.create('text');
      text.setText(options['fullErrors'] ? message : this.kind);
      mtext.appendChild(text);
      merror.appendChild(mtext);
      this.parent.replaceChild(merror, this);
    } else {
      this.parent.replaceChild(merror, this);
      merror.appendChild(this);
    }

    return merror;
  };

  return AbstractMmlNode;
}(Node_js_1.AbstractNode);

AbstractMmlNode.defaults = {
  mathbackground: Attributes_js_1.INHERIT,
  mathcolor: Attributes_js_1.INHERIT,
  mathsize: Attributes_js_1.INHERIT,
  dir: Attributes_js_1.INHERIT
};
AbstractMmlNode.noInherit = {
  mstyle: {
    mpadded: {
      width: true,
      height: true,
      depth: true,
      lspace: true,
      voffset: true
    },
    mtable: {
      width: true,
      height: true,
      depth: true,
      align: true
    }
  },
  maligngroup: {
    mrow: {
      groupalign: true
    },
    mtable: {
      groupalign: true
    }
  }
};
AbstractMmlNode.verifyDefaults = {
  checkArity: true,
  checkAttributes: false,
  fullErrors: false,
  fixMmultiscripts: true,
  fixMtables: true
};
exports.AbstractMmlNode = AbstractMmlNode;

var AbstractMmlTokenNode = function (_super) {
  __extends(AbstractMmlTokenNode, _super);

  function AbstractMmlTokenNode() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(AbstractMmlTokenNode.prototype, "isToken", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  AbstractMmlTokenNode.prototype.getText = function () {
    var text = '';

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (child instanceof TextNode) {
          text += child.getText();
        }
      }
    } catch (e_7_1) {
      e_7 = {
        error: e_7_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_7) throw e_7.error;
      }
    }

    return text;

    var e_7, _c;
  };

  AbstractMmlTokenNode.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (child instanceof AbstractMmlNode) {
          child.setInheritedAttributes(attributes, display, level, prime);
        }
      }
    } catch (e_8_1) {
      e_8 = {
        error: e_8_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_8) throw e_8.error;
      }
    }

    var e_8, _c;
  };

  AbstractMmlTokenNode.prototype.walkTree = function (func, data) {
    func(this, data);

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (child instanceof AbstractMmlNode) {
          child.walkTree(func, data);
        }
      }
    } catch (e_9_1) {
      e_9 = {
        error: e_9_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_9) throw e_9.error;
      }
    }

    return data;

    var e_9, _c;
  };

  return AbstractMmlTokenNode;
}(AbstractMmlNode);

AbstractMmlTokenNode.defaults = __assign({}, AbstractMmlNode.defaults, {
  mathvariant: 'normal',
  mathsize: Attributes_js_1.INHERIT
});
exports.AbstractMmlTokenNode = AbstractMmlTokenNode;

var AbstractMmlLayoutNode = function (_super) {
  __extends(AbstractMmlLayoutNode, _super);

  function AbstractMmlLayoutNode() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(AbstractMmlLayoutNode.prototype, "isSpacelike", {
    get: function () {
      return this.childNodes[0].isSpacelike;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlLayoutNode.prototype, "isEmbellished", {
    get: function () {
      return this.childNodes[0].isEmbellished;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlLayoutNode.prototype, "arity", {
    get: function () {
      return -1;
    },
    enumerable: true,
    configurable: true
  });

  AbstractMmlLayoutNode.prototype.core = function () {
    return this.childNodes[0];
  };

  AbstractMmlLayoutNode.prototype.coreMO = function () {
    return this.childNodes[0].coreMO();
  };

  AbstractMmlLayoutNode.prototype.setTeXclass = function (prev) {
    prev = this.childNodes[0].setTeXclass(prev);
    this.updateTeXclass(this.childNodes[0]);
    return prev;
  };

  return AbstractMmlLayoutNode;
}(AbstractMmlNode);

AbstractMmlLayoutNode.defaults = AbstractMmlNode.defaults;
exports.AbstractMmlLayoutNode = AbstractMmlLayoutNode;

var AbstractMmlBaseNode = function (_super) {
  __extends(AbstractMmlBaseNode, _super);

  function AbstractMmlBaseNode() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(AbstractMmlBaseNode.prototype, "isEmbellished", {
    get: function () {
      return this.childNodes[0].isEmbellished;
    },
    enumerable: true,
    configurable: true
  });

  AbstractMmlBaseNode.prototype.core = function () {
    return this.childNodes[0];
  };

  AbstractMmlBaseNode.prototype.coreMO = function () {
    return this.childNodes[0].coreMO();
  };

  AbstractMmlBaseNode.prototype.setTeXclass = function (prev) {
    this.getPrevClass(prev);
    this.texClass = exports.TEXCLASS.NONE;
    var base = this.childNodes[0];

    if (base) {
      if (this.isEmbellished || base.isKind('mi')) {
        prev = base.setTeXclass(prev);
        this.updateTeXclass(this.core());
      } else {
        base.setTeXclass(null);
        prev = this;
      }
    } else {
      prev = this;
    }

    try {
      for (var _a = __values(this.childNodes.slice(1)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (child) {
          child.setTeXclass(null);
        }
      }
    } catch (e_10_1) {
      e_10 = {
        error: e_10_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_10) throw e_10.error;
      }
    }

    return prev;

    var e_10, _c;
  };

  return AbstractMmlBaseNode;
}(AbstractMmlNode);

AbstractMmlBaseNode.defaults = AbstractMmlNode.defaults;
exports.AbstractMmlBaseNode = AbstractMmlBaseNode;

var AbstractMmlEmptyNode = function (_super) {
  __extends(AbstractMmlEmptyNode, _super);

  function AbstractMmlEmptyNode() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(AbstractMmlEmptyNode.prototype, "isToken", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "isEmbellished", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "isSpacelike", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "linebreakContainer", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "hasNewLine", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "arity", {
    get: function () {
      return 0;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "isInferred", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "notParent", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "Parent", {
    get: function () {
      return this.parent;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "texClass", {
    get: function () {
      return exports.TEXCLASS.NONE;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "prevClass", {
    get: function () {
      return exports.TEXCLASS.NONE;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractMmlEmptyNode.prototype, "prevLevel", {
    get: function () {
      return 0;
    },
    enumerable: true,
    configurable: true
  });

  AbstractMmlEmptyNode.prototype.hasSpacingAttributes = function () {
    return false;
  };

  Object.defineProperty(AbstractMmlEmptyNode.prototype, "attributes", {
    get: function () {
      return null;
    },
    enumerable: true,
    configurable: true
  });

  AbstractMmlEmptyNode.prototype.core = function () {
    return this;
  };

  AbstractMmlEmptyNode.prototype.coreMO = function () {
    return this;
  };

  AbstractMmlEmptyNode.prototype.coreIndex = function () {
    return 0;
  };

  AbstractMmlEmptyNode.prototype.childPosition = function () {
    return 0;
  };

  AbstractMmlEmptyNode.prototype.setTeXclass = function (prev) {
    return prev;
  };

  AbstractMmlEmptyNode.prototype.texSpacing = function () {
    return '';
  };

  AbstractMmlEmptyNode.prototype.setInheritedAttributes = function (attributes, display, level, prime) {};

  AbstractMmlEmptyNode.prototype.inheritAttributesFrom = function (node) {};

  AbstractMmlEmptyNode.prototype.verifyTree = function (options) {};

  AbstractMmlEmptyNode.prototype.mError = function (message, options, short) {
    if (short === void 0) {
      short = false;
    }
  };

  return AbstractMmlEmptyNode;
}(Node_js_1.AbstractEmptyNode);

exports.AbstractMmlEmptyNode = AbstractMmlEmptyNode;

var TextNode = function (_super) {
  __extends(TextNode, _super);

  function TextNode() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.text = '';
    return _this;
  }

  Object.defineProperty(TextNode.prototype, "kind", {
    get: function () {
      return 'text';
    },
    enumerable: true,
    configurable: true
  });

  TextNode.prototype.getText = function () {
    return this.text;
  };

  TextNode.prototype.setText = function (text) {
    this.text = text;
    return this;
  };

  TextNode.prototype.toString = function () {
    return this.text;
  };

  return TextNode;
}(AbstractMmlEmptyNode);

exports.TextNode = TextNode;

var XMLNode = function (_super) {
  __extends(XMLNode, _super);

  function XMLNode() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.xml = null;
    return _this;
  }

  Object.defineProperty(XMLNode.prototype, "kind", {
    get: function () {
      return 'XML';
    },
    enumerable: true,
    configurable: true
  });

  XMLNode.prototype.getXML = function () {
    return this.xml;
  };

  XMLNode.prototype.setXML = function (xml) {
    this.xml = xml;
    return this;
  };

  XMLNode.prototype.toString = function () {
    return 'XML data';
  };

  return XMLNode;
}(AbstractMmlEmptyNode);

exports.XMLNode = XMLNode;

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Utilities
//


function _class(obj) {
  return Object.prototype.toString.call(obj);
}

function isString(obj) {
  return _class(obj) === '[object String]';
}

var _hasOwnProperty = Object.prototype.hasOwnProperty;

function has(object, key) {
  return _hasOwnProperty.call(object, key);
} // Merge objects
//


function assign(obj
/*from1, from2, from3, ...*/
) {
  var sources = Array.prototype.slice.call(arguments, 1);
  sources.forEach(function (source) {
    if (!source) {
      return;
    }

    if (typeof source !== 'object') {
      throw new TypeError(source + 'must be object');
    }

    Object.keys(source).forEach(function (key) {
      obj[key] = source[key];
    });
  });
  return obj;
} // Remove element from array and put another array at those position.
// Useful for some operations with tokens


function arrayReplaceAt(src, pos, newElements) {
  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
} ////////////////////////////////////////////////////////////////////////////////


function isValidEntityCode(c) {
  /*eslint no-bitwise:0*/
  // broken sequence
  if (c >= 0xD800 && c <= 0xDFFF) {
    return false;
  } // never used


  if (c >= 0xFDD0 && c <= 0xFDEF) {
    return false;
  }

  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) {
    return false;
  } // control codes


  if (c >= 0x00 && c <= 0x08) {
    return false;
  }

  if (c === 0x0B) {
    return false;
  }

  if (c >= 0x0E && c <= 0x1F) {
    return false;
  }

  if (c >= 0x7F && c <= 0x9F) {
    return false;
  } // out of range


  if (c > 0x10FFFF) {
    return false;
  }

  return true;
}

function fromCodePoint(c) {
  /*eslint no-bitwise:0*/
  if (c > 0xffff) {
    c -= 0x10000;
    var surrogate1 = 0xd800 + (c >> 10),
        surrogate2 = 0xdc00 + (c & 0x3ff);
    return String.fromCharCode(surrogate1, surrogate2);
  }

  return String.fromCharCode(c);
}

var UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])/g;
var ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
var UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');
var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;

var entities = __webpack_require__(62);

function replaceEntityPattern(match, name) {
  var code = 0;

  if (has(entities, name)) {
    return entities[name];
  }

  if (name.charCodeAt(0) === 0x23
  /* # */
  && DIGITAL_ENTITY_TEST_RE.test(name)) {
    code = name[1].toLowerCase() === 'x' ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);

    if (isValidEntityCode(code)) {
      return fromCodePoint(code);
    }
  }

  return match;
}
/*function replaceEntities(str) {
  if (str.indexOf('&') < 0) { return str; }

  return str.replace(ENTITY_RE, replaceEntityPattern);
}*/


function unescapeMd(str) {
  if (str.indexOf('\\') < 0) {
    return str;
  }

  return str.replace(UNESCAPE_MD_RE, '$1');
}

function unescapeAll(str) {
  if (str.indexOf('\\') < 0 && str.indexOf('&') < 0) {
    return str;
  }

  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {
    if (escaped) {
      return escaped;
    }

    return replaceEntityPattern(match, entity);
  });
} ////////////////////////////////////////////////////////////////////////////////


var HTML_ESCAPE_TEST_RE = /[&<>"]/;
var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
var HTML_REPLACEMENTS = {
  '&': '&amp;',
  '<': '&lt;',
  '>': '&gt;',
  '"': '&quot;'
};

function replaceUnsafeChar(ch) {
  return HTML_REPLACEMENTS[ch];
}

function escapeHtml(str) {
  if (HTML_ESCAPE_TEST_RE.test(str)) {
    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
  }

  return str;
} ////////////////////////////////////////////////////////////////////////////////


var REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;

function escapeRE(str) {
  return str.replace(REGEXP_ESCAPE_RE, '\\$&');
} ////////////////////////////////////////////////////////////////////////////////


function isSpace(code) {
  switch (code) {
    case 0x09:
    case 0x20:
      return true;
  }

  return false;
} // Zs (unicode class) || [\t\f\v\r\n]


function isWhiteSpace(code) {
  if (code >= 0x2000 && code <= 0x200A) {
    return true;
  }

  switch (code) {
    case 0x09: // \t

    case 0x0A: // \n

    case 0x0B: // \v

    case 0x0C: // \f

    case 0x0D: // \r

    case 0x20:
    case 0xA0:
    case 0x1680:
    case 0x202F:
    case 0x205F:
    case 0x3000:
      return true;
  }

  return false;
} ////////////////////////////////////////////////////////////////////////////////

/*eslint-disable max-len*/


var UNICODE_PUNCT_RE = __webpack_require__(39); // Currently without astral characters support.


function isPunctChar(ch) {
  return UNICODE_PUNCT_RE.test(ch);
} // Markdown ASCII punctuation characters.
//
// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
// http://spec.commonmark.org/0.15/#ascii-punctuation-character
//
// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
//


function isMdAsciiPunct(ch) {
  switch (ch) {
    case 0x21
    /* ! */
    :
    case 0x22
    /* " */
    :
    case 0x23
    /* # */
    :
    case 0x24
    /* $ */
    :
    case 0x25
    /* % */
    :
    case 0x26
    /* & */
    :
    case 0x27
    /* ' */
    :
    case 0x28
    /* ( */
    :
    case 0x29
    /* ) */
    :
    case 0x2A
    /* * */
    :
    case 0x2B
    /* + */
    :
    case 0x2C
    /* , */
    :
    case 0x2D
    /* - */
    :
    case 0x2E
    /* . */
    :
    case 0x2F
    /* / */
    :
    case 0x3A
    /* : */
    :
    case 0x3B
    /* ; */
    :
    case 0x3C
    /* < */
    :
    case 0x3D
    /* = */
    :
    case 0x3E
    /* > */
    :
    case 0x3F
    /* ? */
    :
    case 0x40
    /* @ */
    :
    case 0x5B
    /* [ */
    :
    case 0x5C
    /* \ */
    :
    case 0x5D
    /* ] */
    :
    case 0x5E
    /* ^ */
    :
    case 0x5F
    /* _ */
    :
    case 0x60
    /* ` */
    :
    case 0x7B
    /* { */
    :
    case 0x7C
    /* | */
    :
    case 0x7D
    /* } */
    :
    case 0x7E
    /* ~ */
    :
      return true;

    default:
      return false;
  }
} // Hepler to unify [reference labels].
//


function normalizeReference(str) {
  // Trim and collapse whitespace
  //
  str = str.trim().replace(/\s+/g, ' '); // In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug
  // fixed in v12 (couldn't find any details).
  //
  // So treat this one as a special case
  // (remove this when node v10 is no longer supported).
  //

  if ('ẞ'.toLowerCase() === 'Ṿ') {
    str = str.replace(/ẞ/g, 'ß');
  } // .toLowerCase().toUpperCase() should get rid of all differences
  // between letter variants.
  //
  // Simple .toLowerCase() doesn't normalize 125 code points correctly,
  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:
  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently
  // uppercased versions).
  //
  // Here's an example showing how it happens. Lets take greek letter omega:
  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)
  //
  // Unicode entries:
  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;
  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398
  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398
  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;
  //
  // Case-insensitive comparison should treat all of them as equivalent.
  //
  // But .toLowerCase() doesn't change ϑ (it's already lowercase),
  // and .toUpperCase() doesn't change ϴ (already uppercase).
  //
  // Applying first lower then upper case normalizes any character:
  // '\u0398\u03f4\u03b8\u03d1'.toLowerCase().toUpperCase() === '\u0398\u0398\u0398\u0398'
  //
  // Note: this is equivalent to unicode case folding; unicode normalization
  // is a different step that is not required here.
  //
  // Final result should be uppercased, because it's later stored in an object
  // (this avoid a conflict with Object.prototype members,
  // most notably, `__proto__`)
  //


  return str.toLowerCase().toUpperCase();
} ////////////////////////////////////////////////////////////////////////////////
// Re-export libraries commonly used in both markdown-it and its plugins,
// so plugins won't have to depend on them explicitly, which reduces their
// bundled size (e.g. a browser build).
//


exports.lib = {};
exports.lib.mdurl = __webpack_require__(63);
exports.lib.ucmicro = __webpack_require__(148);
exports.assign = assign;
exports.isString = isString;
exports.has = has;
exports.unescapeMd = unescapeMd;
exports.unescapeAll = unescapeAll;
exports.isValidEntityCode = isValidEntityCode;
exports.fromCodePoint = fromCodePoint; // exports.replaceEntities     = replaceEntities;

exports.escapeHtml = escapeHtml;
exports.arrayReplaceAt = arrayReplaceAt;
exports.isSpace = isSpace;
exports.isWhiteSpace = isWhiteSpace;
exports.isMdAsciiPunct = isMdAsciiPunct;
exports.isPunctChar = isPunctChar;
exports.escapeRE = escapeRE;
exports.normalizeReference = normalizeReference;

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

function __export(m) {
  for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}

Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(29);

var lengths_js_1 = __webpack_require__(22);

var Options_js_1 = __webpack_require__(10);

__export(__webpack_require__(29));

;
;

var CHTMLFontData = function (_super) {
  __extends(CHTMLFontData, _super);

  function CHTMLFontData(options) {
    if (options === void 0) {
      options = null;
    }

    var _this = _super.call(this) || this;

    _this.cssRoot = '';
    var CLASS = _this.constructor;
    _this.options = Options_js_1.userOptions(Options_js_1.defaultOptions({}, CLASS.OPTIONS), options);

    try {
      for (var _a = __values(Object.keys(CLASS.defaultVariantClasses)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var name_1 = _b.value;
        _this.variant[name_1].classes = CLASS.defaultVariantClasses[name_1];
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    return _this;

    var e_1, _c;
  }

  CHTMLFontData.prototype.adaptiveCSS = function (adapt) {
    this.options.adaptiveCSS = adapt;
  };

  CHTMLFontData.prototype.clearCache = function () {
    if (!this.options.adaptiveCSS) return;

    try {
      for (var _a = __values(Object.keys(this.delimiters)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var n = _b.value;
        this.delimiters[parseInt(n)].used = false;
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    try {
      for (var _d = __values(Object.keys(this.variant)), _e = _d.next(); !_e.done; _e = _d.next()) {
        var name_2 = _e.value;
        var chars = this.variant[name_2].chars;

        try {
          for (var _f = __values(Object.keys(chars)), _g = _f.next(); !_g.done; _g = _f.next()) {
            var n = _g.value;
            var options = chars[parseInt(n)][3];

            if (options) {
              options.used = false;
            }
          }
        } catch (e_3_1) {
          e_3 = {
            error: e_3_1
          };
        } finally {
          try {
            if (_g && !_g.done && (_h = _f.return)) _h.call(_f);
          } finally {
            if (e_3) throw e_3.error;
          }
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_e && !_e.done && (_j = _d.return)) _j.call(_d);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    var e_2, _c, e_4, _j, e_3, _h;
  };

  Object.defineProperty(CHTMLFontData.prototype, "styles", {
    get: function () {
      var CLASS = this.constructor;

      var styles = __assign({}, CLASS.defaultStyles);

      this.addFontURLs(styles, CLASS.defaultFonts, this.options.fontURL);

      try {
        for (var _a = __values(Object.keys(this.delimiters)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var n = _b.value;
          var N = parseInt(n);
          this.addDelimiterStyles(styles, N, this.delimiters[N]);
        }
      } catch (e_5_1) {
        e_5 = {
          error: e_5_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_5) throw e_5.error;
        }
      }

      this.addVariantChars(styles);
      return styles;

      var e_5, _c;
    },
    enumerable: true,
    configurable: true
  });

  CHTMLFontData.prototype.addVariantChars = function (styles) {
    var charUsed = new Map();

    try {
      for (var _a = __values(Object.keys(this.variant)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var name_3 = _b.value;
        var variant = this.variant[name_3];
        var vclass = name_3 === 'normal' ? '' : '.' + variant.classes.replace(/ /g, '.');

        try {
          for (var _c = __values(Object.keys(variant.chars)), _d = _c.next(); !_d.done; _d = _c.next()) {
            var n = _d.value;
            var N = parseInt(n);

            if (variant.chars[N].length === 4) {
              this.addCharStyles(styles, vclass, N, variant.chars[N], charUsed);
            }
          }
        } catch (e_6_1) {
          e_6 = {
            error: e_6_1
          };
        } finally {
          try {
            if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
          } finally {
            if (e_6) throw e_6.error;
          }
        }
      }
    } catch (e_7_1) {
      e_7 = {
        error: e_7_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
      } finally {
        if (e_7) throw e_7.error;
      }
    }

    var e_7, _f, e_6, _e;
  };

  CHTMLFontData.prototype.addFontURLs = function (styles, fonts, url) {
    try {
      for (var _a = __values(Object.keys(fonts)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var name_4 = _b.value;

        var font = __assign({}, fonts[name_4]);

        font.src = font.src.replace(/%%URL%%/, url);
        styles[name_4] = font;
      }
    } catch (e_8_1) {
      e_8 = {
        error: e_8_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_8) throw e_8.error;
      }
    }

    var e_8, _c;
  };

  CHTMLFontData.prototype.addDelimiterStyles = function (styles, n, data) {
    if (this.options.adaptiveCSS && !data.used) return;
    var c = this.charSelector(n);

    if (data.c && data.c !== n) {
      styles[this.cssRoot + '.mjx-stretched mjx-c' + c + '::before'] = {
        content: this.charContent(data.c)
      };
    }

    if (!data.stretch) return;

    if (data.dir === 1) {
      this.addDelimiterVStyles(styles, c, data);
    } else {
      this.addDelimiterHStyles(styles, c, data);
    }
  };

  CHTMLFontData.prototype.addDelimiterVStyles = function (styles, c, data) {
    var W = data.HDW[2];

    var _a = __read(data.stretch, 4),
        beg = _a[0],
        ext = _a[1],
        end = _a[2],
        mid = _a[3];

    var Hb = this.addDelimiterVPart(styles, c, W, 'beg', beg);
    this.addDelimiterVPart(styles, c, W, 'ext', ext);
    var He = this.addDelimiterVPart(styles, c, W, 'end', end);
    var css = {};
    var root = this.cssRoot;

    if (mid) {
      var Hm = this.addDelimiterVPart(styles, c, W, 'mid', mid);
      css.height = '50%';
      styles[root + 'mjx-stretchy-v' + c + ' > mjx-mid'] = {
        'margin-top': this.em(-Hm / 2),
        'margin-bottom': this.em(-Hm / 2)
      };
    }

    if (Hb) {
      css['border-top-width'] = this.em0(Hb - .03);
    }

    if (He) {
      css['border-bottom-width'] = this.em0(He - .03);
      styles[root + 'mjx-stretchy-v' + c + ' > mjx-end'] = {
        'margin-top': this.em(-He)
      };
    }

    if (Object.keys(css).length) {
      styles[root + 'mjx-stretchy-v' + c + ' > mjx-ext'] = css;
    }
  };

  CHTMLFontData.prototype.addDelimiterVPart = function (styles, c, W, part, n) {
    if (!n) return 0;
    var data = this.getDelimiterData(n);
    var dw = (W - data[2]) / 2;
    var css = {
      content: this.charContent(n)
    };

    if (part !== 'ext') {
      css.padding = this.padding(data, dw);
    } else if (dw) {
      css['padding-left'] = this.em0(dw);
    }

    styles[this.cssRoot + 'mjx-stretchy-v' + c + ' mjx-' + part + ' mjx-c::before'] = css;
    return data[0] + data[1];
  };

  CHTMLFontData.prototype.addDelimiterHStyles = function (styles, c, data) {
    var _a = __read(data.stretch, 4),
        beg = _a[0],
        ext = _a[1],
        end = _a[2],
        mid = _a[3];

    this.addDelimiterHPart(styles, c, 'beg', beg);
    this.addDelimiterHPart(styles, c, 'ext', ext, !(beg || end));
    this.addDelimiterHPart(styles, c, 'end', end);

    if (mid) {
      this.addDelimiterHPart(styles, c, 'mid', mid);
      styles[this.cssRoot + 'mjx-stretchy-h' + c + ' > mjx-ext'] = {
        width: '50%'
      };
    }
  };

  CHTMLFontData.prototype.addDelimiterHPart = function (styles, c, part, n, force) {
    if (force === void 0) {
      force = false;
    }

    if (!n) {
      return 0;
    }

    var data = this.getDelimiterData(n);
    var options = data[3];
    var css = {
      content: options && options.c ? '"' + options.c + '"' : this.charContent(n)
    };

    if (part !== 'ext' || force) {
      css.padding = this.padding(data, 0, -data[2]);
    }

    styles[this.cssRoot + 'mjx-stretchy-h' + c + ' mjx-' + part + ' mjx-c::before'] = css;
  };

  CHTMLFontData.prototype.addCharStyles = function (styles, vclass, n, data, charUsed) {
    var _a = __read(data, 4),
        h = _a[0],
        d = _a[1],
        w = _a[2],
        options = _a[3];

    if (this.options.adaptiveCSS && !options.used) return;
    var css = {};
    var selector = 'mjx-c' + this.charSelector(n);
    var root = this.cssRoot;
    css.padding = this.padding(data, 0, options.ic || 0);
    var content = options.c ? '"' + options.c + '"' : this.charContent(n);

    if (charUsed.get(n) !== content) {
      if (!charUsed.has(n) && !options.c) {
        styles[root + selector + '::before'] = {
          content: content
        };
        charUsed.set(n, content);
      } else {
        styles[root + vclass + ' ' + selector + '::before'] = {
          content: content
        };
      }
    }

    if (options.f !== undefined) {
      css['font-family'] = 'MJXZERO, MJXTEX' + (options.f ? '-' + options.f : '');
    }

    var char = (vclass ? vclass + ' ' : '') + selector;
    styles[root + char] = css;

    if (options.ic) {
      var _b = __read([root + 'mjx-', '[noIC]' + char + ':last-child'], 2),
          MJX = _b[0],
          noIC = _b[1];

      styles[MJX + 'mi' + noIC] = styles[MJX + 'mo' + noIC] = {
        'padding-right': this.em(w)
      };
    }
  };

  CHTMLFontData.prototype.getDelimiterData = function (n) {
    return this.getChar('-smallop', n);
  };

  CHTMLFontData.charOptions = function (font, n) {
    return _super.charOptions.call(this, font, n);
  };

  CHTMLFontData.prototype.em = function (n) {
    return lengths_js_1.em(n);
  };

  CHTMLFontData.prototype.em0 = function (n) {
    return lengths_js_1.em(Math.max(0, n));
  };

  CHTMLFontData.prototype.padding = function (_a, dw, ic) {
    var _b = __read(_a, 3),
        h = _b[0],
        d = _b[1],
        w = _b[2];

    if (dw === void 0) {
      dw = 0;
    }

    if (ic === void 0) {
      ic = 0;
    }

    return [h, w + ic, d, dw].map(this.em0).join(' ');
  };

  CHTMLFontData.prototype.charContent = function (n) {
    return '"' + (n >= 0x20 && n <= 0x7E && n !== 0x22 && n !== 0x27 && n !== 0x5C ? String.fromCharCode(n) : '\\' + n.toString(16).toUpperCase()) + '"';
  };

  CHTMLFontData.prototype.charSelector = function (n) {
    return '.mjx-c' + n.toString(16).toUpperCase();
  };

  return CHTMLFontData;
}(FontData_js_1.FontData);

CHTMLFontData.OPTIONS = {
  fontURL: 'mathjax3-ts/output/chtml/fonts/tex-woff-v2'
};
CHTMLFontData.defaultVariantClasses = {};
CHTMLFontData.defaultStyles = {
  'mjx-c::before': {
    display: 'inline-block',
    width: 0
  }
};
CHTMLFontData.defaultFonts = {
  '@font-face /* 0 */': {
    'font-family': 'MJXZERO',
    src: 'url("%%URL%%/MathJax_Zero.woff") format("woff")'
  }
};
exports.CHTMLFontData = CHTMLFontData;

function AddCSS(font, options) {
  try {
    for (var _a = __values(Object.keys(options)), _b = _a.next(); !_b.done; _b = _a.next()) {
      var c = _b.value;
      var n = parseInt(c);
      Object.assign(FontData_js_1.FontData.charOptions(font, n), options[n]);
    }
  } catch (e_9_1) {
    e_9 = {
      error: e_9_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_9) throw e_9.error;
    }
  }

  return font;

  var e_9, _c;
}

exports.AddCSS = AddCSS;

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var LENGTHS = __webpack_require__(22);

var Wrapper_js_1 = __webpack_require__(249);

var BBox_js_1 = __webpack_require__(75);

exports.FONTSIZE = {
  '70.7%': 's',
  '70%': 's',
  '50%': 'ss',
  '60%': 'Tn',
  '85%': 'sm',
  '120%': 'lg',
  '144%': 'Lg',
  '173%': 'LG',
  '207%': 'hg',
  '249%': 'HG'
};
exports.SPACE = (_a = {}, _a[LENGTHS.em(2 / 18)] = '1', _a[LENGTHS.em(3 / 18)] = '2', _a[LENGTHS.em(4 / 18)] = '3', _a[LENGTHS.em(5 / 18)] = '4', _a[LENGTHS.em(6 / 18)] = '5', _a);

var CHTMLWrapper = function (_super) {
  __extends(CHTMLWrapper, _super);

  function CHTMLWrapper() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.chtml = null;
    return _this;
  }

  CHTMLWrapper.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        child.toCHTML(chtml);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _c;
  };

  CHTMLWrapper.prototype.standardCHTMLnode = function (parent) {
    this.markUsed();
    var chtml = this.createCHTMLnode(parent);
    this.handleStyles();
    this.handleVariant();
    this.handleScale();
    this.handleColor();
    this.handleSpace();
    this.handleAttributes();
    this.handlePWidth();
    return chtml;
  };

  CHTMLWrapper.prototype.markUsed = function () {
    this.constructor.used = true;
  };

  CHTMLWrapper.prototype.createCHTMLnode = function (parent) {
    var href = this.node.attributes.get('href');

    if (href) {
      parent = this.adaptor.append(parent, this.html('a', {
        href: href
      }));
    }

    this.chtml = this.adaptor.append(parent, this.html('mjx-' + this.node.kind));
    return this.chtml;
  };

  CHTMLWrapper.prototype.handleStyles = function () {
    if (!this.styles) return;
    var styles = this.styles.cssText;

    if (styles) {
      this.adaptor.setAttribute(this.chtml, 'style', styles);
      var family = this.styles.get('font-family');

      if (family) {
        this.adaptor.setStyle(this.chtml, 'font-family', 'MJXZERO, ' + family);
      }
    }
  };

  CHTMLWrapper.prototype.handleVariant = function () {
    if (this.node.isToken && this.variant !== '-explicitFont') {
      this.adaptor.setAttribute(this.chtml, 'class', (this.font.getVariant(this.variant) || this.font.getVariant('normal')).classes);
    }
  };

  CHTMLWrapper.prototype.handleScale = function () {
    this.setScale(this.chtml, this.bbox.rscale);
  };

  CHTMLWrapper.prototype.setScale = function (chtml, rscale) {
    var scale = Math.abs(rscale - 1) < .001 ? 1 : rscale;

    if (chtml && scale !== 1) {
      var size = this.percent(scale);

      if (exports.FONTSIZE[size]) {
        this.adaptor.setAttribute(chtml, 'size', exports.FONTSIZE[size]);
      } else {
        this.adaptor.setStyle(chtml, 'fontSize', size);
      }
    }

    return chtml;
  };

  CHTMLWrapper.prototype.handleSpace = function () {
    try {
      for (var _a = __values([[this.bbox.L, 'space', 'marginLeft'], [this.bbox.R, 'rspace', 'marginRight']]), _b = _a.next(); !_b.done; _b = _a.next()) {
        var data = _b.value;

        var _c = __read(data, 3),
            dimen = _c[0],
            name_1 = _c[1],
            margin = _c[2];

        if (dimen) {
          var space = this.em(dimen);

          if (exports.SPACE[space]) {
            this.adaptor.setAttribute(this.chtml, name_1, exports.SPACE[space]);
          } else {
            this.adaptor.setStyle(this.chtml, margin, space);
          }
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_2, _d;
  };

  CHTMLWrapper.prototype.handleColor = function () {
    var attributes = this.node.attributes;
    var mathcolor = attributes.getExplicit('mathcolor');
    var color = attributes.getExplicit('color');
    var mathbackground = attributes.getExplicit('mathbackground');
    var background = attributes.getExplicit('background');

    if (mathcolor || color) {
      this.adaptor.setStyle(this.chtml, 'color', mathcolor || color);
    }

    if (mathbackground || background) {
      this.adaptor.setStyle(this.chtml, 'backgroundColor', mathbackground || background);
    }
  };

  CHTMLWrapper.prototype.handleAttributes = function () {
    var attributes = this.node.attributes;
    var defaults = attributes.getAllDefaults();
    var skip = CHTMLWrapper.skipAttributes;

    try {
      for (var _a = __values(attributes.getExplicitNames()), _b = _a.next(); !_b.done; _b = _a.next()) {
        var name_2 = _b.value;

        if (skip[name_2] === false || !(name_2 in defaults) && !skip[name_2] && !this.adaptor.hasAttribute(this.chtml, name_2)) {
          this.adaptor.setAttribute(this.chtml, name_2, attributes.getExplicit(name_2));
        }
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    if (attributes.get('class')) {
      this.adaptor.addClass(this.chtml, attributes.get('class'));
    }

    var e_3, _c;
  };

  CHTMLWrapper.prototype.handlePWidth = function () {
    if (this.bbox.pwidth) {
      if (this.bbox.pwidth === BBox_js_1.BBox.fullWidth) {
        this.adaptor.setAttribute(this.chtml, 'width', 'full');
      } else {
        this.adaptor.setStyle(this.chtml, 'width', this.bbox.pwidth);
      }
    }
  };

  CHTMLWrapper.prototype.setIndent = function (chtml, align, shift) {
    var adaptor = this.adaptor;

    if (align === 'center' || align === 'left') {
      var L = this.getBBox().L;
      adaptor.setStyle(chtml, 'margin-left', this.em(shift + L));
    }

    if (align === 'center' || align === 'right') {
      var R = this.getBBox().R;
      adaptor.setStyle(chtml, 'margin-right', this.em(-shift + R));
    }
  };

  CHTMLWrapper.prototype.drawBBox = function () {
    var _a = this.getBBox(),
        w = _a.w,
        h = _a.h,
        d = _a.d,
        R = _a.R;

    var box = this.html('mjx-box', {
      style: {
        opacity: .25,
        'margin-left': this.em(-w - R)
      }
    }, [this.html('mjx-box', {
      style: {
        height: this.em(h),
        width: this.em(w),
        'background-color': 'red'
      }
    }), this.html('mjx-box', {
      style: {
        height: this.em(d),
        width: this.em(w),
        'margin-left': this.em(-w),
        'vertical-align': this.em(-d),
        'background-color': 'green'
      }
    })]);
    var node = this.chtml || this.parent.chtml;
    var size = this.adaptor.getAttribute(node, 'size');

    if (size) {
      this.adaptor.setAttribute(box, 'size', size);
    }

    var fontsize = this.adaptor.getStyle(node, 'fontSize');

    if (fontsize) {
      this.adaptor.setStyle(box, 'fontSize', fontsize);
    }

    this.adaptor.append(this.adaptor.parent(node), box);
    this.adaptor.setStyle(node, 'backgroundColor', '#FFEE00');
  };

  CHTMLWrapper.prototype.html = function (type, def, content) {
    if (def === void 0) {
      def = {};
    }

    if (content === void 0) {
      content = [];
    }

    return this.jax.html(type, def, content);
  };

  CHTMLWrapper.prototype.text = function (text) {
    return this.jax.text(text);
  };

  CHTMLWrapper.prototype.createMo = function (text) {
    return _super.prototype.createMo.call(this, text);
  };

  CHTMLWrapper.prototype.coreMO = function () {
    return _super.prototype.coreMO.call(this);
  };

  CHTMLWrapper.prototype.char = function (n) {
    return this.font.charSelector(n).substr(1);
  };

  return CHTMLWrapper;
}(Wrapper_js_1.CommonWrapper);

CHTMLWrapper.kind = 'unknown';
CHTMLWrapper.autoStyle = true;
CHTMLWrapper.used = false;
exports.CHTMLWrapper = CHTMLWrapper;

var _a;

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var ParseMethods_js_1 = __webpack_require__(28);

var MapHandler_js_1 = __webpack_require__(17);

var Options_js_1 = __webpack_require__(10);

var sm = __webpack_require__(5);

var MapHandler_js_2 = __webpack_require__(17);

var FunctionList_js_1 = __webpack_require__(44);

var Configuration = function () {
  function Configuration(name, handler, fallback, items, tags, options, nodes, preprocessors, postprocessors, _a, _b) {
    if (handler === void 0) {
      handler = {};
    }

    if (fallback === void 0) {
      fallback = {};
    }

    if (items === void 0) {
      items = {};
    }

    if (tags === void 0) {
      tags = {};
    }

    if (options === void 0) {
      options = {};
    }

    if (nodes === void 0) {
      nodes = {};
    }

    if (preprocessors === void 0) {
      preprocessors = [];
    }

    if (postprocessors === void 0) {
      postprocessors = [];
    }

    var _c = __read(_a, 2),
        init = _c[0],
        priority = _c[1];

    var _d = __read(_b, 2),
        config = _d[0],
        configPriority = _d[1];

    this.name = name;
    this.handler = handler;
    this.fallback = fallback;
    this.items = items;
    this.tags = tags;
    this.options = options;
    this.nodes = nodes;
    this.preprocessors = preprocessors;
    this.postprocessors = postprocessors;
    this.initMethod = new FunctionList_js_1.FunctionList();
    this.configMethod = new FunctionList_js_1.FunctionList();

    if (init) {
      this.initMethod.add(init, priority || 0);
    }

    if (config) {
      this.configMethod.add(config, configPriority || priority || 0);
    }

    this.handler = Object.assign({
      character: [],
      delimiter: [],
      macro: [],
      environment: []
    }, handler);
    ConfigurationHandler.set(name, this);
  }

  Configuration.create = function (name, config) {
    if (config === void 0) {
      config = {};
    }

    return new Configuration(name, config.handler || {}, config.fallback || {}, config.items || {}, config.tags || {}, config.options || {}, config.nodes || {}, config.preprocessors || [], config.postprocessors || [], [config.init, config.priority], [config.config, config.configPriority]);
  };

  Configuration.empty = function () {
    return Configuration.create('empty');
  };

  ;

  Configuration.extension = function () {
    new sm.MacroMap(MapHandler_js_1.ExtensionMaps.NEW_MACRO, {}, {});
    new sm.DelimiterMap(MapHandler_js_1.ExtensionMaps.NEW_DELIMITER, ParseMethods_js_1.default.delimiter, {});
    new sm.CommandMap(MapHandler_js_1.ExtensionMaps.NEW_COMMAND, {}, {});
    new sm.EnvironmentMap(MapHandler_js_1.ExtensionMaps.NEW_ENVIRONMENT, ParseMethods_js_1.default.environment, {}, {});
    return Configuration.create('extension', {
      handler: {
        character: [],
        delimiter: [MapHandler_js_1.ExtensionMaps.NEW_DELIMITER],
        macro: [MapHandler_js_1.ExtensionMaps.NEW_DELIMITER, MapHandler_js_1.ExtensionMaps.NEW_COMMAND, MapHandler_js_1.ExtensionMaps.NEW_MACRO],
        environment: [MapHandler_js_1.ExtensionMaps.NEW_ENVIRONMENT]
      }
    });
  };

  ;

  Configuration.prototype.init = function (configuration) {
    this.initMethod.execute(configuration);
  };

  Configuration.prototype.config = function (configuration, jax) {
    this.configMethod.execute(configuration, jax);

    try {
      for (var _a = __values(this.preprocessors), _b = _a.next(); !_b.done; _b = _a.next()) {
        var pre = _b.value;
        typeof pre === 'function' ? jax.preFilters.add(pre) : jax.preFilters.add(pre[0], pre[1]);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    try {
      for (var _d = __values(this.postprocessors), _e = _d.next(); !_e.done; _e = _d.next()) {
        var post = _e.value;
        typeof post === 'function' ? jax.postFilters.add(post) : jax.postFilters.add(post[0], post[1]);
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_1, _c, e_2, _f;
  };

  Configuration.prototype.append = function (config) {
    var handlers = Object.keys(config.handler);

    try {
      for (var handlers_1 = __values(handlers), handlers_1_1 = handlers_1.next(); !handlers_1_1.done; handlers_1_1 = handlers_1.next()) {
        var key = handlers_1_1.value;

        try {
          for (var _a = __values(config.handler[key]), _b = _a.next(); !_b.done; _b = _a.next()) {
            var map = _b.value;
            this.handler[key].unshift(map);
          }
        } catch (e_3_1) {
          e_3 = {
            error: e_3_1
          };
        } finally {
          try {
            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
          } finally {
            if (e_3) throw e_3.error;
          }
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (handlers_1_1 && !handlers_1_1.done && (_d = handlers_1.return)) _d.call(handlers_1);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    Object.assign(this.fallback, config.fallback);
    Object.assign(this.items, config.items);
    Object.assign(this.tags, config.tags);
    Options_js_1.defaultOptions(this.options, config.options);
    Object.assign(this.nodes, config.nodes);

    try {
      for (var _e = __values(config.preprocessors), _f = _e.next(); !_f.done; _f = _e.next()) {
        var pre = _f.value;
        this.preprocessors.push(pre);
      }
    } catch (e_5_1) {
      e_5 = {
        error: e_5_1
      };
    } finally {
      try {
        if (_f && !_f.done && (_g = _e.return)) _g.call(_e);
      } finally {
        if (e_5) throw e_5.error;
      }
    }

    ;

    try {
      for (var _h = __values(config.postprocessors), _j = _h.next(); !_j.done; _j = _h.next()) {
        var post = _j.value;
        this.postprocessors.push(post);
      }
    } catch (e_6_1) {
      e_6 = {
        error: e_6_1
      };
    } finally {
      try {
        if (_j && !_j.done && (_k = _h.return)) _k.call(_h);
      } finally {
        if (e_6) throw e_6.error;
      }
    }

    ;

    try {
      for (var _l = __values(config.initMethod), _m = _l.next(); !_m.done; _m = _l.next()) {
        var init = _m.value;
        this.initMethod.add(init.item, init.priority);
      }
    } catch (e_7_1) {
      e_7 = {
        error: e_7_1
      };
    } finally {
      try {
        if (_m && !_m.done && (_o = _l.return)) _o.call(_l);
      } finally {
        if (e_7) throw e_7.error;
      }
    }

    ;

    try {
      for (var _p = __values(config.configMethod), _q = _p.next(); !_q.done; _q = _p.next()) {
        var init = _q.value;
        this.configMethod.add(init.item, init.priority);
      }
    } catch (e_8_1) {
      e_8 = {
        error: e_8_1
      };
    } finally {
      try {
        if (_q && !_q.done && (_r = _p.return)) _r.call(_p);
      } finally {
        if (e_8) throw e_8.error;
      }
    }

    ;

    var e_4, _d, e_3, _c, e_5, _g, e_6, _k, e_7, _o, e_8, _r;
  };

  Configuration.prototype.register = function (config, jax, options) {
    if (options === void 0) {
      options = {};
    }

    this.append(config);
    config.init(this);
    var parser = jax.parseOptions;
    parser.handlers = new MapHandler_js_2.SubHandlers(this);
    parser.nodeFactory.setCreators(config.nodes);

    try {
      for (var _a = __values(Object.keys(config.items)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var kind = _b.value;
        parser.itemFactory.setNodeClass(kind, config.items[kind]);
      }
    } catch (e_9_1) {
      e_9 = {
        error: e_9_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_9) throw e_9.error;
      }
    }

    Options_js_1.defaultOptions(parser.options, config.options);
    Options_js_1.userOptions(parser.options, options);
    config.config(this, jax);

    try {
      for (var _d = __values(config.preprocessors), _e = _d.next(); !_e.done; _e = _d.next()) {
        var pre = _e.value;
        Array.isArray(pre) ? jax.preFilters.add(pre[0], pre[1]) : jax.preFilters.add(pre);
      }
    } catch (e_10_1) {
      e_10 = {
        error: e_10_1
      };
    } finally {
      try {
        if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
      } finally {
        if (e_10) throw e_10.error;
      }
    }

    try {
      for (var _g = __values(config.postprocessors), _h = _g.next(); !_h.done; _h = _g.next()) {
        var post = _h.value;
        Array.isArray(post) ? jax.postFilters.add(post[0], post[1]) : jax.postFilters.add(post);
      }
    } catch (e_11_1) {
      e_11 = {
        error: e_11_1
      };
    } finally {
      try {
        if (_h && !_h.done && (_j = _g.return)) _j.call(_g);
      } finally {
        if (e_11) throw e_11.error;
      }
    }

    var e_9, _c, e_10, _f, e_11, _j;
  };

  return Configuration;
}();

exports.Configuration = Configuration;
;
var ConfigurationHandler;

(function (ConfigurationHandler) {
  var maps = new Map();

  ConfigurationHandler.set = function (name, map) {
    maps.set(name, map);
  };

  ConfigurationHandler.get = function (name) {
    return maps.get(name);
  };

  ConfigurationHandler.keys = function () {
    return maps.keys();
  };
})(ConfigurationHandler = exports.ConfigurationHandler || (exports.ConfigurationHandler = {}));

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Symbol_js_1 = __webpack_require__(36);

var MapHandler_js_1 = __webpack_require__(17);

var AbstractSymbolMap = function () {
  function AbstractSymbolMap(_name, _parser) {
    this._name = _name;
    this._parser = _parser;
    MapHandler_js_1.MapHandler.register(this);
  }

  ;
  Object.defineProperty(AbstractSymbolMap.prototype, "name", {
    get: function () {
      return this._name;
    },
    enumerable: true,
    configurable: true
  });

  AbstractSymbolMap.prototype.parserFor = function (symbol) {
    return this.contains(symbol) ? this.parser : null;
  };

  AbstractSymbolMap.prototype.parse = function (_a) {
    var _b = __read(_a, 2),
        env = _b[0],
        symbol = _b[1];

    var parser = this.parserFor(symbol);
    var mapped = this.lookup(symbol);
    return parser && mapped ? parser(env, mapped) || true : null;
  };

  Object.defineProperty(AbstractSymbolMap.prototype, "parser", {
    get: function () {
      return this._parser;
    },
    set: function (parser) {
      this._parser = parser;
    },
    enumerable: true,
    configurable: true
  });
  return AbstractSymbolMap;
}();

exports.AbstractSymbolMap = AbstractSymbolMap;

var RegExpMap = function (_super) {
  __extends(RegExpMap, _super);

  function RegExpMap(name, parser, _regExp) {
    var _this = _super.call(this, name, parser) || this;

    _this._regExp = _regExp;
    return _this;
  }

  ;

  RegExpMap.prototype.contains = function (symbol) {
    return this._regExp.test(symbol);
  };

  RegExpMap.prototype.lookup = function (symbol) {
    return this.contains(symbol) ? symbol : null;
  };

  return RegExpMap;
}(AbstractSymbolMap);

exports.RegExpMap = RegExpMap;

var AbstractParseMap = function (_super) {
  __extends(AbstractParseMap, _super);

  function AbstractParseMap() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.map = new Map();
    return _this;
  }

  AbstractParseMap.prototype.lookup = function (symbol) {
    return this.map.get(symbol);
  };

  AbstractParseMap.prototype.contains = function (symbol) {
    return this.map.has(symbol);
  };

  AbstractParseMap.prototype.add = function (symbol, object) {
    this.map.set(symbol, object);
  };

  return AbstractParseMap;
}(AbstractSymbolMap);

exports.AbstractParseMap = AbstractParseMap;

var CharacterMap = function (_super) {
  __extends(CharacterMap, _super);

  function CharacterMap(name, parser, json) {
    var _this = _super.call(this, name, parser) || this;

    try {
      for (var _a = __values(Object.keys(json)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var key = _b.value;
        var value = json[key];

        var _c = __read(typeof value === 'string' ? [value, null] : value, 2),
            char = _c[0],
            attrs = _c[1];

        var character = new Symbol_js_1.Symbol(key, char, attrs);

        _this.add(key, character);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    return _this;

    var e_1, _d;
  }

  ;
  return CharacterMap;
}(AbstractParseMap);

exports.CharacterMap = CharacterMap;

var DelimiterMap = function (_super) {
  __extends(DelimiterMap, _super);

  function DelimiterMap() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  DelimiterMap.prototype.parse = function (_a) {
    var _b = __read(_a, 2),
        env = _b[0],
        symbol = _b[1];

    return _super.prototype.parse.call(this, [env, '\\' + symbol]);
  };

  return DelimiterMap;
}(CharacterMap);

exports.DelimiterMap = DelimiterMap;

var MacroMap = function (_super) {
  __extends(MacroMap, _super);

  function MacroMap(name, json, functionMap) {
    var _this = _super.call(this, name, null) || this;

    try {
      for (var _a = __values(Object.keys(json)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var key = _b.value;
        var value = json[key];

        var _c = __read(typeof value === 'string' ? [value] : value),
            func = _c[0],
            attrs = _c.slice(1);

        var character = new Symbol_js_1.Macro(key, functionMap[func], attrs);

        _this.add(key, character);
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    return _this;

    var e_2, _d;
  }

  ;

  MacroMap.prototype.parserFor = function (symbol) {
    var macro = this.lookup(symbol);
    return macro ? macro.func : null;
  };

  MacroMap.prototype.parse = function (_a) {
    var _b = __read(_a, 2),
        env = _b[0],
        symbol = _b[1];

    var macro = this.lookup(symbol);
    var parser = this.parserFor(symbol);

    if (!macro || !parser) {
      return null;
    }

    return parser.apply(void 0, __spread([env, macro.symbol], macro.args)) || true;
  };

  return MacroMap;
}(AbstractParseMap);

exports.MacroMap = MacroMap;

var CommandMap = function (_super) {
  __extends(CommandMap, _super);

  function CommandMap() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CommandMap.prototype.parse = function (_a) {
    var _b = __read(_a, 2),
        env = _b[0],
        symbol = _b[1];

    var macro = this.lookup(symbol);
    var parser = this.parserFor(symbol);

    if (!macro || !parser) {
      return null;
    }

    var args = ['\\' + macro.symbol].concat(macro.args);

    if (!parser) {
      return null;
    }

    var saveCommand = env.currentCS;
    env.currentCS = '\\' + symbol;
    var result = parser.apply(void 0, __spread([env, '\\' + macro.symbol], macro.args));
    env.currentCS = saveCommand;
    return result || true;
  };

  return CommandMap;
}(MacroMap);

exports.CommandMap = CommandMap;

var EnvironmentMap = function (_super) {
  __extends(EnvironmentMap, _super);

  function EnvironmentMap(name, parser, json, functionMap) {
    var _this = _super.call(this, name, json, functionMap) || this;

    _this.parser = parser;
    return _this;
  }

  ;

  EnvironmentMap.prototype.parse = function (_a) {
    var _b = __read(_a, 2),
        env = _b[0],
        symbol = _b[1];

    var macro = this.lookup(symbol);
    var envParser = this.parserFor(symbol);

    if (!macro || !envParser) {
      return null;
    }

    this.parser(env, macro.symbol, envParser, macro.args);
    return true;
  };

  return EnvironmentMap;
}(MacroMap);

exports.EnvironmentMap = EnvironmentMap;

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var TexError = function () {
  function TexError(id, message) {
    var rest = [];

    for (var _i = 2; _i < arguments.length; _i++) {
      rest[_i - 2] = arguments[_i];
    }

    this.id = id;
    this.message = TexError.processString(message, rest);
  }

  TexError.processString = function (str, args) {
    var parts = str.split(TexError.pattern);

    for (var i = 1, m = parts.length; i < m; i += 2) {
      var c = parts[i].charAt(0);

      if (c >= '0' && c <= '9') {
        parts[i] = args[parseInt(parts[i], 10) - 1];

        if (typeof parts[i] === 'number') {
          parts[i] = parts[i].toString();
        }
      } else if (c === '{') {
        c = parts[i].substr(1);

        if (c >= '0' && c <= '9') {
          parts[i] = args[parseInt(parts[i].substr(1, parts[i].length - 2), 10) - 1];

          if (typeof parts[i] === 'number') {
            parts[i] = parts[i].toString();
          }
        } else {
          var match = parts[i].match(/^\{([a-z]+):%(\d+)\|(.*)\}$/);

          if (match) {
            parts[i] = '%' + parts[i];
          }
        }
      }

      if (parts[i] == null) {
        parts[i] = '???';
      }
    }

    return parts.join('');
  };

  return TexError;
}();

TexError.pattern = /%(\d+|\{\d+\}|\{[a-z]+:\%\d+(?:\|(?:%\{\d+\}|%.|[^\}])*)+\}|.)/g;
exports.default = TexError;

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var YAMLException = __webpack_require__(24);

var TYPE_CONSTRUCTOR_OPTIONS = ['kind', 'resolve', 'construct', 'instanceOf', 'predicate', 'represent', 'defaultStyle', 'styleAliases'];
var YAML_NODE_KINDS = ['scalar', 'sequence', 'mapping'];

function compileStyleAliases(map) {
  var result = {};

  if (map !== null) {
    Object.keys(map).forEach(function (style) {
      map[style].forEach(function (alias) {
        result[String(alias)] = style;
      });
    });
  }

  return result;
}

function Type(tag, options) {
  options = options || {};
  Object.keys(options).forEach(function (name) {
    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
      throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
    }
  }); // TODO: Add tag format check.

  this.tag = tag;
  this.kind = options['kind'] || null;

  this.resolve = options['resolve'] || function () {
    return true;
  };

  this.construct = options['construct'] || function (data) {
    return data;
  };

  this.instanceOf = options['instanceOf'] || null;
  this.predicate = options['predicate'] || null;
  this.represent = options['represent'] || null;
  this.defaultStyle = options['defaultStyle'] || null;
  this.styleAliases = compileStyleAliases(options['styleAliases'] || null);

  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
    throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
  }
}

module.exports = Type;

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var mo_js_1 = __webpack_require__(34);

var NodeUtil;

(function (NodeUtil) {
  var attrs = new Map([['autoOP', true], ['fnOP', true], ['movesupsub', true], ['subsupOK', true], ['texprimestyle', true], ['useHeight', true], ['variantForm', true], ['withDelims', true], ['open', true], ['close', true]]);
  var methodOut = false;

  function createEntity(code) {
    return String.fromCharCode(parseInt(code, 16));
  }

  NodeUtil.createEntity = createEntity;
  ;

  function getChildren(node) {
    return node.childNodes;
  }

  NodeUtil.getChildren = getChildren;
  ;

  function getText(node) {
    return node.getText();
  }

  NodeUtil.getText = getText;
  ;

  function appendChildren(node, children) {
    try {
      for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
        var child = children_1_1.value;
        node.appendChild(child);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _a;
  }

  NodeUtil.appendChildren = appendChildren;
  ;

  function setAttribute(node, attribute, value) {
    node.attributes.set(attribute, value);
  }

  NodeUtil.setAttribute = setAttribute;
  ;

  function setProperty(node, property, value) {
    node.setProperty(property, value);
  }

  NodeUtil.setProperty = setProperty;
  ;

  function setProperties(node, properties) {
    try {
      for (var _a = __values(Object.keys(properties)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var name_1 = _b.value;
        var value = properties[name_1];

        if (name_1 === 'texClass') {
          node.texClass = value;
        } else if (name_1 === 'movablelimits') {
          node.setProperty('movablelimits', value);

          if (node.isKind('mo') || node.isKind('mstyle')) {
            node.attributes.set('movablelimits', value);
          }
        } else if (name_1 === 'inferred') {} else if (attrs.has(name_1)) {
          node.setProperty(name_1, value);
        } else {
          node.attributes.set(name_1, value);
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_2, _c;
  }

  NodeUtil.setProperties = setProperties;
  ;

  function getProperty(node, property) {
    return node.getProperty(property);
  }

  NodeUtil.getProperty = getProperty;
  ;

  function getAttribute(node, attr) {
    return node.attributes.get(attr);
  }

  NodeUtil.getAttribute = getAttribute;

  function removeProperties(node) {
    var properties = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      properties[_i - 1] = arguments[_i];
    }

    node.removeProperty.apply(node, __spread(properties));
  }

  NodeUtil.removeProperties = removeProperties;

  function getChildAt(node, position) {
    return node.childNodes[position];
  }

  NodeUtil.getChildAt = getChildAt;
  ;

  function setChild(node, position, child) {
    var children = node.childNodes;
    children[position] = child;

    if (child) {
      child.parent = node;
    }
  }

  NodeUtil.setChild = setChild;
  ;

  function copyChildren(oldNode, newNode) {
    var children = oldNode.childNodes;

    for (var i = 0; i < children.length; i++) {
      setChild(newNode, i, children[i]);
    }
  }

  NodeUtil.copyChildren = copyChildren;
  ;

  function copyAttributes(oldNode, newNode) {
    newNode.attributes = oldNode.attributes;
    setProperties(newNode, oldNode.getAllProperties());
  }

  NodeUtil.copyAttributes = copyAttributes;
  ;

  function isType(node, kind) {
    return node.isKind(kind);
  }

  NodeUtil.isType = isType;
  ;

  function isEmbellished(node) {
    return node.isEmbellished;
  }

  NodeUtil.isEmbellished = isEmbellished;
  ;

  function getTexClass(node) {
    return node.texClass;
  }

  NodeUtil.getTexClass = getTexClass;
  ;

  function getCoreMO(node) {
    return node.coreMO();
  }

  NodeUtil.getCoreMO = getCoreMO;
  ;

  function isNode(item) {
    return item instanceof MmlNode_js_1.AbstractMmlNode || item instanceof MmlNode_js_1.AbstractMmlEmptyNode;
  }

  NodeUtil.isNode = isNode;
  ;

  function isInferred(node) {
    return node.isInferred;
  }

  NodeUtil.isInferred = isInferred;
  ;

  function getForm(node) {
    if (!isType(node, 'mo')) {
      return null;
    }

    var mo = node;
    var forms = mo.getForms();

    try {
      for (var forms_1 = __values(forms), forms_1_1 = forms_1.next(); !forms_1_1.done; forms_1_1 = forms_1.next()) {
        var form = forms_1_1.value;
        var symbol = mo_js_1.MmlMo.OPTABLE[form][mo.getText()];

        if (symbol) {
          return symbol;
        }
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (forms_1_1 && !forms_1_1.done && (_a = forms_1.return)) _a.call(forms_1);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    return null;

    var e_3, _a;
  }

  NodeUtil.getForm = getForm;
  ;
})(NodeUtil || (NodeUtil = {}));

exports.default = NodeUtil;

/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var NodeUtil_js_1 = __webpack_require__(8);

var TexParser_js_1 = __webpack_require__(15);

var TexError_js_1 = __webpack_require__(6);

var Entities_js_1 = __webpack_require__(18);

__webpack_require__(72);

var ParseUtil;

(function (ParseUtil) {
  var emPerInch = 7.2;
  var pxPerInch = 72;
  var UNIT_CASES = {
    'em': function (m) {
      return m;
    },
    'ex': function (m) {
      return m * .43;
    },
    'pt': function (m) {
      return m / 10;
    },
    'pc': function (m) {
      return m * 1.2;
    },
    'px': function (m) {
      return m * emPerInch / pxPerInch;
    },
    'in': function (m) {
      return m * emPerInch;
    },
    'cm': function (m) {
      return m * emPerInch / 2.54;
    },
    'mm': function (m) {
      return m * emPerInch / 25.4;
    },
    'mu': function (m) {
      return m / 18;
    }
  };
  var num = '([-+]?([.,]\\d+|\\d+([.,]\\d*)?))';
  var unit = '(pt|em|ex|mu|px|mm|cm|in|pc)';
  var dimenEnd = RegExp('^\\s*' + num + '\\s*' + unit + '\\s*$');
  var dimenRest = RegExp('^\\s*' + num + '\\s*' + unit + ' ?');

  function matchDimen(dim, rest) {
    if (rest === void 0) {
      rest = false;
    }

    var match = dim.match(rest ? dimenRest : dimenEnd);
    return match ? [match[1].replace(/,/, '.'), match[4], match[0].length] : [null, null, 0];
  }

  ParseUtil.matchDimen = matchDimen;

  function dimen2em(dim) {
    var _a = __read(matchDimen(dim), 3),
        value = _a[0],
        unit = _a[1],
        _ = _a[2];

    var m = parseFloat(value || '1');
    var func = UNIT_CASES[unit];
    return func ? func(m) : 0;
  }

  ParseUtil.dimen2em = dimen2em;

  function Em(m) {
    if (Math.abs(m) < .0006) {
      return '0em';
    }

    return m.toFixed(3).replace(/\.?0+$/, '') + 'em';
  }

  ParseUtil.Em = Em;

  function fenced(configuration, open, mml, close, big) {
    if (big === void 0) {
      big = '';
    }

    var nf = configuration.nodeFactory;
    var mrow = nf.create('node', 'mrow', [], {
      open: open,
      close: close,
      texClass: MmlNode_js_1.TEXCLASS.INNER
    });
    var mo;

    if (big) {
      mo = new TexParser_js_1.default('\\' + big + 'l' + open, configuration.parser.stack.env, configuration).mml();
    } else {
      var openNode = nf.create('text', open);
      mo = nf.create('node', 'mo', [], {
        fence: true,
        stretchy: true,
        symmetric: true,
        texClass: MmlNode_js_1.TEXCLASS.OPEN
      }, openNode);
    }

    NodeUtil_js_1.default.appendChildren(mrow, [mo]);

    if (NodeUtil_js_1.default.isType(mml, 'mrow') && NodeUtil_js_1.default.isInferred(mml)) {
      NodeUtil_js_1.default.appendChildren(mrow, NodeUtil_js_1.default.getChildren(mml));
    } else {
      NodeUtil_js_1.default.appendChildren(mrow, [mml]);
    }

    if (big) {
      mo = new TexParser_js_1.default('\\' + big + 'r' + close, configuration.parser.stack.env, configuration).mml();
    } else {
      var closeNode = nf.create('text', close);
      mo = nf.create('node', 'mo', [], {
        fence: true,
        stretchy: true,
        symmetric: true,
        texClass: MmlNode_js_1.TEXCLASS.CLOSE
      }, closeNode);
    }

    NodeUtil_js_1.default.appendChildren(mrow, [mo]);
    return mrow;
  }

  ParseUtil.fenced = fenced;

  function fixedFence(configuration, open, mml, close) {
    var mrow = configuration.nodeFactory.create('node', 'mrow', [], {
      open: open,
      close: close,
      texClass: MmlNode_js_1.TEXCLASS.ORD
    });

    if (open) {
      NodeUtil_js_1.default.appendChildren(mrow, [mathPalette(configuration, open, 'l')]);
    }

    if (NodeUtil_js_1.default.isType(mml, 'mrow')) {
      NodeUtil_js_1.default.appendChildren(mrow, NodeUtil_js_1.default.getChildren(mml));
    } else {
      NodeUtil_js_1.default.appendChildren(mrow, [mml]);
    }

    if (close) {
      NodeUtil_js_1.default.appendChildren(mrow, [mathPalette(configuration, close, 'r')]);
    }

    return mrow;
  }

  ParseUtil.fixedFence = fixedFence;

  function mathPalette(configuration, fence, side) {
    if (fence === '{' || fence === '}') {
      fence = '\\' + fence;
    }

    var D = '{\\bigg' + side + ' ' + fence + '}';
    var T = '{\\big' + side + ' ' + fence + '}';
    return new TexParser_js_1.default('\\mathchoice' + D + T + T + T, {}, configuration).mml();
  }

  ParseUtil.mathPalette = mathPalette;

  function fixInitialMO(configuration, nodes) {
    for (var i = 0, m = nodes.length; i < m; i++) {
      var child = nodes[i];

      if (child && !NodeUtil_js_1.default.isType(child, 'mspace') && (!NodeUtil_js_1.default.isType(child, 'TeXAtom') || NodeUtil_js_1.default.getChildren(child)[0] && NodeUtil_js_1.default.getChildren(NodeUtil_js_1.default.getChildren(child)[0]).length)) {
        if (NodeUtil_js_1.default.isEmbellished(child)) {
          var mi = configuration.nodeFactory.create('node', 'mi');
          nodes.unshift(mi);
        }

        break;
      }
    }
  }

  ParseUtil.fixInitialMO = fixInitialMO;

  function mi2mo(parser, mi) {
    var mo = parser.create('node', 'mo');
    NodeUtil_js_1.default.copyChildren(mi, mo);
    NodeUtil_js_1.default.copyAttributes(mi, mo);
    NodeUtil_js_1.default.setProperties(mo, {
      lspace: '0',
      rspace: '0'
    });
    NodeUtil_js_1.default.removeProperties(mo, 'movesupsub');
    return mo;
  }

  ParseUtil.mi2mo = mi2mo;

  function internalMath(parser, text, level) {
    var def = parser.stack.env['font'] ? {
      mathvariant: parser.stack.env['font']
    } : {};
    var mml = [],
        i = 0,
        k = 0,
        c,
        node,
        match = '',
        braces = 0;

    if (text.match(/\\?[${}\\]|\\\(|\\(eq)?ref\s*\{/)) {
      while (i < text.length) {
        c = text.charAt(i++);

        if (c === '$') {
          if (match === '$' && braces === 0) {
            node = parser.create('node', 'TeXAtom', [new TexParser_js_1.default(text.slice(k, i - 1), {}, parser.configuration).mml()]);
            mml.push(node);
            match = '';
            k = i;
          } else if (match === '') {
            if (k < i - 1) {
              mml.push(internalText(parser, text.slice(k, i - 1), def));
            }

            match = '$';
            k = i;
          }
        } else if (c === '{' && match !== '') {
          braces++;
        } else if (c === '}') {
          if (match === '}' && braces === 0) {
            var atom = new TexParser_js_1.default(text.slice(k, i), {}, parser.configuration).mml();
            node = parser.create('node', 'TeXAtom', [atom], def);
            mml.push(node);
            match = '';
            k = i;
          } else if (match !== '') {
            if (braces) {
              braces--;
            }
          }
        } else if (c === '\\') {
          if (match === '' && text.substr(i).match(/^(eq)?ref\s*\{/)) {
            var len = RegExp['$&'].length;

            if (k < i - 1) {
              mml.push(internalText(parser, text.slice(k, i - 1), def));
            }

            match = '}';
            k = i - 1;
            i += len;
          } else {
            c = text.charAt(i++);

            if (c === '(' && match === '') {
              if (k < i - 2) {
                mml.push(internalText(parser, text.slice(k, i - 2), def));
              }

              match = ')';
              k = i;
            } else if (c === ')' && match === ')' && braces === 0) {
              node = parser.create('node', 'TeXAtom', [new TexParser_js_1.default(text.slice(k, i - 2), {}, parser.configuration).mml()]);
              mml.push(node);
              match = '';
              k = i;
            } else if (c.match(/[${}\\]/) && match === '') {
              i--;
              text = text.substr(0, i - 1) + text.substr(i);
            }
          }
        }
      }

      if (match !== '') {
        throw new TexError_js_1.default('MathNotTerminated', 'Math not terminated in text box');
      }
    }

    if (k < text.length) {
      mml.push(internalText(parser, text.slice(k), def));
    }

    if (level != null) {
      mml = [parser.create('node', 'mstyle', mml, {
        displaystyle: false,
        scriptlevel: level
      })];
    } else if (mml.length > 1) {
      mml = [parser.create('node', 'mrow', mml)];
    }

    return mml;
  }

  ParseUtil.internalMath = internalMath;

  function internalText(parser, text, def) {
    text = text.replace(/^\s+/, Entities_js_1.entities.nbsp).replace(/\s+$/, Entities_js_1.entities.nbsp);
    var textNode = parser.create('text', text);
    return parser.create('node', 'mtext', [], def, textNode);
  }

  function trimSpaces(text) {
    if (typeof text !== 'string') {
      return text;
    }

    var TEXT = text.trim();

    if (TEXT.match(/\\$/) && text.match(/ $/)) {
      TEXT += ' ';
    }

    return TEXT;
  }

  ParseUtil.trimSpaces = trimSpaces;

  function setArrayAlign(array, align) {
    align = ParseUtil.trimSpaces(align || '');

    if (align === 't') {
      array.arraydef.align = 'baseline 1';
    } else if (align === 'b') {
      array.arraydef.align = 'baseline -1';
    } else if (align === 'c') {
      array.arraydef.align = 'center';
    } else if (align) {
      array.arraydef.align = align;
    }

    return array;
  }

  ParseUtil.setArrayAlign = setArrayAlign;

  function substituteArgs(parser, args, str) {
    var text = '';
    var newstring = '';
    var i = 0;

    while (i < str.length) {
      var c = str.charAt(i++);

      if (c === '\\') {
        text += c + str.charAt(i++);
      } else if (c === '#') {
        c = str.charAt(i++);

        if (c === '#') {
          text += c;
        } else {
          if (!c.match(/[1-9]/) || parseInt(c, 10) > args.length) {
            throw new TexError_js_1.default('IllegalMacroParam', 'Illegal macro parameter reference');
          }

          newstring = addArgs(parser, addArgs(parser, newstring, text), args[parseInt(c, 10) - 1]);
          text = '';
        }
      } else {
        text += c;
      }
    }

    return addArgs(parser, newstring, text);
  }

  ParseUtil.substituteArgs = substituteArgs;

  function addArgs(parser, s1, s2) {
    if (s2.match(/^[a-z]/i) && s1.match(/(^|[^\\])(\\\\)*\\[a-z]+$/i)) {
      s1 += ' ';
    }

    if (s1.length + s2.length > parser.configuration.options['maxBuffer']) {
      throw new TexError_js_1.default('MaxBufferSize', 'MathJax internal buffer size exceeded; is there a' + ' recursive macro call?');
    }

    return s1 + s2;
  }

  ParseUtil.addArgs = addArgs;

  function checkEqnEnv(parser) {
    if (parser.stack.global.eqnenv) {
      throw new TexError_js_1.default('ErroneousNestingEq', 'Erroneous nesting of equation structures');
    }

    parser.stack.global.eqnenv = true;
  }

  ParseUtil.checkEqnEnv = checkEqnEnv;
  ;

  function MmlFilterAttribute(parser, name, value) {
    return value;
  }

  ParseUtil.MmlFilterAttribute = MmlFilterAttribute;
  ;

  function getFontDef(parser) {
    var font = parser.stack.env['font'];
    return font ? {
      mathvariant: font
    } : {};
  }

  ParseUtil.getFontDef = getFontDef;
  ;

  function splitPackageOptions(attrib, allowed) {
    if (allowed === void 0) {
      allowed = {};
    }

    var def = {};

    if (attrib !== '') {
      var attr = attrib.replace(/ /g, '').split(/,/);

      for (var i = 0, m = attr.length; i < m; i++) {
        var keyvalue = attr[i].split(/[:=]/);

        if (allowed[keyvalue[0]]) {
          var value = keyvalue[1];
          def[keyvalue[0]] = value === 'true' ? true : value === 'false' ? false : value;
        }
      }
    }

    return def;
  }

  ParseUtil.splitPackageOptions = splitPackageOptions;
})(ParseUtil || (ParseUtil = {}));

exports.default = ParseUtil;

/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});
var OBJECT = {}.constructor;

function isObject(obj) {
  return typeof obj === 'object' && obj !== null && obj.constructor === OBJECT;
}

exports.APPEND = '[+]';
exports.REMOVE = '[-]';

var Expandable = function () {
  function Expandable() {}

  return Expandable;
}();

exports.Expandable = Expandable;
;

function expandable(def) {
  return Object.assign(Object.create(Expandable.prototype), def);
}

exports.expandable = expandable;

function makeArray(x) {
  return Array.isArray(x) ? x : [x];
}

exports.makeArray = makeArray;

function keys(def) {
  if (!def) {
    return [];
  }

  return Object.keys(def).concat(Object.getOwnPropertySymbols(def));
}

exports.keys = keys;

function copy(def) {
  var props = {};

  try {
    for (var _a = __values(keys(def)), _b = _a.next(); !_b.done; _b = _a.next()) {
      var key = _b.value;
      var prop = Object.getOwnPropertyDescriptor(def, key);
      var value = prop.value;

      if (Array.isArray(value)) {
        prop.value = insert([], value, false);
      } else if (isObject(value)) {
        prop.value = copy(value);
      }

      if (prop.enumerable) {
        props[key] = prop;
      }
    }
  } catch (e_1_1) {
    e_1 = {
      error: e_1_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_1) throw e_1.error;
    }
  }

  return Object.defineProperties({}, props);

  var e_1, _c;
}

exports.copy = copy;

function insert(dst, src, warn) {
  if (warn === void 0) {
    warn = true;
  }

  var _loop_1 = function (key) {
    if (warn && dst[key] === undefined && !(dst instanceof Expandable)) {
      if (typeof key === 'symbol') {
        key = key.toString();
      }

      throw new Error('Invalid option "' + key + '" (no default value).');
    }

    var sval = src[key],
        dval = dst[key];

    if (isObject(sval) && dval !== null && (typeof dval === 'object' || typeof dval === 'function')) {
      var ids = keys(sval);

      if (Array.isArray(dval) && (ids.length === 1 && (ids[0] === exports.APPEND || ids[0] === exports.REMOVE) && Array.isArray(sval[ids[0]]) || ids.length === 2 && ids.sort().join(',') === exports.APPEND + ',' + exports.REMOVE && Array.isArray(sval[exports.APPEND]) && Array.isArray(sval[exports.REMOVE]))) {
        if (sval[exports.REMOVE]) {
          dval = dst[key] = dval.filter(function (x) {
            return sval[exports.REMOVE].indexOf(x) < 0;
          });
        }

        if (sval[exports.APPEND]) {
          dst[key] = __spread(dval, sval[exports.APPEND]);
        }
      } else {
        insert(dval, sval, warn);
      }
    } else if (Array.isArray(sval)) {
      dst[key] = [];
      insert(dst[key], sval, false);
    } else if (isObject(sval)) {
      dst[key] = copy(sval);
    } else {
      dst[key] = sval;
    }
  };

  try {
    for (var _a = __values(keys(src)), _b = _a.next(); !_b.done; _b = _a.next()) {
      var key = _b.value;

      _loop_1(key);
    }
  } catch (e_2_1) {
    e_2 = {
      error: e_2_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_2) throw e_2.error;
    }
  }

  return dst;

  var e_2, _c;
}

exports.insert = insert;

function defaultOptions(options) {
  var defs = [];

  for (var _i = 1; _i < arguments.length; _i++) {
    defs[_i - 1] = arguments[_i];
  }

  defs.forEach(function (def) {
    return insert(options, def, false);
  });
  return options;
}

exports.defaultOptions = defaultOptions;

function userOptions(options) {
  var defs = [];

  for (var _i = 1; _i < arguments.length; _i++) {
    defs[_i - 1] = arguments[_i];
  }

  defs.forEach(function (def) {
    return insert(options, def, true);
  });
  return options;
}

exports.userOptions = userOptions;

function selectOptions(options) {
  var keys = [];

  for (var _i = 1; _i < arguments.length; _i++) {
    keys[_i - 1] = arguments[_i];
  }

  var subset = {};

  try {
    for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
      var key = keys_1_1.value;

      if (options.hasOwnProperty(key)) {
        subset[key] = options[key];
      }
    }
  } catch (e_3_1) {
    e_3 = {
      error: e_3_1
    };
  } finally {
    try {
      if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
    } finally {
      if (e_3) throw e_3.error;
    }
  }

  return subset;

  var e_3, _a;
}

exports.selectOptions = selectOptions;

function selectOptionsFromKeys(options, object) {
  return selectOptions.apply(void 0, __spread([options], Object.keys(object)));
}

exports.selectOptionsFromKeys = selectOptionsFromKeys;

function separateOptions(options) {
  var objects = [];

  for (var _i = 1; _i < arguments.length; _i++) {
    objects[_i - 1] = arguments[_i];
  }

  var results = [];

  try {
    for (var objects_1 = __values(objects), objects_1_1 = objects_1.next(); !objects_1_1.done; objects_1_1 = objects_1.next()) {
      var object = objects_1_1.value;
      var exists = {},
          missing = {};

      try {
        for (var _a = __values(Object.keys(options || {})), _b = _a.next(); !_b.done; _b = _a.next()) {
          var key = _b.value;
          (object[key] === undefined ? missing : exists)[key] = options[key];
        }
      } catch (e_4_1) {
        e_4 = {
          error: e_4_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_4) throw e_4.error;
        }
      }

      results.push(exists);
      options = missing;
    }
  } catch (e_5_1) {
    e_5 = {
      error: e_5_1
    };
  } finally {
    try {
      if (objects_1_1 && !objects_1_1.done && (_d = objects_1.return)) _d.call(objects_1);
    } finally {
      if (e_5) throw e_5.error;
    }
  }

  results.unshift(options);
  return results;

  var e_5, _d, e_4, _c;
}

exports.separateOptions = separateOptions;

/***/ }),
/* 11 */
/***/ (function(module, exports) {

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
module.exports = function(src) {
	function log(error) {
		(typeof console !== "undefined")
		&& (console.error || console.log)("[Script Loader]", error);
	}

	// Check for IE =< 8
	function isIE() {
		return typeof attachEvent !== "undefined" && typeof addEventListener === "undefined";
	}

	try {
		if (typeof execScript !== "undefined" && isIE()) {
			execScript(src);
		} else if (typeof eval !== "undefined") {
			eval.call(null, src);
		} else {
			log("EvalError: No eval function available");
		}
	} catch (error) {
		log(error);
	}
}


/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/*
  MIT License http://www.opensource.org/licenses/mit-license.php
  Author Tobias Koppers @sokra
*/
// css base code, injected by the css-loader

module.exports = function (useSourceMap) {
  var list = []; // return the list of modules as css string

  list.toString = function toString() {
    return this.map(function (item) {
      var content = cssWithMappingToString(item, useSourceMap);

      if (item[2]) {
        return '@media ' + item[2] + '{' + content + '}';
      } else {
        return content;
      }
    }).join('');
  }; // import a list of modules into the list


  list.i = function (modules, mediaQuery) {
    if (typeof modules === 'string') {
      modules = [[null, modules, '']];
    }

    var alreadyImportedModules = {};

    for (var i = 0; i < this.length; i++) {
      var id = this[i][0];

      if (id != null) {
        alreadyImportedModules[id] = true;
      }
    }

    for (i = 0; i < modules.length; i++) {
      var item = modules[i]; // skip already imported module
      // this implementation is not 100% perfect for weird media query combinations
      // when a module is imported multiple times with different media queries.
      // I hope this will never occur (Hey this way we have smaller bundles)

      if (item[0] == null || !alreadyImportedModules[item[0]]) {
        if (mediaQuery && !item[2]) {
          item[2] = mediaQuery;
        } else if (mediaQuery) {
          item[2] = '(' + item[2] + ') and (' + mediaQuery + ')';
        }

        list.push(item);
      }
    }
  };

  return list;
};

function cssWithMappingToString(item, useSourceMap) {
  var content = item[1] || '';
  var cssMapping = item[3];

  if (!cssMapping) {
    return content;
  }

  if (useSourceMap && typeof btoa === 'function') {
    var sourceMapping = toComment(cssMapping);
    var sourceURLs = cssMapping.sources.map(function (source) {
      return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */';
    });
    return [content].concat(sourceURLs).concat([sourceMapping]).join('\n');
  }

  return [content].join('\n');
} // Adapted from convert-source-map (MIT)


function toComment(sourceMap) {
  // eslint-disable-next-line no-undef
  var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));
  var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;
  return '/*# ' + data + ' */';
}

/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

var stylesInDom = {};

var	memoize = function (fn) {
	var memo;

	return function () {
		if (typeof memo === "undefined") memo = fn.apply(this, arguments);
		return memo;
	};
};

var isOldIE = memoize(function () {
	// Test for IE <= 9 as proposed by Browserhacks
	// @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805
	// Tests for existence of standard globals is to allow style-loader
	// to operate correctly into non-standard environments
	// @see https://github.com/webpack-contrib/style-loader/issues/177
	return window && document && document.all && !window.atob;
});

var getTarget = function (target, parent) {
  if (parent){
    return parent.querySelector(target);
  }
  return document.querySelector(target);
};

var getElement = (function (fn) {
	var memo = {};

	return function(target, parent) {
                // If passing function in options, then use it for resolve "head" element.
                // Useful for Shadow Root style i.e
                // {
                //   insertInto: function () { return document.querySelector("#foo").shadowRoot }
                // }
                if (typeof target === 'function') {
                        return target();
                }
                if (typeof memo[target] === "undefined") {
			var styleTarget = getTarget.call(this, target, parent);
			// Special case to return head of iframe instead of iframe itself
			if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
				try {
					// This will throw an exception if access to iframe is blocked
					// due to cross-origin restrictions
					styleTarget = styleTarget.contentDocument.head;
				} catch(e) {
					styleTarget = null;
				}
			}
			memo[target] = styleTarget;
		}
		return memo[target]
	};
})();

var singleton = null;
var	singletonCounter = 0;
var	stylesInsertedAtTop = [];

var	fixUrls = __webpack_require__(407);

module.exports = function(list, options) {
	if (typeof DEBUG !== "undefined" && DEBUG) {
		if (typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
	}

	options = options || {};

	options.attrs = typeof options.attrs === "object" ? options.attrs : {};

	// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
	// tags it will allow on a page
	if (!options.singleton && typeof options.singleton !== "boolean") options.singleton = isOldIE();

	// By default, add <style> tags to the <head> element
        if (!options.insertInto) options.insertInto = "head";

	// By default, add <style> tags to the bottom of the target
	if (!options.insertAt) options.insertAt = "bottom";

	var styles = listToStyles(list, options);

	addStylesToDom(styles, options);

	return function update (newList) {
		var mayRemove = [];

		for (var i = 0; i < styles.length; i++) {
			var item = styles[i];
			var domStyle = stylesInDom[item.id];

			domStyle.refs--;
			mayRemove.push(domStyle);
		}

		if(newList) {
			var newStyles = listToStyles(newList, options);
			addStylesToDom(newStyles, options);
		}

		for (var i = 0; i < mayRemove.length; i++) {
			var domStyle = mayRemove[i];

			if(domStyle.refs === 0) {
				for (var j = 0; j < domStyle.parts.length; j++) domStyle.parts[j]();

				delete stylesInDom[domStyle.id];
			}
		}
	};
};

function addStylesToDom (styles, options) {
	for (var i = 0; i < styles.length; i++) {
		var item = styles[i];
		var domStyle = stylesInDom[item.id];

		if(domStyle) {
			domStyle.refs++;

			for(var j = 0; j < domStyle.parts.length; j++) {
				domStyle.parts[j](item.parts[j]);
			}

			for(; j < item.parts.length; j++) {
				domStyle.parts.push(addStyle(item.parts[j], options));
			}
		} else {
			var parts = [];

			for(var j = 0; j < item.parts.length; j++) {
				parts.push(addStyle(item.parts[j], options));
			}

			stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
		}
	}
}

function listToStyles (list, options) {
	var styles = [];
	var newStyles = {};

	for (var i = 0; i < list.length; i++) {
		var item = list[i];
		var id = options.base ? item[0] + options.base : item[0];
		var css = item[1];
		var media = item[2];
		var sourceMap = item[3];
		var part = {css: css, media: media, sourceMap: sourceMap};

		if(!newStyles[id]) styles.push(newStyles[id] = {id: id, parts: [part]});
		else newStyles[id].parts.push(part);
	}

	return styles;
}

function insertStyleElement (options, style) {
	var target = getElement(options.insertInto)

	if (!target) {
		throw new Error("Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.");
	}

	var lastStyleElementInsertedAtTop = stylesInsertedAtTop[stylesInsertedAtTop.length - 1];

	if (options.insertAt === "top") {
		if (!lastStyleElementInsertedAtTop) {
			target.insertBefore(style, target.firstChild);
		} else if (lastStyleElementInsertedAtTop.nextSibling) {
			target.insertBefore(style, lastStyleElementInsertedAtTop.nextSibling);
		} else {
			target.appendChild(style);
		}
		stylesInsertedAtTop.push(style);
	} else if (options.insertAt === "bottom") {
		target.appendChild(style);
	} else if (typeof options.insertAt === "object" && options.insertAt.before) {
		var nextSibling = getElement(options.insertAt.before, target);
		target.insertBefore(style, nextSibling);
	} else {
		throw new Error("[Style Loader]\n\n Invalid value for parameter 'insertAt' ('options.insertAt') found.\n Must be 'top', 'bottom', or Object.\n (https://github.com/webpack-contrib/style-loader#insertat)\n");
	}
}

function removeStyleElement (style) {
	if (style.parentNode === null) return false;
	style.parentNode.removeChild(style);

	var idx = stylesInsertedAtTop.indexOf(style);
	if(idx >= 0) {
		stylesInsertedAtTop.splice(idx, 1);
	}
}

function createStyleElement (options) {
	var style = document.createElement("style");

	if(options.attrs.type === undefined) {
		options.attrs.type = "text/css";
	}

	if(options.attrs.nonce === undefined) {
		var nonce = getNonce();
		if (nonce) {
			options.attrs.nonce = nonce;
		}
	}

	addAttrs(style, options.attrs);
	insertStyleElement(options, style);

	return style;
}

function createLinkElement (options) {
	var link = document.createElement("link");

	if(options.attrs.type === undefined) {
		options.attrs.type = "text/css";
	}
	options.attrs.rel = "stylesheet";

	addAttrs(link, options.attrs);
	insertStyleElement(options, link);

	return link;
}

function addAttrs (el, attrs) {
	Object.keys(attrs).forEach(function (key) {
		el.setAttribute(key, attrs[key]);
	});
}

function getNonce() {
	if (false) {}

	return __webpack_require__.nc;
}

function addStyle (obj, options) {
	var style, update, remove, result;

	// If a transform function was defined, run it on the css
	if (options.transform && obj.css) {
	    result = typeof options.transform === 'function'
		 ? options.transform(obj.css) 
		 : options.transform.default(obj.css);

	    if (result) {
	    	// If transform returns a value, use that instead of the original css.
	    	// This allows running runtime transformations on the css.
	    	obj.css = result;
	    } else {
	    	// If the transform function returns a falsy value, don't add this css.
	    	// This allows conditional loading of css
	    	return function() {
	    		// noop
	    	};
	    }
	}

	if (options.singleton) {
		var styleIndex = singletonCounter++;

		style = singleton || (singleton = createStyleElement(options));

		update = applyToSingletonTag.bind(null, style, styleIndex, false);
		remove = applyToSingletonTag.bind(null, style, styleIndex, true);

	} else if (
		obj.sourceMap &&
		typeof URL === "function" &&
		typeof URL.createObjectURL === "function" &&
		typeof URL.revokeObjectURL === "function" &&
		typeof Blob === "function" &&
		typeof btoa === "function"
	) {
		style = createLinkElement(options);
		update = updateLink.bind(null, style, options);
		remove = function () {
			removeStyleElement(style);

			if(style.href) URL.revokeObjectURL(style.href);
		};
	} else {
		style = createStyleElement(options);
		update = applyToTag.bind(null, style);
		remove = function () {
			removeStyleElement(style);
		};
	}

	update(obj);

	return function updateStyle (newObj) {
		if (newObj) {
			if (
				newObj.css === obj.css &&
				newObj.media === obj.media &&
				newObj.sourceMap === obj.sourceMap
			) {
				return;
			}

			update(obj = newObj);
		} else {
			remove();
		}
	};
}

var replaceText = (function () {
	var textStore = [];

	return function (index, replacement) {
		textStore[index] = replacement;

		return textStore.filter(Boolean).join('\n');
	};
})();

function applyToSingletonTag (style, index, remove, obj) {
	var css = remove ? "" : obj.css;

	if (style.styleSheet) {
		style.styleSheet.cssText = replaceText(index, css);
	} else {
		var cssNode = document.createTextNode(css);
		var childNodes = style.childNodes;

		if (childNodes[index]) style.removeChild(childNodes[index]);

		if (childNodes.length) {
			style.insertBefore(cssNode, childNodes[index]);
		} else {
			style.appendChild(cssNode);
		}
	}
}

function applyToTag (style, obj) {
	var css = obj.css;
	var media = obj.media;

	if(media) {
		style.setAttribute("media", media)
	}

	if(style.styleSheet) {
		style.styleSheet.cssText = css;
	} else {
		while(style.firstChild) {
			style.removeChild(style.firstChild);
		}

		style.appendChild(document.createTextNode(css));
	}
}

function updateLink (link, options, obj) {
	var css = obj.css;
	var sourceMap = obj.sourceMap;

	/*
		If convertToAbsoluteUrls isn't defined, but sourcemaps are enabled
		and there is no publicPath defined then lets turn convertToAbsoluteUrls
		on by default.  Otherwise default to the convertToAbsoluteUrls option
		directly
	*/
	var autoFixUrls = options.convertToAbsoluteUrls === undefined && sourceMap;

	if (options.convertToAbsoluteUrls || autoFixUrls) {
		css = fixUrls(css);
	}

	if (sourceMap) {
		// http://stackoverflow.com/a/26603875
		css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
	}

	var blob = new Blob([css], { type: "text/css" });

	var oldSrc = link.href;

	link.href = URL.createObjectURL(blob);

	if(oldSrc) URL.revokeObjectURL(oldSrc);
}


/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
var TexConstant;

(function (TexConstant) {
  TexConstant.Variant = {
    NORMAL: 'normal',
    BOLD: 'bold',
    ITALIC: 'italic',
    BOLDITALIC: 'bold-italic',
    DOUBLESTRUCK: 'double-struck',
    FRAKTUR: 'fraktur',
    BOLDFRAKTUR: 'bold-fraktur',
    SCRIPT: 'script',
    BOLDSCRIPT: 'bold-script',
    SANSSERIF: 'sans-serif',
    BOLDSANSSERIF: 'bold-sans-serif',
    SANSSERIFITALIC: 'sans-serif-italic',
    SANSSERIFBOLDITALIC: 'sans-serif-bold-italic',
    MONOSPACE: 'monospace',
    INITIAL: 'inital',
    TAILED: 'tailed',
    LOOPED: 'looped',
    STRETCHED: 'stretched',
    CALIGRAPHIC: '-tex-caligraphic',
    OLDSTYLE: '-tex-oldstyle'
  };
  TexConstant.Form = {
    PREFIX: 'prefix',
    INFIX: 'infix',
    POSTFIX: 'postfix'
  };
  TexConstant.LineBreak = {
    AUTO: 'auto',
    NEWLINE: 'newline',
    NOBREAK: 'nobreak',
    GOODBREAK: 'goodbreak',
    BADBREAK: 'badbreak'
  };
  TexConstant.LineBreakStyle = {
    BEFORE: 'before',
    AFTER: 'after',
    DUPLICATE: 'duplicate',
    INFIXLINBREAKSTYLE: 'infixlinebreakstyle'
  };
  TexConstant.IndentAlign = {
    LEFT: 'left',
    CENTER: 'center',
    RIGHT: 'right',
    AUTO: 'auto',
    ID: 'id',
    INDENTALIGN: 'indentalign'
  };
  TexConstant.IndentShift = {
    INDENTSHIFT: 'indentshift'
  };
  TexConstant.LineThickness = {
    THIN: 'thin',
    MEDIUM: 'medium',
    THICK: 'thick'
  };
  TexConstant.Notation = {
    LONGDIV: 'longdiv',
    ACTUARIAL: 'actuarial',
    RADICAL: 'radical',
    BOX: 'box',
    ROUNDEDBOX: 'roundedbox',
    CIRCLE: 'circle',
    LEFT: 'left',
    RIGHT: 'right',
    TOP: 'top',
    BOTTOM: 'bottom',
    UPDIAGONALSTRIKE: 'updiagonalstrike',
    DOWNDIAGONALSTRIKE: 'downdiagonalstrike',
    UPDIAGONALARROW: 'updiagonalarrow',
    VERTICALSTRIKE: 'verticalstrike',
    HORIZONTALSTRIKE: 'horizontalstrike',
    PHASORANGLE: 'phasorangle',
    MADRUWB: 'madruwb'
  };
  TexConstant.Align = {
    TOP: 'top',
    BOTTOM: 'bottom',
    CENTER: 'center',
    BASELINE: 'baseline',
    AXIS: 'axis',
    LEFT: 'left',
    RIGHT: 'right'
  };
  TexConstant.Lines = {
    NONE: 'none',
    SOLID: 'solid',
    DASHED: 'dashed'
  };
  TexConstant.Side = {
    LEFT: 'left',
    RIGHT: 'right',
    LEFTOVERLAP: 'leftoverlap',
    RIGHTOVERLAP: 'rightoverlap'
  };
  TexConstant.Width = {
    AUTO: 'auto',
    FIT: 'fit'
  };
  TexConstant.Actiontype = {
    TOGGLE: 'toggle',
    STATUSLINE: 'statusline',
    TOOLTIP: 'tooltip',
    INPUT: 'input'
  };
  TexConstant.Length = {
    VERYVERYTHINMATHSPACE: 'veryverythinmathspace',
    VERYTHINMATHSPACE: 'verythinmathspace',
    THINMATHSPACE: 'thinmathspace',
    MEDIUMMATHSPACE: 'mediummathspace',
    THICKMATHSPACE: 'thickmathspace',
    VERYTHICKMATHSPACE: 'verythickmathspace',
    VERYVERYTHICKMATHSPACE: 'veryverythickmathspace',
    NEGATIVEVERYVERYTHINMATHSPACE: 'negativeveryverythinmathspace',
    NEGATIVEVERYTHINMATHSPACE: 'negativeverythinmathspace',
    NEGATIVETHINMATHSPACE: 'negativethinmathspace',
    NEGATIVEMEDIUMMATHSPACE: 'negativemediummathspace',
    NEGATIVETHICKMATHSPACE: 'negativethickmathspace',
    NEGATIVEVERYTHICKMATHSPACE: 'negativeverythickmathspace',
    NEGATIVEVERYVERYTHICKMATHSPACE: 'negativeveryverythickmathspace'
  };
  TexConstant.Overflow = {
    LINBREAK: 'linebreak',
    SCROLL: 'scroll',
    ELIDE: 'elide',
    TRUNCATE: 'truncate',
    SCALE: 'scale'
  };
  TexConstant.Unit = {
    EM: 'em',
    EX: 'ex',
    PX: 'px',
    IN: 'in',
    CM: 'cm',
    MM: 'mm',
    PT: 'pt',
    PC: 'pc'
  };
})(TexConstant = exports.TexConstant || (exports.TexConstant = {}));

/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var ParseUtil_js_1 = __webpack_require__(9);

var Stack_js_1 = __webpack_require__(236);

var TexError_js_1 = __webpack_require__(6);

var TexParser = function () {
  function TexParser(_string, env, configuration) {
    this._string = _string;
    this.configuration = configuration;
    this.macroCount = 0;
    this.i = 0;
    this.currentCS = '';
    var inner = env.hasOwnProperty('isInner');
    var isInner = env['isInner'];
    delete env['isInner'];
    var ENV;

    if (env) {
      ENV = {};

      try {
        for (var _a = __values(Object.keys(env)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var id = _b.value;
          ENV[id] = env[id];
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }
    }

    this.configuration.pushParser(this);
    this.stack = new Stack_js_1.default(this.itemFactory, ENV, inner ? isInner : true);
    this.Parse();
    this.Push(this.itemFactory.create('stop'));

    var e_1, _c;
  }

  Object.defineProperty(TexParser.prototype, "options", {
    get: function () {
      return this.configuration.options;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(TexParser.prototype, "itemFactory", {
    get: function () {
      return this.configuration.itemFactory;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(TexParser.prototype, "tags", {
    get: function () {
      return this.configuration.tags;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(TexParser.prototype, "string", {
    get: function () {
      return this._string;
    },
    set: function (str) {
      this._string = str;
    },
    enumerable: true,
    configurable: true
  });

  TexParser.prototype.parse = function (kind, input) {
    return this.configuration.handlers.get(kind).parse(input);
  };

  TexParser.prototype.lookup = function (kind, symbol) {
    return this.configuration.handlers.get(kind).lookup(symbol);
  };

  TexParser.prototype.contains = function (kind, symbol) {
    return this.configuration.handlers.get(kind).contains(symbol);
  };

  TexParser.prototype.toString = function () {
    var str = '';

    try {
      for (var _a = __values(Array.from(this.configuration.handlers.keys())), _b = _a.next(); !_b.done; _b = _a.next()) {
        var config = _b.value;
        str += config + ': ' + this.configuration.handlers.get(config) + '\n';
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    return str;

    var e_2, _c;
  };

  TexParser.prototype.Parse = function () {
    var c;
    var n;

    while (this.i < this.string.length) {
      c = this.string.charAt(this.i++);
      n = c.charCodeAt(0);

      if (n >= 0xD800 && n < 0xDC00) {
        c += this.string.charAt(this.i++);
      }

      this.parse('character', [this, c]);
    }
  };

  TexParser.prototype.Push = function (arg) {
    this.stack.Push(arg);
  };

  TexParser.prototype.PushAll = function (args) {
    try {
      for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
        var arg = args_1_1.value;
        this.stack.Push(arg);
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    var e_3, _a;
  };

  TexParser.prototype.mml = function () {
    if (!this.stack.Top().isKind('mml')) {
      return null;
    }

    var node = this.stack.Top().First;
    this.configuration.popParser();
    return node;
  };

  TexParser.prototype.convertDelimiter = function (c) {
    var symbol = this.lookup('delimiter', c);
    return symbol ? symbol.char : null;
  };

  TexParser.prototype.nextIsSpace = function () {
    return this.string.charAt(this.i).match(/\s/);
  };

  TexParser.prototype.GetNext = function () {
    while (this.nextIsSpace()) {
      this.i++;
    }

    return this.string.charAt(this.i);
  };

  TexParser.prototype.GetCS = function () {
    var CS = this.string.slice(this.i).match(/^([a-z]+|.) ?/i);

    if (CS) {
      this.i += CS[1].length;
      return CS[1];
    } else {
      this.i++;
      return ' ';
    }
  };

  TexParser.prototype.GetArgument = function (name, noneOK) {
    switch (this.GetNext()) {
      case '':
        if (!noneOK) {
          throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', this.currentCS);
        }

        return null;

      case '}':
        if (!noneOK) {
          throw new TexError_js_1.default('ExtraCloseMissingOpen', 'Extra close brace or missing open brace');
        }

        return null;

      case '\\':
        this.i++;
        return '\\' + this.GetCS();

      case '{':
        var j = ++this.i,
            parens = 1;

        while (this.i < this.string.length) {
          switch (this.string.charAt(this.i++)) {
            case '\\':
              this.i++;
              break;

            case '{':
              parens++;
              break;

            case '}':
              if (--parens === 0) {
                return this.string.slice(j, this.i - 1);
              }

              break;
          }
        }

        throw new TexError_js_1.default('MissingCloseBrace', 'Missing close brace');
    }

    return this.string.charAt(this.i++);
  };

  TexParser.prototype.GetBrackets = function (name, def) {
    if (this.GetNext() !== '[') {
      return def;
    }

    var j = ++this.i,
        parens = 0;

    while (this.i < this.string.length) {
      switch (this.string.charAt(this.i++)) {
        case '{':
          parens++;
          break;

        case '\\':
          this.i++;
          break;

        case '}':
          if (parens-- <= 0) {
            throw new TexError_js_1.default('ExtraCloseLooking', 'Extra close brace while looking for %1', '\']\'');
          }

          break;

        case ']':
          if (parens === 0) {
            return this.string.slice(j, this.i - 1);
          }

          break;
      }
    }

    throw new TexError_js_1.default('MissingCloseBracket', 'Could not find closing \']\' for argument to %1', this.currentCS);
  };

  TexParser.prototype.GetDelimiter = function (name, braceOK) {
    while (this.nextIsSpace()) {
      this.i++;
    }

    var c = this.string.charAt(this.i);
    this.i++;

    if (this.i <= this.string.length) {
      if (c === '\\') {
        c += this.GetCS();
      } else if (c === '{' && braceOK) {
        this.i--;
        c = this.GetArgument(name);
      }

      if (this.contains('delimiter', c)) {
        return this.convertDelimiter(c);
      }
    }

    throw new TexError_js_1.default('MissingOrUnrecognizedDelim', 'Missing or unrecognized delimiter for %1', this.currentCS);
  };

  TexParser.prototype.GetDimen = function (name) {
    if (this.nextIsSpace()) {
      this.i++;
    }

    if (this.string.charAt(this.i) === '{') {
      var dimen = this.GetArgument(name);

      var _a = __read(ParseUtil_js_1.default.matchDimen(dimen), 3),
          value = _a[0],
          unit = _a[1],
          _ = _a[2];

      if (value) {
        return value + unit;
      }
    } else {
      var dimen = this.string.slice(this.i);

      var _b = __read(ParseUtil_js_1.default.matchDimen(dimen, true), 3),
          value = _b[0],
          unit = _b[1],
          length_1 = _b[2];

      if (value) {
        this.i += length_1;
        return value + unit;
      }
    }

    throw new TexError_js_1.default('MissingDimOrUnits', 'Missing dimension or its units for %1', this.currentCS);
  };

  TexParser.prototype.GetUpTo = function (name, token) {
    while (this.nextIsSpace()) {
      this.i++;
    }

    var j = this.i;
    var parens = 0;

    while (this.i < this.string.length) {
      var k = this.i;
      var c = this.string.charAt(this.i++);

      switch (c) {
        case '\\':
          c += this.GetCS();
          break;

        case '{':
          parens++;
          break;

        case '}':
          if (parens === 0) {
            throw new TexError_js_1.default('ExtraCloseLooking', 'Extra close brace while looking for %1', token);
          }

          parens--;
          break;
      }

      if (parens === 0 && c === token) {
        return this.string.slice(j, k);
      }
    }

    throw new TexError_js_1.default('TokenNotFoundForCommand', 'Could not find %1 for %2', token, this.currentCS);
  };

  TexParser.prototype.ParseArg = function (name) {
    return new TexParser(this.GetArgument(name), this.stack.env, this.configuration).mml();
  };

  TexParser.prototype.ParseUpTo = function (name, token) {
    return new TexParser(this.GetUpTo(name, token), this.stack.env, this.configuration).mml();
  };

  TexParser.prototype.GetDelimiterArg = function (name) {
    var c = ParseUtil_js_1.default.trimSpaces(this.GetArgument(name));

    if (c === '') {
      return null;
    }

    if (this.contains('delimiter', c)) {
      return c;
    }

    throw new TexError_js_1.default('MissingOrUnrecognizedDelim', 'Missing or unrecognized delimiter for %1', this.currentCS);
  };

  TexParser.prototype.GetStar = function () {
    var star = this.GetNext() === '*';

    if (star) {
      this.i++;
    }

    return star;
  };

  TexParser.prototype.create = function (kind) {
    var rest = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      rest[_i - 1] = arguments[_i];
    }

    return (_a = this.configuration.nodeFactory).create.apply(_a, __spread([kind], rest));

    var _a;
  };

  return TexParser;
}();

exports.default = TexParser;

/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

function sortLength(a, b) {
  return a.length !== b.length ? b.length - a.length : a === b ? 0 : a < b ? -1 : 1;
}

exports.sortLength = sortLength;

function quotePattern(text) {
  return text.replace(/([\^$(){}+*?\-|\[\]\:\\])/g, '\\$1');
}

exports.quotePattern = quotePattern;

function unicodeChars(text) {
  var unicode = [];

  for (var i = 0, m = text.length; i < m; i++) {
    var n = text.charCodeAt(i);

    if (n >= 0xD800 && n < 0xDBFF) {
      n = (n - 0xD800 << 10) + (text.charCodeAt(i++) - 0xDC00) + 0x10000;
    }

    unicode.push(n);
  }

  return unicode;
}

exports.unicodeChars = unicodeChars;

function isPercent(x) {
  return !!x.match(/%\s*$/);
}

exports.isPercent = isPercent;

function split(x) {
  return x.trim().split(/\s+/);
}

exports.split = split;

/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});
var MapHandler;

(function (MapHandler) {
  var maps = new Map();

  MapHandler.register = function (map) {
    maps.set(map.name, map);
  };

  MapHandler.getMap = function (name) {
    return maps.get(name);
  };
})(MapHandler = exports.MapHandler || (exports.MapHandler = {}));

exports.ExtensionMaps = {
  NEW_MACRO: 'new-Macro',
  NEW_DELIMITER: 'new-Delimiter',
  NEW_COMMAND: 'new-Command',
  NEW_ENVIRONMENT: 'new-Environment'
};

var SubHandler = function () {
  function SubHandler(maps, _fallback) {
    this._fallback = _fallback;
    this._configuration = [];

    try {
      for (var maps_1 = __values(maps), maps_1_1 = maps_1.next(); !maps_1_1.done; maps_1_1 = maps_1.next()) {
        var name_1 = maps_1_1.value;
        this.add(name_1);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (maps_1_1 && !maps_1_1.done && (_a = maps_1.return)) _a.call(maps_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _a;
  }

  SubHandler.prototype.add = function (name) {
    var map = MapHandler.getMap(name);

    if (!map) {
      this.warn('Configuration ' + name + ' not found! Omitted.');
      return;
    }

    this._configuration.push(map);
  };

  SubHandler.prototype.parse = function (input) {
    try {
      for (var _a = __values(this._configuration), _b = _a.next(); !_b.done; _b = _a.next()) {
        var map = _b.value;
        var result = map.parse(input);

        if (result) {
          return result;
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var _d = __read(input, 2),
        env = _d[0],
        symbol = _d[1];

    this._fallback(env, symbol);

    var e_2, _c;
  };

  SubHandler.prototype.lookup = function (symbol) {
    var map = this.applicable(symbol);
    return map ? map.lookup(symbol) : null;
  };

  SubHandler.prototype.contains = function (symbol) {
    return this.applicable(symbol) ? true : false;
  };

  SubHandler.prototype.toString = function () {
    return this._configuration.map(function (x) {
      return x.name;
    }).join(', ');
  };

  SubHandler.prototype.applicable = function (symbol) {
    try {
      for (var _a = __values(this._configuration), _b = _a.next(); !_b.done; _b = _a.next()) {
        var map = _b.value;

        if (map.contains(symbol)) {
          return map;
        }
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    return null;

    var e_3, _c;
  };

  SubHandler.prototype.retrieve = function (name) {
    return this._configuration.find(function (x) {
      return x.name === name;
    });
  };

  SubHandler.prototype.warn = function (message) {
    console.log('TexParser Warning: ' + message);
  };

  return SubHandler;
}();

exports.SubHandler = SubHandler;

var SubHandlers = function () {
  function SubHandlers(config) {
    this.map = new Map();

    try {
      for (var _a = __values(Object.keys(config.handler)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var key = _b.value;
        var name_2 = key;
        var subHandler = new SubHandler(config.handler[name_2] || [], config.fallback[name_2]);
        this.set(name_2, subHandler);
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    var e_4, _c;
  }

  SubHandlers.prototype.set = function (name, subHandler) {
    this.map.set(name, subHandler);
  };

  SubHandlers.prototype.get = function (name) {
    return this.map.get(name);
  };

  SubHandlers.prototype.retrieve = function (name) {
    try {
      for (var _a = __values(this.map.values()), _b = _a.next(); !_b.done; _b = _a.next()) {
        var handler = _b.value;
        var map = handler.retrieve(name);

        if (map) {
          return map;
        }
      }
    } catch (e_5_1) {
      e_5 = {
        error: e_5_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_5) throw e_5.error;
      }
    }

    return null;

    var e_5, _c;
  };

  SubHandlers.prototype.keys = function () {
    return this.map.keys();
  };

  return SubHandlers;
}();

exports.SubHandlers = SubHandlers;

/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Retries_js_1 = __webpack_require__(70);

var AsyncLoad_js_1 = __webpack_require__(235);

exports.options = {
  loadMissingEntities: true
};
exports.entities = {
  ApplyFunction: '\u2061',
  Backslash: '\u2216',
  Because: '\u2235',
  Breve: '\u02D8',
  Cap: '\u22D2',
  CenterDot: '\u00B7',
  CircleDot: '\u2299',
  CircleMinus: '\u2296',
  CirclePlus: '\u2295',
  CircleTimes: '\u2297',
  Congruent: '\u2261',
  ContourIntegral: '\u222E',
  Coproduct: '\u2210',
  Cross: '\u2A2F',
  Cup: '\u22D3',
  CupCap: '\u224D',
  Dagger: '\u2021',
  Del: '\u2207',
  Delta: '\u0394',
  Diamond: '\u22C4',
  DifferentialD: '\u2146',
  DotEqual: '\u2250',
  DoubleDot: '\u00A8',
  DoubleRightTee: '\u22A8',
  DoubleVerticalBar: '\u2225',
  DownArrow: '\u2193',
  DownLeftVector: '\u21BD',
  DownRightVector: '\u21C1',
  DownTee: '\u22A4',
  Downarrow: '\u21D3',
  Element: '\u2208',
  EqualTilde: '\u2242',
  Equilibrium: '\u21CC',
  Exists: '\u2203',
  ExponentialE: '\u2147',
  FilledVerySmallSquare: '\u25AA',
  ForAll: '\u2200',
  Gamma: '\u0393',
  Gg: '\u22D9',
  GreaterEqual: '\u2265',
  GreaterEqualLess: '\u22DB',
  GreaterFullEqual: '\u2267',
  GreaterLess: '\u2277',
  GreaterSlantEqual: '\u2A7E',
  GreaterTilde: '\u2273',
  Hacek: '\u02C7',
  Hat: '\u005E',
  HumpDownHump: '\u224E',
  HumpEqual: '\u224F',
  Im: '\u2111',
  ImaginaryI: '\u2148',
  Integral: '\u222B',
  Intersection: '\u22C2',
  InvisibleComma: '\u2063',
  InvisibleTimes: '\u2062',
  Lambda: '\u039B',
  Larr: '\u219E',
  LeftAngleBracket: '\u27E8',
  LeftArrow: '\u2190',
  LeftArrowRightArrow: '\u21C6',
  LeftCeiling: '\u2308',
  LeftDownVector: '\u21C3',
  LeftFloor: '\u230A',
  LeftRightArrow: '\u2194',
  LeftTee: '\u22A3',
  LeftTriangle: '\u22B2',
  LeftTriangleEqual: '\u22B4',
  LeftUpVector: '\u21BF',
  LeftVector: '\u21BC',
  Leftarrow: '\u21D0',
  Leftrightarrow: '\u21D4',
  LessEqualGreater: '\u22DA',
  LessFullEqual: '\u2266',
  LessGreater: '\u2276',
  LessSlantEqual: '\u2A7D',
  LessTilde: '\u2272',
  Ll: '\u22D8',
  Lleftarrow: '\u21DA',
  LongLeftArrow: '\u27F5',
  LongLeftRightArrow: '\u27F7',
  LongRightArrow: '\u27F6',
  Longleftarrow: '\u27F8',
  Longleftrightarrow: '\u27FA',
  Longrightarrow: '\u27F9',
  Lsh: '\u21B0',
  MinusPlus: '\u2213',
  NestedGreaterGreater: '\u226B',
  NestedLessLess: '\u226A',
  NotDoubleVerticalBar: '\u2226',
  NotElement: '\u2209',
  NotEqual: '\u2260',
  NotExists: '\u2204',
  NotGreater: '\u226F',
  NotGreaterEqual: '\u2271',
  NotLeftTriangle: '\u22EA',
  NotLeftTriangleEqual: '\u22EC',
  NotLess: '\u226E',
  NotLessEqual: '\u2270',
  NotPrecedes: '\u2280',
  NotPrecedesSlantEqual: '\u22E0',
  NotRightTriangle: '\u22EB',
  NotRightTriangleEqual: '\u22ED',
  NotSubsetEqual: '\u2288',
  NotSucceeds: '\u2281',
  NotSucceedsSlantEqual: '\u22E1',
  NotSupersetEqual: '\u2289',
  NotTilde: '\u2241',
  NotVerticalBar: '\u2224',
  Omega: '\u03A9',
  OverBar: '\u203E',
  OverBrace: '\u23DE',
  PartialD: '\u2202',
  Phi: '\u03A6',
  Pi: '\u03A0',
  PlusMinus: '\u00B1',
  Precedes: '\u227A',
  PrecedesEqual: '\u2AAF',
  PrecedesSlantEqual: '\u227C',
  PrecedesTilde: '\u227E',
  Product: '\u220F',
  Proportional: '\u221D',
  Psi: '\u03A8',
  Rarr: '\u21A0',
  Re: '\u211C',
  ReverseEquilibrium: '\u21CB',
  RightAngleBracket: '\u27E9',
  RightArrow: '\u2192',
  RightArrowLeftArrow: '\u21C4',
  RightCeiling: '\u2309',
  RightDownVector: '\u21C2',
  RightFloor: '\u230B',
  RightTee: '\u22A2',
  RightTeeArrow: '\u21A6',
  RightTriangle: '\u22B3',
  RightTriangleEqual: '\u22B5',
  RightUpVector: '\u21BE',
  RightVector: '\u21C0',
  Rightarrow: '\u21D2',
  Rrightarrow: '\u21DB',
  Rsh: '\u21B1',
  Sigma: '\u03A3',
  SmallCircle: '\u2218',
  Sqrt: '\u221A',
  Square: '\u25A1',
  SquareIntersection: '\u2293',
  SquareSubset: '\u228F',
  SquareSubsetEqual: '\u2291',
  SquareSuperset: '\u2290',
  SquareSupersetEqual: '\u2292',
  SquareUnion: '\u2294',
  Star: '\u22C6',
  Subset: '\u22D0',
  SubsetEqual: '\u2286',
  Succeeds: '\u227B',
  SucceedsEqual: '\u2AB0',
  SucceedsSlantEqual: '\u227D',
  SucceedsTilde: '\u227F',
  SuchThat: '\u220B',
  Sum: '\u2211',
  Superset: '\u2283',
  SupersetEqual: '\u2287',
  Supset: '\u22D1',
  Therefore: '\u2234',
  Theta: '\u0398',
  Tilde: '\u223C',
  TildeEqual: '\u2243',
  TildeFullEqual: '\u2245',
  TildeTilde: '\u2248',
  UnderBar: '\u005F',
  UnderBrace: '\u23DF',
  Union: '\u22C3',
  UnionPlus: '\u228E',
  UpArrow: '\u2191',
  UpDownArrow: '\u2195',
  UpTee: '\u22A5',
  Uparrow: '\u21D1',
  Updownarrow: '\u21D5',
  Upsilon: '\u03A5',
  Vdash: '\u22A9',
  Vee: '\u22C1',
  VerticalBar: '\u2223',
  VerticalTilde: '\u2240',
  Vvdash: '\u22AA',
  Wedge: '\u22C0',
  Xi: '\u039E',
  amp: '\u0026',
  acute: '\u00B4',
  aleph: '\u2135',
  alpha: '\u03B1',
  amalg: '\u2A3F',
  and: '\u2227',
  ang: '\u2220',
  angmsd: '\u2221',
  angsph: '\u2222',
  ape: '\u224A',
  backprime: '\u2035',
  backsim: '\u223D',
  backsimeq: '\u22CD',
  beta: '\u03B2',
  beth: '\u2136',
  between: '\u226C',
  bigcirc: '\u25EF',
  bigodot: '\u2A00',
  bigoplus: '\u2A01',
  bigotimes: '\u2A02',
  bigsqcup: '\u2A06',
  bigstar: '\u2605',
  bigtriangledown: '\u25BD',
  bigtriangleup: '\u25B3',
  biguplus: '\u2A04',
  blacklozenge: '\u29EB',
  blacktriangle: '\u25B4',
  blacktriangledown: '\u25BE',
  blacktriangleleft: '\u25C2',
  bowtie: '\u22C8',
  boxdl: '\u2510',
  boxdr: '\u250C',
  boxminus: '\u229F',
  boxplus: '\u229E',
  boxtimes: '\u22A0',
  boxul: '\u2518',
  boxur: '\u2514',
  bsol: '\u005C',
  bull: '\u2022',
  cap: '\u2229',
  check: '\u2713',
  chi: '\u03C7',
  circ: '\u02C6',
  circeq: '\u2257',
  circlearrowleft: '\u21BA',
  circlearrowright: '\u21BB',
  circledR: '\u00AE',
  circledS: '\u24C8',
  circledast: '\u229B',
  circledcirc: '\u229A',
  circleddash: '\u229D',
  clubs: '\u2663',
  colon: '\u003A',
  comp: '\u2201',
  ctdot: '\u22EF',
  cuepr: '\u22DE',
  cuesc: '\u22DF',
  cularr: '\u21B6',
  cup: '\u222A',
  curarr: '\u21B7',
  curlyvee: '\u22CE',
  curlywedge: '\u22CF',
  dagger: '\u2020',
  daleth: '\u2138',
  ddarr: '\u21CA',
  deg: '\u00B0',
  delta: '\u03B4',
  digamma: '\u03DD',
  div: '\u00F7',
  divideontimes: '\u22C7',
  dot: '\u02D9',
  doteqdot: '\u2251',
  dotplus: '\u2214',
  dotsquare: '\u22A1',
  dtdot: '\u22F1',
  ecir: '\u2256',
  efDot: '\u2252',
  egs: '\u2A96',
  ell: '\u2113',
  els: '\u2A95',
  empty: '\u2205',
  epsi: '\u03B5',
  epsiv: '\u03F5',
  erDot: '\u2253',
  eta: '\u03B7',
  eth: '\u00F0',
  flat: '\u266D',
  fork: '\u22D4',
  frown: '\u2322',
  gEl: '\u2A8C',
  gamma: '\u03B3',
  gap: '\u2A86',
  gimel: '\u2137',
  gnE: '\u2269',
  gnap: '\u2A8A',
  gne: '\u2A88',
  gnsim: '\u22E7',
  gt: '\u003E',
  gtdot: '\u22D7',
  harrw: '\u21AD',
  hbar: '\u210F',
  hellip: '\u2026',
  hookleftarrow: '\u21A9',
  hookrightarrow: '\u21AA',
  imath: '\u0131',
  infin: '\u221E',
  intcal: '\u22BA',
  iota: '\u03B9',
  jmath: '\u0237',
  kappa: '\u03BA',
  kappav: '\u03F0',
  lEg: '\u2A8B',
  lambda: '\u03BB',
  lap: '\u2A85',
  larrlp: '\u21AB',
  larrtl: '\u21A2',
  lbrace: '\u007B',
  lbrack: '\u005B',
  le: '\u2264',
  leftleftarrows: '\u21C7',
  leftthreetimes: '\u22CB',
  lessdot: '\u22D6',
  lmoust: '\u23B0',
  lnE: '\u2268',
  lnap: '\u2A89',
  lne: '\u2A87',
  lnsim: '\u22E6',
  longmapsto: '\u27FC',
  looparrowright: '\u21AC',
  lowast: '\u2217',
  loz: '\u25CA',
  lt: '\u003C',
  ltimes: '\u22C9',
  ltri: '\u25C3',
  macr: '\u00AF',
  malt: '\u2720',
  mho: '\u2127',
  mu: '\u03BC',
  multimap: '\u22B8',
  nLeftarrow: '\u21CD',
  nLeftrightarrow: '\u21CE',
  nRightarrow: '\u21CF',
  nVDash: '\u22AF',
  nVdash: '\u22AE',
  natur: '\u266E',
  nearr: '\u2197',
  nharr: '\u21AE',
  nlarr: '\u219A',
  not: '\u00AC',
  nrarr: '\u219B',
  nu: '\u03BD',
  nvDash: '\u22AD',
  nvdash: '\u22AC',
  nwarr: '\u2196',
  omega: '\u03C9',
  omicron: '\u03BF',
  or: '\u2228',
  osol: '\u2298',
  period: '\u002E',
  phi: '\u03C6',
  phiv: '\u03D5',
  pi: '\u03C0',
  piv: '\u03D6',
  prap: '\u2AB7',
  precnapprox: '\u2AB9',
  precneqq: '\u2AB5',
  precnsim: '\u22E8',
  prime: '\u2032',
  psi: '\u03C8',
  quot: '\u0022',
  rarrtl: '\u21A3',
  rbrace: '\u007D',
  rbrack: '\u005D',
  rho: '\u03C1',
  rhov: '\u03F1',
  rightrightarrows: '\u21C9',
  rightthreetimes: '\u22CC',
  ring: '\u02DA',
  rmoust: '\u23B1',
  rtimes: '\u22CA',
  rtri: '\u25B9',
  scap: '\u2AB8',
  scnE: '\u2AB6',
  scnap: '\u2ABA',
  scnsim: '\u22E9',
  sdot: '\u22C5',
  searr: '\u2198',
  sect: '\u00A7',
  sharp: '\u266F',
  sigma: '\u03C3',
  sigmav: '\u03C2',
  simne: '\u2246',
  smile: '\u2323',
  spades: '\u2660',
  sub: '\u2282',
  subE: '\u2AC5',
  subnE: '\u2ACB',
  subne: '\u228A',
  supE: '\u2AC6',
  supnE: '\u2ACC',
  supne: '\u228B',
  swarr: '\u2199',
  tau: '\u03C4',
  theta: '\u03B8',
  thetav: '\u03D1',
  tilde: '\u02DC',
  times: '\u00D7',
  triangle: '\u25B5',
  triangleq: '\u225C',
  upsi: '\u03C5',
  upuparrows: '\u21C8',
  veebar: '\u22BB',
  vellip: '\u22EE',
  weierp: '\u2118',
  xi: '\u03BE',
  yen: '\u00A5',
  zeta: '\u03B6',
  zigrarr: '\u21DD'
};
var loaded = {};

function add(additions, file) {
  Object.assign(exports.entities, additions);
  loaded[file] = true;
}

exports.add = add;

function remove(entity) {
  delete exports.entities[entity];
}

exports.remove = remove;

function translate(text) {
  return text.replace(/&([a-z][a-z0-9]*|#(?:[0-9]+|x[0-9a-f]+));/ig, replace);
}

exports.translate = translate;

function replace(match, entity) {
  if (entity.charAt(0) === '#') {
    return numeric(entity.slice(1));
  }

  if (exports.entities[entity]) {
    return exports.entities[entity];
  }

  if (exports.options['loadMissingEntities']) {
    var file = entity.match(/^[a-zA-Z](fr|scr|opf)$/) ? RegExp.$1 : entity.charAt(0).toLowerCase();

    if (!loaded[file]) {
      loaded[file] = true;
      Retries_js_1.retryAfter(AsyncLoad_js_1.asyncLoad('./util/entities/' + file + '.js'));
    }
  }

  return match;
}

function numeric(entity) {
  var n = entity.charAt(0) === 'x' ? parseInt(entity.slice(1), 16) : parseInt(entity);

  if (n < 0x10000) {
    return String.fromCharCode(n);
  }

  n -= 0x10000;
  var hi = (n >> 10) + 0xD800;
  var lo = (n & 0x3FF) + 0xDC00;
  return String.fromCharCode(hi, lo);
}

exports.numeric = numeric;

/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var sitem = __webpack_require__(48);

var NodeUtil_js_1 = __webpack_require__(8);

var TexError_js_1 = __webpack_require__(6);

var TexParser_js_1 = __webpack_require__(15);

var TexConstants_js_1 = __webpack_require__(14);

var ParseUtil_js_1 = __webpack_require__(9);

var MmlNode_js_1 = __webpack_require__(0);

var Tags_js_1 = __webpack_require__(35);

var Entities_js_1 = __webpack_require__(18);

__webpack_require__(72);

__webpack_require__(240);

__webpack_require__(241);

var BaseMethods = {};
var P_HEIGHT = 1.2 / .85;
var MmlTokenAllow = {
  fontfamily: 1,
  fontsize: 1,
  fontweight: 1,
  fontstyle: 1,
  color: 1,
  background: 1,
  id: 1,
  'class': 1,
  href: 1,
  style: 1
};

BaseMethods.Open = function (parser, c) {
  parser.Push(parser.itemFactory.create('open'));
};

BaseMethods.Close = function (parser, c) {
  parser.Push(parser.itemFactory.create('close'));
};

BaseMethods.Tilde = function (parser, c) {
  parser.Push(parser.create('token', 'mtext', {}, Entities_js_1.entities.nbsp));
};

BaseMethods.Space = function (parser, c) {};

BaseMethods.Superscript = function (parser, c) {
  if (parser.GetNext().match(/\d/)) {
    parser.string = parser.string.substr(0, parser.i + 1) + ' ' + parser.string.substr(parser.i + 1);
  }

  var primes;
  var base;
  var top = parser.stack.Top();

  if (top.isKind('prime')) {
    _a = __read(top.Peek(2), 2), base = _a[0], primes = _a[1];
    parser.stack.Pop();
  } else {
    base = parser.stack.Prev();

    if (!base) {
      base = parser.create('token', 'mi', {}, '');
    }
  }

  var movesupsub = NodeUtil_js_1.default.getProperty(base, 'movesupsub');
  var position = NodeUtil_js_1.default.isType(base, 'msubsup') ? base.sup : base.over;

  if (NodeUtil_js_1.default.isType(base, 'msubsup') && NodeUtil_js_1.default.getChildAt(base, base.sup) || NodeUtil_js_1.default.isType(base, 'munderover') && NodeUtil_js_1.default.getChildAt(base, base.over) && !NodeUtil_js_1.default.getProperty(base, 'subsupOK')) {
    throw new TexError_js_1.default('DoubleExponent', 'Double exponent: use braces to clarify');
  }

  if (!NodeUtil_js_1.default.isType(base, 'msubsup')) {
    if (movesupsub) {
      if (!NodeUtil_js_1.default.isType(base, 'munderover') || NodeUtil_js_1.default.getChildAt(base, base.over)) {
        if (NodeUtil_js_1.default.getProperty(base, 'movablelimits') && NodeUtil_js_1.default.isType(base, 'mi')) {
          base = ParseUtil_js_1.default.mi2mo(parser, base);
        }

        base = parser.create('node', 'munderover', [base], {
          movesupsub: true
        });
      }

      position = base.over;
    } else {
      base = parser.create('node', 'msubsup', [base]);
      position = base.sup;
    }
  }

  parser.Push(parser.itemFactory.create('subsup', base).setProperties({
    position: position,
    primes: primes,
    movesupsub: movesupsub
  }));

  var _a;
};

BaseMethods.Subscript = function (parser, c) {
  if (parser.GetNext().match(/\d/)) {
    parser.string = parser.string.substr(0, parser.i + 1) + ' ' + parser.string.substr(parser.i + 1);
  }

  var primes, base;
  var top = parser.stack.Top();

  if (top.isKind('prime')) {
    _a = __read(top.Peek(2), 2), base = _a[0], primes = _a[1];
    parser.stack.Pop();
  } else {
    base = parser.stack.Prev();

    if (!base) {
      base = parser.create('token', 'mi', {}, '');
    }
  }

  var movesupsub = NodeUtil_js_1.default.getProperty(base, 'movesupsub');
  var position = NodeUtil_js_1.default.isType(base, 'msubsup') ? base.sub : base.under;

  if (NodeUtil_js_1.default.isType(base, 'msubsup') && NodeUtil_js_1.default.getChildAt(base, base.sub) || NodeUtil_js_1.default.isType(base, 'munderover') && NodeUtil_js_1.default.getChildAt(base, base.under) && !NodeUtil_js_1.default.getProperty(base, 'subsupOK')) {
    throw new TexError_js_1.default('DoubleSubscripts', 'Double subscripts: use braces to clarify');
  }

  if (!NodeUtil_js_1.default.isType(base, 'msubsup')) {
    if (movesupsub) {
      if (!NodeUtil_js_1.default.isType(base, 'munderover') || NodeUtil_js_1.default.getChildAt(base, base.under)) {
        if (NodeUtil_js_1.default.getProperty(base, 'movablelimits') && NodeUtil_js_1.default.isType(base, 'mi')) {
          base = ParseUtil_js_1.default.mi2mo(parser, base);
        }

        base = parser.create('node', 'munderover', [base], {
          movesupsub: true
        });
      }

      position = base.under;
    } else {
      base = parser.create('node', 'msubsup', [base]);
      position = base.sub;
    }
  }

  parser.Push(parser.itemFactory.create('subsup', base).setProperties({
    position: position,
    primes: primes,
    movesupsub: movesupsub
  }));

  var _a;
};

BaseMethods.Prime = function (parser, c) {
  var base = parser.stack.Prev();

  if (!base) {
    base = parser.create('node', 'mi');
  }

  if (NodeUtil_js_1.default.isType(base, 'msubsup') && NodeUtil_js_1.default.getChildAt(base, base.sup)) {
    throw new TexError_js_1.default('DoubleExponentPrime', 'Prime causes double exponent: use braces to clarify');
  }

  var sup = '';
  parser.i--;

  do {
    sup += Entities_js_1.entities.prime;
    parser.i++, c = parser.GetNext();
  } while (c === '\'' || c === Entities_js_1.entities.rquote);

  sup = ['', '\u2032', '\u2033', '\u2034', '\u2057'][sup.length] || sup;
  var node = parser.create('token', 'mo', {}, sup);
  parser.Push(parser.itemFactory.create('prime', base, node));
};

BaseMethods.Comment = function (parser, c) {
  while (parser.i < parser.string.length && parser.string.charAt(parser.i) !== '\n') {
    parser.i++;
  }
};

BaseMethods.Hash = function (parser, c) {
  throw new TexError_js_1.default('CantUseHash1', 'You can\'t use \'macro parameter character #\' in math mode');
};

BaseMethods.SetFont = function (parser, name, font) {
  parser.stack.env['font'] = font;
};

BaseMethods.SetStyle = function (parser, name, texStyle, style, level) {
  parser.stack.env['style'] = texStyle;
  parser.stack.env['level'] = level;
  parser.Push(parser.itemFactory.create('style').setProperty('styles', {
    displaystyle: style,
    scriptlevel: level
  }));
};

BaseMethods.SetSize = function (parser, name, size) {
  parser.stack.env['size'] = size;
  parser.Push(parser.itemFactory.create('style').setProperty('styles', {
    mathsize: size + 'em'
  }));
};

BaseMethods.Color = function (parser, name) {
  var color = parser.GetArgument(name);
  var old = parser.stack.env['color'];
  parser.stack.env['color'] = color;
  var math = parser.ParseArg(name);

  if (old) {
    parser.stack.env['color'] = old;
  } else {
    delete parser.stack.env['color'];
  }

  var node = parser.create('node', 'mstyle', [math], {
    mathcolor: color
  });
  parser.Push(node);
};

BaseMethods.Spacer = function (parser, name, space) {
  var node = parser.create('node', 'mspace', [], {
    width: space
  });
  var style = parser.create('node', 'mstyle', [node], {
    scriptlevel: 0
  });
  parser.Push(style);
};

BaseMethods.LeftRight = function (parser, name) {
  var first = name.substr(1);
  parser.Push(parser.itemFactory.create(first).setProperty('delim', parser.GetDelimiter(name)));
};

BaseMethods.Middle = function (parser, name) {
  var delim = parser.GetDelimiter(name);
  var node = parser.create('node', 'TeXAtom', [], {
    texClass: MmlNode_js_1.TEXCLASS.CLOSE
  });
  parser.Push(node);

  if (!parser.stack.Top().isKind('left')) {
    throw new TexError_js_1.default('MisplacedMiddle', '%1 must be within \\left and \\right', parser.currentCS);
  }

  node = parser.create('token', 'mo', {
    stretchy: true
  }, delim);
  parser.Push(node);
  node = parser.create('node', 'TeXAtom', [], {
    texClass: MmlNode_js_1.TEXCLASS.OPEN
  });
  parser.Push(node);
};

BaseMethods.NamedFn = function (parser, name, id) {
  if (!id) {
    id = name.substr(1);
  }

  var mml = parser.create('token', 'mi', {
    texClass: MmlNode_js_1.TEXCLASS.OP
  }, id);
  parser.Push(parser.itemFactory.create('fn', mml));
};

BaseMethods.NamedOp = function (parser, name, id) {
  if (!id) {
    id = name.substr(1);
  }

  id = id.replace(/&thinsp;/, '\u2006');
  var mml = parser.create('token', 'mo', {
    movablelimits: true,
    movesupsub: true,
    form: TexConstants_js_1.TexConstant.Form.PREFIX,
    texClass: MmlNode_js_1.TEXCLASS.OP
  }, id);
  parser.Push(mml);
};

BaseMethods.Limits = function (parser, name, limits) {
  var op = parser.stack.Prev(true);

  if (!op || NodeUtil_js_1.default.getTexClass(NodeUtil_js_1.default.getCoreMO(op)) !== MmlNode_js_1.TEXCLASS.OP && NodeUtil_js_1.default.getProperty(op, 'movesupsub') == null) {
    throw new TexError_js_1.default('MisplacedLimits', '%1 is allowed only on operators', parser.currentCS);
  }

  var top = parser.stack.Top();
  var node;

  if (NodeUtil_js_1.default.isType(op, 'munderover') && !limits) {
    node = parser.create('node', 'msubsup');
    NodeUtil_js_1.default.copyChildren(op, node);
    op = top.Last = node;
  } else if (NodeUtil_js_1.default.isType(op, 'msubsup') && limits) {
    node = parser.create('node', 'munderover');
    NodeUtil_js_1.default.copyChildren(op, node);
    op = top.Last = node;
  }

  NodeUtil_js_1.default.setProperty(op, 'movesupsub', limits ? true : false);
  NodeUtil_js_1.default.setProperties(NodeUtil_js_1.default.getCoreMO(op), {
    'movablelimits': false
  });

  if (NodeUtil_js_1.default.getAttribute(op, 'movablelimits') || NodeUtil_js_1.default.getProperty(op, 'movablelimits')) {
    NodeUtil_js_1.default.setProperties(op, {
      'movablelimits': false
    });
  }
};

BaseMethods.Over = function (parser, name, open, close) {
  var mml = parser.itemFactory.create('over').setProperty('name', parser.currentCS);

  if (open || close) {
    mml.setProperty('open', open);
    mml.setProperty('close', close);
  } else if (name.match(/withdelims$/)) {
    mml.setProperty('open', parser.GetDelimiter(name));
    mml.setProperty('close', parser.GetDelimiter(name));
  }

  if (name.match(/^\\above/)) {
    mml.setProperty('thickness', parser.GetDimen(name));
  } else if (name.match(/^\\atop/) || open || close) {
    mml.setProperty('thickness', 0);
  }

  parser.Push(mml);
};

BaseMethods.Frac = function (parser, name) {
  var num = parser.ParseArg(name);
  var den = parser.ParseArg(name);
  var node = parser.create('node', 'mfrac', [num, den]);
  parser.Push(node);
};

BaseMethods.Sqrt = function (parser, name) {
  var n = parser.GetBrackets(name);
  var arg = parser.GetArgument(name);

  if (arg === '\\frac') {
    arg += '{' + parser.GetArgument(arg) + '}{' + parser.GetArgument(arg) + '}';
  }

  var mml = new TexParser_js_1.default(arg, parser.stack.env, parser.configuration).mml();

  if (!n) {
    mml = parser.create('node', 'msqrt', [mml]);
  } else {
    mml = parser.create('node', 'mroot', [mml, parseRoot(parser, n)]);
  }

  parser.Push(mml);
};

function parseRoot(parser, n) {
  var env = parser.stack.env;
  var inRoot = env['inRoot'];
  env['inRoot'] = true;
  var newParser = new TexParser_js_1.default(n, env, parser.configuration);
  var node = newParser.mml();
  var global = newParser.stack.global;

  if (global['leftRoot'] || global['upRoot']) {
    var def = {};

    if (global['leftRoot']) {
      def['width'] = global['leftRoot'];
    }

    if (global['upRoot']) {
      def['voffset'] = global['upRoot'];
      def['height'] = global['upRoot'];
    }

    node = parser.create('node', 'mpadded', [node], def);
  }

  env['inRoot'] = inRoot;
  return node;
}

;

BaseMethods.Root = function (parser, name) {
  var n = parser.GetUpTo(name, '\\of');
  var arg = parser.ParseArg(name);
  var node = parser.create('node', 'mroot', [arg, parseRoot(parser, n)]);
  parser.Push(node);
};

BaseMethods.MoveRoot = function (parser, name, id) {
  if (!parser.stack.env['inRoot']) {
    throw new TexError_js_1.default('MisplacedMoveRoot', '%1 can appear only within a root', parser.currentCS);
  }

  if (parser.stack.global[id]) {
    throw new TexError_js_1.default('MultipleMoveRoot', 'Multiple use of %1', parser.currentCS);
  }

  var n = parser.GetArgument(name);

  if (!n.match(/-?[0-9]+/)) {
    throw new TexError_js_1.default('IntegerArg', 'The argument to %1 must be an integer', parser.currentCS);
  }

  n = parseInt(n, 10) / 15 + 'em';

  if (n.substr(0, 1) !== '-') {
    n = '+' + n;
  }

  parser.stack.global[id] = n;
};

BaseMethods.Accent = function (parser, name, accent, stretchy) {
  var c = parser.ParseArg(name);
  var def = ParseUtil_js_1.default.getFontDef(parser);
  def['accent'] = true;
  var entity = NodeUtil_js_1.default.createEntity(accent);
  var moNode = parser.create('token', 'mo', def, entity);
  var mml = moNode;
  NodeUtil_js_1.default.setAttribute(mml, 'stretchy', stretchy ? true : false);
  var mo = NodeUtil_js_1.default.isEmbellished(c) ? NodeUtil_js_1.default.getCoreMO(c) : c;

  if (NodeUtil_js_1.default.isType(mo, 'mo')) {
    NodeUtil_js_1.default.setProperties(mo, {
      'movablelimits': false
    });
  }

  var muoNode = parser.create('node', 'munderover');
  NodeUtil_js_1.default.setChild(muoNode, 0, c);
  NodeUtil_js_1.default.setChild(muoNode, 1, null);
  NodeUtil_js_1.default.setChild(muoNode, 2, mml);
  var texAtom = parser.create('node', 'TeXAtom', [muoNode]);
  parser.Push(texAtom);
};

BaseMethods.UnderOver = function (parser, name, c, stack, noaccent) {
  var base = parser.ParseArg(name);
  var symbol = NodeUtil_js_1.default.getForm(base);

  if (symbol && symbol[3] && symbol[3]['movablelimits'] || NodeUtil_js_1.default.getProperty(base, 'movablelimits')) {
    NodeUtil_js_1.default.setProperties(base, {
      'movablelimits': false
    });
  }

  var mo;

  if (NodeUtil_js_1.default.isType(base, 'munderover') && NodeUtil_js_1.default.isEmbellished(base)) {
    NodeUtil_js_1.default.setProperties(NodeUtil_js_1.default.getCoreMO(base), {
      lspace: 0,
      rspace: 0
    });
    mo = parser.create('node', 'mo', [], {
      rspace: 0
    });
    base = parser.create('node', 'mrow', [mo, base]);
  }

  var mml = parser.create('node', 'munderover', [base]);
  var entity = NodeUtil_js_1.default.createEntity(c);
  mo = parser.create('token', 'mo', {
    stretchy: true,
    accent: !noaccent
  }, entity);
  NodeUtil_js_1.default.setChild(mml, name.charAt(1) === 'o' ? mml.over : mml.under, mo);
  var node = mml;

  if (stack) {
    node = parser.create('node', 'TeXAtom', [mml], {
      texClass: MmlNode_js_1.TEXCLASS.OP,
      movesupsub: true
    });
  }

  NodeUtil_js_1.default.setProperty(node, 'subsupOK', true);
  parser.Push(node);
};

BaseMethods.Overset = function (parser, name) {
  var top = parser.ParseArg(name),
      base = parser.ParseArg(name);

  if (NodeUtil_js_1.default.getAttribute(base, 'movablelimits') || NodeUtil_js_1.default.getProperty(base, 'movablelimits')) {
    NodeUtil_js_1.default.setProperties(base, {
      'movablelimits': false
    });
  }

  var node = parser.create('node', 'mover', [base, top]);
  parser.Push(node);
};

BaseMethods.Underset = function (parser, name) {
  var bot = parser.ParseArg(name),
      base = parser.ParseArg(name);

  if (NodeUtil_js_1.default.getAttribute(base, 'movablelimits') || NodeUtil_js_1.default.getProperty(base, 'movablelimits')) {
    NodeUtil_js_1.default.setProperties(base, {
      'movablelimits': false
    });
  }

  var node = parser.create('node', 'munder', [base, bot]);
  parser.Push(node);
};

BaseMethods.TeXAtom = function (parser, name, mclass) {
  var def = {
    texClass: mclass
  };
  var mml;
  var node;
  var parsed;

  if (mclass === MmlNode_js_1.TEXCLASS.OP) {
    def['movesupsub'] = def['movablelimits'] = true;
    var arg = parser.GetArgument(name);
    var match = arg.match(/^\s*\\rm\s+([a-zA-Z0-9 ]+)$/);

    if (match) {
      def['mathvariant'] = TexConstants_js_1.TexConstant.Variant.NORMAL;
      node = parser.create('token', 'mi', def, match[1]);
    } else {
      parsed = new TexParser_js_1.default(arg, parser.stack.env, parser.configuration).mml();
      node = parser.create('node', 'TeXAtom', [parsed], def);
    }

    mml = parser.itemFactory.create('fn', node);
  } else {
    parsed = parser.ParseArg(name);
    mml = parser.create('node', 'TeXAtom', [parsed], def);
  }

  parser.Push(mml);
};

BaseMethods.MmlToken = function (parser, name) {
  var kind = parser.GetArgument(name);
  var attr = parser.GetBrackets(name, '').replace(/^\s+/, '');
  var text = parser.GetArgument(name);
  var def = {};
  var node;

  try {
    node = parser.create('node', kind);
  } catch (e) {
    node = null;
  }

  if (!node || !node.isToken) {
    throw new TexError_js_1.default('NotMathMLToken', '%1 is not a token element', kind);
  }

  while (attr !== '') {
    var match = attr.match(/^([a-z]+)\s*=\s*('[^']*'|"[^"]*"|[^ ,]*)\s*,?\s*/i);

    if (!match) {
      throw new TexError_js_1.default('InvalidMathMLAttr', 'Invalid MathML attribute: %1', attr);
    }

    if (!node.attributes.hasDefault(match[1]) && !MmlTokenAllow[match[1]]) {
      throw new TexError_js_1.default('UnknownAttrForElement', '%1 is not a recognized attribute for %2', match[1], kind);
    }

    var value = ParseUtil_js_1.default.MmlFilterAttribute(parser, match[1], match[2].replace(/^(['"])(.*)\1$/, '$2'));

    if (value) {
      if (value.toLowerCase() === 'true') {
        value = true;
      } else if (value.toLowerCase() === 'false') {
        value = false;
      }

      def[match[1]] = value;
    }

    attr = attr.substr(match[0].length);
  }

  var textNode = parser.create('text', text);
  node.appendChild(textNode);
  NodeUtil_js_1.default.setProperties(node, def);
  parser.Push(node);
};

BaseMethods.Strut = function (parser, name) {
  var row = parser.create('node', 'mrow');
  var padded = parser.create('node', 'mpadded', [row], {
    height: '8.6pt',
    depth: '3pt',
    width: 0
  });
  parser.Push(padded);
};

BaseMethods.Phantom = function (parser, name, v, h) {
  var box = parser.create('node', 'mphantom', [parser.ParseArg(name)]);

  if (v || h) {
    box = parser.create('node', 'mpadded', [box]);

    if (h) {
      NodeUtil_js_1.default.setAttribute(box, 'height', 0);
      NodeUtil_js_1.default.setAttribute(box, 'depth', 0);
    }

    if (v) {
      NodeUtil_js_1.default.setAttribute(box, 'width', 0);
    }
  }

  var atom = parser.create('node', 'TeXAtom', [box]);
  parser.Push(atom);
};

BaseMethods.Smash = function (parser, name) {
  var bt = ParseUtil_js_1.default.trimSpaces(parser.GetBrackets(name, ''));
  var smash = parser.create('node', 'mpadded', [parser.ParseArg(name)]);

  switch (bt) {
    case 'b':
      NodeUtil_js_1.default.setAttribute(smash, 'depth', 0);
      break;

    case 't':
      NodeUtil_js_1.default.setAttribute(smash, 'height', 0);
      break;

    default:
      NodeUtil_js_1.default.setAttribute(smash, 'height', 0);
      NodeUtil_js_1.default.setAttribute(smash, 'depth', 0);
  }

  var atom = parser.create('node', 'TeXAtom', [smash]);
  parser.Push(atom);
};

BaseMethods.Lap = function (parser, name) {
  var mml = parser.create('node', 'mpadded', [parser.ParseArg(name)], {
    width: 0
  });

  if (name === '\\llap') {
    NodeUtil_js_1.default.setAttribute(mml, 'lspace', '-1width');
  }

  var atom = parser.create('node', 'TeXAtom', [mml]);
  parser.Push(atom);
};

BaseMethods.RaiseLower = function (parser, name) {
  var h = parser.GetDimen(name);
  var item = parser.itemFactory.create('position').setProperties({
    name: parser.currentCS,
    move: 'vertical'
  });

  if (h.charAt(0) === '-') {
    h = h.slice(1);
    name = name.substr(1) === 'raise' ? '\\lower' : '\\raise';
  }

  if (name === '\\lower') {
    item.setProperty('dh', '-' + h);
    item.setProperty('dd', '+' + h);
  } else {
    item.setProperty('dh', '+' + h);
    item.setProperty('dd', '-' + h);
  }

  parser.Push(item);
};

BaseMethods.MoveLeftRight = function (parser, name) {
  var h = parser.GetDimen(name);
  var nh = h.charAt(0) === '-' ? h.slice(1) : '-' + h;

  if (name === '\\moveleft') {
    var tmp = h;
    h = nh;
    nh = tmp;
  }

  parser.Push(parser.itemFactory.create('position').setProperties({
    name: parser.currentCS,
    move: 'horizontal',
    left: parser.create('node', 'mspace', [], {
      width: h
    }),
    right: parser.create('node', 'mspace', [], {
      width: nh
    })
  }));
};

BaseMethods.Hskip = function (parser, name) {
  var node = parser.create('node', 'mspace', [], {
    width: parser.GetDimen(name)
  });
  parser.Push(node);
};

BaseMethods.Rule = function (parser, name, style) {
  var w = parser.GetDimen(name),
      h = parser.GetDimen(name),
      d = parser.GetDimen(name);
  var def = {
    width: w,
    height: h,
    depth: d
  };

  if (style !== 'blank') {
    def['mathbackground'] = parser.stack.env['color'] || 'black';
  }

  var node = parser.create('node', 'mspace', [], def);
  parser.Push(node);
};

BaseMethods.rule = function (parser, name) {
  var v = parser.GetBrackets(name),
      w = parser.GetDimen(name),
      h = parser.GetDimen(name);
  var mml = parser.create('node', 'mspace', [], {
    width: w,
    height: h,
    mathbackground: parser.stack.env['color'] || 'black'
  });

  if (v) {
    mml = parser.create('node', 'mpadded', [mml], {
      voffset: v
    });

    if (v.match(/^\-/)) {
      NodeUtil_js_1.default.setAttribute(mml, 'height', v);
      NodeUtil_js_1.default.setAttribute(mml, 'depth', '+' + v.substr(1));
    } else {
      NodeUtil_js_1.default.setAttribute(mml, 'height', '+' + v);
    }
  }

  parser.Push(mml);
};

BaseMethods.MakeBig = function (parser, name, mclass, size) {
  size *= P_HEIGHT;
  var sizeStr = String(size).replace(/(\.\d\d\d).+/, '$1') + 'em';
  var delim = parser.GetDelimiter(name, true);
  var mo = parser.create('token', 'mo', {
    minsize: sizeStr,
    maxsize: sizeStr,
    fence: true,
    stretchy: true,
    symmetric: true
  }, delim);
  var node = parser.create('node', 'TeXAtom', [mo], {
    texClass: mclass
  });
  parser.Push(node);
};

BaseMethods.BuildRel = function (parser, name) {
  var top = parser.ParseUpTo(name, '\\over');
  var bot = parser.ParseArg(name);
  var node = parser.create('node', 'munderover');
  NodeUtil_js_1.default.setChild(node, 0, bot);
  NodeUtil_js_1.default.setChild(node, 1, null);
  NodeUtil_js_1.default.setChild(node, 2, top);
  var atom = parser.create('node', 'TeXAtom', [node], {
    texClass: MmlNode_js_1.TEXCLASS.REL
  });
  parser.Push(atom);
};

BaseMethods.HBox = function (parser, name, style) {
  parser.PushAll(ParseUtil_js_1.default.internalMath(parser, parser.GetArgument(name), style));
};

BaseMethods.FBox = function (parser, name) {
  var internal = ParseUtil_js_1.default.internalMath(parser, parser.GetArgument(name));
  var node = parser.create('node', 'menclose', internal, {
    notation: 'box'
  });
  parser.Push(node);
};

BaseMethods.Not = function (parser, name) {
  parser.Push(parser.itemFactory.create('not'));
};

BaseMethods.Dots = function (parser, name) {
  var ldotsEntity = NodeUtil_js_1.default.createEntity('2026');
  var cdotsEntity = NodeUtil_js_1.default.createEntity('22EF');
  var ldots = parser.create('token', 'mo', {
    stretchy: false
  }, ldotsEntity);
  var cdots = parser.create('token', 'mo', {
    stretchy: false
  }, cdotsEntity);
  parser.Push(parser.itemFactory.create('dots').setProperties({
    ldots: ldots,
    cdots: cdots
  }));
};

BaseMethods.Matrix = function (parser, name, open, close, align, spacing, vspacing, style, cases, numbered) {
  var c = parser.GetNext();

  if (c === '') {
    throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', parser.currentCS);
  }

  if (c === '{') {
    parser.i++;
  } else {
    parser.string = c + '}' + parser.string.slice(parser.i + 1);
    parser.i = 0;
  }

  var array = parser.itemFactory.create('array').setProperty('requireClose', true);
  array.arraydef = {
    rowspacing: vspacing || '4pt',
    columnspacing: spacing || '1em'
  };

  if (cases) {
    array.setProperty('isCases', true);
  }

  if (numbered) {
    array.setProperty('isNumbered', true);
    array.arraydef.side = numbered;
  }

  if (open || close) {
    array.setProperty('open', open);
    array.setProperty('close', close);
  }

  if (style === 'D') {
    array.arraydef.displaystyle = true;
  }

  if (align != null) {
    array.arraydef.columnalign = align;
  }

  parser.Push(array);
};

BaseMethods.Entry = function (parser, name) {
  parser.Push(parser.itemFactory.create('cell').setProperties({
    isEntry: true,
    name: name
  }));

  if (parser.stack.Top().getProperty('isCases')) {
    var str = parser.string;
    var braces = 0,
        close_1 = -1,
        i = parser.i,
        m = str.length;

    while (i < m) {
      var c = str.charAt(i);

      if (c === '{') {
        braces++;
        i++;
      } else if (c === '}') {
        if (braces === 0) {
          m = 0;
        } else {
          braces--;

          if (braces === 0 && close_1 < 0) {
            close_1 = i - parser.i;
          }

          i++;
        }
      } else if (c === '&' && braces === 0) {
        throw new TexError_js_1.default('ExtraAlignTab', 'Extra alignment tab in \\cases text');
      } else if (c === '\\') {
        if (str.substr(i).match(/^((\\cr)[^a-zA-Z]|\\\\)/)) {
          m = 0;
        } else {
          i += 2;
        }
      } else {
        i++;
      }
    }

    var text = str.substr(parser.i, i - parser.i);

    if (!text.match(/^\s*\\text[^a-zA-Z]/) || close_1 !== text.replace(/\s+$/, '').length - 1) {
      var internal = ParseUtil_js_1.default.internalMath(parser, text, 0);
      parser.PushAll(internal);
      parser.i = i;
    }
  }
};

BaseMethods.Cr = function (parser, name) {
  parser.Push(parser.itemFactory.create('cell').setProperties({
    isCR: true,
    name: name
  }));
};

BaseMethods.CrLaTeX = function (parser, name) {
  var n;

  if (parser.string.charAt(parser.i) === '[') {
    var dim = parser.GetBrackets(name, '');

    var _a = __read(ParseUtil_js_1.default.matchDimen(dim), 3),
        value = _a[0],
        unit = _a[1],
        _ = _a[2];

    if (dim && !value) {
      throw new TexError_js_1.default('BracketMustBeDimension', 'Bracket argument to %1 must be a dimension', parser.currentCS);
    }

    n = value + unit;
  }

  parser.Push(parser.itemFactory.create('cell').setProperties({
    isCR: true,
    name: name,
    linebreak: true
  }));
  var top = parser.stack.Top();
  var node;

  if (top instanceof sitem.ArrayItem) {
    if (n && top.arraydef['rowspacing']) {
      var rows = top.arraydef['rowspacing'].split(/ /);

      if (!top.getProperty('rowspacing')) {
        var dimem = ParseUtil_js_1.default.dimen2em(rows[0]);
        top.setProperty('rowspacing', dimem);
      }

      var rowspacing = top.getProperty('rowspacing');

      while (rows.length < top.table.length) {
        rows.push(ParseUtil_js_1.default.Em(rowspacing));
      }

      rows[top.table.length - 1] = ParseUtil_js_1.default.Em(Math.max(0, rowspacing + ParseUtil_js_1.default.dimen2em(n)));
      top.arraydef['rowspacing'] = rows.join(' ');
    }
  } else {
    if (n) {
      node = parser.create('node', 'mspace', [], {
        depth: n
      });
      parser.Push(node);
    }

    node = parser.create('node', 'mspace', [], {
      linebreak: TexConstants_js_1.TexConstant.LineBreak.NEWLINE
    });
    parser.Push(node);
  }
};

BaseMethods.HLine = function (parser, name, style) {
  if (style == null) {
    style = 'solid';
  }

  var top = parser.stack.Top();

  if (!(top instanceof sitem.ArrayItem) || top.Size()) {
    throw new TexError_js_1.default('Misplaced', 'Misplaced %1', parser.currentCS);
  }

  if (!top.table.length) {
    top.frame.push('top');
  } else {
    var lines = top.arraydef['rowlines'] ? top.arraydef['rowlines'].split(/ /) : [];

    while (lines.length < top.table.length) {
      lines.push('none');
    }

    lines[top.table.length - 1] = style;
    top.arraydef['rowlines'] = lines.join(' ');
  }
};

BaseMethods.HFill = function (parser, name) {
  var top = parser.stack.Top();

  if (top instanceof sitem.ArrayItem) {
    top.hfill.push(top.Size());
  } else {
    throw new TexError_js_1.default('UnsupportedHFill', 'Unsupported use of %1', parser.currentCS);
  }
};

BaseMethods.BeginEnd = function (parser, name) {
  var env = parser.GetArgument(name);

  if (env.match(/\\/i)) {
    throw new TexError_js_1.default('InvalidEnv', 'Invalid environment name \'%1\'', env);
  }

  var macro = parser.configuration.handlers.get('environment').lookup(env);

  if (macro && name === '\\end') {
    if (!macro.args[0]) {
      var mml = parser.itemFactory.create('end').setProperty('name', env);
      parser.Push(mml);
      return;
    }

    parser.stack.env['closing'] = env;
  }

  if (++parser.macroCount > parser.configuration.options['maxMacros']) {
    throw new TexError_js_1.default('MaxMacroSub2', 'MathJax maximum substitution count exceeded; ' + 'is there a recursive latex environment?');
  }

  parser.parse('environment', [parser, env]);
};

BaseMethods.Array = function (parser, begin, open, close, align, spacing, vspacing, style, raggedHeight) {
  if (!align) {
    align = parser.GetArgument('\\begin{' + begin.getName() + '}');
  }

  var lines = ('c' + align).replace(/[^clr|:]/g, '').replace(/[^|:]([|:])+/g, '$1');
  align = align.replace(/[^clr]/g, '').split('').join(' ');
  align = align.replace(/l/g, 'left').replace(/r/g, 'right').replace(/c/g, 'center');
  var array = parser.itemFactory.create('array');
  array.arraydef = {
    columnalign: align,
    columnspacing: spacing || '1em',
    rowspacing: vspacing || '4pt'
  };

  if (lines.match(/[|:]/)) {
    if (lines.charAt(0).match(/[|:]/)) {
      array.frame.push('left');
      array.dashed = lines.charAt(0) === ':';
    }

    if (lines.charAt(lines.length - 1).match(/[|:]/)) {
      array.frame.push('right');
    }

    lines = lines.substr(1, lines.length - 2);
    array.arraydef.columnlines = lines.split('').join(' ').replace(/[^|: ]/g, 'none').replace(/\|/g, 'solid').replace(/:/g, 'dashed');
  }

  if (open) {
    array.setProperty('open', parser.convertDelimiter(open));
  }

  if (close) {
    array.setProperty('close', parser.convertDelimiter(close));
  }

  if (style === 'D') {
    array.arraydef['displaystyle'] = true;
  } else if (style) {
    array.arraydef['displaystyle'] = false;
  }

  if (style === 'S') {
    array.arraydef['scriptlevel'] = 1;
  }

  if (raggedHeight) {
    array.arraydef['useHeight'] = false;
  }

  parser.Push(begin);
  return array;
};

BaseMethods.AlignedArray = function (parser, begin) {
  var align = parser.GetBrackets('\\begin{' + begin.getName() + '}');
  var item = BaseMethods.Array(parser, begin);
  return ParseUtil_js_1.default.setArrayAlign(item, align);
};

BaseMethods.Equation = function (parser, begin, numbered) {
  parser.Push(begin);
  ParseUtil_js_1.default.checkEqnEnv(parser);
  return parser.itemFactory.create('equation', numbered).setProperty('name', begin.getName());
};

BaseMethods.EqnArray = function (parser, begin, numbered, taggable, align, spacing) {
  parser.Push(begin);

  if (taggable) {
    ParseUtil_js_1.default.checkEqnEnv(parser);
  }

  align = align.replace(/[^clr]/g, '').split('').join(' ');
  align = align.replace(/l/g, 'left').replace(/r/g, 'right').replace(/c/g, 'center');
  var newItem = parser.itemFactory.create('eqnarray', begin.getName(), numbered, taggable, parser.stack.global);
  newItem.arraydef = {
    displaystyle: true,
    columnalign: align,
    columnspacing: spacing || '1em',
    rowspacing: '3pt',
    side: parser.options['TagSide'],
    minlabelspacing: parser.options['TagIndent']
  };
  return newItem;
};

BaseMethods.HandleNoTag = function (parser, name) {
  parser.tags.notag();
};

BaseMethods.HandleLabel = function (parser, name) {
  var global = parser.stack.global;
  var label = parser.GetArgument(name);

  if (label === '') {
    return;
  }

  if (!parser.options['refUpdate']) {
    if (parser.tags.label) {
      throw new TexError_js_1.default('MultipleCommand', 'Multiple %1', parser.currentCS);
    }

    parser.tags.label = label;

    if (parser.tags.allLabels[label] || parser.tags.labels[label]) {
      throw new TexError_js_1.default('MultipleLabel', 'Label \'%1\' multiply defined', label);
    }

    parser.tags.labels[label] = new Tags_js_1.Label();
  }
};

BaseMethods.HandleRef = function (parser, name, eqref) {
  var label = parser.GetArgument(name);
  var ref = parser.tags.allLabels[label] || parser.tags.labels[label];

  if (!ref) {
    ref = new Tags_js_1.Label();
  }

  var tag = ref.tag;

  if (eqref) {
    tag = parser.tags.formatTag(tag);
  }

  var node = parser.create('node', 'mrow', ParseUtil_js_1.default.internalMath(parser, tag), {
    href: parser.tags.formatUrl(ref.id, parser.options.baseURL),
    'class': 'MathJax_ref'
  });
  parser.Push(node);
};

BaseMethods.Macro = function (parser, name, macro, argcount, def) {
  if (argcount) {
    var args = [];

    if (def != null) {
      var optional = parser.GetBrackets(name);
      args.push(optional == null ? def : optional);
    }

    for (var i = args.length; i < argcount; i++) {
      args.push(parser.GetArgument(name));
    }

    macro = ParseUtil_js_1.default.substituteArgs(parser, args, macro);
  }

  parser.string = ParseUtil_js_1.default.addArgs(parser, macro, parser.string.slice(parser.i));
  parser.i = 0;

  if (++parser.macroCount > parser.configuration.options['maxMacros']) {
    throw new TexError_js_1.default('MaxMacroSub1', 'MathJax maximum macro substitution count exceeded; ' + 'is there a recursive macro call?');
  }
};

BaseMethods.MathChoice = function (parser, name) {
  var D = parser.ParseArg(name);
  var T = parser.ParseArg(name);
  var S = parser.ParseArg(name);
  var SS = parser.ParseArg(name);
  parser.Push(parser.create('node', 'mathchoice', [D, T, S, SS]));
};

exports.default = BaseMethods;

/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


function isNothing(subject) {
  return typeof subject === 'undefined' || subject === null;
}

function isObject(subject) {
  return typeof subject === 'object' && subject !== null;
}

function toArray(sequence) {
  if (Array.isArray(sequence)) return sequence;else if (isNothing(sequence)) return [];
  return [sequence];
}

function extend(target, source) {
  var index, length, key, sourceKeys;

  if (source) {
    sourceKeys = Object.keys(source);

    for (index = 0, length = sourceKeys.length; index < length; index += 1) {
      key = sourceKeys[index];
      target[key] = source[key];
    }
  }

  return target;
}

function repeat(string, count) {
  var result = '',
      cycle;

  for (cycle = 0; cycle < count; cycle += 1) {
    result += string;
  }

  return result;
}

function isNegativeZero(number) {
  return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
}

module.exports.isNothing = isNothing;
module.exports.isObject = isObject;
module.exports.toArray = toArray;
module.exports.repeat = repeat;
module.exports.isNegativeZero = isNegativeZero;
module.exports.extend = extend;

/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/*eslint-disable max-len*/

var common = __webpack_require__(20);

var YAMLException = __webpack_require__(24);

var Type = __webpack_require__(7);

function compileList(schema, name, result) {
  var exclude = [];
  schema.include.forEach(function (includedSchema) {
    result = compileList(includedSchema, name, result);
  });
  schema[name].forEach(function (currentType) {
    result.forEach(function (previousType, previousIndex) {
      if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
        exclude.push(previousIndex);
      }
    });
    result.push(currentType);
  });
  return result.filter(function (type, index) {
    return exclude.indexOf(index) === -1;
  });
}

function compileMap()
/* lists... */
{
  var result = {
    scalar: {},
    sequence: {},
    mapping: {},
    fallback: {}
  },
      index,
      length;

  function collectType(type) {
    result[type.kind][type.tag] = result['fallback'][type.tag] = type;
  }

  for (index = 0, length = arguments.length; index < length; index += 1) {
    arguments[index].forEach(collectType);
  }

  return result;
}

function Schema(definition) {
  this.include = definition.include || [];
  this.implicit = definition.implicit || [];
  this.explicit = definition.explicit || [];
  this.implicit.forEach(function (type) {
    if (type.loadKind && type.loadKind !== 'scalar') {
      throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
    }
  });
  this.compiledImplicit = compileList(this, 'implicit', []);
  this.compiledExplicit = compileList(this, 'explicit', []);
  this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
}

Schema.DEFAULT = null;

Schema.create = function createSchema() {
  var schemas, types;

  switch (arguments.length) {
    case 1:
      schemas = Schema.DEFAULT;
      types = arguments[0];
      break;

    case 2:
      schemas = arguments[0];
      types = arguments[1];
      break;

    default:
      throw new YAMLException('Wrong number of arguments for Schema.create function');
  }

  schemas = common.toArray(schemas);
  types = common.toArray(types);

  if (!schemas.every(function (schema) {
    return schema instanceof Schema;
  })) {
    throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
  }

  if (!types.every(function (type) {
    return type instanceof Type;
  })) {
    throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
  }

  return new Schema({
    include: schemas,
    explicit: types
  });
};

module.exports = Schema;

/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.BIGDIMEN = 1000000;
exports.UNITS = {
  px: 1,
  pt: 96 / 72,
  pc: 96 / 12,
  'in': 96,
  cm: 96 / 2.54,
  mm: 96 / 25.4
};
exports.RELUNITS = {
  em: 1,
  ex: .431,
  mu: 1 / 18
};
exports.MATHSPACE = {
  veryverythinmathspace: 1 / 18,
  verythinmathspace: 2 / 18,
  thinmathspace: 3 / 18,
  mediummathspace: 4 / 18,
  thickmathspace: 5 / 18,
  verythickmathspace: 6 / 18,
  veryverythickmathspace: 7 / 18,
  negativeveryverythinmathspace: -1 / 18,
  negativeverythinmathspace: -2 / 18,
  negativethinmathspace: -3 / 18,
  negativemediummathspace: -4 / 18,
  negativethickmathspace: -5 / 18,
  negativeverythickmathspace: -6 / 18,
  negativeveryverythickmathspace: -7 / 18,
  thin: .04,
  medium: .06,
  thick: .1,
  normal: 1,
  big: 2,
  small: 1 / Math.sqrt(2),
  infinity: exports.BIGDIMEN
};

function length2em(length, size, scale, em) {
  if (size === void 0) {
    size = 0;
  }

  if (scale === void 0) {
    scale = 1;
  }

  if (em === void 0) {
    em = 16;
  }

  if (typeof length !== 'string') {
    length = String(length);
  }

  if (length === '' || length == null) {
    return size;
  }

  if (exports.MATHSPACE[length]) {
    return exports.MATHSPACE[length];
  }

  var match = length.match(/^\s*([-+]?(?:\.\d+|\d+(?:\.\d*)?))?(pt|em|ex|mu|px|pc|in|mm|cm|%)?/);

  if (!match) {
    return size;
  }

  var m = parseFloat(match[1] || '1'),
      unit = match[2];

  if (exports.UNITS.hasOwnProperty(unit)) {
    return m * exports.UNITS[unit] / em / scale;
  }

  if (exports.RELUNITS.hasOwnProperty(unit)) {
    return m * exports.RELUNITS[unit];
  }

  if (unit === '%') {
    return m / 100 * size;
  }

  return m * size;
}

exports.length2em = length2em;

function percent(m) {
  return (100 * m).toFixed(1).replace(/\.?0+$/, '') + '%';
}

exports.percent = percent;

function em(m) {
  if (Math.abs(m) < .001) return '0';
  return m.toFixed(3).replace(/\.?0+$/, '') + 'em';
}

exports.em = em;

function emRounded(m, em) {
  if (em === void 0) {
    em = 16;
  }

  m = (Math.round(m * em) + .05) / em;
  if (Math.abs(m) < .001) return '0em';
  return m.toFixed(3).replace(/\.?0+$/, '') + 'em';
}

exports.emRounded = emRounded;

function px(m, M, em) {
  if (M === void 0) {
    M = -exports.BIGDIMEN;
  }

  if (em === void 0) {
    em = 16;
  }

  m *= em;
  if (M && m < M) m = M;
  if (Math.abs(m) < .1) return '0';
  return m.toFixed(1).replace(/\.0$/, '') + 'px';
}

exports.px = px;

/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var lengths_js_1 = __webpack_require__(22);

exports.BBoxStyleAdjust = [['borderTopWidth', 'h'], ['borderRightWidth', 'w'], ['borderBottomWidth', 'd'], ['borderLeftWidth', 'w', 0], ['paddingTop', 'h'], ['paddingRight', 'w'], ['paddingBottom', 'd'], ['paddingLeft', 'w', 0]];

var BBox = function () {
  function BBox(def) {
    if (def === void 0) {
      def = {
        w: 0,
        h: -lengths_js_1.BIGDIMEN,
        d: -lengths_js_1.BIGDIMEN
      };
    }

    this.w = def.w || 0;
    this.h = 'h' in def ? def.h : -lengths_js_1.BIGDIMEN;
    this.d = 'd' in def ? def.d : -lengths_js_1.BIGDIMEN;
    this.L = this.R = this.ic = this.sk = 0;
    this.scale = this.rscale = 1;
    this.pwidth = '';
  }

  BBox.zero = function () {
    return new BBox({
      h: 0,
      d: 0,
      w: 0
    });
  };

  BBox.empty = function () {
    return new BBox();
  };

  BBox.prototype.empty = function () {
    this.w = 0;
    this.h = this.d = -lengths_js_1.BIGDIMEN;
    return this;
  };

  BBox.prototype.clean = function () {
    if (this.w === -lengths_js_1.BIGDIMEN) this.w = 0;
    if (this.h === -lengths_js_1.BIGDIMEN) this.h = 0;
    if (this.d === -lengths_js_1.BIGDIMEN) this.d = 0;
  };

  BBox.prototype.rescale = function (scale) {
    this.w *= scale;
    this.h *= scale;
    this.d *= scale;
  };

  BBox.prototype.combine = function (cbox, x, y) {
    if (x === void 0) {
      x = 0;
    }

    if (y === void 0) {
      y = 0;
    }

    var rscale = cbox.rscale;
    var w = x + rscale * (cbox.w + cbox.L + cbox.R);
    var h = y + rscale * cbox.h;
    var d = rscale * cbox.d - y;
    if (w > this.w) this.w = w;
    if (h > this.h) this.h = h;
    if (d > this.d) this.d = d;
  };

  BBox.prototype.append = function (cbox) {
    var scale = cbox.rscale;
    this.w += scale * (cbox.w + cbox.L + cbox.R);

    if (scale * cbox.h > this.h) {
      this.h = scale * cbox.h;
    }

    if (scale * cbox.d > this.d) {
      this.d = scale * cbox.d;
    }
  };

  BBox.prototype.updateFrom = function (cbox) {
    this.h = cbox.h;
    this.d = cbox.d;
    this.w = cbox.w;

    if (cbox.pwidth) {
      this.pwidth = cbox.pwidth;
    }
  };

  return BBox;
}();

BBox.fullWidth = '100%';
exports.BBox = BBox;

/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// YAML error class. http://stackoverflow.com/questions/8458984
//


function YAMLException(reason, mark) {
  // Super constructor
  Error.call(this);
  this.name = 'YAMLException';
  this.reason = reason;
  this.mark = mark;
  this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : ''); // Include stack trace in error object

  if (Error.captureStackTrace) {
    // Chrome and NodeJS
    Error.captureStackTrace(this, this.constructor);
  } else {
    // FF, IE 10+ and Safari 6+. Fallback for others
    this.stack = new Error().stack || '';
  }
} // Inherit from Error


YAMLException.prototype = Object.create(Error.prototype);
YAMLException.prototype.constructor = YAMLException;

YAMLException.prototype.toString = function toString(compact) {
  var result = this.name + ': ';
  result += this.reason || '(unknown reason)';

  if (!compact && this.mark) {
    result += ' ' + this.mark.toString();
  }

  return result;
};

module.exports = YAMLException;

/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// JS-YAML's default schema for `safeLoad` function.
// It is not described in the YAML specification.
//
// This schema is based on standard YAML's Core schema and includes most of
// extra types described at YAML tag repository. (http://yaml.org/type/)


var Schema = __webpack_require__(21);

module.exports = new Schema({
  include: [__webpack_require__(56)],
  implicit: [__webpack_require__(124), __webpack_require__(125)],
  explicit: [__webpack_require__(126), __webpack_require__(130), __webpack_require__(131), __webpack_require__(132)]
});

/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.INHERIT = '_inherit_';

var Attributes = function () {
  function Attributes(defaults, global) {
    this.global = global;
    this.defaults = Object.create(global);
    this.inherited = Object.create(this.defaults);
    this.attributes = Object.create(this.inherited);
    Object.assign(this.defaults, defaults);
  }

  Attributes.prototype.set = function (name, value) {
    this.attributes[name] = value;
  };

  Attributes.prototype.setList = function (list) {
    Object.assign(this.attributes, list);
  };

  Attributes.prototype.get = function (name) {
    var value = this.attributes[name];

    if (value === exports.INHERIT) {
      value = this.global[name];
    }

    return value;
  };

  Attributes.prototype.getExplicit = function (name) {
    if (!this.attributes.hasOwnProperty(name)) {
      return undefined;
    }

    return this.attributes[name];
  };

  Attributes.prototype.getList = function () {
    var names = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      names[_i] = arguments[_i];
    }

    var values = {};

    try {
      for (var names_1 = __values(names), names_1_1 = names_1.next(); !names_1_1.done; names_1_1 = names_1.next()) {
        var name_1 = names_1_1.value;
        values[name_1] = this.get(name_1);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (names_1_1 && !names_1_1.done && (_a = names_1.return)) _a.call(names_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    return values;

    var e_1, _a;
  };

  Attributes.prototype.setInherited = function (name, value) {
    this.inherited[name] = value;
  };

  Attributes.prototype.getInherited = function (name) {
    return this.inherited[name];
  };

  Attributes.prototype.getDefault = function (name) {
    return this.defaults[name];
  };

  Attributes.prototype.isSet = function (name) {
    return this.attributes.hasOwnProperty(name) || this.inherited.hasOwnProperty(name);
  };

  Attributes.prototype.hasDefault = function (name) {
    return name in this.defaults;
  };

  Attributes.prototype.getExplicitNames = function () {
    return Object.keys(this.attributes);
  };

  Attributes.prototype.getInheritedNames = function () {
    return Object.keys(this.inherited);
  };

  Attributes.prototype.getDefaultNames = function () {
    return Object.keys(this.defaults);
  };

  Attributes.prototype.getGlobalNames = function () {
    return Object.keys(this.global);
  };

  Attributes.prototype.getAllAttributes = function () {
    return this.attributes;
  };

  Attributes.prototype.getAllInherited = function () {
    return this.inherited;
  };

  Attributes.prototype.getAllDefaults = function () {
    return this.defaults;
  };

  Attributes.prototype.getAllGlobals = function () {
    return this.global;
  };

  return Attributes;
}();

exports.Attributes = Attributes;

/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var TexError_js_1 = __webpack_require__(6);

var MmlStack = function () {
  function MmlStack(_nodes) {
    this._nodes = _nodes;
  }

  Object.defineProperty(MmlStack.prototype, "nodes", {
    get: function () {
      return this._nodes;
    },
    enumerable: true,
    configurable: true
  });

  MmlStack.prototype.Push = function () {
    var nodes = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      nodes[_i] = arguments[_i];
    }

    (_a = this._nodes).push.apply(_a, __spread(nodes));

    var _a;
  };

  MmlStack.prototype.Pop = function () {
    return this._nodes.pop();
  };

  Object.defineProperty(MmlStack.prototype, "First", {
    get: function () {
      return this._nodes[this.Size() - 1];
    },
    set: function (node) {
      this._nodes[this.Size() - 1] = node;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlStack.prototype, "Last", {
    get: function () {
      return this._nodes[0];
    },
    set: function (node) {
      this._nodes[0] = node;
    },
    enumerable: true,
    configurable: true
  });

  MmlStack.prototype.Peek = function (n) {
    if (n == null) {
      n = 1;
    }

    return this._nodes.slice(this.Size() - n);
  };

  MmlStack.prototype.Size = function () {
    return this._nodes.length;
  };

  MmlStack.prototype.Clear = function () {
    this._nodes = [];
  };

  MmlStack.prototype.toMml = function (inferred, forceRow) {
    if (inferred === void 0) {
      inferred = true;
    }

    if (this._nodes.length === 1 && !forceRow) {
      return this.First;
    }

    return this.create('node', inferred ? 'inferredMrow' : 'mrow', this._nodes, {});
  };

  MmlStack.prototype.create = function (kind) {
    var rest = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      rest[_i - 1] = arguments[_i];
    }

    return (_a = this.factory.configuration.nodeFactory).create.apply(_a, __spread([kind], rest));

    var _a;
  };

  return MmlStack;
}();

exports.MmlStack = MmlStack;

var BaseItem = function (_super) {
  __extends(BaseItem, _super);

  function BaseItem(factory) {
    var nodes = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      nodes[_i - 1] = arguments[_i];
    }

    var _this = _super.call(this, nodes) || this;

    _this.factory = factory;
    _this.global = {};
    _this._properties = {};

    if (_this.isOpen) {
      _this._env = {};
    }

    return _this;
  }

  Object.defineProperty(BaseItem.prototype, "kind", {
    get: function () {
      return 'base';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(BaseItem.prototype, "env", {
    get: function () {
      return this._env;
    },
    set: function (value) {
      this._env = value;
    },
    enumerable: true,
    configurable: true
  });

  BaseItem.prototype.getProperty = function (key) {
    return this._properties[key];
  };

  BaseItem.prototype.setProperty = function (key, value) {
    this._properties[key] = value;
    return this;
  };

  Object.defineProperty(BaseItem.prototype, "isOpen", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(BaseItem.prototype, "isClose", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(BaseItem.prototype, "isFinal", {
    get: function () {
      return false;
    },
    enumerable: true,
    configurable: true
  });

  BaseItem.prototype.isKind = function (kind) {
    return kind === this.kind;
  };

  BaseItem.prototype.checkItem = function (item) {
    if (item.isKind('over') && this.isOpen) {
      item.setProperty('num', this.toMml(false));
      this.Clear();
    }

    if (item.isKind('cell') && this.isOpen) {
      if (item.getProperty('linebreak')) {
        return BaseItem.fail;
      }

      throw new TexError_js_1.default('Misplaced', 'Misplaced %1', item.getName());
    }

    if (item.isClose && this.getErrors(item.kind)) {
      var _a = __read(this.getErrors(item.kind), 2),
          id = _a[0],
          message = _a[1];

      throw new TexError_js_1.default(id, message, item.getName());
    }

    if (!item.isFinal) {
      return BaseItem.success;
    }

    this.Push(item.First);
    return BaseItem.fail;
  };

  BaseItem.prototype.clearEnv = function () {
    try {
      for (var _a = __values(Object.keys(this.env)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var id = _b.value;
        delete this.env[id];
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _c;
  };

  BaseItem.prototype.setProperties = function (def) {
    Object.assign(this._properties, def);
    return this;
  };

  BaseItem.prototype.getName = function () {
    return this.getProperty('name');
  };

  BaseItem.prototype.toString = function () {
    return this.kind + '[' + this.nodes.join('; ') + ']';
  };

  BaseItem.prototype.getErrors = function (kind) {
    var CLASS = this.constructor;
    return (CLASS.errors || {})[kind] || BaseItem.errors[kind];
  };

  return BaseItem;
}(MmlStack);

BaseItem.fail = [null, false];
BaseItem.success = [null, true];
BaseItem.errors = {
  end: ['MissingBeginExtraEnd', 'Missing \\begin{%1} or extra \\end{%1}'],
  close: ['ExtraCloseMissingOpen', 'Extra close brace or missing open brace'],
  right: ['MissingLeftExtraRight', 'Missing \\left or extra \\right']
};
exports.BaseItem = BaseItem;

/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var NodeUtil_js_1 = __webpack_require__(8);

var TexConstants_js_1 = __webpack_require__(14);

var ParseUtil_js_1 = __webpack_require__(9);

var ParseMethods;

(function (ParseMethods) {
  function variable(parser, c) {
    var def = ParseUtil_js_1.default.getFontDef(parser);
    var node = parser.create('token', 'mi', def, c);
    parser.Push(node);
  }

  ParseMethods.variable = variable;
  ;

  function digit(parser, c) {
    var mml;
    var pattern = parser.configuration.options['digits'];
    var n = parser.string.slice(parser.i - 1).match(pattern);
    var def = ParseUtil_js_1.default.getFontDef(parser);

    if (n) {
      mml = parser.create('token', 'mn', def, n[0].replace(/[{}]/g, ''));
      parser.i += n[0].length - 1;
    } else {
      mml = parser.create('token', 'mo', def, c);
    }

    parser.Push(mml);
  }

  ParseMethods.digit = digit;
  ;

  function controlSequence(parser, c) {
    var name = parser.GetCS();
    parser.parse('macro', [parser, name]);
  }

  ParseMethods.controlSequence = controlSequence;
  ;

  function mathchar0mi(parser, mchar) {
    var def = mchar.attributes || {
      mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
    };
    var node = parser.create('token', 'mi', def, mchar.char);
    parser.Push(node);
  }

  ParseMethods.mathchar0mi = mathchar0mi;
  ;

  function mathchar0mo(parser, mchar) {
    var def = mchar.attributes || {};
    def['stretchy'] = false;
    var node = parser.create('token', 'mo', def, mchar.char);
    NodeUtil_js_1.default.setProperty(node, 'fixStretchy', true);
    parser.configuration.addNode('fixStretchy', node);
    parser.Push(node);
  }

  ParseMethods.mathchar0mo = mathchar0mo;
  ;

  function mathchar7(parser, mchar) {
    var def = mchar.attributes || {
      mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
    };

    if (parser.stack.env['font']) {
      def['mathvariant'] = parser.stack.env['font'];
    }

    var node = parser.create('token', 'mi', def, mchar.char);
    parser.Push(node);
  }

  ParseMethods.mathchar7 = mathchar7;
  ;

  function delimiter(parser, delim) {
    var def = delim.attributes || {};
    def = Object.assign({
      fence: false,
      stretchy: false
    }, def);
    var node = parser.create('token', 'mo', def, delim.char);
    parser.Push(node);
  }

  ParseMethods.delimiter = delimiter;
  ;

  function environment(parser, env, func, args) {
    var end = args[0];
    var mml = parser.itemFactory.create('begin').setProperties({
      name: env,
      end: end
    });
    mml = func.apply(void 0, __spread([parser, mml], args.slice(1)));
    parser.Push(mml);
  }

  ParseMethods.environment = environment;
  ;
})(ParseMethods || (ParseMethods = {}));

exports.default = ParseMethods;

/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});
;
;
exports.V = 1;
exports.H = 2;
exports.NOSTRETCH = {
  dir: 0
};

var FontData = function () {
  function FontData() {
    this.variant = {};
    this.delimiters = {};
    this.cssFontMap = {};
    this.remapChars = {};
    var CLASS = this.constructor;
    this.params = __assign({}, CLASS.defaultParams);
    this.sizeVariants = __spread(CLASS.defaultSizeVariants);
    this.cssFontMap = __assign({}, CLASS.defaultCssFonts);
    this.createVariants(CLASS.defaultVariants);
    this.defineDelimiters(CLASS.defaultDelimiters);

    try {
      for (var _a = __values(Object.keys(CLASS.defaultChars)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var name_1 = _b.value;
        this.defineChars(name_1, CLASS.defaultChars[name_1]);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    this.defineRemap('accent', CLASS.defaultAccentMap);
    this.defineRemap('mo', CLASS.defaultMoMap);
    this.defineRemap('mn', CLASS.defaultMnMap);

    var e_1, _c;
  }

  FontData.charOptions = function (font, n) {
    var char = font[n];

    if (char.length === 3) {
      char[3] = {};
    }

    return char[3];
  };

  FontData.prototype.createVariant = function (name, inherit, link) {
    if (inherit === void 0) {
      inherit = null;
    }

    if (link === void 0) {
      link = null;
    }

    var variant = {
      linked: [],
      chars: inherit ? Object.create(this.variant[inherit].chars) : {}
    };

    if (link && this.variant[link]) {
      Object.assign(variant.chars, this.variant[link].chars);
      this.variant[link].linked.push(variant.chars);
      variant.chars = Object.create(variant.chars);
    }

    this.variant[name] = variant;
  };

  FontData.prototype.createVariants = function (variants) {
    try {
      for (var variants_1 = __values(variants), variants_1_1 = variants_1.next(); !variants_1_1.done; variants_1_1 = variants_1.next()) {
        var variant = variants_1_1.value;
        this.createVariant(variant[0], variant[1], variant[2]);
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (variants_1_1 && !variants_1_1.done && (_a = variants_1.return)) _a.call(variants_1);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_2, _a;
  };

  FontData.prototype.defineChars = function (name, chars) {
    var variant = this.variant[name];
    Object.assign(variant.chars, chars);

    try {
      for (var _a = __values(variant.linked), _b = _a.next(); !_b.done; _b = _a.next()) {
        var link = _b.value;
        Object.assign(link, chars);
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    var e_3, _c;
  };

  FontData.prototype.defineDelimiters = function (delims) {
    Object.assign(this.delimiters, delims);
  };

  FontData.prototype.defineRemap = function (name, remap) {
    if (!this.remapChars.hasOwnProperty(name)) {
      this.remapChars[name] = {};
    }

    Object.assign(this.remapChars[name], remap);
  };

  FontData.prototype.getDelimiter = function (n) {
    return this.delimiters[n];
  };

  FontData.prototype.getSizeVariant = function (n, i) {
    if (this.delimiters[n].variants) {
      i = this.delimiters[n].variants[i];
    }

    return this.sizeVariants[i];
  };

  FontData.prototype.getChar = function (name, n) {
    return this.variant[name].chars[n];
  };

  FontData.prototype.getVariant = function (name) {
    return this.variant[name];
  };

  FontData.prototype.getCssFont = function (variant) {
    return this.cssFontMap[variant] || ['serif', false, false];
  };

  FontData.prototype.getRemappedChar = function (name, c) {
    var map = this.remapChars[name] || {};
    return map[c];
  };

  return FontData;
}();

FontData.OPTIONS = {};
FontData.defaultVariants = [['normal'], ['bold', 'normal'], ['italic', 'normal'], ['bold-italic', 'italic', 'bold'], ['double-struck', 'bold'], ['fraktur', 'normal'], ['bold-fraktur', 'bold', 'fraktur'], ['script', 'normal'], ['bold-script', 'bold', 'script'], ['sans-serif', 'normal'], ['bold-sans-serif', 'bold', 'sans-serif'], ['sans-serif-italic', 'italic', 'sans-serif'], ['bold-sans-serif-italic', 'bold-italic', 'sans-serif'], ['monospace', 'normal']];
FontData.defaultCssFonts = {
  normal: ['serif', false, false],
  bold: ['serif', false, true],
  italic: ['serif', true, false],
  'bold-italic': ['serif', true, true],
  'double-struck': ['serif', false, true],
  fraktur: ['serif', false, false],
  'bold-fraktur': ['serif', false, true],
  script: ['cursive', false, false],
  'bold-script': ['cursive', false, true],
  'sans-serif': ['sans-serif', false, false],
  'bold-sans-serif': ['sans-serif', false, true],
  'sans-serif-italic': ['sans-serif', true, false],
  'bold-sans-serif-italic': ['sans-serif', true, true],
  monospace: ['monospace', false, false]
};
FontData.defaultAccentMap = {
  0x0300: '\u02CB',
  0x0301: '\u02CA',
  0x0302: '\u02C6',
  0x0303: '\u02DC',
  0x0304: '\u02C9',
  0x0306: '\u02D8',
  0x0307: '\u02D9',
  0x0308: '\u00A8',
  0x030A: '\u02DA',
  0x030C: '\u02C7',
  0x2192: '\u20D7',
  0x2032: '\'',
  0x2033: '\'\'',
  0x2034: '\'\'\'',
  0x2035: '`',
  0x2036: '``',
  0x2037: '```',
  0x2057: '\'\'\'\'',
  0x20D0: '\u21BC',
  0x20D1: '\u21C0',
  0x20D6: '\u2190',
  0x20E1: '\u2194',
  0x20F0: '*',
  0x20DB: '...',
  0x20DC: '....',
  0x20EC: '\u21C1',
  0x20ED: '\u21BD',
  0x20EE: '\u2190',
  0x20EF: '\u2192'
};
FontData.defaultMoMap = {
  0x002D: '\u2212'
};
FontData.defaultMnMap = {
  0x002D: '\u2212'
};
FontData.defaultParams = {
  x_height: .442,
  quad: 1,
  num1: .676,
  num2: .394,
  num3: .444,
  denom1: .686,
  denom2: .345,
  sup1: .413,
  sup2: .363,
  sup3: .289,
  sub1: .15,
  sub2: .247,
  sup_drop: .386,
  sub_drop: .05,
  delim1: 2.39,
  delim2: 1.0,
  axis_height: .25,
  rule_thickness: .06,
  big_op_spacing1: .111,
  big_op_spacing2: .167,
  big_op_spacing3: .2,
  big_op_spacing4: .6,
  big_op_spacing5: .1,
  surd_height: .075,
  scriptspace: .05,
  nulldelimiterspace: .12,
  delimiterfactor: 901,
  delimitershortfall: .3,
  min_rule_thickness: 1.25
};
FontData.defaultDelimiters = {};
FontData.defaultChars = {};
FontData.defaultSizeVariants = [];
exports.FontData = FontData;
;

/***/ }),
/* 30 */
/***/ (function(module, exports) {

var toString = Object.prototype.toString;

module.exports = function kindOf(val) {
  if (val === void 0) return 'undefined';
  if (val === null) return 'null';
  var type = typeof val;
  if (type === 'boolean') return 'boolean';
  if (type === 'string') return 'string';
  if (type === 'number') return 'number';
  if (type === 'symbol') return 'symbol';

  if (type === 'function') {
    return isGeneratorFn(val) ? 'generatorfunction' : 'function';
  }

  if (isArray(val)) return 'array';
  if (isBuffer(val)) return 'buffer';
  if (isArguments(val)) return 'arguments';
  if (isDate(val)) return 'date';
  if (isError(val)) return 'error';
  if (isRegexp(val)) return 'regexp';

  switch (ctorName(val)) {
    case 'Symbol':
      return 'symbol';

    case 'Promise':
      return 'promise';
    // Set, Map, WeakSet, WeakMap

    case 'WeakMap':
      return 'weakmap';

    case 'WeakSet':
      return 'weakset';

    case 'Map':
      return 'map';

    case 'Set':
      return 'set';
    // 8-bit typed arrays

    case 'Int8Array':
      return 'int8array';

    case 'Uint8Array':
      return 'uint8array';

    case 'Uint8ClampedArray':
      return 'uint8clampedarray';
    // 16-bit typed arrays

    case 'Int16Array':
      return 'int16array';

    case 'Uint16Array':
      return 'uint16array';
    // 32-bit typed arrays

    case 'Int32Array':
      return 'int32array';

    case 'Uint32Array':
      return 'uint32array';

    case 'Float32Array':
      return 'float32array';

    case 'Float64Array':
      return 'float64array';
  }

  if (isGeneratorObj(val)) {
    return 'generator';
  } // Non-plain objects


  type = toString.call(val);

  switch (type) {
    case '[object Object]':
      return 'object';
    // iterators

    case '[object Map Iterator]':
      return 'mapiterator';

    case '[object Set Iterator]':
      return 'setiterator';

    case '[object String Iterator]':
      return 'stringiterator';

    case '[object Array Iterator]':
      return 'arrayiterator';
  } // other


  return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
};

function ctorName(val) {
  return typeof val.constructor === 'function' ? val.constructor.name : null;
}

function isArray(val) {
  if (Array.isArray) return Array.isArray(val);
  return val instanceof Array;
}

function isError(val) {
  return val instanceof Error || typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number';
}

function isDate(val) {
  if (val instanceof Date) return true;
  return typeof val.toDateString === 'function' && typeof val.getDate === 'function' && typeof val.setDate === 'function';
}

function isRegexp(val) {
  if (val instanceof RegExp) return true;
  return typeof val.flags === 'string' && typeof val.ignoreCase === 'boolean' && typeof val.multiline === 'boolean' && typeof val.global === 'boolean';
}

function isGeneratorFn(name, val) {
  return ctorName(name) === 'GeneratorFunction';
}

function isGeneratorObj(val) {
  return typeof val.throw === 'function' && typeof val.return === 'function' && typeof val.next === 'function';
}

function isArguments(val) {
  try {
    if (typeof val.length === 'number' && typeof val.callee === 'function') {
      return true;
    }
  } catch (err) {
    if (err.message.indexOf('callee') !== -1) {
      return true;
    }
  }

  return false;
}
/**
 * If you need to support Safari 5-7 (8-10 yr-old browser),
 * take a look at https://github.com/feross/is-buffer
 */


function isBuffer(val) {
  if (val.constructor && typeof val.constructor.isBuffer === 'function') {
    return val.constructor.isBuffer(val);
  }

  return false;
}

/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


const engines = __webpack_require__(55);

const utils = __webpack_require__(38);

module.exports = function (options) {
  const opts = Object.assign({}, options); // ensure that delimiters are an array

  opts.delimiters = utils.arrayify(opts.delims || opts.delimiters || '---');

  if (opts.delimiters.length === 1) {
    opts.delimiters.push(opts.delimiters[0]);
  }

  opts.language = (opts.language || opts.lang || 'yaml').toLowerCase();
  opts.engines = Object.assign({}, engines, opts.parsers, opts.engines);
  return opts;
};

/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// JS-YAML's default schema for `load` function.
// It is not described in the YAML specification.
//
// This schema is based on JS-YAML's default safe schema and includes
// JavaScript-specific types: !!js/undefined, !!js/regexp and !!js/function.
//
// Also this schema is used as default base schema at `Schema.create` function.


var Schema = __webpack_require__(21);

module.exports = Schema.DEFAULT = new Schema({
  include: [__webpack_require__(25)],
  explicit: [__webpack_require__(133), __webpack_require__(134), __webpack_require__(135)]
});

/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

function protoItem(open, math, close, n, start, end, display) {
  if (display === void 0) {
    display = null;
  }

  var item = {
    open: open,
    math: math,
    close: close,
    n: n,
    start: {
      n: start
    },
    end: {
      n: end
    },
    display: display
  };
  return item;
}

exports.protoItem = protoItem;

var AbstractMathItem = function () {
  function AbstractMathItem(math, jax, display, start, end) {
    if (display === void 0) {
      display = true;
    }

    if (start === void 0) {
      start = {
        i: 0,
        n: 0,
        delim: ''
      };
    }

    if (end === void 0) {
      end = {
        i: 0,
        n: 0,
        delim: ''
      };
    }

    this.root = null;
    this.typesetRoot = null;
    this._state = exports.STATE.UNPROCESSED;
    this.metrics = {};
    this.bbox = {};
    this.inputData = {};
    this.outputData = {};
    this.math = math;
    this.inputJax = jax;
    this.display = display;
    this.start = start;
    this.end = end;
    this.root = null;
    this.typesetRoot = null;
    this.metrics = {};
    this.bbox = {};
    this.inputData = {};
    this.outputData = {};
  }

  AbstractMathItem.prototype.render = function (document) {
    document.renderActions.renderMath(this, document);
  };

  AbstractMathItem.prototype.rerender = function (document, start) {
    if (start === void 0) {
      start = exports.STATE.RERENDER;
    }

    if (this.state() >= start) {
      this.state(start - 1);
    }

    document.renderActions.renderMath(this, document, start);
  };

  AbstractMathItem.prototype.convert = function (document, end) {
    if (end === void 0) {
      end = exports.STATE.LAST;
    }

    document.renderActions.renderConvert(this, document, end);
  };

  AbstractMathItem.prototype.compile = function (document) {
    if (this.state() < exports.STATE.COMPILED) {
      this.root = this.inputJax.compile(this);
      this.state(exports.STATE.COMPILED);
    }
  };

  AbstractMathItem.prototype.typeset = function (document) {
    if (this.state() < exports.STATE.TYPESET) {
      this.typesetRoot = document.outputJax[this.display === null ? 'escaped' : 'typeset'](this, document);
      this.state(exports.STATE.TYPESET);
    }
  };

  AbstractMathItem.prototype.updateDocument = function (document) {};

  AbstractMathItem.prototype.removeFromDocument = function (restore) {
    if (restore === void 0) {
      restore = false;
    }
  };

  AbstractMathItem.prototype.setMetrics = function (em, ex, cwidth, lwidth, scale) {
    this.metrics = {
      em: em,
      ex: ex,
      containerWidth: cwidth,
      lineWidth: lwidth,
      scale: scale
    };
  };

  AbstractMathItem.prototype.state = function (state, restore) {
    if (state === void 0) {
      state = null;
    }

    if (restore === void 0) {
      restore = false;
    }

    if (state != null) {
      if (state < exports.STATE.INSERTED && this._state >= exports.STATE.INSERTED) {
        this.removeFromDocument(restore);
      }

      if (state < exports.STATE.TYPESET && this._state >= exports.STATE.TYPESET) {
        this.bbox = {};
        this.outputData = {};
      }

      if (state < exports.STATE.COMPILED && this._state >= exports.STATE.COMPILED) {
        this.inputData = {};
      }

      this._state = state;
    }

    return this._state;
  };

  AbstractMathItem.prototype.reset = function (restore) {
    if (restore === void 0) {
      restore = false;
    }

    this.state(exports.STATE.UNPROCESSED);
  };

  return AbstractMathItem;
}();

exports.AbstractMathItem = AbstractMathItem;
exports.STATE = {
  UNPROCESSED: 0,
  FINDMATH: 10,
  COMPILED: 20,
  CONVERT: 100,
  METRICS: 110,
  RERENDER: 125,
  TYPESET: 150,
  INSERTED: 200,
  RESET: 500,
  LAST: 10000
};

function newState(name, state) {
  if (name in exports.STATE) {
    throw Error('State ' + name + ' already exists');
  }

  exports.STATE[name] = state;
}

exports.newState = newState;

/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var OperatorDictionary_js_1 = __webpack_require__(234);

var MmlMo = function (_super) {
  __extends(MmlMo, _super);

  function MmlMo() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.REL;
    _this.lspace = 5 / 18;
    _this.rspace = 5 / 18;
    return _this;
  }

  Object.defineProperty(MmlMo.prototype, "kind", {
    get: function () {
      return 'mo';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMo.prototype, "isEmbellished", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMo.prototype, "hasNewLine", {
    get: function () {
      return this.attributes.get('linebreak') === 'newline';
    },
    enumerable: true,
    configurable: true
  });

  MmlMo.prototype.coreParent = function () {
    var parent = this;
    var math = this.factory.getNodeClass('math');

    while (parent && parent.isEmbellished && parent.coreMO() === this && !(parent instanceof math)) {
      parent = parent.Parent;
    }

    return parent;
  };

  MmlMo.prototype.coreText = function (parent) {
    if (!parent) {
      return '';
    }

    if (parent.isEmbellished) {
      return parent.coreMO().getText();
    }

    while (((parent.isKind('mrow') || parent.isKind('TeXAtom') || parent.isKind('mstyle') || parent.isKind('mphantom')) && parent.childNodes.length === 1 || parent.isKind('munderover')) && parent.childNodes[0]) {
      parent = parent.childNodes[0];
    }

    return parent.isToken ? parent.getText() : '';
  };

  MmlMo.prototype.hasSpacingAttributes = function () {
    return this.attributes.isSet('lspace') || this.attributes.isSet('rspace');
  };

  Object.defineProperty(MmlMo.prototype, "isAccent", {
    get: function () {
      var accent = false;
      var node = this.coreParent();

      if (node) {
        var key = node.isKind('mover') ? node.childNodes[node.over].coreMO() ? 'accent' : '' : node.isKind('munder') ? node.childNodes[node.under].coreMO() ? 'accentunder' : '' : node.isKind('munderover') ? this === node.childNodes[node.over].coreMO() ? 'accent' : this === node.childNodes[node.under].coreMO() ? 'accentunder' : '' : '';

        if (key) {
          var value = node.attributes.getExplicit(key);
          accent = value !== undefined ? accent : this.attributes.get('accent');
        }
      }

      return accent;
    },
    enumerable: true,
    configurable: true
  });

  MmlMo.prototype.setTeXclass = function (prev) {
    var _a = this.attributes.getList('form', 'lspace', 'rspace', 'fence'),
        form = _a.form,
        lspace = _a.lspace,
        rspace = _a.rspace,
        fence = _a.fence;

    if (fence && this.texClass === MmlNode_js_1.TEXCLASS.REL) {
      if (form === 'prefix') {
        this.texClass = MmlNode_js_1.TEXCLASS.OPEN;
      }

      if (form === 'postfix') {
        this.texClass = MmlNode_js_1.TEXCLASS.CLOSE;
      }
    }

    if (this.getText() === '\u2061') {
      if (prev) {
        prev.texClass = MmlNode_js_1.TEXCLASS.OP;
        prev.setProperty('fnOP', true);
      }

      this.texClass = this.prevClass = MmlNode_js_1.TEXCLASS.NONE;
      return prev;
    }

    return this.adjustTeXclass(prev);
  };

  MmlMo.prototype.adjustTeXclass = function (prev) {
    var texClass = this.texClass;
    var prevClass = this.prevClass;

    if (texClass === MmlNode_js_1.TEXCLASS.NONE) {
      return prev;
    }

    if (prev) {
      if (prev.getProperty('autoOp') && (texClass === MmlNode_js_1.TEXCLASS.BIN || texClass === MmlNode_js_1.TEXCLASS.REL)) {
        texClass = this.texClass = MmlNode_js_1.TEXCLASS.ORD;
      }

      prevClass = this.prevClass = prev.texClass || MmlNode_js_1.TEXCLASS.ORD;
      this.prevLevel = this.attributes.getInherited('scriptlevel');
    } else {
      prevClass = this.prevClass = MmlNode_js_1.TEXCLASS.NONE;
    }

    if (texClass === MmlNode_js_1.TEXCLASS.BIN && (prevClass === MmlNode_js_1.TEXCLASS.NONE || prevClass === MmlNode_js_1.TEXCLASS.BIN || prevClass === MmlNode_js_1.TEXCLASS.OP || prevClass === MmlNode_js_1.TEXCLASS.REL || prevClass === MmlNode_js_1.TEXCLASS.OPEN || prevClass === MmlNode_js_1.TEXCLASS.PUNCT)) {
      this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    } else if (prevClass === MmlNode_js_1.TEXCLASS.BIN && (texClass === MmlNode_js_1.TEXCLASS.REL || texClass === MmlNode_js_1.TEXCLASS.CLOSE || texClass === MmlNode_js_1.TEXCLASS.PUNCT)) {
      prev.texClass = this.prevClass = MmlNode_js_1.TEXCLASS.ORD;
    } else if (texClass === MmlNode_js_1.TEXCLASS.BIN) {
      var child = this;
      var parent_1 = this.parent;

      while (parent_1 && parent_1.parent && parent_1.isEmbellished && (parent_1.childNodes.length === 1 || !parent_1.isKind('mrow') && parent_1.core() === child)) {
        child = parent_1;
        parent_1 = parent_1.parent;
      }

      if (parent_1.childNodes[parent_1.childNodes.length - 1] === child) {
        this.texClass = MmlNode_js_1.TEXCLASS.ORD;
      }
    }

    return this;
  };

  MmlMo.prototype.setInheritedAttributes = function (attributes, display, level, prime) {
    if (attributes === void 0) {
      attributes = {};
    }

    if (display === void 0) {
      display = false;
    }

    if (level === void 0) {
      level = 0;
    }

    if (prime === void 0) {
      prime = false;
    }

    _super.prototype.setInheritedAttributes.call(this, attributes, display, level, prime);

    var mo = this.getText();

    var _a = __read(this.handleExplicitForm(this.getForms()), 3),
        form1 = _a[0],
        form2 = _a[1],
        form3 = _a[2];

    this.attributes.setInherited('form', form1);
    var OPTABLE = this.constructor.OPTABLE;
    var def = OPTABLE[form1][mo] || OPTABLE[form2][mo] || OPTABLE[form3][mo];

    if (def) {
      this.texClass = def[2];

      try {
        for (var _b = __values(Object.keys(def[3] || {})), _c = _b.next(); !_c.done; _c = _b.next()) {
          var name_1 = _c.value;
          this.attributes.setInherited(name_1, def[3][name_1]);
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      this.lspace = (def[0] + 1) / 18;
      this.rspace = (def[1] + 1) / 18;
    } else {
      var range = this.getRange(mo);

      if (range) {
        this.texClass = range[2];
        var spacing = this.constructor.MMLSPACING[range[2]];
        this.lspace = (spacing[0] + 1) / 18;
        this.rspace = (spacing[1] + 1) / 18;
      }
    }

    var e_1, _d;
  };

  MmlMo.prototype.getForms = function () {
    var core = this;
    var parent = this.parent;
    var Parent = this.Parent;

    while (Parent && Parent.isEmbellished) {
      core = parent;
      parent = Parent.parent;
      Parent = Parent.Parent;
    }

    if (parent && parent.isKind('mrow') && parent.nonSpaceLength() !== 1) {
      if (parent.firstNonSpace() === core) {
        return ['prefix', 'infix', 'postfix'];
      }

      if (parent.lastNonSpace() === core) {
        return ['postfix', 'infix', 'prefix'];
      }
    }

    return ['infix', 'prefix', 'postfix'];
  };

  MmlMo.prototype.handleExplicitForm = function (forms) {
    if (this.attributes.isSet('form')) {
      var form_1 = this.attributes.get('form');
      forms = [form_1].concat(forms.filter(function (name) {
        return name !== form_1;
      }));
    }

    return forms;
  };

  MmlMo.prototype.getRange = function (mo) {
    if (!mo.match(/^[\uD800-\uDBFF]?.$/)) {
      return null;
    }

    var n = mo.charCodeAt(0);

    if (mo.length === 2) {
      n = (n - 0xD800) * 0x400 + mo.charCodeAt(1) - 0xDC00 + 0x10000;
    }

    var ranges = this.constructor.RANGES;

    try {
      for (var ranges_1 = __values(ranges), ranges_1_1 = ranges_1.next(); !ranges_1_1.done; ranges_1_1 = ranges_1.next()) {
        var range = ranges_1_1.value;

        if (range[0] <= n && n <= range[1]) {
          return range;
        }

        if (n < range[0]) {
          return null;
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (ranges_1_1 && !ranges_1_1.done && (_a = ranges_1.return)) _a.call(ranges_1);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    return null;

    var e_2, _a;
  };

  return MmlMo;
}(MmlNode_js_1.AbstractMmlTokenNode);

MmlMo.defaults = __assign({}, MmlNode_js_1.AbstractMmlTokenNode.defaults, {
  form: 'infix',
  fence: false,
  separator: false,
  lspace: 'thickmathspace',
  rspace: 'thickmathspace',
  stretchy: false,
  symmetric: false,
  maxsize: 'infinity',
  minsize: '0em',
  largeop: false,
  movablelimits: false,
  accent: false,
  linebreak: 'auto',
  lineleading: '1ex',
  linebreakstyle: 'before',
  indentalign: 'auto',
  indentshift: '0',
  indenttarget: '',
  indentalignfirst: 'indentalign',
  indentshiftfirst: 'indentshift',
  indentalignlast: 'indentalign',
  indentshiftlast: 'indentshift'
});
MmlMo.RANGES = OperatorDictionary_js_1.RANGES;
MmlMo.MMLSPACING = OperatorDictionary_js_1.MMLSPACING;
MmlMo.OPTABLE = OperatorDictionary_js_1.OPTABLE;
exports.MmlMo = MmlMo;

/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var TexParser_js_1 = __webpack_require__(15);

var Label = function () {
  function Label(tag, id) {
    if (tag === void 0) {
      tag = '???';
    }

    if (id === void 0) {
      id = '';
    }

    this.tag = tag;
    this.id = id;
  }

  return Label;
}();

exports.Label = Label;

var TagInfo = function () {
  function TagInfo(env, taggable, defaultTags, tag, tagId, tagFormat, noTag, labelId) {
    if (env === void 0) {
      env = '';
    }

    if (taggable === void 0) {
      taggable = false;
    }

    if (defaultTags === void 0) {
      defaultTags = false;
    }

    if (tag === void 0) {
      tag = null;
    }

    if (tagId === void 0) {
      tagId = '';
    }

    if (tagFormat === void 0) {
      tagFormat = '';
    }

    if (noTag === void 0) {
      noTag = false;
    }

    if (labelId === void 0) {
      labelId = '';
    }

    this.env = env;
    this.taggable = taggable;
    this.defaultTags = defaultTags;
    this.tag = tag;
    this.tagId = tagId;
    this.tagFormat = tagFormat;
    this.noTag = noTag;
    this.labelId = labelId;
  }

  return TagInfo;
}();

exports.TagInfo = TagInfo;

var AbstractTags = function () {
  function AbstractTags() {
    this.counter = 0;
    this.offset = 0;
    this.configuration = null;
    this.ids = {};
    this.allIds = {};
    this.labels = {};
    this.allLabels = {};
    this.refs = new Array();
    this.currentTag = new TagInfo();
    this.history = [];
    this.stack = [];

    this.enTag = function (node, tag) {
      var nf = this.configuration.nodeFactory;
      var cell = nf.create('node', 'mtd', [node]);
      var row = nf.create('node', 'mlabeledtr', [tag, cell]);
      var table = nf.create('node', 'mtable', [row], {
        side: this.configuration.options['TagSide'],
        minlabelspacing: this.configuration.options['TagIndent'],
        displaystyle: true
      });
      return table;
    };
  }

  AbstractTags.prototype.start = function (env, taggable, defaultTags) {
    if (this.currentTag) {
      this.stack.push(this.currentTag);
    }

    this.currentTag = new TagInfo(env, taggable, defaultTags);
  };

  Object.defineProperty(AbstractTags.prototype, "env", {
    get: function () {
      return this.currentTag.env;
    },
    enumerable: true,
    configurable: true
  });

  AbstractTags.prototype.end = function () {
    this.history.push(this.currentTag);
    this.currentTag = this.stack.pop();
  };

  AbstractTags.prototype.tag = function (tag, noFormat) {
    this.currentTag.tag = tag;
    this.currentTag.tagFormat = noFormat ? tag : this.formatTag(tag);
    this.currentTag.noTag = false;
  };

  AbstractTags.prototype.notag = function () {
    this.tag('', true);
    this.currentTag.noTag = true;
  };

  Object.defineProperty(AbstractTags.prototype, "noTag", {
    get: function () {
      return this.currentTag.noTag;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractTags.prototype, "label", {
    get: function () {
      return this.currentTag.labelId;
    },
    set: function (label) {
      this.currentTag.labelId = label;
    },
    enumerable: true,
    configurable: true
  });

  AbstractTags.prototype.formatUrl = function (id, base) {
    return base + '#' + encodeURIComponent(id);
  };

  AbstractTags.prototype.formatTag = function (tag) {
    return '(' + tag + ')';
  };

  AbstractTags.prototype.formatId = function (id) {
    return 'mjx-eqn-' + id.replace(/\s/g, '_');
  };

  AbstractTags.prototype.formatNumber = function (n) {
    return n.toString();
  };

  AbstractTags.prototype.autoTag = function () {
    if (this.currentTag.tag == null) {
      this.counter++;
      this.tag(this.formatNumber(this.counter), false);
    }
  };

  AbstractTags.prototype.clearTag = function () {
    this.label = '';
    this.tag(null, true);
    this.currentTag.tagId = '';
  };

  AbstractTags.prototype.getTag = function (force) {
    if (force === void 0) {
      force = false;
    }

    if (force) {
      this.autoTag();
      return this.makeTag();
    }

    var ct = this.currentTag;

    if (ct.taggable && !ct.noTag) {
      if (ct.defaultTags) {
        this.autoTag();
      } else {
        return null;
      }

      return this.makeTag();
    }

    return null;
  };

  AbstractTags.prototype.resetTag = function () {
    this.history = [];
    this.clearTag();
  };

  AbstractTags.prototype.reset = function (offset) {
    if (offset === void 0) {
      offset = 0;
    }

    this.resetTag();
    this.offset = offset;
    this.labels = {};
    this.ids = {};
  };

  AbstractTags.prototype.finalize = function (node, env) {
    if (!env.display || this.currentTag.env || this.currentTag.tag == null) {
      return node;
    }

    var tag = this.makeTag();
    var table = this.enTag(node, tag);
    return table;
  };

  AbstractTags.prototype.makeId = function () {
    this.currentTag.tagId = this.formatId(this.configuration.options['useLabelIds'] ? this.label || this.currentTag.tag : this.currentTag.tag);
  };

  AbstractTags.prototype.makeTag = function () {
    this.makeId();

    if (this.label) {
      this.labels[this.label] = new Label(this.currentTag.tag, this.currentTag.tagId);
    }

    var mml = new TexParser_js_1.default('\\text{' + this.currentTag.tagFormat + '}', {}, this.configuration).mml();
    return this.configuration.nodeFactory.create('node', 'mtd', [mml], {
      id: this.currentTag.tagId
    });
  };

  return AbstractTags;
}();

exports.AbstractTags = AbstractTags;
;

var NoTags = function (_super) {
  __extends(NoTags, _super);

  function NoTags() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  NoTags.prototype.autoTag = function () {};

  NoTags.prototype.getTag = function () {
    return !this.currentTag.tag ? null : _super.prototype.getTag.call(this);
  };

  return NoTags;
}(AbstractTags);

exports.NoTags = NoTags;

var AllTags = function (_super) {
  __extends(AllTags, _super);

  function AllTags() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  AllTags.prototype.finalize = function (node, env) {
    if (!env.display || this.history.find(function (x) {
      return x.taggable;
    })) {
      return node;
    }

    var tag = this.getTag(true);
    return this.enTag(node, tag);
  };

  return AllTags;
}(AbstractTags);

exports.AllTags = AllTags;
var TagsFactory;

(function (TagsFactory) {
  var tagsMapping = new Map([['none', NoTags], ['all', AllTags]]);
  var defaultTags = 'none';
  TagsFactory.OPTIONS = {
    tags: defaultTags,
    TagSide: 'right',
    TagIndent: '0.8em',
    MultLineWidth: '85%',
    useLabelIds: true,
    refUpdate: false
  };

  TagsFactory.add = function (name, constr) {
    tagsMapping.set(name, constr);
  };

  TagsFactory.addTags = function (tags) {
    try {
      for (var _a = __values(Object.keys(tags)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var key = _b.value;
        TagsFactory.add(key, tags[key]);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _c;
  };

  TagsFactory.create = function (name) {
    var constr = tagsMapping.get(name) || this.defaultTags;
    return new constr();
  };

  TagsFactory.setDefault = function (name) {
    defaultTags = name;
  };

  TagsFactory.getDefault = function () {
    return TagsFactory.create(defaultTags);
  };
})(TagsFactory = exports.TagsFactory || (exports.TagsFactory = {}));

/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Symbol = function () {
  function Symbol(_symbol, _char, _attributes) {
    this._symbol = _symbol;
    this._char = _char;
    this._attributes = _attributes;
  }

  Object.defineProperty(Symbol.prototype, "symbol", {
    get: function () {
      return this._symbol;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(Symbol.prototype, "char", {
    get: function () {
      return this._char;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(Symbol.prototype, "attributes", {
    get: function () {
      return this._attributes;
    },
    enumerable: true,
    configurable: true
  });
  return Symbol;
}();

exports.Symbol = Symbol;
;

var Macro = function () {
  function Macro(_symbol, _func, _args) {
    if (_args === void 0) {
      _args = [];
    }

    this._symbol = _symbol;
    this._func = _func;
    this._args = _args;
  }

  Object.defineProperty(Macro.prototype, "symbol", {
    get: function () {
      return this._symbol;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(Macro.prototype, "func", {
    get: function () {
      return this._func;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(Macro.prototype, "args", {
    get: function () {
      return this._args;
    },
    enumerable: true,
    configurable: true
  });
  return Macro;
}();

exports.Macro = Macro;
;

/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Standard YAML's Failsafe schema.
// http://www.yaml.org/spec/1.2/spec.html#id2802346


var Schema = __webpack_require__(21);

module.exports = new Schema({
  explicit: [__webpack_require__(117), __webpack_require__(118), __webpack_require__(119)]
});

/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Buffer) {

const stripBom = __webpack_require__(138);

const typeOf = __webpack_require__(30);

exports.define = function (obj, key, val) {
  Reflect.defineProperty(obj, key, {
    enumerable: false,
    configurable: true,
    writable: true,
    value: val
  });
};
/**
 * Returns true if `val` is a buffer
 */


exports.isBuffer = val => typeOf(val) === 'buffer';
/**
 * Returns true if `val` is an object
 */


exports.isObject = val => typeOf(val) === 'object';
/**
 * Cast `input` to a buffer
 */


exports.toBuffer = function (input) {
  return typeof input === 'string' ? Buffer.from(input) : input;
};
/**
 * Cast `val` to a string.
 */


exports.toString = function (input) {
  if (exports.isBuffer(input)) return stripBom(String(input));

  if (typeof input !== 'string') {
    throw new TypeError('expected input to be a string or buffer');
  }

  return stripBom(input);
};
/**
 * Cast `val` to an array.
 */


exports.arrayify = function (val) {
  return val ? Array.isArray(val) ? val : [val] : [];
};
/**
 * Returns true if `str` starts with `substr`.
 */


exports.startsWith = function (str, substr, len) {
  if (typeof len !== 'number') len = substr.length;
  return str.slice(0, len) === substr;
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(58).Buffer))

/***/ }),
/* 39 */
/***/ (function(module, exports) {

module.exports = /[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4E\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/;

/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * class Ruler
 *
 * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
 * [[MarkdownIt#inline]] to manage sequences of functions (rules):
 *
 * - keep rules in defined order
 * - assign the name to each rule
 * - enable/disable rules
 * - add/replace rules
 * - allow assign rules to additional named chains (in the same)
 * - cacheing lists of active rules
 *
 * You will not need use this class directly until write plugins. For simple
 * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
 * [[MarkdownIt.use]].
 **/

/**
 * new Ruler()
 **/

function Ruler() {
  // List of added rules. Each element is:
  //
  // {
  //   name: XXX,
  //   enabled: Boolean,
  //   fn: Function(),
  //   alt: [ name2, name3 ]
  // }
  //
  this.__rules__ = []; // Cached rule chains.
  //
  // First level - chain name, '' for default.
  // Second level - diginal anchor for fast filtering by charcodes.
  //

  this.__cache__ = null;
} ////////////////////////////////////////////////////////////////////////////////
// Helper methods, should not be used directly
// Find rule index by name
//


Ruler.prototype.__find__ = function (name) {
  for (var i = 0; i < this.__rules__.length; i++) {
    if (this.__rules__[i].name === name) {
      return i;
    }
  }

  return -1;
}; // Build rules lookup cache
//


Ruler.prototype.__compile__ = function () {
  var self = this;
  var chains = ['']; // collect unique names

  self.__rules__.forEach(function (rule) {
    if (!rule.enabled) {
      return;
    }

    rule.alt.forEach(function (altName) {
      if (chains.indexOf(altName) < 0) {
        chains.push(altName);
      }
    });
  });

  self.__cache__ = {};
  chains.forEach(function (chain) {
    self.__cache__[chain] = [];

    self.__rules__.forEach(function (rule) {
      if (!rule.enabled) {
        return;
      }

      if (chain && rule.alt.indexOf(chain) < 0) {
        return;
      }

      self.__cache__[chain].push(rule.fn);
    });
  });
};
/**
 * Ruler.at(name, fn [, options])
 * - name (String): rule name to replace.
 * - fn (Function): new rule function.
 * - options (Object): new rule options (not mandatory).
 *
 * Replace rule by name with new function & options. Throws error if name not
 * found.
 *
 * ##### Options:
 *
 * - __alt__ - array with names of "alternate" chains.
 *
 * ##### Example
 *
 * Replace existing typographer replacement rule with new one:
 *
 * ```javascript
 * var md = require('markdown-it')();
 *
 * md.core.ruler.at('replacements', function replace(state) {
 *   //...
 * });
 * ```
 **/


Ruler.prototype.at = function (name, fn, options) {
  var index = this.__find__(name);

  var opt = options || {};

  if (index === -1) {
    throw new Error('Parser rule not found: ' + name);
  }

  this.__rules__[index].fn = fn;
  this.__rules__[index].alt = opt.alt || [];
  this.__cache__ = null;
};
/**
 * Ruler.before(beforeName, ruleName, fn [, options])
 * - beforeName (String): new rule will be added before this one.
 * - ruleName (String): name of added rule.
 * - fn (Function): rule function.
 * - options (Object): rule options (not mandatory).
 *
 * Add new rule to chain before one with given name. See also
 * [[Ruler.after]], [[Ruler.push]].
 *
 * ##### Options:
 *
 * - __alt__ - array with names of "alternate" chains.
 *
 * ##### Example
 *
 * ```javascript
 * var md = require('markdown-it')();
 *
 * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
 *   //...
 * });
 * ```
 **/


Ruler.prototype.before = function (beforeName, ruleName, fn, options) {
  var index = this.__find__(beforeName);

  var opt = options || {};

  if (index === -1) {
    throw new Error('Parser rule not found: ' + beforeName);
  }

  this.__rules__.splice(index, 0, {
    name: ruleName,
    enabled: true,
    fn: fn,
    alt: opt.alt || []
  });

  this.__cache__ = null;
};
/**
 * Ruler.after(afterName, ruleName, fn [, options])
 * - afterName (String): new rule will be added after this one.
 * - ruleName (String): name of added rule.
 * - fn (Function): rule function.
 * - options (Object): rule options (not mandatory).
 *
 * Add new rule to chain after one with given name. See also
 * [[Ruler.before]], [[Ruler.push]].
 *
 * ##### Options:
 *
 * - __alt__ - array with names of "alternate" chains.
 *
 * ##### Example
 *
 * ```javascript
 * var md = require('markdown-it')();
 *
 * md.inline.ruler.after('text', 'my_rule', function replace(state) {
 *   //...
 * });
 * ```
 **/


Ruler.prototype.after = function (afterName, ruleName, fn, options) {
  var index = this.__find__(afterName);

  var opt = options || {};

  if (index === -1) {
    throw new Error('Parser rule not found: ' + afterName);
  }

  this.__rules__.splice(index + 1, 0, {
    name: ruleName,
    enabled: true,
    fn: fn,
    alt: opt.alt || []
  });

  this.__cache__ = null;
};
/**
 * Ruler.push(ruleName, fn [, options])
 * - ruleName (String): name of added rule.
 * - fn (Function): rule function.
 * - options (Object): rule options (not mandatory).
 *
 * Push new rule to the end of chain. See also
 * [[Ruler.before]], [[Ruler.after]].
 *
 * ##### Options:
 *
 * - __alt__ - array with names of "alternate" chains.
 *
 * ##### Example
 *
 * ```javascript
 * var md = require('markdown-it')();
 *
 * md.core.ruler.push('my_rule', function replace(state) {
 *   //...
 * });
 * ```
 **/


Ruler.prototype.push = function (ruleName, fn, options) {
  var opt = options || {};

  this.__rules__.push({
    name: ruleName,
    enabled: true,
    fn: fn,
    alt: opt.alt || []
  });

  this.__cache__ = null;
};
/**
 * Ruler.enable(list [, ignoreInvalid]) -> Array
 * - list (String|Array): list of rule names to enable.
 * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
 *
 * Enable rules with given names. If any rule name not found - throw Error.
 * Errors can be disabled by second param.
 *
 * Returns list of found rule names (if no exception happened).
 *
 * See also [[Ruler.disable]], [[Ruler.enableOnly]].
 **/


Ruler.prototype.enable = function (list, ignoreInvalid) {
  if (!Array.isArray(list)) {
    list = [list];
  }

  var result = []; // Search by name and enable

  list.forEach(function (name) {
    var idx = this.__find__(name);

    if (idx < 0) {
      if (ignoreInvalid) {
        return;
      }

      throw new Error('Rules manager: invalid rule name ' + name);
    }

    this.__rules__[idx].enabled = true;
    result.push(name);
  }, this);
  this.__cache__ = null;
  return result;
};
/**
 * Ruler.enableOnly(list [, ignoreInvalid])
 * - list (String|Array): list of rule names to enable (whitelist).
 * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
 *
 * Enable rules with given names, and disable everything else. If any rule name
 * not found - throw Error. Errors can be disabled by second param.
 *
 * See also [[Ruler.disable]], [[Ruler.enable]].
 **/


Ruler.prototype.enableOnly = function (list, ignoreInvalid) {
  if (!Array.isArray(list)) {
    list = [list];
  }

  this.__rules__.forEach(function (rule) {
    rule.enabled = false;
  });

  this.enable(list, ignoreInvalid);
};
/**
 * Ruler.disable(list [, ignoreInvalid]) -> Array
 * - list (String|Array): list of rule names to disable.
 * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
 *
 * Disable rules with given names. If any rule name not found - throw Error.
 * Errors can be disabled by second param.
 *
 * Returns list of found rule names (if no exception happened).
 *
 * See also [[Ruler.enable]], [[Ruler.enableOnly]].
 **/


Ruler.prototype.disable = function (list, ignoreInvalid) {
  if (!Array.isArray(list)) {
    list = [list];
  }

  var result = []; // Search by name and disable

  list.forEach(function (name) {
    var idx = this.__find__(name);

    if (idx < 0) {
      if (ignoreInvalid) {
        return;
      }

      throw new Error('Rules manager: invalid rule name ' + name);
    }

    this.__rules__[idx].enabled = false;
    result.push(name);
  }, this);
  this.__cache__ = null;
  return result;
};
/**
 * Ruler.getRules(chainName) -> Array
 *
 * Return array of active functions (rules) for given chain name. It analyzes
 * rules configuration, compiles caches if not exists and returns result.
 *
 * Default chain name is `''` (empty string). It can't be skipped. That's
 * done intentionally, to keep signature monomorphic for high speed.
 **/


Ruler.prototype.getRules = function (chainName) {
  if (this.__cache__ === null) {
    this.__compile__();
  } // Chain can be empty, if rules disabled. But we still have to return Array.


  return this.__cache__[chainName] || [];
};

module.exports = Ruler;

/***/ }),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Token class

/**
 * class Token
 **/

/**
 * new Token(type, tag, nesting)
 *
 * Create new token and fill passed properties.
 **/

function Token(type, tag, nesting) {
  /**
   * Token#type -> String
   *
   * Type of the token (string, e.g. "paragraph_open")
   **/
  this.type = type;
  /**
   * Token#tag -> String
   *
   * html tag name, e.g. "p"
   **/

  this.tag = tag;
  /**
   * Token#attrs -> Array
   *
   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
   **/

  this.attrs = null;
  /**
   * Token#map -> Array
   *
   * Source map info. Format: `[ line_begin, line_end ]`
   **/

  this.map = null;
  /**
   * Token#nesting -> Number
   *
   * Level change (number in {-1, 0, 1} set), where:
   *
   * -  `1` means the tag is opening
   * -  `0` means the tag is self-closing
   * - `-1` means the tag is closing
   **/

  this.nesting = nesting;
  /**
   * Token#level -> Number
   *
   * nesting level, the same as `state.level`
   **/

  this.level = 0;
  /**
   * Token#children -> Array
   *
   * An array of child nodes (inline and img tokens)
   **/

  this.children = null;
  /**
   * Token#content -> String
   *
   * In a case of self-closing tag (code, html, fence, etc.),
   * it has contents of this tag.
   **/

  this.content = '';
  /**
   * Token#markup -> String
   *
   * '*' or '_' for emphasis, fence string for fence, etc.
   **/

  this.markup = '';
  /**
   * Token#info -> String
   *
   * fence infostring
   **/

  this.info = '';
  /**
   * Token#meta -> Object
   *
   * A place for plugins to store an arbitrary data
   **/

  this.meta = null;
  /**
   * Token#block -> Boolean
   *
   * True for block-level tokens, false for inline tokens.
   * Used in renderer to calculate line breaks
   **/

  this.block = false;
  /**
   * Token#hidden -> Boolean
   *
   * If it's true, ignore this element when rendering. Used for tight lists
   * to hide paragraphs.
   **/

  this.hidden = false;
}
/**
 * Token.attrIndex(name) -> Number
 *
 * Search attribute index by name.
 **/


Token.prototype.attrIndex = function attrIndex(name) {
  var attrs, i, len;

  if (!this.attrs) {
    return -1;
  }

  attrs = this.attrs;

  for (i = 0, len = attrs.length; i < len; i++) {
    if (attrs[i][0] === name) {
      return i;
    }
  }

  return -1;
};
/**
 * Token.attrPush(attrData)
 *
 * Add `[ name, value ]` attribute to list. Init attrs if necessary
 **/


Token.prototype.attrPush = function attrPush(attrData) {
  if (this.attrs) {
    this.attrs.push(attrData);
  } else {
    this.attrs = [attrData];
  }
};
/**
 * Token.attrSet(name, value)
 *
 * Set `name` attribute to `value`. Override old value if exists.
 **/


Token.prototype.attrSet = function attrSet(name, value) {
  var idx = this.attrIndex(name),
      attrData = [name, value];

  if (idx < 0) {
    this.attrPush(attrData);
  } else {
    this.attrs[idx] = attrData;
  }
};
/**
 * Token.attrGet(name)
 *
 * Get the value of attribute `name`, or null if it does not exist.
 **/


Token.prototype.attrGet = function attrGet(name) {
  var idx = this.attrIndex(name),
      value = null;

  if (idx >= 0) {
    value = this.attrs[idx][1];
  }

  return value;
};
/**
 * Token.attrJoin(name, value)
 *
 * Join value to existing attribute via space. Or create new attribute if not
 * exists. Useful to operate with token classes.
 **/


Token.prototype.attrJoin = function attrJoin(name, value) {
  var idx = this.attrIndex(name);

  if (idx < 0) {
    this.attrPush([name, value]);
  } else {
    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value;
  }
};

module.exports = Token;

/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var HandlerList_js_1 = __webpack_require__(228);

var Retries_js_1 = __webpack_require__(70);

exports.MathJax = {
  version: '3.0.0-beta.4',
  handlers: new HandlerList_js_1.HandlerList(),
  document: function (document, options) {
    return exports.MathJax.handlers.document(document, options);
  },
  handleRetriesFor: Retries_js_1.handleRetriesFor,
  retryAfter: Retries_js_1.retryAfter,
  asyncLoad: null
};

/***/ }),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var PrioritizedList = function () {
  function PrioritizedList() {
    this.items = [];
    this.items = [];
  }

  PrioritizedList.prototype[Symbol.iterator] = function () {
    var i = 0;
    var items = this.items;
    return {
      next: function () {
        return {
          value: items[i++],
          done: i > items.length
        };
      }
    };
  };

  PrioritizedList.prototype.add = function (item, priority) {
    if (priority === void 0) {
      priority = PrioritizedList.DEFAULTPRIORITY;
    }

    var i = this.items.length;

    do {
      i--;
    } while (i >= 0 && priority < this.items[i].priority);

    this.items.splice(i + 1, 0, {
      item: item,
      priority: priority
    });
    return item;
  };

  PrioritizedList.prototype.remove = function (item) {
    var i = this.items.length;

    do {
      i--;
    } while (i >= 0 && this.items[i].item !== item);

    if (i >= 0) {
      this.items.splice(i, 1);
    }
  };

  PrioritizedList.prototype.toArray = function () {
    return Array.from(this);
  };

  return PrioritizedList;
}();

PrioritizedList.DEFAULTPRIORITY = 5;
exports.PrioritizedList = PrioritizedList;

/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var PrioritizedList_js_1 = __webpack_require__(43);

var FunctionList = function (_super) {
  __extends(FunctionList, _super);

  function FunctionList() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  FunctionList.prototype.execute = function () {
    var data = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      data[_i] = arguments[_i];
    }

    try {
      for (var _a = __values(this), _b = _a.next(); !_b.done; _b = _a.next()) {
        var item = _b.value;
        var result = item.item.apply(item, __spread(data));

        if (result === false) {
          return false;
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    return true;

    var e_1, _c;
  };

  FunctionList.prototype.asyncExecute = function () {
    var data = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      data[_i] = arguments[_i];
    }

    var i = -1;
    var items = this.items;
    return new Promise(function (ok, fail) {
      (function execute() {
        while (++i < items.length) {
          var result = (_a = items[i]).item.apply(_a, __spread(data));

          if (result instanceof Promise) {
            result.then(execute).catch(function (err) {
              return fail(err);
            });
            return;
          }

          if (result === false) {
            ok(false);
            return;
          }
        }

        ok(true);

        var _a;
      })();
    });
  };

  return FunctionList;
}(PrioritizedList_js_1.PrioritizedList);

exports.FunctionList = FunctionList;

/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var AbstractFactory = function () {
  function AbstractFactory(nodes) {
    if (nodes === void 0) {
      nodes = null;
    }

    this.defaultKind = 'unknown';
    this.nodeMap = new Map();
    this.node = {};

    if (nodes === null) {
      nodes = this.constructor.defaultNodes;
    }

    try {
      for (var _a = __values(Object.keys(nodes)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var kind = _b.value;
        this.setNodeClass(kind, nodes[kind]);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _c;
  }

  AbstractFactory.prototype.create = function (kind) {
    var args = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      args[_i - 1] = arguments[_i];
    }

    return (this.node[kind] || this.node[this.defaultKind]).apply(void 0, __spread(args));
  };

  AbstractFactory.prototype.setNodeClass = function (kind, nodeClass) {
    this.nodeMap.set(kind, nodeClass);
    var THIS = this;
    var KIND = this.nodeMap.get(kind);

    this.node[kind] = function () {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      return new (KIND.bind.apply(KIND, __spread([void 0, THIS], args)))();
    };
  };

  AbstractFactory.prototype.getNodeClass = function (kind) {
    return this.nodeMap.get(kind);
  };

  AbstractFactory.prototype.deleteNodeClass = function (kind) {
    this.nodeMap.delete(kind);
    delete this.node[kind];
  };

  AbstractFactory.prototype.nodeIsKind = function (node, kind) {
    return node instanceof this.getNodeClass(kind);
  };

  AbstractFactory.prototype.getKinds = function () {
    return Array.from(this.nodeMap.keys());
  };

  return AbstractFactory;
}();

AbstractFactory.defaultNodes = {};
exports.AbstractFactory = AbstractFactory;

/***/ }),
/* 46 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var NodeUtil_js_1 = __webpack_require__(8);

var NodeFactory = function () {
  function NodeFactory() {
    this.mmlFactory = null;
    this.factory = {
      'node': NodeFactory.createNode,
      'token': NodeFactory.createToken,
      'text': NodeFactory.createText,
      'error': NodeFactory.createError
    };
  }

  NodeFactory.prototype.setMmlFactory = function (mmlFactory) {
    this.mmlFactory = mmlFactory;
  };

  NodeFactory.createNode = function (factory, kind, children, def, text) {
    if (children === void 0) {
      children = [];
    }

    if (def === void 0) {
      def = {};
    }

    var node = factory.mmlFactory.create(kind);
    var arity = node.arity;

    if (arity === Infinity || arity === -1) {
      if (children.length === 1 && children[0].isInferred) {
        node.setChildren(NodeUtil_js_1.default.getChildren(children[0]));
      } else {
        node.setChildren(children);
      }
    } else {
      var cleanChildren = [];

      for (var i = 0, child = void 0; child = children[i]; i++) {
        if (child.isInferred) {
          var mrow = factory.mmlFactory.create('mrow', {}, NodeUtil_js_1.default.getChildren(child));
          NodeUtil_js_1.default.copyAttributes(child, mrow);
          cleanChildren.push(mrow);
        } else {
          cleanChildren.push(child);
        }
      }

      node.setChildren(cleanChildren);
    }

    if (text) {
      node.appendChild(text);
    }

    NodeUtil_js_1.default.setProperties(node, def);
    return node;
  };

  ;

  NodeFactory.createToken = function (factory, kind, def, text) {
    if (def === void 0) {
      def = {};
    }

    if (text === void 0) {
      text = '';
    }

    var textNode = factory.create('text', text);
    return factory.create('node', kind, [], def, textNode);
  };

  NodeFactory.createText = function (factory, text) {
    if (text == null) {
      return null;
    }

    return factory.mmlFactory.create('text').setText(text);
  };

  ;

  NodeFactory.createError = function (factory, message) {
    var text = factory.create('text', message);
    var mtext = factory.create('node', 'mtext', [], {}, text);
    var error = factory.create('node', 'merror', [mtext]);
    return error;
  };

  ;

  NodeFactory.prototype.set = function (kind, func) {
    this.factory[kind] = func;
  };

  NodeFactory.prototype.setCreators = function (maps) {
    for (var kind in maps) {
      this.set(kind, maps[kind]);
    }
  };

  NodeFactory.prototype.create = function (kind) {
    var rest = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      rest[_i - 1] = arguments[_i];
    }

    var func = this.factory[kind] || this.factory['node'];
    var node = func.apply(void 0, __spread([this, rest[0]], rest.slice(1)));
    this.configuration.addNode(rest[0], node);
    return node;
  };

  NodeFactory.prototype.get = function (kind) {
    return this.factory[kind];
  };

  return NodeFactory;
}();

exports.NodeFactory = NodeFactory;

/***/ }),
/* 47 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var MapHandler_js_1 = __webpack_require__(17);

var TexError_js_1 = __webpack_require__(6);

var NodeUtil_js_1 = __webpack_require__(8);

var SymbolMap_js_1 = __webpack_require__(5);

var bitem = __webpack_require__(48);

var Tags_js_1 = __webpack_require__(35);

__webpack_require__(239);

new SymbolMap_js_1.CharacterMap('remap', null, {
  '-': '\u2212',
  '*': '\u2217',
  '`': '\u2018'
});

function Other(parser, char) {
  var font = parser.stack.env['font'];
  var def = font ? {
    mathvariant: parser.stack.env['font']
  } : {};
  var remap = MapHandler_js_1.MapHandler.getMap('remap').lookup(char);
  var mo = parser.create('token', 'mo', def, remap ? remap.char : char);
  NodeUtil_js_1.default.setProperty(mo, 'fixStretchy', true);
  parser.configuration.addNode('fixStretchy', mo);
  parser.Push(mo);
}

exports.Other = Other;
;

function csUndefined(parser, name) {
  throw new TexError_js_1.default('UndefinedControlSequence', 'Undefined control sequence %1', '\\' + name);
}

;

function envUndefined(parser, env) {
  throw new TexError_js_1.default('UnknownEnv', 'Unknown environment \'%1\'', env);
}

;

var BaseTags = function (_super) {
  __extends(BaseTags, _super);

  function BaseTags() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return BaseTags;
}(Tags_js_1.AbstractTags);

exports.BaseTags = BaseTags;
exports.BaseConfiguration = Configuration_js_1.Configuration.create('base', {
  handler: {
    character: ['command', 'special', 'letter', 'digit'],
    delimiter: ['delimiter'],
    macro: ['delimiter', 'macros', 'mathchar0mi', 'mathchar0mo', 'mathchar7'],
    environment: ['environment']
  },
  fallback: {
    character: Other,
    macro: csUndefined,
    environment: envUndefined
  },
  items: (_a = {}, _a[bitem.StartItem.prototype.kind] = bitem.StartItem, _a[bitem.StopItem.prototype.kind] = bitem.StopItem, _a[bitem.OpenItem.prototype.kind] = bitem.OpenItem, _a[bitem.CloseItem.prototype.kind] = bitem.CloseItem, _a[bitem.PrimeItem.prototype.kind] = bitem.PrimeItem, _a[bitem.SubsupItem.prototype.kind] = bitem.SubsupItem, _a[bitem.OverItem.prototype.kind] = bitem.OverItem, _a[bitem.LeftItem.prototype.kind] = bitem.LeftItem, _a[bitem.RightItem.prototype.kind] = bitem.RightItem, _a[bitem.BeginItem.prototype.kind] = bitem.BeginItem, _a[bitem.EndItem.prototype.kind] = bitem.EndItem, _a[bitem.StyleItem.prototype.kind] = bitem.StyleItem, _a[bitem.PositionItem.prototype.kind] = bitem.PositionItem, _a[bitem.CellItem.prototype.kind] = bitem.CellItem, _a[bitem.MmlItem.prototype.kind] = bitem.MmlItem, _a[bitem.FnItem.prototype.kind] = bitem.FnItem, _a[bitem.NotItem.prototype.kind] = bitem.NotItem, _a[bitem.DotsItem.prototype.kind] = bitem.DotsItem, _a[bitem.ArrayItem.prototype.kind] = bitem.ArrayItem, _a[bitem.EqnArrayItem.prototype.kind] = bitem.EqnArrayItem, _a[bitem.EquationItem.prototype.kind] = bitem.EquationItem, _a),
  options: {
    maxMacros: 1000,
    baseURL: typeof document === 'undefined' || document.getElementsByTagName('base').length === 0 ? '' : String(document.location).replace(/#.*$/, '')
  },
  tags: {
    base: BaseTags
  }
});

var _a;

/***/ }),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MapHandler_js_1 = __webpack_require__(17);

var Entities_js_1 = __webpack_require__(18);

var MmlNode_js_1 = __webpack_require__(0);

var TexError_js_1 = __webpack_require__(6);

var ParseUtil_js_1 = __webpack_require__(9);

var NodeUtil_js_1 = __webpack_require__(8);

var StackItem_js_1 = __webpack_require__(27);

var StartItem = function (_super) {
  __extends(StartItem, _super);

  function StartItem(factory, global) {
    var _this = _super.call(this, factory) || this;

    _this.global = global;
    return _this;
  }

  Object.defineProperty(StartItem.prototype, "kind", {
    get: function () {
      return 'start';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(StartItem.prototype, "isOpen", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  StartItem.prototype.checkItem = function (item) {
    if (item.isKind('stop')) {
      var node = this.toMml();

      if (!this.global.isInner) {
        node = this.factory.configuration.tags.finalize(node, this.env);
      }

      return [[this.factory.create('mml', node)], true];
    }

    return _super.prototype.checkItem.call(this, item);
  };

  return StartItem;
}(StackItem_js_1.BaseItem);

exports.StartItem = StartItem;

var StopItem = function (_super) {
  __extends(StopItem, _super);

  function StopItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(StopItem.prototype, "kind", {
    get: function () {
      return 'stop';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(StopItem.prototype, "isClose", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  return StopItem;
}(StackItem_js_1.BaseItem);

exports.StopItem = StopItem;

var OpenItem = function (_super) {
  __extends(OpenItem, _super);

  function OpenItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(OpenItem.prototype, "kind", {
    get: function () {
      return 'open';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(OpenItem.prototype, "isOpen", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  OpenItem.prototype.checkItem = function (item) {
    if (item.isKind('close')) {
      var mml = this.toMml();
      var node = this.create('node', 'TeXAtom', [mml]);
      return [[this.factory.create('mml', node)], true];
    }

    return _super.prototype.checkItem.call(this, item);
  };

  return OpenItem;
}(StackItem_js_1.BaseItem);

OpenItem.errors = Object.assign(Object.create(StackItem_js_1.BaseItem.errors), {
  'stop': ['ExtraOpenMissingClose', 'Extra open brace or missing close brace']
});
exports.OpenItem = OpenItem;

var CloseItem = function (_super) {
  __extends(CloseItem, _super);

  function CloseItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(CloseItem.prototype, "kind", {
    get: function () {
      return 'close';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(CloseItem.prototype, "isClose", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  return CloseItem;
}(StackItem_js_1.BaseItem);

exports.CloseItem = CloseItem;

var PrimeItem = function (_super) {
  __extends(PrimeItem, _super);

  function PrimeItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(PrimeItem.prototype, "kind", {
    get: function () {
      return 'prime';
    },
    enumerable: true,
    configurable: true
  });

  PrimeItem.prototype.checkItem = function (item) {
    var _a = __read(this.Peek(2), 2),
        top0 = _a[0],
        top1 = _a[1];

    if (!NodeUtil_js_1.default.isType(top0, 'msubsup')) {
      var node = this.create('node', 'msup', [top0, top1]);
      return [[node, item], true];
    }

    NodeUtil_js_1.default.setChild(top0, top0.sup, top1);
    return [[top0, item], true];
  };

  return PrimeItem;
}(StackItem_js_1.BaseItem);

exports.PrimeItem = PrimeItem;

var SubsupItem = function (_super) {
  __extends(SubsupItem, _super);

  function SubsupItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(SubsupItem.prototype, "kind", {
    get: function () {
      return 'subsup';
    },
    enumerable: true,
    configurable: true
  });

  SubsupItem.prototype.checkItem = function (item) {
    if (item.isKind('open') || item.isKind('left')) {
      return StackItem_js_1.BaseItem.success;
    }

    var top = this.First;
    var position = this.getProperty('position');

    if (item.isKind('mml')) {
      if (this.getProperty('primes')) {
        if (position !== 2) {
          NodeUtil_js_1.default.setChild(top, 2, this.getProperty('primes'));
        } else {
          NodeUtil_js_1.default.setProperty(this.getProperty('primes'), 'variantForm', true);
          var node = this.create('node', 'mrow', [this.getProperty('primes'), item.First]);
          item.First = node;
        }
      }

      NodeUtil_js_1.default.setChild(top, position, item.First);

      if (this.getProperty('movesupsub') != null) {
        NodeUtil_js_1.default.setProperty(top, 'movesupsub', this.getProperty('movesupsub'));
      }

      var result = this.factory.create('mml', top);
      return [[result], true];
    }

    if (_super.prototype.checkItem.call(this, item)[1]) {
      var error = this.getErrors(['', 'sub', 'sup'][position]);
      throw new (TexError_js_1.default.bind.apply(TexError_js_1.default, __spread([void 0, error[0], error[1]], error.splice(2))))();
    }
  };

  return SubsupItem;
}(StackItem_js_1.BaseItem);

SubsupItem.errors = Object.assign(Object.create(StackItem_js_1.BaseItem.errors), {
  'stop': ['MissingScript', 'Missing superscript or subscript argument'],
  'sup': ['MissingOpenForSup', 'Missing open brace for superscript'],
  'sub': ['MissingOpenForSub', 'Missing open brace for subscript']
});
exports.SubsupItem = SubsupItem;

var OverItem = function (_super) {
  __extends(OverItem, _super);

  function OverItem(factory) {
    var _this = _super.call(this, factory) || this;

    _this.setProperty('name', '\\over');

    return _this;
  }

  Object.defineProperty(OverItem.prototype, "kind", {
    get: function () {
      return 'over';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(OverItem.prototype, "isClose", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  OverItem.prototype.checkItem = function (item) {
    if (item.isKind('over')) {
      throw new TexError_js_1.default('AmbiguousUseOf', 'Ambiguous use of %1', item.getName());
    }

    if (item.isClose) {
      var mml = this.create('node', 'mfrac', [this.getProperty('num'), this.toMml(false)]);

      if (this.getProperty('thickness') != null) {
        NodeUtil_js_1.default.setAttribute(mml, 'linethickness', this.getProperty('thickness'));
      }

      if (this.getProperty('open') || this.getProperty('close')) {
        NodeUtil_js_1.default.setProperty(mml, 'withDelims', true);
        mml = ParseUtil_js_1.default.fixedFence(this.factory.configuration, this.getProperty('open'), mml, this.getProperty('close'));
      }

      return [[this.factory.create('mml', mml), item], true];
    }

    return _super.prototype.checkItem.call(this, item);
  };

  OverItem.prototype.toString = function () {
    return 'over[' + this.getProperty('num') + ' / ' + this.nodes.join('; ') + ']';
  };

  return OverItem;
}(StackItem_js_1.BaseItem);

exports.OverItem = OverItem;

var LeftItem = function (_super) {
  __extends(LeftItem, _super);

  function LeftItem(factory) {
    var _this = _super.call(this, factory) || this;

    _this.setProperty('delim', '(');

    return _this;
  }

  Object.defineProperty(LeftItem.prototype, "kind", {
    get: function () {
      return 'left';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(LeftItem.prototype, "isOpen", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  LeftItem.prototype.checkItem = function (item) {
    if (item.isKind('right')) {
      return [[this.factory.create('mml', ParseUtil_js_1.default.fenced(this.factory.configuration, this.getProperty('delim'), this.toMml(), item.getProperty('delim')))], true];
    }

    return _super.prototype.checkItem.call(this, item);
  };

  return LeftItem;
}(StackItem_js_1.BaseItem);

LeftItem.errors = Object.assign(Object.create(StackItem_js_1.BaseItem.errors), {
  'stop': ['ExtraLeftMissingRight', 'Extra \\left or missing \\right']
});
exports.LeftItem = LeftItem;

var RightItem = function (_super) {
  __extends(RightItem, _super);

  function RightItem(factory) {
    var _this = _super.call(this, factory) || this;

    _this.setProperty('delim', ')');

    return _this;
  }

  Object.defineProperty(RightItem.prototype, "kind", {
    get: function () {
      return 'right';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(RightItem.prototype, "isClose", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  return RightItem;
}(StackItem_js_1.BaseItem);

exports.RightItem = RightItem;

var BeginItem = function (_super) {
  __extends(BeginItem, _super);

  function BeginItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(BeginItem.prototype, "kind", {
    get: function () {
      return 'begin';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(BeginItem.prototype, "isOpen", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  BeginItem.prototype.checkItem = function (item) {
    if (item.isKind('end')) {
      if (item.getName() !== this.getName()) {
        throw new TexError_js_1.default('EnvBadEnd', '\\begin{%1} ended with \\end{%2}', this.getName(), item.getName());
      }

      if (!this.getProperty('end')) {
        return [[this.factory.create('mml', this.toMml())], true];
      }

      return StackItem_js_1.BaseItem.fail;
    }

    if (item.isKind('stop')) {
      throw new TexError_js_1.default('EnvMissingEnd', 'Missing \\end{%1}', this.getName());
    }

    return _super.prototype.checkItem.call(this, item);
  };

  return BeginItem;
}(StackItem_js_1.BaseItem);

exports.BeginItem = BeginItem;

var EndItem = function (_super) {
  __extends(EndItem, _super);

  function EndItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(EndItem.prototype, "kind", {
    get: function () {
      return 'end';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(EndItem.prototype, "isClose", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  return EndItem;
}(StackItem_js_1.BaseItem);

exports.EndItem = EndItem;

var StyleItem = function (_super) {
  __extends(StyleItem, _super);

  function StyleItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(StyleItem.prototype, "kind", {
    get: function () {
      return 'style';
    },
    enumerable: true,
    configurable: true
  });

  StyleItem.prototype.checkItem = function (item) {
    if (!item.isClose) {
      return _super.prototype.checkItem.call(this, item);
    }

    var mml = this.create('node', 'mstyle', this.nodes, this.getProperty('styles'));
    return [[this.factory.create('mml', mml), item], true];
  };

  return StyleItem;
}(StackItem_js_1.BaseItem);

exports.StyleItem = StyleItem;

var PositionItem = function (_super) {
  __extends(PositionItem, _super);

  function PositionItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(PositionItem.prototype, "kind", {
    get: function () {
      return 'position';
    },
    enumerable: true,
    configurable: true
  });

  PositionItem.prototype.checkItem = function (item) {
    if (item.isClose) {
      throw new TexError_js_1.default('MissingBoxFor', 'Missing box for %1', this.getName());
    }

    if (item.isFinal) {
      var mml = item.toMml();

      switch (this.getProperty('move')) {
        case 'vertical':
          mml = this.create('node', 'mpadded', [mml], {
            height: this.getProperty('dh'),
            depth: this.getProperty('dd'),
            voffset: this.getProperty('dh')
          });
          return [[this.factory.create('mml', mml)], true];

        case 'horizontal':
          return [[this.factory.create('mml', this.getProperty('left')), item, this.factory.create('mml', this.getProperty('right'))], true];
      }
    }

    return _super.prototype.checkItem.call(this, item);
  };

  return PositionItem;
}(StackItem_js_1.BaseItem);

exports.PositionItem = PositionItem;

var CellItem = function (_super) {
  __extends(CellItem, _super);

  function CellItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(CellItem.prototype, "kind", {
    get: function () {
      return 'cell';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(CellItem.prototype, "isClose", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  return CellItem;
}(StackItem_js_1.BaseItem);

exports.CellItem = CellItem;

var MmlItem = function (_super) {
  __extends(MmlItem, _super);

  function MmlItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlItem.prototype, "isFinal", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlItem.prototype, "kind", {
    get: function () {
      return 'mml';
    },
    enumerable: true,
    configurable: true
  });
  return MmlItem;
}(StackItem_js_1.BaseItem);

exports.MmlItem = MmlItem;

var FnItem = function (_super) {
  __extends(FnItem, _super);

  function FnItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(FnItem.prototype, "kind", {
    get: function () {
      return 'fn';
    },
    enumerable: true,
    configurable: true
  });

  FnItem.prototype.checkItem = function (item) {
    var top = this.First;

    if (top) {
      if (item.isOpen) {
        return StackItem_js_1.BaseItem.success;
      }

      if (!item.isKind('fn')) {
        var mml = item.First;

        if (!item.isKind('mml') || !mml) {
          return [[top, item], true];
        }

        if (NodeUtil_js_1.default.isType(mml, 'mstyle') && mml.childNodes.length && NodeUtil_js_1.default.isType(mml.childNodes[0].childNodes[0], 'mspace') || NodeUtil_js_1.default.isType(mml, 'mspace')) {
          return [[top, item], true];
        }

        if (NodeUtil_js_1.default.isEmbellished(mml)) {
          mml = NodeUtil_js_1.default.getCoreMO(mml);
        }

        var form = NodeUtil_js_1.default.getForm(mml);

        if (form != null && [0, 0, 1, 1, 0, 1, 1, 0, 0, 0][form[2]]) {
          return [[top, item], true];
        }
      }

      var node = this.create('token', 'mo', {
        texClass: MmlNode_js_1.TEXCLASS.NONE
      }, Entities_js_1.entities.ApplyFunction);
      return [[top, node, item], true];
    }

    return _super.prototype.checkItem.apply(this, arguments);
  };

  return FnItem;
}(StackItem_js_1.BaseItem);

exports.FnItem = FnItem;

var NotItem = function (_super) {
  __extends(NotItem, _super);

  function NotItem() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.remap = MapHandler_js_1.MapHandler.getMap('not_remap');
    return _this;
  }

  Object.defineProperty(NotItem.prototype, "kind", {
    get: function () {
      return 'not';
    },
    enumerable: true,
    configurable: true
  });

  NotItem.prototype.checkItem = function (item) {
    var mml;
    var c;
    var textNode;

    if (item.isKind('open') || item.isKind('left')) {
      return StackItem_js_1.BaseItem.success;
    }

    if (item.isKind('mml') && (NodeUtil_js_1.default.isType(item.First, 'mo') || NodeUtil_js_1.default.isType(item.First, 'mi') || NodeUtil_js_1.default.isType(item.First, 'mtext'))) {
      mml = item.First;
      c = NodeUtil_js_1.default.getText(mml);

      if (c.length === 1 && !NodeUtil_js_1.default.getProperty(mml, 'movesupsub') && NodeUtil_js_1.default.getChildren(mml).length === 1) {
        if (this.remap.contains(c)) {
          textNode = this.create('text', this.remap.lookup(c).char);
          NodeUtil_js_1.default.setChild(mml, 0, textNode);
        } else {
          textNode = this.create('text', '\u0338');
          NodeUtil_js_1.default.appendChildren(mml, [textNode]);
        }

        return [[item], true];
      }
    }

    textNode = this.create('text', '\u29F8');
    var mtextNode = this.create('node', 'mtext', [], {}, textNode);
    var paddedNode = this.create('node', 'mpadded', [mtextNode], {
      width: 0
    });
    mml = this.create('node', 'TeXAtom', [paddedNode], {
      texClass: MmlNode_js_1.TEXCLASS.REL
    });
    return [[mml, item], true];
  };

  return NotItem;
}(StackItem_js_1.BaseItem);

exports.NotItem = NotItem;

var DotsItem = function (_super) {
  __extends(DotsItem, _super);

  function DotsItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(DotsItem.prototype, "kind", {
    get: function () {
      return 'dots';
    },
    enumerable: true,
    configurable: true
  });

  DotsItem.prototype.checkItem = function (item) {
    if (item.isKind('open') || item.isKind('left')) {
      return StackItem_js_1.BaseItem.success;
    }

    var dots = this.getProperty('ldots');
    var top = item.First;

    if (item.isKind('mml') && NodeUtil_js_1.default.isEmbellished(top)) {
      var tclass = NodeUtil_js_1.default.getTexClass(NodeUtil_js_1.default.getCoreMO(top));

      if (tclass === MmlNode_js_1.TEXCLASS.BIN || tclass === MmlNode_js_1.TEXCLASS.REL) {
        dots = this.getProperty('cdots');
      }
    }

    return [[dots, item], true];
  };

  return DotsItem;
}(StackItem_js_1.BaseItem);

exports.DotsItem = DotsItem;

var ArrayItem = function (_super) {
  __extends(ArrayItem, _super);

  function ArrayItem() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.table = [];
    _this.row = [];
    _this.frame = [];
    _this.hfill = [];
    _this.arraydef = {};
    _this.dashed = false;
    return _this;
  }

  Object.defineProperty(ArrayItem.prototype, "kind", {
    get: function () {
      return 'array';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(ArrayItem.prototype, "isOpen", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  ArrayItem.prototype.checkItem = function (item) {
    if (item.isClose && !item.isKind('over')) {
      if (item.getProperty('isEntry')) {
        this.EndEntry();
        this.clearEnv();
        return StackItem_js_1.BaseItem.fail;
      }

      if (item.getProperty('isCR')) {
        this.EndEntry();
        this.EndRow();
        this.clearEnv();
        return StackItem_js_1.BaseItem.fail;
      }

      this.EndTable();
      this.clearEnv();
      var scriptlevel = this.arraydef['scriptlevel'];
      delete this.arraydef['scriptlevel'];
      var mml = this.create('node', 'mtable', this.table, this.arraydef);

      if (this.frame.length === 4) {
        NodeUtil_js_1.default.setAttribute(mml, 'frame', this.dashed ? 'dashed' : 'solid');
      } else if (this.frame.length) {
        if (this.arraydef['rowlines']) {
          this.arraydef['rowlines'] = this.arraydef['rowlines'].replace(/none( none)+$/, 'none');
        }

        mml = this.create('node', 'menclose', [mml], {
          notation: this.frame.join(' '),
          isFrame: true
        });

        if ((this.arraydef['columnlines'] || 'none') !== 'none' || (this.arraydef['rowlines'] || 'none') !== 'none') {
          NodeUtil_js_1.default.setAttribute(mml, 'padding', 0);
        }
      }

      if (scriptlevel) {
        mml = this.create('node', 'mstyle', [mml], {
          scriptlevel: scriptlevel
        });
      }

      if (this.getProperty('open') || this.getProperty('close')) {
        mml = ParseUtil_js_1.default.fenced(this.factory.configuration, this.getProperty('open'), mml, this.getProperty('close'));
      }

      var newItem = this.factory.create('mml', mml);

      if (this.getProperty('requireClose')) {
        if (item.isKind('close')) {
          return [[newItem], true];
        }

        throw new TexError_js_1.default('MissingCloseBrace', 'Missing close brace');
      }

      return [[newItem, item], true];
    }

    return _super.prototype.checkItem.call(this, item);
  };

  ArrayItem.prototype.EndEntry = function () {
    var mtd = this.create('node', 'mtd', this.nodes);

    if (this.hfill.length) {
      if (this.hfill[0] === 0) {
        NodeUtil_js_1.default.setAttribute(mtd, 'columnalign', 'right');
      }

      if (this.hfill[this.hfill.length - 1] === this.Size()) {
        NodeUtil_js_1.default.setAttribute(mtd, 'columnalign', NodeUtil_js_1.default.getAttribute(mtd, 'columnalign') ? 'center' : 'left');
      }
    }

    this.row.push(mtd);
    this.Clear();
    this.hfill = [];
  };

  ArrayItem.prototype.EndRow = function () {
    var node;

    if (this.getProperty('isNumbered') && this.row.length === 3) {
      this.row.unshift(this.row.pop());
      node = this.create('node', 'mlabeledtr', this.row);
    } else {
      node = this.create('node', 'mtr', this.row);
    }

    this.table.push(node);
    this.row = [];
  };

  ArrayItem.prototype.EndTable = function () {
    if (this.Size() || this.row.length) {
      this.EndEntry();
      this.EndRow();
    }

    this.checkLines();
  };

  ArrayItem.prototype.checkLines = function () {
    if (this.arraydef['rowlines']) {
      var lines = this.arraydef['rowlines'].split(/ /);

      if (lines.length === this.table.length) {
        this.frame.push('bottom');
        lines.pop();
        this.arraydef['rowlines'] = lines.join(' ');
      } else if (lines.length < this.table.length - 1) {
        this.arraydef['rowlines'] += ' none';
      }
    }

    if (this.getProperty('rowspacing')) {
      var rows = this.arraydef['rowspacing'].split(/ /);

      while (rows.length < this.table.length) {
        rows.push(this.getProperty('rowspacing') + 'em');
      }

      this.arraydef['rowspacing'] = rows.join(' ');
    }
  };

  return ArrayItem;
}(StackItem_js_1.BaseItem);

exports.ArrayItem = ArrayItem;

var EqnArrayItem = function (_super) {
  __extends(EqnArrayItem, _super);

  function EqnArrayItem(factory) {
    var args = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      args[_i - 1] = arguments[_i];
    }

    var _this = _super.call(this, factory) || this;

    _this.factory.configuration.tags.start(args[0], args[2], args[1]);

    return _this;
  }

  Object.defineProperty(EqnArrayItem.prototype, "kind", {
    get: function () {
      return 'eqnarray';
    },
    enumerable: true,
    configurable: true
  });

  EqnArrayItem.prototype.EndEntry = function () {
    if (this.row.length) {
      ParseUtil_js_1.default.fixInitialMO(this.factory.configuration, this.nodes);
    }

    var node = this.create('node', 'mtd', this.nodes);
    this.row.push(node);
    this.Clear();
  };

  EqnArrayItem.prototype.EndRow = function () {
    var mtr = 'mtr';
    var tag = this.factory.configuration.tags.getTag();

    if (tag) {
      this.row = [tag].concat(this.row);
      mtr = 'mlabeledtr';
    }

    this.factory.configuration.tags.clearTag();
    var node = this.create('node', mtr, this.row);
    this.table.push(node);
    this.row = [];
  };

  EqnArrayItem.prototype.EndTable = function () {
    _super.prototype.EndTable.call(this);

    this.factory.configuration.tags.end();
  };

  return EqnArrayItem;
}(ArrayItem);

exports.EqnArrayItem = EqnArrayItem;

var EquationItem = function (_super) {
  __extends(EquationItem, _super);

  function EquationItem(factory) {
    var args = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      args[_i - 1] = arguments[_i];
    }

    var _this = _super.call(this, factory) || this;

    _this.factory.configuration.tags.start('equation', true, args[0]);

    return _this;
  }

  Object.defineProperty(EquationItem.prototype, "kind", {
    get: function () {
      return 'equation';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(EquationItem.prototype, "isOpen", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  EquationItem.prototype.checkItem = function (item) {
    if (item.isKind('end')) {
      var mml = this.toMml();
      var tag = this.factory.configuration.tags.getTag();
      this.factory.configuration.tags.end();
      return [[tag ? this.factory.configuration.tags.enTag(mml, tag) : mml, item], true];
    }

    if (item.isKind('stop')) {
      throw new TexError_js_1.default('EnvMissingEnd', 'Missing \\end{%1}', this.getName());
    }

    return _super.prototype.checkItem.call(this, item);
  };

  return EquationItem;
}(StackItem_js_1.BaseItem);

exports.EquationItem = EquationItem;

/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ARROWX = 4, exports.ARROWDX = 1, exports.ARROWY = 2;
exports.THICKNESS = .067;
exports.PADDING = .2;
exports.SOLID = exports.THICKNESS + 'em solid';
exports.sideIndex = {
  top: 0,
  right: 1,
  bottom: 2,
  left: 3
};
exports.sideNames = Object.keys(exports.sideIndex);

exports.fullBBox = function (node) {
  return new Array(4).fill(node.thickness + node.padding);
};

exports.fullPadding = function (node) {
  return new Array(4).fill(node.padding);
};

exports.fullBorder = function (node) {
  return new Array(4).fill(node.thickness);
};

exports.arrowHead = function (node) {
  return Math.max(node.padding, node.thickness * (node.arrowhead.x + node.arrowhead.dx + 1));
};

exports.arrowBBoxHD = function (node, TRBL) {
  if (node.childNodes[0]) {
    var _a = node.childNodes[0].getBBox(),
        h = _a.h,
        d = _a.d;

    TRBL[0] = TRBL[2] = Math.max(0, node.thickness * node.arrowhead.y - (h + d) / 2);
  }

  return TRBL;
};

exports.arrowBBoxW = function (node, TRBL) {
  if (node.childNodes[0]) {
    var w = node.childNodes[0].getBBox().w;
    TRBL[1] = TRBL[3] = Math.max(0, node.thickness * node.arrowhead.y - w / 2);
  }

  return TRBL;
};

exports.arrowDef = {
  up: [-Math.PI / 2, false, true, 'verticalstrike'],
  down: [Math.PI / 2, false, true, 'verticakstrike'],
  right: [0, false, false, 'horizontalstrike'],
  left: [Math.PI, false, false, 'horizontalstrike'],
  updown: [Math.PI / 2, true, true, 'verticalstrike uparrow downarrow'],
  leftright: [0, true, false, 'horizontalstrike leftarrow rightarrow']
};
exports.diagonalArrowDef = {
  updiagonal: [-1, 0, false, 'updiagonalstrike'],
  northeast: [-1, 0, false, 'updiagonalstrike'],
  southeast: [1, 0, false, 'downdiagonalstrike'],
  northwest: [1, Math.PI, false, 'downdiagonalstrike'],
  southwest: [-1, Math.PI, false, 'updiagonalstrike'],
  northeastsouthwest: [-1, 0, true, 'updiagonalstrike northeastarrow updiagonalarrow southwestarrow'],
  northwestsoutheast: [1, 0, true, 'downdiagonalstrike northwestarrow southeastarrow']
};
exports.arrowBBox = {
  up: function (node) {
    return exports.arrowBBoxW(node, [exports.arrowHead(node), 0, node.padding, 0]);
  },
  down: function (node) {
    return exports.arrowBBoxW(node, [node.padding, 0, exports.arrowHead(node), 0]);
  },
  right: function (node) {
    return exports.arrowBBoxHD(node, [0, exports.arrowHead(node), 0, node.padding]);
  },
  left: function (node) {
    return exports.arrowBBoxHD(node, [0, node.padding, 0, exports.arrowHead(node)]);
  },
  updown: function (node) {
    return exports.arrowBBoxW(node, [exports.arrowHead(node), 0, exports.arrowHead(node), 0]);
  },
  leftright: function (node) {
    return exports.arrowBBoxHD(node, [0, exports.arrowHead(node), 0, exports.arrowHead(node)]);
  }
};

exports.CommonBorder = function (render) {
  return function (side) {
    var i = exports.sideIndex[side];
    return [side, {
      renderer: render,
      bbox: function (node) {
        var bbox = [0, 0, 0, 0];
        bbox[i] = node.thickness + node.padding;
        return bbox;
      },
      border: function (node) {
        var bbox = [0, 0, 0, 0];
        bbox[i] = node.thickness;
        return bbox;
      }
    }];
  };
};

exports.CommonBorder2 = function (render) {
  return function (name, side1, side2) {
    var i1 = exports.sideIndex[side1];
    var i2 = exports.sideIndex[side2];
    return [name, {
      renderer: render,
      bbox: function (node) {
        var t = node.thickness + node.padding;
        var bbox = [0, 0, 0, 0];
        bbox[i1] = bbox[i2] = t;
        return bbox;
      },
      border: function (node) {
        var bbox = [0, 0, 0, 0];
        bbox[i1] = bbox[i2] = node.thickness;
        return bbox;
      },
      remove: side1 + ' ' + side2
    }];
  };
};

exports.CommonDiagonalStrike = function (render) {
  return function (name) {
    var cname = 'mjx-' + name.charAt(0) + 'strike';
    return [name + 'diagonalstrike', {
      renderer: render(cname),
      bbox: exports.fullBBox
    }];
  };
};

exports.CommonDiagonalArrow = function (render) {
  return function (name) {
    var _a = __read(exports.diagonalArrowDef[name], 4),
        c = _a[0],
        pi = _a[1],
        double = _a[2],
        remove = _a[3];

    return [name + 'arrow', {
      renderer: function (node, child) {
        var _a = node.arrowData(),
            a = _a.a,
            W = _a.W;

        var arrow = node.arrow(W, c * (a - pi), double);
        render(node, arrow);
      },
      bbox: function (node) {
        var _a = node.arrowData(),
            a = _a.a,
            x = _a.x,
            y = _a.y;

        var _b = __read([node.arrowhead.x, node.arrowhead.y, node.arrowhead.dx], 3),
            ax = _b[0],
            ay = _b[1],
            adx = _b[2];

        var _c = __read(node.getArgMod(ax + adx, ay), 2),
            b = _c[0],
            ar = _c[1];

        var dy = y + (b > a ? node.thickness * ar * Math.sin(b - a) : 0);
        var dx = x + (b > Math.PI / 2 - a ? node.thickness * ar * Math.sin(b + a - Math.PI / 2) : 0);
        return [dy, dx, dy, dx];
      },
      remove: remove
    }];
  };
};

exports.CommonArrow = function (render) {
  return function (name) {
    var _a = __read(exports.arrowDef[name], 4),
        angle = _a[0],
        double = _a[1],
        isVertical = _a[2],
        remove = _a[3];

    return [name + 'arrow', {
      renderer: function (node, child) {
        var _a = node.getBBox(),
            w = _a.w,
            h = _a.h,
            d = _a.d;

        var _b = __read(isVertical ? [h + d, w] : [w, h + d], 2),
            W = _b[0],
            H = _b[1];

        var arrow = node.arrow(W, angle, double);
        render(node, arrow);
      },
      bbox: exports.arrowBBox[name],
      remove: remove
    }];
  };
};

/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var scriptbase_js_1 = __webpack_require__(276);

var msubsup_js_1 = __webpack_require__(51);

var msubsup_js_2 = __webpack_require__(51);

var msubsup_js_3 = __webpack_require__(51);

var msubsup_js_4 = __webpack_require__(52);

var CHTMLmsub = function (_super) {
  __extends(CHTMLmsub, _super);

  function CHTMLmsub() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return CHTMLmsub;
}(msubsup_js_1.CommonMsubMixin(scriptbase_js_1.CHTMLscriptbase));

CHTMLmsub.kind = msubsup_js_4.MmlMsub.prototype.kind;
CHTMLmsub.useIC = false;
exports.CHTMLmsub = CHTMLmsub;

var CHTMLmsup = function (_super) {
  __extends(CHTMLmsup, _super);

  function CHTMLmsup() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return CHTMLmsup;
}(msubsup_js_2.CommonMsupMixin(scriptbase_js_1.CHTMLscriptbase));

CHTMLmsup.kind = msubsup_js_4.MmlMsup.prototype.kind;
CHTMLmsup.useIC = true;
exports.CHTMLmsup = CHTMLmsup;

var CHTMLmsubsup = function (_super) {
  __extends(CHTMLmsubsup, _super);

  function CHTMLmsubsup() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmsubsup.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);

    var _a = __read([this.baseChild, this.supChild, this.subChild], 3),
        base = _a[0],
        sup = _a[1],
        sub = _a[2];

    var _b = __read(this.getUVQ(base.getBBox(), sub.getBBox(), sup.getBBox()), 3),
        u = _b[0],
        v = _b[1],
        q = _b[2];

    var style = {
      'vertical-align': this.em(v)
    };
    base.toCHTML(chtml);
    var stack = this.adaptor.append(chtml, this.html('mjx-script', {
      style: style
    }));
    sup.toCHTML(stack);
    this.adaptor.append(stack, this.html('mjx-spacer', {
      style: {
        'margin-top': this.em(q)
      }
    }));
    sub.toCHTML(stack);
    var corebox = this.baseCore.bbox;

    if (corebox.ic) {
      this.adaptor.setStyle(sup.chtml, 'marginLeft', this.em(this.coreIC() / sup.bbox.rscale));
    }
  };

  return CHTMLmsubsup;
}(msubsup_js_3.CommonMsubsupMixin(scriptbase_js_1.CHTMLscriptbase));

CHTMLmsubsup.kind = msubsup_js_4.MmlMsubsup.prototype.kind;
CHTMLmsubsup.styles = {
  'mjx-script': {
    display: 'inline-block',
    'padding-right': '.05em'
  },
  'mjx-script > *': {
    display: 'block'
  }
};
CHTMLmsubsup.useIC = false;
exports.CHTMLmsubsup = CHTMLmsubsup;

/***/ }),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMsubMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    Object.defineProperty(class_1.prototype, "script", {
      get: function () {
        return this.childNodes[this.node.sub];
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.getOffset = function (bbox, sbox) {
      return [0, -this.getV(bbox, sbox)];
    };

    return class_1;
  }(Base);
}

exports.CommonMsubMixin = CommonMsubMixin;

function CommonMsupMixin(Base) {
  return function (_super) {
    __extends(class_2, _super);

    function class_2() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    Object.defineProperty(class_2.prototype, "script", {
      get: function () {
        return this.childNodes[this.node.sup];
      },
      enumerable: true,
      configurable: true
    });

    class_2.prototype.getOffset = function (bbox, sbox) {
      var x = this.baseCore.bbox.ic ? .2 * this.baseCore.bbox.ic + .05 : 0;
      return [x, this.getU(bbox, sbox)];
    };

    return class_2;
  }(Base);
}

exports.CommonMsupMixin = CommonMsupMixin;

function CommonMsubsupMixin(Base) {
  return function (_super) {
    __extends(class_3, _super);

    function class_3() {
      var _this = _super !== null && _super.apply(this, arguments) || this;

      _this.UVQ = null;
      return _this;
    }

    Object.defineProperty(class_3.prototype, "subChild", {
      get: function () {
        return this.childNodes[this.node.sub];
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_3.prototype, "supChild", {
      get: function () {
        return this.childNodes[this.node.sup];
      },
      enumerable: true,
      configurable: true
    });

    class_3.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var basebox = this.baseChild.getBBox();
      var subbox = this.subChild.getBBox();
      var supbox = this.supChild.getBBox();
      bbox.empty();
      bbox.append(basebox);
      var w = bbox.w;

      var _a = __read(this.getUVQ(basebox, subbox, supbox), 3),
          u = _a[0],
          v = _a[1],
          q = _a[2];

      bbox.combine(subbox, w, v);
      bbox.combine(supbox, w + this.coreIC(), u);
      bbox.w += this.font.params.scriptspace;
      bbox.clean();
      this.setChildPWidths(recompute);
    };

    class_3.prototype.getUVQ = function (basebox, subbox, supbox) {
      if (this.UVQ) return this.UVQ;
      var tex = this.font.params;
      var t = 3 * tex.rule_thickness;
      var subscriptshift = this.length2em(this.node.attributes.get('subscriptshift'), tex.sub2);
      var drop = this.isCharBase() ? 0 : basebox.d + tex.sub_drop * subbox.rscale;

      var _a = __read([this.getU(basebox, supbox), Math.max(drop, subscriptshift)], 2),
          u = _a[0],
          v = _a[1];

      var q = u - supbox.d * supbox.rscale - (subbox.h * subbox.rscale - v);

      if (q < t) {
        v += t - q;
        var p = 4 / 5 * tex.x_height - (u - supbox.d * supbox.rscale);

        if (p > 0) {
          u += p;
          v -= p;
        }
      }

      u = Math.max(this.length2em(this.node.attributes.get('superscriptshift'), u), u);
      v = Math.max(this.length2em(this.node.attributes.get('subscriptshift'), v), v);
      q = u - supbox.d * supbox.rscale - (subbox.h * subbox.rscale - v);
      this.UVQ = [u, -v, q];
      return this.UVQ;
    };

    return class_3;
  }(Base);
}

exports.CommonMsubsupMixin = CommonMsubsupMixin;

/***/ }),
/* 52 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMsubsup = function (_super) {
  __extends(MmlMsubsup, _super);

  function MmlMsubsup() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMsubsup.prototype, "kind", {
    get: function () {
      return 'msubsup';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsubsup.prototype, "arity", {
    get: function () {
      return 3;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsubsup.prototype, "base", {
    get: function () {
      return 0;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsubsup.prototype, "sub", {
    get: function () {
      return 1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsubsup.prototype, "sup", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });

  MmlMsubsup.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    var nodes = this.childNodes;
    nodes[0].setInheritedAttributes(attributes, display, level, prime);
    nodes[1].setInheritedAttributes(attributes, false, level + 1, prime || this.sub === 1);

    if (!nodes[2]) {
      return;
    }

    nodes[2].setInheritedAttributes(attributes, false, level + 1, prime || this.sub === 2);
  };

  return MmlMsubsup;
}(MmlNode_js_1.AbstractMmlBaseNode);

MmlMsubsup.defaults = __assign({}, MmlNode_js_1.AbstractMmlBaseNode.defaults, {
  subscriptshift: '',
  superscriptshift: ''
});
exports.MmlMsubsup = MmlMsubsup;

var MmlMsub = function (_super) {
  __extends(MmlMsub, _super);

  function MmlMsub() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMsub.prototype, "kind", {
    get: function () {
      return 'msub';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsub.prototype, "arity", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });
  return MmlMsub;
}(MmlMsubsup);

MmlMsub.defaults = __assign({}, MmlMsubsup.defaults);
exports.MmlMsub = MmlMsub;

var MmlMsup = function (_super) {
  __extends(MmlMsup, _super);

  function MmlMsup() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMsup.prototype, "kind", {
    get: function () {
      return 'msup';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsup.prototype, "arity", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsup.prototype, "sup", {
    get: function () {
      return 1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsup.prototype, "sub", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });
  return MmlMsup;
}(MmlMsubsup);

MmlMsup.defaults = __assign({}, MmlMsubsup.defaults);
exports.MmlMsup = MmlMsup;

/***/ }),
/* 53 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMunderMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.stretchChildren();

      return _this;
    }

    Object.defineProperty(class_1.prototype, "script", {
      get: function () {
        return this.childNodes[this.node.under];
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      if (this.hasMovableLimits()) {
        _super.prototype.computeBBox.call(this, bbox, recompute);

        return;
      }

      bbox.empty();
      var basebox = this.baseChild.getBBox();
      var underbox = this.script.getBBox();

      var _a = __read(this.getUnderKV(basebox, underbox), 2),
          k = _a[0],
          v = _a[1];

      var delta = this.getDelta(true);

      var _b = __read(this.getDeltaW([basebox, underbox], [0, -delta]), 2),
          bw = _b[0],
          uw = _b[1];

      bbox.combine(basebox, bw, 0);
      bbox.combine(underbox, uw, v);
      bbox.d += this.font.params.big_op_spacing5;
      bbox.ic = -this.baseCore.bbox.ic;
      bbox.clean();
      this.setChildPWidths(recompute);
    };

    return class_1;
  }(Base);
}

exports.CommonMunderMixin = CommonMunderMixin;

function CommonMoverMixin(Base) {
  return function (_super) {
    __extends(class_2, _super);

    function class_2() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.stretchChildren();

      return _this;
    }

    Object.defineProperty(class_2.prototype, "script", {
      get: function () {
        return this.childNodes[this.node.over];
      },
      enumerable: true,
      configurable: true
    });

    class_2.prototype.computeBBox = function (bbox) {
      if (this.hasMovableLimits()) {
        _super.prototype.computeBBox.call(this, bbox);

        return;
      }

      bbox.empty();
      var basebox = this.baseChild.getBBox();
      var overbox = this.script.getBBox();

      var _a = __read(this.getOverKU(basebox, overbox), 2),
          k = _a[0],
          u = _a[1];

      var delta = this.getDelta();

      var _b = __read(this.getDeltaW([basebox, overbox], [0, delta]), 2),
          bw = _b[0],
          ow = _b[1];

      bbox.combine(basebox, bw, 0);
      bbox.combine(overbox, ow, u);
      bbox.h += this.font.params.big_op_spacing5;
      bbox.ic = -this.baseCore.bbox.ic;
      bbox.clean();
    };

    return class_2;
  }(Base);
}

exports.CommonMoverMixin = CommonMoverMixin;

function CommonMunderoverMixin(Base) {
  return function (_super) {
    __extends(class_3, _super);

    function class_3() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.stretchChildren();

      return _this;
    }

    Object.defineProperty(class_3.prototype, "underChild", {
      get: function () {
        return this.childNodes[this.node.under];
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_3.prototype, "overChild", {
      get: function () {
        return this.childNodes[this.node.over];
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_3.prototype, "subChild", {
      get: function () {
        return this.underChild;
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_3.prototype, "supChild", {
      get: function () {
        return this.overChild;
      },
      enumerable: true,
      configurable: true
    });

    class_3.prototype.computeBBox = function (bbox) {
      if (this.hasMovableLimits()) {
        _super.prototype.computeBBox.call(this, bbox);

        return;
      }

      bbox.empty();
      var overbox = this.overChild.getBBox();
      var basebox = this.baseChild.getBBox();
      var underbox = this.underChild.getBBox();

      var _a = __read(this.getOverKU(basebox, overbox), 2),
          ok = _a[0],
          u = _a[1];

      var _b = __read(this.getUnderKV(basebox, underbox), 2),
          uk = _b[0],
          v = _b[1];

      var delta = this.getDelta();

      var _c = __read(this.getDeltaW([basebox, underbox, overbox], [0, -delta, delta]), 3),
          bw = _c[0],
          uw = _c[1],
          ow = _c[2];

      bbox.combine(basebox, bw, 0);
      bbox.combine(overbox, ow, u);
      bbox.combine(underbox, uw, v);
      var z = this.font.params.big_op_spacing5;
      bbox.h += z;
      bbox.d += z;
      bbox.ic = -this.baseCore.bbox.ic;
      bbox.clean();
    };

    return class_3;
  }(Base);
}

exports.CommonMunderoverMixin = CommonMunderoverMixin;

/***/ }),
/* 54 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var ParseUtil_js_1 = __webpack_require__(9);

var NodeUtil_js_1 = __webpack_require__(8);

var TexConstants_js_1 = __webpack_require__(14);

var TexParser_js_1 = __webpack_require__(15);

var TexError_js_1 = __webpack_require__(6);

var Symbol_js_1 = __webpack_require__(36);

var MapHandler_js_1 = __webpack_require__(17);

var BaseMethods_js_1 = __webpack_require__(19);

var MmlNode_js_1 = __webpack_require__(0);

var AmsMethods = {};

AmsMethods.AmsEqnArray = function (parser, begin, numbered, taggable, align, spacing, style) {
  var args = parser.GetBrackets('\\begin{' + begin.getName() + '}');
  var array = BaseMethods_js_1.default.EqnArray(parser, begin, numbered, taggable, align, spacing, style);
  return ParseUtil_js_1.default.setArrayAlign(array, args);
};

AmsMethods.AlignAt = function (parser, begin, numbered, taggable) {
  var name = begin.getName();
  var n,
      valign,
      align = '',
      spacing = [];

  if (!taggable) {
    valign = parser.GetBrackets('\\begin{' + name + '}');
  }

  n = parser.GetArgument('\\begin{' + name + '}');

  if (n.match(/[^0-9]/)) {
    throw new TexError_js_1.default('PositiveIntegerArg', 'Argument to %1 must me a positive integer', '\\begin{' + name + '}');
  }

  var count = parseInt(n, 10);

  while (count > 0) {
    align += 'rl';
    spacing.push('0em 0em');
    count--;
  }

  var spaceStr = spacing.join(' ');

  if (taggable) {
    return AmsMethods.EqnArray(parser, begin, numbered, taggable, align, spaceStr);
  }

  var array = AmsMethods.EqnArray(parser, begin, numbered, taggable, align, spaceStr);
  return ParseUtil_js_1.default.setArrayAlign(array, valign);
};

AmsMethods.Multline = function (parser, begin, numbered) {
  parser.Push(begin);
  ParseUtil_js_1.default.checkEqnEnv(parser);
  var item = parser.itemFactory.create('multline', numbered, parser.stack);
  item.arraydef = {
    displaystyle: true,
    rowspacing: '.5em',
    columnwidth: '100%',
    width: parser.options['MultLineWidth'],
    side: parser.options['TagSide'],
    minlabelspacing: parser.options['TagIndent']
  };
  return item;
};

AmsMethods.HandleDeclareOp = function (parser, name) {
  var limits = parser.GetStar() ? '' : '\\nolimits\\SkipLimits';
  var cs = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));

  if (cs.charAt(0) === '\\') {
    cs = cs.substr(1);
  }

  var op = parser.GetArgument(name);
  op = op.replace(/\*/g, '\\text{*}').replace(/-/g, '\\text{-}');
  parser.configuration.handlers.retrieve(MapHandler_js_1.ExtensionMaps.NEW_COMMAND).add(cs, new Symbol_js_1.Macro(cs, AmsMethods.Macro, ['\\mathop{\\rm ' + op + '}' + limits]));
};

AmsMethods.HandleOperatorName = function (parser, name) {
  var limits = parser.GetStar() ? '' : '\\nolimits\\SkipLimits';
  var op = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));
  op = op.replace(/\*/g, '\\text{*}').replace(/-/g, '\\text{-}');
  parser.string = '\\mathop{\\rm ' + op + '}' + limits + ' ' + parser.string.slice(parser.i);
  parser.i = 0;
};

AmsMethods.SkipLimits = function (parser, name) {
  var c = parser.GetNext(),
      i = parser.i;

  if (c === '\\' && ++parser.i && parser.GetCS() !== 'limits') {
    parser.i = i;
  }
};

AmsMethods.MultiIntegral = function (parser, name, integral) {
  var next = parser.GetNext();

  if (next === '\\') {
    var i = parser.i;
    next = parser.GetArgument(name);
    parser.i = i;

    if (next === '\\limits') {
      if (name === '\\idotsint') {
        integral = '\\!\\!\\mathop{\\,\\,' + integral + '}';
      } else {
        integral = '\\!\\!\\!\\mathop{\\,\\,\\,' + integral + '}';
      }
    }
  }

  parser.string = integral + ' ' + parser.string.slice(parser.i);
  parser.i = 0;
};

AmsMethods.xArrow = function (parser, name, chr, l, r) {
  var def = {
    width: '+' + (l + r) + 'mu',
    lspace: l + 'mu'
  };
  var bot = parser.GetBrackets(name);
  var first = parser.ParseArg(name);
  var arrow = parser.create('token', 'mo', {
    stretchy: true,
    texClass: MmlNode_js_1.TEXCLASS.REL
  }, String.fromCharCode(chr));
  var mml = parser.create('node', 'munderover', [arrow]);
  var mpadded = parser.create('node', 'mpadded', [first], def);
  NodeUtil_js_1.default.setAttribute(mpadded, 'voffset', '.15em');
  NodeUtil_js_1.default.setChild(mml, mml.over, mpadded);

  if (bot) {
    var bottom = new TexParser_js_1.default(bot, parser.stack.env, parser.configuration).mml();
    mpadded = parser.create('node', 'mpadded', [bottom], def);
    NodeUtil_js_1.default.setAttribute(mpadded, 'voffset', '-.24em');
    NodeUtil_js_1.default.setChild(mml, mml.under, mpadded);
  }

  NodeUtil_js_1.default.setProperty(mml, 'subsupOK', true);
  parser.Push(mml);
};

AmsMethods.HandleShove = function (parser, name, shove) {
  var top = parser.stack.Top();

  if (top.kind !== 'multline') {
    throw new TexError_js_1.default('CommandOnlyAllowedInEnv', '%1 only allowed in %2 environment', parser.currentCS, 'multline');
  }

  if (top.Size()) {
    throw new TexError_js_1.default('CommandAtTheBeginingOfLine', '%1 must come at the beginning of the line', parser.currentCS);
  }

  top.setProperty('shove', shove);
};

AmsMethods.CFrac = function (parser, name) {
  var lr = ParseUtil_js_1.default.trimSpaces(parser.GetBrackets(name, ''));
  var num = parser.GetArgument(name);
  var den = parser.GetArgument(name);
  var lrMap = {
    l: TexConstants_js_1.TexConstant.Align.LEFT,
    r: TexConstants_js_1.TexConstant.Align.RIGHT,
    '': ''
  };
  var numNode = new TexParser_js_1.default('\\strut\\textstyle{' + num + '}', parser.stack.env, parser.configuration).mml();
  var denNode = new TexParser_js_1.default('\\strut\\textstyle{' + den + '}', parser.stack.env, parser.configuration).mml();
  var frac = parser.create('node', 'mfrac', [numNode, denNode]);
  lr = lrMap[lr];

  if (lr == null) {
    throw new TexError_js_1.default('IllegalAlign', 'Illegal alignment specified in %1', parser.currentCS);
  }

  if (lr) {
    NodeUtil_js_1.default.setProperties(frac, {
      numalign: lr,
      denomalign: lr
    });
  }

  parser.Push(frac);
};

AmsMethods.Genfrac = function (parser, name, left, right, thick, style) {
  if (left == null) {
    left = parser.GetDelimiterArg(name);
  }

  if (right == null) {
    right = parser.GetDelimiterArg(name);
  }

  if (thick == null) {
    thick = parser.GetArgument(name);
  }

  if (style == null) {
    style = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));
  }

  var num = parser.ParseArg(name);
  var den = parser.ParseArg(name);
  var frac = parser.create('node', 'mfrac', [num, den]);

  if (thick !== '') {
    NodeUtil_js_1.default.setAttribute(frac, 'linethickness', thick);
  }

  if (left || right) {
    NodeUtil_js_1.default.setProperty(frac, 'withDelims', true);
    frac = ParseUtil_js_1.default.fixedFence(parser.configuration, left, frac, right);
  }

  if (style !== '') {
    var styleDigit = parseInt(style, 10);
    var styleAlpha = ['D', 'T', 'S', 'SS'][styleDigit];

    if (styleAlpha == null) {
      throw new TexError_js_1.default('BadMathStyleFor', 'Bad math style for %1', parser.currentCS);
    }

    frac = parser.create('node', 'mstyle', [frac]);

    if (styleAlpha === 'D') {
      NodeUtil_js_1.default.setProperties(frac, {
        displaystyle: true,
        scriptlevel: 0
      });
    } else {
      NodeUtil_js_1.default.setProperties(frac, {
        displaystyle: false,
        scriptlevel: styleDigit - 1
      });
    }
  }

  parser.Push(frac);
};

AmsMethods.HandleTag = function (parser, name) {
  if (!parser.tags.currentTag.taggable && parser.tags.env) {
    throw new TexError_js_1.default('CommandNotAllowedInEnv', '%1 not allowed in %2 environment', parser.currentCS, parser.tags.env);
  }

  if (parser.tags.currentTag.tag) {
    throw new TexError_js_1.default('MultipleCommand', 'Multiple %1', parser.currentCS);
  }

  var star = parser.GetStar();
  var tagId = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));
  parser.tags.tag(tagId, star);
};

AmsMethods.HandleNoTag = BaseMethods_js_1.default.HandleNoTag;
AmsMethods.HandleRef = BaseMethods_js_1.default.HandleRef;
AmsMethods.Macro = BaseMethods_js_1.default.Macro;
AmsMethods.Accent = BaseMethods_js_1.default.Accent;
AmsMethods.Tilde = BaseMethods_js_1.default.Tilde;
AmsMethods.Array = BaseMethods_js_1.default.Array;
AmsMethods.Spacer = BaseMethods_js_1.default.Spacer;
AmsMethods.NamedOp = BaseMethods_js_1.default.NamedOp;
AmsMethods.EqnArray = BaseMethods_js_1.default.EqnArray;
exports.default = AmsMethods;

/***/ }),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


const yaml = __webpack_require__(113);
/**
 * Default engines
 */


const engines = exports = module.exports;
/**
 * YAML
 */

engines.yaml = {
  parse: yaml.safeLoad.bind(yaml),
  stringify: yaml.safeDump.bind(yaml)
};
/**
 * JSON
 */

engines.json = {
  parse: JSON.parse.bind(JSON),
  stringify: function (obj, options) {
    const opts = Object.assign({
      replacer: null,
      space: 2
    }, options);
    return JSON.stringify(obj, opts.replacer, opts.space);
  }
};
/**
 * JavaScript
 */

engines.javascript = {
  parse: function parse(str, options, wrap) {
    /* eslint no-eval: 0 */
    try {
      if (wrap !== false) {
        str = '(function() {\nreturn ' + str.trim() + ';\n}());';
      }

      return eval(str) || {};
    } catch (err) {
      if (wrap !== false && /(unexpected|identifier)/i.test(err.message)) {
        return parse(str, options, false);
      }

      throw new SyntaxError(err);
    }
  },
  stringify: function () {
    throw new Error('stringifying JavaScript is not supported');
  }
};

/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Standard YAML's Core schema.
// http://www.yaml.org/spec/1.2/spec.html#id2804923
//
// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
// So, Core schema has no distinctions from JSON schema is JS-YAML.


var Schema = __webpack_require__(21);

module.exports = new Schema({
  include: [__webpack_require__(57)]
});

/***/ }),
/* 57 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Standard YAML's JSON schema.
// http://www.yaml.org/spec/1.2/spec.html#id2803231
//
// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
// So, this schema is not such strict as defined in the YAML specification.
// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc.


var Schema = __webpack_require__(21);

module.exports = new Schema({
  include: [__webpack_require__(37)],
  implicit: [__webpack_require__(120), __webpack_require__(121), __webpack_require__(122), __webpack_require__(123)]
});

/***/ }),
/* 58 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <http://feross.org>
 * @license  MIT
 */

/* eslint-disable no-proto */


var base64 = __webpack_require__(127);

var ieee754 = __webpack_require__(128);

var isArray = __webpack_require__(129);

exports.Buffer = Buffer;
exports.SlowBuffer = SlowBuffer;
exports.INSPECT_MAX_BYTES = 50;
/**
 * If `Buffer.TYPED_ARRAY_SUPPORT`:
 *   === true    Use Uint8Array implementation (fastest)
 *   === false   Use Object implementation (most compatible, even IE6)
 *
 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
 * Opera 11.6+, iOS 4.2+.
 *
 * Due to various browser bugs, sometimes the Object implementation will be used even
 * when the browser supports typed arrays.
 *
 * Note:
 *
 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
 *
 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
 *
 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
 *     incorrect length in some situations.

 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
 * get the Object implementation, which is slower but behaves correctly.
 */

Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport();
/*
 * Export kMaxLength after typed array support is determined.
 */

exports.kMaxLength = kMaxLength();

function typedArraySupport() {
  try {
    var arr = new Uint8Array(1);
    arr.__proto__ = {
      __proto__: Uint8Array.prototype,
      foo: function () {
        return 42;
      }
    };
    return arr.foo() === 42 && // typed array instances can be augmented
    typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
    arr.subarray(1, 1).byteLength === 0; // ie10 has broken `subarray`
  } catch (e) {
    return false;
  }
}

function kMaxLength() {
  return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff;
}

function createBuffer(that, length) {
  if (kMaxLength() < length) {
    throw new RangeError('Invalid typed array length');
  }

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    // Return an augmented `Uint8Array` instance, for best performance
    that = new Uint8Array(length);
    that.__proto__ = Buffer.prototype;
  } else {
    // Fallback: Return an object instance of the Buffer class
    if (that === null) {
      that = new Buffer(length);
    }

    that.length = length;
  }

  return that;
}
/**
 * The Buffer constructor returns instances of `Uint8Array` that have their
 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
 * returns a single octet.
 *
 * The `Uint8Array` prototype remains unmodified.
 */


function Buffer(arg, encodingOrOffset, length) {
  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
    return new Buffer(arg, encodingOrOffset, length);
  } // Common case.


  if (typeof arg === 'number') {
    if (typeof encodingOrOffset === 'string') {
      throw new Error('If encoding is specified then the first argument must be a string');
    }

    return allocUnsafe(this, arg);
  }

  return from(this, arg, encodingOrOffset, length);
}

Buffer.poolSize = 8192; // not used by this implementation
// TODO: Legacy, not needed anymore. Remove in next major version.

Buffer._augment = function (arr) {
  arr.__proto__ = Buffer.prototype;
  return arr;
};

function from(that, value, encodingOrOffset, length) {
  if (typeof value === 'number') {
    throw new TypeError('"value" argument must not be a number');
  }

  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
    return fromArrayBuffer(that, value, encodingOrOffset, length);
  }

  if (typeof value === 'string') {
    return fromString(that, value, encodingOrOffset);
  }

  return fromObject(that, value);
}
/**
 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
 * if value is a number.
 * Buffer.from(str[, encoding])
 * Buffer.from(array)
 * Buffer.from(buffer)
 * Buffer.from(arrayBuffer[, byteOffset[, length]])
 **/


Buffer.from = function (value, encodingOrOffset, length) {
  return from(null, value, encodingOrOffset, length);
};

if (Buffer.TYPED_ARRAY_SUPPORT) {
  Buffer.prototype.__proto__ = Uint8Array.prototype;
  Buffer.__proto__ = Uint8Array;

  if (typeof Symbol !== 'undefined' && Symbol.species && Buffer[Symbol.species] === Buffer) {
    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
    Object.defineProperty(Buffer, Symbol.species, {
      value: null,
      configurable: true
    });
  }
}

function assertSize(size) {
  if (typeof size !== 'number') {
    throw new TypeError('"size" argument must be a number');
  } else if (size < 0) {
    throw new RangeError('"size" argument must not be negative');
  }
}

function alloc(that, size, fill, encoding) {
  assertSize(size);

  if (size <= 0) {
    return createBuffer(that, size);
  }

  if (fill !== undefined) {
    // Only pay attention to encoding if it's a string. This
    // prevents accidentally sending in a number that would
    // be interpretted as a start offset.
    return typeof encoding === 'string' ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);
  }

  return createBuffer(that, size);
}
/**
 * Creates a new filled Buffer instance.
 * alloc(size[, fill[, encoding]])
 **/


Buffer.alloc = function (size, fill, encoding) {
  return alloc(null, size, fill, encoding);
};

function allocUnsafe(that, size) {
  assertSize(size);
  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);

  if (!Buffer.TYPED_ARRAY_SUPPORT) {
    for (var i = 0; i < size; ++i) {
      that[i] = 0;
    }
  }

  return that;
}
/**
 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
 * */


Buffer.allocUnsafe = function (size) {
  return allocUnsafe(null, size);
};
/**
 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
 */


Buffer.allocUnsafeSlow = function (size) {
  return allocUnsafe(null, size);
};

function fromString(that, string, encoding) {
  if (typeof encoding !== 'string' || encoding === '') {
    encoding = 'utf8';
  }

  if (!Buffer.isEncoding(encoding)) {
    throw new TypeError('"encoding" must be a valid string encoding');
  }

  var length = byteLength(string, encoding) | 0;
  that = createBuffer(that, length);
  var actual = that.write(string, encoding);

  if (actual !== length) {
    // Writing a hex string, for example, that contains invalid characters will
    // cause everything after the first invalid character to be ignored. (e.g.
    // 'abxxcd' will be treated as 'ab')
    that = that.slice(0, actual);
  }

  return that;
}

function fromArrayLike(that, array) {
  var length = array.length < 0 ? 0 : checked(array.length) | 0;
  that = createBuffer(that, length);

  for (var i = 0; i < length; i += 1) {
    that[i] = array[i] & 255;
  }

  return that;
}

function fromArrayBuffer(that, array, byteOffset, length) {
  array.byteLength; // this throws if `array` is not a valid ArrayBuffer

  if (byteOffset < 0 || array.byteLength < byteOffset) {
    throw new RangeError('\'offset\' is out of bounds');
  }

  if (array.byteLength < byteOffset + (length || 0)) {
    throw new RangeError('\'length\' is out of bounds');
  }

  if (byteOffset === undefined && length === undefined) {
    array = new Uint8Array(array);
  } else if (length === undefined) {
    array = new Uint8Array(array, byteOffset);
  } else {
    array = new Uint8Array(array, byteOffset, length);
  }

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    // Return an augmented `Uint8Array` instance, for best performance
    that = array;
    that.__proto__ = Buffer.prototype;
  } else {
    // Fallback: Return an object instance of the Buffer class
    that = fromArrayLike(that, array);
  }

  return that;
}

function fromObject(that, obj) {
  if (Buffer.isBuffer(obj)) {
    var len = checked(obj.length) | 0;
    that = createBuffer(that, len);

    if (that.length === 0) {
      return that;
    }

    obj.copy(that, 0, 0, len);
    return that;
  }

  if (obj) {
    if (typeof ArrayBuffer !== 'undefined' && obj.buffer instanceof ArrayBuffer || 'length' in obj) {
      if (typeof obj.length !== 'number' || isnan(obj.length)) {
        return createBuffer(that, 0);
      }

      return fromArrayLike(that, obj);
    }

    if (obj.type === 'Buffer' && isArray(obj.data)) {
      return fromArrayLike(that, obj.data);
    }
  }

  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.');
}

function checked(length) {
  // Note: cannot use `length < kMaxLength()` here because that fails when
  // length is NaN (which is otherwise coerced to zero.)
  if (length >= kMaxLength()) {
    throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes');
  }

  return length | 0;
}

function SlowBuffer(length) {
  if (+length != length) {
    // eslint-disable-line eqeqeq
    length = 0;
  }

  return Buffer.alloc(+length);
}

Buffer.isBuffer = function isBuffer(b) {
  return !!(b != null && b._isBuffer);
};

Buffer.compare = function compare(a, b) {
  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
    throw new TypeError('Arguments must be Buffers');
  }

  if (a === b) return 0;
  var x = a.length;
  var y = b.length;

  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
    if (a[i] !== b[i]) {
      x = a[i];
      y = b[i];
      break;
    }
  }

  if (x < y) return -1;
  if (y < x) return 1;
  return 0;
};

Buffer.isEncoding = function isEncoding(encoding) {
  switch (String(encoding).toLowerCase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'latin1':
    case 'binary':
    case 'base64':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true;

    default:
      return false;
  }
};

Buffer.concat = function concat(list, length) {
  if (!isArray(list)) {
    throw new TypeError('"list" argument must be an Array of Buffers');
  }

  if (list.length === 0) {
    return Buffer.alloc(0);
  }

  var i;

  if (length === undefined) {
    length = 0;

    for (i = 0; i < list.length; ++i) {
      length += list[i].length;
    }
  }

  var buffer = Buffer.allocUnsafe(length);
  var pos = 0;

  for (i = 0; i < list.length; ++i) {
    var buf = list[i];

    if (!Buffer.isBuffer(buf)) {
      throw new TypeError('"list" argument must be an Array of Buffers');
    }

    buf.copy(buffer, pos);
    pos += buf.length;
  }

  return buffer;
};

function byteLength(string, encoding) {
  if (Buffer.isBuffer(string)) {
    return string.length;
  }

  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
    return string.byteLength;
  }

  if (typeof string !== 'string') {
    string = '' + string;
  }

  var len = string.length;
  if (len === 0) return 0; // Use a for loop to avoid recursion

  var loweredCase = false;

  for (;;) {
    switch (encoding) {
      case 'ascii':
      case 'latin1':
      case 'binary':
        return len;

      case 'utf8':
      case 'utf-8':
      case undefined:
        return utf8ToBytes(string).length;

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return len * 2;

      case 'hex':
        return len >>> 1;

      case 'base64':
        return base64ToBytes(string).length;

      default:
        if (loweredCase) return utf8ToBytes(string).length; // assume utf8

        encoding = ('' + encoding).toLowerCase();
        loweredCase = true;
    }
  }
}

Buffer.byteLength = byteLength;

function slowToString(encoding, start, end) {
  var loweredCase = false; // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
  // property of a typed array.
  // This behaves neither like String nor Uint8Array in that we set start/end
  // to their upper/lower bounds if the value passed is out of range.
  // undefined is handled specially as per ECMA-262 6th Edition,
  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.

  if (start === undefined || start < 0) {
    start = 0;
  } // Return early if start > this.length. Done here to prevent potential uint32
  // coercion fail below.


  if (start > this.length) {
    return '';
  }

  if (end === undefined || end > this.length) {
    end = this.length;
  }

  if (end <= 0) {
    return '';
  } // Force coersion to uint32. This will also coerce falsey/NaN values to 0.


  end >>>= 0;
  start >>>= 0;

  if (end <= start) {
    return '';
  }

  if (!encoding) encoding = 'utf8';

  while (true) {
    switch (encoding) {
      case 'hex':
        return hexSlice(this, start, end);

      case 'utf8':
      case 'utf-8':
        return utf8Slice(this, start, end);

      case 'ascii':
        return asciiSlice(this, start, end);

      case 'latin1':
      case 'binary':
        return latin1Slice(this, start, end);

      case 'base64':
        return base64Slice(this, start, end);

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return utf16leSlice(this, start, end);

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);
        encoding = (encoding + '').toLowerCase();
        loweredCase = true;
    }
  }
} // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
// Buffer instances.


Buffer.prototype._isBuffer = true;

function swap(b, n, m) {
  var i = b[n];
  b[n] = b[m];
  b[m] = i;
}

Buffer.prototype.swap16 = function swap16() {
  var len = this.length;

  if (len % 2 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 16-bits');
  }

  for (var i = 0; i < len; i += 2) {
    swap(this, i, i + 1);
  }

  return this;
};

Buffer.prototype.swap32 = function swap32() {
  var len = this.length;

  if (len % 4 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 32-bits');
  }

  for (var i = 0; i < len; i += 4) {
    swap(this, i, i + 3);
    swap(this, i + 1, i + 2);
  }

  return this;
};

Buffer.prototype.swap64 = function swap64() {
  var len = this.length;

  if (len % 8 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 64-bits');
  }

  for (var i = 0; i < len; i += 8) {
    swap(this, i, i + 7);
    swap(this, i + 1, i + 6);
    swap(this, i + 2, i + 5);
    swap(this, i + 3, i + 4);
  }

  return this;
};

Buffer.prototype.toString = function toString() {
  var length = this.length | 0;
  if (length === 0) return '';
  if (arguments.length === 0) return utf8Slice(this, 0, length);
  return slowToString.apply(this, arguments);
};

Buffer.prototype.equals = function equals(b) {
  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');
  if (this === b) return true;
  return Buffer.compare(this, b) === 0;
};

Buffer.prototype.inspect = function inspect() {
  var str = '';
  var max = exports.INSPECT_MAX_BYTES;

  if (this.length > 0) {
    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
    if (this.length > max) str += ' ... ';
  }

  return '<Buffer ' + str + '>';
};

Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
  if (!Buffer.isBuffer(target)) {
    throw new TypeError('Argument must be a Buffer');
  }

  if (start === undefined) {
    start = 0;
  }

  if (end === undefined) {
    end = target ? target.length : 0;
  }

  if (thisStart === undefined) {
    thisStart = 0;
  }

  if (thisEnd === undefined) {
    thisEnd = this.length;
  }

  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
    throw new RangeError('out of range index');
  }

  if (thisStart >= thisEnd && start >= end) {
    return 0;
  }

  if (thisStart >= thisEnd) {
    return -1;
  }

  if (start >= end) {
    return 1;
  }

  start >>>= 0;
  end >>>= 0;
  thisStart >>>= 0;
  thisEnd >>>= 0;
  if (this === target) return 0;
  var x = thisEnd - thisStart;
  var y = end - start;
  var len = Math.min(x, y);
  var thisCopy = this.slice(thisStart, thisEnd);
  var targetCopy = target.slice(start, end);

  for (var i = 0; i < len; ++i) {
    if (thisCopy[i] !== targetCopy[i]) {
      x = thisCopy[i];
      y = targetCopy[i];
      break;
    }
  }

  if (x < y) return -1;
  if (y < x) return 1;
  return 0;
}; // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf


function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
  // Empty buffer means no match
  if (buffer.length === 0) return -1; // Normalize byteOffset

  if (typeof byteOffset === 'string') {
    encoding = byteOffset;
    byteOffset = 0;
  } else if (byteOffset > 0x7fffffff) {
    byteOffset = 0x7fffffff;
  } else if (byteOffset < -0x80000000) {
    byteOffset = -0x80000000;
  }

  byteOffset = +byteOffset; // Coerce to Number.

  if (isNaN(byteOffset)) {
    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
    byteOffset = dir ? 0 : buffer.length - 1;
  } // Normalize byteOffset: negative offsets start from the end of the buffer


  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;

  if (byteOffset >= buffer.length) {
    if (dir) return -1;else byteOffset = buffer.length - 1;
  } else if (byteOffset < 0) {
    if (dir) byteOffset = 0;else return -1;
  } // Normalize val


  if (typeof val === 'string') {
    val = Buffer.from(val, encoding);
  } // Finally, search either indexOf (if dir is true) or lastIndexOf


  if (Buffer.isBuffer(val)) {
    // Special case: looking for empty string/buffer always fails
    if (val.length === 0) {
      return -1;
    }

    return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
  } else if (typeof val === 'number') {
    val = val & 0xFF; // Search for a byte value [0-255]

    if (Buffer.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === 'function') {
      if (dir) {
        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
      } else {
        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
      }
    }

    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
  }

  throw new TypeError('val must be string, number or Buffer');
}

function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
  var indexSize = 1;
  var arrLength = arr.length;
  var valLength = val.length;

  if (encoding !== undefined) {
    encoding = String(encoding).toLowerCase();

    if (encoding === 'ucs2' || encoding === 'ucs-2' || encoding === 'utf16le' || encoding === 'utf-16le') {
      if (arr.length < 2 || val.length < 2) {
        return -1;
      }

      indexSize = 2;
      arrLength /= 2;
      valLength /= 2;
      byteOffset /= 2;
    }
  }

  function read(buf, i) {
    if (indexSize === 1) {
      return buf[i];
    } else {
      return buf.readUInt16BE(i * indexSize);
    }
  }

  var i;

  if (dir) {
    var foundIndex = -1;

    for (i = byteOffset; i < arrLength; i++) {
      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
        if (foundIndex === -1) foundIndex = i;
        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
      } else {
        if (foundIndex !== -1) i -= i - foundIndex;
        foundIndex = -1;
      }
    }
  } else {
    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;

    for (i = byteOffset; i >= 0; i--) {
      var found = true;

      for (var j = 0; j < valLength; j++) {
        if (read(arr, i + j) !== read(val, j)) {
          found = false;
          break;
        }
      }

      if (found) return i;
    }
  }

  return -1;
}

Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
  return this.indexOf(val, byteOffset, encoding) !== -1;
};

Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
};

Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
};

function hexWrite(buf, string, offset, length) {
  offset = Number(offset) || 0;
  var remaining = buf.length - offset;

  if (!length) {
    length = remaining;
  } else {
    length = Number(length);

    if (length > remaining) {
      length = remaining;
    }
  } // must be an even number of digits


  var strLen = string.length;
  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string');

  if (length > strLen / 2) {
    length = strLen / 2;
  }

  for (var i = 0; i < length; ++i) {
    var parsed = parseInt(string.substr(i * 2, 2), 16);
    if (isNaN(parsed)) return i;
    buf[offset + i] = parsed;
  }

  return i;
}

function utf8Write(buf, string, offset, length) {
  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
}

function asciiWrite(buf, string, offset, length) {
  return blitBuffer(asciiToBytes(string), buf, offset, length);
}

function latin1Write(buf, string, offset, length) {
  return asciiWrite(buf, string, offset, length);
}

function base64Write(buf, string, offset, length) {
  return blitBuffer(base64ToBytes(string), buf, offset, length);
}

function ucs2Write(buf, string, offset, length) {
  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
}

Buffer.prototype.write = function write(string, offset, length, encoding) {
  // Buffer#write(string)
  if (offset === undefined) {
    encoding = 'utf8';
    length = this.length;
    offset = 0; // Buffer#write(string, encoding)
  } else if (length === undefined && typeof offset === 'string') {
    encoding = offset;
    length = this.length;
    offset = 0; // Buffer#write(string, offset[, length][, encoding])
  } else if (isFinite(offset)) {
    offset = offset | 0;

    if (isFinite(length)) {
      length = length | 0;
      if (encoding === undefined) encoding = 'utf8';
    } else {
      encoding = length;
      length = undefined;
    } // legacy write(string, encoding, offset, length) - remove in v0.13

  } else {
    throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported');
  }

  var remaining = this.length - offset;
  if (length === undefined || length > remaining) length = remaining;

  if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
    throw new RangeError('Attempt to write outside buffer bounds');
  }

  if (!encoding) encoding = 'utf8';
  var loweredCase = false;

  for (;;) {
    switch (encoding) {
      case 'hex':
        return hexWrite(this, string, offset, length);

      case 'utf8':
      case 'utf-8':
        return utf8Write(this, string, offset, length);

      case 'ascii':
        return asciiWrite(this, string, offset, length);

      case 'latin1':
      case 'binary':
        return latin1Write(this, string, offset, length);

      case 'base64':
        // Warning: maxLength not taken into account in base64Write
        return base64Write(this, string, offset, length);

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return ucs2Write(this, string, offset, length);

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);
        encoding = ('' + encoding).toLowerCase();
        loweredCase = true;
    }
  }
};

Buffer.prototype.toJSON = function toJSON() {
  return {
    type: 'Buffer',
    data: Array.prototype.slice.call(this._arr || this, 0)
  };
};

function base64Slice(buf, start, end) {
  if (start === 0 && end === buf.length) {
    return base64.fromByteArray(buf);
  } else {
    return base64.fromByteArray(buf.slice(start, end));
  }
}

function utf8Slice(buf, start, end) {
  end = Math.min(buf.length, end);
  var res = [];
  var i = start;

  while (i < end) {
    var firstByte = buf[i];
    var codePoint = null;
    var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;

    if (i + bytesPerSequence <= end) {
      var secondByte, thirdByte, fourthByte, tempCodePoint;

      switch (bytesPerSequence) {
        case 1:
          if (firstByte < 0x80) {
            codePoint = firstByte;
          }

          break;

        case 2:
          secondByte = buf[i + 1];

          if ((secondByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;

            if (tempCodePoint > 0x7F) {
              codePoint = tempCodePoint;
            }
          }

          break;

        case 3:
          secondByte = buf[i + 1];
          thirdByte = buf[i + 2];

          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;

            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
              codePoint = tempCodePoint;
            }
          }

          break;

        case 4:
          secondByte = buf[i + 1];
          thirdByte = buf[i + 2];
          fourthByte = buf[i + 3];

          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | fourthByte & 0x3F;

            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
              codePoint = tempCodePoint;
            }
          }

      }
    }

    if (codePoint === null) {
      // we did not generate a valid codePoint so insert a
      // replacement char (U+FFFD) and advance only 1 byte
      codePoint = 0xFFFD;
      bytesPerSequence = 1;
    } else if (codePoint > 0xFFFF) {
      // encode to utf16 (surrogate pair dance)
      codePoint -= 0x10000;
      res.push(codePoint >>> 10 & 0x3FF | 0xD800);
      codePoint = 0xDC00 | codePoint & 0x3FF;
    }

    res.push(codePoint);
    i += bytesPerSequence;
  }

  return decodeCodePointsArray(res);
} // Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety


var MAX_ARGUMENTS_LENGTH = 0x1000;

function decodeCodePointsArray(codePoints) {
  var len = codePoints.length;

  if (len <= MAX_ARGUMENTS_LENGTH) {
    return String.fromCharCode.apply(String, codePoints); // avoid extra slice()
  } // Decode in chunks to avoid "call stack size exceeded".


  var res = '';
  var i = 0;

  while (i < len) {
    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
  }

  return res;
}

function asciiSlice(buf, start, end) {
  var ret = '';
  end = Math.min(buf.length, end);

  for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i] & 0x7F);
  }

  return ret;
}

function latin1Slice(buf, start, end) {
  var ret = '';
  end = Math.min(buf.length, end);

  for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i]);
  }

  return ret;
}

function hexSlice(buf, start, end) {
  var len = buf.length;
  if (!start || start < 0) start = 0;
  if (!end || end < 0 || end > len) end = len;
  var out = '';

  for (var i = start; i < end; ++i) {
    out += toHex(buf[i]);
  }

  return out;
}

function utf16leSlice(buf, start, end) {
  var bytes = buf.slice(start, end);
  var res = '';

  for (var i = 0; i < bytes.length; i += 2) {
    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
  }

  return res;
}

Buffer.prototype.slice = function slice(start, end) {
  var len = this.length;
  start = ~~start;
  end = end === undefined ? len : ~~end;

  if (start < 0) {
    start += len;
    if (start < 0) start = 0;
  } else if (start > len) {
    start = len;
  }

  if (end < 0) {
    end += len;
    if (end < 0) end = 0;
  } else if (end > len) {
    end = len;
  }

  if (end < start) end = start;
  var newBuf;

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    newBuf = this.subarray(start, end);
    newBuf.__proto__ = Buffer.prototype;
  } else {
    var sliceLen = end - start;
    newBuf = new Buffer(sliceLen, undefined);

    for (var i = 0; i < sliceLen; ++i) {
      newBuf[i] = this[i + start];
    }
  }

  return newBuf;
};
/*
 * Need to make sure that buffer isn't trying to write out of bounds.
 */


function checkOffset(offset, ext, length) {
  if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');
  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');
}

Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
  offset = offset | 0;
  byteLength = byteLength | 0;
  if (!noAssert) checkOffset(offset, byteLength, this.length);
  var val = this[offset];
  var mul = 1;
  var i = 0;

  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul;
  }

  return val;
};

Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
  offset = offset | 0;
  byteLength = byteLength | 0;

  if (!noAssert) {
    checkOffset(offset, byteLength, this.length);
  }

  var val = this[offset + --byteLength];
  var mul = 1;

  while (byteLength > 0 && (mul *= 0x100)) {
    val += this[offset + --byteLength] * mul;
  }

  return val;
};

Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 1, this.length);
  return this[offset];
};

Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length);
  return this[offset] | this[offset + 1] << 8;
};

Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length);
  return this[offset] << 8 | this[offset + 1];
};

Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length);
  return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;
};

Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length);
  return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
};

Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
  offset = offset | 0;
  byteLength = byteLength | 0;
  if (!noAssert) checkOffset(offset, byteLength, this.length);
  var val = this[offset];
  var mul = 1;
  var i = 0;

  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul;
  }

  mul *= 0x80;
  if (val >= mul) val -= Math.pow(2, 8 * byteLength);
  return val;
};

Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
  offset = offset | 0;
  byteLength = byteLength | 0;
  if (!noAssert) checkOffset(offset, byteLength, this.length);
  var i = byteLength;
  var mul = 1;
  var val = this[offset + --i];

  while (i > 0 && (mul *= 0x100)) {
    val += this[offset + --i] * mul;
  }

  mul *= 0x80;
  if (val >= mul) val -= Math.pow(2, 8 * byteLength);
  return val;
};

Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 1, this.length);
  if (!(this[offset] & 0x80)) return this[offset];
  return (0xff - this[offset] + 1) * -1;
};

Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length);
  var val = this[offset] | this[offset + 1] << 8;
  return val & 0x8000 ? val | 0xFFFF0000 : val;
};

Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length);
  var val = this[offset + 1] | this[offset] << 8;
  return val & 0x8000 ? val | 0xFFFF0000 : val;
};

Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length);
  return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
};

Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length);
  return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
};

Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length);
  return ieee754.read(this, offset, true, 23, 4);
};

Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length);
  return ieee754.read(this, offset, false, 23, 4);
};

Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 8, this.length);
  return ieee754.read(this, offset, true, 52, 8);
};

Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
  if (!noAssert) checkOffset(offset, 8, this.length);
  return ieee754.read(this, offset, false, 52, 8);
};

function checkInt(buf, value, offset, ext, max, min) {
  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
  if (offset + ext > buf.length) throw new RangeError('Index out of range');
}

Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
  value = +value;
  offset = offset | 0;
  byteLength = byteLength | 0;

  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1;
    checkInt(this, value, offset, byteLength, maxBytes, 0);
  }

  var mul = 1;
  var i = 0;
  this[offset] = value & 0xFF;

  while (++i < byteLength && (mul *= 0x100)) {
    this[offset + i] = value / mul & 0xFF;
  }

  return offset + byteLength;
};

Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
  value = +value;
  offset = offset | 0;
  byteLength = byteLength | 0;

  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1;
    checkInt(this, value, offset, byteLength, maxBytes, 0);
  }

  var i = byteLength - 1;
  var mul = 1;
  this[offset + i] = value & 0xFF;

  while (--i >= 0 && (mul *= 0x100)) {
    this[offset + i] = value / mul & 0xFF;
  }

  return offset + byteLength;
};

Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
  this[offset] = value & 0xff;
  return offset + 1;
};

function objectWriteUInt16(buf, value, offset, littleEndian) {
  if (value < 0) value = 0xffff + value + 1;

  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
    buf[offset + i] = (value & 0xff << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;
  }
}

Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = value & 0xff;
    this[offset + 1] = value >>> 8;
  } else {
    objectWriteUInt16(this, value, offset, true);
  }

  return offset + 2;
};

Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = value >>> 8;
    this[offset + 1] = value & 0xff;
  } else {
    objectWriteUInt16(this, value, offset, false);
  }

  return offset + 2;
};

function objectWriteUInt32(buf, value, offset, littleEndian) {
  if (value < 0) value = 0xffffffff + value + 1;

  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
    buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 0xff;
  }
}

Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset + 3] = value >>> 24;
    this[offset + 2] = value >>> 16;
    this[offset + 1] = value >>> 8;
    this[offset] = value & 0xff;
  } else {
    objectWriteUInt32(this, value, offset, true);
  }

  return offset + 4;
};

Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = value >>> 24;
    this[offset + 1] = value >>> 16;
    this[offset + 2] = value >>> 8;
    this[offset + 3] = value & 0xff;
  } else {
    objectWriteUInt32(this, value, offset, false);
  }

  return offset + 4;
};

Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
  value = +value;
  offset = offset | 0;

  if (!noAssert) {
    var limit = Math.pow(2, 8 * byteLength - 1);
    checkInt(this, value, offset, byteLength, limit - 1, -limit);
  }

  var i = 0;
  var mul = 1;
  var sub = 0;
  this[offset] = value & 0xFF;

  while (++i < byteLength && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
      sub = 1;
    }

    this[offset + i] = (value / mul >> 0) - sub & 0xFF;
  }

  return offset + byteLength;
};

Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
  value = +value;
  offset = offset | 0;

  if (!noAssert) {
    var limit = Math.pow(2, 8 * byteLength - 1);
    checkInt(this, value, offset, byteLength, limit - 1, -limit);
  }

  var i = byteLength - 1;
  var mul = 1;
  var sub = 0;
  this[offset + i] = value & 0xFF;

  while (--i >= 0 && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
      sub = 1;
    }

    this[offset + i] = (value / mul >> 0) - sub & 0xFF;
  }

  return offset + byteLength;
};

Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
  if (value < 0) value = 0xff + value + 1;
  this[offset] = value & 0xff;
  return offset + 1;
};

Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = value & 0xff;
    this[offset + 1] = value >>> 8;
  } else {
    objectWriteUInt16(this, value, offset, true);
  }

  return offset + 2;
};

Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = value >>> 8;
    this[offset + 1] = value & 0xff;
  } else {
    objectWriteUInt16(this, value, offset, false);
  }

  return offset + 2;
};

Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = value & 0xff;
    this[offset + 1] = value >>> 8;
    this[offset + 2] = value >>> 16;
    this[offset + 3] = value >>> 24;
  } else {
    objectWriteUInt32(this, value, offset, true);
  }

  return offset + 4;
};

Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
  value = +value;
  offset = offset | 0;
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
  if (value < 0) value = 0xffffffff + value + 1;

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = value >>> 24;
    this[offset + 1] = value >>> 16;
    this[offset + 2] = value >>> 8;
    this[offset + 3] = value & 0xff;
  } else {
    objectWriteUInt32(this, value, offset, false);
  }

  return offset + 4;
};

function checkIEEE754(buf, value, offset, ext, max, min) {
  if (offset + ext > buf.length) throw new RangeError('Index out of range');
  if (offset < 0) throw new RangeError('Index out of range');
}

function writeFloat(buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);
  }

  ieee754.write(buf, value, offset, littleEndian, 23, 4);
  return offset + 4;
}

Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
  return writeFloat(this, value, offset, true, noAssert);
};

Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
  return writeFloat(this, value, offset, false, noAssert);
};

function writeDouble(buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);
  }

  ieee754.write(buf, value, offset, littleEndian, 52, 8);
  return offset + 8;
}

Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
  return writeDouble(this, value, offset, true, noAssert);
};

Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
  return writeDouble(this, value, offset, false, noAssert);
}; // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)


Buffer.prototype.copy = function copy(target, targetStart, start, end) {
  if (!start) start = 0;
  if (!end && end !== 0) end = this.length;
  if (targetStart >= target.length) targetStart = target.length;
  if (!targetStart) targetStart = 0;
  if (end > 0 && end < start) end = start; // Copy 0 bytes; we're done

  if (end === start) return 0;
  if (target.length === 0 || this.length === 0) return 0; // Fatal error conditions

  if (targetStart < 0) {
    throw new RangeError('targetStart out of bounds');
  }

  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds');
  if (end < 0) throw new RangeError('sourceEnd out of bounds'); // Are we oob?

  if (end > this.length) end = this.length;

  if (target.length - targetStart < end - start) {
    end = target.length - targetStart + start;
  }

  var len = end - start;
  var i;

  if (this === target && start < targetStart && targetStart < end) {
    // descending copy from end
    for (i = len - 1; i >= 0; --i) {
      target[i + targetStart] = this[i + start];
    }
  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
    // ascending copy from start
    for (i = 0; i < len; ++i) {
      target[i + targetStart] = this[i + start];
    }
  } else {
    Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);
  }

  return len;
}; // Usage:
//    buffer.fill(number[, offset[, end]])
//    buffer.fill(buffer[, offset[, end]])
//    buffer.fill(string[, offset[, end]][, encoding])


Buffer.prototype.fill = function fill(val, start, end, encoding) {
  // Handle string cases:
  if (typeof val === 'string') {
    if (typeof start === 'string') {
      encoding = start;
      start = 0;
      end = this.length;
    } else if (typeof end === 'string') {
      encoding = end;
      end = this.length;
    }

    if (val.length === 1) {
      var code = val.charCodeAt(0);

      if (code < 256) {
        val = code;
      }
    }

    if (encoding !== undefined && typeof encoding !== 'string') {
      throw new TypeError('encoding must be a string');
    }

    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
      throw new TypeError('Unknown encoding: ' + encoding);
    }
  } else if (typeof val === 'number') {
    val = val & 255;
  } // Invalid ranges are not set to a default, so can range check early.


  if (start < 0 || this.length < start || this.length < end) {
    throw new RangeError('Out of range index');
  }

  if (end <= start) {
    return this;
  }

  start = start >>> 0;
  end = end === undefined ? this.length : end >>> 0;
  if (!val) val = 0;
  var i;

  if (typeof val === 'number') {
    for (i = start; i < end; ++i) {
      this[i] = val;
    }
  } else {
    var bytes = Buffer.isBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString());
    var len = bytes.length;

    for (i = 0; i < end - start; ++i) {
      this[i + start] = bytes[i % len];
    }
  }

  return this;
}; // HELPER FUNCTIONS
// ================


var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;

function base64clean(str) {
  // Node strips out invalid characters like \n and \t from the string, base64-js does not
  str = stringtrim(str).replace(INVALID_BASE64_RE, ''); // Node converts strings with length < 2 to ''

  if (str.length < 2) return ''; // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not

  while (str.length % 4 !== 0) {
    str = str + '=';
  }

  return str;
}

function stringtrim(str) {
  if (str.trim) return str.trim();
  return str.replace(/^\s+|\s+$/g, '');
}

function toHex(n) {
  if (n < 16) return '0' + n.toString(16);
  return n.toString(16);
}

function utf8ToBytes(string, units) {
  units = units || Infinity;
  var codePoint;
  var length = string.length;
  var leadSurrogate = null;
  var bytes = [];

  for (var i = 0; i < length; ++i) {
    codePoint = string.charCodeAt(i); // is surrogate component

    if (codePoint > 0xD7FF && codePoint < 0xE000) {
      // last char was a lead
      if (!leadSurrogate) {
        // no lead yet
        if (codePoint > 0xDBFF) {
          // unexpected trail
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
          continue;
        } else if (i + 1 === length) {
          // unpaired lead
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
          continue;
        } // valid lead


        leadSurrogate = codePoint;
        continue;
      } // 2 leads in a row


      if (codePoint < 0xDC00) {
        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
        leadSurrogate = codePoint;
        continue;
      } // valid surrogate pair


      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
    } else if (leadSurrogate) {
      // valid bmp char, but last char was a lead
      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
    }

    leadSurrogate = null; // encode utf8

    if (codePoint < 0x80) {
      if ((units -= 1) < 0) break;
      bytes.push(codePoint);
    } else if (codePoint < 0x800) {
      if ((units -= 2) < 0) break;
      bytes.push(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);
    } else if (codePoint < 0x10000) {
      if ((units -= 3) < 0) break;
      bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);
    } else if (codePoint < 0x110000) {
      if ((units -= 4) < 0) break;
      bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);
    } else {
      throw new Error('Invalid code point');
    }
  }

  return bytes;
}

function asciiToBytes(str) {
  var byteArray = [];

  for (var i = 0; i < str.length; ++i) {
    // Node's code seems to be doing this and not & 0x7F..
    byteArray.push(str.charCodeAt(i) & 0xFF);
  }

  return byteArray;
}

function utf16leToBytes(str, units) {
  var c, hi, lo;
  var byteArray = [];

  for (var i = 0; i < str.length; ++i) {
    if ((units -= 2) < 0) break;
    c = str.charCodeAt(i);
    hi = c >> 8;
    lo = c % 256;
    byteArray.push(lo);
    byteArray.push(hi);
  }

  return byteArray;
}

function base64ToBytes(str) {
  return base64.toByteArray(base64clean(str));
}

function blitBuffer(src, dst, offset, length) {
  for (var i = 0; i < length; ++i) {
    if (i + offset >= dst.length || i >= src.length) break;
    dst[i + offset] = src[i];
  }

  return i;
}

function isnan(val) {
  return val !== val; // eslint-disable-line no-self-compare
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(59)))

/***/ }),
/* 59 */
/***/ (function(module, exports) {

var g; // This works in non-strict mode

g = function () {
  return this;
}();

try {
  // This works if eval is allowed (see CSP)
  g = g || new Function("return this")();
} catch (e) {
  // This works if the window reference is available
  if (typeof window === "object") g = window;
} // g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}


module.exports = g;

/***/ }),
/* 60 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


const typeOf = __webpack_require__(30);

const getEngine = __webpack_require__(61);

const defaults = __webpack_require__(31);

module.exports = function (file, data, options) {
  if (data == null && options == null) {
    switch (typeOf(file)) {
      case 'object':
        data = file.data;
        options = {};
        break;

      case 'string':
        return file;

      default:
        {
          throw new TypeError('expected file to be a string or object');
        }
    }
  }

  const str = file.content;
  const opts = defaults(options);

  if (data == null) {
    if (!opts.data) return file;
    data = opts.data;
  }

  const language = file.language || opts.language;
  const engine = getEngine(language, opts);

  if (typeof engine.stringify !== 'function') {
    throw new TypeError('expected "' + language + '.stringify" to be a function');
  }

  data = Object.assign({}, file.data, data);
  const open = opts.delimiters[0];
  const close = opts.delimiters[1];
  const matter = engine.stringify(data, options).trim();
  let buf = '';

  if (matter !== '{}') {
    buf = newline(open) + newline(matter) + newline(close);
  }

  if (typeof file.excerpt === 'string' && file.excerpt !== '') {
    if (str.indexOf(file.excerpt.trim()) === -1) {
      buf += newline(file.excerpt) + newline(close);
    }
  }

  return buf + newline(str);
};

function newline(str) {
  return str.slice(-1) !== '\n' ? str + '\n' : str;
}

/***/ }),
/* 61 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = function (name, options) {
  let engine = options.engines[name] || options.engines[aliase(name)];

  if (typeof engine === 'undefined') {
    throw new Error('gray-matter engine "' + name + '" is not registered');
  }

  if (typeof engine === 'function') {
    engine = {
      parse: engine
    };
  }

  return engine;
};

function aliase(name) {
  switch (name.toLowerCase()) {
    case 'js':
    case 'javascript':
      return 'javascript';

    case 'coffee':
    case 'coffeescript':
    case 'cson':
      return 'coffee';

    case 'yaml':
    case 'yml':
      return 'yaml';

    default:
      {
        return name;
      }
  }
}

/***/ }),
/* 62 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// HTML5 entities map: { name -> utf16string }
//

/*eslint quotes:0*/

module.exports = {
  Aacute: "\u00C1",
  aacute: "\u00E1",
  Abreve: "\u0102",
  abreve: "\u0103",
  ac: "\u223E",
  acd: "\u223F",
  acE: "\u223E\u0333",
  Acirc: "\u00C2",
  acirc: "\u00E2",
  acute: "\u00B4",
  Acy: "\u0410",
  acy: "\u0430",
  AElig: "\u00C6",
  aelig: "\u00E6",
  af: "\u2061",
  Afr: "\uD835\uDD04",
  afr: "\uD835\uDD1E",
  Agrave: "\u00C0",
  agrave: "\u00E0",
  alefsym: "\u2135",
  aleph: "\u2135",
  Alpha: "\u0391",
  alpha: "\u03B1",
  Amacr: "\u0100",
  amacr: "\u0101",
  amalg: "\u2A3F",
  amp: "&",
  AMP: "&",
  andand: "\u2A55",
  And: "\u2A53",
  and: "\u2227",
  andd: "\u2A5C",
  andslope: "\u2A58",
  andv: "\u2A5A",
  ang: "\u2220",
  ange: "\u29A4",
  angle: "\u2220",
  angmsdaa: "\u29A8",
  angmsdab: "\u29A9",
  angmsdac: "\u29AA",
  angmsdad: "\u29AB",
  angmsdae: "\u29AC",
  angmsdaf: "\u29AD",
  angmsdag: "\u29AE",
  angmsdah: "\u29AF",
  angmsd: "\u2221",
  angrt: "\u221F",
  angrtvb: "\u22BE",
  angrtvbd: "\u299D",
  angsph: "\u2222",
  angst: "\u00C5",
  angzarr: "\u237C",
  Aogon: "\u0104",
  aogon: "\u0105",
  Aopf: "\uD835\uDD38",
  aopf: "\uD835\uDD52",
  apacir: "\u2A6F",
  ap: "\u2248",
  apE: "\u2A70",
  ape: "\u224A",
  apid: "\u224B",
  apos: "'",
  ApplyFunction: "\u2061",
  approx: "\u2248",
  approxeq: "\u224A",
  Aring: "\u00C5",
  aring: "\u00E5",
  Ascr: "\uD835\uDC9C",
  ascr: "\uD835\uDCB6",
  Assign: "\u2254",
  ast: "*",
  asymp: "\u2248",
  asympeq: "\u224D",
  Atilde: "\u00C3",
  atilde: "\u00E3",
  Auml: "\u00C4",
  auml: "\u00E4",
  awconint: "\u2233",
  awint: "\u2A11",
  backcong: "\u224C",
  backepsilon: "\u03F6",
  backprime: "\u2035",
  backsim: "\u223D",
  backsimeq: "\u22CD",
  Backslash: "\u2216",
  Barv: "\u2AE7",
  barvee: "\u22BD",
  barwed: "\u2305",
  Barwed: "\u2306",
  barwedge: "\u2305",
  bbrk: "\u23B5",
  bbrktbrk: "\u23B6",
  bcong: "\u224C",
  Bcy: "\u0411",
  bcy: "\u0431",
  bdquo: "\u201E",
  becaus: "\u2235",
  because: "\u2235",
  Because: "\u2235",
  bemptyv: "\u29B0",
  bepsi: "\u03F6",
  bernou: "\u212C",
  Bernoullis: "\u212C",
  Beta: "\u0392",
  beta: "\u03B2",
  beth: "\u2136",
  between: "\u226C",
  Bfr: "\uD835\uDD05",
  bfr: "\uD835\uDD1F",
  bigcap: "\u22C2",
  bigcirc: "\u25EF",
  bigcup: "\u22C3",
  bigodot: "\u2A00",
  bigoplus: "\u2A01",
  bigotimes: "\u2A02",
  bigsqcup: "\u2A06",
  bigstar: "\u2605",
  bigtriangledown: "\u25BD",
  bigtriangleup: "\u25B3",
  biguplus: "\u2A04",
  bigvee: "\u22C1",
  bigwedge: "\u22C0",
  bkarow: "\u290D",
  blacklozenge: "\u29EB",
  blacksquare: "\u25AA",
  blacktriangle: "\u25B4",
  blacktriangledown: "\u25BE",
  blacktriangleleft: "\u25C2",
  blacktriangleright: "\u25B8",
  blank: "\u2423",
  blk12: "\u2592",
  blk14: "\u2591",
  blk34: "\u2593",
  block: "\u2588",
  bne: "=\u20E5",
  bnequiv: "\u2261\u20E5",
  bNot: "\u2AED",
  bnot: "\u2310",
  Bopf: "\uD835\uDD39",
  bopf: "\uD835\uDD53",
  bot: "\u22A5",
  bottom: "\u22A5",
  bowtie: "\u22C8",
  boxbox: "\u29C9",
  boxdl: "\u2510",
  boxdL: "\u2555",
  boxDl: "\u2556",
  boxDL: "\u2557",
  boxdr: "\u250C",
  boxdR: "\u2552",
  boxDr: "\u2553",
  boxDR: "\u2554",
  boxh: "\u2500",
  boxH: "\u2550",
  boxhd: "\u252C",
  boxHd: "\u2564",
  boxhD: "\u2565",
  boxHD: "\u2566",
  boxhu: "\u2534",
  boxHu: "\u2567",
  boxhU: "\u2568",
  boxHU: "\u2569",
  boxminus: "\u229F",
  boxplus: "\u229E",
  boxtimes: "\u22A0",
  boxul: "\u2518",
  boxuL: "\u255B",
  boxUl: "\u255C",
  boxUL: "\u255D",
  boxur: "\u2514",
  boxuR: "\u2558",
  boxUr: "\u2559",
  boxUR: "\u255A",
  boxv: "\u2502",
  boxV: "\u2551",
  boxvh: "\u253C",
  boxvH: "\u256A",
  boxVh: "\u256B",
  boxVH: "\u256C",
  boxvl: "\u2524",
  boxvL: "\u2561",
  boxVl: "\u2562",
  boxVL: "\u2563",
  boxvr: "\u251C",
  boxvR: "\u255E",
  boxVr: "\u255F",
  boxVR: "\u2560",
  bprime: "\u2035",
  breve: "\u02D8",
  Breve: "\u02D8",
  brvbar: "\u00A6",
  bscr: "\uD835\uDCB7",
  Bscr: "\u212C",
  bsemi: "\u204F",
  bsim: "\u223D",
  bsime: "\u22CD",
  bsolb: "\u29C5",
  bsol: "\\",
  bsolhsub: "\u27C8",
  bull: "\u2022",
  bullet: "\u2022",
  bump: "\u224E",
  bumpE: "\u2AAE",
  bumpe: "\u224F",
  Bumpeq: "\u224E",
  bumpeq: "\u224F",
  Cacute: "\u0106",
  cacute: "\u0107",
  capand: "\u2A44",
  capbrcup: "\u2A49",
  capcap: "\u2A4B",
  cap: "\u2229",
  Cap: "\u22D2",
  capcup: "\u2A47",
  capdot: "\u2A40",
  CapitalDifferentialD: "\u2145",
  caps: "\u2229\uFE00",
  caret: "\u2041",
  caron: "\u02C7",
  Cayleys: "\u212D",
  ccaps: "\u2A4D",
  Ccaron: "\u010C",
  ccaron: "\u010D",
  Ccedil: "\u00C7",
  ccedil: "\u00E7",
  Ccirc: "\u0108",
  ccirc: "\u0109",
  Cconint: "\u2230",
  ccups: "\u2A4C",
  ccupssm: "\u2A50",
  Cdot: "\u010A",
  cdot: "\u010B",
  cedil: "\u00B8",
  Cedilla: "\u00B8",
  cemptyv: "\u29B2",
  cent: "\u00A2",
  centerdot: "\u00B7",
  CenterDot: "\u00B7",
  cfr: "\uD835\uDD20",
  Cfr: "\u212D",
  CHcy: "\u0427",
  chcy: "\u0447",
  check: "\u2713",
  checkmark: "\u2713",
  Chi: "\u03A7",
  chi: "\u03C7",
  circ: "\u02C6",
  circeq: "\u2257",
  circlearrowleft: "\u21BA",
  circlearrowright: "\u21BB",
  circledast: "\u229B",
  circledcirc: "\u229A",
  circleddash: "\u229D",
  CircleDot: "\u2299",
  circledR: "\u00AE",
  circledS: "\u24C8",
  CircleMinus: "\u2296",
  CirclePlus: "\u2295",
  CircleTimes: "\u2297",
  cir: "\u25CB",
  cirE: "\u29C3",
  cire: "\u2257",
  cirfnint: "\u2A10",
  cirmid: "\u2AEF",
  cirscir: "\u29C2",
  ClockwiseContourIntegral: "\u2232",
  CloseCurlyDoubleQuote: "\u201D",
  CloseCurlyQuote: "\u2019",
  clubs: "\u2663",
  clubsuit: "\u2663",
  colon: ":",
  Colon: "\u2237",
  Colone: "\u2A74",
  colone: "\u2254",
  coloneq: "\u2254",
  comma: ",",
  commat: "@",
  comp: "\u2201",
  compfn: "\u2218",
  complement: "\u2201",
  complexes: "\u2102",
  cong: "\u2245",
  congdot: "\u2A6D",
  Congruent: "\u2261",
  conint: "\u222E",
  Conint: "\u222F",
  ContourIntegral: "\u222E",
  copf: "\uD835\uDD54",
  Copf: "\u2102",
  coprod: "\u2210",
  Coproduct: "\u2210",
  copy: "\u00A9",
  COPY: "\u00A9",
  copysr: "\u2117",
  CounterClockwiseContourIntegral: "\u2233",
  crarr: "\u21B5",
  cross: "\u2717",
  Cross: "\u2A2F",
  Cscr: "\uD835\uDC9E",
  cscr: "\uD835\uDCB8",
  csub: "\u2ACF",
  csube: "\u2AD1",
  csup: "\u2AD0",
  csupe: "\u2AD2",
  ctdot: "\u22EF",
  cudarrl: "\u2938",
  cudarrr: "\u2935",
  cuepr: "\u22DE",
  cuesc: "\u22DF",
  cularr: "\u21B6",
  cularrp: "\u293D",
  cupbrcap: "\u2A48",
  cupcap: "\u2A46",
  CupCap: "\u224D",
  cup: "\u222A",
  Cup: "\u22D3",
  cupcup: "\u2A4A",
  cupdot: "\u228D",
  cupor: "\u2A45",
  cups: "\u222A\uFE00",
  curarr: "\u21B7",
  curarrm: "\u293C",
  curlyeqprec: "\u22DE",
  curlyeqsucc: "\u22DF",
  curlyvee: "\u22CE",
  curlywedge: "\u22CF",
  curren: "\u00A4",
  curvearrowleft: "\u21B6",
  curvearrowright: "\u21B7",
  cuvee: "\u22CE",
  cuwed: "\u22CF",
  cwconint: "\u2232",
  cwint: "\u2231",
  cylcty: "\u232D",
  dagger: "\u2020",
  Dagger: "\u2021",
  daleth: "\u2138",
  darr: "\u2193",
  Darr: "\u21A1",
  dArr: "\u21D3",
  dash: "\u2010",
  Dashv: "\u2AE4",
  dashv: "\u22A3",
  dbkarow: "\u290F",
  dblac: "\u02DD",
  Dcaron: "\u010E",
  dcaron: "\u010F",
  Dcy: "\u0414",
  dcy: "\u0434",
  ddagger: "\u2021",
  ddarr: "\u21CA",
  DD: "\u2145",
  dd: "\u2146",
  DDotrahd: "\u2911",
  ddotseq: "\u2A77",
  deg: "\u00B0",
  Del: "\u2207",
  Delta: "\u0394",
  delta: "\u03B4",
  demptyv: "\u29B1",
  dfisht: "\u297F",
  Dfr: "\uD835\uDD07",
  dfr: "\uD835\uDD21",
  dHar: "\u2965",
  dharl: "\u21C3",
  dharr: "\u21C2",
  DiacriticalAcute: "\u00B4",
  DiacriticalDot: "\u02D9",
  DiacriticalDoubleAcute: "\u02DD",
  DiacriticalGrave: "`",
  DiacriticalTilde: "\u02DC",
  diam: "\u22C4",
  diamond: "\u22C4",
  Diamond: "\u22C4",
  diamondsuit: "\u2666",
  diams: "\u2666",
  die: "\u00A8",
  DifferentialD: "\u2146",
  digamma: "\u03DD",
  disin: "\u22F2",
  div: "\u00F7",
  divide: "\u00F7",
  divideontimes: "\u22C7",
  divonx: "\u22C7",
  DJcy: "\u0402",
  djcy: "\u0452",
  dlcorn: "\u231E",
  dlcrop: "\u230D",
  dollar: "$",
  Dopf: "\uD835\uDD3B",
  dopf: "\uD835\uDD55",
  Dot: "\u00A8",
  dot: "\u02D9",
  DotDot: "\u20DC",
  doteq: "\u2250",
  doteqdot: "\u2251",
  DotEqual: "\u2250",
  dotminus: "\u2238",
  dotplus: "\u2214",
  dotsquare: "\u22A1",
  doublebarwedge: "\u2306",
  DoubleContourIntegral: "\u222F",
  DoubleDot: "\u00A8",
  DoubleDownArrow: "\u21D3",
  DoubleLeftArrow: "\u21D0",
  DoubleLeftRightArrow: "\u21D4",
  DoubleLeftTee: "\u2AE4",
  DoubleLongLeftArrow: "\u27F8",
  DoubleLongLeftRightArrow: "\u27FA",
  DoubleLongRightArrow: "\u27F9",
  DoubleRightArrow: "\u21D2",
  DoubleRightTee: "\u22A8",
  DoubleUpArrow: "\u21D1",
  DoubleUpDownArrow: "\u21D5",
  DoubleVerticalBar: "\u2225",
  DownArrowBar: "\u2913",
  downarrow: "\u2193",
  DownArrow: "\u2193",
  Downarrow: "\u21D3",
  DownArrowUpArrow: "\u21F5",
  DownBreve: "\u0311",
  downdownarrows: "\u21CA",
  downharpoonleft: "\u21C3",
  downharpoonright: "\u21C2",
  DownLeftRightVector: "\u2950",
  DownLeftTeeVector: "\u295E",
  DownLeftVectorBar: "\u2956",
  DownLeftVector: "\u21BD",
  DownRightTeeVector: "\u295F",
  DownRightVectorBar: "\u2957",
  DownRightVector: "\u21C1",
  DownTeeArrow: "\u21A7",
  DownTee: "\u22A4",
  drbkarow: "\u2910",
  drcorn: "\u231F",
  drcrop: "\u230C",
  Dscr: "\uD835\uDC9F",
  dscr: "\uD835\uDCB9",
  DScy: "\u0405",
  dscy: "\u0455",
  dsol: "\u29F6",
  Dstrok: "\u0110",
  dstrok: "\u0111",
  dtdot: "\u22F1",
  dtri: "\u25BF",
  dtrif: "\u25BE",
  duarr: "\u21F5",
  duhar: "\u296F",
  dwangle: "\u29A6",
  DZcy: "\u040F",
  dzcy: "\u045F",
  dzigrarr: "\u27FF",
  Eacute: "\u00C9",
  eacute: "\u00E9",
  easter: "\u2A6E",
  Ecaron: "\u011A",
  ecaron: "\u011B",
  Ecirc: "\u00CA",
  ecirc: "\u00EA",
  ecir: "\u2256",
  ecolon: "\u2255",
  Ecy: "\u042D",
  ecy: "\u044D",
  eDDot: "\u2A77",
  Edot: "\u0116",
  edot: "\u0117",
  eDot: "\u2251",
  ee: "\u2147",
  efDot: "\u2252",
  Efr: "\uD835\uDD08",
  efr: "\uD835\uDD22",
  eg: "\u2A9A",
  Egrave: "\u00C8",
  egrave: "\u00E8",
  egs: "\u2A96",
  egsdot: "\u2A98",
  el: "\u2A99",
  Element: "\u2208",
  elinters: "\u23E7",
  ell: "\u2113",
  els: "\u2A95",
  elsdot: "\u2A97",
  Emacr: "\u0112",
  emacr: "\u0113",
  empty: "\u2205",
  emptyset: "\u2205",
  EmptySmallSquare: "\u25FB",
  emptyv: "\u2205",
  EmptyVerySmallSquare: "\u25AB",
  emsp13: "\u2004",
  emsp14: "\u2005",
  emsp: "\u2003",
  ENG: "\u014A",
  eng: "\u014B",
  ensp: "\u2002",
  Eogon: "\u0118",
  eogon: "\u0119",
  Eopf: "\uD835\uDD3C",
  eopf: "\uD835\uDD56",
  epar: "\u22D5",
  eparsl: "\u29E3",
  eplus: "\u2A71",
  epsi: "\u03B5",
  Epsilon: "\u0395",
  epsilon: "\u03B5",
  epsiv: "\u03F5",
  eqcirc: "\u2256",
  eqcolon: "\u2255",
  eqsim: "\u2242",
  eqslantgtr: "\u2A96",
  eqslantless: "\u2A95",
  Equal: "\u2A75",
  equals: "=",
  EqualTilde: "\u2242",
  equest: "\u225F",
  Equilibrium: "\u21CC",
  equiv: "\u2261",
  equivDD: "\u2A78",
  eqvparsl: "\u29E5",
  erarr: "\u2971",
  erDot: "\u2253",
  escr: "\u212F",
  Escr: "\u2130",
  esdot: "\u2250",
  Esim: "\u2A73",
  esim: "\u2242",
  Eta: "\u0397",
  eta: "\u03B7",
  ETH: "\u00D0",
  eth: "\u00F0",
  Euml: "\u00CB",
  euml: "\u00EB",
  euro: "\u20AC",
  excl: "!",
  exist: "\u2203",
  Exists: "\u2203",
  expectation: "\u2130",
  exponentiale: "\u2147",
  ExponentialE: "\u2147",
  fallingdotseq: "\u2252",
  Fcy: "\u0424",
  fcy: "\u0444",
  female: "\u2640",
  ffilig: "\uFB03",
  fflig: "\uFB00",
  ffllig: "\uFB04",
  Ffr: "\uD835\uDD09",
  ffr: "\uD835\uDD23",
  filig: "\uFB01",
  FilledSmallSquare: "\u25FC",
  FilledVerySmallSquare: "\u25AA",
  fjlig: "fj",
  flat: "\u266D",
  fllig: "\uFB02",
  fltns: "\u25B1",
  fnof: "\u0192",
  Fopf: "\uD835\uDD3D",
  fopf: "\uD835\uDD57",
  forall: "\u2200",
  ForAll: "\u2200",
  fork: "\u22D4",
  forkv: "\u2AD9",
  Fouriertrf: "\u2131",
  fpartint: "\u2A0D",
  frac12: "\u00BD",
  frac13: "\u2153",
  frac14: "\u00BC",
  frac15: "\u2155",
  frac16: "\u2159",
  frac18: "\u215B",
  frac23: "\u2154",
  frac25: "\u2156",
  frac34: "\u00BE",
  frac35: "\u2157",
  frac38: "\u215C",
  frac45: "\u2158",
  frac56: "\u215A",
  frac58: "\u215D",
  frac78: "\u215E",
  frasl: "\u2044",
  frown: "\u2322",
  fscr: "\uD835\uDCBB",
  Fscr: "\u2131",
  gacute: "\u01F5",
  Gamma: "\u0393",
  gamma: "\u03B3",
  Gammad: "\u03DC",
  gammad: "\u03DD",
  gap: "\u2A86",
  Gbreve: "\u011E",
  gbreve: "\u011F",
  Gcedil: "\u0122",
  Gcirc: "\u011C",
  gcirc: "\u011D",
  Gcy: "\u0413",
  gcy: "\u0433",
  Gdot: "\u0120",
  gdot: "\u0121",
  ge: "\u2265",
  gE: "\u2267",
  gEl: "\u2A8C",
  gel: "\u22DB",
  geq: "\u2265",
  geqq: "\u2267",
  geqslant: "\u2A7E",
  gescc: "\u2AA9",
  ges: "\u2A7E",
  gesdot: "\u2A80",
  gesdoto: "\u2A82",
  gesdotol: "\u2A84",
  gesl: "\u22DB\uFE00",
  gesles: "\u2A94",
  Gfr: "\uD835\uDD0A",
  gfr: "\uD835\uDD24",
  gg: "\u226B",
  Gg: "\u22D9",
  ggg: "\u22D9",
  gimel: "\u2137",
  GJcy: "\u0403",
  gjcy: "\u0453",
  gla: "\u2AA5",
  gl: "\u2277",
  glE: "\u2A92",
  glj: "\u2AA4",
  gnap: "\u2A8A",
  gnapprox: "\u2A8A",
  gne: "\u2A88",
  gnE: "\u2269",
  gneq: "\u2A88",
  gneqq: "\u2269",
  gnsim: "\u22E7",
  Gopf: "\uD835\uDD3E",
  gopf: "\uD835\uDD58",
  grave: "`",
  GreaterEqual: "\u2265",
  GreaterEqualLess: "\u22DB",
  GreaterFullEqual: "\u2267",
  GreaterGreater: "\u2AA2",
  GreaterLess: "\u2277",
  GreaterSlantEqual: "\u2A7E",
  GreaterTilde: "\u2273",
  Gscr: "\uD835\uDCA2",
  gscr: "\u210A",
  gsim: "\u2273",
  gsime: "\u2A8E",
  gsiml: "\u2A90",
  gtcc: "\u2AA7",
  gtcir: "\u2A7A",
  gt: ">",
  GT: ">",
  Gt: "\u226B",
  gtdot: "\u22D7",
  gtlPar: "\u2995",
  gtquest: "\u2A7C",
  gtrapprox: "\u2A86",
  gtrarr: "\u2978",
  gtrdot: "\u22D7",
  gtreqless: "\u22DB",
  gtreqqless: "\u2A8C",
  gtrless: "\u2277",
  gtrsim: "\u2273",
  gvertneqq: "\u2269\uFE00",
  gvnE: "\u2269\uFE00",
  Hacek: "\u02C7",
  hairsp: "\u200A",
  half: "\u00BD",
  hamilt: "\u210B",
  HARDcy: "\u042A",
  hardcy: "\u044A",
  harrcir: "\u2948",
  harr: "\u2194",
  hArr: "\u21D4",
  harrw: "\u21AD",
  Hat: "^",
  hbar: "\u210F",
  Hcirc: "\u0124",
  hcirc: "\u0125",
  hearts: "\u2665",
  heartsuit: "\u2665",
  hellip: "\u2026",
  hercon: "\u22B9",
  hfr: "\uD835\uDD25",
  Hfr: "\u210C",
  HilbertSpace: "\u210B",
  hksearow: "\u2925",
  hkswarow: "\u2926",
  hoarr: "\u21FF",
  homtht: "\u223B",
  hookleftarrow: "\u21A9",
  hookrightarrow: "\u21AA",
  hopf: "\uD835\uDD59",
  Hopf: "\u210D",
  horbar: "\u2015",
  HorizontalLine: "\u2500",
  hscr: "\uD835\uDCBD",
  Hscr: "\u210B",
  hslash: "\u210F",
  Hstrok: "\u0126",
  hstrok: "\u0127",
  HumpDownHump: "\u224E",
  HumpEqual: "\u224F",
  hybull: "\u2043",
  hyphen: "\u2010",
  Iacute: "\u00CD",
  iacute: "\u00ED",
  ic: "\u2063",
  Icirc: "\u00CE",
  icirc: "\u00EE",
  Icy: "\u0418",
  icy: "\u0438",
  Idot: "\u0130",
  IEcy: "\u0415",
  iecy: "\u0435",
  iexcl: "\u00A1",
  iff: "\u21D4",
  ifr: "\uD835\uDD26",
  Ifr: "\u2111",
  Igrave: "\u00CC",
  igrave: "\u00EC",
  ii: "\u2148",
  iiiint: "\u2A0C",
  iiint: "\u222D",
  iinfin: "\u29DC",
  iiota: "\u2129",
  IJlig: "\u0132",
  ijlig: "\u0133",
  Imacr: "\u012A",
  imacr: "\u012B",
  image: "\u2111",
  ImaginaryI: "\u2148",
  imagline: "\u2110",
  imagpart: "\u2111",
  imath: "\u0131",
  Im: "\u2111",
  imof: "\u22B7",
  imped: "\u01B5",
  Implies: "\u21D2",
  incare: "\u2105",
  "in": "\u2208",
  infin: "\u221E",
  infintie: "\u29DD",
  inodot: "\u0131",
  intcal: "\u22BA",
  "int": "\u222B",
  Int: "\u222C",
  integers: "\u2124",
  Integral: "\u222B",
  intercal: "\u22BA",
  Intersection: "\u22C2",
  intlarhk: "\u2A17",
  intprod: "\u2A3C",
  InvisibleComma: "\u2063",
  InvisibleTimes: "\u2062",
  IOcy: "\u0401",
  iocy: "\u0451",
  Iogon: "\u012E",
  iogon: "\u012F",
  Iopf: "\uD835\uDD40",
  iopf: "\uD835\uDD5A",
  Iota: "\u0399",
  iota: "\u03B9",
  iprod: "\u2A3C",
  iquest: "\u00BF",
  iscr: "\uD835\uDCBE",
  Iscr: "\u2110",
  isin: "\u2208",
  isindot: "\u22F5",
  isinE: "\u22F9",
  isins: "\u22F4",
  isinsv: "\u22F3",
  isinv: "\u2208",
  it: "\u2062",
  Itilde: "\u0128",
  itilde: "\u0129",
  Iukcy: "\u0406",
  iukcy: "\u0456",
  Iuml: "\u00CF",
  iuml: "\u00EF",
  Jcirc: "\u0134",
  jcirc: "\u0135",
  Jcy: "\u0419",
  jcy: "\u0439",
  Jfr: "\uD835\uDD0D",
  jfr: "\uD835\uDD27",
  jmath: "\u0237",
  Jopf: "\uD835\uDD41",
  jopf: "\uD835\uDD5B",
  Jscr: "\uD835\uDCA5",
  jscr: "\uD835\uDCBF",
  Jsercy: "\u0408",
  jsercy: "\u0458",
  Jukcy: "\u0404",
  jukcy: "\u0454",
  Kappa: "\u039A",
  kappa: "\u03BA",
  kappav: "\u03F0",
  Kcedil: "\u0136",
  kcedil: "\u0137",
  Kcy: "\u041A",
  kcy: "\u043A",
  Kfr: "\uD835\uDD0E",
  kfr: "\uD835\uDD28",
  kgreen: "\u0138",
  KHcy: "\u0425",
  khcy: "\u0445",
  KJcy: "\u040C",
  kjcy: "\u045C",
  Kopf: "\uD835\uDD42",
  kopf: "\uD835\uDD5C",
  Kscr: "\uD835\uDCA6",
  kscr: "\uD835\uDCC0",
  lAarr: "\u21DA",
  Lacute: "\u0139",
  lacute: "\u013A",
  laemptyv: "\u29B4",
  lagran: "\u2112",
  Lambda: "\u039B",
  lambda: "\u03BB",
  lang: "\u27E8",
  Lang: "\u27EA",
  langd: "\u2991",
  langle: "\u27E8",
  lap: "\u2A85",
  Laplacetrf: "\u2112",
  laquo: "\u00AB",
  larrb: "\u21E4",
  larrbfs: "\u291F",
  larr: "\u2190",
  Larr: "\u219E",
  lArr: "\u21D0",
  larrfs: "\u291D",
  larrhk: "\u21A9",
  larrlp: "\u21AB",
  larrpl: "\u2939",
  larrsim: "\u2973",
  larrtl: "\u21A2",
  latail: "\u2919",
  lAtail: "\u291B",
  lat: "\u2AAB",
  late: "\u2AAD",
  lates: "\u2AAD\uFE00",
  lbarr: "\u290C",
  lBarr: "\u290E",
  lbbrk: "\u2772",
  lbrace: "{",
  lbrack: "[",
  lbrke: "\u298B",
  lbrksld: "\u298F",
  lbrkslu: "\u298D",
  Lcaron: "\u013D",
  lcaron: "\u013E",
  Lcedil: "\u013B",
  lcedil: "\u013C",
  lceil: "\u2308",
  lcub: "{",
  Lcy: "\u041B",
  lcy: "\u043B",
  ldca: "\u2936",
  ldquo: "\u201C",
  ldquor: "\u201E",
  ldrdhar: "\u2967",
  ldrushar: "\u294B",
  ldsh: "\u21B2",
  le: "\u2264",
  lE: "\u2266",
  LeftAngleBracket: "\u27E8",
  LeftArrowBar: "\u21E4",
  leftarrow: "\u2190",
  LeftArrow: "\u2190",
  Leftarrow: "\u21D0",
  LeftArrowRightArrow: "\u21C6",
  leftarrowtail: "\u21A2",
  LeftCeiling: "\u2308",
  LeftDoubleBracket: "\u27E6",
  LeftDownTeeVector: "\u2961",
  LeftDownVectorBar: "\u2959",
  LeftDownVector: "\u21C3",
  LeftFloor: "\u230A",
  leftharpoondown: "\u21BD",
  leftharpoonup: "\u21BC",
  leftleftarrows: "\u21C7",
  leftrightarrow: "\u2194",
  LeftRightArrow: "\u2194",
  Leftrightarrow: "\u21D4",
  leftrightarrows: "\u21C6",
  leftrightharpoons: "\u21CB",
  leftrightsquigarrow: "\u21AD",
  LeftRightVector: "\u294E",
  LeftTeeArrow: "\u21A4",
  LeftTee: "\u22A3",
  LeftTeeVector: "\u295A",
  leftthreetimes: "\u22CB",
  LeftTriangleBar: "\u29CF",
  LeftTriangle: "\u22B2",
  LeftTriangleEqual: "\u22B4",
  LeftUpDownVector: "\u2951",
  LeftUpTeeVector: "\u2960",
  LeftUpVectorBar: "\u2958",
  LeftUpVector: "\u21BF",
  LeftVectorBar: "\u2952",
  LeftVector: "\u21BC",
  lEg: "\u2A8B",
  leg: "\u22DA",
  leq: "\u2264",
  leqq: "\u2266",
  leqslant: "\u2A7D",
  lescc: "\u2AA8",
  les: "\u2A7D",
  lesdot: "\u2A7F",
  lesdoto: "\u2A81",
  lesdotor: "\u2A83",
  lesg: "\u22DA\uFE00",
  lesges: "\u2A93",
  lessapprox: "\u2A85",
  lessdot: "\u22D6",
  lesseqgtr: "\u22DA",
  lesseqqgtr: "\u2A8B",
  LessEqualGreater: "\u22DA",
  LessFullEqual: "\u2266",
  LessGreater: "\u2276",
  lessgtr: "\u2276",
  LessLess: "\u2AA1",
  lesssim: "\u2272",
  LessSlantEqual: "\u2A7D",
  LessTilde: "\u2272",
  lfisht: "\u297C",
  lfloor: "\u230A",
  Lfr: "\uD835\uDD0F",
  lfr: "\uD835\uDD29",
  lg: "\u2276",
  lgE: "\u2A91",
  lHar: "\u2962",
  lhard: "\u21BD",
  lharu: "\u21BC",
  lharul: "\u296A",
  lhblk: "\u2584",
  LJcy: "\u0409",
  ljcy: "\u0459",
  llarr: "\u21C7",
  ll: "\u226A",
  Ll: "\u22D8",
  llcorner: "\u231E",
  Lleftarrow: "\u21DA",
  llhard: "\u296B",
  lltri: "\u25FA",
  Lmidot: "\u013F",
  lmidot: "\u0140",
  lmoustache: "\u23B0",
  lmoust: "\u23B0",
  lnap: "\u2A89",
  lnapprox: "\u2A89",
  lne: "\u2A87",
  lnE: "\u2268",
  lneq: "\u2A87",
  lneqq: "\u2268",
  lnsim: "\u22E6",
  loang: "\u27EC",
  loarr: "\u21FD",
  lobrk: "\u27E6",
  longleftarrow: "\u27F5",
  LongLeftArrow: "\u27F5",
  Longleftarrow: "\u27F8",
  longleftrightarrow: "\u27F7",
  LongLeftRightArrow: "\u27F7",
  Longleftrightarrow: "\u27FA",
  longmapsto: "\u27FC",
  longrightarrow: "\u27F6",
  LongRightArrow: "\u27F6",
  Longrightarrow: "\u27F9",
  looparrowleft: "\u21AB",
  looparrowright: "\u21AC",
  lopar: "\u2985",
  Lopf: "\uD835\uDD43",
  lopf: "\uD835\uDD5D",
  loplus: "\u2A2D",
  lotimes: "\u2A34",
  lowast: "\u2217",
  lowbar: "_",
  LowerLeftArrow: "\u2199",
  LowerRightArrow: "\u2198",
  loz: "\u25CA",
  lozenge: "\u25CA",
  lozf: "\u29EB",
  lpar: "(",
  lparlt: "\u2993",
  lrarr: "\u21C6",
  lrcorner: "\u231F",
  lrhar: "\u21CB",
  lrhard: "\u296D",
  lrm: "\u200E",
  lrtri: "\u22BF",
  lsaquo: "\u2039",
  lscr: "\uD835\uDCC1",
  Lscr: "\u2112",
  lsh: "\u21B0",
  Lsh: "\u21B0",
  lsim: "\u2272",
  lsime: "\u2A8D",
  lsimg: "\u2A8F",
  lsqb: "[",
  lsquo: "\u2018",
  lsquor: "\u201A",
  Lstrok: "\u0141",
  lstrok: "\u0142",
  ltcc: "\u2AA6",
  ltcir: "\u2A79",
  lt: "<",
  LT: "<",
  Lt: "\u226A",
  ltdot: "\u22D6",
  lthree: "\u22CB",
  ltimes: "\u22C9",
  ltlarr: "\u2976",
  ltquest: "\u2A7B",
  ltri: "\u25C3",
  ltrie: "\u22B4",
  ltrif: "\u25C2",
  ltrPar: "\u2996",
  lurdshar: "\u294A",
  luruhar: "\u2966",
  lvertneqq: "\u2268\uFE00",
  lvnE: "\u2268\uFE00",
  macr: "\u00AF",
  male: "\u2642",
  malt: "\u2720",
  maltese: "\u2720",
  Map: "\u2905",
  map: "\u21A6",
  mapsto: "\u21A6",
  mapstodown: "\u21A7",
  mapstoleft: "\u21A4",
  mapstoup: "\u21A5",
  marker: "\u25AE",
  mcomma: "\u2A29",
  Mcy: "\u041C",
  mcy: "\u043C",
  mdash: "\u2014",
  mDDot: "\u223A",
  measuredangle: "\u2221",
  MediumSpace: "\u205F",
  Mellintrf: "\u2133",
  Mfr: "\uD835\uDD10",
  mfr: "\uD835\uDD2A",
  mho: "\u2127",
  micro: "\u00B5",
  midast: "*",
  midcir: "\u2AF0",
  mid: "\u2223",
  middot: "\u00B7",
  minusb: "\u229F",
  minus: "\u2212",
  minusd: "\u2238",
  minusdu: "\u2A2A",
  MinusPlus: "\u2213",
  mlcp: "\u2ADB",
  mldr: "\u2026",
  mnplus: "\u2213",
  models: "\u22A7",
  Mopf: "\uD835\uDD44",
  mopf: "\uD835\uDD5E",
  mp: "\u2213",
  mscr: "\uD835\uDCC2",
  Mscr: "\u2133",
  mstpos: "\u223E",
  Mu: "\u039C",
  mu: "\u03BC",
  multimap: "\u22B8",
  mumap: "\u22B8",
  nabla: "\u2207",
  Nacute: "\u0143",
  nacute: "\u0144",
  nang: "\u2220\u20D2",
  nap: "\u2249",
  napE: "\u2A70\u0338",
  napid: "\u224B\u0338",
  napos: "\u0149",
  napprox: "\u2249",
  natural: "\u266E",
  naturals: "\u2115",
  natur: "\u266E",
  nbsp: "\u00A0",
  nbump: "\u224E\u0338",
  nbumpe: "\u224F\u0338",
  ncap: "\u2A43",
  Ncaron: "\u0147",
  ncaron: "\u0148",
  Ncedil: "\u0145",
  ncedil: "\u0146",
  ncong: "\u2247",
  ncongdot: "\u2A6D\u0338",
  ncup: "\u2A42",
  Ncy: "\u041D",
  ncy: "\u043D",
  ndash: "\u2013",
  nearhk: "\u2924",
  nearr: "\u2197",
  neArr: "\u21D7",
  nearrow: "\u2197",
  ne: "\u2260",
  nedot: "\u2250\u0338",
  NegativeMediumSpace: "\u200B",
  NegativeThickSpace: "\u200B",
  NegativeThinSpace: "\u200B",
  NegativeVeryThinSpace: "\u200B",
  nequiv: "\u2262",
  nesear: "\u2928",
  nesim: "\u2242\u0338",
  NestedGreaterGreater: "\u226B",
  NestedLessLess: "\u226A",
  NewLine: "\n",
  nexist: "\u2204",
  nexists: "\u2204",
  Nfr: "\uD835\uDD11",
  nfr: "\uD835\uDD2B",
  ngE: "\u2267\u0338",
  nge: "\u2271",
  ngeq: "\u2271",
  ngeqq: "\u2267\u0338",
  ngeqslant: "\u2A7E\u0338",
  nges: "\u2A7E\u0338",
  nGg: "\u22D9\u0338",
  ngsim: "\u2275",
  nGt: "\u226B\u20D2",
  ngt: "\u226F",
  ngtr: "\u226F",
  nGtv: "\u226B\u0338",
  nharr: "\u21AE",
  nhArr: "\u21CE",
  nhpar: "\u2AF2",
  ni: "\u220B",
  nis: "\u22FC",
  nisd: "\u22FA",
  niv: "\u220B",
  NJcy: "\u040A",
  njcy: "\u045A",
  nlarr: "\u219A",
  nlArr: "\u21CD",
  nldr: "\u2025",
  nlE: "\u2266\u0338",
  nle: "\u2270",
  nleftarrow: "\u219A",
  nLeftarrow: "\u21CD",
  nleftrightarrow: "\u21AE",
  nLeftrightarrow: "\u21CE",
  nleq: "\u2270",
  nleqq: "\u2266\u0338",
  nleqslant: "\u2A7D\u0338",
  nles: "\u2A7D\u0338",
  nless: "\u226E",
  nLl: "\u22D8\u0338",
  nlsim: "\u2274",
  nLt: "\u226A\u20D2",
  nlt: "\u226E",
  nltri: "\u22EA",
  nltrie: "\u22EC",
  nLtv: "\u226A\u0338",
  nmid: "\u2224",
  NoBreak: "\u2060",
  NonBreakingSpace: "\u00A0",
  nopf: "\uD835\uDD5F",
  Nopf: "\u2115",
  Not: "\u2AEC",
  not: "\u00AC",
  NotCongruent: "\u2262",
  NotCupCap: "\u226D",
  NotDoubleVerticalBar: "\u2226",
  NotElement: "\u2209",
  NotEqual: "\u2260",
  NotEqualTilde: "\u2242\u0338",
  NotExists: "\u2204",
  NotGreater: "\u226F",
  NotGreaterEqual: "\u2271",
  NotGreaterFullEqual: "\u2267\u0338",
  NotGreaterGreater: "\u226B\u0338",
  NotGreaterLess: "\u2279",
  NotGreaterSlantEqual: "\u2A7E\u0338",
  NotGreaterTilde: "\u2275",
  NotHumpDownHump: "\u224E\u0338",
  NotHumpEqual: "\u224F\u0338",
  notin: "\u2209",
  notindot: "\u22F5\u0338",
  notinE: "\u22F9\u0338",
  notinva: "\u2209",
  notinvb: "\u22F7",
  notinvc: "\u22F6",
  NotLeftTriangleBar: "\u29CF\u0338",
  NotLeftTriangle: "\u22EA",
  NotLeftTriangleEqual: "\u22EC",
  NotLess: "\u226E",
  NotLessEqual: "\u2270",
  NotLessGreater: "\u2278",
  NotLessLess: "\u226A\u0338",
  NotLessSlantEqual: "\u2A7D\u0338",
  NotLessTilde: "\u2274",
  NotNestedGreaterGreater: "\u2AA2\u0338",
  NotNestedLessLess: "\u2AA1\u0338",
  notni: "\u220C",
  notniva: "\u220C",
  notnivb: "\u22FE",
  notnivc: "\u22FD",
  NotPrecedes: "\u2280",
  NotPrecedesEqual: "\u2AAF\u0338",
  NotPrecedesSlantEqual: "\u22E0",
  NotReverseElement: "\u220C",
  NotRightTriangleBar: "\u29D0\u0338",
  NotRightTriangle: "\u22EB",
  NotRightTriangleEqual: "\u22ED",
  NotSquareSubset: "\u228F\u0338",
  NotSquareSubsetEqual: "\u22E2",
  NotSquareSuperset: "\u2290\u0338",
  NotSquareSupersetEqual: "\u22E3",
  NotSubset: "\u2282\u20D2",
  NotSubsetEqual: "\u2288",
  NotSucceeds: "\u2281",
  NotSucceedsEqual: "\u2AB0\u0338",
  NotSucceedsSlantEqual: "\u22E1",
  NotSucceedsTilde: "\u227F\u0338",
  NotSuperset: "\u2283\u20D2",
  NotSupersetEqual: "\u2289",
  NotTilde: "\u2241",
  NotTildeEqual: "\u2244",
  NotTildeFullEqual: "\u2247",
  NotTildeTilde: "\u2249",
  NotVerticalBar: "\u2224",
  nparallel: "\u2226",
  npar: "\u2226",
  nparsl: "\u2AFD\u20E5",
  npart: "\u2202\u0338",
  npolint: "\u2A14",
  npr: "\u2280",
  nprcue: "\u22E0",
  nprec: "\u2280",
  npreceq: "\u2AAF\u0338",
  npre: "\u2AAF\u0338",
  nrarrc: "\u2933\u0338",
  nrarr: "\u219B",
  nrArr: "\u21CF",
  nrarrw: "\u219D\u0338",
  nrightarrow: "\u219B",
  nRightarrow: "\u21CF",
  nrtri: "\u22EB",
  nrtrie: "\u22ED",
  nsc: "\u2281",
  nsccue: "\u22E1",
  nsce: "\u2AB0\u0338",
  Nscr: "\uD835\uDCA9",
  nscr: "\uD835\uDCC3",
  nshortmid: "\u2224",
  nshortparallel: "\u2226",
  nsim: "\u2241",
  nsime: "\u2244",
  nsimeq: "\u2244",
  nsmid: "\u2224",
  nspar: "\u2226",
  nsqsube: "\u22E2",
  nsqsupe: "\u22E3",
  nsub: "\u2284",
  nsubE: "\u2AC5\u0338",
  nsube: "\u2288",
  nsubset: "\u2282\u20D2",
  nsubseteq: "\u2288",
  nsubseteqq: "\u2AC5\u0338",
  nsucc: "\u2281",
  nsucceq: "\u2AB0\u0338",
  nsup: "\u2285",
  nsupE: "\u2AC6\u0338",
  nsupe: "\u2289",
  nsupset: "\u2283\u20D2",
  nsupseteq: "\u2289",
  nsupseteqq: "\u2AC6\u0338",
  ntgl: "\u2279",
  Ntilde: "\u00D1",
  ntilde: "\u00F1",
  ntlg: "\u2278",
  ntriangleleft: "\u22EA",
  ntrianglelefteq: "\u22EC",
  ntriangleright: "\u22EB",
  ntrianglerighteq: "\u22ED",
  Nu: "\u039D",
  nu: "\u03BD",
  num: "#",
  numero: "\u2116",
  numsp: "\u2007",
  nvap: "\u224D\u20D2",
  nvdash: "\u22AC",
  nvDash: "\u22AD",
  nVdash: "\u22AE",
  nVDash: "\u22AF",
  nvge: "\u2265\u20D2",
  nvgt: ">\u20D2",
  nvHarr: "\u2904",
  nvinfin: "\u29DE",
  nvlArr: "\u2902",
  nvle: "\u2264\u20D2",
  nvlt: "<\u20D2",
  nvltrie: "\u22B4\u20D2",
  nvrArr: "\u2903",
  nvrtrie: "\u22B5\u20D2",
  nvsim: "\u223C\u20D2",
  nwarhk: "\u2923",
  nwarr: "\u2196",
  nwArr: "\u21D6",
  nwarrow: "\u2196",
  nwnear: "\u2927",
  Oacute: "\u00D3",
  oacute: "\u00F3",
  oast: "\u229B",
  Ocirc: "\u00D4",
  ocirc: "\u00F4",
  ocir: "\u229A",
  Ocy: "\u041E",
  ocy: "\u043E",
  odash: "\u229D",
  Odblac: "\u0150",
  odblac: "\u0151",
  odiv: "\u2A38",
  odot: "\u2299",
  odsold: "\u29BC",
  OElig: "\u0152",
  oelig: "\u0153",
  ofcir: "\u29BF",
  Ofr: "\uD835\uDD12",
  ofr: "\uD835\uDD2C",
  ogon: "\u02DB",
  Ograve: "\u00D2",
  ograve: "\u00F2",
  ogt: "\u29C1",
  ohbar: "\u29B5",
  ohm: "\u03A9",
  oint: "\u222E",
  olarr: "\u21BA",
  olcir: "\u29BE",
  olcross: "\u29BB",
  oline: "\u203E",
  olt: "\u29C0",
  Omacr: "\u014C",
  omacr: "\u014D",
  Omega: "\u03A9",
  omega: "\u03C9",
  Omicron: "\u039F",
  omicron: "\u03BF",
  omid: "\u29B6",
  ominus: "\u2296",
  Oopf: "\uD835\uDD46",
  oopf: "\uD835\uDD60",
  opar: "\u29B7",
  OpenCurlyDoubleQuote: "\u201C",
  OpenCurlyQuote: "\u2018",
  operp: "\u29B9",
  oplus: "\u2295",
  orarr: "\u21BB",
  Or: "\u2A54",
  or: "\u2228",
  ord: "\u2A5D",
  order: "\u2134",
  orderof: "\u2134",
  ordf: "\u00AA",
  ordm: "\u00BA",
  origof: "\u22B6",
  oror: "\u2A56",
  orslope: "\u2A57",
  orv: "\u2A5B",
  oS: "\u24C8",
  Oscr: "\uD835\uDCAA",
  oscr: "\u2134",
  Oslash: "\u00D8",
  oslash: "\u00F8",
  osol: "\u2298",
  Otilde: "\u00D5",
  otilde: "\u00F5",
  otimesas: "\u2A36",
  Otimes: "\u2A37",
  otimes: "\u2297",
  Ouml: "\u00D6",
  ouml: "\u00F6",
  ovbar: "\u233D",
  OverBar: "\u203E",
  OverBrace: "\u23DE",
  OverBracket: "\u23B4",
  OverParenthesis: "\u23DC",
  para: "\u00B6",
  parallel: "\u2225",
  par: "\u2225",
  parsim: "\u2AF3",
  parsl: "\u2AFD",
  part: "\u2202",
  PartialD: "\u2202",
  Pcy: "\u041F",
  pcy: "\u043F",
  percnt: "%",
  period: ".",
  permil: "\u2030",
  perp: "\u22A5",
  pertenk: "\u2031",
  Pfr: "\uD835\uDD13",
  pfr: "\uD835\uDD2D",
  Phi: "\u03A6",
  phi: "\u03C6",
  phiv: "\u03D5",
  phmmat: "\u2133",
  phone: "\u260E",
  Pi: "\u03A0",
  pi: "\u03C0",
  pitchfork: "\u22D4",
  piv: "\u03D6",
  planck: "\u210F",
  planckh: "\u210E",
  plankv: "\u210F",
  plusacir: "\u2A23",
  plusb: "\u229E",
  pluscir: "\u2A22",
  plus: "+",
  plusdo: "\u2214",
  plusdu: "\u2A25",
  pluse: "\u2A72",
  PlusMinus: "\u00B1",
  plusmn: "\u00B1",
  plussim: "\u2A26",
  plustwo: "\u2A27",
  pm: "\u00B1",
  Poincareplane: "\u210C",
  pointint: "\u2A15",
  popf: "\uD835\uDD61",
  Popf: "\u2119",
  pound: "\u00A3",
  prap: "\u2AB7",
  Pr: "\u2ABB",
  pr: "\u227A",
  prcue: "\u227C",
  precapprox: "\u2AB7",
  prec: "\u227A",
  preccurlyeq: "\u227C",
  Precedes: "\u227A",
  PrecedesEqual: "\u2AAF",
  PrecedesSlantEqual: "\u227C",
  PrecedesTilde: "\u227E",
  preceq: "\u2AAF",
  precnapprox: "\u2AB9",
  precneqq: "\u2AB5",
  precnsim: "\u22E8",
  pre: "\u2AAF",
  prE: "\u2AB3",
  precsim: "\u227E",
  prime: "\u2032",
  Prime: "\u2033",
  primes: "\u2119",
  prnap: "\u2AB9",
  prnE: "\u2AB5",
  prnsim: "\u22E8",
  prod: "\u220F",
  Product: "\u220F",
  profalar: "\u232E",
  profline: "\u2312",
  profsurf: "\u2313",
  prop: "\u221D",
  Proportional: "\u221D",
  Proportion: "\u2237",
  propto: "\u221D",
  prsim: "\u227E",
  prurel: "\u22B0",
  Pscr: "\uD835\uDCAB",
  pscr: "\uD835\uDCC5",
  Psi: "\u03A8",
  psi: "\u03C8",
  puncsp: "\u2008",
  Qfr: "\uD835\uDD14",
  qfr: "\uD835\uDD2E",
  qint: "\u2A0C",
  qopf: "\uD835\uDD62",
  Qopf: "\u211A",
  qprime: "\u2057",
  Qscr: "\uD835\uDCAC",
  qscr: "\uD835\uDCC6",
  quaternions: "\u210D",
  quatint: "\u2A16",
  quest: "?",
  questeq: "\u225F",
  quot: "\"",
  QUOT: "\"",
  rAarr: "\u21DB",
  race: "\u223D\u0331",
  Racute: "\u0154",
  racute: "\u0155",
  radic: "\u221A",
  raemptyv: "\u29B3",
  rang: "\u27E9",
  Rang: "\u27EB",
  rangd: "\u2992",
  range: "\u29A5",
  rangle: "\u27E9",
  raquo: "\u00BB",
  rarrap: "\u2975",
  rarrb: "\u21E5",
  rarrbfs: "\u2920",
  rarrc: "\u2933",
  rarr: "\u2192",
  Rarr: "\u21A0",
  rArr: "\u21D2",
  rarrfs: "\u291E",
  rarrhk: "\u21AA",
  rarrlp: "\u21AC",
  rarrpl: "\u2945",
  rarrsim: "\u2974",
  Rarrtl: "\u2916",
  rarrtl: "\u21A3",
  rarrw: "\u219D",
  ratail: "\u291A",
  rAtail: "\u291C",
  ratio: "\u2236",
  rationals: "\u211A",
  rbarr: "\u290D",
  rBarr: "\u290F",
  RBarr: "\u2910",
  rbbrk: "\u2773",
  rbrace: "}",
  rbrack: "]",
  rbrke: "\u298C",
  rbrksld: "\u298E",
  rbrkslu: "\u2990",
  Rcaron: "\u0158",
  rcaron: "\u0159",
  Rcedil: "\u0156",
  rcedil: "\u0157",
  rceil: "\u2309",
  rcub: "}",
  Rcy: "\u0420",
  rcy: "\u0440",
  rdca: "\u2937",
  rdldhar: "\u2969",
  rdquo: "\u201D",
  rdquor: "\u201D",
  rdsh: "\u21B3",
  real: "\u211C",
  realine: "\u211B",
  realpart: "\u211C",
  reals: "\u211D",
  Re: "\u211C",
  rect: "\u25AD",
  reg: "\u00AE",
  REG: "\u00AE",
  ReverseElement: "\u220B",
  ReverseEquilibrium: "\u21CB",
  ReverseUpEquilibrium: "\u296F",
  rfisht: "\u297D",
  rfloor: "\u230B",
  rfr: "\uD835\uDD2F",
  Rfr: "\u211C",
  rHar: "\u2964",
  rhard: "\u21C1",
  rharu: "\u21C0",
  rharul: "\u296C",
  Rho: "\u03A1",
  rho: "\u03C1",
  rhov: "\u03F1",
  RightAngleBracket: "\u27E9",
  RightArrowBar: "\u21E5",
  rightarrow: "\u2192",
  RightArrow: "\u2192",
  Rightarrow: "\u21D2",
  RightArrowLeftArrow: "\u21C4",
  rightarrowtail: "\u21A3",
  RightCeiling: "\u2309",
  RightDoubleBracket: "\u27E7",
  RightDownTeeVector: "\u295D",
  RightDownVectorBar: "\u2955",
  RightDownVector: "\u21C2",
  RightFloor: "\u230B",
  rightharpoondown: "\u21C1",
  rightharpoonup: "\u21C0",
  rightleftarrows: "\u21C4",
  rightleftharpoons: "\u21CC",
  rightrightarrows: "\u21C9",
  rightsquigarrow: "\u219D",
  RightTeeArrow: "\u21A6",
  RightTee: "\u22A2",
  RightTeeVector: "\u295B",
  rightthreetimes: "\u22CC",
  RightTriangleBar: "\u29D0",
  RightTriangle: "\u22B3",
  RightTriangleEqual: "\u22B5",
  RightUpDownVector: "\u294F",
  RightUpTeeVector: "\u295C",
  RightUpVectorBar: "\u2954",
  RightUpVector: "\u21BE",
  RightVectorBar: "\u2953",
  RightVector: "\u21C0",
  ring: "\u02DA",
  risingdotseq: "\u2253",
  rlarr: "\u21C4",
  rlhar: "\u21CC",
  rlm: "\u200F",
  rmoustache: "\u23B1",
  rmoust: "\u23B1",
  rnmid: "\u2AEE",
  roang: "\u27ED",
  roarr: "\u21FE",
  robrk: "\u27E7",
  ropar: "\u2986",
  ropf: "\uD835\uDD63",
  Ropf: "\u211D",
  roplus: "\u2A2E",
  rotimes: "\u2A35",
  RoundImplies: "\u2970",
  rpar: ")",
  rpargt: "\u2994",
  rppolint: "\u2A12",
  rrarr: "\u21C9",
  Rrightarrow: "\u21DB",
  rsaquo: "\u203A",
  rscr: "\uD835\uDCC7",
  Rscr: "\u211B",
  rsh: "\u21B1",
  Rsh: "\u21B1",
  rsqb: "]",
  rsquo: "\u2019",
  rsquor: "\u2019",
  rthree: "\u22CC",
  rtimes: "\u22CA",
  rtri: "\u25B9",
  rtrie: "\u22B5",
  rtrif: "\u25B8",
  rtriltri: "\u29CE",
  RuleDelayed: "\u29F4",
  ruluhar: "\u2968",
  rx: "\u211E",
  Sacute: "\u015A",
  sacute: "\u015B",
  sbquo: "\u201A",
  scap: "\u2AB8",
  Scaron: "\u0160",
  scaron: "\u0161",
  Sc: "\u2ABC",
  sc: "\u227B",
  sccue: "\u227D",
  sce: "\u2AB0",
  scE: "\u2AB4",
  Scedil: "\u015E",
  scedil: "\u015F",
  Scirc: "\u015C",
  scirc: "\u015D",
  scnap: "\u2ABA",
  scnE: "\u2AB6",
  scnsim: "\u22E9",
  scpolint: "\u2A13",
  scsim: "\u227F",
  Scy: "\u0421",
  scy: "\u0441",
  sdotb: "\u22A1",
  sdot: "\u22C5",
  sdote: "\u2A66",
  searhk: "\u2925",
  searr: "\u2198",
  seArr: "\u21D8",
  searrow: "\u2198",
  sect: "\u00A7",
  semi: ";",
  seswar: "\u2929",
  setminus: "\u2216",
  setmn: "\u2216",
  sext: "\u2736",
  Sfr: "\uD835\uDD16",
  sfr: "\uD835\uDD30",
  sfrown: "\u2322",
  sharp: "\u266F",
  SHCHcy: "\u0429",
  shchcy: "\u0449",
  SHcy: "\u0428",
  shcy: "\u0448",
  ShortDownArrow: "\u2193",
  ShortLeftArrow: "\u2190",
  shortmid: "\u2223",
  shortparallel: "\u2225",
  ShortRightArrow: "\u2192",
  ShortUpArrow: "\u2191",
  shy: "\u00AD",
  Sigma: "\u03A3",
  sigma: "\u03C3",
  sigmaf: "\u03C2",
  sigmav: "\u03C2",
  sim: "\u223C",
  simdot: "\u2A6A",
  sime: "\u2243",
  simeq: "\u2243",
  simg: "\u2A9E",
  simgE: "\u2AA0",
  siml: "\u2A9D",
  simlE: "\u2A9F",
  simne: "\u2246",
  simplus: "\u2A24",
  simrarr: "\u2972",
  slarr: "\u2190",
  SmallCircle: "\u2218",
  smallsetminus: "\u2216",
  smashp: "\u2A33",
  smeparsl: "\u29E4",
  smid: "\u2223",
  smile: "\u2323",
  smt: "\u2AAA",
  smte: "\u2AAC",
  smtes: "\u2AAC\uFE00",
  SOFTcy: "\u042C",
  softcy: "\u044C",
  solbar: "\u233F",
  solb: "\u29C4",
  sol: "/",
  Sopf: "\uD835\uDD4A",
  sopf: "\uD835\uDD64",
  spades: "\u2660",
  spadesuit: "\u2660",
  spar: "\u2225",
  sqcap: "\u2293",
  sqcaps: "\u2293\uFE00",
  sqcup: "\u2294",
  sqcups: "\u2294\uFE00",
  Sqrt: "\u221A",
  sqsub: "\u228F",
  sqsube: "\u2291",
  sqsubset: "\u228F",
  sqsubseteq: "\u2291",
  sqsup: "\u2290",
  sqsupe: "\u2292",
  sqsupset: "\u2290",
  sqsupseteq: "\u2292",
  square: "\u25A1",
  Square: "\u25A1",
  SquareIntersection: "\u2293",
  SquareSubset: "\u228F",
  SquareSubsetEqual: "\u2291",
  SquareSuperset: "\u2290",
  SquareSupersetEqual: "\u2292",
  SquareUnion: "\u2294",
  squarf: "\u25AA",
  squ: "\u25A1",
  squf: "\u25AA",
  srarr: "\u2192",
  Sscr: "\uD835\uDCAE",
  sscr: "\uD835\uDCC8",
  ssetmn: "\u2216",
  ssmile: "\u2323",
  sstarf: "\u22C6",
  Star: "\u22C6",
  star: "\u2606",
  starf: "\u2605",
  straightepsilon: "\u03F5",
  straightphi: "\u03D5",
  strns: "\u00AF",
  sub: "\u2282",
  Sub: "\u22D0",
  subdot: "\u2ABD",
  subE: "\u2AC5",
  sube: "\u2286",
  subedot: "\u2AC3",
  submult: "\u2AC1",
  subnE: "\u2ACB",
  subne: "\u228A",
  subplus: "\u2ABF",
  subrarr: "\u2979",
  subset: "\u2282",
  Subset: "\u22D0",
  subseteq: "\u2286",
  subseteqq: "\u2AC5",
  SubsetEqual: "\u2286",
  subsetneq: "\u228A",
  subsetneqq: "\u2ACB",
  subsim: "\u2AC7",
  subsub: "\u2AD5",
  subsup: "\u2AD3",
  succapprox: "\u2AB8",
  succ: "\u227B",
  succcurlyeq: "\u227D",
  Succeeds: "\u227B",
  SucceedsEqual: "\u2AB0",
  SucceedsSlantEqual: "\u227D",
  SucceedsTilde: "\u227F",
  succeq: "\u2AB0",
  succnapprox: "\u2ABA",
  succneqq: "\u2AB6",
  succnsim: "\u22E9",
  succsim: "\u227F",
  SuchThat: "\u220B",
  sum: "\u2211",
  Sum: "\u2211",
  sung: "\u266A",
  sup1: "\u00B9",
  sup2: "\u00B2",
  sup3: "\u00B3",
  sup: "\u2283",
  Sup: "\u22D1",
  supdot: "\u2ABE",
  supdsub: "\u2AD8",
  supE: "\u2AC6",
  supe: "\u2287",
  supedot: "\u2AC4",
  Superset: "\u2283",
  SupersetEqual: "\u2287",
  suphsol: "\u27C9",
  suphsub: "\u2AD7",
  suplarr: "\u297B",
  supmult: "\u2AC2",
  supnE: "\u2ACC",
  supne: "\u228B",
  supplus: "\u2AC0",
  supset: "\u2283",
  Supset: "\u22D1",
  supseteq: "\u2287",
  supseteqq: "\u2AC6",
  supsetneq: "\u228B",
  supsetneqq: "\u2ACC",
  supsim: "\u2AC8",
  supsub: "\u2AD4",
  supsup: "\u2AD6",
  swarhk: "\u2926",
  swarr: "\u2199",
  swArr: "\u21D9",
  swarrow: "\u2199",
  swnwar: "\u292A",
  szlig: "\u00DF",
  Tab: "\t",
  target: "\u2316",
  Tau: "\u03A4",
  tau: "\u03C4",
  tbrk: "\u23B4",
  Tcaron: "\u0164",
  tcaron: "\u0165",
  Tcedil: "\u0162",
  tcedil: "\u0163",
  Tcy: "\u0422",
  tcy: "\u0442",
  tdot: "\u20DB",
  telrec: "\u2315",
  Tfr: "\uD835\uDD17",
  tfr: "\uD835\uDD31",
  there4: "\u2234",
  therefore: "\u2234",
  Therefore: "\u2234",
  Theta: "\u0398",
  theta: "\u03B8",
  thetasym: "\u03D1",
  thetav: "\u03D1",
  thickapprox: "\u2248",
  thicksim: "\u223C",
  ThickSpace: "\u205F\u200A",
  ThinSpace: "\u2009",
  thinsp: "\u2009",
  thkap: "\u2248",
  thksim: "\u223C",
  THORN: "\u00DE",
  thorn: "\u00FE",
  tilde: "\u02DC",
  Tilde: "\u223C",
  TildeEqual: "\u2243",
  TildeFullEqual: "\u2245",
  TildeTilde: "\u2248",
  timesbar: "\u2A31",
  timesb: "\u22A0",
  times: "\u00D7",
  timesd: "\u2A30",
  tint: "\u222D",
  toea: "\u2928",
  topbot: "\u2336",
  topcir: "\u2AF1",
  top: "\u22A4",
  Topf: "\uD835\uDD4B",
  topf: "\uD835\uDD65",
  topfork: "\u2ADA",
  tosa: "\u2929",
  tprime: "\u2034",
  trade: "\u2122",
  TRADE: "\u2122",
  triangle: "\u25B5",
  triangledown: "\u25BF",
  triangleleft: "\u25C3",
  trianglelefteq: "\u22B4",
  triangleq: "\u225C",
  triangleright: "\u25B9",
  trianglerighteq: "\u22B5",
  tridot: "\u25EC",
  trie: "\u225C",
  triminus: "\u2A3A",
  TripleDot: "\u20DB",
  triplus: "\u2A39",
  trisb: "\u29CD",
  tritime: "\u2A3B",
  trpezium: "\u23E2",
  Tscr: "\uD835\uDCAF",
  tscr: "\uD835\uDCC9",
  TScy: "\u0426",
  tscy: "\u0446",
  TSHcy: "\u040B",
  tshcy: "\u045B",
  Tstrok: "\u0166",
  tstrok: "\u0167",
  twixt: "\u226C",
  twoheadleftarrow: "\u219E",
  twoheadrightarrow: "\u21A0",
  Uacute: "\u00DA",
  uacute: "\u00FA",
  uarr: "\u2191",
  Uarr: "\u219F",
  uArr: "\u21D1",
  Uarrocir: "\u2949",
  Ubrcy: "\u040E",
  ubrcy: "\u045E",
  Ubreve: "\u016C",
  ubreve: "\u016D",
  Ucirc: "\u00DB",
  ucirc: "\u00FB",
  Ucy: "\u0423",
  ucy: "\u0443",
  udarr: "\u21C5",
  Udblac: "\u0170",
  udblac: "\u0171",
  udhar: "\u296E",
  ufisht: "\u297E",
  Ufr: "\uD835\uDD18",
  ufr: "\uD835\uDD32",
  Ugrave: "\u00D9",
  ugrave: "\u00F9",
  uHar: "\u2963",
  uharl: "\u21BF",
  uharr: "\u21BE",
  uhblk: "\u2580",
  ulcorn: "\u231C",
  ulcorner: "\u231C",
  ulcrop: "\u230F",
  ultri: "\u25F8",
  Umacr: "\u016A",
  umacr: "\u016B",
  uml: "\u00A8",
  UnderBar: "_",
  UnderBrace: "\u23DF",
  UnderBracket: "\u23B5",
  UnderParenthesis: "\u23DD",
  Union: "\u22C3",
  UnionPlus: "\u228E",
  Uogon: "\u0172",
  uogon: "\u0173",
  Uopf: "\uD835\uDD4C",
  uopf: "\uD835\uDD66",
  UpArrowBar: "\u2912",
  uparrow: "\u2191",
  UpArrow: "\u2191",
  Uparrow: "\u21D1",
  UpArrowDownArrow: "\u21C5",
  updownarrow: "\u2195",
  UpDownArrow: "\u2195",
  Updownarrow: "\u21D5",
  UpEquilibrium: "\u296E",
  upharpoonleft: "\u21BF",
  upharpoonright: "\u21BE",
  uplus: "\u228E",
  UpperLeftArrow: "\u2196",
  UpperRightArrow: "\u2197",
  upsi: "\u03C5",
  Upsi: "\u03D2",
  upsih: "\u03D2",
  Upsilon: "\u03A5",
  upsilon: "\u03C5",
  UpTeeArrow: "\u21A5",
  UpTee: "\u22A5",
  upuparrows: "\u21C8",
  urcorn: "\u231D",
  urcorner: "\u231D",
  urcrop: "\u230E",
  Uring: "\u016E",
  uring: "\u016F",
  urtri: "\u25F9",
  Uscr: "\uD835\uDCB0",
  uscr: "\uD835\uDCCA",
  utdot: "\u22F0",
  Utilde: "\u0168",
  utilde: "\u0169",
  utri: "\u25B5",
  utrif: "\u25B4",
  uuarr: "\u21C8",
  Uuml: "\u00DC",
  uuml: "\u00FC",
  uwangle: "\u29A7",
  vangrt: "\u299C",
  varepsilon: "\u03F5",
  varkappa: "\u03F0",
  varnothing: "\u2205",
  varphi: "\u03D5",
  varpi: "\u03D6",
  varpropto: "\u221D",
  varr: "\u2195",
  vArr: "\u21D5",
  varrho: "\u03F1",
  varsigma: "\u03C2",
  varsubsetneq: "\u228A\uFE00",
  varsubsetneqq: "\u2ACB\uFE00",
  varsupsetneq: "\u228B\uFE00",
  varsupsetneqq: "\u2ACC\uFE00",
  vartheta: "\u03D1",
  vartriangleleft: "\u22B2",
  vartriangleright: "\u22B3",
  vBar: "\u2AE8",
  Vbar: "\u2AEB",
  vBarv: "\u2AE9",
  Vcy: "\u0412",
  vcy: "\u0432",
  vdash: "\u22A2",
  vDash: "\u22A8",
  Vdash: "\u22A9",
  VDash: "\u22AB",
  Vdashl: "\u2AE6",
  veebar: "\u22BB",
  vee: "\u2228",
  Vee: "\u22C1",
  veeeq: "\u225A",
  vellip: "\u22EE",
  verbar: "|",
  Verbar: "\u2016",
  vert: "|",
  Vert: "\u2016",
  VerticalBar: "\u2223",
  VerticalLine: "|",
  VerticalSeparator: "\u2758",
  VerticalTilde: "\u2240",
  VeryThinSpace: "\u200A",
  Vfr: "\uD835\uDD19",
  vfr: "\uD835\uDD33",
  vltri: "\u22B2",
  vnsub: "\u2282\u20D2",
  vnsup: "\u2283\u20D2",
  Vopf: "\uD835\uDD4D",
  vopf: "\uD835\uDD67",
  vprop: "\u221D",
  vrtri: "\u22B3",
  Vscr: "\uD835\uDCB1",
  vscr: "\uD835\uDCCB",
  vsubnE: "\u2ACB\uFE00",
  vsubne: "\u228A\uFE00",
  vsupnE: "\u2ACC\uFE00",
  vsupne: "\u228B\uFE00",
  Vvdash: "\u22AA",
  vzigzag: "\u299A",
  Wcirc: "\u0174",
  wcirc: "\u0175",
  wedbar: "\u2A5F",
  wedge: "\u2227",
  Wedge: "\u22C0",
  wedgeq: "\u2259",
  weierp: "\u2118",
  Wfr: "\uD835\uDD1A",
  wfr: "\uD835\uDD34",
  Wopf: "\uD835\uDD4E",
  wopf: "\uD835\uDD68",
  wp: "\u2118",
  wr: "\u2240",
  wreath: "\u2240",
  Wscr: "\uD835\uDCB2",
  wscr: "\uD835\uDCCC",
  xcap: "\u22C2",
  xcirc: "\u25EF",
  xcup: "\u22C3",
  xdtri: "\u25BD",
  Xfr: "\uD835\uDD1B",
  xfr: "\uD835\uDD35",
  xharr: "\u27F7",
  xhArr: "\u27FA",
  Xi: "\u039E",
  xi: "\u03BE",
  xlarr: "\u27F5",
  xlArr: "\u27F8",
  xmap: "\u27FC",
  xnis: "\u22FB",
  xodot: "\u2A00",
  Xopf: "\uD835\uDD4F",
  xopf: "\uD835\uDD69",
  xoplus: "\u2A01",
  xotime: "\u2A02",
  xrarr: "\u27F6",
  xrArr: "\u27F9",
  Xscr: "\uD835\uDCB3",
  xscr: "\uD835\uDCCD",
  xsqcup: "\u2A06",
  xuplus: "\u2A04",
  xutri: "\u25B3",
  xvee: "\u22C1",
  xwedge: "\u22C0",
  Yacute: "\u00DD",
  yacute: "\u00FD",
  YAcy: "\u042F",
  yacy: "\u044F",
  Ycirc: "\u0176",
  ycirc: "\u0177",
  Ycy: "\u042B",
  ycy: "\u044B",
  yen: "\u00A5",
  Yfr: "\uD835\uDD1C",
  yfr: "\uD835\uDD36",
  YIcy: "\u0407",
  yicy: "\u0457",
  Yopf: "\uD835\uDD50",
  yopf: "\uD835\uDD6A",
  Yscr: "\uD835\uDCB4",
  yscr: "\uD835\uDCCE",
  YUcy: "\u042E",
  yucy: "\u044E",
  yuml: "\u00FF",
  Yuml: "\u0178",
  Zacute: "\u0179",
  zacute: "\u017A",
  Zcaron: "\u017D",
  zcaron: "\u017E",
  Zcy: "\u0417",
  zcy: "\u0437",
  Zdot: "\u017B",
  zdot: "\u017C",
  zeetrf: "\u2128",
  ZeroWidthSpace: "\u200B",
  Zeta: "\u0396",
  zeta: "\u03B6",
  zfr: "\uD835\uDD37",
  Zfr: "\u2128",
  ZHcy: "\u0416",
  zhcy: "\u0436",
  zigrarr: "\u21DD",
  zopf: "\uD835\uDD6B",
  Zopf: "\u2124",
  Zscr: "\uD835\uDCB5",
  zscr: "\uD835\uDCCF",
  zwj: "\u200D",
  zwnj: "\u200C"
};

/***/ }),
/* 63 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports.encode = __webpack_require__(144);
module.exports.decode = __webpack_require__(145);
module.exports.format = __webpack_require__(146);
module.exports.parse = __webpack_require__(147);

/***/ }),
/* 64 */
/***/ (function(module, exports) {

module.exports = /[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;

/***/ }),
/* 65 */
/***/ (function(module, exports) {

module.exports = /[\0-\x1F\x7F-\x9F]/;

/***/ }),
/* 66 */
/***/ (function(module, exports) {

module.exports = /[ \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;

/***/ }),
/* 67 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Regexps to match html elements


var attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
var unquoted = '[^"\'=<>`\\x00-\\x20]+';
var single_quoted = "'[^']*'";
var double_quoted = '"[^"]*"';
var attr_value = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';
var attribute = '(?:\\s+' + attr_name + '(?:\\s*=\\s*' + attr_value + ')?)';
var open_tag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>';
var close_tag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
var comment = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';
var processing = '<[?].*?[?]>';
var declaration = '<![A-Z]+\\s+[^>]*>';
var cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
var HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment + '|' + processing + '|' + declaration + '|' + cdata + ')');
var HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')');
module.exports.HTML_TAG_RE = HTML_TAG_RE;
module.exports.HTML_OPEN_CLOSE_TAG_RE = HTML_OPEN_CLOSE_TAG_RE;

/***/ }),
/* 68 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// ~~strike through~~
//
 // Insert each marker as a separate text token, and add it to delimiter list
//

module.exports.tokenize = function strikethrough(state, silent) {
  var i,
      scanned,
      token,
      len,
      ch,
      start = state.pos,
      marker = state.src.charCodeAt(start);

  if (silent) {
    return false;
  }

  if (marker !== 0x7E
  /* ~ */
  ) {
      return false;
    }

  scanned = state.scanDelims(state.pos, true);
  len = scanned.length;
  ch = String.fromCharCode(marker);

  if (len < 2) {
    return false;
  }

  if (len % 2) {
    token = state.push('text', '', 0);
    token.content = ch;
    len--;
  }

  for (i = 0; i < len; i += 2) {
    token = state.push('text', '', 0);
    token.content = ch + ch;
    state.delimiters.push({
      marker: marker,
      jump: i,
      token: state.tokens.length - 1,
      level: state.level,
      end: -1,
      open: scanned.can_open,
      close: scanned.can_close
    });
  }

  state.pos += scanned.length;
  return true;
}; // Walk through delimiter list and replace text tokens with tags
//


module.exports.postProcess = function strikethrough(state) {
  var i,
      j,
      startDelim,
      endDelim,
      token,
      loneMarkers = [],
      delimiters = state.delimiters,
      max = state.delimiters.length;

  for (i = 0; i < max; i++) {
    startDelim = delimiters[i];

    if (startDelim.marker !== 0x7E
    /* ~ */
    ) {
        continue;
      }

    if (startDelim.end === -1) {
      continue;
    }

    endDelim = delimiters[startDelim.end];
    token = state.tokens[startDelim.token];
    token.type = 's_open';
    token.tag = 's';
    token.nesting = 1;
    token.markup = '~~';
    token.content = '';
    token = state.tokens[endDelim.token];
    token.type = 's_close';
    token.tag = 's';
    token.nesting = -1;
    token.markup = '~~';
    token.content = '';

    if (state.tokens[endDelim.token - 1].type === 'text' && state.tokens[endDelim.token - 1].content === '~') {
      loneMarkers.push(endDelim.token - 1);
    }
  } // If a marker sequence has an odd number of characters, it's splitted
  // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the
  // start of the sequence.
  //
  // So, we have to move all those markers after subsequent s_close tags.
  //


  while (loneMarkers.length) {
    i = loneMarkers.pop();
    j = i + 1;

    while (j < state.tokens.length && state.tokens[j].type === 's_close') {
      j++;
    }

    j--;

    if (i !== j) {
      token = state.tokens[j];
      state.tokens[j] = state.tokens[i];
      state.tokens[i] = token;
    }
  }
};

/***/ }),
/* 69 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Process *this* and _that_
//
 // Insert each marker as a separate text token, and add it to delimiter list
//

module.exports.tokenize = function emphasis(state, silent) {
  var i,
      scanned,
      token,
      start = state.pos,
      marker = state.src.charCodeAt(start);

  if (silent) {
    return false;
  }

  if (marker !== 0x5F
  /* _ */
  && marker !== 0x2A
  /* * */
  ) {
      return false;
    }

  scanned = state.scanDelims(state.pos, marker === 0x2A);

  for (i = 0; i < scanned.length; i++) {
    token = state.push('text', '', 0);
    token.content = String.fromCharCode(marker);
    state.delimiters.push({
      // Char code of the starting marker (number).
      //
      marker: marker,
      // Total length of these series of delimiters.
      //
      length: scanned.length,
      // An amount of characters before this one that's equivalent to
      // current one. In plain English: if this delimiter does not open
      // an emphasis, neither do previous `jump` characters.
      //
      // Used to skip sequences like "*****" in one step, for 1st asterisk
      // value will be 0, for 2nd it's 1 and so on.
      //
      jump: i,
      // A position of the token this delimiter corresponds to.
      //
      token: state.tokens.length - 1,
      // Token level.
      //
      level: state.level,
      // If this delimiter is matched as a valid opener, `end` will be
      // equal to its position, otherwise it's `-1`.
      //
      end: -1,
      // Boolean flags that determine if this delimiter could open or close
      // an emphasis.
      //
      open: scanned.can_open,
      close: scanned.can_close
    });
  }

  state.pos += scanned.length;
  return true;
}; // Walk through delimiter list and replace text tokens with tags
//


module.exports.postProcess = function emphasis(state) {
  var i,
      startDelim,
      endDelim,
      token,
      ch,
      isStrong,
      delimiters = state.delimiters,
      max = state.delimiters.length;

  for (i = max - 1; i >= 0; i--) {
    startDelim = delimiters[i];

    if (startDelim.marker !== 0x5F
    /* _ */
    && startDelim.marker !== 0x2A
    /* * */
    ) {
        continue;
      } // Process only opening markers


    if (startDelim.end === -1) {
      continue;
    }

    endDelim = delimiters[startDelim.end]; // If the previous delimiter has the same marker and is adjacent to this one,
    // merge those into one strong delimiter.
    //
    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`
    //

    isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 && delimiters[i - 1].token === startDelim.token - 1 && delimiters[startDelim.end + 1].token === endDelim.token + 1 && delimiters[i - 1].marker === startDelim.marker;
    ch = String.fromCharCode(startDelim.marker);
    token = state.tokens[startDelim.token];
    token.type = isStrong ? 'strong_open' : 'em_open';
    token.tag = isStrong ? 'strong' : 'em';
    token.nesting = 1;
    token.markup = isStrong ? ch + ch : ch;
    token.content = '';
    token = state.tokens[endDelim.token];
    token.type = isStrong ? 'strong_close' : 'em_close';
    token.tag = isStrong ? 'strong' : 'em';
    token.nesting = -1;
    token.markup = isStrong ? ch + ch : ch;
    token.content = '';

    if (isStrong) {
      state.tokens[delimiters[i - 1].token].content = '';
      state.tokens[delimiters[startDelim.end + 1].token].content = '';
      i--;
    }
  }
};

/***/ }),
/* 70 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

function handleRetriesFor(code) {
  return new Promise(function run(ok, fail) {
    try {
      ok(code());
    } catch (err) {
      if (err.retry && err.retry instanceof Promise) {
        err.retry.then(function () {
          return run(ok, fail);
        }).catch(function (perr) {
          return fail(perr);
        });
      } else if (err.restart && err.restart.isCallback) {
        MathJax.Callback.After(function () {
          return run(ok, fail);
        }, err.restart);
      } else {
        fail(err);
      }
    }
  });
}

exports.handleRetriesFor = handleRetriesFor;

function retryAfter(promise) {
  var err = new Error('MathJax retry');
  err.retry = promise;
  throw err;
}

exports.retryAfter = retryAfter;

/***/ }),
/* 71 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Options_js_1 = __webpack_require__(10);

var FunctionList_js_1 = __webpack_require__(44);

var AbstractInputJax = function () {
  function AbstractInputJax(options) {
    if (options === void 0) {
      options = {};
    }

    this.adaptor = null;
    this.mmlFactory = null;
    var CLASS = this.constructor;
    this.options = Options_js_1.userOptions(Options_js_1.defaultOptions({}, CLASS.OPTIONS), options);
    this.preFilters = new FunctionList_js_1.FunctionList();
    this.postFilters = new FunctionList_js_1.FunctionList();
  }

  Object.defineProperty(AbstractInputJax.prototype, "name", {
    get: function () {
      return this.constructor.NAME;
    },
    enumerable: true,
    configurable: true
  });

  AbstractInputJax.prototype.setAdaptor = function (adaptor) {
    this.adaptor = adaptor;
  };

  AbstractInputJax.prototype.setMmlFactory = function (mmlFactory) {
    this.mmlFactory = mmlFactory;
  };

  AbstractInputJax.prototype.initialize = function () {};

  Object.defineProperty(AbstractInputJax.prototype, "processStrings", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  AbstractInputJax.prototype.findMath = function (node, options) {
    return [];
  };

  AbstractInputJax.prototype.executeFilters = function (filters, math, data) {
    var args = {
      math: math,
      data: data
    };
    filters.execute(args);
    return args.data;
  };

  return AbstractInputJax;
}();

AbstractInputJax.NAME = 'generic';
AbstractInputJax.OPTIONS = {};
exports.AbstractInputJax = AbstractInputJax;

/***/ }),
/* 72 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Entities = __webpack_require__(18);

Entities.add({
  NJcy: '\u040A',
  Nacute: '\u0143',
  Ncaron: '\u0147',
  Ncedil: '\u0145',
  Ncy: '\u041D',
  NegativeMediumSpace: '\u200B',
  NegativeThickSpace: '\u200B',
  NegativeThinSpace: '\u200B',
  NegativeVeryThinSpace: '\u200B',
  NewLine: '\u000A',
  NoBreak: '\u2060',
  NonBreakingSpace: '\u00A0',
  Not: '\u2AEC',
  NotCongruent: '\u2262',
  NotCupCap: '\u226D',
  NotEqualTilde: '\u2242\u0338',
  NotGreaterFullEqual: '\u2267\u0338',
  NotGreaterGreater: '\u226B\u0338',
  NotGreaterLess: '\u2279',
  NotGreaterSlantEqual: '\u2A7E\u0338',
  NotGreaterTilde: '\u2275',
  NotHumpDownHump: '\u224E\u0338',
  NotHumpEqual: '\u224F\u0338',
  NotLeftTriangleBar: '\u29CF\u0338',
  NotLessGreater: '\u2278',
  NotLessLess: '\u226A\u0338',
  NotLessSlantEqual: '\u2A7D\u0338',
  NotLessTilde: '\u2274',
  NotNestedGreaterGreater: '\u2AA2\u0338',
  NotNestedLessLess: '\u2AA1\u0338',
  NotPrecedesEqual: '\u2AAF\u0338',
  NotReverseElement: '\u220C',
  NotRightTriangleBar: '\u29D0\u0338',
  NotSquareSubset: '\u228F\u0338',
  NotSquareSubsetEqual: '\u22E2',
  NotSquareSuperset: '\u2290\u0338',
  NotSquareSupersetEqual: '\u22E3',
  NotSubset: '\u2282\u20D2',
  NotSucceedsEqual: '\u2AB0\u0338',
  NotSucceedsTilde: '\u227F\u0338',
  NotSuperset: '\u2283\u20D2',
  NotTildeEqual: '\u2244',
  NotTildeFullEqual: '\u2247',
  NotTildeTilde: '\u2249',
  Ntilde: '\u00D1',
  Nu: '\u039D',
  nGg: '\u22D9\u0338',
  nGt: '\u226B\u20D2',
  nGtv: '\u226B\u0338',
  nLl: '\u22D8\u0338',
  nLt: '\u226A\u20D2',
  nLtv: '\u226A\u0338',
  nabla: '\u2207',
  nacute: '\u0144',
  nang: '\u2220\u20D2',
  nap: '\u2249',
  napE: '\u2A70\u0338',
  napid: '\u224B\u0338',
  napos: '\u0149',
  napprox: '\u2249',
  natural: '\u266E',
  naturals: '\u2115',
  nbsp: '\u00A0',
  nbump: '\u224E\u0338',
  nbumpe: '\u224F\u0338',
  ncap: '\u2A43',
  ncaron: '\u0148',
  ncedil: '\u0146',
  ncong: '\u2247',
  ncongdot: '\u2A6D\u0338',
  ncup: '\u2A42',
  ncy: '\u043D',
  ndash: '\u2013',
  ne: '\u2260',
  neArr: '\u21D7',
  nearhk: '\u2924',
  nearrow: '\u2197',
  nedot: '\u2250\u0338',
  nequiv: '\u2262',
  nesear: '\u2928',
  nesim: '\u2242\u0338',
  nexist: '\u2204',
  nexists: '\u2204',
  ngE: '\u2267\u0338',
  nge: '\u2271',
  ngeq: '\u2271',
  ngeqq: '\u2267\u0338',
  ngeqslant: '\u2A7E\u0338',
  nges: '\u2A7E\u0338',
  ngsim: '\u2275',
  ngt: '\u226F',
  ngtr: '\u226F',
  nhArr: '\u21CE',
  nhpar: '\u2AF2',
  ni: '\u220B',
  nis: '\u22FC',
  nisd: '\u22FA',
  niv: '\u220B',
  njcy: '\u045A',
  nlArr: '\u21CD',
  nlE: '\u2266\u0338',
  nldr: '\u2025',
  nle: '\u2270',
  nleftarrow: '\u219A',
  nleftrightarrow: '\u21AE',
  nleq: '\u2270',
  nleqq: '\u2266\u0338',
  nleqslant: '\u2A7D\u0338',
  nles: '\u2A7D\u0338',
  nless: '\u226E',
  nlsim: '\u2274',
  nlt: '\u226E',
  nltri: '\u22EA',
  nltrie: '\u22EC',
  nmid: '\u2224',
  notin: '\u2209',
  notinE: '\u22F9\u0338',
  notindot: '\u22F5\u0338',
  notinva: '\u2209',
  notinvb: '\u22F7',
  notinvc: '\u22F6',
  notni: '\u220C',
  notniva: '\u220C',
  notnivb: '\u22FE',
  notnivc: '\u22FD',
  npar: '\u2226',
  nparallel: '\u2226',
  nparsl: '\u2AFD\u20E5',
  npart: '\u2202\u0338',
  npolint: '\u2A14',
  npr: '\u2280',
  nprcue: '\u22E0',
  npre: '\u2AAF\u0338',
  nprec: '\u2280',
  npreceq: '\u2AAF\u0338',
  nrArr: '\u21CF',
  nrarrc: '\u2933\u0338',
  nrarrw: '\u219D\u0338',
  nrightarrow: '\u219B',
  nrtri: '\u22EB',
  nrtrie: '\u22ED',
  nsc: '\u2281',
  nsccue: '\u22E1',
  nsce: '\u2AB0\u0338',
  nshortmid: '\u2224',
  nshortparallel: '\u2226',
  nsim: '\u2241',
  nsime: '\u2244',
  nsimeq: '\u2244',
  nsmid: '\u2224',
  nspar: '\u2226',
  nsqsube: '\u22E2',
  nsqsupe: '\u22E3',
  nsub: '\u2284',
  nsubE: '\u2AC5\u0338',
  nsube: '\u2288',
  nsubset: '\u2282\u20D2',
  nsubseteq: '\u2288',
  nsubseteqq: '\u2AC5\u0338',
  nsucc: '\u2281',
  nsucceq: '\u2AB0\u0338',
  nsup: '\u2285',
  nsupE: '\u2AC6\u0338',
  nsupe: '\u2289',
  nsupset: '\u2283\u20D2',
  nsupseteq: '\u2289',
  nsupseteqq: '\u2AC6\u0338',
  ntgl: '\u2279',
  ntilde: '\u00F1',
  ntlg: '\u2278',
  ntriangleleft: '\u22EA',
  ntrianglelefteq: '\u22EC',
  ntriangleright: '\u22EB',
  ntrianglerighteq: '\u22ED',
  num: '\u0023',
  numero: '\u2116',
  numsp: '\u2007',
  nvHarr: '\u2904',
  nvap: '\u224D\u20D2',
  nvge: '\u2265\u20D2',
  nvgt: '\u003E\u20D2',
  nvinfin: '\u29DE',
  nvlArr: '\u2902',
  nvle: '\u2264\u20D2',
  nvlt: '\u003C\u20D2',
  nvltrie: '\u22B4\u20D2',
  nvrArr: '\u2903',
  nvrtrie: '\u22B5\u20D2',
  nvsim: '\u223C\u20D2',
  nwArr: '\u21D6',
  nwarhk: '\u2923',
  nwarrow: '\u2196',
  nwnear: '\u2927'
}, 'n');

/***/ }),
/* 73 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Options_js_1 = __webpack_require__(10);

var FunctionList_js_1 = __webpack_require__(44);

var AbstractOutputJax = function () {
  function AbstractOutputJax(options) {
    if (options === void 0) {
      options = {};
    }

    this.adaptor = null;
    var CLASS = this.constructor;
    this.options = Options_js_1.userOptions(Options_js_1.defaultOptions({}, CLASS.OPTIONS), options);
    this.postFilters = new FunctionList_js_1.FunctionList();
  }

  Object.defineProperty(AbstractOutputJax.prototype, "name", {
    get: function () {
      return this.constructor.NAME;
    },
    enumerable: true,
    configurable: true
  });

  AbstractOutputJax.prototype.setAdaptor = function (adaptor) {
    this.adaptor = adaptor;
  };

  AbstractOutputJax.prototype.initialize = function () {};

  AbstractOutputJax.prototype.getMetrics = function (document) {};

  AbstractOutputJax.prototype.styleSheet = function (document) {
    return null;
  };

  AbstractOutputJax.prototype.pageElements = function (document) {
    return null;
  };

  AbstractOutputJax.prototype.executeFilters = function (filters, math, data) {
    var args = {
      math: math,
      data: data
    };
    filters.execute(args);
    return args.data;
  };

  return AbstractOutputJax;
}();

AbstractOutputJax.NAME = 'generic';
AbstractOutputJax.OPTIONS = {};
exports.AbstractOutputJax = AbstractOutputJax;

/***/ }),
/* 74 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});
var TRBL = ['top', 'right', 'bottom', 'left'];
var WSC = ['width', 'style', 'color'];

function splitSpaces(text) {
  var parts = text.split(/((?:'[^']*'|"[^"]*"|,[\s\n]|[^\s\n])*)/g);
  var split = [];

  while (parts.length > 1) {
    parts.shift();
    split.push(parts.shift());
  }

  return split;
}

function splitTRBL(name) {
  var parts = splitSpaces(this.styles[name]);

  if (parts.length === 0) {
    parts.push('');
  }

  if (parts.length === 1) {
    parts.push(parts[0]);
  }

  if (parts.length === 2) {
    parts.push(parts[0]);
  }

  if (parts.length === 3) {
    parts.push(parts[1]);
  }

  try {
    for (var _a = __values(Styles.connect[name].children), _b = _a.next(); !_b.done; _b = _a.next()) {
      var child = _b.value;
      this.setStyle(this.childName(name, child), parts.shift());
    }
  } catch (e_1_1) {
    e_1 = {
      error: e_1_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_1) throw e_1.error;
    }
  }

  var e_1, _c;
}

function combineTRBL(name) {
  var children = Styles.connect[name].children;
  var parts = [];

  try {
    for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
      var child = children_1_1.value;
      var part = this.styles[name + '-' + child];

      if (!part) {
        delete this.styles[name];
        return;
      }

      parts.push(part);
    }
  } catch (e_2_1) {
    e_2 = {
      error: e_2_1
    };
  } finally {
    try {
      if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
    } finally {
      if (e_2) throw e_2.error;
    }
  }

  if (parts[3] === parts[1]) {
    parts.pop();

    if (parts[2] === parts[0]) {
      parts.pop();

      if (parts[1] === parts[0]) {
        parts.pop();
      }
    }
  }

  this.styles[name] = parts.join(' ');

  var e_2, _a;
}

function splitSame(name) {
  try {
    for (var _a = __values(Styles.connect[name].children), _b = _a.next(); !_b.done; _b = _a.next()) {
      var child = _b.value;
      this.setStyle(this.childName(name, child), this.styles[name]);
    }
  } catch (e_3_1) {
    e_3 = {
      error: e_3_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_3) throw e_3.error;
    }
  }

  var e_3, _c;
}

function combineSame(name) {
  var children = __spread(Styles.connect[name].children);

  var value = this.styles[this.childName(name, children.shift())];

  try {
    for (var children_2 = __values(children), children_2_1 = children_2.next(); !children_2_1.done; children_2_1 = children_2.next()) {
      var child = children_2_1.value;

      if (this.styles[this.childName(name, child)] !== value) {
        delete this.styles[name];
        return;
      }
    }
  } catch (e_4_1) {
    e_4 = {
      error: e_4_1
    };
  } finally {
    try {
      if (children_2_1 && !children_2_1.done && (_a = children_2.return)) _a.call(children_2);
    } finally {
      if (e_4) throw e_4.error;
    }
  }

  this.styles[name] = value;

  var e_4, _a;
}

var BORDER = {
  width: /^(?:[\d.]+(?:[a-z]+)|thin|medium|thick|inherit|initial|unset)$/,
  style: /^(?:none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset|inherit|initial|unset)$/
};

function splitWSC(name) {
  var parts = {
    width: '',
    style: '',
    color: ''
  };

  try {
    for (var _a = __values(splitSpaces(this.styles[name])), _b = _a.next(); !_b.done; _b = _a.next()) {
      var part = _b.value;

      if (part.match(BORDER.width) && parts.width === '') {
        parts.width = part;
      } else if (part.match(BORDER.style) && parts.style === '') {
        parts.style = part;
      } else {
        parts.color = part;
      }
    }
  } catch (e_5_1) {
    e_5 = {
      error: e_5_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_5) throw e_5.error;
    }
  }

  try {
    for (var _d = __values(Styles.connect[name].children), _e = _d.next(); !_e.done; _e = _d.next()) {
      var child = _e.value;
      this.setStyle(this.childName(name, child), parts[child]);
    }
  } catch (e_6_1) {
    e_6 = {
      error: e_6_1
    };
  } finally {
    try {
      if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
    } finally {
      if (e_6) throw e_6.error;
    }
  }

  var e_5, _c, e_6, _f;
}

function combineWSC(name) {
  var parts = [];

  try {
    for (var _a = __values(Styles.connect[name].children), _b = _a.next(); !_b.done; _b = _a.next()) {
      var child = _b.value;
      var value = this.styles[this.childName(name, child)];

      if (value) {
        parts.push(value);
      }
    }
  } catch (e_7_1) {
    e_7 = {
      error: e_7_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_7) throw e_7.error;
    }
  }

  if (parts.length) {
    this.styles[name] = parts.join(' ');
  } else {
    delete this.styles[name];
  }

  var e_7, _c;
}

var FONT = {
  style: /^(?:normal|italic|oblique|inherit|initial|unset)$/,
  variant: new RegExp('^(?:' + ['normal|none', 'inherit|initial|unset', 'common-ligatures|no-common-ligatures', 'discretionary-ligatures|no-discretionary-ligatures', 'historical-ligatures|no-historical-ligatures', 'contextual|no-contextual', '(?:stylistic|character-variant|swash|ornaments|annotation)\\([^)]*\\)', 'small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps', 'lining-nums|oldstyle-nums|proportional-nums|tabular-nums', 'diagonal-fractions|stacked-fractions', 'ordinal|slashed-zero', 'jis78|jis83|jis90|jis04|simplified|traditional', 'full-width|proportional-width', 'ruby'].join('|') + ')$'),
  weight: /^(?:normal|bold|bolder|lighter|[1-9]00|inherit|initial|unset)$/,
  stretch: new RegExp('^(?:' + ['normal', '(?:(?:ultra|extra|semi)-)?condensed', '(?:(?:semi|extra|ulta)-)?expanded', 'inherit|initial|unset'].join('|') + ')$'),
  size: new RegExp('^(?:' + ['xx-small|x-small|small|medium|large|x-large|xx-large|larger|smaller', '[\d.]+%|[\d.]+[a-z]+', 'inherit|initial|unset'].join('|') + ')' + '(?:\/(?:normal|[\d.\+](?:%|[a-z]+)?))?$')
};

function splitFont(name) {
  var parts = splitSpaces(this.styles[name]);
  var value = {
    style: '',
    variant: [],
    weight: '',
    stretch: '',
    size: '',
    family: '',
    'line-height': ''
  };

  try {
    for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
      var part = parts_1_1.value;
      value.family = part;

      try {
        for (var _a = __values(Object.keys(FONT)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var name_1 = _b.value;

          if ((Array.isArray(value[name_1]) || value[name_1] === '') && part.match(FONT[name_1])) {
            if (name_1 === 'size') {
              var _c = __read(part.split(/\//), 2),
                  size = _c[0],
                  height = _c[1];

              value[name_1] = size;

              if (height) {
                value['line-height'] = height;
              }
            } else if (value.size === '') {
              if (Array.isArray(value[name_1])) {
                value[name_1].push(part);
              } else {
                value[name_1] = part;
              }
            }
          }
        }
      } catch (e_8_1) {
        e_8 = {
          error: e_8_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
        } finally {
          if (e_8) throw e_8.error;
        }
      }
    }
  } catch (e_9_1) {
    e_9 = {
      error: e_9_1
    };
  } finally {
    try {
      if (parts_1_1 && !parts_1_1.done && (_e = parts_1.return)) _e.call(parts_1);
    } finally {
      if (e_9) throw e_9.error;
    }
  }

  saveFontParts(name, value);
  delete this.styles[name];

  var e_9, _e, e_8, _d;
}

function saveFontParts(name, value) {
  try {
    for (var _a = __values(Styles.connect[name].children), _b = _a.next(); !_b.done; _b = _a.next()) {
      var child = _b.value;
      var cname = this.childName(name, child);

      if (Array.isArray(value[child])) {
        var values = value[child];

        if (values.length) {
          this.styles[cname] = values.join(' ');
        }
      } else if (value[child] !== '') {
        this.styles[cname] = value[child];
      }
    }
  } catch (e_10_1) {
    e_10 = {
      error: e_10_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_10) throw e_10.error;
    }
  }

  var e_10, _c;
}

function combineFont(name) {}

var Styles = function () {
  function Styles(cssText) {
    if (cssText === void 0) {
      cssText = '';
    }

    this.parse(cssText);
  }

  Object.defineProperty(Styles.prototype, "cssText", {
    get: function () {
      var styles = [];

      try {
        for (var _a = __values(Object.keys(this.styles)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var name_2 = _b.value;
          var parent_1 = this.parentName(name_2);

          if (!this.styles[parent_1]) {
            styles.push(name_2 + ': ' + this.styles[name_2]);
          }
        }
      } catch (e_11_1) {
        e_11 = {
          error: e_11_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_11) throw e_11.error;
        }
      }

      return styles.join('; ');

      var e_11, _c;
    },
    enumerable: true,
    configurable: true
  });

  Styles.prototype.set = function (name, value) {
    name = this.normalizeName(name);
    this.setStyle(name, value);

    if (Styles.connect[name] && !Styles.connect[name].combine) {
      this.combineChildren(name);
      delete this.styles[name];
    }

    while (name.match(/-/)) {
      name = this.parentName(name);
      if (!Styles.connect[name]) break;
      Styles.connect[name].combine.call(this, name);
    }
  };

  Styles.prototype.get = function (name) {
    name = this.normalizeName(name);
    return this.styles.hasOwnProperty(name) ? this.styles[name] : '';
  };

  Styles.prototype.setStyle = function (name, value) {
    this.styles[name] = value;

    if (Styles.connect[name] && Styles.connect[name].children) {
      Styles.connect[name].split.call(this, name);
    }

    if (value === '') {
      delete this.styles[name];
    }
  };

  Styles.prototype.combineChildren = function (name) {
    var parent = this.parentName(name);

    try {
      for (var _a = __values(Styles.connect[name].children), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        var cname = this.childName(parent, child);
        Styles.connect[cname].combine.call(this, cname);
      }
    } catch (e_12_1) {
      e_12 = {
        error: e_12_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_12) throw e_12.error;
      }
    }

    var e_12, _c;
  };

  Styles.prototype.parentName = function (name) {
    var parent = name.replace(/-[^-]*$/, '');
    return name === parent ? '' : parent;
  };

  Styles.prototype.childName = function (name, child) {
    if (child.match(/-/)) {
      return child;
    }

    if (Styles.connect[name] && !Styles.connect[name].combine) {
      child += name.replace(/.*-/, '-');
      name = this.parentName(name);
    }

    return name + '-' + child;
  };

  Styles.prototype.normalizeName = function (name) {
    return name.replace(/[A-Z]/g, function (c) {
      return '-' + c.toLowerCase();
    });
  };

  Styles.prototype.parse = function (cssText) {
    if (cssText === void 0) {
      cssText = '';
    }

    var PATTERN = this.constructor.pattern;
    this.styles = {};
    var parts = cssText.replace(PATTERN.comment, '').split(PATTERN.style);

    while (parts.length > 1) {
      var _a = __read(parts.splice(0, 3), 3),
          space = _a[0],
          name_3 = _a[1],
          value = _a[2];

      if (space.match(/[^\s\n]/)) return;
      this.set(name_3, value);
    }
  };

  return Styles;
}();

Styles.pattern = {
  style: /([-a-z]+)[\s\n]*:[\s\n]*((?:'[^']*'|"[^"]*"|\n|.)*?)[\s\n]*(?:;|$)/g,
  comment: /\/\*[^]*?\*\//g
};
Styles.connect = {
  padding: {
    children: TRBL,
    split: splitTRBL,
    combine: combineTRBL
  },
  border: {
    children: TRBL,
    split: splitSame,
    combine: combineSame
  },
  'border-top': {
    children: WSC,
    split: splitWSC,
    combine: combineWSC
  },
  'border-right': {
    children: WSC,
    split: splitWSC,
    combine: combineWSC
  },
  'border-bottom': {
    children: WSC,
    split: splitWSC,
    combine: combineWSC
  },
  'border-left': {
    children: WSC,
    split: splitWSC,
    combine: combineWSC
  },
  'border-width': {
    children: TRBL,
    split: splitTRBL,
    combine: null
  },
  'border-style': {
    children: TRBL,
    split: splitTRBL,
    combine: null
  },
  'border-color': {
    children: TRBL,
    split: splitTRBL,
    combine: null
  },
  font: {
    children: ['style', 'variant', 'weight', 'stretch', 'line-height', 'size', 'family'],
    split: splitFont,
    combine: combineFont
  }
};
exports.Styles = Styles;

/***/ }),
/* 75 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var BBox_js_1 = __webpack_require__(23);

exports.BBox = BBox_js_1.BBox;
exports.BBoxStyleAdjust = BBox_js_1.BBoxStyleAdjust;

/***/ }),
/* 76 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMath = function (_super) {
  __extends(MmlMath, _super);

  function MmlMath() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMath.prototype, "kind", {
    get: function () {
      return 'math';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMath.prototype, "linebreakContainer", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMath.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    if (this.attributes.get('mode') === 'display') {
      this.attributes.setInherited('display', 'block');
    }

    attributes = this.addInheritedAttributes(attributes, this.attributes.getAllAttributes());
    display = !!this.attributes.get('displaystyle') || !this.attributes.get('displaystyle') && this.attributes.get('display') === 'block';
    this.attributes.setInherited('displaystyle', display);
    level = this.attributes.get('scriptlevel') || this.constructor.defaults['scriptlevel'];

    _super.prototype.setChildInheritedAttributes.call(this, attributes, display, level, prime);
  };

  return MmlMath;
}(MmlNode_js_1.AbstractMmlLayoutNode);

MmlMath.defaults = __assign({}, MmlNode_js_1.AbstractMmlLayoutNode.defaults, {
  mathvariant: 'normal',
  mathsize: 'normal',
  mathcolor: '',
  mathbackground: 'transparent',
  dir: 'ltr',
  scriptlevel: 0,
  displaystyle: false,
  display: 'inline',
  maxwidth: '',
  overflow: 'linebreak',
  altimg: '',
  'altimg-width': '',
  'altimg-height': '',
  'altimg-valign': '',
  alttext: '',
  cdgroup: '',
  scriptsizemultiplier: 1 / Math.sqrt(2),
  scriptminsize: '8px',
  infixlinebreakstyle: 'before',
  lineleading: '1ex',
  linebreakmultchar: '\u2062',
  indentshift: 'auto',
  indentalign: 'auto',
  indenttarget: '',
  indentalignfirst: 'indentalign',
  indentshiftfirst: 'indentshift',
  indentalignlast: 'indentalign',
  indentshiftlast: 'indentshift'
});
exports.MmlMath = MmlMath;

/***/ }),
/* 77 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMi = function (_super) {
  __extends(MmlMi, _super);

  function MmlMi() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMi.prototype, "kind", {
    get: function () {
      return 'mi';
    },
    enumerable: true,
    configurable: true
  });

  MmlMi.prototype.setInheritedAttributes = function (attributes, display, level, prime) {
    if (attributes === void 0) {
      attributes = {};
    }

    if (display === void 0) {
      display = false;
    }

    if (level === void 0) {
      level = 0;
    }

    if (prime === void 0) {
      prime = false;
    }

    _super.prototype.setInheritedAttributes.call(this, attributes, display, level, prime);

    var text = this.getText();

    if (text.match(MmlMi.singleCharacter) && !attributes.mathvariant) {
      this.attributes.setInherited('mathvariant', 'italic');
    }
  };

  MmlMi.prototype.setTeXclass = function (prev) {
    this.getPrevClass(prev);
    var name = this.getText();

    if (name.length > 1 && name.match(MmlMi.operatorName) && this.texClass === MmlNode_js_1.TEXCLASS.ORD) {
      this.texClass = MmlNode_js_1.TEXCLASS.OP;
      this.setProperty('autoOP', true);
    }

    return this;
  };

  return MmlMi;
}(MmlNode_js_1.AbstractMmlTokenNode);

MmlMi.defaults = __assign({}, MmlNode_js_1.AbstractMmlTokenNode.defaults);
MmlMi.operatorName = /^[a-z][a-z0-9]*$/i;
MmlMi.singleCharacter = /^[\uD800-\uDBFF]?.$/;
exports.MmlMi = MmlMi;

/***/ }),
/* 78 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMn = function (_super) {
  __extends(MmlMn, _super);

  function MmlMn() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMn.prototype, "kind", {
    get: function () {
      return 'mn';
    },
    enumerable: true,
    configurable: true
  });
  return MmlMn;
}(MmlNode_js_1.AbstractMmlTokenNode);

MmlMn.defaults = __assign({}, MmlNode_js_1.AbstractMmlTokenNode.defaults);
exports.MmlMn = MmlMn;

/***/ }),
/* 79 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMs = function (_super) {
  __extends(MmlMs, _super);

  function MmlMs() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMs.prototype, "kind", {
    get: function () {
      return 'ms';
    },
    enumerable: true,
    configurable: true
  });
  return MmlMs;
}(MmlNode_js_1.AbstractMmlTokenNode);

MmlMs.defaults = __assign({}, MmlNode_js_1.AbstractMmlTokenNode.defaults, {
  lquote: '"',
  rquote: '"'
});
exports.MmlMs = MmlMs;

/***/ }),
/* 80 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMspace = function (_super) {
  __extends(MmlMspace, _super);

  function MmlMspace() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMspace.prototype, "kind", {
    get: function () {
      return 'mspace';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMspace.prototype, "arity", {
    get: function () {
      return 0;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMspace.prototype, "isSpacelike", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMspace.prototype, "hasNewline", {
    get: function () {
      var attributes = this.attributes;
      return attributes.getExplicit('width') == null && attributes.getExplicit('height') == null && attributes.getExplicit('depth') == null && attributes.get('linebreak') === 'newline';
    },
    enumerable: true,
    configurable: true
  });
  return MmlMspace;
}(MmlNode_js_1.AbstractMmlTokenNode);

MmlMspace.defaults = __assign({}, MmlNode_js_1.AbstractMmlTokenNode.defaults, {
  width: '0em',
  height: '0ex',
  depth: '0ex',
  linebreak: 'auto'
});
exports.MmlMspace = MmlMspace;

/***/ }),
/* 81 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMpadded = function (_super) {
  __extends(MmlMpadded, _super);

  function MmlMpadded() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMpadded.prototype, "kind", {
    get: function () {
      return 'mpadded';
    },
    enumerable: true,
    configurable: true
  });
  return MmlMpadded;
}(MmlNode_js_1.AbstractMmlLayoutNode);

MmlMpadded.defaults = __assign({}, MmlNode_js_1.AbstractMmlLayoutNode.defaults, {
  width: '',
  height: '',
  depth: '',
  lspace: 0,
  voffset: 0
});
exports.MmlMpadded = MmlMpadded;

/***/ }),
/* 82 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMenclose = function (_super) {
  __extends(MmlMenclose, _super);

  function MmlMenclose() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMenclose.prototype, "kind", {
    get: function () {
      return 'menclose';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMenclose.prototype, "arity", {
    get: function () {
      return -1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMenclose.prototype, "linebreakContininer", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMenclose.prototype.setTeXclass = function (prev) {
    prev = this.childNodes[0].setTeXclass(prev);
    this.updateTeXclass(this.childNodes[0]);
    return prev;
  };

  return MmlMenclose;
}(MmlNode_js_1.AbstractMmlNode);

MmlMenclose.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults, {
  notation: 'longdiv'
});
exports.MmlMenclose = MmlMenclose;

/***/ }),
/* 83 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var BBox_js_1 = __webpack_require__(23);

function CommonMrowMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.stretchChildren();

      try {
        for (var _a = __values(_this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;

          if (child.bbox.pwidth) {
            _this.bbox.pwidth = BBox_js_1.BBox.fullWidth;
            break;
          }
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      return _this;

      var e_1, _c;
    }

    Object.defineProperty(class_1.prototype, "fixesPWidth", {
      get: function () {
        return false;
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.stretchChildren = function () {
      var stretchy = [];

      try {
        for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;

          if (child.canStretch(1)) {
            stretchy.push(child);
          }
        }
      } catch (e_2_1) {
        e_2 = {
          error: e_2_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_2) throw e_2.error;
        }
      }

      var count = stretchy.length;
      var nodeCount = this.childNodes.length;

      if (count && nodeCount > 1) {
        var H = 0,
            D = 0;
        var all = count > 1 && count === nodeCount;

        try {
          for (var _d = __values(this.childNodes), _e = _d.next(); !_e.done; _e = _d.next()) {
            var child = _e.value;
            var noStretch = child.stretch.dir === 0;

            if (all || noStretch) {
              var _f = child.getBBox(noStretch),
                  h = _f.h,
                  d = _f.d;

              if (h > H) H = h;
              if (d > D) D = d;
            }
          }
        } catch (e_3_1) {
          e_3 = {
            error: e_3_1
          };
        } finally {
          try {
            if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
          } finally {
            if (e_3) throw e_3.error;
          }
        }

        try {
          for (var stretchy_1 = __values(stretchy), stretchy_1_1 = stretchy_1.next(); !stretchy_1_1.done; stretchy_1_1 = stretchy_1.next()) {
            var child = stretchy_1_1.value;
            child.coreMO().getStretchedVariant([H, D]);
          }
        } catch (e_4_1) {
          e_4 = {
            error: e_4_1
          };
        } finally {
          try {
            if (stretchy_1_1 && !stretchy_1_1.done && (_h = stretchy_1.return)) _h.call(stretchy_1);
          } finally {
            if (e_4) throw e_4.error;
          }
        }
      }

      var e_2, _c, e_3, _g, e_4, _h;
    };

    return class_1;
  }(Base);
}

exports.CommonMrowMixin = CommonMrowMixin;

function CommonInferredMrowMixin(Base) {
  return function (_super) {
    __extends(class_2, _super);

    function class_2() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    class_2.prototype.getScale = function () {
      this.bbox.scale = this.parent.bbox.scale;
      this.bbox.rscale = 1;
    };

    return class_2;
  }(Base);
}

exports.CommonInferredMrowMixin = CommonInferredMrowMixin;

/***/ }),
/* 84 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMrow = function (_super) {
  __extends(MmlMrow, _super);

  function MmlMrow() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this._core = null;
    return _this;
  }

  Object.defineProperty(MmlMrow.prototype, "kind", {
    get: function () {
      return 'mrow';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMrow.prototype, "isSpacelike", {
    get: function () {
      try {
        for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;

          if (!child.isSpacelike) {
            return false;
          }
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      return true;

      var e_1, _c;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMrow.prototype, "isEmbellished", {
    get: function () {
      var embellished = false;
      var i = 0;

      try {
        for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;

          if (child) {
            if (child.isEmbellished) {
              if (embellished) {
                return false;
              }

              embellished = true;
              this._core = i;
            } else if (!child.isSpacelike) {
              return false;
            }
          }
        }
      } catch (e_2_1) {
        e_2 = {
          error: e_2_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_2) throw e_2.error;
        }
      }

      return embellished;

      var e_2, _c;
    },
    enumerable: true,
    configurable: true
  });

  MmlMrow.prototype.core = function () {
    if (!this.isEmbellished || this._core == null) {
      return this;
    }

    return this.childNodes[this._core];
  };

  MmlMrow.prototype.coreMO = function () {
    if (!this.isEmbellished || this._core == null) {
      return this;
    }

    return this.childNodes[this._core].coreMO();
  };

  MmlMrow.prototype.nonSpaceLength = function () {
    var n = 0;

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (child && !child.isSpacelike) {
          n++;
        }
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    return n;

    var e_3, _c;
  };

  MmlMrow.prototype.firstNonSpace = function () {
    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (child && !child.isSpacelike) {
          return child;
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    return null;

    var e_4, _c;
  };

  MmlMrow.prototype.lastNonSpace = function () {
    var i = this.childNodes.length;

    while (--i >= 0) {
      var child = this.childNodes[i];

      if (child && !child.isSpacelike) {
        return child;
      }
    }

    return null;
  };

  MmlMrow.prototype.setTeXclass = function (prev) {
    if ((this.getProperty('open') != null || this.getProperty('close') != null) && (!prev || prev.getProperty('fnOp') != null)) {
      this.getPrevClass(prev);
      prev = null;

      try {
        for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;
          prev = child.setTeXclass(prev);
        }
      } catch (e_5_1) {
        e_5 = {
          error: e_5_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_5) throw e_5.error;
        }
      }

      if (this.texClass == null) {
        this.texClass = MmlNode_js_1.TEXCLASS.INNER;
      }
    } else {
      try {
        for (var _d = __values(this.childNodes), _e = _d.next(); !_e.done; _e = _d.next()) {
          var child = _e.value;
          prev = child.setTeXclass(prev);
        }
      } catch (e_6_1) {
        e_6 = {
          error: e_6_1
        };
      } finally {
        try {
          if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
        } finally {
          if (e_6) throw e_6.error;
        }
      }

      if (this.childNodes[0]) {
        this.updateTeXclass(this.childNodes[0]);
      }
    }

    return prev;

    var e_5, _c, e_6, _f;
  };

  return MmlMrow;
}(MmlNode_js_1.AbstractMmlNode);

MmlMrow.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults);
exports.MmlMrow = MmlMrow;

var MmlInferredMrow = function (_super) {
  __extends(MmlInferredMrow, _super);

  function MmlInferredMrow() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlInferredMrow.prototype, "kind", {
    get: function () {
      return 'inferredMrow';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlInferredMrow.prototype, "isInferred", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlInferredMrow.prototype, "notParent", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlInferredMrow.prototype.toString = function () {
    return '[' + this.childNodes.join(',') + ']';
  };

  return MmlInferredMrow;
}(MmlMrow);

MmlInferredMrow.defaults = MmlMrow.defaults;
exports.MmlInferredMrow = MmlInferredMrow;

/***/ }),
/* 85 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMfenced = function (_super) {
  __extends(MmlMfenced, _super);

  function MmlMfenced() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.INNER;
    _this.separators = [];
    _this.open = null;
    _this.close = null;
    return _this;
  }

  Object.defineProperty(MmlMfenced.prototype, "kind", {
    get: function () {
      return 'mfenced';
    },
    enumerable: true,
    configurable: true
  });

  MmlMfenced.prototype.setTeXclass = function (prev) {
    this.getPrevClass(prev);

    if (this.open) {
      prev = this.open.setTeXclass(prev);
    }

    if (this.childNodes[0]) {
      prev = this.childNodes[0].setTeXclass(prev);
    }

    for (var i = 1, m = this.childNodes.length; i < m; i++) {
      if (this.separators[i - 1]) {
        prev = this.separators[i - 1].setTeXclass(prev);
      }

      if (this.childNodes[i]) {
        prev = this.childNodes[i].setTeXclass(prev);
      }
    }

    if (this.close) {
      prev = this.close.setTeXclass(prev);
    }

    this.updateTeXclass(this.open);
    return prev;
  };

  MmlMfenced.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    this.addFakeNodes();

    try {
      for (var _a = __values([this.open, this.close].concat(this.separators)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (child) {
          child.setInheritedAttributes(attributes, display, level, prime);
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    _super.prototype.setChildInheritedAttributes.call(this, attributes, display, level, prime);

    var e_1, _c;
  };

  MmlMfenced.prototype.addFakeNodes = function () {
    var _a = this.attributes.getList('open', 'close', 'separators'),
        open = _a.open,
        close = _a.close,
        separators = _a.separators;

    open = open.replace(/[ \t\n\r]/g, '');
    close = close.replace(/[ \t\n\r]/g, '');
    separators = separators.replace(/[ \t\n\r]/g, '');

    if (open) {
      this.open = this.fakeNode(open, {
        fence: true,
        form: 'prefix'
      }, MmlNode_js_1.TEXCLASS.OPEN);
    }

    if (separators) {
      while (separators.length < this.childNodes.length - 1) {
        separators += separators.charAt(separators.length - 1);
      }

      var i = 0;

      try {
        for (var _b = __values(this.childNodes.slice(1)), _c = _b.next(); !_c.done; _c = _b.next()) {
          var child = _c.value;

          if (child) {
            this.separators.push(this.fakeNode(separators.charAt(i++)));
          }
        }
      } catch (e_2_1) {
        e_2 = {
          error: e_2_1
        };
      } finally {
        try {
          if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
        } finally {
          if (e_2) throw e_2.error;
        }
      }
    }

    if (close) {
      this.close = this.fakeNode(close, {
        fence: true,
        form: 'postfix'
      }, MmlNode_js_1.TEXCLASS.CLOSE);
    }

    var e_2, _d;
  };

  MmlMfenced.prototype.fakeNode = function (c, properties, texClass) {
    if (properties === void 0) {
      properties = {};
    }

    if (texClass === void 0) {
      texClass = null;
    }

    var text = this.factory.create('text').setText(c);
    var node = this.factory.create('mo', properties, [text]);
    node.texClass = texClass;
    node.parent = this;
    return node;
  };

  return MmlMfenced;
}(MmlNode_js_1.AbstractMmlNode);

MmlMfenced.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults, {
  open: '(',
  close: ')',
  separators: ','
});
exports.MmlMfenced = MmlMfenced;

/***/ }),
/* 86 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMfrac = function (_super) {
  __extends(MmlMfrac, _super);

  function MmlMfrac() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMfrac.prototype, "kind", {
    get: function () {
      return 'mfrac';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMfrac.prototype, "arity", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMfrac.prototype, "linebreakContainer", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMfrac.prototype.setTeXclass = function (prev) {
    this.getPrevClass(prev);

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        child.setTeXclass(null);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    if (this.isEmbellished) {
      this.updateTeXclass(this.core());
    }

    return this;

    var e_1, _c;
  };

  MmlMfrac.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    if (!display || level > 0) {
      level++;
    }

    this.childNodes[0].setInheritedAttributes(attributes, false, level, prime);
    this.childNodes[1].setInheritedAttributes(attributes, false, level, true);
  };

  return MmlMfrac;
}(MmlNode_js_1.AbstractMmlBaseNode);

MmlMfrac.defaults = __assign({}, MmlNode_js_1.AbstractMmlBaseNode.defaults, {
  linethickness: 'medium',
  numalign: 'center',
  denomalign: 'center',
  bevelled: false
});
exports.MmlMfrac = MmlMfrac;

/***/ }),
/* 87 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var msqrt_js_1 = __webpack_require__(273);

var msqrt_js_2 = __webpack_require__(88);

var CHTMLmsqrt = function (_super) {
  __extends(CHTMLmsqrt, _super);

  function CHTMLmsqrt() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmsqrt.prototype.toCHTML = function (parent) {
    var surd = this.childNodes[this.surd];
    var base = this.childNodes[this.base];
    var sbox = surd.getBBox();
    var bbox = base.getBBox();

    var _a = __read(this.getPQ(sbox), 2),
        p = _a[0],
        q = _a[1];

    var CHTML = this.standardCHTMLnode(parent);
    var SURD, BASE, ROOT, root;

    if (this.root != null) {
      ROOT = this.adaptor.append(CHTML, this.html('mjx-root'));
      root = this.childNodes[this.root];
    }

    var SQRT = this.adaptor.append(CHTML, this.html('mjx-sqrt', {}, [SURD = this.html('mjx-surd'), BASE = this.html('mjx-box', {
      style: {
        paddingTop: this.em(q)
      }
    })]));
    this.addRoot(ROOT, root, sbox);
    surd.toCHTML(SURD);
    base.toCHTML(BASE);

    if (surd.size < 0) {
      this.adaptor.addClass(SQRT, 'mjx-tall');
    }
  };

  CHTMLmsqrt.prototype.addRoot = function (ROOT, root, sbox) {};

  return CHTMLmsqrt;
}(msqrt_js_1.CommonMsqrtMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmsqrt.kind = msqrt_js_2.MmlMsqrt.prototype.kind;
CHTMLmsqrt.styles = {
  'mjx-root': {
    display: 'inline-block',
    'white-space': 'nowrap'
  },
  'mjx-surd': {
    display: 'inline-block',
    'vertical-align': 'top'
  },
  'mjx-sqrt': {
    display: 'inline-block',
    'padding-top': '.07em'
  },
  'mjx-sqrt > mjx-box': {
    'border-top': '.07em solid'
  },
  'mjx-sqrt.mjx-tall > mjx-box': {
    'padding-left': '.3em',
    'margin-left': '-.3em'
  }
};
exports.CHTMLmsqrt = CHTMLmsqrt;

/***/ }),
/* 88 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMsqrt = function (_super) {
  __extends(MmlMsqrt, _super);

  function MmlMsqrt() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMsqrt.prototype, "kind", {
    get: function () {
      return 'msqrt';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsqrt.prototype, "arity", {
    get: function () {
      return -1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMsqrt.prototype, "linebreakContainer", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMsqrt.prototype.setTeXclass = function (prev) {
    this.getPrevClass(prev);
    this.childNodes[0].setTeXclass(null);
    return this;
  };

  MmlMsqrt.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    this.childNodes[0].setInheritedAttributes(attributes, display, level, true);
  };

  return MmlMsqrt;
}(MmlNode_js_1.AbstractMmlNode);

MmlMsqrt.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults);
exports.MmlMsqrt = MmlMsqrt;

/***/ }),
/* 89 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMroot = function (_super) {
  __extends(MmlMroot, _super);

  function MmlMroot() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMroot.prototype, "kind", {
    get: function () {
      return 'mroot';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMroot.prototype, "arity", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });

  MmlMroot.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    this.childNodes[0].setInheritedAttributes(attributes, display, level, true);
    this.childNodes[1].setInheritedAttributes(attributes, false, level + 2, prime);
  };

  return MmlMroot;
}(MmlNode_js_1.AbstractMmlNode);

MmlMroot.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults);
exports.MmlMroot = MmlMroot;

/***/ }),
/* 90 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMunderover = function (_super) {
  __extends(MmlMunderover, _super);

  function MmlMunderover() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMunderover.prototype, "kind", {
    get: function () {
      return 'munderover';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMunderover.prototype, "arity", {
    get: function () {
      return 3;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMunderover.prototype, "base", {
    get: function () {
      return 0;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMunderover.prototype, "under", {
    get: function () {
      return 1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMunderover.prototype, "over", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMunderover.prototype, "linebreakContainer", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMunderover.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    var nodes = this.childNodes;
    nodes[0].setInheritedAttributes(attributes, display, level, prime || !!nodes[this.over]);
    var force = !!(!display && nodes[0].coreMO().attributes.get('movablelimits'));
    var ACCENTS = this.constructor.ACCENTS;
    nodes[1].setInheritedAttributes(attributes, false, this.getScriptlevel(ACCENTS[1], force, level), prime || this.under === 1);
    this.setInheritedAccent(1, ACCENTS[1], display, level, prime, force);

    if (!nodes[2]) {
      return;
    }

    nodes[2].setInheritedAttributes(attributes, false, this.getScriptlevel(ACCENTS[2], force, level), prime || this.under === 2);
    this.setInheritedAccent(2, ACCENTS[2], display, level, prime, force);
  };

  MmlMunderover.prototype.getScriptlevel = function (accent, force, level) {
    if (force || !this.attributes.get(accent)) {
      level++;
    }

    return level;
  };

  MmlMunderover.prototype.setInheritedAccent = function (n, accent, display, level, prime, force) {
    var node = this.childNodes[n];

    if (this.attributes.getExplicit(accent) == null && node.isEmbellished) {
      var value = node.coreMO().attributes.get('accent');
      this.attributes.setInherited(accent, value);

      if (value !== this.attributes.getDefault(accent)) {
        node.setInheritedAttributes({}, display, this.getScriptlevel(accent, force, level), prime);
      }
    }
  };

  return MmlMunderover;
}(MmlNode_js_1.AbstractMmlBaseNode);

MmlMunderover.defaults = __assign({}, MmlNode_js_1.AbstractMmlBaseNode.defaults, {
  accent: false,
  accentunder: false,
  align: 'center'
});
MmlMunderover.ACCENTS = ['', 'accentunder', 'accent'];
exports.MmlMunderover = MmlMunderover;

var MmlMunder = function (_super) {
  __extends(MmlMunder, _super);

  function MmlMunder() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMunder.prototype, "kind", {
    get: function () {
      return 'munder';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMunder.prototype, "arity", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });
  return MmlMunder;
}(MmlMunderover);

MmlMunder.defaults = __assign({}, MmlMunderover.defaults);
exports.MmlMunder = MmlMunder;

var MmlMover = function (_super) {
  __extends(MmlMover, _super);

  function MmlMover() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMover.prototype, "kind", {
    get: function () {
      return 'mover';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMover.prototype, "arity", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMover.prototype, "over", {
    get: function () {
      return 1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMover.prototype, "under", {
    get: function () {
      return 2;
    },
    enumerable: true,
    configurable: true
  });
  return MmlMover;
}(MmlMunderover);

MmlMover.defaults = __assign({}, MmlMunderover.defaults);
MmlMover.ACCENTS = ['', 'accent', 'accentunder'];
exports.MmlMover = MmlMover;

/***/ }),
/* 91 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var msubsup_js_1 = __webpack_require__(52);

var MmlMmultiscripts = function (_super) {
  __extends(MmlMmultiscripts, _super);

  function MmlMmultiscripts() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMmultiscripts.prototype, "kind", {
    get: function () {
      return 'mmultiscripts';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMmultiscripts.prototype, "arity", {
    get: function () {
      return 1;
    },
    enumerable: true,
    configurable: true
  });

  MmlMmultiscripts.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    this.childNodes[0].setInheritedAttributes(attributes, display, level, prime);
    var prescripts = false;

    for (var i = 1, n = 0; i < this.childNodes.length; i++) {
      var child = this.childNodes[i];

      if (child.isKind('mprescripts')) {
        if (!prescripts) {
          prescripts = true;

          if (i % 2 === 0) {
            var mrow = this.factory.create('mrow');
            this.childNodes.splice(i, 0, mrow);
            mrow.parent = this;
            i++;
          }
        }
      } else {
        var primestyle = prime || n % 2 === 0;
        child.setInheritedAttributes(attributes, false, level + 1, primestyle);
        n++;
      }
    }

    if (this.childNodes.length % 2 === (prescripts ? 1 : 0)) {
      this.appendChild(this.factory.create('mrow'));
      this.childNodes[this.childNodes.length - 1].setInheritedAttributes(attributes, false, level + 1, prime);
    }
  };

  MmlMmultiscripts.prototype.verifyChildren = function (options) {
    var prescripts = false;
    var fix = options['fixMmultiscripts'];

    for (var i = 0; i < this.childNodes.length; i++) {
      var child = this.childNodes[i];

      if (child.isKind('mprescripts')) {
        if (prescripts) {
          child.mError(child.kind + ' can only appear once in ' + this.kind, options, true);
        } else {
          prescripts = true;

          if (i % 2 === 0 && !fix) {
            this.mError('There must be an equal number of prescripts of each type', options);
          }
        }
      }
    }

    if (this.childNodes.length % 2 === (prescripts ? 1 : 0) && !fix) {
      this.mError('There must be an equal number of scripts of each type', options);
    }

    _super.prototype.verifyChildren.call(this, options);
  };

  return MmlMmultiscripts;
}(msubsup_js_1.MmlMsubsup);

MmlMmultiscripts.defaults = __assign({}, msubsup_js_1.MmlMsubsup.defaults);
exports.MmlMmultiscripts = MmlMmultiscripts;

var MmlMprescripts = function (_super) {
  __extends(MmlMprescripts, _super);

  function MmlMprescripts() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMprescripts.prototype, "kind", {
    get: function () {
      return 'mprescripts';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMprescripts.prototype, "arity", {
    get: function () {
      return 0;
    },
    enumerable: true,
    configurable: true
  });

  MmlMprescripts.prototype.verifyTree = function (options) {
    _super.prototype.verifyTree.call(this, options);

    if (this.parent && !this.parent.isKind('mmultiscripts')) {
      this.mError(this.kind + ' must be a child of mmultiscripts', options, true);
    }
  };

  return MmlMprescripts;
}(MmlNode_js_1.AbstractMmlNode);

MmlMprescripts.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults);
exports.MmlMprescripts = MmlMprescripts;

var MmlNone = function (_super) {
  __extends(MmlNone, _super);

  function MmlNone() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlNone.prototype, "kind", {
    get: function () {
      return 'none';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlNone.prototype, "arity", {
    get: function () {
      return 0;
    },
    enumerable: true,
    configurable: true
  });

  MmlNone.prototype.verifyTree = function (options) {
    _super.prototype.verifyTree.call(this, options);

    if (this.parent && !this.parent.isKind('mmultiscripts')) {
      this.mError(this.kind + ' must be a child of mmultiscripts', options, true);
    }
  };

  return MmlNone;
}(MmlNode_js_1.AbstractMmlNode);

MmlNone.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults);
exports.MmlNone = MmlNone;

/***/ }),
/* 92 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var string_js_1 = __webpack_require__(16);

var MmlMtable = function (_super) {
  __extends(MmlMtable, _super);

  function MmlMtable() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.properties = {
      useHeight: 1
    };
    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMtable.prototype, "kind", {
    get: function () {
      return 'mtable';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMtable.prototype, "linebreakContainer", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMtable.prototype.setInheritedAttributes = function (attributes, display, level, prime) {
    try {
      for (var indentAttributes_1 = __values(MmlNode_js_1.indentAttributes), indentAttributes_1_1 = indentAttributes_1.next(); !indentAttributes_1_1.done; indentAttributes_1_1 = indentAttributes_1.next()) {
        var name_1 = indentAttributes_1_1.value;

        if (attributes[name_1]) {
          this.attributes.setInherited(name_1, attributes[name_1][1]);
        }

        if (this.attributes.getExplicit(name_1) !== undefined) {
          delete this.attributes.getAllAttributes()[name_1];
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (indentAttributes_1_1 && !indentAttributes_1_1.done && (_a = indentAttributes_1.return)) _a.call(indentAttributes_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    _super.prototype.setInheritedAttributes.call(this, attributes, display, level, prime);

    var e_1, _a;
  };

  ;

  MmlMtable.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (!child.isKind('mtr')) {
          this.replaceChild(this.factory.create('mtr'), child).appendChild(child);
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    display = !!(this.attributes.getExplicit('displaystyle') || this.attributes.getDefault('displaystyle'));
    attributes = this.addInheritedAttributes(attributes, {
      columnalign: this.attributes.get('columnalign'),
      rowalign: 'center'
    });
    var ralign = string_js_1.split(this.attributes.get('rowalign'));

    try {
      for (var _d = __values(this.childNodes), _e = _d.next(); !_e.done; _e = _d.next()) {
        var child = _e.value;
        attributes.rowalign[1] = ralign.shift() || attributes.rowalign[1];
        child.setInheritedAttributes(attributes, display, level, prime);
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    var e_2, _c, e_3, _f;
  };

  MmlMtable.prototype.verifyChildren = function (options) {
    if (!options['fixMtables']) {
      try {
        for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;

          if (!child.isKind('mtr')) {
            this.mError('Children of ' + this.kind + ' must be mtr or mlabeledtr', options);
          }
        }
      } catch (e_4_1) {
        e_4 = {
          error: e_4_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_4) throw e_4.error;
        }
      }
    }

    _super.prototype.verifyChildren.call(this, options);

    var e_4, _c;
  };

  MmlMtable.prototype.setTeXclass = function (prev) {
    this.getPrevClass(prev);

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        child.setTeXclass(null);
      }
    } catch (e_5_1) {
      e_5 = {
        error: e_5_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_5) throw e_5.error;
      }
    }

    return this;

    var e_5, _c;
  };

  return MmlMtable;
}(MmlNode_js_1.AbstractMmlNode);

MmlMtable.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults, {
  align: 'axis',
  rowalign: 'baseline',
  columnalign: 'center',
  groupalign: '{left}',
  alignmentscope: true,
  columnwidth: 'auto',
  width: 'auto',
  rowspacing: '1ex',
  columnspacing: '.8em',
  rowlines: 'none',
  columnlines: 'none',
  frame: 'none',
  framespacing: '0.4em 0.5ex',
  equalrows: false,
  equalcolumns: false,
  displaystyle: false,
  side: 'right',
  minlabelspacing: '0.8em'
});
exports.MmlMtable = MmlMtable;

/***/ }),
/* 93 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMtrMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    Object.defineProperty(class_1.prototype, "fixesPWidth", {
      get: function () {
        return false;
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_1.prototype, "numCells", {
      get: function () {
        return this.childNodes.length;
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_1.prototype, "labeled", {
      get: function () {
        return false;
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_1.prototype, "tableCells", {
      get: function () {
        return this.childNodes;
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.getChild = function (i) {
      return this.childNodes[i];
    };

    class_1.prototype.getChildBBoxes = function () {
      return this.childNodes.map(function (cell) {
        return cell.getBBox();
      });
    };

    class_1.prototype.stretchChildren = function (HD) {
      if (HD === void 0) {
        HD = null;
      }

      var stretchy = [];
      var children = this.labeled ? this.childNodes.slice(1) : this.childNodes;

      try {
        for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
          var mtd = children_1_1.value;
          var child = mtd.childNodes[0];

          if (child.canStretch(1)) {
            stretchy.push(child);
          }
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      var count = stretchy.length;
      var nodeCount = this.childNodes.length;

      if (count && nodeCount > 1) {
        if (HD === null) {
          var H = 0,
              D = 0;
          var all = count > 1 && count === nodeCount;

          try {
            for (var children_2 = __values(children), children_2_1 = children_2.next(); !children_2_1.done; children_2_1 = children_2.next()) {
              var mtd = children_2_1.value;
              var child = mtd.childNodes[0];
              var noStretch = child.stretch.dir === 0;

              if (all || noStretch) {
                var _b = child.getBBox(noStretch),
                    h = _b.h,
                    d = _b.d;

                if (h > H) {
                  H = h;
                }

                if (d > D) {
                  D = d;
                }
              }
            }
          } catch (e_2_1) {
            e_2 = {
              error: e_2_1
            };
          } finally {
            try {
              if (children_2_1 && !children_2_1.done && (_c = children_2.return)) _c.call(children_2);
            } finally {
              if (e_2) throw e_2.error;
            }
          }

          HD = [H, D];
        }

        try {
          for (var stretchy_1 = __values(stretchy), stretchy_1_1 = stretchy_1.next(); !stretchy_1_1.done; stretchy_1_1 = stretchy_1.next()) {
            var child = stretchy_1_1.value;
            child.coreMO().getStretchedVariant(HD);
          }
        } catch (e_3_1) {
          e_3 = {
            error: e_3_1
          };
        } finally {
          try {
            if (stretchy_1_1 && !stretchy_1_1.done && (_d = stretchy_1.return)) _d.call(stretchy_1);
          } finally {
            if (e_3) throw e_3.error;
          }
        }
      }

      var e_1, _a, e_2, _c, e_3, _d;
    };

    return class_1;
  }(Base);
}

exports.CommonMtrMixin = CommonMtrMixin;

function CommonMlabeledtrMixin(Base) {
  return function (_super) {
    __extends(class_2, _super);

    function class_2() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    Object.defineProperty(class_2.prototype, "numCells", {
      get: function () {
        return Math.max(0, this.childNodes.length - 1);
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_2.prototype, "labeled", {
      get: function () {
        return true;
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_2.prototype, "tableCells", {
      get: function () {
        return this.childNodes.slice(1);
      },
      enumerable: true,
      configurable: true
    });

    class_2.prototype.getChild = function (i) {
      return this.childNodes[i + 1];
    };

    class_2.prototype.getChildBBoxes = function () {
      return this.childNodes.slice(1).map(function (cell) {
        return cell.getBBox();
      });
    };

    return class_2;
  }(Base);
}

exports.CommonMlabeledtrMixin = CommonMlabeledtrMixin;

/***/ }),
/* 94 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var Attributes_js_1 = __webpack_require__(26);

var string_js_1 = __webpack_require__(16);

var MmlMtr = function (_super) {
  __extends(MmlMtr, _super);

  function MmlMtr() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMtr.prototype, "kind", {
    get: function () {
      return 'mtr';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMtr.prototype, "linebreakContainer", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMtr.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (!child.isKind('mtd')) {
          this.replaceChild(this.factory.create('mtd'), child).appendChild(child);
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var calign = string_js_1.split(this.attributes.get('columnalign'));

    if (this.arity === 1) {
      calign.unshift(this.parent.attributes.get('side'));
    }

    attributes = this.addInheritedAttributes(attributes, {
      rowalign: this.attributes.get('rowalign'),
      columnalign: 'center'
    });

    try {
      for (var _d = __values(this.childNodes), _e = _d.next(); !_e.done; _e = _d.next()) {
        var child = _e.value;
        attributes.columnalign[1] = calign.shift() || attributes.columnalign[1];
        child.setInheritedAttributes(attributes, display, level, prime);
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_1, _c, e_2, _f;
  };

  MmlMtr.prototype.verifyChildren = function (options) {
    if (this.parent && !this.parent.isKind('mtable')) {
      this.mError(this.kind + ' can only be a child of an mtable', options, true);
      return;
    }

    if (!options['fixMtables']) {
      try {
        for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;

          if (!child.isKind('mtd')) {
            var mtr = this.replaceChild(this.factory.create('mtr'), child);
            mtr.mError('Children of ' + this.kind + ' must be mtd', options, true);
          }
        }
      } catch (e_3_1) {
        e_3 = {
          error: e_3_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_3) throw e_3.error;
        }
      }
    }

    _super.prototype.verifyChildren.call(this, options);

    var e_3, _c;
  };

  MmlMtr.prototype.setTeXclass = function (prev) {
    this.getPrevClass(prev);

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        child.setTeXclass(null);
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    return this;

    var e_4, _c;
  };

  return MmlMtr;
}(MmlNode_js_1.AbstractMmlNode);

MmlMtr.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults, {
  rowalign: Attributes_js_1.INHERIT,
  columnalign: Attributes_js_1.INHERIT,
  groupalign: Attributes_js_1.INHERIT
});
exports.MmlMtr = MmlMtr;

var MmlMlabeledtr = function (_super) {
  __extends(MmlMlabeledtr, _super);

  function MmlMlabeledtr() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMlabeledtr.prototype, "kind", {
    get: function () {
      return 'mlabeledtr';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMlabeledtr.prototype, "arity", {
    get: function () {
      return 1;
    },
    enumerable: true,
    configurable: true
  });
  return MmlMlabeledtr;
}(MmlMtr);

exports.MmlMlabeledtr = MmlMlabeledtr;

/***/ }),
/* 95 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var Attributes_js_1 = __webpack_require__(26);

var MmlMtd = function (_super) {
  __extends(MmlMtd, _super);

  function MmlMtd() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMtd.prototype, "kind", {
    get: function () {
      return 'mtd';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMtd.prototype, "arity", {
    get: function () {
      return -1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMtd.prototype, "linebreakContainer", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMtd.prototype.verifyChildren = function (options) {
    if (this.parent && !this.parent.isKind('mtr')) {
      this.mError(this.kind + ' can only be a child of an mtr or mlabeledtr', options, true);
      return;
    }

    _super.prototype.verifyChildren.call(this, options);
  };

  MmlMtd.prototype.setTeXclass = function (prev) {
    this.getPrevClass(prev);
    this.childNodes[0].setTeXclass(null);
    return this;
  };

  return MmlMtd;
}(MmlNode_js_1.AbstractMmlBaseNode);

MmlMtd.defaults = __assign({}, MmlNode_js_1.AbstractMmlBaseNode.defaults, {
  rowspan: 1,
  columnspan: 1,
  rowalign: Attributes_js_1.INHERIT,
  columnalign: Attributes_js_1.INHERIT,
  groupalign: Attributes_js_1.INHERIT
});
exports.MmlMtd = MmlMtd;

/***/ }),
/* 96 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var string_js_1 = __webpack_require__(16);

exports.TooltipData = {
  dx: '.2em',
  dy: '.1em',
  postDelay: 600,
  clearDelay: 100,
  hoverTimer: new Map(),
  clearTimer: new Map(),
  stopTimers: function (node, data) {
    if (data.clearTimer.has(node)) {
      clearTimeout(data.clearTimer.get(node));
      data.clearTimer.delete(node);
    }

    if (data.hoverTimer.has(node)) {
      clearTimeout(data.hoverTimer.get(node));
      data.hoverTimer.delete(node);
    }
  }
};

function CommonMactionMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      var actions = _this.constructor.actions;

      var action = _this.node.attributes.get('actiontype');

      var _a = __read(actions.get(action) || [function (node, data) {}, {}], 2),
          handler = _a[0],
          data = _a[1];

      _this.action = handler;
      _this.data = data;

      _this.getParameters();

      return _this;
    }

    Object.defineProperty(class_1.prototype, "selected", {
      get: function () {
        var selection = this.node.attributes.get('selection');
        var i = Math.max(1, Math.min(this.childNodes.length, selection)) - 1;
        return this.childNodes[i] || this.wrap(this.node.selected);
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.getParameters = function () {
      var offsets = this.node.attributes.get('data-offsets');

      var _a = __read(string_js_1.split(offsets || ''), 2),
          dx = _a[0],
          dy = _a[1];

      this.dx = this.length2em(dx || exports.TooltipData.dx);
      this.dy = this.length2em(dy || exports.TooltipData.dy);
    };

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      bbox.updateFrom(this.selected.getBBox());
      this.selected.setChildPWidths(recompute);
    };

    return class_1;
  }(Base);
}

exports.CommonMactionMixin = CommonMactionMixin;

/***/ }),
/* 97 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMaction = function (_super) {
  __extends(MmlMaction, _super);

  function MmlMaction() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMaction.prototype, "kind", {
    get: function () {
      return 'maction';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMaction.prototype, "arity", {
    get: function () {
      return 1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMaction.prototype, "selected", {
    get: function () {
      var selection = this.attributes.get('selection');
      var i = Math.max(1, Math.min(this.childNodes.length, selection)) - 1;
      return this.childNodes[i] || this.factory.create('mrow');
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMaction.prototype, "isEmbellished", {
    get: function () {
      return this.selected.isEmbellished;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMaction.prototype, "isSpacelike", {
    get: function () {
      return this.selected.isSpacelike;
    },
    enumerable: true,
    configurable: true
  });

  MmlMaction.prototype.core = function () {
    return this.selected.core();
  };

  MmlMaction.prototype.coreMO = function () {
    return this.selected.coreMO();
  };

  MmlMaction.prototype.verifyAttributes = function (options) {
    _super.prototype.verifyAttributes.call(this, options);

    if (this.attributes.get('actiontype') !== 'toggle' && this.attributes.getExplicit('selection') !== undefined) {
      var attributes = this.attributes.getAllAttributes();
      delete attributes.selection;
    }
  };

  MmlMaction.prototype.setTeXclass = function (prev) {
    if (this.attributes.get('actiontype') === 'tooltip' && this.childNodes[1]) {
      this.childNodes[1].setTeXclass(null);
    }

    var selected = this.selected;
    prev = selected.setTeXclass(prev);
    this.updateTeXclass(selected);
    return prev;
  };

  MmlMaction.prototype.nextToggleSelection = function () {
    var selection = Math.max(1, this.attributes.get('selection') + 1);

    if (selection > this.childNodes.length) {
      selection = 1;
    }

    this.attributes.set('selection', selection);
  };

  return MmlMaction;
}(MmlNode_js_1.AbstractMmlNode);

MmlMaction.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults, {
  actiontype: 'toggle',
  selection: 1
});
exports.MmlMaction = MmlMaction;

/***/ }),
/* 98 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMglyph = function (_super) {
  __extends(MmlMglyph, _super);

  function MmlMglyph() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMglyph.prototype, "kind", {
    get: function () {
      return 'mglyph';
    },
    enumerable: true,
    configurable: true
  });
  return MmlMglyph;
}(MmlNode_js_1.AbstractMmlTokenNode);

MmlMglyph.defaults = __assign({}, MmlNode_js_1.AbstractMmlTokenNode.defaults, {
  alt: '',
  src: '',
  width: 'auto',
  height: 'auto',
  valign: '0em'
});
exports.MmlMglyph = MmlMglyph;

/***/ }),
/* 99 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlSemantics = function (_super) {
  __extends(MmlSemantics, _super);

  function MmlSemantics() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlSemantics.prototype, "kind", {
    get: function () {
      return 'semantics';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlSemantics.prototype, "arity", {
    get: function () {
      return 1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlSemantics.prototype, "notParent", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  return MmlSemantics;
}(MmlNode_js_1.AbstractMmlBaseNode);

MmlSemantics.defaults = __assign({}, MmlNode_js_1.AbstractMmlBaseNode.defaults, {
  definitionUrl: null,
  encoding: null
});
exports.MmlSemantics = MmlSemantics;

var MmlAnnotationXML = function (_super) {
  __extends(MmlAnnotationXML, _super);

  function MmlAnnotationXML() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlAnnotationXML.prototype, "kind", {
    get: function () {
      return 'annotation-xml';
    },
    enumerable: true,
    configurable: true
  });

  MmlAnnotationXML.prototype.setChildInheritedAttributes = function () {};

  return MmlAnnotationXML;
}(MmlNode_js_1.AbstractMmlNode);

MmlAnnotationXML.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults, {
  definitionUrl: null,
  encoding: null,
  cd: 'mathmlkeys',
  name: '',
  src: null
});
exports.MmlAnnotationXML = MmlAnnotationXML;

var MmlAnnotation = function (_super) {
  __extends(MmlAnnotation, _super);

  function MmlAnnotation() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.properties = {
      isChars: true
    };
    return _this;
  }

  Object.defineProperty(MmlAnnotation.prototype, "kind", {
    get: function () {
      return 'annotation';
    },
    enumerable: true,
    configurable: true
  });
  return MmlAnnotation;
}(MmlAnnotationXML);

MmlAnnotation.defaults = __assign({}, MmlAnnotationXML.defaults);
exports.MmlAnnotation = MmlAnnotation;

/***/ }),
/* 100 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var mo_js_1 = __webpack_require__(34);

var TeXAtom = function (_super) {
  __extends(TeXAtom, _super);

  function TeXAtom() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(TeXAtom.prototype, "kind", {
    get: function () {
      return 'TeXAtom';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(TeXAtom.prototype, "arity", {
    get: function () {
      return -1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(TeXAtom.prototype, "notParent", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  TeXAtom.prototype.setTeXclass = function (prev) {
    this.childNodes[0].setTeXclass(null);
    return this.adjustTeXclass(prev);
  };

  TeXAtom.prototype.adjustTeXclass = function (prev) {
    return prev;
  };

  return TeXAtom;
}(MmlNode_js_1.AbstractMmlBaseNode);

TeXAtom.defaults = __assign({}, MmlNode_js_1.AbstractMmlBaseNode.defaults);
exports.TeXAtom = TeXAtom;
TeXAtom.prototype.adjustTeXclass = mo_js_1.MmlMo.prototype.adjustTeXclass;

/***/ }),
/* 101 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var TexError_js_1 = __webpack_require__(6);

var sm = __webpack_require__(5);

var BaseMethods_js_1 = __webpack_require__(19);

var ParseUtil_js_1 = __webpack_require__(9);

var NewcommandUtil_js_1 = __webpack_require__(102);

var NewcommandMethods = {};

NewcommandMethods.NewCommand = function (parser, name) {
  var cs = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));
  var n = parser.GetBrackets(name);
  var opt = parser.GetBrackets(name);
  var def = parser.GetArgument(name);

  if (cs.charAt(0) === '\\') {
    cs = cs.substr(1);
  }

  if (!cs.match(/^(.|[a-z]+)$/i)) {
    throw new TexError_js_1.default('IllegalControlSequenceName', 'Illegal control sequence name for %1', name);
  }

  if (n) {
    n = ParseUtil_js_1.default.trimSpaces(n);

    if (!n.match(/^[0-9]+$/)) {
      throw new TexError_js_1.default('IllegalParamNumber', 'Illegal number of parameters specified in %1', name);
    }
  }

  NewcommandUtil_js_1.default.addMacro(parser, cs, NewcommandMethods.Macro, [def, n, opt]);
};

NewcommandMethods.NewEnvironment = function (parser, name) {
  var env = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));
  var n = parser.GetBrackets(name);
  var opt = parser.GetBrackets(name);
  var bdef = parser.GetArgument(name);
  var edef = parser.GetArgument(name);

  if (n) {
    n = ParseUtil_js_1.default.trimSpaces(n);

    if (!n.match(/^[0-9]+$/)) {
      throw new TexError_js_1.default('IllegalParamNumber', 'Illegal number of parameters specified in %1', name);
    }
  }

  NewcommandUtil_js_1.default.addEnvironment(parser, env, NewcommandMethods.BeginEnv, [true, bdef, edef, n, opt]);
};

NewcommandMethods.MacroDef = function (parser, name) {
  var cs = NewcommandUtil_js_1.default.GetCSname(parser, name);
  var params = NewcommandUtil_js_1.default.GetTemplate(parser, name, '\\' + cs);
  var def = parser.GetArgument(name);
  !(params instanceof Array) ? NewcommandUtil_js_1.default.addMacro(parser, cs, NewcommandMethods.Macro, [def, params]) : NewcommandUtil_js_1.default.addMacro(parser, cs, NewcommandMethods.MacroWithTemplate, [def].concat(params));
};

NewcommandMethods.Let = function (parser, name) {
  var cs = NewcommandUtil_js_1.default.GetCSname(parser, name);
  var c = parser.GetNext();

  if (c === '=') {
    parser.i++;
    c = parser.GetNext();
  }

  var handlers = parser.configuration.handlers;

  if (c === '\\') {
    name = NewcommandUtil_js_1.default.GetCSname(parser, name);
    var macro_1 = handlers.get('delimiter').lookup('\\' + name);

    if (macro_1) {
      NewcommandUtil_js_1.default.addDelimiter(parser, '\\' + cs, macro_1.char, macro_1.attributes);
      return;
    }

    var map_1 = handlers.get('macro').applicable(name);

    if (!map_1) {
      return;
    }

    if (map_1 instanceof sm.MacroMap) {
      var macro_2 = map_1.lookup(name);
      NewcommandUtil_js_1.default.addMacro(parser, cs, macro_2.func, macro_2.args, macro_2.symbol);
      return;
    }

    macro_1 = map_1.lookup(name);
    var newArgs = NewcommandUtil_js_1.default.disassembleSymbol(cs, macro_1);

    var method = function (p, cs) {
      var rest = [];

      for (var _i = 2; _i < arguments.length; _i++) {
        rest[_i - 2] = arguments[_i];
      }

      var symb = NewcommandUtil_js_1.default.assembleSymbol(rest);
      return map_1.parser(p, symb);
    };

    NewcommandUtil_js_1.default.addMacro(parser, cs, method, newArgs);
    return;
  }

  parser.i++;
  var macro = handlers.get('delimiter').lookup(c);

  if (macro) {
    NewcommandUtil_js_1.default.addDelimiter(parser, '\\' + cs, macro.char, macro.attributes);
    return;
  }

  NewcommandUtil_js_1.default.addMacro(parser, cs, NewcommandMethods.Macro, [c]);
};

NewcommandMethods.MacroWithTemplate = function (parser, name, text, n) {
  var params = [];

  for (var _i = 4; _i < arguments.length; _i++) {
    params[_i - 4] = arguments[_i];
  }

  var argCount = parseInt(n, 10);

  if (argCount) {
    var args = [];
    parser.GetNext();

    if (params[0] && !NewcommandUtil_js_1.default.MatchParam(parser, params[0])) {
      throw new TexError_js_1.default('MismatchUseDef', 'Use of %1 doesn\'t match its definition', name);
    }

    for (var i = 0; i < argCount; i++) {
      args.push(NewcommandUtil_js_1.default.GetParameter(parser, name, params[i + 1]));
    }

    text = ParseUtil_js_1.default.substituteArgs(parser, args, text);
  }

  parser.string = ParseUtil_js_1.default.addArgs(parser, text, parser.string.slice(parser.i));
  parser.i = 0;

  if (++parser.macroCount > parser.configuration.options['maxMacros']) {
    throw new TexError_js_1.default('MaxMacroSub1', 'MathJax maximum macro substitution count exceeded; ' + 'is here a recursive macro call?');
  }
};

NewcommandMethods.BeginEnv = function (parser, begin, bdef, edef, n, def) {
  if (begin.getProperty('end') && parser.stack.env['closing'] === begin.getName()) {
    delete parser.stack.env['closing'];
    var rest = parser.string.slice(parser.i);
    parser.string = edef;
    parser.i = 0;
    parser.Parse();
    parser.string = rest;
    parser.i = 0;
    return parser.itemFactory.create('end').setProperty('name', begin.getName());
  }

  if (n) {
    var args = [];

    if (def != null) {
      var optional = parser.GetBrackets('\\begin{' + begin.getName() + '}');
      args.push(optional == null ? def : optional);
    }

    for (var i = args.length; i < n; i++) {
      args.push(parser.GetArgument('\\begin{' + begin.getName() + '}'));
    }

    bdef = ParseUtil_js_1.default.substituteArgs(parser, args, bdef);
    edef = ParseUtil_js_1.default.substituteArgs(parser, [], edef);
  }

  parser.string = ParseUtil_js_1.default.addArgs(parser, bdef, parser.string.slice(parser.i));
  parser.i = 0;
  return parser.itemFactory.create('beginEnv').setProperty('name', begin.getName());
};

NewcommandMethods.Macro = BaseMethods_js_1.default.Macro;
exports.default = NewcommandMethods;

/***/ }),
/* 102 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var ParseUtil_js_1 = __webpack_require__(9);

var TexError_js_1 = __webpack_require__(6);

var Symbol_js_1 = __webpack_require__(36);

var MapHandler_js_1 = __webpack_require__(17);

var NewcommandUtil;

(function (NewcommandUtil) {
  function disassembleSymbol(name, symbol) {
    var newArgs = [name, symbol.char];

    if (symbol.attributes) {
      for (var key in symbol.attributes) {
        newArgs.push(key);
        newArgs.push(symbol.attributes[key]);
      }
    }

    return newArgs;
  }

  NewcommandUtil.disassembleSymbol = disassembleSymbol;
  ;

  function assembleSymbol(args) {
    var name = args[0];
    var char = args[1];
    var attrs = {};

    for (var i = 2; i < args.length; i = i + 2) {
      attrs[args[i]] = args[i + 1];
    }

    return new Symbol_js_1.Symbol(name, char, attrs);
  }

  NewcommandUtil.assembleSymbol = assembleSymbol;
  ;

  function GetCSname(parser, cmd) {
    var c = parser.GetNext();

    if (c !== '\\') {
      throw new TexError_js_1.default('MissingCS', '%1 must be followed by a control sequence', cmd);
    }

    var cs = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(cmd));
    return cs.substr(1);
  }

  NewcommandUtil.GetCSname = GetCSname;
  ;

  function GetTemplate(parser, cmd, cs) {
    var c = parser.GetNext();
    var params = [];
    var n = 0;
    var i = parser.i;

    while (parser.i < parser.string.length) {
      c = parser.GetNext();

      if (c === '#') {
        if (i !== parser.i) {
          params[n] = parser.string.substr(i, parser.i - i);
        }

        c = parser.string.charAt(++parser.i);

        if (!c.match(/^[1-9]$/)) {
          throw new TexError_js_1.default('CantUseHash2', 'Illegal use of # in template for %1', cs);
        }

        if (parseInt(c) !== ++n) {
          throw new TexError_js_1.default('SequentialParam', 'Parameters for %1 must be numbered sequentially', cs);
        }

        i = parser.i + 1;
      } else if (c === '{') {
        if (i !== parser.i) {
          params[n] = parser.string.substr(i, parser.i - i);
        }

        if (params.length > 0) {
          return [n.toString()].concat(params);
        } else {
          return n;
        }
      }

      parser.i++;
    }

    throw new TexError_js_1.default('MissingReplacementString', 'Missing replacement string for definition of %1', cmd);
  }

  NewcommandUtil.GetTemplate = GetTemplate;
  ;

  function GetParameter(parser, name, param) {
    if (param == null) {
      return parser.GetArgument(name);
    }

    var i = parser.i;
    var j = 0;
    var hasBraces = 0;

    while (parser.i < parser.string.length) {
      var c = parser.string.charAt(parser.i);

      if (c === '{') {
        if (parser.i === i) {
          hasBraces = 1;
        }

        parser.GetArgument(name);
        j = parser.i - i;
      } else if (MatchParam(parser, param)) {
        if (hasBraces) {
          i++;
          j -= 2;
        }

        return parser.string.substr(i, j);
      } else if (c === '\\') {
        parser.i++;
        j++;
        hasBraces = 0;
        var match = parser.string.substr(parser.i).match(/[a-z]+|./i);

        if (match) {
          parser.i += match[0].length;
          j = parser.i - i;
        }
      } else {
        parser.i++;
        j++;
        hasBraces = 0;
      }
    }

    throw new TexError_js_1.default('RunawayArgument', 'Runaway argument for %1?', name);
  }

  NewcommandUtil.GetParameter = GetParameter;
  ;

  function MatchParam(parser, param) {
    if (parser.string.substr(parser.i, param.length) !== param) {
      return 0;
    }

    if (param.match(/\\[a-z]+$/i) && parser.string.charAt(parser.i + param.length).match(/[a-z]/i)) {
      return 0;
    }

    parser.i += param.length;
    return 1;
  }

  NewcommandUtil.MatchParam = MatchParam;
  ;

  function addDelimiter(parser, cs, char, attr) {
    var handlers = parser.configuration.handlers;
    var handler = handlers.retrieve(MapHandler_js_1.ExtensionMaps.NEW_DELIMITER);
    handler.add(cs, new Symbol_js_1.Symbol(cs, char, attr));
  }

  NewcommandUtil.addDelimiter = addDelimiter;
  ;

  function addMacro(parser, cs, func, attr, symbol) {
    if (symbol === void 0) {
      symbol = '';
    }

    var handlers = parser.configuration.handlers;
    var handler = handlers.retrieve(MapHandler_js_1.ExtensionMaps.NEW_COMMAND);
    handler.add(cs, new Symbol_js_1.Macro(symbol ? symbol : cs, func, attr));
  }

  NewcommandUtil.addMacro = addMacro;
  ;

  function addEnvironment(parser, env, func, attr) {
    var handlers = parser.configuration.handlers;
    var handler = handlers.retrieve(MapHandler_js_1.ExtensionMaps.NEW_ENVIRONMENT);
    handler.add(env, new Symbol_js_1.Macro(env, func, attr));
  }

  NewcommandUtil.addEnvironment = addEnvironment;
  ;
})(NewcommandUtil || (NewcommandUtil = {}));

exports.default = NewcommandUtil;

/***/ }),
/* 103 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var NewcommandItems_js_1 = __webpack_require__(372);

__webpack_require__(373);

var init = function (config) {
  config.append(Configuration_js_1.Configuration.extension());
};

exports.NewcommandConfiguration = Configuration_js_1.Configuration.create('newcommand', {
  handler: {
    macro: ['Newcommand-macros']
  },
  items: (_a = {}, _a[NewcommandItems_js_1.BeginEnvItem.prototype.kind] = NewcommandItems_js_1.BeginEnvItem, _a),
  options: {
    maxMacros: 1000
  },
  init: init
});

var _a;

/***/ }),
/* 104 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Options_js_1 = __webpack_require__(10);

var InputJax_js_1 = __webpack_require__(71);

var OutputJax_js_1 = __webpack_require__(73);

var MathList_js_1 = __webpack_require__(105);

var MathItem_js_1 = __webpack_require__(33);

var MmlFactory_js_1 = __webpack_require__(390);

var BitField_js_1 = __webpack_require__(400);

var PrioritizedList_js_1 = __webpack_require__(43);

var RenderList = function (_super) {
  __extends(RenderList, _super);

  function RenderList() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  RenderList.create = function (actions) {
    var list = new this();

    try {
      for (var _a = __values(Object.keys(actions)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var id = _b.value;

        var _c = __read(this.action(id, actions[id]), 2),
            action = _c[0],
            priority = _c[1];

        if (priority) {
          list.add(action, priority);
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    return list;

    var e_1, _d;
  };

  RenderList.action = function (id, action) {
    var renderDoc, renderMath;
    var convert = true;
    var priority = action[0];

    if (action.length === 1 || typeof action[1] === 'boolean') {
      action.length === 2 && (convert = action[1]);
      _a = __read(this.methodActions(id), 2), renderDoc = _a[0], renderMath = _a[1];
    } else if (typeof action[1] === 'string') {
      if (typeof action[2] === 'string') {
        action.length === 4 && (convert = action[3]);

        var _b = __read(action.slice(1), 2),
            method1 = _b[0],
            method2 = _b[1];

        _c = __read(this.methodActions(method1, method2), 2), renderDoc = _c[0], renderMath = _c[1];
      } else {
        action.length === 3 && (convert = action[2]);
        _d = __read(this.methodActions(action[1]), 2), renderDoc = _d[0], renderMath = _d[1];
      }
    } else {
      action.length === 4 && (convert = action[3]);
      _e = __read(action.slice(1), 2), renderDoc = _e[0], renderMath = _e[1];
    }

    return [{
      id: id,
      renderDoc: renderDoc,
      renderMath: renderMath,
      convert: convert
    }, priority];

    var _a, _c, _d, _e;
  };

  RenderList.methodActions = function (method1, method2) {
    if (method2 === void 0) {
      method2 = method1;
    }

    return [function (document) {
      method1 && document[method1]();
      return false;
    }, function (math, document) {
      method2 && math[method2](document);
      return false;
    }];
  };

  RenderList.prototype.renderDoc = function (document, start) {
    if (start === void 0) {
      start = MathItem_js_1.STATE.UNPROCESSED;
    }

    try {
      for (var _a = __values(this.items), _b = _a.next(); !_b.done; _b = _a.next()) {
        var item = _b.value;

        if (item.priority >= start) {
          if (item.item.renderDoc(document)) return;
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_2, _c;
  };

  RenderList.prototype.renderMath = function (math, document, start) {
    if (start === void 0) {
      start = MathItem_js_1.STATE.UNPROCESSED;
    }

    try {
      for (var _a = __values(this.items), _b = _a.next(); !_b.done; _b = _a.next()) {
        var item = _b.value;

        if (item.priority >= start) {
          if (item.item.renderMath(math, document)) return;
        }
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    var e_3, _c;
  };

  RenderList.prototype.renderConvert = function (math, document, end) {
    if (end === void 0) {
      end = MathItem_js_1.STATE.LAST;
    }

    try {
      for (var _a = __values(this.items), _b = _a.next(); !_b.done; _b = _a.next()) {
        var item = _b.value;
        if (item.priority >= end) return;

        if (item.item.convert) {
          if (item.item.renderMath(math, document)) return;
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    var e_4, _c;
  };

  RenderList.prototype.findID = function (id) {
    try {
      for (var _a = __values(this.items), _b = _a.next(); !_b.done; _b = _a.next()) {
        var item = _b.value;

        if (item.item.id === id) {
          return item.item;
        }
      }
    } catch (e_5_1) {
      e_5 = {
        error: e_5_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_5) throw e_5.error;
      }
    }

    return null;

    var e_5, _c;
  };

  return RenderList;
}(PrioritizedList_js_1.PrioritizedList);

exports.RenderList = RenderList;

var DefaultInputJax = function (_super) {
  __extends(DefaultInputJax, _super);

  function DefaultInputJax() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  DefaultInputJax.prototype.compile = function (math) {
    return null;
  };

  return DefaultInputJax;
}(InputJax_js_1.AbstractInputJax);

var DefaultOutputJax = function (_super) {
  __extends(DefaultOutputJax, _super);

  function DefaultOutputJax() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  DefaultOutputJax.prototype.typeset = function (math, document) {
    if (document === void 0) {
      document = null;
    }

    return null;
  };

  DefaultOutputJax.prototype.escaped = function (math, document) {
    return null;
  };

  return DefaultOutputJax;
}(OutputJax_js_1.AbstractOutputJax);

var DefaultMathList = function (_super) {
  __extends(DefaultMathList, _super);

  function DefaultMathList() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return DefaultMathList;
}(MathList_js_1.AbstractMathList);

var DefaultMathItem = function (_super) {
  __extends(DefaultMathItem, _super);

  function DefaultMathItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return DefaultMathItem;
}(MathItem_js_1.AbstractMathItem);

var AbstractMathDocument = function () {
  function AbstractMathDocument(document, adaptor, options) {
    var _this = this;

    var CLASS = this.constructor;
    this.document = document;
    this.options = Options_js_1.userOptions(Options_js_1.defaultOptions({}, CLASS.OPTIONS), options);
    this.math = new (this.options['MathList'] || DefaultMathList)();
    this.renderActions = RenderList.create(this.options['renderActions']);
    this.processed = new AbstractMathDocument.ProcessBits();
    this.outputJax = this.options['OutputJax'] || new DefaultOutputJax();
    var inputJax = this.options['InputJax'] || [new DefaultInputJax()];

    if (!Array.isArray(inputJax)) {
      inputJax = [inputJax];
    }

    this.inputJax = inputJax;
    this.adaptor = adaptor;
    this.outputJax.setAdaptor(adaptor);
    this.inputJax.map(function (jax) {
      return jax.setAdaptor(adaptor);
    });
    this.mmlFactory = this.options['MmlFactory'] || new MmlFactory_js_1.MmlFactory();
    this.inputJax.map(function (jax) {
      return jax.setMmlFactory(_this.mmlFactory);
    });
    this.outputJax.initialize();
    this.inputJax.map(function (jax) {
      return jax.initialize();
    });
  }

  Object.defineProperty(AbstractMathDocument.prototype, "kind", {
    get: function () {
      return this.constructor.KIND;
    },
    enumerable: true,
    configurable: true
  });

  AbstractMathDocument.prototype.addRenderAction = function (id) {
    var action = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      action[_i - 1] = arguments[_i];
    }

    var _a = __read(RenderList.action(id, action), 2),
        fn = _a[0],
        p = _a[1];

    this.renderActions.add(fn, p);
  };

  AbstractMathDocument.prototype.removeRenderAction = function (id) {
    var action = this.renderActions.findID(id);

    if (action) {
      this.renderActions.remove(action);
    }
  };

  AbstractMathDocument.prototype.render = function () {
    this.renderActions.renderDoc(this);
    return this;
  };

  AbstractMathDocument.prototype.rerender = function (start) {
    if (start === void 0) {
      start = MathItem_js_1.STATE.RERENDER;
    }

    this.state(start - 1);
    this.render();
    return this;
  };

  AbstractMathDocument.prototype.convert = function (math, options) {
    if (options === void 0) {
      options = {};
    }

    var _a = Options_js_1.userOptions({
      format: this.inputJax[0].name,
      display: true,
      end: MathItem_js_1.STATE.LAST,
      em: 16,
      ex: 8,
      cwidth: 1000000,
      lwidth: 1000000,
      scale: 1
    }, options),
        format = _a.format,
        display = _a.display,
        end = _a.end,
        ex = _a.ex,
        em = _a.em,
        cwidth = _a.cwidth,
        lwidth = _a.lwidth,
        scale = _a.scale;

    var jax = this.inputJax.reduce(function (jax, ijax) {
      return ijax.name === format ? ijax : jax;
    }, null);
    var mitem = new this.options.MathItem(math, jax, display);
    mitem.setMetrics(em, ex, cwidth, lwidth, scale);
    mitem.convert(this, end);
    return mitem.typesetRoot || mitem.root;
  };

  AbstractMathDocument.prototype.findMath = function (options) {
    if (options === void 0) {
      options = null;
    }

    this.processed.set('findMath');
    return this;
  };

  AbstractMathDocument.prototype.compile = function () {
    if (!this.processed.isSet('compile')) {
      try {
        for (var _a = __values(this.math), _b = _a.next(); !_b.done; _b = _a.next()) {
          var math = _b.value;

          try {
            math.compile(this);
          } catch (err) {
            if (err.retry || err.restart) {
              throw err;
            }

            this.options['compileError'](this, math, err);
            math.inputData['error'] = err;
          }
        }
      } catch (e_6_1) {
        e_6 = {
          error: e_6_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_6) throw e_6.error;
        }
      }

      this.processed.set('compile');
    }

    return this;

    var e_6, _c;
  };

  AbstractMathDocument.prototype.compileError = function (math, err) {
    math.root = this.mmlFactory.create('math', null, [this.mmlFactory.create('merror', {
      'data-mjx-error': err.message
    }, [this.mmlFactory.create('mtext', null, [this.mmlFactory.create('text').setText('Math input error')])])]);

    if (math.display) {
      math.root.attributes.set('display', 'block');
    }
  };

  AbstractMathDocument.prototype.typeset = function () {
    if (!this.processed.isSet('typeset')) {
      try {
        for (var _a = __values(this.math), _b = _a.next(); !_b.done; _b = _a.next()) {
          var math = _b.value;

          try {
            math.typeset(this);
          } catch (err) {
            if (err.retry || err.restart) {
              throw err;
            }

            this.options['typesetError'](this, math, err);
            math.outputData['error'] = err;
          }
        }
      } catch (e_7_1) {
        e_7 = {
          error: e_7_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_7) throw e_7.error;
        }
      }

      this.processed.set('typeset');
    }

    return this;

    var e_7, _c;
  };

  AbstractMathDocument.prototype.typesetError = function (math, err) {
    math.typesetRoot = this.adaptor.node('span', {
      'data-mjx-error': err.message
    }, [this.adaptor.text('Math output error')]);
  };

  AbstractMathDocument.prototype.getMetrics = function () {
    if (!this.processed.isSet('getMetrics')) {
      this.outputJax.getMetrics(this);
      this.processed.set('getMetrics');
    }

    return this;
  };

  AbstractMathDocument.prototype.updateDocument = function () {
    if (!this.processed.isSet('updateDocument')) {
      try {
        for (var _a = __values(this.math.reversed()), _b = _a.next(); !_b.done; _b = _a.next()) {
          var math = _b.value;
          math.updateDocument(this);
        }
      } catch (e_8_1) {
        e_8 = {
          error: e_8_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_8) throw e_8.error;
        }
      }

      this.processed.set('updateDocument');
    }

    return this;

    var e_8, _c;
  };

  AbstractMathDocument.prototype.removeFromDocument = function (restore) {
    if (restore === void 0) {
      restore = false;
    }

    return this;
  };

  AbstractMathDocument.prototype.state = function (state, restore) {
    if (restore === void 0) {
      restore = false;
    }

    try {
      for (var _a = __values(this.math), _b = _a.next(); !_b.done; _b = _a.next()) {
        var math = _b.value;
        math.state(state, restore);
      }
    } catch (e_9_1) {
      e_9 = {
        error: e_9_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_9) throw e_9.error;
      }
    }

    if (state < MathItem_js_1.STATE.INSERTED) {
      this.processed.clear('updateDocument');
    }

    if (state < MathItem_js_1.STATE.TYPESET) {
      this.processed.clear('typeset');
      this.processed.clear('getMetrics');
    }

    if (state < MathItem_js_1.STATE.COMPILED) {
      this.processed.clear('compile');
    }

    return this;

    var e_9, _c;
  };

  AbstractMathDocument.prototype.reset = function () {
    this.processed.reset();
    return this;
  };

  AbstractMathDocument.prototype.clear = function () {
    this.reset();
    this.math.clear();
    return this;
  };

  AbstractMathDocument.prototype.concat = function (list) {
    this.math.merge(list);
    return this;
  };

  return AbstractMathDocument;
}();

AbstractMathDocument.KIND = 'MathDocument';
AbstractMathDocument.OPTIONS = {
  OutputJax: null,
  InputJax: null,
  MmlFactory: null,
  MathList: DefaultMathList,
  MathItem: DefaultMathItem,
  compileError: function (doc, math, err) {
    doc.compileError(math, err);
  },
  typesetError: function (doc, math, err) {
    doc.typesetError(math, err);
  },
  renderActions: Options_js_1.expandable({
    find: [MathItem_js_1.STATE.FINDMATH, function (document) {
      var elements = document.options.elements;
      document.findMath(elements ? {
        elements: elements
      } : {});
    }, function () {}, false],
    compile: [MathItem_js_1.STATE.COMPILED],
    metrics: [MathItem_js_1.STATE.METRICS, 'getMetrics', '', false],
    typeset: [MathItem_js_1.STATE.TYPESET],
    update: [MathItem_js_1.STATE.INSERTED, 'updateDocument', false],
    reset: [MathItem_js_1.STATE.RESET, 'reset', '', false]
  })
};
AbstractMathDocument.ProcessBits = BitField_js_1.BitFieldClass('findMath', 'compile', 'getMetrics', 'typeset', 'updateDocument');
exports.AbstractMathDocument = AbstractMathDocument;
;

/***/ }),
/* 105 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var LinkedList_js_1 = __webpack_require__(389);

var AbstractMathList = function (_super) {
  __extends(AbstractMathList, _super);

  function AbstractMathList() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  AbstractMathList.prototype.isBefore = function (a, b) {
    return a.start.i < b.start.i || a.start.i === b.start.i && a.start.n < b.start.n;
  };

  return AbstractMathList;
}(LinkedList_js_1.LinkedList);

exports.AbstractMathList = AbstractMathList;

/***/ }),
/* 106 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var script_loader_codemirror__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(206);
/* harmony import */ var script_loader_codemirror__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var script_loader_codemirror_mode_meta__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(208);
/* harmony import */ var script_loader_codemirror_mode_meta__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_mode_meta__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var script_loader_codemirror_addon_runmode_colorize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(210);
/* harmony import */ var script_loader_codemirror_addon_runmode_colorize__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_addon_runmode_colorize__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var script_loader_codemirror_addon_runmode_runmode__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(212);
/* harmony import */ var script_loader_codemirror_addon_runmode_runmode__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_addon_runmode_runmode__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var script_loader_codemirror_addon_selection_mark_selection__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(214);
/* harmony import */ var script_loader_codemirror_addon_selection_mark_selection__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_addon_selection_mark_selection__WEBPACK_IMPORTED_MODULE_4__);
/* harmony import */ var script_loader_codemirror_mode_clike_clike__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(216);
/* harmony import */ var script_loader_codemirror_mode_clike_clike__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_mode_clike_clike__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var script_loader_codemirror_mode_go_go__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(218);
/* harmony import */ var script_loader_codemirror_mode_go_go__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_mode_go_go__WEBPACK_IMPORTED_MODULE_6__);
/* harmony import */ var script_loader_codemirror_mode_javascript_javascript__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(220);
/* harmony import */ var script_loader_codemirror_mode_javascript_javascript__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_mode_javascript_javascript__WEBPACK_IMPORTED_MODULE_7__);
/* harmony import */ var script_loader_codemirror_mode_perl_perl__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(222);
/* harmony import */ var script_loader_codemirror_mode_perl_perl__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_mode_perl_perl__WEBPACK_IMPORTED_MODULE_8__);
/* harmony import */ var script_loader_codemirror_mode_python_python__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(224);
/* harmony import */ var script_loader_codemirror_mode_python_python__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_mode_python_python__WEBPACK_IMPORTED_MODULE_9__);
/* harmony import */ var script_loader_codemirror_mode_shell_shell__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(226);
/* harmony import */ var script_loader_codemirror_mode_shell_shell__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(script_loader_codemirror_mode_shell_shell__WEBPACK_IMPORTED_MODULE_10__);
/* harmony import */ var _css_reset_reset_min_css__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(405);
/* harmony import */ var _css_reset_reset_min_css__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(_css_reset_reset_min_css__WEBPACK_IMPORTED_MODULE_11__);
/* harmony import */ var _css_reset_bootstrap_reboot_min_css__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(408);
/* harmony import */ var _css_reset_bootstrap_reboot_min_css__WEBPACK_IMPORTED_MODULE_12___default = /*#__PURE__*/__webpack_require__.n(_css_reset_bootstrap_reboot_min_css__WEBPACK_IMPORTED_MODULE_12__);
/* harmony import */ var _css_default_css__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(410);
/* harmony import */ var _css_default_css__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(_css_default_css__WEBPACK_IMPORTED_MODULE_13__);
/* harmony import */ var _css_fontface_css__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(412);
/* harmony import */ var _css_fontface_css__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(_css_fontface_css__WEBPACK_IMPORTED_MODULE_14__);
/* harmony import */ var _css_base_css__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(414);
/* harmony import */ var _css_base_css__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(_css_base_css__WEBPACK_IMPORTED_MODULE_15__);
/* harmony import */ var _css_tooltips_css__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(416);
/* harmony import */ var _css_tooltips_css__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(_css_tooltips_css__WEBPACK_IMPORTED_MODULE_16__);
/* harmony import */ var _node_modules_codemirror_lib_codemirror_css__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(418);
/* harmony import */ var _node_modules_codemirror_lib_codemirror_css__WEBPACK_IMPORTED_MODULE_17___default = /*#__PURE__*/__webpack_require__.n(_node_modules_codemirror_lib_codemirror_css__WEBPACK_IMPORTED_MODULE_17__);
/* harmony import */ var _css_override_css__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(420);
/* harmony import */ var _css_override_css__WEBPACK_IMPORTED_MODULE_18___default = /*#__PURE__*/__webpack_require__.n(_css_override_css__WEBPACK_IMPORTED_MODULE_18__);
/* harmony import */ var _node_modules_codemirror_theme_monokai_css__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(422);
/* harmony import */ var _node_modules_codemirror_theme_monokai_css__WEBPACK_IMPORTED_MODULE_19___default = /*#__PURE__*/__webpack_require__.n(_node_modules_codemirror_theme_monokai_css__WEBPACK_IMPORTED_MODULE_19__);
/* harmony import */ var _node_modules_codemirror_theme_solarized_css__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(424);
/* harmony import */ var _node_modules_codemirror_theme_solarized_css__WEBPACK_IMPORTED_MODULE_20___default = /*#__PURE__*/__webpack_require__.n(_node_modules_codemirror_theme_solarized_css__WEBPACK_IMPORTED_MODULE_20__);
/* harmony import */ var _node_modules_codemirror_theme_zenburn_css__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(426);
/* harmony import */ var _node_modules_codemirror_theme_zenburn_css__WEBPACK_IMPORTED_MODULE_21___default = /*#__PURE__*/__webpack_require__.n(_node_modules_codemirror_theme_zenburn_css__WEBPACK_IMPORTED_MODULE_21__);
// ==UserScript==
// @name        markdown-render
// @namespace   dev.rivy
// @author      rivy
// @description renders markdown files
//
// @version     0.0.231
// @//updateURL   https://github.com/rivy/js-user.markdown-render/raw/master/markdown-render.user.js
//
// file extension: .m(arkdown|kdn?|d(o?wn)?)
// @include     file://*.markdown
// @include     file://*.mkdn
// @include     file://*.mkd
// @include     file://*.mdown
// @include     file://*.mdwn
// @include     file://*.md
//
// @require     https://cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/jquery.min.js
// @require     https://raw.githubusercontent.com/sizzlemctwizzle/GM_config/2207c5c1322ebb56e401f03c2e581719f909762a/gm_config.js
//
// @//grant       none
// @grant       GM_getValue
// @grant       GM_setValue
// @grant       GM_registerMenuCommand
// @grant       GM_xmlhttpRequest
// @grant       unsafeWindow
// ==/UserScript==
// spell-checker:words AMSmath AMSsymbols Cloudflare CodeMirror CommonMark Katex MathJax Pandoc Trello asciimath codeblock codeblocks deauthorize dequote markdownit monokai monospace repo rivy tooltip tooltips zenburn
// spell-checker:ignore CHTML Eedge IEedge Thiht activeline arkdown arve arve0 buttonface buttontext cdnjs cdns clike clippy deflist fontface githubusercontent hscrollbar jsdelivr linenumbers linkify mdwn mkdn rawgit retval runmode scrollbar scroller selectedtext tooltipped xmlhttp
// spell-checker:ignore esversion esnext eqeqeq
// jshint esnext: false, esversion: 6, bitwise: true, eqeqeq: true


var script_name = 'markdown-render';
var script_repo_path = 'rivy/js-user.' + script_name + '/';
var script_repo_CDN_commit = '520d0330bbc2202b0ca2b790e9a5a4d8a0c27c2b';
var script_repo_CDN_base_url = '//cdn.rawgit.com/' + script_repo_path + script_repo_CDN_commit + '/';

var ClipboardJS = __webpack_require__(107);

var grayMatter = __webpack_require__(108);

var markdownit = __webpack_require__(142);

var markdownItAnchor = __webpack_require__(197)["default"];

var markdownItAttrs = __webpack_require__(198);

var markdownItBracketedSpans = __webpack_require__(201);

var markdownItDecorate = __webpack_require__(202);

var markdownitDeflist = __webpack_require__(203);

var markdownitFootnote = __webpack_require__(204);

var markdownItReplacements = __webpack_require__(205); // const markdownItMeta = require('markdown-it-meta');
// CodeMirror mode scripts expect "CodeMirror" as an accessible global variable; use `script-loader` to load as a <script/>






 // * preload common CodeMirror modes into the bundle





 // import 'script-loader!codemirror/mode/rust/rust';  // causes "CodeMirror.defineSimpleMode is not a function" browser console error

 // KaTeX doesn't work in 'quirks' mode
// // import katex from 'katex';
// // var katexAutoRender = require('katex/contrib/auto-render/auto-render')
// import renderMathInElement from 'katex/contrib/auto-render/auto-render';
// // // import MathJax as a global script
// // // ToDO: investigate moving MathJax into usual `require ...`
// import 'script-loader!mathjax/MathJax.js?config=TeX-MML-AM_CHTML&delayStartupUntil=configured';
// var mjAPI = require("mathjax-node");
// mjAPI.config({
//     MathJax: {
//       jax: ["input/TeX","input/MathML","input/AsciiMath","output/CommonHTML"],
//       extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathMenu.js","MathZoom.js","AssistiveMML.js","a11y/accessibility-menu.js"],
//       TeX: {
//         extensions: ["AMSmath.js","AMSsymbols.js","noErrors.js","noUndefined.js"]
//       }
//     }
// });
// mjAPI.start();
// MathJax3

var MathJax = __webpack_require__(42).MathJax; // MathJax core


var TeX = __webpack_require__(229).TeX; // TeX input


var CHTML = __webpack_require__(242).CHTML; // HTML output


var browser = __webpack_require__(347).browserAdaptor; // browser DOM


var AllPackages = __webpack_require__(350).AllPackages;

__webpack_require__(386).RegisterHTMLHandler(browser());








 // * preload common CodeMirror CSS styles into the bundle

var CodeMirror_themes = new Map();
var CM_theme = '';
CM_theme = 'monokai';

CodeMirror_themes.set(CM_theme, (CodeMirror_themes.get(CM_theme) || -1) + 1);
CM_theme = 'solarized';

CodeMirror_themes.set(CM_theme, (CodeMirror_themes.get(CM_theme) || -1) + 1);
CM_theme = 'zenburn';

CodeMirror_themes.set(CM_theme, (CodeMirror_themes.get(CM_theme) || -1) + 1);
GM_registerMenuCommand("'".concat(script_name, "' Settings"), function () {
  GM_config.open();
});
GM_config.init({
  'id': script_name,
  'fields': {
    'CustomCSS_uri': {
      'label': 'CustomCSS URI',
      'type': 'string',
      'default': ''
    } //        'LogoutAction': {
    //            'label': 'Disconnect Trello',
    //            'type': 'button',
    //            'size': 100,
    //            'click': Trello.deauthorize
    //        }

  },
  'events': {
    'save': function save() {
      initialize();
      GM_config.close();
    },
    'reset': initialize
  }
});

function initialize() {//    initializeCss();
  //    initializeCards();
}

(function (
/* USERjs, */
window, $) {
  'use strict'; // #### config
  // note: using cloudflare (primary) and rawgit CDNs ~ for rawgit, (see https://github.com/rgrove/rawgit/blob/master/FAQ.md @@ http://archive.is/rMkAp)
  // note: see CDN ref @ https://cdnjs.com

  var CDN_base_url = '//cdnjs.cloudflare.com/ajax/libs/';
  var CDN_CM_base_url = CDN_base_url + 'codemirror/5.33.0/';
  var CDN_CSS_base_url = script_repo_CDN_base_url + 'css/';
  var assets_js = [// clipboard support
    // ... ref: [Name conflict with Chrome v61+](https://github.com/zenorocha/clipboard.js/issues/468)
    // ... ref: https://github.com/PrismJS/prism/issues/1181 ; https://github.com/PrismJS/prism/pull/1206
    // "//cdn.jsdelivr.net/gh/rivy/clipboard.js@021e74439d7d64da9e44bbfb488850ed7a4dadf4/dist/clipboard.min.js", // clipboard.js-2.0.1 *(quick-fix)
    // markdown conversion
    // CDN_base_url + "markdown-it/8.3.1/markdown-it.min.js",
    // markdown-it ~ attributes (pandoc compatible)
    // "//cdn.jsdelivr.net/gh/arve0/markdown-it-attrs@eef1b2ea2ed9d17738722950b75e259df1e4eb6f/markdown-it-attrs.browser.js", // markdown-it-attrs-1.2.1
    // markdown-it ~ bracketed spans
    // "//cdn.jsdelivr.net/gh/rivy/markdown-it-bracketed-spans@e17f9b658c58b7fb904db8b96f403d2f89206f41/dist/markdown-it-bracketed-spans.min.js", // markdown-it-bracketed-spans-1.0.1
    // markdown-it ~ definition lists
    // "//cdn.jsdelivr.net/gh/markdown-it/markdown-it-deflist@8f2414f23316a2ec1c54bf4631a294fb2ae57ddd/dist/markdown-it-deflist.min.js", // markdown-it-deflist-2.0.1
    // markdown-it ~ footnotes
    // CDN_base_url + "markdown-it-footnote/3.0.1/markdown-it-footnote.min.js",
    // markdown-it ~ meta
    // "//cdn.jsdelivr.net/gh/rivy/markdown-it-meta@466fea07c5e8d5442c0c572f505c330e21f38477/dist/markdown-it-meta.js",
    // CodeMirror / highlighting
    // CDN_CM_base_url + "codemirror.min.js",
    // CDN_CM_base_url + "mode/meta.min.js",
    // CDN_CM_base_url + "addon/runmode/runmode.min.js",
    // CDN_CM_base_url + "addon/runmode/colorize.min.js",
    // CDN_CM_base_url + "addon/selection/mark-selection.js",
    // MathJax
    //  CDN_base_url + "mathjax/2.7.5/MathJax.js?config=TeX-MML-AM_CHTML&delayStartupUntil=configured",
    //CDN_base_url + "mathjax/2.7.5/MathJax.js?config=TeX-AMS-MML_HTMLorMML",
    //  ],
    // // KaTeX
    // CDN_base_url + "KaTeX/0.10.1/katex.min.js",
    // CDN_base_url + "KaTeX/0.10.1/contrib/auto-render.min.js",
  ];
  var assets_css = [// reset ~ see http://meyerweb.com/eric/tools/css/reset @@ http://archive.is/XvC4w
    // ... see https://stackoverflow.com/questions/3388705/why-is-a-table-not-using-the-body-font-size-even-though-i-havent-set-the-table/3388766#3388766 @@ http://archive.is/wePmk
    // CDN_base_url + "meyer-reset/2.0/reset.min.css",
    //  // ref: [normalize] http://necolas.github.io/normalize.css @@ http://archive.is/Fo0od ; info: http://nicolasgallagher.com/about-normalize-css @@ http://archive.is/RSXip ; repo: https://github.com/necolas/normalize.css
    //  "//cdnjs.cloudflare.com/ajax/libs/normalize/7.0.0/normalize.min.css",
    // ref: https://v4-alpha.getbootstrap.com/content/reboot
    // CDN_base_url + "twitter-bootstrap/4.0.0-beta.3/css/bootstrap-reboot.min.css",
    // basic
    // CDN_CSS_base_url + "_default.css",
    // CDN_CSS_base_url + "_fontface.css",
    // CDN_CSS_base_url + "base.css",
    //  "//raw.githubusercontent.com/Thiht/markdown-viewer/master/chrome/lib/sss/sss.css",
    //  "//raw.githubusercontent.com/Thiht/markdown-viewer/master/chrome/lib/sss/sss.print.css",
    // tooltip CSS
    // CDN_CSS_base_url + "tooltips.css",
    // syntax highlighter
    // CDN_CM_base_url + "codemirror.min.css",
    // overrides (* last in order to override prior CSS, without requiring increased CSS specificity)
    // CDN_CSS_base_url + "+override.css",
  ];
  var custom_css = GM_config.get('CustomCSS_uri') || ''; // #### main()

  (function main() {
    'use strict';

    var protocol = window.location.protocol === 'http:' ? 'http:' : 'https:'; // use 'https:' unless current page is using 'http:'

    console.log('document.compatMode = ' + document.compatMode);
    console.log('contentType', window.document.contentType); //console.log(window.document);

    $.when([]) // `.when([])` resolves immediately
    .then(function () {
      return load_raw_text();
    }) // .then( ()=>{ return $('html').attr('lang','en'); } ) // ref: http://blog.adrianroselli.com/2015/01/on-use-of-lang-attribute.html @@ http://archive.is/H0ExZ (older, better typography) + http://archive.is/chYjS
    .then(function () {
      return load_assets(assets_css.concat(assets_js));
    }).then(function () {
      return load_assets(custom_css, undefined, true);
    })["catch"](function (e) {}).then(function () {
      return $.when(do_render(), // $.getScript( [ protocol+CDN_base_url+'mathjax/2.7.5/MathJax.js?config=TeX-MML-AM_CHTML&delayStartupUntil=configured' ] )
      //   .then( trigger_render_MathJax )
      //   .then( ()=>{console.log('MathJax triggered');} ) , // ToDO: discuss the MathJax requirement for `$.getScript( ... )` instead of being able to `eval( ... )` with a MathJax root config on <https://github.com/mathjax/MathJax/issues>
      render_MathJax3(), $.when([]) // placeholder at end-of-list (only syntactic sugar)
      );
    }).then(function () {
      console.log('main(): promise chain completed');
    }).done(function () {
      console.log('main(): DONE ');
    })["catch"](function () {
      console.log('main(): CATCH ');
    }).always(function () {
      console.log('main(): ALWAYS ');
    });
    return;
  })(); // #### subs


  function do_render() {
    // () => {jQuery.Deferred}
    var _ME = 'do_render()';
    console.log(_ME + ': rendering markdown');
    var original = $('body pre').text();
    var render = render_markdown(original);
    $('body pre').remove();
    $('<div style="display:none"/>').html($('<pre/>').text(original)).attr('id', '_src').appendTo('body');
    $('<div/>').html(render).appendTo('body');
    console.log(_ME + ': write data for CODE');
    set_code_data();
    console.log(_ME + ': package codeblocks');
    package_codeblocks(); // find any needed CodeMirror modes (for lazy loading)

    var CodeMirror_mode_js_map = new Map(); //    $('code [class*="language-"]').each( function( index ) {

    $('code').each(function (index) {
      var $CODE = $(this);
      var name = get_language_name($CODE);
      var mime = get_language_mime($CODE);

      if (name === mime && name === undefined) {
        return;
      }

      var CM_mode = find_CM_mode(mime) || find_CM_mode(name);

      if (CM_mode.mode === 'null' || mime === 'text/plain' || name === 'none' || name === 'null' || name === 'plain') {
        return;
      }

      if (!CM_mode) {
        warn("unknown code language ('".concat(name, "'; mime:'").concat(mime, "')"));
        return;
      }

      var CM_mode_template = CDN_CM_base_url + "mode/%N/%N.min.js";
      var CM_mode_uri = CM_mode_template.replace(/%N/g, CM_mode.mode);
      console.log("found requested CodeMirror.mode='".concat(CM_mode.mode, "' for language='").concat(name, "'; URL = '").concat(CM_mode_uri, "'"));

      if (!CodeMirror.modes[CM_mode.mode]) {
        console.log("add asset download request for URL = '".concat(CM_mode_uri, "'"));
        CodeMirror_mode_js_map.set(CM_mode_uri, (CodeMirror_mode_js_map.get(CM_mode_uri) || 0) + 1); //        CodeMirror_mode_js_map.set( CM_mode_uri, true );
      }
    }); // find any needed CodeMirror themes (for lazy loading)

    var CodeMirror_theme_css_map = new Map();
    $('code').each(function (index) {
      var $CODE = $(this);
      var theme = get_theme($CODE);

      if (theme === undefined || theme === 'default') {
        return;
      }

      var theme_name = theme.split(/[\s.]+/)[0];
      var CM_theme_template = CDN_CM_base_url + "theme/%N.min.css";
      var CM_theme_uri = CM_theme_template.replace(/%N/g, theme_name);
      console.log("found requested theme='".concat(theme, "'; URL = '").concat(CM_theme_uri, "'"));

      if (!CodeMirror_themes.has(theme_name)) {
        console.log("add asset download request for URL = '".concat(CM_theme_uri, "'"));
        CodeMirror_theme_css_map.set(CM_theme_uri, (CodeMirror_theme_css_map.get(theme_name) || 0) + 1);
      }

      CodeMirror_themes.set(theme_name, (CodeMirror_themes.get(theme_name) || 0) + 1);
    });
    var assets = Array.from(CodeMirror_theme_css_map.keys()).concat(Array.from(CodeMirror_mode_js_map.keys()));
    return $.when([]).then(function () {
      return load_assets(assets, undefined, true);
    })["catch"](function (e) {}).then(function () {
      console.log(_ME + ': transform codeblocks'); // required CSS
      // ToDO: discuss the need for '.CodeMirror-scroll { height: auto; }' on <https://discuss.codemirror.net>
      //  ...  ? why; And is there a way to calculate the true height? ... (show `... .find('.CodeMirror-sizer').height()`, which fails if scrollbar is shown)
      //  ...  without `.CodeMirror-gutters { height: auto !important }` the inner portion of the editor is over-sized and captures scroll-wheel movement (scrolling text off screen)
      //$('head').append('<style type="text/css">.CodeMirror, .CodeMirror-scroll { height: auto; } .CodeMirror-gutters {height: auto !important}</style>');

      $('head').append('<style type="text/css">.CodeMirror, .CodeMirror-scroll { height: auto; }</style>'); //$('head').append('<style type="text/css">.CodeMirror, .CodeMirror-scroll { height: auto; }</style>');

      transform_codeblocks_to_CodeMirror(); // NOTE: all <code> within CODEBLOCKS have, at this point, been removed by conversion to CodeMirror components; only inline-type <code> elements remain

      add_codeblock_snippet_support();
      highlight_code(); // highlight <code/> elements, as needed (only those tagged with a language)
    });
  }

  var css_class_button = 'button';
  var css_class_codeblock = 'codeblock';
  var css_class_tooltip = 'tooltipped';
  var css_class_tooltip__below = 'tooltipped--s'; // tooltipped--s == position tooltip below

  function add_codeblock_snippet_support() {
    var _ME = 'add_codeblock_snippet_support()';
    var css_class_snip_button = "".concat(css_class_button, "--snip"); // unique / identifying class name

    var css_class_snip_button$ = "".concat(css_class_snip_button, " ").concat(css_class_button); // unique / ID class must be leftmost in the string

    var css_class_snip_button_tooltip$ = "".concat(css_class_tooltip, " ").concat(css_class_tooltip__below);
    var clipboard_src = 'https:' + script_repo_CDN_base_url + 'master/assets/clippy.svg';
    var clipboard_alt = 'Copy to clipboard';
    var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
    /* expected CSS */

    $('head').append('<style type="text/css">' + //'button { align-items: flex-start; text-align: center; cursor: default; color: buttontext; background-color: buttonface; box-sizing: border-box; padding: 2px 6px 3px; border-width: 2px; border-style: outset; border-color: buttonface; border-image: initial; }' +
    ".".concat(css_class_button, " { font-size: 1em; line-height: normal; }") + ".".concat(css_class_button, " { border-width: 1px; }") + ( // increases similarity of appearance between Chrome/Firefox
    isFirefox ? ".".concat(css_class_button, " { padding: 0 0.5rem; }") : ".".concat(css_class_button, " { padding: 0 0.5rem 1px; }")) + ".".concat(css_class_codeblock, " { position: relative; }") + //`.${css_class_codeblock} { page-break-inside: avoid; }` +
    ".".concat(css_class_codeblock, " .").concat(css_class_snip_button, " { position: absolute; top: 0.25em; right: 0.2em; z-index: 101; opacity: 0.1; transition: opacity 0.3s ease-in-out; -webkit-transition: opacity 0.3s ease-in-out; }") +
    /* z-index is used within CodeMirror, use a larger index; heuristic == 10; ToDO: investigate via CodeMirror discourse */
    ".".concat(css_class_codeblock, ":hover .").concat(css_class_snip_button, " { opacity: 1; }") +
    /* z-index is used within CodeMirror, use a larger index; heuristic == 10; ToDO: investigate via CodeMirror discourse */
    '</style>');
    var $codeblocks = $(".".concat(css_class_codeblock));
    $codeblocks.each(function (index) {
      ///console.log( _ME + ': index = ' + index );
      //let content = $('<img />', { height:'100%', src: clipboard_src, alt: clipboard_alt} );
      var content = 'Copy';
      var $button = $('<button>', {
        'class': css_class_snip_button$
      }).prepend(content);
      $(this).prepend($button); //$(this).find('.CodeMirror').get(0).CodeMirror.refresh();
    }); //(function(){

    var _selector = ".".concat(css_class_snip_button); ///console.log( '_selector = '+_selector );


    var snippers = new ClipboardJS(_selector, {
      text: function text(trigger) {
        var $cm = $(trigger).parent().find('.CodeMirror');
        return $cm.get(0).CodeMirror.getDoc().getValue() + "\n";
      }
    });
    snippers.on('success', function (e) {
      e.clearSelection();
      showTooltip(e.trigger, 'Copied!');
    });
    snippers.on('error', function (e) {
      showTooltip(e.trigger, fallbackMessage(e.action));
    });
    var buttons = document.querySelectorAll(_selector);

    for (var i = 0; i < buttons.length; i++) {
      buttons[i].addEventListener('mouseleave', function (e) {
        $(e.currentTarget).removeClass(css_class_snip_button_tooltip$);
        e.currentTarget.removeAttribute('aria-label');
      });
    }

    function showTooltip(elem, msg) {
      $(elem).addClass(css_class_snip_button_tooltip$);
      elem.setAttribute('aria-label', msg);
    }

    function fallbackMessage(action) {
      var actionMsg = '';
      var actionKey = action === 'cut' ? 'X' : 'C';

      if (/iPhone|iPad/i.test(navigator.userAgent)) {
        actionMsg = 'No support :(';
      } else if (/Mac/i.test(navigator.userAgent)) {
        actionMsg = 'Press ⌘-' + actionKey + ' to ' + action;
      } else {
        actionMsg = 'Press Ctrl-' + actionKey + ' to ' + action;
      }

      return actionMsg;
    } //})();

  }

  function render_MathJax3() {
    var html = MathJax.document(document, {
      InputJax: new TeX({
        inlineMath: [['$', '$'], ['${', '}$'], ['$\\phantom{}', '\\phantom{}$']],
        displayMath: [['$$', '$$'], ['$${', '}$$']],
        processEnvironments: true,
        packages: AllPackages
      }),
      OutputJax: new CHTML({
        fontURL: 'https://cdn.rawgit.com/mathjax/mathjax-v3/3.0.0-beta.3/mathjax2/css'
      })
    });
    html.findMath().compile().getMetrics().typeset().updateDocument();
  }

  function trigger_render_MathJax() {
    if (unsafeWindow.MathJax === undefined) return; //    let MathJax_root_uri = 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5';

    unsafeWindow.MathJax.Hub.Config({
      //root: MathJax_root_uri,
      tex2jax: {
        inlineMath: [['$', '$'], ['${', '}$'], ['$\\phantom{}', '\\phantom{}$']],
        displayMath: [['$$', '$$'], ['$${', '}$$']],
        processEnvironments: true
      }
    });
    unsafeWindow.MathJax.Hub.Configured();
  }

  function package_codeblocks() {
    var _ME = 'package_codeblocks()';
    $('pre code').each(function () {
      var $CODE = $(this);
      var class_text = $CODE.attr('class') ? 'class = "' + $CODE.attr('class') + '"' : 'class not defined';
      var theme_text = get_theme($CODE);
      console.log(_ME + ': block found == CODE(' + class_text + '; theme = ' + theme_text + ')'); // hoist 'id' and copy attributes from CODE to PRE

      var $PRE = $CODE.parent('pre');
      $PRE.hoistID($CODE);
      $PRE.copyAllAttributes($CODE); // create new DIV 'codeblock' and hoist id from PRE to DIV

      var $DIV = $PRE.wrapAll('<div/>').parent('div');
      $DIV.addClass(css_class_codeblock);
      $DIV.hoistID($PRE);
      $DIV.copyAllAttributes($PRE);
      class_text = $DIV.attr('class') ? 'class = "' + $DIV.attr('class') + '"' : 'class not defined';
      theme_text = get_theme($DIV);
      console.log(_ME + ': ... => DIV(' + class_text + '; theme = ' + theme_text + ')');
    });
  }

  function find_CM_mode(name) {
    // ref: valid modes/names are listed @ <https://github.com/codemirror/CodeMirror/blob/8b9d8e337eb7c1d48d42589a5caee0a2215f620c/mode/meta.js#L14-169>
    return CodeMirror.findModeByMIME(name) || CodeMirror.findModeByName(name) || function (mode) {
      mode = mode.toLowerCase();

      for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
        var info = CodeMirror.modeInfo[i];
        if (info.mode.toLowerCase() === mode) return info;
      }
    }(name);
  }

  function get_language_name($node) {
    var _ME = 'get_language_name()';
    var attr_class = $node.attr('class') || '';
    var match = dequote($node.attr('data-lang') || (attr_class.match(/(?:^|\s)language-(\w\S*)/) || attr_class.match(/^\s*(\w\S*)/) || [null, undefined])[1]);
    return match;
  }

  function get_language_mime($node) {
    var _ME = 'get_language_mime()';
    var mime = dequote($node.attr('data-mime'));

    if (mime !== undefined) {
      return mime;
    }

    var name = get_language_name($node);

    if (name === undefined) {
      return undefined;
    }

    var CM_mode = find_CM_mode(name) || CodeMirror.findModeByName('Plain Text');
    return dequote(CM_mode.mime);
  }

  function get_theme($node) {
    var _ME = 'get_theme()';
    return dequote($node.attr('data-theme') || $node.css('--theme') || 'default').trim();
  }

  function get_prefix($node) {
    var _ME = 'get_prefix()';
    return dequote($node.attr('data-prefix') || $node.css('--prefix') || '').trim();
  }

  function set_code_data() {
    var _ME = 'set_code_data()';
    $('code').each(function () {
      // add a 'data-lang' and 'data-mime' attributes, if needed and possible
      var $CODE = $(this);
      $CODE.attr('data-lang', get_language_name($CODE) || null);
      $CODE.attr('data-mime', get_language_mime($CODE) || null);
    });
  }

  function highlight_code() {
    // highlight all <code/> elements which are tagged with a language
    var _ME = 'highlight_code()';
    var $code_with_language = $('code[data-lang]');
    CodeMirror.colorize($code_with_language); // add CodeMirror theme, if defined

    var index = 0;
    $code_with_language.each(function () {
      var $CODE = $(this);
      var theme = get_theme($CODE);
      console.log(_ME + ": theme = ".concat(theme));

      if (theme !== 'default') {
        $CODE.removeClass('cm-s-default');
        var theme_classes = theme.split(/[\s.]+/);
        theme_classes = theme_classes.map(function (element) {
          return ('cm-s-' + element).trim();
        });
        $CODE.addClass(theme_classes.join(' ')); // note: color / background for themes is defined by 'cm-s-theme.CodeMirror ...', but assigning a CodeMirror class pulls in other, inappropriate, CSS
        // add .CodeMirror (but only temporarily)

        var had_class_CM = $CODE.hasClass('CodeMirror');
        $CODE.addClass('CodeMirror');
        var background_color = $CODE.css('background-color');
        var color = $CODE.css('color');
        if (!had_class_CM) $CODE.removeClass('CodeMirror');
        var css_class = ['code'].concat(theme_classes).join('.'); ///console.log( _ME+`: background_color = ${background_color}`);
        ///console.log( _ME+`: color = ${color}`);
        ///console.log( _ME+`: css_class = ${css_class}`);

        var id = '_' + css_class;
        var $CSS = $("#".concat(id)).length || $('<style type="text/css" />').html("".concat(css_class, " { background-color: ").concat(background_color, "; color: ").concat(color, " }")).attr('id', id).appendTo('head');
      }
    });
  }

  function transform_codeblocks_to_CodeMirror() {
    // setup CodeMirror as container and syntax highlighter
    var _ME = 'transform_codeblocks_to_CodeMirror()';
    /* expected CSS for *mark-selection* */
    //    $('head').append(
    //        '<style type="text/css">' +
    //        '.CodeMirror-selected  { background-color: blue !important; }' +
    //        //'.CodeMirror-selectedtext { color: white; }' +
    //        '</style>'
    //    );

    var CM_theme_cache = new Map();
    var $codeblock = $(".".concat(css_class_codeblock));
    $codeblock.children('pre').children('code').each(function () {
      var $CODE = $(this);
      var class_text = $CODE.attr('class') ? 'class = "' + $CODE.attr('class') + '"' : 'class not defined';
      console.log(_ME + ': block found == CODE(' + class_text + ')');
      var $PRE = $CODE.parent('pre');
      var $DIV = $PRE.parent('div');
      var $codeblock = $DIV;
      console.log(_ME + ': DIV.codeblock(' + $codeblock.attr('class') + ')');

      var _lineWrapping = $DIV.hasClass('line-wrapping') || $DIV.hasClass('line-wrap') || $DIV.hasClass('wrapLines') || $DIV.hasClass('wordwrap');

      var _lineNumbers = $DIV.hasClass('line-numbers') || $DIV.hasClass('numberLines');

      if (_lineWrapping && !$DIV.hasClass('line-wrapping')) {
        $DIV.addClass('line-wrapping');
      }

      if (_lineNumbers && !$DIV.hasClass('line-numbers')) {
        $DIV.addClass('line-numbers');
      }

      var _firstLineNumber = isDefined($DIV.attr('startFrom')) ? parseInt($DIV.attr('startFrom')) : 1; // NOTE: for conversion alternatives, see https://coderwall.com/p/5tlhmw/converting-strings-to-number-in-javascript-pitfalls @@ http://archive.is/1CH5w


      var _gutters = [];

      if (_lineNumbers) {
        _gutters.push('CodeMirror-linenumbers');
      }

      var prefix = get_prefix($DIV);

      if (prefix !== null && prefix !== '') {
        _gutters.push('CodeMirror-prefix');

        var n;

        for (n = 1; n < prefix.length; n++) {
          _gutters.push("CodeMirror-prefix CodeMirror-prefix-sizer CodeMirror-prefix-sizer-".concat(n));
        }
      }

      if (_gutters.length < 1) {
        _gutters = ['CodeMirror-gutter-extra'];
      }

      var _mode = dequote($DIV.attr('data-mime') || 'text/plain');

      console.log('_mode = ' + _mode);

      var _theme = get_theme($DIV);

      console.log('_theme = ' + _theme); // ToDO: refactor ; is this a hack? load_assets is async (? need a promise here? convert transform_codeblocks_to_CodeMirror() to async with promise return? )

      if (_theme !== undefined && _theme !== 'default') {
        var CM_theme_template = CDN_CM_base_url + "theme/%N.min.css";
        var CM_theme_uri = CM_theme_template.replace(/%N/g, _theme.split(/[\s.]+/)[0]);

        if (!CM_theme_cache.get(CM_theme_uri)) {
          load_assets(CM_theme_uri, undefined, true);
        }

        CM_theme_cache.set(CM_theme_uri, true);
      }

      var _value = $('<div/>').html($CODE.html()).text().trimRight(); // use the CodeMirror standard <textarea/> idiom ## (not strictly necessary, but may save coding aggravation)


      $DIV.empty();
      $DIV.append('<textarea/>');
      var $element = $DIV.children('textarea');
      $element.text(_value);
      var cm = CodeMirror.fromTextArea($element.get(0), {
        mode: _mode,
        lineNumbers: _lineNumbers,
        lineWrapping: _lineWrapping,
        firstLineNumber: _firstLineNumber,
        gutters: _gutters,
        theme: _theme,
        //
        styleSelectedText: true,
        //
        readOnly: true,
        viewportMargin: Infinity
      }); ///console.log( 'sizer.height = ' + $element.find('.CodeMirror-sizer').height());
      ///console.log( 'cm.getScrollerElement().clientHeight = ' + cm.getScrollerElement().clientHeight );
      ///console.log( 'cm.getWrapperElement().offsetHeight ' + cm.getWrapperElement().offsetHeight );
      ///console.log( 'scrollerElement.scrollHeight = ' + cm.getScrollerElement().scrollHeight );
      ///console.log( 'doc.height = ' + cm.doc.height );
      ///console.log( 'hscrollbar.height = ' + $element.find('.CodeMirror-hscrollbar').height());
      //cm.setSize( null, $element.find('.CodeMirror-sizer').height());
      //cm.setSize( null, 'auto');
      //cm.setSize();
      //cm.refresh();
      //        cm.on("refresh", function(cm) {
      //          console.log('in refresh');
      //        });
      //        cm.on("change", function(cm, change) {
      //          console.log("something changed! (" + change.origin + ")");
      //        });
      // HACK: corrects Chrome miscalculation of gutter heights for non-line-wrapped codeblocks
      // NOTE: for expandable blocks, the calculation must be remade whenever lines are added or removed, or scrollbars are turned on/off

      if (isChrome()) {
        cm.on('viewportChange', function (cm, from, to) {
          console.log('viewport changed! (' + from + ' => ' + to + ')');
          reset_gutter_heights(cm);
        }); //CodeMirror.signal( cm, 'viewportChange', cm );

        cm.on('refresh', function (cm) {
          console.log('refresh() triggered');
          reset_gutter_heights(cm);
        });
        reset_gutter_heights(cm);
      } // zebra-fy
      //let BACK_CLASS = 'CodeMirror-activeline-background';


      var BACK_CLASS = 'codeblock-line';
      var lineCount = cm.lineCount();

      for (var i = 1; i <= lineCount; i++) {
        var suffix = '-odd';

        if (i % 2 === 0) {
          suffix = '-even';
        }

        cm.addLineClass(i - 1, 'background', BACK_CLASS + suffix);

        if (prefix !== null && prefix !== '') {
          cm.setGutterMarker(i - 1, "CodeMirror-prefix", make_prefix(prefix));
        }
      }
    });
  }

  function reset_gutter_heights(cm) {
    // HACK: corrects Chrome miscalculation of gutter heights for non-line-wrapped codeblocks
    // NOTE: for expandable blocks, the calculation must be remade whenever lines are added or removed, or scrollbars are turned on/off
    var $G = $(cm.getWrapperElement()).find('.CodeMirror-gutters');
    var h = $G.css('height');
    $G.children('.CodeMirror-gutter').each(function () {
      var $GUTTER = $(this);
      $GUTTER.css({
        'height': h
      });
    });
  }

  function make_prefix(s) {
    var marker = document.createElement("div");
    marker.classList.add('CodeMirror-prefix-text');
    marker.innerHTML = s;
    return marker;
  }

  function render_markdown(text) {
    //md = md || new markdownit( 'commonmark', {
    var md = new markdownit({
      html: true,
      //linkify: true,
      typographer: true //highlight: highlight_code,

    }); // plugins

    md.use(markdownItAttrs);
    md.use(markdownItBracketedSpans);
    md.use(markdownitDeflist);
    md.use(markdownItDecorate);
    md.use(markdownitFootnote); // md.use(markdownItMeta);

    md.use(markdownItReplacements, {
      ellipsis: false
    }); // disable faulty ellipsis replacement (`...` => `…`)

    md.use(markdownItAnchor, {
      permalink: true,
      permalinkBefore: true,
      permalinkSymbol: '#',
      permalinkSpace: false
    }); // after 'attrs' (see <https://github.com/valeriangalliat/markdown-it-anchor/issues/49#issuecomment-431632231>)
    // parse and remove any initial front matter

    var matter = grayMatter(text);
    var content = matter.content; // add meta-data 'title' as initial H1 header (if present)

    if (matter.data.title) {
      content = "# " + matter.data.title + "\n\n" + content;
    }

    return md.render(content);
  } // ** load functions (async)


  function load_raw_text(uri, timeout) {
    // ( {array}, {int} ) => {jQuery.Deferred}
    // Firefox misinterprets non-HTML (non .htm/.html extension) files as HTML if they contain initial HTML tags and irretrievably alters the text ... this replaces the body content with text equivalent to chrome's interpretation
    // NOTE: no perceptible speed difference when using this on a high-end machine (via both SSD or HD)
    //   ... *unneeded by chrome* (also, blocked by cross-origin issue ... ; see below comments) */
    // ToDO: comment / request fix on "support.mozilla.org" (similar to: https://support.mozilla.org/en-US/questions/898460)
    // ToDO: change to GM_xmlhttpRequest
    // const isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
    var retVal = $.Deferred(); // if (window.document.contentType === 'text/html') {

    uri = uri || document.location.href;
    timeout = timeout !== null && timeout >= 0 ? timeout : 2 * 1000
    /* ms */
    ;

    if (isChrome()) {
      // ref: https://wiki.greasespot.net/GM.xmlHttpRequest @@ https://web.archive.org/web/20190821010800/https://wiki.greasespot.net/GM.xmlHttpRequest
      GM_xmlhttpRequest({
        // * works for chrome-ish browsers when
        // ... 1. [as noted in README] "chrome://extensions" / for the TamperMonkey extension, ENABLE the "Allow access to file URLs" option
        // ... 2. "chrome://extensions" / Site Access == SELECT "All sites" ## ToDO: add to README?
        // ... 3. TamperMonkey / Settings / Security / "Allow scripts to access local files" == "All local files"
        // * does NOT work for Firefox; ref: https://github.com/Tampermonkey/tampermonkey/issues/347 ; https://bugzilla.mozilla.org/show_bug.cgi?id=1266960
        // ... "Refused to connect to "file:///C:/...": NetworkError when attempting to fetch resource."
        method: "GET",
        url: uri,
        headers: {
          // "User-Agent": "Mozilla/5.0",    // If not specified, navigator.userAgent will be used.
          "Accept": "text/plain; charset=x-user-defined" // If not specified, browser defaults will be used.

        },
        onload: function onload(response) {
          retVal.resolve(response);
        }
      });
      retVal.done(function (response) {
        $('body').empty();
        $('<pre/>', {
          style: 'word-wrap: break-word; white-space: pre-wrap;'
        }).text(response.responseText).appendTo('body'); // var responseXML = null;
        // // Inject responseXML into existing Object (only appropriate for XML content).
        // if (!response.responseXML) {
        //   responseXML = new DOMParser()
        //     .parseFromString(response.responseText, "text/xml");
        // }

        console.log(['load_raw_text():GM_xmlhttpRequest', 'status', response.status, 'statusText', response.statusText, 'readyState', response.readyState, 'responseHeaders', response.responseHeaders, 'responseText', response.responseText, 'finalUrl', response.finalUrl // ,
        // responseXML
        ].join("\n"));
      });
    } else {
      // * fails for chrome-like browsers: ajax throws here for the "file:///" protocol => "VM4117:7 XMLHttpRequest cannot load file:///C:/Users/Roy/OneDrive/Projects/%23kb/%23pandoc/README.md. Cross origin requests are only supported for protocol schemes: http, data, chrome, chrome-extension, https."
      // ... ref: http://stackoverflow.com/questions/4819060/allow-google-chrome-to-use-xmlhttprequest-to-load-a-url-from-a-local-file/18137280#18137280 @@ http://archive.is/W7a9M
      // suppress XML parsing error for returned content using a MIME override (and assume UTF-8 charset)
      // ... ref: https://stackoverflow.com/questions/16932930/ajax-response-errorxml-parsing-error-no-element-found-location-moz-nullprinci/46920606#46920606 @@ https://web.archive.org/web/20190821002437/https://stackoverflow.com/questions/16932930/ajax-response-errorxml-parsing-error-no-element-found-location-moz-nullprinci/46920606
      retVal = $.ajax(uri, {
        cache: true,
        dataType: 'text',
        timeout: timeout,
        beforeSend: function beforeSend(xhr) {
          xhr.overrideMimeType("text/plain; charset=utf-8");
        }
      }).done(function (data, statusText, jqXHR) {
        $('body').empty();
        $('<pre/>', {
          style: 'word-wrap: break-word; white-space: pre-wrap;'
        }).text(data).appendTo('body');
        console.log('load_raw_text():ajax', 'data', data);
      });
    } // } else { retVal.resolve(); }


    return retVal;
  }

  function load_assets(uris, timeout, optional) {
    // ( {array} [, {int}timeout=0] [, {bool}optional=false] ) => {jQuery.Deferred}

    /**
     * load assets in parallel, insert/initialize results *in order* within the document (creating determinate content from async downloads)
     * @param {array} : an array of script uris, loaded asynchronously, but placed into the file in the given order
     * @param {int}   : a timeout for download failure (default == 0 (aka, no timeout))
     * @returns {jQuery.Deferred}
     * ref: (based on) https://stackoverflow.com/questions/9711160/jquery-load-scripts-in-order/19777866#19777866 @@ https://archive.is/yt1su
     * ref: (based on) https://gist.github.com/rivy/5f1bd5225d4ee315a8d7f3c89986600f from https://gist.github.com/ngryman/7309432
     * ref: https://community.oracle.com/blogs/driscoll/2009/09/08/eval-javascript-global-context @@ http://archive.is/qy9fL
     * ref: [jqXHR ~ .done/.fail/.always/.then argument documentation] http://api.jquery.com/jQuery.ajax/#jqXHR
     */
    // NOTE: this function is needed b/c CSS and JS have order dependence (for rules with equivalent specificity and initialization dependencies, respectively)
    timeout = timeout !== null && timeout >= 0 ? timeout : 2 * 1000
    /* ms */
    ;
    optional = optional !== null ? !!optional : false;
    var _ME = 'load_assets()';
    var asset_uris = $.isArray(uris) ? uris : [uris];
    var retVal = $.Deferred; ///console.log( `${_ME}: asset_uris = ${JSON.stringify( asset_uris )}`);

    asset_uris = asset_uris.filter(function (uri) {
      if (uri === undefined || uri === null || uri === '') {
        return;
      } else {
        return true;
      }
    }); ///console.log( `${_ME}: asset_uris.filter() = ${JSON.stringify( asset_uris )}`);

    if (asset_uris.length < 1) {
      return retVal;
    }

    var default_protocol = window.location.protocol === 'http:' ? 'http:' : 'https:'; // use 'https:' unless current page is using 'http:'

    var requests = asset_uris.map(function (asset_uri) {
      var uri = asset_uri.trim(); ///console.log( `${_ME}: uri = ${JSON.stringify( uri )}`);

      if (/^[\/\\][\/\\]/.test(uri)) {
        uri = default_protocol + uri;
      }

      var uri_path = new URL(uri, window.location).pathname;
      var uri_filename = uri_path.replace(/^.*[\\\/]/, '');
      var uri_extension = uri_filename.replace(/^.*(?=\.)/, '');

      if (uri_extension === uri_filename) {
        uri_extension = '';
      }

      if (uri_extension === '') {
        uri_extension = new URL(uri, window.location).hash.replace(/^.*(?=\.)/, '') || '';
      }

      console.log("".concat(_ME, ": initiating AJAX download of \"").concat(uri, "\" [filename = \"").concat(uri_filename, "\"; extension = \"").concat(uri_extension, "\")"));
      var jqXHR = $.ajax(uri, {
        cache: true,
        dataType: 'text',
        timeout: timeout
      });
      jqXHR.uri = uri;
      jqXHR.extension = uri_extension;
      return jqXHR;
    }); ///console.log( `${_ME}: requests::${JSON.stringify(requests)}::` );

    retVal = $.when.apply($, requests).done(function () {
      var args = $.isArray(arguments[0]) ? arguments : [arguments];
      Array.prototype.forEach.call(args, function (request
      /* :: [data, textStatus, jqXHR] */
      , index) {
        var jqXHR = request[2];
        var data = request[0]; ///console.log( `${_ME}: done::${JSON.stringify(request)}:: (${jqXHR.status}) '${jqXHR.statusText}' for "${jqXHR.uri}"` );

        if (jqXHR.extension === '.css') {
          console.log("insert style from \"".concat(jqXHR.uri, "\""));
          $('<style type="text/css" />').html(data).attr('_uri', jqXHR.uri).attr('_index', index).appendTo('head');
        }

        if (jqXHR.extension === '.js') {
          // console.log( `eval() script from "${jqXHR.uri}"` );
          // window['eval'].call( window, data );  // jshint ignore:line
          console.log("insert script from \"".concat(jqXHR.uri, "\""));
          $('<script />').html(data).attr('_uri', jqXHR.uri).attr('_index', index).appendTo('body'); // or `$.getScript()`? ref: <https://stackoverflow.com/questions/3857874/how-to-dynamically-insert-a-script-tag-via-jquery-after-page-load#3857899>
        }
      });
    }).fail(function () {
      Array.prototype.forEach.call(arguments, function (request
      /* :: [jqXHR, textStatus, errorThrown] */
      , index) {
        var message = "failed to load ".concat(optional ? '( optional ) ' : '', "asset \"").concat(request.uri, "\"");

        if (optional) {
          console.log(_ME + ": warn: ".concat(message, " ::").concat(JSON.stringify(request), "::"));
        } else {
          console.log("".concat(_ME, ": ERR!: ").concat(message, " ::").concat(JSON.stringify(request), "::"));
          error(message + '; render halted');
          throw Error("".concat(_ME, ": ERR!: ").concat(message));
        }
      });
    });
    return retVal;
  } // ** jQuery "graft-on" functions


  (function ($) {
    // ref: http://stackoverflow.com/questions/6753362/jquery-how-to-copy-all-the-attributes-of-one-element-and-apply-them-to-another/24626637#24626637 @@ http://archive.is/i92ld
    $.fn.hoistID = function (from) {
      // from: source jQuery element
      if ($(from).attr('id')) {
        $(this).attr('id', $(from).attr('id'));
        $(from).removeAttr('id');
      }

      return this;
    };
  })(jQuery);

  (function ($) {
    // ref: http://stackoverflow.com/questions/6753362/jquery-how-to-copy-all-the-attributes-of-one-element-and-apply-them-to-another/24626637#24626637 @@ http://archive.is/i92ld
    $.fn.copyAllAttributes = function (from) {
      // from: source jQuery element
      var to = this; // place holder for all attributes

      var allAttributes = $(from) && $(from).length > 0 ? $(from).prop("attributes") : null; // Iterate through attributes and add

      if (allAttributes && $(to) && $(to).length === 1) {
        $.each(allAttributes, function () {
          // Ensure that class names are not copied but rather added
          if (this.name === "class") {
            $(to).addClass(this.value);
          } else if (this.name === "id") {// skip id's
          } else {
            to.attr(this.name, this.value);
          }
        });
      }

      return to;
    };
  })(jQuery); // ** print render fixup
  // NOTE: Firefox print rendering is *broken* b/c Firefox doesn't apply "@media print" CSS to the page before triggering the `beforePrint` event and the print content is "hidden"
  //   ... see: <https://bugzilla.mozilla.org/show_bug.cgi?id=1048317> and <https://bugzilla.mozilla.org/show_bug.cgi?id=774398>
  //   ... IMO, despite being "in-spec" by one interpretation, this is a Firefox *bug* ... so, print using Chrome


  var print_form = false; // signal current document form; used to minimize refresh/setSize on Chrome (which may call these multiple times when printing)

  var beforePrint = function beforePrint() {
    ///console.log(`beforePrint()`);
    if (!print_form) {
      var $cb = $('.codeblock');
      $cb.each(function (index) {
        var $CB = $(this);
        var cm = $CB.find('.CodeMirror').get(0).CodeMirror;
        cm.setOption('lineWrapping', true);
        cm.refresh(); // re-calculate correct height / width

        var height = $CB.find('.CodeMirror-lines').outerHeight();
        cm.setSize(null, height);
      });
      print_form = true;
    }
  };

  var afterPrint = function afterPrint() {
    ///console.log(`afterPrint()`);
    if (print_form) {
      var $cb = $('.codeblock');
      $cb.each(function (index) {
        var $CB = $(this);
        var cm = $CB.find('.CodeMirror').get(0).CodeMirror;

        var _lineWrapping = $CB.hasClass('line-wrapping') || $CB.hasClass('line-wrap') || $CB.hasClass('wrapLines') || $CB.hasClass('wordwrap');

        cm.setOption('lineWrapping', _lineWrapping);
        cm.setSize(null, 'auto');
        cm.refresh(); // fix minor size / text position aberrations after `setSize()`
      });
    }

    print_form = false;
  }; //# install print hooks
  // matchMedia API


  function handleMatchMediaPrint(mql) {
    if (mql.matches) {
      beforePrint();
    } else {
      afterPrint();
    }
  }

  if (window.matchMedia) {
    // matchMedia() API is available
    var mediaQueryList = window.matchMedia('print');
    mediaQueryList.addListener(handleMatchMediaPrint);
  } // older API


  $(window).on('beforeprint', beforePrint);
  $(window).on('afterprint', afterPrint); // ** utility functions

  function isChrome() {
    // ref: https://stackoverflow.com/questions/4565112/javascript-how-to-find-out-if-the-user-browser-is-chrome/13348618#13348618 @@ https://archive.is/HmfdK#14.5%
    var isChromium = window.chrome,
        winNav = window.navigator,
        vendorName = winNav.vendor,
        isOpera = winNav.userAgent.indexOf("OPR") > -1,
        isIEedge = winNav.userAgent.indexOf("Edge") > -1,
        isIOSChrome = winNav.userAgent.match("CriOS");

    if (isIOSChrome) {
      return true;
    } else if (isChromium !== null && typeof isChromium !== "undefined" && vendorName === "Google Inc." && isOpera === false && isIEedge === false) {
      return true;
    } else {
      return false;
    }
  }

  function isDefined(variable) {
    // ref: http://www.codereadability.com/how-to-check-for-undefined-in-javascript @@ http://archive.is/RDiQz
    ///return (typeof variable !== undefined);
    return variable !== undefined;
  } //# assertion


  function assert(condition, message) {
    // based on : http://stackoverflow.com/questions/15313418/javascript-assert/15313435#15313435 @@ http://archive.is/XPo6F
    if (!condition) {
      message = message || "Assertion failed";
      error(message);

      if (typeof Error !== "undefined") {
        throw new Error(message);
      }

      throw message; // Fallback
    }
  } //# user/browser messaging


  var messaging_id = '_messages';

  function add_messaging_area() {
    if ($("#".concat(messaging_id)).length < 1) {
      // basic CSS
      $('<style>').text("#".concat(messaging_id, " { border: red solid 2px; margin: 0; padding: 0 0.5em; }") + "#".concat(messaging_id, " p { margin: 0.5em 0; font-family: monospace }") + '').appendTo('head'); // node

      $('<div/>', {
        id: messaging_id
      }).hide().prependTo($('body'));
    }
  }

  function warn(message) {
    // ( {array} ) : {void}
    var messages = $.isArray(message) ? message : [message];

    if ($("#".concat(messaging_id)).length < 1) {
      add_messaging_area();
    }

    messages.forEach(function (message) {
      $("#".concat(messaging_id)).append($('<p/>', {
        text: 'warn: ' + message
      }));
    });
    $("#".concat(messaging_id)).show();
  }

  function error(message) {
    // ( {array} ) : {void}
    var messages = $.isArray(message) ? message : [message];

    if ($("#".concat(messaging_id)).length < 1) {
      add_messaging_area();
    }

    messages.forEach(function (message) {
      $("#".concat(messaging_id)).append($('<p/>', {
        text: 'ERR!: ' + message
      }));
    });
    $("#".concat(messaging_id)).show();
  } //# string / text functions


  function dequote(s) {
    // remove any surrounding quotes (including any outer surrounding whitespace)
    if (s === undefined || s === null) {
      return s;
    }

    var retval = s.trim();
    var quotes = /["']/;
    var match = retval.charAt(0).match(quotes);

    if (match && match[0].charAt(0) === retval.charAt[retval.length]) {
      retval = retval.slice(1, -1);
    }

    return match ? retval : s;
  } // ####

})(
/* window.USERjs = window.USERjs || {}, */
window, jQuery);

/***/ }),
/* 107 */
/***/ (function(module, exports, __webpack_require__) {

/*!
 * clipboard.js v2.0.6
 * https://clipboardjs.com/
 * 
 * Licensed MIT © Zeno Rocha
 */
(function webpackUniversalModuleDefinition(root, factory) {
  if (true) module.exports = factory();else {}
})(this, function () {
  return (
    /******/
    function (modules) {
      // webpackBootstrap

      /******/
      // The module cache

      /******/
      var installedModules = {};
      /******/

      /******/
      // The require function

      /******/

      function __webpack_require__(moduleId) {
        /******/

        /******/
        // Check if module is in cache

        /******/
        if (installedModules[moduleId]) {
          /******/
          return installedModules[moduleId].exports;
          /******/
        }
        /******/
        // Create a new module (and put it into the cache)

        /******/


        var module = installedModules[moduleId] = {
          /******/
          i: moduleId,

          /******/
          l: false,

          /******/
          exports: {}
          /******/

        };
        /******/

        /******/
        // Execute the module function

        /******/

        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
        /******/

        /******/
        // Flag the module as loaded

        /******/

        module.l = true;
        /******/

        /******/
        // Return the exports of the module

        /******/

        return module.exports;
        /******/
      }
      /******/

      /******/

      /******/
      // expose the modules object (__webpack_modules__)

      /******/


      __webpack_require__.m = modules;
      /******/

      /******/
      // expose the module cache

      /******/

      __webpack_require__.c = installedModules;
      /******/

      /******/
      // define getter function for harmony exports

      /******/

      __webpack_require__.d = function (exports, name, getter) {
        /******/
        if (!__webpack_require__.o(exports, name)) {
          /******/
          Object.defineProperty(exports, name, {
            enumerable: true,
            get: getter
          });
          /******/
        }
        /******/

      };
      /******/

      /******/
      // define __esModule on exports

      /******/


      __webpack_require__.r = function (exports) {
        /******/
        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
          /******/
          Object.defineProperty(exports, Symbol.toStringTag, {
            value: 'Module'
          });
          /******/
        }
        /******/


        Object.defineProperty(exports, '__esModule', {
          value: true
        });
        /******/
      };
      /******/

      /******/
      // create a fake namespace object

      /******/
      // mode & 1: value is a module id, require it

      /******/
      // mode & 2: merge all properties of value into the ns

      /******/
      // mode & 4: return value when already ns object

      /******/
      // mode & 8|1: behave like require

      /******/


      __webpack_require__.t = function (value, mode) {
        /******/
        if (mode & 1) value = __webpack_require__(value);
        /******/

        if (mode & 8) return value;
        /******/

        if (mode & 4 && typeof value === 'object' && value && value.__esModule) return value;
        /******/

        var ns = Object.create(null);
        /******/

        __webpack_require__.r(ns);
        /******/


        Object.defineProperty(ns, 'default', {
          enumerable: true,
          value: value
        });
        /******/

        if (mode & 2 && typeof value != 'string') for (var key in value) __webpack_require__.d(ns, key, function (key) {
          return value[key];
        }.bind(null, key));
        /******/

        return ns;
        /******/
      };
      /******/

      /******/
      // getDefaultExport function for compatibility with non-harmony modules

      /******/


      __webpack_require__.n = function (module) {
        /******/
        var getter = module && module.__esModule ?
        /******/
        function getDefault() {
          return module['default'];
        } :
        /******/
        function getModuleExports() {
          return module;
        };
        /******/

        __webpack_require__.d(getter, 'a', getter);
        /******/


        return getter;
        /******/
      };
      /******/

      /******/
      // Object.prototype.hasOwnProperty.call

      /******/


      __webpack_require__.o = function (object, property) {
        return Object.prototype.hasOwnProperty.call(object, property);
      };
      /******/

      /******/
      // __webpack_public_path__

      /******/


      __webpack_require__.p = "";
      /******/

      /******/

      /******/
      // Load entry module and return exports

      /******/

      return __webpack_require__(__webpack_require__.s = 6);
      /******/
    }(
    /************************************************************************/

    /******/
    [
    /* 0 */

    /***/
    function (module, exports) {
      function select(element) {
        var selectedText;

        if (element.nodeName === 'SELECT') {
          element.focus();
          selectedText = element.value;
        } else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
          var isReadOnly = element.hasAttribute('readonly');

          if (!isReadOnly) {
            element.setAttribute('readonly', '');
          }

          element.select();
          element.setSelectionRange(0, element.value.length);

          if (!isReadOnly) {
            element.removeAttribute('readonly');
          }

          selectedText = element.value;
        } else {
          if (element.hasAttribute('contenteditable')) {
            element.focus();
          }

          var selection = window.getSelection();
          var range = document.createRange();
          range.selectNodeContents(element);
          selection.removeAllRanges();
          selection.addRange(range);
          selectedText = selection.toString();
        }

        return selectedText;
      }

      module.exports = select;
      /***/
    },
    /* 1 */

    /***/
    function (module, exports) {
      function E() {// Keep this empty so it's easier to inherit from
        // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
      }

      E.prototype = {
        on: function (name, callback, ctx) {
          var e = this.e || (this.e = {});
          (e[name] || (e[name] = [])).push({
            fn: callback,
            ctx: ctx
          });
          return this;
        },
        once: function (name, callback, ctx) {
          var self = this;

          function listener() {
            self.off(name, listener);
            callback.apply(ctx, arguments);
          }

          ;
          listener._ = callback;
          return this.on(name, listener, ctx);
        },
        emit: function (name) {
          var data = [].slice.call(arguments, 1);
          var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
          var i = 0;
          var len = evtArr.length;

          for (i; i < len; i++) {
            evtArr[i].fn.apply(evtArr[i].ctx, data);
          }

          return this;
        },
        off: function (name, callback) {
          var e = this.e || (this.e = {});
          var evts = e[name];
          var liveEvents = [];

          if (evts && callback) {
            for (var i = 0, len = evts.length; i < len; i++) {
              if (evts[i].fn !== callback && evts[i].fn._ !== callback) liveEvents.push(evts[i]);
            }
          } // Remove event from queue to prevent memory leak
          // Suggested by https://github.com/lazd
          // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910


          liveEvents.length ? e[name] = liveEvents : delete e[name];
          return this;
        }
      };
      module.exports = E;
      module.exports.TinyEmitter = E;
      /***/
    },
    /* 2 */

    /***/
    function (module, exports, __webpack_require__) {
      var is = __webpack_require__(3);

      var delegate = __webpack_require__(4);
      /**
       * Validates all params and calls the right
       * listener function based on its target type.
       *
       * @param {String|HTMLElement|HTMLCollection|NodeList} target
       * @param {String} type
       * @param {Function} callback
       * @return {Object}
       */


      function listen(target, type, callback) {
        if (!target && !type && !callback) {
          throw new Error('Missing required arguments');
        }

        if (!is.string(type)) {
          throw new TypeError('Second argument must be a String');
        }

        if (!is.fn(callback)) {
          throw new TypeError('Third argument must be a Function');
        }

        if (is.node(target)) {
          return listenNode(target, type, callback);
        } else if (is.nodeList(target)) {
          return listenNodeList(target, type, callback);
        } else if (is.string(target)) {
          return listenSelector(target, type, callback);
        } else {
          throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
        }
      }
      /**
       * Adds an event listener to a HTML element
       * and returns a remove listener function.
       *
       * @param {HTMLElement} node
       * @param {String} type
       * @param {Function} callback
       * @return {Object}
       */


      function listenNode(node, type, callback) {
        node.addEventListener(type, callback);
        return {
          destroy: function () {
            node.removeEventListener(type, callback);
          }
        };
      }
      /**
       * Add an event listener to a list of HTML elements
       * and returns a remove listener function.
       *
       * @param {NodeList|HTMLCollection} nodeList
       * @param {String} type
       * @param {Function} callback
       * @return {Object}
       */


      function listenNodeList(nodeList, type, callback) {
        Array.prototype.forEach.call(nodeList, function (node) {
          node.addEventListener(type, callback);
        });
        return {
          destroy: function () {
            Array.prototype.forEach.call(nodeList, function (node) {
              node.removeEventListener(type, callback);
            });
          }
        };
      }
      /**
       * Add an event listener to a selector
       * and returns a remove listener function.
       *
       * @param {String} selector
       * @param {String} type
       * @param {Function} callback
       * @return {Object}
       */


      function listenSelector(selector, type, callback) {
        return delegate(document.body, selector, type, callback);
      }

      module.exports = listen;
      /***/
    },
    /* 3 */

    /***/
    function (module, exports) {
      /**
       * Check if argument is a HTML element.
       *
       * @param {Object} value
       * @return {Boolean}
       */
      exports.node = function (value) {
        return value !== undefined && value instanceof HTMLElement && value.nodeType === 1;
      };
      /**
       * Check if argument is a list of HTML elements.
       *
       * @param {Object} value
       * @return {Boolean}
       */


      exports.nodeList = function (value) {
        var type = Object.prototype.toString.call(value);
        return value !== undefined && (type === '[object NodeList]' || type === '[object HTMLCollection]') && 'length' in value && (value.length === 0 || exports.node(value[0]));
      };
      /**
       * Check if argument is a string.
       *
       * @param {Object} value
       * @return {Boolean}
       */


      exports.string = function (value) {
        return typeof value === 'string' || value instanceof String;
      };
      /**
       * Check if argument is a function.
       *
       * @param {Object} value
       * @return {Boolean}
       */


      exports.fn = function (value) {
        var type = Object.prototype.toString.call(value);
        return type === '[object Function]';
      };
      /***/

    },
    /* 4 */

    /***/
    function (module, exports, __webpack_require__) {
      var closest = __webpack_require__(5);
      /**
       * Delegates event to a selector.
       *
       * @param {Element} element
       * @param {String} selector
       * @param {String} type
       * @param {Function} callback
       * @param {Boolean} useCapture
       * @return {Object}
       */


      function _delegate(element, selector, type, callback, useCapture) {
        var listenerFn = listener.apply(this, arguments);
        element.addEventListener(type, listenerFn, useCapture);
        return {
          destroy: function () {
            element.removeEventListener(type, listenerFn, useCapture);
          }
        };
      }
      /**
       * Delegates event to a selector.
       *
       * @param {Element|String|Array} [elements]
       * @param {String} selector
       * @param {String} type
       * @param {Function} callback
       * @param {Boolean} useCapture
       * @return {Object}
       */


      function delegate(elements, selector, type, callback, useCapture) {
        // Handle the regular Element usage
        if (typeof elements.addEventListener === 'function') {
          return _delegate.apply(null, arguments);
        } // Handle Element-less usage, it defaults to global delegation


        if (typeof type === 'function') {
          // Use `document` as the first parameter, then apply arguments
          // This is a short way to .unshift `arguments` without running into deoptimizations
          return _delegate.bind(null, document).apply(null, arguments);
        } // Handle Selector-based usage


        if (typeof elements === 'string') {
          elements = document.querySelectorAll(elements);
        } // Handle Array-like based usage


        return Array.prototype.map.call(elements, function (element) {
          return _delegate(element, selector, type, callback, useCapture);
        });
      }
      /**
       * Finds closest match and invokes callback.
       *
       * @param {Element} element
       * @param {String} selector
       * @param {String} type
       * @param {Function} callback
       * @return {Function}
       */


      function listener(element, selector, type, callback) {
        return function (e) {
          e.delegateTarget = closest(e.target, selector);

          if (e.delegateTarget) {
            callback.call(element, e);
          }
        };
      }

      module.exports = delegate;
      /***/
    },
    /* 5 */

    /***/
    function (module, exports) {
      var DOCUMENT_NODE_TYPE = 9;
      /**
       * A polyfill for Element.matches()
       */

      if (typeof Element !== 'undefined' && !Element.prototype.matches) {
        var proto = Element.prototype;
        proto.matches = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector || proto.webkitMatchesSelector;
      }
      /**
       * Finds the closest parent that matches a selector.
       *
       * @param {Element} element
       * @param {String} selector
       * @return {Function}
       */


      function closest(element, selector) {
        while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
          if (typeof element.matches === 'function' && element.matches(selector)) {
            return element;
          }

          element = element.parentNode;
        }
      }

      module.exports = closest;
      /***/
    },
    /* 6 */

    /***/
    function (module, __webpack_exports__, __webpack_require__) {
      "use strict";

      __webpack_require__.r(__webpack_exports__); // EXTERNAL MODULE: ./node_modules/select/src/select.js


      var src_select = __webpack_require__(0);

      var select_default = /*#__PURE__*/__webpack_require__.n(src_select); // CONCATENATED MODULE: ./src/clipboard-action.js


      var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
      } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };

      var _createClass = function () {
        function defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        return function (Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      }();

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }
      /**
       * Inner class which performs selection from either `text` or `target`
       * properties and then executes copy or cut operations.
       */


      var clipboard_action_ClipboardAction = function () {
        /**
         * @param {Object} options
         */
        function ClipboardAction(options) {
          _classCallCheck(this, ClipboardAction);

          this.resolveOptions(options);
          this.initSelection();
        }
        /**
         * Defines base properties passed from constructor.
         * @param {Object} options
         */


        _createClass(ClipboardAction, [{
          key: 'resolveOptions',
          value: function resolveOptions() {
            var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            this.action = options.action;
            this.container = options.container;
            this.emitter = options.emitter;
            this.target = options.target;
            this.text = options.text;
            this.trigger = options.trigger;
            this.selectedText = '';
          }
          /**
           * Decides which selection strategy is going to be applied based
           * on the existence of `text` and `target` properties.
           */

        }, {
          key: 'initSelection',
          value: function initSelection() {
            if (this.text) {
              this.selectFake();
            } else if (this.target) {
              this.selectTarget();
            }
          }
          /**
           * Creates a fake textarea element, sets its value from `text` property,
           * and makes a selection on it.
           */

        }, {
          key: 'selectFake',
          value: function selectFake() {
            var _this = this;

            var isRTL = document.documentElement.getAttribute('dir') == 'rtl';
            this.removeFake();

            this.fakeHandlerCallback = function () {
              return _this.removeFake();
            };

            this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true;
            this.fakeElem = document.createElement('textarea'); // Prevent zooming on iOS

            this.fakeElem.style.fontSize = '12pt'; // Reset box model

            this.fakeElem.style.border = '0';
            this.fakeElem.style.padding = '0';
            this.fakeElem.style.margin = '0'; // Move element out of screen horizontally

            this.fakeElem.style.position = 'absolute';
            this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px'; // Move element to the same position vertically

            var yPosition = window.pageYOffset || document.documentElement.scrollTop;
            this.fakeElem.style.top = yPosition + 'px';
            this.fakeElem.setAttribute('readonly', '');
            this.fakeElem.value = this.text;
            this.container.appendChild(this.fakeElem);
            this.selectedText = select_default()(this.fakeElem);
            this.copyText();
          }
          /**
           * Only removes the fake element after another click event, that way
           * a user can hit `Ctrl+C` to copy because selection still exists.
           */

        }, {
          key: 'removeFake',
          value: function removeFake() {
            if (this.fakeHandler) {
              this.container.removeEventListener('click', this.fakeHandlerCallback);
              this.fakeHandler = null;
              this.fakeHandlerCallback = null;
            }

            if (this.fakeElem) {
              this.container.removeChild(this.fakeElem);
              this.fakeElem = null;
            }
          }
          /**
           * Selects the content from element passed on `target` property.
           */

        }, {
          key: 'selectTarget',
          value: function selectTarget() {
            this.selectedText = select_default()(this.target);
            this.copyText();
          }
          /**
           * Executes the copy operation based on the current selection.
           */

        }, {
          key: 'copyText',
          value: function copyText() {
            var succeeded = void 0;

            try {
              succeeded = document.execCommand(this.action);
            } catch (err) {
              succeeded = false;
            }

            this.handleResult(succeeded);
          }
          /**
           * Fires an event based on the copy operation result.
           * @param {Boolean} succeeded
           */

        }, {
          key: 'handleResult',
          value: function handleResult(succeeded) {
            this.emitter.emit(succeeded ? 'success' : 'error', {
              action: this.action,
              text: this.selectedText,
              trigger: this.trigger,
              clearSelection: this.clearSelection.bind(this)
            });
          }
          /**
           * Moves focus away from `target` and back to the trigger, removes current selection.
           */

        }, {
          key: 'clearSelection',
          value: function clearSelection() {
            if (this.trigger) {
              this.trigger.focus();
            }

            document.activeElement.blur();
            window.getSelection().removeAllRanges();
          }
          /**
           * Sets the `action` to be performed which can be either 'copy' or 'cut'.
           * @param {String} action
           */

        }, {
          key: 'destroy',

          /**
           * Destroy lifecycle.
           */
          value: function destroy() {
            this.removeFake();
          }
        }, {
          key: 'action',
          set: function set() {
            var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';
            this._action = action;

            if (this._action !== 'copy' && this._action !== 'cut') {
              throw new Error('Invalid "action" value, use either "copy" or "cut"');
            }
          }
          /**
           * Gets the `action` property.
           * @return {String}
           */
          ,
          get: function get() {
            return this._action;
          }
          /**
           * Sets the `target` property using an element
           * that will be have its content copied.
           * @param {Element} target
           */

        }, {
          key: 'target',
          set: function set(target) {
            if (target !== undefined) {
              if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) {
                if (this.action === 'copy' && target.hasAttribute('disabled')) {
                  throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
                }

                if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
                  throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
                }

                this._target = target;
              } else {
                throw new Error('Invalid "target" value, use a valid Element');
              }
            }
          }
          /**
           * Gets the `target` property.
           * @return {String|HTMLElement}
           */
          ,
          get: function get() {
            return this._target;
          }
        }]);

        return ClipboardAction;
      }();
      /* harmony default export */


      var clipboard_action = clipboard_action_ClipboardAction; // EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js

      var tiny_emitter = __webpack_require__(1);

      var tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter); // EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js


      var listen = __webpack_require__(2);

      var listen_default = /*#__PURE__*/__webpack_require__.n(listen); // CONCATENATED MODULE: ./src/clipboard.js


      var clipboard_typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
      } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };

      var clipboard_createClass = function () {
        function defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        return function (Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      }();

      function clipboard_classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      function _possibleConstructorReturn(self, call) {
        if (!self) {
          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
        }

        return call && (typeof call === "object" || typeof call === "function") ? call : self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== "function" && superClass !== null) {
          throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
        }

        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true
          }
        });
        if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
      }
      /**
       * Base class which takes one or more elements, adds event listeners to them,
       * and instantiates a new `ClipboardAction` on each click.
       */


      var clipboard_Clipboard = function (_Emitter) {
        _inherits(Clipboard, _Emitter);
        /**
         * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
         * @param {Object} options
         */


        function Clipboard(trigger, options) {
          clipboard_classCallCheck(this, Clipboard);

          var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this));

          _this.resolveOptions(options);

          _this.listenClick(trigger);

          return _this;
        }
        /**
         * Defines if attributes would be resolved using internal setter functions
         * or custom functions that were passed in the constructor.
         * @param {Object} options
         */


        clipboard_createClass(Clipboard, [{
          key: 'resolveOptions',
          value: function resolveOptions() {
            var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
            this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
            this.text = typeof options.text === 'function' ? options.text : this.defaultText;
            this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body;
          }
          /**
           * Adds a click event listener to the passed trigger.
           * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
           */

        }, {
          key: 'listenClick',
          value: function listenClick(trigger) {
            var _this2 = this;

            this.listener = listen_default()(trigger, 'click', function (e) {
              return _this2.onClick(e);
            });
          }
          /**
           * Defines a new `ClipboardAction` on each click event.
           * @param {Event} e
           */

        }, {
          key: 'onClick',
          value: function onClick(e) {
            var trigger = e.delegateTarget || e.currentTarget;

            if (this.clipboardAction) {
              this.clipboardAction = null;
            }

            this.clipboardAction = new clipboard_action({
              action: this.action(trigger),
              target: this.target(trigger),
              text: this.text(trigger),
              container: this.container,
              trigger: trigger,
              emitter: this
            });
          }
          /**
           * Default `action` lookup function.
           * @param {Element} trigger
           */

        }, {
          key: 'defaultAction',
          value: function defaultAction(trigger) {
            return getAttributeValue('action', trigger);
          }
          /**
           * Default `target` lookup function.
           * @param {Element} trigger
           */

        }, {
          key: 'defaultTarget',
          value: function defaultTarget(trigger) {
            var selector = getAttributeValue('target', trigger);

            if (selector) {
              return document.querySelector(selector);
            }
          }
          /**
           * Returns the support of the given action, or all actions if no action is
           * given.
           * @param {String} [action]
           */

        }, {
          key: 'defaultText',

          /**
           * Default `text` lookup function.
           * @param {Element} trigger
           */
          value: function defaultText(trigger) {
            return getAttributeValue('text', trigger);
          }
          /**
           * Destroy lifecycle.
           */

        }, {
          key: 'destroy',
          value: function destroy() {
            this.listener.destroy();

            if (this.clipboardAction) {
              this.clipboardAction.destroy();
              this.clipboardAction = null;
            }
          }
        }], [{
          key: 'isSupported',
          value: function isSupported() {
            var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
            var actions = typeof action === 'string' ? [action] : action;
            var support = !!document.queryCommandSupported;
            actions.forEach(function (action) {
              support = support && !!document.queryCommandSupported(action);
            });
            return support;
          }
        }]);
        return Clipboard;
      }(tiny_emitter_default.a);
      /**
       * Helper function to retrieve attribute value.
       * @param {String} suffix
       * @param {Element} element
       */


      function getAttributeValue(suffix, element) {
        var attribute = 'data-clipboard-' + suffix;

        if (!element.hasAttribute(attribute)) {
          return;
        }

        return element.getAttribute(attribute);
      }
      /* harmony default export */


      var clipboard = __webpack_exports__["default"] = clipboard_Clipboard;
      /***/
    }
    /******/
    ])["default"]
  );
});

/***/ }),
/* 108 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


const fs = __webpack_require__(109);

const sections = __webpack_require__(110);

const defaults = __webpack_require__(31);

const stringify = __webpack_require__(60);

const excerpt = __webpack_require__(139);

const engines = __webpack_require__(55);

const toFile = __webpack_require__(140);

const parse = __webpack_require__(141);

const utils = __webpack_require__(38);
/**
 * Takes a string or object with `content` property, extracts
 * and parses front-matter from the string, then returns an object
 * with `data`, `content` and other [useful properties](#returned-object).
 *
 * ```js
 * const matter = require('gray-matter');
 * console.log(matter('---\ntitle: Home\n---\nOther stuff'));
 * //=> { data: { title: 'Home'}, content: 'Other stuff' }
 * ```
 * @param {Object|String} `input` String, or object with `content` string
 * @param {Object} `options`
 * @return {Object}
 * @api public
 */


function matter(input, options) {
  if (input === '') {
    return {
      data: {},
      content: input,
      excerpt: '',
      orig: input
    };
  }

  let file = toFile(input);
  const cached = matter.cache[file.content];

  if (!options) {
    if (cached) {
      file = Object.assign({}, cached);
      file.orig = cached.orig;
      return file;
    } // only cache if there are no options passed. if we cache when options
    // are passed, we would need to also cache options values, which would
    // negate any performance benefits of caching


    matter.cache[file.content] = file;
  }

  return parseMatter(file, options);
}
/**
 * Parse front matter
 */


function parseMatter(file, options) {
  const opts = defaults(options);
  const open = opts.delimiters[0];
  const close = '\n' + opts.delimiters[1];
  let str = file.content;

  if (opts.language) {
    file.language = opts.language;
  } // get the length of the opening delimiter


  const openLen = open.length;

  if (!utils.startsWith(str, open, openLen)) {
    excerpt(file, opts);
    return file;
  } // if the next character after the opening delimiter is
  // a character from the delimiter, then it's not a front-
  // matter delimiter


  if (str.charAt(openLen) === open.slice(-1)) {
    return file;
  } // strip the opening delimiter


  str = str.slice(openLen);
  const len = str.length; // use the language defined after first delimiter, if it exists

  const language = matter.language(str, opts);

  if (language.name) {
    file.language = language.name;
    str = str.slice(language.raw.length);
  } // get the index of the closing delimiter


  let closeIndex = str.indexOf(close);

  if (closeIndex === -1) {
    closeIndex = len;
  } // get the raw front-matter block


  file.matter = str.slice(0, closeIndex);
  const block = file.matter.replace(/^\s*#[^\n]+/gm, '').trim();

  if (block === '') {
    file.isEmpty = true;
    file.empty = file.content;
    file.data = {};
  } else {
    // create file.data by parsing the raw file.matter block
    file.data = parse(file.language, file.matter, opts);
  } // update file.content


  if (closeIndex === len) {
    file.content = '';
  } else {
    file.content = str.slice(closeIndex + close.length);

    if (file.content[0] === '\r') {
      file.content = file.content.slice(1);
    }

    if (file.content[0] === '\n') {
      file.content = file.content.slice(1);
    }
  }

  excerpt(file, opts);

  if (opts.sections === true || typeof opts.section === 'function') {
    sections(file, opts.section);
  }

  return file;
}
/**
 * Expose engines
 */


matter.engines = engines;
/**
 * Stringify an object to YAML or the specified language, and
 * append it to the given string. By default, only YAML and JSON
 * can be stringified. See the [engines](#engines) section to learn
 * how to stringify other languages.
 *
 * ```js
 * console.log(matter.stringify('foo bar baz', {title: 'Home'}));
 * // results in:
 * // ---
 * // title: Home
 * // ---
 * // foo bar baz
 * ```
 * @param {String|Object} `file` The content string to append to stringified front-matter, or a file object with `file.content` string.
 * @param {Object} `data` Front matter to stringify.
 * @param {Object} `options` [Options](#options) to pass to gray-matter and [js-yaml].
 * @return {String} Returns a string created by wrapping stringified yaml with delimiters, and appending that to the given string.
 * @api public
 */

matter.stringify = function (file, data, options) {
  if (typeof file === 'string') file = matter(file, options);
  return stringify(file, data, options);
};
/**
 * Synchronously read a file from the file system and parse
 * front matter. Returns the same object as the [main function](#matter).
 *
 * ```js
 * const file = matter.read('./content/blog-post.md');
 * ```
 * @param {String} `filepath` file path of the file to read.
 * @param {Object} `options` [Options](#options) to pass to gray-matter.
 * @return {Object} Returns [an object](#returned-object) with `data` and `content`
 * @api public
 */


matter.read = function (filepath, options) {
  const str = fs.readFileSync(filepath, 'utf8');
  const file = matter(str, options);
  file.path = filepath;
  return file;
};
/**
 * Returns true if the given `string` has front matter.
 * @param  {String} `string`
 * @param  {Object} `options`
 * @return {Boolean} True if front matter exists.
 * @api public
 */


matter.test = function (str, options) {
  return utils.startsWith(str, defaults(options).delimiters[0]);
};
/**
 * Detect the language to use, if one is defined after the
 * first front-matter delimiter.
 * @param  {String} `string`
 * @param  {Object} `options`
 * @return {Object} Object with `raw` (actual language string), and `name`, the language with whitespace trimmed
 */


matter.language = function (str, options) {
  const opts = defaults(options);
  const open = opts.delimiters[0];

  if (matter.test(str)) {
    str = str.slice(open.length);
  }

  const language = str.slice(0, str.search(/\r?\n/));
  return {
    raw: language,
    name: language ? language.trim() : ''
  };
};
/**
 * Expose `matter`
 */


matter.cache = {};

matter.clearCache = () => matter.cache = {};

module.exports = matter;

/***/ }),
/* 109 */
/***/ (function(module, exports) {

/* (ignored) */

/***/ }),
/* 110 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var typeOf = __webpack_require__(30);

var extend = __webpack_require__(111);
/**
 * Parse sections in `input` with the given `options`.
 *
 * ```js
 * var sections = require('{%= name %}');
 * var result = sections(input, options);
 * // { content: 'Content before sections', sections: [] }
 * ```
 * @param {String|Buffer|Object} `input` If input is an object, it's `content` property must be a string or buffer.
 * @param {Object} options
 * @return {Object} Returns an object with a `content` string and an array of `sections` objects.
 * @api public
 */


module.exports = function (input, options) {
  if (typeof options === 'function') {
    options = {
      parse: options
    };
  }

  var file = toObject(input);
  var defaults = {
    section_delimiter: '---',
    parse: identity
  };
  var opts = extend({}, defaults, options);
  var delim = opts.section_delimiter;
  var lines = file.content.split(/\r?\n/);
  var sections = null;
  var section = createSection();
  var content = [];
  var stack = [];

  function initSections(val) {
    file.content = val;
    sections = [];
    content = [];
  }

  function closeSection(val) {
    if (stack.length) {
      section.key = getKey(stack[0], delim);
      section.content = val;
      opts.parse(section, sections);
      sections.push(section);
      section = createSection();
      content = [];
      stack = [];
    }
  }

  for (var i = 0; i < lines.length; i++) {
    var line = lines[i];
    var len = stack.length;
    var ln = line.trim();

    if (isDelimiter(ln, delim)) {
      if (ln.length === 3 && i !== 0) {
        if (len === 0 || len === 2) {
          content.push(line);
          continue;
        }

        stack.push(ln);
        section.data = content.join('\n');
        content = [];
        continue;
      }

      if (sections === null) {
        initSections(content.join('\n'));
      }

      if (len === 2) {
        closeSection(content.join('\n'));
      }

      stack.push(ln);
      continue;
    }

    content.push(line);
  }

  if (sections === null) {
    initSections(content.join('\n'));
  } else {
    closeSection(content.join('\n'));
  }

  file.sections = sections;
  return file;
};

function isDelimiter(line, delim) {
  if (line.slice(0, delim.length) !== delim) {
    return false;
  }

  if (line.charAt(delim.length + 1) === delim.slice(-1)) {
    return false;
  }

  return true;
}

function toObject(input) {
  if (typeOf(input) !== 'object') {
    input = {
      content: input
    };
  }

  if (typeof input.content !== 'string' && !isBuffer(input.content)) {
    throw new TypeError('expected a buffer or string');
  }

  input.content = input.content.toString();
  input.sections = [];
  return input;
}

function getKey(val, delim) {
  return val ? val.slice(delim.length).trim() : '';
}

function createSection() {
  return {
    key: '',
    data: '',
    content: ''
  };
}

function identity(val) {
  return val;
}

function isBuffer(val) {
  if (val && val.constructor && typeof val.constructor.isBuffer === 'function') {
    return val.constructor.isBuffer(val);
  }

  return false;
}

/***/ }),
/* 111 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var isObject = __webpack_require__(112);

module.exports = function extend(o
/*, objects*/
) {
  if (!isObject(o)) {
    o = {};
  }

  var len = arguments.length;

  for (var i = 1; i < len; i++) {
    var obj = arguments[i];

    if (isObject(obj)) {
      assign(o, obj);
    }
  }

  return o;
};

function assign(a, b) {
  for (var key in b) {
    if (hasOwn(b, key)) {
      a[key] = b[key];
    }
  }
}
/**
 * Returns true if the given `key` is an own property of `obj`.
 */


function hasOwn(obj, key) {
  return Object.prototype.hasOwnProperty.call(obj, key);
}

/***/ }),
/* 112 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/*!
 * is-extendable <https://github.com/jonschlinkert/is-extendable>
 *
 * Copyright (c) 2015, Jon Schlinkert.
 * Licensed under the MIT License.
 */


module.exports = function isExtendable(val) {
  return typeof val !== 'undefined' && val !== null && (typeof val === 'object' || typeof val === 'function');
};

/***/ }),
/* 113 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var yaml = __webpack_require__(114);

module.exports = yaml;

/***/ }),
/* 114 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var loader = __webpack_require__(115);

var dumper = __webpack_require__(137);

function deprecated(name) {
  return function () {
    throw new Error('Function ' + name + ' is deprecated and cannot be used.');
  };
}

module.exports.Type = __webpack_require__(7);
module.exports.Schema = __webpack_require__(21);
module.exports.FAILSAFE_SCHEMA = __webpack_require__(37);
module.exports.JSON_SCHEMA = __webpack_require__(57);
module.exports.CORE_SCHEMA = __webpack_require__(56);
module.exports.DEFAULT_SAFE_SCHEMA = __webpack_require__(25);
module.exports.DEFAULT_FULL_SCHEMA = __webpack_require__(32);
module.exports.load = loader.load;
module.exports.loadAll = loader.loadAll;
module.exports.safeLoad = loader.safeLoad;
module.exports.safeLoadAll = loader.safeLoadAll;
module.exports.dump = dumper.dump;
module.exports.safeDump = dumper.safeDump;
module.exports.YAMLException = __webpack_require__(24); // Deprecated schema names from JS-YAML 2.0.x

module.exports.MINIMAL_SCHEMA = __webpack_require__(37);
module.exports.SAFE_SCHEMA = __webpack_require__(25);
module.exports.DEFAULT_SCHEMA = __webpack_require__(32); // Deprecated functions from JS-YAML 1.x.x

module.exports.scan = deprecated('scan');
module.exports.parse = deprecated('parse');
module.exports.compose = deprecated('compose');
module.exports.addConstructor = deprecated('addConstructor');

/***/ }),
/* 115 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/*eslint-disable max-len,no-use-before-define*/

var common = __webpack_require__(20);

var YAMLException = __webpack_require__(24);

var Mark = __webpack_require__(116);

var DEFAULT_SAFE_SCHEMA = __webpack_require__(25);

var DEFAULT_FULL_SCHEMA = __webpack_require__(32);

var _hasOwnProperty = Object.prototype.hasOwnProperty;
var CONTEXT_FLOW_IN = 1;
var CONTEXT_FLOW_OUT = 2;
var CONTEXT_BLOCK_IN = 3;
var CONTEXT_BLOCK_OUT = 4;
var CHOMPING_CLIP = 1;
var CHOMPING_STRIP = 2;
var CHOMPING_KEEP = 3;
var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;

function _class(obj) {
  return Object.prototype.toString.call(obj);
}

function is_EOL(c) {
  return c === 0x0A
  /* LF */
  || c === 0x0D
  /* CR */
  ;
}

function is_WHITE_SPACE(c) {
  return c === 0x09
  /* Tab */
  || c === 0x20
  /* Space */
  ;
}

function is_WS_OR_EOL(c) {
  return c === 0x09
  /* Tab */
  || c === 0x20
  /* Space */
  || c === 0x0A
  /* LF */
  || c === 0x0D
  /* CR */
  ;
}

function is_FLOW_INDICATOR(c) {
  return c === 0x2C
  /* , */
  || c === 0x5B
  /* [ */
  || c === 0x5D
  /* ] */
  || c === 0x7B
  /* { */
  || c === 0x7D
  /* } */
  ;
}

function fromHexCode(c) {
  var lc;

  if (0x30
  /* 0 */
  <= c && c <= 0x39
  /* 9 */
  ) {
    return c - 0x30;
  }
  /*eslint-disable no-bitwise*/


  lc = c | 0x20;

  if (0x61
  /* a */
  <= lc && lc <= 0x66
  /* f */
  ) {
    return lc - 0x61 + 10;
  }

  return -1;
}

function escapedHexLen(c) {
  if (c === 0x78
  /* x */
  ) {
      return 2;
    }

  if (c === 0x75
  /* u */
  ) {
      return 4;
    }

  if (c === 0x55
  /* U */
  ) {
      return 8;
    }

  return 0;
}

function fromDecimalCode(c) {
  if (0x30
  /* 0 */
  <= c && c <= 0x39
  /* 9 */
  ) {
    return c - 0x30;
  }

  return -1;
}

function simpleEscapeSequence(c) {
  /* eslint-disable indent */
  return c === 0x30
  /* 0 */
  ? '\x00' : c === 0x61
  /* a */
  ? '\x07' : c === 0x62
  /* b */
  ? '\x08' : c === 0x74
  /* t */
  ? '\x09' : c === 0x09
  /* Tab */
  ? '\x09' : c === 0x6E
  /* n */
  ? '\x0A' : c === 0x76
  /* v */
  ? '\x0B' : c === 0x66
  /* f */
  ? '\x0C' : c === 0x72
  /* r */
  ? '\x0D' : c === 0x65
  /* e */
  ? '\x1B' : c === 0x20
  /* Space */
  ? ' ' : c === 0x22
  /* " */
  ? '\x22' : c === 0x2F
  /* / */
  ? '/' : c === 0x5C
  /* \ */
  ? '\x5C' : c === 0x4E
  /* N */
  ? '\x85' : c === 0x5F
  /* _ */
  ? '\xA0' : c === 0x4C
  /* L */
  ? '\u2028' : c === 0x50
  /* P */
  ? '\u2029' : '';
}

function charFromCodepoint(c) {
  if (c <= 0xFFFF) {
    return String.fromCharCode(c);
  } // Encode UTF-16 surrogate pair
  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF


  return String.fromCharCode((c - 0x010000 >> 10) + 0xD800, (c - 0x010000 & 0x03FF) + 0xDC00);
}

var simpleEscapeCheck = new Array(256); // integer, for fast access

var simpleEscapeMap = new Array(256);

for (var i = 0; i < 256; i++) {
  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
  simpleEscapeMap[i] = simpleEscapeSequence(i);
}

function State(input, options) {
  this.input = input;
  this.filename = options['filename'] || null;
  this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
  this.onWarning = options['onWarning'] || null;
  this.legacy = options['legacy'] || false;
  this.json = options['json'] || false;
  this.listener = options['listener'] || null;
  this.implicitTypes = this.schema.compiledImplicit;
  this.typeMap = this.schema.compiledTypeMap;
  this.length = input.length;
  this.position = 0;
  this.line = 0;
  this.lineStart = 0;
  this.lineIndent = 0;
  this.documents = [];
  /*
  this.version;
  this.checkLineBreaks;
  this.tagMap;
  this.anchorMap;
  this.tag;
  this.anchor;
  this.kind;
  this.result;*/
}

function generateError(state, message) {
  return new YAMLException(message, new Mark(state.filename, state.input, state.position, state.line, state.position - state.lineStart));
}

function throwError(state, message) {
  throw generateError(state, message);
}

function throwWarning(state, message) {
  if (state.onWarning) {
    state.onWarning.call(null, generateError(state, message));
  }
}

var directiveHandlers = {
  YAML: function handleYamlDirective(state, name, args) {
    var match, major, minor;

    if (state.version !== null) {
      throwError(state, 'duplication of %YAML directive');
    }

    if (args.length !== 1) {
      throwError(state, 'YAML directive accepts exactly one argument');
    }

    match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);

    if (match === null) {
      throwError(state, 'ill-formed argument of the YAML directive');
    }

    major = parseInt(match[1], 10);
    minor = parseInt(match[2], 10);

    if (major !== 1) {
      throwError(state, 'unacceptable YAML version of the document');
    }

    state.version = args[0];
    state.checkLineBreaks = minor < 2;

    if (minor !== 1 && minor !== 2) {
      throwWarning(state, 'unsupported YAML version of the document');
    }
  },
  TAG: function handleTagDirective(state, name, args) {
    var handle, prefix;

    if (args.length !== 2) {
      throwError(state, 'TAG directive accepts exactly two arguments');
    }

    handle = args[0];
    prefix = args[1];

    if (!PATTERN_TAG_HANDLE.test(handle)) {
      throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
    }

    if (_hasOwnProperty.call(state.tagMap, handle)) {
      throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
    }

    if (!PATTERN_TAG_URI.test(prefix)) {
      throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
    }

    state.tagMap[handle] = prefix;
  }
};

function captureSegment(state, start, end, checkJson) {
  var _position, _length, _character, _result;

  if (start < end) {
    _result = state.input.slice(start, end);

    if (checkJson) {
      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
        _character = _result.charCodeAt(_position);

        if (!(_character === 0x09 || 0x20 <= _character && _character <= 0x10FFFF)) {
          throwError(state, 'expected valid JSON character');
        }
      }
    } else if (PATTERN_NON_PRINTABLE.test(_result)) {
      throwError(state, 'the stream contains non-printable characters');
    }

    state.result += _result;
  }
}

function mergeMappings(state, destination, source, overridableKeys) {
  var sourceKeys, key, index, quantity;

  if (!common.isObject(source)) {
    throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
  }

  sourceKeys = Object.keys(source);

  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
    key = sourceKeys[index];

    if (!_hasOwnProperty.call(destination, key)) {
      destination[key] = source[key];
      overridableKeys[key] = true;
    }
  }
}

function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
  var index, quantity; // The output is a plain object here, so keys can only be strings.
  // We need to convert keyNode to a string, but doing so can hang the process
  // (deeply nested arrays that explode exponentially using aliases).

  if (Array.isArray(keyNode)) {
    keyNode = Array.prototype.slice.call(keyNode);

    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
      if (Array.isArray(keyNode[index])) {
        throwError(state, 'nested arrays are not supported inside keys');
      }

      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
        keyNode[index] = '[object Object]';
      }
    }
  } // Avoid code execution in load() via toString property
  // (still use its own toString for arrays, timestamps,
  // and whatever user schema extensions happen to have @@toStringTag)


  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
    keyNode = '[object Object]';
  }

  keyNode = String(keyNode);

  if (_result === null) {
    _result = {};
  }

  if (keyTag === 'tag:yaml.org,2002:merge') {
    if (Array.isArray(valueNode)) {
      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
        mergeMappings(state, _result, valueNode[index], overridableKeys);
      }
    } else {
      mergeMappings(state, _result, valueNode, overridableKeys);
    }
  } else {
    if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
      state.line = startLine || state.line;
      state.position = startPos || state.position;
      throwError(state, 'duplicated mapping key');
    }

    _result[keyNode] = valueNode;
    delete overridableKeys[keyNode];
  }

  return _result;
}

function readLineBreak(state) {
  var ch;
  ch = state.input.charCodeAt(state.position);

  if (ch === 0x0A
  /* LF */
  ) {
      state.position++;
    } else if (ch === 0x0D
  /* CR */
  ) {
      state.position++;

      if (state.input.charCodeAt(state.position) === 0x0A
      /* LF */
      ) {
          state.position++;
        }
    } else {
    throwError(state, 'a line break is expected');
  }

  state.line += 1;
  state.lineStart = state.position;
}

function skipSeparationSpace(state, allowComments, checkIndent) {
  var lineBreaks = 0,
      ch = state.input.charCodeAt(state.position);

  while (ch !== 0) {
    while (is_WHITE_SPACE(ch)) {
      ch = state.input.charCodeAt(++state.position);
    }

    if (allowComments && ch === 0x23
    /* # */
    ) {
        do {
          ch = state.input.charCodeAt(++state.position);
        } while (ch !== 0x0A
        /* LF */
        && ch !== 0x0D
        /* CR */
        && ch !== 0);
      }

    if (is_EOL(ch)) {
      readLineBreak(state);
      ch = state.input.charCodeAt(state.position);
      lineBreaks++;
      state.lineIndent = 0;

      while (ch === 0x20
      /* Space */
      ) {
        state.lineIndent++;
        ch = state.input.charCodeAt(++state.position);
      }
    } else {
      break;
    }
  }

  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
    throwWarning(state, 'deficient indentation');
  }

  return lineBreaks;
}

function testDocumentSeparator(state) {
  var _position = state.position,
      ch;
  ch = state.input.charCodeAt(_position); // Condition state.position === state.lineStart is tested
  // in parent on each call, for efficiency. No needs to test here again.

  if ((ch === 0x2D
  /* - */
  || ch === 0x2E
  /* . */
  ) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
    _position += 3;
    ch = state.input.charCodeAt(_position);

    if (ch === 0 || is_WS_OR_EOL(ch)) {
      return true;
    }
  }

  return false;
}

function writeFoldedLines(state, count) {
  if (count === 1) {
    state.result += ' ';
  } else if (count > 1) {
    state.result += common.repeat('\n', count - 1);
  }
}

function readPlainScalar(state, nodeIndent, withinFlowCollection) {
  var preceding,
      following,
      captureStart,
      captureEnd,
      hasPendingContent,
      _line,
      _lineStart,
      _lineIndent,
      _kind = state.kind,
      _result = state.result,
      ch;

  ch = state.input.charCodeAt(state.position);

  if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 0x23
  /* # */
  || ch === 0x26
  /* & */
  || ch === 0x2A
  /* * */
  || ch === 0x21
  /* ! */
  || ch === 0x7C
  /* | */
  || ch === 0x3E
  /* > */
  || ch === 0x27
  /* ' */
  || ch === 0x22
  /* " */
  || ch === 0x25
  /* % */
  || ch === 0x40
  /* @ */
  || ch === 0x60
  /* ` */
  ) {
      return false;
    }

  if (ch === 0x3F
  /* ? */
  || ch === 0x2D
  /* - */
  ) {
      following = state.input.charCodeAt(state.position + 1);

      if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
        return false;
      }
    }

  state.kind = 'scalar';
  state.result = '';
  captureStart = captureEnd = state.position;
  hasPendingContent = false;

  while (ch !== 0) {
    if (ch === 0x3A
    /* : */
    ) {
        following = state.input.charCodeAt(state.position + 1);

        if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
          break;
        }
      } else if (ch === 0x23
    /* # */
    ) {
        preceding = state.input.charCodeAt(state.position - 1);

        if (is_WS_OR_EOL(preceding)) {
          break;
        }
      } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) {
      break;
    } else if (is_EOL(ch)) {
      _line = state.line;
      _lineStart = state.lineStart;
      _lineIndent = state.lineIndent;
      skipSeparationSpace(state, false, -1);

      if (state.lineIndent >= nodeIndent) {
        hasPendingContent = true;
        ch = state.input.charCodeAt(state.position);
        continue;
      } else {
        state.position = captureEnd;
        state.line = _line;
        state.lineStart = _lineStart;
        state.lineIndent = _lineIndent;
        break;
      }
    }

    if (hasPendingContent) {
      captureSegment(state, captureStart, captureEnd, false);
      writeFoldedLines(state, state.line - _line);
      captureStart = captureEnd = state.position;
      hasPendingContent = false;
    }

    if (!is_WHITE_SPACE(ch)) {
      captureEnd = state.position + 1;
    }

    ch = state.input.charCodeAt(++state.position);
  }

  captureSegment(state, captureStart, captureEnd, false);

  if (state.result) {
    return true;
  }

  state.kind = _kind;
  state.result = _result;
  return false;
}

function readSingleQuotedScalar(state, nodeIndent) {
  var ch, captureStart, captureEnd;
  ch = state.input.charCodeAt(state.position);

  if (ch !== 0x27
  /* ' */
  ) {
      return false;
    }

  state.kind = 'scalar';
  state.result = '';
  state.position++;
  captureStart = captureEnd = state.position;

  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
    if (ch === 0x27
    /* ' */
    ) {
        captureSegment(state, captureStart, state.position, true);
        ch = state.input.charCodeAt(++state.position);

        if (ch === 0x27
        /* ' */
        ) {
            captureStart = state.position;
            state.position++;
            captureEnd = state.position;
          } else {
          return true;
        }
      } else if (is_EOL(ch)) {
      captureSegment(state, captureStart, captureEnd, true);
      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
      captureStart = captureEnd = state.position;
    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
      throwError(state, 'unexpected end of the document within a single quoted scalar');
    } else {
      state.position++;
      captureEnd = state.position;
    }
  }

  throwError(state, 'unexpected end of the stream within a single quoted scalar');
}

function readDoubleQuotedScalar(state, nodeIndent) {
  var captureStart, captureEnd, hexLength, hexResult, tmp, ch;
  ch = state.input.charCodeAt(state.position);

  if (ch !== 0x22
  /* " */
  ) {
      return false;
    }

  state.kind = 'scalar';
  state.result = '';
  state.position++;
  captureStart = captureEnd = state.position;

  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
    if (ch === 0x22
    /* " */
    ) {
        captureSegment(state, captureStart, state.position, true);
        state.position++;
        return true;
      } else if (ch === 0x5C
    /* \ */
    ) {
        captureSegment(state, captureStart, state.position, true);
        ch = state.input.charCodeAt(++state.position);

        if (is_EOL(ch)) {
          skipSeparationSpace(state, false, nodeIndent); // TODO: rework to inline fn with no type cast?
        } else if (ch < 256 && simpleEscapeCheck[ch]) {
          state.result += simpleEscapeMap[ch];
          state.position++;
        } else if ((tmp = escapedHexLen(ch)) > 0) {
          hexLength = tmp;
          hexResult = 0;

          for (; hexLength > 0; hexLength--) {
            ch = state.input.charCodeAt(++state.position);

            if ((tmp = fromHexCode(ch)) >= 0) {
              hexResult = (hexResult << 4) + tmp;
            } else {
              throwError(state, 'expected hexadecimal character');
            }
          }

          state.result += charFromCodepoint(hexResult);
          state.position++;
        } else {
          throwError(state, 'unknown escape sequence');
        }

        captureStart = captureEnd = state.position;
      } else if (is_EOL(ch)) {
      captureSegment(state, captureStart, captureEnd, true);
      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
      captureStart = captureEnd = state.position;
    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
      throwError(state, 'unexpected end of the document within a double quoted scalar');
    } else {
      state.position++;
      captureEnd = state.position;
    }
  }

  throwError(state, 'unexpected end of the stream within a double quoted scalar');
}

function readFlowCollection(state, nodeIndent) {
  var readNext = true,
      _line,
      _tag = state.tag,
      _result,
      _anchor = state.anchor,
      following,
      terminator,
      isPair,
      isExplicitPair,
      isMapping,
      overridableKeys = {},
      keyNode,
      keyTag,
      valueNode,
      ch;

  ch = state.input.charCodeAt(state.position);

  if (ch === 0x5B
  /* [ */
  ) {
      terminator = 0x5D;
      /* ] */

      isMapping = false;
      _result = [];
    } else if (ch === 0x7B
  /* { */
  ) {
      terminator = 0x7D;
      /* } */

      isMapping = true;
      _result = {};
    } else {
    return false;
  }

  if (state.anchor !== null) {
    state.anchorMap[state.anchor] = _result;
  }

  ch = state.input.charCodeAt(++state.position);

  while (ch !== 0) {
    skipSeparationSpace(state, true, nodeIndent);
    ch = state.input.charCodeAt(state.position);

    if (ch === terminator) {
      state.position++;
      state.tag = _tag;
      state.anchor = _anchor;
      state.kind = isMapping ? 'mapping' : 'sequence';
      state.result = _result;
      return true;
    } else if (!readNext) {
      throwError(state, 'missed comma between flow collection entries');
    }

    keyTag = keyNode = valueNode = null;
    isPair = isExplicitPair = false;

    if (ch === 0x3F
    /* ? */
    ) {
        following = state.input.charCodeAt(state.position + 1);

        if (is_WS_OR_EOL(following)) {
          isPair = isExplicitPair = true;
          state.position++;
          skipSeparationSpace(state, true, nodeIndent);
        }
      }

    _line = state.line;
    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
    keyTag = state.tag;
    keyNode = state.result;
    skipSeparationSpace(state, true, nodeIndent);
    ch = state.input.charCodeAt(state.position);

    if ((isExplicitPair || state.line === _line) && ch === 0x3A
    /* : */
    ) {
        isPair = true;
        ch = state.input.charCodeAt(++state.position);
        skipSeparationSpace(state, true, nodeIndent);
        composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
        valueNode = state.result;
      }

    if (isMapping) {
      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
    } else if (isPair) {
      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
    } else {
      _result.push(keyNode);
    }

    skipSeparationSpace(state, true, nodeIndent);
    ch = state.input.charCodeAt(state.position);

    if (ch === 0x2C
    /* , */
    ) {
        readNext = true;
        ch = state.input.charCodeAt(++state.position);
      } else {
      readNext = false;
    }
  }

  throwError(state, 'unexpected end of the stream within a flow collection');
}

function readBlockScalar(state, nodeIndent) {
  var captureStart,
      folding,
      chomping = CHOMPING_CLIP,
      didReadContent = false,
      detectedIndent = false,
      textIndent = nodeIndent,
      emptyLines = 0,
      atMoreIndented = false,
      tmp,
      ch;
  ch = state.input.charCodeAt(state.position);

  if (ch === 0x7C
  /* | */
  ) {
      folding = false;
    } else if (ch === 0x3E
  /* > */
  ) {
      folding = true;
    } else {
    return false;
  }

  state.kind = 'scalar';
  state.result = '';

  while (ch !== 0) {
    ch = state.input.charCodeAt(++state.position);

    if (ch === 0x2B
    /* + */
    || ch === 0x2D
    /* - */
    ) {
        if (CHOMPING_CLIP === chomping) {
          chomping = ch === 0x2B
          /* + */
          ? CHOMPING_KEEP : CHOMPING_STRIP;
        } else {
          throwError(state, 'repeat of a chomping mode identifier');
        }
      } else if ((tmp = fromDecimalCode(ch)) >= 0) {
      if (tmp === 0) {
        throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
      } else if (!detectedIndent) {
        textIndent = nodeIndent + tmp - 1;
        detectedIndent = true;
      } else {
        throwError(state, 'repeat of an indentation width identifier');
      }
    } else {
      break;
    }
  }

  if (is_WHITE_SPACE(ch)) {
    do {
      ch = state.input.charCodeAt(++state.position);
    } while (is_WHITE_SPACE(ch));

    if (ch === 0x23
    /* # */
    ) {
        do {
          ch = state.input.charCodeAt(++state.position);
        } while (!is_EOL(ch) && ch !== 0);
      }
  }

  while (ch !== 0) {
    readLineBreak(state);
    state.lineIndent = 0;
    ch = state.input.charCodeAt(state.position);

    while ((!detectedIndent || state.lineIndent < textIndent) && ch === 0x20
    /* Space */
    ) {
      state.lineIndent++;
      ch = state.input.charCodeAt(++state.position);
    }

    if (!detectedIndent && state.lineIndent > textIndent) {
      textIndent = state.lineIndent;
    }

    if (is_EOL(ch)) {
      emptyLines++;
      continue;
    } // End of the scalar.


    if (state.lineIndent < textIndent) {
      // Perform the chomping.
      if (chomping === CHOMPING_KEEP) {
        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
      } else if (chomping === CHOMPING_CLIP) {
        if (didReadContent) {
          // i.e. only if the scalar is not empty.
          state.result += '\n';
        }
      } // Break this `while` cycle and go to the funciton's epilogue.


      break;
    } // Folded style: use fancy rules to handle line breaks.


    if (folding) {
      // Lines starting with white space characters (more-indented lines) are not folded.
      if (is_WHITE_SPACE(ch)) {
        atMoreIndented = true; // except for the first content line (cf. Example 8.1)

        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); // End of more-indented block.
      } else if (atMoreIndented) {
        atMoreIndented = false;
        state.result += common.repeat('\n', emptyLines + 1); // Just one line break - perceive as the same line.
      } else if (emptyLines === 0) {
        if (didReadContent) {
          // i.e. only if we have already read some scalar content.
          state.result += ' ';
        } // Several line breaks - perceive as different lines.

      } else {
        state.result += common.repeat('\n', emptyLines);
      } // Literal style: just add exact number of line breaks between content lines.

    } else {
      // Keep all line breaks except the header line break.
      state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
    }

    didReadContent = true;
    detectedIndent = true;
    emptyLines = 0;
    captureStart = state.position;

    while (!is_EOL(ch) && ch !== 0) {
      ch = state.input.charCodeAt(++state.position);
    }

    captureSegment(state, captureStart, state.position, false);
  }

  return true;
}

function readBlockSequence(state, nodeIndent) {
  var _line,
      _tag = state.tag,
      _anchor = state.anchor,
      _result = [],
      following,
      detected = false,
      ch;

  if (state.anchor !== null) {
    state.anchorMap[state.anchor] = _result;
  }

  ch = state.input.charCodeAt(state.position);

  while (ch !== 0) {
    if (ch !== 0x2D
    /* - */
    ) {
        break;
      }

    following = state.input.charCodeAt(state.position + 1);

    if (!is_WS_OR_EOL(following)) {
      break;
    }

    detected = true;
    state.position++;

    if (skipSeparationSpace(state, true, -1)) {
      if (state.lineIndent <= nodeIndent) {
        _result.push(null);

        ch = state.input.charCodeAt(state.position);
        continue;
      }
    }

    _line = state.line;
    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);

    _result.push(state.result);

    skipSeparationSpace(state, true, -1);
    ch = state.input.charCodeAt(state.position);

    if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
      throwError(state, 'bad indentation of a sequence entry');
    } else if (state.lineIndent < nodeIndent) {
      break;
    }
  }

  if (detected) {
    state.tag = _tag;
    state.anchor = _anchor;
    state.kind = 'sequence';
    state.result = _result;
    return true;
  }

  return false;
}

function readBlockMapping(state, nodeIndent, flowIndent) {
  var following,
      allowCompact,
      _line,
      _pos,
      _tag = state.tag,
      _anchor = state.anchor,
      _result = {},
      overridableKeys = {},
      keyTag = null,
      keyNode = null,
      valueNode = null,
      atExplicitKey = false,
      detected = false,
      ch;

  if (state.anchor !== null) {
    state.anchorMap[state.anchor] = _result;
  }

  ch = state.input.charCodeAt(state.position);

  while (ch !== 0) {
    following = state.input.charCodeAt(state.position + 1);
    _line = state.line; // Save the current line.

    _pos = state.position; //
    // Explicit notation case. There are two separate blocks:
    // first for the key (denoted by "?") and second for the value (denoted by ":")
    //

    if ((ch === 0x3F
    /* ? */
    || ch === 0x3A
    /* : */
    ) && is_WS_OR_EOL(following)) {
      if (ch === 0x3F
      /* ? */
      ) {
          if (atExplicitKey) {
            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
            keyTag = keyNode = valueNode = null;
          }

          detected = true;
          atExplicitKey = true;
          allowCompact = true;
        } else if (atExplicitKey) {
        // i.e. 0x3A/* : */ === character after the explicit key.
        atExplicitKey = false;
        allowCompact = true;
      } else {
        throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
      }

      state.position += 1;
      ch = following; //
      // Implicit notation case. Flow-style node as the key first, then ":", and the value.
      //
    } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
      if (state.line === _line) {
        ch = state.input.charCodeAt(state.position);

        while (is_WHITE_SPACE(ch)) {
          ch = state.input.charCodeAt(++state.position);
        }

        if (ch === 0x3A
        /* : */
        ) {
            ch = state.input.charCodeAt(++state.position);

            if (!is_WS_OR_EOL(ch)) {
              throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
            }

            if (atExplicitKey) {
              storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
              keyTag = keyNode = valueNode = null;
            }

            detected = true;
            atExplicitKey = false;
            allowCompact = false;
            keyTag = state.tag;
            keyNode = state.result;
          } else if (detected) {
          throwError(state, 'can not read an implicit mapping pair; a colon is missed');
        } else {
          state.tag = _tag;
          state.anchor = _anchor;
          return true; // Keep the result of `composeNode`.
        }
      } else if (detected) {
        throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
      } else {
        state.tag = _tag;
        state.anchor = _anchor;
        return true; // Keep the result of `composeNode`.
      }
    } else {
        break; // Reading is done. Go to the epilogue.
      } //
    // Common reading code for both explicit and implicit notations.
    //


    if (state.line === _line || state.lineIndent > nodeIndent) {
      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
        if (atExplicitKey) {
          keyNode = state.result;
        } else {
          valueNode = state.result;
        }
      }

      if (!atExplicitKey) {
        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
        keyTag = keyNode = valueNode = null;
      }

      skipSeparationSpace(state, true, -1);
      ch = state.input.charCodeAt(state.position);
    }

    if (state.lineIndent > nodeIndent && ch !== 0) {
      throwError(state, 'bad indentation of a mapping entry');
    } else if (state.lineIndent < nodeIndent) {
      break;
    }
  } //
  // Epilogue.
  //
  // Special case: last mapping's node contains only the key in explicit notation.


  if (atExplicitKey) {
    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
  } // Expose the resulting mapping.


  if (detected) {
    state.tag = _tag;
    state.anchor = _anchor;
    state.kind = 'mapping';
    state.result = _result;
  }

  return detected;
}

function readTagProperty(state) {
  var _position,
      isVerbatim = false,
      isNamed = false,
      tagHandle,
      tagName,
      ch;

  ch = state.input.charCodeAt(state.position);
  if (ch !== 0x21
  /* ! */
  ) return false;

  if (state.tag !== null) {
    throwError(state, 'duplication of a tag property');
  }

  ch = state.input.charCodeAt(++state.position);

  if (ch === 0x3C
  /* < */
  ) {
      isVerbatim = true;
      ch = state.input.charCodeAt(++state.position);
    } else if (ch === 0x21
  /* ! */
  ) {
      isNamed = true;
      tagHandle = '!!';
      ch = state.input.charCodeAt(++state.position);
    } else {
    tagHandle = '!';
  }

  _position = state.position;

  if (isVerbatim) {
    do {
      ch = state.input.charCodeAt(++state.position);
    } while (ch !== 0 && ch !== 0x3E
    /* > */
    );

    if (state.position < state.length) {
      tagName = state.input.slice(_position, state.position);
      ch = state.input.charCodeAt(++state.position);
    } else {
      throwError(state, 'unexpected end of the stream within a verbatim tag');
    }
  } else {
    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
      if (ch === 0x21
      /* ! */
      ) {
          if (!isNamed) {
            tagHandle = state.input.slice(_position - 1, state.position + 1);

            if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
              throwError(state, 'named tag handle cannot contain such characters');
            }

            isNamed = true;
            _position = state.position + 1;
          } else {
            throwError(state, 'tag suffix cannot contain exclamation marks');
          }
        }

      ch = state.input.charCodeAt(++state.position);
    }

    tagName = state.input.slice(_position, state.position);

    if (PATTERN_FLOW_INDICATORS.test(tagName)) {
      throwError(state, 'tag suffix cannot contain flow indicator characters');
    }
  }

  if (tagName && !PATTERN_TAG_URI.test(tagName)) {
    throwError(state, 'tag name cannot contain such characters: ' + tagName);
  }

  if (isVerbatim) {
    state.tag = tagName;
  } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
    state.tag = state.tagMap[tagHandle] + tagName;
  } else if (tagHandle === '!') {
    state.tag = '!' + tagName;
  } else if (tagHandle === '!!') {
    state.tag = 'tag:yaml.org,2002:' + tagName;
  } else {
    throwError(state, 'undeclared tag handle "' + tagHandle + '"');
  }

  return true;
}

function readAnchorProperty(state) {
  var _position, ch;

  ch = state.input.charCodeAt(state.position);
  if (ch !== 0x26
  /* & */
  ) return false;

  if (state.anchor !== null) {
    throwError(state, 'duplication of an anchor property');
  }

  ch = state.input.charCodeAt(++state.position);
  _position = state.position;

  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
    ch = state.input.charCodeAt(++state.position);
  }

  if (state.position === _position) {
    throwError(state, 'name of an anchor node must contain at least one character');
  }

  state.anchor = state.input.slice(_position, state.position);
  return true;
}

function readAlias(state) {
  var _position, alias, ch;

  ch = state.input.charCodeAt(state.position);
  if (ch !== 0x2A
  /* * */
  ) return false;
  ch = state.input.charCodeAt(++state.position);
  _position = state.position;

  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
    ch = state.input.charCodeAt(++state.position);
  }

  if (state.position === _position) {
    throwError(state, 'name of an alias node must contain at least one character');
  }

  alias = state.input.slice(_position, state.position);

  if (!state.anchorMap.hasOwnProperty(alias)) {
    throwError(state, 'unidentified alias "' + alias + '"');
  }

  state.result = state.anchorMap[alias];
  skipSeparationSpace(state, true, -1);
  return true;
}

function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
  var allowBlockStyles,
      allowBlockScalars,
      allowBlockCollections,
      indentStatus = 1,
      // 1: this>parent, 0: this=parent, -1: this<parent
  atNewLine = false,
      hasContent = false,
      typeIndex,
      typeQuantity,
      type,
      flowIndent,
      blockIndent;

  if (state.listener !== null) {
    state.listener('open', state);
  }

  state.tag = null;
  state.anchor = null;
  state.kind = null;
  state.result = null;
  allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;

  if (allowToSeek) {
    if (skipSeparationSpace(state, true, -1)) {
      atNewLine = true;

      if (state.lineIndent > parentIndent) {
        indentStatus = 1;
      } else if (state.lineIndent === parentIndent) {
        indentStatus = 0;
      } else if (state.lineIndent < parentIndent) {
        indentStatus = -1;
      }
    }
  }

  if (indentStatus === 1) {
    while (readTagProperty(state) || readAnchorProperty(state)) {
      if (skipSeparationSpace(state, true, -1)) {
        atNewLine = true;
        allowBlockCollections = allowBlockStyles;

        if (state.lineIndent > parentIndent) {
          indentStatus = 1;
        } else if (state.lineIndent === parentIndent) {
          indentStatus = 0;
        } else if (state.lineIndent < parentIndent) {
          indentStatus = -1;
        }
      } else {
        allowBlockCollections = false;
      }
    }
  }

  if (allowBlockCollections) {
    allowBlockCollections = atNewLine || allowCompact;
  }

  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
      flowIndent = parentIndent;
    } else {
      flowIndent = parentIndent + 1;
    }

    blockIndent = state.position - state.lineStart;

    if (indentStatus === 1) {
      if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) {
        hasContent = true;
      } else {
        if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) {
          hasContent = true;
        } else if (readAlias(state)) {
          hasContent = true;

          if (state.tag !== null || state.anchor !== null) {
            throwError(state, 'alias node should not have any properties');
          }
        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
          hasContent = true;

          if (state.tag === null) {
            state.tag = '?';
          }
        }

        if (state.anchor !== null) {
          state.anchorMap[state.anchor] = state.result;
        }
      }
    } else if (indentStatus === 0) {
      // Special case: block sequences are allowed to have same indentation level as the parent.
      // http://www.yaml.org/spec/1.2/spec.html#id2799784
      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
    }
  }

  if (state.tag !== null && state.tag !== '!') {
    if (state.tag === '?') {
      // Implicit resolving is not allowed for non-scalar types, and '?'
      // non-specific tag is only automatically assigned to plain scalars.
      //
      // We only need to check kind conformity in case user explicitly assigns '?'
      // tag, for example like this: "!<?> [0]"
      //
      if (state.result !== null && state.kind !== 'scalar') {
        throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
      }

      for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
        type = state.implicitTypes[typeIndex];

        if (type.resolve(state.result)) {
          // `state.result` updated in resolver if matched
          state.result = type.construct(state.result);
          state.tag = type.tag;

          if (state.anchor !== null) {
            state.anchorMap[state.anchor] = state.result;
          }

          break;
        }
      }
    } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
      type = state.typeMap[state.kind || 'fallback'][state.tag];

      if (state.result !== null && type.kind !== state.kind) {
        throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
      }

      if (!type.resolve(state.result)) {
        // `state.result` updated in resolver if matched
        throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
      } else {
        state.result = type.construct(state.result);

        if (state.anchor !== null) {
          state.anchorMap[state.anchor] = state.result;
        }
      }
    } else {
      throwError(state, 'unknown tag !<' + state.tag + '>');
    }
  }

  if (state.listener !== null) {
    state.listener('close', state);
  }

  return state.tag !== null || state.anchor !== null || hasContent;
}

function readDocument(state) {
  var documentStart = state.position,
      _position,
      directiveName,
      directiveArgs,
      hasDirectives = false,
      ch;

  state.version = null;
  state.checkLineBreaks = state.legacy;
  state.tagMap = {};
  state.anchorMap = {};

  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
    skipSeparationSpace(state, true, -1);
    ch = state.input.charCodeAt(state.position);

    if (state.lineIndent > 0 || ch !== 0x25
    /* % */
    ) {
        break;
      }

    hasDirectives = true;
    ch = state.input.charCodeAt(++state.position);
    _position = state.position;

    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
      ch = state.input.charCodeAt(++state.position);
    }

    directiveName = state.input.slice(_position, state.position);
    directiveArgs = [];

    if (directiveName.length < 1) {
      throwError(state, 'directive name must not be less than one character in length');
    }

    while (ch !== 0) {
      while (is_WHITE_SPACE(ch)) {
        ch = state.input.charCodeAt(++state.position);
      }

      if (ch === 0x23
      /* # */
      ) {
          do {
            ch = state.input.charCodeAt(++state.position);
          } while (ch !== 0 && !is_EOL(ch));

          break;
        }

      if (is_EOL(ch)) break;
      _position = state.position;

      while (ch !== 0 && !is_WS_OR_EOL(ch)) {
        ch = state.input.charCodeAt(++state.position);
      }

      directiveArgs.push(state.input.slice(_position, state.position));
    }

    if (ch !== 0) readLineBreak(state);

    if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
      directiveHandlers[directiveName](state, directiveName, directiveArgs);
    } else {
      throwWarning(state, 'unknown document directive "' + directiveName + '"');
    }
  }

  skipSeparationSpace(state, true, -1);

  if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 0x2D
  /* - */
  && state.input.charCodeAt(state.position + 1) === 0x2D
  /* - */
  && state.input.charCodeAt(state.position + 2) === 0x2D
  /* - */
  ) {
      state.position += 3;
      skipSeparationSpace(state, true, -1);
    } else if (hasDirectives) {
    throwError(state, 'directives end mark is expected');
  }

  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
  skipSeparationSpace(state, true, -1);

  if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
    throwWarning(state, 'non-ASCII line breaks are interpreted as content');
  }

  state.documents.push(state.result);

  if (state.position === state.lineStart && testDocumentSeparator(state)) {
    if (state.input.charCodeAt(state.position) === 0x2E
    /* . */
    ) {
        state.position += 3;
        skipSeparationSpace(state, true, -1);
      }

    return;
  }

  if (state.position < state.length - 1) {
    throwError(state, 'end of the stream or a document separator is expected');
  } else {
    return;
  }
}

function loadDocuments(input, options) {
  input = String(input);
  options = options || {};

  if (input.length !== 0) {
    // Add tailing `\n` if not exists
    if (input.charCodeAt(input.length - 1) !== 0x0A
    /* LF */
    && input.charCodeAt(input.length - 1) !== 0x0D
    /* CR */
    ) {
        input += '\n';
      } // Strip BOM


    if (input.charCodeAt(0) === 0xFEFF) {
      input = input.slice(1);
    }
  }

  var state = new State(input, options);
  var nullpos = input.indexOf('\0');

  if (nullpos !== -1) {
    state.position = nullpos;
    throwError(state, 'null byte is not allowed in input');
  } // Use 0 as string terminator. That significantly simplifies bounds check.


  state.input += '\0';

  while (state.input.charCodeAt(state.position) === 0x20
  /* Space */
  ) {
    state.lineIndent += 1;
    state.position += 1;
  }

  while (state.position < state.length - 1) {
    readDocument(state);
  }

  return state.documents;
}

function loadAll(input, iterator, options) {
  if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
    options = iterator;
    iterator = null;
  }

  var documents = loadDocuments(input, options);

  if (typeof iterator !== 'function') {
    return documents;
  }

  for (var index = 0, length = documents.length; index < length; index += 1) {
    iterator(documents[index]);
  }
}

function load(input, options) {
  var documents = loadDocuments(input, options);

  if (documents.length === 0) {
    /*eslint-disable no-undefined*/
    return undefined;
  } else if (documents.length === 1) {
    return documents[0];
  }

  throw new YAMLException('expected a single document in the stream, but found more');
}

function safeLoadAll(input, iterator, options) {
  if (typeof iterator === 'object' && iterator !== null && typeof options === 'undefined') {
    options = iterator;
    iterator = null;
  }

  return loadAll(input, iterator, common.extend({
    schema: DEFAULT_SAFE_SCHEMA
  }, options));
}

function safeLoad(input, options) {
  return load(input, common.extend({
    schema: DEFAULT_SAFE_SCHEMA
  }, options));
}

module.exports.loadAll = loadAll;
module.exports.load = load;
module.exports.safeLoadAll = safeLoadAll;
module.exports.safeLoad = safeLoad;

/***/ }),
/* 116 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var common = __webpack_require__(20);

function Mark(name, buffer, position, line, column) {
  this.name = name;
  this.buffer = buffer;
  this.position = position;
  this.line = line;
  this.column = column;
}

Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
  var head, start, tail, end, snippet;
  if (!this.buffer) return null;
  indent = indent || 4;
  maxLength = maxLength || 75;
  head = '';
  start = this.position;

  while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {
    start -= 1;

    if (this.position - start > maxLength / 2 - 1) {
      head = ' ... ';
      start += 5;
      break;
    }
  }

  tail = '';
  end = this.position;

  while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) {
    end += 1;

    if (end - this.position > maxLength / 2 - 1) {
      tail = ' ... ';
      end -= 5;
      break;
    }
  }

  snippet = this.buffer.slice(start, end);
  return common.repeat(' ', indent) + head + snippet + tail + '\n' + common.repeat(' ', indent + this.position - start + head.length) + '^';
};

Mark.prototype.toString = function toString(compact) {
  var snippet,
      where = '';

  if (this.name) {
    where += 'in "' + this.name + '" ';
  }

  where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);

  if (!compact) {
    snippet = this.getSnippet();

    if (snippet) {
      where += ':\n' + snippet;
    }
  }

  return where;
};

module.exports = Mark;

/***/ }),
/* 117 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

module.exports = new Type('tag:yaml.org,2002:str', {
  kind: 'scalar',
  construct: function (data) {
    return data !== null ? data : '';
  }
});

/***/ }),
/* 118 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

module.exports = new Type('tag:yaml.org,2002:seq', {
  kind: 'sequence',
  construct: function (data) {
    return data !== null ? data : [];
  }
});

/***/ }),
/* 119 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

module.exports = new Type('tag:yaml.org,2002:map', {
  kind: 'mapping',
  construct: function (data) {
    return data !== null ? data : {};
  }
});

/***/ }),
/* 120 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

function resolveYamlNull(data) {
  if (data === null) return true;
  var max = data.length;
  return max === 1 && data === '~' || max === 4 && (data === 'null' || data === 'Null' || data === 'NULL');
}

function constructYamlNull() {
  return null;
}

function isNull(object) {
  return object === null;
}

module.exports = new Type('tag:yaml.org,2002:null', {
  kind: 'scalar',
  resolve: resolveYamlNull,
  construct: constructYamlNull,
  predicate: isNull,
  represent: {
    canonical: function () {
      return '~';
    },
    lowercase: function () {
      return 'null';
    },
    uppercase: function () {
      return 'NULL';
    },
    camelcase: function () {
      return 'Null';
    }
  },
  defaultStyle: 'lowercase'
});

/***/ }),
/* 121 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

function resolveYamlBoolean(data) {
  if (data === null) return false;
  var max = data.length;
  return max === 4 && (data === 'true' || data === 'True' || data === 'TRUE') || max === 5 && (data === 'false' || data === 'False' || data === 'FALSE');
}

function constructYamlBoolean(data) {
  return data === 'true' || data === 'True' || data === 'TRUE';
}

function isBoolean(object) {
  return Object.prototype.toString.call(object) === '[object Boolean]';
}

module.exports = new Type('tag:yaml.org,2002:bool', {
  kind: 'scalar',
  resolve: resolveYamlBoolean,
  construct: constructYamlBoolean,
  predicate: isBoolean,
  represent: {
    lowercase: function (object) {
      return object ? 'true' : 'false';
    },
    uppercase: function (object) {
      return object ? 'TRUE' : 'FALSE';
    },
    camelcase: function (object) {
      return object ? 'True' : 'False';
    }
  },
  defaultStyle: 'lowercase'
});

/***/ }),
/* 122 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var common = __webpack_require__(20);

var Type = __webpack_require__(7);

function isHexCode(c) {
  return 0x30
  /* 0 */
  <= c && c <= 0x39
  /* 9 */
  || 0x41
  /* A */
  <= c && c <= 0x46
  /* F */
  || 0x61
  /* a */
  <= c && c <= 0x66
  /* f */
  ;
}

function isOctCode(c) {
  return 0x30
  /* 0 */
  <= c && c <= 0x37
  /* 7 */
  ;
}

function isDecCode(c) {
  return 0x30
  /* 0 */
  <= c && c <= 0x39
  /* 9 */
  ;
}

function resolveYamlInteger(data) {
  if (data === null) return false;
  var max = data.length,
      index = 0,
      hasDigits = false,
      ch;
  if (!max) return false;
  ch = data[index]; // sign

  if (ch === '-' || ch === '+') {
    ch = data[++index];
  }

  if (ch === '0') {
    // 0
    if (index + 1 === max) return true;
    ch = data[++index]; // base 2, base 8, base 16

    if (ch === 'b') {
      // base 2
      index++;

      for (; index < max; index++) {
        ch = data[index];
        if (ch === '_') continue;
        if (ch !== '0' && ch !== '1') return false;
        hasDigits = true;
      }

      return hasDigits && ch !== '_';
    }

    if (ch === 'x') {
      // base 16
      index++;

      for (; index < max; index++) {
        ch = data[index];
        if (ch === '_') continue;
        if (!isHexCode(data.charCodeAt(index))) return false;
        hasDigits = true;
      }

      return hasDigits && ch !== '_';
    } // base 8


    for (; index < max; index++) {
      ch = data[index];
      if (ch === '_') continue;
      if (!isOctCode(data.charCodeAt(index))) return false;
      hasDigits = true;
    }

    return hasDigits && ch !== '_';
  } // base 10 (except 0) or base 60
  // value should not start with `_`;


  if (ch === '_') return false;

  for (; index < max; index++) {
    ch = data[index];
    if (ch === '_') continue;
    if (ch === ':') break;

    if (!isDecCode(data.charCodeAt(index))) {
      return false;
    }

    hasDigits = true;
  } // Should have digits and should not end with `_`


  if (!hasDigits || ch === '_') return false; // if !base60 - done;

  if (ch !== ':') return true; // base60 almost not used, no needs to optimize

  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
}

function constructYamlInteger(data) {
  var value = data,
      sign = 1,
      ch,
      base,
      digits = [];

  if (value.indexOf('_') !== -1) {
    value = value.replace(/_/g, '');
  }

  ch = value[0];

  if (ch === '-' || ch === '+') {
    if (ch === '-') sign = -1;
    value = value.slice(1);
    ch = value[0];
  }

  if (value === '0') return 0;

  if (ch === '0') {
    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
    if (value[1] === 'x') return sign * parseInt(value, 16);
    return sign * parseInt(value, 8);
  }

  if (value.indexOf(':') !== -1) {
    value.split(':').forEach(function (v) {
      digits.unshift(parseInt(v, 10));
    });
    value = 0;
    base = 1;
    digits.forEach(function (d) {
      value += d * base;
      base *= 60;
    });
    return sign * value;
  }

  return sign * parseInt(value, 10);
}

function isInteger(object) {
  return Object.prototype.toString.call(object) === '[object Number]' && object % 1 === 0 && !common.isNegativeZero(object);
}

module.exports = new Type('tag:yaml.org,2002:int', {
  kind: 'scalar',
  resolve: resolveYamlInteger,
  construct: constructYamlInteger,
  predicate: isInteger,
  represent: {
    binary: function (obj) {
      return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1);
    },
    octal: function (obj) {
      return obj >= 0 ? '0' + obj.toString(8) : '-0' + obj.toString(8).slice(1);
    },
    decimal: function (obj) {
      return obj.toString(10);
    },

    /* eslint-disable max-len */
    hexadecimal: function (obj) {
      return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1);
    }
  },
  defaultStyle: 'decimal',
  styleAliases: {
    binary: [2, 'bin'],
    octal: [8, 'oct'],
    decimal: [10, 'dec'],
    hexadecimal: [16, 'hex']
  }
});

/***/ }),
/* 123 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var common = __webpack_require__(20);

var Type = __webpack_require__(7);

var YAML_FLOAT_PATTERN = new RegExp( // 2.5e4, 2.5 and integers
'^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' + // .2e4, .2
// special case, seems not from spec
'|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' + // 20:59
'|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' + // .inf
'|[-+]?\\.(?:inf|Inf|INF)' + // .nan
'|\\.(?:nan|NaN|NAN))$');

function resolveYamlFloat(data) {
  if (data === null) return false;

  if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_`
  // Probably should update regexp & check speed
  data[data.length - 1] === '_') {
    return false;
  }

  return true;
}

function constructYamlFloat(data) {
  var value, sign, base, digits;
  value = data.replace(/_/g, '').toLowerCase();
  sign = value[0] === '-' ? -1 : 1;
  digits = [];

  if ('+-'.indexOf(value[0]) >= 0) {
    value = value.slice(1);
  }

  if (value === '.inf') {
    return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
  } else if (value === '.nan') {
    return NaN;
  } else if (value.indexOf(':') >= 0) {
    value.split(':').forEach(function (v) {
      digits.unshift(parseFloat(v, 10));
    });
    value = 0.0;
    base = 1;
    digits.forEach(function (d) {
      value += d * base;
      base *= 60;
    });
    return sign * value;
  }

  return sign * parseFloat(value, 10);
}

var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;

function representYamlFloat(object, style) {
  var res;

  if (isNaN(object)) {
    switch (style) {
      case 'lowercase':
        return '.nan';

      case 'uppercase':
        return '.NAN';

      case 'camelcase':
        return '.NaN';
    }
  } else if (Number.POSITIVE_INFINITY === object) {
    switch (style) {
      case 'lowercase':
        return '.inf';

      case 'uppercase':
        return '.INF';

      case 'camelcase':
        return '.Inf';
    }
  } else if (Number.NEGATIVE_INFINITY === object) {
    switch (style) {
      case 'lowercase':
        return '-.inf';

      case 'uppercase':
        return '-.INF';

      case 'camelcase':
        return '-.Inf';
    }
  } else if (common.isNegativeZero(object)) {
    return '-0.0';
  }

  res = object.toString(10); // JS stringifier can build scientific format without dots: 5e-100,
  // while YAML requres dot: 5.e-100. Fix it with simple hack

  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
}

function isFloat(object) {
  return Object.prototype.toString.call(object) === '[object Number]' && (object % 1 !== 0 || common.isNegativeZero(object));
}

module.exports = new Type('tag:yaml.org,2002:float', {
  kind: 'scalar',
  resolve: resolveYamlFloat,
  construct: constructYamlFloat,
  predicate: isFloat,
  represent: representYamlFloat,
  defaultStyle: 'lowercase'
});

/***/ }),
/* 124 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

var YAML_DATE_REGEXP = new RegExp('^([0-9][0-9][0-9][0-9])' + // [1] year
'-([0-9][0-9])' + // [2] month
'-([0-9][0-9])$'); // [3] day

var YAML_TIMESTAMP_REGEXP = new RegExp('^([0-9][0-9][0-9][0-9])' + // [1] year
'-([0-9][0-9]?)' + // [2] month
'-([0-9][0-9]?)' + // [3] day
'(?:[Tt]|[ \\t]+)' + // ...
'([0-9][0-9]?)' + // [4] hour
':([0-9][0-9])' + // [5] minute
':([0-9][0-9])' + // [6] second
'(?:\\.([0-9]*))?' + // [7] fraction
'(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
'(?::([0-9][0-9]))?))?$'); // [11] tz_minute

function resolveYamlTimestamp(data) {
  if (data === null) return false;
  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
  return false;
}

function constructYamlTimestamp(data) {
  var match,
      year,
      month,
      day,
      hour,
      minute,
      second,
      fraction = 0,
      delta = null,
      tz_hour,
      tz_minute,
      date;
  match = YAML_DATE_REGEXP.exec(data);
  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
  if (match === null) throw new Error('Date resolve error'); // match: [1] year [2] month [3] day

  year = +match[1];
  month = +match[2] - 1; // JS month starts with 0

  day = +match[3];

  if (!match[4]) {
    // no hour
    return new Date(Date.UTC(year, month, day));
  } // match: [4] hour [5] minute [6] second [7] fraction


  hour = +match[4];
  minute = +match[5];
  second = +match[6];

  if (match[7]) {
    fraction = match[7].slice(0, 3);

    while (fraction.length < 3) {
      // milli-seconds
      fraction += '0';
    }

    fraction = +fraction;
  } // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute


  if (match[9]) {
    tz_hour = +match[10];
    tz_minute = +(match[11] || 0);
    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds

    if (match[9] === '-') delta = -delta;
  }

  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
  if (delta) date.setTime(date.getTime() - delta);
  return date;
}

function representYamlTimestamp(object
/*, style*/
) {
  return object.toISOString();
}

module.exports = new Type('tag:yaml.org,2002:timestamp', {
  kind: 'scalar',
  resolve: resolveYamlTimestamp,
  construct: constructYamlTimestamp,
  instanceOf: Date,
  represent: representYamlTimestamp
});

/***/ }),
/* 125 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

function resolveYamlMerge(data) {
  return data === '<<' || data === null;
}

module.exports = new Type('tag:yaml.org,2002:merge', {
  kind: 'scalar',
  resolve: resolveYamlMerge
});

/***/ }),
/* 126 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
var require;
/*eslint-disable no-bitwise*/

var NodeBuffer;

try {
  // A trick for browserified version, to not include `Buffer` shim
  var _require = require;
  NodeBuffer = __webpack_require__(58).Buffer;
} catch (__) {}

var Type = __webpack_require__(7); // [ 64, 65, 66 ] -> [ padding, CR, LF ]


var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';

function resolveYamlBinary(data) {
  if (data === null) return false;
  var code,
      idx,
      bitlen = 0,
      max = data.length,
      map = BASE64_MAP; // Convert one by one.

  for (idx = 0; idx < max; idx++) {
    code = map.indexOf(data.charAt(idx)); // Skip CR/LF

    if (code > 64) continue; // Fail on illegal characters

    if (code < 0) return false;
    bitlen += 6;
  } // If there are any bits left, source was corrupted


  return bitlen % 8 === 0;
}

function constructYamlBinary(data) {
  var idx,
      tailbits,
      input = data.replace(/[\r\n=]/g, ''),
      // remove CR/LF & padding to simplify scan
  max = input.length,
      map = BASE64_MAP,
      bits = 0,
      result = []; // Collect by 6*4 bits (3 bytes)

  for (idx = 0; idx < max; idx++) {
    if (idx % 4 === 0 && idx) {
      result.push(bits >> 16 & 0xFF);
      result.push(bits >> 8 & 0xFF);
      result.push(bits & 0xFF);
    }

    bits = bits << 6 | map.indexOf(input.charAt(idx));
  } // Dump tail


  tailbits = max % 4 * 6;

  if (tailbits === 0) {
    result.push(bits >> 16 & 0xFF);
    result.push(bits >> 8 & 0xFF);
    result.push(bits & 0xFF);
  } else if (tailbits === 18) {
    result.push(bits >> 10 & 0xFF);
    result.push(bits >> 2 & 0xFF);
  } else if (tailbits === 12) {
    result.push(bits >> 4 & 0xFF);
  } // Wrap into Buffer for NodeJS and leave Array for browser


  if (NodeBuffer) {
    // Support node 6.+ Buffer API when available
    return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
  }

  return result;
}

function representYamlBinary(object
/*, style*/
) {
  var result = '',
      bits = 0,
      idx,
      tail,
      max = object.length,
      map = BASE64_MAP; // Convert every three bytes to 4 ASCII characters.

  for (idx = 0; idx < max; idx++) {
    if (idx % 3 === 0 && idx) {
      result += map[bits >> 18 & 0x3F];
      result += map[bits >> 12 & 0x3F];
      result += map[bits >> 6 & 0x3F];
      result += map[bits & 0x3F];
    }

    bits = (bits << 8) + object[idx];
  } // Dump tail


  tail = max % 3;

  if (tail === 0) {
    result += map[bits >> 18 & 0x3F];
    result += map[bits >> 12 & 0x3F];
    result += map[bits >> 6 & 0x3F];
    result += map[bits & 0x3F];
  } else if (tail === 2) {
    result += map[bits >> 10 & 0x3F];
    result += map[bits >> 4 & 0x3F];
    result += map[bits << 2 & 0x3F];
    result += map[64];
  } else if (tail === 1) {
    result += map[bits >> 2 & 0x3F];
    result += map[bits << 4 & 0x3F];
    result += map[64];
    result += map[64];
  }

  return result;
}

function isBinary(object) {
  return NodeBuffer && NodeBuffer.isBuffer(object);
}

module.exports = new Type('tag:yaml.org,2002:binary', {
  kind: 'scalar',
  resolve: resolveYamlBinary,
  construct: constructYamlBinary,
  predicate: isBinary,
  represent: representYamlBinary
});

/***/ }),
/* 127 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.byteLength = byteLength;
exports.toByteArray = toByteArray;
exports.fromByteArray = fromByteArray;
var lookup = [];
var revLookup = [];
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

for (var i = 0, len = code.length; i < len; ++i) {
  lookup[i] = code[i];
  revLookup[code.charCodeAt(i)] = i;
} // Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications


revLookup['-'.charCodeAt(0)] = 62;
revLookup['_'.charCodeAt(0)] = 63;

function getLens(b64) {
  var len = b64.length;

  if (len % 4 > 0) {
    throw new Error('Invalid string. Length must be a multiple of 4');
  } // Trim off extra bytes after placeholder bytes are found
  // See: https://github.com/beatgammit/base64-js/issues/42


  var validLen = b64.indexOf('=');
  if (validLen === -1) validLen = len;
  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
  return [validLen, placeHoldersLen];
} // base64 is 4/3 + up to two characters of the original data


function byteLength(b64) {
  var lens = getLens(b64);
  var validLen = lens[0];
  var placeHoldersLen = lens[1];
  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}

function _byteLength(b64, validLen, placeHoldersLen) {
  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}

function toByteArray(b64) {
  var tmp;
  var lens = getLens(b64);
  var validLen = lens[0];
  var placeHoldersLen = lens[1];
  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
  var curByte = 0; // if there are placeholders, only get up to the last complete 4 chars

  var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
  var i;

  for (i = 0; i < len; i += 4) {
    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
    arr[curByte++] = tmp >> 16 & 0xFF;
    arr[curByte++] = tmp >> 8 & 0xFF;
    arr[curByte++] = tmp & 0xFF;
  }

  if (placeHoldersLen === 2) {
    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
    arr[curByte++] = tmp & 0xFF;
  }

  if (placeHoldersLen === 1) {
    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
    arr[curByte++] = tmp >> 8 & 0xFF;
    arr[curByte++] = tmp & 0xFF;
  }

  return arr;
}

function tripletToBase64(num) {
  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];
}

function encodeChunk(uint8, start, end) {
  var tmp;
  var output = [];

  for (var i = start; i < end; i += 3) {
    tmp = (uint8[i] << 16 & 0xFF0000) + (uint8[i + 1] << 8 & 0xFF00) + (uint8[i + 2] & 0xFF);
    output.push(tripletToBase64(tmp));
  }

  return output.join('');
}

function fromByteArray(uint8) {
  var tmp;
  var len = uint8.length;
  var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes

  var parts = [];
  var maxChunkLength = 16383; // must be multiple of 3
  // go through the array every three bytes, we'll deal with trailing stuff later

  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
  } // pad the end with zeros, but make sure to not forget the extra bytes


  if (extraBytes === 1) {
    tmp = uint8[len - 1];
    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + '==');
  } else if (extraBytes === 2) {
    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
    parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 0x3F] + lookup[tmp << 2 & 0x3F] + '=');
  }

  return parts.join('');
}

/***/ }),
/* 128 */
/***/ (function(module, exports) {

exports.read = function (buffer, offset, isLE, mLen, nBytes) {
  var e, m;
  var eLen = nBytes * 8 - mLen - 1;
  var eMax = (1 << eLen) - 1;
  var eBias = eMax >> 1;
  var nBits = -7;
  var i = isLE ? nBytes - 1 : 0;
  var d = isLE ? -1 : 1;
  var s = buffer[offset + i];
  i += d;
  e = s & (1 << -nBits) - 1;
  s >>= -nBits;
  nBits += eLen;

  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}

  m = e & (1 << -nBits) - 1;
  e >>= -nBits;
  nBits += mLen;

  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}

  if (e === 0) {
    e = 1 - eBias;
  } else if (e === eMax) {
    return m ? NaN : (s ? -1 : 1) * Infinity;
  } else {
    m = m + Math.pow(2, mLen);
    e = e - eBias;
  }

  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};

exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
  var e, m, c;
  var eLen = nBytes * 8 - mLen - 1;
  var eMax = (1 << eLen) - 1;
  var eBias = eMax >> 1;
  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
  var i = isLE ? 0 : nBytes - 1;
  var d = isLE ? 1 : -1;
  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
  value = Math.abs(value);

  if (isNaN(value) || value === Infinity) {
    m = isNaN(value) ? 1 : 0;
    e = eMax;
  } else {
    e = Math.floor(Math.log(value) / Math.LN2);

    if (value * (c = Math.pow(2, -e)) < 1) {
      e--;
      c *= 2;
    }

    if (e + eBias >= 1) {
      value += rt / c;
    } else {
      value += rt * Math.pow(2, 1 - eBias);
    }

    if (value * c >= 2) {
      e++;
      c /= 2;
    }

    if (e + eBias >= eMax) {
      m = 0;
      e = eMax;
    } else if (e + eBias >= 1) {
      m = (value * c - 1) * Math.pow(2, mLen);
      e = e + eBias;
    } else {
      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
      e = 0;
    }
  }

  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

  e = e << mLen | m;
  eLen += mLen;

  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

  buffer[offset + i - d] |= s * 128;
};

/***/ }),
/* 129 */
/***/ (function(module, exports) {

var toString = {}.toString;

module.exports = Array.isArray || function (arr) {
  return toString.call(arr) == '[object Array]';
};

/***/ }),
/* 130 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

var _hasOwnProperty = Object.prototype.hasOwnProperty;
var _toString = Object.prototype.toString;

function resolveYamlOmap(data) {
  if (data === null) return true;
  var objectKeys = [],
      index,
      length,
      pair,
      pairKey,
      pairHasKey,
      object = data;

  for (index = 0, length = object.length; index < length; index += 1) {
    pair = object[index];
    pairHasKey = false;
    if (_toString.call(pair) !== '[object Object]') return false;

    for (pairKey in pair) {
      if (_hasOwnProperty.call(pair, pairKey)) {
        if (!pairHasKey) pairHasKey = true;else return false;
      }
    }

    if (!pairHasKey) return false;
    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);else return false;
  }

  return true;
}

function constructYamlOmap(data) {
  return data !== null ? data : [];
}

module.exports = new Type('tag:yaml.org,2002:omap', {
  kind: 'sequence',
  resolve: resolveYamlOmap,
  construct: constructYamlOmap
});

/***/ }),
/* 131 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

var _toString = Object.prototype.toString;

function resolveYamlPairs(data) {
  if (data === null) return true;
  var index,
      length,
      pair,
      keys,
      result,
      object = data;
  result = new Array(object.length);

  for (index = 0, length = object.length; index < length; index += 1) {
    pair = object[index];
    if (_toString.call(pair) !== '[object Object]') return false;
    keys = Object.keys(pair);
    if (keys.length !== 1) return false;
    result[index] = [keys[0], pair[keys[0]]];
  }

  return true;
}

function constructYamlPairs(data) {
  if (data === null) return [];
  var index,
      length,
      pair,
      keys,
      result,
      object = data;
  result = new Array(object.length);

  for (index = 0, length = object.length; index < length; index += 1) {
    pair = object[index];
    keys = Object.keys(pair);
    result[index] = [keys[0], pair[keys[0]]];
  }

  return result;
}

module.exports = new Type('tag:yaml.org,2002:pairs', {
  kind: 'sequence',
  resolve: resolveYamlPairs,
  construct: constructYamlPairs
});

/***/ }),
/* 132 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

var _hasOwnProperty = Object.prototype.hasOwnProperty;

function resolveYamlSet(data) {
  if (data === null) return true;
  var key,
      object = data;

  for (key in object) {
    if (_hasOwnProperty.call(object, key)) {
      if (object[key] !== null) return false;
    }
  }

  return true;
}

function constructYamlSet(data) {
  return data !== null ? data : {};
}

module.exports = new Type('tag:yaml.org,2002:set', {
  kind: 'mapping',
  resolve: resolveYamlSet,
  construct: constructYamlSet
});

/***/ }),
/* 133 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

function resolveJavascriptUndefined() {
  return true;
}

function constructJavascriptUndefined() {
  /*eslint-disable no-undefined*/
  return undefined;
}

function representJavascriptUndefined() {
  return '';
}

function isUndefined(object) {
  return typeof object === 'undefined';
}

module.exports = new Type('tag:yaml.org,2002:js/undefined', {
  kind: 'scalar',
  resolve: resolveJavascriptUndefined,
  construct: constructJavascriptUndefined,
  predicate: isUndefined,
  represent: representJavascriptUndefined
});

/***/ }),
/* 134 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Type = __webpack_require__(7);

function resolveJavascriptRegExp(data) {
  if (data === null) return false;
  if (data.length === 0) return false;
  var regexp = data,
      tail = /\/([gim]*)$/.exec(data),
      modifiers = ''; // if regexp starts with '/' it can have modifiers and must be properly closed
  // `/foo/gim` - modifiers tail can be maximum 3 chars

  if (regexp[0] === '/') {
    if (tail) modifiers = tail[1];
    if (modifiers.length > 3) return false; // if expression starts with /, is should be properly terminated

    if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;
  }

  return true;
}

function constructJavascriptRegExp(data) {
  var regexp = data,
      tail = /\/([gim]*)$/.exec(data),
      modifiers = ''; // `/foo/gim` - tail can be maximum 4 chars

  if (regexp[0] === '/') {
    if (tail) modifiers = tail[1];
    regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
  }

  return new RegExp(regexp, modifiers);
}

function representJavascriptRegExp(object
/*, style*/
) {
  var result = '/' + object.source + '/';
  if (object.global) result += 'g';
  if (object.multiline) result += 'm';
  if (object.ignoreCase) result += 'i';
  return result;
}

function isRegExp(object) {
  return Object.prototype.toString.call(object) === '[object RegExp]';
}

module.exports = new Type('tag:yaml.org,2002:js/regexp', {
  kind: 'scalar',
  resolve: resolveJavascriptRegExp,
  construct: constructJavascriptRegExp,
  predicate: isRegExp,
  represent: representJavascriptRegExp
});

/***/ }),
/* 135 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
var require;

var esprima; // Browserified version does not have esprima
//
// 1. For node.js just require module as deps
// 2. For browser try to require mudule via external AMD system.
//    If not found - try to fallback to window.esprima. If not
//    found too - then fail to parse.
//

try {
  // workaround to exclude package from browserify list.
  var _require = require;
  esprima = __webpack_require__(136);
} catch (_) {
  /* eslint-disable no-redeclare */

  /* global window */
  if (typeof window !== 'undefined') esprima = window.esprima;
}

var Type = __webpack_require__(7);

function resolveJavascriptFunction(data) {
  if (data === null) return false;

  try {
    var source = '(' + data + ')',
        ast = esprima.parse(source, {
      range: true
    });

    if (ast.type !== 'Program' || ast.body.length !== 1 || ast.body[0].type !== 'ExpressionStatement' || ast.body[0].expression.type !== 'ArrowFunctionExpression' && ast.body[0].expression.type !== 'FunctionExpression') {
      return false;
    }

    return true;
  } catch (err) {
    return false;
  }
}

function constructJavascriptFunction(data) {
  /*jslint evil:true*/
  var source = '(' + data + ')',
      ast = esprima.parse(source, {
    range: true
  }),
      params = [],
      body;

  if (ast.type !== 'Program' || ast.body.length !== 1 || ast.body[0].type !== 'ExpressionStatement' || ast.body[0].expression.type !== 'ArrowFunctionExpression' && ast.body[0].expression.type !== 'FunctionExpression') {
    throw new Error('Failed to resolve function');
  }

  ast.body[0].expression.params.forEach(function (param) {
    params.push(param.name);
  });
  body = ast.body[0].expression.body.range; // Esprima's ranges include the first '{' and the last '}' characters on
  // function expressions. So cut them out.

  if (ast.body[0].expression.body.type === 'BlockStatement') {
    /*eslint-disable no-new-func*/
    return new Function(params, source.slice(body[0] + 1, body[1] - 1));
  } // ES6 arrow functions can omit the BlockStatement. In that case, just return
  // the body.

  /*eslint-disable no-new-func*/


  return new Function(params, 'return ' + source.slice(body[0], body[1]));
}

function representJavascriptFunction(object
/*, style*/
) {
  return object.toString();
}

function isFunction(object) {
  return Object.prototype.toString.call(object) === '[object Function]';
}

module.exports = new Type('tag:yaml.org,2002:js/function', {
  kind: 'scalar',
  resolve: resolveJavascriptFunction,
  construct: constructJavascriptFunction,
  predicate: isFunction,
  represent: representJavascriptFunction
});

/***/ }),
/* 136 */
/***/ (function(module, exports, __webpack_require__) {

(function webpackUniversalModuleDefinition(root, factory) {
  /* istanbul ignore next */
  if (true) module.exports = factory();else {}
})(this, function () {
  return (
    /******/
    function (modules) {
      // webpackBootstrap

      /******/
      // The module cache

      /******/
      var installedModules = {};
      /******/
      // The require function

      /******/

      function __webpack_require__(moduleId) {
        /******/
        // Check if module is in cache

        /* istanbul ignore if */

        /******/
        if (installedModules[moduleId])
          /******/
          return installedModules[moduleId].exports;
        /******/
        // Create a new module (and put it into the cache)

        /******/

        var module = installedModules[moduleId] = {
          /******/
          exports: {},

          /******/
          id: moduleId,

          /******/
          loaded: false
          /******/

        };
        /******/
        // Execute the module function

        /******/

        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
        /******/
        // Flag the module as loaded

        /******/

        module.loaded = true;
        /******/
        // Return the exports of the module

        /******/

        return module.exports;
        /******/
      }
      /******/
      // expose the modules object (__webpack_modules__)

      /******/


      __webpack_require__.m = modules;
      /******/
      // expose the module cache

      /******/

      __webpack_require__.c = installedModules;
      /******/
      // __webpack_public_path__

      /******/

      __webpack_require__.p = "";
      /******/
      // Load entry module and return exports

      /******/

      return __webpack_require__(0);
      /******/
    }(
    /************************************************************************/

    /******/
    [
    /* 0 */

    /***/
    function (module, exports, __webpack_require__) {
      "use strict";
      /*
        Copyright JS Foundation and other contributors, https://js.foundation/
      	  Redistribution and use in source and binary forms, with or without
        modification, are permitted provided that the following conditions are met:
      	    * Redistributions of source code must retain the above copyright
            notice, this list of conditions and the following disclaimer.
          * Redistributions in binary form must reproduce the above copyright
            notice, this list of conditions and the following disclaimer in the
            documentation and/or other materials provided with the distribution.
      	  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
        DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
        (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
        LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
        ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
        (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
        THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      */

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var comment_handler_1 = __webpack_require__(1);

      var jsx_parser_1 = __webpack_require__(3);

      var parser_1 = __webpack_require__(8);

      var tokenizer_1 = __webpack_require__(15);

      function parse(code, options, delegate) {
        var commentHandler = null;

        var proxyDelegate = function (node, metadata) {
          if (delegate) {
            delegate(node, metadata);
          }

          if (commentHandler) {
            commentHandler.visit(node, metadata);
          }
        };

        var parserDelegate = typeof delegate === 'function' ? proxyDelegate : null;
        var collectComment = false;

        if (options) {
          collectComment = typeof options.comment === 'boolean' && options.comment;
          var attachComment = typeof options.attachComment === 'boolean' && options.attachComment;

          if (collectComment || attachComment) {
            commentHandler = new comment_handler_1.CommentHandler();
            commentHandler.attach = attachComment;
            options.comment = true;
            parserDelegate = proxyDelegate;
          }
        }

        var isModule = false;

        if (options && typeof options.sourceType === 'string') {
          isModule = options.sourceType === 'module';
        }

        var parser;

        if (options && typeof options.jsx === 'boolean' && options.jsx) {
          parser = new jsx_parser_1.JSXParser(code, options, parserDelegate);
        } else {
          parser = new parser_1.Parser(code, options, parserDelegate);
        }

        var program = isModule ? parser.parseModule() : parser.parseScript();
        var ast = program;

        if (collectComment && commentHandler) {
          ast.comments = commentHandler.comments;
        }

        if (parser.config.tokens) {
          ast.tokens = parser.tokens;
        }

        if (parser.config.tolerant) {
          ast.errors = parser.errorHandler.errors;
        }

        return ast;
      }

      exports.parse = parse;

      function parseModule(code, options, delegate) {
        var parsingOptions = options || {};
        parsingOptions.sourceType = 'module';
        return parse(code, parsingOptions, delegate);
      }

      exports.parseModule = parseModule;

      function parseScript(code, options, delegate) {
        var parsingOptions = options || {};
        parsingOptions.sourceType = 'script';
        return parse(code, parsingOptions, delegate);
      }

      exports.parseScript = parseScript;

      function tokenize(code, options, delegate) {
        var tokenizer = new tokenizer_1.Tokenizer(code, options);
        var tokens;
        tokens = [];

        try {
          while (true) {
            var token = tokenizer.getNextToken();

            if (!token) {
              break;
            }

            if (delegate) {
              token = delegate(token);
            }

            tokens.push(token);
          }
        } catch (e) {
          tokenizer.errorHandler.tolerate(e);
        }

        if (tokenizer.errorHandler.tolerant) {
          tokens.errors = tokenizer.errors();
        }

        return tokens;
      }

      exports.tokenize = tokenize;

      var syntax_1 = __webpack_require__(2);

      exports.Syntax = syntax_1.Syntax; // Sync with *.json manifests.

      exports.version = '4.0.1';
      /***/
    },
    /* 1 */

    /***/
    function (module, exports, __webpack_require__) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var syntax_1 = __webpack_require__(2);

      var CommentHandler = function () {
        function CommentHandler() {
          this.attach = false;
          this.comments = [];
          this.stack = [];
          this.leading = [];
          this.trailing = [];
        }

        CommentHandler.prototype.insertInnerComments = function (node, metadata) {
          //  innnerComments for properties empty block
          //  `function a() {/** comments **\/}`
          if (node.type === syntax_1.Syntax.BlockStatement && node.body.length === 0) {
            var innerComments = [];

            for (var i = this.leading.length - 1; i >= 0; --i) {
              var entry = this.leading[i];

              if (metadata.end.offset >= entry.start) {
                innerComments.unshift(entry.comment);
                this.leading.splice(i, 1);
                this.trailing.splice(i, 1);
              }
            }

            if (innerComments.length) {
              node.innerComments = innerComments;
            }
          }
        };

        CommentHandler.prototype.findTrailingComments = function (metadata) {
          var trailingComments = [];

          if (this.trailing.length > 0) {
            for (var i = this.trailing.length - 1; i >= 0; --i) {
              var entry_1 = this.trailing[i];

              if (entry_1.start >= metadata.end.offset) {
                trailingComments.unshift(entry_1.comment);
              }
            }

            this.trailing.length = 0;
            return trailingComments;
          }

          var entry = this.stack[this.stack.length - 1];

          if (entry && entry.node.trailingComments) {
            var firstComment = entry.node.trailingComments[0];

            if (firstComment && firstComment.range[0] >= metadata.end.offset) {
              trailingComments = entry.node.trailingComments;
              delete entry.node.trailingComments;
            }
          }

          return trailingComments;
        };

        CommentHandler.prototype.findLeadingComments = function (metadata) {
          var leadingComments = [];
          var target;

          while (this.stack.length > 0) {
            var entry = this.stack[this.stack.length - 1];

            if (entry && entry.start >= metadata.start.offset) {
              target = entry.node;
              this.stack.pop();
            } else {
              break;
            }
          }

          if (target) {
            var count = target.leadingComments ? target.leadingComments.length : 0;

            for (var i = count - 1; i >= 0; --i) {
              var comment = target.leadingComments[i];

              if (comment.range[1] <= metadata.start.offset) {
                leadingComments.unshift(comment);
                target.leadingComments.splice(i, 1);
              }
            }

            if (target.leadingComments && target.leadingComments.length === 0) {
              delete target.leadingComments;
            }

            return leadingComments;
          }

          for (var i = this.leading.length - 1; i >= 0; --i) {
            var entry = this.leading[i];

            if (entry.start <= metadata.start.offset) {
              leadingComments.unshift(entry.comment);
              this.leading.splice(i, 1);
            }
          }

          return leadingComments;
        };

        CommentHandler.prototype.visitNode = function (node, metadata) {
          if (node.type === syntax_1.Syntax.Program && node.body.length > 0) {
            return;
          }

          this.insertInnerComments(node, metadata);
          var trailingComments = this.findTrailingComments(metadata);
          var leadingComments = this.findLeadingComments(metadata);

          if (leadingComments.length > 0) {
            node.leadingComments = leadingComments;
          }

          if (trailingComments.length > 0) {
            node.trailingComments = trailingComments;
          }

          this.stack.push({
            node: node,
            start: metadata.start.offset
          });
        };

        CommentHandler.prototype.visitComment = function (node, metadata) {
          var type = node.type[0] === 'L' ? 'Line' : 'Block';
          var comment = {
            type: type,
            value: node.value
          };

          if (node.range) {
            comment.range = node.range;
          }

          if (node.loc) {
            comment.loc = node.loc;
          }

          this.comments.push(comment);

          if (this.attach) {
            var entry = {
              comment: {
                type: type,
                value: node.value,
                range: [metadata.start.offset, metadata.end.offset]
              },
              start: metadata.start.offset
            };

            if (node.loc) {
              entry.comment.loc = node.loc;
            }

            node.type = type;
            this.leading.push(entry);
            this.trailing.push(entry);
          }
        };

        CommentHandler.prototype.visit = function (node, metadata) {
          if (node.type === 'LineComment') {
            this.visitComment(node, metadata);
          } else if (node.type === 'BlockComment') {
            this.visitComment(node, metadata);
          } else if (this.attach) {
            this.visitNode(node, metadata);
          }
        };

        return CommentHandler;
      }();

      exports.CommentHandler = CommentHandler;
      /***/
    },
    /* 2 */

    /***/
    function (module, exports) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      });
      exports.Syntax = {
        AssignmentExpression: 'AssignmentExpression',
        AssignmentPattern: 'AssignmentPattern',
        ArrayExpression: 'ArrayExpression',
        ArrayPattern: 'ArrayPattern',
        ArrowFunctionExpression: 'ArrowFunctionExpression',
        AwaitExpression: 'AwaitExpression',
        BlockStatement: 'BlockStatement',
        BinaryExpression: 'BinaryExpression',
        BreakStatement: 'BreakStatement',
        CallExpression: 'CallExpression',
        CatchClause: 'CatchClause',
        ClassBody: 'ClassBody',
        ClassDeclaration: 'ClassDeclaration',
        ClassExpression: 'ClassExpression',
        ConditionalExpression: 'ConditionalExpression',
        ContinueStatement: 'ContinueStatement',
        DoWhileStatement: 'DoWhileStatement',
        DebuggerStatement: 'DebuggerStatement',
        EmptyStatement: 'EmptyStatement',
        ExportAllDeclaration: 'ExportAllDeclaration',
        ExportDefaultDeclaration: 'ExportDefaultDeclaration',
        ExportNamedDeclaration: 'ExportNamedDeclaration',
        ExportSpecifier: 'ExportSpecifier',
        ExpressionStatement: 'ExpressionStatement',
        ForStatement: 'ForStatement',
        ForOfStatement: 'ForOfStatement',
        ForInStatement: 'ForInStatement',
        FunctionDeclaration: 'FunctionDeclaration',
        FunctionExpression: 'FunctionExpression',
        Identifier: 'Identifier',
        IfStatement: 'IfStatement',
        ImportDeclaration: 'ImportDeclaration',
        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
        ImportSpecifier: 'ImportSpecifier',
        Literal: 'Literal',
        LabeledStatement: 'LabeledStatement',
        LogicalExpression: 'LogicalExpression',
        MemberExpression: 'MemberExpression',
        MetaProperty: 'MetaProperty',
        MethodDefinition: 'MethodDefinition',
        NewExpression: 'NewExpression',
        ObjectExpression: 'ObjectExpression',
        ObjectPattern: 'ObjectPattern',
        Program: 'Program',
        Property: 'Property',
        RestElement: 'RestElement',
        ReturnStatement: 'ReturnStatement',
        SequenceExpression: 'SequenceExpression',
        SpreadElement: 'SpreadElement',
        Super: 'Super',
        SwitchCase: 'SwitchCase',
        SwitchStatement: 'SwitchStatement',
        TaggedTemplateExpression: 'TaggedTemplateExpression',
        TemplateElement: 'TemplateElement',
        TemplateLiteral: 'TemplateLiteral',
        ThisExpression: 'ThisExpression',
        ThrowStatement: 'ThrowStatement',
        TryStatement: 'TryStatement',
        UnaryExpression: 'UnaryExpression',
        UpdateExpression: 'UpdateExpression',
        VariableDeclaration: 'VariableDeclaration',
        VariableDeclarator: 'VariableDeclarator',
        WhileStatement: 'WhileStatement',
        WithStatement: 'WithStatement',
        YieldExpression: 'YieldExpression'
      };
      /***/
    },
    /* 3 */

    /***/
    function (module, exports, __webpack_require__) {
      "use strict";
      /* istanbul ignore next */

      var __extends = this && this.__extends || function () {
        var extendStatics = Object.setPrototypeOf || {
          __proto__: []
        } instanceof Array && function (d, b) {
          d.__proto__ = b;
        } || function (d, b) {
          for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
        };

        return function (d, b) {
          extendStatics(d, b);

          function __() {
            this.constructor = d;
          }

          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
      }();

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var character_1 = __webpack_require__(4);

      var JSXNode = __webpack_require__(5);

      var jsx_syntax_1 = __webpack_require__(6);

      var Node = __webpack_require__(7);

      var parser_1 = __webpack_require__(8);

      var token_1 = __webpack_require__(13);

      var xhtml_entities_1 = __webpack_require__(14);

      token_1.TokenName[100
      /* Identifier */
      ] = 'JSXIdentifier';
      token_1.TokenName[101
      /* Text */
      ] = 'JSXText'; // Fully qualified element name, e.g. <svg:path> returns "svg:path"

      function getQualifiedElementName(elementName) {
        var qualifiedName;

        switch (elementName.type) {
          case jsx_syntax_1.JSXSyntax.JSXIdentifier:
            var id = elementName;
            qualifiedName = id.name;
            break;

          case jsx_syntax_1.JSXSyntax.JSXNamespacedName:
            var ns = elementName;
            qualifiedName = getQualifiedElementName(ns.namespace) + ':' + getQualifiedElementName(ns.name);
            break;

          case jsx_syntax_1.JSXSyntax.JSXMemberExpression:
            var expr = elementName;
            qualifiedName = getQualifiedElementName(expr.object) + '.' + getQualifiedElementName(expr.property);
            break;

          /* istanbul ignore next */

          default:
            break;
        }

        return qualifiedName;
      }

      var JSXParser = function (_super) {
        __extends(JSXParser, _super);

        function JSXParser(code, options, delegate) {
          return _super.call(this, code, options, delegate) || this;
        }

        JSXParser.prototype.parsePrimaryExpression = function () {
          return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this);
        };

        JSXParser.prototype.startJSX = function () {
          // Unwind the scanner before the lookahead token.
          this.scanner.index = this.startMarker.index;
          this.scanner.lineNumber = this.startMarker.line;
          this.scanner.lineStart = this.startMarker.index - this.startMarker.column;
        };

        JSXParser.prototype.finishJSX = function () {
          // Prime the next lookahead.
          this.nextToken();
        };

        JSXParser.prototype.reenterJSX = function () {
          this.startJSX();
          this.expectJSX('}'); // Pop the closing '}' added from the lookahead.

          if (this.config.tokens) {
            this.tokens.pop();
          }
        };

        JSXParser.prototype.createJSXNode = function () {
          this.collectComments();
          return {
            index: this.scanner.index,
            line: this.scanner.lineNumber,
            column: this.scanner.index - this.scanner.lineStart
          };
        };

        JSXParser.prototype.createJSXChildNode = function () {
          return {
            index: this.scanner.index,
            line: this.scanner.lineNumber,
            column: this.scanner.index - this.scanner.lineStart
          };
        };

        JSXParser.prototype.scanXHTMLEntity = function (quote) {
          var result = '&';
          var valid = true;
          var terminated = false;
          var numeric = false;
          var hex = false;

          while (!this.scanner.eof() && valid && !terminated) {
            var ch = this.scanner.source[this.scanner.index];

            if (ch === quote) {
              break;
            }

            terminated = ch === ';';
            result += ch;
            ++this.scanner.index;

            if (!terminated) {
              switch (result.length) {
                case 2:
                  // e.g. '&#123;'
                  numeric = ch === '#';
                  break;

                case 3:
                  if (numeric) {
                    // e.g. '&#x41;'
                    hex = ch === 'x';
                    valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0));
                    numeric = numeric && !hex;
                  }

                  break;

                default:
                  valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0)));
                  valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0)));
                  break;
              }
            }
          }

          if (valid && terminated && result.length > 2) {
            // e.g. '&#x41;' becomes just '#x41'
            var str = result.substr(1, result.length - 2);

            if (numeric && str.length > 1) {
              result = String.fromCharCode(parseInt(str.substr(1), 10));
            } else if (hex && str.length > 2) {
              result = String.fromCharCode(parseInt('0' + str.substr(1), 16));
            } else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) {
              result = xhtml_entities_1.XHTMLEntities[str];
            }
          }

          return result;
        }; // Scan the next JSX token. This replaces Scanner#lex when in JSX mode.


        JSXParser.prototype.lexJSX = function () {
          var cp = this.scanner.source.charCodeAt(this.scanner.index); // < > / : = { }

          if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {
            var value = this.scanner.source[this.scanner.index++];
            return {
              type: 7
              /* Punctuator */
              ,
              value: value,
              lineNumber: this.scanner.lineNumber,
              lineStart: this.scanner.lineStart,
              start: this.scanner.index - 1,
              end: this.scanner.index
            };
          } // " '


          if (cp === 34 || cp === 39) {
            var start = this.scanner.index;
            var quote = this.scanner.source[this.scanner.index++];
            var str = '';

            while (!this.scanner.eof()) {
              var ch = this.scanner.source[this.scanner.index++];

              if (ch === quote) {
                break;
              } else if (ch === '&') {
                str += this.scanXHTMLEntity(quote);
              } else {
                str += ch;
              }
            }

            return {
              type: 8
              /* StringLiteral */
              ,
              value: str,
              lineNumber: this.scanner.lineNumber,
              lineStart: this.scanner.lineStart,
              start: start,
              end: this.scanner.index
            };
          } // ... or .


          if (cp === 46) {
            var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1);
            var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2);
            var value = n1 === 46 && n2 === 46 ? '...' : '.';
            var start = this.scanner.index;
            this.scanner.index += value.length;
            return {
              type: 7
              /* Punctuator */
              ,
              value: value,
              lineNumber: this.scanner.lineNumber,
              lineStart: this.scanner.lineStart,
              start: start,
              end: this.scanner.index
            };
          } // `


          if (cp === 96) {
            // Only placeholder, since it will be rescanned as a real assignment expression.
            return {
              type: 10
              /* Template */
              ,
              value: '',
              lineNumber: this.scanner.lineNumber,
              lineStart: this.scanner.lineStart,
              start: this.scanner.index,
              end: this.scanner.index
            };
          } // Identifer can not contain backslash (char code 92).


          if (character_1.Character.isIdentifierStart(cp) && cp !== 92) {
            var start = this.scanner.index;
            ++this.scanner.index;

            while (!this.scanner.eof()) {
              var ch = this.scanner.source.charCodeAt(this.scanner.index);

              if (character_1.Character.isIdentifierPart(ch) && ch !== 92) {
                ++this.scanner.index;
              } else if (ch === 45) {
                // Hyphen (char code 45) can be part of an identifier.
                ++this.scanner.index;
              } else {
                break;
              }
            }

            var id = this.scanner.source.slice(start, this.scanner.index);
            return {
              type: 100
              /* Identifier */
              ,
              value: id,
              lineNumber: this.scanner.lineNumber,
              lineStart: this.scanner.lineStart,
              start: start,
              end: this.scanner.index
            };
          }

          return this.scanner.lex();
        };

        JSXParser.prototype.nextJSXToken = function () {
          this.collectComments();
          this.startMarker.index = this.scanner.index;
          this.startMarker.line = this.scanner.lineNumber;
          this.startMarker.column = this.scanner.index - this.scanner.lineStart;
          var token = this.lexJSX();
          this.lastMarker.index = this.scanner.index;
          this.lastMarker.line = this.scanner.lineNumber;
          this.lastMarker.column = this.scanner.index - this.scanner.lineStart;

          if (this.config.tokens) {
            this.tokens.push(this.convertToken(token));
          }

          return token;
        };

        JSXParser.prototype.nextJSXText = function () {
          this.startMarker.index = this.scanner.index;
          this.startMarker.line = this.scanner.lineNumber;
          this.startMarker.column = this.scanner.index - this.scanner.lineStart;
          var start = this.scanner.index;
          var text = '';

          while (!this.scanner.eof()) {
            var ch = this.scanner.source[this.scanner.index];

            if (ch === '{' || ch === '<') {
              break;
            }

            ++this.scanner.index;
            text += ch;

            if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
              ++this.scanner.lineNumber;

              if (ch === '\r' && this.scanner.source[this.scanner.index] === '\n') {
                ++this.scanner.index;
              }

              this.scanner.lineStart = this.scanner.index;
            }
          }

          this.lastMarker.index = this.scanner.index;
          this.lastMarker.line = this.scanner.lineNumber;
          this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
          var token = {
            type: 101
            /* Text */
            ,
            value: text,
            lineNumber: this.scanner.lineNumber,
            lineStart: this.scanner.lineStart,
            start: start,
            end: this.scanner.index
          };

          if (text.length > 0 && this.config.tokens) {
            this.tokens.push(this.convertToken(token));
          }

          return token;
        };

        JSXParser.prototype.peekJSXToken = function () {
          var state = this.scanner.saveState();
          this.scanner.scanComments();
          var next = this.lexJSX();
          this.scanner.restoreState(state);
          return next;
        }; // Expect the next JSX token to match the specified punctuator.
        // If not, an exception will be thrown.


        JSXParser.prototype.expectJSX = function (value) {
          var token = this.nextJSXToken();

          if (token.type !== 7
          /* Punctuator */
          || token.value !== value) {
            this.throwUnexpectedToken(token);
          }
        }; // Return true if the next JSX token matches the specified punctuator.


        JSXParser.prototype.matchJSX = function (value) {
          var next = this.peekJSXToken();
          return next.type === 7
          /* Punctuator */
          && next.value === value;
        };

        JSXParser.prototype.parseJSXIdentifier = function () {
          var node = this.createJSXNode();
          var token = this.nextJSXToken();

          if (token.type !== 100
          /* Identifier */
          ) {
              this.throwUnexpectedToken(token);
            }

          return this.finalize(node, new JSXNode.JSXIdentifier(token.value));
        };

        JSXParser.prototype.parseJSXElementName = function () {
          var node = this.createJSXNode();
          var elementName = this.parseJSXIdentifier();

          if (this.matchJSX(':')) {
            var namespace = elementName;
            this.expectJSX(':');
            var name_1 = this.parseJSXIdentifier();
            elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1));
          } else if (this.matchJSX('.')) {
            while (this.matchJSX('.')) {
              var object = elementName;
              this.expectJSX('.');
              var property = this.parseJSXIdentifier();
              elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property));
            }
          }

          return elementName;
        };

        JSXParser.prototype.parseJSXAttributeName = function () {
          var node = this.createJSXNode();
          var attributeName;
          var identifier = this.parseJSXIdentifier();

          if (this.matchJSX(':')) {
            var namespace = identifier;
            this.expectJSX(':');
            var name_2 = this.parseJSXIdentifier();
            attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2));
          } else {
            attributeName = identifier;
          }

          return attributeName;
        };

        JSXParser.prototype.parseJSXStringLiteralAttribute = function () {
          var node = this.createJSXNode();
          var token = this.nextJSXToken();

          if (token.type !== 8
          /* StringLiteral */
          ) {
              this.throwUnexpectedToken(token);
            }

          var raw = this.getTokenRaw(token);
          return this.finalize(node, new Node.Literal(token.value, raw));
        };

        JSXParser.prototype.parseJSXExpressionAttribute = function () {
          var node = this.createJSXNode();
          this.expectJSX('{');
          this.finishJSX();

          if (this.match('}')) {
            this.tolerateError('JSX attributes must only be assigned a non-empty expression');
          }

          var expression = this.parseAssignmentExpression();
          this.reenterJSX();
          return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
        };

        JSXParser.prototype.parseJSXAttributeValue = function () {
          return this.matchJSX('{') ? this.parseJSXExpressionAttribute() : this.matchJSX('<') ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute();
        };

        JSXParser.prototype.parseJSXNameValueAttribute = function () {
          var node = this.createJSXNode();
          var name = this.parseJSXAttributeName();
          var value = null;

          if (this.matchJSX('=')) {
            this.expectJSX('=');
            value = this.parseJSXAttributeValue();
          }

          return this.finalize(node, new JSXNode.JSXAttribute(name, value));
        };

        JSXParser.prototype.parseJSXSpreadAttribute = function () {
          var node = this.createJSXNode();
          this.expectJSX('{');
          this.expectJSX('...');
          this.finishJSX();
          var argument = this.parseAssignmentExpression();
          this.reenterJSX();
          return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument));
        };

        JSXParser.prototype.parseJSXAttributes = function () {
          var attributes = [];

          while (!this.matchJSX('/') && !this.matchJSX('>')) {
            var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() : this.parseJSXNameValueAttribute();
            attributes.push(attribute);
          }

          return attributes;
        };

        JSXParser.prototype.parseJSXOpeningElement = function () {
          var node = this.createJSXNode();
          this.expectJSX('<');
          var name = this.parseJSXElementName();
          var attributes = this.parseJSXAttributes();
          var selfClosing = this.matchJSX('/');

          if (selfClosing) {
            this.expectJSX('/');
          }

          this.expectJSX('>');
          return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
        };

        JSXParser.prototype.parseJSXBoundaryElement = function () {
          var node = this.createJSXNode();
          this.expectJSX('<');

          if (this.matchJSX('/')) {
            this.expectJSX('/');
            var name_3 = this.parseJSXElementName();
            this.expectJSX('>');
            return this.finalize(node, new JSXNode.JSXClosingElement(name_3));
          }

          var name = this.parseJSXElementName();
          var attributes = this.parseJSXAttributes();
          var selfClosing = this.matchJSX('/');

          if (selfClosing) {
            this.expectJSX('/');
          }

          this.expectJSX('>');
          return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
        };

        JSXParser.prototype.parseJSXEmptyExpression = function () {
          var node = this.createJSXChildNode();
          this.collectComments();
          this.lastMarker.index = this.scanner.index;
          this.lastMarker.line = this.scanner.lineNumber;
          this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
          return this.finalize(node, new JSXNode.JSXEmptyExpression());
        };

        JSXParser.prototype.parseJSXExpressionContainer = function () {
          var node = this.createJSXNode();
          this.expectJSX('{');
          var expression;

          if (this.matchJSX('}')) {
            expression = this.parseJSXEmptyExpression();
            this.expectJSX('}');
          } else {
            this.finishJSX();
            expression = this.parseAssignmentExpression();
            this.reenterJSX();
          }

          return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
        };

        JSXParser.prototype.parseJSXChildren = function () {
          var children = [];

          while (!this.scanner.eof()) {
            var node = this.createJSXChildNode();
            var token = this.nextJSXText();

            if (token.start < token.end) {
              var raw = this.getTokenRaw(token);
              var child = this.finalize(node, new JSXNode.JSXText(token.value, raw));
              children.push(child);
            }

            if (this.scanner.source[this.scanner.index] === '{') {
              var container = this.parseJSXExpressionContainer();
              children.push(container);
            } else {
              break;
            }
          }

          return children;
        };

        JSXParser.prototype.parseComplexJSXElement = function (el) {
          var stack = [];

          while (!this.scanner.eof()) {
            el.children = el.children.concat(this.parseJSXChildren());
            var node = this.createJSXChildNode();
            var element = this.parseJSXBoundaryElement();

            if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) {
              var opening = element;

              if (opening.selfClosing) {
                var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null));
                el.children.push(child);
              } else {
                stack.push(el);
                el = {
                  node: node,
                  opening: opening,
                  closing: null,
                  children: []
                };
              }
            }

            if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) {
              el.closing = element;
              var open_1 = getQualifiedElementName(el.opening.name);
              var close_1 = getQualifiedElementName(el.closing.name);

              if (open_1 !== close_1) {
                this.tolerateError('Expected corresponding JSX closing tag for %0', open_1);
              }

              if (stack.length > 0) {
                var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing));
                el = stack[stack.length - 1];
                el.children.push(child);
                stack.pop();
              } else {
                break;
              }
            }
          }

          return el;
        };

        JSXParser.prototype.parseJSXElement = function () {
          var node = this.createJSXNode();
          var opening = this.parseJSXOpeningElement();
          var children = [];
          var closing = null;

          if (!opening.selfClosing) {
            var el = this.parseComplexJSXElement({
              node: node,
              opening: opening,
              closing: closing,
              children: children
            });
            children = el.children;
            closing = el.closing;
          }

          return this.finalize(node, new JSXNode.JSXElement(opening, children, closing));
        };

        JSXParser.prototype.parseJSXRoot = function () {
          // Pop the opening '<' added from the lookahead.
          if (this.config.tokens) {
            this.tokens.pop();
          }

          this.startJSX();
          var element = this.parseJSXElement();
          this.finishJSX();
          return element;
        };

        JSXParser.prototype.isStartOfExpression = function () {
          return _super.prototype.isStartOfExpression.call(this) || this.match('<');
        };

        return JSXParser;
      }(parser_1.Parser);

      exports.JSXParser = JSXParser;
      /***/
    },
    /* 4 */

    /***/
    function (module, exports) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      }); // See also tools/generate-unicode-regex.js.

      var Regex = {
        // Unicode v8.0.0 NonAsciiIdentifierStart:
        NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/,
        // Unicode v8.0.0 NonAsciiIdentifierPart:
        NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/
      };
      exports.Character = {
        /* tslint:disable:no-bitwise */
        fromCodePoint: function (cp) {
          return cp < 0x10000 ? String.fromCharCode(cp) : String.fromCharCode(0xD800 + (cp - 0x10000 >> 10)) + String.fromCharCode(0xDC00 + (cp - 0x10000 & 1023));
        },
        // https://tc39.github.io/ecma262/#sec-white-space
        isWhiteSpace: function (cp) {
          return cp === 0x20 || cp === 0x09 || cp === 0x0B || cp === 0x0C || cp === 0xA0 || cp >= 0x1680 && [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(cp) >= 0;
        },
        // https://tc39.github.io/ecma262/#sec-line-terminators
        isLineTerminator: function (cp) {
          return cp === 0x0A || cp === 0x0D || cp === 0x2028 || cp === 0x2029;
        },
        // https://tc39.github.io/ecma262/#sec-names-and-keywords
        isIdentifierStart: function (cp) {
          return cp === 0x24 || cp === 0x5F || cp >= 0x41 && cp <= 0x5A || cp >= 0x61 && cp <= 0x7A || cp === 0x5C || cp >= 0x80 && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp));
        },
        isIdentifierPart: function (cp) {
          return cp === 0x24 || cp === 0x5F || cp >= 0x41 && cp <= 0x5A || cp >= 0x61 && cp <= 0x7A || cp >= 0x30 && cp <= 0x39 || cp === 0x5C || cp >= 0x80 && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp));
        },
        // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
        isDecimalDigit: function (cp) {
          return cp >= 0x30 && cp <= 0x39; // 0..9
        },
        isHexDigit: function (cp) {
          return cp >= 0x30 && cp <= 0x39 || cp >= 0x41 && cp <= 0x46 || cp >= 0x61 && cp <= 0x66; // a..f
        },
        isOctalDigit: function (cp) {
          return cp >= 0x30 && cp <= 0x37; // 0..7
        }
      };
      /***/
    },
    /* 5 */

    /***/
    function (module, exports, __webpack_require__) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var jsx_syntax_1 = __webpack_require__(6);
      /* tslint:disable:max-classes-per-file */


      var JSXClosingElement = function () {
        function JSXClosingElement(name) {
          this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement;
          this.name = name;
        }

        return JSXClosingElement;
      }();

      exports.JSXClosingElement = JSXClosingElement;

      var JSXElement = function () {
        function JSXElement(openingElement, children, closingElement) {
          this.type = jsx_syntax_1.JSXSyntax.JSXElement;
          this.openingElement = openingElement;
          this.children = children;
          this.closingElement = closingElement;
        }

        return JSXElement;
      }();

      exports.JSXElement = JSXElement;

      var JSXEmptyExpression = function () {
        function JSXEmptyExpression() {
          this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression;
        }

        return JSXEmptyExpression;
      }();

      exports.JSXEmptyExpression = JSXEmptyExpression;

      var JSXExpressionContainer = function () {
        function JSXExpressionContainer(expression) {
          this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer;
          this.expression = expression;
        }

        return JSXExpressionContainer;
      }();

      exports.JSXExpressionContainer = JSXExpressionContainer;

      var JSXIdentifier = function () {
        function JSXIdentifier(name) {
          this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier;
          this.name = name;
        }

        return JSXIdentifier;
      }();

      exports.JSXIdentifier = JSXIdentifier;

      var JSXMemberExpression = function () {
        function JSXMemberExpression(object, property) {
          this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression;
          this.object = object;
          this.property = property;
        }

        return JSXMemberExpression;
      }();

      exports.JSXMemberExpression = JSXMemberExpression;

      var JSXAttribute = function () {
        function JSXAttribute(name, value) {
          this.type = jsx_syntax_1.JSXSyntax.JSXAttribute;
          this.name = name;
          this.value = value;
        }

        return JSXAttribute;
      }();

      exports.JSXAttribute = JSXAttribute;

      var JSXNamespacedName = function () {
        function JSXNamespacedName(namespace, name) {
          this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName;
          this.namespace = namespace;
          this.name = name;
        }

        return JSXNamespacedName;
      }();

      exports.JSXNamespacedName = JSXNamespacedName;

      var JSXOpeningElement = function () {
        function JSXOpeningElement(name, selfClosing, attributes) {
          this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement;
          this.name = name;
          this.selfClosing = selfClosing;
          this.attributes = attributes;
        }

        return JSXOpeningElement;
      }();

      exports.JSXOpeningElement = JSXOpeningElement;

      var JSXSpreadAttribute = function () {
        function JSXSpreadAttribute(argument) {
          this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute;
          this.argument = argument;
        }

        return JSXSpreadAttribute;
      }();

      exports.JSXSpreadAttribute = JSXSpreadAttribute;

      var JSXText = function () {
        function JSXText(value, raw) {
          this.type = jsx_syntax_1.JSXSyntax.JSXText;
          this.value = value;
          this.raw = raw;
        }

        return JSXText;
      }();

      exports.JSXText = JSXText;
      /***/
    },
    /* 6 */

    /***/
    function (module, exports) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      });
      exports.JSXSyntax = {
        JSXAttribute: 'JSXAttribute',
        JSXClosingElement: 'JSXClosingElement',
        JSXElement: 'JSXElement',
        JSXEmptyExpression: 'JSXEmptyExpression',
        JSXExpressionContainer: 'JSXExpressionContainer',
        JSXIdentifier: 'JSXIdentifier',
        JSXMemberExpression: 'JSXMemberExpression',
        JSXNamespacedName: 'JSXNamespacedName',
        JSXOpeningElement: 'JSXOpeningElement',
        JSXSpreadAttribute: 'JSXSpreadAttribute',
        JSXText: 'JSXText'
      };
      /***/
    },
    /* 7 */

    /***/
    function (module, exports, __webpack_require__) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var syntax_1 = __webpack_require__(2);
      /* tslint:disable:max-classes-per-file */


      var ArrayExpression = function () {
        function ArrayExpression(elements) {
          this.type = syntax_1.Syntax.ArrayExpression;
          this.elements = elements;
        }

        return ArrayExpression;
      }();

      exports.ArrayExpression = ArrayExpression;

      var ArrayPattern = function () {
        function ArrayPattern(elements) {
          this.type = syntax_1.Syntax.ArrayPattern;
          this.elements = elements;
        }

        return ArrayPattern;
      }();

      exports.ArrayPattern = ArrayPattern;

      var ArrowFunctionExpression = function () {
        function ArrowFunctionExpression(params, body, expression) {
          this.type = syntax_1.Syntax.ArrowFunctionExpression;
          this.id = null;
          this.params = params;
          this.body = body;
          this.generator = false;
          this.expression = expression;
          this.async = false;
        }

        return ArrowFunctionExpression;
      }();

      exports.ArrowFunctionExpression = ArrowFunctionExpression;

      var AssignmentExpression = function () {
        function AssignmentExpression(operator, left, right) {
          this.type = syntax_1.Syntax.AssignmentExpression;
          this.operator = operator;
          this.left = left;
          this.right = right;
        }

        return AssignmentExpression;
      }();

      exports.AssignmentExpression = AssignmentExpression;

      var AssignmentPattern = function () {
        function AssignmentPattern(left, right) {
          this.type = syntax_1.Syntax.AssignmentPattern;
          this.left = left;
          this.right = right;
        }

        return AssignmentPattern;
      }();

      exports.AssignmentPattern = AssignmentPattern;

      var AsyncArrowFunctionExpression = function () {
        function AsyncArrowFunctionExpression(params, body, expression) {
          this.type = syntax_1.Syntax.ArrowFunctionExpression;
          this.id = null;
          this.params = params;
          this.body = body;
          this.generator = false;
          this.expression = expression;
          this.async = true;
        }

        return AsyncArrowFunctionExpression;
      }();

      exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression;

      var AsyncFunctionDeclaration = function () {
        function AsyncFunctionDeclaration(id, params, body) {
          this.type = syntax_1.Syntax.FunctionDeclaration;
          this.id = id;
          this.params = params;
          this.body = body;
          this.generator = false;
          this.expression = false;
          this.async = true;
        }

        return AsyncFunctionDeclaration;
      }();

      exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration;

      var AsyncFunctionExpression = function () {
        function AsyncFunctionExpression(id, params, body) {
          this.type = syntax_1.Syntax.FunctionExpression;
          this.id = id;
          this.params = params;
          this.body = body;
          this.generator = false;
          this.expression = false;
          this.async = true;
        }

        return AsyncFunctionExpression;
      }();

      exports.AsyncFunctionExpression = AsyncFunctionExpression;

      var AwaitExpression = function () {
        function AwaitExpression(argument) {
          this.type = syntax_1.Syntax.AwaitExpression;
          this.argument = argument;
        }

        return AwaitExpression;
      }();

      exports.AwaitExpression = AwaitExpression;

      var BinaryExpression = function () {
        function BinaryExpression(operator, left, right) {
          var logical = operator === '||' || operator === '&&';
          this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression;
          this.operator = operator;
          this.left = left;
          this.right = right;
        }

        return BinaryExpression;
      }();

      exports.BinaryExpression = BinaryExpression;

      var BlockStatement = function () {
        function BlockStatement(body) {
          this.type = syntax_1.Syntax.BlockStatement;
          this.body = body;
        }

        return BlockStatement;
      }();

      exports.BlockStatement = BlockStatement;

      var BreakStatement = function () {
        function BreakStatement(label) {
          this.type = syntax_1.Syntax.BreakStatement;
          this.label = label;
        }

        return BreakStatement;
      }();

      exports.BreakStatement = BreakStatement;

      var CallExpression = function () {
        function CallExpression(callee, args) {
          this.type = syntax_1.Syntax.CallExpression;
          this.callee = callee;
          this.arguments = args;
        }

        return CallExpression;
      }();

      exports.CallExpression = CallExpression;

      var CatchClause = function () {
        function CatchClause(param, body) {
          this.type = syntax_1.Syntax.CatchClause;
          this.param = param;
          this.body = body;
        }

        return CatchClause;
      }();

      exports.CatchClause = CatchClause;

      var ClassBody = function () {
        function ClassBody(body) {
          this.type = syntax_1.Syntax.ClassBody;
          this.body = body;
        }

        return ClassBody;
      }();

      exports.ClassBody = ClassBody;

      var ClassDeclaration = function () {
        function ClassDeclaration(id, superClass, body) {
          this.type = syntax_1.Syntax.ClassDeclaration;
          this.id = id;
          this.superClass = superClass;
          this.body = body;
        }

        return ClassDeclaration;
      }();

      exports.ClassDeclaration = ClassDeclaration;

      var ClassExpression = function () {
        function ClassExpression(id, superClass, body) {
          this.type = syntax_1.Syntax.ClassExpression;
          this.id = id;
          this.superClass = superClass;
          this.body = body;
        }

        return ClassExpression;
      }();

      exports.ClassExpression = ClassExpression;

      var ComputedMemberExpression = function () {
        function ComputedMemberExpression(object, property) {
          this.type = syntax_1.Syntax.MemberExpression;
          this.computed = true;
          this.object = object;
          this.property = property;
        }

        return ComputedMemberExpression;
      }();

      exports.ComputedMemberExpression = ComputedMemberExpression;

      var ConditionalExpression = function () {
        function ConditionalExpression(test, consequent, alternate) {
          this.type = syntax_1.Syntax.ConditionalExpression;
          this.test = test;
          this.consequent = consequent;
          this.alternate = alternate;
        }

        return ConditionalExpression;
      }();

      exports.ConditionalExpression = ConditionalExpression;

      var ContinueStatement = function () {
        function ContinueStatement(label) {
          this.type = syntax_1.Syntax.ContinueStatement;
          this.label = label;
        }

        return ContinueStatement;
      }();

      exports.ContinueStatement = ContinueStatement;

      var DebuggerStatement = function () {
        function DebuggerStatement() {
          this.type = syntax_1.Syntax.DebuggerStatement;
        }

        return DebuggerStatement;
      }();

      exports.DebuggerStatement = DebuggerStatement;

      var Directive = function () {
        function Directive(expression, directive) {
          this.type = syntax_1.Syntax.ExpressionStatement;
          this.expression = expression;
          this.directive = directive;
        }

        return Directive;
      }();

      exports.Directive = Directive;

      var DoWhileStatement = function () {
        function DoWhileStatement(body, test) {
          this.type = syntax_1.Syntax.DoWhileStatement;
          this.body = body;
          this.test = test;
        }

        return DoWhileStatement;
      }();

      exports.DoWhileStatement = DoWhileStatement;

      var EmptyStatement = function () {
        function EmptyStatement() {
          this.type = syntax_1.Syntax.EmptyStatement;
        }

        return EmptyStatement;
      }();

      exports.EmptyStatement = EmptyStatement;

      var ExportAllDeclaration = function () {
        function ExportAllDeclaration(source) {
          this.type = syntax_1.Syntax.ExportAllDeclaration;
          this.source = source;
        }

        return ExportAllDeclaration;
      }();

      exports.ExportAllDeclaration = ExportAllDeclaration;

      var ExportDefaultDeclaration = function () {
        function ExportDefaultDeclaration(declaration) {
          this.type = syntax_1.Syntax.ExportDefaultDeclaration;
          this.declaration = declaration;
        }

        return ExportDefaultDeclaration;
      }();

      exports.ExportDefaultDeclaration = ExportDefaultDeclaration;

      var ExportNamedDeclaration = function () {
        function ExportNamedDeclaration(declaration, specifiers, source) {
          this.type = syntax_1.Syntax.ExportNamedDeclaration;
          this.declaration = declaration;
          this.specifiers = specifiers;
          this.source = source;
        }

        return ExportNamedDeclaration;
      }();

      exports.ExportNamedDeclaration = ExportNamedDeclaration;

      var ExportSpecifier = function () {
        function ExportSpecifier(local, exported) {
          this.type = syntax_1.Syntax.ExportSpecifier;
          this.exported = exported;
          this.local = local;
        }

        return ExportSpecifier;
      }();

      exports.ExportSpecifier = ExportSpecifier;

      var ExpressionStatement = function () {
        function ExpressionStatement(expression) {
          this.type = syntax_1.Syntax.ExpressionStatement;
          this.expression = expression;
        }

        return ExpressionStatement;
      }();

      exports.ExpressionStatement = ExpressionStatement;

      var ForInStatement = function () {
        function ForInStatement(left, right, body) {
          this.type = syntax_1.Syntax.ForInStatement;
          this.left = left;
          this.right = right;
          this.body = body;
          this.each = false;
        }

        return ForInStatement;
      }();

      exports.ForInStatement = ForInStatement;

      var ForOfStatement = function () {
        function ForOfStatement(left, right, body) {
          this.type = syntax_1.Syntax.ForOfStatement;
          this.left = left;
          this.right = right;
          this.body = body;
        }

        return ForOfStatement;
      }();

      exports.ForOfStatement = ForOfStatement;

      var ForStatement = function () {
        function ForStatement(init, test, update, body) {
          this.type = syntax_1.Syntax.ForStatement;
          this.init = init;
          this.test = test;
          this.update = update;
          this.body = body;
        }

        return ForStatement;
      }();

      exports.ForStatement = ForStatement;

      var FunctionDeclaration = function () {
        function FunctionDeclaration(id, params, body, generator) {
          this.type = syntax_1.Syntax.FunctionDeclaration;
          this.id = id;
          this.params = params;
          this.body = body;
          this.generator = generator;
          this.expression = false;
          this.async = false;
        }

        return FunctionDeclaration;
      }();

      exports.FunctionDeclaration = FunctionDeclaration;

      var FunctionExpression = function () {
        function FunctionExpression(id, params, body, generator) {
          this.type = syntax_1.Syntax.FunctionExpression;
          this.id = id;
          this.params = params;
          this.body = body;
          this.generator = generator;
          this.expression = false;
          this.async = false;
        }

        return FunctionExpression;
      }();

      exports.FunctionExpression = FunctionExpression;

      var Identifier = function () {
        function Identifier(name) {
          this.type = syntax_1.Syntax.Identifier;
          this.name = name;
        }

        return Identifier;
      }();

      exports.Identifier = Identifier;

      var IfStatement = function () {
        function IfStatement(test, consequent, alternate) {
          this.type = syntax_1.Syntax.IfStatement;
          this.test = test;
          this.consequent = consequent;
          this.alternate = alternate;
        }

        return IfStatement;
      }();

      exports.IfStatement = IfStatement;

      var ImportDeclaration = function () {
        function ImportDeclaration(specifiers, source) {
          this.type = syntax_1.Syntax.ImportDeclaration;
          this.specifiers = specifiers;
          this.source = source;
        }

        return ImportDeclaration;
      }();

      exports.ImportDeclaration = ImportDeclaration;

      var ImportDefaultSpecifier = function () {
        function ImportDefaultSpecifier(local) {
          this.type = syntax_1.Syntax.ImportDefaultSpecifier;
          this.local = local;
        }

        return ImportDefaultSpecifier;
      }();

      exports.ImportDefaultSpecifier = ImportDefaultSpecifier;

      var ImportNamespaceSpecifier = function () {
        function ImportNamespaceSpecifier(local) {
          this.type = syntax_1.Syntax.ImportNamespaceSpecifier;
          this.local = local;
        }

        return ImportNamespaceSpecifier;
      }();

      exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;

      var ImportSpecifier = function () {
        function ImportSpecifier(local, imported) {
          this.type = syntax_1.Syntax.ImportSpecifier;
          this.local = local;
          this.imported = imported;
        }

        return ImportSpecifier;
      }();

      exports.ImportSpecifier = ImportSpecifier;

      var LabeledStatement = function () {
        function LabeledStatement(label, body) {
          this.type = syntax_1.Syntax.LabeledStatement;
          this.label = label;
          this.body = body;
        }

        return LabeledStatement;
      }();

      exports.LabeledStatement = LabeledStatement;

      var Literal = function () {
        function Literal(value, raw) {
          this.type = syntax_1.Syntax.Literal;
          this.value = value;
          this.raw = raw;
        }

        return Literal;
      }();

      exports.Literal = Literal;

      var MetaProperty = function () {
        function MetaProperty(meta, property) {
          this.type = syntax_1.Syntax.MetaProperty;
          this.meta = meta;
          this.property = property;
        }

        return MetaProperty;
      }();

      exports.MetaProperty = MetaProperty;

      var MethodDefinition = function () {
        function MethodDefinition(key, computed, value, kind, isStatic) {
          this.type = syntax_1.Syntax.MethodDefinition;
          this.key = key;
          this.computed = computed;
          this.value = value;
          this.kind = kind;
          this.static = isStatic;
        }

        return MethodDefinition;
      }();

      exports.MethodDefinition = MethodDefinition;

      var Module = function () {
        function Module(body) {
          this.type = syntax_1.Syntax.Program;
          this.body = body;
          this.sourceType = 'module';
        }

        return Module;
      }();

      exports.Module = Module;

      var NewExpression = function () {
        function NewExpression(callee, args) {
          this.type = syntax_1.Syntax.NewExpression;
          this.callee = callee;
          this.arguments = args;
        }

        return NewExpression;
      }();

      exports.NewExpression = NewExpression;

      var ObjectExpression = function () {
        function ObjectExpression(properties) {
          this.type = syntax_1.Syntax.ObjectExpression;
          this.properties = properties;
        }

        return ObjectExpression;
      }();

      exports.ObjectExpression = ObjectExpression;

      var ObjectPattern = function () {
        function ObjectPattern(properties) {
          this.type = syntax_1.Syntax.ObjectPattern;
          this.properties = properties;
        }

        return ObjectPattern;
      }();

      exports.ObjectPattern = ObjectPattern;

      var Property = function () {
        function Property(kind, key, computed, value, method, shorthand) {
          this.type = syntax_1.Syntax.Property;
          this.key = key;
          this.computed = computed;
          this.value = value;
          this.kind = kind;
          this.method = method;
          this.shorthand = shorthand;
        }

        return Property;
      }();

      exports.Property = Property;

      var RegexLiteral = function () {
        function RegexLiteral(value, raw, pattern, flags) {
          this.type = syntax_1.Syntax.Literal;
          this.value = value;
          this.raw = raw;
          this.regex = {
            pattern: pattern,
            flags: flags
          };
        }

        return RegexLiteral;
      }();

      exports.RegexLiteral = RegexLiteral;

      var RestElement = function () {
        function RestElement(argument) {
          this.type = syntax_1.Syntax.RestElement;
          this.argument = argument;
        }

        return RestElement;
      }();

      exports.RestElement = RestElement;

      var ReturnStatement = function () {
        function ReturnStatement(argument) {
          this.type = syntax_1.Syntax.ReturnStatement;
          this.argument = argument;
        }

        return ReturnStatement;
      }();

      exports.ReturnStatement = ReturnStatement;

      var Script = function () {
        function Script(body) {
          this.type = syntax_1.Syntax.Program;
          this.body = body;
          this.sourceType = 'script';
        }

        return Script;
      }();

      exports.Script = Script;

      var SequenceExpression = function () {
        function SequenceExpression(expressions) {
          this.type = syntax_1.Syntax.SequenceExpression;
          this.expressions = expressions;
        }

        return SequenceExpression;
      }();

      exports.SequenceExpression = SequenceExpression;

      var SpreadElement = function () {
        function SpreadElement(argument) {
          this.type = syntax_1.Syntax.SpreadElement;
          this.argument = argument;
        }

        return SpreadElement;
      }();

      exports.SpreadElement = SpreadElement;

      var StaticMemberExpression = function () {
        function StaticMemberExpression(object, property) {
          this.type = syntax_1.Syntax.MemberExpression;
          this.computed = false;
          this.object = object;
          this.property = property;
        }

        return StaticMemberExpression;
      }();

      exports.StaticMemberExpression = StaticMemberExpression;

      var Super = function () {
        function Super() {
          this.type = syntax_1.Syntax.Super;
        }

        return Super;
      }();

      exports.Super = Super;

      var SwitchCase = function () {
        function SwitchCase(test, consequent) {
          this.type = syntax_1.Syntax.SwitchCase;
          this.test = test;
          this.consequent = consequent;
        }

        return SwitchCase;
      }();

      exports.SwitchCase = SwitchCase;

      var SwitchStatement = function () {
        function SwitchStatement(discriminant, cases) {
          this.type = syntax_1.Syntax.SwitchStatement;
          this.discriminant = discriminant;
          this.cases = cases;
        }

        return SwitchStatement;
      }();

      exports.SwitchStatement = SwitchStatement;

      var TaggedTemplateExpression = function () {
        function TaggedTemplateExpression(tag, quasi) {
          this.type = syntax_1.Syntax.TaggedTemplateExpression;
          this.tag = tag;
          this.quasi = quasi;
        }

        return TaggedTemplateExpression;
      }();

      exports.TaggedTemplateExpression = TaggedTemplateExpression;

      var TemplateElement = function () {
        function TemplateElement(value, tail) {
          this.type = syntax_1.Syntax.TemplateElement;
          this.value = value;
          this.tail = tail;
        }

        return TemplateElement;
      }();

      exports.TemplateElement = TemplateElement;

      var TemplateLiteral = function () {
        function TemplateLiteral(quasis, expressions) {
          this.type = syntax_1.Syntax.TemplateLiteral;
          this.quasis = quasis;
          this.expressions = expressions;
        }

        return TemplateLiteral;
      }();

      exports.TemplateLiteral = TemplateLiteral;

      var ThisExpression = function () {
        function ThisExpression() {
          this.type = syntax_1.Syntax.ThisExpression;
        }

        return ThisExpression;
      }();

      exports.ThisExpression = ThisExpression;

      var ThrowStatement = function () {
        function ThrowStatement(argument) {
          this.type = syntax_1.Syntax.ThrowStatement;
          this.argument = argument;
        }

        return ThrowStatement;
      }();

      exports.ThrowStatement = ThrowStatement;

      var TryStatement = function () {
        function TryStatement(block, handler, finalizer) {
          this.type = syntax_1.Syntax.TryStatement;
          this.block = block;
          this.handler = handler;
          this.finalizer = finalizer;
        }

        return TryStatement;
      }();

      exports.TryStatement = TryStatement;

      var UnaryExpression = function () {
        function UnaryExpression(operator, argument) {
          this.type = syntax_1.Syntax.UnaryExpression;
          this.operator = operator;
          this.argument = argument;
          this.prefix = true;
        }

        return UnaryExpression;
      }();

      exports.UnaryExpression = UnaryExpression;

      var UpdateExpression = function () {
        function UpdateExpression(operator, argument, prefix) {
          this.type = syntax_1.Syntax.UpdateExpression;
          this.operator = operator;
          this.argument = argument;
          this.prefix = prefix;
        }

        return UpdateExpression;
      }();

      exports.UpdateExpression = UpdateExpression;

      var VariableDeclaration = function () {
        function VariableDeclaration(declarations, kind) {
          this.type = syntax_1.Syntax.VariableDeclaration;
          this.declarations = declarations;
          this.kind = kind;
        }

        return VariableDeclaration;
      }();

      exports.VariableDeclaration = VariableDeclaration;

      var VariableDeclarator = function () {
        function VariableDeclarator(id, init) {
          this.type = syntax_1.Syntax.VariableDeclarator;
          this.id = id;
          this.init = init;
        }

        return VariableDeclarator;
      }();

      exports.VariableDeclarator = VariableDeclarator;

      var WhileStatement = function () {
        function WhileStatement(test, body) {
          this.type = syntax_1.Syntax.WhileStatement;
          this.test = test;
          this.body = body;
        }

        return WhileStatement;
      }();

      exports.WhileStatement = WhileStatement;

      var WithStatement = function () {
        function WithStatement(object, body) {
          this.type = syntax_1.Syntax.WithStatement;
          this.object = object;
          this.body = body;
        }

        return WithStatement;
      }();

      exports.WithStatement = WithStatement;

      var YieldExpression = function () {
        function YieldExpression(argument, delegate) {
          this.type = syntax_1.Syntax.YieldExpression;
          this.argument = argument;
          this.delegate = delegate;
        }

        return YieldExpression;
      }();

      exports.YieldExpression = YieldExpression;
      /***/
    },
    /* 8 */

    /***/
    function (module, exports, __webpack_require__) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var assert_1 = __webpack_require__(9);

      var error_handler_1 = __webpack_require__(10);

      var messages_1 = __webpack_require__(11);

      var Node = __webpack_require__(7);

      var scanner_1 = __webpack_require__(12);

      var syntax_1 = __webpack_require__(2);

      var token_1 = __webpack_require__(13);

      var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder';

      var Parser = function () {
        function Parser(code, options, delegate) {
          if (options === void 0) {
            options = {};
          }

          this.config = {
            range: typeof options.range === 'boolean' && options.range,
            loc: typeof options.loc === 'boolean' && options.loc,
            source: null,
            tokens: typeof options.tokens === 'boolean' && options.tokens,
            comment: typeof options.comment === 'boolean' && options.comment,
            tolerant: typeof options.tolerant === 'boolean' && options.tolerant
          };

          if (this.config.loc && options.source && options.source !== null) {
            this.config.source = String(options.source);
          }

          this.delegate = delegate;
          this.errorHandler = new error_handler_1.ErrorHandler();
          this.errorHandler.tolerant = this.config.tolerant;
          this.scanner = new scanner_1.Scanner(code, this.errorHandler);
          this.scanner.trackComment = this.config.comment;
          this.operatorPrecedence = {
            ')': 0,
            ';': 0,
            ',': 0,
            '=': 0,
            ']': 0,
            '||': 1,
            '&&': 2,
            '|': 3,
            '^': 4,
            '&': 5,
            '==': 6,
            '!=': 6,
            '===': 6,
            '!==': 6,
            '<': 7,
            '>': 7,
            '<=': 7,
            '>=': 7,
            '<<': 8,
            '>>': 8,
            '>>>': 8,
            '+': 9,
            '-': 9,
            '*': 11,
            '/': 11,
            '%': 11
          };
          this.lookahead = {
            type: 2
            /* EOF */
            ,
            value: '',
            lineNumber: this.scanner.lineNumber,
            lineStart: 0,
            start: 0,
            end: 0
          };
          this.hasLineTerminator = false;
          this.context = {
            isModule: false,
            await: false,
            allowIn: true,
            allowStrictDirective: true,
            allowYield: true,
            firstCoverInitializedNameError: null,
            isAssignmentTarget: false,
            isBindingElement: false,
            inFunctionBody: false,
            inIteration: false,
            inSwitch: false,
            labelSet: {},
            strict: false
          };
          this.tokens = [];
          this.startMarker = {
            index: 0,
            line: this.scanner.lineNumber,
            column: 0
          };
          this.lastMarker = {
            index: 0,
            line: this.scanner.lineNumber,
            column: 0
          };
          this.nextToken();
          this.lastMarker = {
            index: this.scanner.index,
            line: this.scanner.lineNumber,
            column: this.scanner.index - this.scanner.lineStart
          };
        }

        Parser.prototype.throwError = function (messageFormat) {
          var values = [];

          for (var _i = 1; _i < arguments.length; _i++) {
            values[_i - 1] = arguments[_i];
          }

          var args = Array.prototype.slice.call(arguments, 1);
          var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
            assert_1.assert(idx < args.length, 'Message reference must be in range');
            return args[idx];
          });
          var index = this.lastMarker.index;
          var line = this.lastMarker.line;
          var column = this.lastMarker.column + 1;
          throw this.errorHandler.createError(index, line, column, msg);
        };

        Parser.prototype.tolerateError = function (messageFormat) {
          var values = [];

          for (var _i = 1; _i < arguments.length; _i++) {
            values[_i - 1] = arguments[_i];
          }

          var args = Array.prototype.slice.call(arguments, 1);
          var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
            assert_1.assert(idx < args.length, 'Message reference must be in range');
            return args[idx];
          });
          var index = this.lastMarker.index;
          var line = this.scanner.lineNumber;
          var column = this.lastMarker.column + 1;
          this.errorHandler.tolerateError(index, line, column, msg);
        }; // Throw an exception because of the token.


        Parser.prototype.unexpectedTokenError = function (token, message) {
          var msg = message || messages_1.Messages.UnexpectedToken;
          var value;

          if (token) {
            if (!message) {
              msg = token.type === 2
              /* EOF */
              ? messages_1.Messages.UnexpectedEOS : token.type === 3
              /* Identifier */
              ? messages_1.Messages.UnexpectedIdentifier : token.type === 6
              /* NumericLiteral */
              ? messages_1.Messages.UnexpectedNumber : token.type === 8
              /* StringLiteral */
              ? messages_1.Messages.UnexpectedString : token.type === 10
              /* Template */
              ? messages_1.Messages.UnexpectedTemplate : messages_1.Messages.UnexpectedToken;

              if (token.type === 4
              /* Keyword */
              ) {
                  if (this.scanner.isFutureReservedWord(token.value)) {
                    msg = messages_1.Messages.UnexpectedReserved;
                  } else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) {
                    msg = messages_1.Messages.StrictReservedWord;
                  }
                }
            }

            value = token.value;
          } else {
            value = 'ILLEGAL';
          }

          msg = msg.replace('%0', value);

          if (token && typeof token.lineNumber === 'number') {
            var index = token.start;
            var line = token.lineNumber;
            var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column;
            var column = token.start - lastMarkerLineStart + 1;
            return this.errorHandler.createError(index, line, column, msg);
          } else {
            var index = this.lastMarker.index;
            var line = this.lastMarker.line;
            var column = this.lastMarker.column + 1;
            return this.errorHandler.createError(index, line, column, msg);
          }
        };

        Parser.prototype.throwUnexpectedToken = function (token, message) {
          throw this.unexpectedTokenError(token, message);
        };

        Parser.prototype.tolerateUnexpectedToken = function (token, message) {
          this.errorHandler.tolerate(this.unexpectedTokenError(token, message));
        };

        Parser.prototype.collectComments = function () {
          if (!this.config.comment) {
            this.scanner.scanComments();
          } else {
            var comments = this.scanner.scanComments();

            if (comments.length > 0 && this.delegate) {
              for (var i = 0; i < comments.length; ++i) {
                var e = comments[i];
                var node = void 0;
                node = {
                  type: e.multiLine ? 'BlockComment' : 'LineComment',
                  value: this.scanner.source.slice(e.slice[0], e.slice[1])
                };

                if (this.config.range) {
                  node.range = e.range;
                }

                if (this.config.loc) {
                  node.loc = e.loc;
                }

                var metadata = {
                  start: {
                    line: e.loc.start.line,
                    column: e.loc.start.column,
                    offset: e.range[0]
                  },
                  end: {
                    line: e.loc.end.line,
                    column: e.loc.end.column,
                    offset: e.range[1]
                  }
                };
                this.delegate(node, metadata);
              }
            }
          }
        }; // From internal representation to an external structure


        Parser.prototype.getTokenRaw = function (token) {
          return this.scanner.source.slice(token.start, token.end);
        };

        Parser.prototype.convertToken = function (token) {
          var t = {
            type: token_1.TokenName[token.type],
            value: this.getTokenRaw(token)
          };

          if (this.config.range) {
            t.range = [token.start, token.end];
          }

          if (this.config.loc) {
            t.loc = {
              start: {
                line: this.startMarker.line,
                column: this.startMarker.column
              },
              end: {
                line: this.scanner.lineNumber,
                column: this.scanner.index - this.scanner.lineStart
              }
            };
          }

          if (token.type === 9
          /* RegularExpression */
          ) {
              var pattern = token.pattern;
              var flags = token.flags;
              t.regex = {
                pattern: pattern,
                flags: flags
              };
            }

          return t;
        };

        Parser.prototype.nextToken = function () {
          var token = this.lookahead;
          this.lastMarker.index = this.scanner.index;
          this.lastMarker.line = this.scanner.lineNumber;
          this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
          this.collectComments();

          if (this.scanner.index !== this.startMarker.index) {
            this.startMarker.index = this.scanner.index;
            this.startMarker.line = this.scanner.lineNumber;
            this.startMarker.column = this.scanner.index - this.scanner.lineStart;
          }

          var next = this.scanner.lex();
          this.hasLineTerminator = token.lineNumber !== next.lineNumber;

          if (next && this.context.strict && next.type === 3
          /* Identifier */
          ) {
              if (this.scanner.isStrictModeReservedWord(next.value)) {
                next.type = 4
                /* Keyword */
                ;
              }
            }

          this.lookahead = next;

          if (this.config.tokens && next.type !== 2
          /* EOF */
          ) {
              this.tokens.push(this.convertToken(next));
            }

          return token;
        };

        Parser.prototype.nextRegexToken = function () {
          this.collectComments();
          var token = this.scanner.scanRegExp();

          if (this.config.tokens) {
            // Pop the previous token, '/' or '/='
            // This is added from the lookahead token.
            this.tokens.pop();
            this.tokens.push(this.convertToken(token));
          } // Prime the next lookahead.


          this.lookahead = token;
          this.nextToken();
          return token;
        };

        Parser.prototype.createNode = function () {
          return {
            index: this.startMarker.index,
            line: this.startMarker.line,
            column: this.startMarker.column
          };
        };

        Parser.prototype.startNode = function (token, lastLineStart) {
          if (lastLineStart === void 0) {
            lastLineStart = 0;
          }

          var column = token.start - token.lineStart;
          var line = token.lineNumber;

          if (column < 0) {
            column += lastLineStart;
            line--;
          }

          return {
            index: token.start,
            line: line,
            column: column
          };
        };

        Parser.prototype.finalize = function (marker, node) {
          if (this.config.range) {
            node.range = [marker.index, this.lastMarker.index];
          }

          if (this.config.loc) {
            node.loc = {
              start: {
                line: marker.line,
                column: marker.column
              },
              end: {
                line: this.lastMarker.line,
                column: this.lastMarker.column
              }
            };

            if (this.config.source) {
              node.loc.source = this.config.source;
            }
          }

          if (this.delegate) {
            var metadata = {
              start: {
                line: marker.line,
                column: marker.column,
                offset: marker.index
              },
              end: {
                line: this.lastMarker.line,
                column: this.lastMarker.column,
                offset: this.lastMarker.index
              }
            };
            this.delegate(node, metadata);
          }

          return node;
        }; // Expect the next token to match the specified punctuator.
        // If not, an exception will be thrown.


        Parser.prototype.expect = function (value) {
          var token = this.nextToken();

          if (token.type !== 7
          /* Punctuator */
          || token.value !== value) {
            this.throwUnexpectedToken(token);
          }
        }; // Quietly expect a comma when in tolerant mode, otherwise delegates to expect().


        Parser.prototype.expectCommaSeparator = function () {
          if (this.config.tolerant) {
            var token = this.lookahead;

            if (token.type === 7
            /* Punctuator */
            && token.value === ',') {
              this.nextToken();
            } else if (token.type === 7
            /* Punctuator */
            && token.value === ';') {
              this.nextToken();
              this.tolerateUnexpectedToken(token);
            } else {
              this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken);
            }
          } else {
            this.expect(',');
          }
        }; // Expect the next token to match the specified keyword.
        // If not, an exception will be thrown.


        Parser.prototype.expectKeyword = function (keyword) {
          var token = this.nextToken();

          if (token.type !== 4
          /* Keyword */
          || token.value !== keyword) {
            this.throwUnexpectedToken(token);
          }
        }; // Return true if the next token matches the specified punctuator.


        Parser.prototype.match = function (value) {
          return this.lookahead.type === 7
          /* Punctuator */
          && this.lookahead.value === value;
        }; // Return true if the next token matches the specified keyword


        Parser.prototype.matchKeyword = function (keyword) {
          return this.lookahead.type === 4
          /* Keyword */
          && this.lookahead.value === keyword;
        }; // Return true if the next token matches the specified contextual keyword
        // (where an identifier is sometimes a keyword depending on the context)


        Parser.prototype.matchContextualKeyword = function (keyword) {
          return this.lookahead.type === 3
          /* Identifier */
          && this.lookahead.value === keyword;
        }; // Return true if the next token is an assignment operator


        Parser.prototype.matchAssign = function () {
          if (this.lookahead.type !== 7
          /* Punctuator */
          ) {
              return false;
            }

          var op = this.lookahead.value;
          return op === '=' || op === '*=' || op === '**=' || op === '/=' || op === '%=' || op === '+=' || op === '-=' || op === '<<=' || op === '>>=' || op === '>>>=' || op === '&=' || op === '^=' || op === '|=';
        }; // Cover grammar support.
        //
        // When an assignment expression position starts with an left parenthesis, the determination of the type
        // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)
        // or the first comma. This situation also defers the determination of all the expressions nested in the pair.
        //
        // There are three productions that can be parsed in a parentheses pair that needs to be determined
        // after the outermost pair is closed. They are:
        //
        //   1. AssignmentExpression
        //   2. BindingElements
        //   3. AssignmentTargets
        //
        // In order to avoid exponential backtracking, we use two flags to denote if the production can be
        // binding element or assignment target.
        //
        // The three productions have the relationship:
        //
        //   BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression
        //
        // with a single exception that CoverInitializedName when used directly in an Expression, generates
        // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the
        // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.
        //
        // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not
        // effect the current flags. This means the production the parser parses is only used as an expression. Therefore
        // the CoverInitializedName check is conducted.
        //
        // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates
        // the flags outside of the parser. This means the production the parser parses is used as a part of a potential
        // pattern. The CoverInitializedName check is deferred.


        Parser.prototype.isolateCoverGrammar = function (parseFunction) {
          var previousIsBindingElement = this.context.isBindingElement;
          var previousIsAssignmentTarget = this.context.isAssignmentTarget;
          var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
          this.context.isBindingElement = true;
          this.context.isAssignmentTarget = true;
          this.context.firstCoverInitializedNameError = null;
          var result = parseFunction.call(this);

          if (this.context.firstCoverInitializedNameError !== null) {
            this.throwUnexpectedToken(this.context.firstCoverInitializedNameError);
          }

          this.context.isBindingElement = previousIsBindingElement;
          this.context.isAssignmentTarget = previousIsAssignmentTarget;
          this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError;
          return result;
        };

        Parser.prototype.inheritCoverGrammar = function (parseFunction) {
          var previousIsBindingElement = this.context.isBindingElement;
          var previousIsAssignmentTarget = this.context.isAssignmentTarget;
          var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
          this.context.isBindingElement = true;
          this.context.isAssignmentTarget = true;
          this.context.firstCoverInitializedNameError = null;
          var result = parseFunction.call(this);
          this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement;
          this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget;
          this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError;
          return result;
        };

        Parser.prototype.consumeSemicolon = function () {
          if (this.match(';')) {
            this.nextToken();
          } else if (!this.hasLineTerminator) {
            if (this.lookahead.type !== 2
            /* EOF */
            && !this.match('}')) {
              this.throwUnexpectedToken(this.lookahead);
            }

            this.lastMarker.index = this.startMarker.index;
            this.lastMarker.line = this.startMarker.line;
            this.lastMarker.column = this.startMarker.column;
          }
        }; // https://tc39.github.io/ecma262/#sec-primary-expression


        Parser.prototype.parsePrimaryExpression = function () {
          var node = this.createNode();
          var expr;
          var token, raw;

          switch (this.lookahead.type) {
            case 3
            /* Identifier */
            :
              if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') {
                this.tolerateUnexpectedToken(this.lookahead);
              }

              expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));
              break;

            case 6
            /* NumericLiteral */
            :
            case 8
            /* StringLiteral */
            :
              if (this.context.strict && this.lookahead.octal) {
                this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);
              }

              this.context.isAssignmentTarget = false;
              this.context.isBindingElement = false;
              token = this.nextToken();
              raw = this.getTokenRaw(token);
              expr = this.finalize(node, new Node.Literal(token.value, raw));
              break;

            case 1
            /* BooleanLiteral */
            :
              this.context.isAssignmentTarget = false;
              this.context.isBindingElement = false;
              token = this.nextToken();
              raw = this.getTokenRaw(token);
              expr = this.finalize(node, new Node.Literal(token.value === 'true', raw));
              break;

            case 5
            /* NullLiteral */
            :
              this.context.isAssignmentTarget = false;
              this.context.isBindingElement = false;
              token = this.nextToken();
              raw = this.getTokenRaw(token);
              expr = this.finalize(node, new Node.Literal(null, raw));
              break;

            case 10
            /* Template */
            :
              expr = this.parseTemplateLiteral();
              break;

            case 7
            /* Punctuator */
            :
              switch (this.lookahead.value) {
                case '(':
                  this.context.isBindingElement = false;
                  expr = this.inheritCoverGrammar(this.parseGroupExpression);
                  break;

                case '[':
                  expr = this.inheritCoverGrammar(this.parseArrayInitializer);
                  break;

                case '{':
                  expr = this.inheritCoverGrammar(this.parseObjectInitializer);
                  break;

                case '/':
                case '/=':
                  this.context.isAssignmentTarget = false;
                  this.context.isBindingElement = false;
                  this.scanner.index = this.startMarker.index;
                  token = this.nextRegexToken();
                  raw = this.getTokenRaw(token);
                  expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags));
                  break;

                default:
                  expr = this.throwUnexpectedToken(this.nextToken());
              }

              break;

            case 4
            /* Keyword */
            :
              if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {
                expr = this.parseIdentifierName();
              } else if (!this.context.strict && this.matchKeyword('let')) {
                expr = this.finalize(node, new Node.Identifier(this.nextToken().value));
              } else {
                this.context.isAssignmentTarget = false;
                this.context.isBindingElement = false;

                if (this.matchKeyword('function')) {
                  expr = this.parseFunctionExpression();
                } else if (this.matchKeyword('this')) {
                  this.nextToken();
                  expr = this.finalize(node, new Node.ThisExpression());
                } else if (this.matchKeyword('class')) {
                  expr = this.parseClassExpression();
                } else {
                  expr = this.throwUnexpectedToken(this.nextToken());
                }
              }

              break;

            default:
              expr = this.throwUnexpectedToken(this.nextToken());
          }

          return expr;
        }; // https://tc39.github.io/ecma262/#sec-array-initializer


        Parser.prototype.parseSpreadElement = function () {
          var node = this.createNode();
          this.expect('...');
          var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);
          return this.finalize(node, new Node.SpreadElement(arg));
        };

        Parser.prototype.parseArrayInitializer = function () {
          var node = this.createNode();
          var elements = [];
          this.expect('[');

          while (!this.match(']')) {
            if (this.match(',')) {
              this.nextToken();
              elements.push(null);
            } else if (this.match('...')) {
              var element = this.parseSpreadElement();

              if (!this.match(']')) {
                this.context.isAssignmentTarget = false;
                this.context.isBindingElement = false;
                this.expect(',');
              }

              elements.push(element);
            } else {
              elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression));

              if (!this.match(']')) {
                this.expect(',');
              }
            }
          }

          this.expect(']');
          return this.finalize(node, new Node.ArrayExpression(elements));
        }; // https://tc39.github.io/ecma262/#sec-object-initializer


        Parser.prototype.parsePropertyMethod = function (params) {
          this.context.isAssignmentTarget = false;
          this.context.isBindingElement = false;
          var previousStrict = this.context.strict;
          var previousAllowStrictDirective = this.context.allowStrictDirective;
          this.context.allowStrictDirective = params.simple;
          var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);

          if (this.context.strict && params.firstRestricted) {
            this.tolerateUnexpectedToken(params.firstRestricted, params.message);
          }

          if (this.context.strict && params.stricted) {
            this.tolerateUnexpectedToken(params.stricted, params.message);
          }

          this.context.strict = previousStrict;
          this.context.allowStrictDirective = previousAllowStrictDirective;
          return body;
        };

        Parser.prototype.parsePropertyMethodFunction = function () {
          var isGenerator = false;
          var node = this.createNode();
          var previousAllowYield = this.context.allowYield;
          this.context.allowYield = true;
          var params = this.parseFormalParameters();
          var method = this.parsePropertyMethod(params);
          this.context.allowYield = previousAllowYield;
          return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
        };

        Parser.prototype.parsePropertyMethodAsyncFunction = function () {
          var node = this.createNode();
          var previousAllowYield = this.context.allowYield;
          var previousAwait = this.context.await;
          this.context.allowYield = false;
          this.context.await = true;
          var params = this.parseFormalParameters();
          var method = this.parsePropertyMethod(params);
          this.context.allowYield = previousAllowYield;
          this.context.await = previousAwait;
          return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method));
        };

        Parser.prototype.parseObjectPropertyKey = function () {
          var node = this.createNode();
          var token = this.nextToken();
          var key;

          switch (token.type) {
            case 8
            /* StringLiteral */
            :
            case 6
            /* NumericLiteral */
            :
              if (this.context.strict && token.octal) {
                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);
              }

              var raw = this.getTokenRaw(token);
              key = this.finalize(node, new Node.Literal(token.value, raw));
              break;

            case 3
            /* Identifier */
            :
            case 1
            /* BooleanLiteral */
            :
            case 5
            /* NullLiteral */
            :
            case 4
            /* Keyword */
            :
              key = this.finalize(node, new Node.Identifier(token.value));
              break;

            case 7
            /* Punctuator */
            :
              if (token.value === '[') {
                key = this.isolateCoverGrammar(this.parseAssignmentExpression);
                this.expect(']');
              } else {
                key = this.throwUnexpectedToken(token);
              }

              break;

            default:
              key = this.throwUnexpectedToken(token);
          }

          return key;
        };

        Parser.prototype.isPropertyKey = function (key, value) {
          return key.type === syntax_1.Syntax.Identifier && key.name === value || key.type === syntax_1.Syntax.Literal && key.value === value;
        };

        Parser.prototype.parseObjectProperty = function (hasProto) {
          var node = this.createNode();
          var token = this.lookahead;
          var kind;
          var key = null;
          var value = null;
          var computed = false;
          var method = false;
          var shorthand = false;
          var isAsync = false;

          if (token.type === 3
          /* Identifier */
          ) {
              var id = token.value;
              this.nextToken();
              computed = this.match('[');
              isAsync = !this.hasLineTerminator && id === 'async' && !this.match(':') && !this.match('(') && !this.match('*') && !this.match(',');
              key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node.Identifier(id));
            } else if (this.match('*')) {
            this.nextToken();
          } else {
            computed = this.match('[');
            key = this.parseObjectPropertyKey();
          }

          var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);

          if (token.type === 3
          /* Identifier */
          && !isAsync && token.value === 'get' && lookaheadPropertyKey) {
            kind = 'get';
            computed = this.match('[');
            key = this.parseObjectPropertyKey();
            this.context.allowYield = false;
            value = this.parseGetterMethod();
          } else if (token.type === 3
          /* Identifier */
          && !isAsync && token.value === 'set' && lookaheadPropertyKey) {
            kind = 'set';
            computed = this.match('[');
            key = this.parseObjectPropertyKey();
            value = this.parseSetterMethod();
          } else if (token.type === 7
          /* Punctuator */
          && token.value === '*' && lookaheadPropertyKey) {
            kind = 'init';
            computed = this.match('[');
            key = this.parseObjectPropertyKey();
            value = this.parseGeneratorMethod();
            method = true;
          } else {
            if (!key) {
              this.throwUnexpectedToken(this.lookahead);
            }

            kind = 'init';

            if (this.match(':') && !isAsync) {
              if (!computed && this.isPropertyKey(key, '__proto__')) {
                if (hasProto.value) {
                  this.tolerateError(messages_1.Messages.DuplicateProtoProperty);
                }

                hasProto.value = true;
              }

              this.nextToken();
              value = this.inheritCoverGrammar(this.parseAssignmentExpression);
            } else if (this.match('(')) {
              value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
              method = true;
            } else if (token.type === 3
            /* Identifier */
            ) {
                var id = this.finalize(node, new Node.Identifier(token.value));

                if (this.match('=')) {
                  this.context.firstCoverInitializedNameError = this.lookahead;
                  this.nextToken();
                  shorthand = true;
                  var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
                  value = this.finalize(node, new Node.AssignmentPattern(id, init));
                } else {
                  shorthand = true;
                  value = id;
                }
              } else {
              this.throwUnexpectedToken(this.nextToken());
            }
          }

          return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand));
        };

        Parser.prototype.parseObjectInitializer = function () {
          var node = this.createNode();
          this.expect('{');
          var properties = [];
          var hasProto = {
            value: false
          };

          while (!this.match('}')) {
            properties.push(this.parseObjectProperty(hasProto));

            if (!this.match('}')) {
              this.expectCommaSeparator();
            }
          }

          this.expect('}');
          return this.finalize(node, new Node.ObjectExpression(properties));
        }; // https://tc39.github.io/ecma262/#sec-template-literals


        Parser.prototype.parseTemplateHead = function () {
          assert_1.assert(this.lookahead.head, 'Template literal must start with a template head');
          var node = this.createNode();
          var token = this.nextToken();
          var raw = token.value;
          var cooked = token.cooked;
          return this.finalize(node, new Node.TemplateElement({
            raw: raw,
            cooked: cooked
          }, token.tail));
        };

        Parser.prototype.parseTemplateElement = function () {
          if (this.lookahead.type !== 10
          /* Template */
          ) {
              this.throwUnexpectedToken();
            }

          var node = this.createNode();
          var token = this.nextToken();
          var raw = token.value;
          var cooked = token.cooked;
          return this.finalize(node, new Node.TemplateElement({
            raw: raw,
            cooked: cooked
          }, token.tail));
        };

        Parser.prototype.parseTemplateLiteral = function () {
          var node = this.createNode();
          var expressions = [];
          var quasis = [];
          var quasi = this.parseTemplateHead();
          quasis.push(quasi);

          while (!quasi.tail) {
            expressions.push(this.parseExpression());
            quasi = this.parseTemplateElement();
            quasis.push(quasi);
          }

          return this.finalize(node, new Node.TemplateLiteral(quasis, expressions));
        }; // https://tc39.github.io/ecma262/#sec-grouping-operator


        Parser.prototype.reinterpretExpressionAsPattern = function (expr) {
          switch (expr.type) {
            case syntax_1.Syntax.Identifier:
            case syntax_1.Syntax.MemberExpression:
            case syntax_1.Syntax.RestElement:
            case syntax_1.Syntax.AssignmentPattern:
              break;

            case syntax_1.Syntax.SpreadElement:
              expr.type = syntax_1.Syntax.RestElement;
              this.reinterpretExpressionAsPattern(expr.argument);
              break;

            case syntax_1.Syntax.ArrayExpression:
              expr.type = syntax_1.Syntax.ArrayPattern;

              for (var i = 0; i < expr.elements.length; i++) {
                if (expr.elements[i] !== null) {
                  this.reinterpretExpressionAsPattern(expr.elements[i]);
                }
              }

              break;

            case syntax_1.Syntax.ObjectExpression:
              expr.type = syntax_1.Syntax.ObjectPattern;

              for (var i = 0; i < expr.properties.length; i++) {
                this.reinterpretExpressionAsPattern(expr.properties[i].value);
              }

              break;

            case syntax_1.Syntax.AssignmentExpression:
              expr.type = syntax_1.Syntax.AssignmentPattern;
              delete expr.operator;
              this.reinterpretExpressionAsPattern(expr.left);
              break;

            default:
              // Allow other node type for tolerant parsing.
              break;
          }
        };

        Parser.prototype.parseGroupExpression = function () {
          var expr;
          this.expect('(');

          if (this.match(')')) {
            this.nextToken();

            if (!this.match('=>')) {
              this.expect('=>');
            }

            expr = {
              type: ArrowParameterPlaceHolder,
              params: [],
              async: false
            };
          } else {
            var startToken = this.lookahead;
            var params = [];

            if (this.match('...')) {
              expr = this.parseRestElement(params);
              this.expect(')');

              if (!this.match('=>')) {
                this.expect('=>');
              }

              expr = {
                type: ArrowParameterPlaceHolder,
                params: [expr],
                async: false
              };
            } else {
              var arrow = false;
              this.context.isBindingElement = true;
              expr = this.inheritCoverGrammar(this.parseAssignmentExpression);

              if (this.match(',')) {
                var expressions = [];
                this.context.isAssignmentTarget = false;
                expressions.push(expr);

                while (this.lookahead.type !== 2
                /* EOF */
                ) {
                  if (!this.match(',')) {
                    break;
                  }

                  this.nextToken();

                  if (this.match(')')) {
                    this.nextToken();

                    for (var i = 0; i < expressions.length; i++) {
                      this.reinterpretExpressionAsPattern(expressions[i]);
                    }

                    arrow = true;
                    expr = {
                      type: ArrowParameterPlaceHolder,
                      params: expressions,
                      async: false
                    };
                  } else if (this.match('...')) {
                    if (!this.context.isBindingElement) {
                      this.throwUnexpectedToken(this.lookahead);
                    }

                    expressions.push(this.parseRestElement(params));
                    this.expect(')');

                    if (!this.match('=>')) {
                      this.expect('=>');
                    }

                    this.context.isBindingElement = false;

                    for (var i = 0; i < expressions.length; i++) {
                      this.reinterpretExpressionAsPattern(expressions[i]);
                    }

                    arrow = true;
                    expr = {
                      type: ArrowParameterPlaceHolder,
                      params: expressions,
                      async: false
                    };
                  } else {
                    expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
                  }

                  if (arrow) {
                    break;
                  }
                }

                if (!arrow) {
                  expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
                }
              }

              if (!arrow) {
                this.expect(')');

                if (this.match('=>')) {
                  if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') {
                    arrow = true;
                    expr = {
                      type: ArrowParameterPlaceHolder,
                      params: [expr],
                      async: false
                    };
                  }

                  if (!arrow) {
                    if (!this.context.isBindingElement) {
                      this.throwUnexpectedToken(this.lookahead);
                    }

                    if (expr.type === syntax_1.Syntax.SequenceExpression) {
                      for (var i = 0; i < expr.expressions.length; i++) {
                        this.reinterpretExpressionAsPattern(expr.expressions[i]);
                      }
                    } else {
                      this.reinterpretExpressionAsPattern(expr);
                    }

                    var parameters = expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr];
                    expr = {
                      type: ArrowParameterPlaceHolder,
                      params: parameters,
                      async: false
                    };
                  }
                }

                this.context.isBindingElement = false;
              }
            }
          }

          return expr;
        }; // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions


        Parser.prototype.parseArguments = function () {
          this.expect('(');
          var args = [];

          if (!this.match(')')) {
            while (true) {
              var expr = this.match('...') ? this.parseSpreadElement() : this.isolateCoverGrammar(this.parseAssignmentExpression);
              args.push(expr);

              if (this.match(')')) {
                break;
              }

              this.expectCommaSeparator();

              if (this.match(')')) {
                break;
              }
            }
          }

          this.expect(')');
          return args;
        };

        Parser.prototype.isIdentifierName = function (token) {
          return token.type === 3
          /* Identifier */
          || token.type === 4
          /* Keyword */
          || token.type === 1
          /* BooleanLiteral */
          || token.type === 5
          /* NullLiteral */
          ;
        };

        Parser.prototype.parseIdentifierName = function () {
          var node = this.createNode();
          var token = this.nextToken();

          if (!this.isIdentifierName(token)) {
            this.throwUnexpectedToken(token);
          }

          return this.finalize(node, new Node.Identifier(token.value));
        };

        Parser.prototype.parseNewExpression = function () {
          var node = this.createNode();
          var id = this.parseIdentifierName();
          assert_1.assert(id.name === 'new', 'New expression must start with `new`');
          var expr;

          if (this.match('.')) {
            this.nextToken();

            if (this.lookahead.type === 3
            /* Identifier */
            && this.context.inFunctionBody && this.lookahead.value === 'target') {
              var property = this.parseIdentifierName();
              expr = new Node.MetaProperty(id, property);
            } else {
              this.throwUnexpectedToken(this.lookahead);
            }
          } else {
            var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression);
            var args = this.match('(') ? this.parseArguments() : [];
            expr = new Node.NewExpression(callee, args);
            this.context.isAssignmentTarget = false;
            this.context.isBindingElement = false;
          }

          return this.finalize(node, expr);
        };

        Parser.prototype.parseAsyncArgument = function () {
          var arg = this.parseAssignmentExpression();
          this.context.firstCoverInitializedNameError = null;
          return arg;
        };

        Parser.prototype.parseAsyncArguments = function () {
          this.expect('(');
          var args = [];

          if (!this.match(')')) {
            while (true) {
              var expr = this.match('...') ? this.parseSpreadElement() : this.isolateCoverGrammar(this.parseAsyncArgument);
              args.push(expr);

              if (this.match(')')) {
                break;
              }

              this.expectCommaSeparator();

              if (this.match(')')) {
                break;
              }
            }
          }

          this.expect(')');
          return args;
        };

        Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {
          var startToken = this.lookahead;
          var maybeAsync = this.matchContextualKeyword('async');
          var previousAllowIn = this.context.allowIn;
          this.context.allowIn = true;
          var expr;

          if (this.matchKeyword('super') && this.context.inFunctionBody) {
            expr = this.createNode();
            this.nextToken();
            expr = this.finalize(expr, new Node.Super());

            if (!this.match('(') && !this.match('.') && !this.match('[')) {
              this.throwUnexpectedToken(this.lookahead);
            }
          } else {
            expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
          }

          while (true) {
            if (this.match('.')) {
              this.context.isBindingElement = false;
              this.context.isAssignmentTarget = true;
              this.expect('.');
              var property = this.parseIdentifierName();
              expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property));
            } else if (this.match('(')) {
              var asyncArrow = maybeAsync && startToken.lineNumber === this.lookahead.lineNumber;
              this.context.isBindingElement = false;
              this.context.isAssignmentTarget = false;
              var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();
              expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));

              if (asyncArrow && this.match('=>')) {
                for (var i = 0; i < args.length; ++i) {
                  this.reinterpretExpressionAsPattern(args[i]);
                }

                expr = {
                  type: ArrowParameterPlaceHolder,
                  params: args,
                  async: true
                };
              }
            } else if (this.match('[')) {
              this.context.isBindingElement = false;
              this.context.isAssignmentTarget = true;
              this.expect('[');
              var property = this.isolateCoverGrammar(this.parseExpression);
              this.expect(']');
              expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property));
            } else if (this.lookahead.type === 10
            /* Template */
            && this.lookahead.head) {
              var quasi = this.parseTemplateLiteral();
              expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi));
            } else {
              break;
            }
          }

          this.context.allowIn = previousAllowIn;
          return expr;
        };

        Parser.prototype.parseSuper = function () {
          var node = this.createNode();
          this.expectKeyword('super');

          if (!this.match('[') && !this.match('.')) {
            this.throwUnexpectedToken(this.lookahead);
          }

          return this.finalize(node, new Node.Super());
        };

        Parser.prototype.parseLeftHandSideExpression = function () {
          assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.');
          var node = this.startNode(this.lookahead);
          var expr = this.matchKeyword('super') && this.context.inFunctionBody ? this.parseSuper() : this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);

          while (true) {
            if (this.match('[')) {
              this.context.isBindingElement = false;
              this.context.isAssignmentTarget = true;
              this.expect('[');
              var property = this.isolateCoverGrammar(this.parseExpression);
              this.expect(']');
              expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property));
            } else if (this.match('.')) {
              this.context.isBindingElement = false;
              this.context.isAssignmentTarget = true;
              this.expect('.');
              var property = this.parseIdentifierName();
              expr = this.finalize(node, new Node.StaticMemberExpression(expr, property));
            } else if (this.lookahead.type === 10
            /* Template */
            && this.lookahead.head) {
              var quasi = this.parseTemplateLiteral();
              expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi));
            } else {
              break;
            }
          }

          return expr;
        }; // https://tc39.github.io/ecma262/#sec-update-expressions


        Parser.prototype.parseUpdateExpression = function () {
          var expr;
          var startToken = this.lookahead;

          if (this.match('++') || this.match('--')) {
            var node = this.startNode(startToken);
            var token = this.nextToken();
            expr = this.inheritCoverGrammar(this.parseUnaryExpression);

            if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
              this.tolerateError(messages_1.Messages.StrictLHSPrefix);
            }

            if (!this.context.isAssignmentTarget) {
              this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
            }

            var prefix = true;
            expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix));
            this.context.isAssignmentTarget = false;
            this.context.isBindingElement = false;
          } else {
            expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall);

            if (!this.hasLineTerminator && this.lookahead.type === 7
            /* Punctuator */
            ) {
                if (this.match('++') || this.match('--')) {
                  if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
                    this.tolerateError(messages_1.Messages.StrictLHSPostfix);
                  }

                  if (!this.context.isAssignmentTarget) {
                    this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
                  }

                  this.context.isAssignmentTarget = false;
                  this.context.isBindingElement = false;
                  var operator = this.nextToken().value;
                  var prefix = false;
                  expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix));
                }
              }
          }

          return expr;
        }; // https://tc39.github.io/ecma262/#sec-unary-operators


        Parser.prototype.parseAwaitExpression = function () {
          var node = this.createNode();
          this.nextToken();
          var argument = this.parseUnaryExpression();
          return this.finalize(node, new Node.AwaitExpression(argument));
        };

        Parser.prototype.parseUnaryExpression = function () {
          var expr;

          if (this.match('+') || this.match('-') || this.match('~') || this.match('!') || this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) {
            var node = this.startNode(this.lookahead);
            var token = this.nextToken();
            expr = this.inheritCoverGrammar(this.parseUnaryExpression);
            expr = this.finalize(node, new Node.UnaryExpression(token.value, expr));

            if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) {
              this.tolerateError(messages_1.Messages.StrictDelete);
            }

            this.context.isAssignmentTarget = false;
            this.context.isBindingElement = false;
          } else if (this.context.await && this.matchContextualKeyword('await')) {
            expr = this.parseAwaitExpression();
          } else {
            expr = this.parseUpdateExpression();
          }

          return expr;
        };

        Parser.prototype.parseExponentiationExpression = function () {
          var startToken = this.lookahead;
          var expr = this.inheritCoverGrammar(this.parseUnaryExpression);

          if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) {
            this.nextToken();
            this.context.isAssignmentTarget = false;
            this.context.isBindingElement = false;
            var left = expr;
            var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
            expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right));
          }

          return expr;
        }; // https://tc39.github.io/ecma262/#sec-exp-operator
        // https://tc39.github.io/ecma262/#sec-multiplicative-operators
        // https://tc39.github.io/ecma262/#sec-additive-operators
        // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators
        // https://tc39.github.io/ecma262/#sec-relational-operators
        // https://tc39.github.io/ecma262/#sec-equality-operators
        // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators
        // https://tc39.github.io/ecma262/#sec-binary-logical-operators


        Parser.prototype.binaryPrecedence = function (token) {
          var op = token.value;
          var precedence;

          if (token.type === 7
          /* Punctuator */
          ) {
              precedence = this.operatorPrecedence[op] || 0;
            } else if (token.type === 4
          /* Keyword */
          ) {
              precedence = op === 'instanceof' || this.context.allowIn && op === 'in' ? 7 : 0;
            } else {
            precedence = 0;
          }

          return precedence;
        };

        Parser.prototype.parseBinaryExpression = function () {
          var startToken = this.lookahead;
          var expr = this.inheritCoverGrammar(this.parseExponentiationExpression);
          var token = this.lookahead;
          var prec = this.binaryPrecedence(token);

          if (prec > 0) {
            this.nextToken();
            this.context.isAssignmentTarget = false;
            this.context.isBindingElement = false;
            var markers = [startToken, this.lookahead];
            var left = expr;
            var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
            var stack = [left, token.value, right];
            var precedences = [prec];

            while (true) {
              prec = this.binaryPrecedence(this.lookahead);

              if (prec <= 0) {
                break;
              } // Reduce: make a binary expression from the three topmost entries.


              while (stack.length > 2 && prec <= precedences[precedences.length - 1]) {
                right = stack.pop();
                var operator = stack.pop();
                precedences.pop();
                left = stack.pop();
                markers.pop();
                var node = this.startNode(markers[markers.length - 1]);
                stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right)));
              } // Shift.


              stack.push(this.nextToken().value);
              precedences.push(prec);
              markers.push(this.lookahead);
              stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression));
            } // Final reduce to clean-up the stack.


            var i = stack.length - 1;
            expr = stack[i];
            var lastMarker = markers.pop();

            while (i > 1) {
              var marker = markers.pop();
              var lastLineStart = lastMarker && lastMarker.lineStart;
              var node = this.startNode(marker, lastLineStart);
              var operator = stack[i - 1];
              expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr));
              i -= 2;
              lastMarker = marker;
            }
          }

          return expr;
        }; // https://tc39.github.io/ecma262/#sec-conditional-operator


        Parser.prototype.parseConditionalExpression = function () {
          var startToken = this.lookahead;
          var expr = this.inheritCoverGrammar(this.parseBinaryExpression);

          if (this.match('?')) {
            this.nextToken();
            var previousAllowIn = this.context.allowIn;
            this.context.allowIn = true;
            var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression);
            this.context.allowIn = previousAllowIn;
            this.expect(':');
            var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression);
            expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate));
            this.context.isAssignmentTarget = false;
            this.context.isBindingElement = false;
          }

          return expr;
        }; // https://tc39.github.io/ecma262/#sec-assignment-operators


        Parser.prototype.checkPatternParam = function (options, param) {
          switch (param.type) {
            case syntax_1.Syntax.Identifier:
              this.validateParam(options, param, param.name);
              break;

            case syntax_1.Syntax.RestElement:
              this.checkPatternParam(options, param.argument);
              break;

            case syntax_1.Syntax.AssignmentPattern:
              this.checkPatternParam(options, param.left);
              break;

            case syntax_1.Syntax.ArrayPattern:
              for (var i = 0; i < param.elements.length; i++) {
                if (param.elements[i] !== null) {
                  this.checkPatternParam(options, param.elements[i]);
                }
              }

              break;

            case syntax_1.Syntax.ObjectPattern:
              for (var i = 0; i < param.properties.length; i++) {
                this.checkPatternParam(options, param.properties[i].value);
              }

              break;

            default:
              break;
          }

          options.simple = options.simple && param instanceof Node.Identifier;
        };

        Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {
          var params = [expr];
          var options;
          var asyncArrow = false;

          switch (expr.type) {
            case syntax_1.Syntax.Identifier:
              break;

            case ArrowParameterPlaceHolder:
              params = expr.params;
              asyncArrow = expr.async;
              break;

            default:
              return null;
          }

          options = {
            simple: true,
            paramSet: {}
          };

          for (var i = 0; i < params.length; ++i) {
            var param = params[i];

            if (param.type === syntax_1.Syntax.AssignmentPattern) {
              if (param.right.type === syntax_1.Syntax.YieldExpression) {
                if (param.right.argument) {
                  this.throwUnexpectedToken(this.lookahead);
                }

                param.right.type = syntax_1.Syntax.Identifier;
                param.right.name = 'yield';
                delete param.right.argument;
                delete param.right.delegate;
              }
            } else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') {
              this.throwUnexpectedToken(this.lookahead);
            }

            this.checkPatternParam(options, param);
            params[i] = param;
          }

          if (this.context.strict || !this.context.allowYield) {
            for (var i = 0; i < params.length; ++i) {
              var param = params[i];

              if (param.type === syntax_1.Syntax.YieldExpression) {
                this.throwUnexpectedToken(this.lookahead);
              }
            }
          }

          if (options.message === messages_1.Messages.StrictParamDupe) {
            var token = this.context.strict ? options.stricted : options.firstRestricted;
            this.throwUnexpectedToken(token, options.message);
          }

          return {
            simple: options.simple,
            params: params,
            stricted: options.stricted,
            firstRestricted: options.firstRestricted,
            message: options.message
          };
        };

        Parser.prototype.parseAssignmentExpression = function () {
          var expr;

          if (!this.context.allowYield && this.matchKeyword('yield')) {
            expr = this.parseYieldExpression();
          } else {
            var startToken = this.lookahead;
            var token = startToken;
            expr = this.parseConditionalExpression();

            if (token.type === 3
            /* Identifier */
            && token.lineNumber === this.lookahead.lineNumber && token.value === 'async') {
              if (this.lookahead.type === 3
              /* Identifier */
              || this.matchKeyword('yield')) {
                var arg = this.parsePrimaryExpression();
                this.reinterpretExpressionAsPattern(arg);
                expr = {
                  type: ArrowParameterPlaceHolder,
                  params: [arg],
                  async: true
                };
              }
            }

            if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) {
              // https://tc39.github.io/ecma262/#sec-arrow-function-definitions
              this.context.isAssignmentTarget = false;
              this.context.isBindingElement = false;
              var isAsync = expr.async;
              var list = this.reinterpretAsCoverFormalsList(expr);

              if (list) {
                if (this.hasLineTerminator) {
                  this.tolerateUnexpectedToken(this.lookahead);
                }

                this.context.firstCoverInitializedNameError = null;
                var previousStrict = this.context.strict;
                var previousAllowStrictDirective = this.context.allowStrictDirective;
                this.context.allowStrictDirective = list.simple;
                var previousAllowYield = this.context.allowYield;
                var previousAwait = this.context.await;
                this.context.allowYield = true;
                this.context.await = isAsync;
                var node = this.startNode(startToken);
                this.expect('=>');
                var body = void 0;

                if (this.match('{')) {
                  var previousAllowIn = this.context.allowIn;
                  this.context.allowIn = true;
                  body = this.parseFunctionSourceElements();
                  this.context.allowIn = previousAllowIn;
                } else {
                  body = this.isolateCoverGrammar(this.parseAssignmentExpression);
                }

                var expression = body.type !== syntax_1.Syntax.BlockStatement;

                if (this.context.strict && list.firstRestricted) {
                  this.throwUnexpectedToken(list.firstRestricted, list.message);
                }

                if (this.context.strict && list.stricted) {
                  this.tolerateUnexpectedToken(list.stricted, list.message);
                }

                expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) : this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression));
                this.context.strict = previousStrict;
                this.context.allowStrictDirective = previousAllowStrictDirective;
                this.context.allowYield = previousAllowYield;
                this.context.await = previousAwait;
              }
            } else {
              if (this.matchAssign()) {
                if (!this.context.isAssignmentTarget) {
                  this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
                }

                if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) {
                  var id = expr;

                  if (this.scanner.isRestrictedWord(id.name)) {
                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);
                  }

                  if (this.scanner.isStrictModeReservedWord(id.name)) {
                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
                  }
                }

                if (!this.match('=')) {
                  this.context.isAssignmentTarget = false;
                  this.context.isBindingElement = false;
                } else {
                  this.reinterpretExpressionAsPattern(expr);
                }

                token = this.nextToken();
                var operator = token.value;
                var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
                expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right));
                this.context.firstCoverInitializedNameError = null;
              }
            }
          }

          return expr;
        }; // https://tc39.github.io/ecma262/#sec-comma-operator


        Parser.prototype.parseExpression = function () {
          var startToken = this.lookahead;
          var expr = this.isolateCoverGrammar(this.parseAssignmentExpression);

          if (this.match(',')) {
            var expressions = [];
            expressions.push(expr);

            while (this.lookahead.type !== 2
            /* EOF */
            ) {
              if (!this.match(',')) {
                break;
              }

              this.nextToken();
              expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
            }

            expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
          }

          return expr;
        }; // https://tc39.github.io/ecma262/#sec-block


        Parser.prototype.parseStatementListItem = function () {
          var statement;
          this.context.isAssignmentTarget = true;
          this.context.isBindingElement = true;

          if (this.lookahead.type === 4
          /* Keyword */
          ) {
              switch (this.lookahead.value) {
                case 'export':
                  if (!this.context.isModule) {
                    this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration);
                  }

                  statement = this.parseExportDeclaration();
                  break;

                case 'import':
                  if (!this.context.isModule) {
                    this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);
                  }

                  statement = this.parseImportDeclaration();
                  break;

                case 'const':
                  statement = this.parseLexicalDeclaration({
                    inFor: false
                  });
                  break;

                case 'function':
                  statement = this.parseFunctionDeclaration();
                  break;

                case 'class':
                  statement = this.parseClassDeclaration();
                  break;

                case 'let':
                  statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({
                    inFor: false
                  }) : this.parseStatement();
                  break;

                default:
                  statement = this.parseStatement();
                  break;
              }
            } else {
            statement = this.parseStatement();
          }

          return statement;
        };

        Parser.prototype.parseBlock = function () {
          var node = this.createNode();
          this.expect('{');
          var block = [];

          while (true) {
            if (this.match('}')) {
              break;
            }

            block.push(this.parseStatementListItem());
          }

          this.expect('}');
          return this.finalize(node, new Node.BlockStatement(block));
        }; // https://tc39.github.io/ecma262/#sec-let-and-const-declarations


        Parser.prototype.parseLexicalBinding = function (kind, options) {
          var node = this.createNode();
          var params = [];
          var id = this.parsePattern(params, kind);

          if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
            if (this.scanner.isRestrictedWord(id.name)) {
              this.tolerateError(messages_1.Messages.StrictVarName);
            }
          }

          var init = null;

          if (kind === 'const') {
            if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) {
              if (this.match('=')) {
                this.nextToken();
                init = this.isolateCoverGrammar(this.parseAssignmentExpression);
              } else {
                this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const');
              }
            }
          } else if (!options.inFor && id.type !== syntax_1.Syntax.Identifier || this.match('=')) {
            this.expect('=');
            init = this.isolateCoverGrammar(this.parseAssignmentExpression);
          }

          return this.finalize(node, new Node.VariableDeclarator(id, init));
        };

        Parser.prototype.parseBindingList = function (kind, options) {
          var list = [this.parseLexicalBinding(kind, options)];

          while (this.match(',')) {
            this.nextToken();
            list.push(this.parseLexicalBinding(kind, options));
          }

          return list;
        };

        Parser.prototype.isLexicalDeclaration = function () {
          var state = this.scanner.saveState();
          this.scanner.scanComments();
          var next = this.scanner.lex();
          this.scanner.restoreState(state);
          return next.type === 3
          /* Identifier */
          || next.type === 7
          /* Punctuator */
          && next.value === '[' || next.type === 7
          /* Punctuator */
          && next.value === '{' || next.type === 4
          /* Keyword */
          && next.value === 'let' || next.type === 4
          /* Keyword */
          && next.value === 'yield';
        };

        Parser.prototype.parseLexicalDeclaration = function (options) {
          var node = this.createNode();
          var kind = this.nextToken().value;
          assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const');
          var declarations = this.parseBindingList(kind, options);
          this.consumeSemicolon();
          return this.finalize(node, new Node.VariableDeclaration(declarations, kind));
        }; // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns


        Parser.prototype.parseBindingRestElement = function (params, kind) {
          var node = this.createNode();
          this.expect('...');
          var arg = this.parsePattern(params, kind);
          return this.finalize(node, new Node.RestElement(arg));
        };

        Parser.prototype.parseArrayPattern = function (params, kind) {
          var node = this.createNode();
          this.expect('[');
          var elements = [];

          while (!this.match(']')) {
            if (this.match(',')) {
              this.nextToken();
              elements.push(null);
            } else {
              if (this.match('...')) {
                elements.push(this.parseBindingRestElement(params, kind));
                break;
              } else {
                elements.push(this.parsePatternWithDefault(params, kind));
              }

              if (!this.match(']')) {
                this.expect(',');
              }
            }
          }

          this.expect(']');
          return this.finalize(node, new Node.ArrayPattern(elements));
        };

        Parser.prototype.parsePropertyPattern = function (params, kind) {
          var node = this.createNode();
          var computed = false;
          var shorthand = false;
          var method = false;
          var key;
          var value;

          if (this.lookahead.type === 3
          /* Identifier */
          ) {
              var keyToken = this.lookahead;
              key = this.parseVariableIdentifier();
              var init = this.finalize(node, new Node.Identifier(keyToken.value));

              if (this.match('=')) {
                params.push(keyToken);
                shorthand = true;
                this.nextToken();
                var expr = this.parseAssignmentExpression();
                value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
              } else if (!this.match(':')) {
                params.push(keyToken);
                shorthand = true;
                value = init;
              } else {
                this.expect(':');
                value = this.parsePatternWithDefault(params, kind);
              }
            } else {
            computed = this.match('[');
            key = this.parseObjectPropertyKey();
            this.expect(':');
            value = this.parsePatternWithDefault(params, kind);
          }

          return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand));
        };

        Parser.prototype.parseObjectPattern = function (params, kind) {
          var node = this.createNode();
          var properties = [];
          this.expect('{');

          while (!this.match('}')) {
            properties.push(this.parsePropertyPattern(params, kind));

            if (!this.match('}')) {
              this.expect(',');
            }
          }

          this.expect('}');
          return this.finalize(node, new Node.ObjectPattern(properties));
        };

        Parser.prototype.parsePattern = function (params, kind) {
          var pattern;

          if (this.match('[')) {
            pattern = this.parseArrayPattern(params, kind);
          } else if (this.match('{')) {
            pattern = this.parseObjectPattern(params, kind);
          } else {
            if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) {
              this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding);
            }

            params.push(this.lookahead);
            pattern = this.parseVariableIdentifier(kind);
          }

          return pattern;
        };

        Parser.prototype.parsePatternWithDefault = function (params, kind) {
          var startToken = this.lookahead;
          var pattern = this.parsePattern(params, kind);

          if (this.match('=')) {
            this.nextToken();
            var previousAllowYield = this.context.allowYield;
            this.context.allowYield = true;
            var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
            this.context.allowYield = previousAllowYield;
            pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right));
          }

          return pattern;
        }; // https://tc39.github.io/ecma262/#sec-variable-statement


        Parser.prototype.parseVariableIdentifier = function (kind) {
          var node = this.createNode();
          var token = this.nextToken();

          if (token.type === 4
          /* Keyword */
          && token.value === 'yield') {
            if (this.context.strict) {
              this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
            } else if (!this.context.allowYield) {
              this.throwUnexpectedToken(token);
            }
          } else if (token.type !== 3
          /* Identifier */
          ) {
              if (this.context.strict && token.type === 4
              /* Keyword */
              && this.scanner.isStrictModeReservedWord(token.value)) {
                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
              } else {
                if (this.context.strict || token.value !== 'let' || kind !== 'var') {
                  this.throwUnexpectedToken(token);
                }
              }
            } else if ((this.context.isModule || this.context.await) && token.type === 3
          /* Identifier */
          && token.value === 'await') {
            this.tolerateUnexpectedToken(token);
          }

          return this.finalize(node, new Node.Identifier(token.value));
        };

        Parser.prototype.parseVariableDeclaration = function (options) {
          var node = this.createNode();
          var params = [];
          var id = this.parsePattern(params, 'var');

          if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
            if (this.scanner.isRestrictedWord(id.name)) {
              this.tolerateError(messages_1.Messages.StrictVarName);
            }
          }

          var init = null;

          if (this.match('=')) {
            this.nextToken();
            init = this.isolateCoverGrammar(this.parseAssignmentExpression);
          } else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
            this.expect('=');
          }

          return this.finalize(node, new Node.VariableDeclarator(id, init));
        };

        Parser.prototype.parseVariableDeclarationList = function (options) {
          var opt = {
            inFor: options.inFor
          };
          var list = [];
          list.push(this.parseVariableDeclaration(opt));

          while (this.match(',')) {
            this.nextToken();
            list.push(this.parseVariableDeclaration(opt));
          }

          return list;
        };

        Parser.prototype.parseVariableStatement = function () {
          var node = this.createNode();
          this.expectKeyword('var');
          var declarations = this.parseVariableDeclarationList({
            inFor: false
          });
          this.consumeSemicolon();
          return this.finalize(node, new Node.VariableDeclaration(declarations, 'var'));
        }; // https://tc39.github.io/ecma262/#sec-empty-statement


        Parser.prototype.parseEmptyStatement = function () {
          var node = this.createNode();
          this.expect(';');
          return this.finalize(node, new Node.EmptyStatement());
        }; // https://tc39.github.io/ecma262/#sec-expression-statement


        Parser.prototype.parseExpressionStatement = function () {
          var node = this.createNode();
          var expr = this.parseExpression();
          this.consumeSemicolon();
          return this.finalize(node, new Node.ExpressionStatement(expr));
        }; // https://tc39.github.io/ecma262/#sec-if-statement


        Parser.prototype.parseIfClause = function () {
          if (this.context.strict && this.matchKeyword('function')) {
            this.tolerateError(messages_1.Messages.StrictFunction);
          }

          return this.parseStatement();
        };

        Parser.prototype.parseIfStatement = function () {
          var node = this.createNode();
          var consequent;
          var alternate = null;
          this.expectKeyword('if');
          this.expect('(');
          var test = this.parseExpression();

          if (!this.match(')') && this.config.tolerant) {
            this.tolerateUnexpectedToken(this.nextToken());
            consequent = this.finalize(this.createNode(), new Node.EmptyStatement());
          } else {
            this.expect(')');
            consequent = this.parseIfClause();

            if (this.matchKeyword('else')) {
              this.nextToken();
              alternate = this.parseIfClause();
            }
          }

          return this.finalize(node, new Node.IfStatement(test, consequent, alternate));
        }; // https://tc39.github.io/ecma262/#sec-do-while-statement


        Parser.prototype.parseDoWhileStatement = function () {
          var node = this.createNode();
          this.expectKeyword('do');
          var previousInIteration = this.context.inIteration;
          this.context.inIteration = true;
          var body = this.parseStatement();
          this.context.inIteration = previousInIteration;
          this.expectKeyword('while');
          this.expect('(');
          var test = this.parseExpression();

          if (!this.match(')') && this.config.tolerant) {
            this.tolerateUnexpectedToken(this.nextToken());
          } else {
            this.expect(')');

            if (this.match(';')) {
              this.nextToken();
            }
          }

          return this.finalize(node, new Node.DoWhileStatement(body, test));
        }; // https://tc39.github.io/ecma262/#sec-while-statement


        Parser.prototype.parseWhileStatement = function () {
          var node = this.createNode();
          var body;
          this.expectKeyword('while');
          this.expect('(');
          var test = this.parseExpression();

          if (!this.match(')') && this.config.tolerant) {
            this.tolerateUnexpectedToken(this.nextToken());
            body = this.finalize(this.createNode(), new Node.EmptyStatement());
          } else {
            this.expect(')');
            var previousInIteration = this.context.inIteration;
            this.context.inIteration = true;
            body = this.parseStatement();
            this.context.inIteration = previousInIteration;
          }

          return this.finalize(node, new Node.WhileStatement(test, body));
        }; // https://tc39.github.io/ecma262/#sec-for-statement
        // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements


        Parser.prototype.parseForStatement = function () {
          var init = null;
          var test = null;
          var update = null;
          var forIn = true;
          var left, right;
          var node = this.createNode();
          this.expectKeyword('for');
          this.expect('(');

          if (this.match(';')) {
            this.nextToken();
          } else {
            if (this.matchKeyword('var')) {
              init = this.createNode();
              this.nextToken();
              var previousAllowIn = this.context.allowIn;
              this.context.allowIn = false;
              var declarations = this.parseVariableDeclarationList({
                inFor: true
              });
              this.context.allowIn = previousAllowIn;

              if (declarations.length === 1 && this.matchKeyword('in')) {
                var decl = declarations[0];

                if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
                  this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in');
                }

                init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
                this.nextToken();
                left = init;
                right = this.parseExpression();
                init = null;
              } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
                init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
                this.nextToken();
                left = init;
                right = this.parseAssignmentExpression();
                init = null;
                forIn = false;
              } else {
                init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
                this.expect(';');
              }
            } else if (this.matchKeyword('const') || this.matchKeyword('let')) {
              init = this.createNode();
              var kind = this.nextToken().value;

              if (!this.context.strict && this.lookahead.value === 'in') {
                init = this.finalize(init, new Node.Identifier(kind));
                this.nextToken();
                left = init;
                right = this.parseExpression();
                init = null;
              } else {
                var previousAllowIn = this.context.allowIn;
                this.context.allowIn = false;
                var declarations = this.parseBindingList(kind, {
                  inFor: true
                });
                this.context.allowIn = previousAllowIn;

                if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) {
                  init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
                  this.nextToken();
                  left = init;
                  right = this.parseExpression();
                  init = null;
                } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
                  init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
                  this.nextToken();
                  left = init;
                  right = this.parseAssignmentExpression();
                  init = null;
                  forIn = false;
                } else {
                  this.consumeSemicolon();
                  init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
                }
              }
            } else {
              var initStartToken = this.lookahead;
              var previousAllowIn = this.context.allowIn;
              this.context.allowIn = false;
              init = this.inheritCoverGrammar(this.parseAssignmentExpression);
              this.context.allowIn = previousAllowIn;

              if (this.matchKeyword('in')) {
                if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
                  this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
                }

                this.nextToken();
                this.reinterpretExpressionAsPattern(init);
                left = init;
                right = this.parseExpression();
                init = null;
              } else if (this.matchContextualKeyword('of')) {
                if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
                  this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
                }

                this.nextToken();
                this.reinterpretExpressionAsPattern(init);
                left = init;
                right = this.parseAssignmentExpression();
                init = null;
                forIn = false;
              } else {
                if (this.match(',')) {
                  var initSeq = [init];

                  while (this.match(',')) {
                    this.nextToken();
                    initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
                  }

                  init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
                }

                this.expect(';');
              }
            }
          }

          if (typeof left === 'undefined') {
            if (!this.match(';')) {
              test = this.parseExpression();
            }

            this.expect(';');

            if (!this.match(')')) {
              update = this.parseExpression();
            }
          }

          var body;

          if (!this.match(')') && this.config.tolerant) {
            this.tolerateUnexpectedToken(this.nextToken());
            body = this.finalize(this.createNode(), new Node.EmptyStatement());
          } else {
            this.expect(')');
            var previousInIteration = this.context.inIteration;
            this.context.inIteration = true;
            body = this.isolateCoverGrammar(this.parseStatement);
            this.context.inIteration = previousInIteration;
          }

          return typeof left === 'undefined' ? this.finalize(node, new Node.ForStatement(init, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
        }; // https://tc39.github.io/ecma262/#sec-continue-statement


        Parser.prototype.parseContinueStatement = function () {
          var node = this.createNode();
          this.expectKeyword('continue');
          var label = null;

          if (this.lookahead.type === 3
          /* Identifier */
          && !this.hasLineTerminator) {
            var id = this.parseVariableIdentifier();
            label = id;
            var key = '$' + id.name;

            if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
              this.throwError(messages_1.Messages.UnknownLabel, id.name);
            }
          }

          this.consumeSemicolon();

          if (label === null && !this.context.inIteration) {
            this.throwError(messages_1.Messages.IllegalContinue);
          }

          return this.finalize(node, new Node.ContinueStatement(label));
        }; // https://tc39.github.io/ecma262/#sec-break-statement


        Parser.prototype.parseBreakStatement = function () {
          var node = this.createNode();
          this.expectKeyword('break');
          var label = null;

          if (this.lookahead.type === 3
          /* Identifier */
          && !this.hasLineTerminator) {
            var id = this.parseVariableIdentifier();
            var key = '$' + id.name;

            if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
              this.throwError(messages_1.Messages.UnknownLabel, id.name);
            }

            label = id;
          }

          this.consumeSemicolon();

          if (label === null && !this.context.inIteration && !this.context.inSwitch) {
            this.throwError(messages_1.Messages.IllegalBreak);
          }

          return this.finalize(node, new Node.BreakStatement(label));
        }; // https://tc39.github.io/ecma262/#sec-return-statement


        Parser.prototype.parseReturnStatement = function () {
          if (!this.context.inFunctionBody) {
            this.tolerateError(messages_1.Messages.IllegalReturn);
          }

          var node = this.createNode();
          this.expectKeyword('return');
          var hasArgument = !this.match(';') && !this.match('}') && !this.hasLineTerminator && this.lookahead.type !== 2
          /* EOF */
          || this.lookahead.type === 8
          /* StringLiteral */
          || this.lookahead.type === 10
          /* Template */
          ;
          var argument = hasArgument ? this.parseExpression() : null;
          this.consumeSemicolon();
          return this.finalize(node, new Node.ReturnStatement(argument));
        }; // https://tc39.github.io/ecma262/#sec-with-statement


        Parser.prototype.parseWithStatement = function () {
          if (this.context.strict) {
            this.tolerateError(messages_1.Messages.StrictModeWith);
          }

          var node = this.createNode();
          var body;
          this.expectKeyword('with');
          this.expect('(');
          var object = this.parseExpression();

          if (!this.match(')') && this.config.tolerant) {
            this.tolerateUnexpectedToken(this.nextToken());
            body = this.finalize(this.createNode(), new Node.EmptyStatement());
          } else {
            this.expect(')');
            body = this.parseStatement();
          }

          return this.finalize(node, new Node.WithStatement(object, body));
        }; // https://tc39.github.io/ecma262/#sec-switch-statement


        Parser.prototype.parseSwitchCase = function () {
          var node = this.createNode();
          var test;

          if (this.matchKeyword('default')) {
            this.nextToken();
            test = null;
          } else {
            this.expectKeyword('case');
            test = this.parseExpression();
          }

          this.expect(':');
          var consequent = [];

          while (true) {
            if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) {
              break;
            }

            consequent.push(this.parseStatementListItem());
          }

          return this.finalize(node, new Node.SwitchCase(test, consequent));
        };

        Parser.prototype.parseSwitchStatement = function () {
          var node = this.createNode();
          this.expectKeyword('switch');
          this.expect('(');
          var discriminant = this.parseExpression();
          this.expect(')');
          var previousInSwitch = this.context.inSwitch;
          this.context.inSwitch = true;
          var cases = [];
          var defaultFound = false;
          this.expect('{');

          while (true) {
            if (this.match('}')) {
              break;
            }

            var clause = this.parseSwitchCase();

            if (clause.test === null) {
              if (defaultFound) {
                this.throwError(messages_1.Messages.MultipleDefaultsInSwitch);
              }

              defaultFound = true;
            }

            cases.push(clause);
          }

          this.expect('}');
          this.context.inSwitch = previousInSwitch;
          return this.finalize(node, new Node.SwitchStatement(discriminant, cases));
        }; // https://tc39.github.io/ecma262/#sec-labelled-statements


        Parser.prototype.parseLabelledStatement = function () {
          var node = this.createNode();
          var expr = this.parseExpression();
          var statement;

          if (expr.type === syntax_1.Syntax.Identifier && this.match(':')) {
            this.nextToken();
            var id = expr;
            var key = '$' + id.name;

            if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
              this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name);
            }

            this.context.labelSet[key] = true;
            var body = void 0;

            if (this.matchKeyword('class')) {
              this.tolerateUnexpectedToken(this.lookahead);
              body = this.parseClassDeclaration();
            } else if (this.matchKeyword('function')) {
              var token = this.lookahead;
              var declaration = this.parseFunctionDeclaration();

              if (this.context.strict) {
                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction);
              } else if (declaration.generator) {
                this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext);
              }

              body = declaration;
            } else {
              body = this.parseStatement();
            }

            delete this.context.labelSet[key];
            statement = new Node.LabeledStatement(id, body);
          } else {
            this.consumeSemicolon();
            statement = new Node.ExpressionStatement(expr);
          }

          return this.finalize(node, statement);
        }; // https://tc39.github.io/ecma262/#sec-throw-statement


        Parser.prototype.parseThrowStatement = function () {
          var node = this.createNode();
          this.expectKeyword('throw');

          if (this.hasLineTerminator) {
            this.throwError(messages_1.Messages.NewlineAfterThrow);
          }

          var argument = this.parseExpression();
          this.consumeSemicolon();
          return this.finalize(node, new Node.ThrowStatement(argument));
        }; // https://tc39.github.io/ecma262/#sec-try-statement


        Parser.prototype.parseCatchClause = function () {
          var node = this.createNode();
          this.expectKeyword('catch');
          this.expect('(');

          if (this.match(')')) {
            this.throwUnexpectedToken(this.lookahead);
          }

          var params = [];
          var param = this.parsePattern(params);
          var paramMap = {};

          for (var i = 0; i < params.length; i++) {
            var key = '$' + params[i].value;

            if (Object.prototype.hasOwnProperty.call(paramMap, key)) {
              this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value);
            }

            paramMap[key] = true;
          }

          if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {
            if (this.scanner.isRestrictedWord(param.name)) {
              this.tolerateError(messages_1.Messages.StrictCatchVariable);
            }
          }

          this.expect(')');
          var body = this.parseBlock();
          return this.finalize(node, new Node.CatchClause(param, body));
        };

        Parser.prototype.parseFinallyClause = function () {
          this.expectKeyword('finally');
          return this.parseBlock();
        };

        Parser.prototype.parseTryStatement = function () {
          var node = this.createNode();
          this.expectKeyword('try');
          var block = this.parseBlock();
          var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null;
          var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null;

          if (!handler && !finalizer) {
            this.throwError(messages_1.Messages.NoCatchOrFinally);
          }

          return this.finalize(node, new Node.TryStatement(block, handler, finalizer));
        }; // https://tc39.github.io/ecma262/#sec-debugger-statement


        Parser.prototype.parseDebuggerStatement = function () {
          var node = this.createNode();
          this.expectKeyword('debugger');
          this.consumeSemicolon();
          return this.finalize(node, new Node.DebuggerStatement());
        }; // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations


        Parser.prototype.parseStatement = function () {
          var statement;

          switch (this.lookahead.type) {
            case 1
            /* BooleanLiteral */
            :
            case 5
            /* NullLiteral */
            :
            case 6
            /* NumericLiteral */
            :
            case 8
            /* StringLiteral */
            :
            case 10
            /* Template */
            :
            case 9
            /* RegularExpression */
            :
              statement = this.parseExpressionStatement();
              break;

            case 7
            /* Punctuator */
            :
              var value = this.lookahead.value;

              if (value === '{') {
                statement = this.parseBlock();
              } else if (value === '(') {
                statement = this.parseExpressionStatement();
              } else if (value === ';') {
                statement = this.parseEmptyStatement();
              } else {
                statement = this.parseExpressionStatement();
              }

              break;

            case 3
            /* Identifier */
            :
              statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement();
              break;

            case 4
            /* Keyword */
            :
              switch (this.lookahead.value) {
                case 'break':
                  statement = this.parseBreakStatement();
                  break;

                case 'continue':
                  statement = this.parseContinueStatement();
                  break;

                case 'debugger':
                  statement = this.parseDebuggerStatement();
                  break;

                case 'do':
                  statement = this.parseDoWhileStatement();
                  break;

                case 'for':
                  statement = this.parseForStatement();
                  break;

                case 'function':
                  statement = this.parseFunctionDeclaration();
                  break;

                case 'if':
                  statement = this.parseIfStatement();
                  break;

                case 'return':
                  statement = this.parseReturnStatement();
                  break;

                case 'switch':
                  statement = this.parseSwitchStatement();
                  break;

                case 'throw':
                  statement = this.parseThrowStatement();
                  break;

                case 'try':
                  statement = this.parseTryStatement();
                  break;

                case 'var':
                  statement = this.parseVariableStatement();
                  break;

                case 'while':
                  statement = this.parseWhileStatement();
                  break;

                case 'with':
                  statement = this.parseWithStatement();
                  break;

                default:
                  statement = this.parseExpressionStatement();
                  break;
              }

              break;

            default:
              statement = this.throwUnexpectedToken(this.lookahead);
          }

          return statement;
        }; // https://tc39.github.io/ecma262/#sec-function-definitions


        Parser.prototype.parseFunctionSourceElements = function () {
          var node = this.createNode();
          this.expect('{');
          var body = this.parseDirectivePrologues();
          var previousLabelSet = this.context.labelSet;
          var previousInIteration = this.context.inIteration;
          var previousInSwitch = this.context.inSwitch;
          var previousInFunctionBody = this.context.inFunctionBody;
          this.context.labelSet = {};
          this.context.inIteration = false;
          this.context.inSwitch = false;
          this.context.inFunctionBody = true;

          while (this.lookahead.type !== 2
          /* EOF */
          ) {
            if (this.match('}')) {
              break;
            }

            body.push(this.parseStatementListItem());
          }

          this.expect('}');
          this.context.labelSet = previousLabelSet;
          this.context.inIteration = previousInIteration;
          this.context.inSwitch = previousInSwitch;
          this.context.inFunctionBody = previousInFunctionBody;
          return this.finalize(node, new Node.BlockStatement(body));
        };

        Parser.prototype.validateParam = function (options, param, name) {
          var key = '$' + name;

          if (this.context.strict) {
            if (this.scanner.isRestrictedWord(name)) {
              options.stricted = param;
              options.message = messages_1.Messages.StrictParamName;
            }

            if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
              options.stricted = param;
              options.message = messages_1.Messages.StrictParamDupe;
            }
          } else if (!options.firstRestricted) {
            if (this.scanner.isRestrictedWord(name)) {
              options.firstRestricted = param;
              options.message = messages_1.Messages.StrictParamName;
            } else if (this.scanner.isStrictModeReservedWord(name)) {
              options.firstRestricted = param;
              options.message = messages_1.Messages.StrictReservedWord;
            } else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
              options.stricted = param;
              options.message = messages_1.Messages.StrictParamDupe;
            }
          }
          /* istanbul ignore next */


          if (typeof Object.defineProperty === 'function') {
            Object.defineProperty(options.paramSet, key, {
              value: true,
              enumerable: true,
              writable: true,
              configurable: true
            });
          } else {
            options.paramSet[key] = true;
          }
        };

        Parser.prototype.parseRestElement = function (params) {
          var node = this.createNode();
          this.expect('...');
          var arg = this.parsePattern(params);

          if (this.match('=')) {
            this.throwError(messages_1.Messages.DefaultRestParameter);
          }

          if (!this.match(')')) {
            this.throwError(messages_1.Messages.ParameterAfterRestParameter);
          }

          return this.finalize(node, new Node.RestElement(arg));
        };

        Parser.prototype.parseFormalParameter = function (options) {
          var params = [];
          var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params);

          for (var i = 0; i < params.length; i++) {
            this.validateParam(options, params[i], params[i].value);
          }

          options.simple = options.simple && param instanceof Node.Identifier;
          options.params.push(param);
        };

        Parser.prototype.parseFormalParameters = function (firstRestricted) {
          var options;
          options = {
            simple: true,
            params: [],
            firstRestricted: firstRestricted
          };
          this.expect('(');

          if (!this.match(')')) {
            options.paramSet = {};

            while (this.lookahead.type !== 2
            /* EOF */
            ) {
              this.parseFormalParameter(options);

              if (this.match(')')) {
                break;
              }

              this.expect(',');

              if (this.match(')')) {
                break;
              }
            }
          }

          this.expect(')');
          return {
            simple: options.simple,
            params: options.params,
            stricted: options.stricted,
            firstRestricted: options.firstRestricted,
            message: options.message
          };
        };

        Parser.prototype.matchAsyncFunction = function () {
          var match = this.matchContextualKeyword('async');

          if (match) {
            var state = this.scanner.saveState();
            this.scanner.scanComments();
            var next = this.scanner.lex();
            this.scanner.restoreState(state);
            match = state.lineNumber === next.lineNumber && next.type === 4
            /* Keyword */
            && next.value === 'function';
          }

          return match;
        };

        Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) {
          var node = this.createNode();
          var isAsync = this.matchContextualKeyword('async');

          if (isAsync) {
            this.nextToken();
          }

          this.expectKeyword('function');
          var isGenerator = isAsync ? false : this.match('*');

          if (isGenerator) {
            this.nextToken();
          }

          var message;
          var id = null;
          var firstRestricted = null;

          if (!identifierIsOptional || !this.match('(')) {
            var token = this.lookahead;
            id = this.parseVariableIdentifier();

            if (this.context.strict) {
              if (this.scanner.isRestrictedWord(token.value)) {
                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
              }
            } else {
              if (this.scanner.isRestrictedWord(token.value)) {
                firstRestricted = token;
                message = messages_1.Messages.StrictFunctionName;
              } else if (this.scanner.isStrictModeReservedWord(token.value)) {
                firstRestricted = token;
                message = messages_1.Messages.StrictReservedWord;
              }
            }
          }

          var previousAllowAwait = this.context.await;
          var previousAllowYield = this.context.allowYield;
          this.context.await = isAsync;
          this.context.allowYield = !isGenerator;
          var formalParameters = this.parseFormalParameters(firstRestricted);
          var params = formalParameters.params;
          var stricted = formalParameters.stricted;
          firstRestricted = formalParameters.firstRestricted;

          if (formalParameters.message) {
            message = formalParameters.message;
          }

          var previousStrict = this.context.strict;
          var previousAllowStrictDirective = this.context.allowStrictDirective;
          this.context.allowStrictDirective = formalParameters.simple;
          var body = this.parseFunctionSourceElements();

          if (this.context.strict && firstRestricted) {
            this.throwUnexpectedToken(firstRestricted, message);
          }

          if (this.context.strict && stricted) {
            this.tolerateUnexpectedToken(stricted, message);
          }

          this.context.strict = previousStrict;
          this.context.allowStrictDirective = previousAllowStrictDirective;
          this.context.await = previousAllowAwait;
          this.context.allowYield = previousAllowYield;
          return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) : this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator));
        };

        Parser.prototype.parseFunctionExpression = function () {
          var node = this.createNode();
          var isAsync = this.matchContextualKeyword('async');

          if (isAsync) {
            this.nextToken();
          }

          this.expectKeyword('function');
          var isGenerator = isAsync ? false : this.match('*');

          if (isGenerator) {
            this.nextToken();
          }

          var message;
          var id = null;
          var firstRestricted;
          var previousAllowAwait = this.context.await;
          var previousAllowYield = this.context.allowYield;
          this.context.await = isAsync;
          this.context.allowYield = !isGenerator;

          if (!this.match('(')) {
            var token = this.lookahead;
            id = !this.context.strict && !isGenerator && this.matchKeyword('yield') ? this.parseIdentifierName() : this.parseVariableIdentifier();

            if (this.context.strict) {
              if (this.scanner.isRestrictedWord(token.value)) {
                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
              }
            } else {
              if (this.scanner.isRestrictedWord(token.value)) {
                firstRestricted = token;
                message = messages_1.Messages.StrictFunctionName;
              } else if (this.scanner.isStrictModeReservedWord(token.value)) {
                firstRestricted = token;
                message = messages_1.Messages.StrictReservedWord;
              }
            }
          }

          var formalParameters = this.parseFormalParameters(firstRestricted);
          var params = formalParameters.params;
          var stricted = formalParameters.stricted;
          firstRestricted = formalParameters.firstRestricted;

          if (formalParameters.message) {
            message = formalParameters.message;
          }

          var previousStrict = this.context.strict;
          var previousAllowStrictDirective = this.context.allowStrictDirective;
          this.context.allowStrictDirective = formalParameters.simple;
          var body = this.parseFunctionSourceElements();

          if (this.context.strict && firstRestricted) {
            this.throwUnexpectedToken(firstRestricted, message);
          }

          if (this.context.strict && stricted) {
            this.tolerateUnexpectedToken(stricted, message);
          }

          this.context.strict = previousStrict;
          this.context.allowStrictDirective = previousAllowStrictDirective;
          this.context.await = previousAllowAwait;
          this.context.allowYield = previousAllowYield;
          return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) : this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator));
        }; // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive


        Parser.prototype.parseDirective = function () {
          var token = this.lookahead;
          var node = this.createNode();
          var expr = this.parseExpression();
          var directive = expr.type === syntax_1.Syntax.Literal ? this.getTokenRaw(token).slice(1, -1) : null;
          this.consumeSemicolon();
          return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr));
        };

        Parser.prototype.parseDirectivePrologues = function () {
          var firstRestricted = null;
          var body = [];

          while (true) {
            var token = this.lookahead;

            if (token.type !== 8
            /* StringLiteral */
            ) {
                break;
              }

            var statement = this.parseDirective();
            body.push(statement);
            var directive = statement.directive;

            if (typeof directive !== 'string') {
              break;
            }

            if (directive === 'use strict') {
              this.context.strict = true;

              if (firstRestricted) {
                this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral);
              }

              if (!this.context.allowStrictDirective) {
                this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective);
              }
            } else {
              if (!firstRestricted && token.octal) {
                firstRestricted = token;
              }
            }
          }

          return body;
        }; // https://tc39.github.io/ecma262/#sec-method-definitions


        Parser.prototype.qualifiedPropertyName = function (token) {
          switch (token.type) {
            case 3
            /* Identifier */
            :
            case 8
            /* StringLiteral */
            :
            case 1
            /* BooleanLiteral */
            :
            case 5
            /* NullLiteral */
            :
            case 6
            /* NumericLiteral */
            :
            case 4
            /* Keyword */
            :
              return true;

            case 7
            /* Punctuator */
            :
              return token.value === '[';

            default:
              break;
          }

          return false;
        };

        Parser.prototype.parseGetterMethod = function () {
          var node = this.createNode();
          var isGenerator = false;
          var previousAllowYield = this.context.allowYield;
          this.context.allowYield = !isGenerator;
          var formalParameters = this.parseFormalParameters();

          if (formalParameters.params.length > 0) {
            this.tolerateError(messages_1.Messages.BadGetterArity);
          }

          var method = this.parsePropertyMethod(formalParameters);
          this.context.allowYield = previousAllowYield;
          return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
        };

        Parser.prototype.parseSetterMethod = function () {
          var node = this.createNode();
          var isGenerator = false;
          var previousAllowYield = this.context.allowYield;
          this.context.allowYield = !isGenerator;
          var formalParameters = this.parseFormalParameters();

          if (formalParameters.params.length !== 1) {
            this.tolerateError(messages_1.Messages.BadSetterArity);
          } else if (formalParameters.params[0] instanceof Node.RestElement) {
            this.tolerateError(messages_1.Messages.BadSetterRestParameter);
          }

          var method = this.parsePropertyMethod(formalParameters);
          this.context.allowYield = previousAllowYield;
          return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
        };

        Parser.prototype.parseGeneratorMethod = function () {
          var node = this.createNode();
          var isGenerator = true;
          var previousAllowYield = this.context.allowYield;
          this.context.allowYield = true;
          var params = this.parseFormalParameters();
          this.context.allowYield = false;
          var method = this.parsePropertyMethod(params);
          this.context.allowYield = previousAllowYield;
          return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
        }; // https://tc39.github.io/ecma262/#sec-generator-function-definitions


        Parser.prototype.isStartOfExpression = function () {
          var start = true;
          var value = this.lookahead.value;

          switch (this.lookahead.type) {
            case 7
            /* Punctuator */
            :
              start = value === '[' || value === '(' || value === '{' || value === '+' || value === '-' || value === '!' || value === '~' || value === '++' || value === '--' || value === '/' || value === '/='; // regular expression literal

              break;

            case 4
            /* Keyword */
            :
              start = value === 'class' || value === 'delete' || value === 'function' || value === 'let' || value === 'new' || value === 'super' || value === 'this' || value === 'typeof' || value === 'void' || value === 'yield';
              break;

            default:
              break;
          }

          return start;
        };

        Parser.prototype.parseYieldExpression = function () {
          var node = this.createNode();
          this.expectKeyword('yield');
          var argument = null;
          var delegate = false;

          if (!this.hasLineTerminator) {
            var previousAllowYield = this.context.allowYield;
            this.context.allowYield = false;
            delegate = this.match('*');

            if (delegate) {
              this.nextToken();
              argument = this.parseAssignmentExpression();
            } else if (this.isStartOfExpression()) {
              argument = this.parseAssignmentExpression();
            }

            this.context.allowYield = previousAllowYield;
          }

          return this.finalize(node, new Node.YieldExpression(argument, delegate));
        }; // https://tc39.github.io/ecma262/#sec-class-definitions


        Parser.prototype.parseClassElement = function (hasConstructor) {
          var token = this.lookahead;
          var node = this.createNode();
          var kind = '';
          var key = null;
          var value = null;
          var computed = false;
          var method = false;
          var isStatic = false;
          var isAsync = false;

          if (this.match('*')) {
            this.nextToken();
          } else {
            computed = this.match('[');
            key = this.parseObjectPropertyKey();
            var id = key;

            if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) {
              token = this.lookahead;
              isStatic = true;
              computed = this.match('[');

              if (this.match('*')) {
                this.nextToken();
              } else {
                key = this.parseObjectPropertyKey();
              }
            }

            if (token.type === 3
            /* Identifier */
            && !this.hasLineTerminator && token.value === 'async') {
              var punctuator = this.lookahead.value;

              if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {
                isAsync = true;
                token = this.lookahead;
                key = this.parseObjectPropertyKey();

                if (token.type === 3
                /* Identifier */
                && token.value === 'constructor') {
                  this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync);
                }
              }
            }
          }

          var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);

          if (token.type === 3
          /* Identifier */
          ) {
              if (token.value === 'get' && lookaheadPropertyKey) {
                kind = 'get';
                computed = this.match('[');
                key = this.parseObjectPropertyKey();
                this.context.allowYield = false;
                value = this.parseGetterMethod();
              } else if (token.value === 'set' && lookaheadPropertyKey) {
                kind = 'set';
                computed = this.match('[');
                key = this.parseObjectPropertyKey();
                value = this.parseSetterMethod();
              }
            } else if (token.type === 7
          /* Punctuator */
          && token.value === '*' && lookaheadPropertyKey) {
            kind = 'init';
            computed = this.match('[');
            key = this.parseObjectPropertyKey();
            value = this.parseGeneratorMethod();
            method = true;
          }

          if (!kind && key && this.match('(')) {
            kind = 'init';
            value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
            method = true;
          }

          if (!kind) {
            this.throwUnexpectedToken(this.lookahead);
          }

          if (kind === 'init') {
            kind = 'method';
          }

          if (!computed) {
            if (isStatic && this.isPropertyKey(key, 'prototype')) {
              this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype);
            }

            if (!isStatic && this.isPropertyKey(key, 'constructor')) {
              if (kind !== 'method' || !method || value && value.generator) {
                this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod);
              }

              if (hasConstructor.value) {
                this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor);
              } else {
                hasConstructor.value = true;
              }

              kind = 'constructor';
            }
          }

          return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic));
        };

        Parser.prototype.parseClassElementList = function () {
          var body = [];
          var hasConstructor = {
            value: false
          };
          this.expect('{');

          while (!this.match('}')) {
            if (this.match(';')) {
              this.nextToken();
            } else {
              body.push(this.parseClassElement(hasConstructor));
            }
          }

          this.expect('}');
          return body;
        };

        Parser.prototype.parseClassBody = function () {
          var node = this.createNode();
          var elementList = this.parseClassElementList();
          return this.finalize(node, new Node.ClassBody(elementList));
        };

        Parser.prototype.parseClassDeclaration = function (identifierIsOptional) {
          var node = this.createNode();
          var previousStrict = this.context.strict;
          this.context.strict = true;
          this.expectKeyword('class');
          var id = identifierIsOptional && this.lookahead.type !== 3
          /* Identifier */
          ? null : this.parseVariableIdentifier();
          var superClass = null;

          if (this.matchKeyword('extends')) {
            this.nextToken();
            superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
          }

          var classBody = this.parseClassBody();
          this.context.strict = previousStrict;
          return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody));
        };

        Parser.prototype.parseClassExpression = function () {
          var node = this.createNode();
          var previousStrict = this.context.strict;
          this.context.strict = true;
          this.expectKeyword('class');
          var id = this.lookahead.type === 3
          /* Identifier */
          ? this.parseVariableIdentifier() : null;
          var superClass = null;

          if (this.matchKeyword('extends')) {
            this.nextToken();
            superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
          }

          var classBody = this.parseClassBody();
          this.context.strict = previousStrict;
          return this.finalize(node, new Node.ClassExpression(id, superClass, classBody));
        }; // https://tc39.github.io/ecma262/#sec-scripts
        // https://tc39.github.io/ecma262/#sec-modules


        Parser.prototype.parseModule = function () {
          this.context.strict = true;
          this.context.isModule = true;
          this.scanner.isModule = true;
          var node = this.createNode();
          var body = this.parseDirectivePrologues();

          while (this.lookahead.type !== 2
          /* EOF */
          ) {
            body.push(this.parseStatementListItem());
          }

          return this.finalize(node, new Node.Module(body));
        };

        Parser.prototype.parseScript = function () {
          var node = this.createNode();
          var body = this.parseDirectivePrologues();

          while (this.lookahead.type !== 2
          /* EOF */
          ) {
            body.push(this.parseStatementListItem());
          }

          return this.finalize(node, new Node.Script(body));
        }; // https://tc39.github.io/ecma262/#sec-imports


        Parser.prototype.parseModuleSpecifier = function () {
          var node = this.createNode();

          if (this.lookahead.type !== 8
          /* StringLiteral */
          ) {
              this.throwError(messages_1.Messages.InvalidModuleSpecifier);
            }

          var token = this.nextToken();
          var raw = this.getTokenRaw(token);
          return this.finalize(node, new Node.Literal(token.value, raw));
        }; // import {<foo as bar>} ...;


        Parser.prototype.parseImportSpecifier = function () {
          var node = this.createNode();
          var imported;
          var local;

          if (this.lookahead.type === 3
          /* Identifier */
          ) {
              imported = this.parseVariableIdentifier();
              local = imported;

              if (this.matchContextualKeyword('as')) {
                this.nextToken();
                local = this.parseVariableIdentifier();
              }
            } else {
            imported = this.parseIdentifierName();
            local = imported;

            if (this.matchContextualKeyword('as')) {
              this.nextToken();
              local = this.parseVariableIdentifier();
            } else {
              this.throwUnexpectedToken(this.nextToken());
            }
          }

          return this.finalize(node, new Node.ImportSpecifier(local, imported));
        }; // {foo, bar as bas}


        Parser.prototype.parseNamedImports = function () {
          this.expect('{');
          var specifiers = [];

          while (!this.match('}')) {
            specifiers.push(this.parseImportSpecifier());

            if (!this.match('}')) {
              this.expect(',');
            }
          }

          this.expect('}');
          return specifiers;
        }; // import <foo> ...;


        Parser.prototype.parseImportDefaultSpecifier = function () {
          var node = this.createNode();
          var local = this.parseIdentifierName();
          return this.finalize(node, new Node.ImportDefaultSpecifier(local));
        }; // import <* as foo> ...;


        Parser.prototype.parseImportNamespaceSpecifier = function () {
          var node = this.createNode();
          this.expect('*');

          if (!this.matchContextualKeyword('as')) {
            this.throwError(messages_1.Messages.NoAsAfterImportNamespace);
          }

          this.nextToken();
          var local = this.parseIdentifierName();
          return this.finalize(node, new Node.ImportNamespaceSpecifier(local));
        };

        Parser.prototype.parseImportDeclaration = function () {
          if (this.context.inFunctionBody) {
            this.throwError(messages_1.Messages.IllegalImportDeclaration);
          }

          var node = this.createNode();
          this.expectKeyword('import');
          var src;
          var specifiers = [];

          if (this.lookahead.type === 8
          /* StringLiteral */
          ) {
              // import 'foo';
              src = this.parseModuleSpecifier();
            } else {
            if (this.match('{')) {
              // import {bar}
              specifiers = specifiers.concat(this.parseNamedImports());
            } else if (this.match('*')) {
              // import * as foo
              specifiers.push(this.parseImportNamespaceSpecifier());
            } else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) {
              // import foo
              specifiers.push(this.parseImportDefaultSpecifier());

              if (this.match(',')) {
                this.nextToken();

                if (this.match('*')) {
                  // import foo, * as foo
                  specifiers.push(this.parseImportNamespaceSpecifier());
                } else if (this.match('{')) {
                  // import foo, {bar}
                  specifiers = specifiers.concat(this.parseNamedImports());
                } else {
                  this.throwUnexpectedToken(this.lookahead);
                }
              }
            } else {
              this.throwUnexpectedToken(this.nextToken());
            }

            if (!this.matchContextualKeyword('from')) {
              var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
              this.throwError(message, this.lookahead.value);
            }

            this.nextToken();
            src = this.parseModuleSpecifier();
          }

          this.consumeSemicolon();
          return this.finalize(node, new Node.ImportDeclaration(specifiers, src));
        }; // https://tc39.github.io/ecma262/#sec-exports


        Parser.prototype.parseExportSpecifier = function () {
          var node = this.createNode();
          var local = this.parseIdentifierName();
          var exported = local;

          if (this.matchContextualKeyword('as')) {
            this.nextToken();
            exported = this.parseIdentifierName();
          }

          return this.finalize(node, new Node.ExportSpecifier(local, exported));
        };

        Parser.prototype.parseExportDeclaration = function () {
          if (this.context.inFunctionBody) {
            this.throwError(messages_1.Messages.IllegalExportDeclaration);
          }

          var node = this.createNode();
          this.expectKeyword('export');
          var exportDeclaration;

          if (this.matchKeyword('default')) {
            // export default ...
            this.nextToken();

            if (this.matchKeyword('function')) {
              // export default function foo () {}
              // export default function () {}
              var declaration = this.parseFunctionDeclaration(true);
              exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
            } else if (this.matchKeyword('class')) {
              // export default class foo {}
              var declaration = this.parseClassDeclaration(true);
              exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
            } else if (this.matchContextualKeyword('async')) {
              // export default async function f () {}
              // export default async function () {}
              // export default async x => x
              var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression();
              exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
            } else {
              if (this.matchContextualKeyword('from')) {
                this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);
              } // export default {};
              // export default [];
              // export default (1 + 2);


              var declaration = this.match('{') ? this.parseObjectInitializer() : this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression();
              this.consumeSemicolon();
              exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
            }
          } else if (this.match('*')) {
            // export * from 'foo';
            this.nextToken();

            if (!this.matchContextualKeyword('from')) {
              var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
              this.throwError(message, this.lookahead.value);
            }

            this.nextToken();
            var src = this.parseModuleSpecifier();
            this.consumeSemicolon();
            exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));
          } else if (this.lookahead.type === 4
          /* Keyword */
          ) {
              // export var f = 1;
              var declaration = void 0;

              switch (this.lookahead.value) {
                case 'let':
                case 'const':
                  declaration = this.parseLexicalDeclaration({
                    inFor: false
                  });
                  break;

                case 'var':
                case 'class':
                case 'function':
                  declaration = this.parseStatementListItem();
                  break;

                default:
                  this.throwUnexpectedToken(this.lookahead);
              }

              exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
            } else if (this.matchAsyncFunction()) {
            var declaration = this.parseFunctionDeclaration();
            exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
          } else {
            var specifiers = [];
            var source = null;
            var isExportFromIdentifier = false;
            this.expect('{');

            while (!this.match('}')) {
              isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');
              specifiers.push(this.parseExportSpecifier());

              if (!this.match('}')) {
                this.expect(',');
              }
            }

            this.expect('}');

            if (this.matchContextualKeyword('from')) {
              // export {default} from 'foo';
              // export {foo} from 'foo';
              this.nextToken();
              source = this.parseModuleSpecifier();
              this.consumeSemicolon();
            } else if (isExportFromIdentifier) {
              // export {default}; // missing fromClause
              var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
              this.throwError(message, this.lookahead.value);
            } else {
              // export {foo};
              this.consumeSemicolon();
            }

            exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source));
          }

          return exportDeclaration;
        };

        return Parser;
      }();

      exports.Parser = Parser;
      /***/
    },
    /* 9 */

    /***/
    function (module, exports) {
      "use strict"; // Ensure the condition is true, otherwise throw an error.
      // This is only to have a better contract semantic, i.e. another safety net
      // to catch a logic error. The condition shall be fulfilled in normal case.
      // Do NOT use this to enforce a certain condition on any user input.

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      function assert(condition, message) {
        /* istanbul ignore if */
        if (!condition) {
          throw new Error('ASSERT: ' + message);
        }
      }

      exports.assert = assert;
      /***/
    },
    /* 10 */

    /***/
    function (module, exports) {
      "use strict";
      /* tslint:disable:max-classes-per-file */

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var ErrorHandler = function () {
        function ErrorHandler() {
          this.errors = [];
          this.tolerant = false;
        }

        ErrorHandler.prototype.recordError = function (error) {
          this.errors.push(error);
        };

        ErrorHandler.prototype.tolerate = function (error) {
          if (this.tolerant) {
            this.recordError(error);
          } else {
            throw error;
          }
        };

        ErrorHandler.prototype.constructError = function (msg, column) {
          var error = new Error(msg);

          try {
            throw error;
          } catch (base) {
            /* istanbul ignore else */
            if (Object.create && Object.defineProperty) {
              error = Object.create(base);
              Object.defineProperty(error, 'column', {
                value: column
              });
            }
          }
          /* istanbul ignore next */


          return error;
        };

        ErrorHandler.prototype.createError = function (index, line, col, description) {
          var msg = 'Line ' + line + ': ' + description;
          var error = this.constructError(msg, col);
          error.index = index;
          error.lineNumber = line;
          error.description = description;
          return error;
        };

        ErrorHandler.prototype.throwError = function (index, line, col, description) {
          throw this.createError(index, line, col, description);
        };

        ErrorHandler.prototype.tolerateError = function (index, line, col, description) {
          var error = this.createError(index, line, col, description);

          if (this.tolerant) {
            this.recordError(error);
          } else {
            throw error;
          }
        };

        return ErrorHandler;
      }();

      exports.ErrorHandler = ErrorHandler;
      /***/
    },
    /* 11 */

    /***/
    function (module, exports) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      }); // Error messages should be identical to V8.

      exports.Messages = {
        BadGetterArity: 'Getter must not have any formal parameters',
        BadSetterArity: 'Setter must have exactly one formal parameter',
        BadSetterRestParameter: 'Setter function argument must not be a rest parameter',
        ConstructorIsAsync: 'Class constructor may not be an async method',
        ConstructorSpecialMethod: 'Class constructor may not be an accessor',
        DeclarationMissingInitializer: 'Missing initializer in %0 declaration',
        DefaultRestParameter: 'Unexpected token =',
        DuplicateBinding: 'Duplicate binding %0',
        DuplicateConstructor: 'A class may only have one constructor',
        DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',
        ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',
        GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts',
        IllegalBreak: 'Illegal break statement',
        IllegalContinue: 'Illegal continue statement',
        IllegalExportDeclaration: 'Unexpected token',
        IllegalImportDeclaration: 'Unexpected token',
        IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list',
        IllegalReturn: 'Illegal return statement',
        InvalidEscapedReservedWord: 'Keyword must not contain escaped characters',
        InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence',
        InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
        InvalidLHSInForIn: 'Invalid left-hand side in for-in',
        InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',
        InvalidModuleSpecifier: 'Unexpected token',
        InvalidRegExp: 'Invalid regular expression',
        LetInLexicalBinding: 'let is disallowed as a lexically bound name',
        MissingFromClause: 'Unexpected token',
        MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
        NewlineAfterThrow: 'Illegal newline after throw',
        NoAsAfterImportNamespace: 'Unexpected token',
        NoCatchOrFinally: 'Missing catch or finally after try',
        ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',
        Redeclaration: '%0 \'%1\' has already been declared',
        StaticPrototype: 'Classes may not have static property named prototype',
        StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
        StrictDelete: 'Delete of an unqualified identifier in strict mode.',
        StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block',
        StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
        StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',
        StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',
        StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',
        StrictModeWith: 'Strict mode code may not include a with statement',
        StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
        StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
        StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
        StrictReservedWord: 'Use of future reserved word in strict mode',
        StrictVarName: 'Variable name may not be eval or arguments in strict mode',
        TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',
        UnexpectedEOS: 'Unexpected end of input',
        UnexpectedIdentifier: 'Unexpected identifier',
        UnexpectedNumber: 'Unexpected number',
        UnexpectedReserved: 'Unexpected reserved word',
        UnexpectedString: 'Unexpected string',
        UnexpectedTemplate: 'Unexpected quasi %0',
        UnexpectedToken: 'Unexpected token %0',
        UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',
        UnknownLabel: 'Undefined label \'%0\'',
        UnterminatedRegExp: 'Invalid regular expression: missing /'
      };
      /***/
    },
    /* 12 */

    /***/
    function (module, exports, __webpack_require__) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var assert_1 = __webpack_require__(9);

      var character_1 = __webpack_require__(4);

      var messages_1 = __webpack_require__(11);

      function hexValue(ch) {
        return '0123456789abcdef'.indexOf(ch.toLowerCase());
      }

      function octalValue(ch) {
        return '01234567'.indexOf(ch);
      }

      var Scanner = function () {
        function Scanner(code, handler) {
          this.source = code;
          this.errorHandler = handler;
          this.trackComment = false;
          this.isModule = false;
          this.length = code.length;
          this.index = 0;
          this.lineNumber = code.length > 0 ? 1 : 0;
          this.lineStart = 0;
          this.curlyStack = [];
        }

        Scanner.prototype.saveState = function () {
          return {
            index: this.index,
            lineNumber: this.lineNumber,
            lineStart: this.lineStart
          };
        };

        Scanner.prototype.restoreState = function (state) {
          this.index = state.index;
          this.lineNumber = state.lineNumber;
          this.lineStart = state.lineStart;
        };

        Scanner.prototype.eof = function () {
          return this.index >= this.length;
        };

        Scanner.prototype.throwUnexpectedToken = function (message) {
          if (message === void 0) {
            message = messages_1.Messages.UnexpectedTokenIllegal;
          }

          return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
        };

        Scanner.prototype.tolerateUnexpectedToken = function (message) {
          if (message === void 0) {
            message = messages_1.Messages.UnexpectedTokenIllegal;
          }

          this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
        }; // https://tc39.github.io/ecma262/#sec-comments


        Scanner.prototype.skipSingleLineComment = function (offset) {
          var comments = [];
          var start, loc;

          if (this.trackComment) {
            comments = [];
            start = this.index - offset;
            loc = {
              start: {
                line: this.lineNumber,
                column: this.index - this.lineStart - offset
              },
              end: {}
            };
          }

          while (!this.eof()) {
            var ch = this.source.charCodeAt(this.index);
            ++this.index;

            if (character_1.Character.isLineTerminator(ch)) {
              if (this.trackComment) {
                loc.end = {
                  line: this.lineNumber,
                  column: this.index - this.lineStart - 1
                };
                var entry = {
                  multiLine: false,
                  slice: [start + offset, this.index - 1],
                  range: [start, this.index - 1],
                  loc: loc
                };
                comments.push(entry);
              }

              if (ch === 13 && this.source.charCodeAt(this.index) === 10) {
                ++this.index;
              }

              ++this.lineNumber;
              this.lineStart = this.index;
              return comments;
            }
          }

          if (this.trackComment) {
            loc.end = {
              line: this.lineNumber,
              column: this.index - this.lineStart
            };
            var entry = {
              multiLine: false,
              slice: [start + offset, this.index],
              range: [start, this.index],
              loc: loc
            };
            comments.push(entry);
          }

          return comments;
        };

        Scanner.prototype.skipMultiLineComment = function () {
          var comments = [];
          var start, loc;

          if (this.trackComment) {
            comments = [];
            start = this.index - 2;
            loc = {
              start: {
                line: this.lineNumber,
                column: this.index - this.lineStart - 2
              },
              end: {}
            };
          }

          while (!this.eof()) {
            var ch = this.source.charCodeAt(this.index);

            if (character_1.Character.isLineTerminator(ch)) {
              if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) {
                ++this.index;
              }

              ++this.lineNumber;
              ++this.index;
              this.lineStart = this.index;
            } else if (ch === 0x2A) {
              // Block comment ends with '*/'.
              if (this.source.charCodeAt(this.index + 1) === 0x2F) {
                this.index += 2;

                if (this.trackComment) {
                  loc.end = {
                    line: this.lineNumber,
                    column: this.index - this.lineStart
                  };
                  var entry = {
                    multiLine: true,
                    slice: [start + 2, this.index - 2],
                    range: [start, this.index],
                    loc: loc
                  };
                  comments.push(entry);
                }

                return comments;
              }

              ++this.index;
            } else {
              ++this.index;
            }
          } // Ran off the end of the file - the whole thing is a comment


          if (this.trackComment) {
            loc.end = {
              line: this.lineNumber,
              column: this.index - this.lineStart
            };
            var entry = {
              multiLine: true,
              slice: [start + 2, this.index],
              range: [start, this.index],
              loc: loc
            };
            comments.push(entry);
          }

          this.tolerateUnexpectedToken();
          return comments;
        };

        Scanner.prototype.scanComments = function () {
          var comments;

          if (this.trackComment) {
            comments = [];
          }

          var start = this.index === 0;

          while (!this.eof()) {
            var ch = this.source.charCodeAt(this.index);

            if (character_1.Character.isWhiteSpace(ch)) {
              ++this.index;
            } else if (character_1.Character.isLineTerminator(ch)) {
              ++this.index;

              if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) {
                ++this.index;
              }

              ++this.lineNumber;
              this.lineStart = this.index;
              start = true;
            } else if (ch === 0x2F) {
              ch = this.source.charCodeAt(this.index + 1);

              if (ch === 0x2F) {
                this.index += 2;
                var comment = this.skipSingleLineComment(2);

                if (this.trackComment) {
                  comments = comments.concat(comment);
                }

                start = true;
              } else if (ch === 0x2A) {
                this.index += 2;
                var comment = this.skipMultiLineComment();

                if (this.trackComment) {
                  comments = comments.concat(comment);
                }
              } else {
                break;
              }
            } else if (start && ch === 0x2D) {
              // U+003E is '>'
              if (this.source.charCodeAt(this.index + 1) === 0x2D && this.source.charCodeAt(this.index + 2) === 0x3E) {
                // '-->' is a single-line comment
                this.index += 3;
                var comment = this.skipSingleLineComment(3);

                if (this.trackComment) {
                  comments = comments.concat(comment);
                }
              } else {
                break;
              }
            } else if (ch === 0x3C && !this.isModule) {
              if (this.source.slice(this.index + 1, this.index + 4) === '!--') {
                this.index += 4; // `<!--`

                var comment = this.skipSingleLineComment(4);

                if (this.trackComment) {
                  comments = comments.concat(comment);
                }
              } else {
                break;
              }
            } else {
              break;
            }
          }

          return comments;
        }; // https://tc39.github.io/ecma262/#sec-future-reserved-words


        Scanner.prototype.isFutureReservedWord = function (id) {
          switch (id) {
            case 'enum':
            case 'export':
            case 'import':
            case 'super':
              return true;

            default:
              return false;
          }
        };

        Scanner.prototype.isStrictModeReservedWord = function (id) {
          switch (id) {
            case 'implements':
            case 'interface':
            case 'package':
            case 'private':
            case 'protected':
            case 'public':
            case 'static':
            case 'yield':
            case 'let':
              return true;

            default:
              return false;
          }
        };

        Scanner.prototype.isRestrictedWord = function (id) {
          return id === 'eval' || id === 'arguments';
        }; // https://tc39.github.io/ecma262/#sec-keywords


        Scanner.prototype.isKeyword = function (id) {
          switch (id.length) {
            case 2:
              return id === 'if' || id === 'in' || id === 'do';

            case 3:
              return id === 'var' || id === 'for' || id === 'new' || id === 'try' || id === 'let';

            case 4:
              return id === 'this' || id === 'else' || id === 'case' || id === 'void' || id === 'with' || id === 'enum';

            case 5:
              return id === 'while' || id === 'break' || id === 'catch' || id === 'throw' || id === 'const' || id === 'yield' || id === 'class' || id === 'super';

            case 6:
              return id === 'return' || id === 'typeof' || id === 'delete' || id === 'switch' || id === 'export' || id === 'import';

            case 7:
              return id === 'default' || id === 'finally' || id === 'extends';

            case 8:
              return id === 'function' || id === 'continue' || id === 'debugger';

            case 10:
              return id === 'instanceof';

            default:
              return false;
          }
        };

        Scanner.prototype.codePointAt = function (i) {
          var cp = this.source.charCodeAt(i);

          if (cp >= 0xD800 && cp <= 0xDBFF) {
            var second = this.source.charCodeAt(i + 1);

            if (second >= 0xDC00 && second <= 0xDFFF) {
              var first = cp;
              cp = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
            }
          }

          return cp;
        };

        Scanner.prototype.scanHexEscape = function (prefix) {
          var len = prefix === 'u' ? 4 : 2;
          var code = 0;

          for (var i = 0; i < len; ++i) {
            if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
              code = code * 16 + hexValue(this.source[this.index++]);
            } else {
              return null;
            }
          }

          return String.fromCharCode(code);
        };

        Scanner.prototype.scanUnicodeCodePointEscape = function () {
          var ch = this.source[this.index];
          var code = 0; // At least, one hex digit is required.

          if (ch === '}') {
            this.throwUnexpectedToken();
          }

          while (!this.eof()) {
            ch = this.source[this.index++];

            if (!character_1.Character.isHexDigit(ch.charCodeAt(0))) {
              break;
            }

            code = code * 16 + hexValue(ch);
          }

          if (code > 0x10FFFF || ch !== '}') {
            this.throwUnexpectedToken();
          }

          return character_1.Character.fromCodePoint(code);
        };

        Scanner.prototype.getIdentifier = function () {
          var start = this.index++;

          while (!this.eof()) {
            var ch = this.source.charCodeAt(this.index);

            if (ch === 0x5C) {
              // Blackslash (U+005C) marks Unicode escape sequence.
              this.index = start;
              return this.getComplexIdentifier();
            } else if (ch >= 0xD800 && ch < 0xDFFF) {
              // Need to handle surrogate pairs.
              this.index = start;
              return this.getComplexIdentifier();
            }

            if (character_1.Character.isIdentifierPart(ch)) {
              ++this.index;
            } else {
              break;
            }
          }

          return this.source.slice(start, this.index);
        };

        Scanner.prototype.getComplexIdentifier = function () {
          var cp = this.codePointAt(this.index);
          var id = character_1.Character.fromCodePoint(cp);
          this.index += id.length; // '\u' (U+005C, U+0075) denotes an escaped character.

          var ch;

          if (cp === 0x5C) {
            if (this.source.charCodeAt(this.index) !== 0x75) {
              this.throwUnexpectedToken();
            }

            ++this.index;

            if (this.source[this.index] === '{') {
              ++this.index;
              ch = this.scanUnicodeCodePointEscape();
            } else {
              ch = this.scanHexEscape('u');

              if (ch === null || ch === '\\' || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) {
                this.throwUnexpectedToken();
              }
            }

            id = ch;
          }

          while (!this.eof()) {
            cp = this.codePointAt(this.index);

            if (!character_1.Character.isIdentifierPart(cp)) {
              break;
            }

            ch = character_1.Character.fromCodePoint(cp);
            id += ch;
            this.index += ch.length; // '\u' (U+005C, U+0075) denotes an escaped character.

            if (cp === 0x5C) {
              id = id.substr(0, id.length - 1);

              if (this.source.charCodeAt(this.index) !== 0x75) {
                this.throwUnexpectedToken();
              }

              ++this.index;

              if (this.source[this.index] === '{') {
                ++this.index;
                ch = this.scanUnicodeCodePointEscape();
              } else {
                ch = this.scanHexEscape('u');

                if (ch === null || ch === '\\' || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
                  this.throwUnexpectedToken();
                }
              }

              id += ch;
            }
          }

          return id;
        };

        Scanner.prototype.octalToDecimal = function (ch) {
          // \0 is not octal escape sequence
          var octal = ch !== '0';
          var code = octalValue(ch);

          if (!this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
            octal = true;
            code = code * 8 + octalValue(this.source[this.index++]); // 3 digits are only allowed when string starts
            // with 0, 1, 2, 3

            if ('0123'.indexOf(ch) >= 0 && !this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
              code = code * 8 + octalValue(this.source[this.index++]);
            }
          }

          return {
            code: code,
            octal: octal
          };
        }; // https://tc39.github.io/ecma262/#sec-names-and-keywords


        Scanner.prototype.scanIdentifier = function () {
          var type;
          var start = this.index; // Backslash (U+005C) starts an escaped character.

          var id = this.source.charCodeAt(start) === 0x5C ? this.getComplexIdentifier() : this.getIdentifier(); // There is no keyword or literal with only one character.
          // Thus, it must be an identifier.

          if (id.length === 1) {
            type = 3
            /* Identifier */
            ;
          } else if (this.isKeyword(id)) {
            type = 4
            /* Keyword */
            ;
          } else if (id === 'null') {
            type = 5
            /* NullLiteral */
            ;
          } else if (id === 'true' || id === 'false') {
            type = 1
            /* BooleanLiteral */
            ;
          } else {
            type = 3
            /* Identifier */
            ;
          }

          if (type !== 3
          /* Identifier */
          && start + id.length !== this.index) {
            var restore = this.index;
            this.index = start;
            this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord);
            this.index = restore;
          }

          return {
            type: type,
            value: id,
            lineNumber: this.lineNumber,
            lineStart: this.lineStart,
            start: start,
            end: this.index
          };
        }; // https://tc39.github.io/ecma262/#sec-punctuators


        Scanner.prototype.scanPunctuator = function () {
          var start = this.index; // Check for most common single-character punctuators.

          var str = this.source[this.index];

          switch (str) {
            case '(':
            case '{':
              if (str === '{') {
                this.curlyStack.push('{');
              }

              ++this.index;
              break;

            case '.':
              ++this.index;

              if (this.source[this.index] === '.' && this.source[this.index + 1] === '.') {
                // Spread operator: ...
                this.index += 2;
                str = '...';
              }

              break;

            case '}':
              ++this.index;
              this.curlyStack.pop();
              break;

            case ')':
            case ';':
            case ',':
            case '[':
            case ']':
            case ':':
            case '?':
            case '~':
              ++this.index;
              break;

            default:
              // 4-character punctuator.
              str = this.source.substr(this.index, 4);

              if (str === '>>>=') {
                this.index += 4;
              } else {
                // 3-character punctuators.
                str = str.substr(0, 3);

                if (str === '===' || str === '!==' || str === '>>>' || str === '<<=' || str === '>>=' || str === '**=') {
                  this.index += 3;
                } else {
                  // 2-character punctuators.
                  str = str.substr(0, 2);

                  if (str === '&&' || str === '||' || str === '==' || str === '!=' || str === '+=' || str === '-=' || str === '*=' || str === '/=' || str === '++' || str === '--' || str === '<<' || str === '>>' || str === '&=' || str === '|=' || str === '^=' || str === '%=' || str === '<=' || str === '>=' || str === '=>' || str === '**') {
                    this.index += 2;
                  } else {
                    // 1-character punctuators.
                    str = this.source[this.index];

                    if ('<>=!+-*%&|^/'.indexOf(str) >= 0) {
                      ++this.index;
                    }
                  }
                }
              }

          }

          if (this.index === start) {
            this.throwUnexpectedToken();
          }

          return {
            type: 7
            /* Punctuator */
            ,
            value: str,
            lineNumber: this.lineNumber,
            lineStart: this.lineStart,
            start: start,
            end: this.index
          };
        }; // https://tc39.github.io/ecma262/#sec-literals-numeric-literals


        Scanner.prototype.scanHexLiteral = function (start) {
          var num = '';

          while (!this.eof()) {
            if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
              break;
            }

            num += this.source[this.index++];
          }

          if (num.length === 0) {
            this.throwUnexpectedToken();
          }

          if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
            this.throwUnexpectedToken();
          }

          return {
            type: 6
            /* NumericLiteral */
            ,
            value: parseInt('0x' + num, 16),
            lineNumber: this.lineNumber,
            lineStart: this.lineStart,
            start: start,
            end: this.index
          };
        };

        Scanner.prototype.scanBinaryLiteral = function (start) {
          var num = '';
          var ch;

          while (!this.eof()) {
            ch = this.source[this.index];

            if (ch !== '0' && ch !== '1') {
              break;
            }

            num += this.source[this.index++];
          }

          if (num.length === 0) {
            // only 0b or 0B
            this.throwUnexpectedToken();
          }

          if (!this.eof()) {
            ch = this.source.charCodeAt(this.index);
            /* istanbul ignore else */

            if (character_1.Character.isIdentifierStart(ch) || character_1.Character.isDecimalDigit(ch)) {
              this.throwUnexpectedToken();
            }
          }

          return {
            type: 6
            /* NumericLiteral */
            ,
            value: parseInt(num, 2),
            lineNumber: this.lineNumber,
            lineStart: this.lineStart,
            start: start,
            end: this.index
          };
        };

        Scanner.prototype.scanOctalLiteral = function (prefix, start) {
          var num = '';
          var octal = false;

          if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {
            octal = true;
            num = '0' + this.source[this.index++];
          } else {
            ++this.index;
          }

          while (!this.eof()) {
            if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
              break;
            }

            num += this.source[this.index++];
          }

          if (!octal && num.length === 0) {
            // only 0o or 0O
            this.throwUnexpectedToken();
          }

          if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index)) || character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
            this.throwUnexpectedToken();
          }

          return {
            type: 6
            /* NumericLiteral */
            ,
            value: parseInt(num, 8),
            octal: octal,
            lineNumber: this.lineNumber,
            lineStart: this.lineStart,
            start: start,
            end: this.index
          };
        };

        Scanner.prototype.isImplicitOctalLiteral = function () {
          // Implicit octal, unless there is a non-octal digit.
          // (Annex B.1.1 on Numeric Literals)
          for (var i = this.index + 1; i < this.length; ++i) {
            var ch = this.source[i];

            if (ch === '8' || ch === '9') {
              return false;
            }

            if (!character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
              return true;
            }
          }

          return true;
        };

        Scanner.prototype.scanNumericLiteral = function () {
          var start = this.index;
          var ch = this.source[start];
          assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || ch === '.', 'Numeric literal must start with a decimal digit or a decimal point');
          var num = '';

          if (ch !== '.') {
            num = this.source[this.index++];
            ch = this.source[this.index]; // Hex number starts with '0x'.
            // Octal number starts with '0'.
            // Octal number in ES6 starts with '0o'.
            // Binary number in ES6 starts with '0b'.

            if (num === '0') {
              if (ch === 'x' || ch === 'X') {
                ++this.index;
                return this.scanHexLiteral(start);
              }

              if (ch === 'b' || ch === 'B') {
                ++this.index;
                return this.scanBinaryLiteral(start);
              }

              if (ch === 'o' || ch === 'O') {
                return this.scanOctalLiteral(ch, start);
              }

              if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
                if (this.isImplicitOctalLiteral()) {
                  return this.scanOctalLiteral(ch, start);
                }
              }
            }

            while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
              num += this.source[this.index++];
            }

            ch = this.source[this.index];
          }

          if (ch === '.') {
            num += this.source[this.index++];

            while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
              num += this.source[this.index++];
            }

            ch = this.source[this.index];
          }

          if (ch === 'e' || ch === 'E') {
            num += this.source[this.index++];
            ch = this.source[this.index];

            if (ch === '+' || ch === '-') {
              num += this.source[this.index++];
            }

            if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
              while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
                num += this.source[this.index++];
              }
            } else {
              this.throwUnexpectedToken();
            }
          }

          if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
            this.throwUnexpectedToken();
          }

          return {
            type: 6
            /* NumericLiteral */
            ,
            value: parseFloat(num),
            lineNumber: this.lineNumber,
            lineStart: this.lineStart,
            start: start,
            end: this.index
          };
        }; // https://tc39.github.io/ecma262/#sec-literals-string-literals


        Scanner.prototype.scanStringLiteral = function () {
          var start = this.index;
          var quote = this.source[start];
          assert_1.assert(quote === '\'' || quote === '"', 'String literal must starts with a quote');
          ++this.index;
          var octal = false;
          var str = '';

          while (!this.eof()) {
            var ch = this.source[this.index++];

            if (ch === quote) {
              quote = '';
              break;
            } else if (ch === '\\') {
              ch = this.source[this.index++];

              if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
                switch (ch) {
                  case 'u':
                    if (this.source[this.index] === '{') {
                      ++this.index;
                      str += this.scanUnicodeCodePointEscape();
                    } else {
                      var unescaped_1 = this.scanHexEscape(ch);

                      if (unescaped_1 === null) {
                        this.throwUnexpectedToken();
                      }

                      str += unescaped_1;
                    }

                    break;

                  case 'x':
                    var unescaped = this.scanHexEscape(ch);

                    if (unescaped === null) {
                      this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
                    }

                    str += unescaped;
                    break;

                  case 'n':
                    str += '\n';
                    break;

                  case 'r':
                    str += '\r';
                    break;

                  case 't':
                    str += '\t';
                    break;

                  case 'b':
                    str += '\b';
                    break;

                  case 'f':
                    str += '\f';
                    break;

                  case 'v':
                    str += '\x0B';
                    break;

                  case '8':
                  case '9':
                    str += ch;
                    this.tolerateUnexpectedToken();
                    break;

                  default:
                    if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
                      var octToDec = this.octalToDecimal(ch);
                      octal = octToDec.octal || octal;
                      str += String.fromCharCode(octToDec.code);
                    } else {
                      str += ch;
                    }

                    break;
                }
              } else {
                ++this.lineNumber;

                if (ch === '\r' && this.source[this.index] === '\n') {
                  ++this.index;
                }

                this.lineStart = this.index;
              }
            } else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
              break;
            } else {
              str += ch;
            }
          }

          if (quote !== '') {
            this.index = start;
            this.throwUnexpectedToken();
          }

          return {
            type: 8
            /* StringLiteral */
            ,
            value: str,
            octal: octal,
            lineNumber: this.lineNumber,
            lineStart: this.lineStart,
            start: start,
            end: this.index
          };
        }; // https://tc39.github.io/ecma262/#sec-template-literal-lexical-components


        Scanner.prototype.scanTemplate = function () {
          var cooked = '';
          var terminated = false;
          var start = this.index;
          var head = this.source[start] === '`';
          var tail = false;
          var rawOffset = 2;
          ++this.index;

          while (!this.eof()) {
            var ch = this.source[this.index++];

            if (ch === '`') {
              rawOffset = 1;
              tail = true;
              terminated = true;
              break;
            } else if (ch === '$') {
              if (this.source[this.index] === '{') {
                this.curlyStack.push('${');
                ++this.index;
                terminated = true;
                break;
              }

              cooked += ch;
            } else if (ch === '\\') {
              ch = this.source[this.index++];

              if (!character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
                switch (ch) {
                  case 'n':
                    cooked += '\n';
                    break;

                  case 'r':
                    cooked += '\r';
                    break;

                  case 't':
                    cooked += '\t';
                    break;

                  case 'u':
                    if (this.source[this.index] === '{') {
                      ++this.index;
                      cooked += this.scanUnicodeCodePointEscape();
                    } else {
                      var restore = this.index;
                      var unescaped_2 = this.scanHexEscape(ch);

                      if (unescaped_2 !== null) {
                        cooked += unescaped_2;
                      } else {
                        this.index = restore;
                        cooked += ch;
                      }
                    }

                    break;

                  case 'x':
                    var unescaped = this.scanHexEscape(ch);

                    if (unescaped === null) {
                      this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
                    }

                    cooked += unescaped;
                    break;

                  case 'b':
                    cooked += '\b';
                    break;

                  case 'f':
                    cooked += '\f';
                    break;

                  case 'v':
                    cooked += '\v';
                    break;

                  default:
                    if (ch === '0') {
                      if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
                        // Illegal: \01 \02 and so on
                        this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
                      }

                      cooked += '\0';
                    } else if (character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
                      // Illegal: \1 \2
                      this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
                    } else {
                      cooked += ch;
                    }

                    break;
                }
              } else {
                ++this.lineNumber;

                if (ch === '\r' && this.source[this.index] === '\n') {
                  ++this.index;
                }

                this.lineStart = this.index;
              }
            } else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
              ++this.lineNumber;

              if (ch === '\r' && this.source[this.index] === '\n') {
                ++this.index;
              }

              this.lineStart = this.index;
              cooked += '\n';
            } else {
              cooked += ch;
            }
          }

          if (!terminated) {
            this.throwUnexpectedToken();
          }

          if (!head) {
            this.curlyStack.pop();
          }

          return {
            type: 10
            /* Template */
            ,
            value: this.source.slice(start + 1, this.index - rawOffset),
            cooked: cooked,
            head: head,
            tail: tail,
            lineNumber: this.lineNumber,
            lineStart: this.lineStart,
            start: start,
            end: this.index
          };
        }; // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals


        Scanner.prototype.testRegExp = function (pattern, flags) {
          // The BMP character to use as a replacement for astral symbols when
          // translating an ES6 "u"-flagged pattern to an ES5-compatible
          // approximation.
          // Note: replacing with '\uFFFF' enables false positives in unlikely
          // scenarios. For example, `[\u{1044f}-\u{10440}]` is an invalid
          // pattern that would not be detected by this substitution.
          var astralSubstitute = '\uFFFF';
          var tmp = pattern;
          var self = this;

          if (flags.indexOf('u') >= 0) {
            tmp = tmp.replace(/\\u\{([0-9a-fA-F]+)\}|\\u([a-fA-F0-9]{4})/g, function ($0, $1, $2) {
              var codePoint = parseInt($1 || $2, 16);

              if (codePoint > 0x10FFFF) {
                self.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
              }

              if (codePoint <= 0xFFFF) {
                return String.fromCharCode(codePoint);
              }

              return astralSubstitute;
            }).replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, astralSubstitute);
          } // First, detect invalid regular expressions.


          try {
            RegExp(tmp);
          } catch (e) {
            this.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
          } // Return a regular expression object for this pattern-flag pair, or
          // `null` in case the current environment doesn't support the flags it
          // uses.


          try {
            return new RegExp(pattern, flags);
          } catch (exception) {
            /* istanbul ignore next */
            return null;
          }
        };

        Scanner.prototype.scanRegExpBody = function () {
          var ch = this.source[this.index];
          assert_1.assert(ch === '/', 'Regular expression literal must start with a slash');
          var str = this.source[this.index++];
          var classMarker = false;
          var terminated = false;

          while (!this.eof()) {
            ch = this.source[this.index++];
            str += ch;

            if (ch === '\\') {
              ch = this.source[this.index++]; // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals

              if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
                this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
              }

              str += ch;
            } else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
              this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
            } else if (classMarker) {
              if (ch === ']') {
                classMarker = false;
              }
            } else {
              if (ch === '/') {
                terminated = true;
                break;
              } else if (ch === '[') {
                classMarker = true;
              }
            }
          }

          if (!terminated) {
            this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
          } // Exclude leading and trailing slash.


          return str.substr(1, str.length - 2);
        };

        Scanner.prototype.scanRegExpFlags = function () {
          var str = '';
          var flags = '';

          while (!this.eof()) {
            var ch = this.source[this.index];

            if (!character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
              break;
            }

            ++this.index;

            if (ch === '\\' && !this.eof()) {
              ch = this.source[this.index];

              if (ch === 'u') {
                ++this.index;
                var restore = this.index;
                var char = this.scanHexEscape('u');

                if (char !== null) {
                  flags += char;

                  for (str += '\\u'; restore < this.index; ++restore) {
                    str += this.source[restore];
                  }
                } else {
                  this.index = restore;
                  flags += 'u';
                  str += '\\u';
                }

                this.tolerateUnexpectedToken();
              } else {
                str += '\\';
                this.tolerateUnexpectedToken();
              }
            } else {
              flags += ch;
              str += ch;
            }
          }

          return flags;
        };

        Scanner.prototype.scanRegExp = function () {
          var start = this.index;
          var pattern = this.scanRegExpBody();
          var flags = this.scanRegExpFlags();
          var value = this.testRegExp(pattern, flags);
          return {
            type: 9
            /* RegularExpression */
            ,
            value: '',
            pattern: pattern,
            flags: flags,
            regex: value,
            lineNumber: this.lineNumber,
            lineStart: this.lineStart,
            start: start,
            end: this.index
          };
        };

        Scanner.prototype.lex = function () {
          if (this.eof()) {
            return {
              type: 2
              /* EOF */
              ,
              value: '',
              lineNumber: this.lineNumber,
              lineStart: this.lineStart,
              start: this.index,
              end: this.index
            };
          }

          var cp = this.source.charCodeAt(this.index);

          if (character_1.Character.isIdentifierStart(cp)) {
            return this.scanIdentifier();
          } // Very common: ( and ) and ;


          if (cp === 0x28 || cp === 0x29 || cp === 0x3B) {
            return this.scanPunctuator();
          } // String literal starts with single quote (U+0027) or double quote (U+0022).


          if (cp === 0x27 || cp === 0x22) {
            return this.scanStringLiteral();
          } // Dot (.) U+002E can also start a floating-point number, hence the need
          // to check the next character.


          if (cp === 0x2E) {
            if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {
              return this.scanNumericLiteral();
            }

            return this.scanPunctuator();
          }

          if (character_1.Character.isDecimalDigit(cp)) {
            return this.scanNumericLiteral();
          } // Template literals start with ` (U+0060) for template head
          // or } (U+007D) for template middle or template tail.


          if (cp === 0x60 || cp === 0x7D && this.curlyStack[this.curlyStack.length - 1] === '${') {
            return this.scanTemplate();
          } // Possible identifier start in a surrogate pair.


          if (cp >= 0xD800 && cp < 0xDFFF) {
            if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {
              return this.scanIdentifier();
            }
          }

          return this.scanPunctuator();
        };

        return Scanner;
      }();

      exports.Scanner = Scanner;
      /***/
    },
    /* 13 */

    /***/
    function (module, exports) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      });
      exports.TokenName = {};
      exports.TokenName[1
      /* BooleanLiteral */
      ] = 'Boolean';
      exports.TokenName[2
      /* EOF */
      ] = '<end>';
      exports.TokenName[3
      /* Identifier */
      ] = 'Identifier';
      exports.TokenName[4
      /* Keyword */
      ] = 'Keyword';
      exports.TokenName[5
      /* NullLiteral */
      ] = 'Null';
      exports.TokenName[6
      /* NumericLiteral */
      ] = 'Numeric';
      exports.TokenName[7
      /* Punctuator */
      ] = 'Punctuator';
      exports.TokenName[8
      /* StringLiteral */
      ] = 'String';
      exports.TokenName[9
      /* RegularExpression */
      ] = 'RegularExpression';
      exports.TokenName[10
      /* Template */
      ] = 'Template';
      /***/
    },
    /* 14 */

    /***/
    function (module, exports) {
      "use strict"; // Generated by generate-xhtml-entities.js. DO NOT MODIFY!

      Object.defineProperty(exports, "__esModule", {
        value: true
      });
      exports.XHTMLEntities = {
        quot: '\u0022',
        amp: '\u0026',
        apos: '\u0027',
        gt: '\u003E',
        nbsp: '\u00A0',
        iexcl: '\u00A1',
        cent: '\u00A2',
        pound: '\u00A3',
        curren: '\u00A4',
        yen: '\u00A5',
        brvbar: '\u00A6',
        sect: '\u00A7',
        uml: '\u00A8',
        copy: '\u00A9',
        ordf: '\u00AA',
        laquo: '\u00AB',
        not: '\u00AC',
        shy: '\u00AD',
        reg: '\u00AE',
        macr: '\u00AF',
        deg: '\u00B0',
        plusmn: '\u00B1',
        sup2: '\u00B2',
        sup3: '\u00B3',
        acute: '\u00B4',
        micro: '\u00B5',
        para: '\u00B6',
        middot: '\u00B7',
        cedil: '\u00B8',
        sup1: '\u00B9',
        ordm: '\u00BA',
        raquo: '\u00BB',
        frac14: '\u00BC',
        frac12: '\u00BD',
        frac34: '\u00BE',
        iquest: '\u00BF',
        Agrave: '\u00C0',
        Aacute: '\u00C1',
        Acirc: '\u00C2',
        Atilde: '\u00C3',
        Auml: '\u00C4',
        Aring: '\u00C5',
        AElig: '\u00C6',
        Ccedil: '\u00C7',
        Egrave: '\u00C8',
        Eacute: '\u00C9',
        Ecirc: '\u00CA',
        Euml: '\u00CB',
        Igrave: '\u00CC',
        Iacute: '\u00CD',
        Icirc: '\u00CE',
        Iuml: '\u00CF',
        ETH: '\u00D0',
        Ntilde: '\u00D1',
        Ograve: '\u00D2',
        Oacute: '\u00D3',
        Ocirc: '\u00D4',
        Otilde: '\u00D5',
        Ouml: '\u00D6',
        times: '\u00D7',
        Oslash: '\u00D8',
        Ugrave: '\u00D9',
        Uacute: '\u00DA',
        Ucirc: '\u00DB',
        Uuml: '\u00DC',
        Yacute: '\u00DD',
        THORN: '\u00DE',
        szlig: '\u00DF',
        agrave: '\u00E0',
        aacute: '\u00E1',
        acirc: '\u00E2',
        atilde: '\u00E3',
        auml: '\u00E4',
        aring: '\u00E5',
        aelig: '\u00E6',
        ccedil: '\u00E7',
        egrave: '\u00E8',
        eacute: '\u00E9',
        ecirc: '\u00EA',
        euml: '\u00EB',
        igrave: '\u00EC',
        iacute: '\u00ED',
        icirc: '\u00EE',
        iuml: '\u00EF',
        eth: '\u00F0',
        ntilde: '\u00F1',
        ograve: '\u00F2',
        oacute: '\u00F3',
        ocirc: '\u00F4',
        otilde: '\u00F5',
        ouml: '\u00F6',
        divide: '\u00F7',
        oslash: '\u00F8',
        ugrave: '\u00F9',
        uacute: '\u00FA',
        ucirc: '\u00FB',
        uuml: '\u00FC',
        yacute: '\u00FD',
        thorn: '\u00FE',
        yuml: '\u00FF',
        OElig: '\u0152',
        oelig: '\u0153',
        Scaron: '\u0160',
        scaron: '\u0161',
        Yuml: '\u0178',
        fnof: '\u0192',
        circ: '\u02C6',
        tilde: '\u02DC',
        Alpha: '\u0391',
        Beta: '\u0392',
        Gamma: '\u0393',
        Delta: '\u0394',
        Epsilon: '\u0395',
        Zeta: '\u0396',
        Eta: '\u0397',
        Theta: '\u0398',
        Iota: '\u0399',
        Kappa: '\u039A',
        Lambda: '\u039B',
        Mu: '\u039C',
        Nu: '\u039D',
        Xi: '\u039E',
        Omicron: '\u039F',
        Pi: '\u03A0',
        Rho: '\u03A1',
        Sigma: '\u03A3',
        Tau: '\u03A4',
        Upsilon: '\u03A5',
        Phi: '\u03A6',
        Chi: '\u03A7',
        Psi: '\u03A8',
        Omega: '\u03A9',
        alpha: '\u03B1',
        beta: '\u03B2',
        gamma: '\u03B3',
        delta: '\u03B4',
        epsilon: '\u03B5',
        zeta: '\u03B6',
        eta: '\u03B7',
        theta: '\u03B8',
        iota: '\u03B9',
        kappa: '\u03BA',
        lambda: '\u03BB',
        mu: '\u03BC',
        nu: '\u03BD',
        xi: '\u03BE',
        omicron: '\u03BF',
        pi: '\u03C0',
        rho: '\u03C1',
        sigmaf: '\u03C2',
        sigma: '\u03C3',
        tau: '\u03C4',
        upsilon: '\u03C5',
        phi: '\u03C6',
        chi: '\u03C7',
        psi: '\u03C8',
        omega: '\u03C9',
        thetasym: '\u03D1',
        upsih: '\u03D2',
        piv: '\u03D6',
        ensp: '\u2002',
        emsp: '\u2003',
        thinsp: '\u2009',
        zwnj: '\u200C',
        zwj: '\u200D',
        lrm: '\u200E',
        rlm: '\u200F',
        ndash: '\u2013',
        mdash: '\u2014',
        lsquo: '\u2018',
        rsquo: '\u2019',
        sbquo: '\u201A',
        ldquo: '\u201C',
        rdquo: '\u201D',
        bdquo: '\u201E',
        dagger: '\u2020',
        Dagger: '\u2021',
        bull: '\u2022',
        hellip: '\u2026',
        permil: '\u2030',
        prime: '\u2032',
        Prime: '\u2033',
        lsaquo: '\u2039',
        rsaquo: '\u203A',
        oline: '\u203E',
        frasl: '\u2044',
        euro: '\u20AC',
        image: '\u2111',
        weierp: '\u2118',
        real: '\u211C',
        trade: '\u2122',
        alefsym: '\u2135',
        larr: '\u2190',
        uarr: '\u2191',
        rarr: '\u2192',
        darr: '\u2193',
        harr: '\u2194',
        crarr: '\u21B5',
        lArr: '\u21D0',
        uArr: '\u21D1',
        rArr: '\u21D2',
        dArr: '\u21D3',
        hArr: '\u21D4',
        forall: '\u2200',
        part: '\u2202',
        exist: '\u2203',
        empty: '\u2205',
        nabla: '\u2207',
        isin: '\u2208',
        notin: '\u2209',
        ni: '\u220B',
        prod: '\u220F',
        sum: '\u2211',
        minus: '\u2212',
        lowast: '\u2217',
        radic: '\u221A',
        prop: '\u221D',
        infin: '\u221E',
        ang: '\u2220',
        and: '\u2227',
        or: '\u2228',
        cap: '\u2229',
        cup: '\u222A',
        int: '\u222B',
        there4: '\u2234',
        sim: '\u223C',
        cong: '\u2245',
        asymp: '\u2248',
        ne: '\u2260',
        equiv: '\u2261',
        le: '\u2264',
        ge: '\u2265',
        sub: '\u2282',
        sup: '\u2283',
        nsub: '\u2284',
        sube: '\u2286',
        supe: '\u2287',
        oplus: '\u2295',
        otimes: '\u2297',
        perp: '\u22A5',
        sdot: '\u22C5',
        lceil: '\u2308',
        rceil: '\u2309',
        lfloor: '\u230A',
        rfloor: '\u230B',
        loz: '\u25CA',
        spades: '\u2660',
        clubs: '\u2663',
        hearts: '\u2665',
        diams: '\u2666',
        lang: '\u27E8',
        rang: '\u27E9'
      };
      /***/
    },
    /* 15 */

    /***/
    function (module, exports, __webpack_require__) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var error_handler_1 = __webpack_require__(10);

      var scanner_1 = __webpack_require__(12);

      var token_1 = __webpack_require__(13);

      var Reader = function () {
        function Reader() {
          this.values = [];
          this.curly = this.paren = -1;
        } // A function following one of those tokens is an expression.


        Reader.prototype.beforeFunctionExpression = function (t) {
          return ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new', 'return', 'case', 'delete', 'throw', 'void', // assignment operators
          '=', '+=', '-=', '*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=', '&=', '|=', '^=', ',', // binary/unary operators
          '+', '-', '*', '**', '/', '%', '++', '--', '<<', '>>', '>>>', '&', '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=', '<=', '<', '>', '!=', '!=='].indexOf(t) >= 0;
        }; // Determine if forward slash (/) is an operator or part of a regular expression
        // https://github.com/mozilla/sweet.js/wiki/design


        Reader.prototype.isRegexStart = function () {
          var previous = this.values[this.values.length - 1];
          var regex = previous !== null;

          switch (previous) {
            case 'this':
            case ']':
              regex = false;
              break;

            case ')':
              var keyword = this.values[this.paren - 1];
              regex = keyword === 'if' || keyword === 'while' || keyword === 'for' || keyword === 'with';
              break;

            case '}':
              // Dividing a function by anything makes little sense,
              // but we have to check for that.
              regex = false;

              if (this.values[this.curly - 3] === 'function') {
                // Anonymous function, e.g. function(){} /42
                var check = this.values[this.curly - 4];
                regex = check ? !this.beforeFunctionExpression(check) : false;
              } else if (this.values[this.curly - 4] === 'function') {
                // Named function, e.g. function f(){} /42/
                var check = this.values[this.curly - 5];
                regex = check ? !this.beforeFunctionExpression(check) : true;
              }

              break;

            default:
              break;
          }

          return regex;
        };

        Reader.prototype.push = function (token) {
          if (token.type === 7
          /* Punctuator */
          || token.type === 4
          /* Keyword */
          ) {
              if (token.value === '{') {
                this.curly = this.values.length;
              } else if (token.value === '(') {
                this.paren = this.values.length;
              }

              this.values.push(token.value);
            } else {
            this.values.push(null);
          }
        };

        return Reader;
      }();

      var Tokenizer = function () {
        function Tokenizer(code, config) {
          this.errorHandler = new error_handler_1.ErrorHandler();
          this.errorHandler.tolerant = config ? typeof config.tolerant === 'boolean' && config.tolerant : false;
          this.scanner = new scanner_1.Scanner(code, this.errorHandler);
          this.scanner.trackComment = config ? typeof config.comment === 'boolean' && config.comment : false;
          this.trackRange = config ? typeof config.range === 'boolean' && config.range : false;
          this.trackLoc = config ? typeof config.loc === 'boolean' && config.loc : false;
          this.buffer = [];
          this.reader = new Reader();
        }

        Tokenizer.prototype.errors = function () {
          return this.errorHandler.errors;
        };

        Tokenizer.prototype.getNextToken = function () {
          if (this.buffer.length === 0) {
            var comments = this.scanner.scanComments();

            if (this.scanner.trackComment) {
              for (var i = 0; i < comments.length; ++i) {
                var e = comments[i];
                var value = this.scanner.source.slice(e.slice[0], e.slice[1]);
                var comment = {
                  type: e.multiLine ? 'BlockComment' : 'LineComment',
                  value: value
                };

                if (this.trackRange) {
                  comment.range = e.range;
                }

                if (this.trackLoc) {
                  comment.loc = e.loc;
                }

                this.buffer.push(comment);
              }
            }

            if (!this.scanner.eof()) {
              var loc = void 0;

              if (this.trackLoc) {
                loc = {
                  start: {
                    line: this.scanner.lineNumber,
                    column: this.scanner.index - this.scanner.lineStart
                  },
                  end: {}
                };
              }

              var startRegex = this.scanner.source[this.scanner.index] === '/' && this.reader.isRegexStart();
              var token = startRegex ? this.scanner.scanRegExp() : this.scanner.lex();
              this.reader.push(token);
              var entry = {
                type: token_1.TokenName[token.type],
                value: this.scanner.source.slice(token.start, token.end)
              };

              if (this.trackRange) {
                entry.range = [token.start, token.end];
              }

              if (this.trackLoc) {
                loc.end = {
                  line: this.scanner.lineNumber,
                  column: this.scanner.index - this.scanner.lineStart
                };
                entry.loc = loc;
              }

              if (token.type === 9
              /* RegularExpression */
              ) {
                  var pattern = token.pattern;
                  var flags = token.flags;
                  entry.regex = {
                    pattern: pattern,
                    flags: flags
                  };
                }

              this.buffer.push(entry);
            }
          }

          return this.buffer.shift();
        };

        return Tokenizer;
      }();

      exports.Tokenizer = Tokenizer;
      /***/
    }
    /******/
    ])
  );
});

;

/***/ }),
/* 137 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/*eslint-disable no-use-before-define*/

var common = __webpack_require__(20);

var YAMLException = __webpack_require__(24);

var DEFAULT_FULL_SCHEMA = __webpack_require__(32);

var DEFAULT_SAFE_SCHEMA = __webpack_require__(25);

var _toString = Object.prototype.toString;
var _hasOwnProperty = Object.prototype.hasOwnProperty;
var CHAR_TAB = 0x09;
/* Tab */

var CHAR_LINE_FEED = 0x0A;
/* LF */

var CHAR_CARRIAGE_RETURN = 0x0D;
/* CR */

var CHAR_SPACE = 0x20;
/* Space */

var CHAR_EXCLAMATION = 0x21;
/* ! */

var CHAR_DOUBLE_QUOTE = 0x22;
/* " */

var CHAR_SHARP = 0x23;
/* # */

var CHAR_PERCENT = 0x25;
/* % */

var CHAR_AMPERSAND = 0x26;
/* & */

var CHAR_SINGLE_QUOTE = 0x27;
/* ' */

var CHAR_ASTERISK = 0x2A;
/* * */

var CHAR_COMMA = 0x2C;
/* , */

var CHAR_MINUS = 0x2D;
/* - */

var CHAR_COLON = 0x3A;
/* : */

var CHAR_EQUALS = 0x3D;
/* = */

var CHAR_GREATER_THAN = 0x3E;
/* > */

var CHAR_QUESTION = 0x3F;
/* ? */

var CHAR_COMMERCIAL_AT = 0x40;
/* @ */

var CHAR_LEFT_SQUARE_BRACKET = 0x5B;
/* [ */

var CHAR_RIGHT_SQUARE_BRACKET = 0x5D;
/* ] */

var CHAR_GRAVE_ACCENT = 0x60;
/* ` */

var CHAR_LEFT_CURLY_BRACKET = 0x7B;
/* { */

var CHAR_VERTICAL_LINE = 0x7C;
/* | */

var CHAR_RIGHT_CURLY_BRACKET = 0x7D;
/* } */

var ESCAPE_SEQUENCES = {};
ESCAPE_SEQUENCES[0x00] = '\\0';
ESCAPE_SEQUENCES[0x07] = '\\a';
ESCAPE_SEQUENCES[0x08] = '\\b';
ESCAPE_SEQUENCES[0x09] = '\\t';
ESCAPE_SEQUENCES[0x0A] = '\\n';
ESCAPE_SEQUENCES[0x0B] = '\\v';
ESCAPE_SEQUENCES[0x0C] = '\\f';
ESCAPE_SEQUENCES[0x0D] = '\\r';
ESCAPE_SEQUENCES[0x1B] = '\\e';
ESCAPE_SEQUENCES[0x22] = '\\"';
ESCAPE_SEQUENCES[0x5C] = '\\\\';
ESCAPE_SEQUENCES[0x85] = '\\N';
ESCAPE_SEQUENCES[0xA0] = '\\_';
ESCAPE_SEQUENCES[0x2028] = '\\L';
ESCAPE_SEQUENCES[0x2029] = '\\P';
var DEPRECATED_BOOLEANS_SYNTAX = ['y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON', 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'];

function compileStyleMap(schema, map) {
  var result, keys, index, length, tag, style, type;
  if (map === null) return {};
  result = {};
  keys = Object.keys(map);

  for (index = 0, length = keys.length; index < length; index += 1) {
    tag = keys[index];
    style = String(map[tag]);

    if (tag.slice(0, 2) === '!!') {
      tag = 'tag:yaml.org,2002:' + tag.slice(2);
    }

    type = schema.compiledTypeMap['fallback'][tag];

    if (type && _hasOwnProperty.call(type.styleAliases, style)) {
      style = type.styleAliases[style];
    }

    result[tag] = style;
  }

  return result;
}

function encodeHex(character) {
  var string, handle, length;
  string = character.toString(16).toUpperCase();

  if (character <= 0xFF) {
    handle = 'x';
    length = 2;
  } else if (character <= 0xFFFF) {
    handle = 'u';
    length = 4;
  } else if (character <= 0xFFFFFFFF) {
    handle = 'U';
    length = 8;
  } else {
    throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
  }

  return '\\' + handle + common.repeat('0', length - string.length) + string;
}

function State(options) {
  this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
  this.indent = Math.max(1, options['indent'] || 2);
  this.noArrayIndent = options['noArrayIndent'] || false;
  this.skipInvalid = options['skipInvalid'] || false;
  this.flowLevel = common.isNothing(options['flowLevel']) ? -1 : options['flowLevel'];
  this.styleMap = compileStyleMap(this.schema, options['styles'] || null);
  this.sortKeys = options['sortKeys'] || false;
  this.lineWidth = options['lineWidth'] || 80;
  this.noRefs = options['noRefs'] || false;
  this.noCompatMode = options['noCompatMode'] || false;
  this.condenseFlow = options['condenseFlow'] || false;
  this.implicitTypes = this.schema.compiledImplicit;
  this.explicitTypes = this.schema.compiledExplicit;
  this.tag = null;
  this.result = '';
  this.duplicates = [];
  this.usedDuplicates = null;
} // Indents every line in a string. Empty lines (\n only) are not indented.


function indentString(string, spaces) {
  var ind = common.repeat(' ', spaces),
      position = 0,
      next = -1,
      result = '',
      line,
      length = string.length;

  while (position < length) {
    next = string.indexOf('\n', position);

    if (next === -1) {
      line = string.slice(position);
      position = length;
    } else {
      line = string.slice(position, next + 1);
      position = next + 1;
    }

    if (line.length && line !== '\n') result += ind;
    result += line;
  }

  return result;
}

function generateNextLine(state, level) {
  return '\n' + common.repeat(' ', state.indent * level);
}

function testImplicitResolving(state, str) {
  var index, length, type;

  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
    type = state.implicitTypes[index];

    if (type.resolve(str)) {
      return true;
    }
  }

  return false;
} // [33] s-white ::= s-space | s-tab


function isWhitespace(c) {
  return c === CHAR_SPACE || c === CHAR_TAB;
} // Returns true if the character can be printed without escaping.
// From YAML 1.2: "any allowed characters known to be non-printable
// should also be escaped. [However,] This isn’t mandatory"
// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.


function isPrintable(c) {
  return 0x00020 <= c && c <= 0x00007E || 0x000A1 <= c && c <= 0x00D7FF && c !== 0x2028 && c !== 0x2029 || 0x0E000 <= c && c <= 0x00FFFD && c !== 0xFEFF
  /* BOM */
  || 0x10000 <= c && c <= 0x10FFFF;
} // [34] ns-char ::= nb-char - s-white
// [27] nb-char ::= c-printable - b-char - c-byte-order-mark
// [26] b-char  ::= b-line-feed | b-carriage-return
// [24] b-line-feed       ::=     #xA    /* LF */
// [25] b-carriage-return ::=     #xD    /* CR */
// [3]  c-byte-order-mark ::=     #xFEFF


function isNsChar(c) {
  return isPrintable(c) && !isWhitespace(c) // byte-order-mark
  && c !== 0xFEFF // b-char
  && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
} // Simplified test for values allowed after the first character in plain style.


function isPlainSafe(c, prev) {
  // Uses a subset of nb-char - c-flow-indicator - ":" - "#"
  // where nb-char ::= c-printable - b-char - c-byte-order-mark.
  return isPrintable(c) && c !== 0xFEFF // - c-flow-indicator
  && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET // - ":" - "#"
  // /* An ns-char preceding */ "#"
  && c !== CHAR_COLON && (c !== CHAR_SHARP || prev && isNsChar(prev));
} // Simplified test for values allowed as the first character in plain style.


function isPlainSafeFirst(c) {
  // Uses a subset of ns-char - c-indicator
  // where ns-char = nb-char - s-white.
  return isPrintable(c) && c !== 0xFEFF && !isWhitespace(c) // - s-white
  // - (c-indicator ::=
  // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
  && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
  && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE // | “%” | “@” | “`”)
  && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
} // Determines whether block indentation indicator is required.


function needIndentIndicator(string) {
  var leadingSpaceRe = /^\n* /;
  return leadingSpaceRe.test(string);
}

var STYLE_PLAIN = 1,
    STYLE_SINGLE = 2,
    STYLE_LITERAL = 3,
    STYLE_FOLDED = 4,
    STYLE_DOUBLE = 5; // Determines which scalar styles are possible and returns the preferred style.
// lineWidth = -1 => no limit.
// Pre-conditions: str.length > 0.
// Post-conditions:
//    STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).

function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
  var i;
  var char, prev_char;
  var hasLineBreak = false;
  var hasFoldableLine = false; // only checked if shouldTrackWidth

  var shouldTrackWidth = lineWidth !== -1;
  var previousLineBreak = -1; // count the first line correctly

  var plain = isPlainSafeFirst(string.charCodeAt(0)) && !isWhitespace(string.charCodeAt(string.length - 1));

  if (singleLineOnly) {
    // Case: no block styles.
    // Check for disallowed characters to rule out plain and single.
    for (i = 0; i < string.length; i++) {
      char = string.charCodeAt(i);

      if (!isPrintable(char)) {
        return STYLE_DOUBLE;
      }

      prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
      plain = plain && isPlainSafe(char, prev_char);
    }
  } else {
    // Case: block styles permitted.
    for (i = 0; i < string.length; i++) {
      char = string.charCodeAt(i);

      if (char === CHAR_LINE_FEED) {
        hasLineBreak = true; // Check if any line can be folded.

        if (shouldTrackWidth) {
          hasFoldableLine = hasFoldableLine || // Foldable line = too long, and not more-indented.
          i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== ' ';
          previousLineBreak = i;
        }
      } else if (!isPrintable(char)) {
        return STYLE_DOUBLE;
      }

      prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
      plain = plain && isPlainSafe(char, prev_char);
    } // in case the end is missing a \n


    hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== ' ';
  } // Although every style can represent \n without escaping, prefer block styles
  // for multiline, since they're more readable and they don't add empty lines.
  // Also prefer folding a super-long line.


  if (!hasLineBreak && !hasFoldableLine) {
    // Strings interpretable as another type have to be quoted;
    // e.g. the string 'true' vs. the boolean true.
    return plain && !testAmbiguousType(string) ? STYLE_PLAIN : STYLE_SINGLE;
  } // Edge case: block indentation indicator can only have one digit.


  if (indentPerLevel > 9 && needIndentIndicator(string)) {
    return STYLE_DOUBLE;
  } // At this point we know block styles are valid.
  // Prefer literal style unless we want to fold.


  return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
} // Note: line breaking/folding is implemented for only the folded style.
// NB. We drop the last trailing newline (if any) of a returned block scalar
//  since the dumper adds its own newline. This always works:
//    • No ending newline => unaffected; already using strip "-" chomping.
//    • Ending newline    => removed then restored.
//  Importantly, this keeps the "+" chomp indicator from gaining an extra line.


function writeScalar(state, string, level, iskey) {
  state.dump = function () {
    if (string.length === 0) {
      return "''";
    }

    if (!state.noCompatMode && DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
      return "'" + string + "'";
    }

    var indent = state.indent * Math.max(1, level); // no 0-indent scalars
    // As indentation gets deeper, let the width decrease monotonically
    // to the lower bound min(state.lineWidth, 40).
    // Note that this implies
    //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.
    // This behaves better than a constant minimum width which disallows narrower options,
    // or an indent threshold which causes the width to suddenly increase.

    var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); // Without knowing if keys are implicit/explicit, assume implicit for safety.

    var singleLineOnly = iskey // No block styles in flow mode.
    || state.flowLevel > -1 && level >= state.flowLevel;

    function testAmbiguity(string) {
      return testImplicitResolving(state, string);
    }

    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
      case STYLE_PLAIN:
        return string;

      case STYLE_SINGLE:
        return "'" + string.replace(/'/g, "''") + "'";

      case STYLE_LITERAL:
        return '|' + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));

      case STYLE_FOLDED:
        return '>' + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));

      case STYLE_DOUBLE:
        return '"' + escapeString(string, lineWidth) + '"';

      default:
        throw new YAMLException('impossible error: invalid scalar style');
    }
  }();
} // Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.


function blockHeader(string, indentPerLevel) {
  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ''; // note the special case: the string '\n' counts as a "trailing" empty line.

  var clip = string[string.length - 1] === '\n';
  var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
  var chomp = keep ? '+' : clip ? '' : '-';
  return indentIndicator + chomp + '\n';
} // (See the note for writeScalar.)


function dropEndingNewline(string) {
  return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
} // Note: a long line without a suitable break point will exceed the width limit.
// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.


function foldString(string, width) {
  // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
  // unless they're before or after a more-indented line, or at the very
  // beginning or end, in which case $k$ maps to $k$.
  // Therefore, parse each chunk as newline(s) followed by a content line.
  var lineRe = /(\n+)([^\n]*)/g; // first line (possibly an empty line)

  var result = function () {
    var nextLF = string.indexOf('\n');
    nextLF = nextLF !== -1 ? nextLF : string.length;
    lineRe.lastIndex = nextLF;
    return foldLine(string.slice(0, nextLF), width);
  }(); // If we haven't reached the first content line yet, don't add an extra \n.


  var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
  var moreIndented; // rest of the lines

  var match;

  while (match = lineRe.exec(string)) {
    var prefix = match[1],
        line = match[2];
    moreIndented = line[0] === ' ';
    result += prefix + (!prevMoreIndented && !moreIndented && line !== '' ? '\n' : '') + foldLine(line, width);
    prevMoreIndented = moreIndented;
  }

  return result;
} // Greedy line breaking.
// Picks the longest line under the limit each time,
// otherwise settles for the shortest line over the limit.
// NB. More-indented lines *cannot* be folded, as that would add an extra \n.


function foldLine(line, width) {
  if (line === '' || line[0] === ' ') return line; // Since a more-indented line adds a \n, breaks can't be followed by a space.

  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.

  var match; // start is an inclusive index. end, curr, and next are exclusive.

  var start = 0,
      end,
      curr = 0,
      next = 0;
  var result = ''; // Invariants: 0 <= start <= length-1.
  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.
  // Inside the loop:
  //   A match implies length >= 2, so curr and next are <= length-2.

  while (match = breakRe.exec(line)) {
    next = match.index; // maintain invariant: curr - start <= width

    if (next - start > width) {
      end = curr > start ? curr : next; // derive end <= length-2

      result += '\n' + line.slice(start, end); // skip the space that was output as \n

      start = end + 1; // derive start <= length-1
    }

    curr = next;
  } // By the invariants, start <= length-1, so there is something left over.
  // It is either the whole string or a part starting from non-whitespace.


  result += '\n'; // Insert a break if the remainder is too long and there is a break available.

  if (line.length - start > width && curr > start) {
    result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
  } else {
    result += line.slice(start);
  }

  return result.slice(1); // drop extra \n joiner
} // Escapes a double-quoted string.


function escapeString(string) {
  var result = '';
  var char, nextChar;
  var escapeSeq;

  for (var i = 0; i < string.length; i++) {
    char = string.charCodeAt(i); // Check for surrogate pairs (reference Unicode 3.0 section "3.7 Surrogates").

    if (char >= 0xD800 && char <= 0xDBFF
    /* high surrogate */
    ) {
        nextChar = string.charCodeAt(i + 1);

        if (nextChar >= 0xDC00 && nextChar <= 0xDFFF
        /* low surrogate */
        ) {
            // Combine the surrogate pair and store it escaped.
            result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000); // Advance index one extra since we already used that char here.

            i++;
            continue;
          }
      }

    escapeSeq = ESCAPE_SEQUENCES[char];
    result += !escapeSeq && isPrintable(char) ? string[i] : escapeSeq || encodeHex(char);
  }

  return result;
}

function writeFlowSequence(state, level, object) {
  var _result = '',
      _tag = state.tag,
      index,
      length;

  for (index = 0, length = object.length; index < length; index += 1) {
    // Write only valid elements.
    if (writeNode(state, level, object[index], false, false)) {
      if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');
      _result += state.dump;
    }
  }

  state.tag = _tag;
  state.dump = '[' + _result + ']';
}

function writeBlockSequence(state, level, object, compact) {
  var _result = '',
      _tag = state.tag,
      index,
      length;

  for (index = 0, length = object.length; index < length; index += 1) {
    // Write only valid elements.
    if (writeNode(state, level + 1, object[index], true, true)) {
      if (!compact || index !== 0) {
        _result += generateNextLine(state, level);
      }

      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
        _result += '-';
      } else {
        _result += '- ';
      }

      _result += state.dump;
    }
  }

  state.tag = _tag;
  state.dump = _result || '[]'; // Empty sequence if no valid values.
}

function writeFlowMapping(state, level, object) {
  var _result = '',
      _tag = state.tag,
      objectKeyList = Object.keys(object),
      index,
      length,
      objectKey,
      objectValue,
      pairBuffer;

  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
    pairBuffer = '';
    if (index !== 0) pairBuffer += ', ';
    if (state.condenseFlow) pairBuffer += '"';
    objectKey = objectKeyList[index];
    objectValue = object[objectKey];

    if (!writeNode(state, level, objectKey, false, false)) {
      continue; // Skip this pair because of invalid key;
    }

    if (state.dump.length > 1024) pairBuffer += '? ';
    pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');

    if (!writeNode(state, level, objectValue, false, false)) {
      continue; // Skip this pair because of invalid value.
    }

    pairBuffer += state.dump; // Both key and value are valid.

    _result += pairBuffer;
  }

  state.tag = _tag;
  state.dump = '{' + _result + '}';
}

function writeBlockMapping(state, level, object, compact) {
  var _result = '',
      _tag = state.tag,
      objectKeyList = Object.keys(object),
      index,
      length,
      objectKey,
      objectValue,
      explicitPair,
      pairBuffer; // Allow sorting keys so that the output file is deterministic

  if (state.sortKeys === true) {
    // Default sorting
    objectKeyList.sort();
  } else if (typeof state.sortKeys === 'function') {
    // Custom sort function
    objectKeyList.sort(state.sortKeys);
  } else if (state.sortKeys) {
    // Something is wrong
    throw new YAMLException('sortKeys must be a boolean or a function');
  }

  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
    pairBuffer = '';

    if (!compact || index !== 0) {
      pairBuffer += generateNextLine(state, level);
    }

    objectKey = objectKeyList[index];
    objectValue = object[objectKey];

    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
      continue; // Skip this pair because of invalid key.
    }

    explicitPair = state.tag !== null && state.tag !== '?' || state.dump && state.dump.length > 1024;

    if (explicitPair) {
      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
        pairBuffer += '?';
      } else {
        pairBuffer += '? ';
      }
    }

    pairBuffer += state.dump;

    if (explicitPair) {
      pairBuffer += generateNextLine(state, level);
    }

    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
      continue; // Skip this pair because of invalid value.
    }

    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
      pairBuffer += ':';
    } else {
      pairBuffer += ': ';
    }

    pairBuffer += state.dump; // Both key and value are valid.

    _result += pairBuffer;
  }

  state.tag = _tag;
  state.dump = _result || '{}'; // Empty mapping if no valid pairs.
}

function detectType(state, object, explicit) {
  var _result, typeList, index, length, type, style;

  typeList = explicit ? state.explicitTypes : state.implicitTypes;

  for (index = 0, length = typeList.length; index < length; index += 1) {
    type = typeList[index];

    if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === 'object' && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
      state.tag = explicit ? type.tag : '?';

      if (type.represent) {
        style = state.styleMap[type.tag] || type.defaultStyle;

        if (_toString.call(type.represent) === '[object Function]') {
          _result = type.represent(object, style);
        } else if (_hasOwnProperty.call(type.represent, style)) {
          _result = type.represent[style](object, style);
        } else {
          throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
        }

        state.dump = _result;
      }

      return true;
    }
  }

  return false;
} // Serializes `object` and writes it to global `result`.
// Returns true on success, or false on invalid object.
//


function writeNode(state, level, object, block, compact, iskey) {
  state.tag = null;
  state.dump = object;

  if (!detectType(state, object, false)) {
    detectType(state, object, true);
  }

  var type = _toString.call(state.dump);

  if (block) {
    block = state.flowLevel < 0 || state.flowLevel > level;
  }

  var objectOrArray = type === '[object Object]' || type === '[object Array]',
      duplicateIndex,
      duplicate;

  if (objectOrArray) {
    duplicateIndex = state.duplicates.indexOf(object);
    duplicate = duplicateIndex !== -1;
  }

  if (state.tag !== null && state.tag !== '?' || duplicate || state.indent !== 2 && level > 0) {
    compact = false;
  }

  if (duplicate && state.usedDuplicates[duplicateIndex]) {
    state.dump = '*ref_' + duplicateIndex;
  } else {
    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
      state.usedDuplicates[duplicateIndex] = true;
    }

    if (type === '[object Object]') {
      if (block && Object.keys(state.dump).length !== 0) {
        writeBlockMapping(state, level, state.dump, compact);

        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + state.dump;
        }
      } else {
        writeFlowMapping(state, level, state.dump);

        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
        }
      }
    } else if (type === '[object Array]') {
      var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level;

      if (block && state.dump.length !== 0) {
        writeBlockSequence(state, arrayLevel, state.dump, compact);

        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + state.dump;
        }
      } else {
        writeFlowSequence(state, arrayLevel, state.dump);

        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
        }
      }
    } else if (type === '[object String]') {
      if (state.tag !== '?') {
        writeScalar(state, state.dump, level, iskey);
      }
    } else {
      if (state.skipInvalid) return false;
      throw new YAMLException('unacceptable kind of an object to dump ' + type);
    }

    if (state.tag !== null && state.tag !== '?') {
      state.dump = '!<' + state.tag + '> ' + state.dump;
    }
  }

  return true;
}

function getDuplicateReferences(object, state) {
  var objects = [],
      duplicatesIndexes = [],
      index,
      length;
  inspectNode(object, objects, duplicatesIndexes);

  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
    state.duplicates.push(objects[duplicatesIndexes[index]]);
  }

  state.usedDuplicates = new Array(length);
}

function inspectNode(object, objects, duplicatesIndexes) {
  var objectKeyList, index, length;

  if (object !== null && typeof object === 'object') {
    index = objects.indexOf(object);

    if (index !== -1) {
      if (duplicatesIndexes.indexOf(index) === -1) {
        duplicatesIndexes.push(index);
      }
    } else {
      objects.push(object);

      if (Array.isArray(object)) {
        for (index = 0, length = object.length; index < length; index += 1) {
          inspectNode(object[index], objects, duplicatesIndexes);
        }
      } else {
        objectKeyList = Object.keys(object);

        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
        }
      }
    }
  }
}

function dump(input, options) {
  options = options || {};
  var state = new State(options);
  if (!state.noRefs) getDuplicateReferences(input, state);
  if (writeNode(state, 0, input, true, true)) return state.dump + '\n';
  return '';
}

function safeDump(input, options) {
  return dump(input, common.extend({
    schema: DEFAULT_SAFE_SCHEMA
  }, options));
}

module.exports.dump = dump;
module.exports.safeDump = safeDump;

/***/ }),
/* 138 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/*!
 * strip-bom-string <https://github.com/jonschlinkert/strip-bom-string>
 *
 * Copyright (c) 2015, 2017, Jon Schlinkert.
 * Released under the MIT License.
 */


module.exports = function (str) {
  if (typeof str === 'string' && str.charAt(0) === '\ufeff') {
    return str.slice(1);
  }

  return str;
};

/***/ }),
/* 139 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


const defaults = __webpack_require__(31);

module.exports = function (file, options) {
  const opts = defaults(options);

  if (file.data == null) {
    file.data = {};
  }

  if (typeof opts.excerpt === 'function') {
    return opts.excerpt(file, opts);
  }

  const sep = file.data.excerpt_separator || opts.excerpt_separator;

  if (sep == null && (opts.excerpt === false || opts.excerpt == null)) {
    return file;
  }

  const delimiter = typeof opts.excerpt === 'string' ? opts.excerpt : sep || opts.delimiters[0]; // if enabled, get the excerpt defined after front-matter

  const idx = file.content.indexOf(delimiter);

  if (idx !== -1) {
    file.excerpt = file.content.slice(0, idx);
  }

  return file;
};

/***/ }),
/* 140 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


const typeOf = __webpack_require__(30);

const stringify = __webpack_require__(60);

const utils = __webpack_require__(38);
/**
 * Normalize the given value to ensure an object is returned
 * with the expected properties.
 */


module.exports = function (file) {
  if (typeOf(file) !== 'object') {
    file = {
      content: file
    };
  }

  if (typeOf(file.data) !== 'object') {
    file.data = {};
  } // if file was passed as an object, ensure that
  // "file.content" is set


  if (file.contents && file.content == null) {
    file.content = file.contents;
  } // set non-enumerable properties on the file object


  utils.define(file, 'orig', utils.toBuffer(file.content));
  utils.define(file, 'language', file.language || '');
  utils.define(file, 'matter', file.matter || '');
  utils.define(file, 'stringify', function (data, options) {
    if (options && options.language) {
      file.language = options.language;
    }

    return stringify(file, data, options);
  }); // strip BOM and ensure that "file.content" is a string

  file.content = utils.toString(file.content);
  file.isEmpty = false;
  file.excerpt = '';
  return file;
};

/***/ }),
/* 141 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


const getEngine = __webpack_require__(61);

const defaults = __webpack_require__(31);

module.exports = function (language, str, options) {
  const opts = defaults(options);
  const engine = getEngine(language, opts);

  if (typeof engine.parse !== 'function') {
    throw new TypeError('expected "' + language + '.parse" to be a function');
  }

  return engine.parse(str, opts);
};

/***/ }),
/* 142 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = __webpack_require__(143);

/***/ }),
/* 143 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Main parser class


var utils = __webpack_require__(1);

var helpers = __webpack_require__(150);

var Renderer = __webpack_require__(154);

var ParserCore = __webpack_require__(155);

var ParserBlock = __webpack_require__(163);

var ParserInline = __webpack_require__(177);

var LinkifyIt = __webpack_require__(190);

var mdurl = __webpack_require__(63);

var punycode = __webpack_require__(192);

var config = {
  'default': __webpack_require__(194),
  zero: __webpack_require__(195),
  commonmark: __webpack_require__(196)
}; ////////////////////////////////////////////////////////////////////////////////
//
// This validator can prohibit more than really needed to prevent XSS. It's a
// tradeoff to keep code simple and to be secure by default.
//
// If you need different setup - override validator method as you wish. Or
// replace it with dummy function and use external sanitizer.
//

var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;

function validateLink(url) {
  // url should be normalized at this point, and existing entities are decoded
  var str = url.trim().toLowerCase();
  return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) ? true : false : true;
} ////////////////////////////////////////////////////////////////////////////////


var RECODE_HOSTNAME_FOR = ['http:', 'https:', 'mailto:'];

function normalizeLink(url) {
  var parsed = mdurl.parse(url, true);

  if (parsed.hostname) {
    // Encode hostnames in urls like:
    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
    //
    // We don't encode unknown schemas, because it's likely that we encode
    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)
    //
    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
      try {
        parsed.hostname = punycode.toASCII(parsed.hostname);
      } catch (er) {
        /**/
      }
    }
  }

  return mdurl.encode(mdurl.format(parsed));
}

function normalizeLinkText(url) {
  var parsed = mdurl.parse(url, true);

  if (parsed.hostname) {
    // Encode hostnames in urls like:
    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
    //
    // We don't encode unknown schemas, because it's likely that we encode
    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)
    //
    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
      try {
        parsed.hostname = punycode.toUnicode(parsed.hostname);
      } catch (er) {
        /**/
      }
    }
  }

  return mdurl.decode(mdurl.format(parsed));
}
/**
 * class MarkdownIt
 *
 * Main parser/renderer class.
 *
 * ##### Usage
 *
 * ```javascript
 * // node.js, "classic" way:
 * var MarkdownIt = require('markdown-it'),
 *     md = new MarkdownIt();
 * var result = md.render('# markdown-it rulezz!');
 *
 * // node.js, the same, but with sugar:
 * var md = require('markdown-it')();
 * var result = md.render('# markdown-it rulezz!');
 *
 * // browser without AMD, added to "window" on script load
 * // Note, there are no dash.
 * var md = window.markdownit();
 * var result = md.render('# markdown-it rulezz!');
 * ```
 *
 * Single line rendering, without paragraph wrap:
 *
 * ```javascript
 * var md = require('markdown-it')();
 * var result = md.renderInline('__markdown-it__ rulezz!');
 * ```
 **/

/**
 * new MarkdownIt([presetName, options])
 * - presetName (String): optional, `commonmark` / `zero`
 * - options (Object)
 *
 * Creates parser instanse with given config. Can be called without `new`.
 *
 * ##### presetName
 *
 * MarkdownIt provides named presets as a convenience to quickly
 * enable/disable active syntax rules and options for common use cases.
 *
 * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -
 *   configures parser to strict [CommonMark](http://commonmark.org/) mode.
 * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -
 *   similar to GFM, used when no preset name given. Enables all available rules,
 *   but still without html, typographer & autolinker.
 * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -
 *   all rules disabled. Useful to quickly setup your config via `.enable()`.
 *   For example, when you need only `bold` and `italic` markup and nothing else.
 *
 * ##### options:
 *
 * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!
 *   That's not safe! You may need external sanitizer to protect output from XSS.
 *   It's better to extend features via plugins, instead of enabling HTML.
 * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags
 *   (`<br />`). This is needed only for full CommonMark compatibility. In real
 *   world you will need HTML output.
 * - __breaks__ - `false`. Set `true` to convert `\n` in paragraphs into `<br>`.
 * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.
 *   Can be useful for external highlighters.
 * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.
 * - __typographer__  - `false`. Set `true` to enable [some language-neutral
 *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +
 *   quotes beautification (smartquotes).
 * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement
 *   pairs, when typographer enabled and smartquotes on. For example, you can
 *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and
 *   `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
 * - __highlight__ - `null`. Highlighter function for fenced code blocks.
 *   Highlighter `function (str, lang)` should return escaped HTML. It can also
 *   return empty string if the source was not changed and should be escaped
 *   externaly. If result starts with <pre... internal wrapper is skipped.
 *
 * ##### Example
 *
 * ```javascript
 * // commonmark mode
 * var md = require('markdown-it')('commonmark');
 *
 * // default mode
 * var md = require('markdown-it')();
 *
 * // enable everything
 * var md = require('markdown-it')({
 *   html: true,
 *   linkify: true,
 *   typographer: true
 * });
 * ```
 *
 * ##### Syntax highlighting
 *
 * ```js
 * var hljs = require('highlight.js') // https://highlightjs.org/
 *
 * var md = require('markdown-it')({
 *   highlight: function (str, lang) {
 *     if (lang && hljs.getLanguage(lang)) {
 *       try {
 *         return hljs.highlight(lang, str, true).value;
 *       } catch (__) {}
 *     }
 *
 *     return ''; // use external default escaping
 *   }
 * });
 * ```
 *
 * Or with full wrapper override (if you need assign class to `<pre>`):
 *
 * ```javascript
 * var hljs = require('highlight.js') // https://highlightjs.org/
 *
 * // Actual default values
 * var md = require('markdown-it')({
 *   highlight: function (str, lang) {
 *     if (lang && hljs.getLanguage(lang)) {
 *       try {
 *         return '<pre class="hljs"><code>' +
 *                hljs.highlight(lang, str, true).value +
 *                '</code></pre>';
 *       } catch (__) {}
 *     }
 *
 *     return '<pre class="hljs"><code>' + md.utils.escapeHtml(str) + '</code></pre>';
 *   }
 * });
 * ```
 *
 **/


function MarkdownIt(presetName, options) {
  if (!(this instanceof MarkdownIt)) {
    return new MarkdownIt(presetName, options);
  }

  if (!options) {
    if (!utils.isString(presetName)) {
      options = presetName || {};
      presetName = 'default';
    }
  }
  /**
   * MarkdownIt#inline -> ParserInline
   *
   * Instance of [[ParserInline]]. You may need it to add new rules when
   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
   * [[MarkdownIt.enable]].
   **/


  this.inline = new ParserInline();
  /**
   * MarkdownIt#block -> ParserBlock
   *
   * Instance of [[ParserBlock]]. You may need it to add new rules when
   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
   * [[MarkdownIt.enable]].
   **/

  this.block = new ParserBlock();
  /**
   * MarkdownIt#core -> Core
   *
   * Instance of [[Core]] chain executor. You may need it to add new rules when
   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
   * [[MarkdownIt.enable]].
   **/

  this.core = new ParserCore();
  /**
   * MarkdownIt#renderer -> Renderer
   *
   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering
   * rules for new token types, generated by plugins.
   *
   * ##### Example
   *
   * ```javascript
   * var md = require('markdown-it')();
   *
   * function myToken(tokens, idx, options, env, self) {
   *   //...
   *   return result;
   * };
   *
   * md.renderer.rules['my_token'] = myToken
   * ```
   *
   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).
   **/

  this.renderer = new Renderer();
  /**
   * MarkdownIt#linkify -> LinkifyIt
   *
   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)
   * rule.
   **/

  this.linkify = new LinkifyIt();
  /**
   * MarkdownIt#validateLink(url) -> Boolean
   *
   * Link validation function. CommonMark allows too much in links. By default
   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
   * except some embedded image types.
   *
   * You can change this behaviour:
   *
   * ```javascript
   * var md = require('markdown-it')();
   * // enable everything
   * md.validateLink = function () { return true; }
   * ```
   **/

  this.validateLink = validateLink;
  /**
   * MarkdownIt#normalizeLink(url) -> String
   *
   * Function used to encode link url to a machine-readable format,
   * which includes url-encoding, punycode, etc.
   **/

  this.normalizeLink = normalizeLink;
  /**
   * MarkdownIt#normalizeLinkText(url) -> String
   *
   * Function used to decode link url to a human-readable format`
   **/

  this.normalizeLinkText = normalizeLinkText; // Expose utils & helpers for easy acces from plugins

  /**
   * MarkdownIt#utils -> utils
   *
   * Assorted utility functions, useful to write plugins. See details
   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js).
   **/

  this.utils = utils;
  /**
   * MarkdownIt#helpers -> helpers
   *
   * Link components parser functions, useful to write plugins. See details
   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).
   **/

  this.helpers = utils.assign({}, helpers);
  this.options = {};
  this.configure(presetName);

  if (options) {
    this.set(options);
  }
}
/** chainable
 * MarkdownIt.set(options)
 *
 * Set parser options (in the same format as in constructor). Probably, you
 * will never need it, but you can change options after constructor call.
 *
 * ##### Example
 *
 * ```javascript
 * var md = require('markdown-it')()
 *             .set({ html: true, breaks: true })
 *             .set({ typographer, true });
 * ```
 *
 * __Note:__ To achieve the best possible performance, don't modify a
 * `markdown-it` instance options on the fly. If you need multiple configurations
 * it's best to create multiple instances and initialize each with separate
 * config.
 **/


MarkdownIt.prototype.set = function (options) {
  utils.assign(this.options, options);
  return this;
};
/** chainable, internal
 * MarkdownIt.configure(presets)
 *
 * Batch load of all options and compenent settings. This is internal method,
 * and you probably will not need it. But if you with - see available presets
 * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
 *
 * We strongly recommend to use presets instead of direct config loads. That
 * will give better compatibility with next versions.
 **/


MarkdownIt.prototype.configure = function (presets) {
  var self = this,
      presetName;

  if (utils.isString(presets)) {
    presetName = presets;
    presets = config[presetName];

    if (!presets) {
      throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name');
    }
  }

  if (!presets) {
    throw new Error('Wrong `markdown-it` preset, can\'t be empty');
  }

  if (presets.options) {
    self.set(presets.options);
  }

  if (presets.components) {
    Object.keys(presets.components).forEach(function (name) {
      if (presets.components[name].rules) {
        self[name].ruler.enableOnly(presets.components[name].rules);
      }

      if (presets.components[name].rules2) {
        self[name].ruler2.enableOnly(presets.components[name].rules2);
      }
    });
  }

  return this;
};
/** chainable
 * MarkdownIt.enable(list, ignoreInvalid)
 * - list (String|Array): rule name or list of rule names to enable
 * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
 *
 * Enable list or rules. It will automatically find appropriate components,
 * containing rules with given names. If rule not found, and `ignoreInvalid`
 * not set - throws exception.
 *
 * ##### Example
 *
 * ```javascript
 * var md = require('markdown-it')()
 *             .enable(['sub', 'sup'])
 *             .disable('smartquotes');
 * ```
 **/


MarkdownIt.prototype.enable = function (list, ignoreInvalid) {
  var result = [];

  if (!Array.isArray(list)) {
    list = [list];
  }

  ['core', 'block', 'inline'].forEach(function (chain) {
    result = result.concat(this[chain].ruler.enable(list, true));
  }, this);
  result = result.concat(this.inline.ruler2.enable(list, true));
  var missed = list.filter(function (name) {
    return result.indexOf(name) < 0;
  });

  if (missed.length && !ignoreInvalid) {
    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed);
  }

  return this;
};
/** chainable
 * MarkdownIt.disable(list, ignoreInvalid)
 * - list (String|Array): rule name or list of rule names to disable.
 * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
 *
 * The same as [[MarkdownIt.enable]], but turn specified rules off.
 **/


MarkdownIt.prototype.disable = function (list, ignoreInvalid) {
  var result = [];

  if (!Array.isArray(list)) {
    list = [list];
  }

  ['core', 'block', 'inline'].forEach(function (chain) {
    result = result.concat(this[chain].ruler.disable(list, true));
  }, this);
  result = result.concat(this.inline.ruler2.disable(list, true));
  var missed = list.filter(function (name) {
    return result.indexOf(name) < 0;
  });

  if (missed.length && !ignoreInvalid) {
    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed);
  }

  return this;
};
/** chainable
 * MarkdownIt.use(plugin, params)
 *
 * Load specified plugin with given params into current parser instance.
 * It's just a sugar to call `plugin(md, params)` with curring.
 *
 * ##### Example
 *
 * ```javascript
 * var iterator = require('markdown-it-for-inline');
 * var md = require('markdown-it')()
 *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
 *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
 *             });
 * ```
 **/


MarkdownIt.prototype.use = function (plugin
/*, params, ... */
) {
  var args = [this].concat(Array.prototype.slice.call(arguments, 1));
  plugin.apply(plugin, args);
  return this;
};
/** internal
 * MarkdownIt.parse(src, env) -> Array
 * - src (String): source string
 * - env (Object): environment sandbox
 *
 * Parse input string and returns list of block tokens (special token type
 * "inline" will contain list of inline tokens). You should not call this
 * method directly, until you write custom renderer (for example, to produce
 * AST).
 *
 * `env` is used to pass data between "distributed" rules and return additional
 * metadata like reference info, needed for the renderer. It also can be used to
 * inject data in specific cases. Usually, you will be ok to pass `{}`,
 * and then pass updated object to renderer.
 **/


MarkdownIt.prototype.parse = function (src, env) {
  if (typeof src !== 'string') {
    throw new Error('Input data should be a String');
  }

  var state = new this.core.State(src, this, env);
  this.core.process(state);
  return state.tokens;
};
/**
 * MarkdownIt.render(src [, env]) -> String
 * - src (String): source string
 * - env (Object): environment sandbox
 *
 * Render markdown string into html. It does all magic for you :).
 *
 * `env` can be used to inject additional metadata (`{}` by default).
 * But you will not need it with high probability. See also comment
 * in [[MarkdownIt.parse]].
 **/


MarkdownIt.prototype.render = function (src, env) {
  env = env || {};
  return this.renderer.render(this.parse(src, env), this.options, env);
};
/** internal
 * MarkdownIt.parseInline(src, env) -> Array
 * - src (String): source string
 * - env (Object): environment sandbox
 *
 * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the
 * block tokens list with the single `inline` element, containing parsed inline
 * tokens in `children` property. Also updates `env` object.
 **/


MarkdownIt.prototype.parseInline = function (src, env) {
  var state = new this.core.State(src, this, env);
  state.inlineMode = true;
  this.core.process(state);
  return state.tokens;
};
/**
 * MarkdownIt.renderInline(src [, env]) -> String
 * - src (String): source string
 * - env (Object): environment sandbox
 *
 * Similar to [[MarkdownIt.render]] but for single paragraph content. Result
 * will NOT be wrapped into `<p>` tags.
 **/


MarkdownIt.prototype.renderInline = function (src, env) {
  env = env || {};
  return this.renderer.render(this.parseInline(src, env), this.options, env);
};

module.exports = MarkdownIt;

/***/ }),
/* 144 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var encodeCache = {}; // Create a lookup array where anything but characters in `chars` string
// and alphanumeric chars is percent-encoded.
//

function getEncodeCache(exclude) {
  var i,
      ch,
      cache = encodeCache[exclude];

  if (cache) {
    return cache;
  }

  cache = encodeCache[exclude] = [];

  for (i = 0; i < 128; i++) {
    ch = String.fromCharCode(i);

    if (/^[0-9a-z]$/i.test(ch)) {
      // always allow unencoded alphanumeric characters
      cache.push(ch);
    } else {
      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));
    }
  }

  for (i = 0; i < exclude.length; i++) {
    cache[exclude.charCodeAt(i)] = exclude[i];
  }

  return cache;
} // Encode unsafe characters with percent-encoding, skipping already
// encoded sequences.
//
//  - string       - string to encode
//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)
//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)
//


function encode(string, exclude, keepEscaped) {
  var i,
      l,
      code,
      nextCode,
      cache,
      result = '';

  if (typeof exclude !== 'string') {
    // encode(string, keepEscaped)
    keepEscaped = exclude;
    exclude = encode.defaultChars;
  }

  if (typeof keepEscaped === 'undefined') {
    keepEscaped = true;
  }

  cache = getEncodeCache(exclude);

  for (i = 0, l = string.length; i < l; i++) {
    code = string.charCodeAt(i);

    if (keepEscaped && code === 0x25
    /* % */
    && i + 2 < l) {
      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
        result += string.slice(i, i + 3);
        i += 2;
        continue;
      }
    }

    if (code < 128) {
      result += cache[code];
      continue;
    }

    if (code >= 0xD800 && code <= 0xDFFF) {
      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {
        nextCode = string.charCodeAt(i + 1);

        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {
          result += encodeURIComponent(string[i] + string[i + 1]);
          i++;
          continue;
        }
      }

      result += '%EF%BF%BD';
      continue;
    }

    result += encodeURIComponent(string[i]);
  }

  return result;
}

encode.defaultChars = ";/?:@&=+$,-_.!~*'()#";
encode.componentChars = "-_.!~*'()";
module.exports = encode;

/***/ }),
/* 145 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/* eslint-disable no-bitwise */

var decodeCache = {};

function getDecodeCache(exclude) {
  var i,
      ch,
      cache = decodeCache[exclude];

  if (cache) {
    return cache;
  }

  cache = decodeCache[exclude] = [];

  for (i = 0; i < 128; i++) {
    ch = String.fromCharCode(i);
    cache.push(ch);
  }

  for (i = 0; i < exclude.length; i++) {
    ch = exclude.charCodeAt(i);
    cache[ch] = '%' + ('0' + ch.toString(16).toUpperCase()).slice(-2);
  }

  return cache;
} // Decode percent-encoded string.
//


function decode(string, exclude) {
  var cache;

  if (typeof exclude !== 'string') {
    exclude = decode.defaultChars;
  }

  cache = getDecodeCache(exclude);
  return string.replace(/(%[a-f0-9]{2})+/gi, function (seq) {
    var i,
        l,
        b1,
        b2,
        b3,
        b4,
        chr,
        result = '';

    for (i = 0, l = seq.length; i < l; i += 3) {
      b1 = parseInt(seq.slice(i + 1, i + 3), 16);

      if (b1 < 0x80) {
        result += cache[b1];
        continue;
      }

      if ((b1 & 0xE0) === 0xC0 && i + 3 < l) {
        // 110xxxxx 10xxxxxx
        b2 = parseInt(seq.slice(i + 4, i + 6), 16);

        if ((b2 & 0xC0) === 0x80) {
          chr = b1 << 6 & 0x7C0 | b2 & 0x3F;

          if (chr < 0x80) {
            result += '\ufffd\ufffd';
          } else {
            result += String.fromCharCode(chr);
          }

          i += 3;
          continue;
        }
      }

      if ((b1 & 0xF0) === 0xE0 && i + 6 < l) {
        // 1110xxxx 10xxxxxx 10xxxxxx
        b2 = parseInt(seq.slice(i + 4, i + 6), 16);
        b3 = parseInt(seq.slice(i + 7, i + 9), 16);

        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {
          chr = b1 << 12 & 0xF000 | b2 << 6 & 0xFC0 | b3 & 0x3F;

          if (chr < 0x800 || chr >= 0xD800 && chr <= 0xDFFF) {
            result += '\ufffd\ufffd\ufffd';
          } else {
            result += String.fromCharCode(chr);
          }

          i += 6;
          continue;
        }
      }

      if ((b1 & 0xF8) === 0xF0 && i + 9 < l) {
        // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx
        b2 = parseInt(seq.slice(i + 4, i + 6), 16);
        b3 = parseInt(seq.slice(i + 7, i + 9), 16);
        b4 = parseInt(seq.slice(i + 10, i + 12), 16);

        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80 && (b4 & 0xC0) === 0x80) {
          chr = b1 << 18 & 0x1C0000 | b2 << 12 & 0x3F000 | b3 << 6 & 0xFC0 | b4 & 0x3F;

          if (chr < 0x10000 || chr > 0x10FFFF) {
            result += '\ufffd\ufffd\ufffd\ufffd';
          } else {
            chr -= 0x10000;
            result += String.fromCharCode(0xD800 + (chr >> 10), 0xDC00 + (chr & 0x3FF));
          }

          i += 9;
          continue;
        }
      }

      result += '\ufffd';
    }

    return result;
  });
}

decode.defaultChars = ';/?:@&=+$,#';
decode.componentChars = '';
module.exports = decode;

/***/ }),
/* 146 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = function format(url) {
  var result = '';
  result += url.protocol || '';
  result += url.slashes ? '//' : '';
  result += url.auth ? url.auth + '@' : '';

  if (url.hostname && url.hostname.indexOf(':') !== -1) {
    // ipv6 address
    result += '[' + url.hostname + ']';
  } else {
    result += url.hostname || '';
  }

  result += url.port ? ':' + url.port : '';
  result += url.pathname || '';
  result += url.search || '';
  result += url.hash || '';
  return result;
};

/***/ }),
/* 147 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
// Changes from joyent/node:
//
// 1. No leading slash in paths,
//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`
//
// 2. Backslashes are not replaced with slashes,
//    so `http:\\example.org\` is treated like a relative path
//
// 3. Trailing colon is treated like a part of the path,
//    i.e. in `http://example.org:foo` pathname is `:foo`
//
// 4. Nothing is URL-encoded in the resulting object,
//    (in joyent/node some chars in auth and paths are encoded)
//
// 5. `url.parse()` does not have `parseQueryString` argument
//
// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,
//    which can be constructed using other parts of the url.
//

function Url() {
  this.protocol = null;
  this.slashes = null;
  this.auth = null;
  this.port = null;
  this.hostname = null;
  this.hash = null;
  this.search = null;
  this.pathname = null;
} // Reference: RFC 3986, RFC 1808, RFC 2396
// define these here so at least they only have to be
// compiled once on the first module load.


var protocolPattern = /^([a-z0-9.+-]+:)/i,
    portPattern = /:[0-9]*$/,
    // Special case for a simple path URL
simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
    // RFC 2396: characters reserved for delimiting URLs.
// We actually just auto-escape these.
delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
    // RFC 2396: characters not allowed for various reasons.
unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
autoEscape = ['\''].concat(unwise),
    // Characters that are never ever allowed in a hostname.
// Note that any invalid chars are also handled, but these
// are the ones that are *expected* to be seen, so we fast-path
// them.
nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
    hostEndingChars = ['/', '?', '#'],
    hostnameMaxLen = 255,
    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
    // protocols that can allow "unsafe" and "unwise" chars.

/* eslint-disable no-script-url */
// protocols that never have a hostname.
hostlessProtocol = {
  'javascript': true,
  'javascript:': true
},
    // protocols that always contain a // bit.
slashedProtocol = {
  'http': true,
  'https': true,
  'ftp': true,
  'gopher': true,
  'file': true,
  'http:': true,
  'https:': true,
  'ftp:': true,
  'gopher:': true,
  'file:': true
};
/* eslint-enable no-script-url */

function urlParse(url, slashesDenoteHost) {
  if (url && url instanceof Url) {
    return url;
  }

  var u = new Url();
  u.parse(url, slashesDenoteHost);
  return u;
}

Url.prototype.parse = function (url, slashesDenoteHost) {
  var i,
      l,
      lowerProto,
      hec,
      slashes,
      rest = url; // trim before proceeding.
  // This is to support parse stuff like "  http://foo.com  \n"

  rest = rest.trim();

  if (!slashesDenoteHost && url.split('#').length === 1) {
    // Try fast path regexp
    var simplePath = simplePathPattern.exec(rest);

    if (simplePath) {
      this.pathname = simplePath[1];

      if (simplePath[2]) {
        this.search = simplePath[2];
      }

      return this;
    }
  }

  var proto = protocolPattern.exec(rest);

  if (proto) {
    proto = proto[0];
    lowerProto = proto.toLowerCase();
    this.protocol = proto;
    rest = rest.substr(proto.length);
  } // figure out if it's got a host
  // user@server is *always* interpreted as a hostname, and url
  // resolution will treat //foo/bar as host=foo,path=bar because that's
  // how the browser resolves relative URLs.


  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
    slashes = rest.substr(0, 2) === '//';

    if (slashes && !(proto && hostlessProtocol[proto])) {
      rest = rest.substr(2);
      this.slashes = true;
    }
  }

  if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
    // there's a hostname.
    // the first instance of /, ?, ;, or # ends the host.
    //
    // If there is an @ in the hostname, then non-host chars *are* allowed
    // to the left of the last @ sign, unless some host-ending character
    // comes *before* the @-sign.
    // URLs are obnoxious.
    //
    // ex:
    // http://a@b@c/ => user:a@b host:c
    // http://a@b?@c => user:a host:c path:/?@c
    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
    // Review our test case against browsers more comprehensively.
    // find the first instance of any hostEndingChars
    var hostEnd = -1;

    for (i = 0; i < hostEndingChars.length; i++) {
      hec = rest.indexOf(hostEndingChars[i]);

      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
        hostEnd = hec;
      }
    } // at this point, either we have an explicit point where the
    // auth portion cannot go past, or the last @ char is the decider.


    var auth, atSign;

    if (hostEnd === -1) {
      // atSign can be anywhere.
      atSign = rest.lastIndexOf('@');
    } else {
      // atSign must be in auth portion.
      // http://a@b/c@d => host:b auth:a path:/c@d
      atSign = rest.lastIndexOf('@', hostEnd);
    } // Now we have a portion which is definitely the auth.
    // Pull that off.


    if (atSign !== -1) {
      auth = rest.slice(0, atSign);
      rest = rest.slice(atSign + 1);
      this.auth = auth;
    } // the host is the remaining to the left of the first non-host char


    hostEnd = -1;

    for (i = 0; i < nonHostChars.length; i++) {
      hec = rest.indexOf(nonHostChars[i]);

      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
        hostEnd = hec;
      }
    } // if we still have not hit it, then the entire thing is a host.


    if (hostEnd === -1) {
      hostEnd = rest.length;
    }

    if (rest[hostEnd - 1] === ':') {
      hostEnd--;
    }

    var host = rest.slice(0, hostEnd);
    rest = rest.slice(hostEnd); // pull out port.

    this.parseHost(host); // we've indicated that there is a hostname,
    // so even if it's empty, it has to be present.

    this.hostname = this.hostname || ''; // if hostname begins with [ and ends with ]
    // assume that it's an IPv6 address.

    var ipv6Hostname = this.hostname[0] === '[' && this.hostname[this.hostname.length - 1] === ']'; // validate a little.

    if (!ipv6Hostname) {
      var hostparts = this.hostname.split(/\./);

      for (i = 0, l = hostparts.length; i < l; i++) {
        var part = hostparts[i];

        if (!part) {
          continue;
        }

        if (!part.match(hostnamePartPattern)) {
          var newpart = '';

          for (var j = 0, k = part.length; j < k; j++) {
            if (part.charCodeAt(j) > 127) {
              // we replace non-ASCII char with a temporary placeholder
              // we need this to make sure size of hostname is not
              // broken by replacing non-ASCII by nothing
              newpart += 'x';
            } else {
              newpart += part[j];
            }
          } // we test again with ASCII char only


          if (!newpart.match(hostnamePartPattern)) {
            var validParts = hostparts.slice(0, i);
            var notHost = hostparts.slice(i + 1);
            var bit = part.match(hostnamePartStart);

            if (bit) {
              validParts.push(bit[1]);
              notHost.unshift(bit[2]);
            }

            if (notHost.length) {
              rest = notHost.join('.') + rest;
            }

            this.hostname = validParts.join('.');
            break;
          }
        }
      }
    }

    if (this.hostname.length > hostnameMaxLen) {
      this.hostname = '';
    } // strip [ and ] from the hostname
    // the host field still retains them, though


    if (ipv6Hostname) {
      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
    }
  } // chop off from the tail first.


  var hash = rest.indexOf('#');

  if (hash !== -1) {
    // got a fragment string.
    this.hash = rest.substr(hash);
    rest = rest.slice(0, hash);
  }

  var qm = rest.indexOf('?');

  if (qm !== -1) {
    this.search = rest.substr(qm);
    rest = rest.slice(0, qm);
  }

  if (rest) {
    this.pathname = rest;
  }

  if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
    this.pathname = '';
  }

  return this;
};

Url.prototype.parseHost = function (host) {
  var port = portPattern.exec(host);

  if (port) {
    port = port[0];

    if (port !== ':') {
      this.port = port.substr(1);
    }

    host = host.substr(0, host.length - port.length);
  }

  if (host) {
    this.hostname = host;
  }
};

module.exports = urlParse;

/***/ }),
/* 148 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.Any = __webpack_require__(64);
exports.Cc = __webpack_require__(65);
exports.Cf = __webpack_require__(149);
exports.P = __webpack_require__(39);
exports.Z = __webpack_require__(66);

/***/ }),
/* 149 */
/***/ (function(module, exports) {

module.exports = /[\xAD\u0600-\u0605\u061C\u06DD\u070F\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB]|\uD804[\uDCBD\uDCCD]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/;

/***/ }),
/* 150 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Just a shortcut for bulk export


exports.parseLinkLabel = __webpack_require__(151);
exports.parseLinkDestination = __webpack_require__(152);
exports.parseLinkTitle = __webpack_require__(153);

/***/ }),
/* 151 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Parse link label
//
// this function assumes that first character ("[") already matches;
// returns the end of the label
//


module.exports = function parseLinkLabel(state, start, disableNested) {
  var level,
      found,
      marker,
      prevPos,
      labelEnd = -1,
      max = state.posMax,
      oldPos = state.pos;
  state.pos = start + 1;
  level = 1;

  while (state.pos < max) {
    marker = state.src.charCodeAt(state.pos);

    if (marker === 0x5D
    /* ] */
    ) {
        level--;

        if (level === 0) {
          found = true;
          break;
        }
      }

    prevPos = state.pos;
    state.md.inline.skipToken(state);

    if (marker === 0x5B
    /* [ */
    ) {
        if (prevPos === state.pos - 1) {
          // increase level if we find text `[`, which is not a part of any token
          level++;
        } else if (disableNested) {
          state.pos = oldPos;
          return -1;
        }
      }
  }

  if (found) {
    labelEnd = state.pos;
  } // restore old state


  state.pos = oldPos;
  return labelEnd;
};

/***/ }),
/* 152 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Parse link destination
//


var unescapeAll = __webpack_require__(1).unescapeAll;

module.exports = function parseLinkDestination(str, pos, max) {
  var code,
      level,
      lines = 0,
      start = pos,
      result = {
    ok: false,
    pos: 0,
    lines: 0,
    str: ''
  };

  if (str.charCodeAt(pos) === 0x3C
  /* < */
  ) {
      pos++;

      while (pos < max) {
        code = str.charCodeAt(pos);

        if (code === 0x0A
        /* \n */
        ) {
            return result;
          }

        if (code === 0x3E
        /* > */
        ) {
            result.pos = pos + 1;
            result.str = unescapeAll(str.slice(start + 1, pos));
            result.ok = true;
            return result;
          }

        if (code === 0x5C
        /* \ */
        && pos + 1 < max) {
          pos += 2;
          continue;
        }

        pos++;
      } // no closing '>'


      return result;
    } // this should be ... } else { ... branch


  level = 0;

  while (pos < max) {
    code = str.charCodeAt(pos);

    if (code === 0x20) {
      break;
    } // ascii control characters


    if (code < 0x20 || code === 0x7F) {
      break;
    }

    if (code === 0x5C
    /* \ */
    && pos + 1 < max) {
      pos += 2;
      continue;
    }

    if (code === 0x28
    /* ( */
    ) {
        level++;
      }

    if (code === 0x29
    /* ) */
    ) {
        if (level === 0) {
          break;
        }

        level--;
      }

    pos++;
  }

  if (start === pos) {
    return result;
  }

  if (level !== 0) {
    return result;
  }

  result.str = unescapeAll(str.slice(start, pos));
  result.lines = lines;
  result.pos = pos;
  result.ok = true;
  return result;
};

/***/ }),
/* 153 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Parse link title
//


var unescapeAll = __webpack_require__(1).unescapeAll;

module.exports = function parseLinkTitle(str, pos, max) {
  var code,
      marker,
      lines = 0,
      start = pos,
      result = {
    ok: false,
    pos: 0,
    lines: 0,
    str: ''
  };

  if (pos >= max) {
    return result;
  }

  marker = str.charCodeAt(pos);

  if (marker !== 0x22
  /* " */
  && marker !== 0x27
  /* ' */
  && marker !== 0x28
  /* ( */
  ) {
      return result;
    }

  pos++; // if opening marker is "(", switch it to closing marker ")"

  if (marker === 0x28) {
    marker = 0x29;
  }

  while (pos < max) {
    code = str.charCodeAt(pos);

    if (code === marker) {
      result.pos = pos + 1;
      result.lines = lines;
      result.str = unescapeAll(str.slice(start + 1, pos));
      result.ok = true;
      return result;
    } else if (code === 0x0A) {
      lines++;
    } else if (code === 0x5C
    /* \ */
    && pos + 1 < max) {
      pos++;

      if (str.charCodeAt(pos) === 0x0A) {
        lines++;
      }
    }

    pos++;
  }

  return result;
};

/***/ }),
/* 154 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * class Renderer
 *
 * Generates HTML from parsed token stream. Each instance has independent
 * copy of rules. Those can be rewritten with ease. Also, you can add new
 * rules if you create plugin and adds new token types.
 **/


var assign = __webpack_require__(1).assign;

var unescapeAll = __webpack_require__(1).unescapeAll;

var escapeHtml = __webpack_require__(1).escapeHtml; ////////////////////////////////////////////////////////////////////////////////


var default_rules = {};

default_rules.code_inline = function (tokens, idx, options, env, slf) {
  var token = tokens[idx];
  return '<code' + slf.renderAttrs(token) + '>' + escapeHtml(tokens[idx].content) + '</code>';
};

default_rules.code_block = function (tokens, idx, options, env, slf) {
  var token = tokens[idx];
  return '<pre' + slf.renderAttrs(token) + '><code>' + escapeHtml(tokens[idx].content) + '</code></pre>\n';
};

default_rules.fence = function (tokens, idx, options, env, slf) {
  var token = tokens[idx],
      info = token.info ? unescapeAll(token.info).trim() : '',
      langName = '',
      highlighted,
      i,
      tmpAttrs,
      tmpToken;

  if (info) {
    langName = info.split(/\s+/g)[0];
  }

  if (options.highlight) {
    highlighted = options.highlight(token.content, langName) || escapeHtml(token.content);
  } else {
    highlighted = escapeHtml(token.content);
  }

  if (highlighted.indexOf('<pre') === 0) {
    return highlighted + '\n';
  } // If language exists, inject class gently, without modifying original token.
  // May be, one day we will add .clone() for token and simplify this part, but
  // now we prefer to keep things local.


  if (info) {
    i = token.attrIndex('class');
    tmpAttrs = token.attrs ? token.attrs.slice() : [];

    if (i < 0) {
      tmpAttrs.push(['class', options.langPrefix + langName]);
    } else {
      tmpAttrs[i][1] += ' ' + options.langPrefix + langName;
    } // Fake token just to render attributes


    tmpToken = {
      attrs: tmpAttrs
    };
    return '<pre><code' + slf.renderAttrs(tmpToken) + '>' + highlighted + '</code></pre>\n';
  }

  return '<pre><code' + slf.renderAttrs(token) + '>' + highlighted + '</code></pre>\n';
};

default_rules.image = function (tokens, idx, options, env, slf) {
  var token = tokens[idx]; // "alt" attr MUST be set, even if empty. Because it's mandatory and
  // should be placed on proper position for tests.
  //
  // Replace content with actual value

  token.attrs[token.attrIndex('alt')][1] = slf.renderInlineAsText(token.children, options, env);
  return slf.renderToken(tokens, idx, options);
};

default_rules.hardbreak = function (tokens, idx, options
/*, env */
) {
  return options.xhtmlOut ? '<br />\n' : '<br>\n';
};

default_rules.softbreak = function (tokens, idx, options
/*, env */
) {
  return options.breaks ? options.xhtmlOut ? '<br />\n' : '<br>\n' : '\n';
};

default_rules.text = function (tokens, idx
/*, options, env */
) {
  return escapeHtml(tokens[idx].content);
};

default_rules.html_block = function (tokens, idx
/*, options, env */
) {
  return tokens[idx].content;
};

default_rules.html_inline = function (tokens, idx
/*, options, env */
) {
  return tokens[idx].content;
};
/**
 * new Renderer()
 *
 * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
 **/


function Renderer() {
  /**
   * Renderer#rules -> Object
   *
   * Contains render rules for tokens. Can be updated and extended.
   *
   * ##### Example
   *
   * ```javascript
   * var md = require('markdown-it')();
   *
   * md.renderer.rules.strong_open  = function () { return '<b>'; };
   * md.renderer.rules.strong_close = function () { return '</b>'; };
   *
   * var result = md.renderInline(...);
   * ```
   *
   * Each rule is called as independent static function with fixed signature:
   *
   * ```javascript
   * function my_token_render(tokens, idx, options, env, renderer) {
   *   // ...
   *   return renderedHTML;
   * }
   * ```
   *
   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)
   * for more details and examples.
   **/
  this.rules = assign({}, default_rules);
}
/**
 * Renderer.renderAttrs(token) -> String
 *
 * Render token attributes to string.
 **/


Renderer.prototype.renderAttrs = function renderAttrs(token) {
  var i, l, result;

  if (!token.attrs) {
    return '';
  }

  result = '';

  for (i = 0, l = token.attrs.length; i < l; i++) {
    result += ' ' + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
  }

  return result;
};
/**
 * Renderer.renderToken(tokens, idx, options) -> String
 * - tokens (Array): list of tokens
 * - idx (Numbed): token index to render
 * - options (Object): params of parser instance
 *
 * Default token renderer. Can be overriden by custom function
 * in [[Renderer#rules]].
 **/


Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {
  var nextToken,
      result = '',
      needLf = false,
      token = tokens[idx]; // Tight list paragraphs

  if (token.hidden) {
    return '';
  } // Insert a newline between hidden paragraph and subsequent opening
  // block-level tag.
  //
  // For example, here we should insert a newline before blockquote:
  //  - a
  //    >
  //


  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
    result += '\n';
  } // Add token name, e.g. `<img`


  result += (token.nesting === -1 ? '</' : '<') + token.tag; // Encode attributes, e.g. `<img src="foo"`

  result += this.renderAttrs(token); // Add a slash for self-closing tags, e.g. `<img src="foo" /`

  if (token.nesting === 0 && options.xhtmlOut) {
    result += ' /';
  } // Check if we need to add a newline after this tag


  if (token.block) {
    needLf = true;

    if (token.nesting === 1) {
      if (idx + 1 < tokens.length) {
        nextToken = tokens[idx + 1];

        if (nextToken.type === 'inline' || nextToken.hidden) {
          // Block-level tag containing an inline tag.
          //
          needLf = false;
        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
          // Opening tag + closing tag of the same type. E.g. `<li></li>`.
          //
          needLf = false;
        }
      }
    }
  }

  result += needLf ? '>\n' : '>';
  return result;
};
/**
 * Renderer.renderInline(tokens, options, env) -> String
 * - tokens (Array): list on block tokens to renter
 * - options (Object): params of parser instance
 * - env (Object): additional data from parsed input (references, for example)
 *
 * The same as [[Renderer.render]], but for single token of `inline` type.
 **/


Renderer.prototype.renderInline = function (tokens, options, env) {
  var type,
      result = '',
      rules = this.rules;

  for (var i = 0, len = tokens.length; i < len; i++) {
    type = tokens[i].type;

    if (typeof rules[type] !== 'undefined') {
      result += rules[type](tokens, i, options, env, this);
    } else {
      result += this.renderToken(tokens, i, options);
    }
  }

  return result;
};
/** internal
 * Renderer.renderInlineAsText(tokens, options, env) -> String
 * - tokens (Array): list on block tokens to renter
 * - options (Object): params of parser instance
 * - env (Object): additional data from parsed input (references, for example)
 *
 * Special kludge for image `alt` attributes to conform CommonMark spec.
 * Don't try to use it! Spec requires to show `alt` content with stripped markup,
 * instead of simple escaping.
 **/


Renderer.prototype.renderInlineAsText = function (tokens, options, env) {
  var result = '';

  for (var i = 0, len = tokens.length; i < len; i++) {
    if (tokens[i].type === 'text') {
      result += tokens[i].content;
    } else if (tokens[i].type === 'image') {
      result += this.renderInlineAsText(tokens[i].children, options, env);
    }
  }

  return result;
};
/**
 * Renderer.render(tokens, options, env) -> String
 * - tokens (Array): list on block tokens to renter
 * - options (Object): params of parser instance
 * - env (Object): additional data from parsed input (references, for example)
 *
 * Takes token stream and generates HTML. Probably, you will never need to call
 * this method directly.
 **/


Renderer.prototype.render = function (tokens, options, env) {
  var i,
      len,
      type,
      result = '',
      rules = this.rules;

  for (i = 0, len = tokens.length; i < len; i++) {
    type = tokens[i].type;

    if (type === 'inline') {
      result += this.renderInline(tokens[i].children, options, env);
    } else if (typeof rules[type] !== 'undefined') {
      result += rules[tokens[i].type](tokens, i, options, env, this);
    } else {
      result += this.renderToken(tokens, i, options, env);
    }
  }

  return result;
};

module.exports = Renderer;

/***/ }),
/* 155 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/** internal
 * class Core
 *
 * Top-level rules executor. Glues block/inline parsers and does intermediate
 * transformations.
 **/


var Ruler = __webpack_require__(40);

var _rules = [['normalize', __webpack_require__(156)], ['block', __webpack_require__(157)], ['inline', __webpack_require__(158)], ['linkify', __webpack_require__(159)], ['replacements', __webpack_require__(160)], ['smartquotes', __webpack_require__(161)]];
/**
 * new Core()
 **/

function Core() {
  /**
   * Core#ruler -> Ruler
   *
   * [[Ruler]] instance. Keep configuration of core rules.
   **/
  this.ruler = new Ruler();

  for (var i = 0; i < _rules.length; i++) {
    this.ruler.push(_rules[i][0], _rules[i][1]);
  }
}
/**
 * Core.process(state)
 *
 * Executes core chain rules.
 **/


Core.prototype.process = function (state) {
  var i, l, rules;
  rules = this.ruler.getRules('');

  for (i = 0, l = rules.length; i < l; i++) {
    rules[i](state);
  }
};

Core.prototype.State = __webpack_require__(162);
module.exports = Core;

/***/ }),
/* 156 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Normalize input string
 // https://spec.commonmark.org/0.29/#line-ending

var NEWLINES_RE = /\r\n?|\n/g;
var NULL_RE = /\0/g;

module.exports = function normalize(state) {
  var str; // Normalize newlines

  str = state.src.replace(NEWLINES_RE, '\n'); // Replace NULL characters

  str = str.replace(NULL_RE, '\uFFFD');
  state.src = str;
};

/***/ }),
/* 157 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = function block(state) {
  var token;

  if (state.inlineMode) {
    token = new state.Token('inline', '', 0);
    token.content = state.src;
    token.map = [0, 1];
    token.children = [];
    state.tokens.push(token);
  } else {
    state.md.block.parse(state.src, state.md, state.env, state.tokens);
  }
};

/***/ }),
/* 158 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = function inline(state) {
  var tokens = state.tokens,
      tok,
      i,
      l; // Parse inlines

  for (i = 0, l = tokens.length; i < l; i++) {
    tok = tokens[i];

    if (tok.type === 'inline') {
      state.md.inline.parse(tok.content, state.md, state.env, tok.children);
    }
  }
};

/***/ }),
/* 159 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Replace link-like texts with link nodes.
//
// Currently restricted by `md.validateLink()` to http/https/ftp
//


var arrayReplaceAt = __webpack_require__(1).arrayReplaceAt;

function isLinkOpen(str) {
  return /^<a[>\s]/i.test(str);
}

function isLinkClose(str) {
  return /^<\/a\s*>/i.test(str);
}

module.exports = function linkify(state) {
  var i,
      j,
      l,
      tokens,
      token,
      currentToken,
      nodes,
      ln,
      text,
      pos,
      lastPos,
      level,
      htmlLinkLevel,
      url,
      fullUrl,
      urlText,
      blockTokens = state.tokens,
      links;

  if (!state.md.options.linkify) {
    return;
  }

  for (j = 0, l = blockTokens.length; j < l; j++) {
    if (blockTokens[j].type !== 'inline' || !state.md.linkify.pretest(blockTokens[j].content)) {
      continue;
    }

    tokens = blockTokens[j].children;
    htmlLinkLevel = 0; // We scan from the end, to keep position when new tags added.
    // Use reversed logic in links start/end match

    for (i = tokens.length - 1; i >= 0; i--) {
      currentToken = tokens[i]; // Skip content of markdown links

      if (currentToken.type === 'link_close') {
        i--;

        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {
          i--;
        }

        continue;
      } // Skip content of html tag links


      if (currentToken.type === 'html_inline') {
        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
          htmlLinkLevel--;
        }

        if (isLinkClose(currentToken.content)) {
          htmlLinkLevel++;
        }
      }

      if (htmlLinkLevel > 0) {
        continue;
      }

      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {
        text = currentToken.content;
        links = state.md.linkify.match(text); // Now split string to nodes

        nodes = [];
        level = currentToken.level;
        lastPos = 0;

        for (ln = 0; ln < links.length; ln++) {
          url = links[ln].url;
          fullUrl = state.md.normalizeLink(url);

          if (!state.md.validateLink(fullUrl)) {
            continue;
          }

          urlText = links[ln].text; // Linkifier might send raw hostnames like "example.com", where url
          // starts with domain name. So we prepend http:// in those cases,
          // and remove it afterwards.
          //

          if (!links[ln].schema) {
            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\/\//, '');
          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {
            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');
          } else {
            urlText = state.md.normalizeLinkText(urlText);
          }

          pos = links[ln].index;

          if (pos > lastPos) {
            token = new state.Token('text', '', 0);
            token.content = text.slice(lastPos, pos);
            token.level = level;
            nodes.push(token);
          }

          token = new state.Token('link_open', 'a', 1);
          token.attrs = [['href', fullUrl]];
          token.level = level++;
          token.markup = 'linkify';
          token.info = 'auto';
          nodes.push(token);
          token = new state.Token('text', '', 0);
          token.content = urlText;
          token.level = level;
          nodes.push(token);
          token = new state.Token('link_close', 'a', -1);
          token.level = --level;
          token.markup = 'linkify';
          token.info = 'auto';
          nodes.push(token);
          lastPos = links[ln].lastIndex;
        }

        if (lastPos < text.length) {
          token = new state.Token('text', '', 0);
          token.content = text.slice(lastPos);
          token.level = level;
          nodes.push(token);
        } // replace current node


        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
      }
    }
  }
};

/***/ }),
/* 160 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Simple typographic replacements
//
// (c) (C) → ©
// (tm) (TM) → ™
// (r) (R) → ®
// +- → ±
// (p) (P) -> §
// ... → … (also ?.... → ?.., !.... → !..)
// ???????? → ???, !!!!! → !!!, `,,` → `,`
// -- → &ndash;, --- → &mdash;
//
 // TODO:
// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾
// - miltiplication 2 x 4 -> 2 × 4

var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/; // Workaround for phantomjs - need regex without /g flag,
// or root check will fail every second time

var SCOPED_ABBR_TEST_RE = /\((c|tm|r|p)\)/i;
var SCOPED_ABBR_RE = /\((c|tm|r|p)\)/ig;
var SCOPED_ABBR = {
  c: '©',
  r: '®',
  p: '§',
  tm: '™'
};

function replaceFn(match, name) {
  return SCOPED_ABBR[name.toLowerCase()];
}

function replace_scoped(inlineTokens) {
  var i,
      token,
      inside_autolink = 0;

  for (i = inlineTokens.length - 1; i >= 0; i--) {
    token = inlineTokens[i];

    if (token.type === 'text' && !inside_autolink) {
      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
    }

    if (token.type === 'link_open' && token.info === 'auto') {
      inside_autolink--;
    }

    if (token.type === 'link_close' && token.info === 'auto') {
      inside_autolink++;
    }
  }
}

function replace_rare(inlineTokens) {
  var i,
      token,
      inside_autolink = 0;

  for (i = inlineTokens.length - 1; i >= 0; i--) {
    token = inlineTokens[i];

    if (token.type === 'text' && !inside_autolink) {
      if (RARE_RE.test(token.content)) {
        token.content = token.content.replace(/\+-/g, '±') // .., ..., ....... -> …
        // but ?..... & !..... -> ?.. & !..
        .replace(/\.{2,}/g, '…').replace(/([?!])…/g, '$1..').replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',') // em-dash
        .replace(/(^|[^-])---([^-]|$)/mg, '$1\u2014$2') // en-dash
        .replace(/(^|\s)--(\s|$)/mg, '$1\u2013$2').replace(/(^|[^-\s])--([^-\s]|$)/mg, '$1\u2013$2');
      }
    }

    if (token.type === 'link_open' && token.info === 'auto') {
      inside_autolink--;
    }

    if (token.type === 'link_close' && token.info === 'auto') {
      inside_autolink++;
    }
  }
}

module.exports = function replace(state) {
  var blkIdx;

  if (!state.md.options.typographer) {
    return;
  }

  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
    if (state.tokens[blkIdx].type !== 'inline') {
      continue;
    }

    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
      replace_scoped(state.tokens[blkIdx].children);
    }

    if (RARE_RE.test(state.tokens[blkIdx].content)) {
      replace_rare(state.tokens[blkIdx].children);
    }
  }
};

/***/ }),
/* 161 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Convert straight quotation marks to typographic ones
//


var isWhiteSpace = __webpack_require__(1).isWhiteSpace;

var isPunctChar = __webpack_require__(1).isPunctChar;

var isMdAsciiPunct = __webpack_require__(1).isMdAsciiPunct;

var QUOTE_TEST_RE = /['"]/;
var QUOTE_RE = /['"]/g;
var APOSTROPHE = '\u2019';
/* ’ */

function replaceAt(str, index, ch) {
  return str.substr(0, index) + ch + str.substr(index + 1);
}

function process_inlines(tokens, state) {
  var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar, isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace, canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;
  stack = [];

  for (i = 0; i < tokens.length; i++) {
    token = tokens[i];
    thisLevel = tokens[i].level;

    for (j = stack.length - 1; j >= 0; j--) {
      if (stack[j].level <= thisLevel) {
        break;
      }
    }

    stack.length = j + 1;

    if (token.type !== 'text') {
      continue;
    }

    text = token.content;
    pos = 0;
    max = text.length;
    /*eslint no-labels:0,block-scoped-var:0*/

    OUTER: while (pos < max) {
      QUOTE_RE.lastIndex = pos;
      t = QUOTE_RE.exec(text);

      if (!t) {
        break;
      }

      canOpen = canClose = true;
      pos = t.index + 1;
      isSingle = t[0] === "'"; // Find previous character,
      // default to space if it's the beginning of the line
      //

      lastChar = 0x20;

      if (t.index - 1 >= 0) {
        lastChar = text.charCodeAt(t.index - 1);
      } else {
        for (j = i - 1; j >= 0; j--) {
          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // lastChar defaults to 0x20

          if (tokens[j].type !== 'text') continue;
          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);
          break;
        }
      } // Find next character,
      // default to space if it's the end of the line
      //


      nextChar = 0x20;

      if (pos < max) {
        nextChar = text.charCodeAt(pos);
      } else {
        for (j = i + 1; j < tokens.length; j++) {
          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // nextChar defaults to 0x20

          if (tokens[j].type !== 'text') continue;
          nextChar = tokens[j].content.charCodeAt(0);
          break;
        }
      }

      isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
      isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
      isLastWhiteSpace = isWhiteSpace(lastChar);
      isNextWhiteSpace = isWhiteSpace(nextChar);

      if (isNextWhiteSpace) {
        canOpen = false;
      } else if (isNextPunctChar) {
        if (!(isLastWhiteSpace || isLastPunctChar)) {
          canOpen = false;
        }
      }

      if (isLastWhiteSpace) {
        canClose = false;
      } else if (isLastPunctChar) {
        if (!(isNextWhiteSpace || isNextPunctChar)) {
          canClose = false;
        }
      }

      if (nextChar === 0x22
      /* " */
      && t[0] === '"') {
        if (lastChar >= 0x30
        /* 0 */
        && lastChar <= 0x39
        /* 9 */
        ) {
            // special case: 1"" - count first quote as an inch
            canClose = canOpen = false;
          }
      }

      if (canOpen && canClose) {
        // treat this as the middle of the word
        canOpen = false;
        canClose = isNextPunctChar;
      }

      if (!canOpen && !canClose) {
        // middle of word
        if (isSingle) {
          token.content = replaceAt(token.content, t.index, APOSTROPHE);
        }

        continue;
      }

      if (canClose) {
        // this could be a closing quote, rewind the stack to get a match
        for (j = stack.length - 1; j >= 0; j--) {
          item = stack[j];

          if (stack[j].level < thisLevel) {
            break;
          }

          if (item.single === isSingle && stack[j].level === thisLevel) {
            item = stack[j];

            if (isSingle) {
              openQuote = state.md.options.quotes[2];
              closeQuote = state.md.options.quotes[3];
            } else {
              openQuote = state.md.options.quotes[0];
              closeQuote = state.md.options.quotes[1];
            } // replace token.content *before* tokens[item.token].content,
            // because, if they are pointing at the same token, replaceAt
            // could mess up indices when quote length != 1


            token.content = replaceAt(token.content, t.index, closeQuote);
            tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, openQuote);
            pos += closeQuote.length - 1;

            if (item.token === i) {
              pos += openQuote.length - 1;
            }

            text = token.content;
            max = text.length;
            stack.length = j;
            continue OUTER;
          }
        }
      }

      if (canOpen) {
        stack.push({
          token: i,
          pos: t.index,
          single: isSingle,
          level: thisLevel
        });
      } else if (canClose && isSingle) {
        token.content = replaceAt(token.content, t.index, APOSTROPHE);
      }
    }
  }
}

module.exports = function smartquotes(state) {
  /*eslint max-depth:0*/
  var blkIdx;

  if (!state.md.options.typographer) {
    return;
  }

  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
    if (state.tokens[blkIdx].type !== 'inline' || !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
      continue;
    }

    process_inlines(state.tokens[blkIdx].children, state);
  }
};

/***/ }),
/* 162 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Core state object
//


var Token = __webpack_require__(41);

function StateCore(src, md, env) {
  this.src = src;
  this.env = env;
  this.tokens = [];
  this.inlineMode = false;
  this.md = md; // link to parser instance
} // re-export Token class to use in core rules


StateCore.prototype.Token = Token;
module.exports = StateCore;

/***/ }),
/* 163 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/** internal
 * class ParserBlock
 *
 * Block-level tokenizer.
 **/


var Ruler = __webpack_require__(40);

var _rules = [// First 2 params - rule name & source. Secondary array - list of rules,
// which can be terminated by this one.
['table', __webpack_require__(164), ['paragraph', 'reference']], ['code', __webpack_require__(165)], ['fence', __webpack_require__(166), ['paragraph', 'reference', 'blockquote', 'list']], ['blockquote', __webpack_require__(167), ['paragraph', 'reference', 'blockquote', 'list']], ['hr', __webpack_require__(168), ['paragraph', 'reference', 'blockquote', 'list']], ['list', __webpack_require__(169), ['paragraph', 'reference', 'blockquote']], ['reference', __webpack_require__(170)], ['heading', __webpack_require__(171), ['paragraph', 'reference', 'blockquote']], ['lheading', __webpack_require__(172)], ['html_block', __webpack_require__(173), ['paragraph', 'reference', 'blockquote']], ['paragraph', __webpack_require__(175)]];
/**
 * new ParserBlock()
 **/

function ParserBlock() {
  /**
   * ParserBlock#ruler -> Ruler
   *
   * [[Ruler]] instance. Keep configuration of block rules.
   **/
  this.ruler = new Ruler();

  for (var i = 0; i < _rules.length; i++) {
    this.ruler.push(_rules[i][0], _rules[i][1], {
      alt: (_rules[i][2] || []).slice()
    });
  }
} // Generate tokens for input range
//


ParserBlock.prototype.tokenize = function (state, startLine, endLine) {
  var ok,
      i,
      rules = this.ruler.getRules(''),
      len = rules.length,
      line = startLine,
      hasEmptyLines = false,
      maxNesting = state.md.options.maxNesting;

  while (line < endLine) {
    state.line = line = state.skipEmptyLines(line);

    if (line >= endLine) {
      break;
    } // Termination condition for nested calls.
    // Nested calls currently used for blockquotes & lists


    if (state.sCount[line] < state.blkIndent) {
      break;
    } // If nesting level exceeded - skip tail to the end. That's not ordinary
    // situation and we should not care about content.


    if (state.level >= maxNesting) {
      state.line = endLine;
      break;
    } // Try all possible rules.
    // On success, rule should:
    //
    // - update `state.line`
    // - update `state.tokens`
    // - return true


    for (i = 0; i < len; i++) {
      ok = rules[i](state, line, endLine, false);

      if (ok) {
        break;
      }
    } // set state.tight if we had an empty line before current tag
    // i.e. latest empty line should not count


    state.tight = !hasEmptyLines; // paragraph might "eat" one newline after it in nested lists

    if (state.isEmpty(state.line - 1)) {
      hasEmptyLines = true;
    }

    line = state.line;

    if (line < endLine && state.isEmpty(line)) {
      hasEmptyLines = true;
      line++;
      state.line = line;
    }
  }
};
/**
 * ParserBlock.parse(str, md, env, outTokens)
 *
 * Process input string and push block tokens into `outTokens`
 **/


ParserBlock.prototype.parse = function (src, md, env, outTokens) {
  var state;

  if (!src) {
    return;
  }

  state = new this.State(src, md, env, outTokens);
  this.tokenize(state, state.line, state.lineMax);
};

ParserBlock.prototype.State = __webpack_require__(176);
module.exports = ParserBlock;

/***/ }),
/* 164 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// GFM table, non-standard


var isSpace = __webpack_require__(1).isSpace;

function getLine(state, line) {
  var pos = state.bMarks[line] + state.blkIndent,
      max = state.eMarks[line];
  return state.src.substr(pos, max - pos);
}

function escapedSplit(str) {
  var result = [],
      pos = 0,
      max = str.length,
      ch,
      escapes = 0,
      lastPos = 0,
      backTicked = false,
      lastBackTick = 0;
  ch = str.charCodeAt(pos);

  while (pos < max) {
    if (ch === 0x60
    /* ` */
    ) {
        if (backTicked) {
          // make \` close code sequence, but not open it;
          // the reason is: `\` is correct code block
          backTicked = false;
          lastBackTick = pos;
        } else if (escapes % 2 === 0) {
          backTicked = true;
          lastBackTick = pos;
        }
      } else if (ch === 0x7c
    /* | */
    && escapes % 2 === 0 && !backTicked) {
      result.push(str.substring(lastPos, pos));
      lastPos = pos + 1;
    }

    if (ch === 0x5c
    /* \ */
    ) {
        escapes++;
      } else {
      escapes = 0;
    }

    pos++; // If there was an un-closed backtick, go back to just after
    // the last backtick, but as if it was a normal character

    if (pos === max && backTicked) {
      backTicked = false;
      pos = lastBackTick + 1;
    }

    ch = str.charCodeAt(pos);
  }

  result.push(str.substring(lastPos));
  return result;
}

module.exports = function table(state, startLine, endLine, silent) {
  var ch, lineText, pos, i, nextLine, columns, columnCount, token, aligns, t, tableLines, tbodyLines; // should have at least two lines

  if (startLine + 2 > endLine) {
    return false;
  }

  nextLine = startLine + 1;

  if (state.sCount[nextLine] < state.blkIndent) {
    return false;
  } // if it's indented more than 3 spaces, it should be a code block


  if (state.sCount[nextLine] - state.blkIndent >= 4) {
    return false;
  } // first character of the second line should be '|', '-', ':',
  // and no other characters are allowed but spaces;
  // basically, this is the equivalent of /^[-:|][-:|\s]*$/ regexp


  pos = state.bMarks[nextLine] + state.tShift[nextLine];

  if (pos >= state.eMarks[nextLine]) {
    return false;
  }

  ch = state.src.charCodeAt(pos++);

  if (ch !== 0x7C
  /* | */
  && ch !== 0x2D
  /* - */
  && ch !== 0x3A
  /* : */
  ) {
      return false;
    }

  while (pos < state.eMarks[nextLine]) {
    ch = state.src.charCodeAt(pos);

    if (ch !== 0x7C
    /* | */
    && ch !== 0x2D
    /* - */
    && ch !== 0x3A
    /* : */
    && !isSpace(ch)) {
      return false;
    }

    pos++;
  }

  lineText = getLine(state, startLine + 1);
  columns = lineText.split('|');
  aligns = [];

  for (i = 0; i < columns.length; i++) {
    t = columns[i].trim();

    if (!t) {
      // allow empty columns before and after table, but not in between columns;
      // e.g. allow ` |---| `, disallow ` ---||--- `
      if (i === 0 || i === columns.length - 1) {
        continue;
      } else {
        return false;
      }
    }

    if (!/^:?-+:?$/.test(t)) {
      return false;
    }

    if (t.charCodeAt(t.length - 1) === 0x3A
    /* : */
    ) {
        aligns.push(t.charCodeAt(0) === 0x3A
        /* : */
        ? 'center' : 'right');
      } else if (t.charCodeAt(0) === 0x3A
    /* : */
    ) {
        aligns.push('left');
      } else {
      aligns.push('');
    }
  }

  lineText = getLine(state, startLine).trim();

  if (lineText.indexOf('|') === -1) {
    return false;
  }

  if (state.sCount[startLine] - state.blkIndent >= 4) {
    return false;
  }

  columns = escapedSplit(lineText.replace(/^\||\|$/g, '')); // header row will define an amount of columns in the entire table,
  // and align row shouldn't be smaller than that (the rest of the rows can)

  columnCount = columns.length;

  if (columnCount > aligns.length) {
    return false;
  }

  if (silent) {
    return true;
  }

  token = state.push('table_open', 'table', 1);
  token.map = tableLines = [startLine, 0];
  token = state.push('thead_open', 'thead', 1);
  token.map = [startLine, startLine + 1];
  token = state.push('tr_open', 'tr', 1);
  token.map = [startLine, startLine + 1];

  for (i = 0; i < columns.length; i++) {
    token = state.push('th_open', 'th', 1);
    token.map = [startLine, startLine + 1];

    if (aligns[i]) {
      token.attrs = [['style', 'text-align:' + aligns[i]]];
    }

    token = state.push('inline', '', 0);
    token.content = columns[i].trim();
    token.map = [startLine, startLine + 1];
    token.children = [];
    token = state.push('th_close', 'th', -1);
  }

  token = state.push('tr_close', 'tr', -1);
  token = state.push('thead_close', 'thead', -1);
  token = state.push('tbody_open', 'tbody', 1);
  token.map = tbodyLines = [startLine + 2, 0];

  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
    if (state.sCount[nextLine] < state.blkIndent) {
      break;
    }

    lineText = getLine(state, nextLine).trim();

    if (lineText.indexOf('|') === -1) {
      break;
    }

    if (state.sCount[nextLine] - state.blkIndent >= 4) {
      break;
    }

    columns = escapedSplit(lineText.replace(/^\||\|$/g, ''));
    token = state.push('tr_open', 'tr', 1);

    for (i = 0; i < columnCount; i++) {
      token = state.push('td_open', 'td', 1);

      if (aligns[i]) {
        token.attrs = [['style', 'text-align:' + aligns[i]]];
      }

      token = state.push('inline', '', 0);
      token.content = columns[i] ? columns[i].trim() : '';
      token.children = [];
      token = state.push('td_close', 'td', -1);
    }

    token = state.push('tr_close', 'tr', -1);
  }

  token = state.push('tbody_close', 'tbody', -1);
  token = state.push('table_close', 'table', -1);
  tableLines[1] = tbodyLines[1] = nextLine;
  state.line = nextLine;
  return true;
};

/***/ }),
/* 165 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Code block (4 spaces padded)


module.exports = function code(state, startLine, endLine
/*, silent*/
) {
  var nextLine, last, token;

  if (state.sCount[startLine] - state.blkIndent < 4) {
    return false;
  }

  last = nextLine = startLine + 1;

  while (nextLine < endLine) {
    if (state.isEmpty(nextLine)) {
      nextLine++;
      continue;
    }

    if (state.sCount[nextLine] - state.blkIndent >= 4) {
      nextLine++;
      last = nextLine;
      continue;
    }

    break;
  }

  state.line = last;
  token = state.push('code_block', 'code', 0);
  token.content = state.getLines(startLine, last, 4 + state.blkIndent, true);
  token.map = [startLine, state.line];
  return true;
};

/***/ }),
/* 166 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// fences (``` lang, ~~~ lang)


module.exports = function fence(state, startLine, endLine, silent) {
  var marker,
      len,
      params,
      nextLine,
      mem,
      token,
      markup,
      haveEndMarker = false,
      pos = state.bMarks[startLine] + state.tShift[startLine],
      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block

  if (state.sCount[startLine] - state.blkIndent >= 4) {
    return false;
  }

  if (pos + 3 > max) {
    return false;
  }

  marker = state.src.charCodeAt(pos);

  if (marker !== 0x7E
  /* ~ */
  && marker !== 0x60
  /* ` */
  ) {
      return false;
    } // scan marker length


  mem = pos;
  pos = state.skipChars(pos, marker);
  len = pos - mem;

  if (len < 3) {
    return false;
  }

  markup = state.src.slice(mem, pos);
  params = state.src.slice(pos, max);

  if (marker === 0x60
  /* ` */
  ) {
      if (params.indexOf(String.fromCharCode(marker)) >= 0) {
        return false;
      }
    } // Since start is found, we can report success here in validation mode


  if (silent) {
    return true;
  } // search end of block


  nextLine = startLine;

  for (;;) {
    nextLine++;

    if (nextLine >= endLine) {
      // unclosed block should be autoclosed by end of document.
      // also block seems to be autoclosed by end of parent
      break;
    }

    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
    max = state.eMarks[nextLine];

    if (pos < max && state.sCount[nextLine] < state.blkIndent) {
      // non-empty line with negative indent should stop the list:
      // - ```
      //  test
      break;
    }

    if (state.src.charCodeAt(pos) !== marker) {
      continue;
    }

    if (state.sCount[nextLine] - state.blkIndent >= 4) {
      // closing fence should be indented less than 4 spaces
      continue;
    }

    pos = state.skipChars(pos, marker); // closing code fence must be at least as long as the opening one

    if (pos - mem < len) {
      continue;
    } // make sure tail has spaces only


    pos = state.skipSpaces(pos);

    if (pos < max) {
      continue;
    }

    haveEndMarker = true; // found!

    break;
  } // If a fence has heading spaces, they should be removed from its inner block


  len = state.sCount[startLine];
  state.line = nextLine + (haveEndMarker ? 1 : 0);
  token = state.push('fence', 'code', 0);
  token.info = params;
  token.content = state.getLines(startLine + 1, nextLine, len, true);
  token.markup = markup;
  token.map = [startLine, state.line];
  return true;
};

/***/ }),
/* 167 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Block quotes


var isSpace = __webpack_require__(1).isSpace;

module.exports = function blockquote(state, startLine, endLine, silent) {
  var adjustTab,
      ch,
      i,
      initial,
      l,
      lastLineEmpty,
      lines,
      nextLine,
      offset,
      oldBMarks,
      oldBSCount,
      oldIndent,
      oldParentType,
      oldSCount,
      oldTShift,
      spaceAfterMarker,
      terminate,
      terminatorRules,
      token,
      wasOutdented,
      oldLineMax = state.lineMax,
      pos = state.bMarks[startLine] + state.tShift[startLine],
      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block

  if (state.sCount[startLine] - state.blkIndent >= 4) {
    return false;
  } // check the block quote marker


  if (state.src.charCodeAt(pos++) !== 0x3E
  /* > */
  ) {
      return false;
    } // we know that it's going to be a valid blockquote,
  // so no point trying to find the end of it in silent mode


  if (silent) {
    return true;
  } // skip spaces after ">" and re-calculate offset


  initial = offset = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine]); // skip one optional space after '>'

  if (state.src.charCodeAt(pos) === 0x20
  /* space */
  ) {
      // ' >   test '
      //     ^ -- position start of line here:
      pos++;
      initial++;
      offset++;
      adjustTab = false;
      spaceAfterMarker = true;
    } else if (state.src.charCodeAt(pos) === 0x09
  /* tab */
  ) {
      spaceAfterMarker = true;

      if ((state.bsCount[startLine] + offset) % 4 === 3) {
        // '  >\t  test '
        //       ^ -- position start of line here (tab has width===1)
        pos++;
        initial++;
        offset++;
        adjustTab = false;
      } else {
        // ' >\t  test '
        //    ^ -- position start of line here + shift bsCount slightly
        //         to make extra space appear
        adjustTab = true;
      }
    } else {
    spaceAfterMarker = false;
  }

  oldBMarks = [state.bMarks[startLine]];
  state.bMarks[startLine] = pos;

  while (pos < max) {
    ch = state.src.charCodeAt(pos);

    if (isSpace(ch)) {
      if (ch === 0x09) {
        offset += 4 - (offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4;
      } else {
        offset++;
      }
    } else {
      break;
    }

    pos++;
  }

  oldBSCount = [state.bsCount[startLine]];
  state.bsCount[startLine] = state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0);
  lastLineEmpty = pos >= max;
  oldSCount = [state.sCount[startLine]];
  state.sCount[startLine] = offset - initial;
  oldTShift = [state.tShift[startLine]];
  state.tShift[startLine] = pos - state.bMarks[startLine];
  terminatorRules = state.md.block.ruler.getRules('blockquote');
  oldParentType = state.parentType;
  state.parentType = 'blockquote';
  wasOutdented = false; // Search the end of the block
  //
  // Block ends with either:
  //  1. an empty line outside:
  //     ```
  //     > test
  //
  //     ```
  //  2. an empty line inside:
  //     ```
  //     >
  //     test
  //     ```
  //  3. another tag:
  //     ```
  //     > test
  //      - - -
  //     ```

  for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
    // check if it's outdented, i.e. it's inside list item and indented
    // less than said list item:
    //
    // ```
    // 1. anything
    //    > current blockquote
    // 2. checking this line
    // ```
    if (state.sCount[nextLine] < state.blkIndent) wasOutdented = true;
    pos = state.bMarks[nextLine] + state.tShift[nextLine];
    max = state.eMarks[nextLine];

    if (pos >= max) {
      // Case 1: line is not inside the blockquote, and this line is empty.
      break;
    }

    if (state.src.charCodeAt(pos++) === 0x3E
    /* > */
    && !wasOutdented) {
      // This line is inside the blockquote.
      // skip spaces after ">" and re-calculate offset
      initial = offset = state.sCount[nextLine] + pos - (state.bMarks[nextLine] + state.tShift[nextLine]); // skip one optional space after '>'

      if (state.src.charCodeAt(pos) === 0x20
      /* space */
      ) {
          // ' >   test '
          //     ^ -- position start of line here:
          pos++;
          initial++;
          offset++;
          adjustTab = false;
          spaceAfterMarker = true;
        } else if (state.src.charCodeAt(pos) === 0x09
      /* tab */
      ) {
          spaceAfterMarker = true;

          if ((state.bsCount[nextLine] + offset) % 4 === 3) {
            // '  >\t  test '
            //       ^ -- position start of line here (tab has width===1)
            pos++;
            initial++;
            offset++;
            adjustTab = false;
          } else {
            // ' >\t  test '
            //    ^ -- position start of line here + shift bsCount slightly
            //         to make extra space appear
            adjustTab = true;
          }
        } else {
        spaceAfterMarker = false;
      }

      oldBMarks.push(state.bMarks[nextLine]);
      state.bMarks[nextLine] = pos;

      while (pos < max) {
        ch = state.src.charCodeAt(pos);

        if (isSpace(ch)) {
          if (ch === 0x09) {
            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
          } else {
            offset++;
          }
        } else {
          break;
        }

        pos++;
      }

      lastLineEmpty = pos >= max;
      oldBSCount.push(state.bsCount[nextLine]);
      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);
      oldSCount.push(state.sCount[nextLine]);
      state.sCount[nextLine] = offset - initial;
      oldTShift.push(state.tShift[nextLine]);
      state.tShift[nextLine] = pos - state.bMarks[nextLine];
      continue;
    } // Case 2: line is not inside the blockquote, and the last line was empty.


    if (lastLineEmpty) {
      break;
    } // Case 3: another tag found.


    terminate = false;

    for (i = 0, l = terminatorRules.length; i < l; i++) {
      if (terminatorRules[i](state, nextLine, endLine, true)) {
        terminate = true;
        break;
      }
    }

    if (terminate) {
      // Quirk to enforce "hard termination mode" for paragraphs;
      // normally if you call `tokenize(state, startLine, nextLine)`,
      // paragraphs will look below nextLine for paragraph continuation,
      // but if blockquote is terminated by another tag, they shouldn't
      state.lineMax = nextLine;

      if (state.blkIndent !== 0) {
        // state.blkIndent was non-zero, we now set it to zero,
        // so we need to re-calculate all offsets to appear as
        // if indent wasn't changed
        oldBMarks.push(state.bMarks[nextLine]);
        oldBSCount.push(state.bsCount[nextLine]);
        oldTShift.push(state.tShift[nextLine]);
        oldSCount.push(state.sCount[nextLine]);
        state.sCount[nextLine] -= state.blkIndent;
      }

      break;
    }

    oldBMarks.push(state.bMarks[nextLine]);
    oldBSCount.push(state.bsCount[nextLine]);
    oldTShift.push(state.tShift[nextLine]);
    oldSCount.push(state.sCount[nextLine]); // A negative indentation means that this is a paragraph continuation
    //

    state.sCount[nextLine] = -1;
  }

  oldIndent = state.blkIndent;
  state.blkIndent = 0;
  token = state.push('blockquote_open', 'blockquote', 1);
  token.markup = '>';
  token.map = lines = [startLine, 0];
  state.md.block.tokenize(state, startLine, nextLine);
  token = state.push('blockquote_close', 'blockquote', -1);
  token.markup = '>';
  state.lineMax = oldLineMax;
  state.parentType = oldParentType;
  lines[1] = state.line; // Restore original tShift; this might not be necessary since the parser
  // has already been here, but just to make sure we can do that.

  for (i = 0; i < oldTShift.length; i++) {
    state.bMarks[i + startLine] = oldBMarks[i];
    state.tShift[i + startLine] = oldTShift[i];
    state.sCount[i + startLine] = oldSCount[i];
    state.bsCount[i + startLine] = oldBSCount[i];
  }

  state.blkIndent = oldIndent;
  return true;
};

/***/ }),
/* 168 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Horizontal rule


var isSpace = __webpack_require__(1).isSpace;

module.exports = function hr(state, startLine, endLine, silent) {
  var marker,
      cnt,
      ch,
      token,
      pos = state.bMarks[startLine] + state.tShift[startLine],
      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block

  if (state.sCount[startLine] - state.blkIndent >= 4) {
    return false;
  }

  marker = state.src.charCodeAt(pos++); // Check hr marker

  if (marker !== 0x2A
  /* * */
  && marker !== 0x2D
  /* - */
  && marker !== 0x5F
  /* _ */
  ) {
      return false;
    } // markers can be mixed with spaces, but there should be at least 3 of them


  cnt = 1;

  while (pos < max) {
    ch = state.src.charCodeAt(pos++);

    if (ch !== marker && !isSpace(ch)) {
      return false;
    }

    if (ch === marker) {
      cnt++;
    }
  }

  if (cnt < 3) {
    return false;
  }

  if (silent) {
    return true;
  }

  state.line = startLine + 1;
  token = state.push('hr', 'hr', 0);
  token.map = [startLine, state.line];
  token.markup = Array(cnt + 1).join(String.fromCharCode(marker));
  return true;
};

/***/ }),
/* 169 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Lists


var isSpace = __webpack_require__(1).isSpace; // Search `[-+*][\n ]`, returns next pos after marker on success
// or -1 on fail.


function skipBulletListMarker(state, startLine) {
  var marker, pos, max, ch;
  pos = state.bMarks[startLine] + state.tShift[startLine];
  max = state.eMarks[startLine];
  marker = state.src.charCodeAt(pos++); // Check bullet

  if (marker !== 0x2A
  /* * */
  && marker !== 0x2D
  /* - */
  && marker !== 0x2B
  /* + */
  ) {
      return -1;
    }

  if (pos < max) {
    ch = state.src.charCodeAt(pos);

    if (!isSpace(ch)) {
      // " -test " - is not a list item
      return -1;
    }
  }

  return pos;
} // Search `\d+[.)][\n ]`, returns next pos after marker on success
// or -1 on fail.


function skipOrderedListMarker(state, startLine) {
  var ch,
      start = state.bMarks[startLine] + state.tShift[startLine],
      pos = start,
      max = state.eMarks[startLine]; // List marker should have at least 2 chars (digit + dot)

  if (pos + 1 >= max) {
    return -1;
  }

  ch = state.src.charCodeAt(pos++);

  if (ch < 0x30
  /* 0 */
  || ch > 0x39
  /* 9 */
  ) {
      return -1;
    }

  for (;;) {
    // EOL -> fail
    if (pos >= max) {
      return -1;
    }

    ch = state.src.charCodeAt(pos++);

    if (ch >= 0x30
    /* 0 */
    && ch <= 0x39
    /* 9 */
    ) {
        // List marker should have no more than 9 digits
        // (prevents integer overflow in browsers)
        if (pos - start >= 10) {
          return -1;
        }

        continue;
      } // found valid marker


    if (ch === 0x29
    /* ) */
    || ch === 0x2e
    /* . */
    ) {
        break;
      }

    return -1;
  }

  if (pos < max) {
    ch = state.src.charCodeAt(pos);

    if (!isSpace(ch)) {
      // " 1.test " - is not a list item
      return -1;
    }
  }

  return pos;
}

function markTightParagraphs(state, idx) {
  var i,
      l,
      level = state.level + 2;

  for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {
      state.tokens[i + 2].hidden = true;
      state.tokens[i].hidden = true;
      i += 2;
    }
  }
}

module.exports = function list(state, startLine, endLine, silent) {
  var ch,
      contentStart,
      i,
      indent,
      indentAfterMarker,
      initial,
      isOrdered,
      itemLines,
      l,
      listLines,
      listTokIdx,
      markerCharCode,
      markerValue,
      max,
      nextLine,
      offset,
      oldListIndent,
      oldParentType,
      oldSCount,
      oldTShift,
      oldTight,
      pos,
      posAfterMarker,
      prevEmptyEnd,
      start,
      terminate,
      terminatorRules,
      token,
      isTerminatingParagraph = false,
      tight = true; // if it's indented more than 3 spaces, it should be a code block

  if (state.sCount[startLine] - state.blkIndent >= 4) {
    return false;
  } // Special case:
  //  - item 1
  //   - item 2
  //    - item 3
  //     - item 4
  //      - this one is a paragraph continuation


  if (state.listIndent >= 0 && state.sCount[startLine] - state.listIndent >= 4 && state.sCount[startLine] < state.blkIndent) {
    return false;
  } // limit conditions when list can interrupt
  // a paragraph (validation mode only)


  if (silent && state.parentType === 'paragraph') {
    // Next list item should still terminate previous list item;
    //
    // This code can fail if plugins use blkIndent as well as lists,
    // but I hope the spec gets fixed long before that happens.
    //
    if (state.tShift[startLine] >= state.blkIndent) {
      isTerminatingParagraph = true;
    }
  } // Detect list type and position after marker


  if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {
    isOrdered = true;
    start = state.bMarks[startLine] + state.tShift[startLine];
    markerValue = Number(state.src.substr(start, posAfterMarker - start - 1)); // If we're starting a new ordered list right after
    // a paragraph, it should start with 1.

    if (isTerminatingParagraph && markerValue !== 1) return false;
  } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {
    isOrdered = false;
  } else {
    return false;
  } // If we're starting a new unordered list right after
  // a paragraph, first line should not be empty.


  if (isTerminatingParagraph) {
    if (state.skipSpaces(posAfterMarker) >= state.eMarks[startLine]) return false;
  } // We should terminate list on style change. Remember first one to compare.


  markerCharCode = state.src.charCodeAt(posAfterMarker - 1); // For validation mode we can terminate immediately

  if (silent) {
    return true;
  } // Start list


  listTokIdx = state.tokens.length;

  if (isOrdered) {
    token = state.push('ordered_list_open', 'ol', 1);

    if (markerValue !== 1) {
      token.attrs = [['start', markerValue]];
    }
  } else {
    token = state.push('bullet_list_open', 'ul', 1);
  }

  token.map = listLines = [startLine, 0];
  token.markup = String.fromCharCode(markerCharCode); //
  // Iterate list items
  //

  nextLine = startLine;
  prevEmptyEnd = false;
  terminatorRules = state.md.block.ruler.getRules('list');
  oldParentType = state.parentType;
  state.parentType = 'list';

  while (nextLine < endLine) {
    pos = posAfterMarker;
    max = state.eMarks[nextLine];
    initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine]);

    while (pos < max) {
      ch = state.src.charCodeAt(pos);

      if (ch === 0x09) {
        offset += 4 - (offset + state.bsCount[nextLine]) % 4;
      } else if (ch === 0x20) {
        offset++;
      } else {
        break;
      }

      pos++;
    }

    contentStart = pos;

    if (contentStart >= max) {
      // trimming space in "-    \n  3" case, indent is 1 here
      indentAfterMarker = 1;
    } else {
      indentAfterMarker = offset - initial;
    } // If we have more than 4 spaces, the indent is 1
    // (the rest is just indented code block)


    if (indentAfterMarker > 4) {
      indentAfterMarker = 1;
    } // "  -  test"
    //  ^^^^^ - calculating total length of this thing


    indent = initial + indentAfterMarker; // Run subparser & write tokens

    token = state.push('list_item_open', 'li', 1);
    token.markup = String.fromCharCode(markerCharCode);
    token.map = itemLines = [startLine, 0]; // change current state, then restore it after parser subcall

    oldTight = state.tight;
    oldTShift = state.tShift[startLine];
    oldSCount = state.sCount[startLine]; //  - example list
    // ^ listIndent position will be here
    //   ^ blkIndent position will be here
    //

    oldListIndent = state.listIndent;
    state.listIndent = state.blkIndent;
    state.blkIndent = indent;
    state.tight = true;
    state.tShift[startLine] = contentStart - state.bMarks[startLine];
    state.sCount[startLine] = offset;

    if (contentStart >= max && state.isEmpty(startLine + 1)) {
      // workaround for this case
      // (list item is empty, list terminates before "foo"):
      // ~~~~~~~~
      //   -
      //
      //     foo
      // ~~~~~~~~
      state.line = Math.min(state.line + 2, endLine);
    } else {
      state.md.block.tokenize(state, startLine, endLine, true);
    } // If any of list item is tight, mark list as tight


    if (!state.tight || prevEmptyEnd) {
      tight = false;
    } // Item become loose if finish with empty line,
    // but we should filter last element, because it means list finish


    prevEmptyEnd = state.line - startLine > 1 && state.isEmpty(state.line - 1);
    state.blkIndent = state.listIndent;
    state.listIndent = oldListIndent;
    state.tShift[startLine] = oldTShift;
    state.sCount[startLine] = oldSCount;
    state.tight = oldTight;
    token = state.push('list_item_close', 'li', -1);
    token.markup = String.fromCharCode(markerCharCode);
    nextLine = startLine = state.line;
    itemLines[1] = nextLine;
    contentStart = state.bMarks[startLine];

    if (nextLine >= endLine) {
      break;
    } //
    // Try to check if list is terminated or continued.
    //


    if (state.sCount[nextLine] < state.blkIndent) {
      break;
    } // if it's indented more than 3 spaces, it should be a code block


    if (state.sCount[startLine] - state.blkIndent >= 4) {
      break;
    } // fail if terminating block found


    terminate = false;

    for (i = 0, l = terminatorRules.length; i < l; i++) {
      if (terminatorRules[i](state, nextLine, endLine, true)) {
        terminate = true;
        break;
      }
    }

    if (terminate) {
      break;
    } // fail if list has another type


    if (isOrdered) {
      posAfterMarker = skipOrderedListMarker(state, nextLine);

      if (posAfterMarker < 0) {
        break;
      }
    } else {
      posAfterMarker = skipBulletListMarker(state, nextLine);

      if (posAfterMarker < 0) {
        break;
      }
    }

    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {
      break;
    }
  } // Finalize list


  if (isOrdered) {
    token = state.push('ordered_list_close', 'ol', -1);
  } else {
    token = state.push('bullet_list_close', 'ul', -1);
  }

  token.markup = String.fromCharCode(markerCharCode);
  listLines[1] = nextLine;
  state.line = nextLine;
  state.parentType = oldParentType; // mark paragraphs tight if needed

  if (tight) {
    markTightParagraphs(state, listTokIdx);
  }

  return true;
};

/***/ }),
/* 170 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var normalizeReference = __webpack_require__(1).normalizeReference;

var isSpace = __webpack_require__(1).isSpace;

module.exports = function reference(state, startLine, _endLine, silent) {
  var ch,
      destEndPos,
      destEndLineNo,
      endLine,
      href,
      i,
      l,
      label,
      labelEnd,
      oldParentType,
      res,
      start,
      str,
      terminate,
      terminatorRules,
      title,
      lines = 0,
      pos = state.bMarks[startLine] + state.tShift[startLine],
      max = state.eMarks[startLine],
      nextLine = startLine + 1; // if it's indented more than 3 spaces, it should be a code block

  if (state.sCount[startLine] - state.blkIndent >= 4) {
    return false;
  }

  if (state.src.charCodeAt(pos) !== 0x5B
  /* [ */
  ) {
      return false;
    } // Simple check to quickly interrupt scan on [link](url) at the start of line.
  // Can be useful on practice: https://github.com/markdown-it/markdown-it/issues/54


  while (++pos < max) {
    if (state.src.charCodeAt(pos) === 0x5D
    /* ] */
    && state.src.charCodeAt(pos - 1) !== 0x5C
    /* \ */
    ) {
        if (pos + 1 === max) {
          return false;
        }

        if (state.src.charCodeAt(pos + 1) !== 0x3A
        /* : */
        ) {
            return false;
          }

        break;
      }
  }

  endLine = state.lineMax; // jump line-by-line until empty one or EOF

  terminatorRules = state.md.block.ruler.getRules('reference');
  oldParentType = state.parentType;
  state.parentType = 'reference';

  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
    // this would be a code block normally, but after paragraph
    // it's considered a lazy continuation regardless of what's there
    if (state.sCount[nextLine] - state.blkIndent > 3) {
      continue;
    } // quirk for blockquotes, this line should already be checked by that rule


    if (state.sCount[nextLine] < 0) {
      continue;
    } // Some tags can terminate paragraph without empty line.


    terminate = false;

    for (i = 0, l = terminatorRules.length; i < l; i++) {
      if (terminatorRules[i](state, nextLine, endLine, true)) {
        terminate = true;
        break;
      }
    }

    if (terminate) {
      break;
    }
  }

  str = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
  max = str.length;

  for (pos = 1; pos < max; pos++) {
    ch = str.charCodeAt(pos);

    if (ch === 0x5B
    /* [ */
    ) {
        return false;
      } else if (ch === 0x5D
    /* ] */
    ) {
        labelEnd = pos;
        break;
      } else if (ch === 0x0A
    /* \n */
    ) {
        lines++;
      } else if (ch === 0x5C
    /* \ */
    ) {
        pos++;

        if (pos < max && str.charCodeAt(pos) === 0x0A) {
          lines++;
        }
      }
  }

  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A
  /* : */
  ) {
      return false;
    } // [label]:   destination   'title'
  //         ^^^ skip optional whitespace here


  for (pos = labelEnd + 2; pos < max; pos++) {
    ch = str.charCodeAt(pos);

    if (ch === 0x0A) {
      lines++;
    } else if (isSpace(ch)) {
      /*eslint no-empty:0*/
    } else {
      break;
    }
  } // [label]:   destination   'title'
  //            ^^^^^^^^^^^ parse this


  res = state.md.helpers.parseLinkDestination(str, pos, max);

  if (!res.ok) {
    return false;
  }

  href = state.md.normalizeLink(res.str);

  if (!state.md.validateLink(href)) {
    return false;
  }

  pos = res.pos;
  lines += res.lines; // save cursor state, we could require to rollback later

  destEndPos = pos;
  destEndLineNo = lines; // [label]:   destination   'title'
  //                       ^^^ skipping those spaces

  start = pos;

  for (; pos < max; pos++) {
    ch = str.charCodeAt(pos);

    if (ch === 0x0A) {
      lines++;
    } else if (isSpace(ch)) {
      /*eslint no-empty:0*/
    } else {
      break;
    }
  } // [label]:   destination   'title'
  //                          ^^^^^^^ parse this


  res = state.md.helpers.parseLinkTitle(str, pos, max);

  if (pos < max && start !== pos && res.ok) {
    title = res.str;
    pos = res.pos;
    lines += res.lines;
  } else {
    title = '';
    pos = destEndPos;
    lines = destEndLineNo;
  } // skip trailing spaces until the rest of the line


  while (pos < max) {
    ch = str.charCodeAt(pos);

    if (!isSpace(ch)) {
      break;
    }

    pos++;
  }

  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
    if (title) {
      // garbage at the end of the line after title,
      // but it could still be a valid reference if we roll back
      title = '';
      pos = destEndPos;
      lines = destEndLineNo;

      while (pos < max) {
        ch = str.charCodeAt(pos);

        if (!isSpace(ch)) {
          break;
        }

        pos++;
      }
    }
  }

  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
    // garbage at the end of the line
    return false;
  }

  label = normalizeReference(str.slice(1, labelEnd));

  if (!label) {
    // CommonMark 0.20 disallows empty labels
    return false;
  } // Reference can not terminate anything. This check is for safety only.

  /*istanbul ignore if*/


  if (silent) {
    return true;
  }

  if (typeof state.env.references === 'undefined') {
    state.env.references = {};
  }

  if (typeof state.env.references[label] === 'undefined') {
    state.env.references[label] = {
      title: title,
      href: href
    };
  }

  state.parentType = oldParentType;
  state.line = startLine + lines + 1;
  return true;
};

/***/ }),
/* 171 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// heading (#, ##, ...)


var isSpace = __webpack_require__(1).isSpace;

module.exports = function heading(state, startLine, endLine, silent) {
  var ch,
      level,
      tmp,
      token,
      pos = state.bMarks[startLine] + state.tShift[startLine],
      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block

  if (state.sCount[startLine] - state.blkIndent >= 4) {
    return false;
  }

  ch = state.src.charCodeAt(pos);

  if (ch !== 0x23
  /* # */
  || pos >= max) {
    return false;
  } // count heading level


  level = 1;
  ch = state.src.charCodeAt(++pos);

  while (ch === 0x23
  /* # */
  && pos < max && level <= 6) {
    level++;
    ch = state.src.charCodeAt(++pos);
  }

  if (level > 6 || pos < max && !isSpace(ch)) {
    return false;
  }

  if (silent) {
    return true;
  } // Let's cut tails like '    ###  ' from the end of string


  max = state.skipSpacesBack(max, pos);
  tmp = state.skipCharsBack(max, 0x23, pos); // #

  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
    max = tmp;
  }

  state.line = startLine + 1;
  token = state.push('heading_open', 'h' + String(level), 1);
  token.markup = '########'.slice(0, level);
  token.map = [startLine, state.line];
  token = state.push('inline', '', 0);
  token.content = state.src.slice(pos, max).trim();
  token.map = [startLine, state.line];
  token.children = [];
  token = state.push('heading_close', 'h' + String(level), -1);
  token.markup = '########'.slice(0, level);
  return true;
};

/***/ }),
/* 172 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// lheading (---, ===)


module.exports = function lheading(state, startLine, endLine
/*, silent*/
) {
  var content,
      terminate,
      i,
      l,
      token,
      pos,
      max,
      level,
      marker,
      nextLine = startLine + 1,
      oldParentType,
      terminatorRules = state.md.block.ruler.getRules('paragraph'); // if it's indented more than 3 spaces, it should be a code block

  if (state.sCount[startLine] - state.blkIndent >= 4) {
    return false;
  }

  oldParentType = state.parentType;
  state.parentType = 'paragraph'; // use paragraph to match terminatorRules
  // jump line-by-line until empty one or EOF

  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
    // this would be a code block normally, but after paragraph
    // it's considered a lazy continuation regardless of what's there
    if (state.sCount[nextLine] - state.blkIndent > 3) {
      continue;
    } //
    // Check for underline in setext header
    //


    if (state.sCount[nextLine] >= state.blkIndent) {
      pos = state.bMarks[nextLine] + state.tShift[nextLine];
      max = state.eMarks[nextLine];

      if (pos < max) {
        marker = state.src.charCodeAt(pos);

        if (marker === 0x2D
        /* - */
        || marker === 0x3D
        /* = */
        ) {
            pos = state.skipChars(pos, marker);
            pos = state.skipSpaces(pos);

            if (pos >= max) {
              level = marker === 0x3D
              /* = */
              ? 1 : 2;
              break;
            }
          }
      }
    } // quirk for blockquotes, this line should already be checked by that rule


    if (state.sCount[nextLine] < 0) {
      continue;
    } // Some tags can terminate paragraph without empty line.


    terminate = false;

    for (i = 0, l = terminatorRules.length; i < l; i++) {
      if (terminatorRules[i](state, nextLine, endLine, true)) {
        terminate = true;
        break;
      }
    }

    if (terminate) {
      break;
    }
  }

  if (!level) {
    // Didn't find valid underline
    return false;
  }

  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
  state.line = nextLine + 1;
  token = state.push('heading_open', 'h' + String(level), 1);
  token.markup = String.fromCharCode(marker);
  token.map = [startLine, state.line];
  token = state.push('inline', '', 0);
  token.content = content;
  token.map = [startLine, state.line - 1];
  token.children = [];
  token = state.push('heading_close', 'h' + String(level), -1);
  token.markup = String.fromCharCode(marker);
  state.parentType = oldParentType;
  return true;
};

/***/ }),
/* 173 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// HTML block


var block_names = __webpack_require__(174);

var HTML_OPEN_CLOSE_TAG_RE = __webpack_require__(67).HTML_OPEN_CLOSE_TAG_RE; // An array of opening and corresponding closing sequences for html tags,
// last argument defines whether it can terminate a paragraph or not
//


var HTML_SEQUENCES = [[/^<(script|pre|style)(?=(\s|>|$))/i, /<\/(script|pre|style)>/i, true], [/^<!--/, /-->/, true], [/^<\?/, /\?>/, true], [/^<![A-Z]/, />/, true], [/^<!\[CDATA\[/, /\]\]>/, true], [new RegExp('^</?(' + block_names.join('|') + ')(?=(\\s|/?>|$))', 'i'), /^$/, true], [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\s*$'), /^$/, false]];

module.exports = function html_block(state, startLine, endLine, silent) {
  var i,
      nextLine,
      token,
      lineText,
      pos = state.bMarks[startLine] + state.tShift[startLine],
      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block

  if (state.sCount[startLine] - state.blkIndent >= 4) {
    return false;
  }

  if (!state.md.options.html) {
    return false;
  }

  if (state.src.charCodeAt(pos) !== 0x3C
  /* < */
  ) {
      return false;
    }

  lineText = state.src.slice(pos, max);

  for (i = 0; i < HTML_SEQUENCES.length; i++) {
    if (HTML_SEQUENCES[i][0].test(lineText)) {
      break;
    }
  }

  if (i === HTML_SEQUENCES.length) {
    return false;
  }

  if (silent) {
    // true if this sequence can be a terminator, false otherwise
    return HTML_SEQUENCES[i][2];
  }

  nextLine = startLine + 1; // If we are here - we detected HTML block.
  // Let's roll down till block end.

  if (!HTML_SEQUENCES[i][1].test(lineText)) {
    for (; nextLine < endLine; nextLine++) {
      if (state.sCount[nextLine] < state.blkIndent) {
        break;
      }

      pos = state.bMarks[nextLine] + state.tShift[nextLine];
      max = state.eMarks[nextLine];
      lineText = state.src.slice(pos, max);

      if (HTML_SEQUENCES[i][1].test(lineText)) {
        if (lineText.length !== 0) {
          nextLine++;
        }

        break;
      }
    }
  }

  state.line = nextLine;
  token = state.push('html_block', '', 0);
  token.map = [startLine, nextLine];
  token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
  return true;
};

/***/ }),
/* 174 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// List of valid html blocks names, accorting to commonmark spec
// http://jgm.github.io/CommonMark/spec.html#html-blocks


module.exports = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'meta', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section', 'source', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];

/***/ }),
/* 175 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Paragraph


module.exports = function paragraph(state, startLine
/*, endLine*/
) {
  var content,
      terminate,
      i,
      l,
      token,
      oldParentType,
      nextLine = startLine + 1,
      terminatorRules = state.md.block.ruler.getRules('paragraph'),
      endLine = state.lineMax;
  oldParentType = state.parentType;
  state.parentType = 'paragraph'; // jump line-by-line until empty one or EOF

  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
    // this would be a code block normally, but after paragraph
    // it's considered a lazy continuation regardless of what's there
    if (state.sCount[nextLine] - state.blkIndent > 3) {
      continue;
    } // quirk for blockquotes, this line should already be checked by that rule


    if (state.sCount[nextLine] < 0) {
      continue;
    } // Some tags can terminate paragraph without empty line.


    terminate = false;

    for (i = 0, l = terminatorRules.length; i < l; i++) {
      if (terminatorRules[i](state, nextLine, endLine, true)) {
        terminate = true;
        break;
      }
    }

    if (terminate) {
      break;
    }
  }

  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
  state.line = nextLine;
  token = state.push('paragraph_open', 'p', 1);
  token.map = [startLine, state.line];
  token = state.push('inline', '', 0);
  token.content = content;
  token.map = [startLine, state.line];
  token.children = [];
  token = state.push('paragraph_close', 'p', -1);
  state.parentType = oldParentType;
  return true;
};

/***/ }),
/* 176 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Parser state class


var Token = __webpack_require__(41);

var isSpace = __webpack_require__(1).isSpace;

function StateBlock(src, md, env, tokens) {
  var ch, s, start, pos, len, indent, offset, indent_found;
  this.src = src; // link to parser instance

  this.md = md;
  this.env = env; //
  // Internal state vartiables
  //

  this.tokens = tokens;
  this.bMarks = []; // line begin offsets for fast jumps

  this.eMarks = []; // line end offsets for fast jumps

  this.tShift = []; // offsets of the first non-space characters (tabs not expanded)

  this.sCount = []; // indents for each line (tabs expanded)
  // An amount of virtual spaces (tabs expanded) between beginning
  // of each line (bMarks) and real beginning of that line.
  //
  // It exists only as a hack because blockquotes override bMarks
  // losing information in the process.
  //
  // It's used only when expanding tabs, you can think about it as
  // an initial tab length, e.g. bsCount=21 applied to string `\t123`
  // means first tab should be expanded to 4-21%4 === 3 spaces.
  //

  this.bsCount = []; // block parser variables

  this.blkIndent = 0; // required block content indent (for example, if we are
  // inside a list, it would be positioned after list marker)

  this.line = 0; // line index in src

  this.lineMax = 0; // lines count

  this.tight = false; // loose/tight mode for lists

  this.ddIndent = -1; // indent of the current dd block (-1 if there isn't any)

  this.listIndent = -1; // indent of the current list block (-1 if there isn't any)
  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
  // used in lists to determine if they interrupt a paragraph

  this.parentType = 'root';
  this.level = 0; // renderer

  this.result = ''; // Create caches
  // Generate markers.

  s = this.src;
  indent_found = false;

  for (start = pos = indent = offset = 0, len = s.length; pos < len; pos++) {
    ch = s.charCodeAt(pos);

    if (!indent_found) {
      if (isSpace(ch)) {
        indent++;

        if (ch === 0x09) {
          offset += 4 - offset % 4;
        } else {
          offset++;
        }

        continue;
      } else {
        indent_found = true;
      }
    }

    if (ch === 0x0A || pos === len - 1) {
      if (ch !== 0x0A) {
        pos++;
      }

      this.bMarks.push(start);
      this.eMarks.push(pos);
      this.tShift.push(indent);
      this.sCount.push(offset);
      this.bsCount.push(0);
      indent_found = false;
      indent = 0;
      offset = 0;
      start = pos + 1;
    }
  } // Push fake entry to simplify cache bounds checks


  this.bMarks.push(s.length);
  this.eMarks.push(s.length);
  this.tShift.push(0);
  this.sCount.push(0);
  this.bsCount.push(0);
  this.lineMax = this.bMarks.length - 1; // don't count last fake line
} // Push new token to "stream".
//


StateBlock.prototype.push = function (type, tag, nesting) {
  var token = new Token(type, tag, nesting);
  token.block = true;
  if (nesting < 0) this.level--; // closing tag

  token.level = this.level;
  if (nesting > 0) this.level++; // opening tag

  this.tokens.push(token);
  return token;
};

StateBlock.prototype.isEmpty = function isEmpty(line) {
  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
};

StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
  for (var max = this.lineMax; from < max; from++) {
    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
      break;
    }
  }

  return from;
}; // Skip spaces from given position.


StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
  var ch;

  for (var max = this.src.length; pos < max; pos++) {
    ch = this.src.charCodeAt(pos);

    if (!isSpace(ch)) {
      break;
    }
  }

  return pos;
}; // Skip spaces from given position in reverse.


StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
  if (pos <= min) {
    return pos;
  }

  while (pos > min) {
    if (!isSpace(this.src.charCodeAt(--pos))) {
      return pos + 1;
    }
  }

  return pos;
}; // Skip char codes from given position


StateBlock.prototype.skipChars = function skipChars(pos, code) {
  for (var max = this.src.length; pos < max; pos++) {
    if (this.src.charCodeAt(pos) !== code) {
      break;
    }
  }

  return pos;
}; // Skip char codes reverse from given position - 1


StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {
  if (pos <= min) {
    return pos;
  }

  while (pos > min) {
    if (code !== this.src.charCodeAt(--pos)) {
      return pos + 1;
    }
  }

  return pos;
}; // cut lines range from source.


StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {
  var i,
      lineIndent,
      ch,
      first,
      last,
      queue,
      lineStart,
      line = begin;

  if (begin >= end) {
    return '';
  }

  queue = new Array(end - begin);

  for (i = 0; line < end; line++, i++) {
    lineIndent = 0;
    lineStart = first = this.bMarks[line];

    if (line + 1 < end || keepLastLF) {
      // No need for bounds check because we have fake entry on tail.
      last = this.eMarks[line] + 1;
    } else {
      last = this.eMarks[line];
    }

    while (first < last && lineIndent < indent) {
      ch = this.src.charCodeAt(first);

      if (isSpace(ch)) {
        if (ch === 0x09) {
          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
        } else {
          lineIndent++;
        }
      } else if (first - lineStart < this.tShift[line]) {
        // patched tShift masked characters to look like spaces (blockquotes, list markers)
        lineIndent++;
      } else {
        break;
      }

      first++;
    }

    if (lineIndent > indent) {
      // partially expanding tabs in code blocks, e.g '\t\tfoobar'
      // with indent=2 becomes '  \tfoobar'
      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last);
    } else {
      queue[i] = this.src.slice(first, last);
    }
  }

  return queue.join('');
}; // re-export Token class to use in block rules


StateBlock.prototype.Token = Token;
module.exports = StateBlock;

/***/ }),
/* 177 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/** internal
 * class ParserInline
 *
 * Tokenizes paragraph content.
 **/


var Ruler = __webpack_require__(40); ////////////////////////////////////////////////////////////////////////////////
// Parser rules


var _rules = [['text', __webpack_require__(178)], ['newline', __webpack_require__(179)], ['escape', __webpack_require__(180)], ['backticks', __webpack_require__(181)], ['strikethrough', __webpack_require__(68).tokenize], ['emphasis', __webpack_require__(69).tokenize], ['link', __webpack_require__(182)], ['image', __webpack_require__(183)], ['autolink', __webpack_require__(184)], ['html_inline', __webpack_require__(185)], ['entity', __webpack_require__(186)]];
var _rules2 = [['balance_pairs', __webpack_require__(187)], ['strikethrough', __webpack_require__(68).postProcess], ['emphasis', __webpack_require__(69).postProcess], ['text_collapse', __webpack_require__(188)]];
/**
 * new ParserInline()
 **/

function ParserInline() {
  var i;
  /**
   * ParserInline#ruler -> Ruler
   *
   * [[Ruler]] instance. Keep configuration of inline rules.
   **/

  this.ruler = new Ruler();

  for (i = 0; i < _rules.length; i++) {
    this.ruler.push(_rules[i][0], _rules[i][1]);
  }
  /**
   * ParserInline#ruler2 -> Ruler
   *
   * [[Ruler]] instance. Second ruler used for post-processing
   * (e.g. in emphasis-like rules).
   **/


  this.ruler2 = new Ruler();

  for (i = 0; i < _rules2.length; i++) {
    this.ruler2.push(_rules2[i][0], _rules2[i][1]);
  }
} // Skip single token by running all rules in validation mode;
// returns `true` if any rule reported success
//


ParserInline.prototype.skipToken = function (state) {
  var ok,
      i,
      pos = state.pos,
      rules = this.ruler.getRules(''),
      len = rules.length,
      maxNesting = state.md.options.maxNesting,
      cache = state.cache;

  if (typeof cache[pos] !== 'undefined') {
    state.pos = cache[pos];
    return;
  }

  if (state.level < maxNesting) {
    for (i = 0; i < len; i++) {
      // Increment state.level and decrement it later to limit recursion.
      // It's harmless to do here, because no tokens are created. But ideally,
      // we'd need a separate private state variable for this purpose.
      //
      state.level++;
      ok = rules[i](state, true);
      state.level--;

      if (ok) {
        break;
      }
    }
  } else {
    // Too much nesting, just skip until the end of the paragraph.
    //
    // NOTE: this will cause links to behave incorrectly in the following case,
    //       when an amount of `[` is exactly equal to `maxNesting + 1`:
    //
    //       [[[[[[[[[[[[[[[[[[[[[foo]()
    //
    // TODO: remove this workaround when CM standard will allow nested links
    //       (we can replace it by preventing links from being parsed in
    //       validation mode)
    //
    state.pos = state.posMax;
  }

  if (!ok) {
    state.pos++;
  }

  cache[pos] = state.pos;
}; // Generate tokens for input range
//


ParserInline.prototype.tokenize = function (state) {
  var ok,
      i,
      rules = this.ruler.getRules(''),
      len = rules.length,
      end = state.posMax,
      maxNesting = state.md.options.maxNesting;

  while (state.pos < end) {
    // Try all possible rules.
    // On success, rule should:
    //
    // - update `state.pos`
    // - update `state.tokens`
    // - return true
    if (state.level < maxNesting) {
      for (i = 0; i < len; i++) {
        ok = rules[i](state, false);

        if (ok) {
          break;
        }
      }
    }

    if (ok) {
      if (state.pos >= end) {
        break;
      }

      continue;
    }

    state.pending += state.src[state.pos++];
  }

  if (state.pending) {
    state.pushPending();
  }
};
/**
 * ParserInline.parse(str, md, env, outTokens)
 *
 * Process input string and push inline tokens into `outTokens`
 **/


ParserInline.prototype.parse = function (str, md, env, outTokens) {
  var i, rules, len;
  var state = new this.State(str, md, env, outTokens);
  this.tokenize(state);
  rules = this.ruler2.getRules('');
  len = rules.length;

  for (i = 0; i < len; i++) {
    rules[i](state);
  }
};

ParserInline.prototype.State = __webpack_require__(189);
module.exports = ParserInline;

/***/ }),
/* 178 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Skip text characters for text token, place those to pending buffer
// and increment current pos
 // Rule to skip pure text
// '{}$%@~+=:' reserved for extentions
// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
// !!!! Don't confuse with "Markdown ASCII Punctuation" chars
// http://spec.commonmark.org/0.15/#ascii-punctuation-character

function isTerminatorChar(ch) {
  switch (ch) {
    case 0x0A
    /* \n */
    :
    case 0x21
    /* ! */
    :
    case 0x23
    /* # */
    :
    case 0x24
    /* $ */
    :
    case 0x25
    /* % */
    :
    case 0x26
    /* & */
    :
    case 0x2A
    /* * */
    :
    case 0x2B
    /* + */
    :
    case 0x2D
    /* - */
    :
    case 0x3A
    /* : */
    :
    case 0x3C
    /* < */
    :
    case 0x3D
    /* = */
    :
    case 0x3E
    /* > */
    :
    case 0x40
    /* @ */
    :
    case 0x5B
    /* [ */
    :
    case 0x5C
    /* \ */
    :
    case 0x5D
    /* ] */
    :
    case 0x5E
    /* ^ */
    :
    case 0x5F
    /* _ */
    :
    case 0x60
    /* ` */
    :
    case 0x7B
    /* { */
    :
    case 0x7D
    /* } */
    :
    case 0x7E
    /* ~ */
    :
      return true;

    default:
      return false;
  }
}

module.exports = function text(state, silent) {
  var pos = state.pos;

  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
    pos++;
  }

  if (pos === state.pos) {
    return false;
  }

  if (!silent) {
    state.pending += state.src.slice(state.pos, pos);
  }

  state.pos = pos;
  return true;
}; // Alternative implementation, for memory.
//
// It costs 10% of performance, but allows extend terminators list, if place it
// to `ParcerInline` property. Probably, will switch to it sometime, such
// flexibility required.

/*
var TERMINATOR_RE = /[\n!#$%&*+\-:<=>@[\\\]^_`{}~]/;

module.exports = function text(state, silent) {
  var pos = state.pos,
      idx = state.src.slice(pos).search(TERMINATOR_RE);

  // first char is terminator -> empty text
  if (idx === 0) { return false; }

  // no terminator -> text till end of string
  if (idx < 0) {
    if (!silent) { state.pending += state.src.slice(pos); }
    state.pos = state.src.length;
    return true;
  }

  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }

  state.pos += idx;

  return true;
};*/

/***/ }),
/* 179 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Proceess '\n'


var isSpace = __webpack_require__(1).isSpace;

module.exports = function newline(state, silent) {
  var pmax,
      max,
      pos = state.pos;

  if (state.src.charCodeAt(pos) !== 0x0A
  /* \n */
  ) {
      return false;
    }

  pmax = state.pending.length - 1;
  max = state.posMax; // '  \n' -> hardbreak
  // Lookup in pending chars is bad practice! Don't copy to other rules!
  // Pending string is stored in concat mode, indexed lookups will cause
  // convertion to flat mode.

  if (!silent) {
    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {
      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {
        state.pending = state.pending.replace(/ +$/, '');
        state.push('hardbreak', 'br', 0);
      } else {
        state.pending = state.pending.slice(0, -1);
        state.push('softbreak', 'br', 0);
      }
    } else {
      state.push('softbreak', 'br', 0);
    }
  }

  pos++; // skip heading spaces for next line

  while (pos < max && isSpace(state.src.charCodeAt(pos))) {
    pos++;
  }

  state.pos = pos;
  return true;
};

/***/ }),
/* 180 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Process escaped chars and hardbreaks


var isSpace = __webpack_require__(1).isSpace;

var ESCAPED = [];

for (var i = 0; i < 256; i++) {
  ESCAPED.push(0);
}

'\\!"#$%&\'()*+,./:;<=>?@[]^_`{|}~-'.split('').forEach(function (ch) {
  ESCAPED[ch.charCodeAt(0)] = 1;
});

module.exports = function escape(state, silent) {
  var ch,
      pos = state.pos,
      max = state.posMax;

  if (state.src.charCodeAt(pos) !== 0x5C
  /* \ */
  ) {
      return false;
    }

  pos++;

  if (pos < max) {
    ch = state.src.charCodeAt(pos);

    if (ch < 256 && ESCAPED[ch] !== 0) {
      if (!silent) {
        state.pending += state.src[pos];
      }

      state.pos += 2;
      return true;
    }

    if (ch === 0x0A) {
      if (!silent) {
        state.push('hardbreak', 'br', 0);
      }

      pos++; // skip leading whitespaces from next line

      while (pos < max) {
        ch = state.src.charCodeAt(pos);

        if (!isSpace(ch)) {
          break;
        }

        pos++;
      }

      state.pos = pos;
      return true;
    }
  }

  if (!silent) {
    state.pending += '\\';
  }

  state.pos++;
  return true;
};

/***/ }),
/* 181 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Parse backticks


module.exports = function backtick(state, silent) {
  var start,
      max,
      marker,
      matchStart,
      matchEnd,
      token,
      pos = state.pos,
      ch = state.src.charCodeAt(pos);

  if (ch !== 0x60
  /* ` */
  ) {
      return false;
    }

  start = pos;
  pos++;
  max = state.posMax;

  while (pos < max && state.src.charCodeAt(pos) === 0x60
  /* ` */
  ) {
    pos++;
  }

  marker = state.src.slice(start, pos);
  matchStart = matchEnd = pos;

  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {
    matchEnd = matchStart + 1;

    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60
    /* ` */
    ) {
      matchEnd++;
    }

    if (matchEnd - matchStart === marker.length) {
      if (!silent) {
        token = state.push('code_inline', 'code', 0);
        token.markup = marker;
        token.content = state.src.slice(pos, matchStart).replace(/\n/g, ' ').replace(/^ (.+) $/, '$1');
      }

      state.pos = matchEnd;
      return true;
    }
  }

  if (!silent) {
    state.pending += marker;
  }

  state.pos += marker.length;
  return true;
};

/***/ }),
/* 182 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Process [link](<to> "stuff")


var normalizeReference = __webpack_require__(1).normalizeReference;

var isSpace = __webpack_require__(1).isSpace;

module.exports = function link(state, silent) {
  var attrs,
      code,
      label,
      labelEnd,
      labelStart,
      pos,
      res,
      ref,
      title,
      token,
      href = '',
      oldPos = state.pos,
      max = state.posMax,
      start = state.pos,
      parseReference = true;

  if (state.src.charCodeAt(state.pos) !== 0x5B
  /* [ */
  ) {
      return false;
    }

  labelStart = state.pos + 1;
  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true); // parser failed to find ']', so it's not a valid link

  if (labelEnd < 0) {
    return false;
  }

  pos = labelEnd + 1;

  if (pos < max && state.src.charCodeAt(pos) === 0x28
  /* ( */
  ) {
      //
      // Inline link
      //
      // might have found a valid shortcut link, disable reference parsing
      parseReference = false; // [link](  <href>  "title"  )
      //        ^^ skipping these spaces

      pos++;

      for (; pos < max; pos++) {
        code = state.src.charCodeAt(pos);

        if (!isSpace(code) && code !== 0x0A) {
          break;
        }
      }

      if (pos >= max) {
        return false;
      } // [link](  <href>  "title"  )
      //          ^^^^^^ parsing link destination


      start = pos;
      res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);

      if (res.ok) {
        href = state.md.normalizeLink(res.str);

        if (state.md.validateLink(href)) {
          pos = res.pos;
        } else {
          href = '';
        }
      } // [link](  <href>  "title"  )
      //                ^^ skipping these spaces


      start = pos;

      for (; pos < max; pos++) {
        code = state.src.charCodeAt(pos);

        if (!isSpace(code) && code !== 0x0A) {
          break;
        }
      } // [link](  <href>  "title"  )
      //                  ^^^^^^^ parsing link title


      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);

      if (pos < max && start !== pos && res.ok) {
        title = res.str;
        pos = res.pos; // [link](  <href>  "title"  )
        //                         ^^ skipping these spaces

        for (; pos < max; pos++) {
          code = state.src.charCodeAt(pos);

          if (!isSpace(code) && code !== 0x0A) {
            break;
          }
        }
      } else {
        title = '';
      }

      if (pos >= max || state.src.charCodeAt(pos) !== 0x29
      /* ) */
      ) {
          // parsing a valid shortcut link failed, fallback to reference
          parseReference = true;
        }

      pos++;
    }

  if (parseReference) {
    //
    // Link reference
    //
    if (typeof state.env.references === 'undefined') {
      return false;
    }

    if (pos < max && state.src.charCodeAt(pos) === 0x5B
    /* [ */
    ) {
        start = pos + 1;
        pos = state.md.helpers.parseLinkLabel(state, pos);

        if (pos >= 0) {
          label = state.src.slice(start, pos++);
        } else {
          pos = labelEnd + 1;
        }
      } else {
      pos = labelEnd + 1;
    } // covers label === '' and label === undefined
    // (collapsed reference link and shortcut reference link respectively)


    if (!label) {
      label = state.src.slice(labelStart, labelEnd);
    }

    ref = state.env.references[normalizeReference(label)];

    if (!ref) {
      state.pos = oldPos;
      return false;
    }

    href = ref.href;
    title = ref.title;
  } //
  // We found the end of the link, and know for a fact it's a valid link;
  // so all that's left to do is to call tokenizer.
  //


  if (!silent) {
    state.pos = labelStart;
    state.posMax = labelEnd;
    token = state.push('link_open', 'a', 1);
    token.attrs = attrs = [['href', href]];

    if (title) {
      attrs.push(['title', title]);
    }

    state.md.inline.tokenize(state);
    token = state.push('link_close', 'a', -1);
  }

  state.pos = pos;
  state.posMax = max;
  return true;
};

/***/ }),
/* 183 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Process ![image](<src> "title")


var normalizeReference = __webpack_require__(1).normalizeReference;

var isSpace = __webpack_require__(1).isSpace;

module.exports = function image(state, silent) {
  var attrs,
      code,
      content,
      label,
      labelEnd,
      labelStart,
      pos,
      ref,
      res,
      title,
      token,
      tokens,
      start,
      href = '',
      oldPos = state.pos,
      max = state.posMax;

  if (state.src.charCodeAt(state.pos) !== 0x21
  /* ! */
  ) {
      return false;
    }

  if (state.src.charCodeAt(state.pos + 1) !== 0x5B
  /* [ */
  ) {
      return false;
    }

  labelStart = state.pos + 2;
  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false); // parser failed to find ']', so it's not a valid link

  if (labelEnd < 0) {
    return false;
  }

  pos = labelEnd + 1;

  if (pos < max && state.src.charCodeAt(pos) === 0x28
  /* ( */
  ) {
      //
      // Inline link
      //
      // [link](  <href>  "title"  )
      //        ^^ skipping these spaces
      pos++;

      for (; pos < max; pos++) {
        code = state.src.charCodeAt(pos);

        if (!isSpace(code) && code !== 0x0A) {
          break;
        }
      }

      if (pos >= max) {
        return false;
      } // [link](  <href>  "title"  )
      //          ^^^^^^ parsing link destination


      start = pos;
      res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);

      if (res.ok) {
        href = state.md.normalizeLink(res.str);

        if (state.md.validateLink(href)) {
          pos = res.pos;
        } else {
          href = '';
        }
      } // [link](  <href>  "title"  )
      //                ^^ skipping these spaces


      start = pos;

      for (; pos < max; pos++) {
        code = state.src.charCodeAt(pos);

        if (!isSpace(code) && code !== 0x0A) {
          break;
        }
      } // [link](  <href>  "title"  )
      //                  ^^^^^^^ parsing link title


      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);

      if (pos < max && start !== pos && res.ok) {
        title = res.str;
        pos = res.pos; // [link](  <href>  "title"  )
        //                         ^^ skipping these spaces

        for (; pos < max; pos++) {
          code = state.src.charCodeAt(pos);

          if (!isSpace(code) && code !== 0x0A) {
            break;
          }
        }
      } else {
        title = '';
      }

      if (pos >= max || state.src.charCodeAt(pos) !== 0x29
      /* ) */
      ) {
          state.pos = oldPos;
          return false;
        }

      pos++;
    } else {
    //
    // Link reference
    //
    if (typeof state.env.references === 'undefined') {
      return false;
    }

    if (pos < max && state.src.charCodeAt(pos) === 0x5B
    /* [ */
    ) {
        start = pos + 1;
        pos = state.md.helpers.parseLinkLabel(state, pos);

        if (pos >= 0) {
          label = state.src.slice(start, pos++);
        } else {
          pos = labelEnd + 1;
        }
      } else {
      pos = labelEnd + 1;
    } // covers label === '' and label === undefined
    // (collapsed reference link and shortcut reference link respectively)


    if (!label) {
      label = state.src.slice(labelStart, labelEnd);
    }

    ref = state.env.references[normalizeReference(label)];

    if (!ref) {
      state.pos = oldPos;
      return false;
    }

    href = ref.href;
    title = ref.title;
  } //
  // We found the end of the link, and know for a fact it's a valid link;
  // so all that's left to do is to call tokenizer.
  //


  if (!silent) {
    content = state.src.slice(labelStart, labelEnd);
    state.md.inline.parse(content, state.md, state.env, tokens = []);
    token = state.push('image', 'img', 0);
    token.attrs = attrs = [['src', href], ['alt', '']];
    token.children = tokens;
    token.content = content;

    if (title) {
      attrs.push(['title', title]);
    }
  }

  state.pos = pos;
  state.posMax = max;
  return true;
};

/***/ }),
/* 184 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Process autolinks '<protocol:...>'

/*eslint max-len:0*/

var EMAIL_RE = /^<([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;
var AUTOLINK_RE = /^<([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)>/;

module.exports = function autolink(state, silent) {
  var tail,
      linkMatch,
      emailMatch,
      url,
      fullUrl,
      token,
      pos = state.pos;

  if (state.src.charCodeAt(pos) !== 0x3C
  /* < */
  ) {
      return false;
    }

  tail = state.src.slice(pos);

  if (tail.indexOf('>') < 0) {
    return false;
  }

  if (AUTOLINK_RE.test(tail)) {
    linkMatch = tail.match(AUTOLINK_RE);
    url = linkMatch[0].slice(1, -1);
    fullUrl = state.md.normalizeLink(url);

    if (!state.md.validateLink(fullUrl)) {
      return false;
    }

    if (!silent) {
      token = state.push('link_open', 'a', 1);
      token.attrs = [['href', fullUrl]];
      token.markup = 'autolink';
      token.info = 'auto';
      token = state.push('text', '', 0);
      token.content = state.md.normalizeLinkText(url);
      token = state.push('link_close', 'a', -1);
      token.markup = 'autolink';
      token.info = 'auto';
    }

    state.pos += linkMatch[0].length;
    return true;
  }

  if (EMAIL_RE.test(tail)) {
    emailMatch = tail.match(EMAIL_RE);
    url = emailMatch[0].slice(1, -1);
    fullUrl = state.md.normalizeLink('mailto:' + url);

    if (!state.md.validateLink(fullUrl)) {
      return false;
    }

    if (!silent) {
      token = state.push('link_open', 'a', 1);
      token.attrs = [['href', fullUrl]];
      token.markup = 'autolink';
      token.info = 'auto';
      token = state.push('text', '', 0);
      token.content = state.md.normalizeLinkText(url);
      token = state.push('link_close', 'a', -1);
      token.markup = 'autolink';
      token.info = 'auto';
    }

    state.pos += emailMatch[0].length;
    return true;
  }

  return false;
};

/***/ }),
/* 185 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Process html tags


var HTML_TAG_RE = __webpack_require__(67).HTML_TAG_RE;

function isLetter(ch) {
  /*eslint no-bitwise:0*/
  var lc = ch | 0x20; // to lower case

  return lc >= 0x61
  /* a */
  && lc <= 0x7a
  /* z */
  ;
}

module.exports = function html_inline(state, silent) {
  var ch,
      match,
      max,
      token,
      pos = state.pos;

  if (!state.md.options.html) {
    return false;
  } // Check start


  max = state.posMax;

  if (state.src.charCodeAt(pos) !== 0x3C
  /* < */
  || pos + 2 >= max) {
    return false;
  } // Quick fail on second char


  ch = state.src.charCodeAt(pos + 1);

  if (ch !== 0x21
  /* ! */
  && ch !== 0x3F
  /* ? */
  && ch !== 0x2F
  /* / */
  && !isLetter(ch)) {
    return false;
  }

  match = state.src.slice(pos).match(HTML_TAG_RE);

  if (!match) {
    return false;
  }

  if (!silent) {
    token = state.push('html_inline', '', 0);
    token.content = state.src.slice(pos, pos + match[0].length);
  }

  state.pos += match[0].length;
  return true;
};

/***/ }),
/* 186 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Process html entity - &#123;, &#xAF;, &quot;, ...


var entities = __webpack_require__(62);

var has = __webpack_require__(1).has;

var isValidEntityCode = __webpack_require__(1).isValidEntityCode;

var fromCodePoint = __webpack_require__(1).fromCodePoint;

var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
var NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;

module.exports = function entity(state, silent) {
  var ch,
      code,
      match,
      pos = state.pos,
      max = state.posMax;

  if (state.src.charCodeAt(pos) !== 0x26
  /* & */
  ) {
      return false;
    }

  if (pos + 1 < max) {
    ch = state.src.charCodeAt(pos + 1);

    if (ch === 0x23
    /* # */
    ) {
        match = state.src.slice(pos).match(DIGITAL_RE);

        if (match) {
          if (!silent) {
            code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);
            state.pending += isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);
          }

          state.pos += match[0].length;
          return true;
        }
      } else {
      match = state.src.slice(pos).match(NAMED_RE);

      if (match) {
        if (has(entities, match[1])) {
          if (!silent) {
            state.pending += entities[match[1]];
          }

          state.pos += match[0].length;
          return true;
        }
      }
    }
  }

  if (!silent) {
    state.pending += '&';
  }

  state.pos++;
  return true;
};

/***/ }),
/* 187 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// For each opening emphasis-like marker find a matching closing one
//


module.exports = function link_pairs(state) {
  var i,
      j,
      lastDelim,
      currDelim,
      delimiters = state.delimiters,
      max = state.delimiters.length;

  for (i = 0; i < max; i++) {
    lastDelim = delimiters[i];

    if (!lastDelim.close) {
      continue;
    }

    j = i - lastDelim.jump - 1;

    while (j >= 0) {
      currDelim = delimiters[j];

      if (currDelim.open && currDelim.marker === lastDelim.marker && currDelim.end < 0 && currDelim.level === lastDelim.level) {
        var odd_match = false; // typeofs are for backward compatibility with plugins

        if ((currDelim.close || lastDelim.open) && typeof currDelim.length !== 'undefined' && typeof lastDelim.length !== 'undefined') {
          // from spec:
          // sum of the lengths [...] must not be a multiple of 3
          // unless both lengths are multiples of 3
          if ((currDelim.length + lastDelim.length) % 3 === 0) {
            if (currDelim.length % 3 !== 0 || lastDelim.length % 3 !== 0) {
              odd_match = true;
            }
          }
        }

        if (!odd_match) {
          lastDelim.jump = i - j;
          lastDelim.open = false;
          currDelim.end = i;
          currDelim.jump = 0;
          break;
        }
      }

      j -= currDelim.jump + 1;
    }
  }
};

/***/ }),
/* 188 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Clean up tokens after emphasis and strikethrough postprocessing:
// merge adjacent text nodes into one and re-calculate all token levels
//
// This is necessary because initially emphasis delimiter markers (*, _, ~)
// are treated as their own separate text tokens. Then emphasis rule either
// leaves them as text (needed to merge with adjacent text) or turns them
// into opening/closing tags (which messes up levels inside).
//


module.exports = function text_collapse(state) {
  var curr,
      last,
      level = 0,
      tokens = state.tokens,
      max = state.tokens.length;

  for (curr = last = 0; curr < max; curr++) {
    // re-calculate levels after emphasis/strikethrough turns some text nodes
    // into opening/closing tags
    if (tokens[curr].nesting < 0) level--; // closing tag

    tokens[curr].level = level;
    if (tokens[curr].nesting > 0) level++; // opening tag

    if (tokens[curr].type === 'text' && curr + 1 < max && tokens[curr + 1].type === 'text') {
      // collapse two adjacent text nodes
      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
    } else {
      if (curr !== last) {
        tokens[last] = tokens[curr];
      }

      last++;
    }
  }

  if (curr !== last) {
    tokens.length = last;
  }
};

/***/ }),
/* 189 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Inline parser state


var Token = __webpack_require__(41);

var isWhiteSpace = __webpack_require__(1).isWhiteSpace;

var isPunctChar = __webpack_require__(1).isPunctChar;

var isMdAsciiPunct = __webpack_require__(1).isMdAsciiPunct;

function StateInline(src, md, env, outTokens) {
  this.src = src;
  this.env = env;
  this.md = md;
  this.tokens = outTokens;
  this.pos = 0;
  this.posMax = this.src.length;
  this.level = 0;
  this.pending = '';
  this.pendingLevel = 0;
  this.cache = {}; // Stores { start: end } pairs. Useful for backtrack
  // optimization of pairs parse (emphasis, strikes).

  this.delimiters = []; // Emphasis-like delimiters
} // Flush pending text
//


StateInline.prototype.pushPending = function () {
  var token = new Token('text', '', 0);
  token.content = this.pending;
  token.level = this.pendingLevel;
  this.tokens.push(token);
  this.pending = '';
  return token;
}; // Push new token to "stream".
// If pending text exists - flush it as text token
//


StateInline.prototype.push = function (type, tag, nesting) {
  if (this.pending) {
    this.pushPending();
  }

  var token = new Token(type, tag, nesting);
  if (nesting < 0) this.level--; // closing tag

  token.level = this.level;
  if (nesting > 0) this.level++; // opening tag

  this.pendingLevel = this.level;
  this.tokens.push(token);
  return token;
}; // Scan a sequence of emphasis-like markers, and determine whether
// it can start an emphasis sequence or end an emphasis sequence.
//
//  - start - position to scan from (it should point at a valid marker);
//  - canSplitWord - determine if these markers can be found inside a word
//


StateInline.prototype.scanDelims = function (start, canSplitWord) {
  var pos = start,
      lastChar,
      nextChar,
      count,
      can_open,
      can_close,
      isLastWhiteSpace,
      isLastPunctChar,
      isNextWhiteSpace,
      isNextPunctChar,
      left_flanking = true,
      right_flanking = true,
      max = this.posMax,
      marker = this.src.charCodeAt(start); // treat beginning of the line as a whitespace

  lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20;

  while (pos < max && this.src.charCodeAt(pos) === marker) {
    pos++;
  }

  count = pos - start; // treat end of the line as a whitespace

  nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20;
  isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
  isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
  isLastWhiteSpace = isWhiteSpace(lastChar);
  isNextWhiteSpace = isWhiteSpace(nextChar);

  if (isNextWhiteSpace) {
    left_flanking = false;
  } else if (isNextPunctChar) {
    if (!(isLastWhiteSpace || isLastPunctChar)) {
      left_flanking = false;
    }
  }

  if (isLastWhiteSpace) {
    right_flanking = false;
  } else if (isLastPunctChar) {
    if (!(isNextWhiteSpace || isNextPunctChar)) {
      right_flanking = false;
    }
  }

  if (!canSplitWord) {
    can_open = left_flanking && (!right_flanking || isLastPunctChar);
    can_close = right_flanking && (!left_flanking || isNextPunctChar);
  } else {
    can_open = left_flanking;
    can_close = right_flanking;
  }

  return {
    can_open: can_open,
    can_close: can_close,
    length: count
  };
}; // re-export Token class to use in block rules


StateInline.prototype.Token = Token;
module.exports = StateInline;

/***/ }),
/* 190 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
 ////////////////////////////////////////////////////////////////////////////////
// Helpers
// Merge objects
//

function assign(obj
/*from1, from2, from3, ...*/
) {
  var sources = Array.prototype.slice.call(arguments, 1);
  sources.forEach(function (source) {
    if (!source) {
      return;
    }

    Object.keys(source).forEach(function (key) {
      obj[key] = source[key];
    });
  });
  return obj;
}

function _class(obj) {
  return Object.prototype.toString.call(obj);
}

function isString(obj) {
  return _class(obj) === '[object String]';
}

function isObject(obj) {
  return _class(obj) === '[object Object]';
}

function isRegExp(obj) {
  return _class(obj) === '[object RegExp]';
}

function isFunction(obj) {
  return _class(obj) === '[object Function]';
}

function escapeRE(str) {
  return str.replace(/[.?*+^$[\]\\(){}|-]/g, '\\$&');
} ////////////////////////////////////////////////////////////////////////////////


var defaultOptions = {
  fuzzyLink: true,
  fuzzyEmail: true,
  fuzzyIP: false
};

function isOptionsObj(obj) {
  return Object.keys(obj || {}).reduce(function (acc, k) {
    return acc || defaultOptions.hasOwnProperty(k);
  }, false);
}

var defaultSchemas = {
  'http:': {
    validate: function (text, pos, self) {
      var tail = text.slice(pos);

      if (!self.re.http) {
        // compile lazily, because "host"-containing variables can change on tlds update.
        self.re.http = new RegExp('^\\/\\/' + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path, 'i');
      }

      if (self.re.http.test(tail)) {
        return tail.match(self.re.http)[0].length;
      }

      return 0;
    }
  },
  'https:': 'http:',
  'ftp:': 'http:',
  '//': {
    validate: function (text, pos, self) {
      var tail = text.slice(pos);

      if (!self.re.no_http) {
        // compile lazily, because "host"-containing variables can change on tlds update.
        self.re.no_http = new RegExp('^' + self.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
        // with code comments
        '(?:localhost|(?:(?:' + self.re.src_domain + ')\\.)+' + self.re.src_domain_root + ')' + self.re.src_port + self.re.src_host_terminator + self.re.src_path, 'i');
      }

      if (self.re.no_http.test(tail)) {
        // should not be `://` & `///`, that protects from errors in protocol name
        if (pos >= 3 && text[pos - 3] === ':') {
          return 0;
        }

        if (pos >= 3 && text[pos - 3] === '/') {
          return 0;
        }

        return tail.match(self.re.no_http)[0].length;
      }

      return 0;
    }
  },
  'mailto:': {
    validate: function (text, pos, self) {
      var tail = text.slice(pos);

      if (!self.re.mailto) {
        self.re.mailto = new RegExp('^' + self.re.src_email_name + '@' + self.re.src_host_strict, 'i');
      }

      if (self.re.mailto.test(tail)) {
        return tail.match(self.re.mailto)[0].length;
      }

      return 0;
    }
  }
};
/*eslint-disable max-len*/
// RE pattern for 2-character tlds (autogenerated by ./support/tlds_2char_gen.js)

var tlds_2ch_src_re = 'a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]'; // DON'T try to make PRs with changes. Extend TLDs with LinkifyIt.tlds() instead

var tlds_default = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|');
/*eslint-enable max-len*/
////////////////////////////////////////////////////////////////////////////////

function resetScanCache(self) {
  self.__index__ = -1;
  self.__text_cache__ = '';
}

function createValidator(re) {
  return function (text, pos) {
    var tail = text.slice(pos);

    if (re.test(tail)) {
      return tail.match(re)[0].length;
    }

    return 0;
  };
}

function createNormalizer() {
  return function (match, self) {
    self.normalize(match);
  };
} // Schemas compiler. Build regexps.
//


function compile(self) {
  // Load & clone RE patterns.
  var re = self.re = __webpack_require__(191)(self.__opts__); // Define dynamic patterns


  var tlds = self.__tlds__.slice();

  self.onCompile();

  if (!self.__tlds_replaced__) {
    tlds.push(tlds_2ch_src_re);
  }

  tlds.push(re.src_xn);
  re.src_tlds = tlds.join('|');

  function untpl(tpl) {
    return tpl.replace('%TLDS%', re.src_tlds);
  }

  re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), 'i');
  re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), 'i');
  re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), 'i');
  re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), 'i'); //
  // Compile each schema
  //

  var aliases = [];
  self.__compiled__ = {}; // Reset compiled data

  function schemaError(name, val) {
    throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
  }

  Object.keys(self.__schemas__).forEach(function (name) {
    var val = self.__schemas__[name]; // skip disabled methods

    if (val === null) {
      return;
    }

    var compiled = {
      validate: null,
      link: null
    };
    self.__compiled__[name] = compiled;

    if (isObject(val)) {
      if (isRegExp(val.validate)) {
        compiled.validate = createValidator(val.validate);
      } else if (isFunction(val.validate)) {
        compiled.validate = val.validate;
      } else {
        schemaError(name, val);
      }

      if (isFunction(val.normalize)) {
        compiled.normalize = val.normalize;
      } else if (!val.normalize) {
        compiled.normalize = createNormalizer();
      } else {
        schemaError(name, val);
      }

      return;
    }

    if (isString(val)) {
      aliases.push(name);
      return;
    }

    schemaError(name, val);
  }); //
  // Compile postponed aliases
  //

  aliases.forEach(function (alias) {
    if (!self.__compiled__[self.__schemas__[alias]]) {
      // Silently fail on missed schemas to avoid errons on disable.
      // schemaError(alias, self.__schemas__[alias]);
      return;
    }

    self.__compiled__[alias].validate = self.__compiled__[self.__schemas__[alias]].validate;
    self.__compiled__[alias].normalize = self.__compiled__[self.__schemas__[alias]].normalize;
  }); //
  // Fake record for guessed links
  //

  self.__compiled__[''] = {
    validate: null,
    normalize: createNormalizer()
  }; //
  // Build schema condition
  //

  var slist = Object.keys(self.__compiled__).filter(function (name) {
    // Filter disabled & fake schemas
    return name.length > 0 && self.__compiled__[name];
  }).map(escapeRE).join('|'); // (?!_) cause 1.5x slowdown

  self.re.schema_test = RegExp('(^|(?!_)(?:[><\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'i');
  self.re.schema_search = RegExp('(^|(?!_)(?:[><\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'ig');
  self.re.pretest = RegExp('(' + self.re.schema_test.source + ')|(' + self.re.host_fuzzy_test.source + ')|@', 'i'); //
  // Cleanup
  //

  resetScanCache(self);
}
/**
 * class Match
 *
 * Match result. Single element of array, returned by [[LinkifyIt#match]]
 **/


function Match(self, shift) {
  var start = self.__index__,
      end = self.__last_index__,
      text = self.__text_cache__.slice(start, end);
  /**
   * Match#schema -> String
   *
   * Prefix (protocol) for matched string.
   **/


  this.schema = self.__schema__.toLowerCase();
  /**
   * Match#index -> Number
   *
   * First position of matched string.
   **/

  this.index = start + shift;
  /**
   * Match#lastIndex -> Number
   *
   * Next position after matched string.
   **/

  this.lastIndex = end + shift;
  /**
   * Match#raw -> String
   *
   * Matched string.
   **/

  this.raw = text;
  /**
   * Match#text -> String
   *
   * Notmalized text of matched string.
   **/

  this.text = text;
  /**
   * Match#url -> String
   *
   * Normalized url of matched string.
   **/

  this.url = text;
}

function createMatch(self, shift) {
  var match = new Match(self, shift);

  self.__compiled__[match.schema].normalize(match, self);

  return match;
}
/**
 * class LinkifyIt
 **/

/**
 * new LinkifyIt(schemas, options)
 * - schemas (Object): Optional. Additional schemas to validate (prefix/validator)
 * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }
 *
 * Creates new linkifier instance with optional additional schemas.
 * Can be called without `new` keyword for convenience.
 *
 * By default understands:
 *
 * - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links
 * - "fuzzy" links and emails (example.com, foo@bar.com).
 *
 * `schemas` is an object, where each key/value describes protocol/rule:
 *
 * - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`
 *   for example). `linkify-it` makes shure that prefix is not preceeded with
 *   alphanumeric char and symbols. Only whitespaces and punctuation allowed.
 * - __value__ - rule to check tail after link prefix
 *   - _String_ - just alias to existing rule
 *   - _Object_
 *     - _validate_ - validator function (should return matched length on success),
 *       or `RegExp`.
 *     - _normalize_ - optional function to normalize text & url of matched result
 *       (for example, for @twitter mentions).
 *
 * `options`:
 *
 * - __fuzzyLink__ - recognige URL-s without `http(s):` prefix. Default `true`.
 * - __fuzzyIP__ - allow IPs in fuzzy links above. Can conflict with some texts
 *   like version numbers. Default `false`.
 * - __fuzzyEmail__ - recognize emails without `mailto:` prefix.
 *
 **/


function LinkifyIt(schemas, options) {
  if (!(this instanceof LinkifyIt)) {
    return new LinkifyIt(schemas, options);
  }

  if (!options) {
    if (isOptionsObj(schemas)) {
      options = schemas;
      schemas = {};
    }
  }

  this.__opts__ = assign({}, defaultOptions, options); // Cache last tested result. Used to skip repeating steps on next `match` call.

  this.__index__ = -1;
  this.__last_index__ = -1; // Next scan position

  this.__schema__ = '';
  this.__text_cache__ = '';
  this.__schemas__ = assign({}, defaultSchemas, schemas);
  this.__compiled__ = {};
  this.__tlds__ = tlds_default;
  this.__tlds_replaced__ = false;
  this.re = {};
  compile(this);
}
/** chainable
 * LinkifyIt#add(schema, definition)
 * - schema (String): rule name (fixed pattern prefix)
 * - definition (String|RegExp|Object): schema definition
 *
 * Add new rule definition. See constructor description for details.
 **/


LinkifyIt.prototype.add = function add(schema, definition) {
  this.__schemas__[schema] = definition;
  compile(this);
  return this;
};
/** chainable
 * LinkifyIt#set(options)
 * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }
 *
 * Set recognition options for links without schema.
 **/


LinkifyIt.prototype.set = function set(options) {
  this.__opts__ = assign(this.__opts__, options);
  return this;
};
/**
 * LinkifyIt#test(text) -> Boolean
 *
 * Searches linkifiable pattern and returns `true` on success or `false` on fail.
 **/


LinkifyIt.prototype.test = function test(text) {
  // Reset scan cache
  this.__text_cache__ = text;
  this.__index__ = -1;

  if (!text.length) {
    return false;
  }

  var m, ml, me, len, shift, next, re, tld_pos, at_pos; // try to scan for link with schema - that's the most simple rule

  if (this.re.schema_test.test(text)) {
    re = this.re.schema_search;
    re.lastIndex = 0;

    while ((m = re.exec(text)) !== null) {
      len = this.testSchemaAt(text, m[2], re.lastIndex);

      if (len) {
        this.__schema__ = m[2];
        this.__index__ = m.index + m[1].length;
        this.__last_index__ = m.index + m[0].length + len;
        break;
      }
    }
  }

  if (this.__opts__.fuzzyLink && this.__compiled__['http:']) {
    // guess schemaless links
    tld_pos = text.search(this.re.host_fuzzy_test);

    if (tld_pos >= 0) {
      // if tld is located after found link - no need to check fuzzy pattern
      if (this.__index__ < 0 || tld_pos < this.__index__) {
        if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
          shift = ml.index + ml[1].length;

          if (this.__index__ < 0 || shift < this.__index__) {
            this.__schema__ = '';
            this.__index__ = shift;
            this.__last_index__ = ml.index + ml[0].length;
          }
        }
      }
    }
  }

  if (this.__opts__.fuzzyEmail && this.__compiled__['mailto:']) {
    // guess schemaless emails
    at_pos = text.indexOf('@');

    if (at_pos >= 0) {
      // We can't skip this check, because this cases are possible:
      // 192.168.1.1@gmail.com, my.in@example.com
      if ((me = text.match(this.re.email_fuzzy)) !== null) {
        shift = me.index + me[1].length;
        next = me.index + me[0].length;

        if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {
          this.__schema__ = 'mailto:';
          this.__index__ = shift;
          this.__last_index__ = next;
        }
      }
    }
  }

  return this.__index__ >= 0;
};
/**
 * LinkifyIt#pretest(text) -> Boolean
 *
 * Very quick check, that can give false positives. Returns true if link MAY BE
 * can exists. Can be used for speed optimization, when you need to check that
 * link NOT exists.
 **/


LinkifyIt.prototype.pretest = function pretest(text) {
  return this.re.pretest.test(text);
};
/**
 * LinkifyIt#testSchemaAt(text, name, position) -> Number
 * - text (String): text to scan
 * - name (String): rule (schema) name
 * - position (Number): text offset to check from
 *
 * Similar to [[LinkifyIt#test]] but checks only specific protocol tail exactly
 * at given position. Returns length of found pattern (0 on fail).
 **/


LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
  // If not supported schema check requested - terminate
  if (!this.__compiled__[schema.toLowerCase()]) {
    return 0;
  }

  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
};
/**
 * LinkifyIt#match(text) -> Array|null
 *
 * Returns array of found link descriptions or `null` on fail. We strongly
 * recommend to use [[LinkifyIt#test]] first, for best speed.
 *
 * ##### Result match description
 *
 * - __schema__ - link schema, can be empty for fuzzy links, or `//` for
 *   protocol-neutral  links.
 * - __index__ - offset of matched text
 * - __lastIndex__ - index of next char after mathch end
 * - __raw__ - matched text
 * - __text__ - normalized text
 * - __url__ - link, generated from matched text
 **/


LinkifyIt.prototype.match = function match(text) {
  var shift = 0,
      result = []; // Try to take previous element from cache, if .test() called before

  if (this.__index__ >= 0 && this.__text_cache__ === text) {
    result.push(createMatch(this, shift));
    shift = this.__last_index__;
  } // Cut head if cache was used


  var tail = shift ? text.slice(shift) : text; // Scan string until end reached

  while (this.test(tail)) {
    result.push(createMatch(this, shift));
    tail = tail.slice(this.__last_index__);
    shift += this.__last_index__;
  }

  if (result.length) {
    return result;
  }

  return null;
};
/** chainable
 * LinkifyIt#tlds(list [, keepOld]) -> this
 * - list (Array): list of tlds
 * - keepOld (Boolean): merge with current list if `true` (`false` by default)
 *
 * Load (or merge) new tlds list. Those are user for fuzzy links (without prefix)
 * to avoid false positives. By default this algorythm used:
 *
 * - hostname with any 2-letter root zones are ok.
 * - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф
 *   are ok.
 * - encoded (`xn--...`) root zones are ok.
 *
 * If list is replaced, then exact match for 2-chars root zones will be checked.
 **/


LinkifyIt.prototype.tlds = function tlds(list, keepOld) {
  list = Array.isArray(list) ? list : [list];

  if (!keepOld) {
    this.__tlds__ = list.slice();
    this.__tlds_replaced__ = true;
    compile(this);
    return this;
  }

  this.__tlds__ = this.__tlds__.concat(list).sort().filter(function (el, idx, arr) {
    return el !== arr[idx - 1];
  }).reverse();
  compile(this);
  return this;
};
/**
 * LinkifyIt#normalize(match)
 *
 * Default normalizer (if schema does not define it's own).
 **/


LinkifyIt.prototype.normalize = function normalize(match) {
  // Do minimal possible changes by default. Need to collect feedback prior
  // to move forward https://github.com/markdown-it/linkify-it/issues/1
  if (!match.schema) {
    match.url = 'http://' + match.url;
  }

  if (match.schema === 'mailto:' && !/^mailto:/i.test(match.url)) {
    match.url = 'mailto:' + match.url;
  }
};
/**
 * LinkifyIt#onCompile()
 *
 * Override to modify basic RegExp-s.
 **/


LinkifyIt.prototype.onCompile = function onCompile() {};

module.exports = LinkifyIt;

/***/ }),
/* 191 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = function (opts) {
  var re = {}; // Use direct extract instead of `regenerate` to reduse browserified size

  re.src_Any = __webpack_require__(64).source;
  re.src_Cc = __webpack_require__(65).source;
  re.src_Z = __webpack_require__(66).source;
  re.src_P = __webpack_require__(39).source; // \p{\Z\P\Cc\CF} (white spaces + control + format + punctuation)

  re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join('|'); // \p{\Z\Cc} (white spaces + control)

  re.src_ZCc = [re.src_Z, re.src_Cc].join('|'); // Experimental. List of chars, completely prohibited in links
  // because can separate it from other part of text

  var text_separators = '[><\uff5c]'; // All possible word characters (everything without punctuation, spaces & controls)
  // Defined via punctuation & spaces to save space
  // Should be something like \p{\L\N\S\M} (\w but without `_`)

  re.src_pseudo_letter = '(?:(?!' + text_separators + '|' + re.src_ZPCc + ')' + re.src_Any + ')'; // The same as abothe but without [0-9]
  // var src_pseudo_letter_non_d = '(?:(?![0-9]|' + src_ZPCc + ')' + src_Any + ')';
  ////////////////////////////////////////////////////////////////////////////////

  re.src_ip4 = '(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)'; // Prohibit any of "@/[]()" in user/pass to avoid wrong domain fetch.

  re.src_auth = '(?:(?:(?!' + re.src_ZCc + '|[@/\\[\\]()]).)+@)?';
  re.src_port = '(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?';
  re.src_host_terminator = '(?=$|' + text_separators + '|' + re.src_ZPCc + ')(?!-|_|:\\d|\\.-|\\.(?!$|' + re.src_ZPCc + '))';
  re.src_path = '(?:' + '[/?#]' + '(?:' + '(?!' + re.src_ZCc + '|' + text_separators + '|[()[\\]{}.,"\'?!\\-]).|' + '\\[(?:(?!' + re.src_ZCc + '|\\]).)*\\]|' + '\\((?:(?!' + re.src_ZCc + '|[)]).)*\\)|' + '\\{(?:(?!' + re.src_ZCc + '|[}]).)*\\}|' + '\\"(?:(?!' + re.src_ZCc + '|["]).)+\\"|' + "\\'(?:(?!" + re.src_ZCc + "|[']).)+\\'|" + "\\'(?=" + re.src_pseudo_letter + '|[-]).|' + // allow `I'm_king` if no pair found
  '\\.{2,4}[a-zA-Z0-9%/]|' + // github has ... in commit range links,
  // google has .... in links (issue #66)
  // Restrict to
  // - english
  // - percent-encoded
  // - parts of file path
  // until more examples found.
  '\\.(?!' + re.src_ZCc + '|[.]).|' + (opts && opts['---'] ? '\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate
  : '\\-+|') + '\\,(?!' + re.src_ZCc + ').|' + // allow `,,,` in paths
  '\\!(?!' + re.src_ZCc + '|[!]).|' + '\\?(?!' + re.src_ZCc + '|[?]).' + ')+' + '|\\/' + ')?'; // Allow anything in markdown spec, forbid quote (") at the first position
  // because emails enclosed in quotes are far more common

  re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
  re.src_xn = 'xn--[a-z0-9\\-]{1,59}'; // More to read about domain names
  // http://serverfault.com/questions/638260/

  re.src_domain_root = // Allow letters & digits (http://test1)
  '(?:' + re.src_xn + '|' + re.src_pseudo_letter + '{1,63}' + ')';
  re.src_domain = '(?:' + re.src_xn + '|' + '(?:' + re.src_pseudo_letter + ')' + '|' + '(?:' + re.src_pseudo_letter + '(?:-|' + re.src_pseudo_letter + '){0,61}' + re.src_pseudo_letter + ')' + ')';
  re.src_host = '(?:' + // Don't need IP check, because digits are already allowed in normal domain names
  //   src_ip4 +
  // '|' +
  '(?:(?:(?:' + re.src_domain + ')\\.)*' + re.src_domain
  /*_root*/
  + ')' + ')';
  re.tpl_host_fuzzy = '(?:' + re.src_ip4 + '|' + '(?:(?:(?:' + re.src_domain + ')\\.)+(?:%TLDS%))' + ')';
  re.tpl_host_no_ip_fuzzy = '(?:(?:(?:' + re.src_domain + ')\\.)+(?:%TLDS%))';
  re.src_host_strict = re.src_host + re.src_host_terminator;
  re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
  re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
  re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
  re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator; ////////////////////////////////////////////////////////////////////////////////
  // Main rules
  // Rude test fuzzy links by host, for quick deny

  re.tpl_host_fuzzy_test = 'localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:' + re.src_ZPCc + '|>|$))';
  re.tpl_email_fuzzy = '(^|' + text_separators + '|"|\\(|' + re.src_ZCc + ')' + '(' + re.src_email_name + '@' + re.tpl_host_fuzzy_strict + ')';
  re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
  // but can start with > (markdown blockquote)
  '(^|(?![.:/\\-_@])(?:[$+<=>^`|\uff5c]|' + re.src_ZPCc + '))' + '((?![$+<=>^`|\uff5c])' + re.tpl_host_port_fuzzy_strict + re.src_path + ')';
  re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
  // but can start with > (markdown blockquote)
  '(^|(?![.:/\\-_@])(?:[$+<=>^`|\uff5c]|' + re.src_ZPCc + '))' + '((?![$+<=>^`|\uff5c])' + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ')';
  return re;
};

/***/ }),
/* 192 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(module, global) {var __WEBPACK_AMD_DEFINE_RESULT__;/*! https://mths.be/punycode v1.4.1 by @mathias */
;

(function (root) {
  /** Detect free variables */
  var freeExports =  true && exports && !exports.nodeType && exports;
  var freeModule =  true && module && !module.nodeType && module;
  var freeGlobal = typeof global == 'object' && global;

  if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
    root = freeGlobal;
  }
  /**
   * The `punycode` object.
   * @name punycode
   * @type Object
   */


  var punycode,

  /** Highest positive signed 32-bit float value */
  maxInt = 2147483647,
      // aka. 0x7FFFFFFF or 2^31-1

  /** Bootstring parameters */
  base = 36,
      tMin = 1,
      tMax = 26,
      skew = 38,
      damp = 700,
      initialBias = 72,
      initialN = 128,
      // 0x80
  delimiter = '-',
      // '\x2D'

  /** Regular expressions */
  regexPunycode = /^xn--/,
      regexNonASCII = /[^\x20-\x7E]/,
      // unprintable ASCII chars + non-ASCII chars
  regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g,
      // RFC 3490 separators

  /** Error messages */
  errors = {
    'overflow': 'Overflow: input needs wider integers to process',
    'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
    'invalid-input': 'Invalid input'
  },

  /** Convenience shortcuts */
  baseMinusTMin = base - tMin,
      floor = Math.floor,
      stringFromCharCode = String.fromCharCode,

  /** Temporary variable */
  key;
  /*--------------------------------------------------------------------------*/

  /**
   * A generic error utility function.
   * @private
   * @param {String} type The error type.
   * @returns {Error} Throws a `RangeError` with the applicable error message.
   */

  function error(type) {
    throw new RangeError(errors[type]);
  }
  /**
   * A generic `Array#map` utility function.
   * @private
   * @param {Array} array The array to iterate over.
   * @param {Function} callback The function that gets called for every array
   * item.
   * @returns {Array} A new array of values returned by the callback function.
   */


  function map(array, fn) {
    var length = array.length;
    var result = [];

    while (length--) {
      result[length] = fn(array[length]);
    }

    return result;
  }
  /**
   * A simple `Array#map`-like wrapper to work with domain name strings or email
   * addresses.
   * @private
   * @param {String} domain The domain name or email address.
   * @param {Function} callback The function that gets called for every
   * character.
   * @returns {Array} A new string of characters returned by the callback
   * function.
   */


  function mapDomain(string, fn) {
    var parts = string.split('@');
    var result = '';

    if (parts.length > 1) {
      // In email addresses, only the domain name should be punycoded. Leave
      // the local part (i.e. everything up to `@`) intact.
      result = parts[0] + '@';
      string = parts[1];
    } // Avoid `split(regex)` for IE8 compatibility. See #17.


    string = string.replace(regexSeparators, '\x2E');
    var labels = string.split('.');
    var encoded = map(labels, fn).join('.');
    return result + encoded;
  }
  /**
   * Creates an array containing the numeric code points of each Unicode
   * character in the string. While JavaScript uses UCS-2 internally,
   * this function will convert a pair of surrogate halves (each of which
   * UCS-2 exposes as separate characters) into a single code point,
   * matching UTF-16.
   * @see `punycode.ucs2.encode`
   * @see <https://mathiasbynens.be/notes/javascript-encoding>
   * @memberOf punycode.ucs2
   * @name decode
   * @param {String} string The Unicode input string (UCS-2).
   * @returns {Array} The new array of code points.
   */


  function ucs2decode(string) {
    var output = [],
        counter = 0,
        length = string.length,
        value,
        extra;

    while (counter < length) {
      value = string.charCodeAt(counter++);

      if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
        // high surrogate, and there is a next character
        extra = string.charCodeAt(counter++);

        if ((extra & 0xFC00) == 0xDC00) {
          // low surrogate
          output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
        } else {
          // unmatched surrogate; only append this code unit, in case the next
          // code unit is the high surrogate of a surrogate pair
          output.push(value);
          counter--;
        }
      } else {
        output.push(value);
      }
    }

    return output;
  }
  /**
   * Creates a string based on an array of numeric code points.
   * @see `punycode.ucs2.decode`
   * @memberOf punycode.ucs2
   * @name encode
   * @param {Array} codePoints The array of numeric code points.
   * @returns {String} The new Unicode string (UCS-2).
   */


  function ucs2encode(array) {
    return map(array, function (value) {
      var output = '';

      if (value > 0xFFFF) {
        value -= 0x10000;
        output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
        value = 0xDC00 | value & 0x3FF;
      }

      output += stringFromCharCode(value);
      return output;
    }).join('');
  }
  /**
   * Converts a basic code point into a digit/integer.
   * @see `digitToBasic()`
   * @private
   * @param {Number} codePoint The basic numeric code point value.
   * @returns {Number} The numeric value of a basic code point (for use in
   * representing integers) in the range `0` to `base - 1`, or `base` if
   * the code point does not represent a value.
   */


  function basicToDigit(codePoint) {
    if (codePoint - 48 < 10) {
      return codePoint - 22;
    }

    if (codePoint - 65 < 26) {
      return codePoint - 65;
    }

    if (codePoint - 97 < 26) {
      return codePoint - 97;
    }

    return base;
  }
  /**
   * Converts a digit/integer into a basic code point.
   * @see `basicToDigit()`
   * @private
   * @param {Number} digit The numeric value of a basic code point.
   * @returns {Number} The basic code point whose value (when used for
   * representing integers) is `digit`, which needs to be in the range
   * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
   * used; else, the lowercase form is used. The behavior is undefined
   * if `flag` is non-zero and `digit` has no uppercase form.
   */


  function digitToBasic(digit, flag) {
    //  0..25 map to ASCII a..z or A..Z
    // 26..35 map to ASCII 0..9
    return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
  }
  /**
   * Bias adaptation function as per section 3.4 of RFC 3492.
   * https://tools.ietf.org/html/rfc3492#section-3.4
   * @private
   */


  function adapt(delta, numPoints, firstTime) {
    var k = 0;
    delta = firstTime ? floor(delta / damp) : delta >> 1;
    delta += floor(delta / numPoints);

    for (;
    /* no initialization */
    delta > baseMinusTMin * tMax >> 1; k += base) {
      delta = floor(delta / baseMinusTMin);
    }

    return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
  }
  /**
   * Converts a Punycode string of ASCII-only symbols to a string of Unicode
   * symbols.
   * @memberOf punycode
   * @param {String} input The Punycode string of ASCII-only symbols.
   * @returns {String} The resulting string of Unicode symbols.
   */


  function decode(input) {
    // Don't use UCS-2
    var output = [],
        inputLength = input.length,
        out,
        i = 0,
        n = initialN,
        bias = initialBias,
        basic,
        j,
        index,
        oldi,
        w,
        k,
        digit,
        t,

    /** Cached calculation results */
    baseMinusT; // Handle the basic code points: let `basic` be the number of input code
    // points before the last delimiter, or `0` if there is none, then copy
    // the first basic code points to the output.

    basic = input.lastIndexOf(delimiter);

    if (basic < 0) {
      basic = 0;
    }

    for (j = 0; j < basic; ++j) {
      // if it's not a basic code point
      if (input.charCodeAt(j) >= 0x80) {
        error('not-basic');
      }

      output.push(input.charCodeAt(j));
    } // Main decoding loop: start just after the last delimiter if any basic code
    // points were copied; start at the beginning otherwise.


    for (index = basic > 0 ? basic + 1 : 0; index < inputLength;)
    /* no final expression */
    {
      // `index` is the index of the next character to be consumed.
      // Decode a generalized variable-length integer into `delta`,
      // which gets added to `i`. The overflow checking is easier
      // if we increase `i` as we go, then subtract off its starting
      // value at the end to obtain `delta`.
      for (oldi = i, w = 1, k = base;;
      /* no condition */
      k += base) {
        if (index >= inputLength) {
          error('invalid-input');
        }

        digit = basicToDigit(input.charCodeAt(index++));

        if (digit >= base || digit > floor((maxInt - i) / w)) {
          error('overflow');
        }

        i += digit * w;
        t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;

        if (digit < t) {
          break;
        }

        baseMinusT = base - t;

        if (w > floor(maxInt / baseMinusT)) {
          error('overflow');
        }

        w *= baseMinusT;
      }

      out = output.length + 1;
      bias = adapt(i - oldi, out, oldi == 0); // `i` was supposed to wrap around from `out` to `0`,
      // incrementing `n` each time, so we'll fix that now:

      if (floor(i / out) > maxInt - n) {
        error('overflow');
      }

      n += floor(i / out);
      i %= out; // Insert `n` at position `i` of the output

      output.splice(i++, 0, n);
    }

    return ucs2encode(output);
  }
  /**
   * Converts a string of Unicode symbols (e.g. a domain name label) to a
   * Punycode string of ASCII-only symbols.
   * @memberOf punycode
   * @param {String} input The string of Unicode symbols.
   * @returns {String} The resulting Punycode string of ASCII-only symbols.
   */


  function encode(input) {
    var n,
        delta,
        handledCPCount,
        basicLength,
        bias,
        j,
        m,
        q,
        k,
        t,
        currentValue,
        output = [],

    /** `inputLength` will hold the number of code points in `input`. */
    inputLength,

    /** Cached calculation results */
    handledCPCountPlusOne,
        baseMinusT,
        qMinusT; // Convert the input in UCS-2 to Unicode

    input = ucs2decode(input); // Cache the length

    inputLength = input.length; // Initialize the state

    n = initialN;
    delta = 0;
    bias = initialBias; // Handle the basic code points

    for (j = 0; j < inputLength; ++j) {
      currentValue = input[j];

      if (currentValue < 0x80) {
        output.push(stringFromCharCode(currentValue));
      }
    }

    handledCPCount = basicLength = output.length; // `handledCPCount` is the number of code points that have been handled;
    // `basicLength` is the number of basic code points.
    // Finish the basic string - if it is not empty - with a delimiter

    if (basicLength) {
      output.push(delimiter);
    } // Main encoding loop:


    while (handledCPCount < inputLength) {
      // All non-basic code points < n have been handled already. Find the next
      // larger one:
      for (m = maxInt, j = 0; j < inputLength; ++j) {
        currentValue = input[j];

        if (currentValue >= n && currentValue < m) {
          m = currentValue;
        }
      } // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
      // but guard against overflow


      handledCPCountPlusOne = handledCPCount + 1;

      if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
        error('overflow');
      }

      delta += (m - n) * handledCPCountPlusOne;
      n = m;

      for (j = 0; j < inputLength; ++j) {
        currentValue = input[j];

        if (currentValue < n && ++delta > maxInt) {
          error('overflow');
        }

        if (currentValue == n) {
          // Represent delta as a generalized variable-length integer
          for (q = delta, k = base;;
          /* no condition */
          k += base) {
            t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;

            if (q < t) {
              break;
            }

            qMinusT = q - t;
            baseMinusT = base - t;
            output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));
            q = floor(qMinusT / baseMinusT);
          }

          output.push(stringFromCharCode(digitToBasic(q, 0)));
          bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
          delta = 0;
          ++handledCPCount;
        }
      }

      ++delta;
      ++n;
    }

    return output.join('');
  }
  /**
   * Converts a Punycode string representing a domain name or an email address
   * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
   * it doesn't matter if you call it on a string that has already been
   * converted to Unicode.
   * @memberOf punycode
   * @param {String} input The Punycoded domain name or email address to
   * convert to Unicode.
   * @returns {String} The Unicode representation of the given Punycode
   * string.
   */


  function toUnicode(input) {
    return mapDomain(input, function (string) {
      return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
    });
  }
  /**
   * Converts a Unicode string representing a domain name or an email address to
   * Punycode. Only the non-ASCII parts of the domain name will be converted,
   * i.e. it doesn't matter if you call it with a domain that's already in
   * ASCII.
   * @memberOf punycode
   * @param {String} input The domain name or email address to convert, as a
   * Unicode string.
   * @returns {String} The Punycode representation of the given domain name or
   * email address.
   */


  function toASCII(input) {
    return mapDomain(input, function (string) {
      return regexNonASCII.test(string) ? 'xn--' + encode(string) : string;
    });
  }
  /*--------------------------------------------------------------------------*/

  /** Define the public API */


  punycode = {
    /**
     * A string representing the current Punycode.js version number.
     * @memberOf punycode
     * @type String
     */
    'version': '1.4.1',

    /**
     * An object of methods to convert from JavaScript's internal character
     * representation (UCS-2) to Unicode code points, and back.
     * @see <https://mathiasbynens.be/notes/javascript-encoding>
     * @memberOf punycode
     * @type Object
     */
    'ucs2': {
      'decode': ucs2decode,
      'encode': ucs2encode
    },
    'decode': decode,
    'encode': encode,
    'toASCII': toASCII,
    'toUnicode': toUnicode
  };
  /** Expose `punycode` */
  // Some AMD build optimizers, like r.js, check for specific condition patterns
  // like the following:

  if (true) {
    !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {
      return punycode;
    }).call(exports, __webpack_require__, exports, module),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else {}
})(this);
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(193)(module), __webpack_require__(59)))

/***/ }),
/* 193 */
/***/ (function(module, exports) {

module.exports = function (module) {
  if (!module.webpackPolyfill) {
    module.deprecate = function () {};

    module.paths = []; // module.parent = undefined by default

    if (!module.children) module.children = [];
    Object.defineProperty(module, "loaded", {
      enumerable: true,
      get: function () {
        return module.l;
      }
    });
    Object.defineProperty(module, "id", {
      enumerable: true,
      get: function () {
        return module.i;
      }
    });
    module.webpackPolyfill = 1;
  }

  return module;
};

/***/ }),
/* 194 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// markdown-it default options


module.exports = {
  options: {
    html: false,
    // Enable HTML tags in source
    xhtmlOut: false,
    // Use '/' to close single tags (<br />)
    breaks: false,
    // Convert '\n' in paragraphs into <br>
    langPrefix: 'language-',
    // CSS language prefix for fenced blocks
    linkify: false,
    // autoconvert URL-like texts to links
    // Enable some language-neutral replacements + quotes beautification
    typographer: false,
    // Double + single quotes replacement pairs, when typographer enabled,
    // and smartquotes on. Could be either a String or an Array.
    //
    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
    quotes: '\u201c\u201d\u2018\u2019',

    /* “”‘’ */
    // Highlighter function. Should return escaped HTML,
    // or '' if the source string is not changed and should be escaped externaly.
    // If result starts with <pre... internal wrapper is skipped.
    //
    // function (/*str, lang*/) { return ''; }
    //
    highlight: null,
    maxNesting: 100 // Internal protection, recursion limit

  },
  components: {
    core: {},
    block: {},
    inline: {}
  }
};

/***/ }),
/* 195 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// "Zero" preset, with nothing enabled. Useful for manual configuring of simple
// modes. For example, to parse bold/italic only.


module.exports = {
  options: {
    html: false,
    // Enable HTML tags in source
    xhtmlOut: false,
    // Use '/' to close single tags (<br />)
    breaks: false,
    // Convert '\n' in paragraphs into <br>
    langPrefix: 'language-',
    // CSS language prefix for fenced blocks
    linkify: false,
    // autoconvert URL-like texts to links
    // Enable some language-neutral replacements + quotes beautification
    typographer: false,
    // Double + single quotes replacement pairs, when typographer enabled,
    // and smartquotes on. Could be either a String or an Array.
    //
    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
    quotes: '\u201c\u201d\u2018\u2019',

    /* “”‘’ */
    // Highlighter function. Should return escaped HTML,
    // or '' if the source string is not changed and should be escaped externaly.
    // If result starts with <pre... internal wrapper is skipped.
    //
    // function (/*str, lang*/) { return ''; }
    //
    highlight: null,
    maxNesting: 20 // Internal protection, recursion limit

  },
  components: {
    core: {
      rules: ['normalize', 'block', 'inline']
    },
    block: {
      rules: ['paragraph']
    },
    inline: {
      rules: ['text'],
      rules2: ['balance_pairs', 'text_collapse']
    }
  }
};

/***/ }),
/* 196 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Commonmark default options


module.exports = {
  options: {
    html: true,
    // Enable HTML tags in source
    xhtmlOut: true,
    // Use '/' to close single tags (<br />)
    breaks: false,
    // Convert '\n' in paragraphs into <br>
    langPrefix: 'language-',
    // CSS language prefix for fenced blocks
    linkify: false,
    // autoconvert URL-like texts to links
    // Enable some language-neutral replacements + quotes beautification
    typographer: false,
    // Double + single quotes replacement pairs, when typographer enabled,
    // and smartquotes on. Could be either a String or an Array.
    //
    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
    quotes: '\u201c\u201d\u2018\u2019',

    /* “”‘’ */
    // Highlighter function. Should return escaped HTML,
    // or '' if the source string is not changed and should be escaped externaly.
    // If result starts with <pre... internal wrapper is skipped.
    //
    // function (/*str, lang*/) { return ''; }
    //
    highlight: null,
    maxNesting: 20 // Internal protection, recursion limit

  },
  components: {
    core: {
      rules: ['normalize', 'block', 'inline']
    },
    block: {
      rules: ['blockquote', 'code', 'fence', 'heading', 'hr', 'html_block', 'lheading', 'list', 'reference', 'paragraph']
    },
    inline: {
      rules: ['autolink', 'backticks', 'emphasis', 'entity', 'escape', 'html_inline', 'image', 'link', 'newline', 'text'],
      rules2: ['balance_pairs', 'emphasis', 'text_collapse']
    }
  }
};

/***/ }),
/* 197 */
/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
var n={false:"push",true:"unshift"},e=Object.prototype.hasOwnProperty,r=function(n,r,t){var i=n,u=2;if(t&&e.call(r,i))throw Error("User defined id attribute '"+n+"' is NOT unique. Please fix it in your markdown to continue.");for(;e.call(r,i);)i=n+"-"+u++;return r[i]=!0,i},t=function n(e,t){t=Object.assign({},n.defaults,t),e.core.ruler.push("anchor",function(n){var e,i={},u=n.tokens,o=Array.isArray(t.level)?(e=t.level,function(n){return e.includes(n)}):function(n){return function(e){return e>=n}}(t.level);u.filter(function(n){return"heading_open"===n.type}).filter(function(n){return o(Number(n.tag.substr(1)))}).forEach(function(e){var o=u[u.indexOf(e)+1].children.filter(function(n){return"text"===n.type||"code_inline"===n.type}).reduce(function(n,e){return n+e.content},""),c=e.attrGet("id");c=null==c?r(t.slugify(o),i,!1):r(c,i,!0),e.attrSet("id",c),t.permalink&&t.renderPermalink(c,t,n,u.indexOf(e)),t.callback&&t.callback(e,{slug:c,title:o})})})};t.defaults={level:1,slugify:function(n){return encodeURIComponent(String(n).trim().toLowerCase().replace(/\s+/g,"-"))},permalink:!1,renderPermalink:function(e,r,t,i){var u,o=[Object.assign(new t.Token("link_open","a",1),{attrs:[["class",r.permalinkClass],["href",r.permalinkHref(e,t)]].concat(Object.entries(r.permalinkAttrs(e,t)))}),Object.assign(new t.Token("html_block","",0),{content:r.permalinkSymbol}),new t.Token("link_close","a",-1)];r.permalinkSpace&&o[n[!r.permalinkBefore]](Object.assign(new t.Token("text","",0),{content:" "})),(u=t.tokens[i+1].children)[n[r.permalinkBefore]].apply(u,o)},permalinkClass:"header-anchor",permalinkSpace:!0,permalinkSymbol:"¶",permalinkBefore:!1,permalinkHref:function(n){return"#"+n},permalinkAttrs:function(n){return{}}};/* harmony default export */ __webpack_exports__["default"] = (t);
//# sourceMappingURL=markdownItAnchor.mjs.map


/***/ }),
/* 198 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


const patternsConfig = __webpack_require__(199);

const defaultOptions = {
  leftDelimiter: '{',
  rightDelimiter: '}',
  allowedAttributes: []
};

module.exports = function attributes(md, options_) {
  let options = Object.assign({}, defaultOptions);
  options = Object.assign(options, options_);
  const patterns = patternsConfig(options);

  function curlyAttrs(state) {
    let tokens = state.tokens;

    for (let i = 0; i < tokens.length; i++) {
      for (let p = 0; p < patterns.length; p++) {
        let pattern = patterns[p];
        let j = null; // position of child with offset 0

        let match = pattern.tests.every(t => {
          let res = test(tokens, i, t);

          if (res.j !== null) {
            j = res.j;
          }

          return res.match;
        });

        if (match) {
          pattern.transform(tokens, i, j);

          if (pattern.name === 'inline attributes' || pattern.name === 'inline nesting 0') {
            // retry, may be several inline attributes
            p--;
          }
        }
      }
    }
  }

  md.core.ruler.before('linkify', 'curly_attributes', curlyAttrs);
};
/**
 * Test if t matches token stream.
 *
 * @param {array} tokens
 * @param {number} i
 * @param {object} t Test to match.
 * @return {object} { match: true|false, j: null|number }
 */


function test(tokens, i, t) {
  let res = {
    match: false,
    j: null // position of child

  };
  let ii = t.shift !== undefined ? i + t.shift : t.position;
  let token = get(tokens, ii); // supports negative ii

  if (token === undefined) {
    return res;
  }

  for (let key in t) {
    if (key === 'shift' || key === 'position') {
      continue;
    }

    if (token[key] === undefined) {
      return res;
    }

    if (key === 'children' && isArrayOfObjects(t.children)) {
      if (token.children.length === 0) {
        return res;
      }

      let match;
      let childTests = t.children;
      let children = token.children;

      if (childTests.every(tt => tt.position !== undefined)) {
        // positions instead of shifts, do not loop all children
        match = childTests.every(tt => test(children, tt.position, tt).match);

        if (match) {
          // we may need position of child in transform
          let j = last(childTests).position;
          res.j = j >= 0 ? j : children.length + j;
        }
      } else {
        for (let j = 0; j < children.length; j++) {
          match = childTests.every(tt => test(children, j, tt).match);

          if (match) {
            res.j = j; // all tests true, continue with next key of pattern t

            break;
          }
        }
      }

      if (match === false) {
        return res;
      }

      continue;
    }

    switch (typeof t[key]) {
      case 'boolean':
      case 'number':
      case 'string':
        if (token[key] !== t[key]) {
          return res;
        }

        break;

      case 'function':
        if (!t[key](token[key])) {
          return res;
        }

        break;

      case 'object':
        if (isArrayOfFunctions(t[key])) {
          let r = t[key].every(tt => tt(token[key]));

          if (r === false) {
            return res;
          }

          break;
        }

      // fall through for objects !== arrays of functions

      default:
        throw new Error(`Unknown type of pattern test (key: ${key}). Test should be of type boolean, number, string, function or array of functions.`);
    }
  } // no tests returned false -> all tests returns true


  res.match = true;
  return res;
}

function isArrayOfObjects(arr) {
  return Array.isArray(arr) && arr.length && arr.every(i => typeof i === 'object');
}

function isArrayOfFunctions(arr) {
  return Array.isArray(arr) && arr.length && arr.every(i => typeof i === 'function');
}
/**
 * Get n item of array. Supports negative n, where -1 is last
 * element in array.
 * @param {array} arr
 * @param {number} n
 */


function get(arr, n) {
  return n >= 0 ? arr[n] : arr[arr.length + n];
} // get last element of array, safe - returns {} if not found


function last(arr) {
  return arr.slice(-1)[0] || {};
}

/***/ }),
/* 199 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * If a pattern matches the token stream,
 * then run transform.
 */

const utils = __webpack_require__(200);

module.exports = options => {
  const __hr = new RegExp('^ {0,3}[-*_]{3,} ?' + utils.escapeRegExp(options.leftDelimiter) + '[^' + utils.escapeRegExp(options.rightDelimiter) + ']');

  return [{
    /**
     * ```python {.cls}
     * for i in range(10):
     *     print(i)
     * ```
     */
    name: 'fenced code blocks',
    tests: [{
      shift: 0,
      block: true,
      info: utils.hasDelimiters('end', options)
    }],
    transform: (tokens, i) => {
      let token = tokens[i];
      let start = token.info.lastIndexOf(options.leftDelimiter);
      let attrs = utils.getAttrs(token.info, start, options);
      utils.addAttrs(attrs, token);
      token.info = utils.removeDelimiter(token.info, options);
    }
  }, {
    /**
     * bla `click()`{.c} ![](img.png){.d}
     *
     * differs from 'inline attributes' as it does
     * not have a closing tag (nesting: -1)
     */
    name: 'inline nesting 0',
    tests: [{
      shift: 0,
      type: 'inline',
      children: [{
        shift: -1,
        type: str => str === 'image' || str === 'code_inline'
      }, {
        shift: 0,
        type: 'text',
        content: utils.hasDelimiters('start', options)
      }]
    }],
    transform: (tokens, i, j) => {
      let token = tokens[i].children[j];
      let endChar = token.content.indexOf(options.rightDelimiter);
      let attrToken = tokens[i].children[j - 1];
      let attrs = utils.getAttrs(token.content, 0, options);
      utils.addAttrs(attrs, attrToken);

      if (token.content.length === endChar + options.rightDelimiter.length) {
        tokens[i].children.splice(j, 1);
      } else {
        token.content = token.content.slice(endChar + options.rightDelimiter.length);
      }
    }
  }, {
    /**
     * | h1 |
     * | -- |
     * | c1 |
     * {.c}
     */
    name: 'tables',
    tests: [{
      // let this token be i, such that for-loop continues at
      // next token after tokens.splice
      shift: 0,
      type: 'table_close'
    }, {
      shift: 1,
      type: 'paragraph_open'
    }, {
      shift: 2,
      type: 'inline',
      content: utils.hasDelimiters('only', options)
    }],
    transform: (tokens, i) => {
      let token = tokens[i + 2];
      let tableOpen = utils.getMatchingOpeningToken(tokens, i);
      let attrs = utils.getAttrs(token.content, 0, options); // add attributes

      utils.addAttrs(attrs, tableOpen); // remove <p>{.c}</p>

      tokens.splice(i + 1, 3);
    }
  }, {
    /**
     * *emphasis*{.with attrs=1}
     */
    name: 'inline attributes',
    tests: [{
      shift: 0,
      type: 'inline',
      children: [{
        shift: -1,
        nesting: -1 // closing inline tag, </em>{.a}

      }, {
        shift: 0,
        type: 'text',
        content: utils.hasDelimiters('start', options)
      }]
    }],
    transform: (tokens, i, j) => {
      let token = tokens[i].children[j];
      let content = token.content;
      let attrs = utils.getAttrs(content, 0, options);
      let openingToken = utils.getMatchingOpeningToken(tokens[i].children, j - 1);
      utils.addAttrs(attrs, openingToken);
      token.content = content.slice(content.indexOf(options.rightDelimiter) + options.rightDelimiter.length);
    }
  }, {
    /**
     * - item
     * {.a}
     */
    name: 'list softbreak',
    tests: [{
      shift: -2,
      type: 'list_item_open'
    }, {
      shift: 0,
      type: 'inline',
      children: [{
        position: -2,
        type: 'softbreak'
      }, {
        position: -1,
        type: 'text',
        content: utils.hasDelimiters('only', options)
      }]
    }],
    transform: (tokens, i, j) => {
      let token = tokens[i].children[j];
      let content = token.content;
      let attrs = utils.getAttrs(content, 0, options);
      let ii = i - 2;

      while (tokens[ii - 1] && tokens[ii - 1].type !== 'ordered_list_open' && tokens[ii - 1].type !== 'bullet_list_open') {
        ii--;
      }

      utils.addAttrs(attrs, tokens[ii - 1]);
      tokens[i].children = tokens[i].children.slice(0, -2);
    }
  }, {
    /**
     * - nested list
     *   - with double \n
     *   {.a} <-- apply to nested ul
     *
     * {.b} <-- apply to root <ul>
     */
    name: 'list double softbreak',
    tests: [{
      // let this token be i = 0 so that we can erase
      // the <p>{.a}</p> tokens below
      shift: 0,
      type: str => str === 'bullet_list_close' || str === 'ordered_list_close'
    }, {
      shift: 1,
      type: 'paragraph_open'
    }, {
      shift: 2,
      type: 'inline',
      content: utils.hasDelimiters('only', options),
      children: arr => arr.length === 1
    }, {
      shift: 3,
      type: 'paragraph_close'
    }],
    transform: (tokens, i) => {
      let token = tokens[i + 2];
      let content = token.content;
      let attrs = utils.getAttrs(content, 0, options);
      let openingToken = utils.getMatchingOpeningToken(tokens, i);
      utils.addAttrs(attrs, openingToken);
      tokens.splice(i + 1, 3);
    }
  }, {
    /**
     * - end of {.list-item}
     */
    name: 'list item end',
    tests: [{
      shift: -2,
      type: 'list_item_open'
    }, {
      shift: 0,
      type: 'inline',
      children: [{
        position: -1,
        type: 'text',
        content: utils.hasDelimiters('end', options)
      }]
    }],
    transform: (tokens, i, j) => {
      let token = tokens[i].children[j];
      let content = token.content;
      let attrs = utils.getAttrs(content, content.lastIndexOf(options.leftDelimiter), options);
      utils.addAttrs(attrs, tokens[i - 2]);
      let trimmed = content.slice(0, content.lastIndexOf(options.leftDelimiter));
      token.content = last(trimmed) !== ' ' ? trimmed : trimmed.slice(0, -1);
    }
  }, {
    /**
     * something with softbreak
     * {.cls}
     */
    name: '\n{.a} softbreak then curly in start',
    tests: [{
      shift: 0,
      type: 'inline',
      children: [{
        position: -2,
        type: 'softbreak'
      }, {
        position: -1,
        type: 'text',
        content: utils.hasDelimiters('only', options)
      }]
    }],
    transform: (tokens, i, j) => {
      let token = tokens[i].children[j];
      let attrs = utils.getAttrs(token.content, 0, options); // find last closing tag

      let ii = i + 1;

      while (tokens[ii + 1] && tokens[ii + 1].nesting === -1) {
        ii++;
      }

      let openingToken = utils.getMatchingOpeningToken(tokens, ii);
      utils.addAttrs(attrs, openingToken);
      tokens[i].children = tokens[i].children.slice(0, -2);
    }
  }, {
    /**
     * horizontal rule --- {#id}
     */
    name: 'horizontal rule',
    tests: [{
      shift: 0,
      type: 'paragraph_open'
    }, {
      shift: 1,
      type: 'inline',
      children: arr => arr.length === 1,
      content: str => str.match(__hr) !== null
    }, {
      shift: 2,
      type: 'paragraph_close'
    }],
    transform: (tokens, i) => {
      let token = tokens[i];
      token.type = 'hr';
      token.tag = 'hr';
      token.nesting = 0;
      let content = tokens[i + 1].content;
      let start = content.lastIndexOf(options.leftDelimiter);
      token.attrs = utils.getAttrs(content, start, options);
      token.markup = content;
      tokens.splice(i + 1, 2);
    }
  }, {
    /**
     * end of {.block}
     */
    name: 'end of block',
    tests: [{
      shift: 0,
      type: 'inline',
      children: [{
        position: -1,
        content: utils.hasDelimiters('end', options),
        type: t => t !== 'code_inline'
      }]
    }],
    transform: (tokens, i, j) => {
      let token = tokens[i].children[j];
      let content = token.content;
      let attrs = utils.getAttrs(content, content.lastIndexOf(options.leftDelimiter), options);
      let ii = i + 1;

      while (tokens[ii + 1] && tokens[ii + 1].nesting === -1) {
        ii++;
      }

      let openingToken = utils.getMatchingOpeningToken(tokens, ii);
      utils.addAttrs(attrs, openingToken);
      let trimmed = content.slice(0, content.lastIndexOf(options.leftDelimiter));
      token.content = last(trimmed) !== ' ' ? trimmed : trimmed.slice(0, -1);
    }
  }];
}; // get last element of array or string


function last(arr) {
  return arr.slice(-1)[0];
}

/***/ }),
/* 200 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * parse {.class #id key=val} strings
 * @param {string} str: string to parse
 * @param {int} start: where to start parsing (including {)
 * @returns {2d array}: [['key', 'val'], ['class', 'red']]
 */

exports.getAttrs = function (str, start, options) {
  // not tab, line feed, form feed, space, solidus, greater than sign, quotation mark, apostrophe and equals sign
  const allowedKeyChars = /[^\t\n\f />"'=]/;
  const pairSeparator = ' ';
  const keySeparator = '=';
  const classChar = '.';
  const idChar = '#';
  const attrs = [];
  let key = '';
  let value = '';
  let parsingKey = true;
  let valueInsideQuotes = false; // read inside {}
  // start + left delimiter length to avoid beginning {
  // breaks when } is found or end of string

  for (let i = start + options.leftDelimiter.length; i < str.length; i++) {
    if (str.slice(i, i + options.rightDelimiter.length) === options.rightDelimiter) {
      if (key !== '') {
        attrs.push([key, value]);
      }

      break;
    }

    let char_ = str.charAt(i); // switch to reading value if equal sign

    if (char_ === keySeparator && parsingKey) {
      parsingKey = false;
      continue;
    } // {.class} {..css-module}


    if (char_ === classChar && key === '') {
      if (str.charAt(i + 1) === classChar) {
        key = 'css-module';
        i += 1;
      } else {
        key = 'class';
      }

      parsingKey = false;
      continue;
    } // {#id}


    if (char_ === idChar && key === '') {
      key = 'id';
      parsingKey = false;
      continue;
    } // {value="inside quotes"}


    if (char_ === '"' && value === '') {
      valueInsideQuotes = true;
      continue;
    }

    if (char_ === '"' && valueInsideQuotes) {
      valueInsideQuotes = false;
      continue;
    } // read next key/value pair


    if (char_ === pairSeparator && !valueInsideQuotes) {
      if (key === '') {
        // beginning or ending space: { .red } vs {.red}
        continue;
      }

      attrs.push([key, value]);
      key = '';
      value = '';
      parsingKey = true;
      continue;
    } // continue if character not allowed


    if (parsingKey && char_.search(allowedKeyChars) === -1) {
      continue;
    } // no other conditions met; append to key/value


    if (parsingKey) {
      key += char_;
      continue;
    }

    value += char_;
  }

  if (options.allowedAttributes && options.allowedAttributes.length) {
    let allowedAttributes = options.allowedAttributes;
    return attrs.filter(function (attrPair) {
      let attr = attrPair[0];

      function isAllowedAttribute(allowedAttribute) {
        return attr === allowedAttribute || allowedAttribute instanceof RegExp && allowedAttribute.test(attr);
      }

      return allowedAttributes.some(isAllowedAttribute);
    });
  } else {
    return attrs;
  }
};
/**
 * add attributes from [['key', 'val']] list
 * @param {array} attrs: [['key', 'val']]
 * @param {token} token: which token to add attributes
 * @returns token
 */


exports.addAttrs = function (attrs, token) {
  for (let j = 0, l = attrs.length; j < l; ++j) {
    let key = attrs[j][0];

    if (key === 'class') {
      token.attrJoin('class', attrs[j][1]);
    } else if (key === 'css-module') {
      token.attrJoin('css-module', attrs[j][1]);
    } else {
      token.attrPush(attrs[j]);
    }
  }

  return token;
};
/**
 * Does string have properly formatted curly?
 *
 * start: '{.a} asdf'
 * middle: 'a{.b}c'
 * end: 'asdf {.a}'
 * only: '{.a}'
 *
 * @param {string} where to expect {} curly. start, middle, end or only.
 * @return {function(string)} Function which testes if string has curly.
 */


exports.hasDelimiters = function (where, options) {
  if (!where) {
    throw new Error('Parameter `where` not passed. Should be "start", "middle", "end" or "only".');
  }
  /**
   * @param {string} str
   * @return {boolean}
   */


  return function (str) {
    // we need minimum three chars, for example {b}
    let minCurlyLength = options.leftDelimiter.length + 1 + options.rightDelimiter.length;

    if (!str || typeof str !== 'string' || str.length < minCurlyLength) {
      return false;
    }

    function validCurlyLength(curly) {
      let isClass = curly.charAt(options.leftDelimiter.length) === '.';
      let isId = curly.charAt(options.leftDelimiter.length) === '#';
      return isClass || isId ? curly.length >= minCurlyLength + 1 : curly.length >= minCurlyLength;
    }

    let start, end, slice, nextChar;
    let rightDelimiterMinimumShift = minCurlyLength - options.rightDelimiter.length;

    switch (where) {
      case 'start':
        // first char should be {, } found in char 2 or more
        slice = str.slice(0, options.leftDelimiter.length);
        start = slice === options.leftDelimiter ? 0 : -1;
        end = start === -1 ? -1 : str.indexOf(options.rightDelimiter, rightDelimiterMinimumShift); // check if next character is not one of the delimiters

        nextChar = str.charAt(end + options.rightDelimiter.length);

        if (nextChar && options.rightDelimiter.indexOf(nextChar) !== -1) {
          end = -1;
        }

        break;

      case 'end':
        // last char should be }
        start = str.lastIndexOf(options.leftDelimiter);
        end = start === -1 ? -1 : str.indexOf(options.rightDelimiter, start + rightDelimiterMinimumShift);
        end = end === str.length - options.rightDelimiter.length ? end : -1;
        break;

      case 'only':
        // '{.a}'
        slice = str.slice(0, options.leftDelimiter.length);
        start = slice === options.leftDelimiter ? 0 : -1;
        slice = str.slice(str.length - options.rightDelimiter.length);
        end = slice === options.rightDelimiter ? str.length - options.rightDelimiter.length : -1;
        break;
    }

    return start !== -1 && end !== -1 && validCurlyLength(str.substring(start, end + options.rightDelimiter.length));
  };
};
/**
 * Removes last curly from string.
 */


exports.removeDelimiter = function (str, options) {
  const start = escapeRegExp(options.leftDelimiter);
  const end = escapeRegExp(options.rightDelimiter);
  let curly = new RegExp('[ \\n]?' + start + '[^' + start + end + ']+' + end + '$');
  let pos = str.search(curly);
  return pos !== -1 ? str.slice(0, pos) : str;
};
/**
 * Escapes special characters in string s such that the string
 * can be used in `new RegExp`. For example "[" becomes "\\[".
 *
 * @param {string} s Regex string.
 * @return {string} Escaped string.
 */


function escapeRegExp(s) {
  return s.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
}

exports.escapeRegExp = escapeRegExp;
/**
 * find corresponding opening block
 */

exports.getMatchingOpeningToken = function (tokens, i) {
  if (tokens[i].type === 'softbreak') {
    return false;
  } // non closing blocks, example img


  if (tokens[i].nesting === 0) {
    return tokens[i];
  }

  let level = tokens[i].level;
  let type = tokens[i].type.replace('_close', '_open');

  for (; i >= 0; --i) {
    if (tokens[i].type === type && tokens[i].level === level) {
      return tokens[i];
    }
  }
};
/**
 * from https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js
 */


let HTML_ESCAPE_TEST_RE = /[&<>"]/;
let HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
let HTML_REPLACEMENTS = {
  '&': '&amp;',
  '<': '&lt;',
  '>': '&gt;',
  '"': '&quot;'
};

function replaceUnsafeChar(ch) {
  return HTML_REPLACEMENTS[ch];
}

exports.escapeHtml = function (str) {
  if (HTML_ESCAPE_TEST_RE.test(str)) {
    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
  }

  return str;
};

/***/ }),
/* 201 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = function bracketed_spans_plugin(md) {
  function span(state) {
    var max = state.posMax;

    if (state.src.charCodeAt(state.pos) !== 0x5B) {
      // opening [
      return false;
    }

    var labelStart = state.pos + 1;
    var labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);

    if (labelEnd < 0) {
      // parser failed to find closing ]
      return false;
    }

    var pos = labelEnd + 1;

    if (pos < max && state.src.charCodeAt(pos) === 0x7B
    /* { */
    ) {
        // probably found span
        state.pos = labelStart;
        state.posMax = labelEnd;
        state.push('span_open', 'span', 1);
        state.md.inline.tokenize(state);
        state.push('span_close', 'span', -1);
        state.pos = pos;
        state.posMax = max;
        return true;
      } else {
      return false;
    }
  }

  ;
  md.inline.ruler.push('bracketed-spans', span);
};

/***/ }),
/* 202 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/* eslint-disable no-cond-assign */

var tagExpr = /^<!-- ?\{(?:([a-z0-9]+)(\^[0-9]*)?: ?)?(.*)\} ?-->\n?$/;
var tagExprRehype = /^<!--rehype:(?:([a-z0-9]+)(\^[0-9]*)?: ?)?(.*)-->\n?$/;

module.exports = function attributes(md) {
  md.core.ruler.push('curly_attributes', curlyAttrs);
};
/*
 * List of tag -> token type mappings. Eg, `<li>` is `list_item_open`.
 */


var opening = {
  li: ['list_item'],
  ul: ['bullet_list'],
  p: ['paragraph'],
  ol: ['ordered_list'],
  blockquote: ['blockquote'],
  h1: ['heading'],
  h2: ['heading'],
  h3: ['heading'],
  h4: ['heading'],
  h5: ['heading'],
  h6: ['heading'],
  a: ['link'],
  code: ['code_inline', 'code_block', 'fence']
};
var selfClosing = {
  hr: true,
  image: true
};
/**
 * ...
 */

function curlyAttrs(state) {
  var tokens = state.tokens;
  var omissions = [];
  var parent, m;
  var stack = {
    len: 0,
    contents: [],
    types: {}
  };
  tokens.forEach(function (token, i) {
    // Save breadcrumbs so html_block will pick it up
    if (isOpener(token.type) || selfClosing[token.type]) {
      spush(stack, token);
    } // "# Hello\n<!--{.classname}-->"
    // ...sequence of [heading_open, inline, heading_close, html_block]


    if (token.type === 'html_block') {
      m = token.content.match(tagExpr) || token.content.match(tagExprRehype);
      if (!m) return;
      parent = findParent(stack, m[1], m[2]);

      if (parent && applyToToken(parent, m[3])) {
        omissions.unshift(i);
      }
    } // "# Hello <!--{.classname} -->"
    // { type: 'inline', children: { ..., '<!--{...}-->' } }


    if (token.type === 'inline') {
      curlyInline(token.children, stack);
    }
  }); // Remove <!--...--> html_block tokens

  omissions.forEach(function (idx) {
    return tokens.splice(idx, 1);
  });
}
/**
 * Internal: checks in a token type is a block opener
 */


function isOpener(type) {
  return type.match(/_(open|start)$/) || type === 'fence' || type === 'code_block';
}
/**
 * Internal: Run through inline and stuff
 */


function curlyInline(children, stack) {
  var lastText, m, parent; // Keep a list of sub-tokens to be removed

  var omissions = [];
  children.forEach(function (child, i) {
    if (isOpener(child.type) || selfClosing[child.type] || child.type === 'code_inline') {
      spush(stack, child);
    } // Decorate tags are found


    if (m = child.content.match(tagExpr) || child.content.match(tagExprRehype)) {
      var tag = m[1];
      var depth = m[2];
      var attrs = m[3]; // Remove the comment, then remove the extra space

      parent = findParent(stack, tag, depth);

      if (parent && applyToToken(parent, attrs)) {
        omissions.unshift(i);
        if (lastText) trimRight(lastText, 'content');
      }
    }

    if (child.type === 'text') lastText = child;
  }); // Remove them in a separate step so we don't

  omissions.forEach(function (idx) {
    children.splice(idx, 1);
  });
}
/**
 * Private: given a list of tokens `list` and `lastParent`, find the one that
 * matches `tag`.
 */


function findParent(stack, tag, depth) {
  if (!tag) return stack.last;

  if (depth === '^') {
    depth = 1;
  } else if (typeof depth === 'string') {
    /* '^2' */
    depth = +depth.substr(1);
  } else {
    depth = 0;
  }

  var targets = opening[tag.toLowerCase()] || [tag.toLowerCase()];
  var target = targets.filter(function (target) {
    return stack.types[target];
  });
  var list = stack.types[target];
  if (!list) return; // Can't find tag `tag`

  return list[list.length - 1 - depth];
}
/**
 * Private: trim the right
 */


function trimRight(obj, attr) {
  obj[attr] = obj[attr].replace(/\s*$/, '');
}
/**
 * Private: apply tag to token
 *
 *     applyToToken(token, '.classname')
 */


function applyToToken(token, attrs) {
  var m;
  var todo = [];

  while (attrs.length > 0) {
    if (m = attrs.match(/^\s*\.([a-zA-Z0-9\-_]+)/)) {
      todo.push(['class', m[1], {
        append: true
      }]);
      shift();
    } else if (m = attrs.match(/^\s*#([a-zA-Z0-9\-_]+)/)) {
      todo.push(['id', m[1]]);
      shift();
    } else if (m = attrs.match(/^\s*([a-zA-Z0-9\-_]+)="([^"]*)"/)) {
      todo.push([m[1], m[2]]);
      shift();
    } else if (m = attrs.match(/^\s*([a-zA-Z0-9\-_]+)='([^']*)'/)) {
      todo.push([m[1], m[2]]);
      shift();
    } else if (m = attrs.match(/^\s*([a-zA-Z0-9\-_]+)=([^ ]*)/)) {
      todo.push([m[1], m[2]]);
      shift();
    } else if (m = attrs.match(/^\s*([a-zA-Z0-9\-_]+)/)) {
      todo.push([m[1], '']);
      shift();
    } else if (m = attrs.match(/^\s+/)) {
      shift();
    } else {
      return;
    }
  }

  todo.forEach(function (args) {
    setAttr.apply(this, [token].concat(args));
  });
  return true;

  function shift() {
    attrs = attrs.substr(m[0].length);
  }
}
/**
 * Private: sets an attribute `attr` to `value` in a token. If `options.append`
 * is true, append to the old value instead of overwriting it.
 */


function setAttr(token, attr, value, options) {
  var idx = token.attrIndex(attr);

  if (idx === -1) {
    token.attrPush([attr, value]);
  } else if (options && options.append) {
    token.attrs[idx][1] = token.attrs[idx][1] + ' ' + value;
  } else {
    token.attrs[idx][1] = value;
  }
}
/**
 * Private: pushes a token to the stack
 */


function spush(stack, token) {
  var type = token.type.replace(/_(open|start)$/, '');

  if (!stack.types[type]) {
    stack.types[type] = [];
  }

  stack.types[type].push(token);
  stack.last = token;
}

/***/ }),
/* 203 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Process definition lists
//


module.exports = function deflist_plugin(md) {
  var isSpace = md.utils.isSpace; // Search `[:~][\n ]`, returns next pos after marker on success
  // or -1 on fail.

  function skipMarker(state, line) {
    var pos,
        marker,
        start = state.bMarks[line] + state.tShift[line],
        max = state.eMarks[line];

    if (start >= max) {
      return -1;
    } // Check bullet


    marker = state.src.charCodeAt(start++);

    if (marker !== 0x7E
    /* ~ */
    && marker !== 0x3A
    /* : */
    ) {
        return -1;
      }

    pos = state.skipSpaces(start); // require space after ":"

    if (start === pos) {
      return -1;
    } // no empty definitions, e.g. "  : "


    if (pos >= max) {
      return -1;
    }

    return start;
  }

  function markTightParagraphs(state, idx) {
    var i,
        l,
        level = state.level + 2;

    for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
      if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {
        state.tokens[i + 2].hidden = true;
        state.tokens[i].hidden = true;
        i += 2;
      }
    }
  }

  function deflist(state, startLine, endLine, silent) {
    var ch, contentStart, ddLine, dtLine, itemLines, listLines, listTokIdx, max, nextLine, offset, oldDDIndent, oldIndent, oldParentType, oldSCount, oldTShift, oldTight, pos, prevEmptyEnd, tight, token;

    if (silent) {
      // quirk: validation mode validates a dd block only, not a whole deflist
      if (state.ddIndent < 0) {
        return false;
      }

      return skipMarker(state, startLine) >= 0;
    }

    nextLine = startLine + 1;

    if (nextLine >= endLine) {
      return false;
    }

    if (state.isEmpty(nextLine)) {
      nextLine++;

      if (nextLine >= endLine) {
        return false;
      }
    }

    if (state.sCount[nextLine] < state.blkIndent) {
      return false;
    }

    contentStart = skipMarker(state, nextLine);

    if (contentStart < 0) {
      return false;
    } // Start list


    listTokIdx = state.tokens.length;
    tight = true;
    token = state.push('dl_open', 'dl', 1);
    token.map = listLines = [startLine, 0]; //
    // Iterate list items
    //

    dtLine = startLine;
    ddLine = nextLine; // One definition list can contain multiple DTs,
    // and one DT can be followed by multiple DDs.
    //
    // Thus, there is two loops here, and label is
    // needed to break out of the second one
    //

    /*eslint no-labels:0,block-scoped-var:0*/

    OUTER: for (;;) {
      prevEmptyEnd = false;
      token = state.push('dt_open', 'dt', 1);
      token.map = [dtLine, dtLine];
      token = state.push('inline', '', 0);
      token.map = [dtLine, dtLine];
      token.content = state.getLines(dtLine, dtLine + 1, state.blkIndent, false).trim();
      token.children = [];
      token = state.push('dt_close', 'dt', -1);

      for (;;) {
        token = state.push('dd_open', 'dd', 1);
        token.map = itemLines = [nextLine, 0];
        pos = contentStart;
        max = state.eMarks[ddLine];
        offset = state.sCount[ddLine] + contentStart - (state.bMarks[ddLine] + state.tShift[ddLine]);

        while (pos < max) {
          ch = state.src.charCodeAt(pos);

          if (isSpace(ch)) {
            if (ch === 0x09) {
              offset += 4 - offset % 4;
            } else {
              offset++;
            }
          } else {
            break;
          }

          pos++;
        }

        contentStart = pos;
        oldTight = state.tight;
        oldDDIndent = state.ddIndent;
        oldIndent = state.blkIndent;
        oldTShift = state.tShift[ddLine];
        oldSCount = state.sCount[ddLine];
        oldParentType = state.parentType;
        state.blkIndent = state.ddIndent = state.sCount[ddLine] + 2;
        state.tShift[ddLine] = contentStart - state.bMarks[ddLine];
        state.sCount[ddLine] = offset;
        state.tight = true;
        state.parentType = 'deflist';
        state.md.block.tokenize(state, ddLine, endLine, true); // If any of list item is tight, mark list as tight

        if (!state.tight || prevEmptyEnd) {
          tight = false;
        } // Item become loose if finish with empty line,
        // but we should filter last element, because it means list finish


        prevEmptyEnd = state.line - ddLine > 1 && state.isEmpty(state.line - 1);
        state.tShift[ddLine] = oldTShift;
        state.sCount[ddLine] = oldSCount;
        state.tight = oldTight;
        state.parentType = oldParentType;
        state.blkIndent = oldIndent;
        state.ddIndent = oldDDIndent;
        token = state.push('dd_close', 'dd', -1);
        itemLines[1] = nextLine = state.line;

        if (nextLine >= endLine) {
          break OUTER;
        }

        if (state.sCount[nextLine] < state.blkIndent) {
          break OUTER;
        }

        contentStart = skipMarker(state, nextLine);

        if (contentStart < 0) {
          break;
        }

        ddLine = nextLine; // go to the next loop iteration:
        // insert DD tag and repeat checking
      }

      if (nextLine >= endLine) {
        break;
      }

      dtLine = nextLine;

      if (state.isEmpty(dtLine)) {
        break;
      }

      if (state.sCount[dtLine] < state.blkIndent) {
        break;
      }

      ddLine = dtLine + 1;

      if (ddLine >= endLine) {
        break;
      }

      if (state.isEmpty(ddLine)) {
        ddLine++;
      }

      if (ddLine >= endLine) {
        break;
      }

      if (state.sCount[ddLine] < state.blkIndent) {
        break;
      }

      contentStart = skipMarker(state, ddLine);

      if (contentStart < 0) {
        break;
      } // go to the next loop iteration:
      // insert DT and DD tags and repeat checking

    } // Finilize list


    token = state.push('dl_close', 'dl', -1);
    listLines[1] = nextLine;
    state.line = nextLine; // mark paragraphs tight if needed

    if (tight) {
      markTightParagraphs(state, listTokIdx);
    }

    return true;
  }

  md.block.ruler.before('paragraph', 'deflist', deflist, {
    alt: ['paragraph', 'reference']
  });
};

/***/ }),
/* 204 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// Process footnotes
//
 ////////////////////////////////////////////////////////////////////////////////
// Renderer partials

function render_footnote_anchor_name(tokens, idx, options, env
/*, slf*/
) {
  var n = Number(tokens[idx].meta.id + 1).toString();
  var prefix = '';

  if (typeof env.docId === 'string') {
    prefix = '-' + env.docId + '-';
  }

  return prefix + n;
}

function render_footnote_caption(tokens, idx
/*, options, env, slf*/
) {
  var n = Number(tokens[idx].meta.id + 1).toString();

  if (tokens[idx].meta.subId > 0) {
    n += ':' + tokens[idx].meta.subId;
  }

  return '[' + n + ']';
}

function render_footnote_ref(tokens, idx, options, env, slf) {
  var id = slf.rules.footnote_anchor_name(tokens, idx, options, env, slf);
  var caption = slf.rules.footnote_caption(tokens, idx, options, env, slf);
  var refid = id;

  if (tokens[idx].meta.subId > 0) {
    refid += ':' + tokens[idx].meta.subId;
  }

  return '<sup class="footnote-ref"><a href="#fn' + id + '" id="fnref' + refid + '">' + caption + '</a></sup>';
}

function render_footnote_block_open(tokens, idx, options) {
  return (options.xhtmlOut ? '<hr class="footnotes-sep" />\n' : '<hr class="footnotes-sep">\n') + '<section class="footnotes">\n' + '<ol class="footnotes-list">\n';
}

function render_footnote_block_close() {
  return '</ol>\n</section>\n';
}

function render_footnote_open(tokens, idx, options, env, slf) {
  var id = slf.rules.footnote_anchor_name(tokens, idx, options, env, slf);

  if (tokens[idx].meta.subId > 0) {
    id += ':' + tokens[idx].meta.subId;
  }

  return '<li id="fn' + id + '" class="footnote-item">';
}

function render_footnote_close() {
  return '</li>\n';
}

function render_footnote_anchor(tokens, idx, options, env, slf) {
  var id = slf.rules.footnote_anchor_name(tokens, idx, options, env, slf);

  if (tokens[idx].meta.subId > 0) {
    id += ':' + tokens[idx].meta.subId;
  }
  /* ↩ with escape code to prevent display as Apple Emoji on iOS */


  return ' <a href="#fnref' + id + '" class="footnote-backref">\u21a9\uFE0E</a>';
}

module.exports = function footnote_plugin(md) {
  var parseLinkLabel = md.helpers.parseLinkLabel,
      isSpace = md.utils.isSpace;
  md.renderer.rules.footnote_ref = render_footnote_ref;
  md.renderer.rules.footnote_block_open = render_footnote_block_open;
  md.renderer.rules.footnote_block_close = render_footnote_block_close;
  md.renderer.rules.footnote_open = render_footnote_open;
  md.renderer.rules.footnote_close = render_footnote_close;
  md.renderer.rules.footnote_anchor = render_footnote_anchor; // helpers (only used in other rules, no tokens are attached to those)

  md.renderer.rules.footnote_caption = render_footnote_caption;
  md.renderer.rules.footnote_anchor_name = render_footnote_anchor_name; // Process footnote block definition

  function footnote_def(state, startLine, endLine, silent) {
    var oldBMark,
        oldTShift,
        oldSCount,
        oldParentType,
        pos,
        label,
        token,
        initial,
        offset,
        ch,
        posAfterColon,
        start = state.bMarks[startLine] + state.tShift[startLine],
        max = state.eMarks[startLine]; // line should be at least 5 chars - "[^x]:"

    if (start + 4 > max) {
      return false;
    }

    if (state.src.charCodeAt(start) !== 0x5B
    /* [ */
    ) {
        return false;
      }

    if (state.src.charCodeAt(start + 1) !== 0x5E
    /* ^ */
    ) {
        return false;
      }

    for (pos = start + 2; pos < max; pos++) {
      if (state.src.charCodeAt(pos) === 0x20) {
        return false;
      }

      if (state.src.charCodeAt(pos) === 0x5D
      /* ] */
      ) {
          break;
        }
    }

    if (pos === start + 2) {
      return false;
    } // no empty footnote labels


    if (pos + 1 >= max || state.src.charCodeAt(++pos) !== 0x3A
    /* : */
    ) {
        return false;
      }

    if (silent) {
      return true;
    }

    pos++;

    if (!state.env.footnotes) {
      state.env.footnotes = {};
    }

    if (!state.env.footnotes.refs) {
      state.env.footnotes.refs = {};
    }

    label = state.src.slice(start + 2, pos - 2);
    state.env.footnotes.refs[':' + label] = -1;
    token = new state.Token('footnote_reference_open', '', 1);
    token.meta = {
      label: label
    };
    token.level = state.level++;
    state.tokens.push(token);
    oldBMark = state.bMarks[startLine];
    oldTShift = state.tShift[startLine];
    oldSCount = state.sCount[startLine];
    oldParentType = state.parentType;
    posAfterColon = pos;
    initial = offset = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine]);

    while (pos < max) {
      ch = state.src.charCodeAt(pos);

      if (isSpace(ch)) {
        if (ch === 0x09) {
          offset += 4 - offset % 4;
        } else {
          offset++;
        }
      } else {
        break;
      }

      pos++;
    }

    state.tShift[startLine] = pos - posAfterColon;
    state.sCount[startLine] = offset - initial;
    state.bMarks[startLine] = posAfterColon;
    state.blkIndent += 4;
    state.parentType = 'footnote';

    if (state.sCount[startLine] < state.blkIndent) {
      state.sCount[startLine] += state.blkIndent;
    }

    state.md.block.tokenize(state, startLine, endLine, true);
    state.parentType = oldParentType;
    state.blkIndent -= 4;
    state.tShift[startLine] = oldTShift;
    state.sCount[startLine] = oldSCount;
    state.bMarks[startLine] = oldBMark;
    token = new state.Token('footnote_reference_close', '', -1);
    token.level = --state.level;
    state.tokens.push(token);
    return true;
  } // Process inline footnotes (^[...])


  function footnote_inline(state, silent) {
    var labelStart,
        labelEnd,
        footnoteId,
        token,
        tokens,
        max = state.posMax,
        start = state.pos;

    if (start + 2 >= max) {
      return false;
    }

    if (state.src.charCodeAt(start) !== 0x5E
    /* ^ */
    ) {
        return false;
      }

    if (state.src.charCodeAt(start + 1) !== 0x5B
    /* [ */
    ) {
        return false;
      }

    labelStart = start + 2;
    labelEnd = parseLinkLabel(state, start + 1); // parser failed to find ']', so it's not a valid note

    if (labelEnd < 0) {
      return false;
    } // We found the end of the link, and know for a fact it's a valid link;
    // so all that's left to do is to call tokenizer.
    //


    if (!silent) {
      if (!state.env.footnotes) {
        state.env.footnotes = {};
      }

      if (!state.env.footnotes.list) {
        state.env.footnotes.list = [];
      }

      footnoteId = state.env.footnotes.list.length;
      state.md.inline.parse(state.src.slice(labelStart, labelEnd), state.md, state.env, tokens = []);
      token = state.push('footnote_ref', '', 0);
      token.meta = {
        id: footnoteId
      };
      state.env.footnotes.list[footnoteId] = {
        content: state.src.slice(labelStart, labelEnd),
        tokens: tokens
      };
    }

    state.pos = labelEnd + 1;
    state.posMax = max;
    return true;
  } // Process footnote references ([^...])


  function footnote_ref(state, silent) {
    var label,
        pos,
        footnoteId,
        footnoteSubId,
        token,
        max = state.posMax,
        start = state.pos; // should be at least 4 chars - "[^x]"

    if (start + 3 > max) {
      return false;
    }

    if (!state.env.footnotes || !state.env.footnotes.refs) {
      return false;
    }

    if (state.src.charCodeAt(start) !== 0x5B
    /* [ */
    ) {
        return false;
      }

    if (state.src.charCodeAt(start + 1) !== 0x5E
    /* ^ */
    ) {
        return false;
      }

    for (pos = start + 2; pos < max; pos++) {
      if (state.src.charCodeAt(pos) === 0x20) {
        return false;
      }

      if (state.src.charCodeAt(pos) === 0x0A) {
        return false;
      }

      if (state.src.charCodeAt(pos) === 0x5D
      /* ] */
      ) {
          break;
        }
    }

    if (pos === start + 2) {
      return false;
    } // no empty footnote labels


    if (pos >= max) {
      return false;
    }

    pos++;
    label = state.src.slice(start + 2, pos - 1);

    if (typeof state.env.footnotes.refs[':' + label] === 'undefined') {
      return false;
    }

    if (!silent) {
      if (!state.env.footnotes.list) {
        state.env.footnotes.list = [];
      }

      if (state.env.footnotes.refs[':' + label] < 0) {
        footnoteId = state.env.footnotes.list.length;
        state.env.footnotes.list[footnoteId] = {
          label: label,
          count: 0
        };
        state.env.footnotes.refs[':' + label] = footnoteId;
      } else {
        footnoteId = state.env.footnotes.refs[':' + label];
      }

      footnoteSubId = state.env.footnotes.list[footnoteId].count;
      state.env.footnotes.list[footnoteId].count++;
      token = state.push('footnote_ref', '', 0);
      token.meta = {
        id: footnoteId,
        subId: footnoteSubId,
        label: label
      };
    }

    state.pos = pos;
    state.posMax = max;
    return true;
  } // Glue footnote tokens to end of token stream


  function footnote_tail(state) {
    var i,
        l,
        j,
        t,
        lastParagraph,
        list,
        token,
        tokens,
        current,
        currentLabel,
        insideRef = false,
        refTokens = {};

    if (!state.env.footnotes) {
      return;
    }

    state.tokens = state.tokens.filter(function (tok) {
      if (tok.type === 'footnote_reference_open') {
        insideRef = true;
        current = [];
        currentLabel = tok.meta.label;
        return false;
      }

      if (tok.type === 'footnote_reference_close') {
        insideRef = false; // prepend ':' to avoid conflict with Object.prototype members

        refTokens[':' + currentLabel] = current;
        return false;
      }

      if (insideRef) {
        current.push(tok);
      }

      return !insideRef;
    });

    if (!state.env.footnotes.list) {
      return;
    }

    list = state.env.footnotes.list;
    token = new state.Token('footnote_block_open', '', 1);
    state.tokens.push(token);

    for (i = 0, l = list.length; i < l; i++) {
      token = new state.Token('footnote_open', '', 1);
      token.meta = {
        id: i,
        label: list[i].label
      };
      state.tokens.push(token);

      if (list[i].tokens) {
        tokens = [];
        token = new state.Token('paragraph_open', 'p', 1);
        token.block = true;
        tokens.push(token);
        token = new state.Token('inline', '', 0);
        token.children = list[i].tokens;
        token.content = list[i].content;
        tokens.push(token);
        token = new state.Token('paragraph_close', 'p', -1);
        token.block = true;
        tokens.push(token);
      } else if (list[i].label) {
        tokens = refTokens[':' + list[i].label];
      }

      state.tokens = state.tokens.concat(tokens);

      if (state.tokens[state.tokens.length - 1].type === 'paragraph_close') {
        lastParagraph = state.tokens.pop();
      } else {
        lastParagraph = null;
      }

      t = list[i].count > 0 ? list[i].count : 1;

      for (j = 0; j < t; j++) {
        token = new state.Token('footnote_anchor', '', 0);
        token.meta = {
          id: i,
          subId: j,
          label: list[i].label
        };
        state.tokens.push(token);
      }

      if (lastParagraph) {
        state.tokens.push(lastParagraph);
      }

      token = new state.Token('footnote_close', '', -1);
      state.tokens.push(token);
    }

    token = new state.Token('footnote_block_close', '', -1);
    state.tokens.push(token);
  }

  md.block.ruler.before('reference', 'footnote_def', footnote_def, {
    alt: ['paragraph', 'reference']
  });
  md.inline.ruler.after('image', 'footnote_inline', footnote_inline);
  md.inline.ruler.after('footnote_inline', 'footnote_ref', footnote_ref);
  md.core.ruler.after('inline', 'footnote_tail', footnote_tail);
};

/***/ }),
/* 205 */
/***/ (function(module, exports) {

// Generated by CoffeeScript 1.12.4

/*
These regular expressions are based on
https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js
(also distributed under MIT License)
 */
(function () {
  var replacements;
  replacements = [{
    name: 'plusminus',
    re: /\+-/g,
    sub: '\u00b1',
    "default": true
  }, {
    name: 'ellipsis',
    re: /\.\.\./g,
    sub: '\u2026',
    "default": true
  }, {
    name: 'mdash',
    re: /(^|[^-])---([^-]|$)/mg,
    sub: '$1\u2014$2',
    "default": true
  }, {
    name: 'ndash',
    re: /(^|[^-])--([^-]|$)/mg,
    sub: '$1\u2013$2',
    "default": true
  }, {
    name: 'ndash',
    re: /(^|[^-\s])--([^-\s]|$)/mg,
    sub: '$1\u2013$2',
    "default": true
  }];

  module.exports = function (md, options) {
    if (options == null) {
      options = {};
    }

    md.core.ruler.at('replacements', function (state) {
      var block, i, inside_autolink, j, k, l, len, len1, len2, m, n, o, ref, ref1, ref2, ref3, ref4, ref5, replacement, results, results1, token;

      ref1 = function () {
        results = [];

        for (var l = 0, ref = state.tokens.length; 0 <= ref ? l < ref : l > ref; 0 <= ref ? l++ : l--) {
          results.push(l);
        }

        return results;
      }.apply(this).reverse();

      for (k = 0, len = ref1.length; k < len; k++) {
        i = ref1[k];
        block = state.tokens[i];

        if (block.type !== 'inline') {
          continue;
        }

        inside_autolink = 0;

        ref3 = function () {
          results1 = [];

          for (var n = 0, ref2 = block.children.length; 0 <= ref2 ? n < ref2 : n > ref2; 0 <= ref2 ? n++ : n--) {
            results1.push(n);
          }

          return results1;
        }.apply(this).reverse();

        for (m = 0, len1 = ref3.length; m < len1; m++) {
          j = ref3[m];
          token = block.children[j];

          switch (token.type) {
            case 'link_open':
              if (token.info === 'auto') {
                inside_autolink -= 1;
              }

              break;

            case 'link_close':
              if (token.info === 'auto') {
                inside_autolink += 1;
              }

              break;

            case 'text':
              if (!inside_autolink) {
                for (o = 0, len2 = replacements.length; o < len2; o++) {
                  replacement = replacements[o];

                  if ((ref4 = (ref5 = options[replacement.name]) != null ? ref5 : replacement["default"]) != null ? ref4 : true) {
                    token.content = token.content.replace(replacement.re, replacement.sub);
                  }
                }
              }

          }
        }
      }

      return null;
    });
    return null;
  };
  /*
  Export replacements array so that user can add their own rules.
  For example: require('markdown-it-replacements').replacements.push({...})
   */


  module.exports.replacements = replacements;
}).call(this);

/***/ }),
/* 206 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(207))

/***/ }),
/* 207 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n// This is CodeMirror (https://codemirror.net), a code editor\n// implemented in JavaScript on top of the browser's DOM.\n//\n// You can find some technical background for some of the code below\n// at http://marijnhaverbeke.nl/blog/#cm-internals .\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = global || self, global.CodeMirror = factory());\n})(this, function () {\n  'use strict'; // Kludges for bugs and behavior differences that can't be feature\n  // detected are enabled based on userAgent etc sniffing.\n\n  var userAgent = navigator.userAgent;\n  var platform = navigator.platform;\n  var gecko = /gecko\\/\\d/i.test(userAgent);\n  var ie_upto10 = /MSIE \\d/.test(userAgent);\n  var ie_11up = /Trident\\/(?:[7-9]|\\d{2,})\\..*rv:(\\d+)/.exec(userAgent);\n  var edge = /Edge\\/(\\d+)/.exec(userAgent);\n  var ie = ie_upto10 || ie_11up || edge;\n  var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]);\n  var webkit = !edge && /WebKit\\//.test(userAgent);\n  var qtwebkit = webkit && /Qt\\/\\d+\\.\\d+/.test(userAgent);\n  var chrome = !edge && /Chrome\\//.test(userAgent);\n  var presto = /Opera\\//.test(userAgent);\n  var safari = /Apple Computer/.test(navigator.vendor);\n  var mac_geMountainLion = /Mac OS X 1\\d\\D([8-9]|\\d\\d)\\D/.test(userAgent);\n  var phantom = /PhantomJS/.test(userAgent);\n  var ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\\/\\w+/.test(userAgent);\n  var android = /Android/.test(userAgent); // This is woefully incomplete. Suggestions for alternative methods welcome.\n\n  var mobile = ios || android || /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent);\n  var mac = ios || /Mac/.test(platform);\n  var chromeOS = /\\bCrOS\\b/.test(userAgent);\n  var windows = /win/i.test(platform);\n  var presto_version = presto && userAgent.match(/Version\\/(\\d*\\.\\d*)/);\n\n  if (presto_version) {\n    presto_version = Number(presto_version[1]);\n  }\n\n  if (presto_version && presto_version >= 15) {\n    presto = false;\n    webkit = true;\n  } // Some browsers use the wrong event properties to signal cmd/ctrl on OS X\n\n\n  var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11));\n  var captureRightClick = gecko || ie && ie_version >= 9;\n\n  function classTest(cls) {\n    return new RegExp(\"(^|\\\\s)\" + cls + \"(?:$|\\\\s)\\\\s*\");\n  }\n\n  var rmClass = function (node, cls) {\n    var current = node.className;\n    var match = classTest(cls).exec(current);\n\n    if (match) {\n      var after = current.slice(match.index + match[0].length);\n      node.className = current.slice(0, match.index) + (after ? match[1] + after : \"\");\n    }\n  };\n\n  function removeChildren(e) {\n    for (var count = e.childNodes.length; count > 0; --count) {\n      e.removeChild(e.firstChild);\n    }\n\n    return e;\n  }\n\n  function removeChildrenAndAdd(parent, e) {\n    return removeChildren(parent).appendChild(e);\n  }\n\n  function elt(tag, content, className, style) {\n    var e = document.createElement(tag);\n\n    if (className) {\n      e.className = className;\n    }\n\n    if (style) {\n      e.style.cssText = style;\n    }\n\n    if (typeof content == \"string\") {\n      e.appendChild(document.createTextNode(content));\n    } else if (content) {\n      for (var i = 0; i < content.length; ++i) {\n        e.appendChild(content[i]);\n      }\n    }\n\n    return e;\n  } // wrapper for elt, which removes the elt from the accessibility tree\n\n\n  function eltP(tag, content, className, style) {\n    var e = elt(tag, content, className, style);\n    e.setAttribute(\"role\", \"presentation\");\n    return e;\n  }\n\n  var range;\n\n  if (document.createRange) {\n    range = function (node, start, end, endNode) {\n      var r = document.createRange();\n      r.setEnd(endNode || node, end);\n      r.setStart(node, start);\n      return r;\n    };\n  } else {\n    range = function (node, start, end) {\n      var r = document.body.createTextRange();\n\n      try {\n        r.moveToElementText(node.parentNode);\n      } catch (e) {\n        return r;\n      }\n\n      r.collapse(true);\n      r.moveEnd(\"character\", end);\n      r.moveStart(\"character\", start);\n      return r;\n    };\n  }\n\n  function contains(parent, child) {\n    if (child.nodeType == 3) // Android browser always returns false when child is a textnode\n      {\n        child = child.parentNode;\n      }\n\n    if (parent.contains) {\n      return parent.contains(child);\n    }\n\n    do {\n      if (child.nodeType == 11) {\n        child = child.host;\n      }\n\n      if (child == parent) {\n        return true;\n      }\n    } while (child = child.parentNode);\n  }\n\n  function activeElt() {\n    // IE and Edge may throw an \"Unspecified Error\" when accessing document.activeElement.\n    // IE < 10 will throw when accessed while the page is loading or in an iframe.\n    // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.\n    var activeElement;\n\n    try {\n      activeElement = document.activeElement;\n    } catch (e) {\n      activeElement = document.body || null;\n    }\n\n    while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement) {\n      activeElement = activeElement.shadowRoot.activeElement;\n    }\n\n    return activeElement;\n  }\n\n  function addClass(node, cls) {\n    var current = node.className;\n\n    if (!classTest(cls).test(current)) {\n      node.className += (current ? \" \" : \"\") + cls;\n    }\n  }\n\n  function joinClasses(a, b) {\n    var as = a.split(\" \");\n\n    for (var i = 0; i < as.length; i++) {\n      if (as[i] && !classTest(as[i]).test(b)) {\n        b += \" \" + as[i];\n      }\n    }\n\n    return b;\n  }\n\n  var selectInput = function (node) {\n    node.select();\n  };\n\n  if (ios) // Mobile Safari apparently has a bug where select() is broken.\n    {\n      selectInput = function (node) {\n        node.selectionStart = 0;\n        node.selectionEnd = node.value.length;\n      };\n    } else if (ie) // Suppress mysterious IE10 errors\n    {\n      selectInput = function (node) {\n        try {\n          node.select();\n        } catch (_e) {}\n      };\n    }\n\n  function bind(f) {\n    var args = Array.prototype.slice.call(arguments, 1);\n    return function () {\n      return f.apply(null, args);\n    };\n  }\n\n  function copyObj(obj, target, overwrite) {\n    if (!target) {\n      target = {};\n    }\n\n    for (var prop in obj) {\n      if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop))) {\n        target[prop] = obj[prop];\n      }\n    }\n\n    return target;\n  } // Counts the column offset in a string, taking tabs into account.\n  // Used mostly to find indentation.\n\n\n  function countColumn(string, end, tabSize, startIndex, startValue) {\n    if (end == null) {\n      end = string.search(/[^\\s\\u00a0]/);\n\n      if (end == -1) {\n        end = string.length;\n      }\n    }\n\n    for (var i = startIndex || 0, n = startValue || 0;;) {\n      var nextTab = string.indexOf(\"\\t\", i);\n\n      if (nextTab < 0 || nextTab >= end) {\n        return n + (end - i);\n      }\n\n      n += nextTab - i;\n      n += tabSize - n % tabSize;\n      i = nextTab + 1;\n    }\n  }\n\n  var Delayed = function () {\n    this.id = null;\n    this.f = null;\n    this.time = 0;\n    this.handler = bind(this.onTimeout, this);\n  };\n\n  Delayed.prototype.onTimeout = function (self) {\n    self.id = 0;\n\n    if (self.time <= +new Date()) {\n      self.f();\n    } else {\n      setTimeout(self.handler, self.time - +new Date());\n    }\n  };\n\n  Delayed.prototype.set = function (ms, f) {\n    this.f = f;\n    var time = +new Date() + ms;\n\n    if (!this.id || time < this.time) {\n      clearTimeout(this.id);\n      this.id = setTimeout(this.handler, ms);\n      this.time = time;\n    }\n  };\n\n  function indexOf(array, elt) {\n    for (var i = 0; i < array.length; ++i) {\n      if (array[i] == elt) {\n        return i;\n      }\n    }\n\n    return -1;\n  } // Number of pixels added to scroller and sizer to hide scrollbar\n\n\n  var scrollerGap = 50; // Returned or thrown by various protocols to signal 'I'm not\n  // handling this'.\n\n  var Pass = {\n    toString: function () {\n      return \"CodeMirror.Pass\";\n    }\n  }; // Reused option objects for setSelection & friends\n\n  var sel_dontScroll = {\n    scroll: false\n  },\n      sel_mouse = {\n    origin: \"*mouse\"\n  },\n      sel_move = {\n    origin: \"+move\"\n  }; // The inverse of countColumn -- find the offset that corresponds to\n  // a particular column.\n\n  function findColumn(string, goal, tabSize) {\n    for (var pos = 0, col = 0;;) {\n      var nextTab = string.indexOf(\"\\t\", pos);\n\n      if (nextTab == -1) {\n        nextTab = string.length;\n      }\n\n      var skipped = nextTab - pos;\n\n      if (nextTab == string.length || col + skipped >= goal) {\n        return pos + Math.min(skipped, goal - col);\n      }\n\n      col += nextTab - pos;\n      col += tabSize - col % tabSize;\n      pos = nextTab + 1;\n\n      if (col >= goal) {\n        return pos;\n      }\n    }\n  }\n\n  var spaceStrs = [\"\"];\n\n  function spaceStr(n) {\n    while (spaceStrs.length <= n) {\n      spaceStrs.push(lst(spaceStrs) + \" \");\n    }\n\n    return spaceStrs[n];\n  }\n\n  function lst(arr) {\n    return arr[arr.length - 1];\n  }\n\n  function map(array, f) {\n    var out = [];\n\n    for (var i = 0; i < array.length; i++) {\n      out[i] = f(array[i], i);\n    }\n\n    return out;\n  }\n\n  function insertSorted(array, value, score) {\n    var pos = 0,\n        priority = score(value);\n\n    while (pos < array.length && score(array[pos]) <= priority) {\n      pos++;\n    }\n\n    array.splice(pos, 0, value);\n  }\n\n  function nothing() {}\n\n  function createObj(base, props) {\n    var inst;\n\n    if (Object.create) {\n      inst = Object.create(base);\n    } else {\n      nothing.prototype = base;\n      inst = new nothing();\n    }\n\n    if (props) {\n      copyObj(props, inst);\n    }\n\n    return inst;\n  }\n\n  var nonASCIISingleCaseWordChar = /[\\u00df\\u0587\\u0590-\\u05f4\\u0600-\\u06ff\\u3040-\\u309f\\u30a0-\\u30ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\uac00-\\ud7af]/;\n\n  function isWordCharBasic(ch) {\n    return /\\w/.test(ch) || ch > \"\\x80\" && (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch));\n  }\n\n  function isWordChar(ch, helper) {\n    if (!helper) {\n      return isWordCharBasic(ch);\n    }\n\n    if (helper.source.indexOf(\"\\\\w\") > -1 && isWordCharBasic(ch)) {\n      return true;\n    }\n\n    return helper.test(ch);\n  }\n\n  function isEmpty(obj) {\n    for (var n in obj) {\n      if (obj.hasOwnProperty(n) && obj[n]) {\n        return false;\n      }\n    }\n\n    return true;\n  } // Extending unicode characters. A series of a non-extending char +\n  // any number of extending chars is treated as a single unit as far\n  // as editing and measuring is concerned. This is not fully correct,\n  // since some scripts/fonts/browsers also treat other configurations\n  // of code points as a group.\n\n\n  var extendingChars = /[\\u0300-\\u036f\\u0483-\\u0489\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u065e\\u0670\\u06d6-\\u06dc\\u06de-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07eb-\\u07f3\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0900-\\u0902\\u093c\\u0941-\\u0948\\u094d\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09bc\\u09be\\u09c1-\\u09c4\\u09cd\\u09d7\\u09e2\\u09e3\\u0a01\\u0a02\\u0a3c\\u0a41\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a70\\u0a71\\u0a75\\u0a81\\u0a82\\u0abc\\u0ac1-\\u0ac5\\u0ac7\\u0ac8\\u0acd\\u0ae2\\u0ae3\\u0b01\\u0b3c\\u0b3e\\u0b3f\\u0b41-\\u0b44\\u0b4d\\u0b56\\u0b57\\u0b62\\u0b63\\u0b82\\u0bbe\\u0bc0\\u0bcd\\u0bd7\\u0c3e-\\u0c40\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0cbc\\u0cbf\\u0cc2\\u0cc6\\u0ccc\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0d3e\\u0d41-\\u0d44\\u0d4d\\u0d57\\u0d62\\u0d63\\u0dca\\u0dcf\\u0dd2-\\u0dd4\\u0dd6\\u0ddf\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0eb1\\u0eb4-\\u0eb9\\u0ebb\\u0ebc\\u0ec8-\\u0ecd\\u0f18\\u0f19\\u0f35\\u0f37\\u0f39\\u0f71-\\u0f7e\\u0f80-\\u0f84\\u0f86\\u0f87\\u0f90-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102d-\\u1030\\u1032-\\u1037\\u1039\\u103a\\u103d\\u103e\\u1058\\u1059\\u105e-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108d\\u109d\\u135f\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b7-\\u17bd\\u17c6\\u17c9-\\u17d3\\u17dd\\u180b-\\u180d\\u18a9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193b\\u1a17\\u1a18\\u1a56\\u1a58-\\u1a5e\\u1a60\\u1a62\\u1a65-\\u1a6c\\u1a73-\\u1a7c\\u1a7f\\u1b00-\\u1b03\\u1b34\\u1b36-\\u1b3a\\u1b3c\\u1b42\\u1b6b-\\u1b73\\u1b80\\u1b81\\u1ba2-\\u1ba5\\u1ba8\\u1ba9\\u1c2c-\\u1c33\\u1c36\\u1c37\\u1cd0-\\u1cd2\\u1cd4-\\u1ce0\\u1ce2-\\u1ce8\\u1ced\\u1dc0-\\u1de6\\u1dfd-\\u1dff\\u200c\\u200d\\u20d0-\\u20f0\\u2cef-\\u2cf1\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\ua66f-\\ua672\\ua67c\\ua67d\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua825\\ua826\\ua8c4\\ua8e0-\\ua8f1\\ua926-\\ua92d\\ua947-\\ua951\\ua980-\\ua982\\ua9b3\\ua9b6-\\ua9b9\\ua9bc\\uaa29-\\uaa2e\\uaa31\\uaa32\\uaa35\\uaa36\\uaa43\\uaa4c\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uabe5\\uabe8\\uabed\\udc00-\\udfff\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe26\\uff9e\\uff9f]/;\n\n  function isExtendingChar(ch) {\n    return ch.charCodeAt(0) >= 768 && extendingChars.test(ch);\n  } // Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range.\n\n\n  function skipExtendingChars(str, pos, dir) {\n    while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) {\n      pos += dir;\n    }\n\n    return pos;\n  } // Returns the value from the range [`from`; `to`] that satisfies\n  // `pred` and is closest to `from`. Assumes that at least `to`\n  // satisfies `pred`. Supports `from` being greater than `to`.\n\n\n  function findFirst(pred, from, to) {\n    // At any point we are certain `to` satisfies `pred`, don't know\n    // whether `from` does.\n    var dir = from > to ? -1 : 1;\n\n    for (;;) {\n      if (from == to) {\n        return from;\n      }\n\n      var midF = (from + to) / 2,\n          mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF);\n\n      if (mid == from) {\n        return pred(mid) ? from : to;\n      }\n\n      if (pred(mid)) {\n        to = mid;\n      } else {\n        from = mid + dir;\n      }\n    }\n  } // BIDI HELPERS\n\n\n  function iterateBidiSections(order, from, to, f) {\n    if (!order) {\n      return f(from, to, \"ltr\", 0);\n    }\n\n    var found = false;\n\n    for (var i = 0; i < order.length; ++i) {\n      var part = order[i];\n\n      if (part.from < to && part.to > from || from == to && part.to == from) {\n        f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? \"rtl\" : \"ltr\", i);\n        found = true;\n      }\n    }\n\n    if (!found) {\n      f(from, to, \"ltr\");\n    }\n  }\n\n  var bidiOther = null;\n\n  function getBidiPartAt(order, ch, sticky) {\n    var found;\n    bidiOther = null;\n\n    for (var i = 0; i < order.length; ++i) {\n      var cur = order[i];\n\n      if (cur.from < ch && cur.to > ch) {\n        return i;\n      }\n\n      if (cur.to == ch) {\n        if (cur.from != cur.to && sticky == \"before\") {\n          found = i;\n        } else {\n          bidiOther = i;\n        }\n      }\n\n      if (cur.from == ch) {\n        if (cur.from != cur.to && sticky != \"before\") {\n          found = i;\n        } else {\n          bidiOther = i;\n        }\n      }\n    }\n\n    return found != null ? found : bidiOther;\n  } // Bidirectional ordering algorithm\n  // See http://unicode.org/reports/tr9/tr9-13.html for the algorithm\n  // that this (partially) implements.\n  // One-char codes used for character types:\n  // L (L):   Left-to-Right\n  // R (R):   Right-to-Left\n  // r (AL):  Right-to-Left Arabic\n  // 1 (EN):  European Number\n  // + (ES):  European Number Separator\n  // % (ET):  European Number Terminator\n  // n (AN):  Arabic Number\n  // , (CS):  Common Number Separator\n  // m (NSM): Non-Spacing Mark\n  // b (BN):  Boundary Neutral\n  // s (B):   Paragraph Separator\n  // t (S):   Segment Separator\n  // w (WS):  Whitespace\n  // N (ON):  Other Neutrals\n  // Returns null if characters are ordered as they appear\n  // (left-to-right), or an array of sections ({from, to, level}\n  // objects) in the order in which they occur visually.\n\n\n  var bidiOrdering = function () {\n    // Character types for codepoints 0 to 0xff\n    var lowTypes = \"bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN\"; // Character types for codepoints 0x600 to 0x6f9\n\n    var arabicTypes = \"nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111\";\n\n    function charType(code) {\n      if (code <= 0xf7) {\n        return lowTypes.charAt(code);\n      } else if (0x590 <= code && code <= 0x5f4) {\n        return \"R\";\n      } else if (0x600 <= code && code <= 0x6f9) {\n        return arabicTypes.charAt(code - 0x600);\n      } else if (0x6ee <= code && code <= 0x8ac) {\n        return \"r\";\n      } else if (0x2000 <= code && code <= 0x200b) {\n        return \"w\";\n      } else if (code == 0x200c) {\n        return \"b\";\n      } else {\n        return \"L\";\n      }\n    }\n\n    var bidiRE = /[\\u0590-\\u05f4\\u0600-\\u06ff\\u0700-\\u08ac]/;\n    var isNeutral = /[stwN]/,\n        isStrong = /[LRr]/,\n        countsAsLeft = /[Lb1n]/,\n        countsAsNum = /[1n]/;\n\n    function BidiSpan(level, from, to) {\n      this.level = level;\n      this.from = from;\n      this.to = to;\n    }\n\n    return function (str, direction) {\n      var outerType = direction == \"ltr\" ? \"L\" : \"R\";\n\n      if (str.length == 0 || direction == \"ltr\" && !bidiRE.test(str)) {\n        return false;\n      }\n\n      var len = str.length,\n          types = [];\n\n      for (var i = 0; i < len; ++i) {\n        types.push(charType(str.charCodeAt(i)));\n      } // W1. Examine each non-spacing mark (NSM) in the level run, and\n      // change the type of the NSM to the type of the previous\n      // character. If the NSM is at the start of the level run, it will\n      // get the type of sor.\n\n\n      for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {\n        var type = types[i$1];\n\n        if (type == \"m\") {\n          types[i$1] = prev;\n        } else {\n          prev = type;\n        }\n      } // W2. Search backwards from each instance of a European number\n      // until the first strong type (R, L, AL, or sor) is found. If an\n      // AL is found, change the type of the European number to Arabic\n      // number.\n      // W3. Change all ALs to R.\n\n\n      for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {\n        var type$1 = types[i$2];\n\n        if (type$1 == \"1\" && cur == \"r\") {\n          types[i$2] = \"n\";\n        } else if (isStrong.test(type$1)) {\n          cur = type$1;\n\n          if (type$1 == \"r\") {\n            types[i$2] = \"R\";\n          }\n        }\n      } // W4. A single European separator between two European numbers\n      // changes to a European number. A single common separator between\n      // two numbers of the same type changes to that type.\n\n\n      for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {\n        var type$2 = types[i$3];\n\n        if (type$2 == \"+\" && prev$1 == \"1\" && types[i$3 + 1] == \"1\") {\n          types[i$3] = \"1\";\n        } else if (type$2 == \",\" && prev$1 == types[i$3 + 1] && (prev$1 == \"1\" || prev$1 == \"n\")) {\n          types[i$3] = prev$1;\n        }\n\n        prev$1 = type$2;\n      } // W5. A sequence of European terminators adjacent to European\n      // numbers changes to all European numbers.\n      // W6. Otherwise, separators and terminators change to Other\n      // Neutral.\n\n\n      for (var i$4 = 0; i$4 < len; ++i$4) {\n        var type$3 = types[i$4];\n\n        if (type$3 == \",\") {\n          types[i$4] = \"N\";\n        } else if (type$3 == \"%\") {\n          var end = void 0;\n\n          for (end = i$4 + 1; end < len && types[end] == \"%\"; ++end) {}\n\n          var replace = i$4 && types[i$4 - 1] == \"!\" || end < len && types[end] == \"1\" ? \"1\" : \"N\";\n\n          for (var j = i$4; j < end; ++j) {\n            types[j] = replace;\n          }\n\n          i$4 = end - 1;\n        }\n      } // W7. Search backwards from each instance of a European number\n      // until the first strong type (R, L, or sor) is found. If an L is\n      // found, then change the type of the European number to L.\n\n\n      for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {\n        var type$4 = types[i$5];\n\n        if (cur$1 == \"L\" && type$4 == \"1\") {\n          types[i$5] = \"L\";\n        } else if (isStrong.test(type$4)) {\n          cur$1 = type$4;\n        }\n      } // N1. A sequence of neutrals takes the direction of the\n      // surrounding strong text if the text on both sides has the same\n      // direction. European and Arabic numbers act as if they were R in\n      // terms of their influence on neutrals. Start-of-level-run (sor)\n      // and end-of-level-run (eor) are used at level run boundaries.\n      // N2. Any remaining neutrals take the embedding direction.\n\n\n      for (var i$6 = 0; i$6 < len; ++i$6) {\n        if (isNeutral.test(types[i$6])) {\n          var end$1 = void 0;\n\n          for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}\n\n          var before = (i$6 ? types[i$6 - 1] : outerType) == \"L\";\n          var after = (end$1 < len ? types[end$1] : outerType) == \"L\";\n          var replace$1 = before == after ? before ? \"L\" : \"R\" : outerType;\n\n          for (var j$1 = i$6; j$1 < end$1; ++j$1) {\n            types[j$1] = replace$1;\n          }\n\n          i$6 = end$1 - 1;\n        }\n      } // Here we depart from the documented algorithm, in order to avoid\n      // building up an actual levels array. Since there are only three\n      // levels (0, 1, 2) in an implementation that doesn't take\n      // explicit embedding into account, we can build up the order on\n      // the fly, without following the level-based algorithm.\n\n\n      var order = [],\n          m;\n\n      for (var i$7 = 0; i$7 < len;) {\n        if (countsAsLeft.test(types[i$7])) {\n          var start = i$7;\n\n          for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}\n\n          order.push(new BidiSpan(0, start, i$7));\n        } else {\n          var pos = i$7,\n              at = order.length,\n              isRTL = direction == \"rtl\" ? 1 : 0;\n\n          for (++i$7; i$7 < len && types[i$7] != \"L\"; ++i$7) {}\n\n          for (var j$2 = pos; j$2 < i$7;) {\n            if (countsAsNum.test(types[j$2])) {\n              if (pos < j$2) {\n                order.splice(at, 0, new BidiSpan(1, pos, j$2));\n                at += isRTL;\n              }\n\n              var nstart = j$2;\n\n              for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}\n\n              order.splice(at, 0, new BidiSpan(2, nstart, j$2));\n              at += isRTL;\n              pos = j$2;\n            } else {\n              ++j$2;\n            }\n          }\n\n          if (pos < i$7) {\n            order.splice(at, 0, new BidiSpan(1, pos, i$7));\n          }\n        }\n      }\n\n      if (direction == \"ltr\") {\n        if (order[0].level == 1 && (m = str.match(/^\\s+/))) {\n          order[0].from = m[0].length;\n          order.unshift(new BidiSpan(0, 0, m[0].length));\n        }\n\n        if (lst(order).level == 1 && (m = str.match(/\\s+$/))) {\n          lst(order).to -= m[0].length;\n          order.push(new BidiSpan(0, len - m[0].length, len));\n        }\n      }\n\n      return direction == \"rtl\" ? order.reverse() : order;\n    };\n  }(); // Get the bidi ordering for the given line (and cache it). Returns\n  // false for lines that are fully left-to-right, and an array of\n  // BidiSpan objects otherwise.\n\n\n  function getOrder(line, direction) {\n    var order = line.order;\n\n    if (order == null) {\n      order = line.order = bidiOrdering(line.text, direction);\n    }\n\n    return order;\n  } // EVENT HANDLING\n  // Lightweight event framework. on/off also work on DOM nodes,\n  // registering native DOM handlers.\n\n\n  var noHandlers = [];\n\n  var on = function (emitter, type, f) {\n    if (emitter.addEventListener) {\n      emitter.addEventListener(type, f, false);\n    } else if (emitter.attachEvent) {\n      emitter.attachEvent(\"on\" + type, f);\n    } else {\n      var map = emitter._handlers || (emitter._handlers = {});\n      map[type] = (map[type] || noHandlers).concat(f);\n    }\n  };\n\n  function getHandlers(emitter, type) {\n    return emitter._handlers && emitter._handlers[type] || noHandlers;\n  }\n\n  function off(emitter, type, f) {\n    if (emitter.removeEventListener) {\n      emitter.removeEventListener(type, f, false);\n    } else if (emitter.detachEvent) {\n      emitter.detachEvent(\"on\" + type, f);\n    } else {\n      var map = emitter._handlers,\n          arr = map && map[type];\n\n      if (arr) {\n        var index = indexOf(arr, f);\n\n        if (index > -1) {\n          map[type] = arr.slice(0, index).concat(arr.slice(index + 1));\n        }\n      }\n    }\n  }\n\n  function signal(emitter, type\n  /*, values...*/\n  ) {\n    var handlers = getHandlers(emitter, type);\n\n    if (!handlers.length) {\n      return;\n    }\n\n    var args = Array.prototype.slice.call(arguments, 2);\n\n    for (var i = 0; i < handlers.length; ++i) {\n      handlers[i].apply(null, args);\n    }\n  } // The DOM events that CodeMirror handles can be overridden by\n  // registering a (non-DOM) handler on the editor for the event name,\n  // and preventDefault-ing the event in that handler.\n\n\n  function signalDOMEvent(cm, e, override) {\n    if (typeof e == \"string\") {\n      e = {\n        type: e,\n        preventDefault: function () {\n          this.defaultPrevented = true;\n        }\n      };\n    }\n\n    signal(cm, override || e.type, cm, e);\n    return e_defaultPrevented(e) || e.codemirrorIgnore;\n  }\n\n  function signalCursorActivity(cm) {\n    var arr = cm._handlers && cm._handlers.cursorActivity;\n\n    if (!arr) {\n      return;\n    }\n\n    var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []);\n\n    for (var i = 0; i < arr.length; ++i) {\n      if (indexOf(set, arr[i]) == -1) {\n        set.push(arr[i]);\n      }\n    }\n  }\n\n  function hasHandler(emitter, type) {\n    return getHandlers(emitter, type).length > 0;\n  } // Add on and off methods to a constructor's prototype, to make\n  // registering events on such objects more convenient.\n\n\n  function eventMixin(ctor) {\n    ctor.prototype.on = function (type, f) {\n      on(this, type, f);\n    };\n\n    ctor.prototype.off = function (type, f) {\n      off(this, type, f);\n    };\n  } // Due to the fact that we still support jurassic IE versions, some\n  // compatibility wrappers are needed.\n\n\n  function e_preventDefault(e) {\n    if (e.preventDefault) {\n      e.preventDefault();\n    } else {\n      e.returnValue = false;\n    }\n  }\n\n  function e_stopPropagation(e) {\n    if (e.stopPropagation) {\n      e.stopPropagation();\n    } else {\n      e.cancelBubble = true;\n    }\n  }\n\n  function e_defaultPrevented(e) {\n    return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false;\n  }\n\n  function e_stop(e) {\n    e_preventDefault(e);\n    e_stopPropagation(e);\n  }\n\n  function e_target(e) {\n    return e.target || e.srcElement;\n  }\n\n  function e_button(e) {\n    var b = e.which;\n\n    if (b == null) {\n      if (e.button & 1) {\n        b = 1;\n      } else if (e.button & 2) {\n        b = 3;\n      } else if (e.button & 4) {\n        b = 2;\n      }\n    }\n\n    if (mac && e.ctrlKey && b == 1) {\n      b = 3;\n    }\n\n    return b;\n  } // Detect drag-and-drop\n\n\n  var dragAndDrop = function () {\n    // There is *some* kind of drag-and-drop support in IE6-8, but I\n    // couldn't get it to work yet.\n    if (ie && ie_version < 9) {\n      return false;\n    }\n\n    var div = elt('div');\n    return \"draggable\" in div || \"dragDrop\" in div;\n  }();\n\n  var zwspSupported;\n\n  function zeroWidthElement(measure) {\n    if (zwspSupported == null) {\n      var test = elt(\"span\", \"\\u200b\");\n      removeChildrenAndAdd(measure, elt(\"span\", [test, document.createTextNode(\"x\")]));\n\n      if (measure.firstChild.offsetHeight != 0) {\n        zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8);\n      }\n    }\n\n    var node = zwspSupported ? elt(\"span\", \"\\u200b\") : elt(\"span\", \"\\u00a0\", null, \"display: inline-block; width: 1px; margin-right: -1px\");\n    node.setAttribute(\"cm-text\", \"\");\n    return node;\n  } // Feature-detect IE's crummy client rect reporting for bidi text\n\n\n  var badBidiRects;\n\n  function hasBadBidiRects(measure) {\n    if (badBidiRects != null) {\n      return badBidiRects;\n    }\n\n    var txt = removeChildrenAndAdd(measure, document.createTextNode(\"A\\u062eA\"));\n    var r0 = range(txt, 0, 1).getBoundingClientRect();\n    var r1 = range(txt, 1, 2).getBoundingClientRect();\n    removeChildren(measure);\n\n    if (!r0 || r0.left == r0.right) {\n      return false;\n    } // Safari returns null in some cases (#2780)\n\n\n    return badBidiRects = r1.right - r0.right < 3;\n  } // See if \"\".split is the broken IE version, if so, provide an\n  // alternative way to split lines.\n\n\n  var splitLinesAuto = \"\\n\\nb\".split(/\\n/).length != 3 ? function (string) {\n    var pos = 0,\n        result = [],\n        l = string.length;\n\n    while (pos <= l) {\n      var nl = string.indexOf(\"\\n\", pos);\n\n      if (nl == -1) {\n        nl = string.length;\n      }\n\n      var line = string.slice(pos, string.charAt(nl - 1) == \"\\r\" ? nl - 1 : nl);\n      var rt = line.indexOf(\"\\r\");\n\n      if (rt != -1) {\n        result.push(line.slice(0, rt));\n        pos += rt + 1;\n      } else {\n        result.push(line);\n        pos = nl + 1;\n      }\n    }\n\n    return result;\n  } : function (string) {\n    return string.split(/\\r\\n?|\\n/);\n  };\n  var hasSelection = window.getSelection ? function (te) {\n    try {\n      return te.selectionStart != te.selectionEnd;\n    } catch (e) {\n      return false;\n    }\n  } : function (te) {\n    var range;\n\n    try {\n      range = te.ownerDocument.selection.createRange();\n    } catch (e) {}\n\n    if (!range || range.parentElement() != te) {\n      return false;\n    }\n\n    return range.compareEndPoints(\"StartToEnd\", range) != 0;\n  };\n\n  var hasCopyEvent = function () {\n    var e = elt(\"div\");\n\n    if (\"oncopy\" in e) {\n      return true;\n    }\n\n    e.setAttribute(\"oncopy\", \"return;\");\n    return typeof e.oncopy == \"function\";\n  }();\n\n  var badZoomedRects = null;\n\n  function hasBadZoomedRects(measure) {\n    if (badZoomedRects != null) {\n      return badZoomedRects;\n    }\n\n    var node = removeChildrenAndAdd(measure, elt(\"span\", \"x\"));\n    var normal = node.getBoundingClientRect();\n    var fromRange = range(node, 0, 1).getBoundingClientRect();\n    return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1;\n  } // Known modes, by name and by MIME\n\n\n  var modes = {},\n      mimeModes = {}; // Extra arguments are stored as the mode's dependencies, which is\n  // used by (legacy) mechanisms like loadmode.js to automatically\n  // load a mode. (Preferred mechanism is the require/define calls.)\n\n  function defineMode(name, mode) {\n    if (arguments.length > 2) {\n      mode.dependencies = Array.prototype.slice.call(arguments, 2);\n    }\n\n    modes[name] = mode;\n  }\n\n  function defineMIME(mime, spec) {\n    mimeModes[mime] = spec;\n  } // Given a MIME type, a {name, ...options} config object, or a name\n  // string, return a mode config object.\n\n\n  function resolveMode(spec) {\n    if (typeof spec == \"string\" && mimeModes.hasOwnProperty(spec)) {\n      spec = mimeModes[spec];\n    } else if (spec && typeof spec.name == \"string\" && mimeModes.hasOwnProperty(spec.name)) {\n      var found = mimeModes[spec.name];\n\n      if (typeof found == \"string\") {\n        found = {\n          name: found\n        };\n      }\n\n      spec = createObj(found, spec);\n      spec.name = found.name;\n    } else if (typeof spec == \"string\" && /^[\\w\\-]+\\/[\\w\\-]+\\+xml$/.test(spec)) {\n      return resolveMode(\"application/xml\");\n    } else if (typeof spec == \"string\" && /^[\\w\\-]+\\/[\\w\\-]+\\+json$/.test(spec)) {\n      return resolveMode(\"application/json\");\n    }\n\n    if (typeof spec == \"string\") {\n      return {\n        name: spec\n      };\n    } else {\n      return spec || {\n        name: \"null\"\n      };\n    }\n  } // Given a mode spec (anything that resolveMode accepts), find and\n  // initialize an actual mode object.\n\n\n  function getMode(options, spec) {\n    spec = resolveMode(spec);\n    var mfactory = modes[spec.name];\n\n    if (!mfactory) {\n      return getMode(options, \"text/plain\");\n    }\n\n    var modeObj = mfactory(options, spec);\n\n    if (modeExtensions.hasOwnProperty(spec.name)) {\n      var exts = modeExtensions[spec.name];\n\n      for (var prop in exts) {\n        if (!exts.hasOwnProperty(prop)) {\n          continue;\n        }\n\n        if (modeObj.hasOwnProperty(prop)) {\n          modeObj[\"_\" + prop] = modeObj[prop];\n        }\n\n        modeObj[prop] = exts[prop];\n      }\n    }\n\n    modeObj.name = spec.name;\n\n    if (spec.helperType) {\n      modeObj.helperType = spec.helperType;\n    }\n\n    if (spec.modeProps) {\n      for (var prop$1 in spec.modeProps) {\n        modeObj[prop$1] = spec.modeProps[prop$1];\n      }\n    }\n\n    return modeObj;\n  } // This can be used to attach properties to mode objects from\n  // outside the actual mode definition.\n\n\n  var modeExtensions = {};\n\n  function extendMode(mode, properties) {\n    var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : modeExtensions[mode] = {};\n    copyObj(properties, exts);\n  }\n\n  function copyState(mode, state) {\n    if (state === true) {\n      return state;\n    }\n\n    if (mode.copyState) {\n      return mode.copyState(state);\n    }\n\n    var nstate = {};\n\n    for (var n in state) {\n      var val = state[n];\n\n      if (val instanceof Array) {\n        val = val.concat([]);\n      }\n\n      nstate[n] = val;\n    }\n\n    return nstate;\n  } // Given a mode and a state (for that mode), find the inner mode and\n  // state at the position that the state refers to.\n\n\n  function innerMode(mode, state) {\n    var info;\n\n    while (mode.innerMode) {\n      info = mode.innerMode(state);\n\n      if (!info || info.mode == mode) {\n        break;\n      }\n\n      state = info.state;\n      mode = info.mode;\n    }\n\n    return info || {\n      mode: mode,\n      state: state\n    };\n  }\n\n  function startState(mode, a1, a2) {\n    return mode.startState ? mode.startState(a1, a2) : true;\n  } // STRING STREAM\n  // Fed to the mode parsers, provides helper functions to make\n  // parsers more succinct.\n\n\n  var StringStream = function (string, tabSize, lineOracle) {\n    this.pos = this.start = 0;\n    this.string = string;\n    this.tabSize = tabSize || 8;\n    this.lastColumnPos = this.lastColumnValue = 0;\n    this.lineStart = 0;\n    this.lineOracle = lineOracle;\n  };\n\n  StringStream.prototype.eol = function () {\n    return this.pos >= this.string.length;\n  };\n\n  StringStream.prototype.sol = function () {\n    return this.pos == this.lineStart;\n  };\n\n  StringStream.prototype.peek = function () {\n    return this.string.charAt(this.pos) || undefined;\n  };\n\n  StringStream.prototype.next = function () {\n    if (this.pos < this.string.length) {\n      return this.string.charAt(this.pos++);\n    }\n  };\n\n  StringStream.prototype.eat = function (match) {\n    var ch = this.string.charAt(this.pos);\n    var ok;\n\n    if (typeof match == \"string\") {\n      ok = ch == match;\n    } else {\n      ok = ch && (match.test ? match.test(ch) : match(ch));\n    }\n\n    if (ok) {\n      ++this.pos;\n      return ch;\n    }\n  };\n\n  StringStream.prototype.eatWhile = function (match) {\n    var start = this.pos;\n\n    while (this.eat(match)) {}\n\n    return this.pos > start;\n  };\n\n  StringStream.prototype.eatSpace = function () {\n    var start = this.pos;\n\n    while (/[\\s\\u00a0]/.test(this.string.charAt(this.pos))) {\n      ++this.pos;\n    }\n\n    return this.pos > start;\n  };\n\n  StringStream.prototype.skipToEnd = function () {\n    this.pos = this.string.length;\n  };\n\n  StringStream.prototype.skipTo = function (ch) {\n    var found = this.string.indexOf(ch, this.pos);\n\n    if (found > -1) {\n      this.pos = found;\n      return true;\n    }\n  };\n\n  StringStream.prototype.backUp = function (n) {\n    this.pos -= n;\n  };\n\n  StringStream.prototype.column = function () {\n    if (this.lastColumnPos < this.start) {\n      this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);\n      this.lastColumnPos = this.start;\n    }\n\n    return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);\n  };\n\n  StringStream.prototype.indentation = function () {\n    return countColumn(this.string, null, this.tabSize) - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);\n  };\n\n  StringStream.prototype.match = function (pattern, consume, caseInsensitive) {\n    if (typeof pattern == \"string\") {\n      var cased = function (str) {\n        return caseInsensitive ? str.toLowerCase() : str;\n      };\n\n      var substr = this.string.substr(this.pos, pattern.length);\n\n      if (cased(substr) == cased(pattern)) {\n        if (consume !== false) {\n          this.pos += pattern.length;\n        }\n\n        return true;\n      }\n    } else {\n      var match = this.string.slice(this.pos).match(pattern);\n\n      if (match && match.index > 0) {\n        return null;\n      }\n\n      if (match && consume !== false) {\n        this.pos += match[0].length;\n      }\n\n      return match;\n    }\n  };\n\n  StringStream.prototype.current = function () {\n    return this.string.slice(this.start, this.pos);\n  };\n\n  StringStream.prototype.hideFirstChars = function (n, inner) {\n    this.lineStart += n;\n\n    try {\n      return inner();\n    } finally {\n      this.lineStart -= n;\n    }\n  };\n\n  StringStream.prototype.lookAhead = function (n) {\n    var oracle = this.lineOracle;\n    return oracle && oracle.lookAhead(n);\n  };\n\n  StringStream.prototype.baseToken = function () {\n    var oracle = this.lineOracle;\n    return oracle && oracle.baseToken(this.pos);\n  }; // Find the line object corresponding to the given line number.\n\n\n  function getLine(doc, n) {\n    n -= doc.first;\n\n    if (n < 0 || n >= doc.size) {\n      throw new Error(\"There is no line \" + (n + doc.first) + \" in the document.\");\n    }\n\n    var chunk = doc;\n\n    while (!chunk.lines) {\n      for (var i = 0;; ++i) {\n        var child = chunk.children[i],\n            sz = child.chunkSize();\n\n        if (n < sz) {\n          chunk = child;\n          break;\n        }\n\n        n -= sz;\n      }\n    }\n\n    return chunk.lines[n];\n  } // Get the part of a document between two positions, as an array of\n  // strings.\n\n\n  function getBetween(doc, start, end) {\n    var out = [],\n        n = start.line;\n    doc.iter(start.line, end.line + 1, function (line) {\n      var text = line.text;\n\n      if (n == end.line) {\n        text = text.slice(0, end.ch);\n      }\n\n      if (n == start.line) {\n        text = text.slice(start.ch);\n      }\n\n      out.push(text);\n      ++n;\n    });\n    return out;\n  } // Get the lines between from and to, as array of strings.\n\n\n  function getLines(doc, from, to) {\n    var out = [];\n    doc.iter(from, to, function (line) {\n      out.push(line.text);\n    }); // iter aborts when callback returns truthy value\n\n    return out;\n  } // Update the height of a line, propagating the height change\n  // upwards to parent nodes.\n\n\n  function updateLineHeight(line, height) {\n    var diff = height - line.height;\n\n    if (diff) {\n      for (var n = line; n; n = n.parent) {\n        n.height += diff;\n      }\n    }\n  } // Given a line object, find its line number by walking up through\n  // its parent links.\n\n\n  function lineNo(line) {\n    if (line.parent == null) {\n      return null;\n    }\n\n    var cur = line.parent,\n        no = indexOf(cur.lines, line);\n\n    for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {\n      for (var i = 0;; ++i) {\n        if (chunk.children[i] == cur) {\n          break;\n        }\n\n        no += chunk.children[i].chunkSize();\n      }\n    }\n\n    return no + cur.first;\n  } // Find the line at the given vertical position, using the height\n  // information in the document tree.\n\n\n  function lineAtHeight(chunk, h) {\n    var n = chunk.first;\n\n    outer: do {\n      for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {\n        var child = chunk.children[i$1],\n            ch = child.height;\n\n        if (h < ch) {\n          chunk = child;\n          continue outer;\n        }\n\n        h -= ch;\n        n += child.chunkSize();\n      }\n\n      return n;\n    } while (!chunk.lines);\n\n    var i = 0;\n\n    for (; i < chunk.lines.length; ++i) {\n      var line = chunk.lines[i],\n          lh = line.height;\n\n      if (h < lh) {\n        break;\n      }\n\n      h -= lh;\n    }\n\n    return n + i;\n  }\n\n  function isLine(doc, l) {\n    return l >= doc.first && l < doc.first + doc.size;\n  }\n\n  function lineNumberFor(options, i) {\n    return String(options.lineNumberFormatter(i + options.firstLineNumber));\n  } // A Pos instance represents a position within the text.\n\n\n  function Pos(line, ch, sticky) {\n    if (sticky === void 0) sticky = null;\n\n    if (!(this instanceof Pos)) {\n      return new Pos(line, ch, sticky);\n    }\n\n    this.line = line;\n    this.ch = ch;\n    this.sticky = sticky;\n  } // Compare two positions, return 0 if they are the same, a negative\n  // number when a is less, and a positive number otherwise.\n\n\n  function cmp(a, b) {\n    return a.line - b.line || a.ch - b.ch;\n  }\n\n  function equalCursorPos(a, b) {\n    return a.sticky == b.sticky && cmp(a, b) == 0;\n  }\n\n  function copyPos(x) {\n    return Pos(x.line, x.ch);\n  }\n\n  function maxPos(a, b) {\n    return cmp(a, b) < 0 ? b : a;\n  }\n\n  function minPos(a, b) {\n    return cmp(a, b) < 0 ? a : b;\n  } // Most of the external API clips given positions to make sure they\n  // actually exist within the document.\n\n\n  function clipLine(doc, n) {\n    return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1));\n  }\n\n  function clipPos(doc, pos) {\n    if (pos.line < doc.first) {\n      return Pos(doc.first, 0);\n    }\n\n    var last = doc.first + doc.size - 1;\n\n    if (pos.line > last) {\n      return Pos(last, getLine(doc, last).text.length);\n    }\n\n    return clipToLen(pos, getLine(doc, pos.line).text.length);\n  }\n\n  function clipToLen(pos, linelen) {\n    var ch = pos.ch;\n\n    if (ch == null || ch > linelen) {\n      return Pos(pos.line, linelen);\n    } else if (ch < 0) {\n      return Pos(pos.line, 0);\n    } else {\n      return pos;\n    }\n  }\n\n  function clipPosArray(doc, array) {\n    var out = [];\n\n    for (var i = 0; i < array.length; i++) {\n      out[i] = clipPos(doc, array[i]);\n    }\n\n    return out;\n  }\n\n  var SavedContext = function (state, lookAhead) {\n    this.state = state;\n    this.lookAhead = lookAhead;\n  };\n\n  var Context = function (doc, state, line, lookAhead) {\n    this.state = state;\n    this.doc = doc;\n    this.line = line;\n    this.maxLookAhead = lookAhead || 0;\n    this.baseTokens = null;\n    this.baseTokenPos = 1;\n  };\n\n  Context.prototype.lookAhead = function (n) {\n    var line = this.doc.getLine(this.line + n);\n\n    if (line != null && n > this.maxLookAhead) {\n      this.maxLookAhead = n;\n    }\n\n    return line;\n  };\n\n  Context.prototype.baseToken = function (n) {\n    if (!this.baseTokens) {\n      return null;\n    }\n\n    while (this.baseTokens[this.baseTokenPos] <= n) {\n      this.baseTokenPos += 2;\n    }\n\n    var type = this.baseTokens[this.baseTokenPos + 1];\n    return {\n      type: type && type.replace(/( |^)overlay .*/, \"\"),\n      size: this.baseTokens[this.baseTokenPos] - n\n    };\n  };\n\n  Context.prototype.nextLine = function () {\n    this.line++;\n\n    if (this.maxLookAhead > 0) {\n      this.maxLookAhead--;\n    }\n  };\n\n  Context.fromSaved = function (doc, saved, line) {\n    if (saved instanceof SavedContext) {\n      return new Context(doc, copyState(doc.mode, saved.state), line, saved.lookAhead);\n    } else {\n      return new Context(doc, copyState(doc.mode, saved), line);\n    }\n  };\n\n  Context.prototype.save = function (copy) {\n    var state = copy !== false ? copyState(this.doc.mode, this.state) : this.state;\n    return this.maxLookAhead > 0 ? new SavedContext(state, this.maxLookAhead) : state;\n  }; // Compute a style array (an array starting with a mode generation\n  // -- for invalidation -- followed by pairs of end positions and\n  // style strings), which is used to highlight the tokens on the\n  // line.\n\n\n  function highlightLine(cm, line, context, forceToEnd) {\n    // A styles array always starts with a number identifying the\n    // mode/overlays that it is based on (for easy invalidation).\n    var st = [cm.state.modeGen],\n        lineClasses = {}; // Compute the base array of styles\n\n    runMode(cm, line.text, cm.doc.mode, context, function (end, style) {\n      return st.push(end, style);\n    }, lineClasses, forceToEnd);\n    var state = context.state; // Run overlays, adjust style array.\n\n    var loop = function (o) {\n      context.baseTokens = st;\n      var overlay = cm.state.overlays[o],\n          i = 1,\n          at = 0;\n      context.state = true;\n      runMode(cm, line.text, overlay.mode, context, function (end, style) {\n        var start = i; // Ensure there's a token end at the current position, and that i points at it\n\n        while (at < end) {\n          var i_end = st[i];\n\n          if (i_end > end) {\n            st.splice(i, 1, end, st[i + 1], i_end);\n          }\n\n          i += 2;\n          at = Math.min(end, i_end);\n        }\n\n        if (!style) {\n          return;\n        }\n\n        if (overlay.opaque) {\n          st.splice(start, i - start, end, \"overlay \" + style);\n          i = start + 2;\n        } else {\n          for (; start < i; start += 2) {\n            var cur = st[start + 1];\n            st[start + 1] = (cur ? cur + \" \" : \"\") + \"overlay \" + style;\n          }\n        }\n      }, lineClasses);\n      context.state = state;\n      context.baseTokens = null;\n      context.baseTokenPos = 1;\n    };\n\n    for (var o = 0; o < cm.state.overlays.length; ++o) loop(o);\n\n    return {\n      styles: st,\n      classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null\n    };\n  }\n\n  function getLineStyles(cm, line, updateFrontier) {\n    if (!line.styles || line.styles[0] != cm.state.modeGen) {\n      var context = getContextBefore(cm, lineNo(line));\n      var resetState = line.text.length > cm.options.maxHighlightLength && copyState(cm.doc.mode, context.state);\n      var result = highlightLine(cm, line, context);\n\n      if (resetState) {\n        context.state = resetState;\n      }\n\n      line.stateAfter = context.save(!resetState);\n      line.styles = result.styles;\n\n      if (result.classes) {\n        line.styleClasses = result.classes;\n      } else if (line.styleClasses) {\n        line.styleClasses = null;\n      }\n\n      if (updateFrontier === cm.doc.highlightFrontier) {\n        cm.doc.modeFrontier = Math.max(cm.doc.modeFrontier, ++cm.doc.highlightFrontier);\n      }\n    }\n\n    return line.styles;\n  }\n\n  function getContextBefore(cm, n, precise) {\n    var doc = cm.doc,\n        display = cm.display;\n\n    if (!doc.mode.startState) {\n      return new Context(doc, true, n);\n    }\n\n    var start = findStartLine(cm, n, precise);\n    var saved = start > doc.first && getLine(doc, start - 1).stateAfter;\n    var context = saved ? Context.fromSaved(doc, saved, start) : new Context(doc, startState(doc.mode), start);\n    doc.iter(start, n, function (line) {\n      processLine(cm, line.text, context);\n      var pos = context.line;\n      line.stateAfter = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo ? context.save() : null;\n      context.nextLine();\n    });\n\n    if (precise) {\n      doc.modeFrontier = context.line;\n    }\n\n    return context;\n  } // Lightweight form of highlight -- proceed over this line and\n  // update state, but don't save a style array. Used for lines that\n  // aren't currently visible.\n\n\n  function processLine(cm, text, context, startAt) {\n    var mode = cm.doc.mode;\n    var stream = new StringStream(text, cm.options.tabSize, context);\n    stream.start = stream.pos = startAt || 0;\n\n    if (text == \"\") {\n      callBlankLine(mode, context.state);\n    }\n\n    while (!stream.eol()) {\n      readToken(mode, stream, context.state);\n      stream.start = stream.pos;\n    }\n  }\n\n  function callBlankLine(mode, state) {\n    if (mode.blankLine) {\n      return mode.blankLine(state);\n    }\n\n    if (!mode.innerMode) {\n      return;\n    }\n\n    var inner = innerMode(mode, state);\n\n    if (inner.mode.blankLine) {\n      return inner.mode.blankLine(inner.state);\n    }\n  }\n\n  function readToken(mode, stream, state, inner) {\n    for (var i = 0; i < 10; i++) {\n      if (inner) {\n        inner[0] = innerMode(mode, state).mode;\n      }\n\n      var style = mode.token(stream, state);\n\n      if (stream.pos > stream.start) {\n        return style;\n      }\n    }\n\n    throw new Error(\"Mode \" + mode.name + \" failed to advance stream.\");\n  }\n\n  var Token = function (stream, type, state) {\n    this.start = stream.start;\n    this.end = stream.pos;\n    this.string = stream.current();\n    this.type = type || null;\n    this.state = state;\n  }; // Utility for getTokenAt and getLineTokens\n\n\n  function takeToken(cm, pos, precise, asArray) {\n    var doc = cm.doc,\n        mode = doc.mode,\n        style;\n    pos = clipPos(doc, pos);\n    var line = getLine(doc, pos.line),\n        context = getContextBefore(cm, pos.line, precise);\n    var stream = new StringStream(line.text, cm.options.tabSize, context),\n        tokens;\n\n    if (asArray) {\n      tokens = [];\n    }\n\n    while ((asArray || stream.pos < pos.ch) && !stream.eol()) {\n      stream.start = stream.pos;\n      style = readToken(mode, stream, context.state);\n\n      if (asArray) {\n        tokens.push(new Token(stream, style, copyState(doc.mode, context.state)));\n      }\n    }\n\n    return asArray ? tokens : new Token(stream, style, context.state);\n  }\n\n  function extractLineClasses(type, output) {\n    if (type) {\n      for (;;) {\n        var lineClass = type.match(/(?:^|\\s+)line-(background-)?(\\S+)/);\n\n        if (!lineClass) {\n          break;\n        }\n\n        type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length);\n        var prop = lineClass[1] ? \"bgClass\" : \"textClass\";\n\n        if (output[prop] == null) {\n          output[prop] = lineClass[2];\n        } else if (!new RegExp(\"(?:^|\\\\s)\" + lineClass[2] + \"(?:$|\\\\s)\").test(output[prop])) {\n          output[prop] += \" \" + lineClass[2];\n        }\n      }\n    }\n\n    return type;\n  } // Run the given mode's parser over a line, calling f for each token.\n\n\n  function runMode(cm, text, mode, context, f, lineClasses, forceToEnd) {\n    var flattenSpans = mode.flattenSpans;\n\n    if (flattenSpans == null) {\n      flattenSpans = cm.options.flattenSpans;\n    }\n\n    var curStart = 0,\n        curStyle = null;\n    var stream = new StringStream(text, cm.options.tabSize, context),\n        style;\n    var inner = cm.options.addModeClass && [null];\n\n    if (text == \"\") {\n      extractLineClasses(callBlankLine(mode, context.state), lineClasses);\n    }\n\n    while (!stream.eol()) {\n      if (stream.pos > cm.options.maxHighlightLength) {\n        flattenSpans = false;\n\n        if (forceToEnd) {\n          processLine(cm, text, context, stream.pos);\n        }\n\n        stream.pos = text.length;\n        style = null;\n      } else {\n        style = extractLineClasses(readToken(mode, stream, context.state, inner), lineClasses);\n      }\n\n      if (inner) {\n        var mName = inner[0].name;\n\n        if (mName) {\n          style = \"m-\" + (style ? mName + \" \" + style : mName);\n        }\n      }\n\n      if (!flattenSpans || curStyle != style) {\n        while (curStart < stream.start) {\n          curStart = Math.min(stream.start, curStart + 5000);\n          f(curStart, curStyle);\n        }\n\n        curStyle = style;\n      }\n\n      stream.start = stream.pos;\n    }\n\n    while (curStart < stream.pos) {\n      // Webkit seems to refuse to render text nodes longer than 57444\n      // characters, and returns inaccurate measurements in nodes\n      // starting around 5000 chars.\n      var pos = Math.min(stream.pos, curStart + 5000);\n      f(pos, curStyle);\n      curStart = pos;\n    }\n  } // Finds the line to start with when starting a parse. Tries to\n  // find a line with a stateAfter, so that it can start with a\n  // valid state. If that fails, it returns the line with the\n  // smallest indentation, which tends to need the least context to\n  // parse correctly.\n\n\n  function findStartLine(cm, n, precise) {\n    var minindent,\n        minline,\n        doc = cm.doc;\n    var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100);\n\n    for (var search = n; search > lim; --search) {\n      if (search <= doc.first) {\n        return doc.first;\n      }\n\n      var line = getLine(doc, search - 1),\n          after = line.stateAfter;\n\n      if (after && (!precise || search + (after instanceof SavedContext ? after.lookAhead : 0) <= doc.modeFrontier)) {\n        return search;\n      }\n\n      var indented = countColumn(line.text, null, cm.options.tabSize);\n\n      if (minline == null || minindent > indented) {\n        minline = search - 1;\n        minindent = indented;\n      }\n    }\n\n    return minline;\n  }\n\n  function retreatFrontier(doc, n) {\n    doc.modeFrontier = Math.min(doc.modeFrontier, n);\n\n    if (doc.highlightFrontier < n - 10) {\n      return;\n    }\n\n    var start = doc.first;\n\n    for (var line = n - 1; line > start; line--) {\n      var saved = getLine(doc, line).stateAfter; // change is on 3\n      // state on line 1 looked ahead 2 -- so saw 3\n      // test 1 + 2 < 3 should cover this\n\n      if (saved && (!(saved instanceof SavedContext) || line + saved.lookAhead < n)) {\n        start = line + 1;\n        break;\n      }\n    }\n\n    doc.highlightFrontier = Math.min(doc.highlightFrontier, start);\n  } // Optimize some code when these features are not used.\n\n\n  var sawReadOnlySpans = false,\n      sawCollapsedSpans = false;\n\n  function seeReadOnlySpans() {\n    sawReadOnlySpans = true;\n  }\n\n  function seeCollapsedSpans() {\n    sawCollapsedSpans = true;\n  } // TEXTMARKER SPANS\n\n\n  function MarkedSpan(marker, from, to) {\n    this.marker = marker;\n    this.from = from;\n    this.to = to;\n  } // Search an array of spans for a span matching the given marker.\n\n\n  function getMarkedSpanFor(spans, marker) {\n    if (spans) {\n      for (var i = 0; i < spans.length; ++i) {\n        var span = spans[i];\n\n        if (span.marker == marker) {\n          return span;\n        }\n      }\n    }\n  } // Remove a span from an array, returning undefined if no spans are\n  // left (we don't store arrays for lines without spans).\n\n\n  function removeMarkedSpan(spans, span) {\n    var r;\n\n    for (var i = 0; i < spans.length; ++i) {\n      if (spans[i] != span) {\n        (r || (r = [])).push(spans[i]);\n      }\n    }\n\n    return r;\n  } // Add a span to a line.\n\n\n  function addMarkedSpan(line, span) {\n    line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span];\n    span.marker.attachLine(line);\n  } // Used for the algorithm that adjusts markers for a change in the\n  // document. These functions cut an array of spans at a given\n  // character position, returning an array of remaining chunks (or\n  // undefined if nothing remains).\n\n\n  function markedSpansBefore(old, startCh, isInsert) {\n    var nw;\n\n    if (old) {\n      for (var i = 0; i < old.length; ++i) {\n        var span = old[i],\n            marker = span.marker;\n        var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh);\n\n        if (startsBefore || span.from == startCh && marker.type == \"bookmark\" && (!isInsert || !span.marker.insertLeft)) {\n          var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh);\n          (nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to));\n        }\n      }\n    }\n\n    return nw;\n  }\n\n  function markedSpansAfter(old, endCh, isInsert) {\n    var nw;\n\n    if (old) {\n      for (var i = 0; i < old.length; ++i) {\n        var span = old[i],\n            marker = span.marker;\n        var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh);\n\n        if (endsAfter || span.from == endCh && marker.type == \"bookmark\" && (!isInsert || span.marker.insertLeft)) {\n          var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh);\n          (nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh, span.to == null ? null : span.to - endCh));\n        }\n      }\n    }\n\n    return nw;\n  } // Given a change object, compute the new set of marker spans that\n  // cover the line in which the change took place. Removes spans\n  // entirely within the change, reconnects spans belonging to the\n  // same marker that appear on both sides of the change, and cuts off\n  // spans partially within the change. Returns an array of span\n  // arrays with one element for each line in (after) the change.\n\n\n  function stretchSpansOverChange(doc, change) {\n    if (change.full) {\n      return null;\n    }\n\n    var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans;\n    var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans;\n\n    if (!oldFirst && !oldLast) {\n      return null;\n    }\n\n    var startCh = change.from.ch,\n        endCh = change.to.ch,\n        isInsert = cmp(change.from, change.to) == 0; // Get the spans that 'stick out' on both sides\n\n    var first = markedSpansBefore(oldFirst, startCh, isInsert);\n    var last = markedSpansAfter(oldLast, endCh, isInsert); // Next, merge those two ends\n\n    var sameLine = change.text.length == 1,\n        offset = lst(change.text).length + (sameLine ? startCh : 0);\n\n    if (first) {\n      // Fix up .to properties of first\n      for (var i = 0; i < first.length; ++i) {\n        var span = first[i];\n\n        if (span.to == null) {\n          var found = getMarkedSpanFor(last, span.marker);\n\n          if (!found) {\n            span.to = startCh;\n          } else if (sameLine) {\n            span.to = found.to == null ? null : found.to + offset;\n          }\n        }\n      }\n    }\n\n    if (last) {\n      // Fix up .from in last (or move them into first in case of sameLine)\n      for (var i$1 = 0; i$1 < last.length; ++i$1) {\n        var span$1 = last[i$1];\n\n        if (span$1.to != null) {\n          span$1.to += offset;\n        }\n\n        if (span$1.from == null) {\n          var found$1 = getMarkedSpanFor(first, span$1.marker);\n\n          if (!found$1) {\n            span$1.from = offset;\n\n            if (sameLine) {\n              (first || (first = [])).push(span$1);\n            }\n          }\n        } else {\n          span$1.from += offset;\n\n          if (sameLine) {\n            (first || (first = [])).push(span$1);\n          }\n        }\n      }\n    } // Make sure we didn't create any zero-length spans\n\n\n    if (first) {\n      first = clearEmptySpans(first);\n    }\n\n    if (last && last != first) {\n      last = clearEmptySpans(last);\n    }\n\n    var newMarkers = [first];\n\n    if (!sameLine) {\n      // Fill gap with whole-line-spans\n      var gap = change.text.length - 2,\n          gapMarkers;\n\n      if (gap > 0 && first) {\n        for (var i$2 = 0; i$2 < first.length; ++i$2) {\n          if (first[i$2].to == null) {\n            (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null));\n          }\n        }\n      }\n\n      for (var i$3 = 0; i$3 < gap; ++i$3) {\n        newMarkers.push(gapMarkers);\n      }\n\n      newMarkers.push(last);\n    }\n\n    return newMarkers;\n  } // Remove spans that are empty and don't have a clearWhenEmpty\n  // option of false.\n\n\n  function clearEmptySpans(spans) {\n    for (var i = 0; i < spans.length; ++i) {\n      var span = spans[i];\n\n      if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false) {\n        spans.splice(i--, 1);\n      }\n    }\n\n    if (!spans.length) {\n      return null;\n    }\n\n    return spans;\n  } // Used to 'clip' out readOnly ranges when making a change.\n\n\n  function removeReadOnlyRanges(doc, from, to) {\n    var markers = null;\n    doc.iter(from.line, to.line + 1, function (line) {\n      if (line.markedSpans) {\n        for (var i = 0; i < line.markedSpans.length; ++i) {\n          var mark = line.markedSpans[i].marker;\n\n          if (mark.readOnly && (!markers || indexOf(markers, mark) == -1)) {\n            (markers || (markers = [])).push(mark);\n          }\n        }\n      }\n    });\n\n    if (!markers) {\n      return null;\n    }\n\n    var parts = [{\n      from: from,\n      to: to\n    }];\n\n    for (var i = 0; i < markers.length; ++i) {\n      var mk = markers[i],\n          m = mk.find(0);\n\n      for (var j = 0; j < parts.length; ++j) {\n        var p = parts[j];\n\n        if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) {\n          continue;\n        }\n\n        var newParts = [j, 1],\n            dfrom = cmp(p.from, m.from),\n            dto = cmp(p.to, m.to);\n\n        if (dfrom < 0 || !mk.inclusiveLeft && !dfrom) {\n          newParts.push({\n            from: p.from,\n            to: m.from\n          });\n        }\n\n        if (dto > 0 || !mk.inclusiveRight && !dto) {\n          newParts.push({\n            from: m.to,\n            to: p.to\n          });\n        }\n\n        parts.splice.apply(parts, newParts);\n        j += newParts.length - 3;\n      }\n    }\n\n    return parts;\n  } // Connect or disconnect spans from a line.\n\n\n  function detachMarkedSpans(line) {\n    var spans = line.markedSpans;\n\n    if (!spans) {\n      return;\n    }\n\n    for (var i = 0; i < spans.length; ++i) {\n      spans[i].marker.detachLine(line);\n    }\n\n    line.markedSpans = null;\n  }\n\n  function attachMarkedSpans(line, spans) {\n    if (!spans) {\n      return;\n    }\n\n    for (var i = 0; i < spans.length; ++i) {\n      spans[i].marker.attachLine(line);\n    }\n\n    line.markedSpans = spans;\n  } // Helpers used when computing which overlapping collapsed span\n  // counts as the larger one.\n\n\n  function extraLeft(marker) {\n    return marker.inclusiveLeft ? -1 : 0;\n  }\n\n  function extraRight(marker) {\n    return marker.inclusiveRight ? 1 : 0;\n  } // Returns a number indicating which of two overlapping collapsed\n  // spans is larger (and thus includes the other). Falls back to\n  // comparing ids when the spans cover exactly the same range.\n\n\n  function compareCollapsedMarkers(a, b) {\n    var lenDiff = a.lines.length - b.lines.length;\n\n    if (lenDiff != 0) {\n      return lenDiff;\n    }\n\n    var aPos = a.find(),\n        bPos = b.find();\n    var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b);\n\n    if (fromCmp) {\n      return -fromCmp;\n    }\n\n    var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b);\n\n    if (toCmp) {\n      return toCmp;\n    }\n\n    return b.id - a.id;\n  } // Find out whether a line ends or starts in a collapsed span. If\n  // so, return the marker for that span.\n\n\n  function collapsedSpanAtSide(line, start) {\n    var sps = sawCollapsedSpans && line.markedSpans,\n        found;\n\n    if (sps) {\n      for (var sp = void 0, i = 0; i < sps.length; ++i) {\n        sp = sps[i];\n\n        if (sp.marker.collapsed && (start ? sp.from : sp.to) == null && (!found || compareCollapsedMarkers(found, sp.marker) < 0)) {\n          found = sp.marker;\n        }\n      }\n    }\n\n    return found;\n  }\n\n  function collapsedSpanAtStart(line) {\n    return collapsedSpanAtSide(line, true);\n  }\n\n  function collapsedSpanAtEnd(line) {\n    return collapsedSpanAtSide(line, false);\n  }\n\n  function collapsedSpanAround(line, ch) {\n    var sps = sawCollapsedSpans && line.markedSpans,\n        found;\n\n    if (sps) {\n      for (var i = 0; i < sps.length; ++i) {\n        var sp = sps[i];\n\n        if (sp.marker.collapsed && (sp.from == null || sp.from < ch) && (sp.to == null || sp.to > ch) && (!found || compareCollapsedMarkers(found, sp.marker) < 0)) {\n          found = sp.marker;\n        }\n      }\n    }\n\n    return found;\n  } // Test whether there exists a collapsed span that partially\n  // overlaps (covers the start or end, but not both) of a new span.\n  // Such overlap is not allowed.\n\n\n  function conflictingCollapsedRange(doc, lineNo, from, to, marker) {\n    var line = getLine(doc, lineNo);\n    var sps = sawCollapsedSpans && line.markedSpans;\n\n    if (sps) {\n      for (var i = 0; i < sps.length; ++i) {\n        var sp = sps[i];\n\n        if (!sp.marker.collapsed) {\n          continue;\n        }\n\n        var found = sp.marker.find(0);\n        var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker);\n        var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker);\n\n        if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) {\n          continue;\n        }\n\n        if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) || fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0)) {\n          return true;\n        }\n      }\n    }\n  } // A visual line is a line as drawn on the screen. Folding, for\n  // example, can cause multiple logical lines to appear on the same\n  // visual line. This finds the start of the visual line that the\n  // given line is part of (usually that is the line itself).\n\n\n  function visualLine(line) {\n    var merged;\n\n    while (merged = collapsedSpanAtStart(line)) {\n      line = merged.find(-1, true).line;\n    }\n\n    return line;\n  }\n\n  function visualLineEnd(line) {\n    var merged;\n\n    while (merged = collapsedSpanAtEnd(line)) {\n      line = merged.find(1, true).line;\n    }\n\n    return line;\n  } // Returns an array of logical lines that continue the visual line\n  // started by the argument, or undefined if there are no such lines.\n\n\n  function visualLineContinued(line) {\n    var merged, lines;\n\n    while (merged = collapsedSpanAtEnd(line)) {\n      line = merged.find(1, true).line;\n      (lines || (lines = [])).push(line);\n    }\n\n    return lines;\n  } // Get the line number of the start of the visual line that the\n  // given line number is part of.\n\n\n  function visualLineNo(doc, lineN) {\n    var line = getLine(doc, lineN),\n        vis = visualLine(line);\n\n    if (line == vis) {\n      return lineN;\n    }\n\n    return lineNo(vis);\n  } // Get the line number of the start of the next visual line after\n  // the given line.\n\n\n  function visualLineEndNo(doc, lineN) {\n    if (lineN > doc.lastLine()) {\n      return lineN;\n    }\n\n    var line = getLine(doc, lineN),\n        merged;\n\n    if (!lineIsHidden(doc, line)) {\n      return lineN;\n    }\n\n    while (merged = collapsedSpanAtEnd(line)) {\n      line = merged.find(1, true).line;\n    }\n\n    return lineNo(line) + 1;\n  } // Compute whether a line is hidden. Lines count as hidden when they\n  // are part of a visual line that starts with another line, or when\n  // they are entirely covered by collapsed, non-widget span.\n\n\n  function lineIsHidden(doc, line) {\n    var sps = sawCollapsedSpans && line.markedSpans;\n\n    if (sps) {\n      for (var sp = void 0, i = 0; i < sps.length; ++i) {\n        sp = sps[i];\n\n        if (!sp.marker.collapsed) {\n          continue;\n        }\n\n        if (sp.from == null) {\n          return true;\n        }\n\n        if (sp.marker.widgetNode) {\n          continue;\n        }\n\n        if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp)) {\n          return true;\n        }\n      }\n    }\n  }\n\n  function lineIsHiddenInner(doc, line, span) {\n    if (span.to == null) {\n      var end = span.marker.find(1, true);\n      return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker));\n    }\n\n    if (span.marker.inclusiveRight && span.to == line.text.length) {\n      return true;\n    }\n\n    for (var sp = void 0, i = 0; i < line.markedSpans.length; ++i) {\n      sp = line.markedSpans[i];\n\n      if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to && (sp.to == null || sp.to != span.from) && (sp.marker.inclusiveLeft || span.marker.inclusiveRight) && lineIsHiddenInner(doc, line, sp)) {\n        return true;\n      }\n    }\n  } // Find the height above the given line.\n\n\n  function heightAtLine(lineObj) {\n    lineObj = visualLine(lineObj);\n    var h = 0,\n        chunk = lineObj.parent;\n\n    for (var i = 0; i < chunk.lines.length; ++i) {\n      var line = chunk.lines[i];\n\n      if (line == lineObj) {\n        break;\n      } else {\n        h += line.height;\n      }\n    }\n\n    for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {\n      for (var i$1 = 0; i$1 < p.children.length; ++i$1) {\n        var cur = p.children[i$1];\n\n        if (cur == chunk) {\n          break;\n        } else {\n          h += cur.height;\n        }\n      }\n    }\n\n    return h;\n  } // Compute the character length of a line, taking into account\n  // collapsed ranges (see markText) that might hide parts, and join\n  // other lines onto it.\n\n\n  function lineLength(line) {\n    if (line.height == 0) {\n      return 0;\n    }\n\n    var len = line.text.length,\n        merged,\n        cur = line;\n\n    while (merged = collapsedSpanAtStart(cur)) {\n      var found = merged.find(0, true);\n      cur = found.from.line;\n      len += found.from.ch - found.to.ch;\n    }\n\n    cur = line;\n\n    while (merged = collapsedSpanAtEnd(cur)) {\n      var found$1 = merged.find(0, true);\n      len -= cur.text.length - found$1.from.ch;\n      cur = found$1.to.line;\n      len += cur.text.length - found$1.to.ch;\n    }\n\n    return len;\n  } // Find the longest line in the document.\n\n\n  function findMaxLine(cm) {\n    var d = cm.display,\n        doc = cm.doc;\n    d.maxLine = getLine(doc, doc.first);\n    d.maxLineLength = lineLength(d.maxLine);\n    d.maxLineChanged = true;\n    doc.iter(function (line) {\n      var len = lineLength(line);\n\n      if (len > d.maxLineLength) {\n        d.maxLineLength = len;\n        d.maxLine = line;\n      }\n    });\n  } // LINE DATA STRUCTURE\n  // Line objects. These hold state related to a line, including\n  // highlighting info (the styles array).\n\n\n  var Line = function (text, markedSpans, estimateHeight) {\n    this.text = text;\n    attachMarkedSpans(this, markedSpans);\n    this.height = estimateHeight ? estimateHeight(this) : 1;\n  };\n\n  Line.prototype.lineNo = function () {\n    return lineNo(this);\n  };\n\n  eventMixin(Line); // Change the content (text, markers) of a line. Automatically\n  // invalidates cached information and tries to re-estimate the\n  // line's height.\n\n  function updateLine(line, text, markedSpans, estimateHeight) {\n    line.text = text;\n\n    if (line.stateAfter) {\n      line.stateAfter = null;\n    }\n\n    if (line.styles) {\n      line.styles = null;\n    }\n\n    if (line.order != null) {\n      line.order = null;\n    }\n\n    detachMarkedSpans(line);\n    attachMarkedSpans(line, markedSpans);\n    var estHeight = estimateHeight ? estimateHeight(line) : 1;\n\n    if (estHeight != line.height) {\n      updateLineHeight(line, estHeight);\n    }\n  } // Detach a line from the document tree and its markers.\n\n\n  function cleanUpLine(line) {\n    line.parent = null;\n    detachMarkedSpans(line);\n  } // Convert a style as returned by a mode (either null, or a string\n  // containing one or more styles) to a CSS style. This is cached,\n  // and also looks for line-wide styles.\n\n\n  var styleToClassCache = {},\n      styleToClassCacheWithMode = {};\n\n  function interpretTokenStyle(style, options) {\n    if (!style || /^\\s*$/.test(style)) {\n      return null;\n    }\n\n    var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache;\n    return cache[style] || (cache[style] = style.replace(/\\S+/g, \"cm-$&\"));\n  } // Render the DOM representation of the text of a line. Also builds\n  // up a 'line map', which points at the DOM nodes that represent\n  // specific stretches of text, and is used by the measuring code.\n  // The returned object contains the DOM node, this map, and\n  // information about line-wide styles that were set by the mode.\n\n\n  function buildLineContent(cm, lineView) {\n    // The padding-right forces the element to have a 'border', which\n    // is needed on Webkit to be able to get line-level bounding\n    // rectangles for it (in measureChar).\n    var content = eltP(\"span\", null, null, webkit ? \"padding-right: .1px\" : null);\n    var builder = {\n      pre: eltP(\"pre\", [content], \"CodeMirror-line\"),\n      content: content,\n      col: 0,\n      pos: 0,\n      cm: cm,\n      trailingSpace: false,\n      splitSpaces: cm.getOption(\"lineWrapping\")\n    };\n    lineView.measure = {}; // Iterate over the logical lines that make up this visual line.\n\n    for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {\n      var line = i ? lineView.rest[i - 1] : lineView.line,\n          order = void 0;\n      builder.pos = 0;\n      builder.addToken = buildToken; // Optionally wire in some hacks into the token-rendering\n      // algorithm, to deal with browser quirks.\n\n      if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line, cm.doc.direction))) {\n        builder.addToken = buildTokenBadBidi(builder.addToken, order);\n      }\n\n      builder.map = [];\n      var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line);\n      insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate));\n\n      if (line.styleClasses) {\n        if (line.styleClasses.bgClass) {\n          builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || \"\");\n        }\n\n        if (line.styleClasses.textClass) {\n          builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || \"\");\n        }\n      } // Ensure at least a single node is present, for measuring.\n\n\n      if (builder.map.length == 0) {\n        builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure)));\n      } // Store the map and a cache object for the current logical line\n\n\n      if (i == 0) {\n        lineView.measure.map = builder.map;\n        lineView.measure.cache = {};\n      } else {\n        (lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map);\n        (lineView.measure.caches || (lineView.measure.caches = [])).push({});\n      }\n    } // See issue #2901\n\n\n    if (webkit) {\n      var last = builder.content.lastChild;\n\n      if (/\\bcm-tab\\b/.test(last.className) || last.querySelector && last.querySelector(\".cm-tab\")) {\n        builder.content.className = \"cm-tab-wrap-hack\";\n      }\n    }\n\n    signal(cm, \"renderLine\", cm, lineView.line, builder.pre);\n\n    if (builder.pre.className) {\n      builder.textClass = joinClasses(builder.pre.className, builder.textClass || \"\");\n    }\n\n    return builder;\n  }\n\n  function defaultSpecialCharPlaceholder(ch) {\n    var token = elt(\"span\", \"\\u2022\", \"cm-invalidchar\");\n    token.title = \"\\\\u\" + ch.charCodeAt(0).toString(16);\n    token.setAttribute(\"aria-label\", token.title);\n    return token;\n  } // Build up the DOM representation for a single token, and add it to\n  // the line map. Takes care to render special characters separately.\n\n\n  function buildToken(builder, text, style, startStyle, endStyle, css, attributes) {\n    if (!text) {\n      return;\n    }\n\n    var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text;\n    var special = builder.cm.state.specialChars,\n        mustWrap = false;\n    var content;\n\n    if (!special.test(text)) {\n      builder.col += text.length;\n      content = document.createTextNode(displayText);\n      builder.map.push(builder.pos, builder.pos + text.length, content);\n\n      if (ie && ie_version < 9) {\n        mustWrap = true;\n      }\n\n      builder.pos += text.length;\n    } else {\n      content = document.createDocumentFragment();\n      var pos = 0;\n\n      while (true) {\n        special.lastIndex = pos;\n        var m = special.exec(text);\n        var skipped = m ? m.index - pos : text.length - pos;\n\n        if (skipped) {\n          var txt = document.createTextNode(displayText.slice(pos, pos + skipped));\n\n          if (ie && ie_version < 9) {\n            content.appendChild(elt(\"span\", [txt]));\n          } else {\n            content.appendChild(txt);\n          }\n\n          builder.map.push(builder.pos, builder.pos + skipped, txt);\n          builder.col += skipped;\n          builder.pos += skipped;\n        }\n\n        if (!m) {\n          break;\n        }\n\n        pos += skipped + 1;\n        var txt$1 = void 0;\n\n        if (m[0] == \"\\t\") {\n          var tabSize = builder.cm.options.tabSize,\n              tabWidth = tabSize - builder.col % tabSize;\n          txt$1 = content.appendChild(elt(\"span\", spaceStr(tabWidth), \"cm-tab\"));\n          txt$1.setAttribute(\"role\", \"presentation\");\n          txt$1.setAttribute(\"cm-text\", \"\\t\");\n          builder.col += tabWidth;\n        } else if (m[0] == \"\\r\" || m[0] == \"\\n\") {\n          txt$1 = content.appendChild(elt(\"span\", m[0] == \"\\r\" ? \"\\u240d\" : \"\\u2424\", \"cm-invalidchar\"));\n          txt$1.setAttribute(\"cm-text\", m[0]);\n          builder.col += 1;\n        } else {\n          txt$1 = builder.cm.options.specialCharPlaceholder(m[0]);\n          txt$1.setAttribute(\"cm-text\", m[0]);\n\n          if (ie && ie_version < 9) {\n            content.appendChild(elt(\"span\", [txt$1]));\n          } else {\n            content.appendChild(txt$1);\n          }\n\n          builder.col += 1;\n        }\n\n        builder.map.push(builder.pos, builder.pos + 1, txt$1);\n        builder.pos++;\n      }\n    }\n\n    builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32;\n\n    if (style || startStyle || endStyle || mustWrap || css) {\n      var fullStyle = style || \"\";\n\n      if (startStyle) {\n        fullStyle += startStyle;\n      }\n\n      if (endStyle) {\n        fullStyle += endStyle;\n      }\n\n      var token = elt(\"span\", [content], fullStyle, css);\n\n      if (attributes) {\n        for (var attr in attributes) {\n          if (attributes.hasOwnProperty(attr) && attr != \"style\" && attr != \"class\") {\n            token.setAttribute(attr, attributes[attr]);\n          }\n        }\n      }\n\n      return builder.content.appendChild(token);\n    }\n\n    builder.content.appendChild(content);\n  } // Change some spaces to NBSP to prevent the browser from collapsing\n  // trailing spaces at the end of a line when rendering text (issue #1362).\n\n\n  function splitSpaces(text, trailingBefore) {\n    if (text.length > 1 && !/  /.test(text)) {\n      return text;\n    }\n\n    var spaceBefore = trailingBefore,\n        result = \"\";\n\n    for (var i = 0; i < text.length; i++) {\n      var ch = text.charAt(i);\n\n      if (ch == \" \" && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32)) {\n        ch = \"\\u00a0\";\n      }\n\n      result += ch;\n      spaceBefore = ch == \" \";\n    }\n\n    return result;\n  } // Work around nonsense dimensions being reported for stretches of\n  // right-to-left text.\n\n\n  function buildTokenBadBidi(inner, order) {\n    return function (builder, text, style, startStyle, endStyle, css, attributes) {\n      style = style ? style + \" cm-force-border\" : \"cm-force-border\";\n      var start = builder.pos,\n          end = start + text.length;\n\n      for (;;) {\n        // Find the part that overlaps with the start of this text\n        var part = void 0;\n\n        for (var i = 0; i < order.length; i++) {\n          part = order[i];\n\n          if (part.to > start && part.from <= start) {\n            break;\n          }\n        }\n\n        if (part.to >= end) {\n          return inner(builder, text, style, startStyle, endStyle, css, attributes);\n        }\n\n        inner(builder, text.slice(0, part.to - start), style, startStyle, null, css, attributes);\n        startStyle = null;\n        text = text.slice(part.to - start);\n        start = part.to;\n      }\n    };\n  }\n\n  function buildCollapsedSpan(builder, size, marker, ignoreWidget) {\n    var widget = !ignoreWidget && marker.widgetNode;\n\n    if (widget) {\n      builder.map.push(builder.pos, builder.pos + size, widget);\n    }\n\n    if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {\n      if (!widget) {\n        widget = builder.content.appendChild(document.createElement(\"span\"));\n      }\n\n      widget.setAttribute(\"cm-marker\", marker.id);\n    }\n\n    if (widget) {\n      builder.cm.display.input.setUneditable(widget);\n      builder.content.appendChild(widget);\n    }\n\n    builder.pos += size;\n    builder.trailingSpace = false;\n  } // Outputs a number of spans to make up a line, taking highlighting\n  // and marked text into account.\n\n\n  function insertLineContent(line, builder, styles) {\n    var spans = line.markedSpans,\n        allText = line.text,\n        at = 0;\n\n    if (!spans) {\n      for (var i$1 = 1; i$1 < styles.length; i$1 += 2) {\n        builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1 + 1], builder.cm.options));\n      }\n\n      return;\n    }\n\n    var len = allText.length,\n        pos = 0,\n        i = 1,\n        text = \"\",\n        style,\n        css;\n    var nextChange = 0,\n        spanStyle,\n        spanEndStyle,\n        spanStartStyle,\n        collapsed,\n        attributes;\n\n    for (;;) {\n      if (nextChange == pos) {\n        // Update current marker set\n        spanStyle = spanEndStyle = spanStartStyle = css = \"\";\n        attributes = null;\n        collapsed = null;\n        nextChange = Infinity;\n        var foundBookmarks = [],\n            endStyles = void 0;\n\n        for (var j = 0; j < spans.length; ++j) {\n          var sp = spans[j],\n              m = sp.marker;\n\n          if (m.type == \"bookmark\" && sp.from == pos && m.widgetNode) {\n            foundBookmarks.push(m);\n          } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {\n            if (sp.to != null && sp.to != pos && nextChange > sp.to) {\n              nextChange = sp.to;\n              spanEndStyle = \"\";\n            }\n\n            if (m.className) {\n              spanStyle += \" \" + m.className;\n            }\n\n            if (m.css) {\n              css = (css ? css + \";\" : \"\") + m.css;\n            }\n\n            if (m.startStyle && sp.from == pos) {\n              spanStartStyle += \" \" + m.startStyle;\n            }\n\n            if (m.endStyle && sp.to == nextChange) {\n              (endStyles || (endStyles = [])).push(m.endStyle, sp.to);\n            } // support for the old title property\n            // https://github.com/codemirror/CodeMirror/pull/5673\n\n\n            if (m.title) {\n              (attributes || (attributes = {})).title = m.title;\n            }\n\n            if (m.attributes) {\n              for (var attr in m.attributes) {\n                (attributes || (attributes = {}))[attr] = m.attributes[attr];\n              }\n            }\n\n            if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0)) {\n              collapsed = sp;\n            }\n          } else if (sp.from > pos && nextChange > sp.from) {\n            nextChange = sp.from;\n          }\n        }\n\n        if (endStyles) {\n          for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2) {\n            if (endStyles[j$1 + 1] == nextChange) {\n              spanEndStyle += \" \" + endStyles[j$1];\n            }\n          }\n        }\n\n        if (!collapsed || collapsed.from == pos) {\n          for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2) {\n            buildCollapsedSpan(builder, 0, foundBookmarks[j$2]);\n          }\n        }\n\n        if (collapsed && (collapsed.from || 0) == pos) {\n          buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos, collapsed.marker, collapsed.from == null);\n\n          if (collapsed.to == null) {\n            return;\n          }\n\n          if (collapsed.to == pos) {\n            collapsed = false;\n          }\n        }\n      }\n\n      if (pos >= len) {\n        break;\n      }\n\n      var upto = Math.min(len, nextChange);\n\n      while (true) {\n        if (text) {\n          var end = pos + text.length;\n\n          if (!collapsed) {\n            var tokenText = end > upto ? text.slice(0, upto - pos) : text;\n            builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle, spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : \"\", css, attributes);\n          }\n\n          if (end >= upto) {\n            text = text.slice(upto - pos);\n            pos = upto;\n            break;\n          }\n\n          pos = end;\n          spanStartStyle = \"\";\n        }\n\n        text = allText.slice(at, at = styles[i++]);\n        style = interpretTokenStyle(styles[i++], builder.cm.options);\n      }\n    }\n  } // These objects are used to represent the visible (currently drawn)\n  // part of the document. A LineView may correspond to multiple\n  // logical lines, if those are connected by collapsed ranges.\n\n\n  function LineView(doc, line, lineN) {\n    // The starting line\n    this.line = line; // Continuing lines, if any\n\n    this.rest = visualLineContinued(line); // Number of logical lines in this visual line\n\n    this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1;\n    this.node = this.text = null;\n    this.hidden = lineIsHidden(doc, line);\n  } // Create a range of LineView objects for the given lines.\n\n\n  function buildViewArray(cm, from, to) {\n    var array = [],\n        nextPos;\n\n    for (var pos = from; pos < to; pos = nextPos) {\n      var view = new LineView(cm.doc, getLine(cm.doc, pos), pos);\n      nextPos = pos + view.size;\n      array.push(view);\n    }\n\n    return array;\n  }\n\n  var operationGroup = null;\n\n  function pushOperation(op) {\n    if (operationGroup) {\n      operationGroup.ops.push(op);\n    } else {\n      op.ownsGroup = operationGroup = {\n        ops: [op],\n        delayedCallbacks: []\n      };\n    }\n  }\n\n  function fireCallbacksForOps(group) {\n    // Calls delayed callbacks and cursorActivity handlers until no\n    // new ones appear\n    var callbacks = group.delayedCallbacks,\n        i = 0;\n\n    do {\n      for (; i < callbacks.length; i++) {\n        callbacks[i].call(null);\n      }\n\n      for (var j = 0; j < group.ops.length; j++) {\n        var op = group.ops[j];\n\n        if (op.cursorActivityHandlers) {\n          while (op.cursorActivityCalled < op.cursorActivityHandlers.length) {\n            op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm);\n          }\n        }\n      }\n    } while (i < callbacks.length);\n  }\n\n  function finishOperation(op, endCb) {\n    var group = op.ownsGroup;\n\n    if (!group) {\n      return;\n    }\n\n    try {\n      fireCallbacksForOps(group);\n    } finally {\n      operationGroup = null;\n      endCb(group);\n    }\n  }\n\n  var orphanDelayedCallbacks = null; // Often, we want to signal events at a point where we are in the\n  // middle of some work, but don't want the handler to start calling\n  // other methods on the editor, which might be in an inconsistent\n  // state or simply not expect any other events to happen.\n  // signalLater looks whether there are any handlers, and schedules\n  // them to be executed when the last operation ends, or, if no\n  // operation is active, when a timeout fires.\n\n  function signalLater(emitter, type\n  /*, values...*/\n  ) {\n    var arr = getHandlers(emitter, type);\n\n    if (!arr.length) {\n      return;\n    }\n\n    var args = Array.prototype.slice.call(arguments, 2),\n        list;\n\n    if (operationGroup) {\n      list = operationGroup.delayedCallbacks;\n    } else if (orphanDelayedCallbacks) {\n      list = orphanDelayedCallbacks;\n    } else {\n      list = orphanDelayedCallbacks = [];\n      setTimeout(fireOrphanDelayed, 0);\n    }\n\n    var loop = function (i) {\n      list.push(function () {\n        return arr[i].apply(null, args);\n      });\n    };\n\n    for (var i = 0; i < arr.length; ++i) loop(i);\n  }\n\n  function fireOrphanDelayed() {\n    var delayed = orphanDelayedCallbacks;\n    orphanDelayedCallbacks = null;\n\n    for (var i = 0; i < delayed.length; ++i) {\n      delayed[i]();\n    }\n  } // When an aspect of a line changes, a string is added to\n  // lineView.changes. This updates the relevant part of the line's\n  // DOM structure.\n\n\n  function updateLineForChanges(cm, lineView, lineN, dims) {\n    for (var j = 0; j < lineView.changes.length; j++) {\n      var type = lineView.changes[j];\n\n      if (type == \"text\") {\n        updateLineText(cm, lineView);\n      } else if (type == \"gutter\") {\n        updateLineGutter(cm, lineView, lineN, dims);\n      } else if (type == \"class\") {\n        updateLineClasses(cm, lineView);\n      } else if (type == \"widget\") {\n        updateLineWidgets(cm, lineView, dims);\n      }\n    }\n\n    lineView.changes = null;\n  } // Lines with gutter elements, widgets or a background class need to\n  // be wrapped, and have the extra elements added to the wrapper div\n\n\n  function ensureLineWrapped(lineView) {\n    if (lineView.node == lineView.text) {\n      lineView.node = elt(\"div\", null, null, \"position: relative\");\n\n      if (lineView.text.parentNode) {\n        lineView.text.parentNode.replaceChild(lineView.node, lineView.text);\n      }\n\n      lineView.node.appendChild(lineView.text);\n\n      if (ie && ie_version < 8) {\n        lineView.node.style.zIndex = 2;\n      }\n    }\n\n    return lineView.node;\n  }\n\n  function updateLineBackground(cm, lineView) {\n    var cls = lineView.bgClass ? lineView.bgClass + \" \" + (lineView.line.bgClass || \"\") : lineView.line.bgClass;\n\n    if (cls) {\n      cls += \" CodeMirror-linebackground\";\n    }\n\n    if (lineView.background) {\n      if (cls) {\n        lineView.background.className = cls;\n      } else {\n        lineView.background.parentNode.removeChild(lineView.background);\n        lineView.background = null;\n      }\n    } else if (cls) {\n      var wrap = ensureLineWrapped(lineView);\n      lineView.background = wrap.insertBefore(elt(\"div\", null, cls), wrap.firstChild);\n      cm.display.input.setUneditable(lineView.background);\n    }\n  } // Wrapper around buildLineContent which will reuse the structure\n  // in display.externalMeasured when possible.\n\n\n  function getLineContent(cm, lineView) {\n    var ext = cm.display.externalMeasured;\n\n    if (ext && ext.line == lineView.line) {\n      cm.display.externalMeasured = null;\n      lineView.measure = ext.measure;\n      return ext.built;\n    }\n\n    return buildLineContent(cm, lineView);\n  } // Redraw the line's text. Interacts with the background and text\n  // classes because the mode may output tokens that influence these\n  // classes.\n\n\n  function updateLineText(cm, lineView) {\n    var cls = lineView.text.className;\n    var built = getLineContent(cm, lineView);\n\n    if (lineView.text == lineView.node) {\n      lineView.node = built.pre;\n    }\n\n    lineView.text.parentNode.replaceChild(built.pre, lineView.text);\n    lineView.text = built.pre;\n\n    if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {\n      lineView.bgClass = built.bgClass;\n      lineView.textClass = built.textClass;\n      updateLineClasses(cm, lineView);\n    } else if (cls) {\n      lineView.text.className = cls;\n    }\n  }\n\n  function updateLineClasses(cm, lineView) {\n    updateLineBackground(cm, lineView);\n\n    if (lineView.line.wrapClass) {\n      ensureLineWrapped(lineView).className = lineView.line.wrapClass;\n    } else if (lineView.node != lineView.text) {\n      lineView.node.className = \"\";\n    }\n\n    var textClass = lineView.textClass ? lineView.textClass + \" \" + (lineView.line.textClass || \"\") : lineView.line.textClass;\n    lineView.text.className = textClass || \"\";\n  }\n\n  function updateLineGutter(cm, lineView, lineN, dims) {\n    if (lineView.gutter) {\n      lineView.node.removeChild(lineView.gutter);\n      lineView.gutter = null;\n    }\n\n    if (lineView.gutterBackground) {\n      lineView.node.removeChild(lineView.gutterBackground);\n      lineView.gutterBackground = null;\n    }\n\n    if (lineView.line.gutterClass) {\n      var wrap = ensureLineWrapped(lineView);\n      lineView.gutterBackground = elt(\"div\", null, \"CodeMirror-gutter-background \" + lineView.line.gutterClass, \"left: \" + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + \"px; width: \" + dims.gutterTotalWidth + \"px\");\n      cm.display.input.setUneditable(lineView.gutterBackground);\n      wrap.insertBefore(lineView.gutterBackground, lineView.text);\n    }\n\n    var markers = lineView.line.gutterMarkers;\n\n    if (cm.options.lineNumbers || markers) {\n      var wrap$1 = ensureLineWrapped(lineView);\n      var gutterWrap = lineView.gutter = elt(\"div\", null, \"CodeMirror-gutter-wrapper\", \"left: \" + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + \"px\");\n      cm.display.input.setUneditable(gutterWrap);\n      wrap$1.insertBefore(gutterWrap, lineView.text);\n\n      if (lineView.line.gutterClass) {\n        gutterWrap.className += \" \" + lineView.line.gutterClass;\n      }\n\n      if (cm.options.lineNumbers && (!markers || !markers[\"CodeMirror-linenumbers\"])) {\n        lineView.lineNumber = gutterWrap.appendChild(elt(\"div\", lineNumberFor(cm.options, lineN), \"CodeMirror-linenumber CodeMirror-gutter-elt\", \"left: \" + dims.gutterLeft[\"CodeMirror-linenumbers\"] + \"px; width: \" + cm.display.lineNumInnerWidth + \"px\"));\n      }\n\n      if (markers) {\n        for (var k = 0; k < cm.display.gutterSpecs.length; ++k) {\n          var id = cm.display.gutterSpecs[k].className,\n              found = markers.hasOwnProperty(id) && markers[id];\n\n          if (found) {\n            gutterWrap.appendChild(elt(\"div\", [found], \"CodeMirror-gutter-elt\", \"left: \" + dims.gutterLeft[id] + \"px; width: \" + dims.gutterWidth[id] + \"px\"));\n          }\n        }\n      }\n    }\n  }\n\n  function updateLineWidgets(cm, lineView, dims) {\n    if (lineView.alignable) {\n      lineView.alignable = null;\n    }\n\n    var isWidget = classTest(\"CodeMirror-linewidget\");\n\n    for (var node = lineView.node.firstChild, next = void 0; node; node = next) {\n      next = node.nextSibling;\n\n      if (isWidget.test(node.className)) {\n        lineView.node.removeChild(node);\n      }\n    }\n\n    insertLineWidgets(cm, lineView, dims);\n  } // Build a line's DOM representation from scratch\n\n\n  function buildLineElement(cm, lineView, lineN, dims) {\n    var built = getLineContent(cm, lineView);\n    lineView.text = lineView.node = built.pre;\n\n    if (built.bgClass) {\n      lineView.bgClass = built.bgClass;\n    }\n\n    if (built.textClass) {\n      lineView.textClass = built.textClass;\n    }\n\n    updateLineClasses(cm, lineView);\n    updateLineGutter(cm, lineView, lineN, dims);\n    insertLineWidgets(cm, lineView, dims);\n    return lineView.node;\n  } // A lineView may contain multiple logical lines (when merged by\n  // collapsed spans). The widgets for all of them need to be drawn.\n\n\n  function insertLineWidgets(cm, lineView, dims) {\n    insertLineWidgetsFor(cm, lineView.line, lineView, dims, true);\n\n    if (lineView.rest) {\n      for (var i = 0; i < lineView.rest.length; i++) {\n        insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false);\n      }\n    }\n  }\n\n  function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {\n    if (!line.widgets) {\n      return;\n    }\n\n    var wrap = ensureLineWrapped(lineView);\n\n    for (var i = 0, ws = line.widgets; i < ws.length; ++i) {\n      var widget = ws[i],\n          node = elt(\"div\", [widget.node], \"CodeMirror-linewidget\" + (widget.className ? \" \" + widget.className : \"\"));\n\n      if (!widget.handleMouseEvents) {\n        node.setAttribute(\"cm-ignore-events\", \"true\");\n      }\n\n      positionLineWidget(widget, node, lineView, dims);\n      cm.display.input.setUneditable(node);\n\n      if (allowAbove && widget.above) {\n        wrap.insertBefore(node, lineView.gutter || lineView.text);\n      } else {\n        wrap.appendChild(node);\n      }\n\n      signalLater(widget, \"redraw\");\n    }\n  }\n\n  function positionLineWidget(widget, node, lineView, dims) {\n    if (widget.noHScroll) {\n      (lineView.alignable || (lineView.alignable = [])).push(node);\n      var width = dims.wrapperWidth;\n      node.style.left = dims.fixedPos + \"px\";\n\n      if (!widget.coverGutter) {\n        width -= dims.gutterTotalWidth;\n        node.style.paddingLeft = dims.gutterTotalWidth + \"px\";\n      }\n\n      node.style.width = width + \"px\";\n    }\n\n    if (widget.coverGutter) {\n      node.style.zIndex = 5;\n      node.style.position = \"relative\";\n\n      if (!widget.noHScroll) {\n        node.style.marginLeft = -dims.gutterTotalWidth + \"px\";\n      }\n    }\n  }\n\n  function widgetHeight(widget) {\n    if (widget.height != null) {\n      return widget.height;\n    }\n\n    var cm = widget.doc.cm;\n\n    if (!cm) {\n      return 0;\n    }\n\n    if (!contains(document.body, widget.node)) {\n      var parentStyle = \"position: relative;\";\n\n      if (widget.coverGutter) {\n        parentStyle += \"margin-left: -\" + cm.display.gutters.offsetWidth + \"px;\";\n      }\n\n      if (widget.noHScroll) {\n        parentStyle += \"width: \" + cm.display.wrapper.clientWidth + \"px;\";\n      }\n\n      removeChildrenAndAdd(cm.display.measure, elt(\"div\", [widget.node], null, parentStyle));\n    }\n\n    return widget.height = widget.node.parentNode.offsetHeight;\n  } // Return true when the given mouse event happened in a widget\n\n\n  function eventInWidget(display, e) {\n    for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {\n      if (!n || n.nodeType == 1 && n.getAttribute(\"cm-ignore-events\") == \"true\" || n.parentNode == display.sizer && n != display.mover) {\n        return true;\n      }\n    }\n  } // POSITION MEASUREMENT\n\n\n  function paddingTop(display) {\n    return display.lineSpace.offsetTop;\n  }\n\n  function paddingVert(display) {\n    return display.mover.offsetHeight - display.lineSpace.offsetHeight;\n  }\n\n  function paddingH(display) {\n    if (display.cachedPaddingH) {\n      return display.cachedPaddingH;\n    }\n\n    var e = removeChildrenAndAdd(display.measure, elt(\"pre\", \"x\", \"CodeMirror-line-like\"));\n    var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle;\n    var data = {\n      left: parseInt(style.paddingLeft),\n      right: parseInt(style.paddingRight)\n    };\n\n    if (!isNaN(data.left) && !isNaN(data.right)) {\n      display.cachedPaddingH = data;\n    }\n\n    return data;\n  }\n\n  function scrollGap(cm) {\n    return scrollerGap - cm.display.nativeBarWidth;\n  }\n\n  function displayWidth(cm) {\n    return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth;\n  }\n\n  function displayHeight(cm) {\n    return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight;\n  } // Ensure the lineView.wrapping.heights array is populated. This is\n  // an array of bottom offsets for the lines that make up a drawn\n  // line. When lineWrapping is on, there might be more than one\n  // height.\n\n\n  function ensureLineHeights(cm, lineView, rect) {\n    var wrapping = cm.options.lineWrapping;\n    var curWidth = wrapping && displayWidth(cm);\n\n    if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {\n      var heights = lineView.measure.heights = [];\n\n      if (wrapping) {\n        lineView.measure.width = curWidth;\n        var rects = lineView.text.firstChild.getClientRects();\n\n        for (var i = 0; i < rects.length - 1; i++) {\n          var cur = rects[i],\n              next = rects[i + 1];\n\n          if (Math.abs(cur.bottom - next.bottom) > 2) {\n            heights.push((cur.bottom + next.top) / 2 - rect.top);\n          }\n        }\n      }\n\n      heights.push(rect.bottom - rect.top);\n    }\n  } // Find a line map (mapping character offsets to text nodes) and a\n  // measurement cache for the given line number. (A line view might\n  // contain multiple lines when collapsed ranges are present.)\n\n\n  function mapFromLineView(lineView, line, lineN) {\n    if (lineView.line == line) {\n      return {\n        map: lineView.measure.map,\n        cache: lineView.measure.cache\n      };\n    }\n\n    for (var i = 0; i < lineView.rest.length; i++) {\n      if (lineView.rest[i] == line) {\n        return {\n          map: lineView.measure.maps[i],\n          cache: lineView.measure.caches[i]\n        };\n      }\n    }\n\n    for (var i$1 = 0; i$1 < lineView.rest.length; i$1++) {\n      if (lineNo(lineView.rest[i$1]) > lineN) {\n        return {\n          map: lineView.measure.maps[i$1],\n          cache: lineView.measure.caches[i$1],\n          before: true\n        };\n      }\n    }\n  } // Render a line into the hidden node display.externalMeasured. Used\n  // when measurement is needed for a line that's not in the viewport.\n\n\n  function updateExternalMeasurement(cm, line) {\n    line = visualLine(line);\n    var lineN = lineNo(line);\n    var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN);\n    view.lineN = lineN;\n    var built = view.built = buildLineContent(cm, view);\n    view.text = built.pre;\n    removeChildrenAndAdd(cm.display.lineMeasure, built.pre);\n    return view;\n  } // Get a {top, bottom, left, right} box (in line-local coordinates)\n  // for a given character.\n\n\n  function measureChar(cm, line, ch, bias) {\n    return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias);\n  } // Find a line view that corresponds to the given line number.\n\n\n  function findViewForLine(cm, lineN) {\n    if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo) {\n      return cm.display.view[findViewIndex(cm, lineN)];\n    }\n\n    var ext = cm.display.externalMeasured;\n\n    if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size) {\n      return ext;\n    }\n  } // Measurement can be split in two steps, the set-up work that\n  // applies to the whole line, and the measurement of the actual\n  // character. Functions like coordsChar, that need to do a lot of\n  // measurements in a row, can thus ensure that the set-up work is\n  // only done once.\n\n\n  function prepareMeasureForLine(cm, line) {\n    var lineN = lineNo(line);\n    var view = findViewForLine(cm, lineN);\n\n    if (view && !view.text) {\n      view = null;\n    } else if (view && view.changes) {\n      updateLineForChanges(cm, view, lineN, getDimensions(cm));\n      cm.curOp.forceUpdate = true;\n    }\n\n    if (!view) {\n      view = updateExternalMeasurement(cm, line);\n    }\n\n    var info = mapFromLineView(view, line, lineN);\n    return {\n      line: line,\n      view: view,\n      rect: null,\n      map: info.map,\n      cache: info.cache,\n      before: info.before,\n      hasHeights: false\n    };\n  } // Given a prepared measurement object, measures the position of an\n  // actual character (or fetches it from the cache).\n\n\n  function measureCharPrepared(cm, prepared, ch, bias, varHeight) {\n    if (prepared.before) {\n      ch = -1;\n    }\n\n    var key = ch + (bias || \"\"),\n        found;\n\n    if (prepared.cache.hasOwnProperty(key)) {\n      found = prepared.cache[key];\n    } else {\n      if (!prepared.rect) {\n        prepared.rect = prepared.view.text.getBoundingClientRect();\n      }\n\n      if (!prepared.hasHeights) {\n        ensureLineHeights(cm, prepared.view, prepared.rect);\n        prepared.hasHeights = true;\n      }\n\n      found = measureCharInner(cm, prepared, ch, bias);\n\n      if (!found.bogus) {\n        prepared.cache[key] = found;\n      }\n    }\n\n    return {\n      left: found.left,\n      right: found.right,\n      top: varHeight ? found.rtop : found.top,\n      bottom: varHeight ? found.rbottom : found.bottom\n    };\n  }\n\n  var nullRect = {\n    left: 0,\n    right: 0,\n    top: 0,\n    bottom: 0\n  };\n\n  function nodeAndOffsetInLineMap(map, ch, bias) {\n    var node, start, end, collapse, mStart, mEnd; // First, search the line map for the text node corresponding to,\n    // or closest to, the target character.\n\n    for (var i = 0; i < map.length; i += 3) {\n      mStart = map[i];\n      mEnd = map[i + 1];\n\n      if (ch < mStart) {\n        start = 0;\n        end = 1;\n        collapse = \"left\";\n      } else if (ch < mEnd) {\n        start = ch - mStart;\n        end = start + 1;\n      } else if (i == map.length - 3 || ch == mEnd && map[i + 3] > ch) {\n        end = mEnd - mStart;\n        start = end - 1;\n\n        if (ch >= mEnd) {\n          collapse = \"right\";\n        }\n      }\n\n      if (start != null) {\n        node = map[i + 2];\n\n        if (mStart == mEnd && bias == (node.insertLeft ? \"left\" : \"right\")) {\n          collapse = bias;\n        }\n\n        if (bias == \"left\" && start == 0) {\n          while (i && map[i - 2] == map[i - 3] && map[i - 1].insertLeft) {\n            node = map[(i -= 3) + 2];\n            collapse = \"left\";\n          }\n        }\n\n        if (bias == \"right\" && start == mEnd - mStart) {\n          while (i < map.length - 3 && map[i + 3] == map[i + 4] && !map[i + 5].insertLeft) {\n            node = map[(i += 3) + 2];\n            collapse = \"right\";\n          }\n        }\n\n        break;\n      }\n    }\n\n    return {\n      node: node,\n      start: start,\n      end: end,\n      collapse: collapse,\n      coverStart: mStart,\n      coverEnd: mEnd\n    };\n  }\n\n  function getUsefulRect(rects, bias) {\n    var rect = nullRect;\n\n    if (bias == \"left\") {\n      for (var i = 0; i < rects.length; i++) {\n        if ((rect = rects[i]).left != rect.right) {\n          break;\n        }\n      }\n    } else {\n      for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) {\n        if ((rect = rects[i$1]).left != rect.right) {\n          break;\n        }\n      }\n    }\n\n    return rect;\n  }\n\n  function measureCharInner(cm, prepared, ch, bias) {\n    var place = nodeAndOffsetInLineMap(prepared.map, ch, bias);\n    var node = place.node,\n        start = place.start,\n        end = place.end,\n        collapse = place.collapse;\n    var rect;\n\n    if (node.nodeType == 3) {\n      // If it is a text node, use a range to retrieve the coordinates.\n      for (var i$1 = 0; i$1 < 4; i$1++) {\n        // Retry a maximum of 4 times when nonsense rectangles are returned\n        while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) {\n          --start;\n        }\n\n        while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) {\n          ++end;\n        }\n\n        if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart) {\n          rect = node.parentNode.getBoundingClientRect();\n        } else {\n          rect = getUsefulRect(range(node, start, end).getClientRects(), bias);\n        }\n\n        if (rect.left || rect.right || start == 0) {\n          break;\n        }\n\n        end = start;\n        start = start - 1;\n        collapse = \"right\";\n      }\n\n      if (ie && ie_version < 11) {\n        rect = maybeUpdateRectForZooming(cm.display.measure, rect);\n      }\n    } else {\n      // If it is a widget, simply get the box for the whole widget.\n      if (start > 0) {\n        collapse = bias = \"right\";\n      }\n\n      var rects;\n\n      if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1) {\n        rect = rects[bias == \"right\" ? rects.length - 1 : 0];\n      } else {\n        rect = node.getBoundingClientRect();\n      }\n    }\n\n    if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {\n      var rSpan = node.parentNode.getClientRects()[0];\n\n      if (rSpan) {\n        rect = {\n          left: rSpan.left,\n          right: rSpan.left + charWidth(cm.display),\n          top: rSpan.top,\n          bottom: rSpan.bottom\n        };\n      } else {\n        rect = nullRect;\n      }\n    }\n\n    var rtop = rect.top - prepared.rect.top,\n        rbot = rect.bottom - prepared.rect.top;\n    var mid = (rtop + rbot) / 2;\n    var heights = prepared.view.measure.heights;\n    var i = 0;\n\n    for (; i < heights.length - 1; i++) {\n      if (mid < heights[i]) {\n        break;\n      }\n    }\n\n    var top = i ? heights[i - 1] : 0,\n        bot = heights[i];\n    var result = {\n      left: (collapse == \"right\" ? rect.right : rect.left) - prepared.rect.left,\n      right: (collapse == \"left\" ? rect.left : rect.right) - prepared.rect.left,\n      top: top,\n      bottom: bot\n    };\n\n    if (!rect.left && !rect.right) {\n      result.bogus = true;\n    }\n\n    if (!cm.options.singleCursorHeightPerLine) {\n      result.rtop = rtop;\n      result.rbottom = rbot;\n    }\n\n    return result;\n  } // Work around problem with bounding client rects on ranges being\n  // returned incorrectly when zoomed on IE10 and below.\n\n\n  function maybeUpdateRectForZooming(measure, rect) {\n    if (!window.screen || screen.logicalXDPI == null || screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure)) {\n      return rect;\n    }\n\n    var scaleX = screen.logicalXDPI / screen.deviceXDPI;\n    var scaleY = screen.logicalYDPI / screen.deviceYDPI;\n    return {\n      left: rect.left * scaleX,\n      right: rect.right * scaleX,\n      top: rect.top * scaleY,\n      bottom: rect.bottom * scaleY\n    };\n  }\n\n  function clearLineMeasurementCacheFor(lineView) {\n    if (lineView.measure) {\n      lineView.measure.cache = {};\n      lineView.measure.heights = null;\n\n      if (lineView.rest) {\n        for (var i = 0; i < lineView.rest.length; i++) {\n          lineView.measure.caches[i] = {};\n        }\n      }\n    }\n  }\n\n  function clearLineMeasurementCache(cm) {\n    cm.display.externalMeasure = null;\n    removeChildren(cm.display.lineMeasure);\n\n    for (var i = 0; i < cm.display.view.length; i++) {\n      clearLineMeasurementCacheFor(cm.display.view[i]);\n    }\n  }\n\n  function clearCaches(cm) {\n    clearLineMeasurementCache(cm);\n    cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null;\n\n    if (!cm.options.lineWrapping) {\n      cm.display.maxLineChanged = true;\n    }\n\n    cm.display.lineNumChars = null;\n  }\n\n  function pageScrollX() {\n    // Work around https://bugs.chromium.org/p/chromium/issues/detail?id=489206\n    // which causes page_Offset and bounding client rects to use\n    // different reference viewports and invalidate our calculations.\n    if (chrome && android) {\n      return -(document.body.getBoundingClientRect().left - parseInt(getComputedStyle(document.body).marginLeft));\n    }\n\n    return window.pageXOffset || (document.documentElement || document.body).scrollLeft;\n  }\n\n  function pageScrollY() {\n    if (chrome && android) {\n      return -(document.body.getBoundingClientRect().top - parseInt(getComputedStyle(document.body).marginTop));\n    }\n\n    return window.pageYOffset || (document.documentElement || document.body).scrollTop;\n  }\n\n  function widgetTopHeight(lineObj) {\n    var height = 0;\n\n    if (lineObj.widgets) {\n      for (var i = 0; i < lineObj.widgets.length; ++i) {\n        if (lineObj.widgets[i].above) {\n          height += widgetHeight(lineObj.widgets[i]);\n        }\n      }\n    }\n\n    return height;\n  } // Converts a {top, bottom, left, right} box from line-local\n  // coordinates into another coordinate system. Context may be one of\n  // \"line\", \"div\" (display.lineDiv), \"local\"./null (editor), \"window\",\n  // or \"page\".\n\n\n  function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {\n    if (!includeWidgets) {\n      var height = widgetTopHeight(lineObj);\n      rect.top += height;\n      rect.bottom += height;\n    }\n\n    if (context == \"line\") {\n      return rect;\n    }\n\n    if (!context) {\n      context = \"local\";\n    }\n\n    var yOff = heightAtLine(lineObj);\n\n    if (context == \"local\") {\n      yOff += paddingTop(cm.display);\n    } else {\n      yOff -= cm.display.viewOffset;\n    }\n\n    if (context == \"page\" || context == \"window\") {\n      var lOff = cm.display.lineSpace.getBoundingClientRect();\n      yOff += lOff.top + (context == \"window\" ? 0 : pageScrollY());\n      var xOff = lOff.left + (context == \"window\" ? 0 : pageScrollX());\n      rect.left += xOff;\n      rect.right += xOff;\n    }\n\n    rect.top += yOff;\n    rect.bottom += yOff;\n    return rect;\n  } // Coverts a box from \"div\" coords to another coordinate system.\n  // Context may be \"window\", \"page\", \"div\", or \"local\"./null.\n\n\n  function fromCoordSystem(cm, coords, context) {\n    if (context == \"div\") {\n      return coords;\n    }\n\n    var left = coords.left,\n        top = coords.top; // First move into \"page\" coordinate system\n\n    if (context == \"page\") {\n      left -= pageScrollX();\n      top -= pageScrollY();\n    } else if (context == \"local\" || !context) {\n      var localBox = cm.display.sizer.getBoundingClientRect();\n      left += localBox.left;\n      top += localBox.top;\n    }\n\n    var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect();\n    return {\n      left: left - lineSpaceBox.left,\n      top: top - lineSpaceBox.top\n    };\n  }\n\n  function charCoords(cm, pos, context, lineObj, bias) {\n    if (!lineObj) {\n      lineObj = getLine(cm.doc, pos.line);\n    }\n\n    return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context);\n  } // Returns a box for a given cursor position, which may have an\n  // 'other' property containing the position of the secondary cursor\n  // on a bidi boundary.\n  // A cursor Pos(line, char, \"before\") is on the same visual line as `char - 1`\n  // and after `char - 1` in writing order of `char - 1`\n  // A cursor Pos(line, char, \"after\") is on the same visual line as `char`\n  // and before `char` in writing order of `char`\n  // Examples (upper-case letters are RTL, lower-case are LTR):\n  //     Pos(0, 1, ...)\n  //     before   after\n  // ab     a|b     a|b\n  // aB     a|B     aB|\n  // Ab     |Ab     A|b\n  // AB     B|A     B|A\n  // Every position after the last character on a line is considered to stick\n  // to the last character on the line.\n\n\n  function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {\n    lineObj = lineObj || getLine(cm.doc, pos.line);\n\n    if (!preparedMeasure) {\n      preparedMeasure = prepareMeasureForLine(cm, lineObj);\n    }\n\n    function get(ch, right) {\n      var m = measureCharPrepared(cm, preparedMeasure, ch, right ? \"right\" : \"left\", varHeight);\n\n      if (right) {\n        m.left = m.right;\n      } else {\n        m.right = m.left;\n      }\n\n      return intoCoordSystem(cm, lineObj, m, context);\n    }\n\n    var order = getOrder(lineObj, cm.doc.direction),\n        ch = pos.ch,\n        sticky = pos.sticky;\n\n    if (ch >= lineObj.text.length) {\n      ch = lineObj.text.length;\n      sticky = \"before\";\n    } else if (ch <= 0) {\n      ch = 0;\n      sticky = \"after\";\n    }\n\n    if (!order) {\n      return get(sticky == \"before\" ? ch - 1 : ch, sticky == \"before\");\n    }\n\n    function getBidi(ch, partPos, invert) {\n      var part = order[partPos],\n          right = part.level == 1;\n      return get(invert ? ch - 1 : ch, right != invert);\n    }\n\n    var partPos = getBidiPartAt(order, ch, sticky);\n    var other = bidiOther;\n    var val = getBidi(ch, partPos, sticky == \"before\");\n\n    if (other != null) {\n      val.other = getBidi(ch, other, sticky != \"before\");\n    }\n\n    return val;\n  } // Used to cheaply estimate the coordinates for a position. Used for\n  // intermediate scroll updates.\n\n\n  function estimateCoords(cm, pos) {\n    var left = 0;\n    pos = clipPos(cm.doc, pos);\n\n    if (!cm.options.lineWrapping) {\n      left = charWidth(cm.display) * pos.ch;\n    }\n\n    var lineObj = getLine(cm.doc, pos.line);\n    var top = heightAtLine(lineObj) + paddingTop(cm.display);\n    return {\n      left: left,\n      right: left,\n      top: top,\n      bottom: top + lineObj.height\n    };\n  } // Positions returned by coordsChar contain some extra information.\n  // xRel is the relative x position of the input coordinates compared\n  // to the found position (so xRel > 0 means the coordinates are to\n  // the right of the character position, for example). When outside\n  // is true, that means the coordinates lie outside the line's\n  // vertical range.\n\n\n  function PosWithInfo(line, ch, sticky, outside, xRel) {\n    var pos = Pos(line, ch, sticky);\n    pos.xRel = xRel;\n\n    if (outside) {\n      pos.outside = outside;\n    }\n\n    return pos;\n  } // Compute the character position closest to the given coordinates.\n  // Input must be lineSpace-local (\"div\" coordinate system).\n\n\n  function coordsChar(cm, x, y) {\n    var doc = cm.doc;\n    y += cm.display.viewOffset;\n\n    if (y < 0) {\n      return PosWithInfo(doc.first, 0, null, -1, -1);\n    }\n\n    var lineN = lineAtHeight(doc, y),\n        last = doc.first + doc.size - 1;\n\n    if (lineN > last) {\n      return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, null, 1, 1);\n    }\n\n    if (x < 0) {\n      x = 0;\n    }\n\n    var lineObj = getLine(doc, lineN);\n\n    for (;;) {\n      var found = coordsCharInner(cm, lineObj, lineN, x, y);\n      var collapsed = collapsedSpanAround(lineObj, found.ch + (found.xRel > 0 || found.outside > 0 ? 1 : 0));\n\n      if (!collapsed) {\n        return found;\n      }\n\n      var rangeEnd = collapsed.find(1);\n\n      if (rangeEnd.line == lineN) {\n        return rangeEnd;\n      }\n\n      lineObj = getLine(doc, lineN = rangeEnd.line);\n    }\n  }\n\n  function wrappedLineExtent(cm, lineObj, preparedMeasure, y) {\n    y -= widgetTopHeight(lineObj);\n    var end = lineObj.text.length;\n    var begin = findFirst(function (ch) {\n      return measureCharPrepared(cm, preparedMeasure, ch - 1).bottom <= y;\n    }, end, 0);\n    end = findFirst(function (ch) {\n      return measureCharPrepared(cm, preparedMeasure, ch).top > y;\n    }, begin, end);\n    return {\n      begin: begin,\n      end: end\n    };\n  }\n\n  function wrappedLineExtentChar(cm, lineObj, preparedMeasure, target) {\n    if (!preparedMeasure) {\n      preparedMeasure = prepareMeasureForLine(cm, lineObj);\n    }\n\n    var targetTop = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, target), \"line\").top;\n    return wrappedLineExtent(cm, lineObj, preparedMeasure, targetTop);\n  } // Returns true if the given side of a box is after the given\n  // coordinates, in top-to-bottom, left-to-right order.\n\n\n  function boxIsAfter(box, x, y, left) {\n    return box.bottom <= y ? false : box.top > y ? true : (left ? box.left : box.right) > x;\n  }\n\n  function coordsCharInner(cm, lineObj, lineNo, x, y) {\n    // Move y into line-local coordinate space\n    y -= heightAtLine(lineObj);\n    var preparedMeasure = prepareMeasureForLine(cm, lineObj); // When directly calling `measureCharPrepared`, we have to adjust\n    // for the widgets at this line.\n\n    var widgetHeight = widgetTopHeight(lineObj);\n    var begin = 0,\n        end = lineObj.text.length,\n        ltr = true;\n    var order = getOrder(lineObj, cm.doc.direction); // If the line isn't plain left-to-right text, first figure out\n    // which bidi section the coordinates fall into.\n\n    if (order) {\n      var part = (cm.options.lineWrapping ? coordsBidiPartWrapped : coordsBidiPart)(cm, lineObj, lineNo, preparedMeasure, order, x, y);\n      ltr = part.level != 1; // The awkward -1 offsets are needed because findFirst (called\n      // on these below) will treat its first bound as inclusive,\n      // second as exclusive, but we want to actually address the\n      // characters in the part's range\n\n      begin = ltr ? part.from : part.to - 1;\n      end = ltr ? part.to : part.from - 1;\n    } // A binary search to find the first character whose bounding box\n    // starts after the coordinates. If we run across any whose box wrap\n    // the coordinates, store that.\n\n\n    var chAround = null,\n        boxAround = null;\n    var ch = findFirst(function (ch) {\n      var box = measureCharPrepared(cm, preparedMeasure, ch);\n      box.top += widgetHeight;\n      box.bottom += widgetHeight;\n\n      if (!boxIsAfter(box, x, y, false)) {\n        return false;\n      }\n\n      if (box.top <= y && box.left <= x) {\n        chAround = ch;\n        boxAround = box;\n      }\n\n      return true;\n    }, begin, end);\n    var baseX,\n        sticky,\n        outside = false; // If a box around the coordinates was found, use that\n\n    if (boxAround) {\n      // Distinguish coordinates nearer to the left or right side of the box\n      var atLeft = x - boxAround.left < boxAround.right - x,\n          atStart = atLeft == ltr;\n      ch = chAround + (atStart ? 0 : 1);\n      sticky = atStart ? \"after\" : \"before\";\n      baseX = atLeft ? boxAround.left : boxAround.right;\n    } else {\n      // (Adjust for extended bound, if necessary.)\n      if (!ltr && (ch == end || ch == begin)) {\n        ch++;\n      } // To determine which side to associate with, get the box to the\n      // left of the character and compare it's vertical position to the\n      // coordinates\n\n\n      sticky = ch == 0 ? \"after\" : ch == lineObj.text.length ? \"before\" : measureCharPrepared(cm, preparedMeasure, ch - (ltr ? 1 : 0)).bottom + widgetHeight <= y == ltr ? \"after\" : \"before\"; // Now get accurate coordinates for this place, in order to get a\n      // base X position\n\n      var coords = cursorCoords(cm, Pos(lineNo, ch, sticky), \"line\", lineObj, preparedMeasure);\n      baseX = coords.left;\n      outside = y < coords.top ? -1 : y >= coords.bottom ? 1 : 0;\n    }\n\n    ch = skipExtendingChars(lineObj.text, ch, 1);\n    return PosWithInfo(lineNo, ch, sticky, outside, x - baseX);\n  }\n\n  function coordsBidiPart(cm, lineObj, lineNo, preparedMeasure, order, x, y) {\n    // Bidi parts are sorted left-to-right, and in a non-line-wrapping\n    // situation, we can take this ordering to correspond to the visual\n    // ordering. This finds the first part whose end is after the given\n    // coordinates.\n    var index = findFirst(function (i) {\n      var part = order[i],\n          ltr = part.level != 1;\n      return boxIsAfter(cursorCoords(cm, Pos(lineNo, ltr ? part.to : part.from, ltr ? \"before\" : \"after\"), \"line\", lineObj, preparedMeasure), x, y, true);\n    }, 0, order.length - 1);\n    var part = order[index]; // If this isn't the first part, the part's start is also after\n    // the coordinates, and the coordinates aren't on the same line as\n    // that start, move one part back.\n\n    if (index > 0) {\n      var ltr = part.level != 1;\n      var start = cursorCoords(cm, Pos(lineNo, ltr ? part.from : part.to, ltr ? \"after\" : \"before\"), \"line\", lineObj, preparedMeasure);\n\n      if (boxIsAfter(start, x, y, true) && start.top > y) {\n        part = order[index - 1];\n      }\n    }\n\n    return part;\n  }\n\n  function coordsBidiPartWrapped(cm, lineObj, _lineNo, preparedMeasure, order, x, y) {\n    // In a wrapped line, rtl text on wrapping boundaries can do things\n    // that don't correspond to the ordering in our `order` array at\n    // all, so a binary search doesn't work, and we want to return a\n    // part that only spans one line so that the binary search in\n    // coordsCharInner is safe. As such, we first find the extent of the\n    // wrapped line, and then do a flat search in which we discard any\n    // spans that aren't on the line.\n    var ref = wrappedLineExtent(cm, lineObj, preparedMeasure, y);\n    var begin = ref.begin;\n    var end = ref.end;\n\n    if (/\\s/.test(lineObj.text.charAt(end - 1))) {\n      end--;\n    }\n\n    var part = null,\n        closestDist = null;\n\n    for (var i = 0; i < order.length; i++) {\n      var p = order[i];\n\n      if (p.from >= end || p.to <= begin) {\n        continue;\n      }\n\n      var ltr = p.level != 1;\n      var endX = measureCharPrepared(cm, preparedMeasure, ltr ? Math.min(end, p.to) - 1 : Math.max(begin, p.from)).right; // Weigh against spans ending before this, so that they are only\n      // picked if nothing ends after\n\n      var dist = endX < x ? x - endX + 1e9 : endX - x;\n\n      if (!part || closestDist > dist) {\n        part = p;\n        closestDist = dist;\n      }\n    }\n\n    if (!part) {\n      part = order[order.length - 1];\n    } // Clip the part to the wrapped line.\n\n\n    if (part.from < begin) {\n      part = {\n        from: begin,\n        to: part.to,\n        level: part.level\n      };\n    }\n\n    if (part.to > end) {\n      part = {\n        from: part.from,\n        to: end,\n        level: part.level\n      };\n    }\n\n    return part;\n  }\n\n  var measureText; // Compute the default text height.\n\n  function textHeight(display) {\n    if (display.cachedTextHeight != null) {\n      return display.cachedTextHeight;\n    }\n\n    if (measureText == null) {\n      measureText = elt(\"pre\", null, \"CodeMirror-line-like\"); // Measure a bunch of lines, for browsers that compute\n      // fractional heights.\n\n      for (var i = 0; i < 49; ++i) {\n        measureText.appendChild(document.createTextNode(\"x\"));\n        measureText.appendChild(elt(\"br\"));\n      }\n\n      measureText.appendChild(document.createTextNode(\"x\"));\n    }\n\n    removeChildrenAndAdd(display.measure, measureText);\n    var height = measureText.offsetHeight / 50;\n\n    if (height > 3) {\n      display.cachedTextHeight = height;\n    }\n\n    removeChildren(display.measure);\n    return height || 1;\n  } // Compute the default character width.\n\n\n  function charWidth(display) {\n    if (display.cachedCharWidth != null) {\n      return display.cachedCharWidth;\n    }\n\n    var anchor = elt(\"span\", \"xxxxxxxxxx\");\n    var pre = elt(\"pre\", [anchor], \"CodeMirror-line-like\");\n    removeChildrenAndAdd(display.measure, pre);\n    var rect = anchor.getBoundingClientRect(),\n        width = (rect.right - rect.left) / 10;\n\n    if (width > 2) {\n      display.cachedCharWidth = width;\n    }\n\n    return width || 10;\n  } // Do a bulk-read of the DOM positions and sizes needed to draw the\n  // view, so that we don't interleave reading and writing to the DOM.\n\n\n  function getDimensions(cm) {\n    var d = cm.display,\n        left = {},\n        width = {};\n    var gutterLeft = d.gutters.clientLeft;\n\n    for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {\n      var id = cm.display.gutterSpecs[i].className;\n      left[id] = n.offsetLeft + n.clientLeft + gutterLeft;\n      width[id] = n.clientWidth;\n    }\n\n    return {\n      fixedPos: compensateForHScroll(d),\n      gutterTotalWidth: d.gutters.offsetWidth,\n      gutterLeft: left,\n      gutterWidth: width,\n      wrapperWidth: d.wrapper.clientWidth\n    };\n  } // Computes display.scroller.scrollLeft + display.gutters.offsetWidth,\n  // but using getBoundingClientRect to get a sub-pixel-accurate\n  // result.\n\n\n  function compensateForHScroll(display) {\n    return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left;\n  } // Returns a function that estimates the height of a line, to use as\n  // first approximation until the line becomes visible (and is thus\n  // properly measurable).\n\n\n  function estimateHeight(cm) {\n    var th = textHeight(cm.display),\n        wrapping = cm.options.lineWrapping;\n    var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3);\n    return function (line) {\n      if (lineIsHidden(cm.doc, line)) {\n        return 0;\n      }\n\n      var widgetsHeight = 0;\n\n      if (line.widgets) {\n        for (var i = 0; i < line.widgets.length; i++) {\n          if (line.widgets[i].height) {\n            widgetsHeight += line.widgets[i].height;\n          }\n        }\n      }\n\n      if (wrapping) {\n        return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th;\n      } else {\n        return widgetsHeight + th;\n      }\n    };\n  }\n\n  function estimateLineHeights(cm) {\n    var doc = cm.doc,\n        est = estimateHeight(cm);\n    doc.iter(function (line) {\n      var estHeight = est(line);\n\n      if (estHeight != line.height) {\n        updateLineHeight(line, estHeight);\n      }\n    });\n  } // Given a mouse event, find the corresponding position. If liberal\n  // is false, it checks whether a gutter or scrollbar was clicked,\n  // and returns null if it was. forRect is used by rectangular\n  // selections, and tries to estimate a character position even for\n  // coordinates beyond the right of the text.\n\n\n  function posFromMouse(cm, e, liberal, forRect) {\n    var display = cm.display;\n\n    if (!liberal && e_target(e).getAttribute(\"cm-not-content\") == \"true\") {\n      return null;\n    }\n\n    var x,\n        y,\n        space = display.lineSpace.getBoundingClientRect(); // Fails unpredictably on IE[67] when mouse is dragged around quickly.\n\n    try {\n      x = e.clientX - space.left;\n      y = e.clientY - space.top;\n    } catch (e$1) {\n      return null;\n    }\n\n    var coords = coordsChar(cm, x, y),\n        line;\n\n    if (forRect && coords.xRel > 0 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {\n      var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length;\n      coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff));\n    }\n\n    return coords;\n  } // Find the view element corresponding to a given line. Return null\n  // when the line isn't visible.\n\n\n  function findViewIndex(cm, n) {\n    if (n >= cm.display.viewTo) {\n      return null;\n    }\n\n    n -= cm.display.viewFrom;\n\n    if (n < 0) {\n      return null;\n    }\n\n    var view = cm.display.view;\n\n    for (var i = 0; i < view.length; i++) {\n      n -= view[i].size;\n\n      if (n < 0) {\n        return i;\n      }\n    }\n  } // Updates the display.view data structure for a given change to the\n  // document. From and to are in pre-change coordinates. Lendiff is\n  // the amount of lines added or subtracted by the change. This is\n  // used for changes that span multiple lines, or change the way\n  // lines are divided into visual lines. regLineChange (below)\n  // registers single-line changes.\n\n\n  function regChange(cm, from, to, lendiff) {\n    if (from == null) {\n      from = cm.doc.first;\n    }\n\n    if (to == null) {\n      to = cm.doc.first + cm.doc.size;\n    }\n\n    if (!lendiff) {\n      lendiff = 0;\n    }\n\n    var display = cm.display;\n\n    if (lendiff && to < display.viewTo && (display.updateLineNumbers == null || display.updateLineNumbers > from)) {\n      display.updateLineNumbers = from;\n    }\n\n    cm.curOp.viewChanged = true;\n\n    if (from >= display.viewTo) {\n      // Change after\n      if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo) {\n        resetView(cm);\n      }\n    } else if (to <= display.viewFrom) {\n      // Change before\n      if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {\n        resetView(cm);\n      } else {\n        display.viewFrom += lendiff;\n        display.viewTo += lendiff;\n      }\n    } else if (from <= display.viewFrom && to >= display.viewTo) {\n      // Full overlap\n      resetView(cm);\n    } else if (from <= display.viewFrom) {\n      // Top overlap\n      var cut = viewCuttingPoint(cm, to, to + lendiff, 1);\n\n      if (cut) {\n        display.view = display.view.slice(cut.index);\n        display.viewFrom = cut.lineN;\n        display.viewTo += lendiff;\n      } else {\n        resetView(cm);\n      }\n    } else if (to >= display.viewTo) {\n      // Bottom overlap\n      var cut$1 = viewCuttingPoint(cm, from, from, -1);\n\n      if (cut$1) {\n        display.view = display.view.slice(0, cut$1.index);\n        display.viewTo = cut$1.lineN;\n      } else {\n        resetView(cm);\n      }\n    } else {\n      // Gap in the middle\n      var cutTop = viewCuttingPoint(cm, from, from, -1);\n      var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1);\n\n      if (cutTop && cutBot) {\n        display.view = display.view.slice(0, cutTop.index).concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN)).concat(display.view.slice(cutBot.index));\n        display.viewTo += lendiff;\n      } else {\n        resetView(cm);\n      }\n    }\n\n    var ext = display.externalMeasured;\n\n    if (ext) {\n      if (to < ext.lineN) {\n        ext.lineN += lendiff;\n      } else if (from < ext.lineN + ext.size) {\n        display.externalMeasured = null;\n      }\n    }\n  } // Register a change to a single line. Type must be one of \"text\",\n  // \"gutter\", \"class\", \"widget\"\n\n\n  function regLineChange(cm, line, type) {\n    cm.curOp.viewChanged = true;\n    var display = cm.display,\n        ext = cm.display.externalMeasured;\n\n    if (ext && line >= ext.lineN && line < ext.lineN + ext.size) {\n      display.externalMeasured = null;\n    }\n\n    if (line < display.viewFrom || line >= display.viewTo) {\n      return;\n    }\n\n    var lineView = display.view[findViewIndex(cm, line)];\n\n    if (lineView.node == null) {\n      return;\n    }\n\n    var arr = lineView.changes || (lineView.changes = []);\n\n    if (indexOf(arr, type) == -1) {\n      arr.push(type);\n    }\n  } // Clear the view.\n\n\n  function resetView(cm) {\n    cm.display.viewFrom = cm.display.viewTo = cm.doc.first;\n    cm.display.view = [];\n    cm.display.viewOffset = 0;\n  }\n\n  function viewCuttingPoint(cm, oldN, newN, dir) {\n    var index = findViewIndex(cm, oldN),\n        diff,\n        view = cm.display.view;\n\n    if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size) {\n      return {\n        index: index,\n        lineN: newN\n      };\n    }\n\n    var n = cm.display.viewFrom;\n\n    for (var i = 0; i < index; i++) {\n      n += view[i].size;\n    }\n\n    if (n != oldN) {\n      if (dir > 0) {\n        if (index == view.length - 1) {\n          return null;\n        }\n\n        diff = n + view[index].size - oldN;\n        index++;\n      } else {\n        diff = n - oldN;\n      }\n\n      oldN += diff;\n      newN += diff;\n    }\n\n    while (visualLineNo(cm.doc, newN) != newN) {\n      if (index == (dir < 0 ? 0 : view.length - 1)) {\n        return null;\n      }\n\n      newN += dir * view[index - (dir < 0 ? 1 : 0)].size;\n      index += dir;\n    }\n\n    return {\n      index: index,\n      lineN: newN\n    };\n  } // Force the view to cover a given range, adding empty view element\n  // or clipping off existing ones as needed.\n\n\n  function adjustView(cm, from, to) {\n    var display = cm.display,\n        view = display.view;\n\n    if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {\n      display.view = buildViewArray(cm, from, to);\n      display.viewFrom = from;\n    } else {\n      if (display.viewFrom > from) {\n        display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view);\n      } else if (display.viewFrom < from) {\n        display.view = display.view.slice(findViewIndex(cm, from));\n      }\n\n      display.viewFrom = from;\n\n      if (display.viewTo < to) {\n        display.view = display.view.concat(buildViewArray(cm, display.viewTo, to));\n      } else if (display.viewTo > to) {\n        display.view = display.view.slice(0, findViewIndex(cm, to));\n      }\n    }\n\n    display.viewTo = to;\n  } // Count the number of lines in the view whose DOM representation is\n  // out of date (or nonexistent).\n\n\n  function countDirtyView(cm) {\n    var view = cm.display.view,\n        dirty = 0;\n\n    for (var i = 0; i < view.length; i++) {\n      var lineView = view[i];\n\n      if (!lineView.hidden && (!lineView.node || lineView.changes)) {\n        ++dirty;\n      }\n    }\n\n    return dirty;\n  }\n\n  function updateSelection(cm) {\n    cm.display.input.showSelection(cm.display.input.prepareSelection());\n  }\n\n  function prepareSelection(cm, primary) {\n    if (primary === void 0) primary = true;\n    var doc = cm.doc,\n        result = {};\n    var curFragment = result.cursors = document.createDocumentFragment();\n    var selFragment = result.selection = document.createDocumentFragment();\n\n    for (var i = 0; i < doc.sel.ranges.length; i++) {\n      if (!primary && i == doc.sel.primIndex) {\n        continue;\n      }\n\n      var range = doc.sel.ranges[i];\n\n      if (range.from().line >= cm.display.viewTo || range.to().line < cm.display.viewFrom) {\n        continue;\n      }\n\n      var collapsed = range.empty();\n\n      if (collapsed || cm.options.showCursorWhenSelecting) {\n        drawSelectionCursor(cm, range.head, curFragment);\n      }\n\n      if (!collapsed) {\n        drawSelectionRange(cm, range, selFragment);\n      }\n    }\n\n    return result;\n  } // Draws a cursor for the given range\n\n\n  function drawSelectionCursor(cm, head, output) {\n    var pos = cursorCoords(cm, head, \"div\", null, null, !cm.options.singleCursorHeightPerLine);\n    var cursor = output.appendChild(elt(\"div\", \"\\u00a0\", \"CodeMirror-cursor\"));\n    cursor.style.left = pos.left + \"px\";\n    cursor.style.top = pos.top + \"px\";\n    cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + \"px\";\n\n    if (pos.other) {\n      // Secondary cursor, shown when on a 'jump' in bi-directional text\n      var otherCursor = output.appendChild(elt(\"div\", \"\\u00a0\", \"CodeMirror-cursor CodeMirror-secondarycursor\"));\n      otherCursor.style.display = \"\";\n      otherCursor.style.left = pos.other.left + \"px\";\n      otherCursor.style.top = pos.other.top + \"px\";\n      otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + \"px\";\n    }\n  }\n\n  function cmpCoords(a, b) {\n    return a.top - b.top || a.left - b.left;\n  } // Draws the given range as a highlighted selection\n\n\n  function drawSelectionRange(cm, range, output) {\n    var display = cm.display,\n        doc = cm.doc;\n    var fragment = document.createDocumentFragment();\n    var padding = paddingH(cm.display),\n        leftSide = padding.left;\n    var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right;\n    var docLTR = doc.direction == \"ltr\";\n\n    function add(left, top, width, bottom) {\n      if (top < 0) {\n        top = 0;\n      }\n\n      top = Math.round(top);\n      bottom = Math.round(bottom);\n      fragment.appendChild(elt(\"div\", null, \"CodeMirror-selected\", \"position: absolute; left: \" + left + \"px;\\n                             top: \" + top + \"px; width: \" + (width == null ? rightSide - left : width) + \"px;\\n                             height: \" + (bottom - top) + \"px\"));\n    }\n\n    function drawForLine(line, fromArg, toArg) {\n      var lineObj = getLine(doc, line);\n      var lineLen = lineObj.text.length;\n      var start, end;\n\n      function coords(ch, bias) {\n        return charCoords(cm, Pos(line, ch), \"div\", lineObj, bias);\n      }\n\n      function wrapX(pos, dir, side) {\n        var extent = wrappedLineExtentChar(cm, lineObj, null, pos);\n        var prop = dir == \"ltr\" == (side == \"after\") ? \"left\" : \"right\";\n        var ch = side == \"after\" ? extent.begin : extent.end - (/\\s/.test(lineObj.text.charAt(extent.end - 1)) ? 2 : 1);\n        return coords(ch, prop)[prop];\n      }\n\n      var order = getOrder(lineObj, doc.direction);\n      iterateBidiSections(order, fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir, i) {\n        var ltr = dir == \"ltr\";\n        var fromPos = coords(from, ltr ? \"left\" : \"right\");\n        var toPos = coords(to - 1, ltr ? \"right\" : \"left\");\n        var openStart = fromArg == null && from == 0,\n            openEnd = toArg == null && to == lineLen;\n        var first = i == 0,\n            last = !order || i == order.length - 1;\n\n        if (toPos.top - fromPos.top <= 3) {\n          // Single line\n          var openLeft = (docLTR ? openStart : openEnd) && first;\n          var openRight = (docLTR ? openEnd : openStart) && last;\n          var left = openLeft ? leftSide : (ltr ? fromPos : toPos).left;\n          var right = openRight ? rightSide : (ltr ? toPos : fromPos).right;\n          add(left, fromPos.top, right - left, fromPos.bottom);\n        } else {\n          // Multiple lines\n          var topLeft, topRight, botLeft, botRight;\n\n          if (ltr) {\n            topLeft = docLTR && openStart && first ? leftSide : fromPos.left;\n            topRight = docLTR ? rightSide : wrapX(from, dir, \"before\");\n            botLeft = docLTR ? leftSide : wrapX(to, dir, \"after\");\n            botRight = docLTR && openEnd && last ? rightSide : toPos.right;\n          } else {\n            topLeft = !docLTR ? leftSide : wrapX(from, dir, \"before\");\n            topRight = !docLTR && openStart && first ? rightSide : fromPos.right;\n            botLeft = !docLTR && openEnd && last ? leftSide : toPos.left;\n            botRight = !docLTR ? rightSide : wrapX(to, dir, \"after\");\n          }\n\n          add(topLeft, fromPos.top, topRight - topLeft, fromPos.bottom);\n\n          if (fromPos.bottom < toPos.top) {\n            add(leftSide, fromPos.bottom, null, toPos.top);\n          }\n\n          add(botLeft, toPos.top, botRight - botLeft, toPos.bottom);\n        }\n\n        if (!start || cmpCoords(fromPos, start) < 0) {\n          start = fromPos;\n        }\n\n        if (cmpCoords(toPos, start) < 0) {\n          start = toPos;\n        }\n\n        if (!end || cmpCoords(fromPos, end) < 0) {\n          end = fromPos;\n        }\n\n        if (cmpCoords(toPos, end) < 0) {\n          end = toPos;\n        }\n      });\n      return {\n        start: start,\n        end: end\n      };\n    }\n\n    var sFrom = range.from(),\n        sTo = range.to();\n\n    if (sFrom.line == sTo.line) {\n      drawForLine(sFrom.line, sFrom.ch, sTo.ch);\n    } else {\n      var fromLine = getLine(doc, sFrom.line),\n          toLine = getLine(doc, sTo.line);\n      var singleVLine = visualLine(fromLine) == visualLine(toLine);\n      var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end;\n      var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start;\n\n      if (singleVLine) {\n        if (leftEnd.top < rightStart.top - 2) {\n          add(leftEnd.right, leftEnd.top, null, leftEnd.bottom);\n          add(leftSide, rightStart.top, rightStart.left, rightStart.bottom);\n        } else {\n          add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom);\n        }\n      }\n\n      if (leftEnd.bottom < rightStart.top) {\n        add(leftSide, leftEnd.bottom, null, rightStart.top);\n      }\n    }\n\n    output.appendChild(fragment);\n  } // Cursor-blinking\n\n\n  function restartBlink(cm) {\n    if (!cm.state.focused) {\n      return;\n    }\n\n    var display = cm.display;\n    clearInterval(display.blinker);\n    var on = true;\n    display.cursorDiv.style.visibility = \"\";\n\n    if (cm.options.cursorBlinkRate > 0) {\n      display.blinker = setInterval(function () {\n        return display.cursorDiv.style.visibility = (on = !on) ? \"\" : \"hidden\";\n      }, cm.options.cursorBlinkRate);\n    } else if (cm.options.cursorBlinkRate < 0) {\n      display.cursorDiv.style.visibility = \"hidden\";\n    }\n  }\n\n  function ensureFocus(cm) {\n    if (!cm.state.focused) {\n      cm.display.input.focus();\n      onFocus(cm);\n    }\n  }\n\n  function delayBlurEvent(cm) {\n    cm.state.delayingBlurEvent = true;\n    setTimeout(function () {\n      if (cm.state.delayingBlurEvent) {\n        cm.state.delayingBlurEvent = false;\n        onBlur(cm);\n      }\n    }, 100);\n  }\n\n  function onFocus(cm, e) {\n    if (cm.state.delayingBlurEvent) {\n      cm.state.delayingBlurEvent = false;\n    }\n\n    if (cm.options.readOnly == \"nocursor\") {\n      return;\n    }\n\n    if (!cm.state.focused) {\n      signal(cm, \"focus\", cm, e);\n      cm.state.focused = true;\n      addClass(cm.display.wrapper, \"CodeMirror-focused\"); // This test prevents this from firing when a context\n      // menu is closed (since the input reset would kill the\n      // select-all detection hack)\n\n      if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {\n        cm.display.input.reset();\n\n        if (webkit) {\n          setTimeout(function () {\n            return cm.display.input.reset(true);\n          }, 20);\n        } // Issue #1730\n\n      }\n\n      cm.display.input.receivedFocus();\n    }\n\n    restartBlink(cm);\n  }\n\n  function onBlur(cm, e) {\n    if (cm.state.delayingBlurEvent) {\n      return;\n    }\n\n    if (cm.state.focused) {\n      signal(cm, \"blur\", cm, e);\n      cm.state.focused = false;\n      rmClass(cm.display.wrapper, \"CodeMirror-focused\");\n    }\n\n    clearInterval(cm.display.blinker);\n    setTimeout(function () {\n      if (!cm.state.focused) {\n        cm.display.shift = false;\n      }\n    }, 150);\n  } // Read the actual heights of the rendered lines, and update their\n  // stored heights to match.\n\n\n  function updateHeightsInViewport(cm) {\n    var display = cm.display;\n    var prevBottom = display.lineDiv.offsetTop;\n\n    for (var i = 0; i < display.view.length; i++) {\n      var cur = display.view[i],\n          wrapping = cm.options.lineWrapping;\n      var height = void 0,\n          width = 0;\n\n      if (cur.hidden) {\n        continue;\n      }\n\n      if (ie && ie_version < 8) {\n        var bot = cur.node.offsetTop + cur.node.offsetHeight;\n        height = bot - prevBottom;\n        prevBottom = bot;\n      } else {\n        var box = cur.node.getBoundingClientRect();\n        height = box.bottom - box.top; // Check that lines don't extend past the right of the current\n        // editor width\n\n        if (!wrapping && cur.text.firstChild) {\n          width = cur.text.firstChild.getBoundingClientRect().right - box.left - 1;\n        }\n      }\n\n      var diff = cur.line.height - height;\n\n      if (diff > .005 || diff < -.005) {\n        updateLineHeight(cur.line, height);\n        updateWidgetHeight(cur.line);\n\n        if (cur.rest) {\n          for (var j = 0; j < cur.rest.length; j++) {\n            updateWidgetHeight(cur.rest[j]);\n          }\n        }\n      }\n\n      if (width > cm.display.sizerWidth) {\n        var chWidth = Math.ceil(width / charWidth(cm.display));\n\n        if (chWidth > cm.display.maxLineLength) {\n          cm.display.maxLineLength = chWidth;\n          cm.display.maxLine = cur.line;\n          cm.display.maxLineChanged = true;\n        }\n      }\n    }\n  } // Read and store the height of line widgets associated with the\n  // given line.\n\n\n  function updateWidgetHeight(line) {\n    if (line.widgets) {\n      for (var i = 0; i < line.widgets.length; ++i) {\n        var w = line.widgets[i],\n            parent = w.node.parentNode;\n\n        if (parent) {\n          w.height = parent.offsetHeight;\n        }\n      }\n    }\n  } // Compute the lines that are visible in a given viewport (defaults\n  // the the current scroll position). viewport may contain top,\n  // height, and ensure (see op.scrollToPos) properties.\n\n\n  function visibleLines(display, doc, viewport) {\n    var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop;\n    top = Math.floor(top - paddingTop(display));\n    var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight;\n    var from = lineAtHeight(doc, top),\n        to = lineAtHeight(doc, bottom); // Ensure is a {from: {line, ch}, to: {line, ch}} object, and\n    // forces those lines into the viewport (if possible).\n\n    if (viewport && viewport.ensure) {\n      var ensureFrom = viewport.ensure.from.line,\n          ensureTo = viewport.ensure.to.line;\n\n      if (ensureFrom < from) {\n        from = ensureFrom;\n        to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight);\n      } else if (Math.min(ensureTo, doc.lastLine()) >= to) {\n        from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight);\n        to = ensureTo;\n      }\n    }\n\n    return {\n      from: from,\n      to: Math.max(to, from + 1)\n    };\n  } // SCROLLING THINGS INTO VIEW\n  // If an editor sits on the top or bottom of the window, partially\n  // scrolled out of view, this ensures that the cursor is visible.\n\n\n  function maybeScrollWindow(cm, rect) {\n    if (signalDOMEvent(cm, \"scrollCursorIntoView\")) {\n      return;\n    }\n\n    var display = cm.display,\n        box = display.sizer.getBoundingClientRect(),\n        doScroll = null;\n\n    if (rect.top + box.top < 0) {\n      doScroll = true;\n    } else if (rect.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) {\n      doScroll = false;\n    }\n\n    if (doScroll != null && !phantom) {\n      var scrollNode = elt(\"div\", \"\\u200b\", null, \"position: absolute;\\n                         top: \" + (rect.top - display.viewOffset - paddingTop(cm.display)) + \"px;\\n                         height: \" + (rect.bottom - rect.top + scrollGap(cm) + display.barHeight) + \"px;\\n                         left: \" + rect.left + \"px; width: \" + Math.max(2, rect.right - rect.left) + \"px;\");\n      cm.display.lineSpace.appendChild(scrollNode);\n      scrollNode.scrollIntoView(doScroll);\n      cm.display.lineSpace.removeChild(scrollNode);\n    }\n  } // Scroll a given position into view (immediately), verifying that\n  // it actually became visible (as line heights are accurately\n  // measured, the position of something may 'drift' during drawing).\n\n\n  function scrollPosIntoView(cm, pos, end, margin) {\n    if (margin == null) {\n      margin = 0;\n    }\n\n    var rect;\n\n    if (!cm.options.lineWrapping && pos == end) {\n      // Set pos and end to the cursor positions around the character pos sticks to\n      // If pos.sticky == \"before\", that is around pos.ch - 1, otherwise around pos.ch\n      // If pos == Pos(_, 0, \"before\"), pos and end are unchanged\n      pos = pos.ch ? Pos(pos.line, pos.sticky == \"before\" ? pos.ch - 1 : pos.ch, \"after\") : pos;\n      end = pos.sticky == \"before\" ? Pos(pos.line, pos.ch + 1, \"before\") : pos;\n    }\n\n    for (var limit = 0; limit < 5; limit++) {\n      var changed = false;\n      var coords = cursorCoords(cm, pos);\n      var endCoords = !end || end == pos ? coords : cursorCoords(cm, end);\n      rect = {\n        left: Math.min(coords.left, endCoords.left),\n        top: Math.min(coords.top, endCoords.top) - margin,\n        right: Math.max(coords.left, endCoords.left),\n        bottom: Math.max(coords.bottom, endCoords.bottom) + margin\n      };\n      var scrollPos = calculateScrollPos(cm, rect);\n      var startTop = cm.doc.scrollTop,\n          startLeft = cm.doc.scrollLeft;\n\n      if (scrollPos.scrollTop != null) {\n        updateScrollTop(cm, scrollPos.scrollTop);\n\n        if (Math.abs(cm.doc.scrollTop - startTop) > 1) {\n          changed = true;\n        }\n      }\n\n      if (scrollPos.scrollLeft != null) {\n        setScrollLeft(cm, scrollPos.scrollLeft);\n\n        if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) {\n          changed = true;\n        }\n      }\n\n      if (!changed) {\n        break;\n      }\n    }\n\n    return rect;\n  } // Scroll a given set of coordinates into view (immediately).\n\n\n  function scrollIntoView(cm, rect) {\n    var scrollPos = calculateScrollPos(cm, rect);\n\n    if (scrollPos.scrollTop != null) {\n      updateScrollTop(cm, scrollPos.scrollTop);\n    }\n\n    if (scrollPos.scrollLeft != null) {\n      setScrollLeft(cm, scrollPos.scrollLeft);\n    }\n  } // Calculate a new scroll position needed to scroll the given\n  // rectangle into view. Returns an object with scrollTop and\n  // scrollLeft properties. When these are undefined, the\n  // vertical/horizontal position does not need to be adjusted.\n\n\n  function calculateScrollPos(cm, rect) {\n    var display = cm.display,\n        snapMargin = textHeight(cm.display);\n\n    if (rect.top < 0) {\n      rect.top = 0;\n    }\n\n    var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop;\n    var screen = displayHeight(cm),\n        result = {};\n\n    if (rect.bottom - rect.top > screen) {\n      rect.bottom = rect.top + screen;\n    }\n\n    var docBottom = cm.doc.height + paddingVert(display);\n    var atTop = rect.top < snapMargin,\n        atBottom = rect.bottom > docBottom - snapMargin;\n\n    if (rect.top < screentop) {\n      result.scrollTop = atTop ? 0 : rect.top;\n    } else if (rect.bottom > screentop + screen) {\n      var newTop = Math.min(rect.top, (atBottom ? docBottom : rect.bottom) - screen);\n\n      if (newTop != screentop) {\n        result.scrollTop = newTop;\n      }\n    }\n\n    var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft;\n    var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0);\n    var tooWide = rect.right - rect.left > screenw;\n\n    if (tooWide) {\n      rect.right = rect.left + screenw;\n    }\n\n    if (rect.left < 10) {\n      result.scrollLeft = 0;\n    } else if (rect.left < screenleft) {\n      result.scrollLeft = Math.max(0, rect.left - (tooWide ? 0 : 10));\n    } else if (rect.right > screenw + screenleft - 3) {\n      result.scrollLeft = rect.right + (tooWide ? 0 : 10) - screenw;\n    }\n\n    return result;\n  } // Store a relative adjustment to the scroll position in the current\n  // operation (to be applied when the operation finishes).\n\n\n  function addToScrollTop(cm, top) {\n    if (top == null) {\n      return;\n    }\n\n    resolveScrollToPos(cm);\n    cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top;\n  } // Make sure that at the end of the operation the current cursor is\n  // shown.\n\n\n  function ensureCursorVisible(cm) {\n    resolveScrollToPos(cm);\n    var cur = cm.getCursor();\n    cm.curOp.scrollToPos = {\n      from: cur,\n      to: cur,\n      margin: cm.options.cursorScrollMargin\n    };\n  }\n\n  function scrollToCoords(cm, x, y) {\n    if (x != null || y != null) {\n      resolveScrollToPos(cm);\n    }\n\n    if (x != null) {\n      cm.curOp.scrollLeft = x;\n    }\n\n    if (y != null) {\n      cm.curOp.scrollTop = y;\n    }\n  }\n\n  function scrollToRange(cm, range) {\n    resolveScrollToPos(cm);\n    cm.curOp.scrollToPos = range;\n  } // When an operation has its scrollToPos property set, and another\n  // scroll action is applied before the end of the operation, this\n  // 'simulates' scrolling that position into view in a cheap way, so\n  // that the effect of intermediate scroll commands is not ignored.\n\n\n  function resolveScrollToPos(cm) {\n    var range = cm.curOp.scrollToPos;\n\n    if (range) {\n      cm.curOp.scrollToPos = null;\n      var from = estimateCoords(cm, range.from),\n          to = estimateCoords(cm, range.to);\n      scrollToCoordsRange(cm, from, to, range.margin);\n    }\n  }\n\n  function scrollToCoordsRange(cm, from, to, margin) {\n    var sPos = calculateScrollPos(cm, {\n      left: Math.min(from.left, to.left),\n      top: Math.min(from.top, to.top) - margin,\n      right: Math.max(from.right, to.right),\n      bottom: Math.max(from.bottom, to.bottom) + margin\n    });\n    scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop);\n  } // Sync the scrollable area and scrollbars, ensure the viewport\n  // covers the visible area.\n\n\n  function updateScrollTop(cm, val) {\n    if (Math.abs(cm.doc.scrollTop - val) < 2) {\n      return;\n    }\n\n    if (!gecko) {\n      updateDisplaySimple(cm, {\n        top: val\n      });\n    }\n\n    setScrollTop(cm, val, true);\n\n    if (gecko) {\n      updateDisplaySimple(cm);\n    }\n\n    startWorker(cm, 100);\n  }\n\n  function setScrollTop(cm, val, forceScroll) {\n    val = Math.max(0, Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight, val));\n\n    if (cm.display.scroller.scrollTop == val && !forceScroll) {\n      return;\n    }\n\n    cm.doc.scrollTop = val;\n    cm.display.scrollbars.setScrollTop(val);\n\n    if (cm.display.scroller.scrollTop != val) {\n      cm.display.scroller.scrollTop = val;\n    }\n  } // Sync scroller and scrollbar, ensure the gutter elements are\n  // aligned.\n\n\n  function setScrollLeft(cm, val, isScroller, forceScroll) {\n    val = Math.max(0, Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth));\n\n    if ((isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) && !forceScroll) {\n      return;\n    }\n\n    cm.doc.scrollLeft = val;\n    alignHorizontally(cm);\n\n    if (cm.display.scroller.scrollLeft != val) {\n      cm.display.scroller.scrollLeft = val;\n    }\n\n    cm.display.scrollbars.setScrollLeft(val);\n  } // SCROLLBARS\n  // Prepare DOM reads needed to update the scrollbars. Done in one\n  // shot to minimize update/measure roundtrips.\n\n\n  function measureForScrollbars(cm) {\n    var d = cm.display,\n        gutterW = d.gutters.offsetWidth;\n    var docH = Math.round(cm.doc.height + paddingVert(cm.display));\n    return {\n      clientHeight: d.scroller.clientHeight,\n      viewHeight: d.wrapper.clientHeight,\n      scrollWidth: d.scroller.scrollWidth,\n      clientWidth: d.scroller.clientWidth,\n      viewWidth: d.wrapper.clientWidth,\n      barLeft: cm.options.fixedGutter ? gutterW : 0,\n      docHeight: docH,\n      scrollHeight: docH + scrollGap(cm) + d.barHeight,\n      nativeBarWidth: d.nativeBarWidth,\n      gutterWidth: gutterW\n    };\n  }\n\n  var NativeScrollbars = function (place, scroll, cm) {\n    this.cm = cm;\n    var vert = this.vert = elt(\"div\", [elt(\"div\", null, null, \"min-width: 1px\")], \"CodeMirror-vscrollbar\");\n    var horiz = this.horiz = elt(\"div\", [elt(\"div\", null, null, \"height: 100%; min-height: 1px\")], \"CodeMirror-hscrollbar\");\n    vert.tabIndex = horiz.tabIndex = -1;\n    place(vert);\n    place(horiz);\n    on(vert, \"scroll\", function () {\n      if (vert.clientHeight) {\n        scroll(vert.scrollTop, \"vertical\");\n      }\n    });\n    on(horiz, \"scroll\", function () {\n      if (horiz.clientWidth) {\n        scroll(horiz.scrollLeft, \"horizontal\");\n      }\n    });\n    this.checkedZeroWidth = false; // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).\n\n    if (ie && ie_version < 8) {\n      this.horiz.style.minHeight = this.vert.style.minWidth = \"18px\";\n    }\n  };\n\n  NativeScrollbars.prototype.update = function (measure) {\n    var needsH = measure.scrollWidth > measure.clientWidth + 1;\n    var needsV = measure.scrollHeight > measure.clientHeight + 1;\n    var sWidth = measure.nativeBarWidth;\n\n    if (needsV) {\n      this.vert.style.display = \"block\";\n      this.vert.style.bottom = needsH ? sWidth + \"px\" : \"0\";\n      var totalHeight = measure.viewHeight - (needsH ? sWidth : 0); // A bug in IE8 can cause this value to be negative, so guard it.\n\n      this.vert.firstChild.style.height = Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + \"px\";\n    } else {\n      this.vert.style.display = \"\";\n      this.vert.firstChild.style.height = \"0\";\n    }\n\n    if (needsH) {\n      this.horiz.style.display = \"block\";\n      this.horiz.style.right = needsV ? sWidth + \"px\" : \"0\";\n      this.horiz.style.left = measure.barLeft + \"px\";\n      var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0);\n      this.horiz.firstChild.style.width = Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + \"px\";\n    } else {\n      this.horiz.style.display = \"\";\n      this.horiz.firstChild.style.width = \"0\";\n    }\n\n    if (!this.checkedZeroWidth && measure.clientHeight > 0) {\n      if (sWidth == 0) {\n        this.zeroWidthHack();\n      }\n\n      this.checkedZeroWidth = true;\n    }\n\n    return {\n      right: needsV ? sWidth : 0,\n      bottom: needsH ? sWidth : 0\n    };\n  };\n\n  NativeScrollbars.prototype.setScrollLeft = function (pos) {\n    if (this.horiz.scrollLeft != pos) {\n      this.horiz.scrollLeft = pos;\n    }\n\n    if (this.disableHoriz) {\n      this.enableZeroWidthBar(this.horiz, this.disableHoriz, \"horiz\");\n    }\n  };\n\n  NativeScrollbars.prototype.setScrollTop = function (pos) {\n    if (this.vert.scrollTop != pos) {\n      this.vert.scrollTop = pos;\n    }\n\n    if (this.disableVert) {\n      this.enableZeroWidthBar(this.vert, this.disableVert, \"vert\");\n    }\n  };\n\n  NativeScrollbars.prototype.zeroWidthHack = function () {\n    var w = mac && !mac_geMountainLion ? \"12px\" : \"18px\";\n    this.horiz.style.height = this.vert.style.width = w;\n    this.horiz.style.pointerEvents = this.vert.style.pointerEvents = \"none\";\n    this.disableHoriz = new Delayed();\n    this.disableVert = new Delayed();\n  };\n\n  NativeScrollbars.prototype.enableZeroWidthBar = function (bar, delay, type) {\n    bar.style.pointerEvents = \"auto\";\n\n    function maybeDisable() {\n      // To find out whether the scrollbar is still visible, we\n      // check whether the element under the pixel in the bottom\n      // right corner of the scrollbar box is the scrollbar box\n      // itself (when the bar is still visible) or its filler child\n      // (when the bar is hidden). If it is still visible, we keep\n      // it enabled, if it's hidden, we disable pointer events.\n      var box = bar.getBoundingClientRect();\n      var elt = type == \"vert\" ? document.elementFromPoint(box.right - 1, (box.top + box.bottom) / 2) : document.elementFromPoint((box.right + box.left) / 2, box.bottom - 1);\n\n      if (elt != bar) {\n        bar.style.pointerEvents = \"none\";\n      } else {\n        delay.set(1000, maybeDisable);\n      }\n    }\n\n    delay.set(1000, maybeDisable);\n  };\n\n  NativeScrollbars.prototype.clear = function () {\n    var parent = this.horiz.parentNode;\n    parent.removeChild(this.horiz);\n    parent.removeChild(this.vert);\n  };\n\n  var NullScrollbars = function () {};\n\n  NullScrollbars.prototype.update = function () {\n    return {\n      bottom: 0,\n      right: 0\n    };\n  };\n\n  NullScrollbars.prototype.setScrollLeft = function () {};\n\n  NullScrollbars.prototype.setScrollTop = function () {};\n\n  NullScrollbars.prototype.clear = function () {};\n\n  function updateScrollbars(cm, measure) {\n    if (!measure) {\n      measure = measureForScrollbars(cm);\n    }\n\n    var startWidth = cm.display.barWidth,\n        startHeight = cm.display.barHeight;\n    updateScrollbarsInner(cm, measure);\n\n    for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {\n      if (startWidth != cm.display.barWidth && cm.options.lineWrapping) {\n        updateHeightsInViewport(cm);\n      }\n\n      updateScrollbarsInner(cm, measureForScrollbars(cm));\n      startWidth = cm.display.barWidth;\n      startHeight = cm.display.barHeight;\n    }\n  } // Re-synchronize the fake scrollbars with the actual size of the\n  // content.\n\n\n  function updateScrollbarsInner(cm, measure) {\n    var d = cm.display;\n    var sizes = d.scrollbars.update(measure);\n    d.sizer.style.paddingRight = (d.barWidth = sizes.right) + \"px\";\n    d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + \"px\";\n    d.heightForcer.style.borderBottom = sizes.bottom + \"px solid transparent\";\n\n    if (sizes.right && sizes.bottom) {\n      d.scrollbarFiller.style.display = \"block\";\n      d.scrollbarFiller.style.height = sizes.bottom + \"px\";\n      d.scrollbarFiller.style.width = sizes.right + \"px\";\n    } else {\n      d.scrollbarFiller.style.display = \"\";\n    }\n\n    if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {\n      d.gutterFiller.style.display = \"block\";\n      d.gutterFiller.style.height = sizes.bottom + \"px\";\n      d.gutterFiller.style.width = measure.gutterWidth + \"px\";\n    } else {\n      d.gutterFiller.style.display = \"\";\n    }\n  }\n\n  var scrollbarModel = {\n    \"native\": NativeScrollbars,\n    \"null\": NullScrollbars\n  };\n\n  function initScrollbars(cm) {\n    if (cm.display.scrollbars) {\n      cm.display.scrollbars.clear();\n\n      if (cm.display.scrollbars.addClass) {\n        rmClass(cm.display.wrapper, cm.display.scrollbars.addClass);\n      }\n    }\n\n    cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) {\n      cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller); // Prevent clicks in the scrollbars from killing focus\n\n      on(node, \"mousedown\", function () {\n        if (cm.state.focused) {\n          setTimeout(function () {\n            return cm.display.input.focus();\n          }, 0);\n        }\n      });\n      node.setAttribute(\"cm-not-content\", \"true\");\n    }, function (pos, axis) {\n      if (axis == \"horizontal\") {\n        setScrollLeft(cm, pos);\n      } else {\n        updateScrollTop(cm, pos);\n      }\n    }, cm);\n\n    if (cm.display.scrollbars.addClass) {\n      addClass(cm.display.wrapper, cm.display.scrollbars.addClass);\n    }\n  } // Operations are used to wrap a series of changes to the editor\n  // state in such a way that each change won't have to update the\n  // cursor and display (which would be awkward, slow, and\n  // error-prone). Instead, display updates are batched and then all\n  // combined and executed at once.\n\n\n  var nextOpId = 0; // Start a new operation.\n\n  function startOperation(cm) {\n    cm.curOp = {\n      cm: cm,\n      viewChanged: false,\n      // Flag that indicates that lines might need to be redrawn\n      startHeight: cm.doc.height,\n      // Used to detect need to update scrollbar\n      forceUpdate: false,\n      // Used to force a redraw\n      updateInput: 0,\n      // Whether to reset the input textarea\n      typing: false,\n      // Whether this reset should be careful to leave existing text (for compositing)\n      changeObjs: null,\n      // Accumulated changes, for firing change events\n      cursorActivityHandlers: null,\n      // Set of handlers to fire cursorActivity on\n      cursorActivityCalled: 0,\n      // Tracks which cursorActivity handlers have been called already\n      selectionChanged: false,\n      // Whether the selection needs to be redrawn\n      updateMaxLine: false,\n      // Set when the widest line needs to be determined anew\n      scrollLeft: null,\n      scrollTop: null,\n      // Intermediate scroll position, not pushed to DOM yet\n      scrollToPos: null,\n      // Used to scroll to a specific position\n      focus: false,\n      id: ++nextOpId // Unique ID\n\n    };\n    pushOperation(cm.curOp);\n  } // Finish an operation, updating the display and signalling delayed events\n\n\n  function endOperation(cm) {\n    var op = cm.curOp;\n\n    if (op) {\n      finishOperation(op, function (group) {\n        for (var i = 0; i < group.ops.length; i++) {\n          group.ops[i].cm.curOp = null;\n        }\n\n        endOperations(group);\n      });\n    }\n  } // The DOM updates done when an operation finishes are batched so\n  // that the minimum number of relayouts are required.\n\n\n  function endOperations(group) {\n    var ops = group.ops;\n\n    for (var i = 0; i < ops.length; i++) // Read DOM\n    {\n      endOperation_R1(ops[i]);\n    }\n\n    for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe)\n    {\n      endOperation_W1(ops[i$1]);\n    }\n\n    for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM\n    {\n      endOperation_R2(ops[i$2]);\n    }\n\n    for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe)\n    {\n      endOperation_W2(ops[i$3]);\n    }\n\n    for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM\n    {\n      endOperation_finish(ops[i$4]);\n    }\n  }\n\n  function endOperation_R1(op) {\n    var cm = op.cm,\n        display = cm.display;\n    maybeClipScrollbars(cm);\n\n    if (op.updateMaxLine) {\n      findMaxLine(cm);\n    }\n\n    op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null || op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom || op.scrollToPos.to.line >= display.viewTo) || display.maxLineChanged && cm.options.lineWrapping;\n    op.update = op.mustUpdate && new DisplayUpdate(cm, op.mustUpdate && {\n      top: op.scrollTop,\n      ensure: op.scrollToPos\n    }, op.forceUpdate);\n  }\n\n  function endOperation_W1(op) {\n    op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update);\n  }\n\n  function endOperation_R2(op) {\n    var cm = op.cm,\n        display = cm.display;\n\n    if (op.updatedDisplay) {\n      updateHeightsInViewport(cm);\n    }\n\n    op.barMeasure = measureForScrollbars(cm); // If the max line changed since it was last measured, measure it,\n    // and ensure the document's width matches it.\n    // updateDisplay_W2 will use these properties to do the actual resizing\n\n    if (display.maxLineChanged && !cm.options.lineWrapping) {\n      op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3;\n      cm.display.sizerWidth = op.adjustWidthTo;\n      op.barMeasure.scrollWidth = Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth);\n      op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm));\n    }\n\n    if (op.updatedDisplay || op.selectionChanged) {\n      op.preparedSelection = display.input.prepareSelection();\n    }\n  }\n\n  function endOperation_W2(op) {\n    var cm = op.cm;\n\n    if (op.adjustWidthTo != null) {\n      cm.display.sizer.style.minWidth = op.adjustWidthTo + \"px\";\n\n      if (op.maxScrollLeft < cm.doc.scrollLeft) {\n        setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true);\n      }\n\n      cm.display.maxLineChanged = false;\n    }\n\n    var takeFocus = op.focus && op.focus == activeElt();\n\n    if (op.preparedSelection) {\n      cm.display.input.showSelection(op.preparedSelection, takeFocus);\n    }\n\n    if (op.updatedDisplay || op.startHeight != cm.doc.height) {\n      updateScrollbars(cm, op.barMeasure);\n    }\n\n    if (op.updatedDisplay) {\n      setDocumentHeight(cm, op.barMeasure);\n    }\n\n    if (op.selectionChanged) {\n      restartBlink(cm);\n    }\n\n    if (cm.state.focused && op.updateInput) {\n      cm.display.input.reset(op.typing);\n    }\n\n    if (takeFocus) {\n      ensureFocus(op.cm);\n    }\n  }\n\n  function endOperation_finish(op) {\n    var cm = op.cm,\n        display = cm.display,\n        doc = cm.doc;\n\n    if (op.updatedDisplay) {\n      postUpdateDisplay(cm, op.update);\n    } // Abort mouse wheel delta measurement, when scrolling explicitly\n\n\n    if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos)) {\n      display.wheelStartX = display.wheelStartY = null;\n    } // Propagate the scroll position to the actual DOM scroller\n\n\n    if (op.scrollTop != null) {\n      setScrollTop(cm, op.scrollTop, op.forceScroll);\n    }\n\n    if (op.scrollLeft != null) {\n      setScrollLeft(cm, op.scrollLeft, true, true);\n    } // If we need to scroll a specific position into view, do so.\n\n\n    if (op.scrollToPos) {\n      var rect = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from), clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin);\n      maybeScrollWindow(cm, rect);\n    } // Fire events for markers that are hidden/unidden by editing or\n    // undoing\n\n\n    var hidden = op.maybeHiddenMarkers,\n        unhidden = op.maybeUnhiddenMarkers;\n\n    if (hidden) {\n      for (var i = 0; i < hidden.length; ++i) {\n        if (!hidden[i].lines.length) {\n          signal(hidden[i], \"hide\");\n        }\n      }\n    }\n\n    if (unhidden) {\n      for (var i$1 = 0; i$1 < unhidden.length; ++i$1) {\n        if (unhidden[i$1].lines.length) {\n          signal(unhidden[i$1], \"unhide\");\n        }\n      }\n    }\n\n    if (display.wrapper.offsetHeight) {\n      doc.scrollTop = cm.display.scroller.scrollTop;\n    } // Fire change events, and delayed event handlers\n\n\n    if (op.changeObjs) {\n      signal(cm, \"changes\", cm, op.changeObjs);\n    }\n\n    if (op.update) {\n      op.update.finish();\n    }\n  } // Run the given function in an operation\n\n\n  function runInOp(cm, f) {\n    if (cm.curOp) {\n      return f();\n    }\n\n    startOperation(cm);\n\n    try {\n      return f();\n    } finally {\n      endOperation(cm);\n    }\n  } // Wraps a function in an operation. Returns the wrapped function.\n\n\n  function operation(cm, f) {\n    return function () {\n      if (cm.curOp) {\n        return f.apply(cm, arguments);\n      }\n\n      startOperation(cm);\n\n      try {\n        return f.apply(cm, arguments);\n      } finally {\n        endOperation(cm);\n      }\n    };\n  } // Used to add methods to editor and doc instances, wrapping them in\n  // operations.\n\n\n  function methodOp(f) {\n    return function () {\n      if (this.curOp) {\n        return f.apply(this, arguments);\n      }\n\n      startOperation(this);\n\n      try {\n        return f.apply(this, arguments);\n      } finally {\n        endOperation(this);\n      }\n    };\n  }\n\n  function docMethodOp(f) {\n    return function () {\n      var cm = this.cm;\n\n      if (!cm || cm.curOp) {\n        return f.apply(this, arguments);\n      }\n\n      startOperation(cm);\n\n      try {\n        return f.apply(this, arguments);\n      } finally {\n        endOperation(cm);\n      }\n    };\n  } // HIGHLIGHT WORKER\n\n\n  function startWorker(cm, time) {\n    if (cm.doc.highlightFrontier < cm.display.viewTo) {\n      cm.state.highlight.set(time, bind(highlightWorker, cm));\n    }\n  }\n\n  function highlightWorker(cm) {\n    var doc = cm.doc;\n\n    if (doc.highlightFrontier >= cm.display.viewTo) {\n      return;\n    }\n\n    var end = +new Date() + cm.options.workTime;\n    var context = getContextBefore(cm, doc.highlightFrontier);\n    var changedLines = [];\n    doc.iter(context.line, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) {\n      if (context.line >= cm.display.viewFrom) {\n        // Visible\n        var oldStyles = line.styles;\n        var resetState = line.text.length > cm.options.maxHighlightLength ? copyState(doc.mode, context.state) : null;\n        var highlighted = highlightLine(cm, line, context, true);\n\n        if (resetState) {\n          context.state = resetState;\n        }\n\n        line.styles = highlighted.styles;\n        var oldCls = line.styleClasses,\n            newCls = highlighted.classes;\n\n        if (newCls) {\n          line.styleClasses = newCls;\n        } else if (oldCls) {\n          line.styleClasses = null;\n        }\n\n        var ischange = !oldStyles || oldStyles.length != line.styles.length || oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass);\n\n        for (var i = 0; !ischange && i < oldStyles.length; ++i) {\n          ischange = oldStyles[i] != line.styles[i];\n        }\n\n        if (ischange) {\n          changedLines.push(context.line);\n        }\n\n        line.stateAfter = context.save();\n        context.nextLine();\n      } else {\n        if (line.text.length <= cm.options.maxHighlightLength) {\n          processLine(cm, line.text, context);\n        }\n\n        line.stateAfter = context.line % 5 == 0 ? context.save() : null;\n        context.nextLine();\n      }\n\n      if (+new Date() > end) {\n        startWorker(cm, cm.options.workDelay);\n        return true;\n      }\n    });\n    doc.highlightFrontier = context.line;\n    doc.modeFrontier = Math.max(doc.modeFrontier, context.line);\n\n    if (changedLines.length) {\n      runInOp(cm, function () {\n        for (var i = 0; i < changedLines.length; i++) {\n          regLineChange(cm, changedLines[i], \"text\");\n        }\n      });\n    }\n  } // DISPLAY DRAWING\n\n\n  var DisplayUpdate = function (cm, viewport, force) {\n    var display = cm.display;\n    this.viewport = viewport; // Store some values that we'll need later (but don't want to force a relayout for)\n\n    this.visible = visibleLines(display, cm.doc, viewport);\n    this.editorIsHidden = !display.wrapper.offsetWidth;\n    this.wrapperHeight = display.wrapper.clientHeight;\n    this.wrapperWidth = display.wrapper.clientWidth;\n    this.oldDisplayWidth = displayWidth(cm);\n    this.force = force;\n    this.dims = getDimensions(cm);\n    this.events = [];\n  };\n\n  DisplayUpdate.prototype.signal = function (emitter, type) {\n    if (hasHandler(emitter, type)) {\n      this.events.push(arguments);\n    }\n  };\n\n  DisplayUpdate.prototype.finish = function () {\n    for (var i = 0; i < this.events.length; i++) {\n      signal.apply(null, this.events[i]);\n    }\n  };\n\n  function maybeClipScrollbars(cm) {\n    var display = cm.display;\n\n    if (!display.scrollbarsClipped && display.scroller.offsetWidth) {\n      display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth;\n      display.heightForcer.style.height = scrollGap(cm) + \"px\";\n      display.sizer.style.marginBottom = -display.nativeBarWidth + \"px\";\n      display.sizer.style.borderRightWidth = scrollGap(cm) + \"px\";\n      display.scrollbarsClipped = true;\n    }\n  }\n\n  function selectionSnapshot(cm) {\n    if (cm.hasFocus()) {\n      return null;\n    }\n\n    var active = activeElt();\n\n    if (!active || !contains(cm.display.lineDiv, active)) {\n      return null;\n    }\n\n    var result = {\n      activeElt: active\n    };\n\n    if (window.getSelection) {\n      var sel = window.getSelection();\n\n      if (sel.anchorNode && sel.extend && contains(cm.display.lineDiv, sel.anchorNode)) {\n        result.anchorNode = sel.anchorNode;\n        result.anchorOffset = sel.anchorOffset;\n        result.focusNode = sel.focusNode;\n        result.focusOffset = sel.focusOffset;\n      }\n    }\n\n    return result;\n  }\n\n  function restoreSelection(snapshot) {\n    if (!snapshot || !snapshot.activeElt || snapshot.activeElt == activeElt()) {\n      return;\n    }\n\n    snapshot.activeElt.focus();\n\n    if (!/^(INPUT|TEXTAREA)$/.test(snapshot.activeElt.nodeName) && snapshot.anchorNode && contains(document.body, snapshot.anchorNode) && contains(document.body, snapshot.focusNode)) {\n      var sel = window.getSelection(),\n          range = document.createRange();\n      range.setEnd(snapshot.anchorNode, snapshot.anchorOffset);\n      range.collapse(false);\n      sel.removeAllRanges();\n      sel.addRange(range);\n      sel.extend(snapshot.focusNode, snapshot.focusOffset);\n    }\n  } // Does the actual updating of the line display. Bails out\n  // (returning false) when there is nothing to be done and forced is\n  // false.\n\n\n  function updateDisplayIfNeeded(cm, update) {\n    var display = cm.display,\n        doc = cm.doc;\n\n    if (update.editorIsHidden) {\n      resetView(cm);\n      return false;\n    } // Bail out if the visible area is already rendered and nothing changed.\n\n\n    if (!update.force && update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo && (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) && display.renderedView == display.view && countDirtyView(cm) == 0) {\n      return false;\n    }\n\n    if (maybeUpdateLineNumberWidth(cm)) {\n      resetView(cm);\n      update.dims = getDimensions(cm);\n    } // Compute a suitable new viewport (from & to)\n\n\n    var end = doc.first + doc.size;\n    var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first);\n    var to = Math.min(end, update.visible.to + cm.options.viewportMargin);\n\n    if (display.viewFrom < from && from - display.viewFrom < 20) {\n      from = Math.max(doc.first, display.viewFrom);\n    }\n\n    if (display.viewTo > to && display.viewTo - to < 20) {\n      to = Math.min(end, display.viewTo);\n    }\n\n    if (sawCollapsedSpans) {\n      from = visualLineNo(cm.doc, from);\n      to = visualLineEndNo(cm.doc, to);\n    }\n\n    var different = from != display.viewFrom || to != display.viewTo || display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth;\n    adjustView(cm, from, to);\n    display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom)); // Position the mover div to align with the current scroll position\n\n    cm.display.mover.style.top = display.viewOffset + \"px\";\n    var toUpdate = countDirtyView(cm);\n\n    if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view && (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo)) {\n      return false;\n    } // For big changes, we hide the enclosing element during the\n    // update, since that speeds up the operations on most browsers.\n\n\n    var selSnapshot = selectionSnapshot(cm);\n\n    if (toUpdate > 4) {\n      display.lineDiv.style.display = \"none\";\n    }\n\n    patchDisplay(cm, display.updateLineNumbers, update.dims);\n\n    if (toUpdate > 4) {\n      display.lineDiv.style.display = \"\";\n    }\n\n    display.renderedView = display.view; // There might have been a widget with a focused element that got\n    // hidden or updated, if so re-focus it.\n\n    restoreSelection(selSnapshot); // Prevent selection and cursors from interfering with the scroll\n    // width and height.\n\n    removeChildren(display.cursorDiv);\n    removeChildren(display.selectionDiv);\n    display.gutters.style.height = display.sizer.style.minHeight = 0;\n\n    if (different) {\n      display.lastWrapHeight = update.wrapperHeight;\n      display.lastWrapWidth = update.wrapperWidth;\n      startWorker(cm, 400);\n    }\n\n    display.updateLineNumbers = null;\n    return true;\n  }\n\n  function postUpdateDisplay(cm, update) {\n    var viewport = update.viewport;\n\n    for (var first = true;; first = false) {\n      if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {\n        // Clip forced viewport to actual scrollable area.\n        if (viewport && viewport.top != null) {\n          viewport = {\n            top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)\n          };\n        } // Updated line heights might result in the drawn area not\n        // actually covering the viewport. Keep looping until it does.\n\n\n        update.visible = visibleLines(cm.display, cm.doc, viewport);\n\n        if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo) {\n          break;\n        }\n      } else if (first) {\n        update.visible = visibleLines(cm.display, cm.doc, viewport);\n      }\n\n      if (!updateDisplayIfNeeded(cm, update)) {\n        break;\n      }\n\n      updateHeightsInViewport(cm);\n      var barMeasure = measureForScrollbars(cm);\n      updateSelection(cm);\n      updateScrollbars(cm, barMeasure);\n      setDocumentHeight(cm, barMeasure);\n      update.force = false;\n    }\n\n    update.signal(cm, \"update\", cm);\n\n    if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {\n      update.signal(cm, \"viewportChange\", cm, cm.display.viewFrom, cm.display.viewTo);\n      cm.display.reportedViewFrom = cm.display.viewFrom;\n      cm.display.reportedViewTo = cm.display.viewTo;\n    }\n  }\n\n  function updateDisplaySimple(cm, viewport) {\n    var update = new DisplayUpdate(cm, viewport);\n\n    if (updateDisplayIfNeeded(cm, update)) {\n      updateHeightsInViewport(cm);\n      postUpdateDisplay(cm, update);\n      var barMeasure = measureForScrollbars(cm);\n      updateSelection(cm);\n      updateScrollbars(cm, barMeasure);\n      setDocumentHeight(cm, barMeasure);\n      update.finish();\n    }\n  } // Sync the actual display DOM structure with display.view, removing\n  // nodes for lines that are no longer in view, and creating the ones\n  // that are not there yet, and updating the ones that are out of\n  // date.\n\n\n  function patchDisplay(cm, updateNumbersFrom, dims) {\n    var display = cm.display,\n        lineNumbers = cm.options.lineNumbers;\n    var container = display.lineDiv,\n        cur = container.firstChild;\n\n    function rm(node) {\n      var next = node.nextSibling; // Works around a throw-scroll bug in OS X Webkit\n\n      if (webkit && mac && cm.display.currentWheelTarget == node) {\n        node.style.display = \"none\";\n      } else {\n        node.parentNode.removeChild(node);\n      }\n\n      return next;\n    }\n\n    var view = display.view,\n        lineN = display.viewFrom; // Loop over the elements in the view, syncing cur (the DOM nodes\n    // in display.lineDiv) with the view as we go.\n\n    for (var i = 0; i < view.length; i++) {\n      var lineView = view[i];\n      if (lineView.hidden) ;else if (!lineView.node || lineView.node.parentNode != container) {\n        // Not drawn yet\n        var node = buildLineElement(cm, lineView, lineN, dims);\n        container.insertBefore(node, cur);\n      } else {\n        // Already drawn\n        while (cur != lineView.node) {\n          cur = rm(cur);\n        }\n\n        var updateNumber = lineNumbers && updateNumbersFrom != null && updateNumbersFrom <= lineN && lineView.lineNumber;\n\n        if (lineView.changes) {\n          if (indexOf(lineView.changes, \"gutter\") > -1) {\n            updateNumber = false;\n          }\n\n          updateLineForChanges(cm, lineView, lineN, dims);\n        }\n\n        if (updateNumber) {\n          removeChildren(lineView.lineNumber);\n          lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)));\n        }\n\n        cur = lineView.node.nextSibling;\n      }\n      lineN += lineView.size;\n    }\n\n    while (cur) {\n      cur = rm(cur);\n    }\n  }\n\n  function updateGutterSpace(display) {\n    var width = display.gutters.offsetWidth;\n    display.sizer.style.marginLeft = width + \"px\";\n  }\n\n  function setDocumentHeight(cm, measure) {\n    cm.display.sizer.style.minHeight = measure.docHeight + \"px\";\n    cm.display.heightForcer.style.top = measure.docHeight + \"px\";\n    cm.display.gutters.style.height = measure.docHeight + cm.display.barHeight + scrollGap(cm) + \"px\";\n  } // Re-align line numbers and gutter marks to compensate for\n  // horizontal scrolling.\n\n\n  function alignHorizontally(cm) {\n    var display = cm.display,\n        view = display.view;\n\n    if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) {\n      return;\n    }\n\n    var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft;\n    var gutterW = display.gutters.offsetWidth,\n        left = comp + \"px\";\n\n    for (var i = 0; i < view.length; i++) {\n      if (!view[i].hidden) {\n        if (cm.options.fixedGutter) {\n          if (view[i].gutter) {\n            view[i].gutter.style.left = left;\n          }\n\n          if (view[i].gutterBackground) {\n            view[i].gutterBackground.style.left = left;\n          }\n        }\n\n        var align = view[i].alignable;\n\n        if (align) {\n          for (var j = 0; j < align.length; j++) {\n            align[j].style.left = left;\n          }\n        }\n      }\n    }\n\n    if (cm.options.fixedGutter) {\n      display.gutters.style.left = comp + gutterW + \"px\";\n    }\n  } // Used to ensure that the line number gutter is still the right\n  // size for the current document size. Returns true when an update\n  // is needed.\n\n\n  function maybeUpdateLineNumberWidth(cm) {\n    if (!cm.options.lineNumbers) {\n      return false;\n    }\n\n    var doc = cm.doc,\n        last = lineNumberFor(cm.options, doc.first + doc.size - 1),\n        display = cm.display;\n\n    if (last.length != display.lineNumChars) {\n      var test = display.measure.appendChild(elt(\"div\", [elt(\"div\", last)], \"CodeMirror-linenumber CodeMirror-gutter-elt\"));\n      var innerW = test.firstChild.offsetWidth,\n          padding = test.offsetWidth - innerW;\n      display.lineGutter.style.width = \"\";\n      display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1;\n      display.lineNumWidth = display.lineNumInnerWidth + padding;\n      display.lineNumChars = display.lineNumInnerWidth ? last.length : -1;\n      display.lineGutter.style.width = display.lineNumWidth + \"px\";\n      updateGutterSpace(cm.display);\n      return true;\n    }\n\n    return false;\n  }\n\n  function getGutters(gutters, lineNumbers) {\n    var result = [],\n        sawLineNumbers = false;\n\n    for (var i = 0; i < gutters.length; i++) {\n      var name = gutters[i],\n          style = null;\n\n      if (typeof name != \"string\") {\n        style = name.style;\n        name = name.className;\n      }\n\n      if (name == \"CodeMirror-linenumbers\") {\n        if (!lineNumbers) {\n          continue;\n        } else {\n          sawLineNumbers = true;\n        }\n      }\n\n      result.push({\n        className: name,\n        style: style\n      });\n    }\n\n    if (lineNumbers && !sawLineNumbers) {\n      result.push({\n        className: \"CodeMirror-linenumbers\",\n        style: null\n      });\n    }\n\n    return result;\n  } // Rebuild the gutter elements, ensure the margin to the left of the\n  // code matches their width.\n\n\n  function renderGutters(display) {\n    var gutters = display.gutters,\n        specs = display.gutterSpecs;\n    removeChildren(gutters);\n    display.lineGutter = null;\n\n    for (var i = 0; i < specs.length; ++i) {\n      var ref = specs[i];\n      var className = ref.className;\n      var style = ref.style;\n      var gElt = gutters.appendChild(elt(\"div\", null, \"CodeMirror-gutter \" + className));\n\n      if (style) {\n        gElt.style.cssText = style;\n      }\n\n      if (className == \"CodeMirror-linenumbers\") {\n        display.lineGutter = gElt;\n        gElt.style.width = (display.lineNumWidth || 1) + \"px\";\n      }\n    }\n\n    gutters.style.display = specs.length ? \"\" : \"none\";\n    updateGutterSpace(display);\n  }\n\n  function updateGutters(cm) {\n    renderGutters(cm.display);\n    regChange(cm);\n    alignHorizontally(cm);\n  } // The display handles the DOM integration, both for input reading\n  // and content drawing. It holds references to DOM nodes and\n  // display-related state.\n\n\n  function Display(place, doc, input, options) {\n    var d = this;\n    this.input = input; // Covers bottom-right square when both scrollbars are present.\n\n    d.scrollbarFiller = elt(\"div\", null, \"CodeMirror-scrollbar-filler\");\n    d.scrollbarFiller.setAttribute(\"cm-not-content\", \"true\"); // Covers bottom of gutter when coverGutterNextToScrollbar is on\n    // and h scrollbar is present.\n\n    d.gutterFiller = elt(\"div\", null, \"CodeMirror-gutter-filler\");\n    d.gutterFiller.setAttribute(\"cm-not-content\", \"true\"); // Will contain the actual code, positioned to cover the viewport.\n\n    d.lineDiv = eltP(\"div\", null, \"CodeMirror-code\"); // Elements are added to these to represent selection and cursors.\n\n    d.selectionDiv = elt(\"div\", null, null, \"position: relative; z-index: 1\");\n    d.cursorDiv = elt(\"div\", null, \"CodeMirror-cursors\"); // A visibility: hidden element used to find the size of things.\n\n    d.measure = elt(\"div\", null, \"CodeMirror-measure\"); // When lines outside of the viewport are measured, they are drawn in this.\n\n    d.lineMeasure = elt(\"div\", null, \"CodeMirror-measure\"); // Wraps everything that needs to exist inside the vertically-padded coordinate system\n\n    d.lineSpace = eltP(\"div\", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv], null, \"position: relative; outline: none\");\n    var lines = eltP(\"div\", [d.lineSpace], \"CodeMirror-lines\"); // Moved around its parent to cover visible view.\n\n    d.mover = elt(\"div\", [lines], null, \"position: relative\"); // Set to the height of the document, allowing scrolling.\n\n    d.sizer = elt(\"div\", [d.mover], \"CodeMirror-sizer\");\n    d.sizerWidth = null; // Behavior of elts with overflow: auto and padding is\n    // inconsistent across browsers. This is used to ensure the\n    // scrollable area is big enough.\n\n    d.heightForcer = elt(\"div\", null, null, \"position: absolute; height: \" + scrollerGap + \"px; width: 1px;\"); // Will contain the gutters, if any.\n\n    d.gutters = elt(\"div\", null, \"CodeMirror-gutters\");\n    d.lineGutter = null; // Actual scrollable element.\n\n    d.scroller = elt(\"div\", [d.sizer, d.heightForcer, d.gutters], \"CodeMirror-scroll\");\n    d.scroller.setAttribute(\"tabIndex\", \"-1\"); // The element in which the editor lives.\n\n    d.wrapper = elt(\"div\", [d.scrollbarFiller, d.gutterFiller, d.scroller], \"CodeMirror\"); // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)\n\n    if (ie && ie_version < 8) {\n      d.gutters.style.zIndex = -1;\n      d.scroller.style.paddingRight = 0;\n    }\n\n    if (!webkit && !(gecko && mobile)) {\n      d.scroller.draggable = true;\n    }\n\n    if (place) {\n      if (place.appendChild) {\n        place.appendChild(d.wrapper);\n      } else {\n        place(d.wrapper);\n      }\n    } // Current rendered range (may be bigger than the view window).\n\n\n    d.viewFrom = d.viewTo = doc.first;\n    d.reportedViewFrom = d.reportedViewTo = doc.first; // Information about the rendered lines.\n\n    d.view = [];\n    d.renderedView = null; // Holds info about a single rendered line when it was rendered\n    // for measurement, while not in view.\n\n    d.externalMeasured = null; // Empty space (in pixels) above the view\n\n    d.viewOffset = 0;\n    d.lastWrapHeight = d.lastWrapWidth = 0;\n    d.updateLineNumbers = null;\n    d.nativeBarWidth = d.barHeight = d.barWidth = 0;\n    d.scrollbarsClipped = false; // Used to only resize the line number gutter when necessary (when\n    // the amount of lines crosses a boundary that makes its width change)\n\n    d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null; // Set to true when a non-horizontal-scrolling line widget is\n    // added. As an optimization, line widget aligning is skipped when\n    // this is false.\n\n    d.alignWidgets = false;\n    d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null; // Tracks the maximum line length so that the horizontal scrollbar\n    // can be kept static when scrolling.\n\n    d.maxLine = null;\n    d.maxLineLength = 0;\n    d.maxLineChanged = false; // Used for measuring wheel scrolling granularity\n\n    d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null; // True when shift is held down.\n\n    d.shift = false; // Used to track whether anything happened since the context menu\n    // was opened.\n\n    d.selForContextMenu = null;\n    d.activeTouch = null;\n    d.gutterSpecs = getGutters(options.gutters, options.lineNumbers);\n    renderGutters(d);\n    input.init(d);\n  } // Since the delta values reported on mouse wheel events are\n  // unstandardized between browsers and even browser versions, and\n  // generally horribly unpredictable, this code starts by measuring\n  // the scroll effect that the first few mouse wheel events have,\n  // and, from that, detects the way it can convert deltas to pixel\n  // offsets afterwards.\n  //\n  // The reason we want to know the amount a wheel event will scroll\n  // is that it gives us a chance to update the display before the\n  // actual scrolling happens, reducing flickering.\n\n\n  var wheelSamples = 0,\n      wheelPixelsPerUnit = null; // Fill in a browser-detected starting value on browsers where we\n  // know one. These don't have to be accurate -- the result of them\n  // being wrong would just be a slight flicker on the first wheel\n  // scroll (if it is large enough).\n\n  if (ie) {\n    wheelPixelsPerUnit = -.53;\n  } else if (gecko) {\n    wheelPixelsPerUnit = 15;\n  } else if (chrome) {\n    wheelPixelsPerUnit = -.7;\n  } else if (safari) {\n    wheelPixelsPerUnit = -1 / 3;\n  }\n\n  function wheelEventDelta(e) {\n    var dx = e.wheelDeltaX,\n        dy = e.wheelDeltaY;\n\n    if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) {\n      dx = e.detail;\n    }\n\n    if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) {\n      dy = e.detail;\n    } else if (dy == null) {\n      dy = e.wheelDelta;\n    }\n\n    return {\n      x: dx,\n      y: dy\n    };\n  }\n\n  function wheelEventPixels(e) {\n    var delta = wheelEventDelta(e);\n    delta.x *= wheelPixelsPerUnit;\n    delta.y *= wheelPixelsPerUnit;\n    return delta;\n  }\n\n  function onScrollWheel(cm, e) {\n    var delta = wheelEventDelta(e),\n        dx = delta.x,\n        dy = delta.y;\n    var display = cm.display,\n        scroll = display.scroller; // Quit if there's nothing to scroll here\n\n    var canScrollX = scroll.scrollWidth > scroll.clientWidth;\n    var canScrollY = scroll.scrollHeight > scroll.clientHeight;\n\n    if (!(dx && canScrollX || dy && canScrollY)) {\n      return;\n    } // Webkit browsers on OS X abort momentum scrolls when the target\n    // of the scroll event is removed from the scrollable element.\n    // This hack (see related code in patchDisplay) makes sure the\n    // element is kept around.\n\n\n    if (dy && mac && webkit) {\n      outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {\n        for (var i = 0; i < view.length; i++) {\n          if (view[i].node == cur) {\n            cm.display.currentWheelTarget = cur;\n            break outer;\n          }\n        }\n      }\n    } // On some browsers, horizontal scrolling will cause redraws to\n    // happen before the gutter has been realigned, causing it to\n    // wriggle around in a most unseemly way. When we have an\n    // estimated pixels/delta value, we just handle horizontal\n    // scrolling entirely here. It'll be slightly off from native, but\n    // better than glitching out.\n\n\n    if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {\n      if (dy && canScrollY) {\n        updateScrollTop(cm, Math.max(0, scroll.scrollTop + dy * wheelPixelsPerUnit));\n      }\n\n      setScrollLeft(cm, Math.max(0, scroll.scrollLeft + dx * wheelPixelsPerUnit)); // Only prevent default scrolling if vertical scrolling is\n      // actually possible. Otherwise, it causes vertical scroll\n      // jitter on OSX trackpads when deltaX is small and deltaY\n      // is large (issue #3579)\n\n      if (!dy || dy && canScrollY) {\n        e_preventDefault(e);\n      }\n\n      display.wheelStartX = null; // Abort measurement, if in progress\n\n      return;\n    } // 'Project' the visible viewport to cover the area that is being\n    // scrolled into view (if we know enough to estimate it).\n\n\n    if (dy && wheelPixelsPerUnit != null) {\n      var pixels = dy * wheelPixelsPerUnit;\n      var top = cm.doc.scrollTop,\n          bot = top + display.wrapper.clientHeight;\n\n      if (pixels < 0) {\n        top = Math.max(0, top + pixels - 50);\n      } else {\n        bot = Math.min(cm.doc.height, bot + pixels + 50);\n      }\n\n      updateDisplaySimple(cm, {\n        top: top,\n        bottom: bot\n      });\n    }\n\n    if (wheelSamples < 20) {\n      if (display.wheelStartX == null) {\n        display.wheelStartX = scroll.scrollLeft;\n        display.wheelStartY = scroll.scrollTop;\n        display.wheelDX = dx;\n        display.wheelDY = dy;\n        setTimeout(function () {\n          if (display.wheelStartX == null) {\n            return;\n          }\n\n          var movedX = scroll.scrollLeft - display.wheelStartX;\n          var movedY = scroll.scrollTop - display.wheelStartY;\n          var sample = movedY && display.wheelDY && movedY / display.wheelDY || movedX && display.wheelDX && movedX / display.wheelDX;\n          display.wheelStartX = display.wheelStartY = null;\n\n          if (!sample) {\n            return;\n          }\n\n          wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1);\n          ++wheelSamples;\n        }, 200);\n      } else {\n        display.wheelDX += dx;\n        display.wheelDY += dy;\n      }\n    }\n  } // Selection objects are immutable. A new one is created every time\n  // the selection changes. A selection is one or more non-overlapping\n  // (and non-touching) ranges, sorted, and an integer that indicates\n  // which one is the primary selection (the one that's scrolled into\n  // view, that getCursor returns, etc).\n\n\n  var Selection = function (ranges, primIndex) {\n    this.ranges = ranges;\n    this.primIndex = primIndex;\n  };\n\n  Selection.prototype.primary = function () {\n    return this.ranges[this.primIndex];\n  };\n\n  Selection.prototype.equals = function (other) {\n    if (other == this) {\n      return true;\n    }\n\n    if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) {\n      return false;\n    }\n\n    for (var i = 0; i < this.ranges.length; i++) {\n      var here = this.ranges[i],\n          there = other.ranges[i];\n\n      if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  Selection.prototype.deepCopy = function () {\n    var out = [];\n\n    for (var i = 0; i < this.ranges.length; i++) {\n      out[i] = new Range(copyPos(this.ranges[i].anchor), copyPos(this.ranges[i].head));\n    }\n\n    return new Selection(out, this.primIndex);\n  };\n\n  Selection.prototype.somethingSelected = function () {\n    for (var i = 0; i < this.ranges.length; i++) {\n      if (!this.ranges[i].empty()) {\n        return true;\n      }\n    }\n\n    return false;\n  };\n\n  Selection.prototype.contains = function (pos, end) {\n    if (!end) {\n      end = pos;\n    }\n\n    for (var i = 0; i < this.ranges.length; i++) {\n      var range = this.ranges[i];\n\n      if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0) {\n        return i;\n      }\n    }\n\n    return -1;\n  };\n\n  var Range = function (anchor, head) {\n    this.anchor = anchor;\n    this.head = head;\n  };\n\n  Range.prototype.from = function () {\n    return minPos(this.anchor, this.head);\n  };\n\n  Range.prototype.to = function () {\n    return maxPos(this.anchor, this.head);\n  };\n\n  Range.prototype.empty = function () {\n    return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch;\n  }; // Take an unsorted, potentially overlapping set of ranges, and\n  // build a selection out of it. 'Consumes' ranges array (modifying\n  // it).\n\n\n  function normalizeSelection(cm, ranges, primIndex) {\n    var mayTouch = cm && cm.options.selectionsMayTouch;\n    var prim = ranges[primIndex];\n    ranges.sort(function (a, b) {\n      return cmp(a.from(), b.from());\n    });\n    primIndex = indexOf(ranges, prim);\n\n    for (var i = 1; i < ranges.length; i++) {\n      var cur = ranges[i],\n          prev = ranges[i - 1];\n      var diff = cmp(prev.to(), cur.from());\n\n      if (mayTouch && !cur.empty() ? diff > 0 : diff >= 0) {\n        var from = minPos(prev.from(), cur.from()),\n            to = maxPos(prev.to(), cur.to());\n        var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head;\n\n        if (i <= primIndex) {\n          --primIndex;\n        }\n\n        ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to));\n      }\n    }\n\n    return new Selection(ranges, primIndex);\n  }\n\n  function simpleSelection(anchor, head) {\n    return new Selection([new Range(anchor, head || anchor)], 0);\n  } // Compute the position of the end of a change (its 'to' property\n  // refers to the pre-change end).\n\n\n  function changeEnd(change) {\n    if (!change.text) {\n      return change.to;\n    }\n\n    return Pos(change.from.line + change.text.length - 1, lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0));\n  } // Adjust a position to refer to the post-change position of the\n  // same text, or the end of the change if the change covers it.\n\n\n  function adjustForChange(pos, change) {\n    if (cmp(pos, change.from) < 0) {\n      return pos;\n    }\n\n    if (cmp(pos, change.to) <= 0) {\n      return changeEnd(change);\n    }\n\n    var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1,\n        ch = pos.ch;\n\n    if (pos.line == change.to.line) {\n      ch += changeEnd(change).ch - change.to.ch;\n    }\n\n    return Pos(line, ch);\n  }\n\n  function computeSelAfterChange(doc, change) {\n    var out = [];\n\n    for (var i = 0; i < doc.sel.ranges.length; i++) {\n      var range = doc.sel.ranges[i];\n      out.push(new Range(adjustForChange(range.anchor, change), adjustForChange(range.head, change)));\n    }\n\n    return normalizeSelection(doc.cm, out, doc.sel.primIndex);\n  }\n\n  function offsetPos(pos, old, nw) {\n    if (pos.line == old.line) {\n      return Pos(nw.line, pos.ch - old.ch + nw.ch);\n    } else {\n      return Pos(nw.line + (pos.line - old.line), pos.ch);\n    }\n  } // Used by replaceSelections to allow moving the selection to the\n  // start or around the replaced test. Hint may be \"start\" or \"around\".\n\n\n  function computeReplacedSel(doc, changes, hint) {\n    var out = [];\n    var oldPrev = Pos(doc.first, 0),\n        newPrev = oldPrev;\n\n    for (var i = 0; i < changes.length; i++) {\n      var change = changes[i];\n      var from = offsetPos(change.from, oldPrev, newPrev);\n      var to = offsetPos(changeEnd(change), oldPrev, newPrev);\n      oldPrev = change.to;\n      newPrev = to;\n\n      if (hint == \"around\") {\n        var range = doc.sel.ranges[i],\n            inv = cmp(range.head, range.anchor) < 0;\n        out[i] = new Range(inv ? to : from, inv ? from : to);\n      } else {\n        out[i] = new Range(from, from);\n      }\n    }\n\n    return new Selection(out, doc.sel.primIndex);\n  } // Used to get the editor into a consistent state again when options change.\n\n\n  function loadMode(cm) {\n    cm.doc.mode = getMode(cm.options, cm.doc.modeOption);\n    resetModeState(cm);\n  }\n\n  function resetModeState(cm) {\n    cm.doc.iter(function (line) {\n      if (line.stateAfter) {\n        line.stateAfter = null;\n      }\n\n      if (line.styles) {\n        line.styles = null;\n      }\n    });\n    cm.doc.modeFrontier = cm.doc.highlightFrontier = cm.doc.first;\n    startWorker(cm, 100);\n    cm.state.modeGen++;\n\n    if (cm.curOp) {\n      regChange(cm);\n    }\n  } // DOCUMENT DATA STRUCTURE\n  // By default, updates that start and end at the beginning of a line\n  // are treated specially, in order to make the association of line\n  // widgets and marker elements with the text behave more intuitive.\n\n\n  function isWholeLineUpdate(doc, change) {\n    return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == \"\" && (!doc.cm || doc.cm.options.wholeLineUpdateBefore);\n  } // Perform a change on the document data structure.\n\n\n  function updateDoc(doc, change, markedSpans, estimateHeight) {\n    function spansFor(n) {\n      return markedSpans ? markedSpans[n] : null;\n    }\n\n    function update(line, text, spans) {\n      updateLine(line, text, spans, estimateHeight);\n      signalLater(line, \"change\", line, change);\n    }\n\n    function linesFor(start, end) {\n      var result = [];\n\n      for (var i = start; i < end; ++i) {\n        result.push(new Line(text[i], spansFor(i), estimateHeight));\n      }\n\n      return result;\n    }\n\n    var from = change.from,\n        to = change.to,\n        text = change.text;\n    var firstLine = getLine(doc, from.line),\n        lastLine = getLine(doc, to.line);\n    var lastText = lst(text),\n        lastSpans = spansFor(text.length - 1),\n        nlines = to.line - from.line; // Adjust the line structure\n\n    if (change.full) {\n      doc.insert(0, linesFor(0, text.length));\n      doc.remove(text.length, doc.size - text.length);\n    } else if (isWholeLineUpdate(doc, change)) {\n      // This is a whole-line replace. Treated specially to make\n      // sure line objects move the way they are supposed to.\n      var added = linesFor(0, text.length - 1);\n      update(lastLine, lastLine.text, lastSpans);\n\n      if (nlines) {\n        doc.remove(from.line, nlines);\n      }\n\n      if (added.length) {\n        doc.insert(from.line, added);\n      }\n    } else if (firstLine == lastLine) {\n      if (text.length == 1) {\n        update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans);\n      } else {\n        var added$1 = linesFor(1, text.length - 1);\n        added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight));\n        update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));\n        doc.insert(from.line + 1, added$1);\n      }\n    } else if (text.length == 1) {\n      update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0));\n      doc.remove(from.line + 1, nlines);\n    } else {\n      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));\n      update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans);\n      var added$2 = linesFor(1, text.length - 1);\n\n      if (nlines > 1) {\n        doc.remove(from.line + 1, nlines - 1);\n      }\n\n      doc.insert(from.line + 1, added$2);\n    }\n\n    signalLater(doc, \"change\", doc, change);\n  } // Call f for all linked documents.\n\n\n  function linkedDocs(doc, f, sharedHistOnly) {\n    function propagate(doc, skip, sharedHist) {\n      if (doc.linked) {\n        for (var i = 0; i < doc.linked.length; ++i) {\n          var rel = doc.linked[i];\n\n          if (rel.doc == skip) {\n            continue;\n          }\n\n          var shared = sharedHist && rel.sharedHist;\n\n          if (sharedHistOnly && !shared) {\n            continue;\n          }\n\n          f(rel.doc, shared);\n          propagate(rel.doc, doc, shared);\n        }\n      }\n    }\n\n    propagate(doc, null, true);\n  } // Attach a document to an editor.\n\n\n  function attachDoc(cm, doc) {\n    if (doc.cm) {\n      throw new Error(\"This document is already in use.\");\n    }\n\n    cm.doc = doc;\n    doc.cm = cm;\n    estimateLineHeights(cm);\n    loadMode(cm);\n    setDirectionClass(cm);\n\n    if (!cm.options.lineWrapping) {\n      findMaxLine(cm);\n    }\n\n    cm.options.mode = doc.modeOption;\n    regChange(cm);\n  }\n\n  function setDirectionClass(cm) {\n    (cm.doc.direction == \"rtl\" ? addClass : rmClass)(cm.display.lineDiv, \"CodeMirror-rtl\");\n  }\n\n  function directionChanged(cm) {\n    runInOp(cm, function () {\n      setDirectionClass(cm);\n      regChange(cm);\n    });\n  }\n\n  function History(startGen) {\n    // Arrays of change events and selections. Doing something adds an\n    // event to done and clears undo. Undoing moves events from done\n    // to undone, redoing moves them in the other direction.\n    this.done = [];\n    this.undone = [];\n    this.undoDepth = Infinity; // Used to track when changes can be merged into a single undo\n    // event\n\n    this.lastModTime = this.lastSelTime = 0;\n    this.lastOp = this.lastSelOp = null;\n    this.lastOrigin = this.lastSelOrigin = null; // Used by the isClean() method\n\n    this.generation = this.maxGeneration = startGen || 1;\n  } // Create a history change event from an updateDoc-style change\n  // object.\n\n\n  function historyChangeFromChange(doc, change) {\n    var histChange = {\n      from: copyPos(change.from),\n      to: changeEnd(change),\n      text: getBetween(doc, change.from, change.to)\n    };\n    attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);\n    linkedDocs(doc, function (doc) {\n      return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);\n    }, true);\n    return histChange;\n  } // Pop all selection events off the end of a history array. Stop at\n  // a change event.\n\n\n  function clearSelectionEvents(array) {\n    while (array.length) {\n      var last = lst(array);\n\n      if (last.ranges) {\n        array.pop();\n      } else {\n        break;\n      }\n    }\n  } // Find the top change event in the history. Pop off selection\n  // events that are in the way.\n\n\n  function lastChangeEvent(hist, force) {\n    if (force) {\n      clearSelectionEvents(hist.done);\n      return lst(hist.done);\n    } else if (hist.done.length && !lst(hist.done).ranges) {\n      return lst(hist.done);\n    } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {\n      hist.done.pop();\n      return lst(hist.done);\n    }\n  } // Register a change in the history. Merges changes that are within\n  // a single operation, or are close together with an origin that\n  // allows merging (starting with \"+\") into a single event.\n\n\n  function addChangeToHistory(doc, change, selAfter, opId) {\n    var hist = doc.history;\n    hist.undone.length = 0;\n    var time = +new Date(),\n        cur;\n    var last;\n\n    if ((hist.lastOp == opId || hist.lastOrigin == change.origin && change.origin && (change.origin.charAt(0) == \"+\" && hist.lastModTime > time - (doc.cm ? doc.cm.options.historyEventDelay : 500) || change.origin.charAt(0) == \"*\")) && (cur = lastChangeEvent(hist, hist.lastOp == opId))) {\n      // Merge this change into the last event\n      last = lst(cur.changes);\n\n      if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {\n        // Optimized case for simple insertion -- don't want to add\n        // new changesets for every character typed\n        last.to = changeEnd(change);\n      } else {\n        // Add new sub-event\n        cur.changes.push(historyChangeFromChange(doc, change));\n      }\n    } else {\n      // Can not be merged, start a new event.\n      var before = lst(hist.done);\n\n      if (!before || !before.ranges) {\n        pushSelectionToHistory(doc.sel, hist.done);\n      }\n\n      cur = {\n        changes: [historyChangeFromChange(doc, change)],\n        generation: hist.generation\n      };\n      hist.done.push(cur);\n\n      while (hist.done.length > hist.undoDepth) {\n        hist.done.shift();\n\n        if (!hist.done[0].ranges) {\n          hist.done.shift();\n        }\n      }\n    }\n\n    hist.done.push(selAfter);\n    hist.generation = ++hist.maxGeneration;\n    hist.lastModTime = hist.lastSelTime = time;\n    hist.lastOp = hist.lastSelOp = opId;\n    hist.lastOrigin = hist.lastSelOrigin = change.origin;\n\n    if (!last) {\n      signal(doc, \"historyAdded\");\n    }\n  }\n\n  function selectionEventCanBeMerged(doc, origin, prev, sel) {\n    var ch = origin.charAt(0);\n    return ch == \"*\" || ch == \"+\" && prev.ranges.length == sel.ranges.length && prev.somethingSelected() == sel.somethingSelected() && new Date() - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500);\n  } // Called whenever the selection changes, sets the new selection as\n  // the pending selection in the history, and pushes the old pending\n  // selection into the 'done' array when it was significantly\n  // different (in number of selected ranges, emptiness, or time).\n\n\n  function addSelectionToHistory(doc, sel, opId, options) {\n    var hist = doc.history,\n        origin = options && options.origin; // A new event is started when the previous origin does not match\n    // the current, or the origins don't allow matching. Origins\n    // starting with * are always merged, those starting with + are\n    // merged when similar and close together in time.\n\n    if (opId == hist.lastSelOp || origin && hist.lastSelOrigin == origin && (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin || selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))) {\n      hist.done[hist.done.length - 1] = sel;\n    } else {\n      pushSelectionToHistory(sel, hist.done);\n    }\n\n    hist.lastSelTime = +new Date();\n    hist.lastSelOrigin = origin;\n    hist.lastSelOp = opId;\n\n    if (options && options.clearRedo !== false) {\n      clearSelectionEvents(hist.undone);\n    }\n  }\n\n  function pushSelectionToHistory(sel, dest) {\n    var top = lst(dest);\n\n    if (!(top && top.ranges && top.equals(sel))) {\n      dest.push(sel);\n    }\n  } // Used to store marked span information in the history.\n\n\n  function attachLocalSpans(doc, change, from, to) {\n    var existing = change[\"spans_\" + doc.id],\n        n = 0;\n    doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) {\n      if (line.markedSpans) {\n        (existing || (existing = change[\"spans_\" + doc.id] = {}))[n] = line.markedSpans;\n      }\n\n      ++n;\n    });\n  } // When un/re-doing restores text containing marked spans, those\n  // that have been explicitly cleared should not be restored.\n\n\n  function removeClearedSpans(spans) {\n    if (!spans) {\n      return null;\n    }\n\n    var out;\n\n    for (var i = 0; i < spans.length; ++i) {\n      if (spans[i].marker.explicitlyCleared) {\n        if (!out) {\n          out = spans.slice(0, i);\n        }\n      } else if (out) {\n        out.push(spans[i]);\n      }\n    }\n\n    return !out ? spans : out.length ? out : null;\n  } // Retrieve and filter the old marked spans stored in a change event.\n\n\n  function getOldSpans(doc, change) {\n    var found = change[\"spans_\" + doc.id];\n\n    if (!found) {\n      return null;\n    }\n\n    var nw = [];\n\n    for (var i = 0; i < change.text.length; ++i) {\n      nw.push(removeClearedSpans(found[i]));\n    }\n\n    return nw;\n  } // Used for un/re-doing changes from the history. Combines the\n  // result of computing the existing spans with the set of spans that\n  // existed in the history (so that deleting around a span and then\n  // undoing brings back the span).\n\n\n  function mergeOldSpans(doc, change) {\n    var old = getOldSpans(doc, change);\n    var stretched = stretchSpansOverChange(doc, change);\n\n    if (!old) {\n      return stretched;\n    }\n\n    if (!stretched) {\n      return old;\n    }\n\n    for (var i = 0; i < old.length; ++i) {\n      var oldCur = old[i],\n          stretchCur = stretched[i];\n\n      if (oldCur && stretchCur) {\n        spans: for (var j = 0; j < stretchCur.length; ++j) {\n          var span = stretchCur[j];\n\n          for (var k = 0; k < oldCur.length; ++k) {\n            if (oldCur[k].marker == span.marker) {\n              continue spans;\n            }\n          }\n\n          oldCur.push(span);\n        }\n      } else if (stretchCur) {\n        old[i] = stretchCur;\n      }\n    }\n\n    return old;\n  } // Used both to provide a JSON-safe object in .getHistory, and, when\n  // detaching a document, to split the history in two\n\n\n  function copyHistoryArray(events, newGroup, instantiateSel) {\n    var copy = [];\n\n    for (var i = 0; i < events.length; ++i) {\n      var event = events[i];\n\n      if (event.ranges) {\n        copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event);\n        continue;\n      }\n\n      var changes = event.changes,\n          newChanges = [];\n      copy.push({\n        changes: newChanges\n      });\n\n      for (var j = 0; j < changes.length; ++j) {\n        var change = changes[j],\n            m = void 0;\n        newChanges.push({\n          from: change.from,\n          to: change.to,\n          text: change.text\n        });\n\n        if (newGroup) {\n          for (var prop in change) {\n            if (m = prop.match(/^spans_(\\d+)$/)) {\n              if (indexOf(newGroup, Number(m[1])) > -1) {\n                lst(newChanges)[prop] = change[prop];\n                delete change[prop];\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return copy;\n  } // The 'scroll' parameter given to many of these indicated whether\n  // the new cursor position should be scrolled into view after\n  // modifying the selection.\n  // If shift is held or the extend flag is set, extends a range to\n  // include a given position (and optionally a second position).\n  // Otherwise, simply returns the range between the given positions.\n  // Used for cursor motion and such.\n\n\n  function extendRange(range, head, other, extend) {\n    if (extend) {\n      var anchor = range.anchor;\n\n      if (other) {\n        var posBefore = cmp(head, anchor) < 0;\n\n        if (posBefore != cmp(other, anchor) < 0) {\n          anchor = head;\n          head = other;\n        } else if (posBefore != cmp(head, other) < 0) {\n          head = other;\n        }\n      }\n\n      return new Range(anchor, head);\n    } else {\n      return new Range(other || head, head);\n    }\n  } // Extend the primary selection range, discard the rest.\n\n\n  function extendSelection(doc, head, other, options, extend) {\n    if (extend == null) {\n      extend = doc.cm && (doc.cm.display.shift || doc.extend);\n    }\n\n    setSelection(doc, new Selection([extendRange(doc.sel.primary(), head, other, extend)], 0), options);\n  } // Extend all selections (pos is an array of selections with length\n  // equal the number of selections)\n\n\n  function extendSelections(doc, heads, options) {\n    var out = [];\n    var extend = doc.cm && (doc.cm.display.shift || doc.extend);\n\n    for (var i = 0; i < doc.sel.ranges.length; i++) {\n      out[i] = extendRange(doc.sel.ranges[i], heads[i], null, extend);\n    }\n\n    var newSel = normalizeSelection(doc.cm, out, doc.sel.primIndex);\n    setSelection(doc, newSel, options);\n  } // Updates a single range in the selection.\n\n\n  function replaceOneSelection(doc, i, range, options) {\n    var ranges = doc.sel.ranges.slice(0);\n    ranges[i] = range;\n    setSelection(doc, normalizeSelection(doc.cm, ranges, doc.sel.primIndex), options);\n  } // Reset the selection to a single range.\n\n\n  function setSimpleSelection(doc, anchor, head, options) {\n    setSelection(doc, simpleSelection(anchor, head), options);\n  } // Give beforeSelectionChange handlers a change to influence a\n  // selection update.\n\n\n  function filterSelectionChange(doc, sel, options) {\n    var obj = {\n      ranges: sel.ranges,\n      update: function (ranges) {\n        this.ranges = [];\n\n        for (var i = 0; i < ranges.length; i++) {\n          this.ranges[i] = new Range(clipPos(doc, ranges[i].anchor), clipPos(doc, ranges[i].head));\n        }\n      },\n      origin: options && options.origin\n    };\n    signal(doc, \"beforeSelectionChange\", doc, obj);\n\n    if (doc.cm) {\n      signal(doc.cm, \"beforeSelectionChange\", doc.cm, obj);\n    }\n\n    if (obj.ranges != sel.ranges) {\n      return normalizeSelection(doc.cm, obj.ranges, obj.ranges.length - 1);\n    } else {\n      return sel;\n    }\n  }\n\n  function setSelectionReplaceHistory(doc, sel, options) {\n    var done = doc.history.done,\n        last = lst(done);\n\n    if (last && last.ranges) {\n      done[done.length - 1] = sel;\n      setSelectionNoUndo(doc, sel, options);\n    } else {\n      setSelection(doc, sel, options);\n    }\n  } // Set a new selection.\n\n\n  function setSelection(doc, sel, options) {\n    setSelectionNoUndo(doc, sel, options);\n    addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options);\n  }\n\n  function setSelectionNoUndo(doc, sel, options) {\n    if (hasHandler(doc, \"beforeSelectionChange\") || doc.cm && hasHandler(doc.cm, \"beforeSelectionChange\")) {\n      sel = filterSelectionChange(doc, sel, options);\n    }\n\n    var bias = options && options.bias || (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1);\n    setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true));\n\n    if (!(options && options.scroll === false) && doc.cm) {\n      ensureCursorVisible(doc.cm);\n    }\n  }\n\n  function setSelectionInner(doc, sel) {\n    if (sel.equals(doc.sel)) {\n      return;\n    }\n\n    doc.sel = sel;\n\n    if (doc.cm) {\n      doc.cm.curOp.updateInput = 1;\n      doc.cm.curOp.selectionChanged = true;\n      signalCursorActivity(doc.cm);\n    }\n\n    signalLater(doc, \"cursorActivity\", doc);\n  } // Verify that the selection does not partially select any atomic\n  // marked ranges.\n\n\n  function reCheckSelection(doc) {\n    setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false));\n  } // Return a selection that does not partially select any atomic\n  // ranges.\n\n\n  function skipAtomicInSelection(doc, sel, bias, mayClear) {\n    var out;\n\n    for (var i = 0; i < sel.ranges.length; i++) {\n      var range = sel.ranges[i];\n      var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i];\n      var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear);\n      var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear);\n\n      if (out || newAnchor != range.anchor || newHead != range.head) {\n        if (!out) {\n          out = sel.ranges.slice(0, i);\n        }\n\n        out[i] = new Range(newAnchor, newHead);\n      }\n    }\n\n    return out ? normalizeSelection(doc.cm, out, sel.primIndex) : sel;\n  }\n\n  function skipAtomicInner(doc, pos, oldPos, dir, mayClear) {\n    var line = getLine(doc, pos.line);\n\n    if (line.markedSpans) {\n      for (var i = 0; i < line.markedSpans.length; ++i) {\n        var sp = line.markedSpans[i],\n            m = sp.marker; // Determine if we should prevent the cursor being placed to the left/right of an atomic marker\n        // Historically this was determined using the inclusiveLeft/Right option, but the new way to control it\n        // is with selectLeft/Right\n\n        var preventCursorLeft = \"selectLeft\" in m ? !m.selectLeft : m.inclusiveLeft;\n        var preventCursorRight = \"selectRight\" in m ? !m.selectRight : m.inclusiveRight;\n\n        if ((sp.from == null || (preventCursorLeft ? sp.from <= pos.ch : sp.from < pos.ch)) && (sp.to == null || (preventCursorRight ? sp.to >= pos.ch : sp.to > pos.ch))) {\n          if (mayClear) {\n            signal(m, \"beforeCursorEnter\");\n\n            if (m.explicitlyCleared) {\n              if (!line.markedSpans) {\n                break;\n              } else {\n                --i;\n                continue;\n              }\n            }\n          }\n\n          if (!m.atomic) {\n            continue;\n          }\n\n          if (oldPos) {\n            var near = m.find(dir < 0 ? 1 : -1),\n                diff = void 0;\n\n            if (dir < 0 ? preventCursorRight : preventCursorLeft) {\n              near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null);\n            }\n\n            if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0)) {\n              return skipAtomicInner(doc, near, pos, dir, mayClear);\n            }\n          }\n\n          var far = m.find(dir < 0 ? -1 : 1);\n\n          if (dir < 0 ? preventCursorLeft : preventCursorRight) {\n            far = movePos(doc, far, dir, far.line == pos.line ? line : null);\n          }\n\n          return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null;\n        }\n      }\n    }\n\n    return pos;\n  } // Ensure a given position is not inside an atomic range.\n\n\n  function skipAtomic(doc, pos, oldPos, bias, mayClear) {\n    var dir = bias || 1;\n    var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) || !mayClear && skipAtomicInner(doc, pos, oldPos, dir, true) || skipAtomicInner(doc, pos, oldPos, -dir, mayClear) || !mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true);\n\n    if (!found) {\n      doc.cantEdit = true;\n      return Pos(doc.first, 0);\n    }\n\n    return found;\n  }\n\n  function movePos(doc, pos, dir, line) {\n    if (dir < 0 && pos.ch == 0) {\n      if (pos.line > doc.first) {\n        return clipPos(doc, Pos(pos.line - 1));\n      } else {\n        return null;\n      }\n    } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) {\n      if (pos.line < doc.first + doc.size - 1) {\n        return Pos(pos.line + 1, 0);\n      } else {\n        return null;\n      }\n    } else {\n      return new Pos(pos.line, pos.ch + dir);\n    }\n  }\n\n  function selectAll(cm) {\n    cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll);\n  } // UPDATING\n  // Allow \"beforeChange\" event handlers to influence a change\n\n\n  function filterChange(doc, change, update) {\n    var obj = {\n      canceled: false,\n      from: change.from,\n      to: change.to,\n      text: change.text,\n      origin: change.origin,\n      cancel: function () {\n        return obj.canceled = true;\n      }\n    };\n\n    if (update) {\n      obj.update = function (from, to, text, origin) {\n        if (from) {\n          obj.from = clipPos(doc, from);\n        }\n\n        if (to) {\n          obj.to = clipPos(doc, to);\n        }\n\n        if (text) {\n          obj.text = text;\n        }\n\n        if (origin !== undefined) {\n          obj.origin = origin;\n        }\n      };\n    }\n\n    signal(doc, \"beforeChange\", doc, obj);\n\n    if (doc.cm) {\n      signal(doc.cm, \"beforeChange\", doc.cm, obj);\n    }\n\n    if (obj.canceled) {\n      if (doc.cm) {\n        doc.cm.curOp.updateInput = 2;\n      }\n\n      return null;\n    }\n\n    return {\n      from: obj.from,\n      to: obj.to,\n      text: obj.text,\n      origin: obj.origin\n    };\n  } // Apply a change to a document, and add it to the document's\n  // history, and propagating it to all linked documents.\n\n\n  function makeChange(doc, change, ignoreReadOnly) {\n    if (doc.cm) {\n      if (!doc.cm.curOp) {\n        return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly);\n      }\n\n      if (doc.cm.state.suppressEdits) {\n        return;\n      }\n    }\n\n    if (hasHandler(doc, \"beforeChange\") || doc.cm && hasHandler(doc.cm, \"beforeChange\")) {\n      change = filterChange(doc, change, true);\n\n      if (!change) {\n        return;\n      }\n    } // Possibly split or suppress the update based on the presence\n    // of read-only spans in its range.\n\n\n    var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to);\n\n    if (split) {\n      for (var i = split.length - 1; i >= 0; --i) {\n        makeChangeInner(doc, {\n          from: split[i].from,\n          to: split[i].to,\n          text: i ? [\"\"] : change.text,\n          origin: change.origin\n        });\n      }\n    } else {\n      makeChangeInner(doc, change);\n    }\n  }\n\n  function makeChangeInner(doc, change) {\n    if (change.text.length == 1 && change.text[0] == \"\" && cmp(change.from, change.to) == 0) {\n      return;\n    }\n\n    var selAfter = computeSelAfterChange(doc, change);\n    addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN);\n    makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change));\n    var rebased = [];\n    linkedDocs(doc, function (doc, sharedHist) {\n      if (!sharedHist && indexOf(rebased, doc.history) == -1) {\n        rebaseHist(doc.history, change);\n        rebased.push(doc.history);\n      }\n\n      makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change));\n    });\n  } // Revert a change stored in a document's history.\n\n\n  function makeChangeFromHistory(doc, type, allowSelectionOnly) {\n    var suppress = doc.cm && doc.cm.state.suppressEdits;\n\n    if (suppress && !allowSelectionOnly) {\n      return;\n    }\n\n    var hist = doc.history,\n        event,\n        selAfter = doc.sel;\n    var source = type == \"undo\" ? hist.done : hist.undone,\n        dest = type == \"undo\" ? hist.undone : hist.done; // Verify that there is a useable event (so that ctrl-z won't\n    // needlessly clear selection events)\n\n    var i = 0;\n\n    for (; i < source.length; i++) {\n      event = source[i];\n\n      if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges) {\n        break;\n      }\n    }\n\n    if (i == source.length) {\n      return;\n    }\n\n    hist.lastOrigin = hist.lastSelOrigin = null;\n\n    for (;;) {\n      event = source.pop();\n\n      if (event.ranges) {\n        pushSelectionToHistory(event, dest);\n\n        if (allowSelectionOnly && !event.equals(doc.sel)) {\n          setSelection(doc, event, {\n            clearRedo: false\n          });\n          return;\n        }\n\n        selAfter = event;\n      } else if (suppress) {\n        source.push(event);\n        return;\n      } else {\n        break;\n      }\n    } // Build up a reverse change object to add to the opposite history\n    // stack (redo when undoing, and vice versa).\n\n\n    var antiChanges = [];\n    pushSelectionToHistory(selAfter, dest);\n    dest.push({\n      changes: antiChanges,\n      generation: hist.generation\n    });\n    hist.generation = event.generation || ++hist.maxGeneration;\n    var filter = hasHandler(doc, \"beforeChange\") || doc.cm && hasHandler(doc.cm, \"beforeChange\");\n\n    var loop = function (i) {\n      var change = event.changes[i];\n      change.origin = type;\n\n      if (filter && !filterChange(doc, change, false)) {\n        source.length = 0;\n        return {};\n      }\n\n      antiChanges.push(historyChangeFromChange(doc, change));\n      var after = i ? computeSelAfterChange(doc, change) : lst(source);\n      makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change));\n\n      if (!i && doc.cm) {\n        doc.cm.scrollIntoView({\n          from: change.from,\n          to: changeEnd(change)\n        });\n      }\n\n      var rebased = []; // Propagate to the linked documents\n\n      linkedDocs(doc, function (doc, sharedHist) {\n        if (!sharedHist && indexOf(rebased, doc.history) == -1) {\n          rebaseHist(doc.history, change);\n          rebased.push(doc.history);\n        }\n\n        makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change));\n      });\n    };\n\n    for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) {\n      var returned = loop(i$1);\n      if (returned) return returned.v;\n    }\n  } // Sub-views need their line numbers shifted when text is added\n  // above or below them in the parent document.\n\n\n  function shiftDoc(doc, distance) {\n    if (distance == 0) {\n      return;\n    }\n\n    doc.first += distance;\n    doc.sel = new Selection(map(doc.sel.ranges, function (range) {\n      return new Range(Pos(range.anchor.line + distance, range.anchor.ch), Pos(range.head.line + distance, range.head.ch));\n    }), doc.sel.primIndex);\n\n    if (doc.cm) {\n      regChange(doc.cm, doc.first, doc.first - distance, distance);\n\n      for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++) {\n        regLineChange(doc.cm, l, \"gutter\");\n      }\n    }\n  } // More lower-level change function, handling only a single document\n  // (not linked ones).\n\n\n  function makeChangeSingleDoc(doc, change, selAfter, spans) {\n    if (doc.cm && !doc.cm.curOp) {\n      return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans);\n    }\n\n    if (change.to.line < doc.first) {\n      shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line));\n      return;\n    }\n\n    if (change.from.line > doc.lastLine()) {\n      return;\n    } // Clip the change to the size of this doc\n\n\n    if (change.from.line < doc.first) {\n      var shift = change.text.length - 1 - (doc.first - change.from.line);\n      shiftDoc(doc, shift);\n      change = {\n        from: Pos(doc.first, 0),\n        to: Pos(change.to.line + shift, change.to.ch),\n        text: [lst(change.text)],\n        origin: change.origin\n      };\n    }\n\n    var last = doc.lastLine();\n\n    if (change.to.line > last) {\n      change = {\n        from: change.from,\n        to: Pos(last, getLine(doc, last).text.length),\n        text: [change.text[0]],\n        origin: change.origin\n      };\n    }\n\n    change.removed = getBetween(doc, change.from, change.to);\n\n    if (!selAfter) {\n      selAfter = computeSelAfterChange(doc, change);\n    }\n\n    if (doc.cm) {\n      makeChangeSingleDocInEditor(doc.cm, change, spans);\n    } else {\n      updateDoc(doc, change, spans);\n    }\n\n    setSelectionNoUndo(doc, selAfter, sel_dontScroll);\n\n    if (doc.cantEdit && skipAtomic(doc, Pos(doc.firstLine(), 0))) {\n      doc.cantEdit = false;\n    }\n  } // Handle the interaction of a change to a document with the editor\n  // that this document is part of.\n\n\n  function makeChangeSingleDocInEditor(cm, change, spans) {\n    var doc = cm.doc,\n        display = cm.display,\n        from = change.from,\n        to = change.to;\n    var recomputeMaxLength = false,\n        checkWidthStart = from.line;\n\n    if (!cm.options.lineWrapping) {\n      checkWidthStart = lineNo(visualLine(getLine(doc, from.line)));\n      doc.iter(checkWidthStart, to.line + 1, function (line) {\n        if (line == display.maxLine) {\n          recomputeMaxLength = true;\n          return true;\n        }\n      });\n    }\n\n    if (doc.sel.contains(change.from, change.to) > -1) {\n      signalCursorActivity(cm);\n    }\n\n    updateDoc(doc, change, spans, estimateHeight(cm));\n\n    if (!cm.options.lineWrapping) {\n      doc.iter(checkWidthStart, from.line + change.text.length, function (line) {\n        var len = lineLength(line);\n\n        if (len > display.maxLineLength) {\n          display.maxLine = line;\n          display.maxLineLength = len;\n          display.maxLineChanged = true;\n          recomputeMaxLength = false;\n        }\n      });\n\n      if (recomputeMaxLength) {\n        cm.curOp.updateMaxLine = true;\n      }\n    }\n\n    retreatFrontier(doc, from.line);\n    startWorker(cm, 400);\n    var lendiff = change.text.length - (to.line - from.line) - 1; // Remember that these lines changed, for updating the display\n\n    if (change.full) {\n      regChange(cm);\n    } else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change)) {\n      regLineChange(cm, from.line, \"text\");\n    } else {\n      regChange(cm, from.line, to.line + 1, lendiff);\n    }\n\n    var changesHandler = hasHandler(cm, \"changes\"),\n        changeHandler = hasHandler(cm, \"change\");\n\n    if (changeHandler || changesHandler) {\n      var obj = {\n        from: from,\n        to: to,\n        text: change.text,\n        removed: change.removed,\n        origin: change.origin\n      };\n\n      if (changeHandler) {\n        signalLater(cm, \"change\", cm, obj);\n      }\n\n      if (changesHandler) {\n        (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj);\n      }\n    }\n\n    cm.display.selForContextMenu = null;\n  }\n\n  function replaceRange(doc, code, from, to, origin) {\n    var assign;\n\n    if (!to) {\n      to = from;\n    }\n\n    if (cmp(to, from) < 0) {\n      assign = [to, from], from = assign[0], to = assign[1];\n    }\n\n    if (typeof code == \"string\") {\n      code = doc.splitLines(code);\n    }\n\n    makeChange(doc, {\n      from: from,\n      to: to,\n      text: code,\n      origin: origin\n    });\n  } // Rebasing/resetting history to deal with externally-sourced changes\n\n\n  function rebaseHistSelSingle(pos, from, to, diff) {\n    if (to < pos.line) {\n      pos.line += diff;\n    } else if (from < pos.line) {\n      pos.line = from;\n      pos.ch = 0;\n    }\n  } // Tries to rebase an array of history events given a change in the\n  // document. If the change touches the same lines as the event, the\n  // event, and everything 'behind' it, is discarded. If the change is\n  // before the event, the event's positions are updated. Uses a\n  // copy-on-write scheme for the positions, to avoid having to\n  // reallocate them all on every rebase, but also avoid problems with\n  // shared position objects being unsafely updated.\n\n\n  function rebaseHistArray(array, from, to, diff) {\n    for (var i = 0; i < array.length; ++i) {\n      var sub = array[i],\n          ok = true;\n\n      if (sub.ranges) {\n        if (!sub.copied) {\n          sub = array[i] = sub.deepCopy();\n          sub.copied = true;\n        }\n\n        for (var j = 0; j < sub.ranges.length; j++) {\n          rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff);\n          rebaseHistSelSingle(sub.ranges[j].head, from, to, diff);\n        }\n\n        continue;\n      }\n\n      for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) {\n        var cur = sub.changes[j$1];\n\n        if (to < cur.from.line) {\n          cur.from = Pos(cur.from.line + diff, cur.from.ch);\n          cur.to = Pos(cur.to.line + diff, cur.to.ch);\n        } else if (from <= cur.to.line) {\n          ok = false;\n          break;\n        }\n      }\n\n      if (!ok) {\n        array.splice(0, i + 1);\n        i = 0;\n      }\n    }\n  }\n\n  function rebaseHist(hist, change) {\n    var from = change.from.line,\n        to = change.to.line,\n        diff = change.text.length - (to - from) - 1;\n    rebaseHistArray(hist.done, from, to, diff);\n    rebaseHistArray(hist.undone, from, to, diff);\n  } // Utility for applying a change to a line by handle or number,\n  // returning the number and optionally registering the line as\n  // changed.\n\n\n  function changeLine(doc, handle, changeType, op) {\n    var no = handle,\n        line = handle;\n\n    if (typeof handle == \"number\") {\n      line = getLine(doc, clipLine(doc, handle));\n    } else {\n      no = lineNo(handle);\n    }\n\n    if (no == null) {\n      return null;\n    }\n\n    if (op(line, no) && doc.cm) {\n      regLineChange(doc.cm, no, changeType);\n    }\n\n    return line;\n  } // The document is represented as a BTree consisting of leaves, with\n  // chunk of lines in them, and branches, with up to ten leaves or\n  // other branch nodes below them. The top node is always a branch\n  // node, and is the document object itself (meaning it has\n  // additional methods and properties).\n  //\n  // All nodes have parent links. The tree is used both to go from\n  // line numbers to line objects, and to go from objects to numbers.\n  // It also indexes by height, and is used to convert between height\n  // and line object, and to find the total height of the document.\n  //\n  // See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html\n\n\n  function LeafChunk(lines) {\n    this.lines = lines;\n    this.parent = null;\n    var height = 0;\n\n    for (var i = 0; i < lines.length; ++i) {\n      lines[i].parent = this;\n      height += lines[i].height;\n    }\n\n    this.height = height;\n  }\n\n  LeafChunk.prototype = {\n    chunkSize: function () {\n      return this.lines.length;\n    },\n    // Remove the n lines at offset 'at'.\n    removeInner: function (at, n) {\n      for (var i = at, e = at + n; i < e; ++i) {\n        var line = this.lines[i];\n        this.height -= line.height;\n        cleanUpLine(line);\n        signalLater(line, \"delete\");\n      }\n\n      this.lines.splice(at, n);\n    },\n    // Helper used to collapse a small branch into a single leaf.\n    collapse: function (lines) {\n      lines.push.apply(lines, this.lines);\n    },\n    // Insert the given array of lines at offset 'at', count them as\n    // having the given height.\n    insertInner: function (at, lines, height) {\n      this.height += height;\n      this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at));\n\n      for (var i = 0; i < lines.length; ++i) {\n        lines[i].parent = this;\n      }\n    },\n    // Used to iterate over a part of the tree.\n    iterN: function (at, n, op) {\n      for (var e = at + n; at < e; ++at) {\n        if (op(this.lines[at])) {\n          return true;\n        }\n      }\n    }\n  };\n\n  function BranchChunk(children) {\n    this.children = children;\n    var size = 0,\n        height = 0;\n\n    for (var i = 0; i < children.length; ++i) {\n      var ch = children[i];\n      size += ch.chunkSize();\n      height += ch.height;\n      ch.parent = this;\n    }\n\n    this.size = size;\n    this.height = height;\n    this.parent = null;\n  }\n\n  BranchChunk.prototype = {\n    chunkSize: function () {\n      return this.size;\n    },\n    removeInner: function (at, n) {\n      this.size -= n;\n\n      for (var i = 0; i < this.children.length; ++i) {\n        var child = this.children[i],\n            sz = child.chunkSize();\n\n        if (at < sz) {\n          var rm = Math.min(n, sz - at),\n              oldHeight = child.height;\n          child.removeInner(at, rm);\n          this.height -= oldHeight - child.height;\n\n          if (sz == rm) {\n            this.children.splice(i--, 1);\n            child.parent = null;\n          }\n\n          if ((n -= rm) == 0) {\n            break;\n          }\n\n          at = 0;\n        } else {\n          at -= sz;\n        }\n      } // If the result is smaller than 25 lines, ensure that it is a\n      // single leaf node.\n\n\n      if (this.size - n < 25 && (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {\n        var lines = [];\n        this.collapse(lines);\n        this.children = [new LeafChunk(lines)];\n        this.children[0].parent = this;\n      }\n    },\n    collapse: function (lines) {\n      for (var i = 0; i < this.children.length; ++i) {\n        this.children[i].collapse(lines);\n      }\n    },\n    insertInner: function (at, lines, height) {\n      this.size += lines.length;\n      this.height += height;\n\n      for (var i = 0; i < this.children.length; ++i) {\n        var child = this.children[i],\n            sz = child.chunkSize();\n\n        if (at <= sz) {\n          child.insertInner(at, lines, height);\n\n          if (child.lines && child.lines.length > 50) {\n            // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.\n            // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.\n            var remaining = child.lines.length % 25 + 25;\n\n            for (var pos = remaining; pos < child.lines.length;) {\n              var leaf = new LeafChunk(child.lines.slice(pos, pos += 25));\n              child.height -= leaf.height;\n              this.children.splice(++i, 0, leaf);\n              leaf.parent = this;\n            }\n\n            child.lines = child.lines.slice(0, remaining);\n            this.maybeSpill();\n          }\n\n          break;\n        }\n\n        at -= sz;\n      }\n    },\n    // When a node has grown, check whether it should be split.\n    maybeSpill: function () {\n      if (this.children.length <= 10) {\n        return;\n      }\n\n      var me = this;\n\n      do {\n        var spilled = me.children.splice(me.children.length - 5, 5);\n        var sibling = new BranchChunk(spilled);\n\n        if (!me.parent) {\n          // Become the parent node\n          var copy = new BranchChunk(me.children);\n          copy.parent = me;\n          me.children = [copy, sibling];\n          me = copy;\n        } else {\n          me.size -= sibling.size;\n          me.height -= sibling.height;\n          var myIndex = indexOf(me.parent.children, me);\n          me.parent.children.splice(myIndex + 1, 0, sibling);\n        }\n\n        sibling.parent = me.parent;\n      } while (me.children.length > 10);\n\n      me.parent.maybeSpill();\n    },\n    iterN: function (at, n, op) {\n      for (var i = 0; i < this.children.length; ++i) {\n        var child = this.children[i],\n            sz = child.chunkSize();\n\n        if (at < sz) {\n          var used = Math.min(n, sz - at);\n\n          if (child.iterN(at, used, op)) {\n            return true;\n          }\n\n          if ((n -= used) == 0) {\n            break;\n          }\n\n          at = 0;\n        } else {\n          at -= sz;\n        }\n      }\n    }\n  }; // Line widgets are block elements displayed above or below a line.\n\n  var LineWidget = function (doc, node, options) {\n    if (options) {\n      for (var opt in options) {\n        if (options.hasOwnProperty(opt)) {\n          this[opt] = options[opt];\n        }\n      }\n    }\n\n    this.doc = doc;\n    this.node = node;\n  };\n\n  LineWidget.prototype.clear = function () {\n    var cm = this.doc.cm,\n        ws = this.line.widgets,\n        line = this.line,\n        no = lineNo(line);\n\n    if (no == null || !ws) {\n      return;\n    }\n\n    for (var i = 0; i < ws.length; ++i) {\n      if (ws[i] == this) {\n        ws.splice(i--, 1);\n      }\n    }\n\n    if (!ws.length) {\n      line.widgets = null;\n    }\n\n    var height = widgetHeight(this);\n    updateLineHeight(line, Math.max(0, line.height - height));\n\n    if (cm) {\n      runInOp(cm, function () {\n        adjustScrollWhenAboveVisible(cm, line, -height);\n        regLineChange(cm, no, \"widget\");\n      });\n      signalLater(cm, \"lineWidgetCleared\", cm, this, no);\n    }\n  };\n\n  LineWidget.prototype.changed = function () {\n    var this$1 = this;\n    var oldH = this.height,\n        cm = this.doc.cm,\n        line = this.line;\n    this.height = null;\n    var diff = widgetHeight(this) - oldH;\n\n    if (!diff) {\n      return;\n    }\n\n    if (!lineIsHidden(this.doc, line)) {\n      updateLineHeight(line, line.height + diff);\n    }\n\n    if (cm) {\n      runInOp(cm, function () {\n        cm.curOp.forceUpdate = true;\n        adjustScrollWhenAboveVisible(cm, line, diff);\n        signalLater(cm, \"lineWidgetChanged\", cm, this$1, lineNo(line));\n      });\n    }\n  };\n\n  eventMixin(LineWidget);\n\n  function adjustScrollWhenAboveVisible(cm, line, diff) {\n    if (heightAtLine(line) < (cm.curOp && cm.curOp.scrollTop || cm.doc.scrollTop)) {\n      addToScrollTop(cm, diff);\n    }\n  }\n\n  function addLineWidget(doc, handle, node, options) {\n    var widget = new LineWidget(doc, node, options);\n    var cm = doc.cm;\n\n    if (cm && widget.noHScroll) {\n      cm.display.alignWidgets = true;\n    }\n\n    changeLine(doc, handle, \"widget\", function (line) {\n      var widgets = line.widgets || (line.widgets = []);\n\n      if (widget.insertAt == null) {\n        widgets.push(widget);\n      } else {\n        widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget);\n      }\n\n      widget.line = line;\n\n      if (cm && !lineIsHidden(doc, line)) {\n        var aboveVisible = heightAtLine(line) < doc.scrollTop;\n        updateLineHeight(line, line.height + widgetHeight(widget));\n\n        if (aboveVisible) {\n          addToScrollTop(cm, widget.height);\n        }\n\n        cm.curOp.forceUpdate = true;\n      }\n\n      return true;\n    });\n\n    if (cm) {\n      signalLater(cm, \"lineWidgetAdded\", cm, widget, typeof handle == \"number\" ? handle : lineNo(handle));\n    }\n\n    return widget;\n  } // TEXTMARKERS\n  // Created with markText and setBookmark methods. A TextMarker is a\n  // handle that can be used to clear or find a marked position in the\n  // document. Line objects hold arrays (markedSpans) containing\n  // {from, to, marker} object pointing to such marker objects, and\n  // indicating that such a marker is present on that line. Multiple\n  // lines may point to the same marker when it spans across lines.\n  // The spans will have null for their from/to properties when the\n  // marker continues beyond the start/end of the line. Markers have\n  // links back to the lines they currently touch.\n  // Collapsed markers have unique ids, in order to be able to order\n  // them, which is needed for uniquely determining an outer marker\n  // when they overlap (they may nest, but not partially overlap).\n\n\n  var nextMarkerId = 0;\n\n  var TextMarker = function (doc, type) {\n    this.lines = [];\n    this.type = type;\n    this.doc = doc;\n    this.id = ++nextMarkerId;\n  }; // Clear the marker.\n\n\n  TextMarker.prototype.clear = function () {\n    if (this.explicitlyCleared) {\n      return;\n    }\n\n    var cm = this.doc.cm,\n        withOp = cm && !cm.curOp;\n\n    if (withOp) {\n      startOperation(cm);\n    }\n\n    if (hasHandler(this, \"clear\")) {\n      var found = this.find();\n\n      if (found) {\n        signalLater(this, \"clear\", found.from, found.to);\n      }\n    }\n\n    var min = null,\n        max = null;\n\n    for (var i = 0; i < this.lines.length; ++i) {\n      var line = this.lines[i];\n      var span = getMarkedSpanFor(line.markedSpans, this);\n\n      if (cm && !this.collapsed) {\n        regLineChange(cm, lineNo(line), \"text\");\n      } else if (cm) {\n        if (span.to != null) {\n          max = lineNo(line);\n        }\n\n        if (span.from != null) {\n          min = lineNo(line);\n        }\n      }\n\n      line.markedSpans = removeMarkedSpan(line.markedSpans, span);\n\n      if (span.from == null && this.collapsed && !lineIsHidden(this.doc, line) && cm) {\n        updateLineHeight(line, textHeight(cm.display));\n      }\n    }\n\n    if (cm && this.collapsed && !cm.options.lineWrapping) {\n      for (var i$1 = 0; i$1 < this.lines.length; ++i$1) {\n        var visual = visualLine(this.lines[i$1]),\n            len = lineLength(visual);\n\n        if (len > cm.display.maxLineLength) {\n          cm.display.maxLine = visual;\n          cm.display.maxLineLength = len;\n          cm.display.maxLineChanged = true;\n        }\n      }\n    }\n\n    if (min != null && cm && this.collapsed) {\n      regChange(cm, min, max + 1);\n    }\n\n    this.lines.length = 0;\n    this.explicitlyCleared = true;\n\n    if (this.atomic && this.doc.cantEdit) {\n      this.doc.cantEdit = false;\n\n      if (cm) {\n        reCheckSelection(cm.doc);\n      }\n    }\n\n    if (cm) {\n      signalLater(cm, \"markerCleared\", cm, this, min, max);\n    }\n\n    if (withOp) {\n      endOperation(cm);\n    }\n\n    if (this.parent) {\n      this.parent.clear();\n    }\n  }; // Find the position of the marker in the document. Returns a {from,\n  // to} object by default. Side can be passed to get a specific side\n  // -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the\n  // Pos objects returned contain a line object, rather than a line\n  // number (used to prevent looking up the same line twice).\n\n\n  TextMarker.prototype.find = function (side, lineObj) {\n    if (side == null && this.type == \"bookmark\") {\n      side = 1;\n    }\n\n    var from, to;\n\n    for (var i = 0; i < this.lines.length; ++i) {\n      var line = this.lines[i];\n      var span = getMarkedSpanFor(line.markedSpans, this);\n\n      if (span.from != null) {\n        from = Pos(lineObj ? line : lineNo(line), span.from);\n\n        if (side == -1) {\n          return from;\n        }\n      }\n\n      if (span.to != null) {\n        to = Pos(lineObj ? line : lineNo(line), span.to);\n\n        if (side == 1) {\n          return to;\n        }\n      }\n    }\n\n    return from && {\n      from: from,\n      to: to\n    };\n  }; // Signals that the marker's widget changed, and surrounding layout\n  // should be recomputed.\n\n\n  TextMarker.prototype.changed = function () {\n    var this$1 = this;\n    var pos = this.find(-1, true),\n        widget = this,\n        cm = this.doc.cm;\n\n    if (!pos || !cm) {\n      return;\n    }\n\n    runInOp(cm, function () {\n      var line = pos.line,\n          lineN = lineNo(pos.line);\n      var view = findViewForLine(cm, lineN);\n\n      if (view) {\n        clearLineMeasurementCacheFor(view);\n        cm.curOp.selectionChanged = cm.curOp.forceUpdate = true;\n      }\n\n      cm.curOp.updateMaxLine = true;\n\n      if (!lineIsHidden(widget.doc, line) && widget.height != null) {\n        var oldHeight = widget.height;\n        widget.height = null;\n        var dHeight = widgetHeight(widget) - oldHeight;\n\n        if (dHeight) {\n          updateLineHeight(line, line.height + dHeight);\n        }\n      }\n\n      signalLater(cm, \"markerChanged\", cm, this$1);\n    });\n  };\n\n  TextMarker.prototype.attachLine = function (line) {\n    if (!this.lines.length && this.doc.cm) {\n      var op = this.doc.cm.curOp;\n\n      if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1) {\n        (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this);\n      }\n    }\n\n    this.lines.push(line);\n  };\n\n  TextMarker.prototype.detachLine = function (line) {\n    this.lines.splice(indexOf(this.lines, line), 1);\n\n    if (!this.lines.length && this.doc.cm) {\n      var op = this.doc.cm.curOp;\n      (op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this);\n    }\n  };\n\n  eventMixin(TextMarker); // Create a marker, wire it up to the right lines, and\n\n  function markText(doc, from, to, options, type) {\n    // Shared markers (across linked documents) are handled separately\n    // (markTextShared will call out to this again, once per\n    // document).\n    if (options && options.shared) {\n      return markTextShared(doc, from, to, options, type);\n    } // Ensure we are in an operation.\n\n\n    if (doc.cm && !doc.cm.curOp) {\n      return operation(doc.cm, markText)(doc, from, to, options, type);\n    }\n\n    var marker = new TextMarker(doc, type),\n        diff = cmp(from, to);\n\n    if (options) {\n      copyObj(options, marker, false);\n    } // Don't connect empty markers unless clearWhenEmpty is false\n\n\n    if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false) {\n      return marker;\n    }\n\n    if (marker.replacedWith) {\n      // Showing up as a widget implies collapsed (widget replaces text)\n      marker.collapsed = true;\n      marker.widgetNode = eltP(\"span\", [marker.replacedWith], \"CodeMirror-widget\");\n\n      if (!options.handleMouseEvents) {\n        marker.widgetNode.setAttribute(\"cm-ignore-events\", \"true\");\n      }\n\n      if (options.insertLeft) {\n        marker.widgetNode.insertLeft = true;\n      }\n    }\n\n    if (marker.collapsed) {\n      if (conflictingCollapsedRange(doc, from.line, from, to, marker) || from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker)) {\n        throw new Error(\"Inserting collapsed marker partially overlapping an existing one\");\n      }\n\n      seeCollapsedSpans();\n    }\n\n    if (marker.addToHistory) {\n      addChangeToHistory(doc, {\n        from: from,\n        to: to,\n        origin: \"markText\"\n      }, doc.sel, NaN);\n    }\n\n    var curLine = from.line,\n        cm = doc.cm,\n        updateMaxLine;\n    doc.iter(curLine, to.line + 1, function (line) {\n      if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine) {\n        updateMaxLine = true;\n      }\n\n      if (marker.collapsed && curLine != from.line) {\n        updateLineHeight(line, 0);\n      }\n\n      addMarkedSpan(line, new MarkedSpan(marker, curLine == from.line ? from.ch : null, curLine == to.line ? to.ch : null));\n      ++curLine;\n    }); // lineIsHidden depends on the presence of the spans, so needs a second pass\n\n    if (marker.collapsed) {\n      doc.iter(from.line, to.line + 1, function (line) {\n        if (lineIsHidden(doc, line)) {\n          updateLineHeight(line, 0);\n        }\n      });\n    }\n\n    if (marker.clearOnEnter) {\n      on(marker, \"beforeCursorEnter\", function () {\n        return marker.clear();\n      });\n    }\n\n    if (marker.readOnly) {\n      seeReadOnlySpans();\n\n      if (doc.history.done.length || doc.history.undone.length) {\n        doc.clearHistory();\n      }\n    }\n\n    if (marker.collapsed) {\n      marker.id = ++nextMarkerId;\n      marker.atomic = true;\n    }\n\n    if (cm) {\n      // Sync editor state\n      if (updateMaxLine) {\n        cm.curOp.updateMaxLine = true;\n      }\n\n      if (marker.collapsed) {\n        regChange(cm, from.line, to.line + 1);\n      } else if (marker.className || marker.startStyle || marker.endStyle || marker.css || marker.attributes || marker.title) {\n        for (var i = from.line; i <= to.line; i++) {\n          regLineChange(cm, i, \"text\");\n        }\n      }\n\n      if (marker.atomic) {\n        reCheckSelection(cm.doc);\n      }\n\n      signalLater(cm, \"markerAdded\", cm, marker);\n    }\n\n    return marker;\n  } // SHARED TEXTMARKERS\n  // A shared marker spans multiple linked documents. It is\n  // implemented as a meta-marker-object controlling multiple normal\n  // markers.\n\n\n  var SharedTextMarker = function (markers, primary) {\n    this.markers = markers;\n    this.primary = primary;\n\n    for (var i = 0; i < markers.length; ++i) {\n      markers[i].parent = this;\n    }\n  };\n\n  SharedTextMarker.prototype.clear = function () {\n    if (this.explicitlyCleared) {\n      return;\n    }\n\n    this.explicitlyCleared = true;\n\n    for (var i = 0; i < this.markers.length; ++i) {\n      this.markers[i].clear();\n    }\n\n    signalLater(this, \"clear\");\n  };\n\n  SharedTextMarker.prototype.find = function (side, lineObj) {\n    return this.primary.find(side, lineObj);\n  };\n\n  eventMixin(SharedTextMarker);\n\n  function markTextShared(doc, from, to, options, type) {\n    options = copyObj(options);\n    options.shared = false;\n    var markers = [markText(doc, from, to, options, type)],\n        primary = markers[0];\n    var widget = options.widgetNode;\n    linkedDocs(doc, function (doc) {\n      if (widget) {\n        options.widgetNode = widget.cloneNode(true);\n      }\n\n      markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type));\n\n      for (var i = 0; i < doc.linked.length; ++i) {\n        if (doc.linked[i].isParent) {\n          return;\n        }\n      }\n\n      primary = lst(markers);\n    });\n    return new SharedTextMarker(markers, primary);\n  }\n\n  function findSharedMarkers(doc) {\n    return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) {\n      return m.parent;\n    });\n  }\n\n  function copySharedMarkers(doc, markers) {\n    for (var i = 0; i < markers.length; i++) {\n      var marker = markers[i],\n          pos = marker.find();\n      var mFrom = doc.clipPos(pos.from),\n          mTo = doc.clipPos(pos.to);\n\n      if (cmp(mFrom, mTo)) {\n        var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type);\n        marker.markers.push(subMark);\n        subMark.parent = marker;\n      }\n    }\n  }\n\n  function detachSharedMarkers(markers) {\n    var loop = function (i) {\n      var marker = markers[i],\n          linked = [marker.primary.doc];\n      linkedDocs(marker.primary.doc, function (d) {\n        return linked.push(d);\n      });\n\n      for (var j = 0; j < marker.markers.length; j++) {\n        var subMarker = marker.markers[j];\n\n        if (indexOf(linked, subMarker.doc) == -1) {\n          subMarker.parent = null;\n          marker.markers.splice(j--, 1);\n        }\n      }\n    };\n\n    for (var i = 0; i < markers.length; i++) loop(i);\n  }\n\n  var nextDocId = 0;\n\n  var Doc = function (text, mode, firstLine, lineSep, direction) {\n    if (!(this instanceof Doc)) {\n      return new Doc(text, mode, firstLine, lineSep, direction);\n    }\n\n    if (firstLine == null) {\n      firstLine = 0;\n    }\n\n    BranchChunk.call(this, [new LeafChunk([new Line(\"\", null)])]);\n    this.first = firstLine;\n    this.scrollTop = this.scrollLeft = 0;\n    this.cantEdit = false;\n    this.cleanGeneration = 1;\n    this.modeFrontier = this.highlightFrontier = firstLine;\n    var start = Pos(firstLine, 0);\n    this.sel = simpleSelection(start);\n    this.history = new History(null);\n    this.id = ++nextDocId;\n    this.modeOption = mode;\n    this.lineSep = lineSep;\n    this.direction = direction == \"rtl\" ? \"rtl\" : \"ltr\";\n    this.extend = false;\n\n    if (typeof text == \"string\") {\n      text = this.splitLines(text);\n    }\n\n    updateDoc(this, {\n      from: start,\n      to: start,\n      text: text\n    });\n    setSelection(this, simpleSelection(start), sel_dontScroll);\n  };\n\n  Doc.prototype = createObj(BranchChunk.prototype, {\n    constructor: Doc,\n    // Iterate over the document. Supports two forms -- with only one\n    // argument, it calls that for each line in the document. With\n    // three, it iterates over the range given by the first two (with\n    // the second being non-inclusive).\n    iter: function (from, to, op) {\n      if (op) {\n        this.iterN(from - this.first, to - from, op);\n      } else {\n        this.iterN(this.first, this.first + this.size, from);\n      }\n    },\n    // Non-public interface for adding and removing lines.\n    insert: function (at, lines) {\n      var height = 0;\n\n      for (var i = 0; i < lines.length; ++i) {\n        height += lines[i].height;\n      }\n\n      this.insertInner(at - this.first, lines, height);\n    },\n    remove: function (at, n) {\n      this.removeInner(at - this.first, n);\n    },\n    // From here, the methods are part of the public interface. Most\n    // are also available from CodeMirror (editor) instances.\n    getValue: function (lineSep) {\n      var lines = getLines(this, this.first, this.first + this.size);\n\n      if (lineSep === false) {\n        return lines;\n      }\n\n      return lines.join(lineSep || this.lineSeparator());\n    },\n    setValue: docMethodOp(function (code) {\n      var top = Pos(this.first, 0),\n          last = this.first + this.size - 1;\n      makeChange(this, {\n        from: top,\n        to: Pos(last, getLine(this, last).text.length),\n        text: this.splitLines(code),\n        origin: \"setValue\",\n        full: true\n      }, true);\n\n      if (this.cm) {\n        scrollToCoords(this.cm, 0, 0);\n      }\n\n      setSelection(this, simpleSelection(top), sel_dontScroll);\n    }),\n    replaceRange: function (code, from, to, origin) {\n      from = clipPos(this, from);\n      to = to ? clipPos(this, to) : from;\n      replaceRange(this, code, from, to, origin);\n    },\n    getRange: function (from, to, lineSep) {\n      var lines = getBetween(this, clipPos(this, from), clipPos(this, to));\n\n      if (lineSep === false) {\n        return lines;\n      }\n\n      return lines.join(lineSep || this.lineSeparator());\n    },\n    getLine: function (line) {\n      var l = this.getLineHandle(line);\n      return l && l.text;\n    },\n    getLineHandle: function (line) {\n      if (isLine(this, line)) {\n        return getLine(this, line);\n      }\n    },\n    getLineNumber: function (line) {\n      return lineNo(line);\n    },\n    getLineHandleVisualStart: function (line) {\n      if (typeof line == \"number\") {\n        line = getLine(this, line);\n      }\n\n      return visualLine(line);\n    },\n    lineCount: function () {\n      return this.size;\n    },\n    firstLine: function () {\n      return this.first;\n    },\n    lastLine: function () {\n      return this.first + this.size - 1;\n    },\n    clipPos: function (pos) {\n      return clipPos(this, pos);\n    },\n    getCursor: function (start) {\n      var range = this.sel.primary(),\n          pos;\n\n      if (start == null || start == \"head\") {\n        pos = range.head;\n      } else if (start == \"anchor\") {\n        pos = range.anchor;\n      } else if (start == \"end\" || start == \"to\" || start === false) {\n        pos = range.to();\n      } else {\n        pos = range.from();\n      }\n\n      return pos;\n    },\n    listSelections: function () {\n      return this.sel.ranges;\n    },\n    somethingSelected: function () {\n      return this.sel.somethingSelected();\n    },\n    setCursor: docMethodOp(function (line, ch, options) {\n      setSimpleSelection(this, clipPos(this, typeof line == \"number\" ? Pos(line, ch || 0) : line), null, options);\n    }),\n    setSelection: docMethodOp(function (anchor, head, options) {\n      setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options);\n    }),\n    extendSelection: docMethodOp(function (head, other, options) {\n      extendSelection(this, clipPos(this, head), other && clipPos(this, other), options);\n    }),\n    extendSelections: docMethodOp(function (heads, options) {\n      extendSelections(this, clipPosArray(this, heads), options);\n    }),\n    extendSelectionsBy: docMethodOp(function (f, options) {\n      var heads = map(this.sel.ranges, f);\n      extendSelections(this, clipPosArray(this, heads), options);\n    }),\n    setSelections: docMethodOp(function (ranges, primary, options) {\n      if (!ranges.length) {\n        return;\n      }\n\n      var out = [];\n\n      for (var i = 0; i < ranges.length; i++) {\n        out[i] = new Range(clipPos(this, ranges[i].anchor), clipPos(this, ranges[i].head));\n      }\n\n      if (primary == null) {\n        primary = Math.min(ranges.length - 1, this.sel.primIndex);\n      }\n\n      setSelection(this, normalizeSelection(this.cm, out, primary), options);\n    }),\n    addSelection: docMethodOp(function (anchor, head, options) {\n      var ranges = this.sel.ranges.slice(0);\n      ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)));\n      setSelection(this, normalizeSelection(this.cm, ranges, ranges.length - 1), options);\n    }),\n    getSelection: function (lineSep) {\n      var ranges = this.sel.ranges,\n          lines;\n\n      for (var i = 0; i < ranges.length; i++) {\n        var sel = getBetween(this, ranges[i].from(), ranges[i].to());\n        lines = lines ? lines.concat(sel) : sel;\n      }\n\n      if (lineSep === false) {\n        return lines;\n      } else {\n        return lines.join(lineSep || this.lineSeparator());\n      }\n    },\n    getSelections: function (lineSep) {\n      var parts = [],\n          ranges = this.sel.ranges;\n\n      for (var i = 0; i < ranges.length; i++) {\n        var sel = getBetween(this, ranges[i].from(), ranges[i].to());\n\n        if (lineSep !== false) {\n          sel = sel.join(lineSep || this.lineSeparator());\n        }\n\n        parts[i] = sel;\n      }\n\n      return parts;\n    },\n    replaceSelection: function (code, collapse, origin) {\n      var dup = [];\n\n      for (var i = 0; i < this.sel.ranges.length; i++) {\n        dup[i] = code;\n      }\n\n      this.replaceSelections(dup, collapse, origin || \"+input\");\n    },\n    replaceSelections: docMethodOp(function (code, collapse, origin) {\n      var changes = [],\n          sel = this.sel;\n\n      for (var i = 0; i < sel.ranges.length; i++) {\n        var range = sel.ranges[i];\n        changes[i] = {\n          from: range.from(),\n          to: range.to(),\n          text: this.splitLines(code[i]),\n          origin: origin\n        };\n      }\n\n      var newSel = collapse && collapse != \"end\" && computeReplacedSel(this, changes, collapse);\n\n      for (var i$1 = changes.length - 1; i$1 >= 0; i$1--) {\n        makeChange(this, changes[i$1]);\n      }\n\n      if (newSel) {\n        setSelectionReplaceHistory(this, newSel);\n      } else if (this.cm) {\n        ensureCursorVisible(this.cm);\n      }\n    }),\n    undo: docMethodOp(function () {\n      makeChangeFromHistory(this, \"undo\");\n    }),\n    redo: docMethodOp(function () {\n      makeChangeFromHistory(this, \"redo\");\n    }),\n    undoSelection: docMethodOp(function () {\n      makeChangeFromHistory(this, \"undo\", true);\n    }),\n    redoSelection: docMethodOp(function () {\n      makeChangeFromHistory(this, \"redo\", true);\n    }),\n    setExtending: function (val) {\n      this.extend = val;\n    },\n    getExtending: function () {\n      return this.extend;\n    },\n    historySize: function () {\n      var hist = this.history,\n          done = 0,\n          undone = 0;\n\n      for (var i = 0; i < hist.done.length; i++) {\n        if (!hist.done[i].ranges) {\n          ++done;\n        }\n      }\n\n      for (var i$1 = 0; i$1 < hist.undone.length; i$1++) {\n        if (!hist.undone[i$1].ranges) {\n          ++undone;\n        }\n      }\n\n      return {\n        undo: done,\n        redo: undone\n      };\n    },\n    clearHistory: function () {\n      var this$1 = this;\n      this.history = new History(this.history.maxGeneration);\n      linkedDocs(this, function (doc) {\n        return doc.history = this$1.history;\n      }, true);\n    },\n    markClean: function () {\n      this.cleanGeneration = this.changeGeneration(true);\n    },\n    changeGeneration: function (forceSplit) {\n      if (forceSplit) {\n        this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null;\n      }\n\n      return this.history.generation;\n    },\n    isClean: function (gen) {\n      return this.history.generation == (gen || this.cleanGeneration);\n    },\n    getHistory: function () {\n      return {\n        done: copyHistoryArray(this.history.done),\n        undone: copyHistoryArray(this.history.undone)\n      };\n    },\n    setHistory: function (histData) {\n      var hist = this.history = new History(this.history.maxGeneration);\n      hist.done = copyHistoryArray(histData.done.slice(0), null, true);\n      hist.undone = copyHistoryArray(histData.undone.slice(0), null, true);\n    },\n    setGutterMarker: docMethodOp(function (line, gutterID, value) {\n      return changeLine(this, line, \"gutter\", function (line) {\n        var markers = line.gutterMarkers || (line.gutterMarkers = {});\n        markers[gutterID] = value;\n\n        if (!value && isEmpty(markers)) {\n          line.gutterMarkers = null;\n        }\n\n        return true;\n      });\n    }),\n    clearGutter: docMethodOp(function (gutterID) {\n      var this$1 = this;\n      this.iter(function (line) {\n        if (line.gutterMarkers && line.gutterMarkers[gutterID]) {\n          changeLine(this$1, line, \"gutter\", function () {\n            line.gutterMarkers[gutterID] = null;\n\n            if (isEmpty(line.gutterMarkers)) {\n              line.gutterMarkers = null;\n            }\n\n            return true;\n          });\n        }\n      });\n    }),\n    lineInfo: function (line) {\n      var n;\n\n      if (typeof line == \"number\") {\n        if (!isLine(this, line)) {\n          return null;\n        }\n\n        n = line;\n        line = getLine(this, line);\n\n        if (!line) {\n          return null;\n        }\n      } else {\n        n = lineNo(line);\n\n        if (n == null) {\n          return null;\n        }\n      }\n\n      return {\n        line: n,\n        handle: line,\n        text: line.text,\n        gutterMarkers: line.gutterMarkers,\n        textClass: line.textClass,\n        bgClass: line.bgClass,\n        wrapClass: line.wrapClass,\n        widgets: line.widgets\n      };\n    },\n    addLineClass: docMethodOp(function (handle, where, cls) {\n      return changeLine(this, handle, where == \"gutter\" ? \"gutter\" : \"class\", function (line) {\n        var prop = where == \"text\" ? \"textClass\" : where == \"background\" ? \"bgClass\" : where == \"gutter\" ? \"gutterClass\" : \"wrapClass\";\n\n        if (!line[prop]) {\n          line[prop] = cls;\n        } else if (classTest(cls).test(line[prop])) {\n          return false;\n        } else {\n          line[prop] += \" \" + cls;\n        }\n\n        return true;\n      });\n    }),\n    removeLineClass: docMethodOp(function (handle, where, cls) {\n      return changeLine(this, handle, where == \"gutter\" ? \"gutter\" : \"class\", function (line) {\n        var prop = where == \"text\" ? \"textClass\" : where == \"background\" ? \"bgClass\" : where == \"gutter\" ? \"gutterClass\" : \"wrapClass\";\n        var cur = line[prop];\n\n        if (!cur) {\n          return false;\n        } else if (cls == null) {\n          line[prop] = null;\n        } else {\n          var found = cur.match(classTest(cls));\n\n          if (!found) {\n            return false;\n          }\n\n          var end = found.index + found[0].length;\n          line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? \"\" : \" \") + cur.slice(end) || null;\n        }\n\n        return true;\n      });\n    }),\n    addLineWidget: docMethodOp(function (handle, node, options) {\n      return addLineWidget(this, handle, node, options);\n    }),\n    removeLineWidget: function (widget) {\n      widget.clear();\n    },\n    markText: function (from, to, options) {\n      return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || \"range\");\n    },\n    setBookmark: function (pos, options) {\n      var realOpts = {\n        replacedWith: options && (options.nodeType == null ? options.widget : options),\n        insertLeft: options && options.insertLeft,\n        clearWhenEmpty: false,\n        shared: options && options.shared,\n        handleMouseEvents: options && options.handleMouseEvents\n      };\n      pos = clipPos(this, pos);\n      return markText(this, pos, pos, realOpts, \"bookmark\");\n    },\n    findMarksAt: function (pos) {\n      pos = clipPos(this, pos);\n      var markers = [],\n          spans = getLine(this, pos.line).markedSpans;\n\n      if (spans) {\n        for (var i = 0; i < spans.length; ++i) {\n          var span = spans[i];\n\n          if ((span.from == null || span.from <= pos.ch) && (span.to == null || span.to >= pos.ch)) {\n            markers.push(span.marker.parent || span.marker);\n          }\n        }\n      }\n\n      return markers;\n    },\n    findMarks: function (from, to, filter) {\n      from = clipPos(this, from);\n      to = clipPos(this, to);\n      var found = [],\n          lineNo = from.line;\n      this.iter(from.line, to.line + 1, function (line) {\n        var spans = line.markedSpans;\n\n        if (spans) {\n          for (var i = 0; i < spans.length; i++) {\n            var span = spans[i];\n\n            if (!(span.to != null && lineNo == from.line && from.ch >= span.to || span.from == null && lineNo != from.line || span.from != null && lineNo == to.line && span.from >= to.ch) && (!filter || filter(span.marker))) {\n              found.push(span.marker.parent || span.marker);\n            }\n          }\n        }\n\n        ++lineNo;\n      });\n      return found;\n    },\n    getAllMarks: function () {\n      var markers = [];\n      this.iter(function (line) {\n        var sps = line.markedSpans;\n\n        if (sps) {\n          for (var i = 0; i < sps.length; ++i) {\n            if (sps[i].from != null) {\n              markers.push(sps[i].marker);\n            }\n          }\n        }\n      });\n      return markers;\n    },\n    posFromIndex: function (off) {\n      var ch,\n          lineNo = this.first,\n          sepSize = this.lineSeparator().length;\n      this.iter(function (line) {\n        var sz = line.text.length + sepSize;\n\n        if (sz > off) {\n          ch = off;\n          return true;\n        }\n\n        off -= sz;\n        ++lineNo;\n      });\n      return clipPos(this, Pos(lineNo, ch));\n    },\n    indexFromPos: function (coords) {\n      coords = clipPos(this, coords);\n      var index = coords.ch;\n\n      if (coords.line < this.first || coords.ch < 0) {\n        return 0;\n      }\n\n      var sepSize = this.lineSeparator().length;\n      this.iter(this.first, coords.line, function (line) {\n        // iter aborts when callback returns a truthy value\n        index += line.text.length + sepSize;\n      });\n      return index;\n    },\n    copy: function (copyHistory) {\n      var doc = new Doc(getLines(this, this.first, this.first + this.size), this.modeOption, this.first, this.lineSep, this.direction);\n      doc.scrollTop = this.scrollTop;\n      doc.scrollLeft = this.scrollLeft;\n      doc.sel = this.sel;\n      doc.extend = false;\n\n      if (copyHistory) {\n        doc.history.undoDepth = this.history.undoDepth;\n        doc.setHistory(this.getHistory());\n      }\n\n      return doc;\n    },\n    linkedDoc: function (options) {\n      if (!options) {\n        options = {};\n      }\n\n      var from = this.first,\n          to = this.first + this.size;\n\n      if (options.from != null && options.from > from) {\n        from = options.from;\n      }\n\n      if (options.to != null && options.to < to) {\n        to = options.to;\n      }\n\n      var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep, this.direction);\n\n      if (options.sharedHist) {\n        copy.history = this.history;\n      }\n\n      (this.linked || (this.linked = [])).push({\n        doc: copy,\n        sharedHist: options.sharedHist\n      });\n      copy.linked = [{\n        doc: this,\n        isParent: true,\n        sharedHist: options.sharedHist\n      }];\n      copySharedMarkers(copy, findSharedMarkers(this));\n      return copy;\n    },\n    unlinkDoc: function (other) {\n      if (other instanceof CodeMirror) {\n        other = other.doc;\n      }\n\n      if (this.linked) {\n        for (var i = 0; i < this.linked.length; ++i) {\n          var link = this.linked[i];\n\n          if (link.doc != other) {\n            continue;\n          }\n\n          this.linked.splice(i, 1);\n          other.unlinkDoc(this);\n          detachSharedMarkers(findSharedMarkers(this));\n          break;\n        }\n      } // If the histories were shared, split them again\n\n\n      if (other.history == this.history) {\n        var splitIds = [other.id];\n        linkedDocs(other, function (doc) {\n          return splitIds.push(doc.id);\n        }, true);\n        other.history = new History(null);\n        other.history.done = copyHistoryArray(this.history.done, splitIds);\n        other.history.undone = copyHistoryArray(this.history.undone, splitIds);\n      }\n    },\n    iterLinkedDocs: function (f) {\n      linkedDocs(this, f);\n    },\n    getMode: function () {\n      return this.mode;\n    },\n    getEditor: function () {\n      return this.cm;\n    },\n    splitLines: function (str) {\n      if (this.lineSep) {\n        return str.split(this.lineSep);\n      }\n\n      return splitLinesAuto(str);\n    },\n    lineSeparator: function () {\n      return this.lineSep || \"\\n\";\n    },\n    setDirection: docMethodOp(function (dir) {\n      if (dir != \"rtl\") {\n        dir = \"ltr\";\n      }\n\n      if (dir == this.direction) {\n        return;\n      }\n\n      this.direction = dir;\n      this.iter(function (line) {\n        return line.order = null;\n      });\n\n      if (this.cm) {\n        directionChanged(this.cm);\n      }\n    })\n  }); // Public alias.\n\n  Doc.prototype.eachLine = Doc.prototype.iter; // Kludge to work around strange IE behavior where it'll sometimes\n  // re-fire a series of drag-related events right after the drop (#1551)\n\n  var lastDrop = 0;\n\n  function onDrop(e) {\n    var cm = this;\n    clearDragCursor(cm);\n\n    if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) {\n      return;\n    }\n\n    e_preventDefault(e);\n\n    if (ie) {\n      lastDrop = +new Date();\n    }\n\n    var pos = posFromMouse(cm, e, true),\n        files = e.dataTransfer.files;\n\n    if (!pos || cm.isReadOnly()) {\n      return;\n    } // Might be a file drop, in which case we simply extract the text\n    // and insert it.\n\n\n    if (files && files.length && window.FileReader && window.File) {\n      var n = files.length,\n          text = Array(n),\n          read = 0;\n\n      var markAsReadAndPasteIfAllFilesAreRead = function () {\n        if (++read == n) {\n          operation(cm, function () {\n            pos = clipPos(cm.doc, pos);\n            var change = {\n              from: pos,\n              to: pos,\n              text: cm.doc.splitLines(text.filter(function (t) {\n                return t != null;\n              }).join(cm.doc.lineSeparator())),\n              origin: \"paste\"\n            };\n            makeChange(cm.doc, change);\n            setSelectionReplaceHistory(cm.doc, simpleSelection(clipPos(cm.doc, pos), clipPos(cm.doc, changeEnd(change))));\n          })();\n        }\n      };\n\n      var readTextFromFile = function (file, i) {\n        if (cm.options.allowDropFileTypes && indexOf(cm.options.allowDropFileTypes, file.type) == -1) {\n          markAsReadAndPasteIfAllFilesAreRead();\n          return;\n        }\n\n        var reader = new FileReader();\n\n        reader.onerror = function () {\n          return markAsReadAndPasteIfAllFilesAreRead();\n        };\n\n        reader.onload = function () {\n          var content = reader.result;\n\n          if (/[\\x00-\\x08\\x0e-\\x1f]{2}/.test(content)) {\n            markAsReadAndPasteIfAllFilesAreRead();\n            return;\n          }\n\n          text[i] = content;\n          markAsReadAndPasteIfAllFilesAreRead();\n        };\n\n        reader.readAsText(file);\n      };\n\n      for (var i = 0; i < files.length; i++) {\n        readTextFromFile(files[i], i);\n      }\n    } else {\n      // Normal drop\n      // Don't do a replace if the drop happened inside of the selected text.\n      if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {\n        cm.state.draggingText(e); // Ensure the editor is re-focused\n\n        setTimeout(function () {\n          return cm.display.input.focus();\n        }, 20);\n        return;\n      }\n\n      try {\n        var text$1 = e.dataTransfer.getData(\"Text\");\n\n        if (text$1) {\n          var selected;\n\n          if (cm.state.draggingText && !cm.state.draggingText.copy) {\n            selected = cm.listSelections();\n          }\n\n          setSelectionNoUndo(cm.doc, simpleSelection(pos, pos));\n\n          if (selected) {\n            for (var i$1 = 0; i$1 < selected.length; ++i$1) {\n              replaceRange(cm.doc, \"\", selected[i$1].anchor, selected[i$1].head, \"drag\");\n            }\n          }\n\n          cm.replaceSelection(text$1, \"around\", \"paste\");\n          cm.display.input.focus();\n        }\n      } catch (e$1) {}\n    }\n  }\n\n  function onDragStart(cm, e) {\n    if (ie && (!cm.state.draggingText || +new Date() - lastDrop < 100)) {\n      e_stop(e);\n      return;\n    }\n\n    if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) {\n      return;\n    }\n\n    e.dataTransfer.setData(\"Text\", cm.getSelection());\n    e.dataTransfer.effectAllowed = \"copyMove\"; // Use dummy image instead of default browsers image.\n    // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.\n\n    if (e.dataTransfer.setDragImage && !safari) {\n      var img = elt(\"img\", null, null, \"position: fixed; left: 0; top: 0;\");\n      img.src = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\n      if (presto) {\n        img.width = img.height = 1;\n        cm.display.wrapper.appendChild(img); // Force a relayout, or Opera won't use our image for some obscure reason\n\n        img._top = img.offsetTop;\n      }\n\n      e.dataTransfer.setDragImage(img, 0, 0);\n\n      if (presto) {\n        img.parentNode.removeChild(img);\n      }\n    }\n  }\n\n  function onDragOver(cm, e) {\n    var pos = posFromMouse(cm, e);\n\n    if (!pos) {\n      return;\n    }\n\n    var frag = document.createDocumentFragment();\n    drawSelectionCursor(cm, pos, frag);\n\n    if (!cm.display.dragCursor) {\n      cm.display.dragCursor = elt(\"div\", null, \"CodeMirror-cursors CodeMirror-dragcursors\");\n      cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv);\n    }\n\n    removeChildrenAndAdd(cm.display.dragCursor, frag);\n  }\n\n  function clearDragCursor(cm) {\n    if (cm.display.dragCursor) {\n      cm.display.lineSpace.removeChild(cm.display.dragCursor);\n      cm.display.dragCursor = null;\n    }\n  } // These must be handled carefully, because naively registering a\n  // handler for each editor will cause the editors to never be\n  // garbage collected.\n\n\n  function forEachCodeMirror(f) {\n    if (!document.getElementsByClassName) {\n      return;\n    }\n\n    var byClass = document.getElementsByClassName(\"CodeMirror\"),\n        editors = [];\n\n    for (var i = 0; i < byClass.length; i++) {\n      var cm = byClass[i].CodeMirror;\n\n      if (cm) {\n        editors.push(cm);\n      }\n    }\n\n    if (editors.length) {\n      editors[0].operation(function () {\n        for (var i = 0; i < editors.length; i++) {\n          f(editors[i]);\n        }\n      });\n    }\n  }\n\n  var globalsRegistered = false;\n\n  function ensureGlobalHandlers() {\n    if (globalsRegistered) {\n      return;\n    }\n\n    registerGlobalHandlers();\n    globalsRegistered = true;\n  }\n\n  function registerGlobalHandlers() {\n    // When the window resizes, we need to refresh active editors.\n    var resizeTimer;\n    on(window, \"resize\", function () {\n      if (resizeTimer == null) {\n        resizeTimer = setTimeout(function () {\n          resizeTimer = null;\n          forEachCodeMirror(onResize);\n        }, 100);\n      }\n    }); // When the window loses focus, we want to show the editor as blurred\n\n    on(window, \"blur\", function () {\n      return forEachCodeMirror(onBlur);\n    });\n  } // Called when the window resizes\n\n\n  function onResize(cm) {\n    var d = cm.display; // Might be a text scaling operation, clear size caches.\n\n    d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;\n    d.scrollbarsClipped = false;\n    cm.setSize();\n  }\n\n  var keyNames = {\n    3: \"Pause\",\n    8: \"Backspace\",\n    9: \"Tab\",\n    13: \"Enter\",\n    16: \"Shift\",\n    17: \"Ctrl\",\n    18: \"Alt\",\n    19: \"Pause\",\n    20: \"CapsLock\",\n    27: \"Esc\",\n    32: \"Space\",\n    33: \"PageUp\",\n    34: \"PageDown\",\n    35: \"End\",\n    36: \"Home\",\n    37: \"Left\",\n    38: \"Up\",\n    39: \"Right\",\n    40: \"Down\",\n    44: \"PrintScrn\",\n    45: \"Insert\",\n    46: \"Delete\",\n    59: \";\",\n    61: \"=\",\n    91: \"Mod\",\n    92: \"Mod\",\n    93: \"Mod\",\n    106: \"*\",\n    107: \"=\",\n    109: \"-\",\n    110: \".\",\n    111: \"/\",\n    145: \"ScrollLock\",\n    173: \"-\",\n    186: \";\",\n    187: \"=\",\n    188: \",\",\n    189: \"-\",\n    190: \".\",\n    191: \"/\",\n    192: \"`\",\n    219: \"[\",\n    220: \"\\\\\",\n    221: \"]\",\n    222: \"'\",\n    63232: \"Up\",\n    63233: \"Down\",\n    63234: \"Left\",\n    63235: \"Right\",\n    63272: \"Delete\",\n    63273: \"Home\",\n    63275: \"End\",\n    63276: \"PageUp\",\n    63277: \"PageDown\",\n    63302: \"Insert\"\n  }; // Number keys\n\n  for (var i = 0; i < 10; i++) {\n    keyNames[i + 48] = keyNames[i + 96] = String(i);\n  } // Alphabetic keys\n\n\n  for (var i$1 = 65; i$1 <= 90; i$1++) {\n    keyNames[i$1] = String.fromCharCode(i$1);\n  } // Function keys\n\n\n  for (var i$2 = 1; i$2 <= 12; i$2++) {\n    keyNames[i$2 + 111] = keyNames[i$2 + 63235] = \"F\" + i$2;\n  }\n\n  var keyMap = {};\n  keyMap.basic = {\n    \"Left\": \"goCharLeft\",\n    \"Right\": \"goCharRight\",\n    \"Up\": \"goLineUp\",\n    \"Down\": \"goLineDown\",\n    \"End\": \"goLineEnd\",\n    \"Home\": \"goLineStartSmart\",\n    \"PageUp\": \"goPageUp\",\n    \"PageDown\": \"goPageDown\",\n    \"Delete\": \"delCharAfter\",\n    \"Backspace\": \"delCharBefore\",\n    \"Shift-Backspace\": \"delCharBefore\",\n    \"Tab\": \"defaultTab\",\n    \"Shift-Tab\": \"indentAuto\",\n    \"Enter\": \"newlineAndIndent\",\n    \"Insert\": \"toggleOverwrite\",\n    \"Esc\": \"singleSelection\"\n  }; // Note that the save and find-related commands aren't defined by\n  // default. User code or addons can define them. Unknown commands\n  // are simply ignored.\n\n  keyMap.pcDefault = {\n    \"Ctrl-A\": \"selectAll\",\n    \"Ctrl-D\": \"deleteLine\",\n    \"Ctrl-Z\": \"undo\",\n    \"Shift-Ctrl-Z\": \"redo\",\n    \"Ctrl-Y\": \"redo\",\n    \"Ctrl-Home\": \"goDocStart\",\n    \"Ctrl-End\": \"goDocEnd\",\n    \"Ctrl-Up\": \"goLineUp\",\n    \"Ctrl-Down\": \"goLineDown\",\n    \"Ctrl-Left\": \"goGroupLeft\",\n    \"Ctrl-Right\": \"goGroupRight\",\n    \"Alt-Left\": \"goLineStart\",\n    \"Alt-Right\": \"goLineEnd\",\n    \"Ctrl-Backspace\": \"delGroupBefore\",\n    \"Ctrl-Delete\": \"delGroupAfter\",\n    \"Ctrl-S\": \"save\",\n    \"Ctrl-F\": \"find\",\n    \"Ctrl-G\": \"findNext\",\n    \"Shift-Ctrl-G\": \"findPrev\",\n    \"Shift-Ctrl-F\": \"replace\",\n    \"Shift-Ctrl-R\": \"replaceAll\",\n    \"Ctrl-[\": \"indentLess\",\n    \"Ctrl-]\": \"indentMore\",\n    \"Ctrl-U\": \"undoSelection\",\n    \"Shift-Ctrl-U\": \"redoSelection\",\n    \"Alt-U\": \"redoSelection\",\n    \"fallthrough\": \"basic\"\n  }; // Very basic readline/emacs-style bindings, which are standard on Mac.\n\n  keyMap.emacsy = {\n    \"Ctrl-F\": \"goCharRight\",\n    \"Ctrl-B\": \"goCharLeft\",\n    \"Ctrl-P\": \"goLineUp\",\n    \"Ctrl-N\": \"goLineDown\",\n    \"Alt-F\": \"goWordRight\",\n    \"Alt-B\": \"goWordLeft\",\n    \"Ctrl-A\": \"goLineStart\",\n    \"Ctrl-E\": \"goLineEnd\",\n    \"Ctrl-V\": \"goPageDown\",\n    \"Shift-Ctrl-V\": \"goPageUp\",\n    \"Ctrl-D\": \"delCharAfter\",\n    \"Ctrl-H\": \"delCharBefore\",\n    \"Alt-D\": \"delWordAfter\",\n    \"Alt-Backspace\": \"delWordBefore\",\n    \"Ctrl-K\": \"killLine\",\n    \"Ctrl-T\": \"transposeChars\",\n    \"Ctrl-O\": \"openLine\"\n  };\n  keyMap.macDefault = {\n    \"Cmd-A\": \"selectAll\",\n    \"Cmd-D\": \"deleteLine\",\n    \"Cmd-Z\": \"undo\",\n    \"Shift-Cmd-Z\": \"redo\",\n    \"Cmd-Y\": \"redo\",\n    \"Cmd-Home\": \"goDocStart\",\n    \"Cmd-Up\": \"goDocStart\",\n    \"Cmd-End\": \"goDocEnd\",\n    \"Cmd-Down\": \"goDocEnd\",\n    \"Alt-Left\": \"goGroupLeft\",\n    \"Alt-Right\": \"goGroupRight\",\n    \"Cmd-Left\": \"goLineLeft\",\n    \"Cmd-Right\": \"goLineRight\",\n    \"Alt-Backspace\": \"delGroupBefore\",\n    \"Ctrl-Alt-Backspace\": \"delGroupAfter\",\n    \"Alt-Delete\": \"delGroupAfter\",\n    \"Cmd-S\": \"save\",\n    \"Cmd-F\": \"find\",\n    \"Cmd-G\": \"findNext\",\n    \"Shift-Cmd-G\": \"findPrev\",\n    \"Cmd-Alt-F\": \"replace\",\n    \"Shift-Cmd-Alt-F\": \"replaceAll\",\n    \"Cmd-[\": \"indentLess\",\n    \"Cmd-]\": \"indentMore\",\n    \"Cmd-Backspace\": \"delWrappedLineLeft\",\n    \"Cmd-Delete\": \"delWrappedLineRight\",\n    \"Cmd-U\": \"undoSelection\",\n    \"Shift-Cmd-U\": \"redoSelection\",\n    \"Ctrl-Up\": \"goDocStart\",\n    \"Ctrl-Down\": \"goDocEnd\",\n    \"fallthrough\": [\"basic\", \"emacsy\"]\n  };\n  keyMap[\"default\"] = mac ? keyMap.macDefault : keyMap.pcDefault; // KEYMAP DISPATCH\n\n  function normalizeKeyName(name) {\n    var parts = name.split(/-(?!$)/);\n    name = parts[parts.length - 1];\n    var alt, ctrl, shift, cmd;\n\n    for (var i = 0; i < parts.length - 1; i++) {\n      var mod = parts[i];\n\n      if (/^(cmd|meta|m)$/i.test(mod)) {\n        cmd = true;\n      } else if (/^a(lt)?$/i.test(mod)) {\n        alt = true;\n      } else if (/^(c|ctrl|control)$/i.test(mod)) {\n        ctrl = true;\n      } else if (/^s(hift)?$/i.test(mod)) {\n        shift = true;\n      } else {\n        throw new Error(\"Unrecognized modifier name: \" + mod);\n      }\n    }\n\n    if (alt) {\n      name = \"Alt-\" + name;\n    }\n\n    if (ctrl) {\n      name = \"Ctrl-\" + name;\n    }\n\n    if (cmd) {\n      name = \"Cmd-\" + name;\n    }\n\n    if (shift) {\n      name = \"Shift-\" + name;\n    }\n\n    return name;\n  } // This is a kludge to keep keymaps mostly working as raw objects\n  // (backwards compatibility) while at the same time support features\n  // like normalization and multi-stroke key bindings. It compiles a\n  // new normalized keymap, and then updates the old object to reflect\n  // this.\n\n\n  function normalizeKeyMap(keymap) {\n    var copy = {};\n\n    for (var keyname in keymap) {\n      if (keymap.hasOwnProperty(keyname)) {\n        var value = keymap[keyname];\n\n        if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) {\n          continue;\n        }\n\n        if (value == \"...\") {\n          delete keymap[keyname];\n          continue;\n        }\n\n        var keys = map(keyname.split(\" \"), normalizeKeyName);\n\n        for (var i = 0; i < keys.length; i++) {\n          var val = void 0,\n              name = void 0;\n\n          if (i == keys.length - 1) {\n            name = keys.join(\" \");\n            val = value;\n          } else {\n            name = keys.slice(0, i + 1).join(\" \");\n            val = \"...\";\n          }\n\n          var prev = copy[name];\n\n          if (!prev) {\n            copy[name] = val;\n          } else if (prev != val) {\n            throw new Error(\"Inconsistent bindings for \" + name);\n          }\n        }\n\n        delete keymap[keyname];\n      }\n    }\n\n    for (var prop in copy) {\n      keymap[prop] = copy[prop];\n    }\n\n    return keymap;\n  }\n\n  function lookupKey(key, map, handle, context) {\n    map = getKeyMap(map);\n    var found = map.call ? map.call(key, context) : map[key];\n\n    if (found === false) {\n      return \"nothing\";\n    }\n\n    if (found === \"...\") {\n      return \"multi\";\n    }\n\n    if (found != null && handle(found)) {\n      return \"handled\";\n    }\n\n    if (map.fallthrough) {\n      if (Object.prototype.toString.call(map.fallthrough) != \"[object Array]\") {\n        return lookupKey(key, map.fallthrough, handle, context);\n      }\n\n      for (var i = 0; i < map.fallthrough.length; i++) {\n        var result = lookupKey(key, map.fallthrough[i], handle, context);\n\n        if (result) {\n          return result;\n        }\n      }\n    }\n  } // Modifier key presses don't count as 'real' key presses for the\n  // purpose of keymap fallthrough.\n\n\n  function isModifierKey(value) {\n    var name = typeof value == \"string\" ? value : keyNames[value.keyCode];\n    return name == \"Ctrl\" || name == \"Alt\" || name == \"Shift\" || name == \"Mod\";\n  }\n\n  function addModifierNames(name, event, noShift) {\n    var base = name;\n\n    if (event.altKey && base != \"Alt\") {\n      name = \"Alt-\" + name;\n    }\n\n    if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != \"Ctrl\") {\n      name = \"Ctrl-\" + name;\n    }\n\n    if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != \"Cmd\") {\n      name = \"Cmd-\" + name;\n    }\n\n    if (!noShift && event.shiftKey && base != \"Shift\") {\n      name = \"Shift-\" + name;\n    }\n\n    return name;\n  } // Look up the name of a key as indicated by an event object.\n\n\n  function keyName(event, noShift) {\n    if (presto && event.keyCode == 34 && event[\"char\"]) {\n      return false;\n    }\n\n    var name = keyNames[event.keyCode];\n\n    if (name == null || event.altGraphKey) {\n      return false;\n    } // Ctrl-ScrollLock has keyCode 3, same as Ctrl-Pause,\n    // so we'll use event.code when available (Chrome 48+, FF 38+, Safari 10.1+)\n\n\n    if (event.keyCode == 3 && event.code) {\n      name = event.code;\n    }\n\n    return addModifierNames(name, event, noShift);\n  }\n\n  function getKeyMap(val) {\n    return typeof val == \"string\" ? keyMap[val] : val;\n  } // Helper for deleting text near the selection(s), used to implement\n  // backspace, delete, and similar functionality.\n\n\n  function deleteNearSelection(cm, compute) {\n    var ranges = cm.doc.sel.ranges,\n        kill = []; // Build up a set of ranges to kill first, merging overlapping\n    // ranges.\n\n    for (var i = 0; i < ranges.length; i++) {\n      var toKill = compute(ranges[i]);\n\n      while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {\n        var replaced = kill.pop();\n\n        if (cmp(replaced.from, toKill.from) < 0) {\n          toKill.from = replaced.from;\n          break;\n        }\n      }\n\n      kill.push(toKill);\n    } // Next, remove those actual ranges.\n\n\n    runInOp(cm, function () {\n      for (var i = kill.length - 1; i >= 0; i--) {\n        replaceRange(cm.doc, \"\", kill[i].from, kill[i].to, \"+delete\");\n      }\n\n      ensureCursorVisible(cm);\n    });\n  }\n\n  function moveCharLogically(line, ch, dir) {\n    var target = skipExtendingChars(line.text, ch + dir, dir);\n    return target < 0 || target > line.text.length ? null : target;\n  }\n\n  function moveLogically(line, start, dir) {\n    var ch = moveCharLogically(line, start.ch, dir);\n    return ch == null ? null : new Pos(start.line, ch, dir < 0 ? \"after\" : \"before\");\n  }\n\n  function endOfLine(visually, cm, lineObj, lineNo, dir) {\n    if (visually) {\n      if (cm.doc.direction == \"rtl\") {\n        dir = -dir;\n      }\n\n      var order = getOrder(lineObj, cm.doc.direction);\n\n      if (order) {\n        var part = dir < 0 ? lst(order) : order[0];\n        var moveInStorageOrder = dir < 0 == (part.level == 1);\n        var sticky = moveInStorageOrder ? \"after\" : \"before\";\n        var ch; // With a wrapped rtl chunk (possibly spanning multiple bidi parts),\n        // it could be that the last bidi part is not on the last visual line,\n        // since visual lines contain content order-consecutive chunks.\n        // Thus, in rtl, we are looking for the first (content-order) character\n        // in the rtl chunk that is on the last line (that is, the same line\n        // as the last (content-order) character).\n\n        if (part.level > 0 || cm.doc.direction == \"rtl\") {\n          var prep = prepareMeasureForLine(cm, lineObj);\n          ch = dir < 0 ? lineObj.text.length - 1 : 0;\n          var targetTop = measureCharPrepared(cm, prep, ch).top;\n          ch = findFirst(function (ch) {\n            return measureCharPrepared(cm, prep, ch).top == targetTop;\n          }, dir < 0 == (part.level == 1) ? part.from : part.to - 1, ch);\n\n          if (sticky == \"before\") {\n            ch = moveCharLogically(lineObj, ch, 1);\n          }\n        } else {\n          ch = dir < 0 ? part.to : part.from;\n        }\n\n        return new Pos(lineNo, ch, sticky);\n      }\n    }\n\n    return new Pos(lineNo, dir < 0 ? lineObj.text.length : 0, dir < 0 ? \"before\" : \"after\");\n  }\n\n  function moveVisually(cm, line, start, dir) {\n    var bidi = getOrder(line, cm.doc.direction);\n\n    if (!bidi) {\n      return moveLogically(line, start, dir);\n    }\n\n    if (start.ch >= line.text.length) {\n      start.ch = line.text.length;\n      start.sticky = \"before\";\n    } else if (start.ch <= 0) {\n      start.ch = 0;\n      start.sticky = \"after\";\n    }\n\n    var partPos = getBidiPartAt(bidi, start.ch, start.sticky),\n        part = bidi[partPos];\n\n    if (cm.doc.direction == \"ltr\" && part.level % 2 == 0 && (dir > 0 ? part.to > start.ch : part.from < start.ch)) {\n      // Case 1: We move within an ltr part in an ltr editor. Even with wrapped lines,\n      // nothing interesting happens.\n      return moveLogically(line, start, dir);\n    }\n\n    var mv = function (pos, dir) {\n      return moveCharLogically(line, pos instanceof Pos ? pos.ch : pos, dir);\n    };\n\n    var prep;\n\n    var getWrappedLineExtent = function (ch) {\n      if (!cm.options.lineWrapping) {\n        return {\n          begin: 0,\n          end: line.text.length\n        };\n      }\n\n      prep = prep || prepareMeasureForLine(cm, line);\n      return wrappedLineExtentChar(cm, line, prep, ch);\n    };\n\n    var wrappedLineExtent = getWrappedLineExtent(start.sticky == \"before\" ? mv(start, -1) : start.ch);\n\n    if (cm.doc.direction == \"rtl\" || part.level == 1) {\n      var moveInStorageOrder = part.level == 1 == dir < 0;\n      var ch = mv(start, moveInStorageOrder ? 1 : -1);\n\n      if (ch != null && (!moveInStorageOrder ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) {\n        // Case 2: We move within an rtl part or in an rtl editor on the same visual line\n        var sticky = moveInStorageOrder ? \"before\" : \"after\";\n        return new Pos(start.line, ch, sticky);\n      }\n    } // Case 3: Could not move within this bidi part in this visual line, so leave\n    // the current bidi part\n\n\n    var searchInVisualLine = function (partPos, dir, wrappedLineExtent) {\n      var getRes = function (ch, moveInStorageOrder) {\n        return moveInStorageOrder ? new Pos(start.line, mv(ch, 1), \"before\") : new Pos(start.line, ch, \"after\");\n      };\n\n      for (; partPos >= 0 && partPos < bidi.length; partPos += dir) {\n        var part = bidi[partPos];\n        var moveInStorageOrder = dir > 0 == (part.level != 1);\n        var ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1);\n\n        if (part.from <= ch && ch < part.to) {\n          return getRes(ch, moveInStorageOrder);\n        }\n\n        ch = moveInStorageOrder ? part.from : mv(part.to, -1);\n\n        if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) {\n          return getRes(ch, moveInStorageOrder);\n        }\n      }\n    }; // Case 3a: Look for other bidi parts on the same visual line\n\n\n    var res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent);\n\n    if (res) {\n      return res;\n    } // Case 3b: Look for other bidi parts on the next visual line\n\n\n    var nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1);\n\n    if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) {\n      res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh));\n\n      if (res) {\n        return res;\n      }\n    } // Case 4: Nowhere to move\n\n\n    return null;\n  } // Commands are parameter-less actions that can be performed on an\n  // editor, mostly used for keybindings.\n\n\n  var commands = {\n    selectAll: selectAll,\n    singleSelection: function (cm) {\n      return cm.setSelection(cm.getCursor(\"anchor\"), cm.getCursor(\"head\"), sel_dontScroll);\n    },\n    killLine: function (cm) {\n      return deleteNearSelection(cm, function (range) {\n        if (range.empty()) {\n          var len = getLine(cm.doc, range.head.line).text.length;\n\n          if (range.head.ch == len && range.head.line < cm.lastLine()) {\n            return {\n              from: range.head,\n              to: Pos(range.head.line + 1, 0)\n            };\n          } else {\n            return {\n              from: range.head,\n              to: Pos(range.head.line, len)\n            };\n          }\n        } else {\n          return {\n            from: range.from(),\n            to: range.to()\n          };\n        }\n      });\n    },\n    deleteLine: function (cm) {\n      return deleteNearSelection(cm, function (range) {\n        return {\n          from: Pos(range.from().line, 0),\n          to: clipPos(cm.doc, Pos(range.to().line + 1, 0))\n        };\n      });\n    },\n    delLineLeft: function (cm) {\n      return deleteNearSelection(cm, function (range) {\n        return {\n          from: Pos(range.from().line, 0),\n          to: range.from()\n        };\n      });\n    },\n    delWrappedLineLeft: function (cm) {\n      return deleteNearSelection(cm, function (range) {\n        var top = cm.charCoords(range.head, \"div\").top + 5;\n        var leftPos = cm.coordsChar({\n          left: 0,\n          top: top\n        }, \"div\");\n        return {\n          from: leftPos,\n          to: range.from()\n        };\n      });\n    },\n    delWrappedLineRight: function (cm) {\n      return deleteNearSelection(cm, function (range) {\n        var top = cm.charCoords(range.head, \"div\").top + 5;\n        var rightPos = cm.coordsChar({\n          left: cm.display.lineDiv.offsetWidth + 100,\n          top: top\n        }, \"div\");\n        return {\n          from: range.from(),\n          to: rightPos\n        };\n      });\n    },\n    undo: function (cm) {\n      return cm.undo();\n    },\n    redo: function (cm) {\n      return cm.redo();\n    },\n    undoSelection: function (cm) {\n      return cm.undoSelection();\n    },\n    redoSelection: function (cm) {\n      return cm.redoSelection();\n    },\n    goDocStart: function (cm) {\n      return cm.extendSelection(Pos(cm.firstLine(), 0));\n    },\n    goDocEnd: function (cm) {\n      return cm.extendSelection(Pos(cm.lastLine()));\n    },\n    goLineStart: function (cm) {\n      return cm.extendSelectionsBy(function (range) {\n        return lineStart(cm, range.head.line);\n      }, {\n        origin: \"+move\",\n        bias: 1\n      });\n    },\n    goLineStartSmart: function (cm) {\n      return cm.extendSelectionsBy(function (range) {\n        return lineStartSmart(cm, range.head);\n      }, {\n        origin: \"+move\",\n        bias: 1\n      });\n    },\n    goLineEnd: function (cm) {\n      return cm.extendSelectionsBy(function (range) {\n        return lineEnd(cm, range.head.line);\n      }, {\n        origin: \"+move\",\n        bias: -1\n      });\n    },\n    goLineRight: function (cm) {\n      return cm.extendSelectionsBy(function (range) {\n        var top = cm.cursorCoords(range.head, \"div\").top + 5;\n        return cm.coordsChar({\n          left: cm.display.lineDiv.offsetWidth + 100,\n          top: top\n        }, \"div\");\n      }, sel_move);\n    },\n    goLineLeft: function (cm) {\n      return cm.extendSelectionsBy(function (range) {\n        var top = cm.cursorCoords(range.head, \"div\").top + 5;\n        return cm.coordsChar({\n          left: 0,\n          top: top\n        }, \"div\");\n      }, sel_move);\n    },\n    goLineLeftSmart: function (cm) {\n      return cm.extendSelectionsBy(function (range) {\n        var top = cm.cursorCoords(range.head, \"div\").top + 5;\n        var pos = cm.coordsChar({\n          left: 0,\n          top: top\n        }, \"div\");\n\n        if (pos.ch < cm.getLine(pos.line).search(/\\S/)) {\n          return lineStartSmart(cm, range.head);\n        }\n\n        return pos;\n      }, sel_move);\n    },\n    goLineUp: function (cm) {\n      return cm.moveV(-1, \"line\");\n    },\n    goLineDown: function (cm) {\n      return cm.moveV(1, \"line\");\n    },\n    goPageUp: function (cm) {\n      return cm.moveV(-1, \"page\");\n    },\n    goPageDown: function (cm) {\n      return cm.moveV(1, \"page\");\n    },\n    goCharLeft: function (cm) {\n      return cm.moveH(-1, \"char\");\n    },\n    goCharRight: function (cm) {\n      return cm.moveH(1, \"char\");\n    },\n    goColumnLeft: function (cm) {\n      return cm.moveH(-1, \"column\");\n    },\n    goColumnRight: function (cm) {\n      return cm.moveH(1, \"column\");\n    },\n    goWordLeft: function (cm) {\n      return cm.moveH(-1, \"word\");\n    },\n    goGroupRight: function (cm) {\n      return cm.moveH(1, \"group\");\n    },\n    goGroupLeft: function (cm) {\n      return cm.moveH(-1, \"group\");\n    },\n    goWordRight: function (cm) {\n      return cm.moveH(1, \"word\");\n    },\n    delCharBefore: function (cm) {\n      return cm.deleteH(-1, \"char\");\n    },\n    delCharAfter: function (cm) {\n      return cm.deleteH(1, \"char\");\n    },\n    delWordBefore: function (cm) {\n      return cm.deleteH(-1, \"word\");\n    },\n    delWordAfter: function (cm) {\n      return cm.deleteH(1, \"word\");\n    },\n    delGroupBefore: function (cm) {\n      return cm.deleteH(-1, \"group\");\n    },\n    delGroupAfter: function (cm) {\n      return cm.deleteH(1, \"group\");\n    },\n    indentAuto: function (cm) {\n      return cm.indentSelection(\"smart\");\n    },\n    indentMore: function (cm) {\n      return cm.indentSelection(\"add\");\n    },\n    indentLess: function (cm) {\n      return cm.indentSelection(\"subtract\");\n    },\n    insertTab: function (cm) {\n      return cm.replaceSelection(\"\\t\");\n    },\n    insertSoftTab: function (cm) {\n      var spaces = [],\n          ranges = cm.listSelections(),\n          tabSize = cm.options.tabSize;\n\n      for (var i = 0; i < ranges.length; i++) {\n        var pos = ranges[i].from();\n        var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize);\n        spaces.push(spaceStr(tabSize - col % tabSize));\n      }\n\n      cm.replaceSelections(spaces);\n    },\n    defaultTab: function (cm) {\n      if (cm.somethingSelected()) {\n        cm.indentSelection(\"add\");\n      } else {\n        cm.execCommand(\"insertTab\");\n      }\n    },\n    // Swap the two chars left and right of each selection's head.\n    // Move cursor behind the two swapped characters afterwards.\n    //\n    // Doesn't consider line feeds a character.\n    // Doesn't scan more than one line above to find a character.\n    // Doesn't do anything on an empty line.\n    // Doesn't do anything with non-empty selections.\n    transposeChars: function (cm) {\n      return runInOp(cm, function () {\n        var ranges = cm.listSelections(),\n            newSel = [];\n\n        for (var i = 0; i < ranges.length; i++) {\n          if (!ranges[i].empty()) {\n            continue;\n          }\n\n          var cur = ranges[i].head,\n              line = getLine(cm.doc, cur.line).text;\n\n          if (line) {\n            if (cur.ch == line.length) {\n              cur = new Pos(cur.line, cur.ch - 1);\n            }\n\n            if (cur.ch > 0) {\n              cur = new Pos(cur.line, cur.ch + 1);\n              cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2), Pos(cur.line, cur.ch - 2), cur, \"+transpose\");\n            } else if (cur.line > cm.doc.first) {\n              var prev = getLine(cm.doc, cur.line - 1).text;\n\n              if (prev) {\n                cur = new Pos(cur.line, 1);\n                cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() + prev.charAt(prev.length - 1), Pos(cur.line - 1, prev.length - 1), cur, \"+transpose\");\n              }\n            }\n          }\n\n          newSel.push(new Range(cur, cur));\n        }\n\n        cm.setSelections(newSel);\n      });\n    },\n    newlineAndIndent: function (cm) {\n      return runInOp(cm, function () {\n        var sels = cm.listSelections();\n\n        for (var i = sels.length - 1; i >= 0; i--) {\n          cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, \"+input\");\n        }\n\n        sels = cm.listSelections();\n\n        for (var i$1 = 0; i$1 < sels.length; i$1++) {\n          cm.indentLine(sels[i$1].from().line, null, true);\n        }\n\n        ensureCursorVisible(cm);\n      });\n    },\n    openLine: function (cm) {\n      return cm.replaceSelection(\"\\n\", \"start\");\n    },\n    toggleOverwrite: function (cm) {\n      return cm.toggleOverwrite();\n    }\n  };\n\n  function lineStart(cm, lineN) {\n    var line = getLine(cm.doc, lineN);\n    var visual = visualLine(line);\n\n    if (visual != line) {\n      lineN = lineNo(visual);\n    }\n\n    return endOfLine(true, cm, visual, lineN, 1);\n  }\n\n  function lineEnd(cm, lineN) {\n    var line = getLine(cm.doc, lineN);\n    var visual = visualLineEnd(line);\n\n    if (visual != line) {\n      lineN = lineNo(visual);\n    }\n\n    return endOfLine(true, cm, line, lineN, -1);\n  }\n\n  function lineStartSmart(cm, pos) {\n    var start = lineStart(cm, pos.line);\n    var line = getLine(cm.doc, start.line);\n    var order = getOrder(line, cm.doc.direction);\n\n    if (!order || order[0].level == 0) {\n      var firstNonWS = Math.max(start.ch, line.text.search(/\\S/));\n      var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch;\n      return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky);\n    }\n\n    return start;\n  } // Run a handler that was bound to a key.\n\n\n  function doHandleBinding(cm, bound, dropShift) {\n    if (typeof bound == \"string\") {\n      bound = commands[bound];\n\n      if (!bound) {\n        return false;\n      }\n    } // Ensure previous input has been read, so that the handler sees a\n    // consistent view of the document\n\n\n    cm.display.input.ensurePolled();\n    var prevShift = cm.display.shift,\n        done = false;\n\n    try {\n      if (cm.isReadOnly()) {\n        cm.state.suppressEdits = true;\n      }\n\n      if (dropShift) {\n        cm.display.shift = false;\n      }\n\n      done = bound(cm) != Pass;\n    } finally {\n      cm.display.shift = prevShift;\n      cm.state.suppressEdits = false;\n    }\n\n    return done;\n  }\n\n  function lookupKeyForEditor(cm, name, handle) {\n    for (var i = 0; i < cm.state.keyMaps.length; i++) {\n      var result = lookupKey(name, cm.state.keyMaps[i], handle, cm);\n\n      if (result) {\n        return result;\n      }\n    }\n\n    return cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm) || lookupKey(name, cm.options.keyMap, handle, cm);\n  } // Note that, despite the name, this function is also used to check\n  // for bound mouse clicks.\n\n\n  var stopSeq = new Delayed();\n\n  function dispatchKey(cm, name, e, handle) {\n    var seq = cm.state.keySeq;\n\n    if (seq) {\n      if (isModifierKey(name)) {\n        return \"handled\";\n      }\n\n      if (/\\'$/.test(name)) {\n        cm.state.keySeq = null;\n      } else {\n        stopSeq.set(50, function () {\n          if (cm.state.keySeq == seq) {\n            cm.state.keySeq = null;\n            cm.display.input.reset();\n          }\n        });\n      }\n\n      if (dispatchKeyInner(cm, seq + \" \" + name, e, handle)) {\n        return true;\n      }\n    }\n\n    return dispatchKeyInner(cm, name, e, handle);\n  }\n\n  function dispatchKeyInner(cm, name, e, handle) {\n    var result = lookupKeyForEditor(cm, name, handle);\n\n    if (result == \"multi\") {\n      cm.state.keySeq = name;\n    }\n\n    if (result == \"handled\") {\n      signalLater(cm, \"keyHandled\", cm, name, e);\n    }\n\n    if (result == \"handled\" || result == \"multi\") {\n      e_preventDefault(e);\n      restartBlink(cm);\n    }\n\n    return !!result;\n  } // Handle a key from the keydown event.\n\n\n  function handleKeyBinding(cm, e) {\n    var name = keyName(e, true);\n\n    if (!name) {\n      return false;\n    }\n\n    if (e.shiftKey && !cm.state.keySeq) {\n      // First try to resolve full name (including 'Shift-'). Failing\n      // that, see if there is a cursor-motion command (starting with\n      // 'go') bound to the keyname without 'Shift-'.\n      return dispatchKey(cm, \"Shift-\" + name, e, function (b) {\n        return doHandleBinding(cm, b, true);\n      }) || dispatchKey(cm, name, e, function (b) {\n        if (typeof b == \"string\" ? /^go[A-Z]/.test(b) : b.motion) {\n          return doHandleBinding(cm, b);\n        }\n      });\n    } else {\n      return dispatchKey(cm, name, e, function (b) {\n        return doHandleBinding(cm, b);\n      });\n    }\n  } // Handle a key from the keypress event\n\n\n  function handleCharBinding(cm, e, ch) {\n    return dispatchKey(cm, \"'\" + ch + \"'\", e, function (b) {\n      return doHandleBinding(cm, b, true);\n    });\n  }\n\n  var lastStoppedKey = null;\n\n  function onKeyDown(e) {\n    var cm = this;\n\n    if (e.target && e.target != cm.display.input.getField()) {\n      return;\n    }\n\n    cm.curOp.focus = activeElt();\n\n    if (signalDOMEvent(cm, e)) {\n      return;\n    } // IE does strange things with escape.\n\n\n    if (ie && ie_version < 11 && e.keyCode == 27) {\n      e.returnValue = false;\n    }\n\n    var code = e.keyCode;\n    cm.display.shift = code == 16 || e.shiftKey;\n    var handled = handleKeyBinding(cm, e);\n\n    if (presto) {\n      lastStoppedKey = handled ? code : null; // Opera has no cut event... we try to at least catch the key combo\n\n      if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey)) {\n        cm.replaceSelection(\"\", null, \"cut\");\n      }\n    }\n\n    if (gecko && !mac && !handled && code == 46 && e.shiftKey && !e.ctrlKey && document.execCommand) {\n      document.execCommand(\"cut\");\n    } // Turn mouse into crosshair when Alt is held on Mac.\n\n\n    if (code == 18 && !/\\bCodeMirror-crosshair\\b/.test(cm.display.lineDiv.className)) {\n      showCrossHair(cm);\n    }\n  }\n\n  function showCrossHair(cm) {\n    var lineDiv = cm.display.lineDiv;\n    addClass(lineDiv, \"CodeMirror-crosshair\");\n\n    function up(e) {\n      if (e.keyCode == 18 || !e.altKey) {\n        rmClass(lineDiv, \"CodeMirror-crosshair\");\n        off(document, \"keyup\", up);\n        off(document, \"mouseover\", up);\n      }\n    }\n\n    on(document, \"keyup\", up);\n    on(document, \"mouseover\", up);\n  }\n\n  function onKeyUp(e) {\n    if (e.keyCode == 16) {\n      this.doc.sel.shift = false;\n    }\n\n    signalDOMEvent(this, e);\n  }\n\n  function onKeyPress(e) {\n    var cm = this;\n\n    if (e.target && e.target != cm.display.input.getField()) {\n      return;\n    }\n\n    if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) {\n      return;\n    }\n\n    var keyCode = e.keyCode,\n        charCode = e.charCode;\n\n    if (presto && keyCode == lastStoppedKey) {\n      lastStoppedKey = null;\n      e_preventDefault(e);\n      return;\n    }\n\n    if (presto && (!e.which || e.which < 10) && handleKeyBinding(cm, e)) {\n      return;\n    }\n\n    var ch = String.fromCharCode(charCode == null ? keyCode : charCode); // Some browsers fire keypress events for backspace\n\n    if (ch == \"\\x08\") {\n      return;\n    }\n\n    if (handleCharBinding(cm, e, ch)) {\n      return;\n    }\n\n    cm.display.input.onKeyPress(e);\n  }\n\n  var DOUBLECLICK_DELAY = 400;\n\n  var PastClick = function (time, pos, button) {\n    this.time = time;\n    this.pos = pos;\n    this.button = button;\n  };\n\n  PastClick.prototype.compare = function (time, pos, button) {\n    return this.time + DOUBLECLICK_DELAY > time && cmp(pos, this.pos) == 0 && button == this.button;\n  };\n\n  var lastClick, lastDoubleClick;\n\n  function clickRepeat(pos, button) {\n    var now = +new Date();\n\n    if (lastDoubleClick && lastDoubleClick.compare(now, pos, button)) {\n      lastClick = lastDoubleClick = null;\n      return \"triple\";\n    } else if (lastClick && lastClick.compare(now, pos, button)) {\n      lastDoubleClick = new PastClick(now, pos, button);\n      lastClick = null;\n      return \"double\";\n    } else {\n      lastClick = new PastClick(now, pos, button);\n      lastDoubleClick = null;\n      return \"single\";\n    }\n  } // A mouse down can be a single click, double click, triple click,\n  // start of selection drag, start of text drag, new cursor\n  // (ctrl-click), rectangle drag (alt-drag), or xwin\n  // middle-click-paste. Or it might be a click on something we should\n  // not interfere with, such as a scrollbar or widget.\n\n\n  function onMouseDown(e) {\n    var cm = this,\n        display = cm.display;\n\n    if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) {\n      return;\n    }\n\n    display.input.ensurePolled();\n    display.shift = e.shiftKey;\n\n    if (eventInWidget(display, e)) {\n      if (!webkit) {\n        // Briefly turn off draggability, to allow widgets to do\n        // normal dragging things.\n        display.scroller.draggable = false;\n        setTimeout(function () {\n          return display.scroller.draggable = true;\n        }, 100);\n      }\n\n      return;\n    }\n\n    if (clickInGutter(cm, e)) {\n      return;\n    }\n\n    var pos = posFromMouse(cm, e),\n        button = e_button(e),\n        repeat = pos ? clickRepeat(pos, button) : \"single\";\n    window.focus(); // #3261: make sure, that we're not starting a second selection\n\n    if (button == 1 && cm.state.selectingText) {\n      cm.state.selectingText(e);\n    }\n\n    if (pos && handleMappedButton(cm, button, pos, repeat, e)) {\n      return;\n    }\n\n    if (button == 1) {\n      if (pos) {\n        leftButtonDown(cm, pos, repeat, e);\n      } else if (e_target(e) == display.scroller) {\n        e_preventDefault(e);\n      }\n    } else if (button == 2) {\n      if (pos) {\n        extendSelection(cm.doc, pos);\n      }\n\n      setTimeout(function () {\n        return display.input.focus();\n      }, 20);\n    } else if (button == 3) {\n      if (captureRightClick) {\n        cm.display.input.onContextMenu(e);\n      } else {\n        delayBlurEvent(cm);\n      }\n    }\n  }\n\n  function handleMappedButton(cm, button, pos, repeat, event) {\n    var name = \"Click\";\n\n    if (repeat == \"double\") {\n      name = \"Double\" + name;\n    } else if (repeat == \"triple\") {\n      name = \"Triple\" + name;\n    }\n\n    name = (button == 1 ? \"Left\" : button == 2 ? \"Middle\" : \"Right\") + name;\n    return dispatchKey(cm, addModifierNames(name, event), event, function (bound) {\n      if (typeof bound == \"string\") {\n        bound = commands[bound];\n      }\n\n      if (!bound) {\n        return false;\n      }\n\n      var done = false;\n\n      try {\n        if (cm.isReadOnly()) {\n          cm.state.suppressEdits = true;\n        }\n\n        done = bound(cm, pos) != Pass;\n      } finally {\n        cm.state.suppressEdits = false;\n      }\n\n      return done;\n    });\n  }\n\n  function configureMouse(cm, repeat, event) {\n    var option = cm.getOption(\"configureMouse\");\n    var value = option ? option(cm, repeat, event) : {};\n\n    if (value.unit == null) {\n      var rect = chromeOS ? event.shiftKey && event.metaKey : event.altKey;\n      value.unit = rect ? \"rectangle\" : repeat == \"single\" ? \"char\" : repeat == \"double\" ? \"word\" : \"line\";\n    }\n\n    if (value.extend == null || cm.doc.extend) {\n      value.extend = cm.doc.extend || event.shiftKey;\n    }\n\n    if (value.addNew == null) {\n      value.addNew = mac ? event.metaKey : event.ctrlKey;\n    }\n\n    if (value.moveOnDrag == null) {\n      value.moveOnDrag = !(mac ? event.altKey : event.ctrlKey);\n    }\n\n    return value;\n  }\n\n  function leftButtonDown(cm, pos, repeat, event) {\n    if (ie) {\n      setTimeout(bind(ensureFocus, cm), 0);\n    } else {\n      cm.curOp.focus = activeElt();\n    }\n\n    var behavior = configureMouse(cm, repeat, event);\n    var sel = cm.doc.sel,\n        contained;\n\n    if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() && repeat == \"single\" && (contained = sel.contains(pos)) > -1 && (cmp((contained = sel.ranges[contained]).from(), pos) < 0 || pos.xRel > 0) && (cmp(contained.to(), pos) > 0 || pos.xRel < 0)) {\n      leftButtonStartDrag(cm, event, pos, behavior);\n    } else {\n      leftButtonSelect(cm, event, pos, behavior);\n    }\n  } // Start a text drag. When it ends, see if any dragging actually\n  // happen, and treat as a click if it didn't.\n\n\n  function leftButtonStartDrag(cm, event, pos, behavior) {\n    var display = cm.display,\n        moved = false;\n    var dragEnd = operation(cm, function (e) {\n      if (webkit) {\n        display.scroller.draggable = false;\n      }\n\n      cm.state.draggingText = false;\n      off(display.wrapper.ownerDocument, \"mouseup\", dragEnd);\n      off(display.wrapper.ownerDocument, \"mousemove\", mouseMove);\n      off(display.scroller, \"dragstart\", dragStart);\n      off(display.scroller, \"drop\", dragEnd);\n\n      if (!moved) {\n        e_preventDefault(e);\n\n        if (!behavior.addNew) {\n          extendSelection(cm.doc, pos, null, null, behavior.extend);\n        } // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)\n\n\n        if (webkit && !safari || ie && ie_version == 9) {\n          setTimeout(function () {\n            display.wrapper.ownerDocument.body.focus({\n              preventScroll: true\n            });\n            display.input.focus();\n          }, 20);\n        } else {\n          display.input.focus();\n        }\n      }\n    });\n\n    var mouseMove = function (e2) {\n      moved = moved || Math.abs(event.clientX - e2.clientX) + Math.abs(event.clientY - e2.clientY) >= 10;\n    };\n\n    var dragStart = function () {\n      return moved = true;\n    }; // Let the drag handler handle this.\n\n\n    if (webkit) {\n      display.scroller.draggable = true;\n    }\n\n    cm.state.draggingText = dragEnd;\n    dragEnd.copy = !behavior.moveOnDrag; // IE's approach to draggable\n\n    if (display.scroller.dragDrop) {\n      display.scroller.dragDrop();\n    }\n\n    on(display.wrapper.ownerDocument, \"mouseup\", dragEnd);\n    on(display.wrapper.ownerDocument, \"mousemove\", mouseMove);\n    on(display.scroller, \"dragstart\", dragStart);\n    on(display.scroller, \"drop\", dragEnd);\n    delayBlurEvent(cm);\n    setTimeout(function () {\n      return display.input.focus();\n    }, 20);\n  }\n\n  function rangeForUnit(cm, pos, unit) {\n    if (unit == \"char\") {\n      return new Range(pos, pos);\n    }\n\n    if (unit == \"word\") {\n      return cm.findWordAt(pos);\n    }\n\n    if (unit == \"line\") {\n      return new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0)));\n    }\n\n    var result = unit(cm, pos);\n    return new Range(result.from, result.to);\n  } // Normal selection, as opposed to text dragging.\n\n\n  function leftButtonSelect(cm, event, start, behavior) {\n    var display = cm.display,\n        doc = cm.doc;\n    e_preventDefault(event);\n    var ourRange,\n        ourIndex,\n        startSel = doc.sel,\n        ranges = startSel.ranges;\n\n    if (behavior.addNew && !behavior.extend) {\n      ourIndex = doc.sel.contains(start);\n\n      if (ourIndex > -1) {\n        ourRange = ranges[ourIndex];\n      } else {\n        ourRange = new Range(start, start);\n      }\n    } else {\n      ourRange = doc.sel.primary();\n      ourIndex = doc.sel.primIndex;\n    }\n\n    if (behavior.unit == \"rectangle\") {\n      if (!behavior.addNew) {\n        ourRange = new Range(start, start);\n      }\n\n      start = posFromMouse(cm, event, true, true);\n      ourIndex = -1;\n    } else {\n      var range = rangeForUnit(cm, start, behavior.unit);\n\n      if (behavior.extend) {\n        ourRange = extendRange(ourRange, range.anchor, range.head, behavior.extend);\n      } else {\n        ourRange = range;\n      }\n    }\n\n    if (!behavior.addNew) {\n      ourIndex = 0;\n      setSelection(doc, new Selection([ourRange], 0), sel_mouse);\n      startSel = doc.sel;\n    } else if (ourIndex == -1) {\n      ourIndex = ranges.length;\n      setSelection(doc, normalizeSelection(cm, ranges.concat([ourRange]), ourIndex), {\n        scroll: false,\n        origin: \"*mouse\"\n      });\n    } else if (ranges.length > 1 && ranges[ourIndex].empty() && behavior.unit == \"char\" && !behavior.extend) {\n      setSelection(doc, normalizeSelection(cm, ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0), {\n        scroll: false,\n        origin: \"*mouse\"\n      });\n      startSel = doc.sel;\n    } else {\n      replaceOneSelection(doc, ourIndex, ourRange, sel_mouse);\n    }\n\n    var lastPos = start;\n\n    function extendTo(pos) {\n      if (cmp(lastPos, pos) == 0) {\n        return;\n      }\n\n      lastPos = pos;\n\n      if (behavior.unit == \"rectangle\") {\n        var ranges = [],\n            tabSize = cm.options.tabSize;\n        var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize);\n        var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize);\n        var left = Math.min(startCol, posCol),\n            right = Math.max(startCol, posCol);\n\n        for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line)); line <= end; line++) {\n          var text = getLine(doc, line).text,\n              leftPos = findColumn(text, left, tabSize);\n\n          if (left == right) {\n            ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos)));\n          } else if (text.length > leftPos) {\n            ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize))));\n          }\n        }\n\n        if (!ranges.length) {\n          ranges.push(new Range(start, start));\n        }\n\n        setSelection(doc, normalizeSelection(cm, startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex), {\n          origin: \"*mouse\",\n          scroll: false\n        });\n        cm.scrollIntoView(pos);\n      } else {\n        var oldRange = ourRange;\n        var range = rangeForUnit(cm, pos, behavior.unit);\n        var anchor = oldRange.anchor,\n            head;\n\n        if (cmp(range.anchor, anchor) > 0) {\n          head = range.head;\n          anchor = minPos(oldRange.from(), range.anchor);\n        } else {\n          head = range.anchor;\n          anchor = maxPos(oldRange.to(), range.head);\n        }\n\n        var ranges$1 = startSel.ranges.slice(0);\n        ranges$1[ourIndex] = bidiSimplify(cm, new Range(clipPos(doc, anchor), head));\n        setSelection(doc, normalizeSelection(cm, ranges$1, ourIndex), sel_mouse);\n      }\n    }\n\n    var editorSize = display.wrapper.getBoundingClientRect(); // Used to ensure timeout re-tries don't fire when another extend\n    // happened in the meantime (clearTimeout isn't reliable -- at\n    // least on Chrome, the timeouts still happen even when cleared,\n    // if the clear happens after their scheduled firing time).\n\n    var counter = 0;\n\n    function extend(e) {\n      var curCount = ++counter;\n      var cur = posFromMouse(cm, e, true, behavior.unit == \"rectangle\");\n\n      if (!cur) {\n        return;\n      }\n\n      if (cmp(cur, lastPos) != 0) {\n        cm.curOp.focus = activeElt();\n        extendTo(cur);\n        var visible = visibleLines(display, doc);\n\n        if (cur.line >= visible.to || cur.line < visible.from) {\n          setTimeout(operation(cm, function () {\n            if (counter == curCount) {\n              extend(e);\n            }\n          }), 150);\n        }\n      } else {\n        var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0;\n\n        if (outside) {\n          setTimeout(operation(cm, function () {\n            if (counter != curCount) {\n              return;\n            }\n\n            display.scroller.scrollTop += outside;\n            extend(e);\n          }), 50);\n        }\n      }\n    }\n\n    function done(e) {\n      cm.state.selectingText = false;\n      counter = Infinity; // If e is null or undefined we interpret this as someone trying\n      // to explicitly cancel the selection rather than the user\n      // letting go of the mouse button.\n\n      if (e) {\n        e_preventDefault(e);\n        display.input.focus();\n      }\n\n      off(display.wrapper.ownerDocument, \"mousemove\", move);\n      off(display.wrapper.ownerDocument, \"mouseup\", up);\n      doc.history.lastSelOrigin = null;\n    }\n\n    var move = operation(cm, function (e) {\n      if (e.buttons === 0 || !e_button(e)) {\n        done(e);\n      } else {\n        extend(e);\n      }\n    });\n    var up = operation(cm, done);\n    cm.state.selectingText = up;\n    on(display.wrapper.ownerDocument, \"mousemove\", move);\n    on(display.wrapper.ownerDocument, \"mouseup\", up);\n  } // Used when mouse-selecting to adjust the anchor to the proper side\n  // of a bidi jump depending on the visual position of the head.\n\n\n  function bidiSimplify(cm, range) {\n    var anchor = range.anchor;\n    var head = range.head;\n    var anchorLine = getLine(cm.doc, anchor.line);\n\n    if (cmp(anchor, head) == 0 && anchor.sticky == head.sticky) {\n      return range;\n    }\n\n    var order = getOrder(anchorLine);\n\n    if (!order) {\n      return range;\n    }\n\n    var index = getBidiPartAt(order, anchor.ch, anchor.sticky),\n        part = order[index];\n\n    if (part.from != anchor.ch && part.to != anchor.ch) {\n      return range;\n    }\n\n    var boundary = index + (part.from == anchor.ch == (part.level != 1) ? 0 : 1);\n\n    if (boundary == 0 || boundary == order.length) {\n      return range;\n    } // Compute the relative visual position of the head compared to the\n    // anchor (<0 is to the left, >0 to the right)\n\n\n    var leftSide;\n\n    if (head.line != anchor.line) {\n      leftSide = (head.line - anchor.line) * (cm.doc.direction == \"ltr\" ? 1 : -1) > 0;\n    } else {\n      var headIndex = getBidiPartAt(order, head.ch, head.sticky);\n      var dir = headIndex - index || (head.ch - anchor.ch) * (part.level == 1 ? -1 : 1);\n\n      if (headIndex == boundary - 1 || headIndex == boundary) {\n        leftSide = dir < 0;\n      } else {\n        leftSide = dir > 0;\n      }\n    }\n\n    var usePart = order[boundary + (leftSide ? -1 : 0)];\n    var from = leftSide == (usePart.level == 1);\n    var ch = from ? usePart.from : usePart.to,\n        sticky = from ? \"after\" : \"before\";\n    return anchor.ch == ch && anchor.sticky == sticky ? range : new Range(new Pos(anchor.line, ch, sticky), head);\n  } // Determines whether an event happened in the gutter, and fires the\n  // handlers for the corresponding event.\n\n\n  function gutterEvent(cm, e, type, prevent) {\n    var mX, mY;\n\n    if (e.touches) {\n      mX = e.touches[0].clientX;\n      mY = e.touches[0].clientY;\n    } else {\n      try {\n        mX = e.clientX;\n        mY = e.clientY;\n      } catch (e$1) {\n        return false;\n      }\n    }\n\n    if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) {\n      return false;\n    }\n\n    if (prevent) {\n      e_preventDefault(e);\n    }\n\n    var display = cm.display;\n    var lineBox = display.lineDiv.getBoundingClientRect();\n\n    if (mY > lineBox.bottom || !hasHandler(cm, type)) {\n      return e_defaultPrevented(e);\n    }\n\n    mY -= lineBox.top - display.viewOffset;\n\n    for (var i = 0; i < cm.display.gutterSpecs.length; ++i) {\n      var g = display.gutters.childNodes[i];\n\n      if (g && g.getBoundingClientRect().right >= mX) {\n        var line = lineAtHeight(cm.doc, mY);\n        var gutter = cm.display.gutterSpecs[i];\n        signal(cm, type, cm, line, gutter.className, e);\n        return e_defaultPrevented(e);\n      }\n    }\n  }\n\n  function clickInGutter(cm, e) {\n    return gutterEvent(cm, e, \"gutterClick\", true);\n  } // CONTEXT MENU HANDLING\n  // To make the context menu work, we need to briefly unhide the\n  // textarea (making it as unobtrusive as possible) to let the\n  // right-click take effect on it.\n\n\n  function onContextMenu(cm, e) {\n    if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) {\n      return;\n    }\n\n    if (signalDOMEvent(cm, e, \"contextmenu\")) {\n      return;\n    }\n\n    if (!captureRightClick) {\n      cm.display.input.onContextMenu(e);\n    }\n  }\n\n  function contextMenuInGutter(cm, e) {\n    if (!hasHandler(cm, \"gutterContextMenu\")) {\n      return false;\n    }\n\n    return gutterEvent(cm, e, \"gutterContextMenu\", false);\n  }\n\n  function themeChanged(cm) {\n    cm.display.wrapper.className = cm.display.wrapper.className.replace(/\\s*cm-s-\\S+/g, \"\") + cm.options.theme.replace(/(^|\\s)\\s*/g, \" cm-s-\");\n    clearCaches(cm);\n  }\n\n  var Init = {\n    toString: function () {\n      return \"CodeMirror.Init\";\n    }\n  };\n  var defaults = {};\n  var optionHandlers = {};\n\n  function defineOptions(CodeMirror) {\n    var optionHandlers = CodeMirror.optionHandlers;\n\n    function option(name, deflt, handle, notOnInit) {\n      CodeMirror.defaults[name] = deflt;\n\n      if (handle) {\n        optionHandlers[name] = notOnInit ? function (cm, val, old) {\n          if (old != Init) {\n            handle(cm, val, old);\n          }\n        } : handle;\n      }\n    }\n\n    CodeMirror.defineOption = option; // Passed to option handlers when there is no old value.\n\n    CodeMirror.Init = Init; // These two are, on init, called from the constructor because they\n    // have to be initialized before the editor can start at all.\n\n    option(\"value\", \"\", function (cm, val) {\n      return cm.setValue(val);\n    }, true);\n    option(\"mode\", null, function (cm, val) {\n      cm.doc.modeOption = val;\n      loadMode(cm);\n    }, true);\n    option(\"indentUnit\", 2, loadMode, true);\n    option(\"indentWithTabs\", false);\n    option(\"smartIndent\", true);\n    option(\"tabSize\", 4, function (cm) {\n      resetModeState(cm);\n      clearCaches(cm);\n      regChange(cm);\n    }, true);\n    option(\"lineSeparator\", null, function (cm, val) {\n      cm.doc.lineSep = val;\n\n      if (!val) {\n        return;\n      }\n\n      var newBreaks = [],\n          lineNo = cm.doc.first;\n      cm.doc.iter(function (line) {\n        for (var pos = 0;;) {\n          var found = line.text.indexOf(val, pos);\n\n          if (found == -1) {\n            break;\n          }\n\n          pos = found + val.length;\n          newBreaks.push(Pos(lineNo, found));\n        }\n\n        lineNo++;\n      });\n\n      for (var i = newBreaks.length - 1; i >= 0; i--) {\n        replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length));\n      }\n    });\n    option(\"specialChars\", /[\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u061c\\u200b-\\u200c\\u200e\\u200f\\u2028\\u2029\\ufeff\\ufff9-\\ufffc]/g, function (cm, val, old) {\n      cm.state.specialChars = new RegExp(val.source + (val.test(\"\\t\") ? \"\" : \"|\\t\"), \"g\");\n\n      if (old != Init) {\n        cm.refresh();\n      }\n    });\n    option(\"specialCharPlaceholder\", defaultSpecialCharPlaceholder, function (cm) {\n      return cm.refresh();\n    }, true);\n    option(\"electricChars\", true);\n    option(\"inputStyle\", mobile ? \"contenteditable\" : \"textarea\", function () {\n      throw new Error(\"inputStyle can not (yet) be changed in a running editor\"); // FIXME\n    }, true);\n    option(\"spellcheck\", false, function (cm, val) {\n      return cm.getInputField().spellcheck = val;\n    }, true);\n    option(\"autocorrect\", false, function (cm, val) {\n      return cm.getInputField().autocorrect = val;\n    }, true);\n    option(\"autocapitalize\", false, function (cm, val) {\n      return cm.getInputField().autocapitalize = val;\n    }, true);\n    option(\"rtlMoveVisually\", !windows);\n    option(\"wholeLineUpdateBefore\", true);\n    option(\"theme\", \"default\", function (cm) {\n      themeChanged(cm);\n      updateGutters(cm);\n    }, true);\n    option(\"keyMap\", \"default\", function (cm, val, old) {\n      var next = getKeyMap(val);\n      var prev = old != Init && getKeyMap(old);\n\n      if (prev && prev.detach) {\n        prev.detach(cm, next);\n      }\n\n      if (next.attach) {\n        next.attach(cm, prev || null);\n      }\n    });\n    option(\"extraKeys\", null);\n    option(\"configureMouse\", null);\n    option(\"lineWrapping\", false, wrappingChanged, true);\n    option(\"gutters\", [], function (cm, val) {\n      cm.display.gutterSpecs = getGutters(val, cm.options.lineNumbers);\n      updateGutters(cm);\n    }, true);\n    option(\"fixedGutter\", true, function (cm, val) {\n      cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + \"px\" : \"0\";\n      cm.refresh();\n    }, true);\n    option(\"coverGutterNextToScrollbar\", false, function (cm) {\n      return updateScrollbars(cm);\n    }, true);\n    option(\"scrollbarStyle\", \"native\", function (cm) {\n      initScrollbars(cm);\n      updateScrollbars(cm);\n      cm.display.scrollbars.setScrollTop(cm.doc.scrollTop);\n      cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft);\n    }, true);\n    option(\"lineNumbers\", false, function (cm, val) {\n      cm.display.gutterSpecs = getGutters(cm.options.gutters, val);\n      updateGutters(cm);\n    }, true);\n    option(\"firstLineNumber\", 1, updateGutters, true);\n    option(\"lineNumberFormatter\", function (integer) {\n      return integer;\n    }, updateGutters, true);\n    option(\"showCursorWhenSelecting\", false, updateSelection, true);\n    option(\"resetSelectionOnContextMenu\", true);\n    option(\"lineWiseCopyCut\", true);\n    option(\"pasteLinesPerSelection\", true);\n    option(\"selectionsMayTouch\", false);\n    option(\"readOnly\", false, function (cm, val) {\n      if (val == \"nocursor\") {\n        onBlur(cm);\n        cm.display.input.blur();\n      }\n\n      cm.display.input.readOnlyChanged(val);\n    });\n    option(\"screenReaderLabel\", null, function (cm, val) {\n      val = val === '' ? null : val;\n      cm.display.input.screenReaderLabelChanged(val);\n    });\n    option(\"disableInput\", false, function (cm, val) {\n      if (!val) {\n        cm.display.input.reset();\n      }\n    }, true);\n    option(\"dragDrop\", true, dragDropChanged);\n    option(\"allowDropFileTypes\", null);\n    option(\"cursorBlinkRate\", 530);\n    option(\"cursorScrollMargin\", 0);\n    option(\"cursorHeight\", 1, updateSelection, true);\n    option(\"singleCursorHeightPerLine\", true, updateSelection, true);\n    option(\"workTime\", 100);\n    option(\"workDelay\", 100);\n    option(\"flattenSpans\", true, resetModeState, true);\n    option(\"addModeClass\", false, resetModeState, true);\n    option(\"pollInterval\", 100);\n    option(\"undoDepth\", 200, function (cm, val) {\n      return cm.doc.history.undoDepth = val;\n    });\n    option(\"historyEventDelay\", 1250);\n    option(\"viewportMargin\", 10, function (cm) {\n      return cm.refresh();\n    }, true);\n    option(\"maxHighlightLength\", 10000, resetModeState, true);\n    option(\"moveInputWithCursor\", true, function (cm, val) {\n      if (!val) {\n        cm.display.input.resetPosition();\n      }\n    });\n    option(\"tabindex\", null, function (cm, val) {\n      return cm.display.input.getField().tabIndex = val || \"\";\n    });\n    option(\"autofocus\", null);\n    option(\"direction\", \"ltr\", function (cm, val) {\n      return cm.doc.setDirection(val);\n    }, true);\n    option(\"phrases\", null);\n  }\n\n  function dragDropChanged(cm, value, old) {\n    var wasOn = old && old != Init;\n\n    if (!value != !wasOn) {\n      var funcs = cm.display.dragFunctions;\n      var toggle = value ? on : off;\n      toggle(cm.display.scroller, \"dragstart\", funcs.start);\n      toggle(cm.display.scroller, \"dragenter\", funcs.enter);\n      toggle(cm.display.scroller, \"dragover\", funcs.over);\n      toggle(cm.display.scroller, \"dragleave\", funcs.leave);\n      toggle(cm.display.scroller, \"drop\", funcs.drop);\n    }\n  }\n\n  function wrappingChanged(cm) {\n    if (cm.options.lineWrapping) {\n      addClass(cm.display.wrapper, \"CodeMirror-wrap\");\n      cm.display.sizer.style.minWidth = \"\";\n      cm.display.sizerWidth = null;\n    } else {\n      rmClass(cm.display.wrapper, \"CodeMirror-wrap\");\n      findMaxLine(cm);\n    }\n\n    estimateLineHeights(cm);\n    regChange(cm);\n    clearCaches(cm);\n    setTimeout(function () {\n      return updateScrollbars(cm);\n    }, 100);\n  } // A CodeMirror instance represents an editor. This is the object\n  // that user code is usually dealing with.\n\n\n  function CodeMirror(place, options) {\n    var this$1 = this;\n\n    if (!(this instanceof CodeMirror)) {\n      return new CodeMirror(place, options);\n    }\n\n    this.options = options = options ? copyObj(options) : {}; // Determine effective options based on given values and defaults.\n\n    copyObj(defaults, options, false);\n    var doc = options.value;\n\n    if (typeof doc == \"string\") {\n      doc = new Doc(doc, options.mode, null, options.lineSeparator, options.direction);\n    } else if (options.mode) {\n      doc.modeOption = options.mode;\n    }\n\n    this.doc = doc;\n    var input = new CodeMirror.inputStyles[options.inputStyle](this);\n    var display = this.display = new Display(place, doc, input, options);\n    display.wrapper.CodeMirror = this;\n    themeChanged(this);\n\n    if (options.lineWrapping) {\n      this.display.wrapper.className += \" CodeMirror-wrap\";\n    }\n\n    initScrollbars(this);\n    this.state = {\n      keyMaps: [],\n      // stores maps added by addKeyMap\n      overlays: [],\n      // highlighting overlays, as added by addOverlay\n      modeGen: 0,\n      // bumped when mode/overlay changes, used to invalidate highlighting info\n      overwrite: false,\n      delayingBlurEvent: false,\n      focused: false,\n      suppressEdits: false,\n      // used to disable editing during key handlers when in readOnly mode\n      pasteIncoming: -1,\n      cutIncoming: -1,\n      // help recognize paste/cut edits in input.poll\n      selectingText: false,\n      draggingText: false,\n      highlight: new Delayed(),\n      // stores highlight worker timeout\n      keySeq: null,\n      // Unfinished key sequence\n      specialChars: null\n    };\n\n    if (options.autofocus && !mobile) {\n      display.input.focus();\n    } // Override magic textarea content restore that IE sometimes does\n    // on our hidden textarea on reload\n\n\n    if (ie && ie_version < 11) {\n      setTimeout(function () {\n        return this$1.display.input.reset(true);\n      }, 20);\n    }\n\n    registerEventHandlers(this);\n    ensureGlobalHandlers();\n    startOperation(this);\n    this.curOp.forceUpdate = true;\n    attachDoc(this, doc);\n\n    if (options.autofocus && !mobile || this.hasFocus()) {\n      setTimeout(bind(onFocus, this), 20);\n    } else {\n      onBlur(this);\n    }\n\n    for (var opt in optionHandlers) {\n      if (optionHandlers.hasOwnProperty(opt)) {\n        optionHandlers[opt](this, options[opt], Init);\n      }\n    }\n\n    maybeUpdateLineNumberWidth(this);\n\n    if (options.finishInit) {\n      options.finishInit(this);\n    }\n\n    for (var i = 0; i < initHooks.length; ++i) {\n      initHooks[i](this);\n    }\n\n    endOperation(this); // Suppress optimizelegibility in Webkit, since it breaks text\n    // measuring on line wrapping boundaries.\n\n    if (webkit && options.lineWrapping && getComputedStyle(display.lineDiv).textRendering == \"optimizelegibility\") {\n      display.lineDiv.style.textRendering = \"auto\";\n    }\n  } // The default configuration options.\n\n\n  CodeMirror.defaults = defaults; // Functions to run when options are changed.\n\n  CodeMirror.optionHandlers = optionHandlers; // Attach the necessary event handlers when initializing the editor\n\n  function registerEventHandlers(cm) {\n    var d = cm.display;\n    on(d.scroller, \"mousedown\", operation(cm, onMouseDown)); // Older IE's will not fire a second mousedown for a double click\n\n    if (ie && ie_version < 11) {\n      on(d.scroller, \"dblclick\", operation(cm, function (e) {\n        if (signalDOMEvent(cm, e)) {\n          return;\n        }\n\n        var pos = posFromMouse(cm, e);\n\n        if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) {\n          return;\n        }\n\n        e_preventDefault(e);\n        var word = cm.findWordAt(pos);\n        extendSelection(cm.doc, word.anchor, word.head);\n      }));\n    } else {\n      on(d.scroller, \"dblclick\", function (e) {\n        return signalDOMEvent(cm, e) || e_preventDefault(e);\n      });\n    } // Some browsers fire contextmenu *after* opening the menu, at\n    // which point we can't mess with it anymore. Context menu is\n    // handled in onMouseDown for these browsers.\n\n\n    on(d.scroller, \"contextmenu\", function (e) {\n      return onContextMenu(cm, e);\n    });\n    on(d.input.getField(), \"contextmenu\", function (e) {\n      if (!d.scroller.contains(e.target)) {\n        onContextMenu(cm, e);\n      }\n    }); // Used to suppress mouse event handling when a touch happens\n\n    var touchFinished,\n        prevTouch = {\n      end: 0\n    };\n\n    function finishTouch() {\n      if (d.activeTouch) {\n        touchFinished = setTimeout(function () {\n          return d.activeTouch = null;\n        }, 1000);\n        prevTouch = d.activeTouch;\n        prevTouch.end = +new Date();\n      }\n    }\n\n    function isMouseLikeTouchEvent(e) {\n      if (e.touches.length != 1) {\n        return false;\n      }\n\n      var touch = e.touches[0];\n      return touch.radiusX <= 1 && touch.radiusY <= 1;\n    }\n\n    function farAway(touch, other) {\n      if (other.left == null) {\n        return true;\n      }\n\n      var dx = other.left - touch.left,\n          dy = other.top - touch.top;\n      return dx * dx + dy * dy > 20 * 20;\n    }\n\n    on(d.scroller, \"touchstart\", function (e) {\n      if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e) && !clickInGutter(cm, e)) {\n        d.input.ensurePolled();\n        clearTimeout(touchFinished);\n        var now = +new Date();\n        d.activeTouch = {\n          start: now,\n          moved: false,\n          prev: now - prevTouch.end <= 300 ? prevTouch : null\n        };\n\n        if (e.touches.length == 1) {\n          d.activeTouch.left = e.touches[0].pageX;\n          d.activeTouch.top = e.touches[0].pageY;\n        }\n      }\n    });\n    on(d.scroller, \"touchmove\", function () {\n      if (d.activeTouch) {\n        d.activeTouch.moved = true;\n      }\n    });\n    on(d.scroller, \"touchend\", function (e) {\n      var touch = d.activeTouch;\n\n      if (touch && !eventInWidget(d, e) && touch.left != null && !touch.moved && new Date() - touch.start < 300) {\n        var pos = cm.coordsChar(d.activeTouch, \"page\"),\n            range;\n\n        if (!touch.prev || farAway(touch, touch.prev)) // Single tap\n          {\n            range = new Range(pos, pos);\n          } else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap\n          {\n            range = cm.findWordAt(pos);\n          } else // Triple tap\n          {\n            range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0)));\n          }\n\n        cm.setSelection(range.anchor, range.head);\n        cm.focus();\n        e_preventDefault(e);\n      }\n\n      finishTouch();\n    });\n    on(d.scroller, \"touchcancel\", finishTouch); // Sync scrolling between fake scrollbars and real scrollable\n    // area, ensure viewport is updated when scrolling.\n\n    on(d.scroller, \"scroll\", function () {\n      if (d.scroller.clientHeight) {\n        updateScrollTop(cm, d.scroller.scrollTop);\n        setScrollLeft(cm, d.scroller.scrollLeft, true);\n        signal(cm, \"scroll\", cm);\n      }\n    }); // Listen to wheel events in order to try and update the viewport on time.\n\n    on(d.scroller, \"mousewheel\", function (e) {\n      return onScrollWheel(cm, e);\n    });\n    on(d.scroller, \"DOMMouseScroll\", function (e) {\n      return onScrollWheel(cm, e);\n    }); // Prevent wrapper from ever scrolling\n\n    on(d.wrapper, \"scroll\", function () {\n      return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0;\n    });\n    d.dragFunctions = {\n      enter: function (e) {\n        if (!signalDOMEvent(cm, e)) {\n          e_stop(e);\n        }\n      },\n      over: function (e) {\n        if (!signalDOMEvent(cm, e)) {\n          onDragOver(cm, e);\n          e_stop(e);\n        }\n      },\n      start: function (e) {\n        return onDragStart(cm, e);\n      },\n      drop: operation(cm, onDrop),\n      leave: function (e) {\n        if (!signalDOMEvent(cm, e)) {\n          clearDragCursor(cm);\n        }\n      }\n    };\n    var inp = d.input.getField();\n    on(inp, \"keyup\", function (e) {\n      return onKeyUp.call(cm, e);\n    });\n    on(inp, \"keydown\", operation(cm, onKeyDown));\n    on(inp, \"keypress\", operation(cm, onKeyPress));\n    on(inp, \"focus\", function (e) {\n      return onFocus(cm, e);\n    });\n    on(inp, \"blur\", function (e) {\n      return onBlur(cm, e);\n    });\n  }\n\n  var initHooks = [];\n\n  CodeMirror.defineInitHook = function (f) {\n    return initHooks.push(f);\n  }; // Indent the given line. The how parameter can be \"smart\",\n  // \"add\"/null, \"subtract\", or \"prev\". When aggressive is false\n  // (typically set to true for forced single-line indents), empty\n  // lines are not indented, and places where the mode returns Pass\n  // are left alone.\n\n\n  function indentLine(cm, n, how, aggressive) {\n    var doc = cm.doc,\n        state;\n\n    if (how == null) {\n      how = \"add\";\n    }\n\n    if (how == \"smart\") {\n      // Fall back to \"prev\" when the mode doesn't have an indentation\n      // method.\n      if (!doc.mode.indent) {\n        how = \"prev\";\n      } else {\n        state = getContextBefore(cm, n).state;\n      }\n    }\n\n    var tabSize = cm.options.tabSize;\n    var line = getLine(doc, n),\n        curSpace = countColumn(line.text, null, tabSize);\n\n    if (line.stateAfter) {\n      line.stateAfter = null;\n    }\n\n    var curSpaceString = line.text.match(/^\\s*/)[0],\n        indentation;\n\n    if (!aggressive && !/\\S/.test(line.text)) {\n      indentation = 0;\n      how = \"not\";\n    } else if (how == \"smart\") {\n      indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text);\n\n      if (indentation == Pass || indentation > 150) {\n        if (!aggressive) {\n          return;\n        }\n\n        how = \"prev\";\n      }\n    }\n\n    if (how == \"prev\") {\n      if (n > doc.first) {\n        indentation = countColumn(getLine(doc, n - 1).text, null, tabSize);\n      } else {\n        indentation = 0;\n      }\n    } else if (how == \"add\") {\n      indentation = curSpace + cm.options.indentUnit;\n    } else if (how == \"subtract\") {\n      indentation = curSpace - cm.options.indentUnit;\n    } else if (typeof how == \"number\") {\n      indentation = curSpace + how;\n    }\n\n    indentation = Math.max(0, indentation);\n    var indentString = \"\",\n        pos = 0;\n\n    if (cm.options.indentWithTabs) {\n      for (var i = Math.floor(indentation / tabSize); i; --i) {\n        pos += tabSize;\n        indentString += \"\\t\";\n      }\n    }\n\n    if (pos < indentation) {\n      indentString += spaceStr(indentation - pos);\n    }\n\n    if (indentString != curSpaceString) {\n      replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), \"+input\");\n      line.stateAfter = null;\n      return true;\n    } else {\n      // Ensure that, if the cursor was in the whitespace at the start\n      // of the line, it is moved to the end of that space.\n      for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) {\n        var range = doc.sel.ranges[i$1];\n\n        if (range.head.line == n && range.head.ch < curSpaceString.length) {\n          var pos$1 = Pos(n, curSpaceString.length);\n          replaceOneSelection(doc, i$1, new Range(pos$1, pos$1));\n          break;\n        }\n      }\n    }\n  } // This will be set to a {lineWise: bool, text: [string]} object, so\n  // that, when pasting, we know what kind of selections the copied\n  // text was made out of.\n\n\n  var lastCopied = null;\n\n  function setLastCopied(newLastCopied) {\n    lastCopied = newLastCopied;\n  }\n\n  function applyTextInput(cm, inserted, deleted, sel, origin) {\n    var doc = cm.doc;\n    cm.display.shift = false;\n\n    if (!sel) {\n      sel = doc.sel;\n    }\n\n    var recent = +new Date() - 200;\n    var paste = origin == \"paste\" || cm.state.pasteIncoming > recent;\n    var textLines = splitLinesAuto(inserted),\n        multiPaste = null; // When pasting N lines into N selections, insert one line per selection\n\n    if (paste && sel.ranges.length > 1) {\n      if (lastCopied && lastCopied.text.join(\"\\n\") == inserted) {\n        if (sel.ranges.length % lastCopied.text.length == 0) {\n          multiPaste = [];\n\n          for (var i = 0; i < lastCopied.text.length; i++) {\n            multiPaste.push(doc.splitLines(lastCopied.text[i]));\n          }\n        }\n      } else if (textLines.length == sel.ranges.length && cm.options.pasteLinesPerSelection) {\n        multiPaste = map(textLines, function (l) {\n          return [l];\n        });\n      }\n    }\n\n    var updateInput = cm.curOp.updateInput; // Normal behavior is to insert the new text into every selection\n\n    for (var i$1 = sel.ranges.length - 1; i$1 >= 0; i$1--) {\n      var range = sel.ranges[i$1];\n      var from = range.from(),\n          to = range.to();\n\n      if (range.empty()) {\n        if (deleted && deleted > 0) // Handle deletion\n          {\n            from = Pos(from.line, from.ch - deleted);\n          } else if (cm.state.overwrite && !paste) // Handle overwrite\n          {\n            to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length));\n          } else if (paste && lastCopied && lastCopied.lineWise && lastCopied.text.join(\"\\n\") == textLines.join(\"\\n\")) {\n          from = to = Pos(from.line, 0);\n        }\n      }\n\n      var changeEvent = {\n        from: from,\n        to: to,\n        text: multiPaste ? multiPaste[i$1 % multiPaste.length] : textLines,\n        origin: origin || (paste ? \"paste\" : cm.state.cutIncoming > recent ? \"cut\" : \"+input\")\n      };\n      makeChange(cm.doc, changeEvent);\n      signalLater(cm, \"inputRead\", cm, changeEvent);\n    }\n\n    if (inserted && !paste) {\n      triggerElectric(cm, inserted);\n    }\n\n    ensureCursorVisible(cm);\n\n    if (cm.curOp.updateInput < 2) {\n      cm.curOp.updateInput = updateInput;\n    }\n\n    cm.curOp.typing = true;\n    cm.state.pasteIncoming = cm.state.cutIncoming = -1;\n  }\n\n  function handlePaste(e, cm) {\n    var pasted = e.clipboardData && e.clipboardData.getData(\"Text\");\n\n    if (pasted) {\n      e.preventDefault();\n\n      if (!cm.isReadOnly() && !cm.options.disableInput) {\n        runInOp(cm, function () {\n          return applyTextInput(cm, pasted, 0, null, \"paste\");\n        });\n      }\n\n      return true;\n    }\n  }\n\n  function triggerElectric(cm, inserted) {\n    // When an 'electric' character is inserted, immediately trigger a reindent\n    if (!cm.options.electricChars || !cm.options.smartIndent) {\n      return;\n    }\n\n    var sel = cm.doc.sel;\n\n    for (var i = sel.ranges.length - 1; i >= 0; i--) {\n      var range = sel.ranges[i];\n\n      if (range.head.ch > 100 || i && sel.ranges[i - 1].head.line == range.head.line) {\n        continue;\n      }\n\n      var mode = cm.getModeAt(range.head);\n      var indented = false;\n\n      if (mode.electricChars) {\n        for (var j = 0; j < mode.electricChars.length; j++) {\n          if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {\n            indented = indentLine(cm, range.head.line, \"smart\");\n            break;\n          }\n        }\n      } else if (mode.electricInput) {\n        if (mode.electricInput.test(getLine(cm.doc, range.head.line).text.slice(0, range.head.ch))) {\n          indented = indentLine(cm, range.head.line, \"smart\");\n        }\n      }\n\n      if (indented) {\n        signalLater(cm, \"electricInput\", cm, range.head.line);\n      }\n    }\n  }\n\n  function copyableRanges(cm) {\n    var text = [],\n        ranges = [];\n\n    for (var i = 0; i < cm.doc.sel.ranges.length; i++) {\n      var line = cm.doc.sel.ranges[i].head.line;\n      var lineRange = {\n        anchor: Pos(line, 0),\n        head: Pos(line + 1, 0)\n      };\n      ranges.push(lineRange);\n      text.push(cm.getRange(lineRange.anchor, lineRange.head));\n    }\n\n    return {\n      text: text,\n      ranges: ranges\n    };\n  }\n\n  function disableBrowserMagic(field, spellcheck, autocorrect, autocapitalize) {\n    field.setAttribute(\"autocorrect\", autocorrect ? \"\" : \"off\");\n    field.setAttribute(\"autocapitalize\", autocapitalize ? \"\" : \"off\");\n    field.setAttribute(\"spellcheck\", !!spellcheck);\n  }\n\n  function hiddenTextarea() {\n    var te = elt(\"textarea\", null, null, \"position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none\");\n    var div = elt(\"div\", [te], null, \"overflow: hidden; position: relative; width: 3px; height: 0px;\"); // The textarea is kept positioned near the cursor to prevent the\n    // fact that it'll be scrolled into view on input from scrolling\n    // our fake cursor out of view. On webkit, when wrap=off, paste is\n    // very slow. So make the area wide instead.\n\n    if (webkit) {\n      te.style.width = \"1000px\";\n    } else {\n      te.setAttribute(\"wrap\", \"off\");\n    } // If border: 0; -- iOS fails to open keyboard (issue #1287)\n\n\n    if (ios) {\n      te.style.border = \"1px solid black\";\n    }\n\n    disableBrowserMagic(te);\n    return div;\n  } // The publicly visible API. Note that methodOp(f) means\n  // 'wrap f in an operation, performed on its `this` parameter'.\n  // This is not the complete set of editor methods. Most of the\n  // methods defined on the Doc type are also injected into\n  // CodeMirror.prototype, for backwards compatibility and\n  // convenience.\n\n\n  function addEditorMethods(CodeMirror) {\n    var optionHandlers = CodeMirror.optionHandlers;\n    var helpers = CodeMirror.helpers = {};\n    CodeMirror.prototype = {\n      constructor: CodeMirror,\n      focus: function () {\n        window.focus();\n        this.display.input.focus();\n      },\n      setOption: function (option, value) {\n        var options = this.options,\n            old = options[option];\n\n        if (options[option] == value && option != \"mode\") {\n          return;\n        }\n\n        options[option] = value;\n\n        if (optionHandlers.hasOwnProperty(option)) {\n          operation(this, optionHandlers[option])(this, value, old);\n        }\n\n        signal(this, \"optionChange\", this, option);\n      },\n      getOption: function (option) {\n        return this.options[option];\n      },\n      getDoc: function () {\n        return this.doc;\n      },\n      addKeyMap: function (map, bottom) {\n        this.state.keyMaps[bottom ? \"push\" : \"unshift\"](getKeyMap(map));\n      },\n      removeKeyMap: function (map) {\n        var maps = this.state.keyMaps;\n\n        for (var i = 0; i < maps.length; ++i) {\n          if (maps[i] == map || maps[i].name == map) {\n            maps.splice(i, 1);\n            return true;\n          }\n        }\n      },\n      addOverlay: methodOp(function (spec, options) {\n        var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec);\n\n        if (mode.startState) {\n          throw new Error(\"Overlays may not be stateful.\");\n        }\n\n        insertSorted(this.state.overlays, {\n          mode: mode,\n          modeSpec: spec,\n          opaque: options && options.opaque,\n          priority: options && options.priority || 0\n        }, function (overlay) {\n          return overlay.priority;\n        });\n        this.state.modeGen++;\n        regChange(this);\n      }),\n      removeOverlay: methodOp(function (spec) {\n        var overlays = this.state.overlays;\n\n        for (var i = 0; i < overlays.length; ++i) {\n          var cur = overlays[i].modeSpec;\n\n          if (cur == spec || typeof spec == \"string\" && cur.name == spec) {\n            overlays.splice(i, 1);\n            this.state.modeGen++;\n            regChange(this);\n            return;\n          }\n        }\n      }),\n      indentLine: methodOp(function (n, dir, aggressive) {\n        if (typeof dir != \"string\" && typeof dir != \"number\") {\n          if (dir == null) {\n            dir = this.options.smartIndent ? \"smart\" : \"prev\";\n          } else {\n            dir = dir ? \"add\" : \"subtract\";\n          }\n        }\n\n        if (isLine(this.doc, n)) {\n          indentLine(this, n, dir, aggressive);\n        }\n      }),\n      indentSelection: methodOp(function (how) {\n        var ranges = this.doc.sel.ranges,\n            end = -1;\n\n        for (var i = 0; i < ranges.length; i++) {\n          var range = ranges[i];\n\n          if (!range.empty()) {\n            var from = range.from(),\n                to = range.to();\n            var start = Math.max(end, from.line);\n            end = Math.min(this.lastLine(), to.line - (to.ch ? 0 : 1)) + 1;\n\n            for (var j = start; j < end; ++j) {\n              indentLine(this, j, how);\n            }\n\n            var newRanges = this.doc.sel.ranges;\n\n            if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0) {\n              replaceOneSelection(this.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll);\n            }\n          } else if (range.head.line > end) {\n            indentLine(this, range.head.line, how, true);\n            end = range.head.line;\n\n            if (i == this.doc.sel.primIndex) {\n              ensureCursorVisible(this);\n            }\n          }\n        }\n      }),\n      // Fetch the parser token for a given character. Useful for hacks\n      // that want to inspect the mode state (say, for completion).\n      getTokenAt: function (pos, precise) {\n        return takeToken(this, pos, precise);\n      },\n      getLineTokens: function (line, precise) {\n        return takeToken(this, Pos(line), precise, true);\n      },\n      getTokenTypeAt: function (pos) {\n        pos = clipPos(this.doc, pos);\n        var styles = getLineStyles(this, getLine(this.doc, pos.line));\n        var before = 0,\n            after = (styles.length - 1) / 2,\n            ch = pos.ch;\n        var type;\n\n        if (ch == 0) {\n          type = styles[2];\n        } else {\n          for (;;) {\n            var mid = before + after >> 1;\n\n            if ((mid ? styles[mid * 2 - 1] : 0) >= ch) {\n              after = mid;\n            } else if (styles[mid * 2 + 1] < ch) {\n              before = mid + 1;\n            } else {\n              type = styles[mid * 2 + 2];\n              break;\n            }\n          }\n        }\n\n        var cut = type ? type.indexOf(\"overlay \") : -1;\n        return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1);\n      },\n      getModeAt: function (pos) {\n        var mode = this.doc.mode;\n\n        if (!mode.innerMode) {\n          return mode;\n        }\n\n        return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode;\n      },\n      getHelper: function (pos, type) {\n        return this.getHelpers(pos, type)[0];\n      },\n      getHelpers: function (pos, type) {\n        var found = [];\n\n        if (!helpers.hasOwnProperty(type)) {\n          return found;\n        }\n\n        var help = helpers[type],\n            mode = this.getModeAt(pos);\n\n        if (typeof mode[type] == \"string\") {\n          if (help[mode[type]]) {\n            found.push(help[mode[type]]);\n          }\n        } else if (mode[type]) {\n          for (var i = 0; i < mode[type].length; i++) {\n            var val = help[mode[type][i]];\n\n            if (val) {\n              found.push(val);\n            }\n          }\n        } else if (mode.helperType && help[mode.helperType]) {\n          found.push(help[mode.helperType]);\n        } else if (help[mode.name]) {\n          found.push(help[mode.name]);\n        }\n\n        for (var i$1 = 0; i$1 < help._global.length; i$1++) {\n          var cur = help._global[i$1];\n\n          if (cur.pred(mode, this) && indexOf(found, cur.val) == -1) {\n            found.push(cur.val);\n          }\n        }\n\n        return found;\n      },\n      getStateAfter: function (line, precise) {\n        var doc = this.doc;\n        line = clipLine(doc, line == null ? doc.first + doc.size - 1 : line);\n        return getContextBefore(this, line + 1, precise).state;\n      },\n      cursorCoords: function (start, mode) {\n        var pos,\n            range = this.doc.sel.primary();\n\n        if (start == null) {\n          pos = range.head;\n        } else if (typeof start == \"object\") {\n          pos = clipPos(this.doc, start);\n        } else {\n          pos = start ? range.from() : range.to();\n        }\n\n        return cursorCoords(this, pos, mode || \"page\");\n      },\n      charCoords: function (pos, mode) {\n        return charCoords(this, clipPos(this.doc, pos), mode || \"page\");\n      },\n      coordsChar: function (coords, mode) {\n        coords = fromCoordSystem(this, coords, mode || \"page\");\n        return coordsChar(this, coords.left, coords.top);\n      },\n      lineAtHeight: function (height, mode) {\n        height = fromCoordSystem(this, {\n          top: height,\n          left: 0\n        }, mode || \"page\").top;\n        return lineAtHeight(this.doc, height + this.display.viewOffset);\n      },\n      heightAtLine: function (line, mode, includeWidgets) {\n        var end = false,\n            lineObj;\n\n        if (typeof line == \"number\") {\n          var last = this.doc.first + this.doc.size - 1;\n\n          if (line < this.doc.first) {\n            line = this.doc.first;\n          } else if (line > last) {\n            line = last;\n            end = true;\n          }\n\n          lineObj = getLine(this.doc, line);\n        } else {\n          lineObj = line;\n        }\n\n        return intoCoordSystem(this, lineObj, {\n          top: 0,\n          left: 0\n        }, mode || \"page\", includeWidgets || end).top + (end ? this.doc.height - heightAtLine(lineObj) : 0);\n      },\n      defaultTextHeight: function () {\n        return textHeight(this.display);\n      },\n      defaultCharWidth: function () {\n        return charWidth(this.display);\n      },\n      getViewport: function () {\n        return {\n          from: this.display.viewFrom,\n          to: this.display.viewTo\n        };\n      },\n      addWidget: function (pos, node, scroll, vert, horiz) {\n        var display = this.display;\n        pos = cursorCoords(this, clipPos(this.doc, pos));\n        var top = pos.bottom,\n            left = pos.left;\n        node.style.position = \"absolute\";\n        node.setAttribute(\"cm-ignore-events\", \"true\");\n        this.display.input.setUneditable(node);\n        display.sizer.appendChild(node);\n\n        if (vert == \"over\") {\n          top = pos.top;\n        } else if (vert == \"above\" || vert == \"near\") {\n          var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),\n              hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth); // Default to positioning above (if specified and possible); otherwise default to positioning below\n\n          if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight) {\n            top = pos.top - node.offsetHeight;\n          } else if (pos.bottom + node.offsetHeight <= vspace) {\n            top = pos.bottom;\n          }\n\n          if (left + node.offsetWidth > hspace) {\n            left = hspace - node.offsetWidth;\n          }\n        }\n\n        node.style.top = top + \"px\";\n        node.style.left = node.style.right = \"\";\n\n        if (horiz == \"right\") {\n          left = display.sizer.clientWidth - node.offsetWidth;\n          node.style.right = \"0px\";\n        } else {\n          if (horiz == \"left\") {\n            left = 0;\n          } else if (horiz == \"middle\") {\n            left = (display.sizer.clientWidth - node.offsetWidth) / 2;\n          }\n\n          node.style.left = left + \"px\";\n        }\n\n        if (scroll) {\n          scrollIntoView(this, {\n            left: left,\n            top: top,\n            right: left + node.offsetWidth,\n            bottom: top + node.offsetHeight\n          });\n        }\n      },\n      triggerOnKeyDown: methodOp(onKeyDown),\n      triggerOnKeyPress: methodOp(onKeyPress),\n      triggerOnKeyUp: onKeyUp,\n      triggerOnMouseDown: methodOp(onMouseDown),\n      execCommand: function (cmd) {\n        if (commands.hasOwnProperty(cmd)) {\n          return commands[cmd].call(null, this);\n        }\n      },\n      triggerElectric: methodOp(function (text) {\n        triggerElectric(this, text);\n      }),\n      findPosH: function (from, amount, unit, visually) {\n        var dir = 1;\n\n        if (amount < 0) {\n          dir = -1;\n          amount = -amount;\n        }\n\n        var cur = clipPos(this.doc, from);\n\n        for (var i = 0; i < amount; ++i) {\n          cur = findPosH(this.doc, cur, dir, unit, visually);\n\n          if (cur.hitSide) {\n            break;\n          }\n        }\n\n        return cur;\n      },\n      moveH: methodOp(function (dir, unit) {\n        var this$1 = this;\n        this.extendSelectionsBy(function (range) {\n          if (this$1.display.shift || this$1.doc.extend || range.empty()) {\n            return findPosH(this$1.doc, range.head, dir, unit, this$1.options.rtlMoveVisually);\n          } else {\n            return dir < 0 ? range.from() : range.to();\n          }\n        }, sel_move);\n      }),\n      deleteH: methodOp(function (dir, unit) {\n        var sel = this.doc.sel,\n            doc = this.doc;\n\n        if (sel.somethingSelected()) {\n          doc.replaceSelection(\"\", null, \"+delete\");\n        } else {\n          deleteNearSelection(this, function (range) {\n            var other = findPosH(doc, range.head, dir, unit, false);\n            return dir < 0 ? {\n              from: other,\n              to: range.head\n            } : {\n              from: range.head,\n              to: other\n            };\n          });\n        }\n      }),\n      findPosV: function (from, amount, unit, goalColumn) {\n        var dir = 1,\n            x = goalColumn;\n\n        if (amount < 0) {\n          dir = -1;\n          amount = -amount;\n        }\n\n        var cur = clipPos(this.doc, from);\n\n        for (var i = 0; i < amount; ++i) {\n          var coords = cursorCoords(this, cur, \"div\");\n\n          if (x == null) {\n            x = coords.left;\n          } else {\n            coords.left = x;\n          }\n\n          cur = findPosV(this, coords, dir, unit);\n\n          if (cur.hitSide) {\n            break;\n          }\n        }\n\n        return cur;\n      },\n      moveV: methodOp(function (dir, unit) {\n        var this$1 = this;\n        var doc = this.doc,\n            goals = [];\n        var collapse = !this.display.shift && !doc.extend && doc.sel.somethingSelected();\n        doc.extendSelectionsBy(function (range) {\n          if (collapse) {\n            return dir < 0 ? range.from() : range.to();\n          }\n\n          var headPos = cursorCoords(this$1, range.head, \"div\");\n\n          if (range.goalColumn != null) {\n            headPos.left = range.goalColumn;\n          }\n\n          goals.push(headPos.left);\n          var pos = findPosV(this$1, headPos, dir, unit);\n\n          if (unit == \"page\" && range == doc.sel.primary()) {\n            addToScrollTop(this$1, charCoords(this$1, pos, \"div\").top - headPos.top);\n          }\n\n          return pos;\n        }, sel_move);\n\n        if (goals.length) {\n          for (var i = 0; i < doc.sel.ranges.length; i++) {\n            doc.sel.ranges[i].goalColumn = goals[i];\n          }\n        }\n      }),\n      // Find the word at the given position (as returned by coordsChar).\n      findWordAt: function (pos) {\n        var doc = this.doc,\n            line = getLine(doc, pos.line).text;\n        var start = pos.ch,\n            end = pos.ch;\n\n        if (line) {\n          var helper = this.getHelper(pos, \"wordChars\");\n\n          if ((pos.sticky == \"before\" || end == line.length) && start) {\n            --start;\n          } else {\n            ++end;\n          }\n\n          var startChar = line.charAt(start);\n          var check = isWordChar(startChar, helper) ? function (ch) {\n            return isWordChar(ch, helper);\n          } : /\\s/.test(startChar) ? function (ch) {\n            return /\\s/.test(ch);\n          } : function (ch) {\n            return !/\\s/.test(ch) && !isWordChar(ch);\n          };\n\n          while (start > 0 && check(line.charAt(start - 1))) {\n            --start;\n          }\n\n          while (end < line.length && check(line.charAt(end))) {\n            ++end;\n          }\n        }\n\n        return new Range(Pos(pos.line, start), Pos(pos.line, end));\n      },\n      toggleOverwrite: function (value) {\n        if (value != null && value == this.state.overwrite) {\n          return;\n        }\n\n        if (this.state.overwrite = !this.state.overwrite) {\n          addClass(this.display.cursorDiv, \"CodeMirror-overwrite\");\n        } else {\n          rmClass(this.display.cursorDiv, \"CodeMirror-overwrite\");\n        }\n\n        signal(this, \"overwriteToggle\", this, this.state.overwrite);\n      },\n      hasFocus: function () {\n        return this.display.input.getField() == activeElt();\n      },\n      isReadOnly: function () {\n        return !!(this.options.readOnly || this.doc.cantEdit);\n      },\n      scrollTo: methodOp(function (x, y) {\n        scrollToCoords(this, x, y);\n      }),\n      getScrollInfo: function () {\n        var scroller = this.display.scroller;\n        return {\n          left: scroller.scrollLeft,\n          top: scroller.scrollTop,\n          height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,\n          width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,\n          clientHeight: displayHeight(this),\n          clientWidth: displayWidth(this)\n        };\n      },\n      scrollIntoView: methodOp(function (range, margin) {\n        if (range == null) {\n          range = {\n            from: this.doc.sel.primary().head,\n            to: null\n          };\n\n          if (margin == null) {\n            margin = this.options.cursorScrollMargin;\n          }\n        } else if (typeof range == \"number\") {\n          range = {\n            from: Pos(range, 0),\n            to: null\n          };\n        } else if (range.from == null) {\n          range = {\n            from: range,\n            to: null\n          };\n        }\n\n        if (!range.to) {\n          range.to = range.from;\n        }\n\n        range.margin = margin || 0;\n\n        if (range.from.line != null) {\n          scrollToRange(this, range);\n        } else {\n          scrollToCoordsRange(this, range.from, range.to, range.margin);\n        }\n      }),\n      setSize: methodOp(function (width, height) {\n        var this$1 = this;\n\n        var interpret = function (val) {\n          return typeof val == \"number\" || /^\\d+$/.test(String(val)) ? val + \"px\" : val;\n        };\n\n        if (width != null) {\n          this.display.wrapper.style.width = interpret(width);\n        }\n\n        if (height != null) {\n          this.display.wrapper.style.height = interpret(height);\n        }\n\n        if (this.options.lineWrapping) {\n          clearLineMeasurementCache(this);\n        }\n\n        var lineNo = this.display.viewFrom;\n        this.doc.iter(lineNo, this.display.viewTo, function (line) {\n          if (line.widgets) {\n            for (var i = 0; i < line.widgets.length; i++) {\n              if (line.widgets[i].noHScroll) {\n                regLineChange(this$1, lineNo, \"widget\");\n                break;\n              }\n            }\n          }\n\n          ++lineNo;\n        });\n        this.curOp.forceUpdate = true;\n        signal(this, \"refresh\", this);\n      }),\n      operation: function (f) {\n        return runInOp(this, f);\n      },\n      startOperation: function () {\n        return startOperation(this);\n      },\n      endOperation: function () {\n        return endOperation(this);\n      },\n      refresh: methodOp(function () {\n        var oldHeight = this.display.cachedTextHeight;\n        regChange(this);\n        this.curOp.forceUpdate = true;\n        clearCaches(this);\n        scrollToCoords(this, this.doc.scrollLeft, this.doc.scrollTop);\n        updateGutterSpace(this.display);\n\n        if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5 || this.options.lineWrapping) {\n          estimateLineHeights(this);\n        }\n\n        signal(this, \"refresh\", this);\n      }),\n      swapDoc: methodOp(function (doc) {\n        var old = this.doc;\n        old.cm = null; // Cancel the current text selection if any (#5821)\n\n        if (this.state.selectingText) {\n          this.state.selectingText();\n        }\n\n        attachDoc(this, doc);\n        clearCaches(this);\n        this.display.input.reset();\n        scrollToCoords(this, doc.scrollLeft, doc.scrollTop);\n        this.curOp.forceScroll = true;\n        signalLater(this, \"swapDoc\", this, old);\n        return old;\n      }),\n      phrase: function (phraseText) {\n        var phrases = this.options.phrases;\n        return phrases && Object.prototype.hasOwnProperty.call(phrases, phraseText) ? phrases[phraseText] : phraseText;\n      },\n      getInputField: function () {\n        return this.display.input.getField();\n      },\n      getWrapperElement: function () {\n        return this.display.wrapper;\n      },\n      getScrollerElement: function () {\n        return this.display.scroller;\n      },\n      getGutterElement: function () {\n        return this.display.gutters;\n      }\n    };\n    eventMixin(CodeMirror);\n\n    CodeMirror.registerHelper = function (type, name, value) {\n      if (!helpers.hasOwnProperty(type)) {\n        helpers[type] = CodeMirror[type] = {\n          _global: []\n        };\n      }\n\n      helpers[type][name] = value;\n    };\n\n    CodeMirror.registerGlobalHelper = function (type, name, predicate, value) {\n      CodeMirror.registerHelper(type, name, value);\n\n      helpers[type]._global.push({\n        pred: predicate,\n        val: value\n      });\n    };\n  } // Used for horizontal relative motion. Dir is -1 or 1 (left or\n  // right), unit can be \"char\", \"column\" (like char, but doesn't\n  // cross line boundaries), \"word\" (across next word), or \"group\" (to\n  // the start of next group of word or non-word-non-whitespace\n  // chars). The visually param controls whether, in right-to-left\n  // text, direction 1 means to move towards the next index in the\n  // string, or towards the character to the right of the current\n  // position. The resulting position will have a hitSide=true\n  // property if it reached the end of the document.\n\n\n  function findPosH(doc, pos, dir, unit, visually) {\n    var oldPos = pos;\n    var origDir = dir;\n    var lineObj = getLine(doc, pos.line);\n    var lineDir = visually && doc.direction == \"rtl\" ? -dir : dir;\n\n    function findNextLine() {\n      var l = pos.line + lineDir;\n\n      if (l < doc.first || l >= doc.first + doc.size) {\n        return false;\n      }\n\n      pos = new Pos(l, pos.ch, pos.sticky);\n      return lineObj = getLine(doc, l);\n    }\n\n    function moveOnce(boundToLine) {\n      var next;\n\n      if (visually) {\n        next = moveVisually(doc.cm, lineObj, pos, dir);\n      } else {\n        next = moveLogically(lineObj, pos, dir);\n      }\n\n      if (next == null) {\n        if (!boundToLine && findNextLine()) {\n          pos = endOfLine(visually, doc.cm, lineObj, pos.line, lineDir);\n        } else {\n          return false;\n        }\n      } else {\n        pos = next;\n      }\n\n      return true;\n    }\n\n    if (unit == \"char\") {\n      moveOnce();\n    } else if (unit == \"column\") {\n      moveOnce(true);\n    } else if (unit == \"word\" || unit == \"group\") {\n      var sawType = null,\n          group = unit == \"group\";\n      var helper = doc.cm && doc.cm.getHelper(pos, \"wordChars\");\n\n      for (var first = true;; first = false) {\n        if (dir < 0 && !moveOnce(!first)) {\n          break;\n        }\n\n        var cur = lineObj.text.charAt(pos.ch) || \"\\n\";\n        var type = isWordChar(cur, helper) ? \"w\" : group && cur == \"\\n\" ? \"n\" : !group || /\\s/.test(cur) ? null : \"p\";\n\n        if (group && !first && !type) {\n          type = \"s\";\n        }\n\n        if (sawType && sawType != type) {\n          if (dir < 0) {\n            dir = 1;\n            moveOnce();\n            pos.sticky = \"after\";\n          }\n\n          break;\n        }\n\n        if (type) {\n          sawType = type;\n        }\n\n        if (dir > 0 && !moveOnce(!first)) {\n          break;\n        }\n      }\n    }\n\n    var result = skipAtomic(doc, pos, oldPos, origDir, true);\n\n    if (equalCursorPos(oldPos, result)) {\n      result.hitSide = true;\n    }\n\n    return result;\n  } // For relative vertical movement. Dir may be -1 or 1. Unit can be\n  // \"page\" or \"line\". The resulting position will have a hitSide=true\n  // property if it reached the end of the document.\n\n\n  function findPosV(cm, pos, dir, unit) {\n    var doc = cm.doc,\n        x = pos.left,\n        y;\n\n    if (unit == \"page\") {\n      var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight);\n      var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3);\n      y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount;\n    } else if (unit == \"line\") {\n      y = dir > 0 ? pos.bottom + 3 : pos.top - 3;\n    }\n\n    var target;\n\n    for (;;) {\n      target = coordsChar(cm, x, y);\n\n      if (!target.outside) {\n        break;\n      }\n\n      if (dir < 0 ? y <= 0 : y >= doc.height) {\n        target.hitSide = true;\n        break;\n      }\n\n      y += dir * 5;\n    }\n\n    return target;\n  } // CONTENTEDITABLE INPUT STYLE\n\n\n  var ContentEditableInput = function (cm) {\n    this.cm = cm;\n    this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null;\n    this.polling = new Delayed();\n    this.composing = null;\n    this.gracePeriod = false;\n    this.readDOMTimeout = null;\n  };\n\n  ContentEditableInput.prototype.init = function (display) {\n    var this$1 = this;\n    var input = this,\n        cm = input.cm;\n    var div = input.div = display.lineDiv;\n    disableBrowserMagic(div, cm.options.spellcheck, cm.options.autocorrect, cm.options.autocapitalize);\n\n    function belongsToInput(e) {\n      for (var t = e.target; t; t = t.parentNode) {\n        if (t == div) {\n          return true;\n        }\n\n        if (/\\bCodeMirror-(?:line)?widget\\b/.test(t.className)) {\n          break;\n        }\n      }\n\n      return false;\n    }\n\n    on(div, \"paste\", function (e) {\n      if (!belongsToInput(e) || signalDOMEvent(cm, e) || handlePaste(e, cm)) {\n        return;\n      } // IE doesn't fire input events, so we schedule a read for the pasted content in this way\n\n\n      if (ie_version <= 11) {\n        setTimeout(operation(cm, function () {\n          return this$1.updateFromDOM();\n        }), 20);\n      }\n    });\n    on(div, \"compositionstart\", function (e) {\n      this$1.composing = {\n        data: e.data,\n        done: false\n      };\n    });\n    on(div, \"compositionupdate\", function (e) {\n      if (!this$1.composing) {\n        this$1.composing = {\n          data: e.data,\n          done: false\n        };\n      }\n    });\n    on(div, \"compositionend\", function (e) {\n      if (this$1.composing) {\n        if (e.data != this$1.composing.data) {\n          this$1.readFromDOMSoon();\n        }\n\n        this$1.composing.done = true;\n      }\n    });\n    on(div, \"touchstart\", function () {\n      return input.forceCompositionEnd();\n    });\n    on(div, \"input\", function () {\n      if (!this$1.composing) {\n        this$1.readFromDOMSoon();\n      }\n    });\n\n    function onCopyCut(e) {\n      if (!belongsToInput(e) || signalDOMEvent(cm, e)) {\n        return;\n      }\n\n      if (cm.somethingSelected()) {\n        setLastCopied({\n          lineWise: false,\n          text: cm.getSelections()\n        });\n\n        if (e.type == \"cut\") {\n          cm.replaceSelection(\"\", null, \"cut\");\n        }\n      } else if (!cm.options.lineWiseCopyCut) {\n        return;\n      } else {\n        var ranges = copyableRanges(cm);\n        setLastCopied({\n          lineWise: true,\n          text: ranges.text\n        });\n\n        if (e.type == \"cut\") {\n          cm.operation(function () {\n            cm.setSelections(ranges.ranges, 0, sel_dontScroll);\n            cm.replaceSelection(\"\", null, \"cut\");\n          });\n        }\n      }\n\n      if (e.clipboardData) {\n        e.clipboardData.clearData();\n        var content = lastCopied.text.join(\"\\n\"); // iOS exposes the clipboard API, but seems to discard content inserted into it\n\n        e.clipboardData.setData(\"Text\", content);\n\n        if (e.clipboardData.getData(\"Text\") == content) {\n          e.preventDefault();\n          return;\n        }\n      } // Old-fashioned briefly-focus-a-textarea hack\n\n\n      var kludge = hiddenTextarea(),\n          te = kludge.firstChild;\n      cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild);\n      te.value = lastCopied.text.join(\"\\n\");\n      var hadFocus = document.activeElement;\n      selectInput(te);\n      setTimeout(function () {\n        cm.display.lineSpace.removeChild(kludge);\n        hadFocus.focus();\n\n        if (hadFocus == div) {\n          input.showPrimarySelection();\n        }\n      }, 50);\n    }\n\n    on(div, \"copy\", onCopyCut);\n    on(div, \"cut\", onCopyCut);\n  };\n\n  ContentEditableInput.prototype.screenReaderLabelChanged = function (label) {\n    // Label for screenreaders, accessibility\n    if (label) {\n      this.div.setAttribute('aria-label', label);\n    } else {\n      this.div.removeAttribute('aria-label');\n    }\n  };\n\n  ContentEditableInput.prototype.prepareSelection = function () {\n    var result = prepareSelection(this.cm, false);\n    result.focus = document.activeElement == this.div;\n    return result;\n  };\n\n  ContentEditableInput.prototype.showSelection = function (info, takeFocus) {\n    if (!info || !this.cm.display.view.length) {\n      return;\n    }\n\n    if (info.focus || takeFocus) {\n      this.showPrimarySelection();\n    }\n\n    this.showMultipleSelections(info);\n  };\n\n  ContentEditableInput.prototype.getSelection = function () {\n    return this.cm.display.wrapper.ownerDocument.getSelection();\n  };\n\n  ContentEditableInput.prototype.showPrimarySelection = function () {\n    var sel = this.getSelection(),\n        cm = this.cm,\n        prim = cm.doc.sel.primary();\n    var from = prim.from(),\n        to = prim.to();\n\n    if (cm.display.viewTo == cm.display.viewFrom || from.line >= cm.display.viewTo || to.line < cm.display.viewFrom) {\n      sel.removeAllRanges();\n      return;\n    }\n\n    var curAnchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);\n    var curFocus = domToPos(cm, sel.focusNode, sel.focusOffset);\n\n    if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad && cmp(minPos(curAnchor, curFocus), from) == 0 && cmp(maxPos(curAnchor, curFocus), to) == 0) {\n      return;\n    }\n\n    var view = cm.display.view;\n    var start = from.line >= cm.display.viewFrom && posToDOM(cm, from) || {\n      node: view[0].measure.map[2],\n      offset: 0\n    };\n    var end = to.line < cm.display.viewTo && posToDOM(cm, to);\n\n    if (!end) {\n      var measure = view[view.length - 1].measure;\n      var map = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map;\n      end = {\n        node: map[map.length - 1],\n        offset: map[map.length - 2] - map[map.length - 3]\n      };\n    }\n\n    if (!start || !end) {\n      sel.removeAllRanges();\n      return;\n    }\n\n    var old = sel.rangeCount && sel.getRangeAt(0),\n        rng;\n\n    try {\n      rng = range(start.node, start.offset, end.offset, end.node);\n    } catch (e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible\n\n\n    if (rng) {\n      if (!gecko && cm.state.focused) {\n        sel.collapse(start.node, start.offset);\n\n        if (!rng.collapsed) {\n          sel.removeAllRanges();\n          sel.addRange(rng);\n        }\n      } else {\n        sel.removeAllRanges();\n        sel.addRange(rng);\n      }\n\n      if (old && sel.anchorNode == null) {\n        sel.addRange(old);\n      } else if (gecko) {\n        this.startGracePeriod();\n      }\n    }\n\n    this.rememberSelection();\n  };\n\n  ContentEditableInput.prototype.startGracePeriod = function () {\n    var this$1 = this;\n    clearTimeout(this.gracePeriod);\n    this.gracePeriod = setTimeout(function () {\n      this$1.gracePeriod = false;\n\n      if (this$1.selectionChanged()) {\n        this$1.cm.operation(function () {\n          return this$1.cm.curOp.selectionChanged = true;\n        });\n      }\n    }, 20);\n  };\n\n  ContentEditableInput.prototype.showMultipleSelections = function (info) {\n    removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors);\n    removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection);\n  };\n\n  ContentEditableInput.prototype.rememberSelection = function () {\n    var sel = this.getSelection();\n    this.lastAnchorNode = sel.anchorNode;\n    this.lastAnchorOffset = sel.anchorOffset;\n    this.lastFocusNode = sel.focusNode;\n    this.lastFocusOffset = sel.focusOffset;\n  };\n\n  ContentEditableInput.prototype.selectionInEditor = function () {\n    var sel = this.getSelection();\n\n    if (!sel.rangeCount) {\n      return false;\n    }\n\n    var node = sel.getRangeAt(0).commonAncestorContainer;\n    return contains(this.div, node);\n  };\n\n  ContentEditableInput.prototype.focus = function () {\n    if (this.cm.options.readOnly != \"nocursor\") {\n      if (!this.selectionInEditor() || document.activeElement != this.div) {\n        this.showSelection(this.prepareSelection(), true);\n      }\n\n      this.div.focus();\n    }\n  };\n\n  ContentEditableInput.prototype.blur = function () {\n    this.div.blur();\n  };\n\n  ContentEditableInput.prototype.getField = function () {\n    return this.div;\n  };\n\n  ContentEditableInput.prototype.supportsTouch = function () {\n    return true;\n  };\n\n  ContentEditableInput.prototype.receivedFocus = function () {\n    var input = this;\n\n    if (this.selectionInEditor()) {\n      this.pollSelection();\n    } else {\n      runInOp(this.cm, function () {\n        return input.cm.curOp.selectionChanged = true;\n      });\n    }\n\n    function poll() {\n      if (input.cm.state.focused) {\n        input.pollSelection();\n        input.polling.set(input.cm.options.pollInterval, poll);\n      }\n    }\n\n    this.polling.set(this.cm.options.pollInterval, poll);\n  };\n\n  ContentEditableInput.prototype.selectionChanged = function () {\n    var sel = this.getSelection();\n    return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset || sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset;\n  };\n\n  ContentEditableInput.prototype.pollSelection = function () {\n    if (this.readDOMTimeout != null || this.gracePeriod || !this.selectionChanged()) {\n      return;\n    }\n\n    var sel = this.getSelection(),\n        cm = this.cm; // On Android Chrome (version 56, at least), backspacing into an\n    // uneditable block element will put the cursor in that element,\n    // and then, because it's not editable, hide the virtual keyboard.\n    // Because Android doesn't allow us to actually detect backspace\n    // presses in a sane way, this code checks for when that happens\n    // and simulates a backspace press in this case.\n\n    if (android && chrome && this.cm.display.gutterSpecs.length && isInGutter(sel.anchorNode)) {\n      this.cm.triggerOnKeyDown({\n        type: \"keydown\",\n        keyCode: 8,\n        preventDefault: Math.abs\n      });\n      this.blur();\n      this.focus();\n      return;\n    }\n\n    if (this.composing) {\n      return;\n    }\n\n    this.rememberSelection();\n    var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);\n    var head = domToPos(cm, sel.focusNode, sel.focusOffset);\n\n    if (anchor && head) {\n      runInOp(cm, function () {\n        setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll);\n\n        if (anchor.bad || head.bad) {\n          cm.curOp.selectionChanged = true;\n        }\n      });\n    }\n  };\n\n  ContentEditableInput.prototype.pollContent = function () {\n    if (this.readDOMTimeout != null) {\n      clearTimeout(this.readDOMTimeout);\n      this.readDOMTimeout = null;\n    }\n\n    var cm = this.cm,\n        display = cm.display,\n        sel = cm.doc.sel.primary();\n    var from = sel.from(),\n        to = sel.to();\n\n    if (from.ch == 0 && from.line > cm.firstLine()) {\n      from = Pos(from.line - 1, getLine(cm.doc, from.line - 1).length);\n    }\n\n    if (to.ch == getLine(cm.doc, to.line).text.length && to.line < cm.lastLine()) {\n      to = Pos(to.line + 1, 0);\n    }\n\n    if (from.line < display.viewFrom || to.line > display.viewTo - 1) {\n      return false;\n    }\n\n    var fromIndex, fromLine, fromNode;\n\n    if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {\n      fromLine = lineNo(display.view[0].line);\n      fromNode = display.view[0].node;\n    } else {\n      fromLine = lineNo(display.view[fromIndex].line);\n      fromNode = display.view[fromIndex - 1].node.nextSibling;\n    }\n\n    var toIndex = findViewIndex(cm, to.line);\n    var toLine, toNode;\n\n    if (toIndex == display.view.length - 1) {\n      toLine = display.viewTo - 1;\n      toNode = display.lineDiv.lastChild;\n    } else {\n      toLine = lineNo(display.view[toIndex + 1].line) - 1;\n      toNode = display.view[toIndex + 1].node.previousSibling;\n    }\n\n    if (!fromNode) {\n      return false;\n    }\n\n    var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine));\n    var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length));\n\n    while (newText.length > 1 && oldText.length > 1) {\n      if (lst(newText) == lst(oldText)) {\n        newText.pop();\n        oldText.pop();\n        toLine--;\n      } else if (newText[0] == oldText[0]) {\n        newText.shift();\n        oldText.shift();\n        fromLine++;\n      } else {\n        break;\n      }\n    }\n\n    var cutFront = 0,\n        cutEnd = 0;\n    var newTop = newText[0],\n        oldTop = oldText[0],\n        maxCutFront = Math.min(newTop.length, oldTop.length);\n\n    while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront)) {\n      ++cutFront;\n    }\n\n    var newBot = lst(newText),\n        oldBot = lst(oldText);\n    var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0), oldBot.length - (oldText.length == 1 ? cutFront : 0));\n\n    while (cutEnd < maxCutEnd && newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1)) {\n      ++cutEnd;\n    } // Try to move start of change to start of selection if ambiguous\n\n\n    if (newText.length == 1 && oldText.length == 1 && fromLine == from.line) {\n      while (cutFront && cutFront > from.ch && newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1)) {\n        cutFront--;\n        cutEnd++;\n      }\n    }\n\n    newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\\u200b+/, \"\");\n    newText[0] = newText[0].slice(cutFront).replace(/\\u200b+$/, \"\");\n    var chFrom = Pos(fromLine, cutFront);\n    var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0);\n\n    if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {\n      replaceRange(cm.doc, newText, chFrom, chTo, \"+input\");\n      return true;\n    }\n  };\n\n  ContentEditableInput.prototype.ensurePolled = function () {\n    this.forceCompositionEnd();\n  };\n\n  ContentEditableInput.prototype.reset = function () {\n    this.forceCompositionEnd();\n  };\n\n  ContentEditableInput.prototype.forceCompositionEnd = function () {\n    if (!this.composing) {\n      return;\n    }\n\n    clearTimeout(this.readDOMTimeout);\n    this.composing = null;\n    this.updateFromDOM();\n    this.div.blur();\n    this.div.focus();\n  };\n\n  ContentEditableInput.prototype.readFromDOMSoon = function () {\n    var this$1 = this;\n\n    if (this.readDOMTimeout != null) {\n      return;\n    }\n\n    this.readDOMTimeout = setTimeout(function () {\n      this$1.readDOMTimeout = null;\n\n      if (this$1.composing) {\n        if (this$1.composing.done) {\n          this$1.composing = null;\n        } else {\n          return;\n        }\n      }\n\n      this$1.updateFromDOM();\n    }, 80);\n  };\n\n  ContentEditableInput.prototype.updateFromDOM = function () {\n    var this$1 = this;\n\n    if (this.cm.isReadOnly() || !this.pollContent()) {\n      runInOp(this.cm, function () {\n        return regChange(this$1.cm);\n      });\n    }\n  };\n\n  ContentEditableInput.prototype.setUneditable = function (node) {\n    node.contentEditable = \"false\";\n  };\n\n  ContentEditableInput.prototype.onKeyPress = function (e) {\n    if (e.charCode == 0 || this.composing) {\n      return;\n    }\n\n    e.preventDefault();\n\n    if (!this.cm.isReadOnly()) {\n      operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0);\n    }\n  };\n\n  ContentEditableInput.prototype.readOnlyChanged = function (val) {\n    this.div.contentEditable = String(val != \"nocursor\");\n  };\n\n  ContentEditableInput.prototype.onContextMenu = function () {};\n\n  ContentEditableInput.prototype.resetPosition = function () {};\n\n  ContentEditableInput.prototype.needsContentAttribute = true;\n\n  function posToDOM(cm, pos) {\n    var view = findViewForLine(cm, pos.line);\n\n    if (!view || view.hidden) {\n      return null;\n    }\n\n    var line = getLine(cm.doc, pos.line);\n    var info = mapFromLineView(view, line, pos.line);\n    var order = getOrder(line, cm.doc.direction),\n        side = \"left\";\n\n    if (order) {\n      var partPos = getBidiPartAt(order, pos.ch);\n      side = partPos % 2 ? \"right\" : \"left\";\n    }\n\n    var result = nodeAndOffsetInLineMap(info.map, pos.ch, side);\n    result.offset = result.collapse == \"right\" ? result.end : result.start;\n    return result;\n  }\n\n  function isInGutter(node) {\n    for (var scan = node; scan; scan = scan.parentNode) {\n      if (/CodeMirror-gutter-wrapper/.test(scan.className)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  function badPos(pos, bad) {\n    if (bad) {\n      pos.bad = true;\n    }\n\n    return pos;\n  }\n\n  function domTextBetween(cm, from, to, fromLine, toLine) {\n    var text = \"\",\n        closing = false,\n        lineSep = cm.doc.lineSeparator(),\n        extraLinebreak = false;\n\n    function recognizeMarker(id) {\n      return function (marker) {\n        return marker.id == id;\n      };\n    }\n\n    function close() {\n      if (closing) {\n        text += lineSep;\n\n        if (extraLinebreak) {\n          text += lineSep;\n        }\n\n        closing = extraLinebreak = false;\n      }\n    }\n\n    function addText(str) {\n      if (str) {\n        close();\n        text += str;\n      }\n    }\n\n    function walk(node) {\n      if (node.nodeType == 1) {\n        var cmText = node.getAttribute(\"cm-text\");\n\n        if (cmText) {\n          addText(cmText);\n          return;\n        }\n\n        var markerID = node.getAttribute(\"cm-marker\"),\n            range;\n\n        if (markerID) {\n          var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID));\n\n          if (found.length && (range = found[0].find(0))) {\n            addText(getBetween(cm.doc, range.from, range.to).join(lineSep));\n          }\n\n          return;\n        }\n\n        if (node.getAttribute(\"contenteditable\") == \"false\") {\n          return;\n        }\n\n        var isBlock = /^(pre|div|p|li|table|br)$/i.test(node.nodeName);\n\n        if (!/^br$/i.test(node.nodeName) && node.textContent.length == 0) {\n          return;\n        }\n\n        if (isBlock) {\n          close();\n        }\n\n        for (var i = 0; i < node.childNodes.length; i++) {\n          walk(node.childNodes[i]);\n        }\n\n        if (/^(pre|p)$/i.test(node.nodeName)) {\n          extraLinebreak = true;\n        }\n\n        if (isBlock) {\n          closing = true;\n        }\n      } else if (node.nodeType == 3) {\n        addText(node.nodeValue.replace(/\\u200b/g, \"\").replace(/\\u00a0/g, \" \"));\n      }\n    }\n\n    for (;;) {\n      walk(from);\n\n      if (from == to) {\n        break;\n      }\n\n      from = from.nextSibling;\n      extraLinebreak = false;\n    }\n\n    return text;\n  }\n\n  function domToPos(cm, node, offset) {\n    var lineNode;\n\n    if (node == cm.display.lineDiv) {\n      lineNode = cm.display.lineDiv.childNodes[offset];\n\n      if (!lineNode) {\n        return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true);\n      }\n\n      node = null;\n      offset = 0;\n    } else {\n      for (lineNode = node;; lineNode = lineNode.parentNode) {\n        if (!lineNode || lineNode == cm.display.lineDiv) {\n          return null;\n        }\n\n        if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) {\n          break;\n        }\n      }\n    }\n\n    for (var i = 0; i < cm.display.view.length; i++) {\n      var lineView = cm.display.view[i];\n\n      if (lineView.node == lineNode) {\n        return locateNodeInLineView(lineView, node, offset);\n      }\n    }\n  }\n\n  function locateNodeInLineView(lineView, node, offset) {\n    var wrapper = lineView.text.firstChild,\n        bad = false;\n\n    if (!node || !contains(wrapper, node)) {\n      return badPos(Pos(lineNo(lineView.line), 0), true);\n    }\n\n    if (node == wrapper) {\n      bad = true;\n      node = wrapper.childNodes[offset];\n      offset = 0;\n\n      if (!node) {\n        var line = lineView.rest ? lst(lineView.rest) : lineView.line;\n        return badPos(Pos(lineNo(line), line.text.length), bad);\n      }\n    }\n\n    var textNode = node.nodeType == 3 ? node : null,\n        topNode = node;\n\n    if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {\n      textNode = node.firstChild;\n\n      if (offset) {\n        offset = textNode.nodeValue.length;\n      }\n    }\n\n    while (topNode.parentNode != wrapper) {\n      topNode = topNode.parentNode;\n    }\n\n    var measure = lineView.measure,\n        maps = measure.maps;\n\n    function find(textNode, topNode, offset) {\n      for (var i = -1; i < (maps ? maps.length : 0); i++) {\n        var map = i < 0 ? measure.map : maps[i];\n\n        for (var j = 0; j < map.length; j += 3) {\n          var curNode = map[j + 2];\n\n          if (curNode == textNode || curNode == topNode) {\n            var line = lineNo(i < 0 ? lineView.line : lineView.rest[i]);\n            var ch = map[j] + offset;\n\n            if (offset < 0 || curNode != textNode) {\n              ch = map[j + (offset ? 1 : 0)];\n            }\n\n            return Pos(line, ch);\n          }\n        }\n      }\n    }\n\n    var found = find(textNode, topNode, offset);\n\n    if (found) {\n      return badPos(found, bad);\n    } // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems\n\n\n    for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {\n      found = find(after, after.firstChild, 0);\n\n      if (found) {\n        return badPos(Pos(found.line, found.ch - dist), bad);\n      } else {\n        dist += after.textContent.length;\n      }\n    }\n\n    for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) {\n      found = find(before, before.firstChild, -1);\n\n      if (found) {\n        return badPos(Pos(found.line, found.ch + dist$1), bad);\n      } else {\n        dist$1 += before.textContent.length;\n      }\n    }\n  } // TEXTAREA INPUT STYLE\n\n\n  var TextareaInput = function (cm) {\n    this.cm = cm; // See input.poll and input.reset\n\n    this.prevInput = \"\"; // Flag that indicates whether we expect input to appear real soon\n    // now (after some event like 'keypress' or 'input') and are\n    // polling intensively.\n\n    this.pollingFast = false; // Self-resetting timeout for the poller\n\n    this.polling = new Delayed(); // Used to work around IE issue with selection being forgotten when focus moves away from textarea\n\n    this.hasSelection = false;\n    this.composing = null;\n  };\n\n  TextareaInput.prototype.init = function (display) {\n    var this$1 = this;\n    var input = this,\n        cm = this.cm;\n    this.createField(display);\n    var te = this.textarea;\n    display.wrapper.insertBefore(this.wrapper, display.wrapper.firstChild); // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)\n\n    if (ios) {\n      te.style.width = \"0px\";\n    }\n\n    on(te, \"input\", function () {\n      if (ie && ie_version >= 9 && this$1.hasSelection) {\n        this$1.hasSelection = null;\n      }\n\n      input.poll();\n    });\n    on(te, \"paste\", function (e) {\n      if (signalDOMEvent(cm, e) || handlePaste(e, cm)) {\n        return;\n      }\n\n      cm.state.pasteIncoming = +new Date();\n      input.fastPoll();\n    });\n\n    function prepareCopyCut(e) {\n      if (signalDOMEvent(cm, e)) {\n        return;\n      }\n\n      if (cm.somethingSelected()) {\n        setLastCopied({\n          lineWise: false,\n          text: cm.getSelections()\n        });\n      } else if (!cm.options.lineWiseCopyCut) {\n        return;\n      } else {\n        var ranges = copyableRanges(cm);\n        setLastCopied({\n          lineWise: true,\n          text: ranges.text\n        });\n\n        if (e.type == \"cut\") {\n          cm.setSelections(ranges.ranges, null, sel_dontScroll);\n        } else {\n          input.prevInput = \"\";\n          te.value = ranges.text.join(\"\\n\");\n          selectInput(te);\n        }\n      }\n\n      if (e.type == \"cut\") {\n        cm.state.cutIncoming = +new Date();\n      }\n    }\n\n    on(te, \"cut\", prepareCopyCut);\n    on(te, \"copy\", prepareCopyCut);\n    on(display.scroller, \"paste\", function (e) {\n      if (eventInWidget(display, e) || signalDOMEvent(cm, e)) {\n        return;\n      }\n\n      if (!te.dispatchEvent) {\n        cm.state.pasteIncoming = +new Date();\n        input.focus();\n        return;\n      } // Pass the `paste` event to the textarea so it's handled by its event listener.\n\n\n      var event = new Event(\"paste\");\n      event.clipboardData = e.clipboardData;\n      te.dispatchEvent(event);\n    }); // Prevent normal selection in the editor (we handle our own)\n\n    on(display.lineSpace, \"selectstart\", function (e) {\n      if (!eventInWidget(display, e)) {\n        e_preventDefault(e);\n      }\n    });\n    on(te, \"compositionstart\", function () {\n      var start = cm.getCursor(\"from\");\n\n      if (input.composing) {\n        input.composing.range.clear();\n      }\n\n      input.composing = {\n        start: start,\n        range: cm.markText(start, cm.getCursor(\"to\"), {\n          className: \"CodeMirror-composing\"\n        })\n      };\n    });\n    on(te, \"compositionend\", function () {\n      if (input.composing) {\n        input.poll();\n        input.composing.range.clear();\n        input.composing = null;\n      }\n    });\n  };\n\n  TextareaInput.prototype.createField = function (_display) {\n    // Wraps and hides input textarea\n    this.wrapper = hiddenTextarea(); // The semihidden textarea that is focused when the editor is\n    // focused, and receives input.\n\n    this.textarea = this.wrapper.firstChild;\n  };\n\n  TextareaInput.prototype.screenReaderLabelChanged = function (label) {\n    // Label for screenreaders, accessibility\n    if (label) {\n      this.textarea.setAttribute('aria-label', label);\n    } else {\n      this.textarea.removeAttribute('aria-label');\n    }\n  };\n\n  TextareaInput.prototype.prepareSelection = function () {\n    // Redraw the selection and/or cursor\n    var cm = this.cm,\n        display = cm.display,\n        doc = cm.doc;\n    var result = prepareSelection(cm); // Move the hidden textarea near the cursor to prevent scrolling artifacts\n\n    if (cm.options.moveInputWithCursor) {\n      var headPos = cursorCoords(cm, doc.sel.primary().head, \"div\");\n      var wrapOff = display.wrapper.getBoundingClientRect(),\n          lineOff = display.lineDiv.getBoundingClientRect();\n      result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10, headPos.top + lineOff.top - wrapOff.top));\n      result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10, headPos.left + lineOff.left - wrapOff.left));\n    }\n\n    return result;\n  };\n\n  TextareaInput.prototype.showSelection = function (drawn) {\n    var cm = this.cm,\n        display = cm.display;\n    removeChildrenAndAdd(display.cursorDiv, drawn.cursors);\n    removeChildrenAndAdd(display.selectionDiv, drawn.selection);\n\n    if (drawn.teTop != null) {\n      this.wrapper.style.top = drawn.teTop + \"px\";\n      this.wrapper.style.left = drawn.teLeft + \"px\";\n    }\n  }; // Reset the input to correspond to the selection (or to be empty,\n  // when not typing and nothing is selected)\n\n\n  TextareaInput.prototype.reset = function (typing) {\n    if (this.contextMenuPending || this.composing) {\n      return;\n    }\n\n    var cm = this.cm;\n\n    if (cm.somethingSelected()) {\n      this.prevInput = \"\";\n      var content = cm.getSelection();\n      this.textarea.value = content;\n\n      if (cm.state.focused) {\n        selectInput(this.textarea);\n      }\n\n      if (ie && ie_version >= 9) {\n        this.hasSelection = content;\n      }\n    } else if (!typing) {\n      this.prevInput = this.textarea.value = \"\";\n\n      if (ie && ie_version >= 9) {\n        this.hasSelection = null;\n      }\n    }\n  };\n\n  TextareaInput.prototype.getField = function () {\n    return this.textarea;\n  };\n\n  TextareaInput.prototype.supportsTouch = function () {\n    return false;\n  };\n\n  TextareaInput.prototype.focus = function () {\n    if (this.cm.options.readOnly != \"nocursor\" && (!mobile || activeElt() != this.textarea)) {\n      try {\n        this.textarea.focus();\n      } catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM\n\n    }\n  };\n\n  TextareaInput.prototype.blur = function () {\n    this.textarea.blur();\n  };\n\n  TextareaInput.prototype.resetPosition = function () {\n    this.wrapper.style.top = this.wrapper.style.left = 0;\n  };\n\n  TextareaInput.prototype.receivedFocus = function () {\n    this.slowPoll();\n  }; // Poll for input changes, using the normal rate of polling. This\n  // runs as long as the editor is focused.\n\n\n  TextareaInput.prototype.slowPoll = function () {\n    var this$1 = this;\n\n    if (this.pollingFast) {\n      return;\n    }\n\n    this.polling.set(this.cm.options.pollInterval, function () {\n      this$1.poll();\n\n      if (this$1.cm.state.focused) {\n        this$1.slowPoll();\n      }\n    });\n  }; // When an event has just come in that is likely to add or change\n  // something in the input textarea, we poll faster, to ensure that\n  // the change appears on the screen quickly.\n\n\n  TextareaInput.prototype.fastPoll = function () {\n    var missed = false,\n        input = this;\n    input.pollingFast = true;\n\n    function p() {\n      var changed = input.poll();\n\n      if (!changed && !missed) {\n        missed = true;\n        input.polling.set(60, p);\n      } else {\n        input.pollingFast = false;\n        input.slowPoll();\n      }\n    }\n\n    input.polling.set(20, p);\n  }; // Read input from the textarea, and update the document to match.\n  // When something is selected, it is present in the textarea, and\n  // selected (unless it is huge, in which case a placeholder is\n  // used). When nothing is selected, the cursor sits after previously\n  // seen text (can be empty), which is stored in prevInput (we must\n  // not reset the textarea when typing, because that breaks IME).\n\n\n  TextareaInput.prototype.poll = function () {\n    var this$1 = this;\n    var cm = this.cm,\n        input = this.textarea,\n        prevInput = this.prevInput; // Since this is called a *lot*, try to bail out as cheaply as\n    // possible when it is clear that nothing happened. hasSelection\n    // will be the case when there is a lot of text in the textarea,\n    // in which case reading its value would be expensive.\n\n    if (this.contextMenuPending || !cm.state.focused || hasSelection(input) && !prevInput && !this.composing || cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq) {\n      return false;\n    }\n\n    var text = input.value; // If nothing changed, bail.\n\n    if (text == prevInput && !cm.somethingSelected()) {\n      return false;\n    } // Work around nonsensical selection resetting in IE9/10, and\n    // inexplicable appearance of private area unicode characters on\n    // some key combos in Mac (#2689).\n\n\n    if (ie && ie_version >= 9 && this.hasSelection === text || mac && /[\\uf700-\\uf7ff]/.test(text)) {\n      cm.display.input.reset();\n      return false;\n    }\n\n    if (cm.doc.sel == cm.display.selForContextMenu) {\n      var first = text.charCodeAt(0);\n\n      if (first == 0x200b && !prevInput) {\n        prevInput = \"\\u200b\";\n      }\n\n      if (first == 0x21da) {\n        this.reset();\n        return this.cm.execCommand(\"undo\");\n      }\n    } // Find the part of the input that is actually new\n\n\n    var same = 0,\n        l = Math.min(prevInput.length, text.length);\n\n    while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) {\n      ++same;\n    }\n\n    runInOp(cm, function () {\n      applyTextInput(cm, text.slice(same), prevInput.length - same, null, this$1.composing ? \"*compose\" : null); // Don't leave long text in the textarea, since it makes further polling slow\n\n      if (text.length > 1000 || text.indexOf(\"\\n\") > -1) {\n        input.value = this$1.prevInput = \"\";\n      } else {\n        this$1.prevInput = text;\n      }\n\n      if (this$1.composing) {\n        this$1.composing.range.clear();\n        this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor(\"to\"), {\n          className: \"CodeMirror-composing\"\n        });\n      }\n    });\n    return true;\n  };\n\n  TextareaInput.prototype.ensurePolled = function () {\n    if (this.pollingFast && this.poll()) {\n      this.pollingFast = false;\n    }\n  };\n\n  TextareaInput.prototype.onKeyPress = function () {\n    if (ie && ie_version >= 9) {\n      this.hasSelection = null;\n    }\n\n    this.fastPoll();\n  };\n\n  TextareaInput.prototype.onContextMenu = function (e) {\n    var input = this,\n        cm = input.cm,\n        display = cm.display,\n        te = input.textarea;\n\n    if (input.contextMenuPending) {\n      input.contextMenuPending();\n    }\n\n    var pos = posFromMouse(cm, e),\n        scrollPos = display.scroller.scrollTop;\n\n    if (!pos || presto) {\n      return;\n    } // Opera is difficult.\n    // Reset the current text selection only if the click is done outside of the selection\n    // and 'resetSelectionOnContextMenu' option is true.\n\n\n    var reset = cm.options.resetSelectionOnContextMenu;\n\n    if (reset && cm.doc.sel.contains(pos) == -1) {\n      operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll);\n    }\n\n    var oldCSS = te.style.cssText,\n        oldWrapperCSS = input.wrapper.style.cssText;\n    var wrapperBox = input.wrapper.offsetParent.getBoundingClientRect();\n    input.wrapper.style.cssText = \"position: static\";\n    te.style.cssText = \"position: absolute; width: 30px; height: 30px;\\n      top: \" + (e.clientY - wrapperBox.top - 5) + \"px; left: \" + (e.clientX - wrapperBox.left - 5) + \"px;\\n      z-index: 1000; background: \" + (ie ? \"rgba(255, 255, 255, .05)\" : \"transparent\") + \";\\n      outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);\";\n    var oldScrollY;\n\n    if (webkit) {\n      oldScrollY = window.scrollY;\n    } // Work around Chrome issue (#2712)\n\n\n    display.input.focus();\n\n    if (webkit) {\n      window.scrollTo(null, oldScrollY);\n    }\n\n    display.input.reset(); // Adds \"Select all\" to context menu in FF\n\n    if (!cm.somethingSelected()) {\n      te.value = input.prevInput = \" \";\n    }\n\n    input.contextMenuPending = rehide;\n    display.selForContextMenu = cm.doc.sel;\n    clearTimeout(display.detectingSelectAll); // Select-all will be greyed out if there's nothing to select, so\n    // this adds a zero-width space so that we can later check whether\n    // it got selected.\n\n    function prepareSelectAllHack() {\n      if (te.selectionStart != null) {\n        var selected = cm.somethingSelected();\n        var extval = \"\\u200b\" + (selected ? te.value : \"\");\n        te.value = \"\\u21da\"; // Used to catch context-menu undo\n\n        te.value = extval;\n        input.prevInput = selected ? \"\" : \"\\u200b\";\n        te.selectionStart = 1;\n        te.selectionEnd = extval.length; // Re-set this, in case some other handler touched the\n        // selection in the meantime.\n\n        display.selForContextMenu = cm.doc.sel;\n      }\n    }\n\n    function rehide() {\n      if (input.contextMenuPending != rehide) {\n        return;\n      }\n\n      input.contextMenuPending = false;\n      input.wrapper.style.cssText = oldWrapperCSS;\n      te.style.cssText = oldCSS;\n\n      if (ie && ie_version < 9) {\n        display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos);\n      } // Try to detect the user choosing select-all\n\n\n      if (te.selectionStart != null) {\n        if (!ie || ie && ie_version < 9) {\n          prepareSelectAllHack();\n        }\n\n        var i = 0,\n            poll = function () {\n          if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 && te.selectionEnd > 0 && input.prevInput == \"\\u200b\") {\n            operation(cm, selectAll)(cm);\n          } else if (i++ < 10) {\n            display.detectingSelectAll = setTimeout(poll, 500);\n          } else {\n            display.selForContextMenu = null;\n            display.input.reset();\n          }\n        };\n\n        display.detectingSelectAll = setTimeout(poll, 200);\n      }\n    }\n\n    if (ie && ie_version >= 9) {\n      prepareSelectAllHack();\n    }\n\n    if (captureRightClick) {\n      e_stop(e);\n\n      var mouseup = function () {\n        off(window, \"mouseup\", mouseup);\n        setTimeout(rehide, 20);\n      };\n\n      on(window, \"mouseup\", mouseup);\n    } else {\n      setTimeout(rehide, 50);\n    }\n  };\n\n  TextareaInput.prototype.readOnlyChanged = function (val) {\n    if (!val) {\n      this.reset();\n    }\n\n    this.textarea.disabled = val == \"nocursor\";\n  };\n\n  TextareaInput.prototype.setUneditable = function () {};\n\n  TextareaInput.prototype.needsContentAttribute = false;\n\n  function fromTextArea(textarea, options) {\n    options = options ? copyObj(options) : {};\n    options.value = textarea.value;\n\n    if (!options.tabindex && textarea.tabIndex) {\n      options.tabindex = textarea.tabIndex;\n    }\n\n    if (!options.placeholder && textarea.placeholder) {\n      options.placeholder = textarea.placeholder;\n    } // Set autofocus to true if this textarea is focused, or if it has\n    // autofocus and no other element is focused.\n\n\n    if (options.autofocus == null) {\n      var hasFocus = activeElt();\n      options.autofocus = hasFocus == textarea || textarea.getAttribute(\"autofocus\") != null && hasFocus == document.body;\n    }\n\n    function save() {\n      textarea.value = cm.getValue();\n    }\n\n    var realSubmit;\n\n    if (textarea.form) {\n      on(textarea.form, \"submit\", save); // Deplorable hack to make the submit method do the right thing.\n\n      if (!options.leaveSubmitMethodAlone) {\n        var form = textarea.form;\n        realSubmit = form.submit;\n\n        try {\n          var wrappedSubmit = form.submit = function () {\n            save();\n            form.submit = realSubmit;\n            form.submit();\n            form.submit = wrappedSubmit;\n          };\n        } catch (e) {}\n      }\n    }\n\n    options.finishInit = function (cm) {\n      cm.save = save;\n\n      cm.getTextArea = function () {\n        return textarea;\n      };\n\n      cm.toTextArea = function () {\n        cm.toTextArea = isNaN; // Prevent this from being ran twice\n\n        save();\n        textarea.parentNode.removeChild(cm.getWrapperElement());\n        textarea.style.display = \"\";\n\n        if (textarea.form) {\n          off(textarea.form, \"submit\", save);\n\n          if (!options.leaveSubmitMethodAlone && typeof textarea.form.submit == \"function\") {\n            textarea.form.submit = realSubmit;\n          }\n        }\n      };\n    };\n\n    textarea.style.display = \"none\";\n    var cm = CodeMirror(function (node) {\n      return textarea.parentNode.insertBefore(node, textarea.nextSibling);\n    }, options);\n    return cm;\n  }\n\n  function addLegacyProps(CodeMirror) {\n    CodeMirror.off = off;\n    CodeMirror.on = on;\n    CodeMirror.wheelEventPixels = wheelEventPixels;\n    CodeMirror.Doc = Doc;\n    CodeMirror.splitLines = splitLinesAuto;\n    CodeMirror.countColumn = countColumn;\n    CodeMirror.findColumn = findColumn;\n    CodeMirror.isWordChar = isWordCharBasic;\n    CodeMirror.Pass = Pass;\n    CodeMirror.signal = signal;\n    CodeMirror.Line = Line;\n    CodeMirror.changeEnd = changeEnd;\n    CodeMirror.scrollbarModel = scrollbarModel;\n    CodeMirror.Pos = Pos;\n    CodeMirror.cmpPos = cmp;\n    CodeMirror.modes = modes;\n    CodeMirror.mimeModes = mimeModes;\n    CodeMirror.resolveMode = resolveMode;\n    CodeMirror.getMode = getMode;\n    CodeMirror.modeExtensions = modeExtensions;\n    CodeMirror.extendMode = extendMode;\n    CodeMirror.copyState = copyState;\n    CodeMirror.startState = startState;\n    CodeMirror.innerMode = innerMode;\n    CodeMirror.commands = commands;\n    CodeMirror.keyMap = keyMap;\n    CodeMirror.keyName = keyName;\n    CodeMirror.isModifierKey = isModifierKey;\n    CodeMirror.lookupKey = lookupKey;\n    CodeMirror.normalizeKeyMap = normalizeKeyMap;\n    CodeMirror.StringStream = StringStream;\n    CodeMirror.SharedTextMarker = SharedTextMarker;\n    CodeMirror.TextMarker = TextMarker;\n    CodeMirror.LineWidget = LineWidget;\n    CodeMirror.e_preventDefault = e_preventDefault;\n    CodeMirror.e_stopPropagation = e_stopPropagation;\n    CodeMirror.e_stop = e_stop;\n    CodeMirror.addClass = addClass;\n    CodeMirror.contains = contains;\n    CodeMirror.rmClass = rmClass;\n    CodeMirror.keyNames = keyNames;\n  } // EDITOR CONSTRUCTOR\n\n\n  defineOptions(CodeMirror);\n  addEditorMethods(CodeMirror); // Set up methods on CodeMirror's prototype to redirect to the editor's document.\n\n  var dontDelegate = \"iter insert remove copy getEditor constructor\".split(\" \");\n\n  for (var prop in Doc.prototype) {\n    if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0) {\n      CodeMirror.prototype[prop] = function (method) {\n        return function () {\n          return method.apply(this.doc, arguments);\n        };\n      }(Doc.prototype[prop]);\n    }\n  }\n\n  eventMixin(Doc);\n  CodeMirror.inputStyles = {\n    \"textarea\": TextareaInput,\n    \"contenteditable\": ContentEditableInput\n  }; // Extra arguments are stored as the mode's dependencies, which is\n  // used by (legacy) mechanisms like loadmode.js to automatically\n  // load a mode. (Preferred mechanism is the require/define calls.)\n\n  CodeMirror.defineMode = function (name\n  /*, mode, …*/\n  ) {\n    if (!CodeMirror.defaults.mode && name != \"null\") {\n      CodeMirror.defaults.mode = name;\n    }\n\n    defineMode.apply(this, arguments);\n  };\n\n  CodeMirror.defineMIME = defineMIME; // Minimal default mode.\n\n  CodeMirror.defineMode(\"null\", function () {\n    return {\n      token: function (stream) {\n        return stream.skipToEnd();\n      }\n    };\n  });\n  CodeMirror.defineMIME(\"text/plain\", \"null\"); // EXTENSIONS\n\n  CodeMirror.defineExtension = function (name, func) {\n    CodeMirror.prototype[name] = func;\n  };\n\n  CodeMirror.defineDocExtension = function (name, func) {\n    Doc.prototype[name] = func;\n  };\n\n  CodeMirror.fromTextArea = fromTextArea;\n  addLegacyProps(CodeMirror);\n  CodeMirror.version = \"5.56.0\";\n  return CodeMirror;\n});"

/***/ }),
/* 208 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(209))

/***/ }),
/* 209 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../lib/codemirror\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../lib/codemirror\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.modeInfo = [{\n    name: \"APL\",\n    mime: \"text/apl\",\n    mode: \"apl\",\n    ext: [\"dyalog\", \"apl\"]\n  }, {\n    name: \"PGP\",\n    mimes: [\"application/pgp\", \"application/pgp-encrypted\", \"application/pgp-keys\", \"application/pgp-signature\"],\n    mode: \"asciiarmor\",\n    ext: [\"asc\", \"pgp\", \"sig\"]\n  }, {\n    name: \"ASN.1\",\n    mime: \"text/x-ttcn-asn\",\n    mode: \"asn.1\",\n    ext: [\"asn\", \"asn1\"]\n  }, {\n    name: \"Asterisk\",\n    mime: \"text/x-asterisk\",\n    mode: \"asterisk\",\n    file: /^extensions\\.conf$/i\n  }, {\n    name: \"Brainfuck\",\n    mime: \"text/x-brainfuck\",\n    mode: \"brainfuck\",\n    ext: [\"b\", \"bf\"]\n  }, {\n    name: \"C\",\n    mime: \"text/x-csrc\",\n    mode: \"clike\",\n    ext: [\"c\", \"h\", \"ino\"]\n  }, {\n    name: \"C++\",\n    mime: \"text/x-c++src\",\n    mode: \"clike\",\n    ext: [\"cpp\", \"c++\", \"cc\", \"cxx\", \"hpp\", \"h++\", \"hh\", \"hxx\"],\n    alias: [\"cpp\"]\n  }, {\n    name: \"Cobol\",\n    mime: \"text/x-cobol\",\n    mode: \"cobol\",\n    ext: [\"cob\", \"cpy\"]\n  }, {\n    name: \"C#\",\n    mime: \"text/x-csharp\",\n    mode: \"clike\",\n    ext: [\"cs\"],\n    alias: [\"csharp\", \"cs\"]\n  }, {\n    name: \"Clojure\",\n    mime: \"text/x-clojure\",\n    mode: \"clojure\",\n    ext: [\"clj\", \"cljc\", \"cljx\"]\n  }, {\n    name: \"ClojureScript\",\n    mime: \"text/x-clojurescript\",\n    mode: \"clojure\",\n    ext: [\"cljs\"]\n  }, {\n    name: \"Closure Stylesheets (GSS)\",\n    mime: \"text/x-gss\",\n    mode: \"css\",\n    ext: [\"gss\"]\n  }, {\n    name: \"CMake\",\n    mime: \"text/x-cmake\",\n    mode: \"cmake\",\n    ext: [\"cmake\", \"cmake.in\"],\n    file: /^CMakeLists.txt$/\n  }, {\n    name: \"CoffeeScript\",\n    mimes: [\"application/vnd.coffeescript\", \"text/coffeescript\", \"text/x-coffeescript\"],\n    mode: \"coffeescript\",\n    ext: [\"coffee\"],\n    alias: [\"coffee\", \"coffee-script\"]\n  }, {\n    name: \"Common Lisp\",\n    mime: \"text/x-common-lisp\",\n    mode: \"commonlisp\",\n    ext: [\"cl\", \"lisp\", \"el\"],\n    alias: [\"lisp\"]\n  }, {\n    name: \"Cypher\",\n    mime: \"application/x-cypher-query\",\n    mode: \"cypher\",\n    ext: [\"cyp\", \"cypher\"]\n  }, {\n    name: \"Cython\",\n    mime: \"text/x-cython\",\n    mode: \"python\",\n    ext: [\"pyx\", \"pxd\", \"pxi\"]\n  }, {\n    name: \"Crystal\",\n    mime: \"text/x-crystal\",\n    mode: \"crystal\",\n    ext: [\"cr\"]\n  }, {\n    name: \"CSS\",\n    mime: \"text/css\",\n    mode: \"css\",\n    ext: [\"css\"]\n  }, {\n    name: \"CQL\",\n    mime: \"text/x-cassandra\",\n    mode: \"sql\",\n    ext: [\"cql\"]\n  }, {\n    name: \"D\",\n    mime: \"text/x-d\",\n    mode: \"d\",\n    ext: [\"d\"]\n  }, {\n    name: \"Dart\",\n    mimes: [\"application/dart\", \"text/x-dart\"],\n    mode: \"dart\",\n    ext: [\"dart\"]\n  }, {\n    name: \"diff\",\n    mime: \"text/x-diff\",\n    mode: \"diff\",\n    ext: [\"diff\", \"patch\"]\n  }, {\n    name: \"Django\",\n    mime: \"text/x-django\",\n    mode: \"django\"\n  }, {\n    name: \"Dockerfile\",\n    mime: \"text/x-dockerfile\",\n    mode: \"dockerfile\",\n    file: /^Dockerfile$/\n  }, {\n    name: \"DTD\",\n    mime: \"application/xml-dtd\",\n    mode: \"dtd\",\n    ext: [\"dtd\"]\n  }, {\n    name: \"Dylan\",\n    mime: \"text/x-dylan\",\n    mode: \"dylan\",\n    ext: [\"dylan\", \"dyl\", \"intr\"]\n  }, {\n    name: \"EBNF\",\n    mime: \"text/x-ebnf\",\n    mode: \"ebnf\"\n  }, {\n    name: \"ECL\",\n    mime: \"text/x-ecl\",\n    mode: \"ecl\",\n    ext: [\"ecl\"]\n  }, {\n    name: \"edn\",\n    mime: \"application/edn\",\n    mode: \"clojure\",\n    ext: [\"edn\"]\n  }, {\n    name: \"Eiffel\",\n    mime: \"text/x-eiffel\",\n    mode: \"eiffel\",\n    ext: [\"e\"]\n  }, {\n    name: \"Elm\",\n    mime: \"text/x-elm\",\n    mode: \"elm\",\n    ext: [\"elm\"]\n  }, {\n    name: \"Embedded Javascript\",\n    mime: \"application/x-ejs\",\n    mode: \"htmlembedded\",\n    ext: [\"ejs\"]\n  }, {\n    name: \"Embedded Ruby\",\n    mime: \"application/x-erb\",\n    mode: \"htmlembedded\",\n    ext: [\"erb\"]\n  }, {\n    name: \"Erlang\",\n    mime: \"text/x-erlang\",\n    mode: \"erlang\",\n    ext: [\"erl\"]\n  }, {\n    name: \"Esper\",\n    mime: \"text/x-esper\",\n    mode: \"sql\"\n  }, {\n    name: \"Factor\",\n    mime: \"text/x-factor\",\n    mode: \"factor\",\n    ext: [\"factor\"]\n  }, {\n    name: \"FCL\",\n    mime: \"text/x-fcl\",\n    mode: \"fcl\"\n  }, {\n    name: \"Forth\",\n    mime: \"text/x-forth\",\n    mode: \"forth\",\n    ext: [\"forth\", \"fth\", \"4th\"]\n  }, {\n    name: \"Fortran\",\n    mime: \"text/x-fortran\",\n    mode: \"fortran\",\n    ext: [\"f\", \"for\", \"f77\", \"f90\", \"f95\"]\n  }, {\n    name: \"F#\",\n    mime: \"text/x-fsharp\",\n    mode: \"mllike\",\n    ext: [\"fs\"],\n    alias: [\"fsharp\"]\n  }, {\n    name: \"Gas\",\n    mime: \"text/x-gas\",\n    mode: \"gas\",\n    ext: [\"s\"]\n  }, {\n    name: \"Gherkin\",\n    mime: \"text/x-feature\",\n    mode: \"gherkin\",\n    ext: [\"feature\"]\n  }, {\n    name: \"GitHub Flavored Markdown\",\n    mime: \"text/x-gfm\",\n    mode: \"gfm\",\n    file: /^(readme|contributing|history).md$/i\n  }, {\n    name: \"Go\",\n    mime: \"text/x-go\",\n    mode: \"go\",\n    ext: [\"go\"]\n  }, {\n    name: \"Groovy\",\n    mime: \"text/x-groovy\",\n    mode: \"groovy\",\n    ext: [\"groovy\", \"gradle\"],\n    file: /^Jenkinsfile$/\n  }, {\n    name: \"HAML\",\n    mime: \"text/x-haml\",\n    mode: \"haml\",\n    ext: [\"haml\"]\n  }, {\n    name: \"Haskell\",\n    mime: \"text/x-haskell\",\n    mode: \"haskell\",\n    ext: [\"hs\"]\n  }, {\n    name: \"Haskell (Literate)\",\n    mime: \"text/x-literate-haskell\",\n    mode: \"haskell-literate\",\n    ext: [\"lhs\"]\n  }, {\n    name: \"Haxe\",\n    mime: \"text/x-haxe\",\n    mode: \"haxe\",\n    ext: [\"hx\"]\n  }, {\n    name: \"HXML\",\n    mime: \"text/x-hxml\",\n    mode: \"haxe\",\n    ext: [\"hxml\"]\n  }, {\n    name: \"ASP.NET\",\n    mime: \"application/x-aspx\",\n    mode: \"htmlembedded\",\n    ext: [\"aspx\"],\n    alias: [\"asp\", \"aspx\"]\n  }, {\n    name: \"HTML\",\n    mime: \"text/html\",\n    mode: \"htmlmixed\",\n    ext: [\"html\", \"htm\", \"handlebars\", \"hbs\"],\n    alias: [\"xhtml\"]\n  }, {\n    name: \"HTTP\",\n    mime: \"message/http\",\n    mode: \"http\"\n  }, {\n    name: \"IDL\",\n    mime: \"text/x-idl\",\n    mode: \"idl\",\n    ext: [\"pro\"]\n  }, {\n    name: \"Pug\",\n    mime: \"text/x-pug\",\n    mode: \"pug\",\n    ext: [\"jade\", \"pug\"],\n    alias: [\"jade\"]\n  }, {\n    name: \"Java\",\n    mime: \"text/x-java\",\n    mode: \"clike\",\n    ext: [\"java\"]\n  }, {\n    name: \"Java Server Pages\",\n    mime: \"application/x-jsp\",\n    mode: \"htmlembedded\",\n    ext: [\"jsp\"],\n    alias: [\"jsp\"]\n  }, {\n    name: \"JavaScript\",\n    mimes: [\"text/javascript\", \"text/ecmascript\", \"application/javascript\", \"application/x-javascript\", \"application/ecmascript\"],\n    mode: \"javascript\",\n    ext: [\"js\"],\n    alias: [\"ecmascript\", \"js\", \"node\"]\n  }, {\n    name: \"JSON\",\n    mimes: [\"application/json\", \"application/x-json\"],\n    mode: \"javascript\",\n    ext: [\"json\", \"map\"],\n    alias: [\"json5\"]\n  }, {\n    name: \"JSON-LD\",\n    mime: \"application/ld+json\",\n    mode: \"javascript\",\n    ext: [\"jsonld\"],\n    alias: [\"jsonld\"]\n  }, {\n    name: \"JSX\",\n    mime: \"text/jsx\",\n    mode: \"jsx\",\n    ext: [\"jsx\"]\n  }, {\n    name: \"Jinja2\",\n    mime: \"text/jinja2\",\n    mode: \"jinja2\",\n    ext: [\"j2\", \"jinja\", \"jinja2\"]\n  }, {\n    name: \"Julia\",\n    mime: \"text/x-julia\",\n    mode: \"julia\",\n    ext: [\"jl\"]\n  }, {\n    name: \"Kotlin\",\n    mime: \"text/x-kotlin\",\n    mode: \"clike\",\n    ext: [\"kt\"]\n  }, {\n    name: \"LESS\",\n    mime: \"text/x-less\",\n    mode: \"css\",\n    ext: [\"less\"]\n  }, {\n    name: \"LiveScript\",\n    mime: \"text/x-livescript\",\n    mode: \"livescript\",\n    ext: [\"ls\"],\n    alias: [\"ls\"]\n  }, {\n    name: \"Lua\",\n    mime: \"text/x-lua\",\n    mode: \"lua\",\n    ext: [\"lua\"]\n  }, {\n    name: \"Markdown\",\n    mime: \"text/x-markdown\",\n    mode: \"markdown\",\n    ext: [\"markdown\", \"md\", \"mkd\"]\n  }, {\n    name: \"mIRC\",\n    mime: \"text/mirc\",\n    mode: \"mirc\"\n  }, {\n    name: \"MariaDB SQL\",\n    mime: \"text/x-mariadb\",\n    mode: \"sql\"\n  }, {\n    name: \"Mathematica\",\n    mime: \"text/x-mathematica\",\n    mode: \"mathematica\",\n    ext: [\"m\", \"nb\", \"wl\", \"wls\"]\n  }, {\n    name: \"Modelica\",\n    mime: \"text/x-modelica\",\n    mode: \"modelica\",\n    ext: [\"mo\"]\n  }, {\n    name: \"MUMPS\",\n    mime: \"text/x-mumps\",\n    mode: \"mumps\",\n    ext: [\"mps\"]\n  }, {\n    name: \"MS SQL\",\n    mime: \"text/x-mssql\",\n    mode: \"sql\"\n  }, {\n    name: \"mbox\",\n    mime: \"application/mbox\",\n    mode: \"mbox\",\n    ext: [\"mbox\"]\n  }, {\n    name: \"MySQL\",\n    mime: \"text/x-mysql\",\n    mode: \"sql\"\n  }, {\n    name: \"Nginx\",\n    mime: \"text/x-nginx-conf\",\n    mode: \"nginx\",\n    file: /nginx.*\\.conf$/i\n  }, {\n    name: \"NSIS\",\n    mime: \"text/x-nsis\",\n    mode: \"nsis\",\n    ext: [\"nsh\", \"nsi\"]\n  }, {\n    name: \"NTriples\",\n    mimes: [\"application/n-triples\", \"application/n-quads\", \"text/n-triples\"],\n    mode: \"ntriples\",\n    ext: [\"nt\", \"nq\"]\n  }, {\n    name: \"Objective-C\",\n    mime: \"text/x-objectivec\",\n    mode: \"clike\",\n    ext: [\"m\"],\n    alias: [\"objective-c\", \"objc\"]\n  }, {\n    name: \"Objective-C++\",\n    mime: \"text/x-objectivec++\",\n    mode: \"clike\",\n    ext: [\"mm\"],\n    alias: [\"objective-c++\", \"objc++\"]\n  }, {\n    name: \"OCaml\",\n    mime: \"text/x-ocaml\",\n    mode: \"mllike\",\n    ext: [\"ml\", \"mli\", \"mll\", \"mly\"]\n  }, {\n    name: \"Octave\",\n    mime: \"text/x-octave\",\n    mode: \"octave\",\n    ext: [\"m\"]\n  }, {\n    name: \"Oz\",\n    mime: \"text/x-oz\",\n    mode: \"oz\",\n    ext: [\"oz\"]\n  }, {\n    name: \"Pascal\",\n    mime: \"text/x-pascal\",\n    mode: \"pascal\",\n    ext: [\"p\", \"pas\"]\n  }, {\n    name: \"PEG.js\",\n    mime: \"null\",\n    mode: \"pegjs\",\n    ext: [\"jsonld\"]\n  }, {\n    name: \"Perl\",\n    mime: \"text/x-perl\",\n    mode: \"perl\",\n    ext: [\"pl\", \"pm\"]\n  }, {\n    name: \"PHP\",\n    mimes: [\"text/x-php\", \"application/x-httpd-php\", \"application/x-httpd-php-open\"],\n    mode: \"php\",\n    ext: [\"php\", \"php3\", \"php4\", \"php5\", \"php7\", \"phtml\"]\n  }, {\n    name: \"Pig\",\n    mime: \"text/x-pig\",\n    mode: \"pig\",\n    ext: [\"pig\"]\n  }, {\n    name: \"Plain Text\",\n    mime: \"text/plain\",\n    mode: \"null\",\n    ext: [\"txt\", \"text\", \"conf\", \"def\", \"list\", \"log\"]\n  }, {\n    name: \"PLSQL\",\n    mime: \"text/x-plsql\",\n    mode: \"sql\",\n    ext: [\"pls\"]\n  }, {\n    name: \"PostgreSQL\",\n    mime: \"text/x-pgsql\",\n    mode: \"sql\"\n  }, {\n    name: \"PowerShell\",\n    mime: \"application/x-powershell\",\n    mode: \"powershell\",\n    ext: [\"ps1\", \"psd1\", \"psm1\"]\n  }, {\n    name: \"Properties files\",\n    mime: \"text/x-properties\",\n    mode: \"properties\",\n    ext: [\"properties\", \"ini\", \"in\"],\n    alias: [\"ini\", \"properties\"]\n  }, {\n    name: \"ProtoBuf\",\n    mime: \"text/x-protobuf\",\n    mode: \"protobuf\",\n    ext: [\"proto\"]\n  }, {\n    name: \"Python\",\n    mime: \"text/x-python\",\n    mode: \"python\",\n    ext: [\"BUILD\", \"bzl\", \"py\", \"pyw\"],\n    file: /^(BUCK|BUILD)$/\n  }, {\n    name: \"Puppet\",\n    mime: \"text/x-puppet\",\n    mode: \"puppet\",\n    ext: [\"pp\"]\n  }, {\n    name: \"Q\",\n    mime: \"text/x-q\",\n    mode: \"q\",\n    ext: [\"q\"]\n  }, {\n    name: \"R\",\n    mime: \"text/x-rsrc\",\n    mode: \"r\",\n    ext: [\"r\", \"R\"],\n    alias: [\"rscript\"]\n  }, {\n    name: \"reStructuredText\",\n    mime: \"text/x-rst\",\n    mode: \"rst\",\n    ext: [\"rst\"],\n    alias: [\"rst\"]\n  }, {\n    name: \"RPM Changes\",\n    mime: \"text/x-rpm-changes\",\n    mode: \"rpm\"\n  }, {\n    name: \"RPM Spec\",\n    mime: \"text/x-rpm-spec\",\n    mode: \"rpm\",\n    ext: [\"spec\"]\n  }, {\n    name: \"Ruby\",\n    mime: \"text/x-ruby\",\n    mode: \"ruby\",\n    ext: [\"rb\"],\n    alias: [\"jruby\", \"macruby\", \"rake\", \"rb\", \"rbx\"]\n  }, {\n    name: \"Rust\",\n    mime: \"text/x-rustsrc\",\n    mode: \"rust\",\n    ext: [\"rs\"]\n  }, {\n    name: \"SAS\",\n    mime: \"text/x-sas\",\n    mode: \"sas\",\n    ext: [\"sas\"]\n  }, {\n    name: \"Sass\",\n    mime: \"text/x-sass\",\n    mode: \"sass\",\n    ext: [\"sass\"]\n  }, {\n    name: \"Scala\",\n    mime: \"text/x-scala\",\n    mode: \"clike\",\n    ext: [\"scala\"]\n  }, {\n    name: \"Scheme\",\n    mime: \"text/x-scheme\",\n    mode: \"scheme\",\n    ext: [\"scm\", \"ss\"]\n  }, {\n    name: \"SCSS\",\n    mime: \"text/x-scss\",\n    mode: \"css\",\n    ext: [\"scss\"]\n  }, {\n    name: \"Shell\",\n    mimes: [\"text/x-sh\", \"application/x-sh\"],\n    mode: \"shell\",\n    ext: [\"sh\", \"ksh\", \"bash\"],\n    alias: [\"bash\", \"sh\", \"zsh\"],\n    file: /^PKGBUILD$/\n  }, {\n    name: \"Sieve\",\n    mime: \"application/sieve\",\n    mode: \"sieve\",\n    ext: [\"siv\", \"sieve\"]\n  }, {\n    name: \"Slim\",\n    mimes: [\"text/x-slim\", \"application/x-slim\"],\n    mode: \"slim\",\n    ext: [\"slim\"]\n  }, {\n    name: \"Smalltalk\",\n    mime: \"text/x-stsrc\",\n    mode: \"smalltalk\",\n    ext: [\"st\"]\n  }, {\n    name: \"Smarty\",\n    mime: \"text/x-smarty\",\n    mode: \"smarty\",\n    ext: [\"tpl\"]\n  }, {\n    name: \"Solr\",\n    mime: \"text/x-solr\",\n    mode: \"solr\"\n  }, {\n    name: \"SML\",\n    mime: \"text/x-sml\",\n    mode: \"mllike\",\n    ext: [\"sml\", \"sig\", \"fun\", \"smackspec\"]\n  }, {\n    name: \"Soy\",\n    mime: \"text/x-soy\",\n    mode: \"soy\",\n    ext: [\"soy\"],\n    alias: [\"closure template\"]\n  }, {\n    name: \"SPARQL\",\n    mime: \"application/sparql-query\",\n    mode: \"sparql\",\n    ext: [\"rq\", \"sparql\"],\n    alias: [\"sparul\"]\n  }, {\n    name: \"Spreadsheet\",\n    mime: \"text/x-spreadsheet\",\n    mode: \"spreadsheet\",\n    alias: [\"excel\", \"formula\"]\n  }, {\n    name: \"SQL\",\n    mime: \"text/x-sql\",\n    mode: \"sql\",\n    ext: [\"sql\"]\n  }, {\n    name: \"SQLite\",\n    mime: \"text/x-sqlite\",\n    mode: \"sql\"\n  }, {\n    name: \"Squirrel\",\n    mime: \"text/x-squirrel\",\n    mode: \"clike\",\n    ext: [\"nut\"]\n  }, {\n    name: \"Stylus\",\n    mime: \"text/x-styl\",\n    mode: \"stylus\",\n    ext: [\"styl\"]\n  }, {\n    name: \"Swift\",\n    mime: \"text/x-swift\",\n    mode: \"swift\",\n    ext: [\"swift\"]\n  }, {\n    name: \"sTeX\",\n    mime: \"text/x-stex\",\n    mode: \"stex\"\n  }, {\n    name: \"LaTeX\",\n    mime: \"text/x-latex\",\n    mode: \"stex\",\n    ext: [\"text\", \"ltx\", \"tex\"],\n    alias: [\"tex\"]\n  }, {\n    name: \"SystemVerilog\",\n    mime: \"text/x-systemverilog\",\n    mode: \"verilog\",\n    ext: [\"v\", \"sv\", \"svh\"]\n  }, {\n    name: \"Tcl\",\n    mime: \"text/x-tcl\",\n    mode: \"tcl\",\n    ext: [\"tcl\"]\n  }, {\n    name: \"Textile\",\n    mime: \"text/x-textile\",\n    mode: \"textile\",\n    ext: [\"textile\"]\n  }, {\n    name: \"TiddlyWiki\",\n    mime: \"text/x-tiddlywiki\",\n    mode: \"tiddlywiki\"\n  }, {\n    name: \"Tiki wiki\",\n    mime: \"text/tiki\",\n    mode: \"tiki\"\n  }, {\n    name: \"TOML\",\n    mime: \"text/x-toml\",\n    mode: \"toml\",\n    ext: [\"toml\"]\n  }, {\n    name: \"Tornado\",\n    mime: \"text/x-tornado\",\n    mode: \"tornado\"\n  }, {\n    name: \"troff\",\n    mime: \"text/troff\",\n    mode: \"troff\",\n    ext: [\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"]\n  }, {\n    name: \"TTCN\",\n    mime: \"text/x-ttcn\",\n    mode: \"ttcn\",\n    ext: [\"ttcn\", \"ttcn3\", \"ttcnpp\"]\n  }, {\n    name: \"TTCN_CFG\",\n    mime: \"text/x-ttcn-cfg\",\n    mode: \"ttcn-cfg\",\n    ext: [\"cfg\"]\n  }, {\n    name: \"Turtle\",\n    mime: \"text/turtle\",\n    mode: \"turtle\",\n    ext: [\"ttl\"]\n  }, {\n    name: \"TypeScript\",\n    mime: \"application/typescript\",\n    mode: \"javascript\",\n    ext: [\"ts\"],\n    alias: [\"ts\"]\n  }, {\n    name: \"TypeScript-JSX\",\n    mime: \"text/typescript-jsx\",\n    mode: \"jsx\",\n    ext: [\"tsx\"],\n    alias: [\"tsx\"]\n  }, {\n    name: \"Twig\",\n    mime: \"text/x-twig\",\n    mode: \"twig\"\n  }, {\n    name: \"Web IDL\",\n    mime: \"text/x-webidl\",\n    mode: \"webidl\",\n    ext: [\"webidl\"]\n  }, {\n    name: \"VB.NET\",\n    mime: \"text/x-vb\",\n    mode: \"vb\",\n    ext: [\"vb\"]\n  }, {\n    name: \"VBScript\",\n    mime: \"text/vbscript\",\n    mode: \"vbscript\",\n    ext: [\"vbs\"]\n  }, {\n    name: \"Velocity\",\n    mime: \"text/velocity\",\n    mode: \"velocity\",\n    ext: [\"vtl\"]\n  }, {\n    name: \"Verilog\",\n    mime: \"text/x-verilog\",\n    mode: \"verilog\",\n    ext: [\"v\"]\n  }, {\n    name: \"VHDL\",\n    mime: \"text/x-vhdl\",\n    mode: \"vhdl\",\n    ext: [\"vhd\", \"vhdl\"]\n  }, {\n    name: \"Vue.js Component\",\n    mimes: [\"script/x-vue\", \"text/x-vue\"],\n    mode: \"vue\",\n    ext: [\"vue\"]\n  }, {\n    name: \"XML\",\n    mimes: [\"application/xml\", \"text/xml\"],\n    mode: \"xml\",\n    ext: [\"xml\", \"xsl\", \"xsd\", \"svg\"],\n    alias: [\"rss\", \"wsdl\", \"xsd\"]\n  }, {\n    name: \"XQuery\",\n    mime: \"application/xquery\",\n    mode: \"xquery\",\n    ext: [\"xy\", \"xquery\"]\n  }, {\n    name: \"Yacas\",\n    mime: \"text/x-yacas\",\n    mode: \"yacas\",\n    ext: [\"ys\"]\n  }, {\n    name: \"YAML\",\n    mimes: [\"text/x-yaml\", \"text/yaml\"],\n    mode: \"yaml\",\n    ext: [\"yaml\", \"yml\"],\n    alias: [\"yml\"]\n  }, {\n    name: \"Z80\",\n    mime: \"text/x-z80\",\n    mode: \"z80\",\n    ext: [\"z80\"]\n  }, {\n    name: \"mscgen\",\n    mime: \"text/x-mscgen\",\n    mode: \"mscgen\",\n    ext: [\"mscgen\", \"mscin\", \"msc\"]\n  }, {\n    name: \"xu\",\n    mime: \"text/x-xu\",\n    mode: \"mscgen\",\n    ext: [\"xu\"]\n  }, {\n    name: \"msgenny\",\n    mime: \"text/x-msgenny\",\n    mode: \"mscgen\",\n    ext: [\"msgenny\"]\n  }]; // Ensure all modes have a mime property for backwards compatibility\n\n  for (var i = 0; i < CodeMirror.modeInfo.length; i++) {\n    var info = CodeMirror.modeInfo[i];\n    if (info.mimes) info.mime = info.mimes[0];\n  }\n\n  CodeMirror.findModeByMIME = function (mime) {\n    mime = mime.toLowerCase();\n\n    for (var i = 0; i < CodeMirror.modeInfo.length; i++) {\n      var info = CodeMirror.modeInfo[i];\n      if (info.mime == mime) return info;\n      if (info.mimes) for (var j = 0; j < info.mimes.length; j++) if (info.mimes[j] == mime) return info;\n    }\n\n    if (/\\+xml$/.test(mime)) return CodeMirror.findModeByMIME(\"application/xml\");\n    if (/\\+json$/.test(mime)) return CodeMirror.findModeByMIME(\"application/json\");\n  };\n\n  CodeMirror.findModeByExtension = function (ext) {\n    ext = ext.toLowerCase();\n\n    for (var i = 0; i < CodeMirror.modeInfo.length; i++) {\n      var info = CodeMirror.modeInfo[i];\n      if (info.ext) for (var j = 0; j < info.ext.length; j++) if (info.ext[j] == ext) return info;\n    }\n  };\n\n  CodeMirror.findModeByFileName = function (filename) {\n    for (var i = 0; i < CodeMirror.modeInfo.length; i++) {\n      var info = CodeMirror.modeInfo[i];\n      if (info.file && info.file.test(filename)) return info;\n    }\n\n    var dot = filename.lastIndexOf(\".\");\n    var ext = dot > -1 && filename.substring(dot + 1, filename.length);\n    if (ext) return CodeMirror.findModeByExtension(ext);\n  };\n\n  CodeMirror.findModeByName = function (name) {\n    name = name.toLowerCase();\n\n    for (var i = 0; i < CodeMirror.modeInfo.length; i++) {\n      var info = CodeMirror.modeInfo[i];\n      if (info.name.toLowerCase() == name) return info;\n      if (info.alias) for (var j = 0; j < info.alias.length; j++) if (info.alias[j].toLowerCase() == name) return info;\n    }\n  };\n});"

/***/ }),
/* 210 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(211))

/***/ }),
/* 211 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"), require(\"./runmode\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\", \"./runmode\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  var isBlock = /^(p|li|div|h\\\\d|pre|blockquote|td)$/;\n\n  function textContent(node, out) {\n    if (node.nodeType == 3) return out.push(node.nodeValue);\n\n    for (var ch = node.firstChild; ch; ch = ch.nextSibling) {\n      textContent(ch, out);\n      if (isBlock.test(node.nodeType)) out.push(\"\\n\");\n    }\n  }\n\n  CodeMirror.colorize = function (collection, defaultMode) {\n    if (!collection) collection = document.body.getElementsByTagName(\"pre\");\n\n    for (var i = 0; i < collection.length; ++i) {\n      var node = collection[i];\n      var mode = node.getAttribute(\"data-lang\") || defaultMode;\n      if (!mode) continue;\n      var text = [];\n      textContent(node, text);\n      node.innerHTML = \"\";\n      CodeMirror.runMode(text.join(\"\"), mode, node);\n      node.className += \" cm-s-default\";\n    }\n  };\n});"

/***/ }),
/* 212 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(213))

/***/ }),
/* 213 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.runMode = function (string, modespec, callback, options) {\n    var mode = CodeMirror.getMode(CodeMirror.defaults, modespec);\n    var tabSize = options && options.tabSize || CodeMirror.defaults.tabSize; // Create a tokenizing callback function if passed-in callback is a DOM element.\n\n    if (callback.appendChild) {\n      var ie = /MSIE \\d/.test(navigator.userAgent);\n      var ie_lt9 = ie && (document.documentMode == null || document.documentMode < 9);\n      var node = callback,\n          col = 0;\n      node.innerHTML = \"\";\n\n      callback = function (text, style) {\n        if (text == \"\\n\") {\n          // Emitting LF or CRLF on IE8 or earlier results in an incorrect display.\n          // Emitting a carriage return makes everything ok.\n          node.appendChild(document.createTextNode(ie_lt9 ? '\\r' : text));\n          col = 0;\n          return;\n        }\n\n        var content = \"\"; // replace tabs\n\n        for (var pos = 0;;) {\n          var idx = text.indexOf(\"\\t\", pos);\n\n          if (idx == -1) {\n            content += text.slice(pos);\n            col += text.length - pos;\n            break;\n          } else {\n            col += idx - pos;\n            content += text.slice(pos, idx);\n            var size = tabSize - col % tabSize;\n            col += size;\n\n            for (var i = 0; i < size; ++i) content += \" \";\n\n            pos = idx + 1;\n          }\n        } // Create a node with token style and append it to the callback DOM element.\n\n\n        if (style) {\n          var sp = node.appendChild(document.createElement(\"span\"));\n          sp.className = \"cm-\" + style.replace(/ +/g, \" cm-\");\n          sp.appendChild(document.createTextNode(content));\n        } else {\n          node.appendChild(document.createTextNode(content));\n        }\n      };\n    }\n\n    var lines = CodeMirror.splitLines(string),\n        state = options && options.state || CodeMirror.startState(mode);\n\n    for (var i = 0, e = lines.length; i < e; ++i) {\n      if (i) callback(\"\\n\");\n      var stream = new CodeMirror.StringStream(lines[i], null, {\n        lookAhead: function (n) {\n          return lines[i + n];\n        },\n        baseToken: function () {}\n      });\n      if (!stream.string && mode.blankLine) mode.blankLine(state);\n\n      while (!stream.eol()) {\n        var style = mode.token(stream, state);\n        callback(stream.current(), style, i, stream.start, state);\n        stream.start = stream.pos;\n      }\n    }\n  };\n});"

/***/ }),
/* 214 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(215))

/***/ }),
/* 215 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n// Because sometimes you need to mark the selected *text*.\n//\n// Adds an option 'styleSelectedText' which, when enabled, gives\n// selected text the CSS class given as option value, or\n// \"CodeMirror-selectedtext\" when the value is not a string.\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.defineOption(\"styleSelectedText\", false, function (cm, val, old) {\n    var prev = old && old != CodeMirror.Init;\n\n    if (val && !prev) {\n      cm.state.markedSelection = [];\n      cm.state.markedSelectionStyle = typeof val == \"string\" ? val : \"CodeMirror-selectedtext\";\n      reset(cm);\n      cm.on(\"cursorActivity\", onCursorActivity);\n      cm.on(\"change\", onChange);\n    } else if (!val && prev) {\n      cm.off(\"cursorActivity\", onCursorActivity);\n      cm.off(\"change\", onChange);\n      clear(cm);\n      cm.state.markedSelection = cm.state.markedSelectionStyle = null;\n    }\n  });\n\n  function onCursorActivity(cm) {\n    if (cm.state.markedSelection) cm.operation(function () {\n      update(cm);\n    });\n  }\n\n  function onChange(cm) {\n    if (cm.state.markedSelection && cm.state.markedSelection.length) cm.operation(function () {\n      clear(cm);\n    });\n  }\n\n  var CHUNK_SIZE = 8;\n  var Pos = CodeMirror.Pos;\n  var cmp = CodeMirror.cmpPos;\n\n  function coverRange(cm, from, to, addAt) {\n    if (cmp(from, to) == 0) return;\n    var array = cm.state.markedSelection;\n    var cls = cm.state.markedSelectionStyle;\n\n    for (var line = from.line;;) {\n      var start = line == from.line ? from : Pos(line, 0);\n      var endLine = line + CHUNK_SIZE,\n          atEnd = endLine >= to.line;\n      var end = atEnd ? to : Pos(endLine, 0);\n      var mark = cm.markText(start, end, {\n        className: cls\n      });\n      if (addAt == null) array.push(mark);else array.splice(addAt++, 0, mark);\n      if (atEnd) break;\n      line = endLine;\n    }\n  }\n\n  function clear(cm) {\n    var array = cm.state.markedSelection;\n\n    for (var i = 0; i < array.length; ++i) array[i].clear();\n\n    array.length = 0;\n  }\n\n  function reset(cm) {\n    clear(cm);\n    var ranges = cm.listSelections();\n\n    for (var i = 0; i < ranges.length; i++) coverRange(cm, ranges[i].from(), ranges[i].to());\n  }\n\n  function update(cm) {\n    if (!cm.somethingSelected()) return clear(cm);\n    if (cm.listSelections().length > 1) return reset(cm);\n    var from = cm.getCursor(\"start\"),\n        to = cm.getCursor(\"end\");\n    var array = cm.state.markedSelection;\n    if (!array.length) return coverRange(cm, from, to);\n    var coverStart = array[0].find(),\n        coverEnd = array[array.length - 1].find();\n    if (!coverStart || !coverEnd || to.line - from.line <= CHUNK_SIZE || cmp(from, coverEnd.to) >= 0 || cmp(to, coverStart.from) <= 0) return reset(cm);\n\n    while (cmp(from, coverStart.from) > 0) {\n      array.shift().clear();\n      coverStart = array[0].find();\n    }\n\n    if (cmp(from, coverStart.from) < 0) {\n      if (coverStart.to.line - from.line < CHUNK_SIZE) {\n        array.shift().clear();\n        coverRange(cm, from, coverStart.to, 0);\n      } else {\n        coverRange(cm, from, coverStart.from, 0);\n      }\n    }\n\n    while (cmp(to, coverEnd.to) < 0) {\n      array.pop().clear();\n      coverEnd = array[array.length - 1].find();\n    }\n\n    if (cmp(to, coverEnd.to) > 0) {\n      if (to.line - coverEnd.from.line < CHUNK_SIZE) {\n        array.pop().clear();\n        coverRange(cm, coverEnd.from, to);\n      } else {\n        coverRange(cm, coverEnd.to, to);\n      }\n    }\n  }\n});"

/***/ }),
/* 216 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(217))

/***/ }),
/* 217 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  function Context(indented, column, type, info, align, prev) {\n    this.indented = indented;\n    this.column = column;\n    this.type = type;\n    this.info = info;\n    this.align = align;\n    this.prev = prev;\n  }\n\n  function pushContext(state, col, type, info) {\n    var indent = state.indented;\n    if (state.context && state.context.type == \"statement\" && type != \"statement\") indent = state.context.indented;\n    return state.context = new Context(indent, col, type, info, null, state.context);\n  }\n\n  function popContext(state) {\n    var t = state.context.type;\n    if (t == \")\" || t == \"]\" || t == \"}\") state.indented = state.context.indented;\n    return state.context = state.context.prev;\n  }\n\n  function typeBefore(stream, state, pos) {\n    if (state.prevToken == \"variable\" || state.prevToken == \"type\") return true;\n    if (/\\S(?:[^- ]>|[*\\]])\\s*$|\\*$/.test(stream.string.slice(0, pos))) return true;\n    if (state.typeAtEndOfLine && stream.column() == stream.indentation()) return true;\n  }\n\n  function isTopScope(context) {\n    for (;;) {\n      if (!context || context.type == \"top\") return true;\n      if (context.type == \"}\" && context.prev.info != \"namespace\") return false;\n      context = context.prev;\n    }\n  }\n\n  CodeMirror.defineMode(\"clike\", function (config, parserConfig) {\n    var indentUnit = config.indentUnit,\n        statementIndentUnit = parserConfig.statementIndentUnit || indentUnit,\n        dontAlignCalls = parserConfig.dontAlignCalls,\n        keywords = parserConfig.keywords || {},\n        types = parserConfig.types || {},\n        builtin = parserConfig.builtin || {},\n        blockKeywords = parserConfig.blockKeywords || {},\n        defKeywords = parserConfig.defKeywords || {},\n        atoms = parserConfig.atoms || {},\n        hooks = parserConfig.hooks || {},\n        multiLineStrings = parserConfig.multiLineStrings,\n        indentStatements = parserConfig.indentStatements !== false,\n        indentSwitch = parserConfig.indentSwitch !== false,\n        namespaceSeparator = parserConfig.namespaceSeparator,\n        isPunctuationChar = parserConfig.isPunctuationChar || /[\\[\\]{}\\(\\),;\\:\\.]/,\n        numberStart = parserConfig.numberStart || /[\\d\\.]/,\n        number = parserConfig.number || /^(?:0x[a-f\\d]+|0b[01]+|(?:\\d+\\.?\\d*|\\.\\d+)(?:e[-+]?\\d+)?)(u|ll?|l|f)?/i,\n        isOperatorChar = parserConfig.isOperatorChar || /[+\\-*&%=<>!?|\\/]/,\n        isIdentifierChar = parserConfig.isIdentifierChar || /[\\w\\$_\\xa1-\\uffff]/,\n        // An optional function that takes a {string} token and returns true if it\n    // should be treated as a builtin.\n    isReservedIdentifier = parserConfig.isReservedIdentifier || false;\n    var curPunc, isDefKeyword;\n\n    function tokenBase(stream, state) {\n      var ch = stream.next();\n\n      if (hooks[ch]) {\n        var result = hooks[ch](stream, state);\n        if (result !== false) return result;\n      }\n\n      if (ch == '\"' || ch == \"'\") {\n        state.tokenize = tokenString(ch);\n        return state.tokenize(stream, state);\n      }\n\n      if (isPunctuationChar.test(ch)) {\n        curPunc = ch;\n        return null;\n      }\n\n      if (numberStart.test(ch)) {\n        stream.backUp(1);\n        if (stream.match(number)) return \"number\";\n        stream.next();\n      }\n\n      if (ch == \"/\") {\n        if (stream.eat(\"*\")) {\n          state.tokenize = tokenComment;\n          return tokenComment(stream, state);\n        }\n\n        if (stream.eat(\"/\")) {\n          stream.skipToEnd();\n          return \"comment\";\n        }\n      }\n\n      if (isOperatorChar.test(ch)) {\n        while (!stream.match(/^\\/[\\/*]/, false) && stream.eat(isOperatorChar)) {}\n\n        return \"operator\";\n      }\n\n      stream.eatWhile(isIdentifierChar);\n      if (namespaceSeparator) while (stream.match(namespaceSeparator)) stream.eatWhile(isIdentifierChar);\n      var cur = stream.current();\n\n      if (contains(keywords, cur)) {\n        if (contains(blockKeywords, cur)) curPunc = \"newstatement\";\n        if (contains(defKeywords, cur)) isDefKeyword = true;\n        return \"keyword\";\n      }\n\n      if (contains(types, cur)) return \"type\";\n\n      if (contains(builtin, cur) || isReservedIdentifier && isReservedIdentifier(cur)) {\n        if (contains(blockKeywords, cur)) curPunc = \"newstatement\";\n        return \"builtin\";\n      }\n\n      if (contains(atoms, cur)) return \"atom\";\n      return \"variable\";\n    }\n\n    function tokenString(quote) {\n      return function (stream, state) {\n        var escaped = false,\n            next,\n            end = false;\n\n        while ((next = stream.next()) != null) {\n          if (next == quote && !escaped) {\n            end = true;\n            break;\n          }\n\n          escaped = !escaped && next == \"\\\\\";\n        }\n\n        if (end || !(escaped || multiLineStrings)) state.tokenize = null;\n        return \"string\";\n      };\n    }\n\n    function tokenComment(stream, state) {\n      var maybeEnd = false,\n          ch;\n\n      while (ch = stream.next()) {\n        if (ch == \"/\" && maybeEnd) {\n          state.tokenize = null;\n          break;\n        }\n\n        maybeEnd = ch == \"*\";\n      }\n\n      return \"comment\";\n    }\n\n    function maybeEOL(stream, state) {\n      if (parserConfig.typeFirstDefinitions && stream.eol() && isTopScope(state.context)) state.typeAtEndOfLine = typeBefore(stream, state, stream.pos);\n    } // Interface\n\n\n    return {\n      startState: function (basecolumn) {\n        return {\n          tokenize: null,\n          context: new Context((basecolumn || 0) - indentUnit, 0, \"top\", null, false),\n          indented: 0,\n          startOfLine: true,\n          prevToken: null\n        };\n      },\n      token: function (stream, state) {\n        var ctx = state.context;\n\n        if (stream.sol()) {\n          if (ctx.align == null) ctx.align = false;\n          state.indented = stream.indentation();\n          state.startOfLine = true;\n        }\n\n        if (stream.eatSpace()) {\n          maybeEOL(stream, state);\n          return null;\n        }\n\n        curPunc = isDefKeyword = null;\n        var style = (state.tokenize || tokenBase)(stream, state);\n        if (style == \"comment\" || style == \"meta\") return style;\n        if (ctx.align == null) ctx.align = true;\n        if (curPunc == \";\" || curPunc == \":\" || curPunc == \",\" && stream.match(/^\\s*(?:\\/\\/.*)?$/, false)) while (state.context.type == \"statement\") popContext(state);else if (curPunc == \"{\") pushContext(state, stream.column(), \"}\");else if (curPunc == \"[\") pushContext(state, stream.column(), \"]\");else if (curPunc == \"(\") pushContext(state, stream.column(), \")\");else if (curPunc == \"}\") {\n          while (ctx.type == \"statement\") ctx = popContext(state);\n\n          if (ctx.type == \"}\") ctx = popContext(state);\n\n          while (ctx.type == \"statement\") ctx = popContext(state);\n        } else if (curPunc == ctx.type) popContext(state);else if (indentStatements && ((ctx.type == \"}\" || ctx.type == \"top\") && curPunc != \";\" || ctx.type == \"statement\" && curPunc == \"newstatement\")) {\n          pushContext(state, stream.column(), \"statement\", stream.current());\n        }\n        if (style == \"variable\" && (state.prevToken == \"def\" || parserConfig.typeFirstDefinitions && typeBefore(stream, state, stream.start) && isTopScope(state.context) && stream.match(/^\\s*\\(/, false))) style = \"def\";\n\n        if (hooks.token) {\n          var result = hooks.token(stream, state, style);\n          if (result !== undefined) style = result;\n        }\n\n        if (style == \"def\" && parserConfig.styleDefs === false) style = \"variable\";\n        state.startOfLine = false;\n        state.prevToken = isDefKeyword ? \"def\" : style || curPunc;\n        maybeEOL(stream, state);\n        return style;\n      },\n      indent: function (state, textAfter) {\n        if (state.tokenize != tokenBase && state.tokenize != null || state.typeAtEndOfLine) return CodeMirror.Pass;\n        var ctx = state.context,\n            firstChar = textAfter && textAfter.charAt(0);\n        var closing = firstChar == ctx.type;\n        if (ctx.type == \"statement\" && firstChar == \"}\") ctx = ctx.prev;\n        if (parserConfig.dontIndentStatements) while (ctx.type == \"statement\" && parserConfig.dontIndentStatements.test(ctx.info)) ctx = ctx.prev;\n\n        if (hooks.indent) {\n          var hook = hooks.indent(state, ctx, textAfter, indentUnit);\n          if (typeof hook == \"number\") return hook;\n        }\n\n        var switchBlock = ctx.prev && ctx.prev.info == \"switch\";\n\n        if (parserConfig.allmanIndentation && /[{(]/.test(firstChar)) {\n          while (ctx.type != \"top\" && ctx.type != \"}\") ctx = ctx.prev;\n\n          return ctx.indented;\n        }\n\n        if (ctx.type == \"statement\") return ctx.indented + (firstChar == \"{\" ? 0 : statementIndentUnit);\n        if (ctx.align && (!dontAlignCalls || ctx.type != \")\")) return ctx.column + (closing ? 0 : 1);\n        if (ctx.type == \")\" && !closing) return ctx.indented + statementIndentUnit;\n        return ctx.indented + (closing ? 0 : indentUnit) + (!closing && switchBlock && !/^(?:case|default)\\b/.test(textAfter) ? indentUnit : 0);\n      },\n      electricInput: indentSwitch ? /^\\s*(?:case .*?:|default:|\\{\\}?|\\})$/ : /^\\s*[{}]$/,\n      blockCommentStart: \"/*\",\n      blockCommentEnd: \"*/\",\n      blockCommentContinue: \" * \",\n      lineComment: \"//\",\n      fold: \"brace\"\n    };\n  });\n\n  function words(str) {\n    var obj = {},\n        words = str.split(\" \");\n\n    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;\n\n    return obj;\n  }\n\n  function contains(words, word) {\n    if (typeof words === \"function\") {\n      return words(word);\n    } else {\n      return words.propertyIsEnumerable(word);\n    }\n  }\n\n  var cKeywords = \"auto if break case register continue return default do sizeof \" + \"static else struct switch extern typedef union for goto while enum const \" + \"volatile inline restrict asm fortran\"; // Keywords from https://en.cppreference.com/w/cpp/keyword includes C++20.\n\n  var cppKeywords = \"alignas alignof and and_eq audit axiom bitand bitor catch \" + \"class compl concept constexpr const_cast decltype delete dynamic_cast \" + \"explicit export final friend import module mutable namespace new noexcept \" + \"not not_eq operator or or_eq override private protected public \" + \"reinterpret_cast requires static_assert static_cast template this \" + \"thread_local throw try typeid typename using virtual xor xor_eq\";\n  var objCKeywords = \"bycopy byref in inout oneway out self super atomic nonatomic retain copy \" + \"readwrite readonly strong weak assign typeof nullable nonnull null_resettable _cmd \" + \"@interface @implementation @end @protocol @encode @property @synthesize @dynamic @class \" + \"@public @package @private @protected @required @optional @try @catch @finally @import \" + \"@selector @encode @defs @synchronized @autoreleasepool @compatibility_alias @available\";\n  var objCBuiltins = \"FOUNDATION_EXPORT FOUNDATION_EXTERN NS_INLINE NS_FORMAT_FUNCTION \" + \" NS_RETURNS_RETAINEDNS_ERROR_ENUM NS_RETURNS_NOT_RETAINED NS_RETURNS_INNER_POINTER \" + \"NS_DESIGNATED_INITIALIZER NS_ENUM NS_OPTIONS NS_REQUIRES_NIL_TERMINATION \" + \"NS_ASSUME_NONNULL_BEGIN NS_ASSUME_NONNULL_END NS_SWIFT_NAME NS_REFINED_FOR_SWIFT\"; // Do not use this. Use the cTypes function below. This is global just to avoid\n  // excessive calls when cTypes is being called multiple times during a parse.\n\n  var basicCTypes = words(\"int long char short double float unsigned signed \" + \"void bool\"); // Do not use this. Use the objCTypes function below. This is global just to avoid\n  // excessive calls when objCTypes is being called multiple times during a parse.\n\n  var basicObjCTypes = words(\"SEL instancetype id Class Protocol BOOL\"); // Returns true if identifier is a \"C\" type.\n  // C type is defined as those that are reserved by the compiler (basicTypes),\n  // and those that end in _t (Reserved by POSIX for types)\n  // http://www.gnu.org/software/libc/manual/html_node/Reserved-Names.html\n\n  function cTypes(identifier) {\n    return contains(basicCTypes, identifier) || /.+_t$/.test(identifier);\n  } // Returns true if identifier is a \"Objective C\" type.\n\n\n  function objCTypes(identifier) {\n    return cTypes(identifier) || contains(basicObjCTypes, identifier);\n  }\n\n  var cBlockKeywords = \"case do else for if switch while struct enum union\";\n  var cDefKeywords = \"struct enum union\";\n\n  function cppHook(stream, state) {\n    if (!state.startOfLine) return false;\n\n    for (var ch, next = null; ch = stream.peek();) {\n      if (ch == \"\\\\\" && stream.match(/^.$/)) {\n        next = cppHook;\n        break;\n      } else if (ch == \"/\" && stream.match(/^\\/[\\/\\*]/, false)) {\n        break;\n      }\n\n      stream.next();\n    }\n\n    state.tokenize = next;\n    return \"meta\";\n  }\n\n  function pointerHook(_stream, state) {\n    if (state.prevToken == \"type\") return \"type\";\n    return false;\n  } // For C and C++ (and ObjC): identifiers starting with __\n  // or _ followed by a capital letter are reserved for the compiler.\n\n\n  function cIsReservedIdentifier(token) {\n    if (!token || token.length < 2) return false;\n    if (token[0] != '_') return false;\n    return token[1] == '_' || token[1] !== token[1].toLowerCase();\n  }\n\n  function cpp14Literal(stream) {\n    stream.eatWhile(/[\\w\\.']/);\n    return \"number\";\n  }\n\n  function cpp11StringHook(stream, state) {\n    stream.backUp(1); // Raw strings.\n\n    if (stream.match(/(R|u8R|uR|UR|LR)/)) {\n      var match = stream.match(/\"([^\\s\\\\()]{0,16})\\(/);\n\n      if (!match) {\n        return false;\n      }\n\n      state.cpp11RawStringDelim = match[1];\n      state.tokenize = tokenRawString;\n      return tokenRawString(stream, state);\n    } // Unicode strings/chars.\n\n\n    if (stream.match(/(u8|u|U|L)/)) {\n      if (stream.match(/[\"']/,\n      /* eat */\n      false)) {\n        return \"string\";\n      }\n\n      return false;\n    } // Ignore this hook.\n\n\n    stream.next();\n    return false;\n  }\n\n  function cppLooksLikeConstructor(word) {\n    var lastTwo = /(\\w+)::~?(\\w+)$/.exec(word);\n    return lastTwo && lastTwo[1] == lastTwo[2];\n  } // C#-style strings where \"\" escapes a quote.\n\n\n  function tokenAtString(stream, state) {\n    var next;\n\n    while ((next = stream.next()) != null) {\n      if (next == '\"' && !stream.eat('\"')) {\n        state.tokenize = null;\n        break;\n      }\n    }\n\n    return \"string\";\n  } // C++11 raw string literal is <prefix>\"<delim>( anything )<delim>\", where\n  // <delim> can be a string up to 16 characters long.\n\n\n  function tokenRawString(stream, state) {\n    // Escape characters that have special regex meanings.\n    var delim = state.cpp11RawStringDelim.replace(/[^\\w\\s]/g, '\\\\$&');\n    var match = stream.match(new RegExp(\".*?\\\\)\" + delim + '\"'));\n    if (match) state.tokenize = null;else stream.skipToEnd();\n    return \"string\";\n  }\n\n  function def(mimes, mode) {\n    if (typeof mimes == \"string\") mimes = [mimes];\n    var words = [];\n\n    function add(obj) {\n      if (obj) for (var prop in obj) if (obj.hasOwnProperty(prop)) words.push(prop);\n    }\n\n    add(mode.keywords);\n    add(mode.types);\n    add(mode.builtin);\n    add(mode.atoms);\n\n    if (words.length) {\n      mode.helperType = mimes[0];\n      CodeMirror.registerHelper(\"hintWords\", mimes[0], words);\n    }\n\n    for (var i = 0; i < mimes.length; ++i) CodeMirror.defineMIME(mimes[i], mode);\n  }\n\n  def([\"text/x-csrc\", \"text/x-c\", \"text/x-chdr\"], {\n    name: \"clike\",\n    keywords: words(cKeywords),\n    types: cTypes,\n    blockKeywords: words(cBlockKeywords),\n    defKeywords: words(cDefKeywords),\n    typeFirstDefinitions: true,\n    atoms: words(\"NULL true false\"),\n    isReservedIdentifier: cIsReservedIdentifier,\n    hooks: {\n      \"#\": cppHook,\n      \"*\": pointerHook\n    },\n    modeProps: {\n      fold: [\"brace\", \"include\"]\n    }\n  });\n  def([\"text/x-c++src\", \"text/x-c++hdr\"], {\n    name: \"clike\",\n    keywords: words(cKeywords + \" \" + cppKeywords),\n    types: cTypes,\n    blockKeywords: words(cBlockKeywords + \" class try catch\"),\n    defKeywords: words(cDefKeywords + \" class namespace\"),\n    typeFirstDefinitions: true,\n    atoms: words(\"true false NULL nullptr\"),\n    dontIndentStatements: /^template$/,\n    isIdentifierChar: /[\\w\\$_~\\xa1-\\uffff]/,\n    isReservedIdentifier: cIsReservedIdentifier,\n    hooks: {\n      \"#\": cppHook,\n      \"*\": pointerHook,\n      \"u\": cpp11StringHook,\n      \"U\": cpp11StringHook,\n      \"L\": cpp11StringHook,\n      \"R\": cpp11StringHook,\n      \"0\": cpp14Literal,\n      \"1\": cpp14Literal,\n      \"2\": cpp14Literal,\n      \"3\": cpp14Literal,\n      \"4\": cpp14Literal,\n      \"5\": cpp14Literal,\n      \"6\": cpp14Literal,\n      \"7\": cpp14Literal,\n      \"8\": cpp14Literal,\n      \"9\": cpp14Literal,\n      token: function (stream, state, style) {\n        if (style == \"variable\" && stream.peek() == \"(\" && (state.prevToken == \";\" || state.prevToken == null || state.prevToken == \"}\") && cppLooksLikeConstructor(stream.current())) return \"def\";\n      }\n    },\n    namespaceSeparator: \"::\",\n    modeProps: {\n      fold: [\"brace\", \"include\"]\n    }\n  });\n  def(\"text/x-java\", {\n    name: \"clike\",\n    keywords: words(\"abstract assert break case catch class const continue default \" + \"do else enum extends final finally for goto if implements import \" + \"instanceof interface native new package private protected public \" + \"return static strictfp super switch synchronized this throw throws transient \" + \"try volatile while @interface\"),\n    types: words(\"byte short int long float double boolean char void Boolean Byte Character Double Float \" + \"Integer Long Number Object Short String StringBuffer StringBuilder Void\"),\n    blockKeywords: words(\"catch class do else finally for if switch try while\"),\n    defKeywords: words(\"class interface enum @interface\"),\n    typeFirstDefinitions: true,\n    atoms: words(\"true false null\"),\n    number: /^(?:0x[a-f\\d_]+|0b[01_]+|(?:[\\d_]+\\.?\\d*|\\.\\d+)(?:e[-+]?[\\d_]+)?)(u|ll?|l|f)?/i,\n    hooks: {\n      \"@\": function (stream) {\n        // Don't match the @interface keyword.\n        if (stream.match('interface', false)) return false;\n        stream.eatWhile(/[\\w\\$_]/);\n        return \"meta\";\n      }\n    },\n    modeProps: {\n      fold: [\"brace\", \"import\"]\n    }\n  });\n  def(\"text/x-csharp\", {\n    name: \"clike\",\n    keywords: words(\"abstract as async await base break case catch checked class const continue\" + \" default delegate do else enum event explicit extern finally fixed for\" + \" foreach goto if implicit in interface internal is lock namespace new\" + \" operator out override params private protected public readonly ref return sealed\" + \" sizeof stackalloc static struct switch this throw try typeof unchecked\" + \" unsafe using virtual void volatile while add alias ascending descending dynamic from get\" + \" global group into join let orderby partial remove select set value var yield\"),\n    types: words(\"Action Boolean Byte Char DateTime DateTimeOffset Decimal Double Func\" + \" Guid Int16 Int32 Int64 Object SByte Single String Task TimeSpan UInt16 UInt32\" + \" UInt64 bool byte char decimal double short int long object\" + \" sbyte float string ushort uint ulong\"),\n    blockKeywords: words(\"catch class do else finally for foreach if struct switch try while\"),\n    defKeywords: words(\"class interface namespace struct var\"),\n    typeFirstDefinitions: true,\n    atoms: words(\"true false null\"),\n    hooks: {\n      \"@\": function (stream, state) {\n        if (stream.eat('\"')) {\n          state.tokenize = tokenAtString;\n          return tokenAtString(stream, state);\n        }\n\n        stream.eatWhile(/[\\w\\$_]/);\n        return \"meta\";\n      }\n    }\n  });\n\n  function tokenTripleString(stream, state) {\n    var escaped = false;\n\n    while (!stream.eol()) {\n      if (!escaped && stream.match('\"\"\"')) {\n        state.tokenize = null;\n        break;\n      }\n\n      escaped = stream.next() == \"\\\\\" && !escaped;\n    }\n\n    return \"string\";\n  }\n\n  function tokenNestedComment(depth) {\n    return function (stream, state) {\n      var ch;\n\n      while (ch = stream.next()) {\n        if (ch == \"*\" && stream.eat(\"/\")) {\n          if (depth == 1) {\n            state.tokenize = null;\n            break;\n          } else {\n            state.tokenize = tokenNestedComment(depth - 1);\n            return state.tokenize(stream, state);\n          }\n        } else if (ch == \"/\" && stream.eat(\"*\")) {\n          state.tokenize = tokenNestedComment(depth + 1);\n          return state.tokenize(stream, state);\n        }\n      }\n\n      return \"comment\";\n    };\n  }\n\n  def(\"text/x-scala\", {\n    name: \"clike\",\n    keywords: words(\n    /* scala */\n    \"abstract case catch class def do else extends final finally for forSome if \" + \"implicit import lazy match new null object override package private protected return \" + \"sealed super this throw trait try type val var while with yield _ \" +\n    /* package scala */\n    \"assert assume require print println printf readLine readBoolean readByte readShort \" + \"readChar readInt readLong readFloat readDouble\"),\n    types: words(\"AnyVal App Application Array BufferedIterator BigDecimal BigInt Char Console Either \" + \"Enumeration Equiv Error Exception Fractional Function IndexedSeq Int Integral Iterable \" + \"Iterator List Map Numeric Nil NotNull Option Ordered Ordering PartialFunction PartialOrdering \" + \"Product Proxy Range Responder Seq Serializable Set Specializable Stream StringBuilder \" + \"StringContext Symbol Throwable Traversable TraversableOnce Tuple Unit Vector \" +\n    /* package java.lang */\n    \"Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable \" + \"Compiler Double Exception Float Integer Long Math Number Object Package Pair Process \" + \"Runtime Runnable SecurityManager Short StackTraceElement StrictMath String \" + \"StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void\"),\n    multiLineStrings: true,\n    blockKeywords: words(\"catch class enum do else finally for forSome if match switch try while\"),\n    defKeywords: words(\"class enum def object package trait type val var\"),\n    atoms: words(\"true false null\"),\n    indentStatements: false,\n    indentSwitch: false,\n    isOperatorChar: /[+\\-*&%=<>!?|\\/#:@]/,\n    hooks: {\n      \"@\": function (stream) {\n        stream.eatWhile(/[\\w\\$_]/);\n        return \"meta\";\n      },\n      '\"': function (stream, state) {\n        if (!stream.match('\"\"')) return false;\n        state.tokenize = tokenTripleString;\n        return state.tokenize(stream, state);\n      },\n      \"'\": function (stream) {\n        stream.eatWhile(/[\\w\\$_\\xa1-\\uffff]/);\n        return \"atom\";\n      },\n      \"=\": function (stream, state) {\n        var cx = state.context;\n\n        if (cx.type == \"}\" && cx.align && stream.eat(\">\")) {\n          state.context = new Context(cx.indented, cx.column, cx.type, cx.info, null, cx.prev);\n          return \"operator\";\n        } else {\n          return false;\n        }\n      },\n      \"/\": function (stream, state) {\n        if (!stream.eat(\"*\")) return false;\n        state.tokenize = tokenNestedComment(1);\n        return state.tokenize(stream, state);\n      }\n    },\n    modeProps: {\n      closeBrackets: {\n        pairs: '()[]{}\"\"',\n        triples: '\"'\n      }\n    }\n  });\n\n  function tokenKotlinString(tripleString) {\n    return function (stream, state) {\n      var escaped = false,\n          next,\n          end = false;\n\n      while (!stream.eol()) {\n        if (!tripleString && !escaped && stream.match('\"')) {\n          end = true;\n          break;\n        }\n\n        if (tripleString && stream.match('\"\"\"')) {\n          end = true;\n          break;\n        }\n\n        next = stream.next();\n        if (!escaped && next == \"$\" && stream.match('{')) stream.skipTo(\"}\");\n        escaped = !escaped && next == \"\\\\\" && !tripleString;\n      }\n\n      if (end || !tripleString) state.tokenize = null;\n      return \"string\";\n    };\n  }\n\n  def(\"text/x-kotlin\", {\n    name: \"clike\",\n    keywords: words(\n    /*keywords*/\n    \"package as typealias class interface this super val operator \" + \"var fun for is in This throw return annotation \" + \"break continue object if else while do try when !in !is as? \" +\n    /*soft keywords*/\n    \"file import where by get set abstract enum open inner override private public internal \" + \"protected catch finally out final vararg reified dynamic companion constructor init \" + \"sealed field property receiver param sparam lateinit data inline noinline tailrec \" + \"external annotation crossinline const operator infix suspend actual expect setparam\"),\n    types: words(\n    /* package java.lang */\n    \"Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable \" + \"Compiler Double Exception Float Integer Long Math Number Object Package Pair Process \" + \"Runtime Runnable SecurityManager Short StackTraceElement StrictMath String \" + \"StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void Annotation Any BooleanArray \" + \"ByteArray Char CharArray DeprecationLevel DoubleArray Enum FloatArray Function Int IntArray Lazy \" + \"LazyThreadSafetyMode LongArray Nothing ShortArray Unit\"),\n    intendSwitch: false,\n    indentStatements: false,\n    multiLineStrings: true,\n    number: /^(?:0x[a-f\\d_]+|0b[01_]+|(?:[\\d_]+(\\.\\d+)?|\\.\\d+)(?:e[-+]?[\\d_]+)?)(u|ll?|l|f)?/i,\n    blockKeywords: words(\"catch class do else finally for if where try while enum\"),\n    defKeywords: words(\"class val var object interface fun\"),\n    atoms: words(\"true false null this\"),\n    hooks: {\n      \"@\": function (stream) {\n        stream.eatWhile(/[\\w\\$_]/);\n        return \"meta\";\n      },\n      '*': function (_stream, state) {\n        return state.prevToken == '.' ? 'variable' : 'operator';\n      },\n      '\"': function (stream, state) {\n        state.tokenize = tokenKotlinString(stream.match('\"\"'));\n        return state.tokenize(stream, state);\n      },\n      \"/\": function (stream, state) {\n        if (!stream.eat(\"*\")) return false;\n        state.tokenize = tokenNestedComment(1);\n        return state.tokenize(stream, state);\n      },\n      indent: function (state, ctx, textAfter, indentUnit) {\n        var firstChar = textAfter && textAfter.charAt(0);\n        if ((state.prevToken == \"}\" || state.prevToken == \")\") && textAfter == \"\") return state.indented;\n        if (state.prevToken == \"operator\" && textAfter != \"}\" && state.context.type != \"}\" || state.prevToken == \"variable\" && firstChar == \".\" || (state.prevToken == \"}\" || state.prevToken == \")\") && firstChar == \".\") return indentUnit * 2 + ctx.indented;\n        if (ctx.align && ctx.type == \"}\") return ctx.indented + (state.context.type == (textAfter || \"\").charAt(0) ? 0 : indentUnit);\n      }\n    },\n    modeProps: {\n      closeBrackets: {\n        triples: '\"'\n      }\n    }\n  });\n  def([\"x-shader/x-vertex\", \"x-shader/x-fragment\"], {\n    name: \"clike\",\n    keywords: words(\"sampler1D sampler2D sampler3D samplerCube \" + \"sampler1DShadow sampler2DShadow \" + \"const attribute uniform varying \" + \"break continue discard return \" + \"for while do if else struct \" + \"in out inout\"),\n    types: words(\"float int bool void \" + \"vec2 vec3 vec4 ivec2 ivec3 ivec4 bvec2 bvec3 bvec4 \" + \"mat2 mat3 mat4\"),\n    blockKeywords: words(\"for while do if else struct\"),\n    builtin: words(\"radians degrees sin cos tan asin acos atan \" + \"pow exp log exp2 sqrt inversesqrt \" + \"abs sign floor ceil fract mod min max clamp mix step smoothstep \" + \"length distance dot cross normalize ftransform faceforward \" + \"reflect refract matrixCompMult \" + \"lessThan lessThanEqual greaterThan greaterThanEqual \" + \"equal notEqual any all not \" + \"texture1D texture1DProj texture1DLod texture1DProjLod \" + \"texture2D texture2DProj texture2DLod texture2DProjLod \" + \"texture3D texture3DProj texture3DLod texture3DProjLod \" + \"textureCube textureCubeLod \" + \"shadow1D shadow2D shadow1DProj shadow2DProj \" + \"shadow1DLod shadow2DLod shadow1DProjLod shadow2DProjLod \" + \"dFdx dFdy fwidth \" + \"noise1 noise2 noise3 noise4\"),\n    atoms: words(\"true false \" + \"gl_FragColor gl_SecondaryColor gl_Normal gl_Vertex \" + \"gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord3 \" + \"gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 \" + \"gl_FogCoord gl_PointCoord \" + \"gl_Position gl_PointSize gl_ClipVertex \" + \"gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor \" + \"gl_TexCoord gl_FogFragCoord \" + \"gl_FragCoord gl_FrontFacing \" + \"gl_FragData gl_FragDepth \" + \"gl_ModelViewMatrix gl_ProjectionMatrix gl_ModelViewProjectionMatrix \" + \"gl_TextureMatrix gl_NormalMatrix gl_ModelViewMatrixInverse \" + \"gl_ProjectionMatrixInverse gl_ModelViewProjectionMatrixInverse \" + \"gl_TexureMatrixTranspose gl_ModelViewMatrixInverseTranspose \" + \"gl_ProjectionMatrixInverseTranspose \" + \"gl_ModelViewProjectionMatrixInverseTranspose \" + \"gl_TextureMatrixInverseTranspose \" + \"gl_NormalScale gl_DepthRange gl_ClipPlane \" + \"gl_Point gl_FrontMaterial gl_BackMaterial gl_LightSource gl_LightModel \" + \"gl_FrontLightModelProduct gl_BackLightModelProduct \" + \"gl_TextureColor gl_EyePlaneS gl_EyePlaneT gl_EyePlaneR gl_EyePlaneQ \" + \"gl_FogParameters \" + \"gl_MaxLights gl_MaxClipPlanes gl_MaxTextureUnits gl_MaxTextureCoords \" + \"gl_MaxVertexAttribs gl_MaxVertexUniformComponents gl_MaxVaryingFloats \" + \"gl_MaxVertexTextureImageUnits gl_MaxTextureImageUnits \" + \"gl_MaxFragmentUniformComponents gl_MaxCombineTextureImageUnits \" + \"gl_MaxDrawBuffers\"),\n    indentSwitch: false,\n    hooks: {\n      \"#\": cppHook\n    },\n    modeProps: {\n      fold: [\"brace\", \"include\"]\n    }\n  });\n  def(\"text/x-nesc\", {\n    name: \"clike\",\n    keywords: words(cKeywords + \" as atomic async call command component components configuration event generic \" + \"implementation includes interface module new norace nx_struct nx_union post provides \" + \"signal task uses abstract extends\"),\n    types: cTypes,\n    blockKeywords: words(cBlockKeywords),\n    atoms: words(\"null true false\"),\n    hooks: {\n      \"#\": cppHook\n    },\n    modeProps: {\n      fold: [\"brace\", \"include\"]\n    }\n  });\n  def(\"text/x-objectivec\", {\n    name: \"clike\",\n    keywords: words(cKeywords + \" \" + objCKeywords),\n    types: objCTypes,\n    builtin: words(objCBuiltins),\n    blockKeywords: words(cBlockKeywords + \" @synthesize @try @catch @finally @autoreleasepool @synchronized\"),\n    defKeywords: words(cDefKeywords + \" @interface @implementation @protocol @class\"),\n    dontIndentStatements: /^@.*$/,\n    typeFirstDefinitions: true,\n    atoms: words(\"YES NO NULL Nil nil true false nullptr\"),\n    isReservedIdentifier: cIsReservedIdentifier,\n    hooks: {\n      \"#\": cppHook,\n      \"*\": pointerHook\n    },\n    modeProps: {\n      fold: [\"brace\", \"include\"]\n    }\n  });\n  def(\"text/x-objectivec++\", {\n    name: \"clike\",\n    keywords: words(cKeywords + \" \" + objCKeywords + \" \" + cppKeywords),\n    types: objCTypes,\n    builtin: words(objCBuiltins),\n    blockKeywords: words(cBlockKeywords + \" @synthesize @try @catch @finally @autoreleasepool @synchronized class try catch\"),\n    defKeywords: words(cDefKeywords + \" @interface @implementation @protocol @class class namespace\"),\n    dontIndentStatements: /^@.*$|^template$/,\n    typeFirstDefinitions: true,\n    atoms: words(\"YES NO NULL Nil nil true false nullptr\"),\n    isReservedIdentifier: cIsReservedIdentifier,\n    hooks: {\n      \"#\": cppHook,\n      \"*\": pointerHook,\n      \"u\": cpp11StringHook,\n      \"U\": cpp11StringHook,\n      \"L\": cpp11StringHook,\n      \"R\": cpp11StringHook,\n      \"0\": cpp14Literal,\n      \"1\": cpp14Literal,\n      \"2\": cpp14Literal,\n      \"3\": cpp14Literal,\n      \"4\": cpp14Literal,\n      \"5\": cpp14Literal,\n      \"6\": cpp14Literal,\n      \"7\": cpp14Literal,\n      \"8\": cpp14Literal,\n      \"9\": cpp14Literal,\n      token: function (stream, state, style) {\n        if (style == \"variable\" && stream.peek() == \"(\" && (state.prevToken == \";\" || state.prevToken == null || state.prevToken == \"}\") && cppLooksLikeConstructor(stream.current())) return \"def\";\n      }\n    },\n    namespaceSeparator: \"::\",\n    modeProps: {\n      fold: [\"brace\", \"include\"]\n    }\n  });\n  def(\"text/x-squirrel\", {\n    name: \"clike\",\n    keywords: words(\"base break clone continue const default delete enum extends function in class\" + \" foreach local resume return this throw typeof yield constructor instanceof static\"),\n    types: cTypes,\n    blockKeywords: words(\"case catch class else for foreach if switch try while\"),\n    defKeywords: words(\"function local class\"),\n    typeFirstDefinitions: true,\n    atoms: words(\"true false null\"),\n    hooks: {\n      \"#\": cppHook\n    },\n    modeProps: {\n      fold: [\"brace\", \"include\"]\n    }\n  }); // Ceylon Strings need to deal with interpolation\n\n  var stringTokenizer = null;\n\n  function tokenCeylonString(type) {\n    return function (stream, state) {\n      var escaped = false,\n          next,\n          end = false;\n\n      while (!stream.eol()) {\n        if (!escaped && stream.match('\"') && (type == \"single\" || stream.match('\"\"'))) {\n          end = true;\n          break;\n        }\n\n        if (!escaped && stream.match('``')) {\n          stringTokenizer = tokenCeylonString(type);\n          end = true;\n          break;\n        }\n\n        next = stream.next();\n        escaped = type == \"single\" && !escaped && next == \"\\\\\";\n      }\n\n      if (end) state.tokenize = null;\n      return \"string\";\n    };\n  }\n\n  def(\"text/x-ceylon\", {\n    name: \"clike\",\n    keywords: words(\"abstracts alias assembly assert assign break case catch class continue dynamic else\" + \" exists extends finally for function given if import in interface is let module new\" + \" nonempty object of out outer package return satisfies super switch then this throw\" + \" try value void while\"),\n    types: function (word) {\n      // In Ceylon all identifiers that start with an uppercase are types\n      var first = word.charAt(0);\n      return first === first.toUpperCase() && first !== first.toLowerCase();\n    },\n    blockKeywords: words(\"case catch class dynamic else finally for function if interface module new object switch try while\"),\n    defKeywords: words(\"class dynamic function interface module object package value\"),\n    builtin: words(\"abstract actual aliased annotation by default deprecated doc final formal late license\" + \" native optional sealed see serializable shared suppressWarnings tagged throws variable\"),\n    isPunctuationChar: /[\\[\\]{}\\(\\),;\\:\\.`]/,\n    isOperatorChar: /[+\\-*&%=<>!?|^~:\\/]/,\n    numberStart: /[\\d#$]/,\n    number: /^(?:#[\\da-fA-F_]+|\\$[01_]+|[\\d_]+[kMGTPmunpf]?|[\\d_]+\\.[\\d_]+(?:[eE][-+]?\\d+|[kMGTPmunpf]|)|)/i,\n    multiLineStrings: true,\n    typeFirstDefinitions: true,\n    atoms: words(\"true false null larger smaller equal empty finished\"),\n    indentSwitch: false,\n    styleDefs: false,\n    hooks: {\n      \"@\": function (stream) {\n        stream.eatWhile(/[\\w\\$_]/);\n        return \"meta\";\n      },\n      '\"': function (stream, state) {\n        state.tokenize = tokenCeylonString(stream.match('\"\"') ? \"triple\" : \"single\");\n        return state.tokenize(stream, state);\n      },\n      '`': function (stream, state) {\n        if (!stringTokenizer || !stream.match('`')) return false;\n        state.tokenize = stringTokenizer;\n        stringTokenizer = null;\n        return state.tokenize(stream, state);\n      },\n      \"'\": function (stream) {\n        stream.eatWhile(/[\\w\\$_\\xa1-\\uffff]/);\n        return \"atom\";\n      },\n      token: function (_stream, state, style) {\n        if ((style == \"variable\" || style == \"type\") && state.prevToken == \".\") {\n          return \"variable-2\";\n        }\n      }\n    },\n    modeProps: {\n      fold: [\"brace\", \"import\"],\n      closeBrackets: {\n        triples: '\"'\n      }\n    }\n  });\n});"

/***/ }),
/* 218 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(219))

/***/ }),
/* 219 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.defineMode(\"go\", function (config) {\n    var indentUnit = config.indentUnit;\n    var keywords = {\n      \"break\": true,\n      \"case\": true,\n      \"chan\": true,\n      \"const\": true,\n      \"continue\": true,\n      \"default\": true,\n      \"defer\": true,\n      \"else\": true,\n      \"fallthrough\": true,\n      \"for\": true,\n      \"func\": true,\n      \"go\": true,\n      \"goto\": true,\n      \"if\": true,\n      \"import\": true,\n      \"interface\": true,\n      \"map\": true,\n      \"package\": true,\n      \"range\": true,\n      \"return\": true,\n      \"select\": true,\n      \"struct\": true,\n      \"switch\": true,\n      \"type\": true,\n      \"var\": true,\n      \"bool\": true,\n      \"byte\": true,\n      \"complex64\": true,\n      \"complex128\": true,\n      \"float32\": true,\n      \"float64\": true,\n      \"int8\": true,\n      \"int16\": true,\n      \"int32\": true,\n      \"int64\": true,\n      \"string\": true,\n      \"uint8\": true,\n      \"uint16\": true,\n      \"uint32\": true,\n      \"uint64\": true,\n      \"int\": true,\n      \"uint\": true,\n      \"uintptr\": true,\n      \"error\": true,\n      \"rune\": true\n    };\n    var atoms = {\n      \"true\": true,\n      \"false\": true,\n      \"iota\": true,\n      \"nil\": true,\n      \"append\": true,\n      \"cap\": true,\n      \"close\": true,\n      \"complex\": true,\n      \"copy\": true,\n      \"delete\": true,\n      \"imag\": true,\n      \"len\": true,\n      \"make\": true,\n      \"new\": true,\n      \"panic\": true,\n      \"print\": true,\n      \"println\": true,\n      \"real\": true,\n      \"recover\": true\n    };\n    var isOperatorChar = /[+\\-*&^%:=<>!|\\/]/;\n    var curPunc;\n\n    function tokenBase(stream, state) {\n      var ch = stream.next();\n\n      if (ch == '\"' || ch == \"'\" || ch == \"`\") {\n        state.tokenize = tokenString(ch);\n        return state.tokenize(stream, state);\n      }\n\n      if (/[\\d\\.]/.test(ch)) {\n        if (ch == \".\") {\n          stream.match(/^[0-9]+([eE][\\-+]?[0-9]+)?/);\n        } else if (ch == \"0\") {\n          stream.match(/^[xX][0-9a-fA-F]+/) || stream.match(/^0[0-7]+/);\n        } else {\n          stream.match(/^[0-9]*\\.?[0-9]*([eE][\\-+]?[0-9]+)?/);\n        }\n\n        return \"number\";\n      }\n\n      if (/[\\[\\]{}\\(\\),;\\:\\.]/.test(ch)) {\n        curPunc = ch;\n        return null;\n      }\n\n      if (ch == \"/\") {\n        if (stream.eat(\"*\")) {\n          state.tokenize = tokenComment;\n          return tokenComment(stream, state);\n        }\n\n        if (stream.eat(\"/\")) {\n          stream.skipToEnd();\n          return \"comment\";\n        }\n      }\n\n      if (isOperatorChar.test(ch)) {\n        stream.eatWhile(isOperatorChar);\n        return \"operator\";\n      }\n\n      stream.eatWhile(/[\\w\\$_\\xa1-\\uffff]/);\n      var cur = stream.current();\n\n      if (keywords.propertyIsEnumerable(cur)) {\n        if (cur == \"case\" || cur == \"default\") curPunc = \"case\";\n        return \"keyword\";\n      }\n\n      if (atoms.propertyIsEnumerable(cur)) return \"atom\";\n      return \"variable\";\n    }\n\n    function tokenString(quote) {\n      return function (stream, state) {\n        var escaped = false,\n            next,\n            end = false;\n\n        while ((next = stream.next()) != null) {\n          if (next == quote && !escaped) {\n            end = true;\n            break;\n          }\n\n          escaped = !escaped && quote != \"`\" && next == \"\\\\\";\n        }\n\n        if (end || !(escaped || quote == \"`\")) state.tokenize = tokenBase;\n        return \"string\";\n      };\n    }\n\n    function tokenComment(stream, state) {\n      var maybeEnd = false,\n          ch;\n\n      while (ch = stream.next()) {\n        if (ch == \"/\" && maybeEnd) {\n          state.tokenize = tokenBase;\n          break;\n        }\n\n        maybeEnd = ch == \"*\";\n      }\n\n      return \"comment\";\n    }\n\n    function Context(indented, column, type, align, prev) {\n      this.indented = indented;\n      this.column = column;\n      this.type = type;\n      this.align = align;\n      this.prev = prev;\n    }\n\n    function pushContext(state, col, type) {\n      return state.context = new Context(state.indented, col, type, null, state.context);\n    }\n\n    function popContext(state) {\n      if (!state.context.prev) return;\n      var t = state.context.type;\n      if (t == \")\" || t == \"]\" || t == \"}\") state.indented = state.context.indented;\n      return state.context = state.context.prev;\n    } // Interface\n\n\n    return {\n      startState: function (basecolumn) {\n        return {\n          tokenize: null,\n          context: new Context((basecolumn || 0) - indentUnit, 0, \"top\", false),\n          indented: 0,\n          startOfLine: true\n        };\n      },\n      token: function (stream, state) {\n        var ctx = state.context;\n\n        if (stream.sol()) {\n          if (ctx.align == null) ctx.align = false;\n          state.indented = stream.indentation();\n          state.startOfLine = true;\n          if (ctx.type == \"case\") ctx.type = \"}\";\n        }\n\n        if (stream.eatSpace()) return null;\n        curPunc = null;\n        var style = (state.tokenize || tokenBase)(stream, state);\n        if (style == \"comment\") return style;\n        if (ctx.align == null) ctx.align = true;\n        if (curPunc == \"{\") pushContext(state, stream.column(), \"}\");else if (curPunc == \"[\") pushContext(state, stream.column(), \"]\");else if (curPunc == \"(\") pushContext(state, stream.column(), \")\");else if (curPunc == \"case\") ctx.type = \"case\";else if (curPunc == \"}\" && ctx.type == \"}\") popContext(state);else if (curPunc == ctx.type) popContext(state);\n        state.startOfLine = false;\n        return style;\n      },\n      indent: function (state, textAfter) {\n        if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass;\n        var ctx = state.context,\n            firstChar = textAfter && textAfter.charAt(0);\n\n        if (ctx.type == \"case\" && /^(?:case|default)\\b/.test(textAfter)) {\n          state.context.type = \"}\";\n          return ctx.indented;\n        }\n\n        var closing = firstChar == ctx.type;\n        if (ctx.align) return ctx.column + (closing ? 0 : 1);else return ctx.indented + (closing ? 0 : indentUnit);\n      },\n      electricChars: \"{}):\",\n      closeBrackets: \"()[]{}''\\\"\\\"``\",\n      fold: \"brace\",\n      blockCommentStart: \"/*\",\n      blockCommentEnd: \"*/\",\n      lineComment: \"//\"\n    };\n  });\n  CodeMirror.defineMIME(\"text/x-go\", \"go\");\n});"

/***/ }),
/* 220 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(221))

/***/ }),
/* 221 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.defineMode(\"javascript\", function (config, parserConfig) {\n    var indentUnit = config.indentUnit;\n    var statementIndent = parserConfig.statementIndent;\n    var jsonldMode = parserConfig.jsonld;\n    var jsonMode = parserConfig.json || jsonldMode;\n    var isTS = parserConfig.typescript;\n    var wordRE = parserConfig.wordCharacters || /[\\w$\\xa1-\\uffff]/; // Tokenizer\n\n    var keywords = function () {\n      function kw(type) {\n        return {\n          type: type,\n          style: \"keyword\"\n        };\n      }\n\n      var A = kw(\"keyword a\"),\n          B = kw(\"keyword b\"),\n          C = kw(\"keyword c\"),\n          D = kw(\"keyword d\");\n      var operator = kw(\"operator\"),\n          atom = {\n        type: \"atom\",\n        style: \"atom\"\n      };\n      return {\n        \"if\": kw(\"if\"),\n        \"while\": A,\n        \"with\": A,\n        \"else\": B,\n        \"do\": B,\n        \"try\": B,\n        \"finally\": B,\n        \"return\": D,\n        \"break\": D,\n        \"continue\": D,\n        \"new\": kw(\"new\"),\n        \"delete\": C,\n        \"void\": C,\n        \"throw\": C,\n        \"debugger\": kw(\"debugger\"),\n        \"var\": kw(\"var\"),\n        \"const\": kw(\"var\"),\n        \"let\": kw(\"var\"),\n        \"function\": kw(\"function\"),\n        \"catch\": kw(\"catch\"),\n        \"for\": kw(\"for\"),\n        \"switch\": kw(\"switch\"),\n        \"case\": kw(\"case\"),\n        \"default\": kw(\"default\"),\n        \"in\": operator,\n        \"typeof\": operator,\n        \"instanceof\": operator,\n        \"true\": atom,\n        \"false\": atom,\n        \"null\": atom,\n        \"undefined\": atom,\n        \"NaN\": atom,\n        \"Infinity\": atom,\n        \"this\": kw(\"this\"),\n        \"class\": kw(\"class\"),\n        \"super\": kw(\"atom\"),\n        \"yield\": C,\n        \"export\": kw(\"export\"),\n        \"import\": kw(\"import\"),\n        \"extends\": C,\n        \"await\": C\n      };\n    }();\n\n    var isOperatorChar = /[+\\-*&%=<>!?|~^@]/;\n    var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)\"/;\n\n    function readRegexp(stream) {\n      var escaped = false,\n          next,\n          inSet = false;\n\n      while ((next = stream.next()) != null) {\n        if (!escaped) {\n          if (next == \"/\" && !inSet) return;\n          if (next == \"[\") inSet = true;else if (inSet && next == \"]\") inSet = false;\n        }\n\n        escaped = !escaped && next == \"\\\\\";\n      }\n    } // Used as scratch variables to communicate multiple values without\n    // consing up tons of objects.\n\n\n    var type, content;\n\n    function ret(tp, style, cont) {\n      type = tp;\n      content = cont;\n      return style;\n    }\n\n    function tokenBase(stream, state) {\n      var ch = stream.next();\n\n      if (ch == '\"' || ch == \"'\") {\n        state.tokenize = tokenString(ch);\n        return state.tokenize(stream, state);\n      } else if (ch == \".\" && stream.match(/^\\d[\\d_]*(?:[eE][+\\-]?[\\d_]+)?/)) {\n        return ret(\"number\", \"number\");\n      } else if (ch == \".\" && stream.match(\"..\")) {\n        return ret(\"spread\", \"meta\");\n      } else if (/[\\[\\]{}\\(\\),;\\:\\.]/.test(ch)) {\n        return ret(ch);\n      } else if (ch == \"=\" && stream.eat(\">\")) {\n        return ret(\"=>\", \"operator\");\n      } else if (ch == \"0\" && stream.match(/^(?:x[\\dA-Fa-f_]+|o[0-7_]+|b[01_]+)n?/)) {\n        return ret(\"number\", \"number\");\n      } else if (/\\d/.test(ch)) {\n        stream.match(/^[\\d_]*(?:n|(?:\\.[\\d_]*)?(?:[eE][+\\-]?[\\d_]+)?)?/);\n        return ret(\"number\", \"number\");\n      } else if (ch == \"/\") {\n        if (stream.eat(\"*\")) {\n          state.tokenize = tokenComment;\n          return tokenComment(stream, state);\n        } else if (stream.eat(\"/\")) {\n          stream.skipToEnd();\n          return ret(\"comment\", \"comment\");\n        } else if (expressionAllowed(stream, state, 1)) {\n          readRegexp(stream);\n          stream.match(/^\\b(([gimyus])(?![gimyus]*\\2))+\\b/);\n          return ret(\"regexp\", \"string-2\");\n        } else {\n          stream.eat(\"=\");\n          return ret(\"operator\", \"operator\", stream.current());\n        }\n      } else if (ch == \"`\") {\n        state.tokenize = tokenQuasi;\n        return tokenQuasi(stream, state);\n      } else if (ch == \"#\" && stream.peek() == \"!\") {\n        stream.skipToEnd();\n        return ret(\"meta\", \"meta\");\n      } else if (ch == \"#\" && stream.eatWhile(wordRE)) {\n        return ret(\"variable\", \"property\");\n      } else if (ch == \"<\" && stream.match(\"!--\") || ch == \"-\" && stream.match(\"->\") && !/\\S/.test(stream.string.slice(0, stream.start))) {\n        stream.skipToEnd();\n        return ret(\"comment\", \"comment\");\n      } else if (isOperatorChar.test(ch)) {\n        if (ch != \">\" || !state.lexical || state.lexical.type != \">\") {\n          if (stream.eat(\"=\")) {\n            if (ch == \"!\" || ch == \"=\") stream.eat(\"=\");\n          } else if (/[<>*+\\-]/.test(ch)) {\n            stream.eat(ch);\n            if (ch == \">\") stream.eat(ch);\n          }\n        }\n\n        if (ch == \"?\" && stream.eat(\".\")) return ret(\".\");\n        return ret(\"operator\", \"operator\", stream.current());\n      } else if (wordRE.test(ch)) {\n        stream.eatWhile(wordRE);\n        var word = stream.current();\n\n        if (state.lastType != \".\") {\n          if (keywords.propertyIsEnumerable(word)) {\n            var kw = keywords[word];\n            return ret(kw.type, kw.style, word);\n          }\n\n          if (word == \"async\" && stream.match(/^(\\s|\\/\\*.*?\\*\\/)*[\\[\\(\\w]/, false)) return ret(\"async\", \"keyword\", word);\n        }\n\n        return ret(\"variable\", \"variable\", word);\n      }\n    }\n\n    function tokenString(quote) {\n      return function (stream, state) {\n        var escaped = false,\n            next;\n\n        if (jsonldMode && stream.peek() == \"@\" && stream.match(isJsonldKeyword)) {\n          state.tokenize = tokenBase;\n          return ret(\"jsonld-keyword\", \"meta\");\n        }\n\n        while ((next = stream.next()) != null) {\n          if (next == quote && !escaped) break;\n          escaped = !escaped && next == \"\\\\\";\n        }\n\n        if (!escaped) state.tokenize = tokenBase;\n        return ret(\"string\", \"string\");\n      };\n    }\n\n    function tokenComment(stream, state) {\n      var maybeEnd = false,\n          ch;\n\n      while (ch = stream.next()) {\n        if (ch == \"/\" && maybeEnd) {\n          state.tokenize = tokenBase;\n          break;\n        }\n\n        maybeEnd = ch == \"*\";\n      }\n\n      return ret(\"comment\", \"comment\");\n    }\n\n    function tokenQuasi(stream, state) {\n      var escaped = false,\n          next;\n\n      while ((next = stream.next()) != null) {\n        if (!escaped && (next == \"`\" || next == \"$\" && stream.eat(\"{\"))) {\n          state.tokenize = tokenBase;\n          break;\n        }\n\n        escaped = !escaped && next == \"\\\\\";\n      }\n\n      return ret(\"quasi\", \"string-2\", stream.current());\n    }\n\n    var brackets = \"([{}])\"; // This is a crude lookahead trick to try and notice that we're\n    // parsing the argument patterns for a fat-arrow function before we\n    // actually hit the arrow token. It only works if the arrow is on\n    // the same line as the arguments and there's no strange noise\n    // (comments) in between. Fallback is to only notice when we hit the\n    // arrow, and not declare the arguments as locals for the arrow\n    // body.\n\n    function findFatArrow(stream, state) {\n      if (state.fatArrowAt) state.fatArrowAt = null;\n      var arrow = stream.string.indexOf(\"=>\", stream.start);\n      if (arrow < 0) return;\n\n      if (isTS) {\n        // Try to skip TypeScript return type declarations after the arguments\n        var m = /:\\s*(?:\\w+(?:<[^>]*>|\\[\\])?|\\{[^}]*\\})\\s*$/.exec(stream.string.slice(stream.start, arrow));\n        if (m) arrow = m.index;\n      }\n\n      var depth = 0,\n          sawSomething = false;\n\n      for (var pos = arrow - 1; pos >= 0; --pos) {\n        var ch = stream.string.charAt(pos);\n        var bracket = brackets.indexOf(ch);\n\n        if (bracket >= 0 && bracket < 3) {\n          if (!depth) {\n            ++pos;\n            break;\n          }\n\n          if (--depth == 0) {\n            if (ch == \"(\") sawSomething = true;\n            break;\n          }\n        } else if (bracket >= 3 && bracket < 6) {\n          ++depth;\n        } else if (wordRE.test(ch)) {\n          sawSomething = true;\n        } else if (/[\"'\\/`]/.test(ch)) {\n          for (;; --pos) {\n            if (pos == 0) return;\n            var next = stream.string.charAt(pos - 1);\n\n            if (next == ch && stream.string.charAt(pos - 2) != \"\\\\\") {\n              pos--;\n              break;\n            }\n          }\n        } else if (sawSomething && !depth) {\n          ++pos;\n          break;\n        }\n      }\n\n      if (sawSomething && !depth) state.fatArrowAt = pos;\n    } // Parser\n\n\n    var atomicTypes = {\n      \"atom\": true,\n      \"number\": true,\n      \"variable\": true,\n      \"string\": true,\n      \"regexp\": true,\n      \"this\": true,\n      \"jsonld-keyword\": true\n    };\n\n    function JSLexical(indented, column, type, align, prev, info) {\n      this.indented = indented;\n      this.column = column;\n      this.type = type;\n      this.prev = prev;\n      this.info = info;\n      if (align != null) this.align = align;\n    }\n\n    function inScope(state, varname) {\n      for (var v = state.localVars; v; v = v.next) if (v.name == varname) return true;\n\n      for (var cx = state.context; cx; cx = cx.prev) {\n        for (var v = cx.vars; v; v = v.next) if (v.name == varname) return true;\n      }\n    }\n\n    function parseJS(state, style, type, content, stream) {\n      var cc = state.cc; // Communicate our context to the combinators.\n      // (Less wasteful than consing up a hundred closures on every call.)\n\n      cx.state = state;\n      cx.stream = stream;\n      cx.marked = null, cx.cc = cc;\n      cx.style = style;\n      if (!state.lexical.hasOwnProperty(\"align\")) state.lexical.align = true;\n\n      while (true) {\n        var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;\n\n        if (combinator(type, content)) {\n          while (cc.length && cc[cc.length - 1].lex) cc.pop()();\n\n          if (cx.marked) return cx.marked;\n          if (type == \"variable\" && inScope(state, content)) return \"variable-2\";\n          return style;\n        }\n      }\n    } // Combinator utils\n\n\n    var cx = {\n      state: null,\n      column: null,\n      marked: null,\n      cc: null\n    };\n\n    function pass() {\n      for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);\n    }\n\n    function cont() {\n      pass.apply(null, arguments);\n      return true;\n    }\n\n    function inList(name, list) {\n      for (var v = list; v; v = v.next) if (v.name == name) return true;\n\n      return false;\n    }\n\n    function register(varname) {\n      var state = cx.state;\n      cx.marked = \"def\";\n\n      if (state.context) {\n        if (state.lexical.info == \"var\" && state.context && state.context.block) {\n          // FIXME function decls are also not block scoped\n          var newContext = registerVarScoped(varname, state.context);\n\n          if (newContext != null) {\n            state.context = newContext;\n            return;\n          }\n        } else if (!inList(varname, state.localVars)) {\n          state.localVars = new Var(varname, state.localVars);\n          return;\n        }\n      } // Fall through means this is global\n\n\n      if (parserConfig.globalVars && !inList(varname, state.globalVars)) state.globalVars = new Var(varname, state.globalVars);\n    }\n\n    function registerVarScoped(varname, context) {\n      if (!context) {\n        return null;\n      } else if (context.block) {\n        var inner = registerVarScoped(varname, context.prev);\n        if (!inner) return null;\n        if (inner == context.prev) return context;\n        return new Context(inner, context.vars, true);\n      } else if (inList(varname, context.vars)) {\n        return context;\n      } else {\n        return new Context(context.prev, new Var(varname, context.vars), false);\n      }\n    }\n\n    function isModifier(name) {\n      return name == \"public\" || name == \"private\" || name == \"protected\" || name == \"abstract\" || name == \"readonly\";\n    } // Combinators\n\n\n    function Context(prev, vars, block) {\n      this.prev = prev;\n      this.vars = vars;\n      this.block = block;\n    }\n\n    function Var(name, next) {\n      this.name = name;\n      this.next = next;\n    }\n\n    var defaultVars = new Var(\"this\", new Var(\"arguments\", null));\n\n    function pushcontext() {\n      cx.state.context = new Context(cx.state.context, cx.state.localVars, false);\n      cx.state.localVars = defaultVars;\n    }\n\n    function pushblockcontext() {\n      cx.state.context = new Context(cx.state.context, cx.state.localVars, true);\n      cx.state.localVars = null;\n    }\n\n    function popcontext() {\n      cx.state.localVars = cx.state.context.vars;\n      cx.state.context = cx.state.context.prev;\n    }\n\n    popcontext.lex = true;\n\n    function pushlex(type, info) {\n      var result = function () {\n        var state = cx.state,\n            indent = state.indented;\n        if (state.lexical.type == \"stat\") indent = state.lexical.indented;else for (var outer = state.lexical; outer && outer.type == \")\" && outer.align; outer = outer.prev) indent = outer.indented;\n        state.lexical = new JSLexical(indent, cx.stream.column(), type, null, state.lexical, info);\n      };\n\n      result.lex = true;\n      return result;\n    }\n\n    function poplex() {\n      var state = cx.state;\n\n      if (state.lexical.prev) {\n        if (state.lexical.type == \")\") state.indented = state.lexical.indented;\n        state.lexical = state.lexical.prev;\n      }\n    }\n\n    poplex.lex = true;\n\n    function expect(wanted) {\n      function exp(type) {\n        if (type == wanted) return cont();else if (wanted == \";\" || type == \"}\" || type == \")\" || type == \"]\") return pass();else return cont(exp);\n      }\n\n      ;\n      return exp;\n    }\n\n    function statement(type, value) {\n      if (type == \"var\") return cont(pushlex(\"vardef\", value), vardef, expect(\";\"), poplex);\n      if (type == \"keyword a\") return cont(pushlex(\"form\"), parenExpr, statement, poplex);\n      if (type == \"keyword b\") return cont(pushlex(\"form\"), statement, poplex);\n      if (type == \"keyword d\") return cx.stream.match(/^\\s*$/, false) ? cont() : cont(pushlex(\"stat\"), maybeexpression, expect(\";\"), poplex);\n      if (type == \"debugger\") return cont(expect(\";\"));\n      if (type == \"{\") return cont(pushlex(\"}\"), pushblockcontext, block, poplex, popcontext);\n      if (type == \";\") return cont();\n\n      if (type == \"if\") {\n        if (cx.state.lexical.info == \"else\" && cx.state.cc[cx.state.cc.length - 1] == poplex) cx.state.cc.pop()();\n        return cont(pushlex(\"form\"), parenExpr, statement, poplex, maybeelse);\n      }\n\n      if (type == \"function\") return cont(functiondef);\n      if (type == \"for\") return cont(pushlex(\"form\"), forspec, statement, poplex);\n\n      if (type == \"class\" || isTS && value == \"interface\") {\n        cx.marked = \"keyword\";\n        return cont(pushlex(\"form\", type == \"class\" ? type : value), className, poplex);\n      }\n\n      if (type == \"variable\") {\n        if (isTS && value == \"declare\") {\n          cx.marked = \"keyword\";\n          return cont(statement);\n        } else if (isTS && (value == \"module\" || value == \"enum\" || value == \"type\") && cx.stream.match(/^\\s*\\w/, false)) {\n          cx.marked = \"keyword\";\n          if (value == \"enum\") return cont(enumdef);else if (value == \"type\") return cont(typename, expect(\"operator\"), typeexpr, expect(\";\"));else return cont(pushlex(\"form\"), pattern, expect(\"{\"), pushlex(\"}\"), block, poplex, poplex);\n        } else if (isTS && value == \"namespace\") {\n          cx.marked = \"keyword\";\n          return cont(pushlex(\"form\"), expression, statement, poplex);\n        } else if (isTS && value == \"abstract\") {\n          cx.marked = \"keyword\";\n          return cont(statement);\n        } else {\n          return cont(pushlex(\"stat\"), maybelabel);\n        }\n      }\n\n      if (type == \"switch\") return cont(pushlex(\"form\"), parenExpr, expect(\"{\"), pushlex(\"}\", \"switch\"), pushblockcontext, block, poplex, poplex, popcontext);\n      if (type == \"case\") return cont(expression, expect(\":\"));\n      if (type == \"default\") return cont(expect(\":\"));\n      if (type == \"catch\") return cont(pushlex(\"form\"), pushcontext, maybeCatchBinding, statement, poplex, popcontext);\n      if (type == \"export\") return cont(pushlex(\"stat\"), afterExport, poplex);\n      if (type == \"import\") return cont(pushlex(\"stat\"), afterImport, poplex);\n      if (type == \"async\") return cont(statement);\n      if (value == \"@\") return cont(expression, statement);\n      return pass(pushlex(\"stat\"), expression, expect(\";\"), poplex);\n    }\n\n    function maybeCatchBinding(type) {\n      if (type == \"(\") return cont(funarg, expect(\")\"));\n    }\n\n    function expression(type, value) {\n      return expressionInner(type, value, false);\n    }\n\n    function expressionNoComma(type, value) {\n      return expressionInner(type, value, true);\n    }\n\n    function parenExpr(type) {\n      if (type != \"(\") return pass();\n      return cont(pushlex(\")\"), maybeexpression, expect(\")\"), poplex);\n    }\n\n    function expressionInner(type, value, noComma) {\n      if (cx.state.fatArrowAt == cx.stream.start) {\n        var body = noComma ? arrowBodyNoComma : arrowBody;\n        if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(funarg, \")\"), poplex, expect(\"=>\"), body, popcontext);else if (type == \"variable\") return pass(pushcontext, pattern, expect(\"=>\"), body, popcontext);\n      }\n\n      var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;\n      if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);\n      if (type == \"function\") return cont(functiondef, maybeop);\n\n      if (type == \"class\" || isTS && value == \"interface\") {\n        cx.marked = \"keyword\";\n        return cont(pushlex(\"form\"), classExpression, poplex);\n      }\n\n      if (type == \"keyword c\" || type == \"async\") return cont(noComma ? expressionNoComma : expression);\n      if (type == \"(\") return cont(pushlex(\")\"), maybeexpression, expect(\")\"), poplex, maybeop);\n      if (type == \"operator\" || type == \"spread\") return cont(noComma ? expressionNoComma : expression);\n      if (type == \"[\") return cont(pushlex(\"]\"), arrayLiteral, poplex, maybeop);\n      if (type == \"{\") return contCommasep(objprop, \"}\", null, maybeop);\n      if (type == \"quasi\") return pass(quasi, maybeop);\n      if (type == \"new\") return cont(maybeTarget(noComma));\n      if (type == \"import\") return cont(expression);\n      return cont();\n    }\n\n    function maybeexpression(type) {\n      if (type.match(/[;\\}\\)\\],]/)) return pass();\n      return pass(expression);\n    }\n\n    function maybeoperatorComma(type, value) {\n      if (type == \",\") return cont(maybeexpression);\n      return maybeoperatorNoComma(type, value, false);\n    }\n\n    function maybeoperatorNoComma(type, value, noComma) {\n      var me = noComma == false ? maybeoperatorComma : maybeoperatorNoComma;\n      var expr = noComma == false ? expression : expressionNoComma;\n      if (type == \"=>\") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);\n\n      if (type == \"operator\") {\n        if (/\\+\\+|--/.test(value) || isTS && value == \"!\") return cont(me);\n        if (isTS && value == \"<\" && cx.stream.match(/^([^<>]|<[^<>]*>)*>\\s*\\(/, false)) return cont(pushlex(\">\"), commasep(typeexpr, \">\"), poplex, me);\n        if (value == \"?\") return cont(expression, expect(\":\"), expr);\n        return cont(expr);\n      }\n\n      if (type == \"quasi\") {\n        return pass(quasi, me);\n      }\n\n      if (type == \";\") return;\n      if (type == \"(\") return contCommasep(expressionNoComma, \")\", \"call\", me);\n      if (type == \".\") return cont(property, me);\n      if (type == \"[\") return cont(pushlex(\"]\"), maybeexpression, expect(\"]\"), poplex, me);\n\n      if (isTS && value == \"as\") {\n        cx.marked = \"keyword\";\n        return cont(typeexpr, me);\n      }\n\n      if (type == \"regexp\") {\n        cx.state.lastType = cx.marked = \"operator\";\n        cx.stream.backUp(cx.stream.pos - cx.stream.start - 1);\n        return cont(expr);\n      }\n    }\n\n    function quasi(type, value) {\n      if (type != \"quasi\") return pass();\n      if (value.slice(value.length - 2) != \"${\") return cont(quasi);\n      return cont(expression, continueQuasi);\n    }\n\n    function continueQuasi(type) {\n      if (type == \"}\") {\n        cx.marked = \"string-2\";\n        cx.state.tokenize = tokenQuasi;\n        return cont(quasi);\n      }\n    }\n\n    function arrowBody(type) {\n      findFatArrow(cx.stream, cx.state);\n      return pass(type == \"{\" ? statement : expression);\n    }\n\n    function arrowBodyNoComma(type) {\n      findFatArrow(cx.stream, cx.state);\n      return pass(type == \"{\" ? statement : expressionNoComma);\n    }\n\n    function maybeTarget(noComma) {\n      return function (type) {\n        if (type == \".\") return cont(noComma ? targetNoComma : target);else if (type == \"variable\" && isTS) return cont(maybeTypeArgs, noComma ? maybeoperatorNoComma : maybeoperatorComma);else return pass(noComma ? expressionNoComma : expression);\n      };\n    }\n\n    function target(_, value) {\n      if (value == \"target\") {\n        cx.marked = \"keyword\";\n        return cont(maybeoperatorComma);\n      }\n    }\n\n    function targetNoComma(_, value) {\n      if (value == \"target\") {\n        cx.marked = \"keyword\";\n        return cont(maybeoperatorNoComma);\n      }\n    }\n\n    function maybelabel(type) {\n      if (type == \":\") return cont(poplex, statement);\n      return pass(maybeoperatorComma, expect(\";\"), poplex);\n    }\n\n    function property(type) {\n      if (type == \"variable\") {\n        cx.marked = \"property\";\n        return cont();\n      }\n    }\n\n    function objprop(type, value) {\n      if (type == \"async\") {\n        cx.marked = \"property\";\n        return cont(objprop);\n      } else if (type == \"variable\" || cx.style == \"keyword\") {\n        cx.marked = \"property\";\n        if (value == \"get\" || value == \"set\") return cont(getterSetter);\n        var m; // Work around fat-arrow-detection complication for detecting typescript typed arrow params\n\n        if (isTS && cx.state.fatArrowAt == cx.stream.start && (m = cx.stream.match(/^\\s*:\\s*/, false))) cx.state.fatArrowAt = cx.stream.pos + m[0].length;\n        return cont(afterprop);\n      } else if (type == \"number\" || type == \"string\") {\n        cx.marked = jsonldMode ? \"property\" : cx.style + \" property\";\n        return cont(afterprop);\n      } else if (type == \"jsonld-keyword\") {\n        return cont(afterprop);\n      } else if (isTS && isModifier(value)) {\n        cx.marked = \"keyword\";\n        return cont(objprop);\n      } else if (type == \"[\") {\n        return cont(expression, maybetype, expect(\"]\"), afterprop);\n      } else if (type == \"spread\") {\n        return cont(expressionNoComma, afterprop);\n      } else if (value == \"*\") {\n        cx.marked = \"keyword\";\n        return cont(objprop);\n      } else if (type == \":\") {\n        return pass(afterprop);\n      }\n    }\n\n    function getterSetter(type) {\n      if (type != \"variable\") return pass(afterprop);\n      cx.marked = \"property\";\n      return cont(functiondef);\n    }\n\n    function afterprop(type) {\n      if (type == \":\") return cont(expressionNoComma);\n      if (type == \"(\") return pass(functiondef);\n    }\n\n    function commasep(what, end, sep) {\n      function proceed(type, value) {\n        if (sep ? sep.indexOf(type) > -1 : type == \",\") {\n          var lex = cx.state.lexical;\n          if (lex.info == \"call\") lex.pos = (lex.pos || 0) + 1;\n          return cont(function (type, value) {\n            if (type == end || value == end) return pass();\n            return pass(what);\n          }, proceed);\n        }\n\n        if (type == end || value == end) return cont();\n        if (sep && sep.indexOf(\";\") > -1) return pass(what);\n        return cont(expect(end));\n      }\n\n      return function (type, value) {\n        if (type == end || value == end) return cont();\n        return pass(what, proceed);\n      };\n    }\n\n    function contCommasep(what, end, info) {\n      for (var i = 3; i < arguments.length; i++) cx.cc.push(arguments[i]);\n\n      return cont(pushlex(end, info), commasep(what, end), poplex);\n    }\n\n    function block(type) {\n      if (type == \"}\") return cont();\n      return pass(statement, block);\n    }\n\n    function maybetype(type, value) {\n      if (isTS) {\n        if (type == \":\") return cont(typeexpr);\n        if (value == \"?\") return cont(maybetype);\n      }\n    }\n\n    function maybetypeOrIn(type, value) {\n      if (isTS && (type == \":\" || value == \"in\")) return cont(typeexpr);\n    }\n\n    function mayberettype(type) {\n      if (isTS && type == \":\") {\n        if (cx.stream.match(/^\\s*\\w+\\s+is\\b/, false)) return cont(expression, isKW, typeexpr);else return cont(typeexpr);\n      }\n    }\n\n    function isKW(_, value) {\n      if (value == \"is\") {\n        cx.marked = \"keyword\";\n        return cont();\n      }\n    }\n\n    function typeexpr(type, value) {\n      if (value == \"keyof\" || value == \"typeof\" || value == \"infer\") {\n        cx.marked = \"keyword\";\n        return cont(value == \"typeof\" ? expressionNoComma : typeexpr);\n      }\n\n      if (type == \"variable\" || value == \"void\") {\n        cx.marked = \"type\";\n        return cont(afterType);\n      }\n\n      if (value == \"|\" || value == \"&\") return cont(typeexpr);\n      if (type == \"string\" || type == \"number\" || type == \"atom\") return cont(afterType);\n      if (type == \"[\") return cont(pushlex(\"]\"), commasep(typeexpr, \"]\", \",\"), poplex, afterType);\n      if (type == \"{\") return cont(pushlex(\"}\"), commasep(typeprop, \"}\", \",;\"), poplex, afterType);\n      if (type == \"(\") return cont(commasep(typearg, \")\"), maybeReturnType, afterType);\n      if (type == \"<\") return cont(commasep(typeexpr, \">\"), typeexpr);\n    }\n\n    function maybeReturnType(type) {\n      if (type == \"=>\") return cont(typeexpr);\n    }\n\n    function typeprop(type, value) {\n      if (type == \"variable\" || cx.style == \"keyword\") {\n        cx.marked = \"property\";\n        return cont(typeprop);\n      } else if (value == \"?\" || type == \"number\" || type == \"string\") {\n        return cont(typeprop);\n      } else if (type == \":\") {\n        return cont(typeexpr);\n      } else if (type == \"[\") {\n        return cont(expect(\"variable\"), maybetypeOrIn, expect(\"]\"), typeprop);\n      } else if (type == \"(\") {\n        return pass(functiondecl, typeprop);\n      }\n    }\n\n    function typearg(type, value) {\n      if (type == \"variable\" && cx.stream.match(/^\\s*[?:]/, false) || value == \"?\") return cont(typearg);\n      if (type == \":\") return cont(typeexpr);\n      if (type == \"spread\") return cont(typearg);\n      return pass(typeexpr);\n    }\n\n    function afterType(type, value) {\n      if (value == \"<\") return cont(pushlex(\">\"), commasep(typeexpr, \">\"), poplex, afterType);\n      if (value == \"|\" || type == \".\" || value == \"&\") return cont(typeexpr);\n      if (type == \"[\") return cont(typeexpr, expect(\"]\"), afterType);\n\n      if (value == \"extends\" || value == \"implements\") {\n        cx.marked = \"keyword\";\n        return cont(typeexpr);\n      }\n\n      if (value == \"?\") return cont(typeexpr, expect(\":\"), typeexpr);\n    }\n\n    function maybeTypeArgs(_, value) {\n      if (value == \"<\") return cont(pushlex(\">\"), commasep(typeexpr, \">\"), poplex, afterType);\n    }\n\n    function typeparam() {\n      return pass(typeexpr, maybeTypeDefault);\n    }\n\n    function maybeTypeDefault(_, value) {\n      if (value == \"=\") return cont(typeexpr);\n    }\n\n    function vardef(_, value) {\n      if (value == \"enum\") {\n        cx.marked = \"keyword\";\n        return cont(enumdef);\n      }\n\n      return pass(pattern, maybetype, maybeAssign, vardefCont);\n    }\n\n    function pattern(type, value) {\n      if (isTS && isModifier(value)) {\n        cx.marked = \"keyword\";\n        return cont(pattern);\n      }\n\n      if (type == \"variable\") {\n        register(value);\n        return cont();\n      }\n\n      if (type == \"spread\") return cont(pattern);\n      if (type == \"[\") return contCommasep(eltpattern, \"]\");\n      if (type == \"{\") return contCommasep(proppattern, \"}\");\n    }\n\n    function proppattern(type, value) {\n      if (type == \"variable\" && !cx.stream.match(/^\\s*:/, false)) {\n        register(value);\n        return cont(maybeAssign);\n      }\n\n      if (type == \"variable\") cx.marked = \"property\";\n      if (type == \"spread\") return cont(pattern);\n      if (type == \"}\") return pass();\n      if (type == \"[\") return cont(expression, expect(']'), expect(':'), proppattern);\n      return cont(expect(\":\"), pattern, maybeAssign);\n    }\n\n    function eltpattern() {\n      return pass(pattern, maybeAssign);\n    }\n\n    function maybeAssign(_type, value) {\n      if (value == \"=\") return cont(expressionNoComma);\n    }\n\n    function vardefCont(type) {\n      if (type == \",\") return cont(vardef);\n    }\n\n    function maybeelse(type, value) {\n      if (type == \"keyword b\" && value == \"else\") return cont(pushlex(\"form\", \"else\"), statement, poplex);\n    }\n\n    function forspec(type, value) {\n      if (value == \"await\") return cont(forspec);\n      if (type == \"(\") return cont(pushlex(\")\"), forspec1, poplex);\n    }\n\n    function forspec1(type) {\n      if (type == \"var\") return cont(vardef, forspec2);\n      if (type == \"variable\") return cont(forspec2);\n      return pass(forspec2);\n    }\n\n    function forspec2(type, value) {\n      if (type == \")\") return cont();\n      if (type == \";\") return cont(forspec2);\n\n      if (value == \"in\" || value == \"of\") {\n        cx.marked = \"keyword\";\n        return cont(expression, forspec2);\n      }\n\n      return pass(expression, forspec2);\n    }\n\n    function functiondef(type, value) {\n      if (value == \"*\") {\n        cx.marked = \"keyword\";\n        return cont(functiondef);\n      }\n\n      if (type == \"variable\") {\n        register(value);\n        return cont(functiondef);\n      }\n\n      if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(funarg, \")\"), poplex, mayberettype, statement, popcontext);\n      if (isTS && value == \"<\") return cont(pushlex(\">\"), commasep(typeparam, \">\"), poplex, functiondef);\n    }\n\n    function functiondecl(type, value) {\n      if (value == \"*\") {\n        cx.marked = \"keyword\";\n        return cont(functiondecl);\n      }\n\n      if (type == \"variable\") {\n        register(value);\n        return cont(functiondecl);\n      }\n\n      if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(funarg, \")\"), poplex, mayberettype, popcontext);\n      if (isTS && value == \"<\") return cont(pushlex(\">\"), commasep(typeparam, \">\"), poplex, functiondecl);\n    }\n\n    function typename(type, value) {\n      if (type == \"keyword\" || type == \"variable\") {\n        cx.marked = \"type\";\n        return cont(typename);\n      } else if (value == \"<\") {\n        return cont(pushlex(\">\"), commasep(typeparam, \">\"), poplex);\n      }\n    }\n\n    function funarg(type, value) {\n      if (value == \"@\") cont(expression, funarg);\n      if (type == \"spread\") return cont(funarg);\n\n      if (isTS && isModifier(value)) {\n        cx.marked = \"keyword\";\n        return cont(funarg);\n      }\n\n      if (isTS && type == \"this\") return cont(maybetype, maybeAssign);\n      return pass(pattern, maybetype, maybeAssign);\n    }\n\n    function classExpression(type, value) {\n      // Class expressions may have an optional name.\n      if (type == \"variable\") return className(type, value);\n      return classNameAfter(type, value);\n    }\n\n    function className(type, value) {\n      if (type == \"variable\") {\n        register(value);\n        return cont(classNameAfter);\n      }\n    }\n\n    function classNameAfter(type, value) {\n      if (value == \"<\") return cont(pushlex(\">\"), commasep(typeparam, \">\"), poplex, classNameAfter);\n\n      if (value == \"extends\" || value == \"implements\" || isTS && type == \",\") {\n        if (value == \"implements\") cx.marked = \"keyword\";\n        return cont(isTS ? typeexpr : expression, classNameAfter);\n      }\n\n      if (type == \"{\") return cont(pushlex(\"}\"), classBody, poplex);\n    }\n\n    function classBody(type, value) {\n      if (type == \"async\" || type == \"variable\" && (value == \"static\" || value == \"get\" || value == \"set\" || isTS && isModifier(value)) && cx.stream.match(/^\\s+[\\w$\\xa1-\\uffff]/, false)) {\n        cx.marked = \"keyword\";\n        return cont(classBody);\n      }\n\n      if (type == \"variable\" || cx.style == \"keyword\") {\n        cx.marked = \"property\";\n        return cont(classfield, classBody);\n      }\n\n      if (type == \"number\" || type == \"string\") return cont(classfield, classBody);\n      if (type == \"[\") return cont(expression, maybetype, expect(\"]\"), classfield, classBody);\n\n      if (value == \"*\") {\n        cx.marked = \"keyword\";\n        return cont(classBody);\n      }\n\n      if (isTS && type == \"(\") return pass(functiondecl, classBody);\n      if (type == \";\" || type == \",\") return cont(classBody);\n      if (type == \"}\") return cont();\n      if (value == \"@\") return cont(expression, classBody);\n    }\n\n    function classfield(type, value) {\n      if (value == \"?\") return cont(classfield);\n      if (type == \":\") return cont(typeexpr, maybeAssign);\n      if (value == \"=\") return cont(expressionNoComma);\n      var context = cx.state.lexical.prev,\n          isInterface = context && context.info == \"interface\";\n      return pass(isInterface ? functiondecl : functiondef);\n    }\n\n    function afterExport(type, value) {\n      if (value == \"*\") {\n        cx.marked = \"keyword\";\n        return cont(maybeFrom, expect(\";\"));\n      }\n\n      if (value == \"default\") {\n        cx.marked = \"keyword\";\n        return cont(expression, expect(\";\"));\n      }\n\n      if (type == \"{\") return cont(commasep(exportField, \"}\"), maybeFrom, expect(\";\"));\n      return pass(statement);\n    }\n\n    function exportField(type, value) {\n      if (value == \"as\") {\n        cx.marked = \"keyword\";\n        return cont(expect(\"variable\"));\n      }\n\n      if (type == \"variable\") return pass(expressionNoComma, exportField);\n    }\n\n    function afterImport(type) {\n      if (type == \"string\") return cont();\n      if (type == \"(\") return pass(expression);\n      return pass(importSpec, maybeMoreImports, maybeFrom);\n    }\n\n    function importSpec(type, value) {\n      if (type == \"{\") return contCommasep(importSpec, \"}\");\n      if (type == \"variable\") register(value);\n      if (value == \"*\") cx.marked = \"keyword\";\n      return cont(maybeAs);\n    }\n\n    function maybeMoreImports(type) {\n      if (type == \",\") return cont(importSpec, maybeMoreImports);\n    }\n\n    function maybeAs(_type, value) {\n      if (value == \"as\") {\n        cx.marked = \"keyword\";\n        return cont(importSpec);\n      }\n    }\n\n    function maybeFrom(_type, value) {\n      if (value == \"from\") {\n        cx.marked = \"keyword\";\n        return cont(expression);\n      }\n    }\n\n    function arrayLiteral(type) {\n      if (type == \"]\") return cont();\n      return pass(commasep(expressionNoComma, \"]\"));\n    }\n\n    function enumdef() {\n      return pass(pushlex(\"form\"), pattern, expect(\"{\"), pushlex(\"}\"), commasep(enummember, \"}\"), poplex, poplex);\n    }\n\n    function enummember() {\n      return pass(pattern, maybeAssign);\n    }\n\n    function isContinuedStatement(state, textAfter) {\n      return state.lastType == \"operator\" || state.lastType == \",\" || isOperatorChar.test(textAfter.charAt(0)) || /[,.]/.test(textAfter.charAt(0));\n    }\n\n    function expressionAllowed(stream, state, backUp) {\n      return state.tokenize == tokenBase && /^(?:operator|sof|keyword [bcd]|case|new|export|default|spread|[\\[{}\\(,;:]|=>)$/.test(state.lastType) || state.lastType == \"quasi\" && /\\{\\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0)));\n    } // Interface\n\n\n    return {\n      startState: function (basecolumn) {\n        var state = {\n          tokenize: tokenBase,\n          lastType: \"sof\",\n          cc: [],\n          lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, \"block\", false),\n          localVars: parserConfig.localVars,\n          context: parserConfig.localVars && new Context(null, null, false),\n          indented: basecolumn || 0\n        };\n        if (parserConfig.globalVars && typeof parserConfig.globalVars == \"object\") state.globalVars = parserConfig.globalVars;\n        return state;\n      },\n      token: function (stream, state) {\n        if (stream.sol()) {\n          if (!state.lexical.hasOwnProperty(\"align\")) state.lexical.align = false;\n          state.indented = stream.indentation();\n          findFatArrow(stream, state);\n        }\n\n        if (state.tokenize != tokenComment && stream.eatSpace()) return null;\n        var style = state.tokenize(stream, state);\n        if (type == \"comment\") return style;\n        state.lastType = type == \"operator\" && (content == \"++\" || content == \"--\") ? \"incdec\" : type;\n        return parseJS(state, style, type, content, stream);\n      },\n      indent: function (state, textAfter) {\n        if (state.tokenize == tokenComment) return CodeMirror.Pass;\n        if (state.tokenize != tokenBase) return 0;\n        var firstChar = textAfter && textAfter.charAt(0),\n            lexical = state.lexical,\n            top; // Kludge to prevent 'maybelse' from blocking lexical scope pops\n\n        if (!/^\\s*else\\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {\n          var c = state.cc[i];\n          if (c == poplex) lexical = lexical.prev;else if (c != maybeelse) break;\n        }\n\n        while ((lexical.type == \"stat\" || lexical.type == \"form\") && (firstChar == \"}\" || (top = state.cc[state.cc.length - 1]) && (top == maybeoperatorComma || top == maybeoperatorNoComma) && !/^[,\\.=+\\-*:?[\\(]/.test(textAfter))) lexical = lexical.prev;\n\n        if (statementIndent && lexical.type == \")\" && lexical.prev.type == \"stat\") lexical = lexical.prev;\n        var type = lexical.type,\n            closing = firstChar == type;\n        if (type == \"vardef\") return lexical.indented + (state.lastType == \"operator\" || state.lastType == \",\" ? lexical.info.length + 1 : 0);else if (type == \"form\" && firstChar == \"{\") return lexical.indented;else if (type == \"form\") return lexical.indented + indentUnit;else if (type == \"stat\") return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0);else if (lexical.info == \"switch\" && !closing && parserConfig.doubleIndentSwitch != false) return lexical.indented + (/^(?:case|default)\\b/.test(textAfter) ? indentUnit : 2 * indentUnit);else if (lexical.align) return lexical.column + (closing ? 0 : 1);else return lexical.indented + (closing ? 0 : indentUnit);\n      },\n      electricInput: /^\\s*(?:case .*?:|default:|\\{|\\})$/,\n      blockCommentStart: jsonMode ? null : \"/*\",\n      blockCommentEnd: jsonMode ? null : \"*/\",\n      blockCommentContinue: jsonMode ? null : \" * \",\n      lineComment: jsonMode ? null : \"//\",\n      fold: \"brace\",\n      closeBrackets: \"()[]{}''\\\"\\\"``\",\n      helperType: jsonMode ? \"json\" : \"javascript\",\n      jsonldMode: jsonldMode,\n      jsonMode: jsonMode,\n      expressionAllowed: expressionAllowed,\n      skipExpression: function (state) {\n        var top = state.cc[state.cc.length - 1];\n        if (top == expression || top == expressionNoComma) state.cc.pop();\n      }\n    };\n  });\n  CodeMirror.registerHelper(\"wordChars\", \"javascript\", /[\\w$]/);\n  CodeMirror.defineMIME(\"text/javascript\", \"javascript\");\n  CodeMirror.defineMIME(\"text/ecmascript\", \"javascript\");\n  CodeMirror.defineMIME(\"application/javascript\", \"javascript\");\n  CodeMirror.defineMIME(\"application/x-javascript\", \"javascript\");\n  CodeMirror.defineMIME(\"application/ecmascript\", \"javascript\");\n  CodeMirror.defineMIME(\"application/json\", {\n    name: \"javascript\",\n    json: true\n  });\n  CodeMirror.defineMIME(\"application/x-json\", {\n    name: \"javascript\",\n    json: true\n  });\n  CodeMirror.defineMIME(\"application/ld+json\", {\n    name: \"javascript\",\n    jsonld: true\n  });\n  CodeMirror.defineMIME(\"text/typescript\", {\n    name: \"javascript\",\n    typescript: true\n  });\n  CodeMirror.defineMIME(\"application/typescript\", {\n    name: \"javascript\",\n    typescript: true\n  });\n});"

/***/ }),
/* 222 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(223))

/***/ }),
/* 223 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n// CodeMirror2 mode/perl/perl.js (text/x-perl) beta 0.10 (2011-11-08)\n// This is a part of CodeMirror from https://github.com/sabaca/CodeMirror_mode_perl (mail@sabaca.com)\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.defineMode(\"perl\", function () {\n    // http://perldoc.perl.org\n    var PERL = {\n      //   null - magic touch\n      //   1 - keyword\n      //   2 - def\n      //   3 - atom\n      //   4 - operator\n      //   5 - variable-2 (predefined)\n      //   [x,y] - x=1,2,3; y=must be defined if x{...}\n      //      PERL operators\n      '->': 4,\n      '++': 4,\n      '--': 4,\n      '**': 4,\n      //   ! ~ \\ and unary + and -\n      '=~': 4,\n      '!~': 4,\n      '*': 4,\n      '/': 4,\n      '%': 4,\n      'x': 4,\n      '+': 4,\n      '-': 4,\n      '.': 4,\n      '<<': 4,\n      '>>': 4,\n      //   named unary operators\n      '<': 4,\n      '>': 4,\n      '<=': 4,\n      '>=': 4,\n      'lt': 4,\n      'gt': 4,\n      'le': 4,\n      'ge': 4,\n      '==': 4,\n      '!=': 4,\n      '<=>': 4,\n      'eq': 4,\n      'ne': 4,\n      'cmp': 4,\n      '~~': 4,\n      '&': 4,\n      '|': 4,\n      '^': 4,\n      '&&': 4,\n      '||': 4,\n      '//': 4,\n      '..': 4,\n      '...': 4,\n      '?': 4,\n      ':': 4,\n      '=': 4,\n      '+=': 4,\n      '-=': 4,\n      '*=': 4,\n      //   etc. ???\n      ',': 4,\n      '=>': 4,\n      '::': 4,\n      //   list operators (rightward)\n      'not': 4,\n      'and': 4,\n      'or': 4,\n      'xor': 4,\n      //      PERL predefined variables (I know, what this is a paranoid idea, but may be needed for people, who learn PERL, and for me as well, ...and may be for you?;)\n      'BEGIN': [5, 1],\n      'END': [5, 1],\n      'PRINT': [5, 1],\n      'PRINTF': [5, 1],\n      'GETC': [5, 1],\n      'READ': [5, 1],\n      'READLINE': [5, 1],\n      'DESTROY': [5, 1],\n      'TIE': [5, 1],\n      'TIEHANDLE': [5, 1],\n      'UNTIE': [5, 1],\n      'STDIN': 5,\n      'STDIN_TOP': 5,\n      'STDOUT': 5,\n      'STDOUT_TOP': 5,\n      'STDERR': 5,\n      'STDERR_TOP': 5,\n      '$ARG': 5,\n      '$_': 5,\n      '@ARG': 5,\n      '@_': 5,\n      '$LIST_SEPARATOR': 5,\n      '$\"': 5,\n      '$PROCESS_ID': 5,\n      '$PID': 5,\n      '$$': 5,\n      '$REAL_GROUP_ID': 5,\n      '$GID': 5,\n      '$(': 5,\n      '$EFFECTIVE_GROUP_ID': 5,\n      '$EGID': 5,\n      '$)': 5,\n      '$PROGRAM_NAME': 5,\n      '$0': 5,\n      '$SUBSCRIPT_SEPARATOR': 5,\n      '$SUBSEP': 5,\n      '$;': 5,\n      '$REAL_USER_ID': 5,\n      '$UID': 5,\n      '$<': 5,\n      '$EFFECTIVE_USER_ID': 5,\n      '$EUID': 5,\n      '$>': 5,\n      '$a': 5,\n      '$b': 5,\n      '$COMPILING': 5,\n      '$^C': 5,\n      '$DEBUGGING': 5,\n      '$^D': 5,\n      '${^ENCODING}': 5,\n      '$ENV': 5,\n      '%ENV': 5,\n      '$SYSTEM_FD_MAX': 5,\n      '$^F': 5,\n      '@F': 5,\n      '${^GLOBAL_PHASE}': 5,\n      '$^H': 5,\n      '%^H': 5,\n      '@INC': 5,\n      '%INC': 5,\n      '$INPLACE_EDIT': 5,\n      '$^I': 5,\n      '$^M': 5,\n      '$OSNAME': 5,\n      '$^O': 5,\n      '${^OPEN}': 5,\n      '$PERLDB': 5,\n      '$^P': 5,\n      '$SIG': 5,\n      '%SIG': 5,\n      '$BASETIME': 5,\n      '$^T': 5,\n      '${^TAINT}': 5,\n      '${^UNICODE}': 5,\n      '${^UTF8CACHE}': 5,\n      '${^UTF8LOCALE}': 5,\n      '$PERL_VERSION': 5,\n      '$^V': 5,\n      '${^WIN32_SLOPPY_STAT}': 5,\n      '$EXECUTABLE_NAME': 5,\n      '$^X': 5,\n      '$1': 5,\n      // - regexp $1, $2...\n      '$MATCH': 5,\n      '$&': 5,\n      '${^MATCH}': 5,\n      '$PREMATCH': 5,\n      '$`': 5,\n      '${^PREMATCH}': 5,\n      '$POSTMATCH': 5,\n      \"$'\": 5,\n      '${^POSTMATCH}': 5,\n      '$LAST_PAREN_MATCH': 5,\n      '$+': 5,\n      '$LAST_SUBMATCH_RESULT': 5,\n      '$^N': 5,\n      '@LAST_MATCH_END': 5,\n      '@+': 5,\n      '%LAST_PAREN_MATCH': 5,\n      '%+': 5,\n      '@LAST_MATCH_START': 5,\n      '@-': 5,\n      '%LAST_MATCH_START': 5,\n      '%-': 5,\n      '$LAST_REGEXP_CODE_RESULT': 5,\n      '$^R': 5,\n      '${^RE_DEBUG_FLAGS}': 5,\n      '${^RE_TRIE_MAXBUF}': 5,\n      '$ARGV': 5,\n      '@ARGV': 5,\n      'ARGV': 5,\n      'ARGVOUT': 5,\n      '$OUTPUT_FIELD_SEPARATOR': 5,\n      '$OFS': 5,\n      '$,': 5,\n      '$INPUT_LINE_NUMBER': 5,\n      '$NR': 5,\n      '$.': 5,\n      '$INPUT_RECORD_SEPARATOR': 5,\n      '$RS': 5,\n      '$/': 5,\n      '$OUTPUT_RECORD_SEPARATOR': 5,\n      '$ORS': 5,\n      '$\\\\': 5,\n      '$OUTPUT_AUTOFLUSH': 5,\n      '$|': 5,\n      '$ACCUMULATOR': 5,\n      '$^A': 5,\n      '$FORMAT_FORMFEED': 5,\n      '$^L': 5,\n      '$FORMAT_PAGE_NUMBER': 5,\n      '$%': 5,\n      '$FORMAT_LINES_LEFT': 5,\n      '$-': 5,\n      '$FORMAT_LINE_BREAK_CHARACTERS': 5,\n      '$:': 5,\n      '$FORMAT_LINES_PER_PAGE': 5,\n      '$=': 5,\n      '$FORMAT_TOP_NAME': 5,\n      '$^': 5,\n      '$FORMAT_NAME': 5,\n      '$~': 5,\n      '${^CHILD_ERROR_NATIVE}': 5,\n      '$EXTENDED_OS_ERROR': 5,\n      '$^E': 5,\n      '$EXCEPTIONS_BEING_CAUGHT': 5,\n      '$^S': 5,\n      '$WARNING': 5,\n      '$^W': 5,\n      '${^WARNING_BITS}': 5,\n      '$OS_ERROR': 5,\n      '$ERRNO': 5,\n      '$!': 5,\n      '%OS_ERROR': 5,\n      '%ERRNO': 5,\n      '%!': 5,\n      '$CHILD_ERROR': 5,\n      '$?': 5,\n      '$EVAL_ERROR': 5,\n      '$@': 5,\n      '$OFMT': 5,\n      '$#': 5,\n      '$*': 5,\n      '$ARRAY_BASE': 5,\n      '$[': 5,\n      '$OLD_PERL_VERSION': 5,\n      '$]': 5,\n      //      PERL blocks\n      'if': [1, 1],\n      elsif: [1, 1],\n      'else': [1, 1],\n      'while': [1, 1],\n      unless: [1, 1],\n      'for': [1, 1],\n      foreach: [1, 1],\n      //      PERL functions\n      'abs': 1,\n      // - absolute value function\n      accept: 1,\n      // - accept an incoming socket connect\n      alarm: 1,\n      // - schedule a SIGALRM\n      'atan2': 1,\n      // - arctangent of Y/X in the range -PI to PI\n      bind: 1,\n      // - binds an address to a socket\n      binmode: 1,\n      // - prepare binary files for I/O\n      bless: 1,\n      // - create an object\n      bootstrap: 1,\n      //\n      'break': 1,\n      // - break out of a \"given\" block\n      caller: 1,\n      // - get context of the current subroutine call\n      chdir: 1,\n      // - change your current working directory\n      chmod: 1,\n      // - changes the permissions on a list of files\n      chomp: 1,\n      // - remove a trailing record separator from a string\n      chop: 1,\n      // - remove the last character from a string\n      chown: 1,\n      // - change the ownership on a list of files\n      chr: 1,\n      // - get character this number represents\n      chroot: 1,\n      // - make directory new root for path lookups\n      close: 1,\n      // - close file (or pipe or socket) handle\n      closedir: 1,\n      // - close directory handle\n      connect: 1,\n      // - connect to a remote socket\n      'continue': [1, 1],\n      // - optional trailing block in a while or foreach\n      'cos': 1,\n      // - cosine function\n      crypt: 1,\n      // - one-way passwd-style encryption\n      dbmclose: 1,\n      // - breaks binding on a tied dbm file\n      dbmopen: 1,\n      // - create binding on a tied dbm file\n      'default': 1,\n      //\n      defined: 1,\n      // - test whether a value, variable, or function is defined\n      'delete': 1,\n      // - deletes a value from a hash\n      die: 1,\n      // - raise an exception or bail out\n      'do': 1,\n      // - turn a BLOCK into a TERM\n      dump: 1,\n      // - create an immediate core dump\n      each: 1,\n      // - retrieve the next key/value pair from a hash\n      endgrent: 1,\n      // - be done using group file\n      endhostent: 1,\n      // - be done using hosts file\n      endnetent: 1,\n      // - be done using networks file\n      endprotoent: 1,\n      // - be done using protocols file\n      endpwent: 1,\n      // - be done using passwd file\n      endservent: 1,\n      // - be done using services file\n      eof: 1,\n      // - test a filehandle for its end\n      'eval': 1,\n      // - catch exceptions or compile and run code\n      'exec': 1,\n      // - abandon this program to run another\n      exists: 1,\n      // - test whether a hash key is present\n      exit: 1,\n      // - terminate this program\n      'exp': 1,\n      // - raise I to a power\n      fcntl: 1,\n      // - file control system call\n      fileno: 1,\n      // - return file descriptor from filehandle\n      flock: 1,\n      // - lock an entire file with an advisory lock\n      fork: 1,\n      // - create a new process just like this one\n      format: 1,\n      // - declare a picture format with use by the write() function\n      formline: 1,\n      // - internal function used for formats\n      getc: 1,\n      // - get the next character from the filehandle\n      getgrent: 1,\n      // - get next group record\n      getgrgid: 1,\n      // - get group record given group user ID\n      getgrnam: 1,\n      // - get group record given group name\n      gethostbyaddr: 1,\n      // - get host record given its address\n      gethostbyname: 1,\n      // - get host record given name\n      gethostent: 1,\n      // - get next hosts record\n      getlogin: 1,\n      // - return who logged in at this tty\n      getnetbyaddr: 1,\n      // - get network record given its address\n      getnetbyname: 1,\n      // - get networks record given name\n      getnetent: 1,\n      // - get next networks record\n      getpeername: 1,\n      // - find the other end of a socket connection\n      getpgrp: 1,\n      // - get process group\n      getppid: 1,\n      // - get parent process ID\n      getpriority: 1,\n      // - get current nice value\n      getprotobyname: 1,\n      // - get protocol record given name\n      getprotobynumber: 1,\n      // - get protocol record numeric protocol\n      getprotoent: 1,\n      // - get next protocols record\n      getpwent: 1,\n      // - get next passwd record\n      getpwnam: 1,\n      // - get passwd record given user login name\n      getpwuid: 1,\n      // - get passwd record given user ID\n      getservbyname: 1,\n      // - get services record given its name\n      getservbyport: 1,\n      // - get services record given numeric port\n      getservent: 1,\n      // - get next services record\n      getsockname: 1,\n      // - retrieve the sockaddr for a given socket\n      getsockopt: 1,\n      // - get socket options on a given socket\n      given: 1,\n      //\n      glob: 1,\n      // - expand filenames using wildcards\n      gmtime: 1,\n      // - convert UNIX time into record or string using Greenwich time\n      'goto': 1,\n      // - create spaghetti code\n      grep: 1,\n      // - locate elements in a list test true against a given criterion\n      hex: 1,\n      // - convert a string to a hexadecimal number\n      'import': 1,\n      // - patch a module's namespace into your own\n      index: 1,\n      // - find a substring within a string\n      'int': 1,\n      // - get the integer portion of a number\n      ioctl: 1,\n      // - system-dependent device control system call\n      'join': 1,\n      // - join a list into a string using a separator\n      keys: 1,\n      // - retrieve list of indices from a hash\n      kill: 1,\n      // - send a signal to a process or process group\n      last: 1,\n      // - exit a block prematurely\n      lc: 1,\n      // - return lower-case version of a string\n      lcfirst: 1,\n      // - return a string with just the next letter in lower case\n      length: 1,\n      // - return the number of bytes in a string\n      'link': 1,\n      // - create a hard link in the filesytem\n      listen: 1,\n      // - register your socket as a server\n      local: 2,\n      // - create a temporary value for a global variable (dynamic scoping)\n      localtime: 1,\n      // - convert UNIX time into record or string using local time\n      lock: 1,\n      // - get a thread lock on a variable, subroutine, or method\n      'log': 1,\n      // - retrieve the natural logarithm for a number\n      lstat: 1,\n      // - stat a symbolic link\n      m: null,\n      // - match a string with a regular expression pattern\n      map: 1,\n      // - apply a change to a list to get back a new list with the changes\n      mkdir: 1,\n      // - create a directory\n      msgctl: 1,\n      // - SysV IPC message control operations\n      msgget: 1,\n      // - get SysV IPC message queue\n      msgrcv: 1,\n      // - receive a SysV IPC message from a message queue\n      msgsnd: 1,\n      // - send a SysV IPC message to a message queue\n      my: 2,\n      // - declare and assign a local variable (lexical scoping)\n      'new': 1,\n      //\n      next: 1,\n      // - iterate a block prematurely\n      no: 1,\n      // - unimport some module symbols or semantics at compile time\n      oct: 1,\n      // - convert a string to an octal number\n      open: 1,\n      // - open a file, pipe, or descriptor\n      opendir: 1,\n      // - open a directory\n      ord: 1,\n      // - find a character's numeric representation\n      our: 2,\n      // - declare and assign a package variable (lexical scoping)\n      pack: 1,\n      // - convert a list into a binary representation\n      'package': 1,\n      // - declare a separate global namespace\n      pipe: 1,\n      // - open a pair of connected filehandles\n      pop: 1,\n      // - remove the last element from an array and return it\n      pos: 1,\n      // - find or set the offset for the last/next m//g search\n      print: 1,\n      // - output a list to a filehandle\n      printf: 1,\n      // - output a formatted list to a filehandle\n      prototype: 1,\n      // - get the prototype (if any) of a subroutine\n      push: 1,\n      // - append one or more elements to an array\n      q: null,\n      // - singly quote a string\n      qq: null,\n      // - doubly quote a string\n      qr: null,\n      // - Compile pattern\n      quotemeta: null,\n      // - quote regular expression magic characters\n      qw: null,\n      // - quote a list of words\n      qx: null,\n      // - backquote quote a string\n      rand: 1,\n      // - retrieve the next pseudorandom number\n      read: 1,\n      // - fixed-length buffered input from a filehandle\n      readdir: 1,\n      // - get a directory from a directory handle\n      readline: 1,\n      // - fetch a record from a file\n      readlink: 1,\n      // - determine where a symbolic link is pointing\n      readpipe: 1,\n      // - execute a system command and collect standard output\n      recv: 1,\n      // - receive a message over a Socket\n      redo: 1,\n      // - start this loop iteration over again\n      ref: 1,\n      // - find out the type of thing being referenced\n      rename: 1,\n      // - change a filename\n      require: 1,\n      // - load in external functions from a library at runtime\n      reset: 1,\n      // - clear all variables of a given name\n      'return': 1,\n      // - get out of a function early\n      reverse: 1,\n      // - flip a string or a list\n      rewinddir: 1,\n      // - reset directory handle\n      rindex: 1,\n      // - right-to-left substring search\n      rmdir: 1,\n      // - remove a directory\n      s: null,\n      // - replace a pattern with a string\n      say: 1,\n      // - print with newline\n      scalar: 1,\n      // - force a scalar context\n      seek: 1,\n      // - reposition file pointer for random-access I/O\n      seekdir: 1,\n      // - reposition directory pointer\n      select: 1,\n      // - reset default output or do I/O multiplexing\n      semctl: 1,\n      // - SysV semaphore control operations\n      semget: 1,\n      // - get set of SysV semaphores\n      semop: 1,\n      // - SysV semaphore operations\n      send: 1,\n      // - send a message over a socket\n      setgrent: 1,\n      // - prepare group file for use\n      sethostent: 1,\n      // - prepare hosts file for use\n      setnetent: 1,\n      // - prepare networks file for use\n      setpgrp: 1,\n      // - set the process group of a process\n      setpriority: 1,\n      // - set a process's nice value\n      setprotoent: 1,\n      // - prepare protocols file for use\n      setpwent: 1,\n      // - prepare passwd file for use\n      setservent: 1,\n      // - prepare services file for use\n      setsockopt: 1,\n      // - set some socket options\n      shift: 1,\n      // - remove the first element of an array, and return it\n      shmctl: 1,\n      // - SysV shared memory operations\n      shmget: 1,\n      // - get SysV shared memory segment identifier\n      shmread: 1,\n      // - read SysV shared memory\n      shmwrite: 1,\n      // - write SysV shared memory\n      shutdown: 1,\n      // - close down just half of a socket connection\n      'sin': 1,\n      // - return the sine of a number\n      sleep: 1,\n      // - block for some number of seconds\n      socket: 1,\n      // - create a socket\n      socketpair: 1,\n      // - create a pair of sockets\n      'sort': 1,\n      // - sort a list of values\n      splice: 1,\n      // - add or remove elements anywhere in an array\n      'split': 1,\n      // - split up a string using a regexp delimiter\n      sprintf: 1,\n      // - formatted print into a string\n      'sqrt': 1,\n      // - square root function\n      srand: 1,\n      // - seed the random number generator\n      stat: 1,\n      // - get a file's status information\n      state: 1,\n      // - declare and assign a state variable (persistent lexical scoping)\n      study: 1,\n      // - optimize input data for repeated searches\n      'sub': 1,\n      // - declare a subroutine, possibly anonymously\n      'substr': 1,\n      // - get or alter a portion of a stirng\n      symlink: 1,\n      // - create a symbolic link to a file\n      syscall: 1,\n      // - execute an arbitrary system call\n      sysopen: 1,\n      // - open a file, pipe, or descriptor\n      sysread: 1,\n      // - fixed-length unbuffered input from a filehandle\n      sysseek: 1,\n      // - position I/O pointer on handle used with sysread and syswrite\n      system: 1,\n      // - run a separate program\n      syswrite: 1,\n      // - fixed-length unbuffered output to a filehandle\n      tell: 1,\n      // - get current seekpointer on a filehandle\n      telldir: 1,\n      // - get current seekpointer on a directory handle\n      tie: 1,\n      // - bind a variable to an object class\n      tied: 1,\n      // - get a reference to the object underlying a tied variable\n      time: 1,\n      // - return number of seconds since 1970\n      times: 1,\n      // - return elapsed time for self and child processes\n      tr: null,\n      // - transliterate a string\n      truncate: 1,\n      // - shorten a file\n      uc: 1,\n      // - return upper-case version of a string\n      ucfirst: 1,\n      // - return a string with just the next letter in upper case\n      umask: 1,\n      // - set file creation mode mask\n      undef: 1,\n      // - remove a variable or function definition\n      unlink: 1,\n      // - remove one link to a file\n      unpack: 1,\n      // - convert binary structure into normal perl variables\n      unshift: 1,\n      // - prepend more elements to the beginning of a list\n      untie: 1,\n      // - break a tie binding to a variable\n      use: 1,\n      // - load in a module at compile time\n      utime: 1,\n      // - set a file's last access and modify times\n      values: 1,\n      // - return a list of the values in a hash\n      vec: 1,\n      // - test or set particular bits in a string\n      wait: 1,\n      // - wait for any child process to die\n      waitpid: 1,\n      // - wait for a particular child process to die\n      wantarray: 1,\n      // - get void vs scalar vs list context of current subroutine call\n      warn: 1,\n      // - print debugging info\n      when: 1,\n      //\n      write: 1,\n      // - print a picture record\n      y: null\n    }; // - transliterate a string\n\n    var RXstyle = \"string-2\";\n    var RXmodifiers = /[goseximacplud]/; // NOTE: \"m\", \"s\", \"y\" and \"tr\" need to correct real modifiers for each regexp type\n\n    function tokenChain(stream, state, chain, style, tail) {\n      // NOTE: chain.length > 2 is not working now (it's for s[...][...]geos;)\n      state.chain = null; //                                                          12   3tail\n\n      state.style = null;\n      state.tail = null;\n\n      state.tokenize = function (stream, state) {\n        var e = false,\n            c,\n            i = 0;\n\n        while (c = stream.next()) {\n          if (c === chain[i] && !e) {\n            if (chain[++i] !== undefined) {\n              state.chain = chain[i];\n              state.style = style;\n              state.tail = tail;\n            } else if (tail) stream.eatWhile(tail);\n\n            state.tokenize = tokenPerl;\n            return style;\n          }\n\n          e = !e && c == \"\\\\\";\n        }\n\n        return style;\n      };\n\n      return state.tokenize(stream, state);\n    }\n\n    function tokenSOMETHING(stream, state, string) {\n      state.tokenize = function (stream, state) {\n        if (stream.string == string) state.tokenize = tokenPerl;\n        stream.skipToEnd();\n        return \"string\";\n      };\n\n      return state.tokenize(stream, state);\n    }\n\n    function tokenPerl(stream, state) {\n      if (stream.eatSpace()) return null;\n      if (state.chain) return tokenChain(stream, state, state.chain, state.style, state.tail);\n      if (stream.match(/^\\-?[\\d\\.]/, false)) if (stream.match(/^(\\-?(\\d*\\.\\d+(e[+-]?\\d+)?|\\d+\\.\\d*)|0x[\\da-fA-F]+|0b[01]+|\\d+(e[+-]?\\d+)?)/)) return 'number';\n\n      if (stream.match(/^<<(?=\\w)/)) {\n        // NOTE: <<SOMETHING\\n...\\nSOMETHING\\n\n        stream.eatWhile(/\\w/);\n        return tokenSOMETHING(stream, state, stream.current().substr(2));\n      }\n\n      if (stream.sol() && stream.match(/^\\=item(?!\\w)/)) {\n        // NOTE: \\n=item...\\n=cut\\n\n        return tokenSOMETHING(stream, state, '=cut');\n      }\n\n      var ch = stream.next();\n\n      if (ch == '\"' || ch == \"'\") {\n        // NOTE: ' or \" or <<'SOMETHING'\\n...\\nSOMETHING\\n or <<\"SOMETHING\"\\n...\\nSOMETHING\\n\n        if (prefix(stream, 3) == \"<<\" + ch) {\n          var p = stream.pos;\n          stream.eatWhile(/\\w/);\n          var n = stream.current().substr(1);\n          if (n && stream.eat(ch)) return tokenSOMETHING(stream, state, n);\n          stream.pos = p;\n        }\n\n        return tokenChain(stream, state, [ch], \"string\");\n      }\n\n      if (ch == \"q\") {\n        var c = look(stream, -2);\n\n        if (!(c && /\\w/.test(c))) {\n          c = look(stream, 0);\n\n          if (c == \"x\") {\n            c = look(stream, 1);\n\n            if (c == \"(\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\")\"], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"[\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\"]\"], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"{\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\"}\"], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"<\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\">\"], RXstyle, RXmodifiers);\n            }\n\n            if (/[\\^'\"!~\\/]/.test(c)) {\n              eatSuffix(stream, 1);\n              return tokenChain(stream, state, [stream.eat(c)], RXstyle, RXmodifiers);\n            }\n          } else if (c == \"q\") {\n            c = look(stream, 1);\n\n            if (c == \"(\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\")\"], \"string\");\n            }\n\n            if (c == \"[\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\"]\"], \"string\");\n            }\n\n            if (c == \"{\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\"}\"], \"string\");\n            }\n\n            if (c == \"<\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\">\"], \"string\");\n            }\n\n            if (/[\\^'\"!~\\/]/.test(c)) {\n              eatSuffix(stream, 1);\n              return tokenChain(stream, state, [stream.eat(c)], \"string\");\n            }\n          } else if (c == \"w\") {\n            c = look(stream, 1);\n\n            if (c == \"(\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\")\"], \"bracket\");\n            }\n\n            if (c == \"[\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\"]\"], \"bracket\");\n            }\n\n            if (c == \"{\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\"}\"], \"bracket\");\n            }\n\n            if (c == \"<\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\">\"], \"bracket\");\n            }\n\n            if (/[\\^'\"!~\\/]/.test(c)) {\n              eatSuffix(stream, 1);\n              return tokenChain(stream, state, [stream.eat(c)], \"bracket\");\n            }\n          } else if (c == \"r\") {\n            c = look(stream, 1);\n\n            if (c == \"(\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\")\"], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"[\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\"]\"], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"{\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\"}\"], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"<\") {\n              eatSuffix(stream, 2);\n              return tokenChain(stream, state, [\">\"], RXstyle, RXmodifiers);\n            }\n\n            if (/[\\^'\"!~\\/]/.test(c)) {\n              eatSuffix(stream, 1);\n              return tokenChain(stream, state, [stream.eat(c)], RXstyle, RXmodifiers);\n            }\n          } else if (/[\\^'\"!~\\/(\\[{<]/.test(c)) {\n            if (c == \"(\") {\n              eatSuffix(stream, 1);\n              return tokenChain(stream, state, [\")\"], \"string\");\n            }\n\n            if (c == \"[\") {\n              eatSuffix(stream, 1);\n              return tokenChain(stream, state, [\"]\"], \"string\");\n            }\n\n            if (c == \"{\") {\n              eatSuffix(stream, 1);\n              return tokenChain(stream, state, [\"}\"], \"string\");\n            }\n\n            if (c == \"<\") {\n              eatSuffix(stream, 1);\n              return tokenChain(stream, state, [\">\"], \"string\");\n            }\n\n            if (/[\\^'\"!~\\/]/.test(c)) {\n              return tokenChain(stream, state, [stream.eat(c)], \"string\");\n            }\n          }\n        }\n      }\n\n      if (ch == \"m\") {\n        var c = look(stream, -2);\n\n        if (!(c && /\\w/.test(c))) {\n          c = stream.eat(/[(\\[{<\\^'\"!~\\/]/);\n\n          if (c) {\n            if (/[\\^'\"!~\\/]/.test(c)) {\n              return tokenChain(stream, state, [c], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"(\") {\n              return tokenChain(stream, state, [\")\"], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"[\") {\n              return tokenChain(stream, state, [\"]\"], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"{\") {\n              return tokenChain(stream, state, [\"}\"], RXstyle, RXmodifiers);\n            }\n\n            if (c == \"<\") {\n              return tokenChain(stream, state, [\">\"], RXstyle, RXmodifiers);\n            }\n          }\n        }\n      }\n\n      if (ch == \"s\") {\n        var c = /[\\/>\\]})\\w]/.test(look(stream, -2));\n\n        if (!c) {\n          c = stream.eat(/[(\\[{<\\^'\"!~\\/]/);\n\n          if (c) {\n            if (c == \"[\") return tokenChain(stream, state, [\"]\", \"]\"], RXstyle, RXmodifiers);\n            if (c == \"{\") return tokenChain(stream, state, [\"}\", \"}\"], RXstyle, RXmodifiers);\n            if (c == \"<\") return tokenChain(stream, state, [\">\", \">\"], RXstyle, RXmodifiers);\n            if (c == \"(\") return tokenChain(stream, state, [\")\", \")\"], RXstyle, RXmodifiers);\n            return tokenChain(stream, state, [c, c], RXstyle, RXmodifiers);\n          }\n        }\n      }\n\n      if (ch == \"y\") {\n        var c = /[\\/>\\]})\\w]/.test(look(stream, -2));\n\n        if (!c) {\n          c = stream.eat(/[(\\[{<\\^'\"!~\\/]/);\n\n          if (c) {\n            if (c == \"[\") return tokenChain(stream, state, [\"]\", \"]\"], RXstyle, RXmodifiers);\n            if (c == \"{\") return tokenChain(stream, state, [\"}\", \"}\"], RXstyle, RXmodifiers);\n            if (c == \"<\") return tokenChain(stream, state, [\">\", \">\"], RXstyle, RXmodifiers);\n            if (c == \"(\") return tokenChain(stream, state, [\")\", \")\"], RXstyle, RXmodifiers);\n            return tokenChain(stream, state, [c, c], RXstyle, RXmodifiers);\n          }\n        }\n      }\n\n      if (ch == \"t\") {\n        var c = /[\\/>\\]})\\w]/.test(look(stream, -2));\n\n        if (!c) {\n          c = stream.eat(\"r\");\n\n          if (c) {\n            c = stream.eat(/[(\\[{<\\^'\"!~\\/]/);\n\n            if (c) {\n              if (c == \"[\") return tokenChain(stream, state, [\"]\", \"]\"], RXstyle, RXmodifiers);\n              if (c == \"{\") return tokenChain(stream, state, [\"}\", \"}\"], RXstyle, RXmodifiers);\n              if (c == \"<\") return tokenChain(stream, state, [\">\", \">\"], RXstyle, RXmodifiers);\n              if (c == \"(\") return tokenChain(stream, state, [\")\", \")\"], RXstyle, RXmodifiers);\n              return tokenChain(stream, state, [c, c], RXstyle, RXmodifiers);\n            }\n          }\n        }\n      }\n\n      if (ch == \"`\") {\n        return tokenChain(stream, state, [ch], \"variable-2\");\n      }\n\n      if (ch == \"/\") {\n        if (!/~\\s*$/.test(prefix(stream))) return \"operator\";else return tokenChain(stream, state, [ch], RXstyle, RXmodifiers);\n      }\n\n      if (ch == \"$\") {\n        var p = stream.pos;\n        if (stream.eatWhile(/\\d/) || stream.eat(\"{\") && stream.eatWhile(/\\d/) && stream.eat(\"}\")) return \"variable-2\";else stream.pos = p;\n      }\n\n      if (/[$@%]/.test(ch)) {\n        var p = stream.pos;\n\n        if (stream.eat(\"^\") && stream.eat(/[A-Z]/) || !/[@$%&]/.test(look(stream, -2)) && stream.eat(/[=|\\\\\\-#?@;:&`~\\^!\\[\\]*'\"$+.,\\/<>()]/)) {\n          var c = stream.current();\n          if (PERL[c]) return \"variable-2\";\n        }\n\n        stream.pos = p;\n      }\n\n      if (/[$@%&]/.test(ch)) {\n        if (stream.eatWhile(/[\\w$\\[\\]]/) || stream.eat(\"{\") && stream.eatWhile(/[\\w$\\[\\]]/) && stream.eat(\"}\")) {\n          var c = stream.current();\n          if (PERL[c]) return \"variable-2\";else return \"variable\";\n        }\n      }\n\n      if (ch == \"#\") {\n        if (look(stream, -2) != \"$\") {\n          stream.skipToEnd();\n          return \"comment\";\n        }\n      }\n\n      if (/[:+\\-\\^*$&%@=<>!?|\\/~\\.]/.test(ch)) {\n        var p = stream.pos;\n        stream.eatWhile(/[:+\\-\\^*$&%@=<>!?|\\/~\\.]/);\n        if (PERL[stream.current()]) return \"operator\";else stream.pos = p;\n      }\n\n      if (ch == \"_\") {\n        if (stream.pos == 1) {\n          if (suffix(stream, 6) == \"_END__\") {\n            return tokenChain(stream, state, ['\\0'], \"comment\");\n          } else if (suffix(stream, 7) == \"_DATA__\") {\n            return tokenChain(stream, state, ['\\0'], \"variable-2\");\n          } else if (suffix(stream, 7) == \"_C__\") {\n            return tokenChain(stream, state, ['\\0'], \"string\");\n          }\n        }\n      }\n\n      if (/\\w/.test(ch)) {\n        var p = stream.pos;\n        if (look(stream, -2) == \"{\" && (look(stream, 0) == \"}\" || stream.eatWhile(/\\w/) && look(stream, 0) == \"}\")) return \"string\";else stream.pos = p;\n      }\n\n      if (/[A-Z]/.test(ch)) {\n        var l = look(stream, -2);\n        var p = stream.pos;\n        stream.eatWhile(/[A-Z_]/);\n\n        if (/[\\da-z]/.test(look(stream, 0))) {\n          stream.pos = p;\n        } else {\n          var c = PERL[stream.current()];\n          if (!c) return \"meta\";\n          if (c[1]) c = c[0];\n\n          if (l != \":\") {\n            if (c == 1) return \"keyword\";else if (c == 2) return \"def\";else if (c == 3) return \"atom\";else if (c == 4) return \"operator\";else if (c == 5) return \"variable-2\";else return \"meta\";\n          } else return \"meta\";\n        }\n      }\n\n      if (/[a-zA-Z_]/.test(ch)) {\n        var l = look(stream, -2);\n        stream.eatWhile(/\\w/);\n        var c = PERL[stream.current()];\n        if (!c) return \"meta\";\n        if (c[1]) c = c[0];\n\n        if (l != \":\") {\n          if (c == 1) return \"keyword\";else if (c == 2) return \"def\";else if (c == 3) return \"atom\";else if (c == 4) return \"operator\";else if (c == 5) return \"variable-2\";else return \"meta\";\n        } else return \"meta\";\n      }\n\n      return null;\n    }\n\n    return {\n      startState: function () {\n        return {\n          tokenize: tokenPerl,\n          chain: null,\n          style: null,\n          tail: null\n        };\n      },\n      token: function (stream, state) {\n        return (state.tokenize || tokenPerl)(stream, state);\n      },\n      lineComment: '#'\n    };\n  });\n  CodeMirror.registerHelper(\"wordChars\", \"perl\", /[\\w$]/);\n  CodeMirror.defineMIME(\"text/x-perl\", \"perl\"); // it's like \"peek\", but need for look-ahead or look-behind if index < 0\n\n  function look(stream, c) {\n    return stream.string.charAt(stream.pos + (c || 0));\n  } // return a part of prefix of current stream from current position\n\n\n  function prefix(stream, c) {\n    if (c) {\n      var x = stream.pos - c;\n      return stream.string.substr(x >= 0 ? x : 0, c);\n    } else {\n      return stream.string.substr(0, stream.pos - 1);\n    }\n  } // return a part of suffix of current stream from current position\n\n\n  function suffix(stream, c) {\n    var y = stream.string.length;\n    var x = y - stream.pos + 1;\n    return stream.string.substr(stream.pos, c && c < y ? c : x);\n  } // eating and vomiting a part of stream from current position\n\n\n  function eatSuffix(stream, c) {\n    var x = stream.pos + c;\n    var y;\n    if (x <= 0) stream.pos = 0;else if (x >= (y = stream.string.length - 1)) stream.pos = y;else stream.pos = x;\n  }\n});"

/***/ }),
/* 224 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(225))

/***/ }),
/* 225 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  function wordRegexp(words) {\n    return new RegExp(\"^((\" + words.join(\")|(\") + \"))\\\\b\");\n  }\n\n  var wordOperators = wordRegexp([\"and\", \"or\", \"not\", \"is\"]);\n  var commonKeywords = [\"as\", \"assert\", \"break\", \"class\", \"continue\", \"def\", \"del\", \"elif\", \"else\", \"except\", \"finally\", \"for\", \"from\", \"global\", \"if\", \"import\", \"lambda\", \"pass\", \"raise\", \"return\", \"try\", \"while\", \"with\", \"yield\", \"in\"];\n  var commonBuiltins = [\"abs\", \"all\", \"any\", \"bin\", \"bool\", \"bytearray\", \"callable\", \"chr\", \"classmethod\", \"compile\", \"complex\", \"delattr\", \"dict\", \"dir\", \"divmod\", \"enumerate\", \"eval\", \"filter\", \"float\", \"format\", \"frozenset\", \"getattr\", \"globals\", \"hasattr\", \"hash\", \"help\", \"hex\", \"id\", \"input\", \"int\", \"isinstance\", \"issubclass\", \"iter\", \"len\", \"list\", \"locals\", \"map\", \"max\", \"memoryview\", \"min\", \"next\", \"object\", \"oct\", \"open\", \"ord\", \"pow\", \"property\", \"range\", \"repr\", \"reversed\", \"round\", \"set\", \"setattr\", \"slice\", \"sorted\", \"staticmethod\", \"str\", \"sum\", \"super\", \"tuple\", \"type\", \"vars\", \"zip\", \"__import__\", \"NotImplemented\", \"Ellipsis\", \"__debug__\"];\n  CodeMirror.registerHelper(\"hintWords\", \"python\", commonKeywords.concat(commonBuiltins));\n\n  function top(state) {\n    return state.scopes[state.scopes.length - 1];\n  }\n\n  CodeMirror.defineMode(\"python\", function (conf, parserConf) {\n    var ERRORCLASS = \"error\";\n    var delimiters = parserConf.delimiters || parserConf.singleDelimiters || /^[\\(\\)\\[\\]\\{\\}@,:`=;\\.\\\\]/; //               (Backwards-compatibility with old, cumbersome config system)\n\n    var operators = [parserConf.singleOperators, parserConf.doubleOperators, parserConf.doubleDelimiters, parserConf.tripleDelimiters, parserConf.operators || /^([-+*/%\\/&|^]=?|[<>=]+|\\/\\/=?|\\*\\*=?|!=|[~!@]|\\.\\.\\.)/];\n\n    for (var i = 0; i < operators.length; i++) if (!operators[i]) operators.splice(i--, 1);\n\n    var hangingIndent = parserConf.hangingIndent || conf.indentUnit;\n    var myKeywords = commonKeywords,\n        myBuiltins = commonBuiltins;\n    if (parserConf.extra_keywords != undefined) myKeywords = myKeywords.concat(parserConf.extra_keywords);\n    if (parserConf.extra_builtins != undefined) myBuiltins = myBuiltins.concat(parserConf.extra_builtins);\n    var py3 = !(parserConf.version && Number(parserConf.version) < 3);\n\n    if (py3) {\n      // since http://legacy.python.org/dev/peps/pep-0465/ @ is also an operator\n      var identifiers = parserConf.identifiers || /^[_A-Za-z\\u00A1-\\uFFFF][_A-Za-z0-9\\u00A1-\\uFFFF]*/;\n      myKeywords = myKeywords.concat([\"nonlocal\", \"False\", \"True\", \"None\", \"async\", \"await\"]);\n      myBuiltins = myBuiltins.concat([\"ascii\", \"bytes\", \"exec\", \"print\"]);\n      var stringPrefixes = new RegExp(\"^(([rbuf]|(br)|(fr))?('{3}|\\\"{3}|['\\\"]))\", \"i\");\n    } else {\n      var identifiers = parserConf.identifiers || /^[_A-Za-z][_A-Za-z0-9]*/;\n      myKeywords = myKeywords.concat([\"exec\", \"print\"]);\n      myBuiltins = myBuiltins.concat([\"apply\", \"basestring\", \"buffer\", \"cmp\", \"coerce\", \"execfile\", \"file\", \"intern\", \"long\", \"raw_input\", \"reduce\", \"reload\", \"unichr\", \"unicode\", \"xrange\", \"False\", \"True\", \"None\"]);\n      var stringPrefixes = new RegExp(\"^(([rubf]|(ur)|(br))?('{3}|\\\"{3}|['\\\"]))\", \"i\");\n    }\n\n    var keywords = wordRegexp(myKeywords);\n    var builtins = wordRegexp(myBuiltins); // tokenizers\n\n    function tokenBase(stream, state) {\n      var sol = stream.sol() && state.lastToken != \"\\\\\";\n      if (sol) state.indent = stream.indentation(); // Handle scope changes\n\n      if (sol && top(state).type == \"py\") {\n        var scopeOffset = top(state).offset;\n\n        if (stream.eatSpace()) {\n          var lineOffset = stream.indentation();\n          if (lineOffset > scopeOffset) pushPyScope(state);else if (lineOffset < scopeOffset && dedent(stream, state) && stream.peek() != \"#\") state.errorToken = true;\n          return null;\n        } else {\n          var style = tokenBaseInner(stream, state);\n          if (scopeOffset > 0 && dedent(stream, state)) style += \" \" + ERRORCLASS;\n          return style;\n        }\n      }\n\n      return tokenBaseInner(stream, state);\n    }\n\n    function tokenBaseInner(stream, state, inFormat) {\n      if (stream.eatSpace()) return null; // Handle Comments\n\n      if (!inFormat && stream.match(/^#.*/)) return \"comment\"; // Handle Number Literals\n\n      if (stream.match(/^[0-9\\.]/, false)) {\n        var floatLiteral = false; // Floats\n\n        if (stream.match(/^[\\d_]*\\.\\d+(e[\\+\\-]?\\d+)?/i)) {\n          floatLiteral = true;\n        }\n\n        if (stream.match(/^[\\d_]+\\.\\d*/)) {\n          floatLiteral = true;\n        }\n\n        if (stream.match(/^\\.\\d+/)) {\n          floatLiteral = true;\n        }\n\n        if (floatLiteral) {\n          // Float literals may be \"imaginary\"\n          stream.eat(/J/i);\n          return \"number\";\n        } // Integers\n\n\n        var intLiteral = false; // Hex\n\n        if (stream.match(/^0x[0-9a-f_]+/i)) intLiteral = true; // Binary\n\n        if (stream.match(/^0b[01_]+/i)) intLiteral = true; // Octal\n\n        if (stream.match(/^0o[0-7_]+/i)) intLiteral = true; // Decimal\n\n        if (stream.match(/^[1-9][\\d_]*(e[\\+\\-]?[\\d_]+)?/)) {\n          // Decimal literals may be \"imaginary\"\n          stream.eat(/J/i); // TODO - Can you have imaginary longs?\n\n          intLiteral = true;\n        } // Zero by itself with no other piece of number.\n\n\n        if (stream.match(/^0(?![\\dx])/i)) intLiteral = true;\n\n        if (intLiteral) {\n          // Integer literals may be \"long\"\n          stream.eat(/L/i);\n          return \"number\";\n        }\n      } // Handle Strings\n\n\n      if (stream.match(stringPrefixes)) {\n        var isFmtString = stream.current().toLowerCase().indexOf('f') !== -1;\n\n        if (!isFmtString) {\n          state.tokenize = tokenStringFactory(stream.current(), state.tokenize);\n          return state.tokenize(stream, state);\n        } else {\n          state.tokenize = formatStringFactory(stream.current(), state.tokenize);\n          return state.tokenize(stream, state);\n        }\n      }\n\n      for (var i = 0; i < operators.length; i++) if (stream.match(operators[i])) return \"operator\";\n\n      if (stream.match(delimiters)) return \"punctuation\";\n      if (state.lastToken == \".\" && stream.match(identifiers)) return \"property\";\n      if (stream.match(keywords) || stream.match(wordOperators)) return \"keyword\";\n      if (stream.match(builtins)) return \"builtin\";\n      if (stream.match(/^(self|cls)\\b/)) return \"variable-2\";\n\n      if (stream.match(identifiers)) {\n        if (state.lastToken == \"def\" || state.lastToken == \"class\") return \"def\";\n        return \"variable\";\n      } // Handle non-detected items\n\n\n      stream.next();\n      return inFormat ? null : ERRORCLASS;\n    }\n\n    function formatStringFactory(delimiter, tokenOuter) {\n      while (\"rubf\".indexOf(delimiter.charAt(0).toLowerCase()) >= 0) delimiter = delimiter.substr(1);\n\n      var singleline = delimiter.length == 1;\n      var OUTCLASS = \"string\";\n\n      function tokenNestedExpr(depth) {\n        return function (stream, state) {\n          var inner = tokenBaseInner(stream, state, true);\n\n          if (inner == \"punctuation\") {\n            if (stream.current() == \"{\") {\n              state.tokenize = tokenNestedExpr(depth + 1);\n            } else if (stream.current() == \"}\") {\n              if (depth > 1) state.tokenize = tokenNestedExpr(depth - 1);else state.tokenize = tokenString;\n            }\n          }\n\n          return inner;\n        };\n      }\n\n      function tokenString(stream, state) {\n        while (!stream.eol()) {\n          stream.eatWhile(/[^'\"\\{\\}\\\\]/);\n\n          if (stream.eat(\"\\\\\")) {\n            stream.next();\n            if (singleline && stream.eol()) return OUTCLASS;\n          } else if (stream.match(delimiter)) {\n            state.tokenize = tokenOuter;\n            return OUTCLASS;\n          } else if (stream.match('{{')) {\n            // ignore {{ in f-str\n            return OUTCLASS;\n          } else if (stream.match('{', false)) {\n            // switch to nested mode\n            state.tokenize = tokenNestedExpr(0);\n            if (stream.current()) return OUTCLASS;else return state.tokenize(stream, state);\n          } else if (stream.match('}}')) {\n            return OUTCLASS;\n          } else if (stream.match('}')) {\n            // single } in f-string is an error\n            return ERRORCLASS;\n          } else {\n            stream.eat(/['\"]/);\n          }\n        }\n\n        if (singleline) {\n          if (parserConf.singleLineStringErrors) return ERRORCLASS;else state.tokenize = tokenOuter;\n        }\n\n        return OUTCLASS;\n      }\n\n      tokenString.isString = true;\n      return tokenString;\n    }\n\n    function tokenStringFactory(delimiter, tokenOuter) {\n      while (\"rubf\".indexOf(delimiter.charAt(0).toLowerCase()) >= 0) delimiter = delimiter.substr(1);\n\n      var singleline = delimiter.length == 1;\n      var OUTCLASS = \"string\";\n\n      function tokenString(stream, state) {\n        while (!stream.eol()) {\n          stream.eatWhile(/[^'\"\\\\]/);\n\n          if (stream.eat(\"\\\\\")) {\n            stream.next();\n            if (singleline && stream.eol()) return OUTCLASS;\n          } else if (stream.match(delimiter)) {\n            state.tokenize = tokenOuter;\n            return OUTCLASS;\n          } else {\n            stream.eat(/['\"]/);\n          }\n        }\n\n        if (singleline) {\n          if (parserConf.singleLineStringErrors) return ERRORCLASS;else state.tokenize = tokenOuter;\n        }\n\n        return OUTCLASS;\n      }\n\n      tokenString.isString = true;\n      return tokenString;\n    }\n\n    function pushPyScope(state) {\n      while (top(state).type != \"py\") state.scopes.pop();\n\n      state.scopes.push({\n        offset: top(state).offset + conf.indentUnit,\n        type: \"py\",\n        align: null\n      });\n    }\n\n    function pushBracketScope(stream, state, type) {\n      var align = stream.match(/^([\\s\\[\\{\\(]|#.*)*$/, false) ? null : stream.column() + 1;\n      state.scopes.push({\n        offset: state.indent + hangingIndent,\n        type: type,\n        align: align\n      });\n    }\n\n    function dedent(stream, state) {\n      var indented = stream.indentation();\n\n      while (state.scopes.length > 1 && top(state).offset > indented) {\n        if (top(state).type != \"py\") return true;\n        state.scopes.pop();\n      }\n\n      return top(state).offset != indented;\n    }\n\n    function tokenLexer(stream, state) {\n      if (stream.sol()) state.beginningOfLine = true;\n      var style = state.tokenize(stream, state);\n      var current = stream.current(); // Handle decorators\n\n      if (state.beginningOfLine && current == \"@\") return stream.match(identifiers, false) ? \"meta\" : py3 ? \"operator\" : ERRORCLASS;\n      if (/\\S/.test(current)) state.beginningOfLine = false;\n      if ((style == \"variable\" || style == \"builtin\") && state.lastToken == \"meta\") style = \"meta\"; // Handle scope changes.\n\n      if (current == \"pass\" || current == \"return\") state.dedent += 1;\n      if (current == \"lambda\") state.lambda = true;\n      if (current == \":\" && !state.lambda && top(state).type == \"py\") pushPyScope(state);\n\n      if (current.length == 1 && !/string|comment/.test(style)) {\n        var delimiter_index = \"[({\".indexOf(current);\n        if (delimiter_index != -1) pushBracketScope(stream, state, \"])}\".slice(delimiter_index, delimiter_index + 1));\n        delimiter_index = \"])}\".indexOf(current);\n\n        if (delimiter_index != -1) {\n          if (top(state).type == current) state.indent = state.scopes.pop().offset - hangingIndent;else return ERRORCLASS;\n        }\n      }\n\n      if (state.dedent > 0 && stream.eol() && top(state).type == \"py\") {\n        if (state.scopes.length > 1) state.scopes.pop();\n        state.dedent -= 1;\n      }\n\n      return style;\n    }\n\n    var external = {\n      startState: function (basecolumn) {\n        return {\n          tokenize: tokenBase,\n          scopes: [{\n            offset: basecolumn || 0,\n            type: \"py\",\n            align: null\n          }],\n          indent: basecolumn || 0,\n          lastToken: null,\n          lambda: false,\n          dedent: 0\n        };\n      },\n      token: function (stream, state) {\n        var addErr = state.errorToken;\n        if (addErr) state.errorToken = false;\n        var style = tokenLexer(stream, state);\n        if (style && style != \"comment\") state.lastToken = style == \"keyword\" || style == \"punctuation\" ? stream.current() : style;\n        if (style == \"punctuation\") style = null;\n        if (stream.eol() && state.lambda) state.lambda = false;\n        return addErr ? style + \" \" + ERRORCLASS : style;\n      },\n      indent: function (state, textAfter) {\n        if (state.tokenize != tokenBase) return state.tokenize.isString ? CodeMirror.Pass : 0;\n        var scope = top(state),\n            closing = scope.type == textAfter.charAt(0);\n        if (scope.align != null) return scope.align - (closing ? 1 : 0);else return scope.offset - (closing ? hangingIndent : 0);\n      },\n      electricInput: /^\\s*[\\}\\]\\)]$/,\n      closeBrackets: {\n        triples: \"'\\\"\"\n      },\n      lineComment: \"#\",\n      fold: \"indent\"\n    };\n    return external;\n  });\n  CodeMirror.defineMIME(\"text/x-python\", \"python\");\n\n  var words = function (str) {\n    return str.split(\" \");\n  };\n\n  CodeMirror.defineMIME(\"text/x-cython\", {\n    name: \"python\",\n    extra_keywords: words(\"by cdef cimport cpdef ctypedef enum except \" + \"extern gil include nogil property public \" + \"readonly struct union DEF IF ELIF ELSE\")\n  });\n});"

/***/ }),
/* 226 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(11)(__webpack_require__(227))

/***/ }),
/* 227 */
/***/ (function(module, exports) {

module.exports = "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n(function (mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);else // Plain browser env\n    mod(CodeMirror);\n})(function (CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.defineMode('shell', function () {\n    var words = {};\n\n    function define(style, dict) {\n      for (var i = 0; i < dict.length; i++) {\n        words[dict[i]] = style;\n      }\n    }\n\n    ;\n    var commonAtoms = [\"true\", \"false\"];\n    var commonKeywords = [\"if\", \"then\", \"do\", \"else\", \"elif\", \"while\", \"until\", \"for\", \"in\", \"esac\", \"fi\", \"fin\", \"fil\", \"done\", \"exit\", \"set\", \"unset\", \"export\", \"function\"];\n    var commonCommands = [\"ab\", \"awk\", \"bash\", \"beep\", \"cat\", \"cc\", \"cd\", \"chown\", \"chmod\", \"chroot\", \"clear\", \"cp\", \"curl\", \"cut\", \"diff\", \"echo\", \"find\", \"gawk\", \"gcc\", \"get\", \"git\", \"grep\", \"hg\", \"kill\", \"killall\", \"ln\", \"ls\", \"make\", \"mkdir\", \"openssl\", \"mv\", \"nc\", \"nl\", \"node\", \"npm\", \"ping\", \"ps\", \"restart\", \"rm\", \"rmdir\", \"sed\", \"service\", \"sh\", \"shopt\", \"shred\", \"source\", \"sort\", \"sleep\", \"ssh\", \"start\", \"stop\", \"su\", \"sudo\", \"svn\", \"tee\", \"telnet\", \"top\", \"touch\", \"vi\", \"vim\", \"wall\", \"wc\", \"wget\", \"who\", \"write\", \"yes\", \"zsh\"];\n    CodeMirror.registerHelper(\"hintWords\", \"shell\", commonAtoms.concat(commonKeywords, commonCommands));\n    define('atom', commonAtoms);\n    define('keyword', commonKeywords);\n    define('builtin', commonCommands);\n\n    function tokenBase(stream, state) {\n      if (stream.eatSpace()) return null;\n      var sol = stream.sol();\n      var ch = stream.next();\n\n      if (ch === '\\\\') {\n        stream.next();\n        return null;\n      }\n\n      if (ch === '\\'' || ch === '\"' || ch === '`') {\n        state.tokens.unshift(tokenString(ch, ch === \"`\" ? \"quote\" : \"string\"));\n        return tokenize(stream, state);\n      }\n\n      if (ch === '#') {\n        if (sol && stream.eat('!')) {\n          stream.skipToEnd();\n          return 'meta'; // 'comment'?\n        }\n\n        stream.skipToEnd();\n        return 'comment';\n      }\n\n      if (ch === '$') {\n        state.tokens.unshift(tokenDollar);\n        return tokenize(stream, state);\n      }\n\n      if (ch === '+' || ch === '=') {\n        return 'operator';\n      }\n\n      if (ch === '-') {\n        stream.eat('-');\n        stream.eatWhile(/\\w/);\n        return 'attribute';\n      }\n\n      if (/\\d/.test(ch)) {\n        stream.eatWhile(/\\d/);\n\n        if (stream.eol() || !/\\w/.test(stream.peek())) {\n          return 'number';\n        }\n      }\n\n      stream.eatWhile(/[\\w-]/);\n      var cur = stream.current();\n      if (stream.peek() === '=' && /\\w+/.test(cur)) return 'def';\n      return words.hasOwnProperty(cur) ? words[cur] : null;\n    }\n\n    function tokenString(quote, style) {\n      var close = quote == \"(\" ? \")\" : quote == \"{\" ? \"}\" : quote;\n      return function (stream, state) {\n        var next,\n            escaped = false;\n\n        while ((next = stream.next()) != null) {\n          if (next === close && !escaped) {\n            state.tokens.shift();\n            break;\n          } else if (next === '$' && !escaped && quote !== \"'\" && stream.peek() != close) {\n            escaped = true;\n            stream.backUp(1);\n            state.tokens.unshift(tokenDollar);\n            break;\n          } else if (!escaped && quote !== close && next === quote) {\n            state.tokens.unshift(tokenString(quote, style));\n            return tokenize(stream, state);\n          } else if (!escaped && /['\"]/.test(next) && !/['\"]/.test(quote)) {\n            state.tokens.unshift(tokenStringStart(next, \"string\"));\n            stream.backUp(1);\n            break;\n          }\n\n          escaped = !escaped && next === '\\\\';\n        }\n\n        return style;\n      };\n    }\n\n    ;\n\n    function tokenStringStart(quote, style) {\n      return function (stream, state) {\n        state.tokens[0] = tokenString(quote, style);\n        stream.next();\n        return tokenize(stream, state);\n      };\n    }\n\n    var tokenDollar = function (stream, state) {\n      if (state.tokens.length > 1) stream.eat('$');\n      var ch = stream.next();\n\n      if (/['\"({]/.test(ch)) {\n        state.tokens[0] = tokenString(ch, ch == \"(\" ? \"quote\" : ch == \"{\" ? \"def\" : \"string\");\n        return tokenize(stream, state);\n      }\n\n      if (!/\\d/.test(ch)) stream.eatWhile(/\\w/);\n      state.tokens.shift();\n      return 'def';\n    };\n\n    function tokenize(stream, state) {\n      return (state.tokens[0] || tokenBase)(stream, state);\n    }\n\n    ;\n    return {\n      startState: function () {\n        return {\n          tokens: []\n        };\n      },\n      token: function (stream, state) {\n        return tokenize(stream, state);\n      },\n      closeBrackets: \"()[]{}''\\\"\\\"``\",\n      lineComment: '#',\n      fold: \"brace\"\n    };\n  });\n  CodeMirror.defineMIME('text/x-sh', 'shell'); // Apache uses a slightly different Media Type for Shell scripts\n  // http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types\n\n  CodeMirror.defineMIME('application/x-sh', 'shell');\n});"

/***/ }),
/* 228 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var PrioritizedList_js_1 = __webpack_require__(43);

var HandlerList = function (_super) {
  __extends(HandlerList, _super);

  function HandlerList() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  HandlerList.prototype.register = function (handler) {
    return this.add(handler, handler.priority);
  };

  HandlerList.prototype.unregister = function (handler) {
    this.remove(handler);
  };

  HandlerList.prototype.handlesDocument = function (document) {
    try {
      for (var _a = __values(this), _b = _a.next(); !_b.done; _b = _a.next()) {
        var item = _b.value;
        var handler = item.item;

        if (handler.handlesDocument(document)) {
          return handler;
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    throw new Error("Can't find handler for document");

    var e_1, _c;
  };

  HandlerList.prototype.document = function (document, options) {
    if (options === void 0) {
      options = null;
    }

    return this.handlesDocument(document).create(document, options);
  };

  return HandlerList;
}(PrioritizedList_js_1.PrioritizedList);

exports.HandlerList = HandlerList;

/***/ }),
/* 229 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var InputJax_js_1 = __webpack_require__(71);

var Options_js_1 = __webpack_require__(10);

var FindTeX_js_1 = __webpack_require__(230);

var FilterUtil_js_1 = __webpack_require__(232);

var NodeUtil_js_1 = __webpack_require__(8);

var TexParser_js_1 = __webpack_require__(15);

var TexError_js_1 = __webpack_require__(6);

var ParseOptions_js_1 = __webpack_require__(237);

var Tags_js_1 = __webpack_require__(35);

var Configuration_js_1 = __webpack_require__(4);

__webpack_require__(47);

var TeX = function (_super) {
  __extends(TeX, _super);

  function TeX(options) {
    if (options === void 0) {
      options = {};
    }

    var _this = this;

    var _a = __read(Options_js_1.separateOptions(options, TeX.OPTIONS, FindTeX_js_1.FindTeX.OPTIONS), 3),
        rest = _a[0],
        tex = _a[1],
        find = _a[2];

    _this = _super.call(this, tex) || this;
    _this.findTeX = _this.options['FindTeX'] || new FindTeX_js_1.FindTeX(find);
    var packages = _this.options.packages;
    var configuration = _this.configuration = TeX.configure(packages);
    var parseOptions = _this._parseOptions = new ParseOptions_js_1.default(configuration, [_this.options, Tags_js_1.TagsFactory.OPTIONS]);
    Options_js_1.userOptions(parseOptions.options, rest);
    configuration.config(configuration, _this);
    TeX.tags(parseOptions, configuration);

    _this.postFilters.add(FilterUtil_js_1.default.cleanSubSup, -4);

    _this.postFilters.add(FilterUtil_js_1.default.cleanStretchy, -3);

    _this.postFilters.add(FilterUtil_js_1.default.cleanAttributes, -2);

    _this.postFilters.add(FilterUtil_js_1.default.combineRelations, -1);

    return _this;
  }

  TeX.configure = function (packages) {
    var configuration = Configuration_js_1.Configuration.empty();

    try {
      for (var packages_1 = __values(packages), packages_1_1 = packages_1.next(); !packages_1_1.done; packages_1_1 = packages_1.next()) {
        var key = packages_1_1.value;
        var conf = Configuration_js_1.ConfigurationHandler.get(key);

        if (conf) {
          configuration.append(conf);
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (packages_1_1 && !packages_1_1.done && (_a = packages_1.return)) _a.call(packages_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    configuration.init(configuration);
    return configuration;

    var e_1, _a;
  };

  TeX.tags = function (options, configuration) {
    Tags_js_1.TagsFactory.addTags(configuration.tags);
    Tags_js_1.TagsFactory.setDefault(options.options.tags);
    options.tags = Tags_js_1.TagsFactory.getDefault();
    options.tags.configuration = options;
  };

  TeX.prototype.setMmlFactory = function (mmlFactory) {
    _super.prototype.setMmlFactory.call(this, mmlFactory);

    this._parseOptions.nodeFactory.setMmlFactory(mmlFactory);
  };

  Object.defineProperty(TeX.prototype, "parseOptions", {
    get: function () {
      return this._parseOptions;
    },
    enumerable: true,
    configurable: true
  });

  TeX.prototype.compile = function (math) {
    this.parseOptions.clear();
    var node;
    var parser;
    var display = math.display;
    this.executeFilters(this.preFilters, math, this.parseOptions);
    this.latex = math.math;

    try {
      parser = new TexParser_js_1.default(this.latex, {
        display: display,
        isInner: false
      }, this.parseOptions);
      node = parser.mml();
    } catch (err) {
      if (!(err instanceof TexError_js_1.default)) {
        throw err;
      }

      this.parseOptions.error = true;
      node = this.formatError(err);
    }

    node = this.parseOptions.nodeFactory.create('node', 'math', [node]);

    if (display) {
      NodeUtil_js_1.default.setAttribute(node, 'display', 'block');
    }

    this.parseOptions.root = node;
    this.executeFilters(this.postFilters, math, this.parseOptions);

    if (this.parseOptions.error) {
      this.parseOptions.root.setInheritedAttributes({}, display, 0, false);
    }

    this.mathNode = this.parseOptions.root;
    return this.mathNode;
  };

  ;

  TeX.prototype.findMath = function (strings) {
    return this.findTeX.findMath(strings);
  };

  TeX.prototype.formatError = function (err) {
    var message = err.message.replace(/\n.*/, '');
    return this.parseOptions.nodeFactory.create('error', message, err.id, this.latex);
  };

  ;
  return TeX;
}(InputJax_js_1.AbstractInputJax);

TeX.NAME = 'TeX';
TeX.OPTIONS = __assign({}, InputJax_js_1.AbstractInputJax.OPTIONS, {
  FindTeX: null,
  packages: ['base'],
  digits: /^(?:[0-9]+(?:\{,\}[0-9]{3})*(?:\.[0-9]*)?|\.[0-9]+)/,
  maxBuffer: 5 * 1024
});
exports.TeX = TeX;

/***/ }),
/* 230 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var FindMath_js_1 = __webpack_require__(231);

var string_js_1 = __webpack_require__(16);

var MathItem_js_1 = __webpack_require__(33);

var FindTeX = function (_super) {
  __extends(FindTeX, _super);

  function FindTeX(options) {
    var _this = _super.call(this, options) || this;

    _this.getPatterns();

    return _this;
  }

  FindTeX.prototype.getPatterns = function () {
    var _this = this;

    var options = this.options;
    var starts = [],
        parts = [],
        subparts = [];
    this.end = {};
    this.env = this.sub = 0;
    var i = 1;
    options['inlineMath'].forEach(function (delims) {
      return _this.addPattern(starts, delims, false);
    });
    options['displayMath'].forEach(function (delims) {
      return _this.addPattern(starts, delims, true);
    });

    if (starts.length) {
      parts.push(starts.sort(string_js_1.sortLength).join('|'));
    }

    if (options['processEnvironments']) {
      parts.push('\\\\begin\\{([^}]*)\\}');
      this.env = i;
      i++;
    }

    if (options['processEscapes']) {
      subparts.push('\\\\([\\\\$])');
    }

    if (options['processRefs']) {
      subparts.push('(\\\\(?:eq)?ref\\{[^}]*\\})');
    }

    if (subparts.length) {
      parts.push('(' + subparts.join('|') + ')');
      this.sub = i;
    }

    this.start = new RegExp(parts.join('|'), 'g');
    this.hasPatterns = parts.length > 0;
  };

  FindTeX.prototype.addPattern = function (starts, delims, display) {
    var _a = __read(delims, 2),
        open = _a[0],
        close = _a[1];

    starts.push(string_js_1.quotePattern(open));
    this.end[open] = [close, display, this.endPattern(close)];
  };

  FindTeX.prototype.endPattern = function (end) {
    return new RegExp(string_js_1.quotePattern(end) + '|\\\\(?:[a-zA-Z]|.)|[{}]', 'g');
  };

  FindTeX.prototype.findEnd = function (text, n, start, end) {
    var _a = __read(end, 3),
        close = _a[0],
        display = _a[1],
        pattern = _a[2];

    var i = pattern.lastIndex = start.index + start[0].length;
    var match,
        braces = 0;

    while (match = pattern.exec(text)) {
      if (match[0] === close && braces === 0) {
        return MathItem_js_1.protoItem(start[0], text.substr(i, match.index - i), match[0], n, start.index, match.index + match[0].length, display);
      } else if (match[0] === '{') {
        braces++;
      } else if (match[0] === '}' && braces) {
        braces--;
      }
    }

    return null;
  };

  FindTeX.prototype.findMathInString = function (math, n, text) {
    var start, match;
    this.start.lastIndex = 0;

    while (start = this.start.exec(text)) {
      if (start[this.env] !== undefined && this.env) {
        var end = '\\end{' + start[this.env] + '}';
        match = this.findEnd(text, n, start, [end, true, this.endPattern(end)]);

        if (match) {
          match.math = match.open + match.math + match.close;
          match.open = match.close = '';
        }
      } else if (start[this.sub] !== undefined && this.sub) {
        var math_1 = start[this.sub];
        var end = start.index + start[this.sub].length;

        if (math_1.length === 2) {
          match = MathItem_js_1.protoItem('', math_1.substr(1), '', n, start.index, end);
        } else {
          match = MathItem_js_1.protoItem('', math_1, '', n, start.index, end, false);
        }
      } else {
        match = this.findEnd(text, n, start, this.end[start[0]]);
      }

      if (match) {
        math.push(match);
        this.start.lastIndex = match.end.n;
      }
    }
  };

  FindTeX.prototype.findMath = function (strings) {
    var math = [];

    if (this.hasPatterns) {
      for (var i = 0, m = strings.length; i < m; i++) {
        this.findMathInString(math, i, strings[i]);
      }
    }

    return math;
  };

  return FindTeX;
}(FindMath_js_1.AbstractFindMath);

FindTeX.OPTIONS = {
  inlineMath: [['\\(', '\\)']],
  displayMath: [['$$', '$$'], ['\\[', '\\]']],
  processEscapes: true,
  processEnvironments: true,
  processRefs: true
};
exports.FindTeX = FindTeX;

/***/ }),
/* 231 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Options_js_1 = __webpack_require__(10);

var AbstractFindMath = function () {
  function AbstractFindMath(options) {
    var CLASS = this.constructor;
    this.options = Options_js_1.userOptions(Options_js_1.defaultOptions({}, CLASS.OPTIONS), options);
  }

  return AbstractFindMath;
}();

AbstractFindMath.OPTIONS = {};
exports.AbstractFindMath = AbstractFindMath;

/***/ }),
/* 232 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var NodeUtil_js_1 = __webpack_require__(8);

var FilterUtil;

(function (FilterUtil) {
  FilterUtil.cleanStretchy = function (arg) {
    var options = arg.data;

    try {
      for (var _a = __values(options.getList('fixStretchy')), _b = _a.next(); !_b.done; _b = _a.next()) {
        var mo = _b.value;

        if (NodeUtil_js_1.default.getProperty(mo, 'fixStretchy')) {
          var symbol = NodeUtil_js_1.default.getForm(mo);

          if (symbol && symbol[3] && symbol[3]['stretchy']) {
            NodeUtil_js_1.default.setAttribute(mo, 'stretchy', false);
          }

          var parent_1 = mo.parent;

          if (!NodeUtil_js_1.default.getTexClass(mo) && (!symbol || !symbol[2])) {
            var texAtom = options.nodeFactory.create('node', 'TeXAtom', [mo]);
            parent_1.replaceChild(texAtom, mo);
            texAtom.inheritAttributesFrom(mo);
          }

          NodeUtil_js_1.default.removeProperties(mo, 'fixStretchy');
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _c;
  };

  FilterUtil.cleanAttributes = function (arg) {
    var node = arg.data.root;
    node.walkTree(function (mml, d) {
      var attribs = mml.attributes;

      try {
        for (var _a = __values(attribs.getExplicitNames()), _b = _a.next(); !_b.done; _b = _a.next()) {
          var key = _b.value;

          if (attribs.attributes[key] === mml.attributes.getInherited(key)) {
            delete attribs.attributes[key];
          }
        }
      } catch (e_2_1) {
        e_2 = {
          error: e_2_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_2) throw e_2.error;
        }
      }

      var e_2, _c;
    }, {});
  };

  FilterUtil.combineRelations = function (arg) {
    try {
      for (var _a = __values(arg.data.getList('mo')), _b = _a.next(); !_b.done; _b = _a.next()) {
        var mo = _b.value;

        if (mo.getProperty('relationsCombined') || !mo.parent || mo.parent && !NodeUtil_js_1.default.isType(mo.parent, 'mrow') || NodeUtil_js_1.default.getTexClass(mo) !== MmlNode_js_1.TEXCLASS.REL) {
          continue;
        }

        var mml = mo.parent;
        var m2 = void 0;
        var children = mml.childNodes;
        var next = children.indexOf(mo) + 1;
        var variantForm = NodeUtil_js_1.default.getProperty(mo, 'variantForm');

        while (next < children.length && (m2 = children[next]) && NodeUtil_js_1.default.isType(m2, 'mo') && NodeUtil_js_1.default.getTexClass(m2) === MmlNode_js_1.TEXCLASS.REL) {
          if (variantForm === NodeUtil_js_1.default.getProperty(m2, 'variantForm') && _compareExplicit(mo, m2)) {
            NodeUtil_js_1.default.appendChildren(mo, NodeUtil_js_1.default.getChildren(m2));

            _copyExplicit(['stretchy', 'rspace'], mo, m2);

            NodeUtil_js_1.default.setProperties(mo, m2.getAllProperties());
            children.splice(next, 1);
            m2.parent = null;
            m2.setProperty('relationsCombined', true);
          } else {
            if (mo.attributes.getExplicit('rspace') == null) {
              NodeUtil_js_1.default.setAttribute(mo, 'rspace', '0pt');
            }

            if (m2.attributes.getExplicit('lspace') == null) {
              NodeUtil_js_1.default.setAttribute(m2, 'lspace', '0pt');
            }

            break;
          }
        }

        mo.attributes.setInherited('form', mo.getForms()[0]);
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    var e_3, _c;
  };

  var _copyExplicit = function (attrs, node1, node2) {
    var attr1 = node1.attributes;
    var attr2 = node2.attributes;
    attrs.forEach(function (x) {
      var attr = attr2.getExplicit(x);

      if (attr != null) {
        attr1.set(x, attr);
      }
    });
  };

  var _compareExplicit = function (node1, node2) {
    var filter = function (attr, space) {
      var exp = attr.getExplicitNames();
      return exp.filter(function (x) {
        return x !== space && (x !== 'stretchy' || attr.getExplicit('stretchy'));
      });
    };

    var attr1 = node1.attributes;
    var attr2 = node2.attributes;
    var exp1 = filter(attr1, 'lspace');
    var exp2 = filter(attr2, 'rspace');

    if (exp1.length !== exp2.length) {
      return false;
    }

    try {
      for (var exp1_1 = __values(exp1), exp1_1_1 = exp1_1.next(); !exp1_1_1.done; exp1_1_1 = exp1_1.next()) {
        var name_1 = exp1_1_1.value;

        if (attr1.getExplicit(name_1) !== attr2.getExplicit(name_1)) {
          return false;
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (exp1_1_1 && !exp1_1_1.done && (_a = exp1_1.return)) _a.call(exp1_1);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    return true;

    var e_4, _a;
  };

  var _cleanSubSup = function (options, low, up) {
    try {
      for (var _a = __values(options.getList('m' + low + up)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var mml = _b.value;
        var children = mml.childNodes;

        if (children[mml[low]] && children[mml[up]]) {
          continue;
        }

        var parent_2 = mml.parent;
        var newNode = children[mml[low]] ? options.nodeFactory.create('node', 'm' + low, [children[mml.base], children[mml[low]]]) : options.nodeFactory.create('node', 'm' + up, [children[mml.base], children[mml[up]]]);
        NodeUtil_js_1.default.copyAttributes(mml, newNode);

        if (parent_2) {
          parent_2.replaceChild(newNode, mml);
        } else {
          options.root = newNode;
        }
      }
    } catch (e_5_1) {
      e_5 = {
        error: e_5_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_5) throw e_5.error;
      }
    }

    var e_5, _c;
  };

  FilterUtil.cleanSubSup = function (arg) {
    var options = arg.data;

    if (options.error) {
      return;
    }

    _cleanSubSup(options, 'sub', 'sup');

    _cleanSubSup(options, 'under', 'over');

    options.root.setInheritedAttributes({}, arg.math['display'], 0, false);
  };
})(FilterUtil || (FilterUtil = {}));

exports.default = FilterUtil;

/***/ }),
/* 233 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var AbstractNode = function () {
  function AbstractNode(factory, properties, children) {
    if (properties === void 0) {
      properties = {};
    }

    if (children === void 0) {
      children = [];
    }

    this.parent = null;
    this.properties = {};
    this._factory = null;
    this.childNodes = [];
    this._factory = factory;

    try {
      for (var _a = __values(Object.keys(properties)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var name_1 = _b.value;
        this.setProperty(name_1, properties[name_1]);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    if (children.length) {
      this.setChildren(children);
    }

    var e_1, _c;
  }

  Object.defineProperty(AbstractNode.prototype, "factory", {
    get: function () {
      return this._factory;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AbstractNode.prototype, "kind", {
    get: function () {
      return 'unknown';
    },
    enumerable: true,
    configurable: true
  });

  AbstractNode.prototype.setProperty = function (name, value) {
    this.properties[name] = value;
  };

  AbstractNode.prototype.getProperty = function (name) {
    return this.properties[name];
  };

  AbstractNode.prototype.getPropertyNames = function () {
    return Object.keys(this.properties);
  };

  AbstractNode.prototype.getAllProperties = function () {
    return this.properties;
  };

  AbstractNode.prototype.removeProperty = function () {
    var names = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      names[_i] = arguments[_i];
    }

    try {
      for (var names_1 = __values(names), names_1_1 = names_1.next(); !names_1_1.done; names_1_1 = names_1.next()) {
        var name_2 = names_1_1.value;
        delete this.properties[name_2];
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (names_1_1 && !names_1_1.done && (_a = names_1.return)) _a.call(names_1);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_2, _a;
  };

  AbstractNode.prototype.isKind = function (kind) {
    return this.factory.nodeIsKind(this, kind);
  };

  AbstractNode.prototype.setChildren = function (children) {
    this.childNodes = [];

    try {
      for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
        var child = children_1_1.value;
        this.appendChild(child);
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    var e_3, _a;
  };

  AbstractNode.prototype.appendChild = function (child) {
    this.childNodes.push(child);
    child.parent = this;
    return child;
  };

  AbstractNode.prototype.replaceChild = function (newChild, oldChild) {
    var i = this.childIndex(oldChild);

    if (i !== null) {
      this.childNodes[i] = newChild;
      newChild.parent = this;
    }

    return newChild;
  };

  AbstractNode.prototype.childIndex = function (node) {
    var i = this.childNodes.indexOf(node);
    return i === -1 ? null : i;
  };

  AbstractNode.prototype.findNodes = function (kind) {
    var nodes = [];
    this.walkTree(function (node) {
      if (node.isKind(kind)) {
        nodes.push(node);
      }
    });
    return nodes;
  };

  AbstractNode.prototype.walkTree = function (func, data) {
    func(this, data);

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;

        if (child) {
          child.walkTree(func, data);
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    return data;

    var e_4, _c;
  };

  AbstractNode.prototype.toString = function () {
    return this.kind + '(' + this.childNodes.join(',') + ')';
  };

  return AbstractNode;
}();

exports.AbstractNode = AbstractNode;

var AbstractEmptyNode = function (_super) {
  __extends(AbstractEmptyNode, _super);

  function AbstractEmptyNode() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  AbstractEmptyNode.prototype.setChildren = function (children) {};

  AbstractEmptyNode.prototype.appendChild = function (child) {
    return child;
  };

  AbstractEmptyNode.prototype.replaceChild = function (newChild, oldChild) {
    return oldChild;
  };

  AbstractEmptyNode.prototype.childIndex = function (node) {
    return null;
  };

  AbstractEmptyNode.prototype.walkTree = function (func, data) {
    func(this, data);
    return data;
  };

  AbstractEmptyNode.prototype.toString = function () {
    return this.kind;
  };

  return AbstractEmptyNode;
}(AbstractNode);

exports.AbstractEmptyNode = AbstractEmptyNode;

/***/ }),
/* 234 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

function OPDEF(lspace, rspace, texClass, properties) {
  if (texClass === void 0) {
    texClass = MmlNode_js_1.TEXCLASS.BIN;
  }

  if (properties === void 0) {
    properties = null;
  }

  return [lspace, rspace, texClass, properties];
}

exports.OPDEF = OPDEF;
exports.MO = {
  ORD: OPDEF(0, 0, MmlNode_js_1.TEXCLASS.ORD),
  ORD11: OPDEF(1, 1, MmlNode_js_1.TEXCLASS.ORD),
  ORD21: OPDEF(2, 1, MmlNode_js_1.TEXCLASS.ORD),
  ORD02: OPDEF(0, 2, MmlNode_js_1.TEXCLASS.ORD),
  ORD55: OPDEF(5, 5, MmlNode_js_1.TEXCLASS.ORD),
  OP: OPDEF(1, 2, MmlNode_js_1.TEXCLASS.OP, {
    largeop: true,
    movablelimits: true,
    symmetric: true
  }),
  OPFIXED: OPDEF(1, 2, MmlNode_js_1.TEXCLASS.OP, {
    largeop: true,
    movablelimits: true
  }),
  INTEGRAL: OPDEF(0, 1, MmlNode_js_1.TEXCLASS.OP, {
    largeop: true,
    symmetric: true
  }),
  INTEGRAL2: OPDEF(1, 2, MmlNode_js_1.TEXCLASS.OP, {
    largeop: true,
    symmetric: true
  }),
  BIN3: OPDEF(3, 3, MmlNode_js_1.TEXCLASS.BIN),
  BIN4: OPDEF(4, 4, MmlNode_js_1.TEXCLASS.BIN),
  BIN01: OPDEF(0, 1, MmlNode_js_1.TEXCLASS.BIN),
  BIN5: OPDEF(5, 5, MmlNode_js_1.TEXCLASS.BIN),
  TALLBIN: OPDEF(4, 4, MmlNode_js_1.TEXCLASS.BIN, {
    stretchy: true
  }),
  BINOP: OPDEF(4, 4, MmlNode_js_1.TEXCLASS.BIN, {
    largeop: true,
    movablelimits: true
  }),
  REL: OPDEF(5, 5, MmlNode_js_1.TEXCLASS.REL),
  REL1: OPDEF(1, 1, MmlNode_js_1.TEXCLASS.REL, {
    stretchy: true
  }),
  REL4: OPDEF(4, 4, MmlNode_js_1.TEXCLASS.REL),
  RELSTRETCH: OPDEF(5, 5, MmlNode_js_1.TEXCLASS.REL, {
    stretchy: true
  }),
  RELACCENT: OPDEF(5, 5, MmlNode_js_1.TEXCLASS.REL, {
    accent: true
  }),
  WIDEREL: OPDEF(5, 5, MmlNode_js_1.TEXCLASS.REL, {
    accent: true,
    stretchy: true
  }),
  OPEN: OPDEF(0, 0, MmlNode_js_1.TEXCLASS.OPEN, {
    fence: true,
    stretchy: true,
    symmetric: true
  }),
  CLOSE: OPDEF(0, 0, MmlNode_js_1.TEXCLASS.CLOSE, {
    fence: true,
    stretchy: true,
    symmetric: true
  }),
  INNER: OPDEF(0, 0, MmlNode_js_1.TEXCLASS.INNER),
  PUNCT: OPDEF(0, 3, MmlNode_js_1.TEXCLASS.PUNCT),
  ACCENT: OPDEF(0, 0, MmlNode_js_1.TEXCLASS.ORD, {
    accent: true
  }),
  WIDEACCENT: OPDEF(0, 0, MmlNode_js_1.TEXCLASS.ORD, {
    accent: true,
    stretchy: true
  })
};
exports.RANGES = [[0x20, 0x7F, MmlNode_js_1.TEXCLASS.REL, 'BasicLatin'], [0xA0, 0xFF, MmlNode_js_1.TEXCLASS.ORD, 'Latin1Supplement'], [0x100, 0x17F, MmlNode_js_1.TEXCLASS.ORD, 'LatinExtendedA'], [0x180, 0x24F, MmlNode_js_1.TEXCLASS.ORD, 'LatinExtendedB'], [0x2B0, 0x2FF, MmlNode_js_1.TEXCLASS.ORD, 'SpacingModLetters'], [0x300, 0x36F, MmlNode_js_1.TEXCLASS.ORD, 'CombDiacritMarks'], [0x370, 0x3FF, MmlNode_js_1.TEXCLASS.ORD, 'GreekAndCoptic'], [0x1E00, 0x1EFF, MmlNode_js_1.TEXCLASS.ORD, 'LatinExtendedAdditional'], [0x2000, 0x206F, MmlNode_js_1.TEXCLASS.PUNCT, 'GeneralPunctuation'], [0x2070, 0x209F, MmlNode_js_1.TEXCLASS.ORD, 'SuperAndSubscripts'], [0x20A0, 0x20CF, MmlNode_js_1.TEXCLASS.ORD, 'Currency'], [0x20D0, 0x20FF, MmlNode_js_1.TEXCLASS.ORD, 'CombDiactForSymbols'], [0x2100, 0x214F, MmlNode_js_1.TEXCLASS.ORD, 'LetterlikeSymbols'], [0x2150, 0x218F, MmlNode_js_1.TEXCLASS.ORD, 'NumberForms'], [0x2190, 0x21FF, MmlNode_js_1.TEXCLASS.REL, 'Arrows'], [0x2200, 0x22FF, MmlNode_js_1.TEXCLASS.BIN, 'MathOperators'], [0x2300, 0x23FF, MmlNode_js_1.TEXCLASS.ORD, 'MiscTechnical'], [0x2460, 0x24FF, MmlNode_js_1.TEXCLASS.ORD, 'EnclosedAlphaNums'], [0x2500, 0x259F, MmlNode_js_1.TEXCLASS.ORD, 'BoxDrawing'], [0x25A0, 0x25FF, MmlNode_js_1.TEXCLASS.ORD, 'GeometricShapes'], [0x2700, 0x27BF, MmlNode_js_1.TEXCLASS.ORD, 'Dingbats'], [0x27C0, 0x27EF, MmlNode_js_1.TEXCLASS.ORD, 'MiscMathSymbolsA'], [0x27F0, 0x27FF, MmlNode_js_1.TEXCLASS.REL, 'SupplementalArrowsA'], [0x2900, 0x297F, MmlNode_js_1.TEXCLASS.REL, 'SupplementalArrowsB'], [0x2980, 0x29FF, MmlNode_js_1.TEXCLASS.ORD, 'MiscMathSymbolsB'], [0x2A00, 0x2AFF, MmlNode_js_1.TEXCLASS.BIN, 'SuppMathOperators'], [0x2B00, 0x2BFF, MmlNode_js_1.TEXCLASS.ORD, 'MiscSymbolsAndArrows'], [0x1D400, 0x1D7FF, MmlNode_js_1.TEXCLASS.ORD, 'MathAlphabets']];
exports.MMLSPACING = [[0, 0], [1, 2], [3, 3], [4, 4], [0, 0], [0, 0], [0, 3]];
exports.OPTABLE = {
  prefix: {
    '(': exports.MO.OPEN,
    '+': exports.MO.BIN01,
    '-': exports.MO.BIN01,
    '[': exports.MO.OPEN,
    '{': exports.MO.OPEN,
    '|': exports.MO.OPEN,
    '||': [0, 0, MmlNode_js_1.TEXCLASS.BIN, {
      fence: true,
      stretchy: true,
      symmetric: true
    }],
    '|||': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      fence: true,
      stretchy: true,
      symmetric: true
    }],
    '\u00AC': exports.MO.ORD21,
    '\u00B1': exports.MO.BIN01,
    '\u2016': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      fence: true,
      stretchy: true
    }],
    '\u2018': [0, 0, MmlNode_js_1.TEXCLASS.OPEN, {
      fence: true
    }],
    '\u201C': [0, 0, MmlNode_js_1.TEXCLASS.OPEN, {
      fence: true
    }],
    '\u2145': exports.MO.ORD21,
    '\u2146': OPDEF(2, 0, MmlNode_js_1.TEXCLASS.ORD),
    '\u2200': exports.MO.ORD21,
    '\u2202': exports.MO.ORD21,
    '\u2203': exports.MO.ORD21,
    '\u2204': exports.MO.ORD21,
    '\u2207': exports.MO.ORD21,
    '\u220F': exports.MO.OP,
    '\u2210': exports.MO.OP,
    '\u2211': exports.MO.OP,
    '\u2212': exports.MO.BIN01,
    '\u2213': exports.MO.BIN01,
    '\u221A': [1, 1, MmlNode_js_1.TEXCLASS.ORD, {
      stretchy: true
    }],
    '\u221B': exports.MO.ORD11,
    '\u221C': exports.MO.ORD11,
    '\u2220': exports.MO.ORD,
    '\u2221': exports.MO.ORD,
    '\u2222': exports.MO.ORD,
    '\u222B': exports.MO.INTEGRAL,
    '\u222C': exports.MO.INTEGRAL,
    '\u222D': exports.MO.INTEGRAL,
    '\u222E': exports.MO.INTEGRAL,
    '\u222F': exports.MO.INTEGRAL,
    '\u2230': exports.MO.INTEGRAL,
    '\u2231': exports.MO.INTEGRAL,
    '\u2232': exports.MO.INTEGRAL,
    '\u2233': exports.MO.INTEGRAL,
    '\u22C0': exports.MO.OP,
    '\u22C1': exports.MO.OP,
    '\u22C2': exports.MO.OP,
    '\u22C3': exports.MO.OP,
    '\u2308': exports.MO.OPEN,
    '\u230A': exports.MO.OPEN,
    '\u2772': exports.MO.OPEN,
    '\u27E6': exports.MO.OPEN,
    '\u27E8': exports.MO.OPEN,
    '\u27EA': exports.MO.OPEN,
    '\u27EC': exports.MO.OPEN,
    '\u27EE': exports.MO.OPEN,
    '\u2980': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      fence: true,
      stretchy: true
    }],
    '\u2983': exports.MO.OPEN,
    '\u2985': exports.MO.OPEN,
    '\u2987': exports.MO.OPEN,
    '\u2989': exports.MO.OPEN,
    '\u298B': exports.MO.OPEN,
    '\u298D': exports.MO.OPEN,
    '\u298F': exports.MO.OPEN,
    '\u2991': exports.MO.OPEN,
    '\u2993': exports.MO.OPEN,
    '\u2995': exports.MO.OPEN,
    '\u2997': exports.MO.OPEN,
    '\u29FC': exports.MO.OPEN,
    '\u2A00': exports.MO.OP,
    '\u2A01': exports.MO.OP,
    '\u2A02': exports.MO.OP,
    '\u2A03': exports.MO.OP,
    '\u2A04': exports.MO.OP,
    '\u2A05': exports.MO.OP,
    '\u2A06': exports.MO.OP,
    '\u2A07': exports.MO.OP,
    '\u2A08': exports.MO.OP,
    '\u2A09': exports.MO.OP,
    '\u2A0A': exports.MO.OP,
    '\u2A0B': exports.MO.INTEGRAL2,
    '\u2A0C': exports.MO.INTEGRAL,
    '\u2A0D': exports.MO.INTEGRAL2,
    '\u2A0E': exports.MO.INTEGRAL2,
    '\u2A0F': exports.MO.INTEGRAL2,
    '\u2A10': exports.MO.OP,
    '\u2A11': exports.MO.OP,
    '\u2A12': exports.MO.OP,
    '\u2A13': exports.MO.OP,
    '\u2A14': exports.MO.OP,
    '\u2A15': exports.MO.INTEGRAL2,
    '\u2A16': exports.MO.INTEGRAL2,
    '\u2A17': exports.MO.INTEGRAL2,
    '\u2A18': exports.MO.INTEGRAL2,
    '\u2A19': exports.MO.INTEGRAL2,
    '\u2A1A': exports.MO.INTEGRAL2,
    '\u2A1B': exports.MO.INTEGRAL2,
    '\u2A1C': exports.MO.INTEGRAL2,
    '\u2AFC': exports.MO.OP,
    '\u2AFF': exports.MO.OP
  },
  postfix: {
    '!!': OPDEF(1, 0),
    '!': [1, 0, MmlNode_js_1.TEXCLASS.CLOSE, null],
    '&': exports.MO.ORD,
    ')': exports.MO.CLOSE,
    '++': OPDEF(0, 0),
    '--': OPDEF(0, 0),
    '..': OPDEF(0, 0),
    '...': exports.MO.ORD,
    '\'': exports.MO.ACCENT,
    ']': exports.MO.CLOSE,
    '^': exports.MO.WIDEACCENT,
    '_': exports.MO.WIDEACCENT,
    '`': exports.MO.ACCENT,
    '|': exports.MO.CLOSE,
    '}': exports.MO.CLOSE,
    '~': exports.MO.WIDEACCENT,
    '||': [0, 0, MmlNode_js_1.TEXCLASS.BIN, {
      fence: true,
      stretchy: true,
      symmetric: true
    }],
    '|||': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      fence: true,
      stretchy: true,
      symmetric: true
    }],
    '\u00A8': exports.MO.ACCENT,
    '\u00AF': exports.MO.WIDEACCENT,
    '\u00B0': exports.MO.ORD,
    '\u00B4': exports.MO.ACCENT,
    '\u00B8': exports.MO.ACCENT,
    '\u02C6': exports.MO.WIDEACCENT,
    '\u02C7': exports.MO.WIDEACCENT,
    '\u02C9': exports.MO.WIDEACCENT,
    '\u02CA': exports.MO.ACCENT,
    '\u02CB': exports.MO.ACCENT,
    '\u02CD': exports.MO.WIDEACCENT,
    '\u02D8': exports.MO.ACCENT,
    '\u02D9': exports.MO.ACCENT,
    '\u02DA': exports.MO.ACCENT,
    '\u02DC': exports.MO.WIDEACCENT,
    '\u02DD': exports.MO.ACCENT,
    '\u02F7': exports.MO.WIDEACCENT,
    '\u0302': exports.MO.WIDEACCENT,
    '\u0311': exports.MO.ACCENT,
    '\u03F6': exports.MO.REL,
    '\u2016': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      fence: true,
      stretchy: true
    }],
    '\u2019': [0, 0, MmlNode_js_1.TEXCLASS.CLOSE, {
      fence: true
    }],
    '\u201D': [0, 0, MmlNode_js_1.TEXCLASS.CLOSE, {
      fence: true
    }],
    '\u2032': exports.MO.ORD02,
    '\u203E': exports.MO.WIDEACCENT,
    '\u20DB': exports.MO.ACCENT,
    '\u20DC': exports.MO.ACCENT,
    '\u2309': exports.MO.CLOSE,
    '\u230B': exports.MO.CLOSE,
    '\u23B4': exports.MO.WIDEACCENT,
    '\u23B5': exports.MO.WIDEACCENT,
    '\u23DC': exports.MO.WIDEACCENT,
    '\u23DD': exports.MO.WIDEACCENT,
    '\u23DE': exports.MO.WIDEACCENT,
    '\u23DF': exports.MO.WIDEACCENT,
    '\u23E0': exports.MO.WIDEACCENT,
    '\u23E1': exports.MO.WIDEACCENT,
    '\u25A0': exports.MO.BIN3,
    '\u25A1': exports.MO.BIN3,
    '\u25AA': exports.MO.BIN3,
    '\u25AB': exports.MO.BIN3,
    '\u25AD': exports.MO.BIN3,
    '\u25AE': exports.MO.BIN3,
    '\u25AF': exports.MO.BIN3,
    '\u25B0': exports.MO.BIN3,
    '\u25B1': exports.MO.BIN3,
    '\u25B2': exports.MO.BIN4,
    '\u25B4': exports.MO.BIN4,
    '\u25B6': exports.MO.BIN4,
    '\u25B7': exports.MO.BIN4,
    '\u25B8': exports.MO.BIN4,
    '\u25BC': exports.MO.BIN4,
    '\u25BE': exports.MO.BIN4,
    '\u25C0': exports.MO.BIN4,
    '\u25C1': exports.MO.BIN4,
    '\u25C2': exports.MO.BIN4,
    '\u25C4': exports.MO.BIN4,
    '\u25C5': exports.MO.BIN4,
    '\u25C6': exports.MO.BIN4,
    '\u25C7': exports.MO.BIN4,
    '\u25C8': exports.MO.BIN4,
    '\u25C9': exports.MO.BIN4,
    '\u25CC': exports.MO.BIN4,
    '\u25CD': exports.MO.BIN4,
    '\u25CE': exports.MO.BIN4,
    '\u25CF': exports.MO.BIN4,
    '\u25D6': exports.MO.BIN4,
    '\u25D7': exports.MO.BIN4,
    '\u25E6': exports.MO.BIN4,
    '\u266D': exports.MO.ORD02,
    '\u266E': exports.MO.ORD02,
    '\u266F': exports.MO.ORD02,
    '\u2773': exports.MO.CLOSE,
    '\u27E7': exports.MO.CLOSE,
    '\u27E9': exports.MO.CLOSE,
    '\u27EB': exports.MO.CLOSE,
    '\u27ED': exports.MO.CLOSE,
    '\u27EF': exports.MO.CLOSE,
    '\u2980': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      fence: true,
      stretchy: true
    }],
    '\u2984': exports.MO.CLOSE,
    '\u2986': exports.MO.CLOSE,
    '\u2988': exports.MO.CLOSE,
    '\u298A': exports.MO.CLOSE,
    '\u298C': exports.MO.CLOSE,
    '\u298E': exports.MO.CLOSE,
    '\u2990': exports.MO.CLOSE,
    '\u2992': exports.MO.CLOSE,
    '\u2994': exports.MO.CLOSE,
    '\u2996': exports.MO.CLOSE,
    '\u2998': exports.MO.CLOSE,
    '\u29FD': exports.MO.CLOSE
  },
  infix: {
    '!=': exports.MO.BIN4,
    '#': exports.MO.ORD,
    '$': exports.MO.ORD,
    '%': [3, 3, MmlNode_js_1.TEXCLASS.ORD, null],
    '&&': exports.MO.BIN4,
    '': exports.MO.ORD,
    '*': exports.MO.BIN3,
    '**': OPDEF(1, 1),
    '*=': exports.MO.BIN4,
    '+': exports.MO.BIN4,
    '+=': exports.MO.BIN4,
    ',': [0, 3, MmlNode_js_1.TEXCLASS.PUNCT, {
      linebreakstyle: 'after',
      separator: true
    }],
    '-': exports.MO.BIN4,
    '-=': exports.MO.BIN4,
    '->': exports.MO.BIN5,
    '.': [0, 3, MmlNode_js_1.TEXCLASS.PUNCT, {
      separator: true
    }],
    '/': exports.MO.ORD11,
    '//': OPDEF(1, 1),
    '/=': exports.MO.BIN4,
    ':': [1, 2, MmlNode_js_1.TEXCLASS.REL, null],
    ':=': exports.MO.BIN4,
    ';': [0, 3, MmlNode_js_1.TEXCLASS.PUNCT, {
      linebreakstyle: 'after',
      separator: true
    }],
    '<': exports.MO.REL,
    '<=': exports.MO.BIN5,
    '<>': OPDEF(1, 1),
    '=': exports.MO.REL,
    '==': exports.MO.BIN4,
    '>': exports.MO.REL,
    '>=': exports.MO.BIN5,
    '?': [1, 1, MmlNode_js_1.TEXCLASS.CLOSE, null],
    '@': exports.MO.ORD11,
    '\\': exports.MO.ORD,
    '^': exports.MO.ORD11,
    '_': exports.MO.ORD11,
    '|': [2, 2, MmlNode_js_1.TEXCLASS.ORD, {
      fence: true,
      stretchy: true,
      symmetric: true
    }],
    '||': [2, 2, MmlNode_js_1.TEXCLASS.BIN, {
      fence: true,
      stretchy: true,
      symmetric: true
    }],
    '|||': [2, 2, MmlNode_js_1.TEXCLASS.ORD, {
      fence: true,
      stretchy: true,
      symmetric: true
    }],
    '\u00B1': exports.MO.BIN4,
    '\u00B7': exports.MO.BIN4,
    '\u00D7': exports.MO.BIN4,
    '\u00F7': exports.MO.BIN4,
    '\u02B9': exports.MO.ORD,
    '\u0300': exports.MO.ACCENT,
    '\u0301': exports.MO.ACCENT,
    '\u0303': exports.MO.WIDEACCENT,
    '\u0304': exports.MO.ACCENT,
    '\u0306': exports.MO.ACCENT,
    '\u0307': exports.MO.ACCENT,
    '\u0308': exports.MO.ACCENT,
    '\u030C': exports.MO.ACCENT,
    '\u0332': exports.MO.WIDEACCENT,
    '\u0338': exports.MO.REL4,
    '\u2015': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      stretchy: true
    }],
    '\u2017': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      stretchy: true
    }],
    '\u2020': exports.MO.BIN3,
    '\u2021': exports.MO.BIN3,
    '\u2022': exports.MO.BIN4,
    '\u2026': exports.MO.INNER,
    '\u2044': exports.MO.TALLBIN,
    '\u2061': exports.MO.ORD,
    '\u2062': exports.MO.ORD,
    '\u2063': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      linebreakstyle: 'after',
      separator: true
    }],
    '\u2064': exports.MO.ORD,
    '\u20D7': exports.MO.ACCENT,
    '\u2111': exports.MO.ORD,
    '\u2113': exports.MO.ORD,
    '\u2118': exports.MO.ORD,
    '\u211C': exports.MO.ORD,
    '\u2190': exports.MO.WIDEREL,
    '\u2191': exports.MO.RELSTRETCH,
    '\u2192': exports.MO.WIDEREL,
    '\u2193': exports.MO.RELSTRETCH,
    '\u2194': exports.MO.WIDEREL,
    '\u2195': exports.MO.RELSTRETCH,
    '\u2196': exports.MO.RELSTRETCH,
    '\u2197': exports.MO.RELSTRETCH,
    '\u2198': exports.MO.RELSTRETCH,
    '\u2199': exports.MO.RELSTRETCH,
    '\u219A': exports.MO.RELACCENT,
    '\u219B': exports.MO.RELACCENT,
    '\u219C': exports.MO.WIDEREL,
    '\u219D': exports.MO.WIDEREL,
    '\u219E': exports.MO.WIDEREL,
    '\u219F': exports.MO.WIDEREL,
    '\u21A0': exports.MO.WIDEREL,
    '\u21A1': exports.MO.RELSTRETCH,
    '\u21A2': exports.MO.WIDEREL,
    '\u21A3': exports.MO.WIDEREL,
    '\u21A4': exports.MO.WIDEREL,
    '\u21A5': exports.MO.RELSTRETCH,
    '\u21A6': exports.MO.WIDEREL,
    '\u21A7': exports.MO.RELSTRETCH,
    '\u21A8': exports.MO.RELSTRETCH,
    '\u21A9': exports.MO.WIDEREL,
    '\u21AA': exports.MO.WIDEREL,
    '\u21AB': exports.MO.WIDEREL,
    '\u21AC': exports.MO.WIDEREL,
    '\u21AD': exports.MO.WIDEREL,
    '\u21AE': exports.MO.RELACCENT,
    '\u21AF': exports.MO.RELSTRETCH,
    '\u21B0': exports.MO.RELSTRETCH,
    '\u21B1': exports.MO.RELSTRETCH,
    '\u21B2': exports.MO.RELSTRETCH,
    '\u21B3': exports.MO.RELSTRETCH,
    '\u21B4': exports.MO.RELSTRETCH,
    '\u21B5': exports.MO.RELSTRETCH,
    '\u21B6': exports.MO.RELACCENT,
    '\u21B7': exports.MO.RELACCENT,
    '\u21B8': exports.MO.REL,
    '\u21B9': exports.MO.WIDEREL,
    '\u21BA': exports.MO.REL,
    '\u21BB': exports.MO.REL,
    '\u21BC': exports.MO.WIDEREL,
    '\u21BD': exports.MO.WIDEREL,
    '\u21BE': exports.MO.RELSTRETCH,
    '\u21BF': exports.MO.RELSTRETCH,
    '\u21C0': exports.MO.WIDEREL,
    '\u21C1': exports.MO.WIDEREL,
    '\u21C2': exports.MO.RELSTRETCH,
    '\u21C3': exports.MO.RELSTRETCH,
    '\u21C4': exports.MO.WIDEREL,
    '\u21C5': exports.MO.RELSTRETCH,
    '\u21C6': exports.MO.WIDEREL,
    '\u21C7': exports.MO.WIDEREL,
    '\u21C8': exports.MO.RELSTRETCH,
    '\u21C9': exports.MO.WIDEREL,
    '\u21CA': exports.MO.RELSTRETCH,
    '\u21CB': exports.MO.WIDEREL,
    '\u21CC': exports.MO.WIDEREL,
    '\u21CD': exports.MO.RELACCENT,
    '\u21CE': exports.MO.RELACCENT,
    '\u21CF': exports.MO.RELACCENT,
    '\u21D0': exports.MO.WIDEREL,
    '\u21D1': exports.MO.RELSTRETCH,
    '\u21D2': exports.MO.WIDEREL,
    '\u21D3': exports.MO.RELSTRETCH,
    '\u21D4': exports.MO.WIDEREL,
    '\u21D5': exports.MO.RELSTRETCH,
    '\u21D6': exports.MO.RELSTRETCH,
    '\u21D7': exports.MO.RELSTRETCH,
    '\u21D8': exports.MO.RELSTRETCH,
    '\u21D9': exports.MO.RELSTRETCH,
    '\u21DA': exports.MO.WIDEREL,
    '\u21DB': exports.MO.WIDEREL,
    '\u21DC': exports.MO.WIDEREL,
    '\u21DD': exports.MO.WIDEREL,
    '\u21DE': exports.MO.REL,
    '\u21DF': exports.MO.REL,
    '\u21E0': exports.MO.WIDEREL,
    '\u21E1': exports.MO.RELSTRETCH,
    '\u21E2': exports.MO.WIDEREL,
    '\u21E3': exports.MO.RELSTRETCH,
    '\u21E4': exports.MO.WIDEREL,
    '\u21E5': exports.MO.WIDEREL,
    '\u21E6': exports.MO.WIDEREL,
    '\u21E7': exports.MO.RELSTRETCH,
    '\u21E8': exports.MO.WIDEREL,
    '\u21E9': exports.MO.RELSTRETCH,
    '\u21EA': exports.MO.RELSTRETCH,
    '\u21EB': exports.MO.RELSTRETCH,
    '\u21EC': exports.MO.RELSTRETCH,
    '\u21ED': exports.MO.RELSTRETCH,
    '\u21EE': exports.MO.RELSTRETCH,
    '\u21EF': exports.MO.RELSTRETCH,
    '\u21F0': exports.MO.WIDEREL,
    '\u21F1': exports.MO.REL,
    '\u21F2': exports.MO.REL,
    '\u21F3': exports.MO.RELSTRETCH,
    '\u21F4': exports.MO.RELACCENT,
    '\u21F5': exports.MO.RELSTRETCH,
    '\u21F6': exports.MO.WIDEREL,
    '\u21F7': exports.MO.RELACCENT,
    '\u21F8': exports.MO.RELACCENT,
    '\u21F9': exports.MO.RELACCENT,
    '\u21FA': exports.MO.RELACCENT,
    '\u21FB': exports.MO.RELACCENT,
    '\u21FC': exports.MO.RELACCENT,
    '\u21FD': exports.MO.WIDEREL,
    '\u21FE': exports.MO.WIDEREL,
    '\u21FF': exports.MO.WIDEREL,
    '\u2201': OPDEF(1, 2, MmlNode_js_1.TEXCLASS.ORD),
    '\u2205': exports.MO.ORD,
    '\u2206': exports.MO.BIN3,
    '\u2208': exports.MO.REL,
    '\u2209': exports.MO.REL,
    '\u220A': exports.MO.REL,
    '\u220B': exports.MO.REL,
    '\u220C': exports.MO.REL,
    '\u220D': exports.MO.REL,
    '\u220E': exports.MO.BIN3,
    '\u2212': exports.MO.BIN4,
    '\u2213': exports.MO.BIN4,
    '\u2214': exports.MO.BIN4,
    '\u2215': exports.MO.TALLBIN,
    '\u2216': exports.MO.BIN4,
    '\u2217': exports.MO.BIN4,
    '\u2218': exports.MO.BIN4,
    '\u2219': exports.MO.BIN4,
    '\u221D': exports.MO.REL,
    '\u221E': exports.MO.ORD,
    '\u221F': exports.MO.REL,
    '\u2223': exports.MO.REL,
    '\u2224': exports.MO.REL,
    '\u2225': exports.MO.REL,
    '\u2226': exports.MO.REL,
    '\u2227': exports.MO.BIN4,
    '\u2228': exports.MO.BIN4,
    '\u2229': exports.MO.BIN4,
    '\u222A': exports.MO.BIN4,
    '\u2234': exports.MO.REL,
    '\u2235': exports.MO.REL,
    '\u2236': exports.MO.REL,
    '\u2237': exports.MO.REL,
    '\u2238': exports.MO.BIN4,
    '\u2239': exports.MO.REL,
    '\u223A': exports.MO.BIN4,
    '\u223B': exports.MO.REL,
    '\u223C': exports.MO.REL,
    '\u223D': exports.MO.REL,
    '\u223D\u0331': exports.MO.BIN3,
    '\u223E': exports.MO.REL,
    '\u223F': exports.MO.BIN3,
    '\u2240': exports.MO.BIN4,
    '\u2241': exports.MO.REL,
    '\u2242': exports.MO.REL,
    '\u2242\u0338': exports.MO.REL,
    '\u2243': exports.MO.REL,
    '\u2244': exports.MO.REL,
    '\u2245': exports.MO.REL,
    '\u2246': exports.MO.REL,
    '\u2247': exports.MO.REL,
    '\u2248': exports.MO.REL,
    '\u2249': exports.MO.REL,
    '\u224A': exports.MO.REL,
    '\u224B': exports.MO.REL,
    '\u224C': exports.MO.REL,
    '\u224D': exports.MO.REL,
    '\u224E': exports.MO.REL,
    '\u224E\u0338': exports.MO.REL,
    '\u224F': exports.MO.REL,
    '\u224F\u0338': exports.MO.REL,
    '\u2250': exports.MO.REL,
    '\u2251': exports.MO.REL,
    '\u2252': exports.MO.REL,
    '\u2253': exports.MO.REL,
    '\u2254': exports.MO.REL,
    '\u2255': exports.MO.REL,
    '\u2256': exports.MO.REL,
    '\u2257': exports.MO.REL,
    '\u2258': exports.MO.REL,
    '\u2259': exports.MO.REL,
    '\u225A': exports.MO.REL,
    '\u225C': exports.MO.REL,
    '\u225D': exports.MO.REL,
    '\u225E': exports.MO.REL,
    '\u225F': exports.MO.REL,
    '\u2260': exports.MO.REL,
    '\u2261': exports.MO.REL,
    '\u2262': exports.MO.REL,
    '\u2263': exports.MO.REL,
    '\u2264': exports.MO.REL,
    '\u2265': exports.MO.REL,
    '\u2266': exports.MO.REL,
    '\u2266\u0338': exports.MO.REL,
    '\u2267': exports.MO.REL,
    '\u2268': exports.MO.REL,
    '\u2269': exports.MO.REL,
    '\u226A': exports.MO.REL,
    '\u226A\u0338': exports.MO.REL,
    '\u226B': exports.MO.REL,
    '\u226B\u0338': exports.MO.REL,
    '\u226C': exports.MO.REL,
    '\u226D': exports.MO.REL,
    '\u226E': exports.MO.REL,
    '\u226F': exports.MO.REL,
    '\u2270': exports.MO.REL,
    '\u2271': exports.MO.REL,
    '\u2272': exports.MO.REL,
    '\u2273': exports.MO.REL,
    '\u2274': exports.MO.REL,
    '\u2275': exports.MO.REL,
    '\u2276': exports.MO.REL,
    '\u2277': exports.MO.REL,
    '\u2278': exports.MO.REL,
    '\u2279': exports.MO.REL,
    '\u227A': exports.MO.REL,
    '\u227B': exports.MO.REL,
    '\u227C': exports.MO.REL,
    '\u227D': exports.MO.REL,
    '\u227E': exports.MO.REL,
    '\u227F': exports.MO.REL,
    '\u227F\u0338': exports.MO.REL,
    '\u2280': exports.MO.REL,
    '\u2281': exports.MO.REL,
    '\u2282': exports.MO.REL,
    '\u2282\u20D2': exports.MO.REL,
    '\u2283': exports.MO.REL,
    '\u2283\u20D2': exports.MO.REL,
    '\u2284': exports.MO.REL,
    '\u2285': exports.MO.REL,
    '\u2286': exports.MO.REL,
    '\u2287': exports.MO.REL,
    '\u2288': exports.MO.REL,
    '\u2289': exports.MO.REL,
    '\u228A': exports.MO.REL,
    '\u228B': exports.MO.REL,
    '\u228C': exports.MO.BIN4,
    '\u228D': exports.MO.BIN4,
    '\u228E': exports.MO.BIN4,
    '\u228F': exports.MO.REL,
    '\u228F\u0338': exports.MO.REL,
    '\u2290': exports.MO.REL,
    '\u2290\u0338': exports.MO.REL,
    '\u2291': exports.MO.REL,
    '\u2292': exports.MO.REL,
    '\u2293': exports.MO.BIN4,
    '\u2294': exports.MO.BIN4,
    '\u2295': exports.MO.BIN4,
    '\u2296': exports.MO.BIN4,
    '\u2297': exports.MO.BIN4,
    '\u2298': exports.MO.BIN4,
    '\u2299': exports.MO.BIN4,
    '\u229A': exports.MO.BIN4,
    '\u229B': exports.MO.BIN4,
    '\u229C': exports.MO.BIN4,
    '\u229D': exports.MO.BIN4,
    '\u229E': exports.MO.BIN4,
    '\u229F': exports.MO.BIN4,
    '\u22A0': exports.MO.BIN4,
    '\u22A1': exports.MO.BIN4,
    '\u22A2': exports.MO.REL,
    '\u22A3': exports.MO.REL,
    '\u22A4': exports.MO.ORD55,
    '\u22A5': exports.MO.REL,
    '\u22A6': exports.MO.REL,
    '\u22A7': exports.MO.REL,
    '\u22A8': exports.MO.REL,
    '\u22A9': exports.MO.REL,
    '\u22AA': exports.MO.REL,
    '\u22AB': exports.MO.REL,
    '\u22AC': exports.MO.REL,
    '\u22AD': exports.MO.REL,
    '\u22AE': exports.MO.REL,
    '\u22AF': exports.MO.REL,
    '\u22B0': exports.MO.REL,
    '\u22B1': exports.MO.REL,
    '\u22B2': exports.MO.REL,
    '\u22B3': exports.MO.REL,
    '\u22B4': exports.MO.REL,
    '\u22B5': exports.MO.REL,
    '\u22B6': exports.MO.REL,
    '\u22B7': exports.MO.REL,
    '\u22B8': exports.MO.REL,
    '\u22B9': exports.MO.REL,
    '\u22BA': exports.MO.BIN4,
    '\u22BB': exports.MO.BIN4,
    '\u22BC': exports.MO.BIN4,
    '\u22BD': exports.MO.BIN4,
    '\u22BE': exports.MO.BIN3,
    '\u22BF': exports.MO.BIN3,
    '\u22C4': exports.MO.BIN4,
    '\u22C5': exports.MO.BIN4,
    '\u22C6': exports.MO.BIN4,
    '\u22C7': exports.MO.BIN4,
    '\u22C8': exports.MO.REL,
    '\u22C9': exports.MO.BIN4,
    '\u22CA': exports.MO.BIN4,
    '\u22CB': exports.MO.BIN4,
    '\u22CC': exports.MO.BIN4,
    '\u22CD': exports.MO.REL,
    '\u22CE': exports.MO.BIN4,
    '\u22CF': exports.MO.BIN4,
    '\u22D0': exports.MO.REL,
    '\u22D1': exports.MO.REL,
    '\u22D2': exports.MO.BIN4,
    '\u22D3': exports.MO.BIN4,
    '\u22D4': exports.MO.REL,
    '\u22D5': exports.MO.REL,
    '\u22D6': exports.MO.REL,
    '\u22D7': exports.MO.REL,
    '\u22D8': exports.MO.REL,
    '\u22D9': exports.MO.REL,
    '\u22DA': exports.MO.REL,
    '\u22DB': exports.MO.REL,
    '\u22DC': exports.MO.REL,
    '\u22DD': exports.MO.REL,
    '\u22DE': exports.MO.REL,
    '\u22DF': exports.MO.REL,
    '\u22E0': exports.MO.REL,
    '\u22E1': exports.MO.REL,
    '\u22E2': exports.MO.REL,
    '\u22E3': exports.MO.REL,
    '\u22E4': exports.MO.REL,
    '\u22E5': exports.MO.REL,
    '\u22E6': exports.MO.REL,
    '\u22E7': exports.MO.REL,
    '\u22E8': exports.MO.REL,
    '\u22E9': exports.MO.REL,
    '\u22EA': exports.MO.REL,
    '\u22EB': exports.MO.REL,
    '\u22EC': exports.MO.REL,
    '\u22ED': exports.MO.REL,
    '\u22EE': exports.MO.ORD55,
    '\u22EF': exports.MO.INNER,
    '\u22F0': exports.MO.REL,
    '\u22F1': [5, 5, MmlNode_js_1.TEXCLASS.INNER, null],
    '\u22F2': exports.MO.REL,
    '\u22F3': exports.MO.REL,
    '\u22F4': exports.MO.REL,
    '\u22F5': exports.MO.REL,
    '\u22F6': exports.MO.REL,
    '\u22F7': exports.MO.REL,
    '\u22F8': exports.MO.REL,
    '\u22F9': exports.MO.REL,
    '\u22FA': exports.MO.REL,
    '\u22FB': exports.MO.REL,
    '\u22FC': exports.MO.REL,
    '\u22FD': exports.MO.REL,
    '\u22FE': exports.MO.REL,
    '\u22FF': exports.MO.REL,
    '\u2305': exports.MO.BIN3,
    '\u2306': exports.MO.BIN3,
    '\u2322': exports.MO.REL4,
    '\u2323': exports.MO.REL4,
    '\u2329': exports.MO.OPEN,
    '\u232A': exports.MO.CLOSE,
    '\u23AA': exports.MO.ORD,
    '\u23AF': [0, 0, MmlNode_js_1.TEXCLASS.ORD, {
      stretchy: true
    }],
    '\u23B0': exports.MO.OPEN,
    '\u23B1': exports.MO.CLOSE,
    '\u2500': exports.MO.ORD,
    '\u25B3': exports.MO.BIN4,
    '\u25B5': exports.MO.BIN4,
    '\u25B9': exports.MO.BIN4,
    '\u25BD': exports.MO.BIN4,
    '\u25BF': exports.MO.BIN4,
    '\u25C3': exports.MO.BIN4,
    '\u25EF': exports.MO.BIN3,
    '\u2660': exports.MO.ORD,
    '\u2661': exports.MO.ORD,
    '\u2662': exports.MO.ORD,
    '\u2663': exports.MO.ORD,
    '\u2758': exports.MO.REL,
    '\u27F0': exports.MO.RELSTRETCH,
    '\u27F1': exports.MO.RELSTRETCH,
    '\u27F5': exports.MO.WIDEREL,
    '\u27F6': exports.MO.WIDEREL,
    '\u27F7': exports.MO.WIDEREL,
    '\u27F8': exports.MO.WIDEREL,
    '\u27F9': exports.MO.WIDEREL,
    '\u27FA': exports.MO.WIDEREL,
    '\u27FB': exports.MO.WIDEREL,
    '\u27FC': exports.MO.WIDEREL,
    '\u27FD': exports.MO.WIDEREL,
    '\u27FE': exports.MO.WIDEREL,
    '\u27FF': exports.MO.WIDEREL,
    '\u2900': exports.MO.RELACCENT,
    '\u2901': exports.MO.RELACCENT,
    '\u2902': exports.MO.RELACCENT,
    '\u2903': exports.MO.RELACCENT,
    '\u2904': exports.MO.RELACCENT,
    '\u2905': exports.MO.RELACCENT,
    '\u2906': exports.MO.RELACCENT,
    '\u2907': exports.MO.RELACCENT,
    '\u2908': exports.MO.REL,
    '\u2909': exports.MO.REL,
    '\u290A': exports.MO.RELSTRETCH,
    '\u290B': exports.MO.RELSTRETCH,
    '\u290C': exports.MO.WIDEREL,
    '\u290D': exports.MO.WIDEREL,
    '\u290E': exports.MO.WIDEREL,
    '\u290F': exports.MO.WIDEREL,
    '\u2910': exports.MO.WIDEREL,
    '\u2911': exports.MO.RELACCENT,
    '\u2912': exports.MO.RELSTRETCH,
    '\u2913': exports.MO.RELSTRETCH,
    '\u2914': exports.MO.RELACCENT,
    '\u2915': exports.MO.RELACCENT,
    '\u2916': exports.MO.RELACCENT,
    '\u2917': exports.MO.RELACCENT,
    '\u2918': exports.MO.RELACCENT,
    '\u2919': exports.MO.RELACCENT,
    '\u291A': exports.MO.RELACCENT,
    '\u291B': exports.MO.RELACCENT,
    '\u291C': exports.MO.RELACCENT,
    '\u291D': exports.MO.RELACCENT,
    '\u291E': exports.MO.RELACCENT,
    '\u291F': exports.MO.RELACCENT,
    '\u2920': exports.MO.RELACCENT,
    '\u2921': exports.MO.RELSTRETCH,
    '\u2922': exports.MO.RELSTRETCH,
    '\u2923': exports.MO.REL,
    '\u2924': exports.MO.REL,
    '\u2925': exports.MO.REL,
    '\u2926': exports.MO.REL,
    '\u2927': exports.MO.REL,
    '\u2928': exports.MO.REL,
    '\u2929': exports.MO.REL,
    '\u292A': exports.MO.REL,
    '\u292B': exports.MO.REL,
    '\u292C': exports.MO.REL,
    '\u292D': exports.MO.REL,
    '\u292E': exports.MO.REL,
    '\u292F': exports.MO.REL,
    '\u2930': exports.MO.REL,
    '\u2931': exports.MO.REL,
    '\u2932': exports.MO.REL,
    '\u2933': exports.MO.RELACCENT,
    '\u2934': exports.MO.REL,
    '\u2935': exports.MO.REL,
    '\u2936': exports.MO.REL,
    '\u2937': exports.MO.REL,
    '\u2938': exports.MO.REL,
    '\u2939': exports.MO.REL,
    '\u293A': exports.MO.RELACCENT,
    '\u293B': exports.MO.RELACCENT,
    '\u293C': exports.MO.RELACCENT,
    '\u293D': exports.MO.RELACCENT,
    '\u293E': exports.MO.REL,
    '\u293F': exports.MO.REL,
    '\u2940': exports.MO.REL,
    '\u2941': exports.MO.REL,
    '\u2942': exports.MO.RELACCENT,
    '\u2943': exports.MO.RELACCENT,
    '\u2944': exports.MO.RELACCENT,
    '\u2945': exports.MO.RELACCENT,
    '\u2946': exports.MO.RELACCENT,
    '\u2947': exports.MO.RELACCENT,
    '\u2948': exports.MO.RELACCENT,
    '\u2949': exports.MO.REL,
    '\u294A': exports.MO.RELACCENT,
    '\u294B': exports.MO.RELACCENT,
    '\u294C': exports.MO.REL,
    '\u294D': exports.MO.REL,
    '\u294E': exports.MO.WIDEREL,
    '\u294F': exports.MO.RELSTRETCH,
    '\u2950': exports.MO.WIDEREL,
    '\u2951': exports.MO.RELSTRETCH,
    '\u2952': exports.MO.WIDEREL,
    '\u2953': exports.MO.WIDEREL,
    '\u2954': exports.MO.RELSTRETCH,
    '\u2955': exports.MO.RELSTRETCH,
    '\u2956': exports.MO.RELSTRETCH,
    '\u2957': exports.MO.RELSTRETCH,
    '\u2958': exports.MO.RELSTRETCH,
    '\u2959': exports.MO.RELSTRETCH,
    '\u295A': exports.MO.WIDEREL,
    '\u295B': exports.MO.WIDEREL,
    '\u295C': exports.MO.RELSTRETCH,
    '\u295D': exports.MO.RELSTRETCH,
    '\u295E': exports.MO.WIDEREL,
    '\u295F': exports.MO.WIDEREL,
    '\u2960': exports.MO.RELSTRETCH,
    '\u2961': exports.MO.RELSTRETCH,
    '\u2962': exports.MO.RELACCENT,
    '\u2963': exports.MO.REL,
    '\u2964': exports.MO.RELACCENT,
    '\u2965': exports.MO.REL,
    '\u2966': exports.MO.RELACCENT,
    '\u2967': exports.MO.RELACCENT,
    '\u2968': exports.MO.RELACCENT,
    '\u2969': exports.MO.RELACCENT,
    '\u296A': exports.MO.RELACCENT,
    '\u296B': exports.MO.RELACCENT,
    '\u296C': exports.MO.RELACCENT,
    '\u296D': exports.MO.RELACCENT,
    '\u296E': exports.MO.RELSTRETCH,
    '\u296F': exports.MO.RELSTRETCH,
    '\u2970': exports.MO.RELACCENT,
    '\u2971': exports.MO.RELACCENT,
    '\u2972': exports.MO.RELACCENT,
    '\u2973': exports.MO.RELACCENT,
    '\u2974': exports.MO.RELACCENT,
    '\u2975': exports.MO.RELACCENT,
    '\u2976': exports.MO.RELACCENT,
    '\u2977': exports.MO.RELACCENT,
    '\u2978': exports.MO.RELACCENT,
    '\u2979': exports.MO.RELACCENT,
    '\u297A': exports.MO.RELACCENT,
    '\u297B': exports.MO.RELACCENT,
    '\u297C': exports.MO.RELACCENT,
    '\u297D': exports.MO.RELACCENT,
    '\u297E': exports.MO.REL,
    '\u297F': exports.MO.REL,
    '\u2981': exports.MO.BIN3,
    '\u2982': exports.MO.BIN3,
    '\u2999': exports.MO.BIN3,
    '\u299A': exports.MO.BIN3,
    '\u299B': exports.MO.BIN3,
    '\u299C': exports.MO.BIN3,
    '\u299D': exports.MO.BIN3,
    '\u299E': exports.MO.BIN3,
    '\u299F': exports.MO.BIN3,
    '\u29A0': exports.MO.BIN3,
    '\u29A1': exports.MO.BIN3,
    '\u29A2': exports.MO.BIN3,
    '\u29A3': exports.MO.BIN3,
    '\u29A4': exports.MO.BIN3,
    '\u29A5': exports.MO.BIN3,
    '\u29A6': exports.MO.BIN3,
    '\u29A7': exports.MO.BIN3,
    '\u29A8': exports.MO.BIN3,
    '\u29A9': exports.MO.BIN3,
    '\u29AA': exports.MO.BIN3,
    '\u29AB': exports.MO.BIN3,
    '\u29AC': exports.MO.BIN3,
    '\u29AD': exports.MO.BIN3,
    '\u29AE': exports.MO.BIN3,
    '\u29AF': exports.MO.BIN3,
    '\u29B0': exports.MO.BIN3,
    '\u29B1': exports.MO.BIN3,
    '\u29B2': exports.MO.BIN3,
    '\u29B3': exports.MO.BIN3,
    '\u29B4': exports.MO.BIN3,
    '\u29B5': exports.MO.BIN3,
    '\u29B6': exports.MO.BIN4,
    '\u29B7': exports.MO.BIN4,
    '\u29B8': exports.MO.BIN4,
    '\u29B9': exports.MO.BIN4,
    '\u29BA': exports.MO.BIN4,
    '\u29BB': exports.MO.BIN4,
    '\u29BC': exports.MO.BIN4,
    '\u29BD': exports.MO.BIN4,
    '\u29BE': exports.MO.BIN4,
    '\u29BF': exports.MO.BIN4,
    '\u29C0': exports.MO.REL,
    '\u29C1': exports.MO.REL,
    '\u29C2': exports.MO.BIN3,
    '\u29C3': exports.MO.BIN3,
    '\u29C4': exports.MO.BIN4,
    '\u29C5': exports.MO.BIN4,
    '\u29C6': exports.MO.BIN4,
    '\u29C7': exports.MO.BIN4,
    '\u29C8': exports.MO.BIN4,
    '\u29C9': exports.MO.BIN3,
    '\u29CA': exports.MO.BIN3,
    '\u29CB': exports.MO.BIN3,
    '\u29CC': exports.MO.BIN3,
    '\u29CD': exports.MO.BIN3,
    '\u29CE': exports.MO.REL,
    '\u29CF': exports.MO.REL,
    '\u29CF\u0338': exports.MO.REL,
    '\u29D0': exports.MO.REL,
    '\u29D0\u0338': exports.MO.REL,
    '\u29D1': exports.MO.REL,
    '\u29D2': exports.MO.REL,
    '\u29D3': exports.MO.REL,
    '\u29D4': exports.MO.REL,
    '\u29D5': exports.MO.REL,
    '\u29D6': exports.MO.BIN4,
    '\u29D7': exports.MO.BIN4,
    '\u29D8': exports.MO.BIN3,
    '\u29D9': exports.MO.BIN3,
    '\u29DB': exports.MO.BIN3,
    '\u29DC': exports.MO.BIN3,
    '\u29DD': exports.MO.BIN3,
    '\u29DE': exports.MO.REL,
    '\u29DF': exports.MO.BIN3,
    '\u29E0': exports.MO.BIN3,
    '\u29E1': exports.MO.REL,
    '\u29E2': exports.MO.BIN4,
    '\u29E3': exports.MO.REL,
    '\u29E4': exports.MO.REL,
    '\u29E5': exports.MO.REL,
    '\u29E6': exports.MO.REL,
    '\u29E7': exports.MO.BIN3,
    '\u29E8': exports.MO.BIN3,
    '\u29E9': exports.MO.BIN3,
    '\u29EA': exports.MO.BIN3,
    '\u29EB': exports.MO.BIN3,
    '\u29EC': exports.MO.BIN3,
    '\u29ED': exports.MO.BIN3,
    '\u29EE': exports.MO.BIN3,
    '\u29EF': exports.MO.BIN3,
    '\u29F0': exports.MO.BIN3,
    '\u29F1': exports.MO.BIN3,
    '\u29F2': exports.MO.BIN3,
    '\u29F3': exports.MO.BIN3,
    '\u29F4': exports.MO.REL,
    '\u29F5': exports.MO.BIN4,
    '\u29F6': exports.MO.BIN4,
    '\u29F7': exports.MO.BIN4,
    '\u29F8': exports.MO.BIN3,
    '\u29F9': exports.MO.BIN3,
    '\u29FA': exports.MO.BIN3,
    '\u29FB': exports.MO.BIN3,
    '\u29FE': exports.MO.BIN4,
    '\u29FF': exports.MO.BIN4,
    '\u2A1D': exports.MO.BIN3,
    '\u2A1E': exports.MO.BIN3,
    '\u2A1F': exports.MO.BIN3,
    '\u2A20': exports.MO.BIN3,
    '\u2A21': exports.MO.BIN3,
    '\u2A22': exports.MO.BIN4,
    '\u2A23': exports.MO.BIN4,
    '\u2A24': exports.MO.BIN4,
    '\u2A25': exports.MO.BIN4,
    '\u2A26': exports.MO.BIN4,
    '\u2A27': exports.MO.BIN4,
    '\u2A28': exports.MO.BIN4,
    '\u2A29': exports.MO.BIN4,
    '\u2A2A': exports.MO.BIN4,
    '\u2A2B': exports.MO.BIN4,
    '\u2A2C': exports.MO.BIN4,
    '\u2A2D': exports.MO.BIN4,
    '\u2A2E': exports.MO.BIN4,
    '\u2A2F': exports.MO.BIN4,
    '\u2A30': exports.MO.BIN4,
    '\u2A31': exports.MO.BIN4,
    '\u2A32': exports.MO.BIN4,
    '\u2A33': exports.MO.BIN4,
    '\u2A34': exports.MO.BIN4,
    '\u2A35': exports.MO.BIN4,
    '\u2A36': exports.MO.BIN4,
    '\u2A37': exports.MO.BIN4,
    '\u2A38': exports.MO.BIN4,
    '\u2A39': exports.MO.BIN4,
    '\u2A3A': exports.MO.BIN4,
    '\u2A3B': exports.MO.BIN4,
    '\u2A3C': exports.MO.BIN4,
    '\u2A3D': exports.MO.BIN4,
    '\u2A3E': exports.MO.BIN4,
    '\u2A3F': exports.MO.BIN4,
    '\u2A40': exports.MO.BIN4,
    '\u2A41': exports.MO.BIN4,
    '\u2A42': exports.MO.BIN4,
    '\u2A43': exports.MO.BIN4,
    '\u2A44': exports.MO.BIN4,
    '\u2A45': exports.MO.BIN4,
    '\u2A46': exports.MO.BIN4,
    '\u2A47': exports.MO.BIN4,
    '\u2A48': exports.MO.BIN4,
    '\u2A49': exports.MO.BIN4,
    '\u2A4A': exports.MO.BIN4,
    '\u2A4B': exports.MO.BIN4,
    '\u2A4C': exports.MO.BIN4,
    '\u2A4D': exports.MO.BIN4,
    '\u2A4E': exports.MO.BIN4,
    '\u2A4F': exports.MO.BIN4,
    '\u2A50': exports.MO.BIN4,
    '\u2A51': exports.MO.BIN4,
    '\u2A52': exports.MO.BIN4,
    '\u2A53': exports.MO.BIN4,
    '\u2A54': exports.MO.BIN4,
    '\u2A55': exports.MO.BIN4,
    '\u2A56': exports.MO.BIN4,
    '\u2A57': exports.MO.BIN4,
    '\u2A58': exports.MO.BIN4,
    '\u2A59': exports.MO.REL,
    '\u2A5A': exports.MO.BIN4,
    '\u2A5B': exports.MO.BIN4,
    '\u2A5C': exports.MO.BIN4,
    '\u2A5D': exports.MO.BIN4,
    '\u2A5E': exports.MO.BIN4,
    '\u2A5F': exports.MO.BIN4,
    '\u2A60': exports.MO.BIN4,
    '\u2A61': exports.MO.BIN4,
    '\u2A62': exports.MO.BIN4,
    '\u2A63': exports.MO.BIN4,
    '\u2A64': exports.MO.BIN4,
    '\u2A65': exports.MO.BIN4,
    '\u2A66': exports.MO.REL,
    '\u2A67': exports.MO.REL,
    '\u2A68': exports.MO.REL,
    '\u2A69': exports.MO.REL,
    '\u2A6A': exports.MO.REL,
    '\u2A6B': exports.MO.REL,
    '\u2A6C': exports.MO.REL,
    '\u2A6D': exports.MO.REL,
    '\u2A6E': exports.MO.REL,
    '\u2A6F': exports.MO.REL,
    '\u2A70': exports.MO.REL,
    '\u2A71': exports.MO.BIN4,
    '\u2A72': exports.MO.BIN4,
    '\u2A73': exports.MO.REL,
    '\u2A74': exports.MO.REL,
    '\u2A75': exports.MO.REL,
    '\u2A76': exports.MO.REL,
    '\u2A77': exports.MO.REL,
    '\u2A78': exports.MO.REL,
    '\u2A79': exports.MO.REL,
    '\u2A7A': exports.MO.REL,
    '\u2A7B': exports.MO.REL,
    '\u2A7C': exports.MO.REL,
    '\u2A7D': exports.MO.REL,
    '\u2A7D\u0338': exports.MO.REL,
    '\u2A7E': exports.MO.REL,
    '\u2A7E\u0338': exports.MO.REL,
    '\u2A7F': exports.MO.REL,
    '\u2A80': exports.MO.REL,
    '\u2A81': exports.MO.REL,
    '\u2A82': exports.MO.REL,
    '\u2A83': exports.MO.REL,
    '\u2A84': exports.MO.REL,
    '\u2A85': exports.MO.REL,
    '\u2A86': exports.MO.REL,
    '\u2A87': exports.MO.REL,
    '\u2A88': exports.MO.REL,
    '\u2A89': exports.MO.REL,
    '\u2A8A': exports.MO.REL,
    '\u2A8B': exports.MO.REL,
    '\u2A8C': exports.MO.REL,
    '\u2A8D': exports.MO.REL,
    '\u2A8E': exports.MO.REL,
    '\u2A8F': exports.MO.REL,
    '\u2A90': exports.MO.REL,
    '\u2A91': exports.MO.REL,
    '\u2A92': exports.MO.REL,
    '\u2A93': exports.MO.REL,
    '\u2A94': exports.MO.REL,
    '\u2A95': exports.MO.REL,
    '\u2A96': exports.MO.REL,
    '\u2A97': exports.MO.REL,
    '\u2A98': exports.MO.REL,
    '\u2A99': exports.MO.REL,
    '\u2A9A': exports.MO.REL,
    '\u2A9B': exports.MO.REL,
    '\u2A9C': exports.MO.REL,
    '\u2A9D': exports.MO.REL,
    '\u2A9E': exports.MO.REL,
    '\u2A9F': exports.MO.REL,
    '\u2AA0': exports.MO.REL,
    '\u2AA1': exports.MO.REL,
    '\u2AA1\u0338': exports.MO.REL,
    '\u2AA2': exports.MO.REL,
    '\u2AA2\u0338': exports.MO.REL,
    '\u2AA3': exports.MO.REL,
    '\u2AA4': exports.MO.REL,
    '\u2AA5': exports.MO.REL,
    '\u2AA6': exports.MO.REL,
    '\u2AA7': exports.MO.REL,
    '\u2AA8': exports.MO.REL,
    '\u2AA9': exports.MO.REL,
    '\u2AAA': exports.MO.REL,
    '\u2AAB': exports.MO.REL,
    '\u2AAC': exports.MO.REL,
    '\u2AAD': exports.MO.REL,
    '\u2AAE': exports.MO.REL,
    '\u2AAF': exports.MO.REL,
    '\u2AAF\u0338': exports.MO.REL,
    '\u2AB0': exports.MO.REL,
    '\u2AB0\u0338': exports.MO.REL,
    '\u2AB1': exports.MO.REL,
    '\u2AB2': exports.MO.REL,
    '\u2AB3': exports.MO.REL,
    '\u2AB4': exports.MO.REL,
    '\u2AB5': exports.MO.REL,
    '\u2AB6': exports.MO.REL,
    '\u2AB7': exports.MO.REL,
    '\u2AB8': exports.MO.REL,
    '\u2AB9': exports.MO.REL,
    '\u2ABA': exports.MO.REL,
    '\u2ABB': exports.MO.REL,
    '\u2ABC': exports.MO.REL,
    '\u2ABD': exports.MO.REL,
    '\u2ABE': exports.MO.REL,
    '\u2ABF': exports.MO.REL,
    '\u2AC0': exports.MO.REL,
    '\u2AC1': exports.MO.REL,
    '\u2AC2': exports.MO.REL,
    '\u2AC3': exports.MO.REL,
    '\u2AC4': exports.MO.REL,
    '\u2AC5': exports.MO.REL,
    '\u2AC6': exports.MO.REL,
    '\u2AC7': exports.MO.REL,
    '\u2AC8': exports.MO.REL,
    '\u2AC9': exports.MO.REL,
    '\u2ACA': exports.MO.REL,
    '\u2ACB': exports.MO.REL,
    '\u2ACC': exports.MO.REL,
    '\u2ACD': exports.MO.REL,
    '\u2ACE': exports.MO.REL,
    '\u2ACF': exports.MO.REL,
    '\u2AD0': exports.MO.REL,
    '\u2AD1': exports.MO.REL,
    '\u2AD2': exports.MO.REL,
    '\u2AD3': exports.MO.REL,
    '\u2AD4': exports.MO.REL,
    '\u2AD5': exports.MO.REL,
    '\u2AD6': exports.MO.REL,
    '\u2AD7': exports.MO.REL,
    '\u2AD8': exports.MO.REL,
    '\u2AD9': exports.MO.REL,
    '\u2ADA': exports.MO.REL,
    '\u2ADB': exports.MO.REL,
    '\u2ADC': exports.MO.REL,
    '\u2ADD': exports.MO.REL,
    '\u2ADE': exports.MO.REL,
    '\u2ADF': exports.MO.REL,
    '\u2AE0': exports.MO.REL,
    '\u2AE1': exports.MO.REL,
    '\u2AE2': exports.MO.REL,
    '\u2AE3': exports.MO.REL,
    '\u2AE4': exports.MO.REL,
    '\u2AE5': exports.MO.REL,
    '\u2AE6': exports.MO.REL,
    '\u2AE7': exports.MO.REL,
    '\u2AE8': exports.MO.REL,
    '\u2AE9': exports.MO.REL,
    '\u2AEA': exports.MO.REL,
    '\u2AEB': exports.MO.REL,
    '\u2AEC': exports.MO.REL,
    '\u2AED': exports.MO.REL,
    '\u2AEE': exports.MO.REL,
    '\u2AEF': exports.MO.REL,
    '\u2AF0': exports.MO.REL,
    '\u2AF1': exports.MO.REL,
    '\u2AF2': exports.MO.REL,
    '\u2AF3': exports.MO.REL,
    '\u2AF4': exports.MO.BIN4,
    '\u2AF5': exports.MO.BIN4,
    '\u2AF6': exports.MO.BIN4,
    '\u2AF7': exports.MO.REL,
    '\u2AF8': exports.MO.REL,
    '\u2AF9': exports.MO.REL,
    '\u2AFA': exports.MO.REL,
    '\u2AFB': exports.MO.BIN4,
    '\u2AFD': exports.MO.BIN4,
    '\u2AFE': exports.MO.BIN3,
    '\u2B45': exports.MO.RELSTRETCH,
    '\u2B46': exports.MO.RELSTRETCH,
    '\u3008': exports.MO.OPEN,
    '\u3009': exports.MO.CLOSE,
    '\uFE37': exports.MO.WIDEACCENT,
    '\uFE38': exports.MO.WIDEACCENT
  }
};
exports.OPTABLE['infix']['^'] = exports.MO.WIDEREL;
exports.OPTABLE['infix']['_'] = exports.MO.WIDEREL;
exports.OPTABLE['prefix']['\u2223'] = exports.MO.OPEN;
exports.OPTABLE['prefix']['\u2225'] = exports.MO.OPEN;
exports.OPTABLE['postfix']['\u2223'] = exports.MO.CLOSE;
exports.OPTABLE['postfix']['\u2225'] = exports.MO.CLOSE;

/***/ }),
/* 235 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var mathjax_js_1 = __webpack_require__(42);

function asyncLoad(name) {
  if (!mathjax_js_1.MathJax.asyncLoad) {
    return Promise.reject("Can't load '" + name + "': No asyncLoad method specified");
  }

  return new Promise(function (ok, fail) {
    var result = mathjax_js_1.MathJax.asyncLoad(name);

    if (result instanceof Promise) {
      result.then(function (value) {
        return ok(value);
      }).catch(function (err) {
        return fail(err);
      });
    } else {
      ok(result);
    }
  });
}

exports.asyncLoad = asyncLoad;

/***/ }),
/* 236 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var NodeUtil_js_1 = __webpack_require__(8);

var Stack = function () {
  function Stack(_factory, _env, inner) {
    this._factory = _factory;
    this._env = _env;
    this.global = {};
    this.stack = [];
    this.global = {
      isInner: inner
    };
    this.stack = [this._factory.create('start', this.global)];

    if (_env) {
      this.stack[0].env = _env;
    }

    this.env = this.stack[0].env;
  }

  Object.defineProperty(Stack.prototype, "env", {
    get: function () {
      return this._env;
    },
    set: function (env) {
      this._env = env;
    },
    enumerable: true,
    configurable: true
  });

  Stack.prototype.Push = function () {
    var args = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }

    try {
      for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
        var node = args_1_1.value;

        if (!node) {
          continue;
        }

        var item = NodeUtil_js_1.default.isNode(node) ? this._factory.create('mml', node) : node;
        item.global = this.global;

        var _a = __read(this.stack.length ? this.Top().checkItem(item) : [null, true], 2),
            top_1 = _a[0],
            success = _a[1];

        if (!success) {
          continue;
        }

        if (top_1) {
          this.Pop();
          this.Push.apply(this, __spread(top_1));
          continue;
        }

        this.stack.push(item);

        if (item.env) {
          Object.assign(item.env, this.env);
          this.env = item.env;
        } else {
          item.env = this.env;
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (args_1_1 && !args_1_1.done && (_b = args_1.return)) _b.call(args_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _b;
  };

  Stack.prototype.Pop = function () {
    var item = this.stack.pop();

    if (!item.isOpen) {
      delete item.env;
    }

    this.env = this.stack.length ? this.Top().env : {};
    return item;
  };

  Stack.prototype.Top = function (n) {
    if (n === void 0) {
      n = 1;
    }

    return this.stack.length < n ? null : this.stack[this.stack.length - n];
  };

  Stack.prototype.Prev = function (noPop) {
    var top = this.Top();
    return noPop ? top.First : top.Pop();
  };

  Stack.prototype.toString = function () {
    return 'stack[\n  ' + this.stack.join('\n  ') + '\n]';
  };

  return Stack;
}();

exports.default = Stack;

/***/ }),
/* 237 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var StackItemFactory_js_1 = __webpack_require__(238);

var MapHandler_js_1 = __webpack_require__(17);

var NodeFactory_js_1 = __webpack_require__(46);

var Options_js_1 = __webpack_require__(10);

var ParseOptions = function () {
  function ParseOptions(configuration, options) {
    if (options === void 0) {
      options = [];
    }

    this.options = {};
    this.parsers = [];
    this.root = null;
    this.nodeLists = {};
    this.error = false;
    this.handlers = new MapHandler_js_1.SubHandlers(configuration);
    this.nodeFactory = new NodeFactory_js_1.NodeFactory();
    this.nodeFactory.configuration = this;
    this.nodeFactory.setCreators(configuration.nodes);
    this.itemFactory = new StackItemFactory_js_1.default(configuration.items);
    this.itemFactory.configuration = this;
    Options_js_1.defaultOptions.apply(void 0, __spread([this.options], options));
    Options_js_1.defaultOptions(this.options, configuration.options);
  }

  ParseOptions.prototype.pushParser = function (parser) {
    this.parsers.unshift(parser);
  };

  ParseOptions.prototype.popParser = function () {
    this.parsers.shift();
  };

  Object.defineProperty(ParseOptions.prototype, "parser", {
    get: function () {
      return this.parsers[0];
    },
    enumerable: true,
    configurable: true
  });

  ParseOptions.prototype.clear = function () {
    this.parsers = [];
    this.root = null;
    this.nodeLists = {};
    this.error = false;
    this.tags.resetTag();
  };

  ParseOptions.prototype.addNode = function (property, node) {
    var list = this.nodeLists[property];

    if (!list) {
      list = this.nodeLists[property] = [];
    }

    list.push(node);
  };

  ParseOptions.prototype.getList = function (property) {
    var list = this.nodeLists[property] || [];
    var result = [];

    try {
      for (var list_1 = __values(list), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
        var node = list_1_1.value;

        if (this.inTree(node)) {
          result.push(node);
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (list_1_1 && !list_1_1.done && (_a = list_1.return)) _a.call(list_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    this.nodeLists[property] = result;
    return result;

    var e_1, _a;
  };

  ParseOptions.prototype.inTree = function (node) {
    while (node && node !== this.root) {
      node = node.parent;
    }

    return !!node;
  };

  return ParseOptions;
}();

exports.default = ParseOptions;

/***/ }),
/* 238 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var StackItem_js_1 = __webpack_require__(27);

var Factory_js_1 = __webpack_require__(45);

var DummyItem = function (_super) {
  __extends(DummyItem, _super);

  function DummyItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return DummyItem;
}(StackItem_js_1.BaseItem);

var StackItemFactory = function (_super) {
  __extends(StackItemFactory, _super);

  function StackItemFactory() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.defaultKind = 'dummy';
    _this.configuration = null;
    return _this;
  }

  return StackItemFactory;
}(Factory_js_1.AbstractFactory);

StackItemFactory.DefaultStackItems = (_a = {}, _a[DummyItem.prototype.kind] = DummyItem, _a);
exports.default = StackItemFactory;

var _a;

/***/ }),
/* 239 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var sm = __webpack_require__(5);

var TexConstants_js_1 = __webpack_require__(14);

var BaseMethods_js_1 = __webpack_require__(19);

var ParseMethods_js_1 = __webpack_require__(28);

var MmlNode_js_1 = __webpack_require__(0);

new sm.RegExpMap('letter', ParseMethods_js_1.default.variable, /[a-z]/i);
new sm.RegExpMap('digit', ParseMethods_js_1.default.digit, /[0-9.,]/);
new sm.RegExpMap('command', ParseMethods_js_1.default.controlSequence, /^\\/);
new sm.MacroMap('special', {
  '{': 'Open',
  '}': 'Close',
  '~': 'Tilde',
  '^': 'Superscript',
  '_': 'Subscript',
  ' ': 'Space',
  '\t': 'Space',
  '\r': 'Space',
  '\n': 'Space',
  '\'': 'Prime',
  '%': 'Comment',
  '&': 'Entry',
  '#': 'Hash',
  '\u00A0': 'Space',
  '\u2019': 'Prime'
}, BaseMethods_js_1.default);
new sm.CharacterMap('mathchar0mi', ParseMethods_js_1.default.mathchar0mi, {
  alpha: '\u03B1',
  beta: '\u03B2',
  gamma: '\u03B3',
  delta: '\u03B4',
  epsilon: '\u03F5',
  zeta: '\u03B6',
  eta: '\u03B7',
  theta: '\u03B8',
  iota: '\u03B9',
  kappa: '\u03BA',
  lambda: '\u03BB',
  mu: '\u03BC',
  nu: '\u03BD',
  xi: '\u03BE',
  omicron: '\u03BF',
  pi: '\u03C0',
  rho: '\u03C1',
  sigma: '\u03C3',
  tau: '\u03C4',
  upsilon: '\u03C5',
  phi: '\u03D5',
  chi: '\u03C7',
  psi: '\u03C8',
  omega: '\u03C9',
  varepsilon: '\u03B5',
  vartheta: '\u03D1',
  varpi: '\u03D6',
  varrho: '\u03F1',
  varsigma: '\u03C2',
  varphi: '\u03C6',
  S: ['\u00A7', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  aleph: ['\u2135', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  hbar: ['\u210F', {
    variantForm: true
  }],
  imath: '\u0131',
  jmath: '\u0237',
  ell: '\u2113',
  wp: ['\u2118', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  Re: ['\u211C', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  Im: ['\u2111', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  partial: ['\u2202', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  infty: ['\u221E', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  prime: ['\u2032', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL,
    variantForm: true
  }],
  emptyset: ['\u2205', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  nabla: ['\u2207', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  top: ['\u22A4', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  bot: ['\u22A5', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  angle: ['\u2220', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  triangle: ['\u25B3', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  backslash: ['\u2216', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL,
    variantForm: true
  }],
  forall: ['\u2200', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  exists: ['\u2203', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  neg: ['\u00AC', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  lnot: ['\u00AC', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  flat: ['\u266D', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  natural: ['\u266E', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  sharp: ['\u266F', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  clubsuit: ['\u2663', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  diamondsuit: ['\u2662', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  heartsuit: ['\u2661', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  spadesuit: ['\u2660', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }]
});
new sm.CharacterMap('mathchar0mo', ParseMethods_js_1.default.mathchar0mo, {
  surd: '\u221A',
  coprod: ['\u2210', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  bigvee: ['\u22C1', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  bigwedge: ['\u22C0', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  biguplus: ['\u2A04', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  bigcap: ['\u22C2', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  bigcup: ['\u22C3', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  'int': ['\u222B', {
    texClass: MmlNode_js_1.TEXCLASS.OP
  }],
  intop: ['\u222B', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true,
    movablelimits: true
  }],
  iint: ['\u222C', {
    texClass: MmlNode_js_1.TEXCLASS.OP
  }],
  iiint: ['\u222D', {
    texClass: MmlNode_js_1.TEXCLASS.OP
  }],
  prod: ['\u220F', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  sum: ['\u2211', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  bigotimes: ['\u2A02', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  bigoplus: ['\u2A01', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  bigodot: ['\u2A00', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  oint: ['\u222E', {
    texClass: MmlNode_js_1.TEXCLASS.OP
  }],
  bigsqcup: ['\u2A06', {
    texClass: MmlNode_js_1.TEXCLASS.OP,
    movesupsub: true
  }],
  smallint: ['\u222B', {
    largeop: false
  }],
  triangleleft: '\u25C3',
  triangleright: '\u25B9',
  bigtriangleup: '\u25B3',
  bigtriangledown: '\u25BD',
  wedge: '\u2227',
  land: '\u2227',
  vee: '\u2228',
  lor: '\u2228',
  cap: '\u2229',
  cup: '\u222A',
  ddagger: '\u2021',
  dagger: '\u2020',
  sqcap: '\u2293',
  sqcup: '\u2294',
  uplus: '\u228E',
  amalg: '\u2A3F',
  diamond: '\u22C4',
  bullet: '\u2219',
  wr: '\u2240',
  div: '\u00F7',
  odot: ['\u2299', {
    largeop: false
  }],
  oslash: ['\u2298', {
    largeop: false
  }],
  otimes: ['\u2297', {
    largeop: false
  }],
  ominus: ['\u2296', {
    largeop: false
  }],
  oplus: ['\u2295', {
    largeop: false
  }],
  mp: '\u2213',
  pm: '\u00B1',
  circ: '\u2218',
  bigcirc: '\u25EF',
  setminus: ['\u2216', {
    variantForm: true
  }],
  cdot: '\u22C5',
  ast: '\u2217',
  times: '\u00D7',
  star: '\u22C6',
  propto: '\u221D',
  sqsubseteq: '\u2291',
  sqsupseteq: '\u2292',
  parallel: '\u2225',
  mid: '\u2223',
  dashv: '\u22A3',
  vdash: '\u22A2',
  leq: '\u2264',
  le: '\u2264',
  geq: '\u2265',
  ge: '\u2265',
  lt: '\u003C',
  gt: '\u003E',
  succ: '\u227B',
  prec: '\u227A',
  approx: '\u2248',
  succeq: '\u2AB0',
  preceq: '\u2AAF',
  supset: '\u2283',
  subset: '\u2282',
  supseteq: '\u2287',
  subseteq: '\u2286',
  'in': '\u2208',
  ni: '\u220B',
  notin: '\u2209',
  owns: '\u220B',
  gg: '\u226B',
  ll: '\u226A',
  sim: '\u223C',
  simeq: '\u2243',
  perp: '\u22A5',
  equiv: '\u2261',
  asymp: '\u224D',
  smile: '\u2323',
  frown: '\u2322',
  ne: '\u2260',
  neq: '\u2260',
  cong: '\u2245',
  doteq: '\u2250',
  bowtie: '\u22C8',
  models: '\u22A8',
  notChar: '\u29F8',
  Leftrightarrow: '\u21D4',
  Leftarrow: '\u21D0',
  Rightarrow: '\u21D2',
  leftrightarrow: '\u2194',
  leftarrow: '\u2190',
  gets: '\u2190',
  rightarrow: '\u2192',
  to: '\u2192',
  mapsto: '\u21A6',
  leftharpoonup: '\u21BC',
  leftharpoondown: '\u21BD',
  rightharpoonup: '\u21C0',
  rightharpoondown: '\u21C1',
  nearrow: '\u2197',
  searrow: '\u2198',
  nwarrow: '\u2196',
  swarrow: '\u2199',
  rightleftharpoons: '\u21CC',
  hookrightarrow: '\u21AA',
  hookleftarrow: '\u21A9',
  longleftarrow: '\u27F5',
  Longleftarrow: '\u27F8',
  longrightarrow: '\u27F6',
  Longrightarrow: '\u27F9',
  Longleftrightarrow: '\u27FA',
  longleftrightarrow: '\u27F7',
  longmapsto: '\u27FC',
  ldots: '\u2026',
  cdots: '\u22EF',
  vdots: '\u22EE',
  ddots: '\u22F1',
  dotsc: '\u2026',
  dotsb: '\u22EF',
  dotsm: '\u22EF',
  dotsi: '\u22EF',
  dotso: '\u2026',
  ldotp: ['\u002E', {
    texClass: MmlNode_js_1.TEXCLASS.PUNCT
  }],
  cdotp: ['\u22C5', {
    texClass: MmlNode_js_1.TEXCLASS.PUNCT
  }],
  colon: ['\u003A', {
    texClass: MmlNode_js_1.TEXCLASS.PUNCT
  }]
});
new sm.CharacterMap('mathchar7', ParseMethods_js_1.default.mathchar7, {
  Gamma: '\u0393',
  Delta: '\u0394',
  Theta: '\u0398',
  Lambda: '\u039B',
  Xi: '\u039E',
  Pi: '\u03A0',
  Sigma: '\u03A3',
  Upsilon: '\u03A5',
  Phi: '\u03A6',
  Psi: '\u03A8',
  Omega: '\u03A9',
  '_': '\u005F',
  '#': '\u0023',
  '$': '\u0024',
  '%': '\u0025',
  '&': '\u0026',
  And: '\u0026'
});
new sm.DelimiterMap('delimiter', ParseMethods_js_1.default.delimiter, {
  '(': '(',
  ')': ')',
  '[': '[',
  ']': ']',
  '<': '\u27E8',
  '>': '\u27E9',
  '\\lt': '\u27E8',
  '\\gt': '\u27E9',
  '/': '/',
  '|': ['|', {
    texClass: MmlNode_js_1.TEXCLASS.ORD
  }],
  '.': '',
  '\\\\': '\\',
  '\\lmoustache': '\u23B0',
  '\\rmoustache': '\u23B1',
  '\\lgroup': '\u27EE',
  '\\rgroup': '\u27EF',
  '\\arrowvert': '\u23D0',
  '\\Arrowvert': '\u2016',
  '\\bracevert': '\u23AA',
  '\\Vert': ['\u2225', {
    texClass: MmlNode_js_1.TEXCLASS.ORD
  }],
  '\\|': ['\u2225', {
    texClass: MmlNode_js_1.TEXCLASS.ORD
  }],
  '\\vert': ['|', {
    texClass: MmlNode_js_1.TEXCLASS.ORD
  }],
  '\\uparrow': '\u2191',
  '\\downarrow': '\u2193',
  '\\updownarrow': '\u2195',
  '\\Uparrow': '\u21D1',
  '\\Downarrow': '\u21D3',
  '\\Updownarrow': '\u21D5',
  '\\backslash': '\\',
  '\\rangle': '\u27E9',
  '\\langle': '\u27E8',
  '\\rbrace': '}',
  '\\lbrace': '{',
  '\\}': '}',
  '\\{': '{',
  '\\rceil': '\u2309',
  '\\lceil': '\u2308',
  '\\rfloor': '\u230B',
  '\\lfloor': '\u230A',
  '\\lbrack': '[',
  '\\rbrack': ']'
});
new sm.CommandMap('macros', {
  displaystyle: ['SetStyle', 'D', true, 0],
  textstyle: ['SetStyle', 'T', false, 0],
  scriptstyle: ['SetStyle', 'S', false, 1],
  scriptscriptstyle: ['SetStyle', 'SS', false, 2],
  rm: ['SetFont', TexConstants_js_1.TexConstant.Variant.NORMAL],
  mit: ['SetFont', TexConstants_js_1.TexConstant.Variant.ITALIC],
  oldstyle: ['SetFont', TexConstants_js_1.TexConstant.Variant.OLDSTYLE],
  cal: ['SetFont', TexConstants_js_1.TexConstant.Variant.CALIGRAPHIC],
  it: ['SetFont', '-tex-mathit'],
  bf: ['SetFont', TexConstants_js_1.TexConstant.Variant.BOLD],
  bbFont: ['SetFont', TexConstants_js_1.TexConstant.Variant.DOUBLESTRUCK],
  scr: ['SetFont', TexConstants_js_1.TexConstant.Variant.SCRIPT],
  frak: ['SetFont', TexConstants_js_1.TexConstant.Variant.FRAKTUR],
  sf: ['SetFont', TexConstants_js_1.TexConstant.Variant.SANSSERIF],
  tt: ['SetFont', TexConstants_js_1.TexConstant.Variant.MONOSPACE],
  tiny: ['SetSize', 0.5],
  Tiny: ['SetSize', 0.6],
  scriptsize: ['SetSize', 0.7],
  small: ['SetSize', 0.85],
  normalsize: ['SetSize', 1.0],
  large: ['SetSize', 1.2],
  Large: ['SetSize', 1.44],
  LARGE: ['SetSize', 1.73],
  huge: ['SetSize', 2.07],
  Huge: ['SetSize', 2.49],
  arcsin: ['NamedFn'],
  arccos: ['NamedFn'],
  arctan: ['NamedFn'],
  arg: ['NamedFn'],
  cos: ['NamedFn'],
  cosh: ['NamedFn'],
  cot: ['NamedFn'],
  coth: ['NamedFn'],
  csc: ['NamedFn'],
  deg: ['NamedFn'],
  det: 'NamedOp',
  dim: ['NamedFn'],
  exp: ['NamedFn'],
  gcd: 'NamedOp',
  hom: ['NamedFn'],
  inf: 'NamedOp',
  ker: ['NamedFn'],
  lg: ['NamedFn'],
  lim: 'NamedOp',
  liminf: ['NamedOp', 'lim&thinsp;inf'],
  limsup: ['NamedOp', 'lim&thinsp;sup'],
  ln: ['NamedFn'],
  log: ['NamedFn'],
  max: 'NamedOp',
  min: 'NamedOp',
  Pr: 'NamedOp',
  sec: ['NamedFn'],
  sin: ['NamedFn'],
  sinh: ['NamedFn'],
  sup: 'NamedOp',
  tan: ['NamedFn'],
  tanh: ['NamedFn'],
  limits: ['Limits', 1],
  nolimits: ['Limits', 0],
  overline: ['UnderOver', '00AF', null, 1],
  underline: ['UnderOver', '005F'],
  overbrace: ['UnderOver', '23DE', 1],
  underbrace: ['UnderOver', '23DF', 1],
  overparen: ['UnderOver', '23DC'],
  underparen: ['UnderOver', '23DD'],
  overrightarrow: ['UnderOver', '2192'],
  underrightarrow: ['UnderOver', '2192'],
  overleftarrow: ['UnderOver', '2190'],
  underleftarrow: ['UnderOver', '2190'],
  overleftrightarrow: ['UnderOver', '2194'],
  underleftrightarrow: ['UnderOver', '2194'],
  overset: 'Overset',
  underset: 'Underset',
  stackrel: ['Macro', '\\mathrel{\\mathop{#2}\\limits^{#1}}', 2],
  over: 'Over',
  overwithdelims: 'Over',
  atop: 'Over',
  atopwithdelims: 'Over',
  above: 'Over',
  abovewithdelims: 'Over',
  brace: ['Over', '{', '}'],
  brack: ['Over', '[', ']'],
  choose: ['Over', '(', ')'],
  frac: 'Frac',
  sqrt: 'Sqrt',
  root: 'Root',
  uproot: ['MoveRoot', 'upRoot'],
  leftroot: ['MoveRoot', 'leftRoot'],
  left: 'LeftRight',
  right: 'LeftRight',
  middle: 'Middle',
  llap: 'Lap',
  rlap: 'Lap',
  raise: 'RaiseLower',
  lower: 'RaiseLower',
  moveleft: 'MoveLeftRight',
  moveright: 'MoveLeftRight',
  ',': ['Spacer', TexConstants_js_1.TexConstant.Length.THINMATHSPACE],
  ':': ['Spacer', TexConstants_js_1.TexConstant.Length.MEDIUMMATHSPACE],
  '>': ['Spacer', TexConstants_js_1.TexConstant.Length.MEDIUMMATHSPACE],
  ';': ['Spacer', TexConstants_js_1.TexConstant.Length.THICKMATHSPACE],
  '!': ['Spacer', TexConstants_js_1.TexConstant.Length.NEGATIVETHINMATHSPACE],
  enspace: ['Spacer', '.5em'],
  quad: ['Spacer', '1em'],
  qquad: ['Spacer', '2em'],
  thinspace: ['Spacer', TexConstants_js_1.TexConstant.Length.THINMATHSPACE],
  negthinspace: ['Spacer', TexConstants_js_1.TexConstant.Length.NEGATIVETHINMATHSPACE],
  hskip: 'Hskip',
  hspace: 'Hskip',
  kern: 'Hskip',
  mskip: 'Hskip',
  mspace: 'Hskip',
  mkern: 'Hskip',
  rule: 'rule',
  Rule: ['Rule'],
  Space: ['Rule', 'blank'],
  big: ['MakeBig', MmlNode_js_1.TEXCLASS.ORD, 0.85],
  Big: ['MakeBig', MmlNode_js_1.TEXCLASS.ORD, 1.15],
  bigg: ['MakeBig', MmlNode_js_1.TEXCLASS.ORD, 1.45],
  Bigg: ['MakeBig', MmlNode_js_1.TEXCLASS.ORD, 1.75],
  bigl: ['MakeBig', MmlNode_js_1.TEXCLASS.OPEN, 0.85],
  Bigl: ['MakeBig', MmlNode_js_1.TEXCLASS.OPEN, 1.15],
  biggl: ['MakeBig', MmlNode_js_1.TEXCLASS.OPEN, 1.45],
  Biggl: ['MakeBig', MmlNode_js_1.TEXCLASS.OPEN, 1.75],
  bigr: ['MakeBig', MmlNode_js_1.TEXCLASS.CLOSE, 0.85],
  Bigr: ['MakeBig', MmlNode_js_1.TEXCLASS.CLOSE, 1.15],
  biggr: ['MakeBig', MmlNode_js_1.TEXCLASS.CLOSE, 1.45],
  Biggr: ['MakeBig', MmlNode_js_1.TEXCLASS.CLOSE, 1.75],
  bigm: ['MakeBig', MmlNode_js_1.TEXCLASS.REL, 0.85],
  Bigm: ['MakeBig', MmlNode_js_1.TEXCLASS.REL, 1.15],
  biggm: ['MakeBig', MmlNode_js_1.TEXCLASS.REL, 1.45],
  Biggm: ['MakeBig', MmlNode_js_1.TEXCLASS.REL, 1.75],
  mathord: ['TeXAtom', MmlNode_js_1.TEXCLASS.ORD],
  mathop: ['TeXAtom', MmlNode_js_1.TEXCLASS.OP],
  mathopen: ['TeXAtom', MmlNode_js_1.TEXCLASS.OPEN],
  mathclose: ['TeXAtom', MmlNode_js_1.TEXCLASS.CLOSE],
  mathbin: ['TeXAtom', MmlNode_js_1.TEXCLASS.BIN],
  mathrel: ['TeXAtom', MmlNode_js_1.TEXCLASS.REL],
  mathpunct: ['TeXAtom', MmlNode_js_1.TEXCLASS.PUNCT],
  mathinner: ['TeXAtom', MmlNode_js_1.TEXCLASS.INNER],
  vcenter: ['TeXAtom', MmlNode_js_1.TEXCLASS.VCENTER],
  buildrel: 'BuildRel',
  hbox: ['HBox', 0],
  text: 'HBox',
  mbox: ['HBox', 0],
  fbox: 'FBox',
  strut: 'Strut',
  mathstrut: ['Macro', '\\vphantom{(}'],
  phantom: 'Phantom',
  vphantom: ['Phantom', 1, 0],
  hphantom: ['Phantom', 0, 1],
  smash: 'Smash',
  acute: ['Accent', '00B4'],
  grave: ['Accent', '0060'],
  ddot: ['Accent', '00A8'],
  tilde: ['Accent', '007E'],
  bar: ['Accent', '00AF'],
  breve: ['Accent', '02D8'],
  check: ['Accent', '02C7'],
  hat: ['Accent', '005E'],
  vec: ['Accent', '2192'],
  dot: ['Accent', '02D9'],
  widetilde: ['Accent', '007E', 1],
  widehat: ['Accent', '005E', 1],
  matrix: 'Matrix',
  array: 'Matrix',
  pmatrix: ['Matrix', '(', ')'],
  cases: ['Matrix', '{', '', 'left left', null, '.1em', null, true],
  eqalign: ['Matrix', null, null, 'right left', TexConstants_js_1.TexConstant.Length.THICKMATHSPACE, '.5em', 'D'],
  displaylines: ['Matrix', null, null, 'center', null, '.5em', 'D'],
  cr: 'Cr',
  '\\': 'CrLaTeX',
  newline: 'Cr',
  hline: ['HLine', 'solid'],
  hdashline: ['HLine', 'dashed'],
  eqalignno: ['Matrix', null, null, 'right left', TexConstants_js_1.TexConstant.Length.THICKMATHSPACE, '.5em', 'D', null, 'right'],
  leqalignno: ['Matrix', null, null, 'right left', TexConstants_js_1.TexConstant.Length.THICKMATHSPACE, '.5em', 'D', null, 'left'],
  hfill: 'HFill',
  hfil: 'HFill',
  hfilll: 'HFill',
  bmod: ['Macro', '\\mmlToken{mo}[lspace="thickmathspace"' + ' rspace="thickmathspace"]{mod}'],
  pmod: ['Macro', '\\pod{\\mmlToken{mi}{mod}\\kern 6mu #1}', 1],
  mod: ['Macro', '\\mathchoice{\\kern18mu}{\\kern12mu}' + '{\\kern12mu}{\\kern12mu}\\mmlToken{mi}{mod}\\,\\,#1', 1],
  pod: ['Macro', '\\mathchoice{\\kern18mu}{\\kern8mu}' + '{\\kern8mu}{\\kern8mu}(#1)', 1],
  iff: ['Macro', '\\;\\Longleftrightarrow\\;'],
  skew: ['Macro', '{{#2{#3\\mkern#1mu}\\mkern-#1mu}{}}', 3],
  mathcal: ['Macro', '{\\cal #1}', 1],
  mathscr: ['Macro', '{\\scr #1}', 1],
  mathrm: ['Macro', '{\\rm #1}', 1],
  mathbf: ['Macro', '{\\bf #1}', 1],
  mathbb: ['Macro', '{\\bbFont #1}', 1],
  Bbb: ['Macro', '{\\bbFont #1}', 1],
  mathit: ['Macro', '{\\it #1}', 1],
  mathfrak: ['Macro', '{\\frak #1}', 1],
  mathsf: ['Macro', '{\\sf #1}', 1],
  mathtt: ['Macro', '{\\tt #1}', 1],
  textrm: ['Macro', '\\mathord{\\rm\\text{#1}}', 1],
  textit: ['Macro', '\\mathord{\\it\\text{#1}}', 1],
  textbf: ['Macro', '\\mathord{\\bf\\text{#1}}', 1],
  textsf: ['Macro', '\\mathord{\\sf\\text{#1}}', 1],
  texttt: ['Macro', '\\mathord{\\tt\\text{#1}}', 1],
  pmb: ['Macro', '\\rlap{#1}\\kern1px{#1}', 1],
  TeX: ['Macro', 'T\\kern-.14em\\lower.5ex{E}\\kern-.115em X'],
  LaTeX: ['Macro', 'L\\kern-.325em\\raise.21em' + '{\\scriptstyle{A}}\\kern-.17em\\TeX'],
  ' ': ['Macro', '\\text{ }'],
  not: 'Not',
  dots: 'Dots',
  space: 'Tilde',
  '\u00A0': 'Tilde',
  begin: 'BeginEnd',
  end: 'BeginEnd',
  label: 'HandleLabel',
  ref: 'HandleRef',
  nonumber: 'HandleNoTag',
  color: 'Color',
  mathchoice: 'MathChoice',
  mmlToken: 'MmlToken'
}, BaseMethods_js_1.default);
var envs = new sm.EnvironmentMap('environment', ParseMethods_js_1.default.environment, {
  array: ['AlignedArray'],
  equation: ['Equation', null, true],
  'equation*': ['Equation', null, false],
  eqnarray: ['EqnArray', null, true, true, 'rcl', '0 ' + TexConstants_js_1.TexConstant.Length.THICKMATHSPACE, '.5em']
}, BaseMethods_js_1.default);
new sm.CharacterMap('not_remap', null, {
  '\u2190': '\u219A',
  '\u2192': '\u219B',
  '\u2194': '\u21AE',
  '\u21D0': '\u21CD',
  '\u21D2': '\u21CF',
  '\u21D4': '\u21CE',
  '\u2208': '\u2209',
  '\u220B': '\u220C',
  '\u2223': '\u2224',
  '\u2225': '\u2226',
  '\u223C': '\u2241',
  '\u007E': '\u2241',
  '\u2243': '\u2244',
  '\u2245': '\u2247',
  '\u2248': '\u2249',
  '\u224D': '\u226D',
  '\u003D': '\u2260',
  '\u2261': '\u2262',
  '\u003C': '\u226E',
  '\u003E': '\u226F',
  '\u2264': '\u2270',
  '\u2265': '\u2271',
  '\u2272': '\u2274',
  '\u2273': '\u2275',
  '\u2276': '\u2278',
  '\u2277': '\u2279',
  '\u227A': '\u2280',
  '\u227B': '\u2281',
  '\u2282': '\u2284',
  '\u2283': '\u2285',
  '\u2286': '\u2288',
  '\u2287': '\u2289',
  '\u22A2': '\u22AC',
  '\u22A8': '\u22AD',
  '\u22A9': '\u22AE',
  '\u22AB': '\u22AF',
  '\u227C': '\u22E0',
  '\u227D': '\u22E1',
  '\u2291': '\u22E2',
  '\u2292': '\u22E3',
  '\u22B2': '\u22EA',
  '\u22B3': '\u22EB',
  '\u22B4': '\u22EC',
  '\u22B5': '\u22ED',
  '\u2203': '\u2204'
});

/***/ }),
/* 240 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Entities = __webpack_require__(18);

Entities.add({
  Pcy: '\u041F',
  Poincareplane: '\u210C',
  Pr: '\u2ABB',
  Prime: '\u2033',
  Proportion: '\u2237',
  par: '\u2225',
  para: '\u00B6',
  parallel: '\u2225',
  parsim: '\u2AF3',
  parsl: '\u2AFD',
  part: '\u2202',
  pcy: '\u043F',
  percnt: '\u0025',
  permil: '\u2030',
  perp: '\u22A5',
  pertenk: '\u2031',
  phmmat: '\u2133',
  phone: '\u260E',
  pitchfork: '\u22D4',
  planck: '\u210F',
  planckh: '\u210E',
  plankv: '\u210F',
  plus: '\u002B',
  plusacir: '\u2A23',
  plusb: '\u229E',
  pluscir: '\u2A22',
  plusdo: '\u2214',
  plusdu: '\u2A25',
  pluse: '\u2A72',
  plusmn: '\u00B1',
  plussim: '\u2A26',
  plustwo: '\u2A27',
  pm: '\u00B1',
  pointint: '\u2A15',
  pound: '\u00A3',
  pr: '\u227A',
  prE: '\u2AB3',
  prcue: '\u227C',
  pre: '\u2AAF',
  prec: '\u227A',
  precapprox: '\u2AB7',
  preccurlyeq: '\u227C',
  preceq: '\u2AAF',
  precsim: '\u227E',
  primes: '\u2119',
  prnE: '\u2AB5',
  prnap: '\u2AB9',
  prnsim: '\u22E8',
  prod: '\u220F',
  profalar: '\u232E',
  profline: '\u2312',
  profsurf: '\u2313',
  prop: '\u221D',
  propto: '\u221D',
  prsim: '\u227E',
  prurel: '\u22B0',
  puncsp: '\u2008'
}, 'p');

/***/ }),
/* 241 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Entities = __webpack_require__(18);

Entities.add({
  RBarr: '\u2910',
  REG: '\u00AE',
  Racute: '\u0154',
  Rang: '\u27EB',
  Rarrtl: '\u2916',
  Rcaron: '\u0158',
  Rcedil: '\u0156',
  Rcy: '\u0420',
  ReverseElement: '\u220B',
  ReverseUpEquilibrium: '\u296F',
  Rho: '\u03A1',
  RightArrowBar: '\u21E5',
  RightDoubleBracket: '\u27E7',
  RightDownTeeVector: '\u295D',
  RightDownVectorBar: '\u2955',
  RightTeeVector: '\u295B',
  RightTriangleBar: '\u29D0',
  RightUpDownVector: '\u294F',
  RightUpTeeVector: '\u295C',
  RightUpVectorBar: '\u2954',
  RightVectorBar: '\u2953',
  RoundImplies: '\u2970',
  RuleDelayed: '\u29F4',
  rAarr: '\u21DB',
  rArr: '\u21D2',
  rAtail: '\u291C',
  rBarr: '\u290F',
  rHar: '\u2964',
  race: '\u223D\u0331',
  racute: '\u0155',
  radic: '\u221A',
  raemptyv: '\u29B3',
  rang: '\u27E9',
  rangd: '\u2992',
  range: '\u29A5',
  rangle: '\u27E9',
  raquo: '\u00BB',
  rarr: '\u2192',
  rarrap: '\u2975',
  rarrb: '\u21E5',
  rarrbfs: '\u2920',
  rarrc: '\u2933',
  rarrfs: '\u291E',
  rarrhk: '\u21AA',
  rarrlp: '\u21AC',
  rarrpl: '\u2945',
  rarrsim: '\u2974',
  rarrw: '\u219D',
  ratail: '\u291A',
  ratio: '\u2236',
  rationals: '\u211A',
  rbarr: '\u290D',
  rbbrk: '\u2773',
  rbrke: '\u298C',
  rbrksld: '\u298E',
  rbrkslu: '\u2990',
  rcaron: '\u0159',
  rcedil: '\u0157',
  rceil: '\u2309',
  rcub: '\u007D',
  rcy: '\u0440',
  rdca: '\u2937',
  rdldhar: '\u2969',
  rdquo: '\u201D',
  rdquor: '\u201D',
  rdsh: '\u21B3',
  real: '\u211C',
  realine: '\u211B',
  realpart: '\u211C',
  reals: '\u211D',
  rect: '\u25AD',
  reg: '\u00AE',
  rfisht: '\u297D',
  rfloor: '\u230B',
  rhard: '\u21C1',
  rharu: '\u21C0',
  rharul: '\u296C',
  rightarrow: '\u2192',
  rightarrowtail: '\u21A3',
  rightharpoondown: '\u21C1',
  rightharpoonup: '\u21C0',
  rightleftarrows: '\u21C4',
  rightleftharpoons: '\u21CC',
  rightsquigarrow: '\u219D',
  risingdotseq: '\u2253',
  rlarr: '\u21C4',
  rlhar: '\u21CC',
  rlm: '\u200F',
  rmoustache: '\u23B1',
  rnmid: '\u2AEE',
  roang: '\u27ED',
  roarr: '\u21FE',
  robrk: '\u27E7',
  ropar: '\u2986',
  roplus: '\u2A2E',
  rotimes: '\u2A35',
  rpar: '\u0029',
  rpargt: '\u2994',
  rppolint: '\u2A12',
  rrarr: '\u21C9',
  rsaquo: '\u203A',
  rsh: '\u21B1',
  rsqb: '\u005D',
  rsquo: '\u2019',
  rsquor: '\u2019',
  rthree: '\u22CC',
  rtrie: '\u22B5',
  rtrif: '\u25B8',
  rtriltri: '\u29CE',
  ruluhar: '\u2968',
  rx: '\u211E'
}, 'r');

/***/ }),
/* 242 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var OutputJax_js_1 = __webpack_require__(243);

var WrapperFactory_js_1 = __webpack_require__(245);

var tex_js_1 = __webpack_require__(296);

var CHTML = function (_super) {
  __extends(CHTML, _super);

  function CHTML(options) {
    if (options === void 0) {
      options = null;
    }

    var _this = _super.call(this, options, WrapperFactory_js_1.CHTMLWrapperFactory, tex_js_1.TeXFont) || this;

    _this.font.adaptiveCSS(_this.options.adaptiveCSS);

    return _this;
  }

  CHTML.prototype.escaped = function (math, html) {
    this.setDocument(html);
    return this.html('span', {}, [this.text(math.math)]);
  };

  CHTML.prototype.styleSheet = function (html) {
    var sheet = _super.prototype.styleSheet.call(this, html);

    this.adaptor.setAttribute(sheet, 'id', CHTML.STYLESHEETID);
    return sheet;
  };

  CHTML.prototype.addClassStyles = function (CLASS) {
    if (!this.options.adaptiveCSS || CLASS.used) {
      if (CLASS.autoStyle && CLASS.kind !== 'unknown') {
        this.cssStyles.addStyles((_a = {}, _a['mjx-' + CLASS.kind] = {
          display: 'inline-block',
          'text-align': 'left'
        }, _a));
      }

      _super.prototype.addClassStyles.call(this, CLASS);
    }

    var _a;
  };

  CHTML.prototype.processMath = function (math, parent) {
    this.factory.wrap(math).toCHTML(parent);
  };

  CHTML.prototype.clearCache = function () {
    this.cssStyles.clear();
    this.font.clearCache();

    try {
      for (var _a = __values(this.factory.getKinds()), _b = _a.next(); !_b.done; _b = _a.next()) {
        var kind = _b.value;
        this.factory.getNodeClass(kind).used = false;
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _c;
  };

  CHTML.prototype.unknownText = function (text, variant) {
    var styles = {};
    var scale = 100 / this.math.metrics.scale;

    if (scale !== 100) {
      styles['font-size'] = this.fixed(scale, 1) + '%';
    }

    if (variant !== '-explicitFont') {
      this.cssFontStyles(this.font.getCssFont(variant), styles);
    }

    return this.html('mjx-utext', {
      variant: variant,
      style: styles
    }, [this.text(text)]);
  };

  CHTML.prototype.measureTextNode = function (text) {
    var adaptor = this.adaptor;
    text = adaptor.clone(text);
    var node = this.html('mjx-measure-text', {}, [text]);
    adaptor.append(adaptor.parent(this.math.start.node), this.container);
    adaptor.append(this.container, node);
    var w = adaptor.nodeSize(text, this.math.metrics.em)[0] / this.math.metrics.scale;
    adaptor.remove(this.container);
    adaptor.remove(node);
    return {
      w: w,
      h: .75,
      d: .25
    };
  };

  CHTML.prototype.getFontData = function (styles) {
    var font = _super.prototype.getFontData.call(this, styles);

    font[0] = 'MJXZERO, ' + font[0];
    return font;
  };

  return CHTML;
}(OutputJax_js_1.CommonOutputJax);

CHTML.NAME = 'CHTML';
CHTML.OPTIONS = __assign({}, OutputJax_js_1.CommonOutputJax.OPTIONS, {
  adaptiveCSS: true
});
CHTML.commonStyles = {
  'mjx-container [space="1"]': {
    'margin-left': '.111em'
  },
  'mjx-container [space="2"]': {
    'margin-left': '.167em'
  },
  'mjx-container [space="3"]': {
    'margin-left': '.222em'
  },
  'mjx-container [space="4"]': {
    'margin-left': '.278em'
  },
  'mjx-container [space="5"]': {
    'margin-left': '.333em'
  },
  'mjx-container [rspace="1"]': {
    'margin-right': '.111em'
  },
  'mjx-container [rspace="2"]': {
    'margin-right': '.167em'
  },
  'mjx-container [rspace="3"]': {
    'margin-right': '.222em'
  },
  'mjx-container [rspace="4"]': {
    'margin-right': '.278em'
  },
  'mjx-container [rspace="5"]': {
    'margin-right': '.333em'
  },
  'mjx-container [size="s"]': {
    'font-size': '70.7%'
  },
  'mjx-container [size="ss"]': {
    'font-size': '50%'
  },
  'mjx-container [size="Tn"]': {
    'font-size': '60%'
  },
  'mjx-container [size="sm"]': {
    'font-size': '85%'
  },
  'mjx-container [size="lg"]': {
    'font-size': '120%'
  },
  'mjx-container [size="Lg"]': {
    'font-size': '144%'
  },
  'mjx-container [size="LG"]': {
    'font-size': '173%'
  },
  'mjx-container [size="hg"]': {
    'font-size': '207%'
  },
  'mjx-container [size="HG"]': {
    'font-size': '249%'
  },
  'mjx-container [width="full"]': {
    width: '100%'
  },
  'mjx-box': {
    display: 'inline-block'
  },
  'mjx-block': {
    display: 'block'
  },
  'mjx-itable': {
    display: 'inline-table'
  },
  'mjx-row': {
    display: 'table-row'
  },
  'mjx-row > *': {
    display: 'table-cell'
  },
  'mjx-mtext': {
    display: 'inline-block'
  },
  'mjx-mstyle': {
    display: 'inline-block'
  },
  'mjx-merror': {
    display: 'inline-block',
    color: 'red',
    'background-color': 'yellow'
  },
  'mjx-mphantom': {
    visibility: 'hidden'
  }
};
CHTML.STYLESHEETID = 'MJX-CHTML-styles';
exports.CHTML = CHTML;

/***/ }),
/* 243 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var OutputJax_js_1 = __webpack_require__(73);

var Options_js_1 = __webpack_require__(10);

var CssStyles_js_1 = __webpack_require__(244);

var lengths_js_1 = __webpack_require__(22);

var Styles_js_1 = __webpack_require__(74);

var CommonOutputJax = function (_super) {
  __extends(CommonOutputJax, _super);

  function CommonOutputJax(options, defaultFactory, defaultFont) {
    if (options === void 0) {
      options = null;
    }

    if (defaultFactory === void 0) {
      defaultFactory = null;
    }

    if (defaultFont === void 0) {
      defaultFont = null;
    }

    var _this = this;

    var _a = __read(Options_js_1.separateOptions(options, defaultFont.OPTIONS), 2),
        jaxOptions = _a[0],
        fontOptions = _a[1];

    _this = _super.call(this, jaxOptions) || this;
    _this.factory = _this.options.wrapperFactory || new defaultFactory();
    _this.factory.jax = _this;
    _this.cssStyles = _this.options.cssStyles || new CssStyles_js_1.CssStyles();
    _this.font = _this.options.font || new defaultFont(fontOptions);
    _this.unknownCache = new Map();
    return _this;
  }

  CommonOutputJax.prototype.typeset = function (math, html) {
    this.setDocument(html);
    var node = this.createNode();
    this.toDOM(math, node, html);
    return node;
  };

  CommonOutputJax.prototype.createNode = function () {
    var jax = this.constructor.NAME;
    return this.html('mjx-container', {
      'class': 'MathJax',
      jax: jax
    });
  };

  CommonOutputJax.prototype.setScale = function (node) {
    var scale = this.math.metrics.scale * this.options.scale;

    if (scale !== 1) {
      this.adaptor.setStyle(node, 'fontSize', lengths_js_1.percent(scale));
    }
  };

  CommonOutputJax.prototype.toDOM = function (math, node, html) {
    if (html === void 0) {
      html = null;
    }

    this.setDocument(html);
    this.math = math;
    this.pxPerEm = math.metrics.ex / this.font.params.x_height;
    math.root.setTeXclass(null);
    this.setScale(node);
    this.nodeMap = new Map();
    this.container = node;
    this.processMath(math.root, node);
    this.nodeMap = null;
    this.executeFilters(this.postFilters, math, node);
  };

  CommonOutputJax.prototype.getBBox = function (math, html) {
    this.setDocument(html);
    this.math = math;
    math.root.setTeXclass(null);
    this.nodeMap = new Map();
    var bbox = this.factory.wrap(math.root).getBBox();
    this.nodeMap = null;
    return bbox;
  };

  CommonOutputJax.prototype.getMetrics = function (html) {
    this.setDocument(html);
    var adaptor = this.adaptor;
    var maps = this.getMetricMaps(html);

    try {
      for (var _a = __values(html.math), _b = _a.next(); !_b.done; _b = _a.next()) {
        var math = _b.value;
        var map = maps[math.display ? 1 : 0];

        var _c = map.get(adaptor.parent(math.start.node)),
            em = _c.em,
            ex = _c.ex,
            containerWidth = _c.containerWidth,
            lineWidth = _c.lineWidth,
            scale = _c.scale;

        math.setMetrics(em, ex, containerWidth, lineWidth, scale);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _d;
  };

  CommonOutputJax.prototype.getMetricMaps = function (html) {
    var adaptor = this.adaptor;
    var domMaps = [new Map(), new Map()];

    try {
      for (var _a = __values(html.math), _b = _a.next(); !_b.done; _b = _a.next()) {
        var math = _b.value;
        var node = adaptor.parent(math.start.node);
        var map = domMaps[math.display ? 1 : 0];

        if (!map.has(node)) {
          map.set(node, this.getTestElement(node, math.display));
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var maps = [new Map(), new Map()];

    try {
      for (var _d = __values(maps.keys()), _e = _d.next(); !_e.done; _e = _d.next()) {
        var i = _e.value;

        try {
          for (var _f = __values(domMaps[i].keys()), _g = _f.next(); !_g.done; _g = _f.next()) {
            var node = _g.value;
            maps[i].set(node, this.measureMetrics(domMaps[i].get(node)));
          }
        } catch (e_3_1) {
          e_3 = {
            error: e_3_1
          };
        } finally {
          try {
            if (_g && !_g.done && (_h = _f.return)) _h.call(_f);
          } finally {
            if (e_3) throw e_3.error;
          }
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_e && !_e.done && (_j = _d.return)) _j.call(_d);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    try {
      for (var _k = __values(maps.keys()), _l = _k.next(); !_l.done; _l = _k.next()) {
        var i = _l.value;

        try {
          for (var _m = __values(domMaps[i].values()), _o = _m.next(); !_o.done; _o = _m.next()) {
            var node = _o.value;
            adaptor.remove(node);
          }
        } catch (e_5_1) {
          e_5 = {
            error: e_5_1
          };
        } finally {
          try {
            if (_o && !_o.done && (_p = _m.return)) _p.call(_m);
          } finally {
            if (e_5) throw e_5.error;
          }
        }
      }
    } catch (e_6_1) {
      e_6 = {
        error: e_6_1
      };
    } finally {
      try {
        if (_l && !_l.done && (_q = _k.return)) _q.call(_k);
      } finally {
        if (e_6) throw e_6.error;
      }
    }

    return maps;

    var e_2, _c, e_4, _j, e_3, _h, e_6, _q, e_5, _p;
  };

  CommonOutputJax.prototype.getTestElement = function (node, display) {
    var adaptor = this.adaptor;

    if (!this.testInline) {
      this.testInline = this.html('mjx-test', {
        style: {
          display: 'inline-block',
          width: '100%',
          'font-style': 'normal',
          'font-weight': 'normal',
          'font-size': '100%',
          'font-size-adjust': 'none',
          'text-indent': 0,
          'text-transform': 'none',
          'letter-spacing': 'normal',
          'word-spacing': 'normal',
          overflow: 'hidden',
          height: '1px',
          'margin-right': '-1px'
        }
      }, [this.html('mjx-left-box', {
        style: {
          display: 'inline-block',
          width: 0,
          'float': 'left'
        }
      }), this.html('mjx-ex-box', {
        style: {
          position: 'absolute',
          overflow: 'hidden',
          width: '1px',
          height: '60ex'
        }
      }), this.html('mjx-right-box', {
        style: {
          display: 'inline-block',
          width: 0,
          'float': 'right'
        }
      })]);
      this.testDisplay = adaptor.clone(this.testInline);
      adaptor.setStyle(this.testDisplay, 'display', 'table');
      adaptor.setStyle(this.testDisplay, 'margin-right', '');
      adaptor.setStyle(adaptor.firstChild(this.testDisplay), 'display', 'none');
      var right = adaptor.lastChild(this.testDisplay);
      adaptor.setStyle(right, 'display', 'table-cell');
      adaptor.setStyle(right, 'width', '10000em');
      adaptor.setStyle(right, 'float', '');
    }

    return adaptor.append(node, adaptor.clone(display ? this.testDisplay : this.testInline));
  };

  CommonOutputJax.prototype.measureMetrics = function (node) {
    var adaptor = this.adaptor;
    var em = adaptor.fontSize(node);
    var ex = adaptor.nodeSize(adaptor.childNode(node, 1))[1] / 60 || em * this.options.exFactor;
    var containerWidth = adaptor.getStyle(node, 'display') === 'table' ? adaptor.nodeSize(adaptor.lastChild(node))[0] - 1 : adaptor.nodeBBox(adaptor.lastChild(node)).left - adaptor.nodeBBox(adaptor.firstChild(node)).left - 2;
    var scale = ex / this.font.params.x_height / em;
    var lineWidth = 1000000;
    return {
      em: em,
      ex: ex,
      containerWidth: containerWidth,
      lineWidth: lineWidth,
      scale: scale
    };
  };

  CommonOutputJax.prototype.styleSheet = function (html) {
    this.setDocument(html);
    this.cssStyles.clear();
    this.cssStyles.addStyles(this.constructor.commonStyles);

    try {
      for (var _a = __values(this.factory.getKinds()), _b = _a.next(); !_b.done; _b = _a.next()) {
        var kind = _b.value;
        this.addClassStyles(this.factory.getNodeClass(kind));
      }
    } catch (e_7_1) {
      e_7 = {
        error: e_7_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_7) throw e_7.error;
      }
    }

    this.cssStyles.addStyles(this.font.styles);
    var sheet = this.html('style', {
      id: 'MJX-styles'
    }, [this.text('\n' + this.cssStyles.cssText + '\n')]);
    return sheet;

    var e_7, _c;
  };

  CommonOutputJax.prototype.addClassStyles = function (CLASS) {
    this.cssStyles.addStyles(CLASS.styles);
  };

  CommonOutputJax.prototype.setDocument = function (html) {
    if (html) {
      this.document = html;
      this.adaptor.document = html.document;
    }
  };

  CommonOutputJax.prototype.html = function (type, def, content, ns) {
    if (def === void 0) {
      def = {};
    }

    if (content === void 0) {
      content = [];
    }

    return this.adaptor.node(type, def, content, ns);
  };

  CommonOutputJax.prototype.text = function (text) {
    return this.adaptor.text(text);
  };

  CommonOutputJax.prototype.fixed = function (m, n) {
    if (n === void 0) {
      n = 3;
    }

    if (Math.abs(m) < .0006) {
      return '0';
    }

    return m.toFixed(n).replace(/\.?0+$/, '');
  };

  CommonOutputJax.prototype.measureText = function (text, variant, font) {
    if (font === void 0) {
      font = ['', false, false];
    }

    var node = this.unknownText(text, variant);

    if (variant === '-explicitFont') {
      var styles = this.cssFontStyles(font);
      this.adaptor.setAttributes(node, {
        style: styles
      });
    }

    return this.measureTextNodeWithCache(node, text, variant, font);
  };

  CommonOutputJax.prototype.measureTextNodeWithCache = function (text, chars, variant, font) {
    if (font === void 0) {
      font = ['', false, false];
    }

    if (variant === '-explicitFont') {
      variant = [font[0], font[1] ? 'T' : 'F', font[2] ? 'T' : 'F', ''].join('-');
    }

    if (!this.unknownCache.has(variant)) {
      this.unknownCache.set(variant, new Map());
    }

    var map = this.unknownCache.get(variant);
    var cached = map.get(chars);
    if (cached) return cached;
    var bbox = this.measureTextNode(text);
    map.set(chars, bbox);
    return bbox;
  };

  CommonOutputJax.prototype.cssFontStyles = function (font, styles) {
    if (styles === void 0) {
      styles = {};
    }

    var _a = __read(font, 3),
        family = _a[0],
        italic = _a[1],
        bold = _a[2];

    styles['font-family'] = family;
    if (italic) styles['font-style'] = 'italic';
    if (bold) styles['font-weight'] = 'bold';
    return styles;
  };

  CommonOutputJax.prototype.getFontData = function (styles) {
    if (!styles) {
      styles = new Styles_js_1.Styles();
    }

    return [styles.get('font-family'), styles.get('font-style') === 'italic', styles.get('font-weight') === 'bold'];
  };

  return CommonOutputJax;
}(OutputJax_js_1.AbstractOutputJax);

CommonOutputJax.NAME = 'Common';
CommonOutputJax.OPTIONS = __assign({}, OutputJax_js_1.AbstractOutputJax.OPTIONS, {
  scale: 1,
  mathmlSpacing: false,
  skipAttributes: {},
  exFactor: .5,
  displayAlign: 'center',
  displayIndent: '0',
  wrapperFactory: null,
  font: null,
  cssStyles: null
});
CommonOutputJax.commonStyles = {};
exports.CommonOutputJax = CommonOutputJax;

/***/ }),
/* 244 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var CssStyles = function () {
  function CssStyles(styles) {
    if (styles === void 0) {
      styles = null;
    }

    this.styles = {};
    this.addStyles(styles);
  }

  Object.defineProperty(CssStyles.prototype, "cssText", {
    get: function () {
      return this.getStyleString();
    },
    enumerable: true,
    configurable: true
  });

  CssStyles.prototype.addStyles = function (styles) {
    if (!styles) return;

    try {
      for (var _a = __values(Object.keys(styles)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var style = _b.value;

        if (!this.styles[style]) {
          this.styles[style] = {};
        }

        Object.assign(this.styles[style], styles[style]);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _c;
  };

  CssStyles.prototype.removeStyles = function () {
    var selectors = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      selectors[_i] = arguments[_i];
    }

    try {
      for (var selectors_1 = __values(selectors), selectors_1_1 = selectors_1.next(); !selectors_1_1.done; selectors_1_1 = selectors_1.next()) {
        var selector = selectors_1_1.value;
        delete this.styles[selector];
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (selectors_1_1 && !selectors_1_1.done && (_a = selectors_1.return)) _a.call(selectors_1);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_2, _a;
  };

  CssStyles.prototype.clear = function () {
    this.styles = {};
  };

  CssStyles.prototype.getStyleString = function () {
    var selectors = Object.keys(this.styles);
    var defs = new Array(selectors.length);
    var i = 0;

    try {
      for (var selectors_2 = __values(selectors), selectors_2_1 = selectors_2.next(); !selectors_2_1.done; selectors_2_1 = selectors_2.next()) {
        var selector = selectors_2_1.value;
        defs[i++] = selector + ' {\n' + this.getStyleDefString(this.styles[selector]) + '\n}';
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (selectors_2_1 && !selectors_2_1.done && (_a = selectors_2.return)) _a.call(selectors_2);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    return defs.join('\n\n');

    var e_3, _a;
  };

  CssStyles.prototype.getStyleDefString = function (styles) {
    var properties = Object.keys(styles);
    var values = new Array(properties.length);
    var i = 0;

    try {
      for (var properties_1 = __values(properties), properties_1_1 = properties_1.next(); !properties_1_1.done; properties_1_1 = properties_1.next()) {
        var property = properties_1_1.value;
        values[i++] = '  ' + property + ': ' + styles[property] + ';';
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (properties_1_1 && !properties_1_1.done && (_a = properties_1.return)) _a.call(properties_1);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    return values.join('\n');

    var e_4, _a;
  };

  return CssStyles;
}();

exports.CssStyles = CssStyles;

/***/ }),
/* 245 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var WrapperFactory_js_1 = __webpack_require__(246);

var Wrappers_js_1 = __webpack_require__(248);

var CHTMLWrapperFactory = function (_super) {
  __extends(CHTMLWrapperFactory, _super);

  function CHTMLWrapperFactory() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return CHTMLWrapperFactory;
}(WrapperFactory_js_1.CommonWrapperFactory);

CHTMLWrapperFactory.defaultNodes = Wrappers_js_1.CHTMLWrappers;
exports.CHTMLWrapperFactory = CHTMLWrapperFactory;

/***/ }),
/* 246 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var WrapperFactory_js_1 = __webpack_require__(247);

var CommonWrapperFactory = function (_super) {
  __extends(CommonWrapperFactory, _super);

  function CommonWrapperFactory() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.jax = null;
    return _this;
  }

  Object.defineProperty(CommonWrapperFactory.prototype, "Wrappers", {
    get: function () {
      return this.node;
    },
    enumerable: true,
    configurable: true
  });
  return CommonWrapperFactory;
}(WrapperFactory_js_1.AbstractWrapperFactory);

CommonWrapperFactory.defaultNodes = {};
exports.CommonWrapperFactory = CommonWrapperFactory;

/***/ }),
/* 247 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Factory_js_1 = __webpack_require__(45);

var AbstractWrapperFactory = function (_super) {
  __extends(AbstractWrapperFactory, _super);

  function AbstractWrapperFactory() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  AbstractWrapperFactory.prototype.wrap = function (node) {
    var args = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      args[_i - 1] = arguments[_i];
    }

    return this.create.apply(this, __spread([node.kind, node], args));
  };

  return AbstractWrapperFactory;
}(Factory_js_1.AbstractFactory);

exports.AbstractWrapperFactory = AbstractWrapperFactory;

/***/ }),
/* 248 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var math_js_1 = __webpack_require__(251);

var mi_js_1 = __webpack_require__(253);

var mo_js_1 = __webpack_require__(255);

var mn_js_1 = __webpack_require__(257);

var ms_js_1 = __webpack_require__(259);

var mspace_js_1 = __webpack_require__(261);

var mpadded_js_1 = __webpack_require__(263);

var menclose_js_1 = __webpack_require__(265);

var mrow_js_1 = __webpack_require__(268);

var mfenced_js_1 = __webpack_require__(269);

var mfrac_js_1 = __webpack_require__(271);

var msqrt_js_1 = __webpack_require__(87);

var mroot_js_1 = __webpack_require__(274);

var msubsup_js_1 = __webpack_require__(50);

var munderover_js_1 = __webpack_require__(278);

var mmultiscripts_js_1 = __webpack_require__(279);

var mtable_js_1 = __webpack_require__(281);

var mtr_js_1 = __webpack_require__(284);

var mtd_js_1 = __webpack_require__(285);

var maction_js_1 = __webpack_require__(287);

var mglyph_js_1 = __webpack_require__(288);

var semantics_js_1 = __webpack_require__(290);

var TeXAtom_js_1 = __webpack_require__(292);

var TextNode_js_1 = __webpack_require__(294);

exports.CHTMLWrappers = (_a = {}, _a[math_js_1.CHTMLmath.kind] = math_js_1.CHTMLmath, _a[mrow_js_1.CHTMLmrow.kind] = mrow_js_1.CHTMLmrow, _a[mrow_js_1.CHTMLinferredMrow.kind] = mrow_js_1.CHTMLinferredMrow, _a[mi_js_1.CHTMLmi.kind] = mi_js_1.CHTMLmi, _a[mo_js_1.CHTMLmo.kind] = mo_js_1.CHTMLmo, _a[mn_js_1.CHTMLmn.kind] = mn_js_1.CHTMLmn, _a[ms_js_1.CHTMLms.kind] = ms_js_1.CHTMLms, _a[mspace_js_1.CHTMLmspace.kind] = mspace_js_1.CHTMLmspace, _a[mpadded_js_1.CHTMLmpadded.kind] = mpadded_js_1.CHTMLmpadded, _a[menclose_js_1.CHTMLmenclose.kind] = menclose_js_1.CHTMLmenclose, _a[mfrac_js_1.CHTMLmfrac.kind] = mfrac_js_1.CHTMLmfrac, _a[msqrt_js_1.CHTMLmsqrt.kind] = msqrt_js_1.CHTMLmsqrt, _a[mroot_js_1.CHTMLmroot.kind] = mroot_js_1.CHTMLmroot, _a[msubsup_js_1.CHTMLmsub.kind] = msubsup_js_1.CHTMLmsub, _a[msubsup_js_1.CHTMLmsup.kind] = msubsup_js_1.CHTMLmsup, _a[msubsup_js_1.CHTMLmsubsup.kind] = msubsup_js_1.CHTMLmsubsup, _a[munderover_js_1.CHTMLmunder.kind] = munderover_js_1.CHTMLmunder, _a[munderover_js_1.CHTMLmover.kind] = munderover_js_1.CHTMLmover, _a[munderover_js_1.CHTMLmunderover.kind] = munderover_js_1.CHTMLmunderover, _a[mmultiscripts_js_1.CHTMLmmultiscripts.kind] = mmultiscripts_js_1.CHTMLmmultiscripts, _a[mfenced_js_1.CHTMLmfenced.kind] = mfenced_js_1.CHTMLmfenced, _a[mtable_js_1.CHTMLmtable.kind] = mtable_js_1.CHTMLmtable, _a[mtr_js_1.CHTMLmtr.kind] = mtr_js_1.CHTMLmtr, _a[mtr_js_1.CHTMLmlabeledtr.kind] = mtr_js_1.CHTMLmlabeledtr, _a[mtd_js_1.CHTMLmtd.kind] = mtd_js_1.CHTMLmtd, _a[maction_js_1.CHTMLmaction.kind] = maction_js_1.CHTMLmaction, _a[mglyph_js_1.CHTMLmglyph.kind] = mglyph_js_1.CHTMLmglyph, _a[semantics_js_1.CHTMLsemantics.kind] = semantics_js_1.CHTMLsemantics, _a[semantics_js_1.CHTMLannotation.kind] = semantics_js_1.CHTMLannotation, _a[semantics_js_1.CHTMLannotationXML.kind] = semantics_js_1.CHTMLannotationXML, _a[semantics_js_1.CHTMLxml.kind] = semantics_js_1.CHTMLxml, _a[TeXAtom_js_1.CHTMLTeXAtom.kind] = TeXAtom_js_1.CHTMLTeXAtom, _a[TextNode_js_1.CHTMLTextNode.kind] = TextNode_js_1.CHTMLTextNode, _a[Wrapper_js_1.CHTMLWrapper.kind] = Wrapper_js_1.CHTMLWrapper, _a);

var _a;

/***/ }),
/* 249 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(250);

var MmlNode_js_1 = __webpack_require__(0);

var string_js_1 = __webpack_require__(16);

var LENGTHS = __webpack_require__(22);

var Styles_js_1 = __webpack_require__(74);

var BBox_js_1 = __webpack_require__(23);

var FontData_js_1 = __webpack_require__(29);

var SMALLSIZE = 2 / 18;

function MathMLSpace(script, size) {
  return script ? size < SMALLSIZE ? 0 : SMALLSIZE : size;
}

var CommonWrapper = function (_super) {
  __extends(CommonWrapper, _super);

  function CommonWrapper(factory, node, parent) {
    if (parent === void 0) {
      parent = null;
    }

    var _this = _super.call(this, factory, node) || this;

    _this.parent = null;
    _this.removedStyles = null;
    _this.styles = null;
    _this.variant = '';
    _this.bboxComputed = false;
    _this.stretch = FontData_js_1.NOSTRETCH;
    _this.font = null;
    _this.parent = parent;
    _this.font = factory.jax.font;
    _this.bbox = BBox_js_1.BBox.zero();

    _this.getStyles();

    _this.getVariant();

    _this.getScale();

    _this.getSpace();

    _this.childNodes = node.childNodes.map(function (child) {
      var wrapped = _this.wrap(child);

      if (wrapped.bbox.pwidth && (node.notParent || node.isKind('math'))) {
        _this.bbox.pwidth = BBox_js_1.BBox.fullWidth;
      }

      return wrapped;
    });
    return _this;
  }

  Object.defineProperty(CommonWrapper.prototype, "jax", {
    get: function () {
      return this.factory.jax;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(CommonWrapper.prototype, "adaptor", {
    get: function () {
      return this.factory.jax.adaptor;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(CommonWrapper.prototype, "metrics", {
    get: function () {
      return this.factory.jax.math.metrics;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(CommonWrapper.prototype, "fixesPWidth", {
    get: function () {
      return !this.node.notParent && !this.node.isToken;
    },
    enumerable: true,
    configurable: true
  });

  CommonWrapper.prototype.wrap = function (node, parent) {
    if (parent === void 0) {
      parent = null;
    }

    var wrapped = this.factory.wrap(node, parent || this);

    if (parent) {
      parent.childNodes.push(wrapped);
    }

    this.jax.nodeMap.set(node, wrapped);
    return wrapped;
  };

  CommonWrapper.prototype.getBBox = function (save) {
    if (save === void 0) {
      save = true;
    }

    if (this.bboxComputed) {
      return this.bbox;
    }

    var bbox = save ? this.bbox : BBox_js_1.BBox.zero();
    this.computeBBox(bbox);
    this.bboxComputed = save;
    return bbox;
  };

  CommonWrapper.prototype.computeBBox = function (bbox, recompute) {
    if (recompute === void 0) {
      recompute = false;
    }

    bbox.empty();

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        bbox.append(child.getBBox());
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    bbox.clean();

    if (this.fixesPWidth && this.setChildPWidths(recompute)) {
      this.computeBBox(bbox, true);
    }

    var e_1, _c;
  };

  CommonWrapper.prototype.setChildPWidths = function (recompute, w, clear) {
    if (w === void 0) {
      w = null;
    }

    if (clear === void 0) {
      clear = true;
    }

    if (recompute) {
      return false;
    }

    if (clear) {
      this.bbox.pwidth = '';
    }

    var changed = false;

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        var cbox = child.getBBox();

        if (cbox.pwidth && child.setChildPWidths(recompute, w === null ? cbox.w : w, clear)) {
          changed = true;
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    return changed;

    var e_2, _c;
  };

  CommonWrapper.prototype.invalidateBBox = function () {
    if (this.bboxComputed) {
      this.bboxComputed = false;

      if (this.parent) {
        this.parent.invalidateBBox();
      }
    }
  };

  CommonWrapper.prototype.copySkewIC = function (bbox) {
    var first = this.childNodes[0];

    if (first && first.bbox.sk) {
      bbox.sk = first.bbox.sk;
    }

    var last = this.childNodes[this.childNodes.length - 1];

    if (last && last.bbox.ic) {
      bbox.ic = last.bbox.ic;
      bbox.w += bbox.ic;
    }
  };

  CommonWrapper.prototype.getStyles = function () {
    var styleString = this.node.attributes.getExplicit('style');
    if (!styleString) return;
    var style = this.styles = new Styles_js_1.Styles(styleString);

    for (var i = 0, m = CommonWrapper.removeStyles.length; i < m; i++) {
      var id = CommonWrapper.removeStyles[i];

      if (style.get(id)) {
        if (!this.removedStyles) this.removedStyles = {};
        this.removedStyles[id] = style.get(id);
        style.set(id, '');
      }
    }
  };

  CommonWrapper.prototype.getVariant = function () {
    if (!this.node.isToken) return;
    var attributes = this.node.attributes;
    var variant = attributes.get('mathvariant');

    if (!attributes.getExplicit('mathvariant')) {
      var values = attributes.getList('fontfamily', 'fontweight', 'fontstyle');

      if (this.removedStyles) {
        var style = this.removedStyles;
        if (style.fontFamily) values.family = style.fontFamily;
        if (style.fontWeight) values.weight = style.fontWeight;
        if (style.fontStyle) values.style = style.fontStyle;
      }

      if (values.fontfamily) values.family = values.fontfamily;
      if (values.fontweight) values.weight = values.fontweight;
      if (values.fontstyle) values.style = values.fontstyle;

      if (values.weight && values.weight.match(/^\d+$/)) {
        values.weight = parseInt(values.weight) > 600 ? 'bold' : 'normal';
      }

      if (values.family) {
        variant = this.explicitVariant(values.family, values.weight, values.style);
      } else {
        if (this.node.getProperty('variantForm')) variant = '-tex-variant';
        variant = (CommonWrapper.BOLDVARIANTS[values.weight] || {})[variant] || variant;
        variant = (CommonWrapper.ITALICVARIANTS[values.style] || {})[variant] || variant;
      }
    }

    this.variant = variant;
  };

  CommonWrapper.prototype.explicitVariant = function (fontFamily, fontWeight, fontStyle) {
    var style = this.styles;
    if (!style) style = this.styles = new Styles_js_1.Styles();
    style.set('fontFamily', fontFamily);
    if (fontWeight) style.set('fontWeight', fontWeight);
    if (fontStyle) style.set('fontStyle', fontStyle);
    return '-explicitFont';
  };

  CommonWrapper.prototype.getScale = function () {
    var scale = 1,
        parent = this.parent;
    var pscale = parent ? parent.bbox.scale : 1;
    var attributes = this.node.attributes;
    var scriptlevel = Math.min(attributes.get('scriptlevel'), 2);
    var fontsize = attributes.get('fontsize');
    var mathsize = this.node.isToken || this.node.isKind('mstyle') ? attributes.get('mathsize') : attributes.getInherited('mathsize');

    if (scriptlevel !== 0) {
      scale = Math.pow(attributes.get('scriptsizemultiplier'), scriptlevel);
      var scriptminsize = this.length2em(attributes.get('scriptminsize'), .8, 1);
      if (scale < scriptminsize) scale = scriptminsize;
    }

    if (this.removedStyles && this.removedStyles.fontSize && !fontsize) {
      fontsize = this.removedStyles.fontSize;
    }

    if (fontsize && !mathsize) {
      mathsize = fontsize;
    }

    if (mathsize !== '1') {
      scale *= this.length2em(mathsize, 1, 1);
    }

    this.bbox.scale = scale;
    this.bbox.rscale = scale / pscale;
  };

  CommonWrapper.prototype.getSpace = function () {
    var isTop = this.isTopEmbellished();
    var hasSpacing = this.node.hasSpacingAttributes();

    if (this.jax.options.mathmlSpacing || hasSpacing) {
      isTop && this.getMathMLSpacing();
    } else {
      this.getTeXSpacing(isTop, hasSpacing);
    }
  };

  CommonWrapper.prototype.getMathMLSpacing = function () {
    var node = this.node.coreMO();
    var attributes = node.attributes;
    var parent = this.jax.nodeMap.get(node.coreParent());
    var isScript = attributes.get('scriptlevel') > 0;
    this.bbox.L = attributes.isSet('lspace') ? Math.max(0, this.length2em(attributes.get('lspace'))) : MathMLSpace(isScript, node.lspace);
    this.bbox.R = attributes.isSet('rspace') ? Math.max(0, this.length2em(attributes.get('rspace'))) : MathMLSpace(isScript, node.rspace);
  };

  CommonWrapper.prototype.getTeXSpacing = function (isTop, hasSpacing) {
    if (!hasSpacing) {
      var space = this.node.texSpacing();

      if (space) {
        this.bbox.L = this.length2em(space);
      }
    }

    if (isTop || hasSpacing) {
      var attributes = this.node.coreMO().attributes;

      if (attributes.isSet('lspace')) {
        this.bbox.L = Math.max(0, this.length2em(attributes.get('lspace')));
      }

      if (attributes.isSet('rspace')) {
        this.bbox.R = Math.max(0, this.length2em(attributes.get('rspace')));
      }
    }
  };

  CommonWrapper.prototype.isTopEmbellished = function () {
    return this.node.isEmbellished && !(this.node.Parent && this.node.Parent.isEmbellished);
  };

  CommonWrapper.prototype.core = function () {
    return this.jax.nodeMap.get(this.node.core());
  };

  CommonWrapper.prototype.coreMO = function () {
    return this.jax.nodeMap.get(this.node.coreMO());
  };

  CommonWrapper.prototype.getText = function () {
    var text = '';

    if (this.node.isToken) {
      try {
        for (var _a = __values(this.node.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;

          if (child instanceof MmlNode_js_1.TextNode) {
            text += child.getText();
          }
        }
      } catch (e_3_1) {
        e_3 = {
          error: e_3_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_3) throw e_3.error;
        }
      }
    }

    return text;

    var e_3, _c;
  };

  CommonWrapper.prototype.canStretch = function (direction) {
    this.stretch = FontData_js_1.NOSTRETCH;

    if (this.node.isEmbellished) {
      var core = this.core();

      if (core && core.node !== this.node) {
        if (core.canStretch(direction)) {
          this.stretch = core.stretch;
        }
      }
    }

    return this.stretch.dir !== 0;
  };

  CommonWrapper.prototype.getAlignShift = function () {
    var _a = (_b = this.node.attributes).getList.apply(_b, __spread(MmlNode_js_1.indentAttributes)),
        indentalign = _a.indentalign,
        indentshift = _a.indentshift,
        indentalignfirst = _a.indentalignfirst,
        indentshiftfirst = _a.indentshiftfirst;

    if (indentalignfirst !== 'indentalign') {
      indentalign = indentalignfirst;
    }

    if (indentalign === 'auto') {
      indentalign = this.jax.options.displayAlign;
    }

    if (indentshiftfirst !== 'indentshift') {
      indentshift = indentshiftfirst;
    }

    if (indentshift === 'auto') {
      indentshift = this.jax.options.displayIndent;

      if (indentalign === 'right' && !indentshift.match(/^\s*0[a-z]*\s*$/)) {
        indentshift = ('-' + indentshift.trim()).replace(/^--/, '');
      }
    }

    var shift = this.length2em(indentshift, this.metrics.containerWidth);
    return [indentalign, shift];

    var _b;
  };

  CommonWrapper.prototype.getAlignX = function (W, bbox, align) {
    return align === 'right' ? W - (bbox.w + bbox.R) * bbox.rscale : align === 'left' ? bbox.L * bbox.rscale : (W - bbox.w * bbox.rscale) / 2;
  };

  CommonWrapper.prototype.getAlignY = function (H, D, h, d, align) {
    return align === 'top' ? H - h : align === 'bottom' ? d - D : align === 'middle' ? (H - h - (D - d)) / 2 : 0;
  };

  CommonWrapper.prototype.getWrapWidth = function (i) {
    return this.childNodes[i].getBBox().w;
  };

  CommonWrapper.prototype.getChildAlign = function (i) {
    return 'left';
  };

  CommonWrapper.prototype.percent = function (m) {
    return LENGTHS.percent(m);
  };

  CommonWrapper.prototype.em = function (m) {
    return LENGTHS.em(m);
  };

  CommonWrapper.prototype.px = function (m, M) {
    if (M === void 0) {
      M = -LENGTHS.BIGDIMEN;
    }

    return LENGTHS.px(m, M, this.metrics.em);
  };

  CommonWrapper.prototype.length2em = function (length, size, scale) {
    if (size === void 0) {
      size = 1;
    }

    if (scale === void 0) {
      scale = null;
    }

    if (scale === null) {
      scale = this.bbox.scale;
    }

    return LENGTHS.length2em(length, size, scale, this.jax.pxPerEm);
  };

  CommonWrapper.prototype.unicodeChars = function (text) {
    return string_js_1.unicodeChars(text);
  };

  CommonWrapper.prototype.remapChars = function (chars) {
    return chars;
  };

  CommonWrapper.prototype.mmlText = function (text) {
    return this.node.factory.create('text').setText(text);
  };

  CommonWrapper.prototype.mmlNode = function (kind, properties, children) {
    if (properties === void 0) {
      properties = {};
    }

    if (children === void 0) {
      children = [];
    }

    return this.node.factory.create(kind, properties, children);
  };

  CommonWrapper.prototype.createMo = function (text) {
    var mmlFactory = this.node.factory;
    var textNode = mmlFactory.create('text').setText(text);
    var mml = mmlFactory.create('mo', {
      stretchy: true
    }, [textNode]);
    mml.inheritAttributesFrom(this.node);
    var node = this.wrap(mml);
    node.parent = this;
    return node;
  };

  CommonWrapper.prototype.getVariantChar = function (variant, n) {
    var char = this.font.getChar(variant, n) || [0, 0, 0, {
      unknown: true
    }];

    if (char.length === 3) {
      char[3] = {};
    }

    return char;
  };

  return CommonWrapper;
}(Wrapper_js_1.AbstractWrapper);

CommonWrapper.kind = 'unknown';
CommonWrapper.styles = {};
CommonWrapper.removeStyles = ['fontSize', 'fontFamily', 'fontWeight', 'fontStyle', 'fontVariant', 'font'];
CommonWrapper.skipAttributes = {
  fontfamily: true,
  fontsize: true,
  fontweight: true,
  fontstyle: true,
  color: true,
  background: true,
  'class': true,
  href: true,
  style: true,
  xmlns: true
};
CommonWrapper.BOLDVARIANTS = {
  bold: {
    normal: 'bold',
    italic: 'bold-italic',
    fraktur: 'bold-fraktur',
    script: 'bold-script',
    'sans-serif': 'bold-sans-serif',
    'sans-serif-italic': 'sans-serif-bold-italic'
  },
  normal: {
    bold: 'normal',
    'bold-italic': 'italic',
    'bold-fraktur': 'fraktur',
    'bold-script': 'script',
    'bold-sans-serif': 'sans-serif',
    'sans-serif-bold-italic': 'sans-serif-italic'
  }
};
CommonWrapper.ITALICVARIANTS = {
  italic: {
    normal: 'italic',
    bold: 'bold-italic',
    'sans-serif': 'sans-serif-italic',
    'bold-sans-serif': 'sans-serif-bold-italic'
  },
  normal: {
    italic: 'normal',
    'bold-italic': 'bold',
    'sans-serif-italic': 'sans-serif',
    'sans-serif-bold-italic': 'bold-sans-serif'
  }
};
exports.CommonWrapper = CommonWrapper;

/***/ }),
/* 250 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var AbstractWrapper = function () {
  function AbstractWrapper(factory, node) {
    this.factory = factory;
    this.node = node;
  }

  Object.defineProperty(AbstractWrapper.prototype, "kind", {
    get: function () {
      return this.node.kind;
    },
    enumerable: true,
    configurable: true
  });

  AbstractWrapper.prototype.wrap = function (node) {
    return this.factory.wrap(node);
  };

  return AbstractWrapper;
}();

exports.AbstractWrapper = AbstractWrapper;

/***/ }),
/* 251 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var math_js_1 = __webpack_require__(252);

var math_js_2 = __webpack_require__(76);

var CHTMLmath = function (_super) {
  __extends(CHTMLmath, _super);

  function CHTMLmath() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmath.prototype.toCHTML = function (parent) {
    _super.prototype.toCHTML.call(this, parent);

    var chtml = this.chtml;
    var adaptor = this.adaptor;
    var attributes = this.node.attributes;
    var display = attributes.get('display') === 'block';

    if (display) {
      adaptor.setAttribute(chtml, 'display', 'true');
      adaptor.setAttribute(parent, 'display', 'true');
    } else {
      var margin = adaptor.getStyle(chtml, 'margin-right');

      if (margin) {
        adaptor.setStyle(chtml, 'margin-right', '');
        adaptor.setStyle(parent, 'margin-right', margin);
        adaptor.setStyle(parent, 'width', '0');
      }
    }

    adaptor.addClass(chtml, 'MJX-TEX');

    var _a = __read(this.getAlignShift(), 2),
        align = _a[0],
        shift = _a[1];

    if (align !== 'center') {
      adaptor.setAttribute(parent, 'justify', align);
    }

    if (display && shift && !adaptor.hasAttribute(chtml, 'width')) {
      this.setIndent(chtml, align, shift);
    }

    var speech = attributes.get('data-semantic-speech');

    if (speech && !attributes.get('aria-label')) {
      adaptor.setAttribute(this.chtml, 'aria-label', speech);

      if (attributes.get('data-semantic-speech')) {
        try {
          for (var _b = __values(this.childNodes[0].childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
            var child = _c.value;
            adaptor.setAttribute(child.chtml, 'aria-hidden', 'true');
          }
        } catch (e_1_1) {
          e_1 = {
            error: e_1_1
          };
        } finally {
          try {
            if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
          } finally {
            if (e_1) throw e_1.error;
          }
        }
      }
    }

    var e_1, _d;
  };

  CHTMLmath.prototype.setChildPWidths = function (recompute, w, clear) {
    if (w === void 0) {
      w = null;
    }

    if (clear === void 0) {
      clear = true;
    }

    return this.parent ? _super.prototype.setChildPWidths.call(this, recompute, w) : false;
  };

  return CHTMLmath;
}(math_js_1.CommonMathMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmath.kind = math_js_2.MmlMath.prototype.kind;
CHTMLmath.styles = {
  'mjx-math': {
    'line-height': 0,
    'text-align': 'left',
    'text-indent': 0,
    'font-style': 'normal',
    'font-weight': 'normal',
    'font-size': '100%',
    'font-size-adjust': 'none',
    'letter-spacing': 'normal',
    'word-wrap': 'normal',
    'word-spacing': 'normal',
    'white-space': 'nowrap',
    'direction': 'ltr',
    'padding': '1px 0'
  },
  'mjx-container[jax="CHTML"][display="true"]': {
    display: 'block',
    'text-align': 'center',
    margin: '1em 0'
  },
  'mjx-container[jax="CHTML"][display="true"] mjx-math': {
    padding: 0
  },
  'mjx-container[jax="CHTML"][justify="left"]': {
    'text-align': 'left'
  },
  'mjx-container[jax="CHTML"][justify="right"]': {
    'text-align': 'right'
  }
};
exports.CHTMLmath = CHTMLmath;

/***/ }),
/* 252 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMathMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    class_1.prototype.getWrapWidth = function (i) {
      return this.parent ? this.getBBox().w : this.metrics.containerWidth / this.jax.pxPerEm;
    };

    return class_1;
  }(Base);
}

exports.CommonMathMixin = CommonMathMixin;

/***/ }),
/* 253 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mi_js_1 = __webpack_require__(254);

var mi_js_2 = __webpack_require__(77);

var CHTMLmi = function (_super) {
  __extends(CHTMLmi, _super);

  function CHTMLmi() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmi.prototype.toCHTML = function (parent) {
    _super.prototype.toCHTML.call(this, parent);

    if (this.noIC) {
      this.adaptor.setAttribute(this.chtml, 'noIC', 'true');
    }
  };

  return CHTMLmi;
}(mi_js_1.CommonMiMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmi.kind = mi_js_2.MmlMi.prototype.kind;
exports.CHTMLmi = CHTMLmi;

/***/ }),
/* 254 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMiMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var _this = _super !== null && _super.apply(this, arguments) || this;

      _this.noIC = false;
      return _this;
    }

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      _super.prototype.computeBBox.call(this, bbox);

      this.copySkewIC(bbox);

      if (this.noIC) {
        bbox.w -= bbox.ic;
      }
    };

    return class_1;
  }(Base);
}

exports.CommonMiMixin = CommonMiMixin;

/***/ }),
/* 255 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mo_js_1 = __webpack_require__(256);

var mo_js_2 = __webpack_require__(34);

var BBox_js_1 = __webpack_require__(75);

var CHTMLmo = function (_super) {
  __extends(CHTMLmo, _super);

  function CHTMLmo() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmo.prototype.toCHTML = function (parent) {
    var attributes = this.node.attributes;
    var symmetric = attributes.get('symmetric') && this.stretch.dir !== 2;
    var stretchy = this.stretch.dir !== 0;

    if (stretchy && this.size === null) {
      this.getStretchedVariant([]);
    }

    var chtml = this.standardCHTMLnode(parent);

    if (this.noIC) {
      this.adaptor.setAttribute(chtml, 'noIC', 'true');
    }

    if (stretchy && this.size < 0) {
      this.stretchHTML(chtml, symmetric);
    } else {
      if (symmetric || attributes.get('largeop')) {
        var bbox = BBox_js_1.BBox.empty();

        _super.prototype.computeBBox.call(this, bbox);

        var u = this.em((bbox.d - bbox.h) / 2 + this.font.params.axis_height);

        if (u !== '0') {
          this.adaptor.setStyle(chtml, 'verticalAlign', u);
        }
      }

      try {
        for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;
          child.toCHTML(chtml);
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }
    }

    var e_1, _c;
  };

  CHTMLmo.prototype.stretchHTML = function (chtml, symmetric) {
    var c = this.getText().charCodeAt(0);
    var delim = this.stretch;
    delim.used = true;
    var stretch = delim.stretch;
    var content = [];

    if (stretch[0]) {
      content.push(this.html('mjx-beg', {}, [this.html('mjx-c')]));
    }

    content.push(this.html('mjx-ext', {}, [this.html('mjx-c')]));

    if (stretch.length === 4) {
      content.push(this.html('mjx-mid', {}, [this.html('mjx-c')]), this.html('mjx-ext', {}, [this.html('mjx-c')]));
    }

    if (stretch[2]) {
      content.push(this.html('mjx-end', {}, [this.html('mjx-c')]));
    }

    var styles = {};
    var _a = this.bbox,
        h = _a.h,
        d = _a.d,
        w = _a.w;

    if (delim.dir === 1) {
      content.push(this.html('mjx-mark'));
      styles.height = this.em(h + d);
      styles.verticalAlign = this.em(-d);
    } else {
      styles.width = this.em(w);
    }

    var dir = mo_js_1.DirectionVH[delim.dir];
    var properties = {
      class: this.char(delim.c || c),
      style: styles
    };
    var html = this.html('mjx-stretchy-' + dir, properties, content);
    this.adaptor.append(chtml, html);
  };

  return CHTMLmo;
}(mo_js_1.CommonMoMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmo.kind = mo_js_2.MmlMo.prototype.kind;
CHTMLmo.styles = {
  'mjx-stretchy-h': {
    display: 'inline-table',
    width: '100%'
  },
  'mjx-stretchy-h > *': {
    display: 'table-cell',
    width: 0
  },
  'mjx-stretchy-h > * > mjx-c': {
    display: 'inline-block'
  },
  'mjx-stretchy-h > * > mjx-c::before': {
    padding: '.001em 0',
    width: 'initial'
  },
  'mjx-stretchy-h > mjx-ext': {
    overflow: 'hidden',
    width: '100%'
  },
  'mjx-stretchy-h > mjx-ext > mjx-c::before': {
    transform: 'scalex(500)'
  },
  'mjx-stretchy-h > mjx-ext > mjx-c': {
    width: 0
  },
  'mjx-stretchy-h > mjx-beg > mjx-c': {
    'margin-right': '-.1em'
  },
  'mjx-stretchy-h > mjx-end > mjx-c': {
    'margin-left': '-.1em'
  },
  'mjx-stretchy-v': {
    display: 'inline-block'
  },
  'mjx-stretchy-v > *': {
    display: 'block'
  },
  'mjx-stretchy-v > mjx-beg': {
    height: 0
  },
  'mjx-stretchy-v > mjx-end > mjx-c': {
    display: 'block'
  },
  'mjx-stretchy-v > * > mjx-c': {
    transform: 'scale(1)',
    'transform-origin': 'left center',
    overflow: 'hidden'
  },
  'mjx-stretchy-v > mjx-ext': {
    display: 'block',
    height: '100%',
    'box-sizing': 'border-box',
    border: '0px solid transparent',
    overflow: 'hidden'
  },
  'mjx-stretchy-v > mjx-ext > mjx-c::before': {
    width: 'initial'
  },
  'mjx-stretchy-v > mjx-ext > mjx-c': {
    transform: 'scaleY(500) translateY(.1em)',
    overflow: 'visible'
  },
  'mjx-mark': {
    display: 'inline-block',
    height: '0px'
  }
};
exports.CHTMLmo = CHTMLmo;

/***/ }),
/* 256 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(29);

exports.DirectionVH = (_a = {}, _a[1] = 'v', _a[2] = 'h', _a);

function CommonMoMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.noIC = false;
      _this.size = null;
      _this.isAccent = _this.node.isAccent;
      return _this;
    }

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var stretchy = this.stretch.dir !== 0;

      if (stretchy && this.size === null) {
        this.getStretchedVariant([0]);
      }

      if (stretchy && this.size < 0) return;

      _super.prototype.computeBBox.call(this, bbox);

      this.copySkewIC(bbox);

      if (this.noIC) {
        bbox.w -= bbox.ic;
      }

      if (this.node.attributes.get('symmetric') && this.stretch.dir !== 2) {
        var d = (bbox.h + bbox.d) / 2 + this.font.params.axis_height - bbox.h;
        bbox.h += d;
        bbox.d -= d;
      }
    };

    class_1.prototype.getVariant = function () {
      if (this.node.attributes.get('largeop')) {
        this.variant = this.node.attributes.get('displaystyle') ? '-largeop' : '-smallop';
      } else {
        _super.prototype.getVariant.call(this);
      }
    };

    class_1.prototype.canStretch = function (direction) {
      if (this.stretch.dir !== 0) {
        return this.stretch.dir === direction;
      }

      var attributes = this.node.attributes;
      if (!attributes.get('stretchy')) return false;
      var c = this.getText();
      if (c.length !== 1) return false;
      var delim = this.font.getDelimiter(c.charCodeAt(0));
      this.stretch = delim && delim.dir === direction ? delim : FontData_js_1.NOSTRETCH;
      return this.stretch.dir !== 0;
    };

    class_1.prototype.getStretchedVariant = function (WH, exact) {
      if (exact === void 0) {
        exact = false;
      }

      if (this.stretch.dir !== 0) {
        var D = this.getWH(WH);
        var min = this.getSize('minsize', 0);
        var max = this.getSize('maxsize', Infinity);
        D = Math.max(min, Math.min(max, D));
        var m = min || exact ? D : Math.max(D * this.font.params.delimiterfactor / 1000, D - this.font.params.delimitershortfall);
        var delim = this.stretch;
        var c = delim.c || this.getText().charCodeAt(0);
        var i = 0;

        if (delim.sizes) {
          try {
            for (var _a = __values(delim.sizes), _b = _a.next(); !_b.done; _b = _a.next()) {
              var d = _b.value;

              if (d >= m) {
                this.variant = this.font.getSizeVariant(c, i);
                this.size = i;
                return;
              }

              i++;
            }
          } catch (e_1_1) {
            e_1 = {
              error: e_1_1
            };
          } finally {
            try {
              if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
            } finally {
              if (e_1) throw e_1.error;
            }
          }
        }

        if (delim.stretch) {
          this.size = -1;
          this.invalidateBBox();
          this.getStretchBBox(WH, D, delim);
        } else {
          this.variant = this.font.getSizeVariant(c, i - 1);
          this.size = i - 1;
        }
      }

      var e_1, _c;
    };

    class_1.prototype.getSize = function (name, value) {
      var attributes = this.node.attributes;

      if (attributes.isSet(name)) {
        value = this.length2em(attributes.get(name), 1, 1);
      }

      return value;
    };

    class_1.prototype.getWH = function (WH) {
      if (WH.length === 0) return 0;
      if (WH.length === 1) return WH[0];

      var _a = __read(WH, 2),
          H = _a[0],
          D = _a[1];

      var a = this.font.params.axis_height;
      return this.node.attributes.get('symmetric') ? 2 * Math.max(H - a, D + a) : H + D;
    };

    class_1.prototype.getStretchBBox = function (WHD, D, C) {
      if (C.hasOwnProperty('min') && C.min > D) {
        D = C.min;
      }

      var _a = __read(C.HDW, 3),
          h = _a[0],
          d = _a[1],
          w = _a[2];

      if (this.stretch.dir === 1) {
        _b = __read(this.getBaseline(WHD, D, C), 2), h = _b[0], d = _b[1];
      } else {
        w = D;
      }

      this.bbox.h = h;
      this.bbox.d = d;
      this.bbox.w = w;

      var _b;
    };

    class_1.prototype.getBaseline = function (WHD, HD, C) {
      var hasWHD = WHD.length === 2 && WHD[0] + WHD[1] === HD;
      var symmetric = this.node.attributes.get('symmetric');

      var _a = __read(hasWHD ? WHD : [HD, 0], 2),
          H = _a[0],
          D = _a[1];

      var _b = __read([H + D, 0], 2),
          h = _b[0],
          d = _b[1];

      if (symmetric) {
        var a = this.font.params.axis_height;

        if (hasWHD) {
          h = 2 * Math.max(H - a, D + a);
        }

        d = h / 2 - a;
      } else if (hasWHD) {
        d = D;
      } else {
        var _c = __read(C.HDW || [.75, .25], 2),
            ch = _c[0],
            cd = _c[1];

        d = cd * (h / (ch + cd));
      }

      return [h - d, d];
    };

    class_1.prototype.remapChars = function (chars) {
      if (chars.length == 1) {
        var parent_1 = this.node.parent;
        var isAccent = this.isAccent && (parent_1 === this.node.coreParent() || parent_1.isEmbellished);
        var map = isAccent ? 'accent' : 'mo';
        var text = this.font.getRemappedChar(map, chars[0]);

        if (text) {
          chars = this.unicodeChars(text);
        }
      }

      return chars;
    };

    return class_1;
  }(Base);
}

exports.CommonMoMixin = CommonMoMixin;

var _a;

/***/ }),
/* 257 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mn_js_1 = __webpack_require__(258);

var mn_js_2 = __webpack_require__(78);

var CHTMLmn = function (_super) {
  __extends(CHTMLmn, _super);

  function CHTMLmn() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return CHTMLmn;
}(mn_js_1.CommonMnMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmn.kind = mn_js_2.MmlMn.prototype.kind;
exports.CHTMLmn = CHTMLmn;

/***/ }),
/* 258 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMnMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    class_1.prototype.remapChars = function (chars) {
      if (chars.length) {
        var string = this.font.getRemappedChar('mn', chars[0]);

        if (string) {
          var c = this.unicodeChars(string);

          if (c.length === 1) {
            chars[0] = c[0];
          } else {
            chars = c.concat(chars.slice(1));
          }
        }
      }

      return chars;
    };

    return class_1;
  }(Base);
}

exports.CommonMnMixin = CommonMnMixin;

/***/ }),
/* 259 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var ms_js_1 = __webpack_require__(260);

var ms_js_2 = __webpack_require__(79);

var CHTMLms = function (_super) {
  __extends(CHTMLms, _super);

  function CHTMLms() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return CHTMLms;
}(ms_js_1.CommonMsMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLms.kind = ms_js_2.MmlMs.prototype.kind;
exports.CHTMLms = CHTMLms;

/***/ }),
/* 260 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMsMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      var attributes = _this.node.attributes;
      var quotes = attributes.getList('lquote', 'rquote');

      if (_this.variant !== 'monospace') {
        if (!attributes.isSet('lquote') && quotes.lquote === '"') quotes.lquote = '\u201C';
        if (!attributes.isSet('rquote') && quotes.rquote === '"') quotes.rquote = '\u201D';
      }

      _this.childNodes.unshift(_this.createText(quotes.lquote));

      _this.childNodes.push(_this.createText(quotes.rquote));

      return _this;
    }

    class_1.prototype.createText = function (text) {
      var node = this.wrap(this.mmlText(text));
      node.parent = this;
      return node;
    };

    return class_1;
  }(Base);
}

exports.CommonMsMixin = CommonMsMixin;

/***/ }),
/* 261 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mspace_js_1 = __webpack_require__(262);

var mspace_js_2 = __webpack_require__(80);

var CHTMLmspace = function (_super) {
  __extends(CHTMLmspace, _super);

  function CHTMLmspace() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmspace.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);

    var _a = this.getBBox(),
        w = _a.w,
        h = _a.h,
        d = _a.d;

    if (w < 0) {
      this.adaptor.setStyle(chtml, 'marginRight', this.em(w));
      w = 0;
    }

    if (w) {
      this.adaptor.setStyle(chtml, 'width', this.em(w));
    }

    h = Math.max(0, h + d);

    if (h) {
      this.adaptor.setStyle(chtml, 'height', this.em(Math.max(0, h)));
    }

    if (d) {
      this.adaptor.setStyle(chtml, 'verticalAlign', this.em(-d));
    }
  };

  return CHTMLmspace;
}(mspace_js_1.CommonMspaceMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmspace.kind = mspace_js_2.MmlMspace.prototype.kind;
exports.CHTMLmspace = CHTMLmspace;

/***/ }),
/* 262 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMspaceMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var attributes = this.node.attributes;
      bbox.w = this.length2em(attributes.get('width'), 0);
      bbox.h = this.length2em(attributes.get('height'), 0);
      bbox.d = this.length2em(attributes.get('depth'), 0);
    };

    class_1.prototype.handleVariant = function () {};

    return class_1;
  }(Base);
}

exports.CommonMspaceMixin = CommonMspaceMixin;

/***/ }),
/* 263 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mpadded_js_1 = __webpack_require__(264);

var mpadded_js_2 = __webpack_require__(81);

var CHTMLmpadded = function (_super) {
  __extends(CHTMLmpadded, _super);

  function CHTMLmpadded() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmpadded.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);
    var content = [];
    var style = {};

    var _a = __read(this.getDimens(), 9),
        H = _a[0],
        D = _a[1],
        W = _a[2],
        dh = _a[3],
        dd = _a[4],
        dw = _a[5],
        x = _a[6],
        y = _a[7],
        dx = _a[8];

    if (dw) {
      style.width = this.em(W + dw);
    }

    if (dh || dd) {
      style.margin = this.em(dh) + ' 0 ' + this.em(dd);
    }

    if (x + dx || y) {
      style.position = 'relative';
      var rbox = this.html('mjx-rbox', {
        style: {
          left: this.em(x + dx),
          top: this.em(-y)
        }
      });

      if (x + dx && this.childNodes[0].getBBox().pwidth) {
        this.adaptor.setAttribute(rbox, 'width', 'full');
        this.adaptor.setStyle(rbox, 'left', this.em(x));
      }

      content.push(rbox);
    }

    chtml = this.adaptor.append(chtml, this.html('mjx-block', {
      style: style
    }, content));

    try {
      for (var _b = __values(this.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
        var child = _c.value;
        child.toCHTML(content[0] || chtml);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _d;
  };

  return CHTMLmpadded;
}(mpadded_js_1.CommonMpaddedMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmpadded.kind = mpadded_js_2.MmlMpadded.prototype.kind;
CHTMLmpadded.styles = {
  'mjx-mpadded': {
    display: 'inline-block'
  },
  'mjx-rbox': {
    display: 'inline-block',
    position: 'relative'
  }
};
exports.CHTMLmpadded = CHTMLmpadded;

/***/ }),
/* 264 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMpaddedMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    class_1.prototype.getDimens = function () {
      var values = this.node.attributes.getList('width', 'height', 'depth', 'lspace', 'voffset');
      var bbox = this.childNodes[0].getBBox();
      var w = bbox.w,
          h = bbox.h,
          d = bbox.d;
      var W = w,
          H = h,
          D = d,
          x = 0,
          y = 0,
          dx = 0;
      if (values.width !== '') w = this.dimen(values.width, bbox, 'w', 0);
      if (values.height !== '') h = this.dimen(values.height, bbox, 'h', 0);
      if (values.depth !== '') d = this.dimen(values.depth, bbox, 'd', 0);
      if (values.voffset !== '') y = this.dimen(values.voffset, bbox);
      if (values.lspace !== '') x = this.dimen(values.lspace, bbox);
      var align = this.node.attributes.get('data-align');

      if (align) {
        dx = this.getAlignX(w, bbox, align);
      }

      return [H, D, W, h - H, d - D, w - W, x, y, dx];
    };

    class_1.prototype.dimen = function (length, bbox, d, m) {
      if (d === void 0) {
        d = '';
      }

      if (m === void 0) {
        m = null;
      }

      length = String(length);
      var match = length.match(/width|height|depth/);
      var size = match ? bbox[match[0].charAt(0)] : d ? bbox[d] : 0;
      var dimen = this.length2em(length, size) || 0;

      if (length.match(/^[-+]/) && d) {
        dimen += size;
      }

      if (m != null) {
        dimen = Math.max(m, dimen);
      }

      return dimen;
    };

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var _a = __read(this.getDimens(), 8),
          H = _a[0],
          D = _a[1],
          W = _a[2],
          dh = _a[3],
          dd = _a[4],
          dw = _a[5],
          x = _a[6],
          y = _a[7];

      bbox.w = W + dw;
      bbox.h = H + dh;
      bbox.d = D + dd;
      this.setChildPWidths(recompute, bbox.w);
    };

    class_1.prototype.getWrapWidth = function (i) {
      return this.getBBox().w;
    };

    class_1.prototype.getChildAlign = function (i) {
      return this.node.attributes.get('data-align') || 'left';
    };

    return class_1;
  }(Base);
}

exports.CommonMpaddedMixin = CommonMpaddedMixin;

/***/ }),
/* 265 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var menclose_js_1 = __webpack_require__(266);

var Notation = __webpack_require__(267);

var menclose_js_2 = __webpack_require__(82);

var lengths_js_1 = __webpack_require__(22);

function Angle(x, y) {
  return Math.atan2(x, y).toFixed(3).replace(/\.?0+$/, '');
}

var ANGLE = Angle(Notation.ARROWDX, Notation.ARROWY);

var CHTMLmenclose = function (_super) {
  __extends(CHTMLmenclose, _super);

  function CHTMLmenclose() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmenclose.prototype.toCHTML = function (parent) {
    var adaptor = this.adaptor;
    var chtml = this.standardCHTMLnode(parent);
    var block = adaptor.append(chtml, this.html('mjx-box'));

    if (this.renderChild) {
      this.renderChild(this, block);
    } else {
      this.childNodes[0].toCHTML(block);
    }

    try {
      for (var _a = __values(Object.keys(this.notations)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var name_1 = _b.value;
        var notation = this.notations[name_1];
        !notation.renderChild && notation.renderer(this, block);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var pbox = this.getPadding();

    try {
      for (var _d = __values(Notation.sideNames), _e = _d.next(); !_e.done; _e = _d.next()) {
        var name_2 = _e.value;
        var i = Notation.sideIndex[name_2];
        pbox[i] > 0 && adaptor.setStyle(block, 'padding-' + name_2, this.em(pbox[i]));
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_1, _c, e_2, _f;
  };

  CHTMLmenclose.prototype.arrow = function (w, a, double) {
    if (double === void 0) {
      double = false;
    }

    var W = this.getBBox().w;
    var style = {
      width: this.em(w)
    };

    if (W !== w) {
      style.left = this.em((W - w) / 2);
    }

    if (a) {
      style.transform = 'rotate(' + this.fixed(a) + 'rad)';
    }

    var arrow = this.html('mjx-arrow', {
      style: style
    }, [this.html('mjx-aline'), this.html('mjx-rthead'), this.html('mjx-rbhead')]);

    if (double) {
      this.adaptor.append(arrow, this.html('mjx-lthead'));
      this.adaptor.append(arrow, this.html('mjx-lbhead'));
      this.adaptor.setAttribute(arrow, 'double', 'true');
    }

    this.adjustArrow(arrow, double);
    return arrow;
  };

  CHTMLmenclose.prototype.adjustArrow = function (arrow, double) {
    var _this = this;

    var t = this.thickness;
    var head = this.arrowhead;
    if (head.x === Notation.ARROWX && head.y === Notation.ARROWY && head.dx === Notation.ARROWDX && t === Notation.THICKNESS) return;

    var _a = __read([t * head.x, t * head.y, t * head.dx].map(function (x) {
      return _this.em(x);
    }), 3),
        x = _a[0],
        y = _a[1],
        dx = _a[2];

    var a = Angle(head.dx, head.y);

    var _b = __read(this.adaptor.childNodes(arrow), 5),
        line = _b[0],
        rthead = _b[1],
        rbhead = _b[2],
        lthead = _b[3],
        lbhead = _b[4];

    this.adjustHead(rthead, [y, '0', '1px', x], a);
    this.adjustHead(rbhead, ['1px', '0', y, x], '-' + a);
    this.adjustHead(lthead, [y, x, '1px', '0'], '-' + a);
    this.adjustHead(lbhead, ['1px', x, y, '0'], a);
    this.adjustLine(line, t, head.x, double);
  };

  CHTMLmenclose.prototype.adjustHead = function (head, border, a) {
    if (head) {
      this.adaptor.setStyle(head, 'border-width', border.join(' '));
      this.adaptor.setStyle(head, 'transform', 'skewX(' + a + 'rad)');
    }
  };

  CHTMLmenclose.prototype.adjustLine = function (line, t, x, double) {
    this.adaptor.setStyle(line, 'borderTop', this.em(t) + ' solid');
    this.adaptor.setStyle(line, 'top', this.em(-t / 2));
    this.adaptor.setStyle(line, 'right', this.em(t * (x - 1)));

    if (double) {
      this.adaptor.setStyle(line, 'left', this.em(t * (x - 1)));
    }
  };

  CHTMLmenclose.prototype.adjustBorder = function (node) {
    if (this.thickness !== Notation.THICKNESS) {
      this.adaptor.setStyle(node, 'borderWidth', this.em(this.thickness));
    }

    return node;
  };

  CHTMLmenclose.prototype.adjustThickness = function (shape) {
    if (this.thickness !== Notation.THICKNESS) {
      this.adaptor.setStyle(shape, 'strokeWidth', this.fixed(this.thickness));
    }

    return shape;
  };

  CHTMLmenclose.prototype.fixed = function (m, n) {
    if (n === void 0) {
      n = 3;
    }

    if (Math.abs(m) < .0006) {
      return '0';
    }

    return m.toFixed(n).replace(/\.?0+$/, '');
  };

  CHTMLmenclose.prototype.em = function (m) {
    return _super.prototype.em.call(this, m);
  };

  return CHTMLmenclose;
}(menclose_js_1.CommonMencloseMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmenclose.kind = menclose_js_2.MmlMenclose.prototype.kind;
CHTMLmenclose.styles = {
  'mjx-menclose': {
    position: 'relative'
  },
  'mjx-menclose > mjx-dstrike': {
    display: 'inline-block',
    left: 0,
    top: 0,
    position: 'absolute',
    'border-top': Notation.SOLID,
    'transform-origin': 'top left'
  },
  'mjx-menclose > mjx-ustrike': {
    display: 'inline-block',
    left: 0,
    bottom: 0,
    position: 'absolute',
    'border-top': Notation.SOLID,
    'transform-origin': 'bottom left'
  },
  'mjx-menclose > mjx-hstrike': {
    'border-top': Notation.SOLID,
    position: 'absolute',
    left: 0,
    right: 0,
    bottom: '50%',
    transform: 'translateY(' + lengths_js_1.em(Notation.THICKNESS / 2) + ')'
  },
  'mjx-menclose > mjx-vstrike': {
    'border-left': Notation.SOLID,
    position: 'absolute',
    top: 0,
    bottom: 0,
    right: '50%',
    transform: 'translateX(' + lengths_js_1.em(Notation.THICKNESS / 2) + ')'
  },
  'mjx-menclose > mjx-rbox': {
    position: 'absolute',
    top: 0,
    bottom: 0,
    right: 0,
    left: 0,
    'border': Notation.SOLID,
    'border-radius': lengths_js_1.em(Notation.THICKNESS + Notation.PADDING)
  },
  'mjx-menclose > mjx-cbox': {
    position: 'absolute',
    top: 0,
    bottom: 0,
    right: 0,
    left: 0,
    'border': Notation.SOLID,
    'border-radius': '50%'
  },
  'mjx-menclose > mjx-arrow': {
    position: 'absolute',
    left: 0,
    bottom: '50%',
    height: 0,
    width: 0
  },
  'mjx-menclose > mjx-arrow > *': {
    display: 'block',
    position: 'absolute',
    'transform-origin': 'bottom',
    'border-left': lengths_js_1.em(Notation.THICKNESS * Notation.ARROWX) + ' solid',
    'border-right': 0,
    'box-sizing': 'border-box'
  },
  'mjx-menclose > mjx-arrow > mjx-aline': {
    left: 0,
    top: lengths_js_1.em(-Notation.THICKNESS / 2),
    right: lengths_js_1.em(Notation.THICKNESS * (Notation.ARROWX - 1)),
    height: 0,
    'border-top': lengths_js_1.em(Notation.THICKNESS) + ' solid',
    'border-left': 0
  },
  'mjx-menclose > mjx-arrow[double] > mjx-aline': {
    left: lengths_js_1.em(Notation.THICKNESS * (Notation.ARROWX - 1)),
    height: 0
  },
  'mjx-menclose > mjx-arrow > mjx-rthead': {
    transform: 'skewX(' + ANGLE + 'rad)',
    right: 0,
    bottom: '-1px',
    'border-bottom': '1px solid transparent',
    'border-top': lengths_js_1.em(Notation.THICKNESS * Notation.ARROWY) + ' solid transparent'
  },
  'mjx-menclose > mjx-arrow > mjx-rbhead': {
    transform: 'skewX(-' + ANGLE + 'rad)',
    'transform-origin': 'top',
    right: 0,
    top: '-1px',
    'border-top': '1px solid transparent',
    'border-bottom': lengths_js_1.em(Notation.THICKNESS * Notation.ARROWY) + ' solid transparent'
  },
  'mjx-menclose > mjx-arrow > mjx-lthead': {
    transform: 'skewX(-' + ANGLE + 'rad)',
    left: 0,
    bottom: '-1px',
    'border-left': 0,
    'border-right': lengths_js_1.em(Notation.THICKNESS * Notation.ARROWX) + ' solid',
    'border-bottom': '1px solid transparent',
    'border-top': lengths_js_1.em(Notation.THICKNESS * Notation.ARROWY) + ' solid transparent'
  },
  'mjx-menclose > mjx-arrow > mjx-lbhead': {
    transform: 'skewX(' + ANGLE + 'rad)',
    'transform-origin': 'top',
    left: 0,
    top: '-1px',
    'border-left': 0,
    'border-right': lengths_js_1.em(Notation.THICKNESS * Notation.ARROWX) + ' solid',
    'border-top': '1px solid transparent',
    'border-bottom': lengths_js_1.em(Notation.THICKNESS * Notation.ARROWY) + ' solid transparent'
  },
  'mjx-menclose > dbox': {
    position: 'absolute',
    top: 0,
    bottom: 0,
    left: lengths_js_1.em(-1.5 * Notation.PADDING),
    width: lengths_js_1.em(3 * Notation.PADDING),
    border: lengths_js_1.em(Notation.THICKNESS) + ' solid',
    'border-radius': '50%',
    'clip-path': 'inset(0 0 0 ' + lengths_js_1.em(1.5 * Notation.PADDING) + ')',
    'box-sizing': 'border-box'
  }
};
CHTMLmenclose.notations = new Map([Notation.Border('top'), Notation.Border('right'), Notation.Border('bottom'), Notation.Border('left'), Notation.Border2('actuarial', 'top', 'right'), Notation.Border2('madruwb', 'bottom', 'right'), Notation.DiagonalStrike('up', 1), Notation.DiagonalStrike('down', -1), ['horizontalstrike', {
  renderer: Notation.RenderElement('hstrike', 'Y'),
  bbox: function (node) {
    return [0, node.padding, 0, node.padding];
  }
}], ['verticalstrike', {
  renderer: Notation.RenderElement('vstrike', 'X'),
  bbox: function (node) {
    return [node.padding, 0, node.padding, 0];
  }
}], ['box', {
  renderer: function (node, child) {
    node.adaptor.setStyle(child, 'border', node.em(node.thickness) + ' solid');
  },
  bbox: Notation.fullBBox,
  border: Notation.fullBorder,
  remove: 'left right top bottom'
}], ['roundedbox', {
  renderer: Notation.RenderElement('rbox'),
  bbox: Notation.fullBBox
}], ['circle', {
  renderer: Notation.RenderElement('cbox'),
  bbox: Notation.fullBBox
}], ['phasorangle', {
  renderer: function (node, child) {
    var _a = node.getBBox(),
        w = _a.w,
        h = _a.h,
        d = _a.d;

    var _b = __read(node.getArgMod(1.75 * node.padding, h + d), 2),
        a = _b[0],
        W = _b[1];

    var t = node.thickness * Math.sin(a) * .9;
    node.adaptor.setStyle(child, 'border-bottom', node.em(node.thickness) + ' solid');
    var strike = node.adjustBorder(node.html('mjx-ustrike', {
      style: {
        width: node.em(W),
        transform: 'translateX(' + node.em(t) + ') rotate(' + node.fixed(-a) + 'rad)'
      }
    }));
    node.adaptor.append(node.chtml, strike);
  },
  bbox: function (node) {
    var p = node.padding / 2;
    var t = node.thickness;
    return [2 * p, p, p + t, 3 * p + t];
  },
  border: function (node) {
    return [0, 0, node.thickness, 0];
  },
  remove: 'bottom'
}], Notation.Arrow('up'), Notation.Arrow('down'), Notation.Arrow('left'), Notation.Arrow('right'), Notation.Arrow('updown'), Notation.Arrow('leftright'), Notation.DiagonalArrow('updiagonal'), Notation.DiagonalArrow('northeast'), Notation.DiagonalArrow('southeast'), Notation.DiagonalArrow('northwest'), Notation.DiagonalArrow('southwest'), Notation.DiagonalArrow('northeastsouthwest'), Notation.DiagonalArrow('northwestsoutheast'), ['longdiv', {
  renderer: function (node, child) {
    var adaptor = node.adaptor;
    adaptor.setStyle(child, 'border-top', node.em(node.thickness) + ' solid');
    var arc = adaptor.append(node.chtml, node.html('dbox'));
    var t = node.thickness;
    var p = node.padding;

    if (t !== Notation.THICKNESS) {
      adaptor.setStyle(arc, 'border-width', node.em(t));
    }

    if (p !== Notation.PADDING) {
      adaptor.setStyle(arc, 'left', node.em(-1.5 * p));
      adaptor.setStyle(arc, 'width', node.em(3 * p));
      adaptor.setStyle(arc, 'clip-path', 'inset(0 0 0 ' + node.em(1.5 * p) + ')');
    }
  },
  bbox: function (node) {
    var p = node.padding;
    var t = node.thickness;
    return [p + t, p, p, 2 * p + t / 2];
  }
}], ['radical', {
  renderer: function (node, child) {
    node.msqrt.toCHTML(child);
    var TRBL = node.sqrtTRBL();
    node.adaptor.setStyle(node.msqrt.chtml, 'margin', TRBL.map(function (x) {
      return node.em(-x);
    }).join(' '));
  },
  init: function (node) {
    node.msqrt = node.createMsqrt(node.childNodes[0]);
  },
  bbox: function (node) {
    return node.sqrtTRBL();
  },
  renderChild: true
}]]);
exports.CHTMLmenclose = CHTMLmenclose;

/***/ }),
/* 266 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Notation = __webpack_require__(49);

var string_js_1 = __webpack_require__(16);

function CommonMencloseMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.notations = {};
      _this.renderChild = null;
      _this.msqrt = null;
      _this.padding = Notation.PADDING;
      _this.thickness = Notation.THICKNESS;
      _this.arrowhead = {
        x: Notation.ARROWX,
        y: Notation.ARROWY,
        dx: Notation.ARROWDX
      };

      _this.getParameters();

      _this.getNotations();

      _this.removeRedundantNotations();

      _this.initializeNotations();

      return _this;
    }

    class_1.prototype.getParameters = function () {
      var attributes = this.node.attributes;
      var padding = attributes.get('data-padding');

      if (padding !== undefined) {
        this.padding = this.length2em(padding, Notation.PADDING);
      }

      var thickness = attributes.get('data-thickness');

      if (thickness !== undefined) {
        this.thickness = this.length2em(thickness, Notation.THICKNESS);
      }

      var arrowhead = attributes.get('data-arrowhead');

      if (arrowhead !== undefined) {
        var _a = __read(string_js_1.split(arrowhead), 3),
            x = _a[0],
            y = _a[1],
            dx = _a[2];

        this.arrowhead = {
          x: x ? parseFloat(x) : Notation.ARROWX,
          y: y ? parseFloat(y) : Notation.ARROWY,
          dx: dx ? parseFloat(dx) : Notation.ARROWDX
        };
      }
    };

    class_1.prototype.getNotations = function () {
      var Notations = this.constructor.notations;

      try {
        for (var _a = __values(string_js_1.split(this.node.attributes.get('notation'))), _b = _a.next(); !_b.done; _b = _a.next()) {
          var name_1 = _b.value;
          var notation = Notations.get(name_1);

          if (notation) {
            this.notations[name_1] = notation;

            if (notation.renderChild) {
              this.renderChild = notation.renderer;
            }
          }
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      var e_1, _c;
    };

    class_1.prototype.removeRedundantNotations = function () {
      try {
        for (var _a = __values(Object.keys(this.notations)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var name_2 = _b.value;

          if (this.notations[name_2]) {
            var remove = this.notations[name_2].remove || '';

            try {
              for (var _c = __values(remove.split(/ /)), _d = _c.next(); !_d.done; _d = _c.next()) {
                var notation = _d.value;
                delete this.notations[notation];
              }
            } catch (e_2_1) {
              e_2 = {
                error: e_2_1
              };
            } finally {
              try {
                if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
              } finally {
                if (e_2) throw e_2.error;
              }
            }
          }
        }
      } catch (e_3_1) {
        e_3 = {
          error: e_3_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
        } finally {
          if (e_3) throw e_3.error;
        }
      }

      var e_3, _f, e_2, _e;
    };

    class_1.prototype.initializeNotations = function () {
      try {
        for (var _a = __values(Object.keys(this.notations)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var name_3 = _b.value;
          var init = this.notations[name_3].init;
          init && init(this);
        }
      } catch (e_4_1) {
        e_4 = {
          error: e_4_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_4) throw e_4.error;
        }
      }

      var e_4, _c;
    };

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var _a = __read(this.getBBoxExtenders(), 4),
          T = _a[0],
          R = _a[1],
          B = _a[2],
          L = _a[3];

      var child = this.childNodes[0].getBBox();
      bbox.combine(child, L, 0);
      bbox.h += T;
      bbox.d += B;
      bbox.w += R;
      this.setChildPWidths(recompute);
    };

    class_1.prototype.getBBoxExtenders = function () {
      var TRBL = [0, 0, 0, 0];

      try {
        for (var _a = __values(Object.keys(this.notations)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var name_4 = _b.value;
          this.maximizeEntries(TRBL, this.notations[name_4].bbox(this));
        }
      } catch (e_5_1) {
        e_5 = {
          error: e_5_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_5) throw e_5.error;
        }
      }

      return TRBL;

      var e_5, _c;
    };

    class_1.prototype.getPadding = function () {
      var TRBL = [0, 0, 0, 0];
      var BTRBL = [0, 0, 0, 0];

      try {
        for (var _a = __values(Object.keys(this.notations)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var name_5 = _b.value;
          this.maximizeEntries(TRBL, this.notations[name_5].bbox(this));
          var border = this.notations[name_5].border;

          if (border) {
            this.maximizeEntries(BTRBL, border(this));
          }
        }
      } catch (e_6_1) {
        e_6 = {
          error: e_6_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_6) throw e_6.error;
        }
      }

      return [0, 1, 2, 3].map(function (i) {
        return TRBL[i] - BTRBL[i];
      });

      var e_6, _c;
    };

    class_1.prototype.maximizeEntries = function (X, Y) {
      for (var i = 0; i < X.length; i++) {
        if (X[i] < Y[i]) {
          X[i] = Y[i];
        }
      }
    };

    class_1.prototype.getArgMod = function (w, h) {
      return [Math.atan2(h, w), Math.sqrt(w * w + h * h)];
    };

    class_1.prototype.arrow = function (w, a, double) {
      if (double === void 0) {
        double = false;
      }

      return null;
    };

    class_1.prototype.arrowData = function () {
      var _a = __read([this.padding, this.thickness], 2),
          p = _a[0],
          t = _a[1];

      var r = t * (this.arrowhead.x + Math.max(1, this.arrowhead.dx));

      var _b = this.childNodes[0].getBBox(),
          h = _b.h,
          d = _b.d,
          w = _b.w;

      var H = h + d;
      var R = Math.sqrt(H * H + w * w);
      var x = Math.max(p, r * w / R);
      var y = Math.max(p, r * H / R);

      var _c = __read(this.getArgMod(w + 2 * x, H + 2 * y), 2),
          a = _c[0],
          W = _c[1];

      return {
        a: a,
        W: W,
        x: x,
        y: y
      };
    };

    class_1.prototype.createMsqrt = function (child) {
      var mmlFactory = this.node.factory;
      var mml = mmlFactory.create('msqrt');
      mml.inheritAttributesFrom(this.node);
      mml.childNodes[0] = child.node;
      var node = this.wrap(mml);
      node.parent = this;
      return node;
    };

    class_1.prototype.sqrtTRBL = function () {
      var bbox = this.msqrt.getBBox();
      var cbox = this.msqrt.childNodes[0].getBBox();
      return [bbox.h - cbox.h, 0, bbox.d - cbox.d, bbox.w - cbox.w];
    };

    return class_1;
  }(Base);
}

exports.CommonMencloseMixin = CommonMencloseMixin;

/***/ }),
/* 267 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

function __export(m) {
  for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Notation = __webpack_require__(49);

__export(__webpack_require__(49));

exports.RenderElement = function (name, offset) {
  if (offset === void 0) {
    offset = '';
  }

  return function (node, child) {
    var shape = node.adjustBorder(node.html('mjx-' + name));

    if (offset && node.thickness !== Notation.THICKNESS) {
      var transform = 'translate' + offset + '(' + node.em(node.thickness / 2) + ')';
      node.adaptor.setStyle(shape, 'transform', transform);
    }

    node.adaptor.append(node.chtml, shape);
  };
};

exports.Border = function (side) {
  return Notation.CommonBorder(function (node, child) {
    node.adaptor.setStyle(child, 'border-' + side, node.em(node.thickness) + ' solid');
  })(side);
};

exports.Border2 = function (name, side1, side2) {
  return Notation.CommonBorder2(function (node, child) {
    var border = node.em(node.thickness) + ' solid';
    node.adaptor.setStyle(child, 'border-' + side1, border);
    node.adaptor.setStyle(child, 'border-' + side2, border);
  })(name, side1, side2);
};

exports.DiagonalStrike = function (name, neg) {
  return Notation.CommonDiagonalStrike(function (cname) {
    return function (node, child) {
      var _a = node.getBBox(),
          w = _a.w,
          h = _a.h,
          d = _a.d;

      var _b = __read(node.getArgMod(w, h + d), 2),
          a = _b[0],
          W = _b[1];

      var t = neg * node.thickness / 2;
      var strike = node.adjustBorder(node.html(cname, {
        style: {
          width: node.em(W),
          transform: 'rotate(' + node.fixed(-neg * a) + 'rad) translateY(' + t + 'em)'
        }
      }));
      node.adaptor.append(node.chtml, strike);
    };
  })(name);
};

exports.DiagonalArrow = function (name) {
  return Notation.CommonDiagonalArrow(function (node, arrow) {
    node.adaptor.append(node.chtml, arrow);
  })(name);
};

exports.Arrow = function (name) {
  return Notation.CommonArrow(function (node, arrow) {
    node.adaptor.append(node.chtml, arrow);
  })(name);
};

/***/ }),
/* 268 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mrow_js_1 = __webpack_require__(83);

var mrow_js_2 = __webpack_require__(83);

var mrow_js_3 = __webpack_require__(84);

var CHTMLmrow = function (_super) {
  __extends(CHTMLmrow, _super);

  function CHTMLmrow() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmrow.prototype.toCHTML = function (parent) {
    var chtml = this.node.isInferred ? this.chtml = parent : this.standardCHTMLnode(parent);
    var hasNegative = false;

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        child.toCHTML(chtml);

        if (child.bbox.w < 0) {
          hasNegative = true;
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    if (hasNegative) {
      var w = this.getBBox().w;

      if (w) {
        this.adaptor.setStyle(chtml, 'width', this.em(Math.max(0, w)));

        if (w < 0) {
          this.adaptor.setStyle(chtml, 'marginRight', this.em(w));
        }
      }
    }

    var e_1, _c;
  };

  return CHTMLmrow;
}(mrow_js_1.CommonMrowMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmrow.kind = mrow_js_3.MmlMrow.prototype.kind;
exports.CHTMLmrow = CHTMLmrow;

var CHTMLinferredMrow = function (_super) {
  __extends(CHTMLinferredMrow, _super);

  function CHTMLinferredMrow() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return CHTMLinferredMrow;
}(mrow_js_2.CommonInferredMrowMixin(CHTMLmrow));

CHTMLinferredMrow.kind = mrow_js_3.MmlInferredMrow.prototype.kind;
exports.CHTMLinferredMrow = CHTMLinferredMrow;

/***/ }),
/* 269 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mfenced_js_1 = __webpack_require__(270);

var mfenced_js_2 = __webpack_require__(85);

var CHTMLmfenced = function (_super) {
  __extends(CHTMLmfenced, _super);

  function CHTMLmfenced() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmfenced.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);
    this.mrow.toCHTML(chtml);
  };

  return CHTMLmfenced;
}(mfenced_js_1.CommonMfencedMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmfenced.kind = mfenced_js_2.MmlMfenced.prototype.kind;
exports.CHTMLmfenced = CHTMLmfenced;

/***/ }),
/* 270 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMfencedMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.mrow = null;

      _this.createMrow();

      _this.addMrowChildren();

      return _this;
    }

    class_1.prototype.createMrow = function () {
      var mmlFactory = this.node.factory;
      var mrow = mmlFactory.create('inferredMrow');
      mrow.inheritAttributesFrom(this.node);
      this.mrow = this.wrap(mrow);
      this.mrow.parent = this;
    };

    class_1.prototype.addMrowChildren = function () {
      var mfenced = this.node;
      var mrow = this.mrow;
      this.addMo(mfenced.open);

      if (this.childNodes.length) {
        mrow.childNodes.push(this.childNodes[0]);
      }

      var i = 0;

      try {
        for (var _a = __values(this.childNodes.slice(1)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;
          this.addMo(mfenced.separators[i++]);
          mrow.childNodes.push(child);
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      this.addMo(mfenced.close);
      mrow.stretchChildren();

      var e_1, _c;
    };

    class_1.prototype.addMo = function (node) {
      if (!node) return;
      var mo = this.wrap(node);
      this.mrow.childNodes.push(mo);
      mo.parent = this.mrow;
    };

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      bbox.updateFrom(this.mrow.getBBox());
      this.setChildPWidths(recompute);
    };

    return class_1;
  }(Base);
}

exports.CommonMfencedMixin = CommonMfencedMixin;

/***/ }),
/* 271 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mfrac_js_1 = __webpack_require__(272);

var mfrac_js_2 = __webpack_require__(86);

var CHTMLmfrac = function (_super) {
  __extends(CHTMLmfrac, _super);

  function CHTMLmfrac() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmfrac.prototype.toCHTML = function (parent) {
    this.standardCHTMLnode(parent);

    var _a = this.node.attributes.getList('linethickness', 'bevelled'),
        linethickness = _a.linethickness,
        bevelled = _a.bevelled;

    var display = this.isDisplay();

    if (bevelled) {
      this.makeBevelled(display);
    } else {
      var thickness = this.length2em(String(linethickness));

      if (thickness === 0) {
        this.makeAtop(display);
      } else {
        this.makeFraction(display, thickness);
      }
    }
  };

  CHTMLmfrac.prototype.makeFraction = function (display, t) {
    var _a = this.node.attributes.getList('numalign', 'denomalign'),
        numalign = _a.numalign,
        denomalign = _a.denomalign;

    var withDelims = this.node.getProperty('withDelims');
    var attr = display ? {
      type: 'd'
    } : {};
    var fattr = withDelims ? __assign({}, attr, {
      delims: 'true'
    }) : __assign({}, attr);
    var nattr = numalign !== 'center' ? {
      align: numalign
    } : {};
    var dattr = denomalign !== 'center' ? {
      align: denomalign
    } : {};

    var dsattr = __assign({}, attr),
        nsattr = __assign({}, attr);

    var tex = this.font.params;

    if (t !== .06) {
      var a = tex.axis_height;
      var tEm = this.em(t);

      var _b = this.getTUV(display, t),
          T = _b.T,
          u = _b.u,
          v = _b.v;

      var m = (display ? this.em(3 * t) : tEm) + ' -.1em';
      attr.style = {
        height: tEm,
        'border-top': tEm + ' solid',
        margin: m
      };
      var nh = this.em(Math.max(0, u));
      nsattr.style = {
        height: nh,
        'vertical-align': '-' + nh
      };
      dsattr.style = {
        height: this.em(Math.max(0, v))
      };
      fattr.style = {
        'vertical-align': this.em(a - T)
      };
    }

    var num, den;
    this.adaptor.append(this.chtml, this.html('mjx-frac', fattr, [num = this.html('mjx-num', nattr, [this.html('mjx-nstrut', nsattr)]), this.html('mjx-dbox', {}, [this.html('mjx-dtable', {}, [this.html('mjx-line', attr), this.html('mjx-row', {}, [den = this.html('mjx-den', dattr, [this.html('mjx-dstrut', dsattr)])])])])]));
    this.childNodes[0].toCHTML(num);
    this.childNodes[1].toCHTML(den);
  };

  CHTMLmfrac.prototype.makeAtop = function (display) {
    var _a = this.node.attributes.getList('numalign', 'denomalign'),
        numalign = _a.numalign,
        denomalign = _a.denomalign;

    var withDelims = this.node.getProperty('withDelims');
    var attr = display ? {
      type: 'd',
      atop: true
    } : {
      atop: true
    };
    var fattr = withDelims ? __assign({}, attr, {
      delims: true
    }) : __assign({}, attr);
    var nattr = numalign !== 'center' ? {
      align: numalign
    } : {};
    var dattr = denomalign !== 'center' ? {
      align: denomalign
    } : {};

    var _b = this.getUVQ(display),
        v = _b.v,
        q = _b.q;

    nattr.style = {
      'padding-bottom': this.em(q)
    };
    fattr.style = {
      'vertical-align': this.em(-v)
    };
    var num, den;
    this.adaptor.append(this.chtml, this.html('mjx-frac', fattr, [num = this.html('mjx-num', nattr), den = this.html('mjx-den', dattr)]));
    this.childNodes[0].toCHTML(num);
    this.childNodes[1].toCHTML(den);
  };

  CHTMLmfrac.prototype.makeBevelled = function (display) {
    var adaptor = this.adaptor;
    adaptor.setAttribute(this.chtml, 'bevelled', 'ture');
    var num = adaptor.append(this.chtml, this.html('mjx-num'));
    this.childNodes[0].toCHTML(num);
    this.bevel.toCHTML(this.chtml);
    var den = adaptor.append(this.chtml, this.html('mjx-den'));
    this.childNodes[1].toCHTML(den);

    var _a = this.getBevelData(display),
        u = _a.u,
        v = _a.v,
        delta = _a.delta,
        nbox = _a.nbox,
        dbox = _a.dbox;

    if (u) {
      adaptor.setStyle(num, 'verticalAlign', this.em(u / nbox.scale));
    }

    if (v) {
      adaptor.setStyle(den, 'verticalAlign', this.em(v / dbox.scale));
    }

    var dx = this.em(-delta / 2);
    adaptor.setStyle(this.bevel.chtml, 'marginLeft', dx);
    adaptor.setStyle(this.bevel.chtml, 'marginRight', dx);
  };

  return CHTMLmfrac;
}(mfrac_js_1.CommonMfracMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmfrac.kind = mfrac_js_2.MmlMfrac.prototype.kind;
CHTMLmfrac.styles = {
  'mjx-frac': {
    display: 'inline-block',
    'vertical-align': '0.17em',
    padding: '0 .22em'
  },
  'mjx-frac[type="d"]': {
    'vertical-align': '.04em'
  },
  'mjx-frac[delims]': {
    padding: '0 .1em'
  },
  'mjx-frac[atop]': {
    padding: '0 .12em'
  },
  'mjx-frac[atop][delims]': {
    padding: '0'
  },
  'mjx-dtable': {
    display: 'inline-table',
    width: '100%'
  },
  'mjx-dtable > *': {
    'font-size': '2000%'
  },
  'mjx-dbox': {
    display: 'block',
    'font-size': '5%'
  },
  'mjx-num': {
    display: 'block',
    'text-align': 'center'
  },
  'mjx-den': {
    display: 'block',
    'text-align': 'center'
  },
  'mjx-mfrac[bevelled] > mjx-num': {
    display: 'inline-block'
  },
  'mjx-mfrac[bevelled] > mjx-den': {
    display: 'inline-block'
  },
  'mjx-den[align="right"], mjx-num[align="right"]': {
    'text-align': 'right'
  },
  'mjx-den[align="left"], mjx-num[align="left"]': {
    'text-align': 'left'
  },
  'mjx-nstrut': {
    display: 'inline-block',
    height: '.054em',
    width: 0,
    'vertical-align': '-.054em'
  },
  'mjx-nstrut[type="d"]': {
    height: '.217em',
    'vertical-align': '-.217em'
  },
  'mjx-dstrut': {
    display: 'inline-block',
    height: '.505em',
    width: 0
  },
  'mjx-dstrut[type="d"]': {
    height: '.726em'
  },
  'mjx-line': {
    display: 'block',
    'box-sizing': 'border-box',
    'min-height': '1px',
    height: '.06em',
    'border-top': '.06em solid',
    margin: '.06em -.1em',
    overflow: 'hidden'
  },
  'mjx-line[type="d"]': {
    margin: '.18em -.1em'
  }
};
exports.CHTMLmfrac = CHTMLmfrac;

/***/ }),
/* 272 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMfracMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.bevel = null;
      _this.pad = _this.node.getProperty('withDelims') ? 0 : _this.font.params.nulldelimiterspace;

      if (_this.node.attributes.get('bevelled')) {
        var H = _this.getBevelData(_this.isDisplay()).H;

        var bevel = _this.bevel = _this.createMo('/');

        bevel.canStretch(1);
        bevel.getStretchedVariant([H], true);
      }

      return _this;
    }

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      bbox.empty();

      var _a = this.node.attributes.getList('linethickness', 'bevelled'),
          linethickness = _a.linethickness,
          bevelled = _a.bevelled;

      var display = this.isDisplay();
      var w = null;

      if (bevelled) {
        this.getBevelledBBox(bbox, display);
      } else {
        var thickness = this.length2em(String(linethickness));
        w = -2 * this.pad;

        if (thickness === 0) {
          this.getAtopBBox(bbox, display);
        } else {
          this.getFractionBBox(bbox, display, thickness);
          w -= .2;
        }

        w += bbox.w;
      }

      bbox.clean();
      this.setChildPWidths(recompute, w);
    };

    class_1.prototype.getFractionBBox = function (bbox, display, t) {
      var nbox = this.childNodes[0].getBBox();
      var dbox = this.childNodes[1].getBBox();
      var tex = this.font.params;
      var a = tex.axis_height;

      var _a = this.getTUV(display, t),
          T = _a.T,
          u = _a.u,
          v = _a.v;

      bbox.combine(nbox, 0, a + T + Math.max(nbox.d * nbox.rscale, u));
      bbox.combine(dbox, 0, a - T - Math.max(dbox.h * dbox.rscale, v));
      bbox.w += 2 * this.pad + .2;
    };

    class_1.prototype.getTUV = function (display, t) {
      var tex = this.font.params;
      var a = tex.axis_height;
      var T = (display ? 3.5 : 1.5) * t;
      return {
        T: (display ? 3.5 : 1.5) * t,
        u: (display ? tex.num1 : tex.num2) - a - T,
        v: (display ? tex.denom1 : tex.denom2) + a - T
      };
    };

    class_1.prototype.getAtopBBox = function (bbox, display) {
      var tex = this.font.params;

      var _a = this.getUVQ(display),
          u = _a.u,
          v = _a.v,
          nbox = _a.nbox,
          dbox = _a.dbox;

      bbox.combine(nbox, 0, u);
      bbox.combine(dbox, 0, -v);
      bbox.w += 2 * this.pad;
    };

    class_1.prototype.getUVQ = function (display) {
      var nbox = this.childNodes[0].getBBox();
      var dbox = this.childNodes[1].getBBox();
      var tex = this.font.params;

      var _a = __read(display ? [tex.num1, tex.denom1] : [tex.num3, tex.denom2], 2),
          u = _a[0],
          v = _a[1];

      var p = (display ? 7 : 3) * tex.rule_thickness;
      var q = u - nbox.d * nbox.scale - (dbox.h * dbox.scale - v);

      if (q < p) {
        u += (p - q) / 2;
        v += (p - q) / 2;
        q = p;
      }

      return {
        u: u,
        v: v,
        q: q,
        nbox: nbox,
        dbox: dbox
      };
    };

    class_1.prototype.getBevelledBBox = function (bbox, display) {
      var _a = this.getBevelData(display),
          u = _a.u,
          v = _a.v,
          delta = _a.delta,
          nbox = _a.nbox,
          dbox = _a.dbox;

      var lbox = this.bevel.getBBox();
      bbox.combine(nbox, 0, u);
      bbox.combine(lbox, bbox.w - delta / 2, 0);
      bbox.combine(dbox, bbox.w - delta / 2, v);
    };

    class_1.prototype.getBevelData = function (display) {
      var nbox = this.childNodes[0].getBBox();
      var dbox = this.childNodes[1].getBBox();
      var delta = display ? .4 : .15;
      var H = Math.max(nbox.scale * (nbox.h + nbox.d), dbox.scale * (dbox.h + dbox.d)) + 2 * delta;
      var a = this.font.params.axis_height;
      var u = nbox.scale * (nbox.d - nbox.h) / 2 + a + delta;
      var v = dbox.scale * (dbox.d - dbox.h) / 2 + a - delta;
      return {
        H: H,
        delta: delta,
        u: u,
        v: v,
        nbox: nbox,
        dbox: dbox
      };
    };

    class_1.prototype.canStretch = function (direction) {
      return false;
    };

    class_1.prototype.isDisplay = function () {
      var _a = this.node.attributes.getList('displaystyle', 'scriptlevel'),
          displaystyle = _a.displaystyle,
          scriptlevel = _a.scriptlevel;

      return displaystyle && scriptlevel === 0;
    };

    class_1.prototype.getWrapWidth = function (i) {
      var attributes = this.node.attributes;

      if (attributes.get('bevelled')) {
        return this.childNodes[i].getBBox().w;
      }

      var w = this.getBBox().w;
      var thickness = this.length2em(attributes.get('linethickness'));
      return w - (thickness ? .2 : 0) - 2 * this.pad;
    };

    class_1.prototype.getChildAlign = function (i) {
      var attributes = this.node.attributes;
      return attributes.get('bevelled') ? 'left' : attributes.get(['numalign', 'denomalign'][i]);
    };

    return class_1;
  }(Base);
}

exports.CommonMfracMixin = CommonMfracMixin;

/***/ }),
/* 273 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var BBox_js_1 = __webpack_require__(23);

function CommonMsqrtMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      var surd = _this.createMo('\u221A');

      surd.canStretch(1);

      var _a = _this.childNodes[_this.base].getBBox(),
          h = _a.h,
          d = _a.d;

      var t = _this.font.params.rule_thickness;
      var p = _this.node.attributes.get('displaystyle') ? _this.font.params.x_height : t;
      _this.surdH = h + d + 2 * t + p / 4;
      surd.getStretchedVariant([_this.surdH - d, d], true);
      return _this;
    }

    Object.defineProperty(class_1.prototype, "base", {
      get: function () {
        return 0;
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_1.prototype, "surd", {
      get: function () {
        return 1;
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_1.prototype, "root", {
      get: function () {
        return null;
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.createMo = function (text) {
      var node = _super.prototype.createMo.call(this, text);

      this.childNodes.push(node);
      return node;
    };

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var surdbox = this.childNodes[this.surd].getBBox();
      var basebox = new BBox_js_1.BBox(this.childNodes[this.base].getBBox());

      var _a = __read(this.getPQ(surdbox), 2),
          p = _a[0],
          q = _a[1];

      var _b = __read(this.getRootDimens(surdbox), 1),
          x = _b[0];

      var t = this.font.params.rule_thickness;
      var H = basebox.h + q + t;
      bbox.h = H + t;
      this.combineRootBBox(bbox, surdbox);
      bbox.combine(surdbox, x, H - surdbox.h);
      bbox.combine(basebox, x + surdbox.w, 0);
      bbox.clean();
      this.setChildPWidths(recompute);
    };

    class_1.prototype.combineRootBBox = function (bbox, sbox) {};

    class_1.prototype.getPQ = function (sbox) {
      var t = this.font.params.rule_thickness;
      var p = this.node.attributes.get('displaystyle') ? this.font.params.x_height : t;
      var q = sbox.h + sbox.d > this.surdH ? (sbox.h + sbox.d - (this.surdH - t)) / 2 : t + p / 4;
      return [p, q];
    };

    class_1.prototype.getRootDimens = function (sbox) {
      return [0, 0, 0, 0];
    };

    return class_1;
  }(Base);
}

exports.CommonMsqrtMixin = CommonMsqrtMixin;

/***/ }),
/* 274 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var msqrt_js_1 = __webpack_require__(87);

var mroot_js_1 = __webpack_require__(275);

var mroot_js_2 = __webpack_require__(89);

var CHTMLmroot = function (_super) {
  __extends(CHTMLmroot, _super);

  function CHTMLmroot() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmroot.prototype.addRoot = function (ROOT, root, sbox) {
    root.toCHTML(ROOT);

    var _a = __read(this.getRootDimens(sbox), 3),
        x = _a[0],
        h = _a[1],
        dx = _a[2];

    var bbox = root.getBBox();
    this.adaptor.setStyle(ROOT, 'verticalAlign', this.em(h));
    this.adaptor.setStyle(ROOT, 'width', this.em(x));

    if (dx) {
      this.adaptor.setStyle(this.adaptor.firstChild(ROOT), 'paddingLeft', this.em(dx));
    }
  };

  return CHTMLmroot;
}(mroot_js_1.CommonMrootMixin(msqrt_js_1.CHTMLmsqrt));

CHTMLmroot.kind = mroot_js_2.MmlMroot.prototype.kind;
exports.CHTMLmroot = CHTMLmroot;

/***/ }),
/* 275 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMrootMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    Object.defineProperty(class_1.prototype, "surd", {
      get: function () {
        return 2;
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_1.prototype, "root", {
      get: function () {
        return 1;
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.combineRootBBox = function (BBOX, sbox) {
      var bbox = this.childNodes[this.root].getBBox();

      var _a = __read(this.getRootDimens(sbox), 2),
          x = _a[0],
          h = _a[1];

      BBOX.combine(bbox, 0, h);
    };

    class_1.prototype.getRootDimens = function (sbox) {
      var surd = this.childNodes[this.surd];
      var bbox = this.childNodes[this.root].getBBox();
      var offset = (surd.size < 0 ? .5 : .6) * sbox.w;
      var w = bbox.w,
          rscale = bbox.rscale;
      var W = Math.max(w, offset / rscale);
      var dx = Math.max(0, W - w);
      var h = this.rootHeight(bbox, sbox, surd.size);
      var x = W * rscale - offset;
      return [x, h, dx];
    };

    class_1.prototype.rootHeight = function (rbox, sbox, size) {
      var H = sbox.h + sbox.d;
      var b = (size < 0 ? 2 + .3 * (H - 4) : .55 * H) - sbox.d;
      return b + Math.max(0, rbox.d * rbox.rscale);
    };

    return class_1;
  }(Base);
}

exports.CommonMrootMixin = CommonMrootMixin;

/***/ }),
/* 276 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var scriptbase_js_1 = __webpack_require__(277);

var CHTMLscriptbase = function (_super) {
  __extends(CHTMLscriptbase, _super);

  function CHTMLscriptbase() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLscriptbase.prototype.toCHTML = function (parent) {
    this.chtml = this.standardCHTMLnode(parent);

    var _a = __read(this.getOffset(this.baseChild.getBBox(), this.script.getBBox()), 2),
        x = _a[0],
        v = _a[1];

    var style = {
      'vertical-align': this.em(v)
    };

    if (x) {
      style['margin-left'] = this.em(x);
    }

    this.baseChild.toCHTML(this.chtml);
    this.script.toCHTML(this.adaptor.append(this.chtml, this.html('mjx-script', {
      style: style
    })));
  };

  CHTMLscriptbase.prototype.setDeltaW = function (nodes, dx) {
    for (var i = 0; i < dx.length; i++) {
      if (dx[i]) {
        this.adaptor.setStyle(nodes[i], 'paddingLeft', this.em(dx[i]));
      }
    }
  };

  CHTMLscriptbase.prototype.adjustOverDepth = function (over, overbox) {
    if (overbox.d >= 0) return;
    this.adaptor.setStyle(over, 'marginBottom', this.em(overbox.d * overbox.rscale));
  };

  CHTMLscriptbase.prototype.adjustUnderDepth = function (under, underbox) {
    if (underbox.d >= 0) return;
    var adaptor = this.adaptor;
    var child = adaptor.firstChild(adaptor.firstChild(under));
    var v = this.em(underbox.d);
    var box = this.html('mjx-box', {
      style: {
        'margin-bottom': v,
        'vertical-align': v
      }
    });

    try {
      for (var _a = __values(adaptor.childNodes(adaptor.firstChild(under))), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child_1 = _b.value;
        adaptor.append(box, child_1);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    adaptor.append(adaptor.firstChild(under), box);

    var e_1, _c;
  };

  return CHTMLscriptbase;
}(scriptbase_js_1.CommonScriptbaseMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLscriptbase.kind = 'scriptbase';
CHTMLscriptbase.useIC = false;
exports.CHTMLscriptbase = CHTMLscriptbase;

/***/ }),
/* 277 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});
var DELTA = 1.5;

function CommonScriptbaseMixin(Base) {
  return _a = function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      var core = _this.baseCore = _this.childNodes[0];
      if (!core) return _this;

      while (core.childNodes.length === 1 && (core.node.isKind('mrow') || core.node.isKind('TeXAtom') || core.node.isKind('mstyle') || core.node.isKind('mpadded') || core.node.isKind('mphantom') || core.node.isKind('semantics'))) {
        core = core.childNodes[0];
        if (!core) return _this;
      }

      if (!('noIC' in core)) return _this;
      _this.baseCore = core;

      if (!_this.constructor.useIC) {
        core.noIC = true;
      }

      return _this;
    }

    Object.defineProperty(class_1.prototype, "baseChild", {
      get: function () {
        return this.childNodes[this.node.base];
      },
      enumerable: true,
      configurable: true
    });
    Object.defineProperty(class_1.prototype, "script", {
      get: function () {
        return this.childNodes[1];
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var basebox = this.baseChild.getBBox();
      var scriptbox = this.script.getBBox();

      var _a = __read(this.getOffset(basebox, scriptbox), 2),
          x = _a[0],
          y = _a[1];

      bbox.append(basebox);
      bbox.combine(scriptbox, bbox.w + x, y);
      bbox.w += this.font.params.scriptspace;
      bbox.clean();
      this.setChildPWidths(recompute);
    };

    class_1.prototype.coreIC = function () {
      var corebox = this.baseCore.getBBox();
      return corebox.ic ? 1.2 * corebox.ic + .05 : 0;
    };

    class_1.prototype.isCharBase = function () {
      var base = this.baseChild;

      if ((base.node.isKind('mstyle') || base.node.isKind('mrow')) && base.childNodes.length === 1) {
        base = base.childNodes[0];
      }

      return (base.node.isKind('mo') || base.node.isKind('mi') || base.node.isKind('mn')) && base.bbox.rscale === 1 && base.getText().length === 1 && !base.node.attributes.get('largeop');
    };

    class_1.prototype.getOffset = function (bbox, sbox) {
      return [0, 0];
    };

    class_1.prototype.getV = function (bbox, sbox) {
      var tex = this.font.params;
      var subscriptshift = this.length2em(this.node.attributes.get('subscriptshift'), tex.sub1);
      return Math.max(this.isCharBase() ? 0 : bbox.d + tex.sub_drop * sbox.rscale, subscriptshift, sbox.h * sbox.rscale - 4 / 5 * tex.x_height);
    };

    class_1.prototype.getU = function (bbox, sbox) {
      var tex = this.font.params;
      var attr = this.node.attributes.getList('displaystyle', 'texprimestyle', 'superscriptshift');
      var p = attr.displaystyle ? tex.sup1 : attr.texprimestyle ? tex.sup3 : tex.sup2;
      var superscriptshift = this.length2em(attr.superscriptshift, p);
      return Math.max(this.isCharBase() ? 0 : bbox.h - tex.sup_drop * sbox.rscale, superscriptshift, sbox.d * sbox.rscale + 1 / 4 * tex.x_height);
    };

    class_1.prototype.hasMovableLimits = function () {
      var display = this.node.attributes.get('displaystyle');
      return !display && (this.node.getProperty('movablelimits') || this.node.attributes.get('movablelimits') || this.baseChild.coreMO().node.attributes.get('movablelimits'));
    };

    class_1.prototype.getOverKU = function (basebox, overbox) {
      var accent = this.node.attributes.get('accent');
      var tex = this.font.params;
      var d = overbox.d * overbox.rscale;
      var k = (accent ? tex.rule_thickness : Math.max(tex.big_op_spacing1, tex.big_op_spacing3 - Math.max(0, d))) - (this.baseChild.node.isKind('munderover') ? .1 : 0);
      return [k, basebox.h * basebox.rscale + k + d];
    };

    class_1.prototype.getUnderKV = function (basebox, underbox) {
      var accent = this.node.attributes.get('accentunder');
      var tex = this.font.params;
      var h = underbox.h * underbox.rscale;
      var k = (accent ? tex.rule_thickness : Math.max(tex.big_op_spacing2, tex.big_op_spacing4 - h)) - (this.baseChild.node.isKind('munderover') ? .1 : 0);
      return [k, -(basebox.d * basebox.rscale + k + h)];
    };

    class_1.prototype.getDeltaW = function (boxes, delta) {
      if (delta === void 0) {
        delta = [0, 0, 0];
      }

      var align = this.node.attributes.get('align');
      var widths = boxes.map(function (box) {
        return box.w * box.rscale;
      });
      var w = Math.max.apply(Math, __spread(widths));
      var dw = [];
      var m = 0;

      try {
        for (var _a = __values(widths.keys()), _b = _a.next(); !_b.done; _b = _a.next()) {
          var i = _b.value;
          dw[i] = (align === 'center' ? (w - widths[i]) / 2 : align === 'right' ? w - widths[i] : 0) + delta[i];

          if (dw[i] < m) {
            m = -dw[i];
          }
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      if (m) {
        try {
          for (var _d = __values(dw.keys()), _e = _d.next(); !_e.done; _e = _d.next()) {
            var i = _e.value;
            dw[i] += m;
          }
        } catch (e_2_1) {
          e_2 = {
            error: e_2_1
          };
        } finally {
          try {
            if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
          } finally {
            if (e_2) throw e_2.error;
          }
        }
      }

      return dw;

      var e_1, _c, e_2, _f;
    };

    class_1.prototype.getDelta = function (noskew) {
      if (noskew === void 0) {
        noskew = false;
      }

      var accent = this.node.attributes.get('accent');
      var ddelta = accent && !noskew ? this.baseChild.coreMO().bbox.sk : 0;
      return DELTA * this.baseCore.bbox.ic / 2 + ddelta;
    };

    class_1.prototype.stretchChildren = function () {
      var stretchy = [];

      try {
        for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;

          if (child.canStretch(2)) {
            stretchy.push(child);
          }
        }
      } catch (e_3_1) {
        e_3 = {
          error: e_3_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_3) throw e_3.error;
        }
      }

      var count = stretchy.length;
      var nodeCount = this.childNodes.length;

      if (count && nodeCount > 1) {
        var W = 0;
        var all = count > 1 && count === nodeCount;

        try {
          for (var _d = __values(this.childNodes), _e = _d.next(); !_e.done; _e = _d.next()) {
            var child = _e.value;
            var noStretch = child.stretch.dir === 0;

            if (all || noStretch) {
              var _f = child.getBBox(noStretch),
                  w = _f.w,
                  rscale = _f.rscale;

              if (w * rscale > W) W = w * rscale;
            }
          }
        } catch (e_4_1) {
          e_4 = {
            error: e_4_1
          };
        } finally {
          try {
            if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
          } finally {
            if (e_4) throw e_4.error;
          }
        }

        try {
          for (var stretchy_1 = __values(stretchy), stretchy_1_1 = stretchy_1.next(); !stretchy_1_1.done; stretchy_1_1 = stretchy_1.next()) {
            var child = stretchy_1_1.value;
            child.coreMO().getStretchedVariant([W / child.bbox.rscale]);
          }
        } catch (e_5_1) {
          e_5 = {
            error: e_5_1
          };
        } finally {
          try {
            if (stretchy_1_1 && !stretchy_1_1.done && (_h = stretchy_1.return)) _h.call(stretchy_1);
          } finally {
            if (e_5) throw e_5.error;
          }
        }
      }

      var e_3, _c, e_4, _g, e_5, _h;
    };

    return class_1;
  }(Base), _a.useIC = false, _a;

  var _a;
}

exports.CommonScriptbaseMixin = CommonScriptbaseMixin;

/***/ }),
/* 278 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var msubsup_js_1 = __webpack_require__(50);

var munderover_js_1 = __webpack_require__(53);

var munderover_js_2 = __webpack_require__(53);

var munderover_js_3 = __webpack_require__(53);

var munderover_js_4 = __webpack_require__(90);

var CHTMLmunder = function (_super) {
  __extends(CHTMLmunder, _super);

  function CHTMLmunder() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmunder.prototype.toCHTML = function (parent) {
    if (this.hasMovableLimits()) {
      _super.prototype.toCHTML.call(this, parent);

      this.adaptor.setAttribute(this.chtml, 'limits', 'false');
      return;
    }

    this.chtml = this.standardCHTMLnode(parent);
    var base = this.adaptor.append(this.adaptor.append(this.chtml, this.html('mjx-row')), this.html('mjx-base'));
    var under = this.adaptor.append(this.adaptor.append(this.chtml, this.html('mjx-row')), this.html('mjx-under'));
    this.baseChild.toCHTML(base);
    this.script.toCHTML(under);
    var basebox = this.baseChild.getBBox();
    var underbox = this.script.getBBox();

    var _a = __read(this.getUnderKV(basebox, underbox), 2),
        k = _a[0],
        v = _a[1];

    var delta = this.getDelta(true);
    this.adaptor.setStyle(under, 'paddingTop', this.em(k));
    this.setDeltaW([base, under], this.getDeltaW([basebox, underbox], [0, -delta]));
    this.adjustUnderDepth(under, underbox);
  };

  return CHTMLmunder;
}(munderover_js_1.CommonMunderMixin(msubsup_js_1.CHTMLmsub));

CHTMLmunder.kind = munderover_js_4.MmlMunder.prototype.kind;
CHTMLmunder.useIC = true;
CHTMLmunder.styles = {
  'mjx-over': {
    'text-align': 'left'
  },
  'mjx-munder:not([limits="false"])': {
    display: 'inline-table'
  },
  'mjx-munder > mjx-row': {
    'text-align': 'left'
  },
  'mjx-under': {
    'padding-bottom': '.1em'
  }
};
exports.CHTMLmunder = CHTMLmunder;

var CHTMLmover = function (_super) {
  __extends(CHTMLmover, _super);

  function CHTMLmover() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmover.prototype.toCHTML = function (parent) {
    if (this.hasMovableLimits()) {
      _super.prototype.toCHTML.call(this, parent);

      this.adaptor.setAttribute(this.chtml, 'limits', 'false');
      return;
    }

    this.chtml = this.standardCHTMLnode(parent);
    var over = this.adaptor.append(this.chtml, this.html('mjx-over'));
    var base = this.adaptor.append(this.chtml, this.html('mjx-base'));
    this.script.toCHTML(over);
    this.baseChild.toCHTML(base);
    var overbox = this.script.getBBox();
    var basebox = this.baseChild.getBBox();

    var _a = __read(this.getOverKU(basebox, overbox), 2),
        k = _a[0],
        u = _a[1];

    var delta = this.getDelta();
    this.adaptor.setStyle(over, 'paddingBottom', this.em(k));
    this.setDeltaW([base, over], this.getDeltaW([basebox, overbox], [0, delta]));
    this.adjustOverDepth(over, overbox);
  };

  return CHTMLmover;
}(munderover_js_2.CommonMoverMixin(msubsup_js_1.CHTMLmsup));

CHTMLmover.kind = munderover_js_4.MmlMover.prototype.kind;
CHTMLmover.useIC = true;
CHTMLmover.styles = {
  'mjx-mover:not([limits="false"])': {
    'padding-top': '.1em'
  },
  'mjx-mover:not([limits="false"]) > *': {
    display: 'block',
    'text-align': 'left'
  }
};
exports.CHTMLmover = CHTMLmover;

var CHTMLmunderover = function (_super) {
  __extends(CHTMLmunderover, _super);

  function CHTMLmunderover() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmunderover.prototype.toCHTML = function (parent) {
    if (this.hasMovableLimits()) {
      _super.prototype.toCHTML.call(this, parent);

      this.adaptor.setAttribute(this.chtml, 'limits', 'false');
      return;
    }

    this.chtml = this.standardCHTMLnode(parent);
    var over = this.adaptor.append(this.chtml, this.html('mjx-over'));
    var table = this.adaptor.append(this.adaptor.append(this.chtml, this.html('mjx-box')), this.html('mjx-munder'));
    var base = this.adaptor.append(this.adaptor.append(table, this.html('mjx-row')), this.html('mjx-base'));
    var under = this.adaptor.append(this.adaptor.append(table, this.html('mjx-row')), this.html('mjx-under'));
    this.overChild.toCHTML(over);
    this.baseChild.toCHTML(base);
    this.underChild.toCHTML(under);
    var overbox = this.overChild.getBBox();
    var basebox = this.baseChild.getBBox();
    var underbox = this.underChild.getBBox();

    var _a = __read(this.getOverKU(basebox, overbox), 2),
        ok = _a[0],
        u = _a[1];

    var _b = __read(this.getUnderKV(basebox, underbox), 2),
        uk = _b[0],
        v = _b[1];

    var delta = this.getDelta();
    this.adaptor.setStyle(over, 'paddingBottom', this.em(ok));
    this.adaptor.setStyle(under, 'paddingTop', this.em(uk));
    this.setDeltaW([base, under, over], this.getDeltaW([basebox, underbox, overbox], [0, -delta, delta]));
    this.adjustOverDepth(over, overbox);
    this.adjustUnderDepth(under, underbox);
  };

  return CHTMLmunderover;
}(munderover_js_3.CommonMunderoverMixin(msubsup_js_1.CHTMLmsubsup));

CHTMLmunderover.kind = munderover_js_4.MmlMunderover.prototype.kind;
CHTMLmunderover.useIC = true;
CHTMLmunderover.styles = {
  'mjx-munderover:not([limits="false"])': {
    'padding-top': '.1em'
  },
  'mjx-munderover:not([limits="false"]) > *': {
    display: 'block'
  }
};
exports.CHTMLmunderover = CHTMLmunderover;

/***/ }),
/* 279 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var msubsup_js_1 = __webpack_require__(50);

var mmultiscripts_js_1 = __webpack_require__(280);

var mmultiscripts_js_2 = __webpack_require__(91);

var CHTMLmmultiscripts = function (_super) {
  __extends(CHTMLmmultiscripts, _super);

  function CHTMLmmultiscripts() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmmultiscripts.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);
    var data = this.getScriptData();
    var sub = this.combinePrePost(data.sub, data.psub);
    var sup = this.combinePrePost(data.sup, data.psup);

    var _a = __read(this.getUVQ(data.base, sub, sup), 3),
        u = _a[0],
        v = _a[1],
        q = _a[2];

    if (data.numPrescripts) {
      this.addScripts(u, -v, true, data.psub, data.psup, this.firstPrescript, data.numPrescripts);
    }

    this.childNodes[0].toCHTML(chtml);

    if (data.numScripts) {
      this.addScripts(u, -v, false, data.sub, data.sup, 1, data.numScripts);
    }
  };

  CHTMLmmultiscripts.prototype.addScripts = function (u, v, isPre, sub, sup, i, n) {
    var adaptor = this.adaptor;
    var q = u - sup.d + (v - sub.h);
    var U = u < 0 && v === 0 ? sub.h + u : u;
    var rowdef = q > 0 ? {
      style: {
        height: this.em(q)
      }
    } : {};
    var tabledef = U ? {
      style: {
        'vertical-align': this.em(U)
      }
    } : {};
    var supRow = this.html('mjx-row');
    var sepRow = this.html('mjx-row', rowdef);
    var subRow = this.html('mjx-row');
    var name = 'mjx-' + (isPre ? 'pre' : '') + 'scripts';
    adaptor.append(this.chtml, this.html(name, tabledef, [supRow, sepRow, subRow]));
    var m = i + 2 * n;

    while (i < m) {
      this.childNodes[i++].toCHTML(adaptor.append(subRow, this.html('mjx-cell')));
      this.childNodes[i++].toCHTML(adaptor.append(supRow, this.html('mjx-cell')));
    }
  };

  return CHTMLmmultiscripts;
}(mmultiscripts_js_1.CommonMmultiscriptsMixin(msubsup_js_1.CHTMLmsubsup));

CHTMLmmultiscripts.kind = mmultiscripts_js_2.MmlMmultiscripts.prototype.kind;
CHTMLmmultiscripts.styles = {
  'mjx-prescripts': {
    display: 'inline-table',
    'padding-left': '.05em'
  },
  'mjx-scripts': {
    display: 'inline-table',
    'padding-right': '.05em'
  },
  'mjx-prescripts > mjx-row > mjx-cell': {
    'text-align': 'right'
  }
};
exports.CHTMLmmultiscripts = CHTMLmmultiscripts;

/***/ }),
/* 280 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var BBox_js_1 = __webpack_require__(23);

exports.NextScript = {
  base: 'subList',
  subList: 'supList',
  supList: 'subList',
  psubList: 'psupList',
  psupList: 'psubList'
};
exports.ScriptNames = ['sup', 'sup', 'psup', 'psub'];

function CommonMmultiscriptsMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var _this = _super !== null && _super.apply(this, arguments) || this;

      _this.scriptData = null;
      _this.firstPrescript = 0;
      return _this;
    }

    class_1.prototype.combinePrePost = function (pre, post) {
      var bbox = new BBox_js_1.BBox(pre);
      bbox.combine(post, 0, 0);
      return bbox;
    };

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var scriptspace = this.font.params.scriptspace;
      var data = this.getScriptData();
      var sub = this.combinePrePost(data.sub, data.psub);
      var sup = this.combinePrePost(data.sup, data.psup);

      var _a = __read(this.getUVQ(data.base, sub, sup), 2),
          u = _a[0],
          v = _a[1];

      bbox.empty();

      if (data.numPrescripts) {
        bbox.combine(data.psup, scriptspace, u);
        bbox.combine(data.psub, scriptspace, v);
      }

      bbox.append(data.base);

      if (data.numScripts) {
        var w = bbox.w;
        bbox.combine(data.sup, w, u);
        bbox.combine(data.sub, w, v);
        bbox.w += scriptspace;
      }

      bbox.clean();
      this.setChildPWidths(recompute);
    };

    class_1.prototype.getScriptData = function () {
      if (this.scriptData) {
        return this.scriptData;
      }

      var data = this.scriptData = {
        base: null,
        sub: BBox_js_1.BBox.empty(),
        sup: BBox_js_1.BBox.empty(),
        psub: BBox_js_1.BBox.empty(),
        psup: BBox_js_1.BBox.empty(),
        numPrescripts: 0,
        numScripts: 0
      };
      var lists = this.getScriptBBoxLists();
      this.combineBBoxLists(data.sub, data.sup, lists.subList, lists.supList);
      this.combineBBoxLists(data.psub, data.psup, lists.psubList, lists.psupList);
      this.scriptData.base = lists.base[0];
      this.scriptData.numPrescripts = lists.psubList.length;
      this.scriptData.numScripts = lists.subList.length;
      return this.scriptData;
    };

    class_1.prototype.getScriptBBoxLists = function () {
      var lists = {
        base: [],
        subList: [],
        supList: [],
        psubList: [],
        psupList: []
      };
      var script = 'base';

      try {
        for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
          var child = _b.value;

          if (child.node.isKind('mprescripts')) {
            script = 'psubList';
          } else {
            lists[script].push(child.getBBox());
            script = exports.NextScript[script];
          }
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      this.firstPrescript = lists.subList.length + lists.supList.length + 2;
      this.padLists(lists.subList, lists.supList);
      this.padLists(lists.psubList, lists.psupList);
      return lists;

      var e_1, _c;
    };

    class_1.prototype.padLists = function (list1, list2) {
      if (list1.length > list2.length) {
        list2.push(BBox_js_1.BBox.empty());
      }
    };

    class_1.prototype.combineBBoxLists = function (bbox1, bbox2, list1, list2) {
      for (var i = 0; i < list1.length; i++) {
        var _a = __read(this.getScaledWHD(list1[i]), 3),
            w1 = _a[0],
            h1 = _a[1],
            d1 = _a[2];

        var _b = __read(this.getScaledWHD(list2[i]), 3),
            w2 = _b[0],
            h2 = _b[1],
            d2 = _b[2];

        var w = Math.max(w1, w2);
        bbox1.w += w;
        bbox2.w += w;
        if (h1 > bbox1.h) bbox1.h = h1;
        if (d1 > bbox1.d) bbox1.d = d1;
        if (h2 > bbox2.h) bbox2.h = h2;
        if (d2 > bbox2.d) bbox2.d = d2;
      }
    };

    class_1.prototype.getScaledWHD = function (bbox) {
      var w = bbox.w,
          h = bbox.h,
          d = bbox.d,
          rscale = bbox.rscale;
      return [w * rscale, h * rscale, d * rscale];
    };

    class_1.prototype.getUVQ = function (basebox, subbox, supbox) {
      if (!this.UVQ) {
        var _a = __read([0, 0, 0], 3),
            u = _a[0],
            v = _a[1],
            q = _a[2];

        if (subbox.h === 0 && subbox.d === 0) {
          u = this.getU(basebox, supbox);
        } else if (supbox.h === 0 && supbox.d === 0) {
          u = -this.getV(basebox, subbox);
        } else {
          _b = __read(_super.prototype.getUVQ.call(this, basebox, subbox, supbox), 3), u = _b[0], v = _b[1], q = _b[2];
        }

        this.UVQ = [u, v, q];
      }

      return this.UVQ;

      var _b;
    };

    return class_1;
  }(Base);
}

exports.CommonMmultiscriptsMixin = CommonMmultiscriptsMixin;

/***/ }),
/* 281 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mtable_js_1 = __webpack_require__(282);

var mtable_js_2 = __webpack_require__(92);

var string_js_1 = __webpack_require__(16);

var CHTMLmtable = function (_super) {
  __extends(CHTMLmtable, _super);

  function CHTMLmtable(factory, node, parent) {
    if (parent === void 0) {
      parent = null;
    }

    var _this = _super.call(this, factory, node, parent) || this;

    _this.itable = _this.html('mjx-itable');
    _this.labels = _this.html('mjx-itable');
    return _this;
  }

  CHTMLmtable.prototype.getAlignShift = function () {
    var data = _super.prototype.getAlignShift.call(this);

    if (!this.isTop) {
      data[1] = 0;
    }

    return data;
  };

  CHTMLmtable.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);
    this.adaptor.append(chtml, this.html('mjx-table', {}, [this.itable]));

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var child = _b.value;
        child.toCHTML(this.itable);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    this.padRows();
    this.handleColumnSpacing();
    this.handleColumnLines();
    this.handleColumnWidths();
    this.handleRowSpacing();
    this.handleRowLines();
    this.handleEqualRows();
    this.handleFrame();
    this.handleWidth();
    this.handleLabels();
    this.handleAlign();
    this.handleJustify();
    this.shiftColor();

    var e_1, _c;
  };

  CHTMLmtable.prototype.shiftColor = function () {
    var adaptor = this.adaptor;
    var color = adaptor.getStyle(this.chtml, 'backgroundColor');

    if (color) {
      adaptor.setStyle(this.chtml, 'backgroundColor', '');
      adaptor.setStyle(this.itable, 'backgroundColor', color);
    }
  };

  CHTMLmtable.prototype.padRows = function () {
    var adaptor = this.adaptor;

    try {
      for (var _a = __values(adaptor.childNodes(this.itable)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var row = _b.value;

        while (adaptor.childNodes(row).length < this.numCols) {
          adaptor.append(row, this.html('mjx-mtd'));
        }
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    var e_2, _c;
  };

  CHTMLmtable.prototype.handleColumnSpacing = function () {
    var spacing = this.getEmHalfSpacing(this.fSpace[0], this.cSpace);
    var frame = this.frame;

    try {
      for (var _a = __values(this.tableRows), _b = _a.next(); !_b.done; _b = _a.next()) {
        var row = _b.value;
        var i = 0;

        try {
          for (var _c = __values(row.tableCells), _d = _c.next(); !_d.done; _d = _c.next()) {
            var cell = _d.value;
            var lspace = spacing[i++];
            var rspace = spacing[i];
            var styleNode = cell ? cell.chtml : this.adaptor.childNodes(row.chtml)[i];

            if (i > 1 && lspace !== '0.4em' || frame && i === 1) {
              this.adaptor.setStyle(styleNode, 'paddingLeft', lspace);
            }

            if (i < this.numCols && rspace !== '0.4em' || frame && i === this.numCols) {
              this.adaptor.setStyle(styleNode, 'paddingRight', rspace);
            }
          }
        } catch (e_3_1) {
          e_3 = {
            error: e_3_1
          };
        } finally {
          try {
            if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
          } finally {
            if (e_3) throw e_3.error;
          }
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    var e_4, _f, e_3, _e;
  };

  CHTMLmtable.prototype.handleColumnLines = function () {
    if (this.node.attributes.get('columnlines') === 'none') return;
    var lines = this.getColumnAttributes('columnlines');

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var row = _b.value;
        var i = 0;

        try {
          for (var _c = __values(this.adaptor.childNodes(row.chtml).slice(1)), _d = _c.next(); !_d.done; _d = _c.next()) {
            var cell = _d.value;
            var line = lines[i++];
            if (line === 'none') continue;
            this.adaptor.setStyle(cell, 'borderLeft', '.07em ' + line);
          }
        } catch (e_5_1) {
          e_5 = {
            error: e_5_1
          };
        } finally {
          try {
            if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
          } finally {
            if (e_5) throw e_5.error;
          }
        }
      }
    } catch (e_6_1) {
      e_6 = {
        error: e_6_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
      } finally {
        if (e_6) throw e_6.error;
      }
    }

    var e_6, _f, e_5, _e;
  };

  CHTMLmtable.prototype.handleColumnWidths = function () {
    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var row = _b.value;
        var i = 0;

        try {
          for (var _c = __values(this.adaptor.childNodes(row.chtml)), _d = _c.next(); !_d.done; _d = _c.next()) {
            var cell = _d.value;
            var w = this.cWidths[i++];

            if (w !== null) {
              var width = typeof w === 'number' ? this.em(w) : w;
              this.adaptor.setStyle(cell, 'width', width);
              this.adaptor.setStyle(cell, 'maxWidth', width);
              this.adaptor.setStyle(cell, 'minWidth', width);
            }
          }
        } catch (e_7_1) {
          e_7 = {
            error: e_7_1
          };
        } finally {
          try {
            if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
          } finally {
            if (e_7) throw e_7.error;
          }
        }
      }
    } catch (e_8_1) {
      e_8 = {
        error: e_8_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
      } finally {
        if (e_8) throw e_8.error;
      }
    }

    var e_8, _f, e_7, _e;
  };

  CHTMLmtable.prototype.handleRowSpacing = function () {
    var spacing = this.getEmHalfSpacing(this.fSpace[1], this.rSpace);
    var frame = this.frame;
    var i = 0;

    try {
      for (var _a = __values(this.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var row = _b.value;
        var tspace = spacing[i++];
        var bspace = spacing[i];

        try {
          for (var _c = __values(row.childNodes), _d = _c.next(); !_d.done; _d = _c.next()) {
            var cell = _d.value;

            if (i > 1 && tspace !== '0.215em' || frame && i === 1) {
              this.adaptor.setStyle(cell.chtml, 'paddingTop', tspace);
            }

            if (i < this.numRows && bspace !== '0.215em' || frame && i === this.numRows) {
              this.adaptor.setStyle(cell.chtml, 'paddingBottom', bspace);
            }
          }
        } catch (e_9_1) {
          e_9 = {
            error: e_9_1
          };
        } finally {
          try {
            if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
          } finally {
            if (e_9) throw e_9.error;
          }
        }
      }
    } catch (e_10_1) {
      e_10 = {
        error: e_10_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
      } finally {
        if (e_10) throw e_10.error;
      }
    }

    var e_10, _f, e_9, _e;
  };

  CHTMLmtable.prototype.handleRowLines = function () {
    if (this.node.attributes.get('rowlines') === 'none') return;
    var lines = this.getRowAttributes('rowlines');
    var i = 0;

    try {
      for (var _a = __values(this.childNodes.slice(1)), _b = _a.next(); !_b.done; _b = _a.next()) {
        var row = _b.value;
        var line = lines[i++];
        if (line === 'none') continue;

        try {
          for (var _c = __values(this.adaptor.childNodes(row.chtml)), _d = _c.next(); !_d.done; _d = _c.next()) {
            var cell = _d.value;
            this.adaptor.setStyle(cell, 'borderTop', '.07em ' + line);
          }
        } catch (e_11_1) {
          e_11 = {
            error: e_11_1
          };
        } finally {
          try {
            if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
          } finally {
            if (e_11) throw e_11.error;
          }
        }
      }
    } catch (e_12_1) {
      e_12 = {
        error: e_12_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
      } finally {
        if (e_12) throw e_12.error;
      }
    }

    var e_12, _f, e_11, _e;
  };

  CHTMLmtable.prototype.handleEqualRows = function () {
    if (!this.node.attributes.get('equalrows')) return;
    var space = this.getRowHalfSpacing();

    var _a = this.getTableData(),
        H = _a.H,
        D = _a.D,
        NH = _a.NH,
        ND = _a.ND;

    var HD = this.getEqualRowHeight();
    var HDem = this.em(HD);

    for (var i = 0; i < this.numRows; i++) {
      var row = this.childNodes[i];

      if (HD !== NH[i] + ND[i]) {
        this.setRowHeight(row, HD, (HD - H[i] + D[i]) / 2, space[i] + space[i + 1]);
      }
    }
  };

  CHTMLmtable.prototype.setRowHeight = function (row, HD, D, space) {
    this.adaptor.setStyle(row.chtml, 'height', this.em(HD + space));
    var ralign = row.node.attributes.get('rowalign');

    try {
      for (var _a = __values(row.childNodes), _b = _a.next(); !_b.done; _b = _a.next()) {
        var cell = _b.value;
        if (this.setCellBaseline(cell, ralign, HD, D)) break;
      }
    } catch (e_13_1) {
      e_13 = {
        error: e_13_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_13) throw e_13.error;
      }
    }

    var e_13, _c;
  };

  CHTMLmtable.prototype.setCellBaseline = function (cell, ralign, HD, D) {
    var calign = cell.node.attributes.get('rowalign');

    if (calign === 'baseline' || calign === 'axis') {
      var adaptor = this.adaptor;
      var child = adaptor.lastChild(cell.chtml);
      adaptor.setStyle(child, 'height', this.em(HD));
      adaptor.setStyle(child, 'verticalAlign', this.em(-D));
      var row = cell.parent;

      if ((!row.node.isKind('mlabeledtr') || cell !== row.childNodes[0]) && (ralign === 'baseline' || ralign === 'axis')) {
        return true;
      }
    }

    return false;
  };

  CHTMLmtable.prototype.handleFrame = function () {
    if (this.frame) {
      this.adaptor.setStyle(this.itable, 'border', '.07em ' + this.node.attributes.get('frame'));
    }
  };

  CHTMLmtable.prototype.handleWidth = function () {
    var adaptor = this.adaptor;

    var _a = this.getBBox(),
        w = _a.w,
        L = _a.L,
        R = _a.R;

    adaptor.setStyle(this.chtml, 'minWidth', this.em(L + w + R));
    var W = this.node.attributes.get('width');

    if (string_js_1.isPercent(W)) {
      adaptor.setStyle(this.chtml, 'width', '');
      adaptor.setAttribute(this.chtml, 'width', 'full');
    } else if (!this.hasLabels) {
      if (W === 'auto') return;
      W = this.em(this.length2em(W) + 2 * this.fLine);
    }

    var table = adaptor.firstChild(this.chtml);
    adaptor.setStyle(table, 'width', W);
    adaptor.setStyle(table, 'minWidth', this.em(w));

    if (L || R) {
      adaptor.setStyle(this.chtml, 'margin', '');

      if (L === R) {
        adaptor.setStyle(table, 'margin', '0 ' + this.em(R));
      } else {
        adaptor.setStyle(table, 'margin', '0 ' + this.em(R) + ' 0 ' + this.em(L));
      }
    }

    adaptor.setAttribute(this.itable, 'width', 'full');
  };

  CHTMLmtable.prototype.handleAlign = function () {
    var _a = __read(this.getAlignmentRow(), 2),
        align = _a[0],
        row = _a[1];

    if (row === null) {
      if (align !== 'axis') {
        this.adaptor.setAttribute(this.chtml, 'align', align);
      }
    } else {
      var y = this.getVerticalPosition(row, align);
      this.adaptor.setAttribute(this.chtml, 'align', 'top');
      this.adaptor.setStyle(this.chtml, 'verticalAlign', this.em(y));
    }
  };

  CHTMLmtable.prototype.handleJustify = function () {
    var _a = __read(this.getAlignShift(), 2),
        align = _a[0],
        shift = _a[1];

    if (align !== 'center') {
      this.adaptor.setAttribute(this.chtml, 'justify', align);
    }
  };

  CHTMLmtable.prototype.handleLabels = function () {
    if (!this.hasLabels) return;
    var labels = this.labels;
    var attributes = this.node.attributes;
    var adaptor = this.adaptor;
    var side = attributes.get('side');
    adaptor.setAttribute(this.chtml, 'side', side);
    adaptor.setAttribute(labels, 'align', side);
    adaptor.setStyle(labels, side, '0');

    var _a = __read(this.addLabelPadding(side), 2),
        align = _a[0],
        shift = _a[1];

    if (shift) {
      var table = adaptor.firstChild(this.chtml);
      this.setIndent(table, align, shift);
    }

    this.updateRowHeights();
    this.addLabelSpacing();
  };

  CHTMLmtable.prototype.addLabelPadding = function (side) {
    var _a = __read(this.getPadAlignShift(side), 3),
        pad = _a[0],
        align = _a[1],
        shift = _a[2];

    var styles = {};

    if (side === 'right') {
      var W = this.node.attributes.get('width');

      var _b = this.getBBox(),
          w = _b.w,
          L = _b.L,
          R = _b.R;

      styles.style = {
        width: string_js_1.isPercent(W) ? 'calc(' + W + ' + ' + this.em(L + R) + ')' : this.em(L + w + R),
        minWidth: '100%'
      };
    }

    this.adaptor.append(this.chtml, this.html('mjx-labels', styles, [this.labels]));
    return [align, shift];
  };

  CHTMLmtable.prototype.updateRowHeights = function () {
    if (this.node.attributes.get('equalrows')) return;

    var _a = this.getTableData(),
        H = _a.H,
        D = _a.D,
        NH = _a.NH,
        ND = _a.ND;

    var space = this.getRowHalfSpacing();

    for (var i = 0; i < this.numRows; i++) {
      var row = this.childNodes[i];

      if (H[i] !== NH[i] || D[i] !== ND[i]) {
        this.setRowHeight(row, H[i] + D[i], D[i], space[i] + space[i + 1]);
      } else if (row.node.isKind('mlabeledtr')) {
        this.setCellBaseline(row.childNodes[0], '', H[i] + D[i], D[i]);
      }
    }
  };

  CHTMLmtable.prototype.addLabelSpacing = function () {
    var adaptor = this.adaptor;
    var equal = this.node.attributes.get('equalrows');

    var _a = this.getTableData(),
        H = _a.H,
        D = _a.D;

    var HD = equal ? this.getEqualRowHeight() : 0;
    var space = this.getRowHalfSpacing();
    var h = this.fLine;
    var current = adaptor.firstChild(this.labels);

    for (var i = 0; i < this.numRows; i++) {
      var row = this.childNodes[i];

      if (row.node.isKind('mlabeledtr')) {
        h && adaptor.insert(this.html('mjx-mtr', {
          style: {
            height: this.em(h)
          }
        }), current);
        adaptor.setStyle(current, 'height', this.em((equal ? HD : H[i] + D[i]) + space[i] + space[i + 1]));
        current = adaptor.next(current);
        h = this.rLines[i];
      } else {
        h += space[i] + (equal ? HD : H[i] + D[i]) + space[i + 1] + this.rLines[i];
      }
    }
  };

  return CHTMLmtable;
}(mtable_js_1.CommonMtableMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmtable.kind = mtable_js_2.MmlMtable.prototype.kind;
CHTMLmtable.styles = {
  'mjx-mtable': {
    'vertical-align': '.25em',
    'text-align': 'center',
    'position': 'relative',
    'box-sizing': 'border-box'
  },
  'mjx-labels': {
    position: 'absolute',
    left: 0,
    top: 0
  },
  'mjx-table': {
    'display': 'inline-block'
  },
  'mjx-table > mjx-itable': {
    'vertical-align': 'middle',
    'text-align': 'left',
    'box-sizing': 'border-box'
  },
  'mjx-labels > mjx-itable': {
    position: 'absolute',
    top: 0
  },
  'mjx-mtable[justify="left"]': {
    'text-align': 'left'
  },
  'mjx-mtable[justify="right"]': {
    'text-align': 'right'
  },
  'mjx-mtable[justify="left"][side="left"]': {
    'padding-right': '0 ! important'
  },
  'mjx-mtable[justify="left"][side="right"]': {
    'padding-left': '0 ! important'
  },
  'mjx-mtable[justify="right"][side="left"]': {
    'padding-right': '0 ! important'
  },
  'mjx-mtable[justify="right"][side="right"]': {
    'padding-left': '0 ! important'
  },
  'mjx-mtable[align]': {
    'vertical-align': 'baseline'
  },
  'mjx-mtable[align="top"] > mjx-table': {
    'vertical-align': 'top'
  },
  'mjx-mtable[align="bottom"] > mjx-table': {
    'vertical-align': 'bottom'
  },
  'mjx-mtable[align="center"] > mjx-table': {
    'vertical-align': 'middle'
  },
  'mjx-mtable[align="baseline"] > mjx-table': {
    'vertical-align': 'middle'
  }
};
exports.CHTMLmtable = CHTMLmtable;

/***/ }),
/* 282 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var BBox_js_1 = __webpack_require__(23);

var string_js_1 = __webpack_require__(16);

var numeric_js_1 = __webpack_require__(283);

function CommonMtableMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.numCols = 0;
      _this.numRows = 0;
      _this.data = null;
      _this.pwidthCells = [];
      _this.pWidth = 0;
      _this.numCols = numeric_js_1.max(_this.tableRows.map(function (row) {
        return row.numCells;
      }));
      _this.numRows = _this.childNodes.length;
      _this.hasLabels = _this.childNodes.reduce(function (value, row) {
        return value || row.node.isKind('mlabeledtr');
      }, false);

      _this.findContainer();

      _this.isTop = _this.container.node.isKind('math') && !_this.container.parent;

      _this.getPercentageWidth();

      var attributes = _this.node.attributes;
      _this.frame = attributes.get('frame') !== 'none';
      _this.fLine = _this.frame ? .07 : 0;
      _this.fSpace = _this.frame ? _this.convertLengths(_this.getAttributeArray('framespacing')) : [0, 0];
      _this.cSpace = _this.convertLengths(_this.getColumnAttributes('columnspacing'));
      _this.rSpace = _this.convertLengths(_this.getRowAttributes('rowspacing'));
      _this.cLines = _this.getColumnAttributes('columnlines').map(function (x) {
        return x === 'none' ? 0 : .07;
      });
      _this.rLines = _this.getRowAttributes('rowlines').map(function (x) {
        return x === 'none' ? 0 : .07;
      });
      _this.cWidths = _this.getColumnWidths();

      _this.stretchRows();

      _this.stretchColumns();

      return _this;
    }

    Object.defineProperty(class_1.prototype, "tableRows", {
      get: function () {
        return this.childNodes;
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.findContainer = function () {
      var node = this;
      var parent = node.parent;

      while (parent && (parent.node.notParent || parent.node.isKind('mrow'))) {
        node = parent;
        parent = parent.parent;
      }

      this.container = parent;
      this.containerI = node.node.childPosition();
    };

    class_1.prototype.getPercentageWidth = function () {
      if (this.hasLabels) {
        this.bbox.pwidth = BBox_js_1.BBox.fullWidth;
      } else {
        var width = this.node.attributes.get('width');

        if (string_js_1.isPercent(width)) {
          this.bbox.pwidth = width;
        }
      }
    };

    class_1.prototype.stretchRows = function () {
      var equal = this.node.attributes.get('equalrows');
      var HD = equal ? this.getEqualRowHeight() : 0;

      var _a = equal ? this.getTableData() : {
        H: [0],
        D: [0]
      },
          H = _a.H,
          D = _a.D;

      var rows = this.tableRows;

      for (var i = 0; i < this.numRows; i++) {
        var hd = equal ? [(HD + H[i] - D[i]) / 2, (HD - H[i] + D[i]) / 2] : null;
        rows[i].stretchChildren(hd);
      }
    };

    class_1.prototype.stretchColumns = function () {
      for (var i = 0; i < this.numCols; i++) {
        var width = typeof this.cWidths[i] === 'number' ? this.cWidths[i] : null;
        this.stretchColumn(i, width);
      }
    };

    class_1.prototype.stretchColumn = function (i, W) {
      var stretchy = [];

      try {
        for (var _a = __values(this.tableRows), _b = _a.next(); !_b.done; _b = _a.next()) {
          var row = _b.value;
          var cell = row.getChild(i);

          if (cell) {
            var child = cell.childNodes[0];

            if (child.stretch.dir === 0 && child.canStretch(2)) {
              stretchy.push(child);
            }
          }
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      var count = stretchy.length;
      var nodeCount = this.childNodes.length;

      if (count && nodeCount > 1) {
        if (W === null) {
          W = 0;
          var all = count > 1 && count === nodeCount;

          try {
            for (var _d = __values(this.tableRows), _e = _d.next(); !_e.done; _e = _d.next()) {
              var row = _e.value;
              var cell = row.getChild(i);

              if (cell) {
                var child = cell.childNodes[0];
                var noStretch = child.stretch.dir === 0;

                if (all || noStretch) {
                  var w = child.getBBox(noStretch).w;

                  if (w > W) {
                    W = w;
                  }
                }
              }
            }
          } catch (e_2_1) {
            e_2 = {
              error: e_2_1
            };
          } finally {
            try {
              if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
            } finally {
              if (e_2) throw e_2.error;
            }
          }
        }

        try {
          for (var stretchy_1 = __values(stretchy), stretchy_1_1 = stretchy_1.next(); !stretchy_1_1.done; stretchy_1_1 = stretchy_1.next()) {
            var child = stretchy_1_1.value;
            child.coreMO().getStretchedVariant([W]);
          }
        } catch (e_3_1) {
          e_3 = {
            error: e_3_1
          };
        } finally {
          try {
            if (stretchy_1_1 && !stretchy_1_1.done && (_g = stretchy_1.return)) _g.call(stretchy_1);
          } finally {
            if (e_3) throw e_3.error;
          }
        }
      }

      var e_1, _c, e_2, _f, e_3, _g;
    };

    class_1.prototype.getTableData = function () {
      if (this.data) {
        return this.data;
      }

      var H = new Array(this.numRows).fill(0);
      var D = new Array(this.numRows).fill(0);
      var W = new Array(this.numCols).fill(0);
      var NH = new Array(this.numRows);
      var ND = new Array(this.numRows);
      var LW = [0];
      var rows = this.tableRows;

      for (var j = 0; j < rows.length; j++) {
        var row = rows[j];

        for (var i = 0; i < row.numCells; i++) {
          var cell = row.getChild(i);
          this.updateHDW(cell, i, j, H, D, W);
          this.recordPWidthCell(cell, i);
        }

        NH[j] = H[j];
        ND[j] = D[j];

        if (row.labeled) {
          this.updateHDW(row.childNodes[0], 0, j, H, D, LW);
        }
      }

      var w = this.node.attributes.get('width');
      var L = LW[0];
      this.data = {
        H: H,
        D: D,
        W: W,
        NH: NH,
        ND: ND,
        L: L
      };
      return this.data;
    };

    class_1.prototype.updateHDW = function (cell, i, j, H, D, W) {
      if (W === void 0) {
        W = null;
      }

      var _a = cell.getBBox(),
          h = _a.h,
          d = _a.d,
          w = _a.w,
          pwidth = _a.pwidth;

      if (h < .75) h = .75;
      if (d < .25) d = .25;
      if (h > H[j]) H[j] = h;
      if (d > D[j]) D[j] = d;
      if (W && w > W[i]) W[i] = w;
    };

    class_1.prototype.recordPWidthCell = function (cell, i) {
      if (cell.childNodes[0] && cell.childNodes[0].getBBox().pwidth) {
        this.pwidthCells.push([cell, i]);
      }
    };

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var _a = this.getTableData(),
          H = _a.H,
          D = _a.D;

      var height, width;

      if (this.node.attributes.get('equalrows')) {
        var HD = this.getEqualRowHeight();
        height = numeric_js_1.sum([].concat(this.rLines, this.rSpace)) + HD * this.numRows;
      } else {
        height = numeric_js_1.sum(H.concat(D, this.rLines, this.rSpace));
      }

      height += 2 * (this.fLine + this.fSpace[1]);
      var CW = this.getComputedWidths();
      width = numeric_js_1.sum(CW.concat(this.cLines, this.cSpace)) + 2 * (this.fLine + this.fSpace[0]);
      var w = this.node.attributes.get('width');

      if (w !== 'auto') {
        width = Math.max(this.length2em(w, 0) + 2 * this.fLine, width);
      }

      var _b = __read(this.getBBoxHD(height), 2),
          h = _b[0],
          d = _b[1];

      bbox.h = h;
      bbox.d = d;
      bbox.w = width;

      var _c = __read(this.getBBoxLR(), 2),
          L = _c[0],
          R = _c[1];

      bbox.L = L;
      bbox.R = R;

      if (!string_js_1.isPercent(w)) {
        this.setColumnPWidths();
      }
    };

    class_1.prototype.setChildPWidths = function (recompute, cwidth, clear) {
      var width = this.node.attributes.get('width');
      if (!string_js_1.isPercent(width)) return;

      if (!this.hasLabels) {
        this.bbox.pwidth = '';
        this.container.bbox.pwidth = '';
      }

      var _a = this.bbox,
          w = _a.w,
          L = _a.L,
          R = _a.R;
      var W = Math.max(w, this.length2em(width, Math.max(cwidth, L + w + R)));
      var cols = this.node.attributes.get('equalcolumns') ? Array(this.numCols).fill(this.percent(1 / Math.max(1, this.numCols))) : this.getColumnAttributes('columnwidth', 0);
      this.cWidths = this.getColumnWidthsFixed(cols, W);
      var CW = this.getComputedWidths();
      this.pWidth = numeric_js_1.sum(CW.concat(this.cLines, this.cSpace)) + 2 * (this.fLine + this.fSpace[0]);

      if (this.isTop) {
        this.bbox.w = this.pWidth;
      }

      this.setColumnPWidths();

      if (this.pWidth !== w) {
        this.parent.invalidateBBox();
      }

      return this.pWidth !== w;
    };

    class_1.prototype.setColumnPWidths = function () {
      var W = this.cWidths;

      try {
        for (var _a = __values(this.pwidthCells), _b = _a.next(); !_b.done; _b = _a.next()) {
          var _c = __read(_b.value, 2),
              cell = _c[0],
              i = _c[1];

          if (cell.setChildPWidths(false, W[i])) {
            cell.invalidateBBox();
            cell.getBBox();
          }
        }
      } catch (e_4_1) {
        e_4 = {
          error: e_4_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
        } finally {
          if (e_4) throw e_4.error;
        }
      }

      var e_4, _d;
    };

    class_1.prototype.getBBoxHD = function (height) {
      var _a = __read(this.getAlignmentRow(), 2),
          align = _a[0],
          row = _a[1];

      if (row === null) {
        var a = this.font.params.axis_height;
        var h2 = height / 2;
        var HD = {
          top: [0, height],
          center: [h2, h2],
          bottom: [height, 0],
          baseline: [h2, h2],
          axis: [h2 + a, h2 - a]
        };
        return HD[align] || [h2, h2];
      } else {
        var y = this.getVerticalPosition(row, align);
        return [y, height - y];
      }
    };

    class_1.prototype.getBBoxLR = function () {
      if (this.hasLabels) {
        var side = this.node.attributes.get('side');

        var _a = __read(this.getPadAlignShift(side), 3),
            pad = _a[0],
            align = _a[1],
            shift = _a[2];

        return align === 'center' ? [pad, pad] : side === 'left' ? [pad, 0] : [0, pad];
      }

      return [0, 0];
    };

    class_1.prototype.getPadAlignShift = function (side) {
      var L = this.getTableData().L;
      var sep = this.length2em(this.node.attributes.get('minlabelspacing'));
      var pad = L + sep;

      var _a = __read(this.styles == null ? ['', ''] : [this.styles.get('padding-left'), this.styles.get('padding-right')], 2),
          lpad = _a[0],
          rpad = _a[1];

      if (lpad || rpad) {
        pad = Math.max(pad, this.length2em(lpad || '0'), this.length2em(rpad || '0'));
      }

      var _b = __read(this.getAlignShift(), 2),
          align = _b[0],
          shift = _b[1];

      if (align === side) {
        shift = side === 'left' ? Math.max(pad, shift) - pad : Math.min(-pad, shift) + pad;
      }

      return [pad, align, shift];
    };

    class_1.prototype.getAlignShift = function () {
      return this.isTop ? _super.prototype.getAlignShift.call(this) : [this.container.getChildAlign(this.containerI), 0];
    };

    class_1.prototype.getWidth = function () {
      return this.pWidth || this.getBBox().w;
    };

    class_1.prototype.getEqualRowHeight = function () {
      var _a = this.getTableData(),
          H = _a.H,
          D = _a.D;

      var HD = Array.from(H.keys()).map(function (i) {
        return H[i] + D[i];
      });
      return Math.max.apply(Math, HD);
    };

    class_1.prototype.getComputedWidths = function () {
      var _this = this;

      var W = this.getTableData().W;
      var CW = Array.from(W.keys()).map(function (i) {
        return typeof _this.cWidths[i] === 'number' ? _this.cWidths[i] : W[i];
      });

      if (this.node.attributes.get('equalcolumns')) {
        CW = Array(CW.length).fill(numeric_js_1.max(CW));
      }

      return CW;
    };

    class_1.prototype.getColumnWidths = function () {
      var width = this.node.attributes.get('width');

      if (this.node.attributes.get('equalcolumns')) {
        return this.getEqualColumns(width);
      }

      var swidths = this.getColumnAttributes('columnwidth', 0);

      if (width === 'auto') {
        return this.getColumnWidthsAuto(swidths);
      }

      if (string_js_1.isPercent(width)) {
        return this.getColumnWidthsPercent(swidths, width);
      }

      return this.getColumnWidthsFixed(swidths, this.length2em(width));
    };

    class_1.prototype.getEqualColumns = function (width) {
      var n = Math.max(1, this.numCols);
      var cwidth;

      if (width === 'auto') {
        var W = this.getTableData().W;
        cwidth = numeric_js_1.max(W);
      } else if (string_js_1.isPercent(width)) {
        cwidth = this.percent(1 / n);
      } else {
        var w = numeric_js_1.sum([].concat(this.cLines, this.cSpace)) + 2 * this.fSpace[0];
        cwidth = Math.max(0, this.length2em(width) - w) / n;
      }

      return Array(this.numCols).fill(cwidth);
    };

    class_1.prototype.getColumnWidthsAuto = function (swidths) {
      var _this = this;

      return swidths.map(function (x) {
        if (x === 'auto' || x === 'fit') return null;
        if (string_js_1.isPercent(x)) return x;
        return _this.length2em(x);
      });
    };

    class_1.prototype.getColumnWidthsPercent = function (swidths, width) {
      var _this = this;

      var hasFit = swidths.indexOf('fit') >= 0;
      var W = (hasFit ? this.getTableData() : {
        W: null
      }).W;
      return Array.from(swidths.keys()).map(function (i) {
        var x = swidths[i];
        if (x === 'fit') return null;
        if (x === 'auto') return hasFit ? W[i] : null;
        if (string_js_1.isPercent(x)) return x;
        return _this.length2em(x);
      });
    };

    class_1.prototype.getColumnWidthsFixed = function (swidths, width) {
      var _this = this;

      var indices = Array.from(swidths.keys());
      var fit = indices.filter(function (i) {
        return swidths[i] === 'fit';
      });
      var auto = indices.filter(function (i) {
        return swidths[i] === 'auto';
      });
      var n = fit.length || auto.length;
      var W = (n ? this.getTableData() : {
        W: null
      }).W;
      var cwidth = width - numeric_js_1.sum([].concat(this.cLines, this.cSpace)) - 2 * this.fSpace[0];
      var dw = cwidth;
      indices.forEach(function (i) {
        var x = swidths[i];
        dw -= x === 'fit' || x === 'auto' ? W[i] : _this.length2em(x, width);
      });
      var fw = n && dw > 0 ? dw / n : 0;
      return indices.map(function (i) {
        var x = swidths[i];
        if (x === 'fit') return W[i] + fw;
        if (x === 'auto') return W[i] + (fit.length === 0 ? fw : 0);
        return _this.length2em(x, cwidth);
      });
    };

    class_1.prototype.getVerticalPosition = function (i, align) {
      var equal = this.node.attributes.get('equalrows');

      var _a = this.getTableData(),
          H = _a.H,
          D = _a.D;

      var HD = equal ? this.getEqualRowHeight() : 0;
      var space = this.getRowHalfSpacing();
      var y = this.fLine;

      for (var j = 0; j < i; j++) {
        y += space[j] + (equal ? HD : H[j] + D[j]) + space[j + 1] + this.rLines[j];
      }

      var _b = __read(equal ? [(HD + H[i] - D[i]) / 2, (HD - H[i] + D[i]) / 2] : [H[i], D[i]], 2),
          h = _b[0],
          d = _b[1];

      var offset = {
        top: 0,
        center: space[i] + (h + d) / 2,
        bottom: space[i] + h + d + space[i + 1],
        baseline: space[i] + h,
        axis: space[i] + h - .25
      };
      y += offset[align] || 0;
      return y;
    };

    class_1.prototype.getEmHalfSpacing = function (fspace, space) {
      var fspaceEm = this.em(fspace);
      var spaceEm = this.addEm(space, 2);
      spaceEm.unshift(fspaceEm);
      spaceEm.push(fspaceEm);
      return spaceEm;
    };

    class_1.prototype.getRowHalfSpacing = function () {
      var space = this.rSpace.map(function (x) {
        return x / 2;
      });
      space.unshift(this.fSpace[1]);
      space.push(this.fSpace[1]);
      return space;
    };

    class_1.prototype.getColumnHalfSpacing = function () {
      var space = this.cSpace.map(function (x) {
        return x / 2;
      });
      space.unshift(this.fSpace[0]);
      space.push(this.fSpace[0]);
      return space;
    };

    class_1.prototype.getAlignmentRow = function () {
      var _a = __read(string_js_1.split(this.node.attributes.get('align')), 2),
          align = _a[0],
          row = _a[1];

      if (row == null) return [align, null];
      var i = parseInt(row);
      if (i < 0) i += this.numRows;
      return [align, i < 1 || i > this.numRows ? null : i - 1];
    };

    class_1.prototype.getColumnAttributes = function (name, i) {
      if (i === void 0) {
        i = 1;
      }

      var n = this.numCols - i;
      var columns = this.getAttributeArray(name);
      if (columns.length === 0) return;

      while (columns.length < n) {
        columns.push(columns[columns.length - 1]);
      }

      if (columns.length > n) {
        columns.splice(n);
      }

      return columns;
    };

    class_1.prototype.getRowAttributes = function (name, i) {
      if (i === void 0) {
        i = 1;
      }

      var n = this.numRows - i;
      var rows = this.getAttributeArray(name);
      if (rows.length === 0) return;

      while (rows.length < n) {
        rows.push(rows[rows.length - 1]);
      }

      if (rows.length > n) {
        rows.splice(n);
      }

      return rows;
    };

    class_1.prototype.getAttributeArray = function (name) {
      var value = this.node.attributes.get(name);
      if (!value) return [this.node.attributes.getDefault(name)];
      return string_js_1.split(value);
    };

    class_1.prototype.addEm = function (list, n) {
      var _this = this;

      if (n === void 0) {
        n = 1;
      }

      if (!list) return;
      return list.map(function (x) {
        return _this.em(x / n);
      });
    };

    class_1.prototype.convertLengths = function (list) {
      var _this = this;

      if (!list) return;
      return list.map(function (x) {
        return _this.length2em(x);
      });
    };

    return class_1;
  }(Base);
}

exports.CommonMtableMixin = CommonMtableMixin;

/***/ }),
/* 283 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

function sum(A) {
  return A.reduce(function (a, b) {
    return a + b;
  }, 0);
}

exports.sum = sum;

function max(A) {
  return A.reduce(function (a, b) {
    return Math.max(a, b);
  }, 0);
}

exports.max = max;

/***/ }),
/* 284 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mtr_js_1 = __webpack_require__(93);

var mtr_js_2 = __webpack_require__(93);

var mtr_js_3 = __webpack_require__(94);

var CHTMLmtr = function (_super) {
  __extends(CHTMLmtr, _super);

  function CHTMLmtr() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmtr.prototype.toCHTML = function (parent) {
    _super.prototype.toCHTML.call(this, parent);

    var align = this.node.attributes.get('rowalign');

    if (align !== 'baseline') {
      this.adaptor.setAttribute(this.chtml, 'rowalign', align);
    }
  };

  return CHTMLmtr;
}(mtr_js_1.CommonMtrMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmtr.kind = mtr_js_3.MmlMtr.prototype.kind;
CHTMLmtr.styles = {
  'mjx-mtr': {
    display: 'table-row'
  },
  'mjx-mtr[rowalign="top"] > mjx-mtd': {
    'vertical-align': 'top'
  },
  'mjx-mtr[rowalign="center"] > mjx-mtd': {
    'vertical-align': 'middle'
  },
  'mjx-mtr[rowalign="bottom"] > mjx-mtd': {
    'vertical-align': 'bottom'
  },
  'mjx-mtr[rowalign="baseline"] > mjx-mtd': {
    'vertical-align': 'baseline'
  },
  'mjx-mtr[rowalign="axis"] > mjx-mtd': {
    'vertical-align': '.25em'
  }
};
exports.CHTMLmtr = CHTMLmtr;

var CHTMLmlabeledtr = function (_super) {
  __extends(CHTMLmlabeledtr, _super);

  function CHTMLmlabeledtr() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmlabeledtr.prototype.toCHTML = function (parent) {
    _super.prototype.toCHTML.call(this, parent);

    var child = this.adaptor.firstChild(this.chtml);

    if (child) {
      this.adaptor.remove(child);
      var align = this.node.attributes.get('rowalign');
      var attr = align !== 'baseline' && align !== 'axis' ? {
        rowalign: align
      } : {};
      var row = this.html('mjx-mtr', attr, [child]);
      this.adaptor.append(this.parent.labels, row);
    }
  };

  return CHTMLmlabeledtr;
}(mtr_js_2.CommonMlabeledtrMixin(CHTMLmtr));

CHTMLmlabeledtr.kind = mtr_js_3.MmlMlabeledtr.prototype.kind;
CHTMLmlabeledtr.styles = {
  'mjx-mlabeledtr': {
    display: 'table-row'
  },
  'mjx-mlabeledtr[rowalign="top"] > mjx-mtd': {
    'vertical-align': 'top'
  },
  'mjx-mlabeledtr[rowalign="center"] > mjx-mtd': {
    'vertical-align': 'middle'
  },
  'mjx-mlabeledtr[rowalign="bottom"] > mjx-mtd': {
    'vertical-align': 'bottom'
  },
  'mjx-mlabeledtr[rowalign="baseline"] > mjx-mtd': {
    'vertical-align': 'baseline'
  },
  'mjx-mlabeledtr[rowalign="axis"] > mjx-mtd': {
    'vertical-align': '.25em'
  }
};
exports.CHTMLmlabeledtr = CHTMLmlabeledtr;

/***/ }),
/* 285 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mtd_js_1 = __webpack_require__(286);

var mtd_js_2 = __webpack_require__(95);

var CHTMLmtd = function (_super) {
  __extends(CHTMLmtd, _super);

  function CHTMLmtd() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmtd.prototype.toCHTML = function (parent) {
    _super.prototype.toCHTML.call(this, parent);

    var ralign = this.node.attributes.get('rowalign');
    var calign = this.node.attributes.get('columnalign');
    var palign = this.parent.node.attributes.get('rowalign');

    if (ralign !== palign) {
      this.adaptor.setAttribute(this.chtml, 'rowalign', ralign);
    }

    if (calign !== 'center' && (this.parent.kind !== 'mlabeledtr' || this !== this.parent.childNodes[0] || calign !== this.parent.parent.node.attributes.get('side'))) {
      this.adaptor.setStyle(this.chtml, 'textAlign', calign);
    }

    this.adaptor.append(this.chtml, this.html('mjx-tstrut'));
  };

  return CHTMLmtd;
}(mtd_js_1.CommonMtdMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmtd.kind = mtd_js_2.MmlMtd.prototype.kind;
CHTMLmtd.styles = {
  'mjx-mtd': {
    display: 'table-cell',
    'text-align': 'center',
    'padding': '.215em .4em'
  },
  'mjx-mtd:first-child': {
    'padding-left': 0
  },
  'mjx-mtd:last-child': {
    'padding-right': 0
  },
  'mjx-mtable > * > mjx-itable > *:first-child > mjx-mtd': {
    'padding-top': 0
  },
  'mjx-mtable > * > mjx-itable > *:last-child > mjx-mtd': {
    'padding-bottom': 0
  },
  'mjx-tstrut': {
    display: 'inline-block',
    height: '1em',
    'vertical-align': '-.25em'
  },
  'mjx-labels[align="left"] > mjx-mtr > mjx-mtd': {
    'text-align': 'left'
  },
  'mjx-labels[align="right"] > mjx-mtr > mjx-mtd': {
    'text-align': 'right'
  },
  'mjx-mtr mjx-mtd[rowalign="top"], mjx-mlabeledtr mjx-mtd[rowalign="top"]': {
    'vertical-align': 'top'
  },
  'mjx-mtr mjx-mtd[rowalign="center"], mjx-mlabeledtr mjx-mtd[rowalign="center"]': {
    'vertical-align': 'middle'
  },
  'mjx-mtr mjx-mtd[rowalign="bottom"], mjx-mlabeledtr mjx-mtd[rowalign="bottom"]': {
    'vertical-align': 'bottom'
  },
  'mjx-mtr mjx-mtd[rowalign="baseline"], mjx-mlabeledtr mjx-mtd[rowalign="baseline"]': {
    'vertical-align': 'baseline'
  },
  'mjx-mtr mjx-mtd[rowalign="axis"], mjx-mlabeledtr mjx-mtd[rowalign="axis"]': {
    'vertical-align': '.25em'
  }
};
exports.CHTMLmtd = CHTMLmtd;

/***/ }),
/* 286 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMtdMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    Object.defineProperty(class_1.prototype, "fixesPWidth", {
      get: function () {
        return false;
      },
      enumerable: true,
      configurable: true
    });

    class_1.prototype.invalidateBBox = function () {
      this.bboxComputed = false;
    };

    class_1.prototype.getWrapWidth = function (j) {
      var table = this.parent.parent;
      var row = this.parent;
      var i = this.node.childPosition() - (row.labeled ? 1 : 0);
      return typeof table.cWidths[i] === 'number' ? table.cWidths[i] : table.getTableData().W[i];
    };

    class_1.prototype.getChildAlign = function (i) {
      return this.node.attributes.get('columnalign');
    };

    return class_1;
  }(Base);
}

exports.CommonMtdMixin = CommonMtdMixin;

/***/ }),
/* 287 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var maction_js_1 = __webpack_require__(96);

var maction_js_2 = __webpack_require__(96);

var maction_js_3 = __webpack_require__(97);

var CHTMLmaction = function (_super) {
  __extends(CHTMLmaction, _super);

  function CHTMLmaction() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmaction.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);
    var child = this.selected;
    child.toCHTML(chtml);
    this.action(this, this.data);
  };

  CHTMLmaction.prototype.setEventHandler = function (type, handler) {
    this.chtml.addEventListener(type, handler);
  };

  return CHTMLmaction;
}(maction_js_1.CommonMactionMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmaction.kind = maction_js_3.MmlMaction.prototype.kind;
CHTMLmaction.styles = {
  'mjx-maction': {
    position: 'relative'
  },
  'mjx-maction > mjx-tool': {
    display: 'none',
    position: 'absolute',
    bottom: 0,
    right: 0,
    width: 0,
    height: 0,
    'z-index': 500
  },
  'mjx-tool > mjx-tip': {
    display: 'inline-block',
    padding: '.2em',
    border: '1px solid #888',
    'font-size': '70%',
    'background-color': '#F8F8F8',
    color: 'black',
    'box-shadow': '2px 2px 5px #AAAAAA'
  },
  'mjx-maction[toggle]': {
    cursor: 'pointer'
  },
  'mjx-status': {
    display: 'block',
    position: 'fixed',
    left: '1em',
    bottom: '1em',
    'min-width': '25%',
    padding: '.2em .4em',
    border: '1px solid #888',
    'font-size': '90%',
    'background-color': '#F8F8F8',
    color: 'black'
  }
};
CHTMLmaction.actions = new Map([['toggle', [function (node, data) {
  node.adaptor.setAttribute(node.chtml, 'toggle', node.node.attributes.get('selection'));
  var math = node.factory.jax.math;
  var document = node.factory.jax.document;
  var mml = node.node;
  node.setEventHandler('click', function (event) {
    if (!math.start.node) {
      math.start.node = math.end.node = math.typesetRoot;
      math.start.n = math.end.n = 0;
    }

    mml.nextToggleSelection();
    math.rerender(document);
    event.stopPropagation();
  });
}, {}]], ['tooltip', [function (node, data) {
  var tip = node.childNodes[1];
  if (!tip) return;

  if (tip.node.isKind('mtext')) {
    var text = tip.node.getText();
    node.adaptor.setAttribute(node.chtml, 'title', text);
  } else {
    var adaptor_1 = node.adaptor;
    var tool_1 = adaptor_1.append(node.chtml, node.html('mjx-tool', {
      style: {
        bottom: node.em(-node.dy),
        right: node.em(-node.dx)
      }
    }, [node.html('mjx-tip')]));
    tip.toCHTML(adaptor_1.firstChild(tool_1));
    node.setEventHandler('mouseover', function (event) {
      data.stopTimers(node, data);
      var timeout = setTimeout(function () {
        return adaptor_1.setStyle(tool_1, 'display', 'block');
      }, data.postDelay);
      data.hoverTimer.set(node, timeout);
      event.stopPropagation();
    });
    node.setEventHandler('mouseout', function (event) {
      data.stopTimers(node, data);
      var timeout = setTimeout(function () {
        return adaptor_1.setStyle(tool_1, 'display', '');
      }, data.clearDelay);
      data.clearTimer.set(node, timeout);
      event.stopPropagation();
    });
  }
}, maction_js_2.TooltipData]], ['statusline', [function (node, data) {
  var tip = node.childNodes[1];
  if (!tip) return;

  if (tip.node.isKind('mtext')) {
    var adaptor_2 = node.adaptor;
    var text_1 = tip.node.getText();
    adaptor_2.setAttribute(node.chtml, 'statusline', text_1);
    node.setEventHandler('mouseover', function (event) {
      if (data.status === null) {
        var body = adaptor_2.body(adaptor_2.document);
        data.status = adaptor_2.append(body, node.html('mjx-status', {}, [node.text(text_1)]));
      }

      event.stopPropagation();
    });
    node.setEventHandler('mouseout', function (event) {
      if (data.status) {
        adaptor_2.remove(data.status);
        data.status = null;
      }

      event.stopPropagation();
    });
  }
}, {
  status: null
}]]]);
exports.CHTMLmaction = CHTMLmaction;

/***/ }),
/* 288 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var mglyph_js_1 = __webpack_require__(289);

var mglyph_js_2 = __webpack_require__(98);

var CHTMLmglyph = function (_super) {
  __extends(CHTMLmglyph, _super);

  function CHTMLmglyph() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLmglyph.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);

    var _a = this.node.attributes.getList('src', 'alt'),
        src = _a.src,
        alt = _a.alt;

    var styles = {
      width: this.em(this.width),
      height: this.em(this.height)
    };

    if (this.voffset) {
      styles.verticalAlign = this.em(-this.voffset);
    }

    var img = this.html('img', {
      src: src,
      style: styles,
      alt: alt,
      title: alt
    });
    this.adaptor.append(chtml, img);
  };

  return CHTMLmglyph;
}(mglyph_js_1.CommonMglyphMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLmglyph.kind = mglyph_js_2.MmlMglyph.prototype.kind;
CHTMLmglyph.styles = {
  'mjx-mglyph > img': {
    display: 'inline-block',
    border: 0,
    padding: 0
  }
};
exports.CHTMLmglyph = CHTMLmglyph;

/***/ }),
/* 289 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonMglyphMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      var args = [];

      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }

      var _this = _super.apply(this, __spread(args)) || this;

      _this.getParameters();

      return _this;
    }

    class_1.prototype.getParameters = function () {
      var _a = this.node.attributes.getList('width', 'height', 'voffset'),
          width = _a.width,
          height = _a.height,
          voffset = _a.voffset;

      this.width = width === 'auto' ? 1 : this.length2em(width);
      this.height = height === 'auto' ? 1 : this.length2em(height);
      this.voffset = this.length2em(voffset || '0');
    };

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      bbox.w = this.width;
      bbox.h = this.height - this.voffset;
      bbox.d = this.voffset;
    };

    return class_1;
  }(Base);
}

exports.CommonMglyphMixin = CommonMglyphMixin;

/***/ }),
/* 290 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var semantics_js_1 = __webpack_require__(291);

var semantics_js_2 = __webpack_require__(99);

var MmlNode_js_1 = __webpack_require__(0);

var CHTMLsemantics = function (_super) {
  __extends(CHTMLsemantics, _super);

  function CHTMLsemantics() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLsemantics.prototype.toCHTML = function (parent) {
    var chtml = this.standardCHTMLnode(parent);

    if (this.childNodes.length) {
      this.childNodes[0].toCHTML(chtml);
    }
  };

  return CHTMLsemantics;
}(semantics_js_1.CommonSemanticsMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLsemantics.kind = semantics_js_2.MmlSemantics.prototype.kind;
exports.CHTMLsemantics = CHTMLsemantics;

var CHTMLannotation = function (_super) {
  __extends(CHTMLannotation, _super);

  function CHTMLannotation() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLannotation.prototype.toCHTML = function (parent) {
    _super.prototype.toCHTML.call(this, parent);
  };

  CHTMLannotation.prototype.computeBBox = function () {
    return this.bbox;
  };

  return CHTMLannotation;
}(Wrapper_js_1.CHTMLWrapper);

CHTMLannotation.kind = semantics_js_2.MmlAnnotation.prototype.kind;
exports.CHTMLannotation = CHTMLannotation;

var CHTMLannotationXML = function (_super) {
  __extends(CHTMLannotationXML, _super);

  function CHTMLannotationXML() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return CHTMLannotationXML;
}(Wrapper_js_1.CHTMLWrapper);

CHTMLannotationXML.kind = semantics_js_2.MmlAnnotationXML.prototype.kind;
exports.CHTMLannotationXML = CHTMLannotationXML;

var CHTMLxml = function (_super) {
  __extends(CHTMLxml, _super);

  function CHTMLxml() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLxml.prototype.toCHTML = function (parent) {
    this.adaptor.append(parent, this.adaptor.clone(this.node.getXML()));
  };

  CHTMLxml.prototype.computeBBox = function () {
    return this.bbox;
  };

  CHTMLxml.prototype.getStyles = function () {};

  CHTMLxml.prototype.getScale = function () {};

  CHTMLxml.prototype.getVariant = function () {};

  return CHTMLxml;
}(Wrapper_js_1.CHTMLWrapper);

CHTMLxml.kind = MmlNode_js_1.XMLNode.prototype.kind;
CHTMLxml.autoStyle = false;
exports.CHTMLxml = CHTMLxml;

/***/ }),
/* 291 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonSemanticsMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      if (this.childNodes.length) {
        var _a = this.childNodes[0].getBBox(),
            w = _a.w,
            h = _a.h,
            d = _a.d;

        bbox.w = w;
        bbox.h = h;
        bbox.d = d;
      }
    };

    return class_1;
  }(Base);
}

exports.CommonSemanticsMixin = CommonSemanticsMixin;

/***/ }),
/* 292 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Wrapper_js_1 = __webpack_require__(3);

var TeXAtom_js_1 = __webpack_require__(293);

var TeXAtom_js_2 = __webpack_require__(100);

var MmlNode_js_1 = __webpack_require__(0);

var CHTMLTeXAtom = function (_super) {
  __extends(CHTMLTeXAtom, _super);

  function CHTMLTeXAtom() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLTeXAtom.prototype.toCHTML = function (parent) {
    _super.prototype.toCHTML.call(this, parent);

    if (this.node.texClass === MmlNode_js_1.TEXCLASS.VCENTER) {
      var bbox = this.childNodes[0].getBBox();
      var h = bbox.h,
          d = bbox.d;
      var a = this.font.params.axis_height;
      var dh = (h + d) / 2 + a - h;
      this.adaptor.setStyle(this.chtml, 'verticalAlign', this.em(dh));
    }
  };

  return CHTMLTeXAtom;
}(TeXAtom_js_1.CommonTeXAtomMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLTeXAtom.kind = TeXAtom_js_2.TeXAtom.prototype.kind;
exports.CHTMLTeXAtom = CHTMLTeXAtom;

/***/ }),
/* 293 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

function CommonTeXAtomMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      _super.prototype.computeBBox.call(this, bbox, recompute);

      if (this.childNodes[0] && this.childNodes[0].bbox.ic) {
        bbox.ic = this.childNodes[0].bbox.ic;
      }

      if (this.node.texClass === MmlNode_js_1.TEXCLASS.VCENTER) {
        var h = bbox.h,
            d = bbox.d;
        var a = this.font.params.axis_height;
        var dh = (h + d) / 2 + a - h;
        bbox.h += dh;
        bbox.d -= dh;
      }
    };

    return class_1;
  }(Base);
}

exports.CommonTeXAtomMixin = CommonTeXAtomMixin;

/***/ }),
/* 294 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var Wrapper_js_1 = __webpack_require__(3);

var TextNode_js_1 = __webpack_require__(295);

var CHTMLTextNode = function (_super) {
  __extends(CHTMLTextNode, _super);

  function CHTMLTextNode() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  CHTMLTextNode.prototype.toCHTML = function (parent) {
    this.markUsed();
    var adaptor = this.adaptor;
    var variant = this.parent.variant;
    var text = this.node.getText();

    if (variant === '-explicitFont') {
      var font = this.jax.getFontData(this.parent.styles);
      adaptor.append(parent, this.jax.unknownText(text, variant, font));
    } else {
      var c = this.parent.stretch.c;
      var chars = this.parent.remapChars(c ? [c] : this.unicodeChars(text));

      try {
        for (var chars_1 = __values(chars), chars_1_1 = chars_1.next(); !chars_1_1.done; chars_1_1 = chars_1.next()) {
          var n = chars_1_1.value;
          var data = this.getVariantChar(variant, n)[3];
          var node = data.unknown ? this.jax.unknownText(String.fromCharCode(n), variant) : this.html('mjx-c', {
            class: this.char(n)
          });
          adaptor.append(parent, node);
          data.used = true;
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (chars_1_1 && !chars_1_1.done && (_a = chars_1.return)) _a.call(chars_1);
        } finally {
          if (e_1) throw e_1.error;
        }
      }
    }

    var e_1, _a;
  };

  return CHTMLTextNode;
}(TextNode_js_1.CommonTextNodeMixin(Wrapper_js_1.CHTMLWrapper));

CHTMLTextNode.kind = MmlNode_js_1.TextNode.prototype.kind;
CHTMLTextNode.autoStyle = false;
CHTMLTextNode.styles = {
  'mjx-c': {
    display: 'inline-block'
  },
  'mjx-utext': {
    display: 'inline-block',
    padding: '.75em 0 .25em 0'
  },
  'mjx-measure-text': {
    position: 'absolute',
    'font-family': 'MJXZERO',
    'white-space': 'nowrap',
    height: '1px',
    width: '1px',
    overflow: 'hidden'
  }
};
exports.CHTMLTextNode = CHTMLTextNode;

/***/ }),
/* 295 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonTextNodeMixin(Base) {
  return function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    class_1.prototype.computeBBox = function (bbox, recompute) {
      if (recompute === void 0) {
        recompute = false;
      }

      var variant = this.parent.variant;
      var text = this.node.getText();

      if (variant === '-explicitFont') {
        var font = this.jax.getFontData(this.parent.styles);

        var _a = this.jax.measureText(text, variant, font),
            w = _a.w,
            h = _a.h,
            d = _a.d;

        bbox.h = h;
        bbox.d = d;
        bbox.w = w;
      } else {
        var c = this.parent.stretch.c;
        var chars = this.parent.remapChars(c ? [c] : this.unicodeChars(text));
        bbox.empty();

        try {
          for (var chars_1 = __values(chars), chars_1_1 = chars_1.next(); !chars_1_1.done; chars_1_1 = chars_1.next()) {
            var char = chars_1_1.value;

            var _b = __read(this.getVariantChar(variant, char), 4),
                h = _b[0],
                d = _b[1],
                w = _b[2],
                data = _b[3];

            if (data.unknown) {
              var cbox = this.jax.measureText(String.fromCharCode(char), variant);
              w = cbox.w;
              h = cbox.h;
              d = cbox.d;
            }

            bbox.w += w;
            if (h > bbox.h) bbox.h = h;
            if (d > bbox.d) bbox.d = d;
            bbox.ic = data.ic || 0;
            bbox.sk = data.sk || 0;
          }
        } catch (e_1_1) {
          e_1 = {
            error: e_1_1
          };
        } finally {
          try {
            if (chars_1_1 && !chars_1_1.done && (_c = chars_1.return)) _c.call(chars_1);
          } finally {
            if (e_1) throw e_1.error;
          }
        }

        if (chars.length > 1) {
          bbox.sk = 0;
        }

        bbox.clean();
      }

      var e_1, _c;
    };

    class_1.prototype.getStyles = function () {};

    class_1.prototype.getVariant = function () {};

    class_1.prototype.getScale = function () {};

    class_1.prototype.getSpace = function () {};

    return class_1;
  }(Base);
}

exports.CommonTextNodeMixin = CommonTextNodeMixin;

/***/ }),
/* 296 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var tex_js_1 = __webpack_require__(297);

var bold_italic_js_1 = __webpack_require__(298);

var bold_js_1 = __webpack_require__(300);

var double_struck_js_1 = __webpack_require__(302);

var fraktur_bold_js_1 = __webpack_require__(304);

var fraktur_js_1 = __webpack_require__(306);

var italic_js_1 = __webpack_require__(308);

var largeop_js_1 = __webpack_require__(310);

var monospace_js_1 = __webpack_require__(312);

var normal_js_1 = __webpack_require__(314);

var sans_serif_bold_italic_js_1 = __webpack_require__(316);

var sans_serif_bold_js_1 = __webpack_require__(318);

var sans_serif_italic_js_1 = __webpack_require__(320);

var sans_serif_js_1 = __webpack_require__(322);

var script_bold_js_1 = __webpack_require__(324);

var script_js_1 = __webpack_require__(326);

var smallop_js_1 = __webpack_require__(328);

var tex_caligraphic_bold_js_1 = __webpack_require__(330);

var tex_caligraphic_js_1 = __webpack_require__(332);

var tex_mathit_js_1 = __webpack_require__(334);

var tex_oldstyle_bold_js_1 = __webpack_require__(336);

var tex_oldstyle_js_1 = __webpack_require__(338);

var tex_size3_js_1 = __webpack_require__(340);

var tex_size4_js_1 = __webpack_require__(342);

var tex_variant_js_1 = __webpack_require__(344);

var delimiters_js_1 = __webpack_require__(346);

var TeXFont = function (_super) {
  __extends(TeXFont, _super);

  function TeXFont() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return TeXFont;
}(tex_js_1.CommonTeXFontMixin(FontData_js_1.CHTMLFontData));

TeXFont.defaultVariantClasses = {
  'normal': 'mjx-n',
  'bold': 'mjx-b',
  'italic': 'mjx-i',
  'bold-italic': 'mjx-b mjx-i',
  'double-struck': 'mjx-ds',
  'fraktur': 'mjx-fr',
  'bold-fraktur': 'mjx-fr mjx-b',
  'script': 'mjx-sc',
  'bold-script': 'mjx-sc mjx-b',
  'sans-serif': 'mjx-ss',
  'bold-sans-serif': 'mjx-ss mjx-b',
  'sans-serif-italic': 'mjx-ss mjx-i',
  'bold-sans-serif-italic': 'mjx-ss mjx-b mjx-i',
  'monospace': 'mjx-ty',
  '-smallop': 'mjx-sop',
  '-largeop': 'mjx-lop',
  '-size3': 'mjx-s3',
  '-size4': 'mjx-s4',
  '-tex-caligraphic': 'mjx-cal',
  '-tex-bold-caligraphic': 'mjx-cal mjx-b',
  '-tex-mathit': 'mjx-mit',
  '-tex-oldstyle': 'mjx-os',
  '-tex-bold-oldstyle': 'mjx-os mjx-b',
  '-tex-variant': 'mjx-v'
};
TeXFont.defaultDelimiters = delimiters_js_1.delimiters;
TeXFont.defaultChars = {
  'normal': normal_js_1.normal,
  'bold': bold_js_1.bold,
  'italic': italic_js_1.italic,
  'bold-italic': bold_italic_js_1.boldItalic,
  'double-struck': double_struck_js_1.doubleStruck,
  'fraktur': fraktur_js_1.fraktur,
  'bold-fraktur': fraktur_bold_js_1.frakturBold,
  'script': script_js_1.script,
  'bold-script': script_bold_js_1.scriptBold,
  'sans-serif': sans_serif_js_1.sansSerif,
  'bold-sans-serif': sans_serif_bold_js_1.sansSerifBold,
  'sans-serif-italic': sans_serif_italic_js_1.sansSerifItalic,
  'bold-sans-serif-italic': sans_serif_bold_italic_js_1.sansSerifBoldItalic,
  'monospace': monospace_js_1.monospace,
  '-smallop': smallop_js_1.smallop,
  '-largeop': largeop_js_1.largeop,
  '-size3': tex_size3_js_1.texSize3,
  '-size4': tex_size4_js_1.texSize4,
  '-tex-caligraphic': tex_caligraphic_js_1.texCaligraphic,
  '-tex-bold-caligraphic': tex_caligraphic_bold_js_1.texCaligraphicBold,
  '-tex-mathit': tex_mathit_js_1.texMathit,
  '-tex-oldstyle': tex_oldstyle_js_1.texOldstyle,
  '-tex-bold-oldstyle': tex_oldstyle_bold_js_1.texOldstyleBold,
  '-tex-variant': tex_variant_js_1.texVariant
};
TeXFont.defaultStyles = __assign({}, FontData_js_1.CHTMLFontData.defaultStyles, {
  '.mjx-n mjx-c': {
    'font-family': 'MJXZERO, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-i mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-I, MJXTEX, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-b mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-B, MJXTEX-BI, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-b.mjx-i mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-BI, MJXTEX-B, MJXTEX-I, MJXTEX, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-cal mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-C, MJXTEX-I, MJXTEX, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-cal.mjx-b mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-C-B, MJXTEX-C, MJXTEX-B, MJXTEX-BI, MJXTEX, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-ds mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-A, MJXTEX-B, MJXTEX-BI, MJXTEX, MJXTEX-I, MJXTEX-S1'
  },
  '.mjx-fr mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-FR, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-fr.mjx-b mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-FR-B, MJXTEX-FR, MJXTEX-B, MJXTEX-BI, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-sc mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-SC, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-sc.mjx-b mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-SC-B, MJXTEX-SC, MJXTEX-B, MJXTEX-BI, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-ss mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-SS, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-ss.mjx-b mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-SS-B, MJXTEX-SS, MJXTEX-B, MJXTEX-BI, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-ss.mjx-i mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-SS-I, MJXTEX-I, MJXTEX, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-ss.mjx-b.mjx-i mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-SS-B, MJXTEX-SS-I, MJXTEX-BI, MJXTEX-B, MJXTEX-I, MJXTEX, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-ty mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-T, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-var mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-A, MJXTEX, MJXTEX-I, MJXTEX-S1'
  },
  '.mjx-os mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-C, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-os.mjx-b mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-C-B, MJXTEX-C, MJXTEX-B, MJXTEX-BI, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-mit mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-MI, MJXTEX-I, MJXTEX, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-lop mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-S2, MJXTEX-S1, MJXTEX, MJXTEX-I, MJXTEX-A'
  },
  '.mjx-sop mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-S1, MJXTEX, MJXTEX-I, MJXTEX-A'
  },
  '.mjx-s3 mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-S3, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.mjx-s4 mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-S4, MJXTEX, MJXTEX-I, MJXTEX-S1, MJXTEX-A'
  },
  '.MJX-TEX': {
    'font-family': 'MJXZERO'
  },
  'mjx-stretchy-v mjx-c, mjx-stretchy-h mjx-c': {
    'font-family': 'MJXZERO, MJXTEX-S1, MJXTEX-S4, MJXTEX, MJXTEX-A ! important'
  }
});
TeXFont.defaultFonts = __assign({}, FontData_js_1.CHTMLFontData.defaultFonts, {
  '@font-face /* 1 */': {
    'font-family': 'MJXTEX',
    src: 'url("%%URL%%/MathJax_Main-Regular.woff") format("woff")'
  },
  '@font-face /* 2 */': {
    'font-family': 'MJXTEX-B',
    src: 'url("%%URL%%/MathJax_Main-Bold.woff") format("woff")'
  },
  '@font-face /* 3 */': {
    'font-family': 'MJXTEX-MI',
    src: 'url("%%URL%%/MathJax_Main-Italic.woff") format("woff")'
  },
  '@font-face /* 4 */': {
    'font-family': 'MJXTEX-I',
    src: 'url("%%URL%%/MathJax_Math-Italic.woff") format("woff")'
  },
  '@font-face /* 5 */': {
    'font-family': 'MJXTEX-BI',
    src: 'url("%%URL%%/MathJax_Math-BoldItalic.woff") format("woff")'
  },
  '@font-face /* 6 */': {
    'font-family': 'MJXTEX-S1',
    src: 'url("%%URL%%/MathJax_Size1-Regular.woff") format("woff")'
  },
  '@font-face /* 7 */': {
    'font-family': 'MJXTEX-S2',
    src: 'url("%%URL%%/MathJax_Size2-Regular.woff") format("woff")'
  },
  '@font-face /* 8 */': {
    'font-family': 'MJXTEX-S3',
    src: 'url("%%URL%%/MathJax_Size3-Regular.woff") format("woff")'
  },
  '@font-face /* 9 */': {
    'font-family': 'MJXTEX-S4',
    src: 'url("%%URL%%/MathJax_Size4-Regular.woff") format("woff")'
  },
  '@font-face /* 10 */': {
    'font-family': 'MJXTEX-A',
    src: 'url("%%URL%%/MathJax_AMS-Regular.woff") format("woff")'
  },
  '@font-face /* 11 */': {
    'font-family': 'MJXTEX-C',
    src: 'url("%%URL%%/MathJax_Caligraphic-Regular.woff") format("woff")'
  },
  '@font-face /* 12 */': {
    'font-family': 'MJXTEX-C-B',
    src: 'url("%%URL%%/MathJax_Caligraphic-Bold.woff") format("woff")'
  },
  '@font-face /* 13 */': {
    'font-family': 'MJXTEX-FR',
    src: 'url("%%URL%%/MathJax_Fraktur-Regular.woff") format("woff")'
  },
  '@font-face /* 14 */': {
    'font-family': 'MJXTEX-FR-B',
    src: 'url("%%URL%%/MathJax_Fraktur-Bold.woff") format("woff")'
  },
  '@font-face /* 15 */': {
    'font-family': 'MJXTEX-SS',
    src: 'url("%%URL%%/MathJax_SansSerif-Regular.woff") format("woff")'
  },
  '@font-face /* 16 */': {
    'font-family': 'MJXTEX-SS-B',
    src: 'url("%%URL%%/MathJax_SansSerif-Bold.woff") format("woff")'
  },
  '@font-face /* 17 */': {
    'font-family': 'MJXTEX-SS-I',
    src: 'url("%%URL%%/MathJax_SansSerif-Italic.woff") format("woff")'
  },
  '@font-face /* 18 */': {
    'font-family': 'MJXTEX-SC',
    src: 'url("%%URL%%/MathJax_Script-Regular.woff") format("woff")'
  },
  '@font-face /* 19 */': {
    'font-family': 'MJXTEX-T',
    src: 'url("%%URL%%/MathJax_Typewriter-Regular.woff") format("woff")'
  },
  '@font-face /* 20 */': {
    'font-family': 'MJXTEX-V',
    src: 'url("%%URL%%/MathJax_Vector-Regular.woff") format("woff")'
  },
  '@font-face /* 21 */': {
    'font-family': 'MJXTEX-VB',
    src: 'url("%%URL%%/MathJax_Vector-Bold.woff") format("woff")'
  }
});
exports.TeXFont = TeXFont;

/***/ }),
/* 297 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

function CommonTeXFontMixin(Base) {
  return _a = function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    class_1.prototype.getDelimiterData = function (n) {
      return this.getChar('-smallop', n) || this.getChar('-size4', n);
    };

    return class_1;
  }(Base), _a.defaultVariants = __spread(Base.defaultVariants, [['-smallop', 'normal'], ['-largeop', 'normal'], ['-size3', 'normal'], ['-size4', 'normal'], ['-tex-caligraphic', 'italic'], ['-tex-bold-caligraphic', 'bold-italic'], ['-tex-oldstyle', 'normal'], ['-tex-bold-oldstyle', 'bold'], ['-tex-mathit', 'italic'], ['-tex-variant', 'normal']]), _a.defaultCssFonts = __assign({}, Base.defaultCssFonts, {
    '-smallop': ['serif', false, false],
    '-largeop': ['serif', false, false],
    '-size3': ['serif', false, false],
    '-size4': ['serif', false, false],
    '-tex-caligraphic': ['cursive', true, false],
    '-tex-bold-caligraphic': ['cursive', true, true],
    '-tex-oldstyle': ['serif', false, false],
    '-tex-bold-oldstyle': ['serif', false, true],
    '-tex-mathit': ['serif', true, false]
  }), _a.defaultSizeVariants = ['normal', '-smallop', '-largeop', '-size3', '-size4'], _a;

  var _a;
}

exports.CommonTeXFontMixin = CommonTeXFontMixin;

/***/ }),
/* 298 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var bold_italic_js_1 = __webpack_require__(299);

exports.boldItalic = FontData_js_1.AddCSS(bold_italic_js_1.boldItalic, {
  0x20: {
    c: ' '
  },
  0x2F: {
    c: '/'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x2044: {
    c: '/'
  },
  0x2206: {
    c: '\\394'
  },
  0x29F8: {
    c: '/',
    f: 'BI'
  }
});

/***/ }),
/* 299 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.boldItalic = {
  0x20: [0, 0, .25],
  0x2F: [.711, .21, .894],
  0x41: [.711, 0, .869, {
    sk: 0.16
  }],
  0x42: [.686, 0, .866, {
    sk: 0.0958
  }],
  0x43: [.703, .017, .817, {
    sk: 0.0958
  }],
  0x44: [.686, 0, .938, {
    sk: 0.0639
  }],
  0x45: [.68, 0, .81, {
    sk: 0.0958
  }],
  0x46: [.68, 0, .689, {
    ic: .12,
    sk: 0.0958
  }],
  0x47: [.703, .016, .887, {
    sk: 0.0958
  }],
  0x48: [.686, 0, .982, {
    sk: 0.0639
  }],
  0x49: [.686, 0, .511, {
    ic: .062,
    sk: 0.128
  }],
  0x4A: [.686, .017, .631, {
    ic: .063,
    sk: 0.192
  }],
  0x4B: [.686, 0, .971, {
    sk: 0.0639
  }],
  0x4C: [.686, 0, .756, {
    sk: 0.0319
  }],
  0x4D: [.686, 0, 1.142, {
    ic: .077,
    sk: 0.0958
  }],
  0x4E: [.686, 0, .95, {
    ic: .077,
    sk: 0.0958
  }],
  0x4F: [.703, .017, .837, {
    sk: 0.0958
  }],
  0x50: [.686, 0, .723, {
    ic: .124,
    sk: 0.0958
  }],
  0x51: [.703, .194, .869, {
    sk: 0.0958
  }],
  0x52: [.686, .017, .872, {
    sk: 0.0958
  }],
  0x53: [.703, .017, .693, {
    sk: 0.0958
  }],
  0x54: [.675, 0, .637, {
    ic: .135,
    sk: 0.0958
  }],
  0x55: [.686, .016, .8, {
    ic: .077,
    sk: 0.0319
  }],
  0x56: [.686, .016, .678, {
    ic: .208
  }],
  0x57: [.686, .017, 1.093, {
    ic: .114
  }],
  0x58: [.686, 0, .947, {
    sk: 0.0958
  }],
  0x59: [.686, 0, .675, {
    ic: .201
  }],
  0x5A: [.686, 0, .773, {
    sk: 0.0958
  }],
  0x61: [.452, .008, .633],
  0x62: [.694, .008, .521],
  0x63: [.451, .008, .513, {
    sk: 0.0639
  }],
  0x64: [.694, .008, .61, {
    sk: 0.192
  }],
  0x65: [.452, .008, .554, {
    sk: 0.0639
  }],
  0x66: [.701, .201, .568, {
    ic: .056,
    sk: 0.192
  }],
  0x67: [.452, .202, .545, {
    sk: 0.0319
  }],
  0x68: [.694, .008, .668, {
    sk: -0.0319
  }],
  0x69: [.694, .008, .405],
  0x6A: [.694, .202, .471],
  0x6B: [.694, .008, .604],
  0x6C: [.694, .008, .348, {
    sk: 0.0958
  }],
  0x6D: [.452, .008, 1.032],
  0x6E: [.452, .008, .713],
  0x6F: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x70: [.452, .194, .601, {
    sk: 0.0958
  }],
  0x71: [.452, .194, .542, {
    sk: 0.0958
  }],
  0x72: [.452, .008, .529, {
    sk: 0.0639
  }],
  0x73: [.451, .008, .531, {
    sk: 0.0639
  }],
  0x74: [.643, .007, .415, {
    sk: 0.0958
  }],
  0x75: [.452, .008, .681, {
    sk: 0.0319
  }],
  0x76: [.453, .008, .567, {
    sk: 0.0319
  }],
  0x77: [.453, .008, .831, {
    sk: 0.0958
  }],
  0x78: [.452, .008, .659, {
    sk: 0.0319
  }],
  0x79: [.452, .202, .59, {
    sk: 0.0639
  }],
  0x7A: [.452, .008, .555, {
    sk: 0.0639
  }],
  0xA0: [0, 0, .25],
  0x391: [.711, 0, .869, {
    sk: 0.16
  }],
  0x392: [.686, 0, .866, {
    sk: 0.0958
  }],
  0x393: [.68, 0, .657, {
    ic: .12,
    sk: 0.0958
  }],
  0x394: [.711, 0, .958, {
    sk: 0.192
  }],
  0x395: [.68, 0, .81, {
    sk: 0.0958
  }],
  0x396: [.686, 0, .773, {
    sk: 0.0958
  }],
  0x397: [.686, 0, .982, {
    sk: 0.0639
  }],
  0x398: [.702, .017, .867, {
    sk: 0.0958
  }],
  0x399: [.686, 0, .511, {
    ic: .062,
    sk: 0.128
  }],
  0x39A: [.686, 0, .971, {
    sk: 0.0639
  }],
  0x39B: [.711, 0, .806, {
    sk: 0.192
  }],
  0x39C: [.686, 0, 1.142, {
    ic: .077,
    sk: 0.0958
  }],
  0x39D: [.686, 0, .95, {
    ic: .077,
    sk: 0.0958
  }],
  0x39E: [.675, 0, .841, {
    sk: 0.0958
  }],
  0x39F: [.703, .017, .837, {
    sk: 0.0958
  }],
  0x3A0: [.68, 0, .982, {
    sk: 0.0639
  }],
  0x3A1: [.686, 0, .723, {
    ic: .124,
    sk: 0.0958
  }],
  0x3A2: [.702, .017, .867, {
    sk: 0.0958
  }],
  0x3A3: [.686, 0, .885, {
    sk: 0.0958
  }],
  0x3A4: [.675, 0, .637, {
    ic: .135,
    sk: 0.0958
  }],
  0x3A5: [.703, 0, .671, {
    ic: .131,
    sk: 0.0639
  }],
  0x3A6: [.686, 0, .767, {
    sk: 0.0958
  }],
  0x3A7: [.686, 0, .947, {
    sk: 0.0958
  }],
  0x3A8: [.686, 0, .714, {
    ic: .076,
    sk: 0.0639
  }],
  0x3A9: [.703, 0, .879, {
    sk: 0.0958
  }],
  0x3B1: [.452, .008, .761, {
    sk: 0.0319
  }],
  0x3B2: [.701, .194, .66, {
    sk: 0.0958
  }],
  0x3B3: [.451, .211, .59],
  0x3B4: [.725, .008, .522, {
    sk: 0.0639
  }],
  0x3B5: [.461, .017, .529, {
    sk: 0.0958
  }],
  0x3B6: [.711, .202, .508, {
    sk: 0.0958
  }],
  0x3B7: [.452, .211, .6, {
    sk: 0.0639
  }],
  0x3B8: [.702, .008, .562, {
    sk: 0.0958
  }],
  0x3B9: [.452, .008, .412, {
    sk: 0.0639
  }],
  0x3BA: [.452, .008, .668],
  0x3BB: [.694, .013, .671],
  0x3BC: [.452, .211, .708, {
    sk: 0.0319
  }],
  0x3BD: [.452, 0, .577, {
    sk: 0.0319
  }],
  0x3BE: [.711, .201, .508, {
    sk: 0.128
  }],
  0x3BF: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x3C0: [.444, .008, .682],
  0x3C1: [.451, .211, .612, {
    sk: 0.0958
  }],
  0x3C2: [.451, .105, .424, {
    sk: 0.0958
  }],
  0x3C3: [.444, .008, .686],
  0x3C4: [.444, .013, .521, {
    ic: .089,
    sk: 0.0319
  }],
  0x3C5: [.453, .008, .631, {
    sk: 0.0319
  }],
  0x3C6: [.452, .216, .747, {
    sk: 0.0958
  }],
  0x3C7: [.452, .201, .718, {
    sk: 0.0639
  }],
  0x3C8: [.694, .202, .758, {
    sk: 0.128
  }],
  0x3C9: [.453, .008, .718],
  0x3D1: [.701, .008, .692, {
    sk: 0.0958
  }],
  0x3D2: [.703, 0, .671, {
    ic: .131,
    sk: 0.0639
  }],
  0x3D5: [.694, .202, .712, {
    sk: 0.0958
  }],
  0x3D6: [.444, .008, .975],
  0x3DC: [.68, 0, .689, {
    ic: .12,
    sk: 0.0958
  }],
  0x3F1: [.451, .194, .612, {
    sk: 0.0958
  }],
  0x3F5: [.444, .007, .483, {
    sk: 0.0639
  }],
  0x2044: [.711, .21, .894],
  0x2206: [.711, 0, .958, {
    sk: 0.192
  }],
  0x29F8: [.711, .21, .894]
};

/***/ }),
/* 300 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var bold_js_1 = __webpack_require__(301);

exports.bold = FontData_js_1.AddCSS(bold_js_1.bold, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x23: {
    c: '#'
  },
  0x24: {
    c: '$'
  },
  0x25: {
    c: '%'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3C: {
    c: '<'
  },
  0x3D: {
    c: '='
  },
  0x3E: {
    c: '>'
  },
  0x3F: {
    c: '?'
  },
  0x40: {
    c: '@'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x5F: {
    c: '_'
  },
  0x60: {
    c: '`'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x7B: {
    c: '{'
  },
  0x7C: {
    c: '|'
  },
  0x7D: {
    c: '}'
  },
  0x7E: {
    c: '~'
  },
  0xB7: {
    c: '\\22C5'
  },
  0x2B9: {
    c: '\\2032'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x2002: {
    c: ''
  },
  0x2003: {
    c: ''
  },
  0x2004: {
    c: ''
  },
  0x2005: {
    c: ''
  },
  0x2006: {
    c: ''
  },
  0x2009: {
    c: ''
  },
  0x200A: {
    c: ''
  },
  0x2015: {
    c: '\\2014'
  },
  0x2016: {
    c: '\\2225'
  },
  0x2017: {
    c: '_'
  },
  0x2022: {
    c: '\\2219'
  },
  0x2033: {
    c: '\\2032\\2032'
  },
  0x2034: {
    c: '\\2032\\2032\\2032'
  },
  0x203E: {
    c: '\\2C9'
  },
  0x2044: {
    c: '/'
  },
  0x2057: {
    c: '\\2032\\2032\\2032\\2032'
  },
  0x20D7: {
    c: '\\2192',
    f: 'VB'
  },
  0x2111: {
    c: 'I',
    f: 'FR'
  },
  0x211C: {
    c: 'R',
    f: 'FR'
  },
  0x219A: {
    c: '\\2190\\338'
  },
  0x219B: {
    c: '\\2192\\338'
  },
  0x21AE: {
    c: '\\2194\\338'
  },
  0x21CD: {
    c: '\\21D0\\338'
  },
  0x21CE: {
    c: '\\21D4\\338'
  },
  0x21CF: {
    c: '\\21D2\\338'
  },
  0x2204: {
    c: '\\2203\\338'
  },
  0x2206: {
    c: '\\394'
  },
  0x220C: {
    c: '\\220B\\338'
  },
  0x2224: {
    c: '\\2223\\338'
  },
  0x2226: {
    c: '\\2225\\338'
  },
  0x2241: {
    c: '\\223C\\338'
  },
  0x2244: {
    c: '\\2243\\338'
  },
  0x2247: {
    c: '\\2245\\338'
  },
  0x2249: {
    c: '\\2248\\338'
  },
  0x2262: {
    c: '\\2261\\338'
  },
  0x226D: {
    c: '\\224D\\338'
  },
  0x226E: {
    c: '<\\338'
  },
  0x226F: {
    c: '>\\338'
  },
  0x2270: {
    c: '\\2264\\338'
  },
  0x2271: {
    c: '\\2265\\338'
  },
  0x2280: {
    c: '\\227A\\338'
  },
  0x2281: {
    c: '\\227B\\338'
  },
  0x2284: {
    c: '\\2282\\338'
  },
  0x2285: {
    c: '\\2283\\338'
  },
  0x2288: {
    c: '\\2286\\338'
  },
  0x2289: {
    c: '\\2287\\338'
  },
  0x22AC: {
    c: '\\22A2\\338'
  },
  0x22AD: {
    c: '\\22A8\\338'
  },
  0x22E2: {
    c: '\\2291\\338'
  },
  0x22E3: {
    c: '\\2292\\338'
  },
  0x2329: {
    c: '\\27E8'
  },
  0x232A: {
    c: '\\27E9'
  },
  0x25B5: {
    c: '\\25B3'
  },
  0x25BF: {
    c: '\\25BD'
  },
  0x2758: {
    c: '\\2223'
  },
  0x29F8: {
    c: '/',
    f: 'BI'
  },
  0x2A2F: {
    c: '\\D7'
  },
  0x3008: {
    c: '\\27E8'
  },
  0x3009: {
    c: '\\27E9'
  }
});

/***/ }),
/* 301 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.bold = {
  0x20: [0, 0, .25],
  0x21: [.705, 0, .35],
  0x22: [.694, -0.329, .603],
  0x23: [.694, .193, .958],
  0x24: [.75, .056, .575],
  0x25: [.75, .056, .958],
  0x26: [.705, .011, .894],
  0x27: [.694, -0.329, .319],
  0x28: [.75, .249, .447],
  0x29: [.75, .249, .447],
  0x2A: [.75, -0.306, .575],
  0x2B: [.633, .131, .894],
  0x2C: [.171, .194, .319],
  0x2D: [.278, -0.166, .383],
  0x2E: [.171, 0, .319],
  0x2F: [.75, .25, .575],
  0x30: [.654, .01, .575],
  0x31: [.655, 0, .575],
  0x32: [.654, 0, .575],
  0x33: [.655, .011, .575],
  0x34: [.656, 0, .575],
  0x35: [.655, .011, .575],
  0x36: [.655, .011, .575],
  0x37: [.676, .011, .575],
  0x38: [.654, .011, .575],
  0x39: [.654, .011, .575],
  0x3A: [.444, 0, .319],
  0x3B: [.444, .194, .319],
  0x3C: [.587, .085, .894],
  0x3D: [.393, -0.109, .894],
  0x3E: [.587, .085, .894],
  0x3F: [.7, 0, .543],
  0x40: [.699, .006, .894],
  0x41: [.698, 0, .869],
  0x42: [.686, 0, .818],
  0x43: [.697, .011, .831],
  0x44: [.686, 0, .882],
  0x45: [.68, 0, .756],
  0x46: [.68, 0, .724],
  0x47: [.697, .01, .904],
  0x48: [.686, 0, .9],
  0x49: [.686, 0, .436],
  0x4A: [.686, .011, .594],
  0x4B: [.686, 0, .901],
  0x4C: [.686, 0, .692],
  0x4D: [.686, 0, 1.092],
  0x4E: [.686, 0, .9],
  0x4F: [.696, .01, .864],
  0x50: [.686, 0, .786],
  0x51: [.696, .193, .864],
  0x52: [.686, .011, .862],
  0x53: [.697, .011, .639],
  0x54: [.675, 0, .8],
  0x55: [.686, .011, .885],
  0x56: [.686, .007, .869],
  0x57: [.686, .007, 1.189],
  0x58: [.686, 0, .869],
  0x59: [.686, 0, .869],
  0x5A: [.686, 0, .703],
  0x5B: [.75, .25, .319],
  0x5C: [.75, .25, .575],
  0x5D: [.75, .25, .319],
  0x5E: [.694, -0.52, .575],
  0x5F: [-0.01, .061, .575],
  0x60: [.706, -0.503, .575],
  0x61: [.453, .006, .559],
  0x62: [.694, .006, .639],
  0x63: [.453, .006, .511],
  0x64: [.694, .006, .639],
  0x65: [.452, .006, .527],
  0x66: [.7, 0, .351, {
    ic: .101
  }],
  0x67: [.455, .201, .575],
  0x68: [.694, 0, .639],
  0x69: [.695, 0, .319],
  0x6A: [.695, .2, .351],
  0x6B: [.694, 0, .607],
  0x6C: [.694, 0, .319],
  0x6D: [.45, 0, .958],
  0x6E: [.45, 0, .639],
  0x6F: [.452, .005, .575],
  0x70: [.45, .194, .639],
  0x71: [.45, .194, .607],
  0x72: [.45, 0, .474],
  0x73: [.453, .006, .454],
  0x74: [.635, .005, .447],
  0x75: [.45, .006, .639],
  0x76: [.444, 0, .607],
  0x77: [.444, 0, .831],
  0x78: [.444, 0, .607],
  0x79: [.444, .2, .607],
  0x7A: [.444, 0, .511],
  0x7B: [.75, .25, .575],
  0x7C: [.75, .249, .319],
  0x7D: [.75, .25, .575],
  0x7E: [.344, -0.202, .575],
  0xA0: [0, 0, .25],
  0xA8: [.695, -0.535, .575],
  0xAC: [.371, -0.061, .767],
  0xAF: [.607, -0.54, .575],
  0xB0: [.702, -0.536, .575],
  0xB1: [.728, .035, .894],
  0xB4: [.706, -0.503, .575],
  0xB7: [.336, -0.166, .319],
  0xD7: [.53, .028, .894],
  0xF7: [.597, .096, .894],
  0x131: [.452, .008, .394, {
    sk: 0.0319
  }],
  0x237: [.451, .201, .439, {
    sk: 0.0958
  }],
  0x2B9: [.563, -0.033, .344],
  0x2C6: [.694, -0.52, .575],
  0x2C7: [.66, -0.515, .575],
  0x2C9: [.607, -0.54, .575],
  0x2CA: [.706, -0.503, .575],
  0x2CB: [.706, -0.503, .575],
  0x2D8: [.694, -0.5, .575],
  0x2D9: [.695, -0.525, .575],
  0x2DA: [.702, -0.536, .575],
  0x2DC: [.694, -0.552, .575],
  0x300: [.706, -0.503, 0],
  0x301: [.706, -0.503, 0],
  0x302: [.694, -0.52, 0],
  0x303: [.694, -0.552, 0],
  0x304: [.607, -0.54, 0],
  0x306: [.694, -0.5, 0],
  0x307: [.695, -0.525, 0],
  0x308: [.695, -0.535, 0],
  0x30A: [.702, -0.536, 0],
  0x30B: [.714, -0.511, 0],
  0x30C: [.66, -0.515, 0],
  0x338: [.711, .21, 0],
  0x391: [.698, 0, .869],
  0x392: [.686, 0, .818],
  0x393: [.68, 0, .692],
  0x394: [.698, 0, .958],
  0x395: [.68, 0, .756],
  0x396: [.686, 0, .703],
  0x397: [.686, 0, .9],
  0x398: [.696, .01, .894],
  0x399: [.686, 0, .436],
  0x39A: [.686, 0, .901],
  0x39B: [.698, 0, .806],
  0x39C: [.686, 0, 1.092],
  0x39D: [.686, 0, .9],
  0x39E: [.675, 0, .767],
  0x39F: [.696, .01, .864],
  0x3A0: [.68, 0, .9],
  0x3A1: [.686, 0, .786],
  0x3A2: [.696, .01, .894],
  0x3A3: [.686, 0, .831],
  0x3A4: [.675, 0, .8],
  0x3A5: [.697, 0, .894],
  0x3A6: [.686, 0, .831],
  0x3A7: [.686, 0, .869],
  0x3A8: [.686, 0, .894],
  0x3A9: [.696, 0, .831],
  0x3B1: [.452, .008, .761, {
    sk: 0.0319
  }],
  0x3B2: [.701, .194, .66, {
    sk: 0.0958
  }],
  0x3B3: [.451, .211, .59],
  0x3B4: [.725, .008, .522, {
    sk: 0.0639
  }],
  0x3B5: [.461, .017, .529, {
    sk: 0.0958
  }],
  0x3B6: [.711, .202, .508, {
    sk: 0.0958
  }],
  0x3B7: [.452, .211, .6, {
    sk: 0.0639
  }],
  0x3B8: [.702, .008, .562, {
    sk: 0.0958
  }],
  0x3B9: [.452, .008, .412, {
    sk: 0.0639
  }],
  0x3BA: [.452, .008, .668],
  0x3BB: [.694, .013, .671],
  0x3BC: [.452, .211, .708, {
    sk: 0.0319
  }],
  0x3BD: [.452, 0, .577, {
    sk: 0.0319
  }],
  0x3BE: [.711, .201, .508, {
    sk: 0.128
  }],
  0x3BF: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x3C0: [.444, .008, .682],
  0x3C1: [.451, .211, .612, {
    sk: 0.0958
  }],
  0x3C2: [.451, .105, .424, {
    sk: 0.0958
  }],
  0x3C3: [.444, .008, .686],
  0x3C4: [.444, .013, .521, {
    ic: .089,
    sk: 0.0319
  }],
  0x3C5: [.453, .008, .631, {
    sk: 0.0319
  }],
  0x3C6: [.452, .216, .747, {
    sk: 0.0958
  }],
  0x3C7: [.452, .201, .718, {
    sk: 0.0639
  }],
  0x3C8: [.694, .202, .758, {
    sk: 0.128
  }],
  0x3C9: [.453, .008, .718],
  0x3D1: [.701, .008, .692, {
    sk: 0.0958
  }],
  0x3D2: [.697, 0, .894],
  0x3D5: [.694, .202, .712, {
    sk: 0.0958
  }],
  0x3D6: [.444, .008, .975],
  0x3DC: [.68, 0, .724],
  0x3F1: [.451, .194, .612, {
    sk: 0.0958
  }],
  0x3F5: [.444, .007, .483, {
    sk: 0.0639
  }],
  0x2002: [0, 0, .5],
  0x2003: [0, 0, .999],
  0x2004: [0, 0, .333],
  0x2005: [0, 0, .25],
  0x2006: [0, 0, .167],
  0x2009: [0, 0, .167],
  0x200A: [0, 0, .083],
  0x2013: [.3, -0.249, .575],
  0x2014: [.3, -0.249, 1.15],
  0x2015: [.3, -0.249, 1.15],
  0x2016: [.75, .248, .575],
  0x2017: [-0.01, .061, .575],
  0x2018: [.694, -0.329, .319],
  0x2019: [.694, -0.329, .319],
  0x201C: [.694, -0.329, .603],
  0x201D: [.694, -0.329, .603],
  0x2020: [.702, .211, .511],
  0x2021: [.702, .202, .511],
  0x2022: [.474, -0.028, .575],
  0x2026: [.171, 0, 1.295],
  0x2032: [.563, -0.033, .344],
  0x2033: [.563, 0, .688],
  0x2034: [.563, 0, 1.032],
  0x203E: [.607, -0.54, .575],
  0x2044: [.75, .25, .575],
  0x2057: [.563, 0, 1.376],
  0x20D7: [.723, -0.513, .575],
  0x210F: [.694, .008, .668, {
    sk: -0.0319
  }],
  0x2111: [.686, .026, .554],
  0x2113: [.702, .019, .474, {
    sk: 0.128
  }],
  0x2118: [.461, .21, .74],
  0x211C: [.686, .026, .828],
  0x2135: [.694, 0, .703],
  0x2190: [.518, .017, 1.15],
  0x2191: [.694, .193, .575],
  0x2192: [.518, .017, 1.15],
  0x2193: [.694, .194, .575],
  0x2194: [.518, .017, 1.15],
  0x2195: [.767, .267, .575],
  0x2196: [.724, .194, 1.15],
  0x2197: [.724, .193, 1.15],
  0x2198: [.694, .224, 1.15],
  0x2199: [.694, .224, 1.15],
  0x219A: [.711, .21, 1.15],
  0x219B: [.711, .21, 1.15],
  0x21A6: [.518, .017, 1.15],
  0x21A9: [.518, .017, 1.282],
  0x21AA: [.518, .017, 1.282],
  0x21AE: [.711, .21, 1.15],
  0x21BC: [.518, -0.22, 1.15],
  0x21BD: [.281, .017, 1.15],
  0x21C0: [.518, -0.22, 1.15],
  0x21C1: [.281, .017, 1.15],
  0x21CC: [.718, .017, 1.15],
  0x21CD: [.711, .21, 1.15],
  0x21CE: [.711, .21, 1.15],
  0x21CF: [.711, .21, 1.15],
  0x21D0: [.547, .046, 1.15],
  0x21D1: [.694, .193, .703],
  0x21D2: [.547, .046, 1.15],
  0x21D3: [.694, .194, .703],
  0x21D4: [.547, .046, 1.15],
  0x21D5: [.767, .267, .703],
  0x2200: [.694, .016, .639],
  0x2202: [.71, .017, .628, {
    sk: 0.0958
  }],
  0x2203: [.694, 0, .639],
  0x2204: [.711, .21, .639],
  0x2205: [.767, .073, .575],
  0x2206: [.698, 0, .958],
  0x2207: [.686, .024, .958],
  0x2208: [.587, .086, .767],
  0x2209: [.711, .21, .767],
  0x220B: [.587, .086, .767],
  0x220C: [.711, .21, .767],
  0x2212: [.281, -0.221, .894],
  0x2213: [.537, .227, .894],
  0x2215: [.75, .25, .575],
  0x2216: [.75, .25, .575],
  0x2217: [.472, -0.028, .575],
  0x2218: [.474, -0.028, .575],
  0x2219: [.474, -0.028, .575],
  0x221A: [.82, .18, .958],
  0x221D: [.451, .008, .894],
  0x221E: [.452, .008, 1.15],
  0x2220: [.714, 0, .722],
  0x2223: [.75, .249, .319],
  0x2224: [.75, .249, .319],
  0x2225: [.75, .248, .575],
  0x2226: [.75, .248, .575],
  0x2227: [.604, .017, .767],
  0x2228: [.604, .016, .767],
  0x2229: [.603, .016, .767],
  0x222A: [.604, .016, .767],
  0x222B: [.711, .211, .569, {
    ic: .063
  }],
  0x223C: [.391, -0.109, .894],
  0x2240: [.583, .082, .319],
  0x2241: [.711, .21, .894],
  0x2243: [.502, 0, .894],
  0x2244: [.711, .21, .894],
  0x2245: [.638, .027, .894],
  0x2247: [.711, .21, .894],
  0x2248: [.524, -0.032, .894],
  0x2249: [.711, .21, .894],
  0x224D: [.533, .032, .894],
  0x2250: [.721, -0.109, .894],
  0x2260: [.711, .21, .894],
  0x2261: [.505, 0, .894],
  0x2262: [.711, .21, .894],
  0x2264: [.697, .199, .894],
  0x2265: [.697, .199, .894],
  0x226A: [.617, .116, 1.15],
  0x226B: [.618, .116, 1.15],
  0x226D: [.711, .21, .894],
  0x226E: [.711, .21, .894],
  0x226F: [.711, .21, .894],
  0x2270: [.711, .21, .894],
  0x2271: [.711, .21, .894],
  0x227A: [.585, .086, .894],
  0x227B: [.586, .086, .894],
  0x2280: [.711, .21, .894],
  0x2281: [.711, .21, .894],
  0x2282: [.587, .085, .894],
  0x2283: [.587, .086, .894],
  0x2284: [.711, .21, .894],
  0x2285: [.711, .21, .894],
  0x2286: [.697, .199, .894],
  0x2287: [.697, .199, .894],
  0x2288: [.711, .21, .894],
  0x2289: [.711, .21, .894],
  0x228E: [.604, .016, .767],
  0x2291: [.697, .199, .894],
  0x2292: [.697, .199, .894],
  0x2293: [.604, 0, .767],
  0x2294: [.604, 0, .767],
  0x2295: [.632, .132, .894],
  0x2296: [.632, .132, .894],
  0x2297: [.632, .132, .894],
  0x2298: [.632, .132, .894],
  0x2299: [.632, .132, .894],
  0x22A2: [.693, 0, .703],
  0x22A3: [.693, 0, .703],
  0x22A4: [.694, 0, .894],
  0x22A5: [.693, 0, .894],
  0x22A8: [.75, .249, .974],
  0x22AC: [.711, .21, .703],
  0x22AD: [.75, .249, .974],
  0x22C4: [.523, .021, .575],
  0x22C5: [.336, -0.166, .319],
  0x22C6: [.502, 0, .575],
  0x22C8: [.54, .039, 1],
  0x22E2: [.711, .21, .894],
  0x22E3: [.711, .21, .894],
  0x22EE: [.951, .029, .319],
  0x22EF: [.336, -0.166, 1.295],
  0x22F1: [.871, -0.101, 1.323],
  0x2308: [.75, .248, .511],
  0x2309: [.75, .248, .511],
  0x230A: [.749, .248, .511],
  0x230B: [.749, .248, .511],
  0x2322: [.405, -0.108, 1.15],
  0x2323: [.392, -0.126, 1.15],
  0x2329: [.75, .249, .447],
  0x232A: [.75, .249, .447],
  0x25B3: [.711, 0, 1.022],
  0x25B5: [.711, 0, 1.022],
  0x25B9: [.54, .039, .575],
  0x25BD: [.5, .21, 1.022],
  0x25BF: [.5, .21, 1.022],
  0x25C3: [.539, .038, .575],
  0x25EF: [.711, .211, 1.15],
  0x2660: [.719, .129, .894],
  0x2661: [.711, .024, .894],
  0x2662: [.719, .154, .894],
  0x2663: [.719, .129, .894],
  0x266D: [.75, .017, .447],
  0x266E: [.741, .223, .447],
  0x266F: [.724, .224, .447],
  0x2758: [.75, .249, .319],
  0x27E8: [.75, .249, .447],
  0x27E9: [.75, .249, .447],
  0x27F5: [.518, .017, 1.805],
  0x27F6: [.518, .017, 1.833],
  0x27F7: [.518, .017, 2.126],
  0x27F8: [.547, .046, 1.868],
  0x27F9: [.547, .046, 1.87],
  0x27FA: [.547, .046, 2.126],
  0x27FC: [.518, .017, 1.833],
  0x29F8: [.711, .21, .894],
  0x2A2F: [.53, .028, .894],
  0x2A3F: [.686, 0, .9],
  0x2AAF: [.696, .199, .894],
  0x2AB0: [.697, .199, .894],
  0x3008: [.75, .249, .447],
  0x3009: [.75, .249, .447]
};

/***/ }),
/* 302 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var double_struck_js_1 = __webpack_require__(303);

exports.doubleStruck = FontData_js_1.AddCSS(double_struck_js_1.doubleStruck, {
  0x20: {
    c: ' '
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x6B: {
    c: 'k'
  },
  0x391: {
    c: 'A',
    f: 'B'
  },
  0x392: {
    c: 'B',
    f: 'B'
  },
  0x395: {
    c: 'E',
    f: 'B'
  },
  0x396: {
    c: 'Z',
    f: 'B'
  },
  0x397: {
    c: 'H',
    f: 'B'
  },
  0x399: {
    c: 'I',
    f: 'B'
  },
  0x39A: {
    c: 'K',
    f: 'B'
  },
  0x39C: {
    c: 'M',
    f: 'B'
  },
  0x39D: {
    c: 'N',
    f: 'B'
  },
  0x39F: {
    c: 'O',
    f: 'B'
  },
  0x3A1: {
    c: 'P',
    f: 'B'
  },
  0x3A2: {
    c: '\\398',
    f: 'B'
  },
  0x3A4: {
    c: 'T',
    f: 'B'
  },
  0x3A7: {
    c: 'X',
    f: 'B'
  },
  0x3D2: {
    c: '\\3A5',
    f: 'B'
  },
  0x3DC: {
    c: 'F',
    f: 'B'
  },
  0x2102: {
    c: 'C',
    f: 'A'
  },
  0x210D: {
    c: 'H',
    f: 'A'
  },
  0x2115: {
    c: 'N',
    f: 'A'
  },
  0x2119: {
    c: 'P',
    f: 'A'
  },
  0x211A: {
    c: 'Q',
    f: 'A'
  },
  0x211D: {
    c: 'R',
    f: 'A'
  },
  0x2124: {
    c: 'Z',
    f: 'A'
  }
});

/***/ }),
/* 303 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.doubleStruck = {
  0x20: [0, 0, .25],
  0x41: [.701, 0, .722],
  0x42: [.683, 0, .667],
  0x43: [.702, .019, .722],
  0x44: [.683, 0, .722],
  0x45: [.683, 0, .667],
  0x46: [.683, 0, .611],
  0x47: [.702, .019, .778],
  0x48: [.683, 0, .778],
  0x49: [.683, 0, .389],
  0x4A: [.683, .077, .5],
  0x4B: [.683, 0, .778],
  0x4C: [.683, 0, .667],
  0x4D: [.683, 0, .944],
  0x4E: [.683, .02, .722],
  0x4F: [.701, .019, .778],
  0x50: [.683, 0, .611],
  0x51: [.701, .181, .778],
  0x52: [.683, 0, .722],
  0x53: [.702, .012, .556],
  0x54: [.683, 0, .667],
  0x55: [.683, .019, .722],
  0x56: [.683, .02, .722],
  0x57: [.683, .019, 1],
  0x58: [.683, 0, .722],
  0x59: [.683, 0, .722],
  0x5A: [.683, 0, .667],
  0x6B: [.683, 0, .556],
  0xA0: [0, 0, .25],
  0x391: [.698, 0, .869],
  0x392: [.686, 0, .818],
  0x395: [.68, 0, .756],
  0x396: [.686, 0, .703],
  0x397: [.686, 0, .9],
  0x399: [.686, 0, .436],
  0x39A: [.686, 0, .901],
  0x39C: [.686, 0, 1.092],
  0x39D: [.686, 0, .9],
  0x39F: [.696, .01, .864],
  0x3A1: [.686, 0, .786],
  0x3A2: [.696, .01, .894],
  0x3A4: [.675, 0, .8],
  0x3A7: [.686, 0, .869],
  0x3D2: [.697, 0, .894],
  0x3DC: [.68, 0, .724],
  0x2102: [.702, .019, .722],
  0x210D: [.683, 0, .778],
  0x2115: [.683, .02, .722],
  0x2119: [.683, 0, .611],
  0x211A: [.701, .181, .778],
  0x211D: [.683, 0, .722],
  0x2124: [.683, 0, .667]
};

/***/ }),
/* 304 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var fraktur_bold_js_1 = __webpack_require__(305);

exports.frakturBold = FontData_js_1.AddCSS(fraktur_bold_js_1.frakturBold, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3D: {
    c: '='
  },
  0x3F: {
    c: '?'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x391: {
    c: 'A',
    f: 'B'
  },
  0x392: {
    c: 'B',
    f: 'B'
  },
  0x395: {
    c: 'E',
    f: 'B'
  },
  0x396: {
    c: 'Z',
    f: 'B'
  },
  0x397: {
    c: 'H',
    f: 'B'
  },
  0x399: {
    c: 'I',
    f: 'B'
  },
  0x39A: {
    c: 'K',
    f: 'B'
  },
  0x39C: {
    c: 'M',
    f: 'B'
  },
  0x39D: {
    c: 'N',
    f: 'B'
  },
  0x39F: {
    c: 'O',
    f: 'B'
  },
  0x3A1: {
    c: 'P',
    f: 'B'
  },
  0x3A2: {
    c: '\\398',
    f: 'B'
  },
  0x3A4: {
    c: 'T',
    f: 'B'
  },
  0x3A7: {
    c: 'X',
    f: 'B'
  },
  0x3D2: {
    c: '\\3A5',
    f: 'B'
  },
  0x3DC: {
    c: 'F',
    f: 'B'
  },
  0x2044: {
    c: '/'
  }
});

/***/ }),
/* 305 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.frakturBold = {
  0x20: [0, 0, .25],
  0x21: [.689, .012, .349],
  0x22: [.695, -0.432, .254],
  0x26: [.696, .016, .871],
  0x27: [.695, -0.436, .25],
  0x28: [.737, .186, .459],
  0x29: [.735, .187, .459],
  0x2A: [.692, -0.449, .328],
  0x2B: [.598, .082, .893],
  0x2C: [.107, .191, .328],
  0x2D: [.275, -0.236, .893],
  0x2E: [.102, .015, .328],
  0x2F: [.721, .182, .593],
  0x30: [.501, .012, .593],
  0x31: [.489, 0, .593],
  0x32: [.491, 0, .593],
  0x33: [.487, .193, .593],
  0x34: [.495, .196, .593],
  0x35: [.481, .19, .593],
  0x36: [.704, .012, .593],
  0x37: [.479, .197, .593],
  0x38: [.714, .005, .593],
  0x39: [.487, .195, .593],
  0x3A: [.457, .012, .255],
  0x3B: [.458, .19, .255],
  0x3D: [.343, -0.168, .582],
  0x3F: [.697, .014, .428],
  0x41: [.686, .031, .847],
  0x42: [.684, .031, 1.044],
  0x43: [.676, .032, .723],
  0x44: [.683, .029, .982],
  0x45: [.686, .029, .783],
  0x46: [.684, .146, .722],
  0x47: [.687, .029, .927],
  0x48: [.683, .126, .851],
  0x49: [.681, .025, .655],
  0x4A: [.68, .141, .652],
  0x4B: [.681, .026, .789],
  0x4C: [.683, .028, .786],
  0x4D: [.683, .032, 1.239],
  0x4E: [.679, .03, .983],
  0x4F: [.726, .03, .976],
  0x50: [.688, .223, .977],
  0x51: [.726, .083, .976],
  0x52: [.688, .028, .978],
  0x53: [.685, .031, .978],
  0x54: [.686, .03, .79],
  0x55: [.688, .039, .851],
  0x56: [.685, .029, .982],
  0x57: [.683, .03, 1.235],
  0x58: [.681, .035, .849],
  0x59: [.688, .214, .984],
  0x5A: [.677, .148, .711],
  0x5B: [.74, .13, .257],
  0x5D: [.738, .132, .257],
  0x5E: [.734, -0.452, .59],
  0x61: [.472, .032, .603],
  0x62: [.69, .032, .59],
  0x63: [.473, .026, .464],
  0x64: [.632, .028, .589],
  0x65: [.471, .027, .472],
  0x66: [.687, .222, .388],
  0x67: [.472, .208, .595],
  0x68: [.687, .207, .615],
  0x69: [.686, .025, .331],
  0x6A: [.682, .203, .332],
  0x6B: [.682, .025, .464],
  0x6C: [.681, .024, .337],
  0x6D: [.476, .031, .921],
  0x6E: [.473, .028, .654],
  0x6F: [.482, .034, .609],
  0x70: [.557, .207, .604],
  0x71: [.485, .211, .596],
  0x72: [.472, .026, .46],
  0x73: [.479, .034, .523],
  0x74: [.648, .027, .393],
  0x75: [.472, .032, .589],
  0x76: [.546, .027, .604],
  0x77: [.549, .032, .918],
  0x78: [.471, .188, .459],
  0x79: [.557, .221, .589],
  0x7A: [.471, .214, .461],
  0xA0: [0, 0, .25],
  0x391: [.698, 0, .869],
  0x392: [.686, 0, .818],
  0x395: [.68, 0, .756],
  0x396: [.686, 0, .703],
  0x397: [.686, 0, .9],
  0x399: [.686, 0, .436],
  0x39A: [.686, 0, .901],
  0x39C: [.686, 0, 1.092],
  0x39D: [.686, 0, .9],
  0x39F: [.696, .01, .864],
  0x3A1: [.686, 0, .786],
  0x3A2: [.696, .01, .894],
  0x3A4: [.675, 0, .8],
  0x3A7: [.686, 0, .869],
  0x3D2: [.697, 0, .894],
  0x3DC: [.68, 0, .724],
  0x2018: [.708, -0.411, .254],
  0x2019: [.692, -0.394, .254],
  0x2044: [.721, .182, .593],
  0xE301: [.63, .027, .587],
  0xE302: [.693, .212, .394],
  0xE303: [.681, .219, .387],
  0xE304: [.473, .212, .593],
  0xE305: [.684, .027, .393],
  0xE308: [.679, .22, .981],
  0xE309: [.717, .137, .727]
};

/***/ }),
/* 306 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var fraktur_js_1 = __webpack_require__(307);

exports.fraktur = FontData_js_1.AddCSS(fraktur_js_1.fraktur, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3D: {
    c: '='
  },
  0x3F: {
    c: '?'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x391: {
    c: 'A',
    f: ''
  },
  0x392: {
    c: 'B',
    f: ''
  },
  0x395: {
    c: 'E',
    f: ''
  },
  0x396: {
    c: 'Z',
    f: ''
  },
  0x397: {
    c: 'H',
    f: ''
  },
  0x399: {
    c: 'I',
    f: ''
  },
  0x39A: {
    c: 'K',
    f: ''
  },
  0x39C: {
    c: 'M',
    f: ''
  },
  0x39D: {
    c: 'N',
    f: ''
  },
  0x39F: {
    c: 'O',
    f: ''
  },
  0x3A1: {
    c: 'P',
    f: ''
  },
  0x3A2: {
    c: '\\398',
    f: ''
  },
  0x3A4: {
    c: 'T',
    f: ''
  },
  0x3A7: {
    c: 'X',
    f: ''
  },
  0x3D2: {
    c: '\\3A5',
    f: ''
  },
  0x3DC: {
    c: 'F',
    f: ''
  },
  0x2044: {
    c: '/'
  },
  0x210C: {
    c: 'H',
    f: 'FR'
  },
  0x2111: {
    c: 'I',
    f: 'FR'
  },
  0x211C: {
    c: 'R',
    f: 'FR'
  },
  0x2128: {
    c: 'Z',
    f: 'FR'
  },
  0x212D: {
    c: 'C',
    f: 'FR'
  }
});

/***/ }),
/* 307 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.fraktur = {
  0x20: [0, 0, .25],
  0x21: [.689, .012, .296],
  0x22: [.695, -0.432, .215],
  0x26: [.698, .011, .738],
  0x27: [.695, -0.436, .212],
  0x28: [.737, .186, .389],
  0x29: [.735, .187, .389],
  0x2A: [.692, -0.449, .278],
  0x2B: [.598, .082, .756],
  0x2C: [.107, .191, .278],
  0x2D: [.275, -0.236, .756],
  0x2E: [.102, .015, .278],
  0x2F: [.721, .182, .502],
  0x30: [.492, .013, .502],
  0x31: [.468, 0, .502],
  0x32: [.474, 0, .502],
  0x33: [.473, .182, .502],
  0x34: [.476, .191, .502],
  0x35: [.458, .184, .502],
  0x36: [.7, .013, .502],
  0x37: [.468, .181, .502],
  0x38: [.705, .01, .502],
  0x39: [.469, .182, .502],
  0x3A: [.457, .012, .216],
  0x3B: [.458, .189, .216],
  0x3D: [.368, -0.132, .756],
  0x3F: [.693, .011, .362],
  0x41: [.696, .026, .718],
  0x42: [.691, .027, .884],
  0x43: [.685, .024, .613],
  0x44: [.685, .027, .832],
  0x45: [.685, .024, .663],
  0x46: [.686, .153, .611],
  0x47: [.69, .026, .785],
  0x48: [.666, .133, .72],
  0x49: [.686, .026, .554],
  0x4A: [.686, .139, .552],
  0x4B: [.68, .027, .668],
  0x4C: [.686, .026, .666],
  0x4D: [.692, .027, 1.05],
  0x4E: [.686, .025, .832],
  0x4F: [.729, .027, .827],
  0x50: [.692, .218, .828],
  0x51: [.729, .069, .827],
  0x52: [.686, .026, .828],
  0x53: [.692, .027, .829],
  0x54: [.701, .027, .669],
  0x55: [.697, .027, .646],
  0x56: [.686, .026, .831],
  0x57: [.686, .027, 1.046],
  0x58: [.688, .027, .719],
  0x59: [.686, .218, .833],
  0x5A: [.729, .139, .602],
  0x5B: [.74, .13, .278],
  0x5D: [.738, .131, .278],
  0x5E: [.734, -0.452, .5],
  0x61: [.47, .035, .5],
  0x62: [.685, .031, .513],
  0x63: [.466, .029, .389],
  0x64: [.609, .033, .499],
  0x65: [.467, .03, .401],
  0x66: [.681, .221, .326],
  0x67: [.47, .209, .504],
  0x68: [.688, .205, .521],
  0x69: [.673, .02, .279],
  0x6A: [.672, .208, .281],
  0x6B: [.689, .025, .389],
  0x6C: [.685, .02, .28],
  0x6D: [.475, .026, .767],
  0x6E: [.475, .022, .527],
  0x6F: [.48, .028, .489],
  0x70: [.541, .212, .5],
  0x71: [.479, .219, .489],
  0x72: [.474, .021, .389],
  0x73: [.478, .029, .443],
  0x74: [.64, .02, .333],
  0x75: [.474, .023, .517],
  0x76: [.53, .028, .512],
  0x77: [.532, .028, .774],
  0x78: [.472, .188, .389],
  0x79: [.528, .218, .499],
  0x7A: [.471, .214, .391],
  0xA0: [0, 0, .25],
  0x391: [.716, 0, .75],
  0x392: [.683, 0, .708],
  0x395: [.68, 0, .681],
  0x396: [.683, 0, .611],
  0x397: [.683, 0, .75],
  0x399: [.683, 0, .361],
  0x39A: [.683, 0, .778],
  0x39C: [.683, 0, .917],
  0x39D: [.683, 0, .75],
  0x39F: [.705, .022, .778],
  0x3A1: [.683, 0, .681],
  0x3A2: [.705, .022, .778],
  0x3A4: [.677, 0, .722],
  0x3A7: [.683, 0, .75],
  0x3D2: [.705, 0, .778],
  0x3DC: [.68, 0, .653],
  0x2018: [.708, -0.41, .215],
  0x2019: [.692, -0.395, .215],
  0x2044: [.721, .182, .502],
  0x210C: [.666, .133, .72],
  0x2111: [.686, .026, .554],
  0x211C: [.686, .026, .828],
  0x2128: [.729, .139, .602],
  0x212D: [.685, .024, .613],
  0xE300: [.683, .032, .497],
  0xE301: [.616, .03, .498],
  0xE302: [.68, .215, .333],
  0xE303: [.679, .224, .329],
  0xE304: [.471, .214, .503],
  0xE305: [.686, .02, .333],
  0xE306: [.577, .021, .334],
  0xE307: [.475, .022, .501]
};

/***/ }),
/* 308 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var italic_js_1 = __webpack_require__(309);

exports.italic = FontData_js_1.AddCSS(italic_js_1.italic, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x23: {
    c: '#'
  },
  0x25: {
    c: '%'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3D: {
    c: '='
  },
  0x3F: {
    c: '?'
  },
  0x40: {
    c: '@'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x5F: {
    c: '_'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x7E: {
    c: '~'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x2015: {
    c: '\\2014'
  },
  0x2017: {
    c: '_'
  },
  0x2044: {
    c: '/'
  },
  0x210E: {
    c: 'h',
    f: 'I'
  },
  0x2206: {
    c: '\\394'
  },
  0x29F8: {
    c: '/',
    f: 'I'
  }
});

/***/ }),
/* 309 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.italic = {
  0x20: [0, 0, .25],
  0x21: [.716, 0, .307, {
    ic: .073
  }],
  0x22: [.694, -0.379, .514],
  0x23: [.694, .194, .818],
  0x25: [.75, .056, .818],
  0x26: [.716, .022, .767],
  0x27: [.694, -0.379, .307, {
    ic: .07
  }],
  0x28: [.75, .25, .409, {
    ic: .108
  }],
  0x29: [.75, .25, .409],
  0x2A: [.75, -0.32, .511, {
    ic: .073
  }],
  0x2B: [.557, .057, .767],
  0x2C: [.121, .194, .307],
  0x2D: [.251, -0.18, .358],
  0x2E: [.121, 0, .307],
  0x2F: [.716, .215, .778],
  0x30: [.665, .021, .511, {
    ic: .051
  }],
  0x31: [.666, 0, .511],
  0x32: [.666, .022, .511],
  0x33: [.666, .022, .511, {
    ic: .051
  }],
  0x34: [.666, .194, .511],
  0x35: [.666, .022, .511, {
    ic: .056
  }],
  0x36: [.665, .022, .511, {
    ic: .054
  }],
  0x37: [.666, .022, .511, {
    ic: .123
  }],
  0x38: [.666, .021, .511],
  0x39: [.666, .022, .511],
  0x3A: [.431, 0, .307],
  0x3B: [.431, .194, .307],
  0x3D: [.367, -0.133, .767],
  0x3F: [.716, 0, .511],
  0x40: [.705, .011, .767],
  0x41: [.716, 0, .75, {
    sk: 0.139
  }],
  0x42: [.683, 0, .759, {
    sk: 0.0833
  }],
  0x43: [.705, .022, .715, {
    sk: 0.0833
  }],
  0x44: [.683, 0, .828, {
    sk: 0.0556
  }],
  0x45: [.68, 0, .738, {
    sk: 0.0833
  }],
  0x46: [.68, 0, .643, {
    ic: .106,
    sk: 0.0833
  }],
  0x47: [.705, .022, .786, {
    sk: 0.0833
  }],
  0x48: [.683, 0, .831, {
    ic: .057,
    sk: 0.0556
  }],
  0x49: [.683, 0, .44, {
    ic: .064,
    sk: 0.111
  }],
  0x4A: [.683, .022, .555, {
    ic: .078,
    sk: 0.167
  }],
  0x4B: [.683, 0, .849, {
    sk: 0.0556
  }],
  0x4C: [.683, 0, .681, {
    sk: 0.0278
  }],
  0x4D: [.683, 0, .97, {
    ic: .081,
    sk: 0.0833
  }],
  0x4E: [.683, 0, .803, {
    ic: .085,
    sk: 0.0833
  }],
  0x4F: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x50: [.683, 0, .642, {
    ic: .109,
    sk: 0.0833
  }],
  0x51: [.704, .194, .791, {
    sk: 0.0833
  }],
  0x52: [.683, .021, .759, {
    sk: 0.0833
  }],
  0x53: [.705, .022, .613, {
    sk: 0.0833
  }],
  0x54: [.677, 0, .584, {
    ic: .12,
    sk: 0.0833
  }],
  0x55: [.683, .022, .683, {
    ic: .084,
    sk: 0.0278
  }],
  0x56: [.683, .022, .583, {
    ic: .186
  }],
  0x57: [.683, .022, .944, {
    ic: .104
  }],
  0x58: [.683, 0, .828, {
    sk: 0.0833
  }],
  0x59: [.683, 0, .581, {
    ic: .182
  }],
  0x5A: [.683, 0, .683, {
    sk: 0.0833
  }],
  0x5B: [.75, .25, .307, {
    ic: .139
  }],
  0x5D: [.75, .25, .307, {
    ic: .052
  }],
  0x5E: [.694, -0.527, .511],
  0x5F: [-0.025, .062, .511],
  0x61: [.441, .01, .529],
  0x62: [.694, .011, .429],
  0x63: [.442, .011, .433, {
    sk: 0.0556
  }],
  0x64: [.694, .01, .52, {
    sk: 0.167
  }],
  0x65: [.442, .011, .466, {
    sk: 0.0556
  }],
  0x66: [.705, .205, .49, {
    ic: .06,
    sk: 0.167
  }],
  0x67: [.442, .205, .477, {
    sk: 0.0278
  }],
  0x68: [.694, .011, .576, {
    sk: -0.0278
  }],
  0x69: [.661, .011, .345],
  0x6A: [.661, .204, .412],
  0x6B: [.694, .011, .521],
  0x6C: [.694, .011, .298, {
    sk: 0.0833
  }],
  0x6D: [.442, .011, .878],
  0x6E: [.442, .011, .6],
  0x6F: [.441, .011, .485, {
    sk: 0.0556
  }],
  0x70: [.442, .194, .503, {
    sk: 0.0833
  }],
  0x71: [.442, .194, .446, {
    sk: 0.0833
  }],
  0x72: [.442, .011, .451, {
    sk: 0.0556
  }],
  0x73: [.442, .01, .469, {
    sk: 0.0556
  }],
  0x74: [.626, .011, .361, {
    sk: 0.0833
  }],
  0x75: [.442, .011, .572, {
    sk: 0.0278
  }],
  0x76: [.443, .011, .485, {
    sk: 0.0278
  }],
  0x77: [.443, .011, .716, {
    sk: 0.0833
  }],
  0x78: [.442, .011, .572, {
    sk: 0.0278
  }],
  0x79: [.442, .205, .49, {
    sk: 0.0556
  }],
  0x7A: [.442, .011, .465, {
    sk: 0.0556
  }],
  0x7E: [.318, -0.208, .511, {
    ic: .06
  }],
  0xA0: [0, 0, .25],
  0xA3: [.714, .011, .769],
  0x131: [.441, .01, .307],
  0x237: [.442, .204, .332],
  0x300: [.697, -0.5, 0],
  0x301: [.697, -0.5, 0],
  0x302: [.694, -0.527, 0],
  0x303: [.668, -0.558, 0, {
    ic: .06
  }],
  0x304: [.589, -0.544, 0, {
    ic: .054
  }],
  0x306: [.694, -0.515, 0, {
    ic: .062
  }],
  0x307: [.669, -0.548, 0],
  0x308: [.669, -0.554, 0],
  0x30A: [.716, -0.542, 0],
  0x30B: [.697, -0.503, 0, {
    ic: .065
  }],
  0x30C: [.638, -0.502, 0],
  0x391: [.716, 0, .75, {
    sk: 0.139
  }],
  0x392: [.683, 0, .759, {
    sk: 0.0833
  }],
  0x393: [.68, 0, .615, {
    ic: .106,
    sk: 0.0833
  }],
  0x394: [.716, 0, .833, {
    sk: 0.167
  }],
  0x395: [.68, 0, .738, {
    sk: 0.0833
  }],
  0x396: [.683, 0, .683, {
    sk: 0.0833
  }],
  0x397: [.683, 0, .831, {
    ic: .057,
    sk: 0.0556
  }],
  0x398: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x399: [.683, 0, .44, {
    ic: .064,
    sk: 0.111
  }],
  0x39A: [.683, 0, .849, {
    sk: 0.0556
  }],
  0x39B: [.716, 0, .694, {
    sk: 0.167
  }],
  0x39C: [.683, 0, .97, {
    ic: .081,
    sk: 0.0833
  }],
  0x39D: [.683, 0, .803, {
    ic: .085,
    sk: 0.0833
  }],
  0x39E: [.677, 0, .742, {
    sk: 0.0833
  }],
  0x39F: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x3A0: [.68, 0, .831, {
    ic: .056,
    sk: 0.0556
  }],
  0x3A1: [.683, 0, .642, {
    ic: .109,
    sk: 0.0833
  }],
  0x3A2: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x3A3: [.683, 0, .78, {
    sk: 0.0833
  }],
  0x3A4: [.677, 0, .584, {
    ic: .12,
    sk: 0.0833
  }],
  0x3A5: [.705, 0, .583, {
    ic: .117,
    sk: 0.0556
  }],
  0x3A6: [.683, 0, .667, {
    sk: 0.0833
  }],
  0x3A7: [.683, 0, .828, {
    sk: 0.0833
  }],
  0x3A8: [.683, 0, .612, {
    ic: .08,
    sk: 0.0556
  }],
  0x3A9: [.704, 0, .772, {
    sk: 0.0833
  }],
  0x3B1: [.442, .011, .64, {
    sk: 0.0278
  }],
  0x3B2: [.705, .194, .566, {
    sk: 0.0833
  }],
  0x3B3: [.441, .216, .518],
  0x3B4: [.717, .01, .444, {
    sk: 0.0556
  }],
  0x3B5: [.452, .022, .466, {
    sk: 0.0833
  }],
  0x3B6: [.704, .204, .438, {
    sk: 0.0833
  }],
  0x3B7: [.442, .216, .497, {
    sk: 0.0556
  }],
  0x3B8: [.705, .01, .469, {
    sk: 0.0833
  }],
  0x3B9: [.442, .01, .354, {
    sk: 0.0556
  }],
  0x3BA: [.442, .011, .576],
  0x3BB: [.694, .012, .583],
  0x3BC: [.442, .216, .603, {
    sk: 0.0278
  }],
  0x3BD: [.442, 0, .494, {
    sk: 0.0278
  }],
  0x3BE: [.704, .205, .438, {
    sk: 0.111
  }],
  0x3BF: [.441, .011, .485, {
    sk: 0.0556
  }],
  0x3C0: [.431, .011, .57],
  0x3C1: [.442, .216, .517, {
    sk: 0.0833
  }],
  0x3C2: [.442, .107, .363, {
    sk: 0.0833
  }],
  0x3C3: [.431, .011, .571],
  0x3C4: [.431, .013, .437, {
    ic: .08,
    sk: 0.0278
  }],
  0x3C5: [.443, .01, .54, {
    sk: 0.0278
  }],
  0x3C6: [.442, .218, .654, {
    sk: 0.0833
  }],
  0x3C7: [.442, .204, .626, {
    sk: 0.0556
  }],
  0x3C8: [.694, .205, .651, {
    sk: 0.111
  }],
  0x3C9: [.443, .011, .622],
  0x3D1: [.705, .011, .591, {
    sk: 0.0833
  }],
  0x3D2: [.705, 0, .583, {
    ic: .117,
    sk: 0.0556
  }],
  0x3D5: [.694, .205, .596, {
    sk: 0.0833
  }],
  0x3D6: [.431, .01, .828],
  0x3DC: [.68, 0, .643, {
    ic: .106,
    sk: 0.0833
  }],
  0x3F1: [.442, .194, .517, {
    sk: 0.0833
  }],
  0x3F5: [.431, .011, .406, {
    sk: 0.0556
  }],
  0x2013: [.285, -0.248, .511],
  0x2014: [.285, -0.248, 1.022],
  0x2015: [.285, -0.248, 1.022],
  0x2017: [-0.025, .062, .511],
  0x2018: [.694, -0.379, .307, {
    ic: .055
  }],
  0x2019: [.694, -0.379, .307, {
    ic: .07
  }],
  0x201C: [.694, -0.379, .514, {
    ic: .092
  }],
  0x201D: [.694, -0.379, .514],
  0x2044: [.716, .215, .778],
  0x210E: [.694, .011, .576, {
    sk: -0.0278
  }],
  0x210F: [.695, .013, .54],
  0x2206: [.716, 0, .833, {
    sk: 0.167
  }],
  0x29F8: [.716, .215, .778]
};

/***/ }),
/* 310 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var largeop_js_1 = __webpack_require__(311);

exports.largeop = FontData_js_1.AddCSS(largeop_js_1.largeop, {
  0x20: {
    c: ' '
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2F: {
    c: '/'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x7B: {
    c: '{'
  },
  0x7D: {
    c: '}'
  },
  0x2044: {
    c: '/'
  },
  0x2329: {
    c: '\\27E8'
  },
  0x232A: {
    c: '\\27E9'
  },
  0x2758: {
    c: '\\2223'
  },
  0x2A0C: {
    c: '\\222C\\222C'
  },
  0x3008: {
    c: '\\27E8'
  },
  0x3009: {
    c: '\\27E9'
  }
});

/***/ }),
/* 311 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.largeop = {
  0x20: [0, 0, .25],
  0x28: [1.15, .649, .597],
  0x29: [1.15, .649, .597],
  0x2F: [1.15, .649, .811],
  0x5B: [1.15, .649, .472],
  0x5C: [1.15, .649, .811],
  0x5D: [1.15, .649, .472],
  0x7B: [1.15, .649, .667],
  0x7D: [1.15, .649, .667],
  0xA0: [0, 0, .25],
  0x2C6: [.772, -0.565, 1],
  0x2DC: [.75, -0.611, 1],
  0x302: [.772, -0.565, 0],
  0x303: [.75, -0.611, 0],
  0x2016: [.602, 0, .778],
  0x2044: [1.15, .649, .811],
  0x2191: [.6, 0, .667],
  0x2193: [.6, 0, .667],
  0x21D1: [.599, 0, .778],
  0x21D3: [.6, 0, .778],
  0x220F: [.95, .45, 1.278],
  0x2210: [.95, .45, 1.278],
  0x2211: [.95, .45, 1.444],
  0x221A: [1.15, .65, 1],
  0x2223: [.627, .015, .333],
  0x2225: [.627, .015, .556],
  0x222B: [1.36, .862, .556, {
    ic: .388
  }],
  0x222C: [1.36, .862, 1.084, {
    ic: .388
  }],
  0x222D: [1.36, .862, 1.592, {
    ic: .388
  }],
  0x222E: [1.36, .862, .556, {
    ic: .388
  }],
  0x22C0: [.95, .45, 1.111],
  0x22C1: [.95, .45, 1.111],
  0x22C2: [.949, .45, 1.111],
  0x22C3: [.95, .449, 1.111],
  0x2308: [1.15, .649, .528],
  0x2309: [1.15, .649, .528],
  0x230A: [1.15, .649, .528],
  0x230B: [1.15, .649, .528],
  0x2329: [1.15, .649, .611],
  0x232A: [1.15, .649, .611],
  0x23D0: [.602, 0, .667],
  0x2758: [.627, .015, .333],
  0x27E8: [1.15, .649, .611],
  0x27E9: [1.15, .649, .611],
  0x2A00: [.949, .449, 1.511],
  0x2A01: [.949, .449, 1.511],
  0x2A02: [.949, .449, 1.511],
  0x2A04: [.95, .449, 1.111],
  0x2A06: [.95, .45, 1.111],
  0x2A0C: [1.36, .862, 2.168, {
    ic: .388
  }],
  0x3008: [1.15, .649, .611],
  0x3009: [1.15, .649, .611]
};

/***/ }),
/* 312 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var monospace_js_1 = __webpack_require__(313);

exports.monospace = FontData_js_1.AddCSS(monospace_js_1.monospace, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x23: {
    c: '#'
  },
  0x24: {
    c: '$'
  },
  0x25: {
    c: '%'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3C: {
    c: '<'
  },
  0x3D: {
    c: '='
  },
  0x3E: {
    c: '>'
  },
  0x3F: {
    c: '?'
  },
  0x40: {
    c: '@'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x5F: {
    c: '_'
  },
  0x60: {
    c: '`'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x7B: {
    c: '{'
  },
  0x7C: {
    c: '|'
  },
  0x7D: {
    c: '}'
  },
  0x7E: {
    c: '~'
  },
  0x2B9: {
    c: '\\2032'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x2017: {
    c: '_'
  },
  0x2033: {
    c: '\\2032\\2032'
  },
  0x2034: {
    c: '\\2032\\2032\\2032'
  },
  0x2044: {
    c: '/'
  },
  0x2057: {
    c: '\\2032\\2032\\2032\\2032'
  },
  0x2206: {
    c: '\\394'
  }
});

/***/ }),
/* 313 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.monospace = {
  0x20: [0, 0, .525],
  0x21: [.622, 0, .525],
  0x22: [.623, -0.333, .525],
  0x23: [.611, 0, .525],
  0x24: [.694, .082, .525],
  0x25: [.694, .083, .525],
  0x26: [.622, .011, .525],
  0x27: [.611, -0.287, .525],
  0x28: [.694, .082, .525],
  0x29: [.694, .082, .525],
  0x2A: [.52, -0.09, .525],
  0x2B: [.531, -0.081, .525],
  0x2C: [.14, .139, .525],
  0x2D: [.341, -0.271, .525],
  0x2E: [.14, 0, .525],
  0x2F: [.694, .083, .525],
  0x30: [.621, .01, .525],
  0x31: [.622, 0, .525],
  0x32: [.622, 0, .525],
  0x33: [.622, .011, .525],
  0x34: [.624, 0, .525],
  0x35: [.611, .01, .525],
  0x36: [.622, .011, .525],
  0x37: [.627, .01, .525],
  0x38: [.621, .01, .525],
  0x39: [.622, .011, .525],
  0x3A: [.431, 0, .525],
  0x3B: [.431, .139, .525],
  0x3C: [.557, -0.055, .525],
  0x3D: [.417, -0.195, .525],
  0x3E: [.557, -0.055, .525],
  0x3F: [.617, 0, .525],
  0x40: [.617, .006, .525],
  0x41: [.623, 0, .525],
  0x42: [.611, 0, .525],
  0x43: [.622, .011, .525],
  0x44: [.611, 0, .525],
  0x45: [.611, 0, .525],
  0x46: [.611, 0, .525],
  0x47: [.622, .011, .525],
  0x48: [.611, 0, .525],
  0x49: [.611, 0, .525],
  0x4A: [.611, .011, .525],
  0x4B: [.611, 0, .525],
  0x4C: [.611, 0, .525],
  0x4D: [.611, 0, .525],
  0x4E: [.611, 0, .525],
  0x4F: [.621, .01, .525],
  0x50: [.611, 0, .525],
  0x51: [.621, .138, .525],
  0x52: [.611, .011, .525],
  0x53: [.622, .011, .525],
  0x54: [.611, 0, .525],
  0x55: [.611, .011, .525],
  0x56: [.611, .007, .525],
  0x57: [.611, .007, .525],
  0x58: [.611, 0, .525],
  0x59: [.611, 0, .525],
  0x5A: [.611, 0, .525],
  0x5B: [.694, .082, .525],
  0x5C: [.694, .083, .525],
  0x5D: [.694, .082, .525],
  0x5E: [.611, -0.46, .525],
  0x5F: [-0.025, .095, .525],
  0x60: [.681, -0.357, .525],
  0x61: [.439, .006, .525],
  0x62: [.611, .006, .525],
  0x63: [.44, .006, .525],
  0x64: [.611, .006, .525],
  0x65: [.44, .006, .525],
  0x66: [.617, 0, .525],
  0x67: [.442, .229, .525],
  0x68: [.611, 0, .525],
  0x69: [.612, 0, .525],
  0x6A: [.612, .228, .525],
  0x6B: [.611, 0, .525],
  0x6C: [.611, 0, .525],
  0x6D: [.436, 0, .525],
  0x6E: [.436, 0, .525],
  0x6F: [.44, .006, .525],
  0x70: [.437, .221, .525],
  0x71: [.437, .221, .525],
  0x72: [.437, 0, .525],
  0x73: [.44, .006, .525],
  0x74: [.554, .006, .525],
  0x75: [.431, .005, .525],
  0x76: [.431, 0, .525],
  0x77: [.431, 0, .525],
  0x78: [.431, 0, .525],
  0x79: [.431, .228, .525],
  0x7A: [.431, 0, .525],
  0x7B: [.694, .083, .525],
  0x7C: [.694, .082, .525],
  0x7D: [.694, .083, .525],
  0x7E: [.611, -0.466, .525],
  0x7F: [.612, -0.519, .525],
  0xA0: [0, 0, .525],
  0x131: [.431, 0, .525],
  0x237: [.431, .228, .525],
  0x2B9: [.623, -0.334, .525],
  0x300: [.611, -0.485, 0],
  0x301: [.611, -0.485, 0],
  0x302: [.611, -0.46, 0],
  0x303: [.611, -0.466, 0],
  0x304: [.577, -0.5, 0],
  0x306: [.611, -0.504, 0],
  0x308: [.612, -0.519, 0],
  0x30A: [.619, -0.499, 0],
  0x30C: [.577, -0.449, 0],
  0x391: [.623, 0, .525],
  0x392: [.611, 0, .525],
  0x393: [.611, 0, .525],
  0x394: [.623, 0, .525],
  0x395: [.611, 0, .525],
  0x396: [.611, 0, .525],
  0x397: [.611, 0, .525],
  0x398: [.621, .01, .525],
  0x399: [.611, 0, .525],
  0x39A: [.611, 0, .525],
  0x39B: [.623, 0, .525],
  0x39C: [.611, 0, .525],
  0x39D: [.611, 0, .525],
  0x39E: [.611, 0, .525],
  0x39F: [.621, .01, .525],
  0x3A0: [.611, 0, .525],
  0x3A1: [.611, 0, .525],
  0x3A2: [.621, .01, .525],
  0x3A3: [.611, 0, .525],
  0x3A4: [.611, 0, .525],
  0x3A5: [.622, 0, .525],
  0x3A6: [.611, 0, .525],
  0x3A7: [.611, 0, .525],
  0x3A8: [.611, 0, .525],
  0x3A9: [.622, 0, .525],
  0x3D2: [.622, 0, .525],
  0x3DC: [.611, 0, .525],
  0x2017: [-0.025, .095, .525],
  0x2032: [.623, -0.334, .525],
  0x2033: [.623, 0, 1.05],
  0x2034: [.623, 0, 1.575],
  0x2044: [.694, .083, .525],
  0x2057: [.623, 0, 2.1],
  0x2206: [.623, 0, .525]
};

/***/ }),
/* 314 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var normal_js_1 = __webpack_require__(315);

exports.normal = FontData_js_1.AddCSS(normal_js_1.normal, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x23: {
    c: '#'
  },
  0x24: {
    c: '$'
  },
  0x25: {
    c: '%'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3C: {
    c: '<'
  },
  0x3D: {
    c: '='
  },
  0x3E: {
    c: '>'
  },
  0x3F: {
    c: '?'
  },
  0x40: {
    c: '@'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x5F: {
    c: '_'
  },
  0x60: {
    c: '`'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x7B: {
    c: '{'
  },
  0x7C: {
    c: '|'
  },
  0x7D: {
    c: '}'
  },
  0x7E: {
    c: '~'
  },
  0xA3: {
    f: 'MI'
  },
  0xB7: {
    c: '\\22C5'
  },
  0x2B9: {
    c: '\\2032'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x3F6: {
    c: '\\220D'
  },
  0x2000: {
    c: ''
  },
  0x2001: {
    c: ''
  },
  0x2002: {
    c: ''
  },
  0x2003: {
    c: ''
  },
  0x2004: {
    c: ''
  },
  0x2005: {
    c: ''
  },
  0x2006: {
    c: ''
  },
  0x2009: {
    c: ''
  },
  0x200A: {
    c: ''
  },
  0x200B: {
    c: ''
  },
  0x200C: {
    c: ''
  },
  0x2015: {
    c: '\\2014'
  },
  0x2016: {
    c: '\\2225'
  },
  0x2017: {
    c: '_'
  },
  0x2022: {
    c: '\\2219'
  },
  0x2033: {
    c: '\\2032\\2032'
  },
  0x2034: {
    c: '\\2032\\2032\\2032'
  },
  0x2036: {
    c: '\\2035\\2035'
  },
  0x2037: {
    c: '\\2035\\2035\\2035'
  },
  0x203E: {
    c: '\\2C9'
  },
  0x2044: {
    c: '/'
  },
  0x2057: {
    c: '\\2032\\2032\\2032\\2032'
  },
  0x2061: {
    c: ''
  },
  0x2062: {
    c: ''
  },
  0x2063: {
    c: ''
  },
  0x2064: {
    c: ''
  },
  0x20D7: {
    c: '\\2192',
    f: 'V'
  },
  0x2102: {
    c: 'C',
    f: 'A'
  },
  0x210B: {
    c: 'H',
    f: 'SC'
  },
  0x210C: {
    c: 'H',
    f: 'FR'
  },
  0x210D: {
    c: 'H',
    f: 'A'
  },
  0x210E: {
    c: 'h',
    f: 'I'
  },
  0x210F: {
    f: ''
  },
  0x2110: {
    c: 'J',
    f: 'SC'
  },
  0x2111: {
    c: 'I',
    f: 'FR'
  },
  0x2112: {
    c: 'L',
    f: 'SC'
  },
  0x2115: {
    c: 'N',
    f: 'A'
  },
  0x2119: {
    c: 'P',
    f: 'A'
  },
  0x211A: {
    c: 'Q',
    f: 'A'
  },
  0x211B: {
    c: 'R',
    f: 'SC'
  },
  0x211C: {
    c: 'R',
    f: 'FR'
  },
  0x211D: {
    c: 'R',
    f: 'A'
  },
  0x2124: {
    c: 'Z',
    f: 'A'
  },
  0x2126: {
    c: '\\3A9',
    f: ''
  },
  0x2128: {
    c: 'Z',
    f: 'FR'
  },
  0x212C: {
    c: 'B',
    f: 'SC'
  },
  0x212D: {
    c: 'C',
    f: 'FR'
  },
  0x2130: {
    c: 'E',
    f: 'SC'
  },
  0x2131: {
    c: 'F',
    f: 'SC'
  },
  0x2133: {
    c: 'M',
    f: 'SC'
  },
  0x2204: {
    c: '\\2203\\338'
  },
  0x2206: {
    c: '\\394'
  },
  0x220C: {
    c: '\\220B\\338'
  },
  0x2216: {
    f: ''
  },
  0x2244: {
    c: '\\2243\\338'
  },
  0x2247: {
    c: '\\2246'
  },
  0x2249: {
    c: '\\2248\\338'
  },
  0x2262: {
    c: '\\2261\\338'
  },
  0x226D: {
    c: '\\224D\\338'
  },
  0x2274: {
    c: '\\2272\\338'
  },
  0x2275: {
    c: '\\2273\\338'
  },
  0x2278: {
    c: '\\2276\\338'
  },
  0x2279: {
    c: '\\2277\\338'
  },
  0x2284: {
    c: '\\2282\\338'
  },
  0x2285: {
    c: '\\2283\\338'
  },
  0x22E2: {
    c: '\\2291\\338'
  },
  0x22E3: {
    c: '\\2292\\338'
  },
  0x2305: {
    c: '\\22BC'
  },
  0x2306: {
    c: '\\2A5E'
  },
  0x231C: {
    c: '\\250C'
  },
  0x231D: {
    c: '\\2510'
  },
  0x231E: {
    c: '\\2514'
  },
  0x231F: {
    c: '\\2518'
  },
  0x2329: {
    c: '\\27E8'
  },
  0x232A: {
    c: '\\27E9'
  },
  0x25AA: {
    c: '\\25A0'
  },
  0x25B4: {
    c: '\\25B2'
  },
  0x25B5: {
    c: '\\25B3'
  },
  0x25B8: {
    c: '\\25B6'
  },
  0x25BE: {
    c: '\\25BC'
  },
  0x25BF: {
    c: '\\25BD'
  },
  0x25C2: {
    c: '\\25C0'
  },
  0x25FB: {
    c: '\\25A1'
  },
  0x25FC: {
    c: '\\25A0'
  },
  0x2758: {
    c: '\\2223'
  },
  0x29F8: {
    c: '/',
    f: 'I'
  },
  0x2A0C: {
    c: '\\222C\\222C'
  },
  0x2A2F: {
    c: '\\D7'
  },
  0x3008: {
    c: '\\27E8'
  },
  0x3009: {
    c: '\\27E9'
  },
  0x1D400: {
    c: 'A',
    f: 'B'
  },
  0x1D401: {
    c: 'B',
    f: 'B'
  },
  0x1D402: {
    c: 'C',
    f: 'B'
  },
  0x1D403: {
    c: 'D',
    f: 'B'
  },
  0x1D404: {
    c: 'E',
    f: 'B'
  },
  0x1D405: {
    c: 'F',
    f: 'B'
  },
  0x1D406: {
    c: 'G',
    f: 'B'
  },
  0x1D407: {
    c: 'H',
    f: 'B'
  },
  0x1D408: {
    c: 'I',
    f: 'B'
  },
  0x1D409: {
    c: 'J',
    f: 'B'
  },
  0x1D40A: {
    c: 'K',
    f: 'B'
  },
  0x1D40B: {
    c: 'L',
    f: 'B'
  },
  0x1D40C: {
    c: 'M',
    f: 'B'
  },
  0x1D40D: {
    c: 'N',
    f: 'B'
  },
  0x1D40E: {
    c: 'O',
    f: 'B'
  },
  0x1D40F: {
    c: 'P',
    f: 'B'
  },
  0x1D410: {
    c: 'Q',
    f: 'B'
  },
  0x1D411: {
    c: 'R',
    f: 'B'
  },
  0x1D412: {
    c: 'S',
    f: 'B'
  },
  0x1D413: {
    c: 'T',
    f: 'B'
  },
  0x1D414: {
    c: 'U',
    f: 'B'
  },
  0x1D415: {
    c: 'V',
    f: 'B'
  },
  0x1D416: {
    c: 'W',
    f: 'B'
  },
  0x1D417: {
    c: 'X',
    f: 'B'
  },
  0x1D418: {
    c: 'Y',
    f: 'B'
  },
  0x1D419: {
    c: 'Z',
    f: 'B'
  },
  0x1D41A: {
    c: 'a',
    f: 'B'
  },
  0x1D41B: {
    c: 'b',
    f: 'B'
  },
  0x1D41C: {
    c: 'c',
    f: 'B'
  },
  0x1D41D: {
    c: 'd',
    f: 'B'
  },
  0x1D41E: {
    c: 'e',
    f: 'B'
  },
  0x1D41F: {
    c: 'f',
    f: 'B'
  },
  0x1D420: {
    c: 'g',
    f: 'B'
  },
  0x1D421: {
    c: 'h',
    f: 'B'
  },
  0x1D422: {
    c: 'i',
    f: 'B'
  },
  0x1D423: {
    c: 'j',
    f: 'B'
  },
  0x1D424: {
    c: 'k',
    f: 'B'
  },
  0x1D425: {
    c: 'l',
    f: 'B'
  },
  0x1D426: {
    c: 'm',
    f: 'B'
  },
  0x1D427: {
    c: 'n',
    f: 'B'
  },
  0x1D428: {
    c: 'o',
    f: 'B'
  },
  0x1D429: {
    c: 'p',
    f: 'B'
  },
  0x1D42A: {
    c: 'q',
    f: 'B'
  },
  0x1D42B: {
    c: 'r',
    f: 'B'
  },
  0x1D42C: {
    c: 's',
    f: 'B'
  },
  0x1D42D: {
    c: 't',
    f: 'B'
  },
  0x1D42E: {
    c: 'u',
    f: 'B'
  },
  0x1D42F: {
    c: 'v',
    f: 'B'
  },
  0x1D430: {
    c: 'w',
    f: 'B'
  },
  0x1D431: {
    c: 'x',
    f: 'B'
  },
  0x1D432: {
    c: 'y',
    f: 'B'
  },
  0x1D433: {
    c: 'z',
    f: 'B'
  },
  0x1D434: {
    c: 'A',
    f: 'I'
  },
  0x1D435: {
    c: 'B',
    f: 'I'
  },
  0x1D436: {
    c: 'C',
    f: 'I'
  },
  0x1D437: {
    c: 'D',
    f: 'I'
  },
  0x1D438: {
    c: 'E',
    f: 'I'
  },
  0x1D439: {
    c: 'F',
    f: 'I'
  },
  0x1D43A: {
    c: 'G',
    f: 'I'
  },
  0x1D43B: {
    c: 'H',
    f: 'I'
  },
  0x1D43C: {
    c: 'I',
    f: 'I'
  },
  0x1D43D: {
    c: 'J',
    f: 'I'
  },
  0x1D43E: {
    c: 'K',
    f: 'I'
  },
  0x1D43F: {
    c: 'L',
    f: 'I'
  },
  0x1D440: {
    c: 'M',
    f: 'I'
  },
  0x1D441: {
    c: 'N',
    f: 'I'
  },
  0x1D442: {
    c: 'O',
    f: 'I'
  },
  0x1D443: {
    c: 'P',
    f: 'I'
  },
  0x1D444: {
    c: 'Q',
    f: 'I'
  },
  0x1D445: {
    c: 'R',
    f: 'I'
  },
  0x1D446: {
    c: 'S',
    f: 'I'
  },
  0x1D447: {
    c: 'T',
    f: 'I'
  },
  0x1D448: {
    c: 'U',
    f: 'I'
  },
  0x1D449: {
    c: 'V',
    f: 'I'
  },
  0x1D44A: {
    c: 'W',
    f: 'I'
  },
  0x1D44B: {
    c: 'X',
    f: 'I'
  },
  0x1D44C: {
    c: 'Y',
    f: 'I'
  },
  0x1D44D: {
    c: 'Z',
    f: 'I'
  },
  0x1D44E: {
    c: 'a',
    f: 'I'
  },
  0x1D44F: {
    c: 'b',
    f: 'I'
  },
  0x1D450: {
    c: 'c',
    f: 'I'
  },
  0x1D451: {
    c: 'd',
    f: 'I'
  },
  0x1D452: {
    c: 'e',
    f: 'I'
  },
  0x1D453: {
    c: 'f',
    f: 'I'
  },
  0x1D454: {
    c: 'g',
    f: 'I'
  },
  0x1D455: {
    c: 'h',
    f: 'I'
  },
  0x1D456: {
    c: 'i',
    f: 'I'
  },
  0x1D457: {
    c: 'j',
    f: 'I'
  },
  0x1D458: {
    c: 'k',
    f: 'I'
  },
  0x1D459: {
    c: 'l',
    f: 'I'
  },
  0x1D45A: {
    c: 'm',
    f: 'I'
  },
  0x1D45B: {
    c: 'n',
    f: 'I'
  },
  0x1D45C: {
    c: 'o',
    f: 'I'
  },
  0x1D45D: {
    c: 'p',
    f: 'I'
  },
  0x1D45E: {
    c: 'q',
    f: 'I'
  },
  0x1D45F: {
    c: 'r',
    f: 'I'
  },
  0x1D460: {
    c: 's',
    f: 'I'
  },
  0x1D461: {
    c: 't',
    f: 'I'
  },
  0x1D462: {
    c: 'u',
    f: 'I'
  },
  0x1D463: {
    c: 'v',
    f: 'I'
  },
  0x1D464: {
    c: 'w',
    f: 'I'
  },
  0x1D465: {
    c: 'x',
    f: 'I'
  },
  0x1D466: {
    c: 'y',
    f: 'I'
  },
  0x1D467: {
    c: 'z',
    f: 'I'
  },
  0x1D468: {
    c: 'A',
    f: 'BI'
  },
  0x1D469: {
    c: 'B',
    f: 'BI'
  },
  0x1D46A: {
    c: 'C',
    f: 'BI'
  },
  0x1D46B: {
    c: 'D',
    f: 'BI'
  },
  0x1D46C: {
    c: 'E',
    f: 'BI'
  },
  0x1D46D: {
    c: 'F',
    f: 'BI'
  },
  0x1D46E: {
    c: 'G',
    f: 'BI'
  },
  0x1D46F: {
    c: 'H',
    f: 'BI'
  },
  0x1D470: {
    c: 'I',
    f: 'BI'
  },
  0x1D471: {
    c: 'J',
    f: 'BI'
  },
  0x1D472: {
    c: 'K',
    f: 'BI'
  },
  0x1D473: {
    c: 'L',
    f: 'BI'
  },
  0x1D474: {
    c: 'M',
    f: 'BI'
  },
  0x1D475: {
    c: 'N',
    f: 'BI'
  },
  0x1D476: {
    c: 'O',
    f: 'BI'
  },
  0x1D477: {
    c: 'P',
    f: 'BI'
  },
  0x1D478: {
    c: 'Q',
    f: 'BI'
  },
  0x1D479: {
    c: 'R',
    f: 'BI'
  },
  0x1D47A: {
    c: 'S',
    f: 'BI'
  },
  0x1D47B: {
    c: 'T',
    f: 'BI'
  },
  0x1D47C: {
    c: 'U',
    f: 'BI'
  },
  0x1D47D: {
    c: 'V',
    f: 'BI'
  },
  0x1D47E: {
    c: 'W',
    f: 'BI'
  },
  0x1D47F: {
    c: 'X',
    f: 'BI'
  },
  0x1D480: {
    c: 'Y',
    f: 'BI'
  },
  0x1D481: {
    c: 'Z',
    f: 'BI'
  },
  0x1D482: {
    c: 'a',
    f: 'BI'
  },
  0x1D483: {
    c: 'b',
    f: 'BI'
  },
  0x1D484: {
    c: 'c',
    f: 'BI'
  },
  0x1D485: {
    c: 'd',
    f: 'BI'
  },
  0x1D486: {
    c: 'e',
    f: 'BI'
  },
  0x1D487: {
    c: 'f',
    f: 'BI'
  },
  0x1D488: {
    c: 'g',
    f: 'BI'
  },
  0x1D489: {
    c: 'h',
    f: 'BI'
  },
  0x1D48A: {
    c: 'i',
    f: 'BI'
  },
  0x1D48B: {
    c: 'j',
    f: 'BI'
  },
  0x1D48C: {
    c: 'k',
    f: 'BI'
  },
  0x1D48D: {
    c: 'l',
    f: 'BI'
  },
  0x1D48E: {
    c: 'm',
    f: 'BI'
  },
  0x1D48F: {
    c: 'n',
    f: 'BI'
  },
  0x1D490: {
    c: 'o',
    f: 'BI'
  },
  0x1D491: {
    c: 'p',
    f: 'BI'
  },
  0x1D492: {
    c: 'q',
    f: 'BI'
  },
  0x1D493: {
    c: 'r',
    f: 'BI'
  },
  0x1D494: {
    c: 's',
    f: 'BI'
  },
  0x1D495: {
    c: 't',
    f: 'BI'
  },
  0x1D496: {
    c: 'u',
    f: 'BI'
  },
  0x1D497: {
    c: 'v',
    f: 'BI'
  },
  0x1D498: {
    c: 'w',
    f: 'BI'
  },
  0x1D499: {
    c: 'x',
    f: 'BI'
  },
  0x1D49A: {
    c: 'y',
    f: 'BI'
  },
  0x1D49B: {
    c: 'z',
    f: 'BI'
  },
  0x1D49C: {
    c: 'A',
    f: 'SC'
  },
  0x1D49D: {
    c: 'B',
    f: 'SC'
  },
  0x1D49E: {
    c: 'C',
    f: 'SC'
  },
  0x1D49F: {
    c: 'D',
    f: 'SC'
  },
  0x1D4A0: {
    c: 'E',
    f: 'SC'
  },
  0x1D4A1: {
    c: 'F',
    f: 'SC'
  },
  0x1D4A2: {
    c: 'G',
    f: 'SC'
  },
  0x1D4A3: {
    c: 'H',
    f: 'SC'
  },
  0x1D4A4: {
    c: 'I',
    f: 'SC'
  },
  0x1D4A5: {
    c: 'J',
    f: 'SC'
  },
  0x1D4A6: {
    c: 'K',
    f: 'SC'
  },
  0x1D4A7: {
    c: 'L',
    f: 'SC'
  },
  0x1D4A8: {
    c: 'M',
    f: 'SC'
  },
  0x1D4A9: {
    c: 'N',
    f: 'SC'
  },
  0x1D4AA: {
    c: 'O',
    f: 'SC'
  },
  0x1D4AB: {
    c: 'P',
    f: 'SC'
  },
  0x1D4AC: {
    c: 'Q',
    f: 'SC'
  },
  0x1D4AD: {
    c: 'R',
    f: 'SC'
  },
  0x1D4AE: {
    c: 'S',
    f: 'SC'
  },
  0x1D4AF: {
    c: 'T',
    f: 'SC'
  },
  0x1D4B0: {
    c: 'U',
    f: 'SC'
  },
  0x1D4B1: {
    c: 'V',
    f: 'SC'
  },
  0x1D4B2: {
    c: 'W',
    f: 'SC'
  },
  0x1D4B3: {
    c: 'X',
    f: 'SC'
  },
  0x1D4B4: {
    c: 'Y',
    f: 'SC'
  },
  0x1D4B5: {
    c: 'Z',
    f: 'SC'
  },
  0x1D4B6: {
    c: 'a',
    f: 'I'
  },
  0x1D4B7: {
    c: 'b',
    f: 'I'
  },
  0x1D4B8: {
    c: 'c',
    f: 'I'
  },
  0x1D4B9: {
    c: 'd',
    f: 'I'
  },
  0x1D4BA: {
    c: 'e',
    f: 'I'
  },
  0x1D4BB: {
    c: 'f',
    f: 'I'
  },
  0x1D4BC: {
    c: 'g',
    f: 'I'
  },
  0x1D4BD: {
    c: 'h',
    f: 'I'
  },
  0x1D4BE: {
    c: 'i',
    f: 'I'
  },
  0x1D4BF: {
    c: 'j',
    f: 'I'
  },
  0x1D4C0: {
    c: 'k',
    f: 'I'
  },
  0x1D4C1: {
    c: 'l',
    f: 'I'
  },
  0x1D4C2: {
    c: 'm',
    f: 'I'
  },
  0x1D4C3: {
    c: 'n',
    f: 'I'
  },
  0x1D4C4: {
    c: 'o',
    f: 'I'
  },
  0x1D4C5: {
    c: 'p',
    f: 'I'
  },
  0x1D4C6: {
    c: 'q',
    f: 'I'
  },
  0x1D4C7: {
    c: 'r',
    f: 'I'
  },
  0x1D4C8: {
    c: 's',
    f: 'I'
  },
  0x1D4C9: {
    c: 't',
    f: 'I'
  },
  0x1D4CA: {
    c: 'u',
    f: 'I'
  },
  0x1D4CB: {
    c: 'v',
    f: 'I'
  },
  0x1D4CC: {
    c: 'w',
    f: 'I'
  },
  0x1D4CD: {
    c: 'x',
    f: 'I'
  },
  0x1D4CE: {
    c: 'y',
    f: 'I'
  },
  0x1D4CF: {
    c: 'z',
    f: 'I'
  },
  0x1D4D0: {
    c: 'A',
    f: 'SC'
  },
  0x1D4D1: {
    c: 'B',
    f: 'SC'
  },
  0x1D4D2: {
    c: 'C',
    f: 'SC'
  },
  0x1D4D3: {
    c: 'D',
    f: 'SC'
  },
  0x1D4D4: {
    c: 'E',
    f: 'SC'
  },
  0x1D4D5: {
    c: 'F',
    f: 'SC'
  },
  0x1D4D6: {
    c: 'G',
    f: 'SC'
  },
  0x1D4D7: {
    c: 'H',
    f: 'SC'
  },
  0x1D4D8: {
    c: 'I',
    f: 'SC'
  },
  0x1D4D9: {
    c: 'J',
    f: 'SC'
  },
  0x1D4DA: {
    c: 'K',
    f: 'SC'
  },
  0x1D4DB: {
    c: 'L',
    f: 'SC'
  },
  0x1D4DC: {
    c: 'M',
    f: 'SC'
  },
  0x1D4DD: {
    c: 'N',
    f: 'SC'
  },
  0x1D4DE: {
    c: 'O',
    f: 'SC'
  },
  0x1D4DF: {
    c: 'P',
    f: 'SC'
  },
  0x1D4E0: {
    c: 'Q',
    f: 'SC'
  },
  0x1D4E1: {
    c: 'R',
    f: 'SC'
  },
  0x1D4E2: {
    c: 'S',
    f: 'SC'
  },
  0x1D4E3: {
    c: 'T',
    f: 'SC'
  },
  0x1D4E4: {
    c: 'U',
    f: 'SC'
  },
  0x1D4E5: {
    c: 'V',
    f: 'SC'
  },
  0x1D4E6: {
    c: 'W',
    f: 'SC'
  },
  0x1D4E7: {
    c: 'X',
    f: 'SC'
  },
  0x1D4E8: {
    c: 'Y',
    f: 'SC'
  },
  0x1D4E9: {
    c: 'Z',
    f: 'SC'
  },
  0x1D4EA: {
    c: 'a',
    f: 'BI'
  },
  0x1D4EB: {
    c: 'b',
    f: 'BI'
  },
  0x1D4EC: {
    c: 'c',
    f: 'BI'
  },
  0x1D4ED: {
    c: 'd',
    f: 'BI'
  },
  0x1D4EE: {
    c: 'e',
    f: 'BI'
  },
  0x1D4EF: {
    c: 'f',
    f: 'BI'
  },
  0x1D4F0: {
    c: 'g',
    f: 'BI'
  },
  0x1D4F1: {
    c: 'h',
    f: 'BI'
  },
  0x1D4F2: {
    c: 'i',
    f: 'BI'
  },
  0x1D4F3: {
    c: 'j',
    f: 'BI'
  },
  0x1D4F4: {
    c: 'k',
    f: 'BI'
  },
  0x1D4F5: {
    c: 'l',
    f: 'BI'
  },
  0x1D4F6: {
    c: 'm',
    f: 'BI'
  },
  0x1D4F7: {
    c: 'n',
    f: 'BI'
  },
  0x1D4F8: {
    c: 'o',
    f: 'BI'
  },
  0x1D4F9: {
    c: 'p',
    f: 'BI'
  },
  0x1D4FA: {
    c: 'q',
    f: 'BI'
  },
  0x1D4FB: {
    c: 'r',
    f: 'BI'
  },
  0x1D4FC: {
    c: 's',
    f: 'BI'
  },
  0x1D4FD: {
    c: 't',
    f: 'BI'
  },
  0x1D4FE: {
    c: 'u',
    f: 'BI'
  },
  0x1D4FF: {
    c: 'v',
    f: 'BI'
  },
  0x1D500: {
    c: 'w',
    f: 'BI'
  },
  0x1D501: {
    c: 'x',
    f: 'BI'
  },
  0x1D502: {
    c: 'y',
    f: 'BI'
  },
  0x1D503: {
    c: 'z',
    f: 'BI'
  },
  0x1D504: {
    c: 'A',
    f: 'FR'
  },
  0x1D505: {
    c: 'B',
    f: 'FR'
  },
  0x1D506: {
    c: 'C',
    f: 'FR'
  },
  0x1D507: {
    c: 'D',
    f: 'FR'
  },
  0x1D508: {
    c: 'E',
    f: 'FR'
  },
  0x1D509: {
    c: 'F',
    f: 'FR'
  },
  0x1D50A: {
    c: 'G',
    f: 'FR'
  },
  0x1D50B: {
    c: 'H',
    f: 'FR'
  },
  0x1D50C: {
    c: 'I',
    f: 'FR'
  },
  0x1D50D: {
    c: 'J',
    f: 'FR'
  },
  0x1D50E: {
    c: 'K',
    f: 'FR'
  },
  0x1D50F: {
    c: 'L',
    f: 'FR'
  },
  0x1D510: {
    c: 'M',
    f: 'FR'
  },
  0x1D511: {
    c: 'N',
    f: 'FR'
  },
  0x1D512: {
    c: 'O',
    f: 'FR'
  },
  0x1D513: {
    c: 'P',
    f: 'FR'
  },
  0x1D514: {
    c: 'Q',
    f: 'FR'
  },
  0x1D515: {
    c: 'R',
    f: 'FR'
  },
  0x1D516: {
    c: 'S',
    f: 'FR'
  },
  0x1D517: {
    c: 'T',
    f: 'FR'
  },
  0x1D518: {
    c: 'U',
    f: 'FR'
  },
  0x1D519: {
    c: 'V',
    f: 'FR'
  },
  0x1D51A: {
    c: 'W',
    f: 'FR'
  },
  0x1D51B: {
    c: 'X',
    f: 'FR'
  },
  0x1D51C: {
    c: 'Y',
    f: 'FR'
  },
  0x1D51D: {
    c: 'Z',
    f: 'FR'
  },
  0x1D51E: {
    c: 'a',
    f: 'FR'
  },
  0x1D51F: {
    c: 'b',
    f: 'FR'
  },
  0x1D520: {
    c: 'c',
    f: 'FR'
  },
  0x1D521: {
    c: 'd',
    f: 'FR'
  },
  0x1D522: {
    c: 'e',
    f: 'FR'
  },
  0x1D523: {
    c: 'f',
    f: 'FR'
  },
  0x1D524: {
    c: 'g',
    f: 'FR'
  },
  0x1D525: {
    c: 'h',
    f: 'FR'
  },
  0x1D526: {
    c: 'i',
    f: 'FR'
  },
  0x1D527: {
    c: 'j',
    f: 'FR'
  },
  0x1D528: {
    c: 'k',
    f: 'FR'
  },
  0x1D529: {
    c: 'l',
    f: 'FR'
  },
  0x1D52A: {
    c: 'm',
    f: 'FR'
  },
  0x1D52B: {
    c: 'n',
    f: 'FR'
  },
  0x1D52C: {
    c: 'o',
    f: 'FR'
  },
  0x1D52D: {
    c: 'p',
    f: 'FR'
  },
  0x1D52E: {
    c: 'q',
    f: 'FR'
  },
  0x1D52F: {
    c: 'r',
    f: 'FR'
  },
  0x1D530: {
    c: 's',
    f: 'FR'
  },
  0x1D531: {
    c: 't',
    f: 'FR'
  },
  0x1D532: {
    c: 'u',
    f: 'FR'
  },
  0x1D533: {
    c: 'v',
    f: 'FR'
  },
  0x1D534: {
    c: 'w',
    f: 'FR'
  },
  0x1D535: {
    c: 'x',
    f: 'FR'
  },
  0x1D536: {
    c: 'y',
    f: 'FR'
  },
  0x1D537: {
    c: 'z',
    f: 'FR'
  },
  0x1D538: {
    c: 'A',
    f: 'A'
  },
  0x1D539: {
    c: 'B',
    f: 'A'
  },
  0x1D53A: {
    c: 'C',
    f: 'A'
  },
  0x1D53B: {
    c: 'D',
    f: 'A'
  },
  0x1D53C: {
    c: 'E',
    f: 'A'
  },
  0x1D53D: {
    c: 'F',
    f: 'A'
  },
  0x1D53E: {
    c: 'G',
    f: 'A'
  },
  0x1D53F: {
    c: 'H',
    f: 'A'
  },
  0x1D540: {
    c: 'I',
    f: 'A'
  },
  0x1D541: {
    c: 'J',
    f: 'A'
  },
  0x1D542: {
    c: 'K',
    f: 'A'
  },
  0x1D543: {
    c: 'L',
    f: 'A'
  },
  0x1D544: {
    c: 'M',
    f: 'A'
  },
  0x1D545: {
    c: 'N',
    f: 'A'
  },
  0x1D546: {
    c: 'O',
    f: 'A'
  },
  0x1D547: {
    c: 'P',
    f: 'A'
  },
  0x1D548: {
    c: 'Q',
    f: 'A'
  },
  0x1D549: {
    c: 'R',
    f: 'A'
  },
  0x1D54A: {
    c: 'S',
    f: 'A'
  },
  0x1D54B: {
    c: 'T',
    f: 'A'
  },
  0x1D54C: {
    c: 'U',
    f: 'A'
  },
  0x1D54D: {
    c: 'V',
    f: 'A'
  },
  0x1D54E: {
    c: 'W',
    f: 'A'
  },
  0x1D54F: {
    c: 'X',
    f: 'A'
  },
  0x1D550: {
    c: 'Y',
    f: 'A'
  },
  0x1D551: {
    c: 'Z',
    f: 'A'
  },
  0x1D552: {
    c: 'a',
    f: 'B'
  },
  0x1D553: {
    c: 'b',
    f: 'B'
  },
  0x1D554: {
    c: 'c',
    f: 'B'
  },
  0x1D555: {
    c: 'd',
    f: 'B'
  },
  0x1D556: {
    c: 'e',
    f: 'B'
  },
  0x1D557: {
    c: 'f',
    f: 'B'
  },
  0x1D558: {
    c: 'g',
    f: 'B'
  },
  0x1D559: {
    c: 'h',
    f: 'B'
  },
  0x1D55A: {
    c: 'i',
    f: 'B'
  },
  0x1D55B: {
    c: 'j',
    f: 'B'
  },
  0x1D55C: {
    c: 'k',
    f: 'A'
  },
  0x1D55D: {
    c: 'l',
    f: 'B'
  },
  0x1D55E: {
    c: 'm',
    f: 'B'
  },
  0x1D55F: {
    c: 'n',
    f: 'B'
  },
  0x1D560: {
    c: 'o',
    f: 'B'
  },
  0x1D561: {
    c: 'p',
    f: 'B'
  },
  0x1D562: {
    c: 'q',
    f: 'B'
  },
  0x1D563: {
    c: 'r',
    f: 'B'
  },
  0x1D564: {
    c: 's',
    f: 'B'
  },
  0x1D565: {
    c: 't',
    f: 'B'
  },
  0x1D566: {
    c: 'u',
    f: 'B'
  },
  0x1D567: {
    c: 'v',
    f: 'B'
  },
  0x1D568: {
    c: 'w',
    f: 'B'
  },
  0x1D569: {
    c: 'x',
    f: 'B'
  },
  0x1D56A: {
    c: 'y',
    f: 'B'
  },
  0x1D56B: {
    c: 'z',
    f: 'B'
  },
  0x1D56C: {
    c: 'A',
    f: 'FR-B'
  },
  0x1D56D: {
    c: 'B',
    f: 'FR-B'
  },
  0x1D56E: {
    c: 'C',
    f: 'FR-B'
  },
  0x1D56F: {
    c: 'D',
    f: 'FR-B'
  },
  0x1D570: {
    c: 'E',
    f: 'FR-B'
  },
  0x1D571: {
    c: 'F',
    f: 'FR-B'
  },
  0x1D572: {
    c: 'G',
    f: 'FR-B'
  },
  0x1D573: {
    c: 'H',
    f: 'FR-B'
  },
  0x1D574: {
    c: 'I',
    f: 'FR-B'
  },
  0x1D575: {
    c: 'J',
    f: 'FR-B'
  },
  0x1D576: {
    c: 'K',
    f: 'FR-B'
  },
  0x1D577: {
    c: 'L',
    f: 'FR-B'
  },
  0x1D578: {
    c: 'M',
    f: 'FR-B'
  },
  0x1D579: {
    c: 'N',
    f: 'FR-B'
  },
  0x1D57A: {
    c: 'O',
    f: 'FR-B'
  },
  0x1D57B: {
    c: 'P',
    f: 'FR-B'
  },
  0x1D57C: {
    c: 'Q',
    f: 'FR-B'
  },
  0x1D57D: {
    c: 'R',
    f: 'FR-B'
  },
  0x1D57E: {
    c: 'S',
    f: 'FR-B'
  },
  0x1D57F: {
    c: 'T',
    f: 'FR-B'
  },
  0x1D580: {
    c: 'U',
    f: 'FR-B'
  },
  0x1D581: {
    c: 'V',
    f: 'FR-B'
  },
  0x1D582: {
    c: 'W',
    f: 'FR-B'
  },
  0x1D583: {
    c: 'X',
    f: 'FR-B'
  },
  0x1D584: {
    c: 'Y',
    f: 'FR-B'
  },
  0x1D585: {
    c: 'Z',
    f: 'FR-B'
  },
  0x1D586: {
    c: 'a',
    f: 'FR-B'
  },
  0x1D587: {
    c: 'b',
    f: 'FR-B'
  },
  0x1D588: {
    c: 'c',
    f: 'FR-B'
  },
  0x1D589: {
    c: 'd',
    f: 'FR-B'
  },
  0x1D58A: {
    c: 'e',
    f: 'FR-B'
  },
  0x1D58B: {
    c: 'f',
    f: 'FR-B'
  },
  0x1D58C: {
    c: 'g',
    f: 'FR-B'
  },
  0x1D58D: {
    c: 'h',
    f: 'FR-B'
  },
  0x1D58E: {
    c: 'i',
    f: 'FR-B'
  },
  0x1D58F: {
    c: 'j',
    f: 'FR-B'
  },
  0x1D590: {
    c: 'k',
    f: 'FR-B'
  },
  0x1D591: {
    c: 'l',
    f: 'FR-B'
  },
  0x1D592: {
    c: 'm',
    f: 'FR-B'
  },
  0x1D593: {
    c: 'n',
    f: 'FR-B'
  },
  0x1D594: {
    c: 'o',
    f: 'FR-B'
  },
  0x1D595: {
    c: 'p',
    f: 'FR-B'
  },
  0x1D596: {
    c: 'q',
    f: 'FR-B'
  },
  0x1D597: {
    c: 'r',
    f: 'FR-B'
  },
  0x1D598: {
    c: 's',
    f: 'FR-B'
  },
  0x1D599: {
    c: 't',
    f: 'FR-B'
  },
  0x1D59A: {
    c: 'u',
    f: 'FR-B'
  },
  0x1D59B: {
    c: 'v',
    f: 'FR-B'
  },
  0x1D59C: {
    c: 'w',
    f: 'FR-B'
  },
  0x1D59D: {
    c: 'x',
    f: 'FR-B'
  },
  0x1D59E: {
    c: 'y',
    f: 'FR-B'
  },
  0x1D59F: {
    c: 'z',
    f: 'FR-B'
  },
  0x1D5A0: {
    c: 'A',
    f: 'SS'
  },
  0x1D5A1: {
    c: 'B',
    f: 'SS'
  },
  0x1D5A2: {
    c: 'C',
    f: 'SS'
  },
  0x1D5A3: {
    c: 'D',
    f: 'SS'
  },
  0x1D5A4: {
    c: 'E',
    f: 'SS'
  },
  0x1D5A5: {
    c: 'F',
    f: 'SS'
  },
  0x1D5A6: {
    c: 'G',
    f: 'SS'
  },
  0x1D5A7: {
    c: 'H',
    f: 'SS'
  },
  0x1D5A8: {
    c: 'I',
    f: 'SS'
  },
  0x1D5A9: {
    c: 'J',
    f: 'SS'
  },
  0x1D5AA: {
    c: 'K',
    f: 'SS'
  },
  0x1D5AB: {
    c: 'L',
    f: 'SS'
  },
  0x1D5AC: {
    c: 'M',
    f: 'SS'
  },
  0x1D5AD: {
    c: 'N',
    f: 'SS'
  },
  0x1D5AE: {
    c: 'O',
    f: 'SS'
  },
  0x1D5AF: {
    c: 'P',
    f: 'SS'
  },
  0x1D5B0: {
    c: 'Q',
    f: 'SS'
  },
  0x1D5B1: {
    c: 'R',
    f: 'SS'
  },
  0x1D5B2: {
    c: 'S',
    f: 'SS'
  },
  0x1D5B3: {
    c: 'T',
    f: 'SS'
  },
  0x1D5B4: {
    c: 'U',
    f: 'SS'
  },
  0x1D5B5: {
    c: 'V',
    f: 'SS'
  },
  0x1D5B6: {
    c: 'W',
    f: 'SS'
  },
  0x1D5B7: {
    c: 'X',
    f: 'SS'
  },
  0x1D5B8: {
    c: 'Y',
    f: 'SS'
  },
  0x1D5B9: {
    c: 'Z',
    f: 'SS'
  },
  0x1D5BA: {
    c: 'a',
    f: 'SS'
  },
  0x1D5BB: {
    c: 'b',
    f: 'SS'
  },
  0x1D5BC: {
    c: 'c',
    f: 'SS'
  },
  0x1D5BD: {
    c: 'd',
    f: 'SS'
  },
  0x1D5BE: {
    c: 'e',
    f: 'SS'
  },
  0x1D5BF: {
    c: 'f',
    f: 'SS'
  },
  0x1D5C0: {
    c: 'g',
    f: 'SS'
  },
  0x1D5C1: {
    c: 'h',
    f: 'SS'
  },
  0x1D5C2: {
    c: 'i',
    f: 'SS'
  },
  0x1D5C3: {
    c: 'j',
    f: 'SS'
  },
  0x1D5C4: {
    c: 'k',
    f: 'SS'
  },
  0x1D5C5: {
    c: 'l',
    f: 'SS'
  },
  0x1D5C6: {
    c: 'm',
    f: 'SS'
  },
  0x1D5C7: {
    c: 'n',
    f: 'SS'
  },
  0x1D5C8: {
    c: 'o',
    f: 'SS'
  },
  0x1D5C9: {
    c: 'p',
    f: 'SS'
  },
  0x1D5CA: {
    c: 'q',
    f: 'SS'
  },
  0x1D5CB: {
    c: 'r',
    f: 'SS'
  },
  0x1D5CC: {
    c: 's',
    f: 'SS'
  },
  0x1D5CD: {
    c: 't',
    f: 'SS'
  },
  0x1D5CE: {
    c: 'u',
    f: 'SS'
  },
  0x1D5CF: {
    c: 'v',
    f: 'SS'
  },
  0x1D5D0: {
    c: 'w',
    f: 'SS'
  },
  0x1D5D1: {
    c: 'x',
    f: 'SS'
  },
  0x1D5D2: {
    c: 'y',
    f: 'SS'
  },
  0x1D5D3: {
    c: 'z',
    f: 'SS'
  },
  0x1D5D4: {
    c: 'A',
    f: 'SS-B'
  },
  0x1D5D5: {
    c: 'B',
    f: 'SS-B'
  },
  0x1D5D6: {
    c: 'C',
    f: 'SS-B'
  },
  0x1D5D7: {
    c: 'D',
    f: 'SS-B'
  },
  0x1D5D8: {
    c: 'E',
    f: 'SS-B'
  },
  0x1D5D9: {
    c: 'F',
    f: 'SS-B'
  },
  0x1D5DA: {
    c: 'G',
    f: 'SS-B'
  },
  0x1D5DB: {
    c: 'H',
    f: 'SS-B'
  },
  0x1D5DC: {
    c: 'I',
    f: 'SS-B'
  },
  0x1D5DD: {
    c: 'J',
    f: 'SS-B'
  },
  0x1D5DE: {
    c: 'K',
    f: 'SS-B'
  },
  0x1D5DF: {
    c: 'L',
    f: 'SS-B'
  },
  0x1D5E0: {
    c: 'M',
    f: 'SS-B'
  },
  0x1D5E1: {
    c: 'N',
    f: 'SS-B'
  },
  0x1D5E2: {
    c: 'O',
    f: 'SS-B'
  },
  0x1D5E3: {
    c: 'P',
    f: 'SS-B'
  },
  0x1D5E4: {
    c: 'Q',
    f: 'SS-B'
  },
  0x1D5E5: {
    c: 'R',
    f: 'SS-B'
  },
  0x1D5E6: {
    c: 'S',
    f: 'SS-B'
  },
  0x1D5E7: {
    c: 'T',
    f: 'SS-B'
  },
  0x1D5E8: {
    c: 'U',
    f: 'SS-B'
  },
  0x1D5E9: {
    c: 'V',
    f: 'SS-B'
  },
  0x1D5EA: {
    c: 'W',
    f: 'SS-B'
  },
  0x1D5EB: {
    c: 'X',
    f: 'SS-B'
  },
  0x1D5EC: {
    c: 'Y',
    f: 'SS-B'
  },
  0x1D5ED: {
    c: 'Z',
    f: 'SS-B'
  },
  0x1D5EE: {
    c: 'a',
    f: 'SS-B'
  },
  0x1D5EF: {
    c: 'b',
    f: 'SS-B'
  },
  0x1D5F0: {
    c: 'c',
    f: 'SS-B'
  },
  0x1D5F1: {
    c: 'd',
    f: 'SS-B'
  },
  0x1D5F2: {
    c: 'e',
    f: 'SS-B'
  },
  0x1D5F3: {
    c: 'f',
    f: 'SS-B'
  },
  0x1D5F4: {
    c: 'g',
    f: 'SS-B'
  },
  0x1D5F5: {
    c: 'h',
    f: 'SS-B'
  },
  0x1D5F6: {
    c: 'i',
    f: 'SS-B'
  },
  0x1D5F7: {
    c: 'j',
    f: 'SS-B'
  },
  0x1D5F8: {
    c: 'k',
    f: 'SS-B'
  },
  0x1D5F9: {
    c: 'l',
    f: 'SS-B'
  },
  0x1D5FA: {
    c: 'm',
    f: 'SS-B'
  },
  0x1D5FB: {
    c: 'n',
    f: 'SS-B'
  },
  0x1D5FC: {
    c: 'o',
    f: 'SS-B'
  },
  0x1D5FD: {
    c: 'p',
    f: 'SS-B'
  },
  0x1D5FE: {
    c: 'q',
    f: 'SS-B'
  },
  0x1D5FF: {
    c: 'r',
    f: 'SS-B'
  },
  0x1D600: {
    c: 's',
    f: 'SS-B'
  },
  0x1D601: {
    c: 't',
    f: 'SS-B'
  },
  0x1D602: {
    c: 'u',
    f: 'SS-B'
  },
  0x1D603: {
    c: 'v',
    f: 'SS-B'
  },
  0x1D604: {
    c: 'w',
    f: 'SS-B'
  },
  0x1D605: {
    c: 'x',
    f: 'SS-B'
  },
  0x1D606: {
    c: 'y',
    f: 'SS-B'
  },
  0x1D607: {
    c: 'z',
    f: 'SS-B'
  },
  0x1D608: {
    c: 'A',
    f: 'SS-I'
  },
  0x1D609: {
    c: 'B',
    f: 'SS-I'
  },
  0x1D60A: {
    c: 'C',
    f: 'SS-I'
  },
  0x1D60B: {
    c: 'D',
    f: 'SS-I'
  },
  0x1D60C: {
    c: 'E',
    f: 'SS-I'
  },
  0x1D60D: {
    c: 'F',
    f: 'SS-I'
  },
  0x1D60E: {
    c: 'G',
    f: 'SS-I'
  },
  0x1D60F: {
    c: 'H',
    f: 'SS-I'
  },
  0x1D610: {
    c: 'I',
    f: 'SS-I'
  },
  0x1D611: {
    c: 'J',
    f: 'SS-I'
  },
  0x1D612: {
    c: 'K',
    f: 'SS-I'
  },
  0x1D613: {
    c: 'L',
    f: 'SS-I'
  },
  0x1D614: {
    c: 'M',
    f: 'SS-I'
  },
  0x1D615: {
    c: 'N',
    f: 'SS-I'
  },
  0x1D616: {
    c: 'O',
    f: 'SS-I'
  },
  0x1D617: {
    c: 'P',
    f: 'SS-I'
  },
  0x1D618: {
    c: 'Q',
    f: 'SS-I'
  },
  0x1D619: {
    c: 'R',
    f: 'SS-I'
  },
  0x1D61A: {
    c: 'S',
    f: 'SS-I'
  },
  0x1D61B: {
    c: 'T',
    f: 'SS-I'
  },
  0x1D61C: {
    c: 'U',
    f: 'SS-I'
  },
  0x1D61D: {
    c: 'V',
    f: 'SS-I'
  },
  0x1D61E: {
    c: 'W',
    f: 'SS-I'
  },
  0x1D61F: {
    c: 'X',
    f: 'SS-I'
  },
  0x1D620: {
    c: 'Y',
    f: 'SS-I'
  },
  0x1D621: {
    c: 'Z',
    f: 'SS-I'
  },
  0x1D622: {
    c: 'a',
    f: 'SS-I'
  },
  0x1D623: {
    c: 'b',
    f: 'SS-I'
  },
  0x1D624: {
    c: 'c',
    f: 'SS-I'
  },
  0x1D625: {
    c: 'd',
    f: 'SS-I'
  },
  0x1D626: {
    c: 'e',
    f: 'SS-I'
  },
  0x1D627: {
    c: 'f',
    f: 'SS-I'
  },
  0x1D628: {
    c: 'g',
    f: 'SS-I'
  },
  0x1D629: {
    c: 'h',
    f: 'SS-I'
  },
  0x1D62A: {
    c: 'i',
    f: 'SS-I'
  },
  0x1D62B: {
    c: 'j',
    f: 'SS-I'
  },
  0x1D62C: {
    c: 'k',
    f: 'SS-I'
  },
  0x1D62D: {
    c: 'l',
    f: 'SS-I'
  },
  0x1D62E: {
    c: 'm',
    f: 'SS-I'
  },
  0x1D62F: {
    c: 'n',
    f: 'SS-I'
  },
  0x1D630: {
    c: 'o',
    f: 'SS-I'
  },
  0x1D631: {
    c: 'p',
    f: 'SS-I'
  },
  0x1D632: {
    c: 'q',
    f: 'SS-I'
  },
  0x1D633: {
    c: 'r',
    f: 'SS-I'
  },
  0x1D634: {
    c: 's',
    f: 'SS-I'
  },
  0x1D635: {
    c: 't',
    f: 'SS-I'
  },
  0x1D636: {
    c: 'u',
    f: 'SS-I'
  },
  0x1D637: {
    c: 'v',
    f: 'SS-I'
  },
  0x1D638: {
    c: 'w',
    f: 'SS-I'
  },
  0x1D639: {
    c: 'x',
    f: 'SS-I'
  },
  0x1D63A: {
    c: 'y',
    f: 'SS-I'
  },
  0x1D63B: {
    c: 'z',
    f: 'SS-I'
  },
  0x1D63C: {
    c: 'A',
    f: 'SS-I'
  },
  0x1D63D: {
    c: 'B',
    f: 'SS-I'
  },
  0x1D63E: {
    c: 'C',
    f: 'SS-I'
  },
  0x1D63F: {
    c: 'D',
    f: 'SS-I'
  },
  0x1D640: {
    c: 'E',
    f: 'SS-I'
  },
  0x1D641: {
    c: 'F',
    f: 'SS-I'
  },
  0x1D642: {
    c: 'G',
    f: 'SS-I'
  },
  0x1D643: {
    c: 'H',
    f: 'SS-I'
  },
  0x1D644: {
    c: 'I',
    f: 'SS-I'
  },
  0x1D645: {
    c: 'J',
    f: 'SS-I'
  },
  0x1D646: {
    c: 'K',
    f: 'SS-I'
  },
  0x1D647: {
    c: 'L',
    f: 'SS-I'
  },
  0x1D648: {
    c: 'M',
    f: 'SS-I'
  },
  0x1D649: {
    c: 'N',
    f: 'SS-I'
  },
  0x1D64A: {
    c: 'O',
    f: 'SS-I'
  },
  0x1D64B: {
    c: 'P',
    f: 'SS-I'
  },
  0x1D64C: {
    c: 'Q',
    f: 'SS-I'
  },
  0x1D64D: {
    c: 'R',
    f: 'SS-I'
  },
  0x1D64E: {
    c: 'S',
    f: 'SS-I'
  },
  0x1D64F: {
    c: 'T',
    f: 'SS-I'
  },
  0x1D650: {
    c: 'U',
    f: 'SS-I'
  },
  0x1D651: {
    c: 'V',
    f: 'SS-I'
  },
  0x1D652: {
    c: 'W',
    f: 'SS-I'
  },
  0x1D653: {
    c: 'X',
    f: 'SS-I'
  },
  0x1D654: {
    c: 'Y',
    f: 'SS-I'
  },
  0x1D655: {
    c: 'Z',
    f: 'SS-I'
  },
  0x1D656: {
    c: 'a',
    f: 'SS-I'
  },
  0x1D657: {
    c: 'b',
    f: 'SS-I'
  },
  0x1D658: {
    c: 'c',
    f: 'SS-I'
  },
  0x1D659: {
    c: 'd',
    f: 'SS-I'
  },
  0x1D65A: {
    c: 'e',
    f: 'SS-I'
  },
  0x1D65B: {
    c: 'f',
    f: 'SS-I'
  },
  0x1D65C: {
    c: 'g',
    f: 'SS-I'
  },
  0x1D65D: {
    c: 'h',
    f: 'SS-I'
  },
  0x1D65E: {
    c: 'i',
    f: 'SS-I'
  },
  0x1D65F: {
    c: 'j',
    f: 'SS-I'
  },
  0x1D660: {
    c: 'k',
    f: 'SS-I'
  },
  0x1D661: {
    c: 'l',
    f: 'SS-I'
  },
  0x1D662: {
    c: 'm',
    f: 'SS-I'
  },
  0x1D663: {
    c: 'n',
    f: 'SS-I'
  },
  0x1D664: {
    c: 'o',
    f: 'SS-I'
  },
  0x1D665: {
    c: 'p',
    f: 'SS-I'
  },
  0x1D666: {
    c: 'q',
    f: 'SS-I'
  },
  0x1D667: {
    c: 'r',
    f: 'SS-I'
  },
  0x1D668: {
    c: 's',
    f: 'SS-I'
  },
  0x1D669: {
    c: 't',
    f: 'SS-I'
  },
  0x1D66A: {
    c: 'u',
    f: 'SS-I'
  },
  0x1D66B: {
    c: 'v',
    f: 'SS-I'
  },
  0x1D66C: {
    c: 'w',
    f: 'SS-I'
  },
  0x1D66D: {
    c: 'x',
    f: 'SS-I'
  },
  0x1D66E: {
    c: 'y',
    f: 'SS-I'
  },
  0x1D66F: {
    c: 'z',
    f: 'SS-I'
  },
  0x1D670: {
    c: 'A',
    f: 'T'
  },
  0x1D671: {
    c: 'B',
    f: 'T'
  },
  0x1D672: {
    c: 'C',
    f: 'T'
  },
  0x1D673: {
    c: 'D',
    f: 'T'
  },
  0x1D674: {
    c: 'E',
    f: 'T'
  },
  0x1D675: {
    c: 'F',
    f: 'T'
  },
  0x1D676: {
    c: 'G',
    f: 'T'
  },
  0x1D677: {
    c: 'H',
    f: 'T'
  },
  0x1D678: {
    c: 'I',
    f: 'T'
  },
  0x1D679: {
    c: 'J',
    f: 'T'
  },
  0x1D67A: {
    c: 'K',
    f: 'T'
  },
  0x1D67B: {
    c: 'L',
    f: 'T'
  },
  0x1D67C: {
    c: 'M',
    f: 'T'
  },
  0x1D67D: {
    c: 'N',
    f: 'T'
  },
  0x1D67E: {
    c: 'O',
    f: 'T'
  },
  0x1D67F: {
    c: 'P',
    f: 'T'
  },
  0x1D680: {
    c: 'Q',
    f: 'T'
  },
  0x1D681: {
    c: 'R',
    f: 'T'
  },
  0x1D682: {
    c: 'S',
    f: 'T'
  },
  0x1D683: {
    c: 'T',
    f: 'T'
  },
  0x1D684: {
    c: 'U',
    f: 'T'
  },
  0x1D685: {
    c: 'V',
    f: 'T'
  },
  0x1D686: {
    c: 'W',
    f: 'T'
  },
  0x1D687: {
    c: 'X',
    f: 'T'
  },
  0x1D688: {
    c: 'Y',
    f: 'T'
  },
  0x1D689: {
    c: 'Z',
    f: 'T'
  },
  0x1D68A: {
    c: 'a',
    f: 'T'
  },
  0x1D68B: {
    c: 'b',
    f: 'T'
  },
  0x1D68C: {
    c: 'c',
    f: 'T'
  },
  0x1D68D: {
    c: 'd',
    f: 'T'
  },
  0x1D68E: {
    c: 'e',
    f: 'T'
  },
  0x1D68F: {
    c: 'f',
    f: 'T'
  },
  0x1D690: {
    c: 'g',
    f: 'T'
  },
  0x1D691: {
    c: 'h',
    f: 'T'
  },
  0x1D692: {
    c: 'i',
    f: 'T'
  },
  0x1D693: {
    c: 'j',
    f: 'T'
  },
  0x1D694: {
    c: 'k',
    f: 'T'
  },
  0x1D695: {
    c: 'l',
    f: 'T'
  },
  0x1D696: {
    c: 'm',
    f: 'T'
  },
  0x1D697: {
    c: 'n',
    f: 'T'
  },
  0x1D698: {
    c: 'o',
    f: 'T'
  },
  0x1D699: {
    c: 'p',
    f: 'T'
  },
  0x1D69A: {
    c: 'q',
    f: 'T'
  },
  0x1D69B: {
    c: 'r',
    f: 'T'
  },
  0x1D69C: {
    c: 's',
    f: 'T'
  },
  0x1D69D: {
    c: 't',
    f: 'T'
  },
  0x1D69E: {
    c: 'u',
    f: 'T'
  },
  0x1D69F: {
    c: 'v',
    f: 'T'
  },
  0x1D6A0: {
    c: 'w',
    f: 'T'
  },
  0x1D6A1: {
    c: 'x',
    f: 'T'
  },
  0x1D6A2: {
    c: 'y',
    f: 'T'
  },
  0x1D6A3: {
    c: 'z',
    f: 'T'
  },
  0x1D6A4: {
    c: '\\131',
    f: 'MI'
  },
  0x1D6A5: {
    c: '\\237',
    f: 'MI'
  },
  0x1D6A8: {
    c: 'A',
    f: 'B'
  },
  0x1D6A9: {
    c: 'B',
    f: 'B'
  },
  0x1D6AA: {
    c: '\\393',
    f: 'B'
  },
  0x1D6AB: {
    c: '\\394',
    f: 'B'
  },
  0x1D6AC: {
    c: 'E',
    f: 'B'
  },
  0x1D6AD: {
    c: 'Z',
    f: 'B'
  },
  0x1D6AE: {
    c: 'H',
    f: 'B'
  },
  0x1D6AF: {
    c: '\\398',
    f: 'B'
  },
  0x1D6B0: {
    c: 'I',
    f: 'B'
  },
  0x1D6B1: {
    c: 'K',
    f: 'B'
  },
  0x1D6B2: {
    c: '\\39B',
    f: 'B'
  },
  0x1D6B3: {
    c: 'M',
    f: 'B'
  },
  0x1D6B4: {
    c: 'N',
    f: 'B'
  },
  0x1D6B5: {
    c: '\\39E',
    f: 'B'
  },
  0x1D6B6: {
    c: 'O',
    f: 'B'
  },
  0x1D6B7: {
    c: '\\3A0',
    f: 'B'
  },
  0x1D6B8: {
    c: 'P',
    f: 'B'
  },
  0x1D6B9: {
    c: '\\398',
    f: 'B'
  },
  0x1D6BA: {
    c: '\\3A3',
    f: 'B'
  },
  0x1D6BB: {
    c: 'T',
    f: 'B'
  },
  0x1D6BC: {
    c: '\\3A5',
    f: 'B'
  },
  0x1D6BD: {
    c: '\\3A6',
    f: 'B'
  },
  0x1D6BE: {
    c: 'X',
    f: 'B'
  },
  0x1D6BF: {
    c: '\\3A8',
    f: 'B'
  },
  0x1D6C0: {
    c: '\\3A9',
    f: 'B'
  },
  0x1D6C1: {
    c: '\\2207',
    f: 'B'
  },
  0x1D6C2: {
    c: '\\3B1',
    f: 'BI'
  },
  0x1D6C3: {
    c: '\\3B2',
    f: 'BI'
  },
  0x1D6C4: {
    c: '\\3B3',
    f: 'BI'
  },
  0x1D6C5: {
    c: '\\3B4',
    f: 'BI'
  },
  0x1D6C6: {
    c: '\\3B5',
    f: 'BI'
  },
  0x1D6C7: {
    c: '\\3B6',
    f: 'BI'
  },
  0x1D6C8: {
    c: '\\3B7',
    f: 'BI'
  },
  0x1D6C9: {
    c: '\\3B8',
    f: 'BI'
  },
  0x1D6CA: {
    c: '\\3B9',
    f: 'BI'
  },
  0x1D6CB: {
    c: '\\3BA',
    f: 'BI'
  },
  0x1D6CC: {
    c: '\\3BB',
    f: 'BI'
  },
  0x1D6CD: {
    c: '\\3BC',
    f: 'BI'
  },
  0x1D6CE: {
    c: '\\3BD',
    f: 'BI'
  },
  0x1D6CF: {
    c: '\\3BE',
    f: 'BI'
  },
  0x1D6D0: {
    c: '\\3BF',
    f: 'BI'
  },
  0x1D6D1: {
    c: '\\3C0',
    f: 'BI'
  },
  0x1D6D2: {
    c: '\\3C1',
    f: 'BI'
  },
  0x1D6D3: {
    c: '\\3C2',
    f: 'BI'
  },
  0x1D6D4: {
    c: '\\3C3',
    f: 'BI'
  },
  0x1D6D5: {
    c: '\\3C4',
    f: 'BI'
  },
  0x1D6D6: {
    c: '\\3C5',
    f: 'BI'
  },
  0x1D6D7: {
    c: '\\3C6',
    f: 'BI'
  },
  0x1D6D8: {
    c: '\\3C7',
    f: 'BI'
  },
  0x1D6D9: {
    c: '\\3C8',
    f: 'BI'
  },
  0x1D6DA: {
    c: '\\3C9',
    f: 'BI'
  },
  0x1D6DB: {
    c: '\\2202',
    f: 'BI'
  },
  0x1D6DC: {
    c: '\\3F5',
    f: 'BI'
  },
  0x1D6DD: {
    c: '\\3D1',
    f: 'BI'
  },
  0x1D6DE: {
    c: '\\E009',
    f: 'A'
  },
  0x1D6DF: {
    c: '\\3D5',
    f: 'BI'
  },
  0x1D6E0: {
    c: '\\3F1',
    f: 'BI'
  },
  0x1D6E1: {
    c: '\\3D6',
    f: 'BI'
  },
  0x1D6E2: {
    c: 'A',
    f: 'I'
  },
  0x1D6E3: {
    c: 'B',
    f: 'I'
  },
  0x1D6E4: {
    c: '\\393',
    f: 'I'
  },
  0x1D6E5: {
    c: '\\394',
    f: 'I'
  },
  0x1D6E6: {
    c: 'E',
    f: 'I'
  },
  0x1D6E7: {
    c: 'Z',
    f: 'I'
  },
  0x1D6E8: {
    c: 'H',
    f: 'I'
  },
  0x1D6E9: {
    c: '\\398',
    f: 'I'
  },
  0x1D6EA: {
    c: 'I',
    f: 'I'
  },
  0x1D6EB: {
    c: 'K',
    f: 'I'
  },
  0x1D6EC: {
    c: '\\39B',
    f: 'I'
  },
  0x1D6ED: {
    c: 'M',
    f: 'I'
  },
  0x1D6EE: {
    c: 'N',
    f: 'I'
  },
  0x1D6EF: {
    c: '\\39E',
    f: 'I'
  },
  0x1D6F0: {
    c: 'O',
    f: 'I'
  },
  0x1D6F1: {
    c: '\\3A0',
    f: 'I'
  },
  0x1D6F2: {
    c: 'P',
    f: 'I'
  },
  0x1D6F3: {
    c: '\\398',
    f: 'I'
  },
  0x1D6F4: {
    c: '\\3A3',
    f: 'I'
  },
  0x1D6F5: {
    c: 'T',
    f: 'I'
  },
  0x1D6F6: {
    c: '\\3A5',
    f: 'I'
  },
  0x1D6F7: {
    c: '\\3A6',
    f: 'I'
  },
  0x1D6F8: {
    c: 'X',
    f: 'I'
  },
  0x1D6F9: {
    c: '\\3A8',
    f: 'I'
  },
  0x1D6FA: {
    c: '\\3A9',
    f: 'I'
  },
  0x1D6FB: {
    c: '\\2207',
    f: ''
  },
  0x1D6FC: {
    c: '\\3B1',
    f: 'I'
  },
  0x1D6FD: {
    c: '\\3B2',
    f: 'I'
  },
  0x1D6FE: {
    c: '\\3B3',
    f: 'I'
  },
  0x1D6FF: {
    c: '\\3B4',
    f: 'I'
  },
  0x1D700: {
    c: '\\3B5',
    f: 'I'
  },
  0x1D701: {
    c: '\\3B6',
    f: 'I'
  },
  0x1D702: {
    c: '\\3B7',
    f: 'I'
  },
  0x1D703: {
    c: '\\3B8',
    f: 'I'
  },
  0x1D704: {
    c: '\\3B9',
    f: 'I'
  },
  0x1D705: {
    c: '\\3BA',
    f: 'I'
  },
  0x1D706: {
    c: '\\3BB',
    f: 'I'
  },
  0x1D707: {
    c: '\\3BC',
    f: 'I'
  },
  0x1D708: {
    c: '\\3BD',
    f: 'I'
  },
  0x1D709: {
    c: '\\3BE',
    f: 'I'
  },
  0x1D70A: {
    c: '\\3BF',
    f: 'I'
  },
  0x1D70B: {
    c: '\\3C0',
    f: 'I'
  },
  0x1D70C: {
    c: '\\3C1',
    f: 'I'
  },
  0x1D70D: {
    c: '\\3C2',
    f: 'I'
  },
  0x1D70E: {
    c: '\\3C3',
    f: 'I'
  },
  0x1D70F: {
    c: '\\3C4',
    f: 'I'
  },
  0x1D710: {
    c: '\\3C5',
    f: 'I'
  },
  0x1D711: {
    c: '\\3C6',
    f: 'I'
  },
  0x1D712: {
    c: '\\3C7',
    f: 'I'
  },
  0x1D713: {
    c: '\\3C8',
    f: 'I'
  },
  0x1D714: {
    c: '\\3C9',
    f: 'I'
  },
  0x1D715: {
    c: '\\2202',
    f: ''
  },
  0x1D716: {
    c: '\\3F5',
    f: 'I'
  },
  0x1D717: {
    c: '\\3D1',
    f: 'I'
  },
  0x1D718: {
    c: '\\E009',
    f: 'A'
  },
  0x1D719: {
    c: '\\3D5',
    f: 'I'
  },
  0x1D71A: {
    c: '\\3F1',
    f: 'I'
  },
  0x1D71B: {
    c: '\\3D6',
    f: 'I'
  },
  0x1D71C: {
    c: 'A',
    f: 'BI'
  },
  0x1D71D: {
    c: 'B',
    f: 'BI'
  },
  0x1D71E: {
    c: '\\393',
    f: 'BI'
  },
  0x1D71F: {
    c: '\\394',
    f: 'BI'
  },
  0x1D720: {
    c: 'E',
    f: 'BI'
  },
  0x1D721: {
    c: 'Z',
    f: 'BI'
  },
  0x1D722: {
    c: 'H',
    f: 'BI'
  },
  0x1D723: {
    c: '\\398',
    f: 'BI'
  },
  0x1D724: {
    c: 'I',
    f: 'BI'
  },
  0x1D725: {
    c: 'K',
    f: 'BI'
  },
  0x1D726: {
    c: '\\39B',
    f: 'BI'
  },
  0x1D727: {
    c: 'M',
    f: 'BI'
  },
  0x1D728: {
    c: 'N',
    f: 'BI'
  },
  0x1D729: {
    c: '\\39E',
    f: 'BI'
  },
  0x1D72A: {
    c: 'O',
    f: 'BI'
  },
  0x1D72B: {
    c: '\\3A0',
    f: 'BI'
  },
  0x1D72C: {
    c: 'P',
    f: 'BI'
  },
  0x1D72D: {
    c: '\\398',
    f: 'BI'
  },
  0x1D72E: {
    c: '\\3A3',
    f: 'BI'
  },
  0x1D72F: {
    c: 'T',
    f: 'BI'
  },
  0x1D730: {
    c: '\\3A5',
    f: 'BI'
  },
  0x1D731: {
    c: '\\3A6',
    f: 'BI'
  },
  0x1D732: {
    c: 'X',
    f: 'BI'
  },
  0x1D733: {
    c: '\\3A8',
    f: 'BI'
  },
  0x1D734: {
    c: '\\3A9',
    f: 'BI'
  },
  0x1D735: {
    c: '\\2207',
    f: ''
  },
  0x1D736: {
    c: '\\3B1',
    f: 'BI'
  },
  0x1D737: {
    c: '\\3B2',
    f: 'BI'
  },
  0x1D738: {
    c: '\\3B3',
    f: 'BI'
  },
  0x1D739: {
    c: '\\3B4',
    f: 'BI'
  },
  0x1D73A: {
    c: '\\3B5',
    f: 'BI'
  },
  0x1D73B: {
    c: '\\3B6',
    f: 'BI'
  },
  0x1D73C: {
    c: '\\3B7',
    f: 'BI'
  },
  0x1D73D: {
    c: '\\3B8',
    f: 'BI'
  },
  0x1D73E: {
    c: '\\3B9',
    f: 'BI'
  },
  0x1D73F: {
    c: '\\3BA',
    f: 'BI'
  },
  0x1D740: {
    c: '\\3BB',
    f: 'BI'
  },
  0x1D741: {
    c: '\\3BC',
    f: 'BI'
  },
  0x1D742: {
    c: '\\3BD',
    f: 'BI'
  },
  0x1D743: {
    c: '\\3BE',
    f: 'BI'
  },
  0x1D744: {
    c: '\\3BF',
    f: 'BI'
  },
  0x1D745: {
    c: '\\3C0',
    f: 'BI'
  },
  0x1D746: {
    c: '\\3C1',
    f: 'BI'
  },
  0x1D747: {
    c: '\\3C2',
    f: 'BI'
  },
  0x1D748: {
    c: '\\3C3',
    f: 'BI'
  },
  0x1D749: {
    c: '\\3C4',
    f: 'BI'
  },
  0x1D74A: {
    c: '\\3C5',
    f: 'BI'
  },
  0x1D74B: {
    c: '\\3C6',
    f: 'BI'
  },
  0x1D74C: {
    c: '\\3C7',
    f: 'BI'
  },
  0x1D74D: {
    c: '\\3C8',
    f: 'BI'
  },
  0x1D74E: {
    c: '\\3C9',
    f: 'BI'
  },
  0x1D74F: {
    c: '\\2202',
    f: ''
  },
  0x1D750: {
    c: '\\3F5',
    f: 'BI'
  },
  0x1D751: {
    c: '\\3D1',
    f: 'BI'
  },
  0x1D752: {
    c: '\\E009',
    f: 'A'
  },
  0x1D753: {
    c: '\\3D5',
    f: 'BI'
  },
  0x1D754: {
    c: '\\3F1',
    f: 'BI'
  },
  0x1D755: {
    c: '\\3D6',
    f: 'BI'
  },
  0x1D756: {
    c: 'A',
    f: 'SS-B'
  },
  0x1D757: {
    c: 'B',
    f: 'SS-B'
  },
  0x1D758: {
    c: '\\393',
    f: 'SS-B'
  },
  0x1D759: {
    c: '\\394',
    f: 'SS-B'
  },
  0x1D75A: {
    c: 'E',
    f: 'SS-B'
  },
  0x1D75B: {
    c: 'Z',
    f: 'SS-B'
  },
  0x1D75C: {
    c: 'H',
    f: 'SS-B'
  },
  0x1D75D: {
    c: '\\398',
    f: 'SS-B'
  },
  0x1D75E: {
    c: 'I',
    f: 'SS-B'
  },
  0x1D75F: {
    c: 'K',
    f: 'SS-B'
  },
  0x1D760: {
    c: '\\39B',
    f: 'SS-B'
  },
  0x1D761: {
    c: 'M',
    f: 'SS-B'
  },
  0x1D762: {
    c: 'N',
    f: 'SS-B'
  },
  0x1D763: {
    c: '\\39E',
    f: 'SS-B'
  },
  0x1D764: {
    c: 'O',
    f: 'SS-B'
  },
  0x1D765: {
    c: '\\3A0',
    f: 'SS-B'
  },
  0x1D766: {
    c: 'P',
    f: 'SS-B'
  },
  0x1D767: {
    c: '\\398',
    f: 'SS-B'
  },
  0x1D768: {
    c: '\\3A3',
    f: 'SS-B'
  },
  0x1D769: {
    c: 'T',
    f: 'SS-B'
  },
  0x1D76A: {
    c: '\\3A5',
    f: 'SS-B'
  },
  0x1D76B: {
    c: '\\3A6',
    f: 'SS-B'
  },
  0x1D76C: {
    c: 'X',
    f: 'SS-B'
  },
  0x1D76D: {
    c: '\\3A8',
    f: 'SS-B'
  },
  0x1D76E: {
    c: '\\3A9',
    f: 'SS-B'
  },
  0x1D76F: {
    c: '\\2207',
    f: ''
  },
  0x1D770: {
    c: '\\3B1',
    f: 'BI'
  },
  0x1D771: {
    c: '\\3B2',
    f: 'BI'
  },
  0x1D772: {
    c: '\\3B3',
    f: 'BI'
  },
  0x1D773: {
    c: '\\3B4',
    f: 'BI'
  },
  0x1D774: {
    c: '\\3B5',
    f: 'BI'
  },
  0x1D775: {
    c: '\\3B6',
    f: 'BI'
  },
  0x1D776: {
    c: '\\3B7',
    f: 'BI'
  },
  0x1D777: {
    c: '\\3B8',
    f: 'BI'
  },
  0x1D778: {
    c: '\\3B9',
    f: 'BI'
  },
  0x1D779: {
    c: '\\3BA',
    f: 'BI'
  },
  0x1D77A: {
    c: '\\3BB',
    f: 'BI'
  },
  0x1D77B: {
    c: '\\3BC',
    f: 'BI'
  },
  0x1D77C: {
    c: '\\3BD',
    f: 'BI'
  },
  0x1D77D: {
    c: '\\3BE',
    f: 'BI'
  },
  0x1D77E: {
    c: '\\3BF',
    f: 'BI'
  },
  0x1D77F: {
    c: '\\3C0',
    f: 'BI'
  },
  0x1D780: {
    c: '\\3C1',
    f: 'BI'
  },
  0x1D781: {
    c: '\\3C2',
    f: 'BI'
  },
  0x1D782: {
    c: '\\3C3',
    f: 'BI'
  },
  0x1D783: {
    c: '\\3C4',
    f: 'BI'
  },
  0x1D784: {
    c: '\\3C5',
    f: 'BI'
  },
  0x1D785: {
    c: '\\3C6',
    f: 'BI'
  },
  0x1D786: {
    c: '\\3C7',
    f: 'BI'
  },
  0x1D787: {
    c: '\\3C8',
    f: 'BI'
  },
  0x1D788: {
    c: '\\3C9',
    f: 'BI'
  },
  0x1D789: {
    c: '\\2202',
    f: ''
  },
  0x1D78A: {
    c: '\\3F5',
    f: 'BI'
  },
  0x1D78B: {
    c: '\\3D1',
    f: 'BI'
  },
  0x1D78C: {
    c: '\\E009',
    f: 'A'
  },
  0x1D78D: {
    c: '\\3D5',
    f: 'BI'
  },
  0x1D78E: {
    c: '\\3F1',
    f: 'BI'
  },
  0x1D78F: {
    c: '\\3D6',
    f: 'BI'
  },
  0x1D790: {
    c: 'A',
    f: 'SS-I'
  },
  0x1D791: {
    c: 'B',
    f: 'SS-I'
  },
  0x1D792: {
    c: '\\393',
    f: 'SS-I'
  },
  0x1D793: {
    c: '\\394',
    f: 'SS-I'
  },
  0x1D794: {
    c: 'E',
    f: 'SS-I'
  },
  0x1D795: {
    c: 'Z',
    f: 'SS-I'
  },
  0x1D796: {
    c: 'H',
    f: 'SS-I'
  },
  0x1D797: {
    c: '\\398',
    f: 'SS-I'
  },
  0x1D798: {
    c: 'I',
    f: 'SS-I'
  },
  0x1D799: {
    c: 'K',
    f: 'SS-I'
  },
  0x1D79A: {
    c: '\\39B',
    f: 'SS-I'
  },
  0x1D79B: {
    c: 'M',
    f: 'SS-I'
  },
  0x1D79C: {
    c: 'N',
    f: 'SS-I'
  },
  0x1D79D: {
    c: '\\39E',
    f: 'SS-I'
  },
  0x1D79E: {
    c: 'O',
    f: 'SS-I'
  },
  0x1D79F: {
    c: '\\3A0',
    f: 'SS-I'
  },
  0x1D7A0: {
    c: 'P',
    f: 'SS-I'
  },
  0x1D7A1: {
    c: '\\398',
    f: 'SS-I'
  },
  0x1D7A2: {
    c: '\\3A3',
    f: 'SS-I'
  },
  0x1D7A3: {
    c: 'T',
    f: 'SS-I'
  },
  0x1D7A4: {
    c: '\\3A5',
    f: 'SS-I'
  },
  0x1D7A5: {
    c: '\\3A6',
    f: 'SS-I'
  },
  0x1D7A6: {
    c: 'X',
    f: 'SS-I'
  },
  0x1D7A7: {
    c: '\\3A8',
    f: 'SS-I'
  },
  0x1D7A8: {
    c: '\\3A9',
    f: 'SS-I'
  },
  0x1D7A9: {
    c: '\\2207',
    f: ''
  },
  0x1D7AA: {
    c: '\\3B1',
    f: 'BI'
  },
  0x1D7AB: {
    c: '\\3B2',
    f: 'BI'
  },
  0x1D7AC: {
    c: '\\3B3',
    f: 'BI'
  },
  0x1D7AD: {
    c: '\\3B4',
    f: 'BI'
  },
  0x1D7AE: {
    c: '\\3B5',
    f: 'BI'
  },
  0x1D7AF: {
    c: '\\3B6',
    f: 'BI'
  },
  0x1D7B0: {
    c: '\\3B7',
    f: 'BI'
  },
  0x1D7B1: {
    c: '\\3B8',
    f: 'BI'
  },
  0x1D7B2: {
    c: '\\3B9',
    f: 'BI'
  },
  0x1D7B3: {
    c: '\\3BA',
    f: 'BI'
  },
  0x1D7B4: {
    c: '\\3BB',
    f: 'BI'
  },
  0x1D7B5: {
    c: '\\3BC',
    f: 'BI'
  },
  0x1D7B6: {
    c: '\\3BD',
    f: 'BI'
  },
  0x1D7B7: {
    c: '\\3BE',
    f: 'BI'
  },
  0x1D7B8: {
    c: '\\3BF',
    f: 'BI'
  },
  0x1D7B9: {
    c: '\\3C0',
    f: 'BI'
  },
  0x1D7BA: {
    c: '\\3C1',
    f: 'BI'
  },
  0x1D7BB: {
    c: '\\3C2',
    f: 'BI'
  },
  0x1D7BC: {
    c: '\\3C3',
    f: 'BI'
  },
  0x1D7BD: {
    c: '\\3C4',
    f: 'BI'
  },
  0x1D7BE: {
    c: '\\3C5',
    f: 'BI'
  },
  0x1D7BF: {
    c: '\\3C6',
    f: 'BI'
  },
  0x1D7C0: {
    c: '\\3C7',
    f: 'BI'
  },
  0x1D7C1: {
    c: '\\3C8',
    f: 'BI'
  },
  0x1D7C2: {
    c: '\\3C9',
    f: 'BI'
  },
  0x1D7C3: {
    c: '\\2202',
    f: ''
  },
  0x1D7C4: {
    c: '\\3F5',
    f: 'BI'
  },
  0x1D7C5: {
    c: '\\3D1',
    f: 'BI'
  },
  0x1D7C6: {
    c: '\\E009',
    f: 'A'
  },
  0x1D7C7: {
    c: '\\3D5',
    f: 'BI'
  },
  0x1D7C8: {
    c: '\\3F1',
    f: 'BI'
  },
  0x1D7C9: {
    c: '\\3D6',
    f: 'BI'
  },
  0x1D7CA: {
    c: 'F',
    f: 'I'
  },
  0x1D7CB: {
    c: '\\3DD',
    f: 'A'
  },
  0x1D7CE: {
    c: '0',
    f: 'B'
  },
  0x1D7CF: {
    c: '1',
    f: 'B'
  },
  0x1D7D0: {
    c: '2',
    f: 'B'
  },
  0x1D7D1: {
    c: '3',
    f: 'B'
  },
  0x1D7D2: {
    c: '4',
    f: 'B'
  },
  0x1D7D3: {
    c: '5',
    f: 'B'
  },
  0x1D7D4: {
    c: '6',
    f: 'B'
  },
  0x1D7D5: {
    c: '7',
    f: 'B'
  },
  0x1D7D6: {
    c: '8',
    f: 'B'
  },
  0x1D7D7: {
    c: '9',
    f: 'B'
  },
  0x1D7D8: {
    c: '0',
    f: 'B'
  },
  0x1D7D9: {
    c: '1',
    f: 'B'
  },
  0x1D7DA: {
    c: '2',
    f: 'B'
  },
  0x1D7DB: {
    c: '3',
    f: 'B'
  },
  0x1D7DC: {
    c: '4',
    f: 'B'
  },
  0x1D7DD: {
    c: '5',
    f: 'B'
  },
  0x1D7DE: {
    c: '6',
    f: 'B'
  },
  0x1D7DF: {
    c: '7',
    f: 'B'
  },
  0x1D7E0: {
    c: '8',
    f: 'B'
  },
  0x1D7E1: {
    c: '9',
    f: 'B'
  },
  0x1D7E2: {
    c: '0',
    f: 'SS'
  },
  0x1D7E3: {
    c: '1',
    f: 'SS'
  },
  0x1D7E4: {
    c: '2',
    f: 'SS'
  },
  0x1D7E5: {
    c: '3',
    f: 'SS'
  },
  0x1D7E6: {
    c: '4',
    f: 'SS'
  },
  0x1D7E7: {
    c: '5',
    f: 'SS'
  },
  0x1D7E8: {
    c: '6',
    f: 'SS'
  },
  0x1D7E9: {
    c: '7',
    f: 'SS'
  },
  0x1D7EA: {
    c: '8',
    f: 'SS'
  },
  0x1D7EB: {
    c: '9',
    f: 'SS'
  },
  0x1D7EC: {
    c: '0',
    f: 'SS-B'
  },
  0x1D7ED: {
    c: '1',
    f: 'SS-B'
  },
  0x1D7EE: {
    c: '2',
    f: 'SS-B'
  },
  0x1D7EF: {
    c: '3',
    f: 'SS-B'
  },
  0x1D7F0: {
    c: '4',
    f: 'SS-B'
  },
  0x1D7F1: {
    c: '5',
    f: 'SS-B'
  },
  0x1D7F2: {
    c: '6',
    f: 'SS-B'
  },
  0x1D7F3: {
    c: '7',
    f: 'SS-B'
  },
  0x1D7F4: {
    c: '8',
    f: 'SS-B'
  },
  0x1D7F5: {
    c: '9',
    f: 'SS-B'
  },
  0x1D7F6: {
    c: '0',
    f: 'T'
  },
  0x1D7F7: {
    c: '1',
    f: 'T'
  },
  0x1D7F8: {
    c: '2',
    f: 'T'
  },
  0x1D7F9: {
    c: '3',
    f: 'T'
  },
  0x1D7FA: {
    c: '4',
    f: 'T'
  },
  0x1D7FB: {
    c: '5',
    f: 'T'
  },
  0x1D7FC: {
    c: '6',
    f: 'T'
  },
  0x1D7FD: {
    c: '7',
    f: 'T'
  },
  0x1D7FE: {
    c: '8',
    f: 'T'
  },
  0x1D7FF: {
    c: '9',
    f: 'T'
  }
});

/***/ }),
/* 315 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.normal = {
  0x20: [0, 0, .25],
  0x21: [.716, 0, .278],
  0x22: [.694, -0.379, .5],
  0x23: [.694, .194, .833],
  0x24: [.75, .056, .5],
  0x25: [.75, .056, .833],
  0x26: [.716, .022, .778],
  0x27: [.694, -0.379, .278],
  0x28: [.75, .25, .389],
  0x29: [.75, .25, .389],
  0x2A: [.75, -0.32, .5],
  0x2B: [.583, .082, .778],
  0x2C: [.121, .194, .278],
  0x2D: [.252, -0.179, .333],
  0x2E: [.12, 0, .278],
  0x2F: [.75, .25, .5],
  0x30: [.666, .022, .5],
  0x31: [.666, 0, .5],
  0x32: [.666, 0, .5],
  0x33: [.665, .022, .5],
  0x34: [.677, 0, .5],
  0x35: [.666, .022, .5],
  0x36: [.666, .022, .5],
  0x37: [.676, .022, .5],
  0x38: [.666, .022, .5],
  0x39: [.666, .022, .5],
  0x3A: [.43, 0, .278],
  0x3B: [.43, .194, .278],
  0x3C: [.54, .04, .778],
  0x3D: [.583, .082, .778],
  0x3E: [.54, .04, .778],
  0x3F: [.705, 0, .472],
  0x40: [.705, .011, .778],
  0x41: [.716, 0, .75],
  0x42: [.683, 0, .708],
  0x43: [.705, .021, .722],
  0x44: [.683, 0, .764],
  0x45: [.68, 0, .681],
  0x46: [.68, 0, .653],
  0x47: [.705, .022, .785],
  0x48: [.683, 0, .75],
  0x49: [.683, 0, .361],
  0x4A: [.683, .022, .514],
  0x4B: [.683, 0, .778],
  0x4C: [.683, 0, .625],
  0x4D: [.683, 0, .917],
  0x4E: [.683, 0, .75],
  0x4F: [.705, .022, .778],
  0x50: [.683, 0, .681],
  0x51: [.705, .193, .778],
  0x52: [.683, .022, .736],
  0x53: [.705, .022, .556],
  0x54: [.677, 0, .722],
  0x55: [.683, .022, .75],
  0x56: [.683, .022, .75],
  0x57: [.683, .022, 1.028],
  0x58: [.683, 0, .75],
  0x59: [.683, 0, .75],
  0x5A: [.683, 0, .611],
  0x5B: [.75, .25, .278],
  0x5C: [.75, .25, .5],
  0x5D: [.75, .25, .278],
  0x5E: [.694, -0.531, .5],
  0x5F: [-0.025, .062, .5],
  0x60: [.699, -0.505, .5],
  0x61: [.448, .011, .5],
  0x62: [.694, .011, .556],
  0x63: [.448, .011, .444],
  0x64: [.694, .011, .556],
  0x65: [.448, .011, .444],
  0x66: [.705, 0, .306, {
    ic: .066
  }],
  0x67: [.453, .206, .5],
  0x68: [.694, 0, .556],
  0x69: [.669, 0, .278],
  0x6A: [.669, .205, .306],
  0x6B: [.694, 0, .528],
  0x6C: [.694, 0, .278],
  0x6D: [.442, 0, .833],
  0x6E: [.442, 0, .556],
  0x6F: [.448, .01, .5],
  0x70: [.442, .194, .556],
  0x71: [.442, .194, .528],
  0x72: [.442, 0, .392],
  0x73: [.448, .011, .394],
  0x74: [.615, .01, .389],
  0x75: [.442, .011, .556],
  0x76: [.431, .011, .528],
  0x77: [.431, .011, .722],
  0x78: [.431, 0, .528],
  0x79: [.431, .204, .528],
  0x7A: [.431, 0, .444],
  0x7B: [.75, .25, .5],
  0x7C: [.75, .249, .278],
  0x7D: [.75, .25, .5],
  0x7E: [.318, -0.215, .5],
  0xA0: [0, 0, .25],
  0xA3: [.714, .011, .769],
  0xA5: [.683, 0, .75],
  0xA8: [.669, -0.554, .5],
  0xAC: [.356, -0.089, .667],
  0xAE: [.709, .175, .947],
  0xAF: [.59, -0.544, .5],
  0xB0: [.715, -0.542, .5],
  0xB1: [.666, 0, .778],
  0xB4: [.699, -0.505, .5],
  0xB7: [.31, -0.19, .278],
  0xD7: [.491, -0.009, .778],
  0xF0: [.749, .021, .556],
  0xF7: [.537, .036, .778],
  0x127: [.695, .013, .54],
  0x131: [.442, 0, .278, {
    sk: 0.0278
  }],
  0x237: [.442, .205, .306, {
    sk: 0.0833
  }],
  0x2B9: [.56, -0.043, .275],
  0x2C6: [.694, -0.531, .5],
  0x2C7: [.644, -0.513, .5],
  0x2C9: [.59, -0.544, .5],
  0x2CA: [.699, -0.505, .5],
  0x2CB: [.699, -0.505, .5],
  0x2D8: [.694, -0.515, .5],
  0x2D9: [.669, -0.549, .5],
  0x2DA: [.715, -0.542, .5],
  0x2DC: [.668, -0.565, .5],
  0x300: [.699, -0.505, 0],
  0x301: [.699, -0.505, 0],
  0x302: [.694, -0.531, 0],
  0x303: [.668, -0.565, 0],
  0x304: [.59, -0.544, 0],
  0x306: [.694, -0.515, 0],
  0x307: [.669, -0.549, 0],
  0x308: [.669, -0.554, 0],
  0x30A: [.715, -0.542, 0],
  0x30B: [.701, -0.51, 0],
  0x30C: [.644, -0.513, 0],
  0x338: [.716, .215, 0],
  0x391: [.716, 0, .75],
  0x392: [.683, 0, .708],
  0x393: [.68, 0, .625],
  0x394: [.716, 0, .833],
  0x395: [.68, 0, .681],
  0x396: [.683, 0, .611],
  0x397: [.683, 0, .75],
  0x398: [.705, .022, .778],
  0x399: [.683, 0, .361],
  0x39A: [.683, 0, .778],
  0x39B: [.716, 0, .694],
  0x39C: [.683, 0, .917],
  0x39D: [.683, 0, .75],
  0x39E: [.677, 0, .667],
  0x39F: [.705, .022, .778],
  0x3A0: [.68, 0, .75],
  0x3A1: [.683, 0, .681],
  0x3A2: [.705, .022, .778],
  0x3A3: [.683, 0, .722],
  0x3A4: [.677, 0, .722],
  0x3A5: [.705, 0, .778],
  0x3A6: [.683, 0, .722],
  0x3A7: [.683, 0, .75],
  0x3A8: [.683, 0, .778],
  0x3A9: [.704, 0, .722],
  0x3D2: [.705, 0, .778],
  0x3DC: [.68, 0, .653],
  0x3DD: [.605, .085, .778],
  0x3F0: [.434, .006, .667, {
    ic: .067
  }],
  0x3F6: [.44, 0, .429],
  0x2000: [0, 0, .5],
  0x2001: [0, 0, 1],
  0x2002: [0, 0, .5],
  0x2003: [0, 0, 1],
  0x2004: [0, 0, .333],
  0x2005: [0, 0, .25],
  0x2006: [0, 0, .167],
  0x2009: [0, 0, .167],
  0x200A: [0, 0, .1],
  0x200B: [0, 0, 0],
  0x200C: [0, 0, 0],
  0x2013: [.285, -0.248, .5],
  0x2014: [.285, -0.248, 1],
  0x2015: [.285, -0.248, 1],
  0x2016: [.75, .25, .5],
  0x2017: [-0.025, .062, .5],
  0x2018: [.694, -0.379, .278],
  0x2019: [.694, -0.379, .278],
  0x201C: [.694, -0.379, .5],
  0x201D: [.694, -0.379, .5],
  0x2020: [.705, .216, .444],
  0x2021: [.705, .205, .444],
  0x2022: [.444, -0.055, .5],
  0x2026: [.12, 0, 1.172],
  0x2032: [.56, -0.043, .275],
  0x2033: [.56, 0, .55],
  0x2034: [.56, 0, .825],
  0x2035: [.56, -0.043, .275],
  0x2036: [.56, 0, .55],
  0x2037: [.56, 0, .825],
  0x203E: [.59, -0.544, .5],
  0x2044: [.75, .25, .5],
  0x2057: [.56, 0, 1.1],
  0x2061: [0, 0, 0],
  0x2062: [0, 0, 0],
  0x2063: [0, 0, 0],
  0x2064: [0, 0, 0],
  0x20D7: [.714, -0.516, .5],
  0x2102: [.702, .019, .722],
  0x210B: [.717, .036, .969, {
    ic: .272,
    sk: 0.333
  }],
  0x210C: [.666, .133, .72],
  0x210D: [.683, 0, .778],
  0x210E: [.694, .011, .576, {
    sk: -0.0278
  }],
  0x210F: [.695, .013, .54],
  0x2110: [.717, .314, 1.052, {
    ic: .081,
    sk: 0.417
  }],
  0x2111: [.686, .026, .554],
  0x2112: [.717, .017, .874, {
    ic: .161,
    sk: 0.306
  }],
  0x2113: [.705, .02, .417, {
    sk: 0.111
  }],
  0x2115: [.683, .02, .722],
  0x2118: [.453, .216, .636, {
    sk: 0.111
  }],
  0x2119: [.683, 0, .611],
  0x211A: [.701, .181, .778],
  0x211B: [.717, .017, .85, {
    sk: 0.194
  }],
  0x211C: [.686, .026, .828],
  0x211D: [.683, 0, .722],
  0x2124: [.683, 0, .667],
  0x2126: [.704, 0, .722],
  0x2127: [.684, .022, .722],
  0x2128: [.729, .139, .602],
  0x212C: [.708, .028, .908, {
    sk: 0.194
  }],
  0x212D: [.685, .024, .613],
  0x2130: [.707, .008, .562, {
    ic: .156,
    sk: 0.139
  }],
  0x2131: [.735, .036, .895, {
    ic: .095,
    sk: 0.222
  }],
  0x2132: [.695, 0, .556],
  0x2133: [.721, .05, 1.08, {
    ic: .136,
    sk: 0.444
  }],
  0x2135: [.694, 0, .611],
  0x2136: [.763, .021, .667],
  0x2137: [.764, .043, .444],
  0x2138: [.764, .043, .667],
  0x2141: [.705, .023, .639],
  0x2190: [.511, .011, 1],
  0x2191: [.694, .193, .5],
  0x2192: [.511, .011, 1],
  0x2193: [.694, .194, .5],
  0x2194: [.511, .011, 1],
  0x2195: [.772, .272, .5],
  0x2196: [.72, .195, 1],
  0x2197: [.72, .195, 1],
  0x2198: [.695, .22, 1],
  0x2199: [.695, .22, 1],
  0x219A: [.437, -0.06, 1],
  0x219B: [.437, -0.06, 1],
  0x219E: [.417, -0.083, 1],
  0x21A0: [.417, -0.083, 1],
  0x21A2: [.417, -0.083, 1.111],
  0x21A3: [.417, -0.083, 1.111],
  0x21A6: [.511, .011, 1],
  0x21A9: [.511, .011, 1.126],
  0x21AA: [.511, .011, 1.126],
  0x21AB: [.575, .041, 1],
  0x21AC: [.575, .041, 1],
  0x21AD: [.417, -0.083, 1.389],
  0x21AE: [.437, -0.06, 1],
  0x21B0: [.722, 0, .5],
  0x21B1: [.722, 0, .5],
  0x21B6: [.461, 0, 1],
  0x21B7: [.46, 0, 1],
  0x21BA: [.65, .083, .778],
  0x21BB: [.65, .083, .778],
  0x21BC: [.511, -0.23, 1],
  0x21BD: [.27, .011, 1],
  0x21BE: [.694, .194, .417],
  0x21BF: [.694, .194, .417],
  0x21C0: [.511, -0.23, 1],
  0x21C1: [.27, .011, 1],
  0x21C2: [.694, .194, .417],
  0x21C3: [.694, .194, .417],
  0x21C4: [.667, 0, 1],
  0x21C6: [.667, 0, 1],
  0x21C7: [.583, .083, 1],
  0x21C8: [.694, .193, .833],
  0x21C9: [.583, .083, 1],
  0x21CA: [.694, .194, .833],
  0x21CB: [.514, .014, 1],
  0x21CC: [.671, .011, 1],
  0x21CD: [.534, .035, 1],
  0x21CE: [.534, .037, 1],
  0x21CF: [.534, .035, 1],
  0x21D0: [.525, .024, 1],
  0x21D1: [.694, .194, .611],
  0x21D2: [.525, .024, 1],
  0x21D3: [.694, .194, .611],
  0x21D4: [.526, .025, 1],
  0x21D5: [.772, .272, .611],
  0x21DA: [.611, .111, 1],
  0x21DB: [.611, .111, 1],
  0x21DD: [.417, -0.083, 1],
  0x21E0: [.437, -0.064, 1.334],
  0x21E2: [.437, -0.064, 1.334],
  0x2200: [.694, .022, .556],
  0x2201: [.846, .021, .5],
  0x2202: [.715, .022, .531, {
    sk: 0.0833
  }],
  0x2203: [.694, 0, .556],
  0x2204: [.716, .215, .556],
  0x2205: [.772, .078, .5],
  0x2206: [.716, 0, .833],
  0x2207: [.683, .033, .833],
  0x2208: [.54, .04, .667],
  0x2209: [.716, .215, .667],
  0x220B: [.54, .04, .667],
  0x220C: [.716, .215, .667],
  0x220D: [.44, 0, .429],
  0x220F: [.75, .25, .944],
  0x2210: [.75, .25, .944],
  0x2211: [.75, .25, 1.056],
  0x2212: [.583, .082, .778],
  0x2213: [.5, .166, .778],
  0x2214: [.766, .093, .778],
  0x2215: [.75, .25, .5],
  0x2216: [.43, .023, .778],
  0x2217: [.465, -0.035, .5],
  0x2218: [.444, -0.055, .5],
  0x2219: [.444, -0.055, .5],
  0x221A: [.8, .2, .833],
  0x221D: [.442, .011, .778],
  0x221E: [.442, .011, 1],
  0x2220: [.694, 0, .722],
  0x2221: [.714, .02, .722],
  0x2222: [.551, .051, .722],
  0x2223: [.75, .249, .278],
  0x2224: [.75, .252, .278],
  0x2225: [.75, .25, .5],
  0x2226: [.75, .25, .5],
  0x2227: [.598, .022, .667],
  0x2228: [.598, .022, .667],
  0x2229: [.598, .022, .667],
  0x222A: [.598, .022, .667],
  0x222B: [.716, .216, .417, {
    ic: .055
  }],
  0x222C: [.805, .306, .819, {
    ic: .138
  }],
  0x222D: [.805, .306, 1.166, {
    ic: .138
  }],
  0x222E: [.805, .306, .472, {
    ic: .138
  }],
  0x2234: [.471, .082, .667],
  0x2235: [.471, .082, .667],
  0x223C: [.367, -0.133, .778],
  0x223D: [.367, -0.133, .778],
  0x2240: [.583, .083, .278],
  0x2241: [.467, -0.032, .778],
  0x2242: [.463, -0.034, .778],
  0x2243: [.464, -0.036, .778],
  0x2244: [.716, .215, .778],
  0x2245: [.589, -0.022, .778],
  0x2246: [.652, .155, .778],
  0x2247: [.652, .155, .778],
  0x2248: [.483, -0.055, .778],
  0x2249: [.716, .215, .778],
  0x224A: [.579, .039, .778],
  0x224D: [.484, -0.016, .778],
  0x224E: [.492, -0.008, .778],
  0x224F: [.492, -0.133, .778],
  0x2250: [.67, -0.133, .778],
  0x2251: [.609, .108, .778],
  0x2252: [.601, .101, .778],
  0x2253: [.601, .102, .778],
  0x2256: [.367, -0.133, .778],
  0x2257: [.721, -0.133, .778],
  0x225C: [.859, -0.133, .778],
  0x2260: [.716, .215, .778],
  0x2261: [.464, -0.036, .778],
  0x2262: [.716, .215, .778],
  0x2264: [.636, .138, .778],
  0x2265: [.636, .138, .778],
  0x2266: [.753, .175, .778],
  0x2267: [.753, .175, .778],
  0x2268: [.752, .286, .778],
  0x2269: [.752, .286, .778],
  0x226A: [.568, .067, 1],
  0x226B: [.567, .067, 1],
  0x226C: [.75, .25, .5],
  0x226D: [.716, .215, .778],
  0x226E: [.708, .209, .778],
  0x226F: [.708, .209, .778],
  0x2270: [.801, .303, .778],
  0x2271: [.801, .303, .778],
  0x2272: [.732, .228, .778],
  0x2273: [.732, .228, .778],
  0x2274: [.732, .228, .778],
  0x2275: [.732, .228, .778],
  0x2276: [.681, .253, .778],
  0x2277: [.681, .253, .778],
  0x2278: [.716, .253, .778],
  0x2279: [.716, .253, .778],
  0x227A: [.539, .041, .778],
  0x227B: [.539, .041, .778],
  0x227C: [.58, .153, .778],
  0x227D: [.58, .154, .778],
  0x227E: [.732, .228, .778],
  0x227F: [.732, .228, .778],
  0x2280: [.705, .208, .778],
  0x2281: [.705, .208, .778],
  0x2282: [.54, .04, .778],
  0x2283: [.54, .04, .778],
  0x2284: [.716, .215, .778],
  0x2285: [.716, .215, .778],
  0x2286: [.636, .138, .778],
  0x2287: [.636, .138, .778],
  0x2288: [.801, .303, .778],
  0x2289: [.801, .303, .778],
  0x228A: [.635, .241, .778],
  0x228B: [.635, .241, .778],
  0x228E: [.598, .022, .667],
  0x228F: [.539, .041, .778],
  0x2290: [.539, .041, .778],
  0x2291: [.636, .138, .778],
  0x2292: [.636, .138, .778],
  0x2293: [.598, 0, .667],
  0x2294: [.598, 0, .667],
  0x2295: [.583, .083, .778],
  0x2296: [.583, .083, .778],
  0x2297: [.583, .083, .778],
  0x2298: [.583, .083, .778],
  0x2299: [.583, .083, .778],
  0x229A: [.582, .082, .778],
  0x229B: [.582, .082, .778],
  0x229D: [.582, .082, .778],
  0x229E: [.689, 0, .778],
  0x229F: [.689, 0, .778],
  0x22A0: [.689, 0, .778],
  0x22A1: [.689, 0, .778],
  0x22A2: [.694, 0, .611],
  0x22A3: [.694, 0, .611],
  0x22A4: [.668, 0, .778],
  0x22A5: [.668, 0, .778],
  0x22A8: [.75, .249, .867],
  0x22A9: [.694, 0, .722],
  0x22AA: [.694, 0, .889],
  0x22AC: [.695, 0, .611],
  0x22AD: [.695, 0, .611],
  0x22AE: [.695, 0, .722],
  0x22AF: [.695, 0, .722],
  0x22B2: [.539, .041, .778],
  0x22B3: [.539, .041, .778],
  0x22B4: [.636, .138, .778],
  0x22B5: [.636, .138, .778],
  0x22B8: [.408, -0.092, 1.111],
  0x22BA: [.431, .212, .556],
  0x22BB: [.716, 0, .611],
  0x22BC: [.716, 0, .611],
  0x22C0: [.75, .249, .833],
  0x22C1: [.75, .249, .833],
  0x22C2: [.75, .249, .833],
  0x22C3: [.75, .249, .833],
  0x22C4: [.488, -0.012, .5],
  0x22C5: [.31, -0.19, .278],
  0x22C6: [.486, -0.016, .5],
  0x22C7: [.545, .044, .778],
  0x22C8: [.505, .005, .9],
  0x22C9: [.492, -0.008, .778],
  0x22CA: [.492, -0.008, .778],
  0x22CB: [.694, .022, .778],
  0x22CC: [.694, .022, .778],
  0x22CD: [.464, -0.036, .778],
  0x22CE: [.578, .021, .76],
  0x22CF: [.578, .022, .76],
  0x22D0: [.54, .04, .778],
  0x22D1: [.54, .04, .778],
  0x22D2: [.598, .022, .667],
  0x22D3: [.598, .022, .667],
  0x22D4: [.736, .022, .667],
  0x22D6: [.541, .041, .778],
  0x22D7: [.541, .041, .778],
  0x22D8: [.568, .067, 1.333],
  0x22D9: [.568, .067, 1.333],
  0x22DA: [.886, .386, .778],
  0x22DB: [.886, .386, .778],
  0x22DE: [.734, 0, .778],
  0x22DF: [.734, 0, .778],
  0x22E0: [.801, .303, .778],
  0x22E1: [.801, .303, .778],
  0x22E2: [.716, .215, .778],
  0x22E3: [.716, .215, .778],
  0x22E6: [.73, .359, .778],
  0x22E7: [.73, .359, .778],
  0x22E8: [.73, .359, .778],
  0x22E9: [.73, .359, .778],
  0x22EA: [.706, .208, .778],
  0x22EB: [.706, .208, .778],
  0x22EC: [.802, .303, .778],
  0x22ED: [.801, .303, .778],
  0x22EE: [1.3, .03, .278],
  0x22EF: [.31, -0.19, 1.172],
  0x22F1: [1.52, -0.1, 1.282],
  0x2305: [.716, 0, .611],
  0x2306: [.813, .097, .611],
  0x2308: [.75, .25, .444],
  0x2309: [.75, .25, .444],
  0x230A: [.75, .25, .444],
  0x230B: [.75, .25, .444],
  0x231C: [.694, -0.306, .5],
  0x231D: [.694, -0.306, .5],
  0x231E: [.366, .022, .5],
  0x231F: [.366, .022, .5],
  0x2322: [.388, -0.122, 1],
  0x2323: [.378, -0.134, 1],
  0x2329: [.75, .25, .389],
  0x232A: [.75, .25, .389],
  0x23B0: [.744, .244, .412],
  0x23B1: [.744, .244, .412],
  0x23D0: [.602, 0, .667],
  0x24C8: [.709, .175, .902],
  0x250C: [.694, -0.306, .5],
  0x2510: [.694, -0.306, .5],
  0x2514: [.366, .022, .5],
  0x2518: [.366, .022, .5],
  0x2571: [.694, .195, .889],
  0x2572: [.694, .195, .889],
  0x25A0: [.689, 0, .778],
  0x25A1: [.689, 0, .778],
  0x25AA: [.689, 0, .778],
  0x25B2: [.575, .02, .722],
  0x25B3: [.716, 0, .889],
  0x25B4: [.575, .02, .722],
  0x25B5: [.716, 0, .889],
  0x25B6: [.539, .041, .778],
  0x25B8: [.539, .041, .778],
  0x25B9: [.505, .005, .5],
  0x25BC: [.576, .019, .722],
  0x25BD: [.5, .215, .889],
  0x25BE: [.576, .019, .722],
  0x25BF: [.5, .215, .889],
  0x25C0: [.539, .041, .778],
  0x25C2: [.539, .041, .778],
  0x25C3: [.505, .005, .5],
  0x25CA: [.716, .132, .667],
  0x25EF: [.715, .215, 1],
  0x25FB: [.689, 0, .778],
  0x25FC: [.689, 0, .778],
  0x2605: [.694, .111, .944],
  0x2660: [.727, .13, .778],
  0x2661: [.716, .033, .778],
  0x2662: [.727, .162, .778],
  0x2663: [.726, .13, .778],
  0x266D: [.75, .022, .389],
  0x266E: [.734, .223, .389],
  0x266F: [.723, .223, .389],
  0x2713: [.706, .034, .833],
  0x2720: [.716, .022, .833],
  0x2758: [.75, .249, .278],
  0x27E8: [.75, .25, .389],
  0x27E9: [.75, .25, .389],
  0x27EE: [.744, .244, .412],
  0x27EF: [.744, .244, .412],
  0x27F5: [.511, .011, 1.609],
  0x27F6: [.511, .011, 1.638],
  0x27F7: [.511, .011, 1.859],
  0x27F8: [.525, .024, 1.609],
  0x27F9: [.525, .024, 1.638],
  0x27FA: [.525, .024, 1.858],
  0x27FC: [.511, .011, 1.638],
  0x29EB: [.716, .132, .667],
  0x29F8: [.716, .215, .778],
  0x2A00: [.75, .25, 1.111],
  0x2A01: [.75, .25, 1.111],
  0x2A02: [.75, .25, 1.111],
  0x2A04: [.75, .249, .833],
  0x2A06: [.75, .249, .833],
  0x2A0C: [.805, .306, 1.638, {
    ic: .138
  }],
  0x2A2F: [.491, -0.009, .778],
  0x2A3F: [.683, 0, .75],
  0x2A5E: [.813, .097, .611],
  0x2A7D: [.636, .138, .778],
  0x2A7E: [.636, .138, .778],
  0x2A85: [.762, .29, .778],
  0x2A86: [.762, .29, .778],
  0x2A87: [.635, .241, .778],
  0x2A88: [.635, .241, .778],
  0x2A89: [.761, .387, .778],
  0x2A8A: [.761, .387, .778],
  0x2A8B: [1.003, .463, .778],
  0x2A8C: [1.003, .463, .778],
  0x2A95: [.636, .138, .778],
  0x2A96: [.636, .138, .778],
  0x2AAF: [.636, .138, .778],
  0x2AB0: [.636, .138, .778],
  0x2AB5: [.752, .286, .778],
  0x2AB6: [.752, .286, .778],
  0x2AB7: [.761, .294, .778],
  0x2AB8: [.761, .294, .778],
  0x2AB9: [.761, .337, .778],
  0x2ABA: [.761, .337, .778],
  0x2AC5: [.753, .215, .778],
  0x2AC6: [.753, .215, .778],
  0x2ACB: [.783, .385, .778],
  0x2ACC: [.783, .385, .778],
  0x3008: [.75, .25, .389],
  0x3009: [.75, .25, .389],
  0xE006: [.43, .023, .222],
  0xE007: [.431, .024, .389],
  0xE008: [.605, .085, .778],
  0xE009: [.434, .006, .667, {
    ic: .067
  }],
  0xE00C: [.752, .284, .778],
  0xE00D: [.752, .284, .778],
  0xE00E: [.919, .421, .778],
  0xE00F: [.801, .303, .778],
  0xE010: [.801, .303, .778],
  0xE011: [.919, .421, .778],
  0xE016: [.828, .33, .778],
  0xE017: [.752, .332, .778],
  0xE018: [.828, .33, .778],
  0xE019: [.752, .333, .778],
  0xE01A: [.634, .255, .778],
  0xE01B: [.634, .254, .778],
  0x1D400: [.698, 0, .869],
  0x1D401: [.686, 0, .818],
  0x1D402: [.697, .011, .831],
  0x1D403: [.686, 0, .882],
  0x1D404: [.68, 0, .756],
  0x1D405: [.68, 0, .724],
  0x1D406: [.697, .01, .904],
  0x1D407: [.686, 0, .9],
  0x1D408: [.686, 0, .436],
  0x1D409: [.686, .011, .594],
  0x1D40A: [.686, 0, .901],
  0x1D40B: [.686, 0, .692],
  0x1D40C: [.686, 0, 1.092],
  0x1D40D: [.686, 0, .9],
  0x1D40E: [.696, .01, .864],
  0x1D40F: [.686, 0, .786],
  0x1D410: [.696, .193, .864],
  0x1D411: [.686, .011, .862],
  0x1D412: [.697, .011, .639],
  0x1D413: [.675, 0, .8],
  0x1D414: [.686, .011, .885],
  0x1D415: [.686, .007, .869],
  0x1D416: [.686, .007, 1.189],
  0x1D417: [.686, 0, .869],
  0x1D418: [.686, 0, .869],
  0x1D419: [.686, 0, .703],
  0x1D41A: [.453, .006, .559],
  0x1D41B: [.694, .006, .639],
  0x1D41C: [.453, .006, .511],
  0x1D41D: [.694, .006, .639],
  0x1D41E: [.452, .006, .527],
  0x1D41F: [.7, 0, .351, {
    ic: .101
  }],
  0x1D420: [.455, .201, .575],
  0x1D421: [.694, 0, .639],
  0x1D422: [.695, 0, .319],
  0x1D423: [.695, .2, .351],
  0x1D424: [.694, 0, .607],
  0x1D425: [.694, 0, .319],
  0x1D426: [.45, 0, .958],
  0x1D427: [.45, 0, .639],
  0x1D428: [.452, .005, .575],
  0x1D429: [.45, .194, .639],
  0x1D42A: [.45, .194, .607],
  0x1D42B: [.45, 0, .474],
  0x1D42C: [.453, .006, .454],
  0x1D42D: [.635, .005, .447],
  0x1D42E: [.45, .006, .639],
  0x1D42F: [.444, 0, .607],
  0x1D430: [.444, 0, .831],
  0x1D431: [.444, 0, .607],
  0x1D432: [.444, .2, .607],
  0x1D433: [.444, 0, .511],
  0x1D434: [.716, 0, .75, {
    sk: 0.139
  }],
  0x1D435: [.683, 0, .759, {
    sk: 0.0833
  }],
  0x1D436: [.705, .022, .715, {
    sk: 0.0833
  }],
  0x1D437: [.683, 0, .828, {
    sk: 0.0556
  }],
  0x1D438: [.68, 0, .738, {
    sk: 0.0833
  }],
  0x1D439: [.68, 0, .643, {
    ic: .106,
    sk: 0.0833
  }],
  0x1D43A: [.705, .022, .786, {
    sk: 0.0833
  }],
  0x1D43B: [.683, 0, .831, {
    ic: .057,
    sk: 0.0556
  }],
  0x1D43C: [.683, 0, .44, {
    ic: .064,
    sk: 0.111
  }],
  0x1D43D: [.683, .022, .555, {
    ic: .078,
    sk: 0.167
  }],
  0x1D43E: [.683, 0, .849, {
    sk: 0.0556
  }],
  0x1D43F: [.683, 0, .681, {
    sk: 0.0278
  }],
  0x1D440: [.683, 0, .97, {
    ic: .081,
    sk: 0.0833
  }],
  0x1D441: [.683, 0, .803, {
    ic: .085,
    sk: 0.0833
  }],
  0x1D442: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x1D443: [.683, 0, .642, {
    ic: .109,
    sk: 0.0833
  }],
  0x1D444: [.704, .194, .791, {
    sk: 0.0833
  }],
  0x1D445: [.683, .021, .759, {
    sk: 0.0833
  }],
  0x1D446: [.705, .022, .613, {
    sk: 0.0833
  }],
  0x1D447: [.677, 0, .584, {
    ic: .12,
    sk: 0.0833
  }],
  0x1D448: [.683, .022, .683, {
    ic: .084,
    sk: 0.0278
  }],
  0x1D449: [.683, .022, .583, {
    ic: .186
  }],
  0x1D44A: [.683, .022, .944, {
    ic: .104
  }],
  0x1D44B: [.683, 0, .828, {
    sk: 0.0833
  }],
  0x1D44C: [.683, 0, .581, {
    ic: .182
  }],
  0x1D44D: [.683, 0, .683, {
    sk: 0.0833
  }],
  0x1D44E: [.441, .01, .529],
  0x1D44F: [.694, .011, .429],
  0x1D450: [.442, .011, .433, {
    sk: 0.0556
  }],
  0x1D451: [.694, .01, .52, {
    sk: 0.167
  }],
  0x1D452: [.442, .011, .466, {
    sk: 0.0556
  }],
  0x1D453: [.705, .205, .49, {
    ic: .06,
    sk: 0.167
  }],
  0x1D454: [.442, .205, .477, {
    sk: 0.0278
  }],
  0x1D455: [.694, .011, .576, {
    sk: -0.0278
  }],
  0x1D456: [.661, .011, .345],
  0x1D457: [.661, .204, .412],
  0x1D458: [.694, .011, .521],
  0x1D459: [.694, .011, .298, {
    sk: 0.0833
  }],
  0x1D45A: [.442, .011, .878],
  0x1D45B: [.442, .011, .6],
  0x1D45C: [.441, .011, .485, {
    sk: 0.0556
  }],
  0x1D45D: [.442, .194, .503, {
    sk: 0.0833
  }],
  0x1D45E: [.442, .194, .446, {
    sk: 0.0833
  }],
  0x1D45F: [.442, .011, .451, {
    sk: 0.0556
  }],
  0x1D460: [.442, .01, .469, {
    sk: 0.0556
  }],
  0x1D461: [.626, .011, .361, {
    sk: 0.0833
  }],
  0x1D462: [.442, .011, .572, {
    sk: 0.0278
  }],
  0x1D463: [.443, .011, .485, {
    sk: 0.0278
  }],
  0x1D464: [.443, .011, .716, {
    sk: 0.0833
  }],
  0x1D465: [.442, .011, .572, {
    sk: 0.0278
  }],
  0x1D466: [.442, .205, .49, {
    sk: 0.0556
  }],
  0x1D467: [.442, .011, .465, {
    sk: 0.0556
  }],
  0x1D468: [.711, 0, .869, {
    sk: 0.16
  }],
  0x1D469: [.686, 0, .866, {
    sk: 0.0958
  }],
  0x1D46A: [.703, .017, .817, {
    sk: 0.0958
  }],
  0x1D46B: [.686, 0, .938, {
    sk: 0.0639
  }],
  0x1D46C: [.68, 0, .81, {
    sk: 0.0958
  }],
  0x1D46D: [.68, 0, .689, {
    ic: .12,
    sk: 0.0958
  }],
  0x1D46E: [.703, .016, .887, {
    sk: 0.0958
  }],
  0x1D46F: [.686, 0, .982, {
    sk: 0.0639
  }],
  0x1D470: [.686, 0, .511, {
    ic: .062,
    sk: 0.128
  }],
  0x1D471: [.686, .017, .631, {
    ic: .063,
    sk: 0.192
  }],
  0x1D472: [.686, 0, .971, {
    sk: 0.0639
  }],
  0x1D473: [.686, 0, .756, {
    sk: 0.0319
  }],
  0x1D474: [.686, 0, 1.142, {
    ic: .077,
    sk: 0.0958
  }],
  0x1D475: [.686, 0, .95, {
    ic: .077,
    sk: 0.0958
  }],
  0x1D476: [.703, .017, .837, {
    sk: 0.0958
  }],
  0x1D477: [.686, 0, .723, {
    ic: .124,
    sk: 0.0958
  }],
  0x1D478: [.703, .194, .869, {
    sk: 0.0958
  }],
  0x1D479: [.686, .017, .872, {
    sk: 0.0958
  }],
  0x1D47A: [.703, .017, .693, {
    sk: 0.0958
  }],
  0x1D47B: [.675, 0, .637, {
    ic: .135,
    sk: 0.0958
  }],
  0x1D47C: [.686, .016, .8, {
    ic: .077,
    sk: 0.0319
  }],
  0x1D47D: [.686, .016, .678, {
    ic: .208
  }],
  0x1D47E: [.686, .017, 1.093, {
    ic: .114
  }],
  0x1D47F: [.686, 0, .947, {
    sk: 0.0958
  }],
  0x1D480: [.686, 0, .675, {
    ic: .201
  }],
  0x1D481: [.686, 0, .773, {
    sk: 0.0958
  }],
  0x1D482: [.452, .008, .633],
  0x1D483: [.694, .008, .521],
  0x1D484: [.451, .008, .513, {
    sk: 0.0639
  }],
  0x1D485: [.694, .008, .61, {
    sk: 0.192
  }],
  0x1D486: [.452, .008, .554, {
    sk: 0.0639
  }],
  0x1D487: [.701, .201, .568, {
    ic: .056,
    sk: 0.192
  }],
  0x1D488: [.452, .202, .545, {
    sk: 0.0319
  }],
  0x1D489: [.694, .008, .668, {
    sk: -0.0319
  }],
  0x1D48A: [.694, .008, .405],
  0x1D48B: [.694, .202, .471],
  0x1D48C: [.694, .008, .604],
  0x1D48D: [.694, .008, .348, {
    sk: 0.0958
  }],
  0x1D48E: [.452, .008, 1.032],
  0x1D48F: [.452, .008, .713],
  0x1D490: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x1D491: [.452, .194, .601, {
    sk: 0.0958
  }],
  0x1D492: [.452, .194, .542, {
    sk: 0.0958
  }],
  0x1D493: [.452, .008, .529, {
    sk: 0.0639
  }],
  0x1D494: [.451, .008, .531, {
    sk: 0.0639
  }],
  0x1D495: [.643, .007, .415, {
    sk: 0.0958
  }],
  0x1D496: [.452, .008, .681, {
    sk: 0.0319
  }],
  0x1D497: [.453, .008, .567, {
    sk: 0.0319
  }],
  0x1D498: [.453, .008, .831, {
    sk: 0.0958
  }],
  0x1D499: [.452, .008, .659, {
    sk: 0.0319
  }],
  0x1D49A: [.452, .202, .59, {
    sk: 0.0639
  }],
  0x1D49B: [.452, .008, .555, {
    sk: 0.0639
  }],
  0x1D49C: [.717, .008, .803, {
    ic: .213,
    sk: 0.389
  }],
  0x1D49D: [.708, .028, .908, {
    sk: 0.194
  }],
  0x1D49E: [.728, .026, .666, {
    ic: .153,
    sk: 0.278
  }],
  0x1D49F: [.708, .031, .774, {
    ic: .081,
    sk: 0.111
  }],
  0x1D4A0: [.707, .008, .562, {
    ic: .156,
    sk: 0.139
  }],
  0x1D4A1: [.735, .036, .895, {
    ic: .095,
    sk: 0.222
  }],
  0x1D4A2: [.717, .037, .61, {
    ic: .128,
    sk: 0.25
  }],
  0x1D4A3: [.717, .036, .969, {
    ic: .272,
    sk: 0.333
  }],
  0x1D4A4: [.717, .017, .809, {
    ic: .137,
    sk: 0.333
  }],
  0x1D4A5: [.717, .314, 1.052, {
    ic: .081,
    sk: 0.417
  }],
  0x1D4A6: [.717, .037, .914, {
    ic: .29,
    sk: 0.361
  }],
  0x1D4A7: [.717, .017, .874, {
    ic: .161,
    sk: 0.306
  }],
  0x1D4A8: [.721, .05, 1.08, {
    ic: .136,
    sk: 0.444
  }],
  0x1D4A9: [.726, .036, .902, {
    ic: .306,
    sk: 0.389
  }],
  0x1D4AA: [.707, .008, .738, {
    ic: .067,
    sk: 0.167
  }],
  0x1D4AB: [.716, .037, 1.013, {
    sk: 0.222
  }],
  0x1D4AC: [.717, .017, .883, {
    sk: 0.278
  }],
  0x1D4AD: [.717, .017, .85, {
    sk: 0.194
  }],
  0x1D4AE: [.708, .036, .868, {
    ic: .148,
    sk: 0.333
  }],
  0x1D4AF: [.735, .037, .747, {
    ic: .249,
    sk: 0.222
  }],
  0x1D4B0: [.717, .017, .8, {
    ic: .16,
    sk: 0.25
  }],
  0x1D4B1: [.717, .017, .622, {
    ic: .228,
    sk: 0.222
  }],
  0x1D4B2: [.717, .017, .805, {
    ic: .221,
    sk: 0.25
  }],
  0x1D4B3: [.717, .017, .944, {
    ic: .187,
    sk: 0.278
  }],
  0x1D4B4: [.716, .017, .71, {
    ic: .249,
    sk: 0.194
  }],
  0x1D4B5: [.717, .016, .821, {
    ic: .211,
    sk: 0.306
  }],
  0x1D4B6: [.441, .01, .529],
  0x1D4B7: [.694, .011, .429],
  0x1D4B8: [.442, .011, .433, {
    sk: 0.0556
  }],
  0x1D4B9: [.694, .01, .52, {
    sk: 0.167
  }],
  0x1D4BA: [.442, .011, .466, {
    sk: 0.0556
  }],
  0x1D4BB: [.705, .205, .49, {
    ic: .06,
    sk: 0.167
  }],
  0x1D4BC: [.442, .205, .477, {
    sk: 0.0278
  }],
  0x1D4BD: [.694, .011, .576, {
    sk: -0.0278
  }],
  0x1D4BE: [.661, .011, .345],
  0x1D4BF: [.661, .204, .412],
  0x1D4C0: [.694, .011, .521],
  0x1D4C1: [.694, .011, .298, {
    sk: 0.0833
  }],
  0x1D4C2: [.442, .011, .878],
  0x1D4C3: [.442, .011, .6],
  0x1D4C4: [.441, .011, .485, {
    sk: 0.0556
  }],
  0x1D4C5: [.442, .194, .503, {
    sk: 0.0833
  }],
  0x1D4C6: [.442, .194, .446, {
    sk: 0.0833
  }],
  0x1D4C7: [.442, .011, .451, {
    sk: 0.0556
  }],
  0x1D4C8: [.442, .01, .469, {
    sk: 0.0556
  }],
  0x1D4C9: [.626, .011, .361, {
    sk: 0.0833
  }],
  0x1D4CA: [.442, .011, .572, {
    sk: 0.0278
  }],
  0x1D4CB: [.443, .011, .485, {
    sk: 0.0278
  }],
  0x1D4CC: [.443, .011, .716, {
    sk: 0.0833
  }],
  0x1D4CD: [.442, .011, .572, {
    sk: 0.0278
  }],
  0x1D4CE: [.442, .205, .49, {
    sk: 0.0556
  }],
  0x1D4CF: [.442, .011, .465, {
    sk: 0.0556
  }],
  0x1D4D0: [.717, .008, .803, {
    ic: .213,
    sk: 0.389
  }],
  0x1D4D1: [.708, .028, .908, {
    sk: 0.194
  }],
  0x1D4D2: [.728, .026, .666, {
    ic: .153,
    sk: 0.278
  }],
  0x1D4D3: [.708, .031, .774, {
    ic: .081,
    sk: 0.111
  }],
  0x1D4D4: [.707, .008, .562, {
    ic: .156,
    sk: 0.139
  }],
  0x1D4D5: [.735, .036, .895, {
    ic: .095,
    sk: 0.222
  }],
  0x1D4D6: [.717, .037, .61, {
    ic: .128,
    sk: 0.25
  }],
  0x1D4D7: [.717, .036, .969, {
    ic: .272,
    sk: 0.333
  }],
  0x1D4D8: [.717, .017, .809, {
    ic: .137,
    sk: 0.333
  }],
  0x1D4D9: [.717, .314, 1.052, {
    ic: .081,
    sk: 0.417
  }],
  0x1D4DA: [.717, .037, .914, {
    ic: .29,
    sk: 0.361
  }],
  0x1D4DB: [.717, .017, .874, {
    ic: .161,
    sk: 0.306
  }],
  0x1D4DC: [.721, .05, 1.08, {
    ic: .136,
    sk: 0.444
  }],
  0x1D4DD: [.726, .036, .902, {
    ic: .306,
    sk: 0.389
  }],
  0x1D4DE: [.707, .008, .738, {
    ic: .067,
    sk: 0.167
  }],
  0x1D4DF: [.716, .037, 1.013, {
    sk: 0.222
  }],
  0x1D4E0: [.717, .017, .883, {
    sk: 0.278
  }],
  0x1D4E1: [.717, .017, .85, {
    sk: 0.194
  }],
  0x1D4E2: [.708, .036, .868, {
    ic: .148,
    sk: 0.333
  }],
  0x1D4E3: [.735, .037, .747, {
    ic: .249,
    sk: 0.222
  }],
  0x1D4E4: [.717, .017, .8, {
    ic: .16,
    sk: 0.25
  }],
  0x1D4E5: [.717, .017, .622, {
    ic: .228,
    sk: 0.222
  }],
  0x1D4E6: [.717, .017, .805, {
    ic: .221,
    sk: 0.25
  }],
  0x1D4E7: [.717, .017, .944, {
    ic: .187,
    sk: 0.278
  }],
  0x1D4E8: [.716, .017, .71, {
    ic: .249,
    sk: 0.194
  }],
  0x1D4E9: [.717, .016, .821, {
    ic: .211,
    sk: 0.306
  }],
  0x1D4EA: [.452, .008, .633],
  0x1D4EB: [.694, .008, .521],
  0x1D4EC: [.451, .008, .513, {
    sk: 0.0639
  }],
  0x1D4ED: [.694, .008, .61, {
    sk: 0.192
  }],
  0x1D4EE: [.452, .008, .554, {
    sk: 0.0639
  }],
  0x1D4EF: [.701, .201, .568, {
    ic: .056,
    sk: 0.192
  }],
  0x1D4F0: [.452, .202, .545, {
    sk: 0.0319
  }],
  0x1D4F1: [.694, .008, .668, {
    sk: -0.0319
  }],
  0x1D4F2: [.694, .008, .405],
  0x1D4F3: [.694, .202, .471],
  0x1D4F4: [.694, .008, .604],
  0x1D4F5: [.694, .008, .348, {
    sk: 0.0958
  }],
  0x1D4F6: [.452, .008, 1.032],
  0x1D4F7: [.452, .008, .713],
  0x1D4F8: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x1D4F9: [.452, .194, .601, {
    sk: 0.0958
  }],
  0x1D4FA: [.452, .194, .542, {
    sk: 0.0958
  }],
  0x1D4FB: [.452, .008, .529, {
    sk: 0.0639
  }],
  0x1D4FC: [.451, .008, .531, {
    sk: 0.0639
  }],
  0x1D4FD: [.643, .007, .415, {
    sk: 0.0958
  }],
  0x1D4FE: [.452, .008, .681, {
    sk: 0.0319
  }],
  0x1D4FF: [.453, .008, .567, {
    sk: 0.0319
  }],
  0x1D500: [.453, .008, .831, {
    sk: 0.0958
  }],
  0x1D501: [.452, .008, .659, {
    sk: 0.0319
  }],
  0x1D502: [.452, .202, .59, {
    sk: 0.0639
  }],
  0x1D503: [.452, .008, .555, {
    sk: 0.0639
  }],
  0x1D504: [.696, .026, .718],
  0x1D505: [.691, .027, .884],
  0x1D506: [.685, .024, .613],
  0x1D507: [.685, .027, .832],
  0x1D508: [.685, .024, .663],
  0x1D509: [.686, .153, .611],
  0x1D50A: [.69, .026, .785],
  0x1D50B: [.666, .133, .72],
  0x1D50C: [.686, .026, .554],
  0x1D50D: [.686, .139, .552],
  0x1D50E: [.68, .027, .668],
  0x1D50F: [.686, .026, .666],
  0x1D510: [.692, .027, 1.05],
  0x1D511: [.686, .025, .832],
  0x1D512: [.729, .027, .827],
  0x1D513: [.692, .218, .828],
  0x1D514: [.729, .069, .827],
  0x1D515: [.686, .026, .828],
  0x1D516: [.692, .027, .829],
  0x1D517: [.701, .027, .669],
  0x1D518: [.697, .027, .646],
  0x1D519: [.686, .026, .831],
  0x1D51A: [.686, .027, 1.046],
  0x1D51B: [.688, .027, .719],
  0x1D51C: [.686, .218, .833],
  0x1D51D: [.729, .139, .602],
  0x1D51E: [.47, .035, .5],
  0x1D51F: [.685, .031, .513],
  0x1D520: [.466, .029, .389],
  0x1D521: [.609, .033, .499],
  0x1D522: [.467, .03, .401],
  0x1D523: [.681, .221, .326],
  0x1D524: [.47, .209, .504],
  0x1D525: [.688, .205, .521],
  0x1D526: [.673, .02, .279],
  0x1D527: [.672, .208, .281],
  0x1D528: [.689, .025, .389],
  0x1D529: [.685, .02, .28],
  0x1D52A: [.475, .026, .767],
  0x1D52B: [.475, .022, .527],
  0x1D52C: [.48, .028, .489],
  0x1D52D: [.541, .212, .5],
  0x1D52E: [.479, .219, .489],
  0x1D52F: [.474, .021, .389],
  0x1D530: [.478, .029, .443],
  0x1D531: [.64, .02, .333],
  0x1D532: [.474, .023, .517],
  0x1D533: [.53, .028, .512],
  0x1D534: [.532, .028, .774],
  0x1D535: [.472, .188, .389],
  0x1D536: [.528, .218, .499],
  0x1D537: [.471, .214, .391],
  0x1D538: [.701, 0, .722],
  0x1D539: [.683, 0, .667],
  0x1D53A: [.702, .019, .722],
  0x1D53B: [.683, 0, .722],
  0x1D53C: [.683, 0, .667],
  0x1D53D: [.683, 0, .611],
  0x1D53E: [.702, .019, .778],
  0x1D53F: [.683, 0, .778],
  0x1D540: [.683, 0, .389],
  0x1D541: [.683, .077, .5],
  0x1D542: [.683, 0, .778],
  0x1D543: [.683, 0, .667],
  0x1D544: [.683, 0, .944],
  0x1D545: [.683, .02, .722],
  0x1D546: [.701, .019, .778],
  0x1D547: [.683, 0, .611],
  0x1D548: [.701, .181, .778],
  0x1D549: [.683, 0, .722],
  0x1D54A: [.702, .012, .556],
  0x1D54B: [.683, 0, .667],
  0x1D54C: [.683, .019, .722],
  0x1D54D: [.683, .02, .722],
  0x1D54E: [.683, .019, 1],
  0x1D54F: [.683, 0, .722],
  0x1D550: [.683, 0, .722],
  0x1D551: [.683, 0, .667],
  0x1D552: [.453, .006, .559],
  0x1D553: [.694, .006, .639],
  0x1D554: [.453, .006, .511],
  0x1D555: [.694, .006, .639],
  0x1D556: [.452, .006, .527],
  0x1D557: [.7, 0, .351, {
    ic: .101
  }],
  0x1D558: [.455, .201, .575],
  0x1D559: [.694, 0, .639],
  0x1D55A: [.695, 0, .319],
  0x1D55B: [.695, .2, .351],
  0x1D55C: [.683, 0, .556],
  0x1D55D: [.694, 0, .319],
  0x1D55E: [.45, 0, .958],
  0x1D55F: [.45, 0, .639],
  0x1D560: [.452, .005, .575],
  0x1D561: [.45, .194, .639],
  0x1D562: [.45, .194, .607],
  0x1D563: [.45, 0, .474],
  0x1D564: [.453, .006, .454],
  0x1D565: [.635, .005, .447],
  0x1D566: [.45, .006, .639],
  0x1D567: [.444, 0, .607],
  0x1D568: [.444, 0, .831],
  0x1D569: [.444, 0, .607],
  0x1D56A: [.444, .2, .607],
  0x1D56B: [.444, 0, .511],
  0x1D56C: [.686, .031, .847],
  0x1D56D: [.684, .031, 1.044],
  0x1D56E: [.676, .032, .723],
  0x1D56F: [.683, .029, .982],
  0x1D570: [.686, .029, .783],
  0x1D571: [.684, .146, .722],
  0x1D572: [.687, .029, .927],
  0x1D573: [.683, .126, .851],
  0x1D574: [.681, .025, .655],
  0x1D575: [.68, .141, .652],
  0x1D576: [.681, .026, .789],
  0x1D577: [.683, .028, .786],
  0x1D578: [.683, .032, 1.239],
  0x1D579: [.679, .03, .983],
  0x1D57A: [.726, .03, .976],
  0x1D57B: [.688, .223, .977],
  0x1D57C: [.726, .083, .976],
  0x1D57D: [.688, .028, .978],
  0x1D57E: [.685, .031, .978],
  0x1D57F: [.686, .03, .79],
  0x1D580: [.688, .039, .851],
  0x1D581: [.685, .029, .982],
  0x1D582: [.683, .03, 1.235],
  0x1D583: [.681, .035, .849],
  0x1D584: [.688, .214, .984],
  0x1D585: [.677, .148, .711],
  0x1D586: [.472, .032, .603],
  0x1D587: [.69, .032, .59],
  0x1D588: [.473, .026, .464],
  0x1D589: [.632, .028, .589],
  0x1D58A: [.471, .027, .472],
  0x1D58B: [.687, .222, .388],
  0x1D58C: [.472, .208, .595],
  0x1D58D: [.687, .207, .615],
  0x1D58E: [.686, .025, .331],
  0x1D58F: [.682, .203, .332],
  0x1D590: [.682, .025, .464],
  0x1D591: [.681, .024, .337],
  0x1D592: [.476, .031, .921],
  0x1D593: [.473, .028, .654],
  0x1D594: [.482, .034, .609],
  0x1D595: [.557, .207, .604],
  0x1D596: [.485, .211, .596],
  0x1D597: [.472, .026, .46],
  0x1D598: [.479, .034, .523],
  0x1D599: [.648, .027, .393],
  0x1D59A: [.472, .032, .589],
  0x1D59B: [.546, .027, .604],
  0x1D59C: [.549, .032, .918],
  0x1D59D: [.471, .188, .459],
  0x1D59E: [.557, .221, .589],
  0x1D59F: [.471, .214, .461],
  0x1D5A0: [.694, 0, .667],
  0x1D5A1: [.694, 0, .667],
  0x1D5A2: [.705, .011, .639],
  0x1D5A3: [.694, 0, .722],
  0x1D5A4: [.691, 0, .597],
  0x1D5A5: [.691, 0, .569],
  0x1D5A6: [.704, .011, .667],
  0x1D5A7: [.694, 0, .708],
  0x1D5A8: [.694, 0, .278],
  0x1D5A9: [.694, .022, .472],
  0x1D5AA: [.694, 0, .694],
  0x1D5AB: [.694, 0, .542],
  0x1D5AC: [.694, 0, .875],
  0x1D5AD: [.694, 0, .708],
  0x1D5AE: [.715, .022, .736],
  0x1D5AF: [.694, 0, .639],
  0x1D5B0: [.715, .125, .736],
  0x1D5B1: [.694, 0, .646],
  0x1D5B2: [.716, .022, .556],
  0x1D5B3: [.688, 0, .681],
  0x1D5B4: [.694, .022, .688],
  0x1D5B5: [.694, 0, .667],
  0x1D5B6: [.694, 0, .944],
  0x1D5B7: [.694, 0, .667],
  0x1D5B8: [.694, 0, .667],
  0x1D5B9: [.694, 0, .611],
  0x1D5BA: [.46, .01, .481],
  0x1D5BB: [.694, .011, .517],
  0x1D5BC: [.46, .01, .444],
  0x1D5BD: [.694, .01, .517],
  0x1D5BE: [.461, .01, .444],
  0x1D5BF: [.705, 0, .306],
  0x1D5C0: [.455, .206, .5],
  0x1D5C1: [.694, 0, .517],
  0x1D5C2: [.68, 0, .239],
  0x1D5C3: [.68, .205, .267],
  0x1D5C4: [.694, 0, .489],
  0x1D5C5: [.694, 0, .239],
  0x1D5C6: [.455, 0, .794],
  0x1D5C7: [.455, 0, .517],
  0x1D5C8: [.46, .01, .5],
  0x1D5C9: [.455, .194, .517],
  0x1D5CA: [.455, .194, .517],
  0x1D5CB: [.455, 0, .342],
  0x1D5CC: [.46, .01, .383],
  0x1D5CD: [.571, .01, .361],
  0x1D5CE: [.444, .01, .517],
  0x1D5CF: [.444, 0, .461],
  0x1D5D0: [.444, 0, .683],
  0x1D5D1: [.444, 0, .461],
  0x1D5D2: [.444, .204, .461],
  0x1D5D3: [.444, 0, .435],
  0x1D5D4: [.694, 0, .733],
  0x1D5D5: [.694, 0, .733],
  0x1D5D6: [.704, .011, .703],
  0x1D5D7: [.694, 0, .794],
  0x1D5D8: [.691, 0, .642],
  0x1D5D9: [.691, 0, .611],
  0x1D5DA: [.705, .011, .733],
  0x1D5DB: [.694, 0, .794],
  0x1D5DC: [.694, 0, .331],
  0x1D5DD: [.694, .022, .519],
  0x1D5DE: [.694, 0, .764],
  0x1D5DF: [.694, 0, .581],
  0x1D5E0: [.694, 0, .978],
  0x1D5E1: [.694, 0, .794],
  0x1D5E2: [.716, .022, .794],
  0x1D5E3: [.694, 0, .703],
  0x1D5E4: [.716, .106, .794],
  0x1D5E5: [.694, 0, .703],
  0x1D5E6: [.716, .022, .611],
  0x1D5E7: [.688, 0, .733],
  0x1D5E8: [.694, .022, .764],
  0x1D5E9: [.694, 0, .733],
  0x1D5EA: [.694, 0, 1.039],
  0x1D5EB: [.694, 0, .733],
  0x1D5EC: [.694, 0, .733],
  0x1D5ED: [.694, 0, .672],
  0x1D5EE: [.475, .011, .525],
  0x1D5EF: [.694, .01, .561],
  0x1D5F0: [.475, .011, .489],
  0x1D5F1: [.694, .011, .561],
  0x1D5F2: [.474, .01, .511],
  0x1D5F3: [.705, 0, .336],
  0x1D5F4: [.469, .206, .55],
  0x1D5F5: [.694, 0, .561],
  0x1D5F6: [.695, 0, .256],
  0x1D5F7: [.695, .205, .286],
  0x1D5F8: [.694, 0, .531],
  0x1D5F9: [.694, 0, .256],
  0x1D5FA: [.469, 0, .867],
  0x1D5FB: [.468, 0, .561],
  0x1D5FC: [.474, .011, .55],
  0x1D5FD: [.469, .194, .561],
  0x1D5FE: [.469, .194, .561],
  0x1D5FF: [.469, 0, .372],
  0x1D600: [.474, .01, .422],
  0x1D601: [.589, .01, .404],
  0x1D602: [.458, .011, .561],
  0x1D603: [.458, 0, .5],
  0x1D604: [.458, 0, .744],
  0x1D605: [.458, 0, .5],
  0x1D606: [.458, .205, .5],
  0x1D607: [.458, 0, .476],
  0x1D608: [.694, 0, .667],
  0x1D609: [.694, 0, .667],
  0x1D60A: [.705, .01, .639, {
    ic: .08
  }],
  0x1D60B: [.694, 0, .722],
  0x1D60C: [.691, 0, .597, {
    ic: .091
  }],
  0x1D60D: [.691, 0, .569, {
    ic: .104
  }],
  0x1D60E: [.705, .011, .667, {
    ic: .063
  }],
  0x1D60F: [.694, 0, .708, {
    ic: .06
  }],
  0x1D610: [.694, 0, .278, {
    ic: .06
  }],
  0x1D611: [.694, .022, .472, {
    ic: .063
  }],
  0x1D612: [.694, 0, .694, {
    ic: .091
  }],
  0x1D613: [.694, 0, .542],
  0x1D614: [.694, 0, .875, {
    ic: .054
  }],
  0x1D615: [.694, 0, .708, {
    ic: .058
  }],
  0x1D616: [.716, .022, .736],
  0x1D617: [.694, 0, .639, {
    ic: .051
  }],
  0x1D618: [.716, .125, .736],
  0x1D619: [.694, 0, .646, {
    ic: .052
  }],
  0x1D61A: [.716, .022, .556, {
    ic: .053
  }],
  0x1D61B: [.688, 0, .681, {
    ic: .109
  }],
  0x1D61C: [.694, .022, .688, {
    ic: .059
  }],
  0x1D61D: [.694, 0, .667, {
    ic: .132
  }],
  0x1D61E: [.694, 0, .944, {
    ic: .132
  }],
  0x1D61F: [.694, 0, .667, {
    ic: .091
  }],
  0x1D620: [.694, 0, .667, {
    ic: .143
  }],
  0x1D621: [.694, 0, .611, {
    ic: .091
  }],
  0x1D622: [.461, .01, .481],
  0x1D623: [.694, .011, .517],
  0x1D624: [.46, .011, .444, {
    ic: .055
  }],
  0x1D625: [.694, .01, .517, {
    ic: .071
  }],
  0x1D626: [.46, .011, .444],
  0x1D627: [.705, 0, .306, {
    ic: .188
  }],
  0x1D628: [.455, .206, .5, {
    ic: .068
  }],
  0x1D629: [.694, 0, .517],
  0x1D62A: [.68, 0, .239, {
    ic: .076
  }],
  0x1D62B: [.68, .204, .267, {
    ic: .069
  }],
  0x1D62C: [.694, 0, .489, {
    ic: .054
  }],
  0x1D62D: [.694, 0, .239, {
    ic: .072
  }],
  0x1D62E: [.455, 0, .794],
  0x1D62F: [.454, 0, .517],
  0x1D630: [.461, .011, .5],
  0x1D631: [.455, .194, .517],
  0x1D632: [.455, .194, .517],
  0x1D633: [.455, 0, .342, {
    ic: .082
  }],
  0x1D634: [.461, .011, .383, {
    ic: .053
  }],
  0x1D635: [.571, .011, .361],
  0x1D636: [.444, .01, .517],
  0x1D637: [.444, 0, .461, {
    ic: .079
  }],
  0x1D638: [.444, 0, .683, {
    ic: .079
  }],
  0x1D639: [.444, 0, .461, {
    ic: .076
  }],
  0x1D63A: [.444, .205, .461, {
    ic: .079
  }],
  0x1D63B: [.444, 0, .435, {
    ic: .059
  }],
  0x1D63C: [.694, 0, .667],
  0x1D63D: [.694, 0, .667],
  0x1D63E: [.705, .01, .639, {
    ic: .08
  }],
  0x1D63F: [.694, 0, .722],
  0x1D640: [.691, 0, .597, {
    ic: .091
  }],
  0x1D641: [.691, 0, .569, {
    ic: .104
  }],
  0x1D642: [.705, .011, .667, {
    ic: .063
  }],
  0x1D643: [.694, 0, .708, {
    ic: .06
  }],
  0x1D644: [.694, 0, .278, {
    ic: .06
  }],
  0x1D645: [.694, .022, .472, {
    ic: .063
  }],
  0x1D646: [.694, 0, .694, {
    ic: .091
  }],
  0x1D647: [.694, 0, .542],
  0x1D648: [.694, 0, .875, {
    ic: .054
  }],
  0x1D649: [.694, 0, .708, {
    ic: .058
  }],
  0x1D64A: [.716, .022, .736],
  0x1D64B: [.694, 0, .639, {
    ic: .051
  }],
  0x1D64C: [.716, .125, .736],
  0x1D64D: [.694, 0, .646, {
    ic: .052
  }],
  0x1D64E: [.716, .022, .556, {
    ic: .053
  }],
  0x1D64F: [.688, 0, .681, {
    ic: .109
  }],
  0x1D650: [.694, .022, .688, {
    ic: .059
  }],
  0x1D651: [.694, 0, .667, {
    ic: .132
  }],
  0x1D652: [.694, 0, .944, {
    ic: .132
  }],
  0x1D653: [.694, 0, .667, {
    ic: .091
  }],
  0x1D654: [.694, 0, .667, {
    ic: .143
  }],
  0x1D655: [.694, 0, .611, {
    ic: .091
  }],
  0x1D656: [.461, .01, .481],
  0x1D657: [.694, .011, .517],
  0x1D658: [.46, .011, .444, {
    ic: .055
  }],
  0x1D659: [.694, .01, .517, {
    ic: .071
  }],
  0x1D65A: [.46, .011, .444],
  0x1D65B: [.705, 0, .306, {
    ic: .188
  }],
  0x1D65C: [.455, .206, .5, {
    ic: .068
  }],
  0x1D65D: [.694, 0, .517],
  0x1D65E: [.68, 0, .239, {
    ic: .076
  }],
  0x1D65F: [.68, .204, .267, {
    ic: .069
  }],
  0x1D660: [.694, 0, .489, {
    ic: .054
  }],
  0x1D661: [.694, 0, .239, {
    ic: .072
  }],
  0x1D662: [.455, 0, .794],
  0x1D663: [.454, 0, .517],
  0x1D664: [.461, .011, .5],
  0x1D665: [.455, .194, .517],
  0x1D666: [.455, .194, .517],
  0x1D667: [.455, 0, .342, {
    ic: .082
  }],
  0x1D668: [.461, .011, .383, {
    ic: .053
  }],
  0x1D669: [.571, .011, .361],
  0x1D66A: [.444, .01, .517],
  0x1D66B: [.444, 0, .461, {
    ic: .079
  }],
  0x1D66C: [.444, 0, .683, {
    ic: .079
  }],
  0x1D66D: [.444, 0, .461, {
    ic: .076
  }],
  0x1D66E: [.444, .205, .461, {
    ic: .079
  }],
  0x1D66F: [.444, 0, .435, {
    ic: .059
  }],
  0x1D670: [.623, 0, .525],
  0x1D671: [.611, 0, .525],
  0x1D672: [.622, .011, .525],
  0x1D673: [.611, 0, .525],
  0x1D674: [.611, 0, .525],
  0x1D675: [.611, 0, .525],
  0x1D676: [.622, .011, .525],
  0x1D677: [.611, 0, .525],
  0x1D678: [.611, 0, .525],
  0x1D679: [.611, .011, .525],
  0x1D67A: [.611, 0, .525],
  0x1D67B: [.611, 0, .525],
  0x1D67C: [.611, 0, .525],
  0x1D67D: [.611, 0, .525],
  0x1D67E: [.621, .01, .525],
  0x1D67F: [.611, 0, .525],
  0x1D680: [.621, .138, .525],
  0x1D681: [.611, .011, .525],
  0x1D682: [.622, .011, .525],
  0x1D683: [.611, 0, .525],
  0x1D684: [.611, .011, .525],
  0x1D685: [.611, .007, .525],
  0x1D686: [.611, .007, .525],
  0x1D687: [.611, 0, .525],
  0x1D688: [.611, 0, .525],
  0x1D689: [.611, 0, .525],
  0x1D68A: [.439, .006, .525],
  0x1D68B: [.611, .006, .525],
  0x1D68C: [.44, .006, .525],
  0x1D68D: [.611, .006, .525],
  0x1D68E: [.44, .006, .525],
  0x1D68F: [.617, 0, .525],
  0x1D690: [.442, .229, .525],
  0x1D691: [.611, 0, .525],
  0x1D692: [.612, 0, .525],
  0x1D693: [.612, .228, .525],
  0x1D694: [.611, 0, .525],
  0x1D695: [.611, 0, .525],
  0x1D696: [.436, 0, .525],
  0x1D697: [.436, 0, .525],
  0x1D698: [.44, .006, .525],
  0x1D699: [.437, .221, .525],
  0x1D69A: [.437, .221, .525],
  0x1D69B: [.437, 0, .525],
  0x1D69C: [.44, .006, .525],
  0x1D69D: [.554, .006, .525],
  0x1D69E: [.431, .005, .525],
  0x1D69F: [.431, 0, .525],
  0x1D6A0: [.431, 0, .525],
  0x1D6A1: [.431, 0, .525],
  0x1D6A2: [.431, .228, .525],
  0x1D6A3: [.431, 0, .525],
  0x1D6A4: [.441, .01, .307],
  0x1D6A5: [.442, .204, .332],
  0x1D6A8: [.698, 0, .869],
  0x1D6A9: [.686, 0, .818],
  0x1D6AA: [.68, 0, .692],
  0x1D6AB: [.698, 0, .958],
  0x1D6AC: [.68, 0, .756],
  0x1D6AD: [.686, 0, .703],
  0x1D6AE: [.686, 0, .9],
  0x1D6AF: [.696, .01, .894],
  0x1D6B0: [.686, 0, .436],
  0x1D6B1: [.686, 0, .901],
  0x1D6B2: [.698, 0, .806],
  0x1D6B3: [.686, 0, 1.092],
  0x1D6B4: [.686, 0, .9],
  0x1D6B5: [.675, 0, .767],
  0x1D6B6: [.696, .01, .864],
  0x1D6B7: [.68, 0, .9],
  0x1D6B8: [.686, 0, .786],
  0x1D6B9: [.696, .01, .894],
  0x1D6BA: [.686, 0, .831],
  0x1D6BB: [.675, 0, .8],
  0x1D6BC: [.697, 0, .894],
  0x1D6BD: [.686, 0, .831],
  0x1D6BE: [.686, 0, .869],
  0x1D6BF: [.686, 0, .894],
  0x1D6C0: [.696, 0, .831],
  0x1D6C1: [.686, .024, .958],
  0x1D6C2: [.452, .008, .761, {
    sk: 0.0319
  }],
  0x1D6C3: [.701, .194, .66, {
    sk: 0.0958
  }],
  0x1D6C4: [.451, .211, .59],
  0x1D6C5: [.725, .008, .522, {
    sk: 0.0639
  }],
  0x1D6C6: [.461, .017, .529, {
    sk: 0.0958
  }],
  0x1D6C7: [.711, .202, .508, {
    sk: 0.0958
  }],
  0x1D6C8: [.452, .211, .6, {
    sk: 0.0639
  }],
  0x1D6C9: [.702, .008, .562, {
    sk: 0.0958
  }],
  0x1D6CA: [.452, .008, .412, {
    sk: 0.0639
  }],
  0x1D6CB: [.452, .008, .668],
  0x1D6CC: [.694, .013, .671],
  0x1D6CD: [.452, .211, .708, {
    sk: 0.0319
  }],
  0x1D6CE: [.452, 0, .577, {
    sk: 0.0319
  }],
  0x1D6CF: [.711, .201, .508, {
    sk: 0.128
  }],
  0x1D6D0: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x1D6D1: [.444, .008, .682],
  0x1D6D2: [.451, .211, .612, {
    sk: 0.0958
  }],
  0x1D6D3: [.451, .105, .424, {
    sk: 0.0958
  }],
  0x1D6D4: [.444, .008, .686],
  0x1D6D5: [.444, .013, .521, {
    ic: .089,
    sk: 0.0319
  }],
  0x1D6D6: [.453, .008, .631, {
    sk: 0.0319
  }],
  0x1D6D7: [.452, .216, .747, {
    sk: 0.0958
  }],
  0x1D6D8: [.452, .201, .718, {
    sk: 0.0639
  }],
  0x1D6D9: [.694, .202, .758, {
    sk: 0.128
  }],
  0x1D6DA: [.453, .008, .718],
  0x1D6DB: [.71, .017, .628, {
    sk: 0.0958
  }],
  0x1D6DC: [.444, .007, .483, {
    sk: 0.0639
  }],
  0x1D6DD: [.701, .008, .692, {
    sk: 0.0958
  }],
  0x1D6DE: [.434, .006, .667, {
    ic: .067
  }],
  0x1D6DF: [.694, .202, .712, {
    sk: 0.0958
  }],
  0x1D6E0: [.451, .194, .612, {
    sk: 0.0958
  }],
  0x1D6E1: [.444, .008, .975],
  0x1D6E2: [.716, 0, .75, {
    sk: 0.139
  }],
  0x1D6E3: [.683, 0, .759, {
    sk: 0.0833
  }],
  0x1D6E4: [.68, 0, .615, {
    ic: .106,
    sk: 0.0833
  }],
  0x1D6E5: [.716, 0, .833, {
    sk: 0.167
  }],
  0x1D6E6: [.68, 0, .738, {
    sk: 0.0833
  }],
  0x1D6E7: [.683, 0, .683, {
    sk: 0.0833
  }],
  0x1D6E8: [.683, 0, .831, {
    ic: .057,
    sk: 0.0556
  }],
  0x1D6E9: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x1D6EA: [.683, 0, .44, {
    ic: .064,
    sk: 0.111
  }],
  0x1D6EB: [.683, 0, .849, {
    sk: 0.0556
  }],
  0x1D6EC: [.716, 0, .694, {
    sk: 0.167
  }],
  0x1D6ED: [.683, 0, .97, {
    ic: .081,
    sk: 0.0833
  }],
  0x1D6EE: [.683, 0, .803, {
    ic: .085,
    sk: 0.0833
  }],
  0x1D6EF: [.677, 0, .742, {
    sk: 0.0833
  }],
  0x1D6F0: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x1D6F1: [.68, 0, .831, {
    ic: .056,
    sk: 0.0556
  }],
  0x1D6F2: [.683, 0, .642, {
    ic: .109,
    sk: 0.0833
  }],
  0x1D6F3: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x1D6F4: [.683, 0, .78, {
    sk: 0.0833
  }],
  0x1D6F5: [.677, 0, .584, {
    ic: .12,
    sk: 0.0833
  }],
  0x1D6F6: [.705, 0, .583, {
    ic: .117,
    sk: 0.0556
  }],
  0x1D6F7: [.683, 0, .667, {
    sk: 0.0833
  }],
  0x1D6F8: [.683, 0, .828, {
    sk: 0.0833
  }],
  0x1D6F9: [.683, 0, .612, {
    ic: .08,
    sk: 0.0556
  }],
  0x1D6FA: [.704, 0, .772, {
    sk: 0.0833
  }],
  0x1D6FB: [.683, .033, .833],
  0x1D6FC: [.442, .011, .64, {
    sk: 0.0278
  }],
  0x1D6FD: [.705, .194, .566, {
    sk: 0.0833
  }],
  0x1D6FE: [.441, .216, .518],
  0x1D6FF: [.717, .01, .444, {
    sk: 0.0556
  }],
  0x1D700: [.452, .022, .466, {
    sk: 0.0833
  }],
  0x1D701: [.704, .204, .438, {
    sk: 0.0833
  }],
  0x1D702: [.442, .216, .497, {
    sk: 0.0556
  }],
  0x1D703: [.705, .01, .469, {
    sk: 0.0833
  }],
  0x1D704: [.442, .01, .354, {
    sk: 0.0556
  }],
  0x1D705: [.442, .011, .576],
  0x1D706: [.694, .012, .583],
  0x1D707: [.442, .216, .603, {
    sk: 0.0278
  }],
  0x1D708: [.442, 0, .494, {
    sk: 0.0278
  }],
  0x1D709: [.704, .205, .438, {
    sk: 0.111
  }],
  0x1D70A: [.441, .011, .485, {
    sk: 0.0556
  }],
  0x1D70B: [.431, .011, .57],
  0x1D70C: [.442, .216, .517, {
    sk: 0.0833
  }],
  0x1D70D: [.442, .107, .363, {
    sk: 0.0833
  }],
  0x1D70E: [.431, .011, .571],
  0x1D70F: [.431, .013, .437, {
    ic: .08,
    sk: 0.0278
  }],
  0x1D710: [.443, .01, .54, {
    sk: 0.0278
  }],
  0x1D711: [.442, .218, .654, {
    sk: 0.0833
  }],
  0x1D712: [.442, .204, .626, {
    sk: 0.0556
  }],
  0x1D713: [.694, .205, .651, {
    sk: 0.111
  }],
  0x1D714: [.443, .011, .622],
  0x1D715: [.715, .022, .531, {
    sk: 0.0833
  }],
  0x1D716: [.431, .011, .406, {
    sk: 0.0556
  }],
  0x1D717: [.705, .011, .591, {
    sk: 0.0833
  }],
  0x1D718: [.434, .006, .667, {
    ic: .067
  }],
  0x1D719: [.694, .205, .596, {
    sk: 0.0833
  }],
  0x1D71A: [.442, .194, .517, {
    sk: 0.0833
  }],
  0x1D71B: [.431, .01, .828],
  0x1D71C: [.711, 0, .869, {
    sk: 0.16
  }],
  0x1D71D: [.686, 0, .866, {
    sk: 0.0958
  }],
  0x1D71E: [.68, 0, .657, {
    ic: .12,
    sk: 0.0958
  }],
  0x1D71F: [.711, 0, .958, {
    sk: 0.192
  }],
  0x1D720: [.68, 0, .81, {
    sk: 0.0958
  }],
  0x1D721: [.686, 0, .773, {
    sk: 0.0958
  }],
  0x1D722: [.686, 0, .982, {
    sk: 0.0639
  }],
  0x1D723: [.702, .017, .867, {
    sk: 0.0958
  }],
  0x1D724: [.686, 0, .511, {
    ic: .062,
    sk: 0.128
  }],
  0x1D725: [.686, 0, .971, {
    sk: 0.0639
  }],
  0x1D726: [.711, 0, .806, {
    sk: 0.192
  }],
  0x1D727: [.686, 0, 1.142, {
    ic: .077,
    sk: 0.0958
  }],
  0x1D728: [.686, 0, .95, {
    ic: .077,
    sk: 0.0958
  }],
  0x1D729: [.675, 0, .841, {
    sk: 0.0958
  }],
  0x1D72A: [.703, .017, .837, {
    sk: 0.0958
  }],
  0x1D72B: [.68, 0, .982, {
    sk: 0.0639
  }],
  0x1D72C: [.686, 0, .723, {
    ic: .124,
    sk: 0.0958
  }],
  0x1D72D: [.702, .017, .867, {
    sk: 0.0958
  }],
  0x1D72E: [.686, 0, .885, {
    sk: 0.0958
  }],
  0x1D72F: [.675, 0, .637, {
    ic: .135,
    sk: 0.0958
  }],
  0x1D730: [.703, 0, .671, {
    ic: .131,
    sk: 0.0639
  }],
  0x1D731: [.686, 0, .767, {
    sk: 0.0958
  }],
  0x1D732: [.686, 0, .947, {
    sk: 0.0958
  }],
  0x1D733: [.686, 0, .714, {
    ic: .076,
    sk: 0.0639
  }],
  0x1D734: [.703, 0, .879, {
    sk: 0.0958
  }],
  0x1D735: [.683, .033, .833],
  0x1D736: [.452, .008, .761, {
    sk: 0.0319
  }],
  0x1D737: [.701, .194, .66, {
    sk: 0.0958
  }],
  0x1D738: [.451, .211, .59],
  0x1D739: [.725, .008, .522, {
    sk: 0.0639
  }],
  0x1D73A: [.461, .017, .529, {
    sk: 0.0958
  }],
  0x1D73B: [.711, .202, .508, {
    sk: 0.0958
  }],
  0x1D73C: [.452, .211, .6, {
    sk: 0.0639
  }],
  0x1D73D: [.702, .008, .562, {
    sk: 0.0958
  }],
  0x1D73E: [.452, .008, .412, {
    sk: 0.0639
  }],
  0x1D73F: [.452, .008, .668],
  0x1D740: [.694, .013, .671],
  0x1D741: [.452, .211, .708, {
    sk: 0.0319
  }],
  0x1D742: [.452, 0, .577, {
    sk: 0.0319
  }],
  0x1D743: [.711, .201, .508, {
    sk: 0.128
  }],
  0x1D744: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x1D745: [.444, .008, .682],
  0x1D746: [.451, .211, .612, {
    sk: 0.0958
  }],
  0x1D747: [.451, .105, .424, {
    sk: 0.0958
  }],
  0x1D748: [.444, .008, .686],
  0x1D749: [.444, .013, .521, {
    ic: .089,
    sk: 0.0319
  }],
  0x1D74A: [.453, .008, .631, {
    sk: 0.0319
  }],
  0x1D74B: [.452, .216, .747, {
    sk: 0.0958
  }],
  0x1D74C: [.452, .201, .718, {
    sk: 0.0639
  }],
  0x1D74D: [.694, .202, .758, {
    sk: 0.128
  }],
  0x1D74E: [.453, .008, .718],
  0x1D74F: [.715, .022, .531, {
    sk: 0.0833
  }],
  0x1D750: [.444, .007, .483, {
    sk: 0.0639
  }],
  0x1D751: [.701, .008, .692, {
    sk: 0.0958
  }],
  0x1D752: [.434, .006, .667, {
    ic: .067
  }],
  0x1D753: [.694, .202, .712, {
    sk: 0.0958
  }],
  0x1D754: [.451, .194, .612, {
    sk: 0.0958
  }],
  0x1D755: [.444, .008, .975],
  0x1D756: [.694, 0, .733],
  0x1D757: [.694, 0, .733],
  0x1D758: [.691, 0, .581],
  0x1D759: [.694, 0, .917],
  0x1D75A: [.691, 0, .642],
  0x1D75B: [.694, 0, .672],
  0x1D75C: [.694, 0, .794],
  0x1D75D: [.716, .022, .856],
  0x1D75E: [.694, 0, .331],
  0x1D75F: [.694, 0, .764],
  0x1D760: [.694, 0, .672],
  0x1D761: [.694, 0, .978],
  0x1D762: [.694, 0, .794],
  0x1D763: [.688, 0, .733],
  0x1D764: [.716, .022, .794],
  0x1D765: [.691, 0, .794],
  0x1D766: [.694, 0, .703],
  0x1D767: [.716, .022, .856],
  0x1D768: [.694, 0, .794],
  0x1D769: [.688, 0, .733],
  0x1D76A: [.715, 0, .856],
  0x1D76B: [.694, 0, .794],
  0x1D76C: [.694, 0, .733],
  0x1D76D: [.694, 0, .856],
  0x1D76E: [.716, 0, .794],
  0x1D76F: [.683, .033, .833],
  0x1D770: [.452, .008, .761, {
    sk: 0.0319
  }],
  0x1D771: [.701, .194, .66, {
    sk: 0.0958
  }],
  0x1D772: [.451, .211, .59],
  0x1D773: [.725, .008, .522, {
    sk: 0.0639
  }],
  0x1D774: [.461, .017, .529, {
    sk: 0.0958
  }],
  0x1D775: [.711, .202, .508, {
    sk: 0.0958
  }],
  0x1D776: [.452, .211, .6, {
    sk: 0.0639
  }],
  0x1D777: [.702, .008, .562, {
    sk: 0.0958
  }],
  0x1D778: [.452, .008, .412, {
    sk: 0.0639
  }],
  0x1D779: [.452, .008, .668],
  0x1D77A: [.694, .013, .671],
  0x1D77B: [.452, .211, .708, {
    sk: 0.0319
  }],
  0x1D77C: [.452, 0, .577, {
    sk: 0.0319
  }],
  0x1D77D: [.711, .201, .508, {
    sk: 0.128
  }],
  0x1D77E: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x1D77F: [.444, .008, .682],
  0x1D780: [.451, .211, .612, {
    sk: 0.0958
  }],
  0x1D781: [.451, .105, .424, {
    sk: 0.0958
  }],
  0x1D782: [.444, .008, .686],
  0x1D783: [.444, .013, .521, {
    ic: .089,
    sk: 0.0319
  }],
  0x1D784: [.453, .008, .631, {
    sk: 0.0319
  }],
  0x1D785: [.452, .216, .747, {
    sk: 0.0958
  }],
  0x1D786: [.452, .201, .718, {
    sk: 0.0639
  }],
  0x1D787: [.694, .202, .758, {
    sk: 0.128
  }],
  0x1D788: [.453, .008, .718],
  0x1D789: [.715, .022, .531, {
    sk: 0.0833
  }],
  0x1D78A: [.444, .007, .483, {
    sk: 0.0639
  }],
  0x1D78B: [.701, .008, .692, {
    sk: 0.0958
  }],
  0x1D78C: [.434, .006, .667, {
    ic: .067
  }],
  0x1D78D: [.694, .202, .712, {
    sk: 0.0958
  }],
  0x1D78E: [.451, .194, .612, {
    sk: 0.0958
  }],
  0x1D78F: [.444, .008, .975],
  0x1D790: [.694, 0, .667],
  0x1D791: [.694, 0, .667],
  0x1D792: [.691, 0, .542, {
    ic: .104
  }],
  0x1D793: [.694, 0, .833],
  0x1D794: [.691, 0, .597, {
    ic: .091
  }],
  0x1D795: [.694, 0, .611, {
    ic: .091
  }],
  0x1D796: [.694, 0, .708, {
    ic: .06
  }],
  0x1D797: [.715, .022, .778],
  0x1D798: [.694, 0, .278, {
    ic: .06
  }],
  0x1D799: [.694, 0, .694, {
    ic: .091
  }],
  0x1D79A: [.694, 0, .611],
  0x1D79B: [.694, 0, .875, {
    ic: .054
  }],
  0x1D79C: [.694, 0, .708, {
    ic: .058
  }],
  0x1D79D: [.688, 0, .667, {
    ic: .098
  }],
  0x1D79E: [.716, .022, .736],
  0x1D79F: [.691, 0, .708, {
    ic: .06
  }],
  0x1D7A0: [.694, 0, .639, {
    ic: .051
  }],
  0x1D7A1: [.715, .022, .778],
  0x1D7A2: [.694, 0, .722, {
    ic: .091
  }],
  0x1D7A3: [.688, 0, .681, {
    ic: .109
  }],
  0x1D7A4: [.716, 0, .778, {
    ic: .065
  }],
  0x1D7A5: [.694, 0, .722],
  0x1D7A6: [.694, 0, .667, {
    ic: .091
  }],
  0x1D7A7: [.694, 0, .778, {
    ic: .076
  }],
  0x1D7A8: [.716, 0, .722],
  0x1D7A9: [.683, .033, .833],
  0x1D7AA: [.452, .008, .761, {
    sk: 0.0319
  }],
  0x1D7AB: [.701, .194, .66, {
    sk: 0.0958
  }],
  0x1D7AC: [.451, .211, .59],
  0x1D7AD: [.725, .008, .522, {
    sk: 0.0639
  }],
  0x1D7AE: [.461, .017, .529, {
    sk: 0.0958
  }],
  0x1D7AF: [.711, .202, .508, {
    sk: 0.0958
  }],
  0x1D7B0: [.452, .211, .6, {
    sk: 0.0639
  }],
  0x1D7B1: [.702, .008, .562, {
    sk: 0.0958
  }],
  0x1D7B2: [.452, .008, .412, {
    sk: 0.0639
  }],
  0x1D7B3: [.452, .008, .668],
  0x1D7B4: [.694, .013, .671],
  0x1D7B5: [.452, .211, .708, {
    sk: 0.0319
  }],
  0x1D7B6: [.452, 0, .577, {
    sk: 0.0319
  }],
  0x1D7B7: [.711, .201, .508, {
    sk: 0.128
  }],
  0x1D7B8: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x1D7B9: [.444, .008, .682],
  0x1D7BA: [.451, .211, .612, {
    sk: 0.0958
  }],
  0x1D7BB: [.451, .105, .424, {
    sk: 0.0958
  }],
  0x1D7BC: [.444, .008, .686],
  0x1D7BD: [.444, .013, .521, {
    ic: .089,
    sk: 0.0319
  }],
  0x1D7BE: [.453, .008, .631, {
    sk: 0.0319
  }],
  0x1D7BF: [.452, .216, .747, {
    sk: 0.0958
  }],
  0x1D7C0: [.452, .201, .718, {
    sk: 0.0639
  }],
  0x1D7C1: [.694, .202, .758, {
    sk: 0.128
  }],
  0x1D7C2: [.453, .008, .718],
  0x1D7C3: [.715, .022, .531, {
    sk: 0.0833
  }],
  0x1D7C4: [.444, .007, .483, {
    sk: 0.0639
  }],
  0x1D7C5: [.701, .008, .692, {
    sk: 0.0958
  }],
  0x1D7C6: [.434, .006, .667, {
    ic: .067
  }],
  0x1D7C7: [.694, .202, .712, {
    sk: 0.0958
  }],
  0x1D7C8: [.451, .194, .612, {
    sk: 0.0958
  }],
  0x1D7C9: [.444, .008, .975],
  0x1D7CA: [.68, 0, .643, {
    ic: .106,
    sk: 0.0833
  }],
  0x1D7CB: [.605, .085, .778],
  0x1D7CE: [.654, .01, .575],
  0x1D7CF: [.655, 0, .575],
  0x1D7D0: [.654, 0, .575],
  0x1D7D1: [.655, .011, .575],
  0x1D7D2: [.656, 0, .575],
  0x1D7D3: [.655, .011, .575],
  0x1D7D4: [.655, .011, .575],
  0x1D7D5: [.676, .011, .575],
  0x1D7D6: [.654, .011, .575],
  0x1D7D7: [.654, .011, .575],
  0x1D7D8: [.654, .01, .575],
  0x1D7D9: [.655, 0, .575],
  0x1D7DA: [.654, 0, .575],
  0x1D7DB: [.655, .011, .575],
  0x1D7DC: [.656, 0, .575],
  0x1D7DD: [.655, .011, .575],
  0x1D7DE: [.655, .011, .575],
  0x1D7DF: [.676, .011, .575],
  0x1D7E0: [.654, .011, .575],
  0x1D7E1: [.654, .011, .575],
  0x1D7E2: [.678, .022, .5],
  0x1D7E3: [.678, 0, .5],
  0x1D7E4: [.677, 0, .5],
  0x1D7E5: [.678, .022, .5],
  0x1D7E6: [.656, 0, .5],
  0x1D7E7: [.656, .021, .5],
  0x1D7E8: [.677, .022, .5],
  0x1D7E9: [.656, .011, .5],
  0x1D7EA: [.678, .022, .5],
  0x1D7EB: [.677, .022, .5],
  0x1D7EC: [.715, .022, .55],
  0x1D7ED: [.716, 0, .55],
  0x1D7EE: [.716, 0, .55],
  0x1D7EF: [.716, .022, .55],
  0x1D7F0: [.694, 0, .55],
  0x1D7F1: [.694, .022, .55],
  0x1D7F2: [.716, .022, .55],
  0x1D7F3: [.695, .011, .55],
  0x1D7F4: [.715, .022, .55],
  0x1D7F5: [.716, .022, .55],
  0x1D7F6: [.621, .01, .525],
  0x1D7F7: [.622, 0, .525],
  0x1D7F8: [.622, 0, .525],
  0x1D7F9: [.622, .011, .525],
  0x1D7FA: [.624, 0, .525],
  0x1D7FB: [.611, .01, .525],
  0x1D7FC: [.622, .011, .525],
  0x1D7FD: [.627, .01, .525],
  0x1D7FE: [.621, .01, .525],
  0x1D7FF: [.622, .011, .525]
};

/***/ }),
/* 316 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var sans_serif_bold_italic_js_1 = __webpack_require__(317);

exports.sansSerifBoldItalic = FontData_js_1.AddCSS(sans_serif_bold_italic_js_1.sansSerifBoldItalic, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x23: {
    c: '#'
  },
  0x24: {
    c: '$'
  },
  0x25: {
    c: '%'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3D: {
    c: '='
  },
  0x3F: {
    c: '?'
  },
  0x40: {
    c: '@'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x5F: {
    c: '_'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x7E: {
    c: '~'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x2015: {
    c: '\\2014'
  },
  0x2017: {
    c: '_'
  },
  0x2044: {
    c: '/'
  },
  0x2206: {
    c: '\\394'
  }
});

/***/ }),
/* 317 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.sansSerifBoldItalic = {
  0x20: [0, 0, .25],
  0x21: [.694, 0, .319],
  0x22: [.694, -0.471, .5],
  0x23: [.694, .194, .833],
  0x24: [.75, .056, .5, {
    ic: .065
  }],
  0x25: [.75, .056, .833],
  0x26: [.716, .022, .758],
  0x27: [.694, -0.471, .278, {
    ic: .057
  }],
  0x28: [.75, .25, .389, {
    ic: .102
  }],
  0x29: [.75, .25, .389],
  0x2A: [.75, -0.306, .5, {
    ic: .068
  }],
  0x2B: [.583, .083, .778],
  0x2C: [.098, .125, .278],
  0x2D: [.259, -0.186, .333],
  0x2E: [.098, 0, .278],
  0x2F: [.75, .25, .5, {
    ic: .1
  }],
  0x30: [.678, .022, .5],
  0x31: [.678, 0, .5],
  0x32: [.678, 0, .5, {
    ic: .051
  }],
  0x33: [.678, .022, .5],
  0x34: [.656, 0, .5],
  0x35: [.656, .022, .5, {
    ic: .055
  }],
  0x36: [.678, .022, .5],
  0x37: [.656, .011, .5, {
    ic: .096
  }],
  0x38: [.678, .022, .5, {
    ic: .054
  }],
  0x39: [.677, .022, .5],
  0x3A: [.444, 0, .278],
  0x3B: [.444, .125, .278],
  0x3D: [.37, -0.13, .778],
  0x3F: [.704, 0, .472, {
    ic: .064
  }],
  0x40: [.705, .01, .667],
  0x41: [.694, 0, .667],
  0x42: [.694, 0, .667],
  0x43: [.705, .01, .639, {
    ic: .08
  }],
  0x44: [.694, 0, .722],
  0x45: [.691, 0, .597, {
    ic: .091
  }],
  0x46: [.691, 0, .569, {
    ic: .104
  }],
  0x47: [.705, .011, .667, {
    ic: .063
  }],
  0x48: [.694, 0, .708, {
    ic: .06
  }],
  0x49: [.694, 0, .278, {
    ic: .06
  }],
  0x4A: [.694, .022, .472, {
    ic: .063
  }],
  0x4B: [.694, 0, .694, {
    ic: .091
  }],
  0x4C: [.694, 0, .542],
  0x4D: [.694, 0, .875, {
    ic: .054
  }],
  0x4E: [.694, 0, .708, {
    ic: .058
  }],
  0x4F: [.716, .022, .736],
  0x50: [.694, 0, .639, {
    ic: .051
  }],
  0x51: [.716, .125, .736],
  0x52: [.694, 0, .646, {
    ic: .052
  }],
  0x53: [.716, .022, .556, {
    ic: .053
  }],
  0x54: [.688, 0, .681, {
    ic: .109
  }],
  0x55: [.694, .022, .688, {
    ic: .059
  }],
  0x56: [.694, 0, .667, {
    ic: .132
  }],
  0x57: [.694, 0, .944, {
    ic: .132
  }],
  0x58: [.694, 0, .667, {
    ic: .091
  }],
  0x59: [.694, 0, .667, {
    ic: .143
  }],
  0x5A: [.694, 0, .611, {
    ic: .091
  }],
  0x5B: [.75, .25, .289, {
    ic: .136
  }],
  0x5D: [.75, .25, .289, {
    ic: .064
  }],
  0x5E: [.694, -0.527, .5],
  0x5F: [-0.038, .114, .5, {
    ic: .065
  }],
  0x61: [.461, .01, .481],
  0x62: [.694, .011, .517],
  0x63: [.46, .011, .444, {
    ic: .055
  }],
  0x64: [.694, .01, .517, {
    ic: .071
  }],
  0x65: [.46, .011, .444],
  0x66: [.705, 0, .306, {
    ic: .188
  }],
  0x67: [.455, .206, .5, {
    ic: .068
  }],
  0x68: [.694, 0, .517],
  0x69: [.68, 0, .239, {
    ic: .076
  }],
  0x6A: [.68, .204, .267, {
    ic: .069
  }],
  0x6B: [.694, 0, .489, {
    ic: .054
  }],
  0x6C: [.694, 0, .239, {
    ic: .072
  }],
  0x6D: [.455, 0, .794],
  0x6E: [.454, 0, .517],
  0x6F: [.461, .011, .5],
  0x70: [.455, .194, .517],
  0x71: [.455, .194, .517],
  0x72: [.455, 0, .342, {
    ic: .082
  }],
  0x73: [.461, .011, .383, {
    ic: .053
  }],
  0x74: [.571, .011, .361],
  0x75: [.444, .01, .517],
  0x76: [.444, 0, .461, {
    ic: .079
  }],
  0x77: [.444, 0, .683, {
    ic: .079
  }],
  0x78: [.444, 0, .461, {
    ic: .076
  }],
  0x79: [.444, .205, .461, {
    ic: .079
  }],
  0x7A: [.444, 0, .435, {
    ic: .059
  }],
  0x7E: [.327, -0.193, .5, {
    ic: .06
  }],
  0xA0: [0, 0, .25],
  0x131: [.444, 0, .239],
  0x237: [.444, .204, .267],
  0x300: [.694, -0.527, 0],
  0x301: [.694, -0.527, 0, {
    ic: .063
  }],
  0x302: [.694, -0.527, 0],
  0x303: [.677, -0.543, 0, {
    ic: .06
  }],
  0x304: [.631, -0.552, 0, {
    ic: .064
  }],
  0x306: [.694, -0.508, 0, {
    ic: .073
  }],
  0x307: [.68, -0.576, 0],
  0x308: [.68, -0.582, 0],
  0x30A: [.693, -0.527, 0],
  0x30B: [.694, -0.527, 0, {
    ic: .063
  }],
  0x30C: [.654, -0.487, 0, {
    ic: .06
  }],
  0x391: [.694, 0, .667],
  0x392: [.694, 0, .667],
  0x393: [.691, 0, .542, {
    ic: .104
  }],
  0x394: [.694, 0, .833],
  0x395: [.691, 0, .597, {
    ic: .091
  }],
  0x396: [.694, 0, .611, {
    ic: .091
  }],
  0x397: [.694, 0, .708, {
    ic: .06
  }],
  0x398: [.715, .022, .778],
  0x399: [.694, 0, .278, {
    ic: .06
  }],
  0x39A: [.694, 0, .694, {
    ic: .091
  }],
  0x39B: [.694, 0, .611],
  0x39C: [.694, 0, .875, {
    ic: .054
  }],
  0x39D: [.694, 0, .708, {
    ic: .058
  }],
  0x39E: [.688, 0, .667, {
    ic: .098
  }],
  0x39F: [.716, .022, .736],
  0x3A0: [.691, 0, .708, {
    ic: .06
  }],
  0x3A1: [.694, 0, .639, {
    ic: .051
  }],
  0x3A2: [.715, .022, .778],
  0x3A3: [.694, 0, .722, {
    ic: .091
  }],
  0x3A4: [.688, 0, .681, {
    ic: .109
  }],
  0x3A5: [.716, 0, .778, {
    ic: .065
  }],
  0x3A6: [.694, 0, .722],
  0x3A7: [.694, 0, .667, {
    ic: .091
  }],
  0x3A8: [.694, 0, .778, {
    ic: .076
  }],
  0x3A9: [.716, 0, .722],
  0x3D2: [.716, 0, .778, {
    ic: .065
  }],
  0x3DC: [.691, 0, .569, {
    ic: .104
  }],
  0x2013: [.312, -0.236, .5, {
    ic: .065
  }],
  0x2014: [.312, -0.236, 1, {
    ic: .065
  }],
  0x2015: [.312, -0.236, 1, {
    ic: .065
  }],
  0x2017: [-0.038, .114, .5, {
    ic: .065
  }],
  0x2018: [.694, -0.471, .278, {
    ic: .058
  }],
  0x2019: [.694, -0.471, .278, {
    ic: .057
  }],
  0x201C: [.694, -0.471, .5, {
    ic: .114
  }],
  0x201D: [.694, -0.471, .5],
  0x2044: [.75, .25, .5, {
    ic: .1
  }],
  0x2206: [.694, 0, .833]
};

/***/ }),
/* 318 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var sans_serif_bold_js_1 = __webpack_require__(319);

exports.sansSerifBold = FontData_js_1.AddCSS(sans_serif_bold_js_1.sansSerifBold, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x23: {
    c: '#'
  },
  0x24: {
    c: '$'
  },
  0x25: {
    c: '%'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3D: {
    c: '='
  },
  0x3F: {
    c: '?'
  },
  0x40: {
    c: '@'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x5F: {
    c: '_'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x7E: {
    c: '~'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x2015: {
    c: '\\2014'
  },
  0x2017: {
    c: '_'
  },
  0x2044: {
    c: '/'
  },
  0x2206: {
    c: '\\394'
  }
});

/***/ }),
/* 319 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.sansSerifBold = {
  0x20: [0, 0, .25],
  0x21: [.694, 0, .367],
  0x22: [.694, -0.442, .558],
  0x23: [.694, .193, .917],
  0x24: [.75, .056, .55],
  0x25: [.75, .056, 1.029],
  0x26: [.716, .022, .831],
  0x27: [.694, -0.442, .306],
  0x28: [.75, .249, .428],
  0x29: [.75, .25, .428],
  0x2A: [.75, -0.293, .55],
  0x2B: [.617, .116, .856],
  0x2C: [.146, .106, .306],
  0x2D: [.273, -0.186, .367],
  0x2E: [.146, 0, .306],
  0x2F: [.75, .249, .55],
  0x30: [.715, .022, .55],
  0x31: [.716, 0, .55],
  0x32: [.716, 0, .55],
  0x33: [.716, .022, .55],
  0x34: [.694, 0, .55],
  0x35: [.694, .022, .55],
  0x36: [.716, .022, .55],
  0x37: [.695, .011, .55],
  0x38: [.715, .022, .55],
  0x39: [.716, .022, .55],
  0x3A: [.458, 0, .306],
  0x3B: [.458, .106, .306],
  0x3D: [.407, -0.094, .856],
  0x3F: [.705, 0, .519],
  0x40: [.704, .011, .733],
  0x41: [.694, 0, .733],
  0x42: [.694, 0, .733],
  0x43: [.704, .011, .703],
  0x44: [.694, 0, .794],
  0x45: [.691, 0, .642],
  0x46: [.691, 0, .611],
  0x47: [.705, .011, .733],
  0x48: [.694, 0, .794],
  0x49: [.694, 0, .331],
  0x4A: [.694, .022, .519],
  0x4B: [.694, 0, .764],
  0x4C: [.694, 0, .581],
  0x4D: [.694, 0, .978],
  0x4E: [.694, 0, .794],
  0x4F: [.716, .022, .794],
  0x50: [.694, 0, .703],
  0x51: [.716, .106, .794],
  0x52: [.694, 0, .703],
  0x53: [.716, .022, .611],
  0x54: [.688, 0, .733],
  0x55: [.694, .022, .764],
  0x56: [.694, 0, .733],
  0x57: [.694, 0, 1.039],
  0x58: [.694, 0, .733],
  0x59: [.694, 0, .733],
  0x5A: [.694, 0, .672],
  0x5B: [.75, .25, .343],
  0x5D: [.75, .25, .343],
  0x5E: [.694, -0.537, .55],
  0x5F: [-0.023, .11, .55],
  0x61: [.475, .011, .525],
  0x62: [.694, .01, .561],
  0x63: [.475, .011, .489],
  0x64: [.694, .011, .561],
  0x65: [.474, .01, .511],
  0x66: [.705, 0, .336],
  0x67: [.469, .206, .55],
  0x68: [.694, 0, .561],
  0x69: [.695, 0, .256],
  0x6A: [.695, .205, .286],
  0x6B: [.694, 0, .531],
  0x6C: [.694, 0, .256],
  0x6D: [.469, 0, .867],
  0x6E: [.468, 0, .561],
  0x6F: [.474, .011, .55],
  0x70: [.469, .194, .561],
  0x71: [.469, .194, .561],
  0x72: [.469, 0, .372],
  0x73: [.474, .01, .422],
  0x74: [.589, .01, .404],
  0x75: [.458, .011, .561],
  0x76: [.458, 0, .5],
  0x77: [.458, 0, .744],
  0x78: [.458, 0, .5],
  0x79: [.458, .205, .5],
  0x7A: [.458, 0, .476],
  0x7E: [.344, -0.198, .55],
  0xA0: [0, 0, .25],
  0x131: [.458, 0, .256],
  0x237: [.458, .205, .286],
  0x300: [.694, -0.537, 0],
  0x301: [.694, -0.537, 0],
  0x302: [.694, -0.537, 0],
  0x303: [.694, -0.548, 0],
  0x304: [.66, -0.56, 0],
  0x306: [.694, -0.552, 0],
  0x307: [.695, -0.596, 0],
  0x308: [.695, -0.595, 0],
  0x30A: [.694, -0.538, 0],
  0x30B: [.694, -0.537, 0],
  0x30C: [.657, -0.5, 0],
  0x391: [.694, 0, .733],
  0x392: [.694, 0, .733],
  0x393: [.691, 0, .581],
  0x394: [.694, 0, .917],
  0x395: [.691, 0, .642],
  0x396: [.694, 0, .672],
  0x397: [.694, 0, .794],
  0x398: [.716, .022, .856],
  0x399: [.694, 0, .331],
  0x39A: [.694, 0, .764],
  0x39B: [.694, 0, .672],
  0x39C: [.694, 0, .978],
  0x39D: [.694, 0, .794],
  0x39E: [.688, 0, .733],
  0x39F: [.716, .022, .794],
  0x3A0: [.691, 0, .794],
  0x3A1: [.694, 0, .703],
  0x3A2: [.716, .022, .856],
  0x3A3: [.694, 0, .794],
  0x3A4: [.688, 0, .733],
  0x3A5: [.715, 0, .856],
  0x3A6: [.694, 0, .794],
  0x3A7: [.694, 0, .733],
  0x3A8: [.694, 0, .856],
  0x3A9: [.716, 0, .794],
  0x3D2: [.715, 0, .856],
  0x3DC: [.691, 0, .611],
  0x2013: [.327, -0.24, .55],
  0x2014: [.327, -0.24, 1.1],
  0x2015: [.327, -0.24, 1.1],
  0x2017: [-0.023, .11, .55],
  0x2018: [.694, -0.443, .306],
  0x2019: [.694, -0.442, .306],
  0x201C: [.694, -0.443, .558],
  0x201D: [.694, -0.442, .558],
  0x2044: [.75, .249, .55],
  0x2206: [.694, 0, .917]
};

/***/ }),
/* 320 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var sans_serif_italic_js_1 = __webpack_require__(321);

exports.sansSerifItalic = FontData_js_1.AddCSS(sans_serif_italic_js_1.sansSerifItalic, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x23: {
    c: '#'
  },
  0x24: {
    c: '$'
  },
  0x25: {
    c: '%'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3D: {
    c: '='
  },
  0x3F: {
    c: '?'
  },
  0x40: {
    c: '@'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x5F: {
    c: '_'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x7E: {
    c: '~'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x2015: {
    c: '\\2014'
  },
  0x2017: {
    c: '_'
  },
  0x2044: {
    c: '/'
  },
  0x2206: {
    c: '\\394'
  }
});

/***/ }),
/* 321 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.sansSerifItalic = {
  0x20: [0, 0, .25],
  0x21: [.694, 0, .319],
  0x22: [.694, -0.471, .5],
  0x23: [.694, .194, .833],
  0x24: [.75, .056, .5, {
    ic: .065
  }],
  0x25: [.75, .056, .833],
  0x26: [.716, .022, .758],
  0x27: [.694, -0.471, .278, {
    ic: .057
  }],
  0x28: [.75, .25, .389, {
    ic: .102
  }],
  0x29: [.75, .25, .389],
  0x2A: [.75, -0.306, .5, {
    ic: .068
  }],
  0x2B: [.583, .083, .778],
  0x2C: [.098, .125, .278],
  0x2D: [.259, -0.186, .333],
  0x2E: [.098, 0, .278],
  0x2F: [.75, .25, .5, {
    ic: .1
  }],
  0x30: [.678, .022, .5],
  0x31: [.678, 0, .5],
  0x32: [.678, 0, .5, {
    ic: .051
  }],
  0x33: [.678, .022, .5],
  0x34: [.656, 0, .5],
  0x35: [.656, .022, .5, {
    ic: .055
  }],
  0x36: [.678, .022, .5],
  0x37: [.656, .011, .5, {
    ic: .096
  }],
  0x38: [.678, .022, .5, {
    ic: .054
  }],
  0x39: [.677, .022, .5],
  0x3A: [.444, 0, .278],
  0x3B: [.444, .125, .278],
  0x3D: [.37, -0.13, .778],
  0x3F: [.704, 0, .472, {
    ic: .064
  }],
  0x40: [.705, .01, .667],
  0x41: [.694, 0, .667],
  0x42: [.694, 0, .667],
  0x43: [.705, .01, .639, {
    ic: .08
  }],
  0x44: [.694, 0, .722],
  0x45: [.691, 0, .597, {
    ic: .091
  }],
  0x46: [.691, 0, .569, {
    ic: .104
  }],
  0x47: [.705, .011, .667, {
    ic: .063
  }],
  0x48: [.694, 0, .708, {
    ic: .06
  }],
  0x49: [.694, 0, .278, {
    ic: .06
  }],
  0x4A: [.694, .022, .472, {
    ic: .063
  }],
  0x4B: [.694, 0, .694, {
    ic: .091
  }],
  0x4C: [.694, 0, .542],
  0x4D: [.694, 0, .875, {
    ic: .054
  }],
  0x4E: [.694, 0, .708, {
    ic: .058
  }],
  0x4F: [.716, .022, .736],
  0x50: [.694, 0, .639, {
    ic: .051
  }],
  0x51: [.716, .125, .736],
  0x52: [.694, 0, .646, {
    ic: .052
  }],
  0x53: [.716, .022, .556, {
    ic: .053
  }],
  0x54: [.688, 0, .681, {
    ic: .109
  }],
  0x55: [.694, .022, .688, {
    ic: .059
  }],
  0x56: [.694, 0, .667, {
    ic: .132
  }],
  0x57: [.694, 0, .944, {
    ic: .132
  }],
  0x58: [.694, 0, .667, {
    ic: .091
  }],
  0x59: [.694, 0, .667, {
    ic: .143
  }],
  0x5A: [.694, 0, .611, {
    ic: .091
  }],
  0x5B: [.75, .25, .289, {
    ic: .136
  }],
  0x5D: [.75, .25, .289, {
    ic: .064
  }],
  0x5E: [.694, -0.527, .5],
  0x5F: [-0.038, .114, .5, {
    ic: .065
  }],
  0x61: [.461, .01, .481],
  0x62: [.694, .011, .517],
  0x63: [.46, .011, .444, {
    ic: .055
  }],
  0x64: [.694, .01, .517, {
    ic: .071
  }],
  0x65: [.46, .011, .444],
  0x66: [.705, 0, .306, {
    ic: .188
  }],
  0x67: [.455, .206, .5, {
    ic: .068
  }],
  0x68: [.694, 0, .517],
  0x69: [.68, 0, .239, {
    ic: .076
  }],
  0x6A: [.68, .204, .267, {
    ic: .069
  }],
  0x6B: [.694, 0, .489, {
    ic: .054
  }],
  0x6C: [.694, 0, .239, {
    ic: .072
  }],
  0x6D: [.455, 0, .794],
  0x6E: [.454, 0, .517],
  0x6F: [.461, .011, .5],
  0x70: [.455, .194, .517],
  0x71: [.455, .194, .517],
  0x72: [.455, 0, .342, {
    ic: .082
  }],
  0x73: [.461, .011, .383, {
    ic: .053
  }],
  0x74: [.571, .011, .361],
  0x75: [.444, .01, .517],
  0x76: [.444, 0, .461, {
    ic: .079
  }],
  0x77: [.444, 0, .683, {
    ic: .079
  }],
  0x78: [.444, 0, .461, {
    ic: .076
  }],
  0x79: [.444, .205, .461, {
    ic: .079
  }],
  0x7A: [.444, 0, .435, {
    ic: .059
  }],
  0x7E: [.327, -0.193, .5, {
    ic: .06
  }],
  0xA0: [0, 0, .25],
  0x131: [.444, 0, .239],
  0x237: [.444, .204, .267],
  0x300: [.694, -0.527, 0],
  0x301: [.694, -0.527, 0, {
    ic: .063
  }],
  0x302: [.694, -0.527, 0],
  0x303: [.677, -0.543, 0, {
    ic: .06
  }],
  0x304: [.631, -0.552, 0, {
    ic: .064
  }],
  0x306: [.694, -0.508, 0, {
    ic: .073
  }],
  0x307: [.68, -0.576, 0],
  0x308: [.68, -0.582, 0],
  0x30A: [.693, -0.527, 0],
  0x30B: [.694, -0.527, 0, {
    ic: .063
  }],
  0x30C: [.654, -0.487, 0, {
    ic: .06
  }],
  0x391: [.694, 0, .667],
  0x392: [.694, 0, .667],
  0x393: [.691, 0, .542, {
    ic: .104
  }],
  0x394: [.694, 0, .833],
  0x395: [.691, 0, .597, {
    ic: .091
  }],
  0x396: [.694, 0, .611, {
    ic: .091
  }],
  0x397: [.694, 0, .708, {
    ic: .06
  }],
  0x398: [.715, .022, .778],
  0x399: [.694, 0, .278, {
    ic: .06
  }],
  0x39A: [.694, 0, .694, {
    ic: .091
  }],
  0x39B: [.694, 0, .611],
  0x39C: [.694, 0, .875, {
    ic: .054
  }],
  0x39D: [.694, 0, .708, {
    ic: .058
  }],
  0x39E: [.688, 0, .667, {
    ic: .098
  }],
  0x39F: [.716, .022, .736],
  0x3A0: [.691, 0, .708, {
    ic: .06
  }],
  0x3A1: [.694, 0, .639, {
    ic: .051
  }],
  0x3A2: [.715, .022, .778],
  0x3A3: [.694, 0, .722, {
    ic: .091
  }],
  0x3A4: [.688, 0, .681, {
    ic: .109
  }],
  0x3A5: [.716, 0, .778, {
    ic: .065
  }],
  0x3A6: [.694, 0, .722],
  0x3A7: [.694, 0, .667, {
    ic: .091
  }],
  0x3A8: [.694, 0, .778, {
    ic: .076
  }],
  0x3A9: [.716, 0, .722],
  0x3D2: [.716, 0, .778, {
    ic: .065
  }],
  0x3DC: [.691, 0, .569, {
    ic: .104
  }],
  0x2013: [.312, -0.236, .5, {
    ic: .065
  }],
  0x2014: [.312, -0.236, 1, {
    ic: .065
  }],
  0x2015: [.312, -0.236, 1, {
    ic: .065
  }],
  0x2017: [-0.038, .114, .5, {
    ic: .065
  }],
  0x2018: [.694, -0.471, .278, {
    ic: .058
  }],
  0x2019: [.694, -0.471, .278, {
    ic: .057
  }],
  0x201C: [.694, -0.471, .5, {
    ic: .114
  }],
  0x201D: [.694, -0.471, .5],
  0x2044: [.75, .25, .5, {
    ic: .1
  }],
  0x2206: [.694, 0, .833]
};

/***/ }),
/* 322 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var sans_serif_js_1 = __webpack_require__(323);

exports.sansSerif = FontData_js_1.AddCSS(sans_serif_js_1.sansSerif, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x23: {
    c: '#'
  },
  0x24: {
    c: '$'
  },
  0x25: {
    c: '%'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3D: {
    c: '='
  },
  0x3F: {
    c: '?'
  },
  0x40: {
    c: '@'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x5F: {
    c: '_'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x7E: {
    c: '~'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x2015: {
    c: '\\2014'
  },
  0x2017: {
    c: '_'
  },
  0x2044: {
    c: '/'
  },
  0x2206: {
    c: '\\394'
  }
});

/***/ }),
/* 323 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.sansSerif = {
  0x20: [0, 0, .25],
  0x21: [.694, 0, .319],
  0x22: [.694, -0.471, .5],
  0x23: [.694, .194, .833],
  0x24: [.75, .056, .5],
  0x25: [.75, .056, .833],
  0x26: [.716, .022, .758],
  0x27: [.694, -0.471, .278],
  0x28: [.75, .25, .389],
  0x29: [.75, .25, .389],
  0x2A: [.75, -0.306, .5],
  0x2B: [.583, .082, .778],
  0x2C: [.098, .125, .278],
  0x2D: [.259, -0.186, .333],
  0x2E: [.098, 0, .278],
  0x2F: [.75, .25, .5],
  0x30: [.678, .022, .5],
  0x31: [.678, 0, .5],
  0x32: [.677, 0, .5],
  0x33: [.678, .022, .5],
  0x34: [.656, 0, .5],
  0x35: [.656, .021, .5],
  0x36: [.677, .022, .5],
  0x37: [.656, .011, .5],
  0x38: [.678, .022, .5],
  0x39: [.677, .022, .5],
  0x3A: [.444, 0, .278],
  0x3B: [.444, .125, .278],
  0x3D: [.37, -0.13, .778],
  0x3F: [.704, 0, .472],
  0x40: [.704, .011, .667],
  0x41: [.694, 0, .667],
  0x42: [.694, 0, .667],
  0x43: [.705, .011, .639],
  0x44: [.694, 0, .722],
  0x45: [.691, 0, .597],
  0x46: [.691, 0, .569],
  0x47: [.704, .011, .667],
  0x48: [.694, 0, .708],
  0x49: [.694, 0, .278],
  0x4A: [.694, .022, .472],
  0x4B: [.694, 0, .694],
  0x4C: [.694, 0, .542],
  0x4D: [.694, 0, .875],
  0x4E: [.694, 0, .708],
  0x4F: [.715, .022, .736],
  0x50: [.694, 0, .639],
  0x51: [.715, .125, .736],
  0x52: [.694, 0, .646],
  0x53: [.716, .022, .556],
  0x54: [.688, 0, .681],
  0x55: [.694, .022, .688],
  0x56: [.694, 0, .667],
  0x57: [.694, 0, .944],
  0x58: [.694, 0, .667],
  0x59: [.694, 0, .667],
  0x5A: [.694, 0, .611],
  0x5B: [.75, .25, .289],
  0x5D: [.75, .25, .289],
  0x5E: [.694, -0.527, .5],
  0x5F: [-0.038, .114, .5],
  0x61: [.46, .01, .481],
  0x62: [.694, .011, .517],
  0x63: [.46, .01, .444],
  0x64: [.694, .01, .517],
  0x65: [.461, .01, .444],
  0x66: [.705, 0, .306],
  0x67: [.455, .206, .5],
  0x68: [.694, 0, .517],
  0x69: [.68, 0, .239],
  0x6A: [.68, .205, .267],
  0x6B: [.694, 0, .489],
  0x6C: [.694, 0, .239],
  0x6D: [.455, 0, .794],
  0x6E: [.455, 0, .517],
  0x6F: [.46, .01, .5],
  0x70: [.455, .194, .517],
  0x71: [.455, .194, .517],
  0x72: [.455, 0, .342],
  0x73: [.46, .01, .383],
  0x74: [.571, .01, .361],
  0x75: [.444, .01, .517],
  0x76: [.444, 0, .461],
  0x77: [.444, 0, .683],
  0x78: [.444, 0, .461],
  0x79: [.444, .204, .461],
  0x7A: [.444, 0, .435],
  0x7E: [.327, -0.193, .5],
  0xA0: [0, 0, .25],
  0x131: [.444, 0, .239],
  0x237: [.444, .205, .267],
  0x300: [.694, -0.527, 0],
  0x301: [.694, -0.527, 0],
  0x302: [.694, -0.527, 0],
  0x303: [.677, -0.543, 0],
  0x304: [.631, -0.552, 0],
  0x306: [.694, -0.508, 0],
  0x307: [.68, -0.576, 0],
  0x308: [.68, -0.582, 0],
  0x30A: [.694, -0.527, 0],
  0x30B: [.694, -0.527, 0],
  0x30C: [.654, -0.487, 0],
  0x391: [.694, 0, .667],
  0x392: [.694, 0, .667],
  0x393: [.691, 0, .542],
  0x394: [.694, 0, .833],
  0x395: [.691, 0, .597],
  0x396: [.694, 0, .611],
  0x397: [.694, 0, .708],
  0x398: [.716, .021, .778],
  0x399: [.694, 0, .278],
  0x39A: [.694, 0, .694],
  0x39B: [.694, 0, .611],
  0x39C: [.694, 0, .875],
  0x39D: [.694, 0, .708],
  0x39E: [.688, 0, .667],
  0x39F: [.715, .022, .736],
  0x3A0: [.691, 0, .708],
  0x3A1: [.694, 0, .639],
  0x3A2: [.716, .021, .778],
  0x3A3: [.694, 0, .722],
  0x3A4: [.688, 0, .681],
  0x3A5: [.716, 0, .778],
  0x3A6: [.694, 0, .722],
  0x3A7: [.694, 0, .667],
  0x3A8: [.694, 0, .778],
  0x3A9: [.716, 0, .722],
  0x3D2: [.716, 0, .778],
  0x3DC: [.691, 0, .569],
  0x2013: [.312, -0.236, .5],
  0x2014: [.312, -0.236, 1],
  0x2015: [.312, -0.236, 1],
  0x2017: [-0.038, .114, .5],
  0x2018: [.694, -0.471, .278],
  0x2019: [.694, -0.471, .278],
  0x201C: [.694, -0.471, .5],
  0x201D: [.694, -0.471, .5],
  0x2044: [.75, .25, .5],
  0x2206: [.694, 0, .833]
};

/***/ }),
/* 324 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var script_bold_js_1 = __webpack_require__(325);

exports.scriptBold = FontData_js_1.AddCSS(script_bold_js_1.scriptBold, {
  0x20: {
    c: ' '
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x391: {
    c: 'A',
    f: 'B'
  },
  0x392: {
    c: 'B',
    f: 'B'
  },
  0x395: {
    c: 'E',
    f: 'B'
  },
  0x396: {
    c: 'Z',
    f: 'B'
  },
  0x397: {
    c: 'H',
    f: 'B'
  },
  0x399: {
    c: 'I',
    f: 'B'
  },
  0x39A: {
    c: 'K',
    f: 'B'
  },
  0x39C: {
    c: 'M',
    f: 'B'
  },
  0x39D: {
    c: 'N',
    f: 'B'
  },
  0x39F: {
    c: 'O',
    f: 'B'
  },
  0x3A1: {
    c: 'P',
    f: 'B'
  },
  0x3A2: {
    c: '\\398',
    f: 'B'
  },
  0x3A4: {
    c: 'T',
    f: 'B'
  },
  0x3A7: {
    c: 'X',
    f: 'B'
  },
  0x3D2: {
    c: '\\3A5',
    f: 'B'
  },
  0x3DC: {
    c: 'F',
    f: 'B'
  }
});

/***/ }),
/* 325 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.scriptBold = {
  0x20: [0, 0, .25],
  0x41: [.717, .008, .803, {
    ic: .213,
    sk: 0.389
  }],
  0x42: [.708, .028, .908, {
    sk: 0.194
  }],
  0x43: [.728, .026, .666, {
    ic: .153,
    sk: 0.278
  }],
  0x44: [.708, .031, .774, {
    ic: .081,
    sk: 0.111
  }],
  0x45: [.707, .008, .562, {
    ic: .156,
    sk: 0.139
  }],
  0x46: [.735, .036, .895, {
    ic: .095,
    sk: 0.222
  }],
  0x47: [.717, .037, .61, {
    ic: .128,
    sk: 0.25
  }],
  0x48: [.717, .036, .969, {
    ic: .272,
    sk: 0.333
  }],
  0x49: [.717, .017, .809, {
    ic: .137,
    sk: 0.333
  }],
  0x4A: [.717, .314, 1.052, {
    ic: .081,
    sk: 0.417
  }],
  0x4B: [.717, .037, .914, {
    ic: .29,
    sk: 0.361
  }],
  0x4C: [.717, .017, .874, {
    ic: .161,
    sk: 0.306
  }],
  0x4D: [.721, .05, 1.08, {
    ic: .136,
    sk: 0.444
  }],
  0x4E: [.726, .036, .902, {
    ic: .306,
    sk: 0.389
  }],
  0x4F: [.707, .008, .738, {
    ic: .067,
    sk: 0.167
  }],
  0x50: [.716, .037, 1.013, {
    sk: 0.222
  }],
  0x51: [.717, .017, .883, {
    sk: 0.278
  }],
  0x52: [.717, .017, .85, {
    sk: 0.194
  }],
  0x53: [.708, .036, .868, {
    ic: .148,
    sk: 0.333
  }],
  0x54: [.735, .037, .747, {
    ic: .249,
    sk: 0.222
  }],
  0x55: [.717, .017, .8, {
    ic: .16,
    sk: 0.25
  }],
  0x56: [.717, .017, .622, {
    ic: .228,
    sk: 0.222
  }],
  0x57: [.717, .017, .805, {
    ic: .221,
    sk: 0.25
  }],
  0x58: [.717, .017, .944, {
    ic: .187,
    sk: 0.278
  }],
  0x59: [.716, .017, .71, {
    ic: .249,
    sk: 0.194
  }],
  0x5A: [.717, .016, .821, {
    ic: .211,
    sk: 0.306
  }],
  0xA0: [0, 0, .25],
  0x391: [.698, 0, .869],
  0x392: [.686, 0, .818],
  0x395: [.68, 0, .756],
  0x396: [.686, 0, .703],
  0x397: [.686, 0, .9],
  0x399: [.686, 0, .436],
  0x39A: [.686, 0, .901],
  0x39C: [.686, 0, 1.092],
  0x39D: [.686, 0, .9],
  0x39F: [.696, .01, .864],
  0x3A1: [.686, 0, .786],
  0x3A2: [.696, .01, .894],
  0x3A4: [.675, 0, .8],
  0x3A7: [.686, 0, .869],
  0x3D2: [.697, 0, .894],
  0x3DC: [.68, 0, .724]
};

/***/ }),
/* 326 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var script_js_1 = __webpack_require__(327);

exports.script = FontData_js_1.AddCSS(script_js_1.script, {
  0x20: {
    c: ' '
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x391: {
    c: 'A',
    f: ''
  },
  0x392: {
    c: 'B',
    f: ''
  },
  0x395: {
    c: 'E',
    f: ''
  },
  0x396: {
    c: 'Z',
    f: ''
  },
  0x397: {
    c: 'H',
    f: ''
  },
  0x399: {
    c: 'I',
    f: ''
  },
  0x39A: {
    c: 'K',
    f: ''
  },
  0x39C: {
    c: 'M',
    f: ''
  },
  0x39D: {
    c: 'N',
    f: ''
  },
  0x39F: {
    c: 'O',
    f: ''
  },
  0x3A1: {
    c: 'P',
    f: ''
  },
  0x3A2: {
    c: '\\398',
    f: ''
  },
  0x3A4: {
    c: 'T',
    f: ''
  },
  0x3A7: {
    c: 'X',
    f: ''
  },
  0x3D2: {
    c: '\\3A5',
    f: ''
  },
  0x3DC: {
    c: 'F',
    f: ''
  },
  0x210B: {
    c: 'H',
    f: 'SC'
  },
  0x2110: {
    c: 'J',
    f: 'SC'
  },
  0x2112: {
    c: 'L',
    f: 'SC'
  },
  0x211B: {
    c: 'R',
    f: 'SC'
  },
  0x212C: {
    c: 'B',
    f: 'SC'
  },
  0x2130: {
    c: 'E',
    f: 'SC'
  },
  0x2131: {
    c: 'F',
    f: 'SC'
  },
  0x2133: {
    c: 'M',
    f: 'SC'
  }
});

/***/ }),
/* 327 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.script = {
  0x20: [0, 0, .25],
  0x41: [.717, .008, .803, {
    ic: .213,
    sk: 0.389
  }],
  0x42: [.708, .028, .908, {
    sk: 0.194
  }],
  0x43: [.728, .026, .666, {
    ic: .153,
    sk: 0.278
  }],
  0x44: [.708, .031, .774, {
    ic: .081,
    sk: 0.111
  }],
  0x45: [.707, .008, .562, {
    ic: .156,
    sk: 0.139
  }],
  0x46: [.735, .036, .895, {
    ic: .095,
    sk: 0.222
  }],
  0x47: [.717, .037, .61, {
    ic: .128,
    sk: 0.25
  }],
  0x48: [.717, .036, .969, {
    ic: .272,
    sk: 0.333
  }],
  0x49: [.717, .017, .809, {
    ic: .137,
    sk: 0.333
  }],
  0x4A: [.717, .314, 1.052, {
    ic: .081,
    sk: 0.417
  }],
  0x4B: [.717, .037, .914, {
    ic: .29,
    sk: 0.361
  }],
  0x4C: [.717, .017, .874, {
    ic: .161,
    sk: 0.306
  }],
  0x4D: [.721, .05, 1.08, {
    ic: .136,
    sk: 0.444
  }],
  0x4E: [.726, .036, .902, {
    ic: .306,
    sk: 0.389
  }],
  0x4F: [.707, .008, .738, {
    ic: .067,
    sk: 0.167
  }],
  0x50: [.716, .037, 1.013, {
    sk: 0.222
  }],
  0x51: [.717, .017, .883, {
    sk: 0.278
  }],
  0x52: [.717, .017, .85, {
    sk: 0.194
  }],
  0x53: [.708, .036, .868, {
    ic: .148,
    sk: 0.333
  }],
  0x54: [.735, .037, .747, {
    ic: .249,
    sk: 0.222
  }],
  0x55: [.717, .017, .8, {
    ic: .16,
    sk: 0.25
  }],
  0x56: [.717, .017, .622, {
    ic: .228,
    sk: 0.222
  }],
  0x57: [.717, .017, .805, {
    ic: .221,
    sk: 0.25
  }],
  0x58: [.717, .017, .944, {
    ic: .187,
    sk: 0.278
  }],
  0x59: [.716, .017, .71, {
    ic: .249,
    sk: 0.194
  }],
  0x5A: [.717, .016, .821, {
    ic: .211,
    sk: 0.306
  }],
  0xA0: [0, 0, .25],
  0x391: [.716, 0, .75],
  0x392: [.683, 0, .708],
  0x395: [.68, 0, .681],
  0x396: [.683, 0, .611],
  0x397: [.683, 0, .75],
  0x399: [.683, 0, .361],
  0x39A: [.683, 0, .778],
  0x39C: [.683, 0, .917],
  0x39D: [.683, 0, .75],
  0x39F: [.705, .022, .778],
  0x3A1: [.683, 0, .681],
  0x3A2: [.705, .022, .778],
  0x3A4: [.677, 0, .722],
  0x3A7: [.683, 0, .75],
  0x3D2: [.705, 0, .778],
  0x3DC: [.68, 0, .653],
  0x210B: [.717, .036, .969, {
    ic: .272,
    sk: 0.333
  }],
  0x2110: [.717, .314, 1.052, {
    ic: .081,
    sk: 0.417
  }],
  0x2112: [.717, .017, .874, {
    ic: .161,
    sk: 0.306
  }],
  0x211B: [.717, .017, .85, {
    sk: 0.194
  }],
  0x212C: [.708, .028, .908, {
    sk: 0.194
  }],
  0x2130: [.707, .008, .562, {
    ic: .156,
    sk: 0.139
  }],
  0x2131: [.735, .036, .895, {
    ic: .095,
    sk: 0.222
  }],
  0x2133: [.721, .05, 1.08, {
    ic: .136,
    sk: 0.444
  }]
};

/***/ }),
/* 328 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var smallop_js_1 = __webpack_require__(329);

exports.smallop = FontData_js_1.AddCSS(smallop_js_1.smallop, {
  0x20: {
    c: ' '
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2F: {
    c: '/'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x7B: {
    c: '{'
  },
  0x7D: {
    c: '}'
  },
  0x2044: {
    c: '/'
  },
  0x2329: {
    c: '\\27E8'
  },
  0x232A: {
    c: '\\27E9'
  },
  0x2758: {
    c: '\\2223'
  },
  0x2A0C: {
    c: '\\222C\\222C'
  },
  0x3008: {
    c: '\\27E8'
  },
  0x3009: {
    c: '\\27E9'
  }
});

/***/ }),
/* 329 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.smallop = {
  0x20: [0, 0, .25],
  0x28: [.85, .349, .458],
  0x29: [.85, .349, .458],
  0x2F: [.85, .349, .578],
  0x5B: [.85, .349, .417],
  0x5C: [.85, .349, .578],
  0x5D: [.85, .349, .417],
  0x7B: [.85, .349, .583],
  0x7D: [.85, .349, .583],
  0xA0: [0, 0, .25],
  0x2C6: [.744, -0.551, .556],
  0x2DC: [.722, -0.597, .556],
  0x302: [.744, -0.551, 0],
  0x303: [.722, -0.597, 0],
  0x2016: [.602, 0, .778],
  0x2044: [.85, .349, .578],
  0x2191: [.6, 0, .667],
  0x2193: [.6, 0, .667],
  0x21D1: [.599, 0, .778],
  0x21D3: [.6, 0, .778],
  0x220F: [.75, .25, .944],
  0x2210: [.75, .25, .944],
  0x2211: [.75, .25, 1.056],
  0x221A: [.85, .35, 1],
  0x2223: [.627, .015, .333],
  0x2225: [.627, .015, .556],
  0x222B: [.805, .306, .472, {
    ic: .138
  }],
  0x222C: [.805, .306, .819, {
    ic: .138
  }],
  0x222D: [.805, .306, 1.166, {
    ic: .138
  }],
  0x222E: [.805, .306, .472, {
    ic: .138
  }],
  0x22C0: [.75, .249, .833],
  0x22C1: [.75, .249, .833],
  0x22C2: [.75, .249, .833],
  0x22C3: [.75, .249, .833],
  0x2308: [.85, .349, .472],
  0x2309: [.85, .349, .472],
  0x230A: [.85, .349, .472],
  0x230B: [.85, .349, .472],
  0x2329: [.85, .35, .472],
  0x232A: [.85, .35, .472],
  0x23D0: [.602, 0, .667],
  0x2758: [.627, .015, .333],
  0x27E8: [.85, .35, .472],
  0x27E9: [.85, .35, .472],
  0x2A00: [.75, .25, 1.111],
  0x2A01: [.75, .25, 1.111],
  0x2A02: [.75, .25, 1.111],
  0x2A04: [.75, .249, .833],
  0x2A06: [.75, .249, .833],
  0x2A0C: [.805, .306, 1.638, {
    ic: .138
  }],
  0x3008: [.85, .35, .472],
  0x3009: [.85, .35, .472]
};

/***/ }),
/* 330 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var tex_caligraphic_bold_js_1 = __webpack_require__(331);

exports.texCaligraphicBold = FontData_js_1.AddCSS(tex_caligraphic_bold_js_1.texCaligraphicBold, {
  0x20: {
    c: ' '
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x391: {
    c: 'A',
    f: 'BI'
  },
  0x392: {
    c: 'B',
    f: 'BI'
  },
  0x395: {
    c: 'E',
    f: 'BI'
  },
  0x396: {
    c: 'Z',
    f: 'BI'
  },
  0x397: {
    c: 'H',
    f: 'BI'
  },
  0x399: {
    c: 'I',
    f: 'BI'
  },
  0x39A: {
    c: 'K',
    f: 'BI'
  },
  0x39C: {
    c: 'M',
    f: 'BI'
  },
  0x39D: {
    c: 'N',
    f: 'BI'
  },
  0x39F: {
    c: 'O',
    f: 'BI'
  },
  0x3A1: {
    c: 'P',
    f: 'BI'
  },
  0x3A2: {
    c: '\\398',
    f: 'BI'
  },
  0x3A4: {
    c: 'T',
    f: 'BI'
  },
  0x3A7: {
    c: 'X',
    f: 'BI'
  },
  0x3D2: {
    c: '\\3A5',
    f: 'BI'
  },
  0x3DC: {
    c: 'F',
    f: 'BI'
  },
  0x2044: {
    c: '/'
  },
  0x2206: {
    c: '\\394'
  }
});

/***/ }),
/* 331 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.texCaligraphicBold = {
  0x20: [0, 0, .25],
  0x2F: [.711, .21, .894],
  0x30: [.46, .017, .575],
  0x31: [.461, 0, .575],
  0x32: [.46, 0, .575],
  0x33: [.461, .211, .575],
  0x34: [.469, .194, .575],
  0x35: [.461, .211, .575],
  0x36: [.66, .017, .575],
  0x37: [.476, .211, .575],
  0x38: [.661, .017, .575],
  0x39: [.461, .21, .575],
  0x41: [.751, .049, .921, {
    ic: .068,
    sk: 0.224
  }],
  0x42: [.705, .017, .748, {
    sk: 0.16
  }],
  0x43: [.703, .02, .613, {
    sk: 0.16
  }],
  0x44: [.686, 0, .892, {
    sk: 0.0958
  }],
  0x45: [.703, .016, .607, {
    sk: 0.128
  }],
  0x46: [.686, .03, .814, {
    ic: .116,
    sk: 0.128
  }],
  0x47: [.703, .113, .682, {
    sk: 0.128
  }],
  0x48: [.686, .048, .987, {
    sk: 0.128
  }],
  0x49: [.686, 0, .642, {
    ic: .104,
    sk: 0.0319
  }],
  0x4A: [.686, .114, .779, {
    ic: .158,
    sk: 0.192
  }],
  0x4B: [.703, .017, .871, {
    sk: 0.0639
  }],
  0x4C: [.703, .017, .788, {
    sk: 0.16
  }],
  0x4D: [.703, .049, 1.378, {
    sk: 0.16
  }],
  0x4E: [.84, .049, .937, {
    ic: .168,
    sk: 0.0958
  }],
  0x4F: [.703, .017, .906, {
    sk: 0.128
  }],
  0x50: [.686, .067, .81, {
    sk: 0.0958
  }],
  0x51: [.703, .146, .939, {
    sk: 0.128
  }],
  0x52: [.686, .017, .99, {
    sk: 0.0958
  }],
  0x53: [.703, .016, .696, {
    sk: 0.16
  }],
  0x54: [.72, .069, .644, {
    ic: .303,
    sk: 0.0319
  }],
  0x55: [.686, .024, .715, {
    ic: .056,
    sk: 0.0958
  }],
  0x56: [.686, .077, .737, {
    sk: 0.0319
  }],
  0x57: [.686, .077, 1.169, {
    sk: 0.0958
  }],
  0x58: [.686, 0, .817, {
    ic: .089,
    sk: 0.16
  }],
  0x59: [.686, .164, .759, {
    sk: 0.0958
  }],
  0x5A: [.686, 0, .818, {
    sk: 0.16
  }],
  0x61: [.452, .008, .633],
  0x62: [.694, .008, .521],
  0x63: [.451, .008, .513, {
    sk: 0.0639
  }],
  0x64: [.694, .008, .61, {
    sk: 0.192
  }],
  0x65: [.452, .008, .554, {
    sk: 0.0639
  }],
  0x66: [.701, .201, .568, {
    ic: .056,
    sk: 0.192
  }],
  0x67: [.452, .202, .545, {
    sk: 0.0319
  }],
  0x68: [.694, .008, .668, {
    sk: -0.0319
  }],
  0x69: [.694, .008, .405],
  0x6A: [.694, .202, .471],
  0x6B: [.694, .008, .604],
  0x6C: [.694, .008, .348, {
    sk: 0.0958
  }],
  0x6D: [.452, .008, 1.032],
  0x6E: [.452, .008, .713],
  0x6F: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x70: [.452, .194, .601, {
    sk: 0.0958
  }],
  0x71: [.452, .194, .542, {
    sk: 0.0958
  }],
  0x72: [.452, .008, .529, {
    sk: 0.0639
  }],
  0x73: [.451, .008, .531, {
    sk: 0.0639
  }],
  0x74: [.643, .007, .415, {
    sk: 0.0958
  }],
  0x75: [.452, .008, .681, {
    sk: 0.0319
  }],
  0x76: [.453, .008, .567, {
    sk: 0.0319
  }],
  0x77: [.453, .008, .831, {
    sk: 0.0958
  }],
  0x78: [.452, .008, .659, {
    sk: 0.0319
  }],
  0x79: [.452, .202, .59, {
    sk: 0.0639
  }],
  0x7A: [.452, .008, .555, {
    sk: 0.0639
  }],
  0xA0: [0, 0, .25],
  0x391: [.711, 0, .869, {
    sk: 0.16
  }],
  0x392: [.686, 0, .866, {
    sk: 0.0958
  }],
  0x393: [.68, 0, .657, {
    ic: .12,
    sk: 0.0958
  }],
  0x394: [.711, 0, .958, {
    sk: 0.192
  }],
  0x395: [.68, 0, .81, {
    sk: 0.0958
  }],
  0x396: [.686, 0, .773, {
    sk: 0.0958
  }],
  0x397: [.686, 0, .982, {
    sk: 0.0639
  }],
  0x398: [.702, .017, .867, {
    sk: 0.0958
  }],
  0x399: [.686, 0, .511, {
    ic: .062,
    sk: 0.128
  }],
  0x39A: [.686, 0, .971, {
    sk: 0.0639
  }],
  0x39B: [.711, 0, .806, {
    sk: 0.192
  }],
  0x39C: [.686, 0, 1.142, {
    ic: .077,
    sk: 0.0958
  }],
  0x39D: [.686, 0, .95, {
    ic: .077,
    sk: 0.0958
  }],
  0x39E: [.675, 0, .841, {
    sk: 0.0958
  }],
  0x39F: [.703, .017, .837, {
    sk: 0.0958
  }],
  0x3A0: [.68, 0, .982, {
    sk: 0.0639
  }],
  0x3A1: [.686, 0, .723, {
    ic: .124,
    sk: 0.0958
  }],
  0x3A2: [.702, .017, .867, {
    sk: 0.0958
  }],
  0x3A3: [.686, 0, .885, {
    sk: 0.0958
  }],
  0x3A4: [.675, 0, .637, {
    ic: .135,
    sk: 0.0958
  }],
  0x3A5: [.703, 0, .671, {
    ic: .131,
    sk: 0.0639
  }],
  0x3A6: [.686, 0, .767, {
    sk: 0.0958
  }],
  0x3A7: [.686, 0, .947, {
    sk: 0.0958
  }],
  0x3A8: [.686, 0, .714, {
    ic: .076,
    sk: 0.0639
  }],
  0x3A9: [.703, 0, .879, {
    sk: 0.0958
  }],
  0x3B1: [.452, .008, .761, {
    sk: 0.0319
  }],
  0x3B2: [.701, .194, .66, {
    sk: 0.0958
  }],
  0x3B3: [.451, .211, .59],
  0x3B4: [.725, .008, .522, {
    sk: 0.0639
  }],
  0x3B5: [.461, .017, .529, {
    sk: 0.0958
  }],
  0x3B6: [.711, .202, .508, {
    sk: 0.0958
  }],
  0x3B7: [.452, .211, .6, {
    sk: 0.0639
  }],
  0x3B8: [.702, .008, .562, {
    sk: 0.0958
  }],
  0x3B9: [.452, .008, .412, {
    sk: 0.0639
  }],
  0x3BA: [.452, .008, .668],
  0x3BB: [.694, .013, .671],
  0x3BC: [.452, .211, .708, {
    sk: 0.0319
  }],
  0x3BD: [.452, 0, .577, {
    sk: 0.0319
  }],
  0x3BE: [.711, .201, .508, {
    sk: 0.128
  }],
  0x3BF: [.452, .008, .585, {
    sk: 0.0639
  }],
  0x3C0: [.444, .008, .682],
  0x3C1: [.451, .211, .612, {
    sk: 0.0958
  }],
  0x3C2: [.451, .105, .424, {
    sk: 0.0958
  }],
  0x3C3: [.444, .008, .686],
  0x3C4: [.444, .013, .521, {
    ic: .089,
    sk: 0.0319
  }],
  0x3C5: [.453, .008, .631, {
    sk: 0.0319
  }],
  0x3C6: [.452, .216, .747, {
    sk: 0.0958
  }],
  0x3C7: [.452, .201, .718, {
    sk: 0.0639
  }],
  0x3C8: [.694, .202, .758, {
    sk: 0.128
  }],
  0x3C9: [.453, .008, .718],
  0x3D1: [.701, .008, .692, {
    sk: 0.0958
  }],
  0x3D2: [.703, 0, .671, {
    ic: .131,
    sk: 0.0639
  }],
  0x3D5: [.694, .202, .712, {
    sk: 0.0958
  }],
  0x3D6: [.444, .008, .975],
  0x3DC: [.68, 0, .689, {
    ic: .12,
    sk: 0.0958
  }],
  0x3F1: [.451, .194, .612, {
    sk: 0.0958
  }],
  0x3F5: [.444, .007, .483, {
    sk: 0.0639
  }],
  0x2044: [.711, .21, .894],
  0x2206: [.711, 0, .958, {
    sk: 0.192
  }]
};

/***/ }),
/* 332 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var tex_caligraphic_js_1 = __webpack_require__(333);

exports.texCaligraphic = FontData_js_1.AddCSS(tex_caligraphic_js_1.texCaligraphic, {
  0x20: {
    c: ' '
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x391: {
    c: 'A',
    f: 'I'
  },
  0x392: {
    c: 'B',
    f: 'I'
  },
  0x395: {
    c: 'E',
    f: 'I'
  },
  0x396: {
    c: 'Z',
    f: 'I'
  },
  0x397: {
    c: 'H',
    f: 'I'
  },
  0x399: {
    c: 'I',
    f: 'I'
  },
  0x39A: {
    c: 'K',
    f: 'I'
  },
  0x39C: {
    c: 'M',
    f: 'I'
  },
  0x39D: {
    c: 'N',
    f: 'I'
  },
  0x39F: {
    c: 'O',
    f: 'I'
  },
  0x3A1: {
    c: 'P',
    f: 'I'
  },
  0x3A2: {
    c: '\\398',
    f: 'I'
  },
  0x3A4: {
    c: 'T',
    f: 'I'
  },
  0x3A7: {
    c: 'X',
    f: 'I'
  },
  0x3D2: {
    c: '\\3A5',
    f: 'I'
  },
  0x3DC: {
    c: 'F',
    f: 'I'
  }
});

/***/ }),
/* 333 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.texCaligraphic = {
  0x20: [0, 0, .25],
  0x30: [.452, .022, .5],
  0x31: [.453, 0, .5],
  0x32: [.453, 0, .5],
  0x33: [.452, .216, .5],
  0x34: [.464, .194, .5],
  0x35: [.453, .216, .5],
  0x36: [.665, .022, .5],
  0x37: [.463, .216, .5],
  0x38: [.666, .021, .5],
  0x39: [.453, .216, .5],
  0x41: [.728, .05, .798, {
    sk: 0.194
  }],
  0x42: [.705, .022, .657, {
    sk: 0.139
  }],
  0x43: [.705, .025, .527, {
    sk: 0.139
  }],
  0x44: [.683, 0, .771, {
    sk: 0.0833
  }],
  0x45: [.705, .022, .528, {
    sk: 0.111
  }],
  0x46: [.683, .032, .719, {
    ic: .11,
    sk: 0.111
  }],
  0x47: [.704, .119, .595, {
    sk: 0.111
  }],
  0x48: [.683, .048, .845, {
    sk: 0.111
  }],
  0x49: [.683, 0, .545, {
    ic: .097,
    sk: 0.0278
  }],
  0x4A: [.683, .119, .678, {
    ic: .161,
    sk: 0.167
  }],
  0x4B: [.705, .022, .762, {
    sk: 0.0556
  }],
  0x4C: [.705, .022, .69, {
    sk: 0.139
  }],
  0x4D: [.705, .05, 1.201, {
    sk: 0.139
  }],
  0x4E: [.789, .05, .82, {
    ic: .159,
    sk: 0.0833
  }],
  0x4F: [.705, .022, .796, {
    sk: 0.111
  }],
  0x50: [.683, .057, .696, {
    sk: 0.0833
  }],
  0x51: [.705, .131, .817, {
    sk: 0.111
  }],
  0x52: [.682, .022, .848, {
    sk: 0.0833
  }],
  0x53: [.705, .022, .606, {
    sk: 0.139
  }],
  0x54: [.717, .068, .545, {
    ic: .288,
    sk: 0.0278
  }],
  0x55: [.683, .028, .626, {
    ic: .061,
    sk: 0.0833
  }],
  0x56: [.683, .052, .613, {
    sk: 0.0278
  }],
  0x57: [.683, .053, .988, {
    sk: 0.0833
  }],
  0x58: [.683, 0, .713, {
    ic: .094,
    sk: 0.139
  }],
  0x59: [.683, .143, .668, {
    sk: 0.0833
  }],
  0x5A: [.683, 0, .725, {
    sk: 0.139
  }],
  0xA0: [0, 0, .25],
  0x391: [.716, 0, .75, {
    sk: 0.139
  }],
  0x392: [.683, 0, .759, {
    sk: 0.0833
  }],
  0x395: [.68, 0, .738, {
    sk: 0.0833
  }],
  0x396: [.683, 0, .683, {
    sk: 0.0833
  }],
  0x397: [.683, 0, .831, {
    ic: .057,
    sk: 0.0556
  }],
  0x399: [.683, 0, .44, {
    ic: .064,
    sk: 0.111
  }],
  0x39A: [.683, 0, .849, {
    sk: 0.0556
  }],
  0x39C: [.683, 0, .97, {
    ic: .081,
    sk: 0.0833
  }],
  0x39D: [.683, 0, .803, {
    ic: .085,
    sk: 0.0833
  }],
  0x39F: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x3A1: [.683, 0, .642, {
    ic: .109,
    sk: 0.0833
  }],
  0x3A2: [.704, .022, .763, {
    sk: 0.0833
  }],
  0x3A4: [.677, 0, .584, {
    ic: .12,
    sk: 0.0833
  }],
  0x3A7: [.683, 0, .828, {
    sk: 0.0833
  }],
  0x3D2: [.705, 0, .583, {
    ic: .117,
    sk: 0.0556
  }],
  0x3DC: [.68, 0, .643, {
    ic: .106,
    sk: 0.0833
  }]
};

/***/ }),
/* 334 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var tex_mathit_js_1 = __webpack_require__(335);

exports.texMathit = FontData_js_1.AddCSS(tex_mathit_js_1.texMathit, {
  0x20: {
    c: ' '
  },
  0x21: {
    c: '!'
  },
  0x23: {
    c: '#'
  },
  0x25: {
    c: '%'
  },
  0x26: {
    c: '&'
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2A: {
    c: '*'
  },
  0x2B: {
    c: '+'
  },
  0x2C: {
    c: ','
  },
  0x2D: {
    c: '-'
  },
  0x2E: {
    c: '.'
  },
  0x2F: {
    c: '/'
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x3A: {
    c: ':'
  },
  0x3B: {
    c: ';'
  },
  0x3D: {
    c: '='
  },
  0x3F: {
    c: '?'
  },
  0x40: {
    c: '@'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x5E: {
    c: '^'
  },
  0x5F: {
    c: '_'
  },
  0x61: {
    c: 'a'
  },
  0x62: {
    c: 'b'
  },
  0x63: {
    c: 'c'
  },
  0x64: {
    c: 'd'
  },
  0x65: {
    c: 'e'
  },
  0x66: {
    c: 'f'
  },
  0x67: {
    c: 'g'
  },
  0x68: {
    c: 'h'
  },
  0x69: {
    c: 'i'
  },
  0x6A: {
    c: 'j'
  },
  0x6B: {
    c: 'k'
  },
  0x6C: {
    c: 'l'
  },
  0x6D: {
    c: 'm'
  },
  0x6E: {
    c: 'n'
  },
  0x6F: {
    c: 'o'
  },
  0x70: {
    c: 'p'
  },
  0x71: {
    c: 'q'
  },
  0x72: {
    c: 'r'
  },
  0x73: {
    c: 's'
  },
  0x74: {
    c: 't'
  },
  0x75: {
    c: 'u'
  },
  0x76: {
    c: 'v'
  },
  0x77: {
    c: 'w'
  },
  0x78: {
    c: 'x'
  },
  0x79: {
    c: 'y'
  },
  0x7A: {
    c: 'z'
  },
  0x7E: {
    c: '~'
  },
  0x391: {
    c: 'A'
  },
  0x392: {
    c: 'B'
  },
  0x395: {
    c: 'E'
  },
  0x396: {
    c: 'Z'
  },
  0x397: {
    c: 'H'
  },
  0x399: {
    c: 'I'
  },
  0x39A: {
    c: 'K'
  },
  0x39C: {
    c: 'M'
  },
  0x39D: {
    c: 'N'
  },
  0x39F: {
    c: 'O'
  },
  0x3A1: {
    c: 'P'
  },
  0x3A2: {
    c: '\\398'
  },
  0x3A4: {
    c: 'T'
  },
  0x3A7: {
    c: 'X'
  },
  0x3D2: {
    c: '\\3A5'
  },
  0x3DC: {
    c: 'F'
  },
  0x2015: {
    c: '\\2014'
  },
  0x2017: {
    c: '_'
  },
  0x2044: {
    c: '/'
  },
  0x2206: {
    c: '\\394'
  }
});

/***/ }),
/* 335 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.texMathit = {
  0x20: [0, 0, .25],
  0x21: [.716, 0, .307, {
    ic: .073
  }],
  0x22: [.694, -0.379, .514],
  0x23: [.694, .194, .818],
  0x25: [.75, .056, .818],
  0x26: [.716, .022, .767],
  0x27: [.694, -0.379, .307, {
    ic: .07
  }],
  0x28: [.75, .25, .409, {
    ic: .108
  }],
  0x29: [.75, .25, .409],
  0x2A: [.75, -0.32, .511, {
    ic: .073
  }],
  0x2B: [.557, .057, .767],
  0x2C: [.121, .194, .307],
  0x2D: [.251, -0.18, .358],
  0x2E: [.121, 0, .307],
  0x2F: [.75, .25, .511, {
    ic: .106
  }],
  0x30: [.665, .021, .511, {
    ic: .051
  }],
  0x31: [.666, 0, .511],
  0x32: [.666, .022, .511],
  0x33: [.666, .022, .511, {
    ic: .051
  }],
  0x34: [.666, .194, .511],
  0x35: [.666, .022, .511, {
    ic: .056
  }],
  0x36: [.665, .022, .511, {
    ic: .054
  }],
  0x37: [.666, .022, .511, {
    ic: .123
  }],
  0x38: [.666, .021, .511],
  0x39: [.666, .022, .511],
  0x3A: [.431, 0, .307],
  0x3B: [.431, .194, .307],
  0x3D: [.367, -0.133, .767],
  0x3F: [.716, 0, .511],
  0x40: [.705, .011, .767],
  0x41: [.716, 0, .743],
  0x42: [.683, 0, .704],
  0x43: [.705, .021, .716, {
    ic: .096
  }],
  0x44: [.683, 0, .755],
  0x45: [.68, 0, .678, {
    ic: .065
  }],
  0x46: [.68, 0, .653, {
    ic: .078
  }],
  0x47: [.705, .022, .774],
  0x48: [.683, 0, .743, {
    ic: .117
  }],
  0x49: [.683, 0, .386, {
    ic: .122
  }],
  0x4A: [.683, .021, .525, {
    ic: .097
  }],
  0x4B: [.683, 0, .769, {
    ic: .09
  }],
  0x4C: [.683, 0, .627],
  0x4D: [.683, 0, .897, {
    ic: .113
  }],
  0x4E: [.683, 0, .743, {
    ic: .117
  }],
  0x4F: [.704, .022, .767],
  0x50: [.683, 0, .678, {
    ic: .051
  }],
  0x51: [.704, .194, .767],
  0x52: [.683, .022, .729],
  0x53: [.705, .022, .562, {
    ic: .071
  }],
  0x54: [.677, 0, .716, {
    ic: .09
  }],
  0x55: [.683, .022, .743, {
    ic: .117
  }],
  0x56: [.683, .022, .743, {
    ic: .125
  }],
  0x57: [.683, .022, .999, {
    ic: .125
  }],
  0x58: [.683, 0, .743, {
    ic: .082
  }],
  0x59: [.683, 0, .743, {
    ic: .132
  }],
  0x5A: [.683, 0, .613, {
    ic: .091
  }],
  0x5B: [.75, .25, .307, {
    ic: .139
  }],
  0x5D: [.75, .25, .307, {
    ic: .052
  }],
  0x5E: [.694, -0.527, .511],
  0x5F: [-0.025, .062, .511],
  0x61: [.442, .011, .511],
  0x62: [.694, .011, .46],
  0x63: [.441, .01, .46],
  0x64: [.694, .011, .511, {
    ic: .056
  }],
  0x65: [.442, .01, .46],
  0x66: [.705, .204, .307, {
    ic: .143
  }],
  0x67: [.442, .205, .46],
  0x68: [.694, .011, .511],
  0x69: [.656, .01, .307],
  0x6A: [.656, .204, .307, {
    ic: .057
  }],
  0x6B: [.694, .011, .46],
  0x6C: [.694, .011, .256, {
    ic: .056
  }],
  0x6D: [.442, .011, .818],
  0x6E: [.442, .011, .562],
  0x6F: [.442, .011, .511],
  0x70: [.442, .194, .511],
  0x71: [.442, .194, .46],
  0x72: [.442, .011, .422, {
    ic: .062
  }],
  0x73: [.442, .011, .409],
  0x74: [.626, .011, .332],
  0x75: [.441, .011, .537],
  0x76: [.443, .01, .46],
  0x77: [.443, .011, .664],
  0x78: [.442, .011, .464],
  0x79: [.441, .205, .486],
  0x7A: [.442, .011, .409, {
    ic: .057
  }],
  0x7E: [.318, -0.208, .511, {
    ic: .06
  }],
  0xA0: [0, 0, .25],
  0xA3: [.714, .011, .769],
  0x131: [.441, .01, .307],
  0x237: [.442, .204, .332],
  0x300: [.697, -0.5, 0],
  0x301: [.697, -0.5, 0],
  0x302: [.694, -0.527, 0],
  0x303: [.668, -0.558, 0, {
    ic: .06
  }],
  0x304: [.589, -0.544, 0, {
    ic: .054
  }],
  0x306: [.694, -0.515, 0, {
    ic: .062
  }],
  0x307: [.669, -0.548, 0],
  0x308: [.669, -0.554, 0],
  0x30A: [.716, -0.542, 0],
  0x30B: [.697, -0.503, 0, {
    ic: .065
  }],
  0x30C: [.638, -0.502, 0],
  0x391: [.716, 0, .743],
  0x392: [.683, 0, .704],
  0x393: [.68, 0, .627, {
    ic: .078
  }],
  0x394: [.716, 0, .818],
  0x395: [.68, 0, .678, {
    ic: .065
  }],
  0x396: [.683, 0, .613, {
    ic: .091
  }],
  0x397: [.683, 0, .743, {
    ic: .117
  }],
  0x398: [.704, .022, .767],
  0x399: [.683, 0, .386, {
    ic: .122
  }],
  0x39A: [.683, 0, .769, {
    ic: .09
  }],
  0x39B: [.716, 0, .692],
  0x39C: [.683, 0, .897, {
    ic: .113
  }],
  0x39D: [.683, 0, .743, {
    ic: .117
  }],
  0x39E: [.677, 0, .664, {
    ic: .09
  }],
  0x39F: [.704, .022, .767],
  0x3A0: [.68, 0, .743, {
    ic: .116
  }],
  0x3A1: [.683, 0, .678, {
    ic: .051
  }],
  0x3A2: [.704, .022, .767],
  0x3A3: [.683, 0, .716, {
    ic: .066
  }],
  0x3A4: [.677, 0, .716, {
    ic: .09
  }],
  0x3A5: [.705, 0, .767, {
    ic: .065
  }],
  0x3A6: [.683, 0, .716],
  0x3A7: [.683, 0, .743, {
    ic: .082
  }],
  0x3A8: [.683, 0, .767, {
    ic: .057
  }],
  0x3A9: [.705, 0, .716],
  0x3D2: [.705, 0, .767, {
    ic: .065
  }],
  0x3DC: [.68, 0, .653, {
    ic: .078
  }],
  0x2013: [.285, -0.248, .511],
  0x2014: [.285, -0.248, 1.022],
  0x2015: [.285, -0.248, 1.022],
  0x2017: [-0.025, .062, .511],
  0x2018: [.694, -0.379, .307, {
    ic: .055
  }],
  0x2019: [.694, -0.379, .307, {
    ic: .07
  }],
  0x201C: [.694, -0.379, .514, {
    ic: .092
  }],
  0x201D: [.694, -0.379, .514],
  0x2044: [.75, .25, .511, {
    ic: .106
  }],
  0x210F: [.695, .013, .54],
  0x2206: [.716, 0, .818]
};

/***/ }),
/* 336 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var tex_oldstyle_bold_js_1 = __webpack_require__(337);

exports.texOldstyleBold = FontData_js_1.AddCSS(tex_oldstyle_bold_js_1.texOldstyleBold, {
  0x20: {
    c: ' '
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x391: {
    c: 'A',
    f: 'B'
  },
  0x392: {
    c: 'B',
    f: 'B'
  },
  0x395: {
    c: 'E',
    f: 'B'
  },
  0x396: {
    c: 'Z',
    f: 'B'
  },
  0x397: {
    c: 'H',
    f: 'B'
  },
  0x399: {
    c: 'I',
    f: 'B'
  },
  0x39A: {
    c: 'K',
    f: 'B'
  },
  0x39C: {
    c: 'M',
    f: 'B'
  },
  0x39D: {
    c: 'N',
    f: 'B'
  },
  0x39F: {
    c: 'O',
    f: 'B'
  },
  0x3A1: {
    c: 'P',
    f: 'B'
  },
  0x3A2: {
    c: '\\398',
    f: 'B'
  },
  0x3A4: {
    c: 'T',
    f: 'B'
  },
  0x3A7: {
    c: 'X',
    f: 'B'
  },
  0x3D2: {
    c: '\\3A5',
    f: 'B'
  },
  0x3DC: {
    c: 'F',
    f: 'B'
  }
});

/***/ }),
/* 337 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.texOldstyleBold = {
  0x20: [0, 0, .25],
  0x30: [.46, .017, .575],
  0x31: [.461, 0, .575],
  0x32: [.46, 0, .575],
  0x33: [.461, .211, .575],
  0x34: [.469, .194, .575],
  0x35: [.461, .211, .575],
  0x36: [.66, .017, .575],
  0x37: [.476, .211, .575],
  0x38: [.661, .017, .575],
  0x39: [.461, .21, .575],
  0x41: [.751, .049, .921, {
    ic: .068,
    sk: 0.224
  }],
  0x42: [.705, .017, .748, {
    sk: 0.16
  }],
  0x43: [.703, .02, .613, {
    sk: 0.16
  }],
  0x44: [.686, 0, .892, {
    sk: 0.0958
  }],
  0x45: [.703, .016, .607, {
    sk: 0.128
  }],
  0x46: [.686, .03, .814, {
    ic: .116,
    sk: 0.128
  }],
  0x47: [.703, .113, .682, {
    sk: 0.128
  }],
  0x48: [.686, .048, .987, {
    sk: 0.128
  }],
  0x49: [.686, 0, .642, {
    ic: .104,
    sk: 0.0319
  }],
  0x4A: [.686, .114, .779, {
    ic: .158,
    sk: 0.192
  }],
  0x4B: [.703, .017, .871, {
    sk: 0.0639
  }],
  0x4C: [.703, .017, .788, {
    sk: 0.16
  }],
  0x4D: [.703, .049, 1.378, {
    sk: 0.16
  }],
  0x4E: [.84, .049, .937, {
    ic: .168,
    sk: 0.0958
  }],
  0x4F: [.703, .017, .906, {
    sk: 0.128
  }],
  0x50: [.686, .067, .81, {
    sk: 0.0958
  }],
  0x51: [.703, .146, .939, {
    sk: 0.128
  }],
  0x52: [.686, .017, .99, {
    sk: 0.0958
  }],
  0x53: [.703, .016, .696, {
    sk: 0.16
  }],
  0x54: [.72, .069, .644, {
    ic: .303,
    sk: 0.0319
  }],
  0x55: [.686, .024, .715, {
    ic: .056,
    sk: 0.0958
  }],
  0x56: [.686, .077, .737, {
    sk: 0.0319
  }],
  0x57: [.686, .077, 1.169, {
    sk: 0.0958
  }],
  0x58: [.686, 0, .817, {
    ic: .089,
    sk: 0.16
  }],
  0x59: [.686, .164, .759, {
    sk: 0.0958
  }],
  0x5A: [.686, 0, .818, {
    sk: 0.16
  }],
  0xA0: [0, 0, .25],
  0x391: [.698, 0, .869],
  0x392: [.686, 0, .818],
  0x395: [.68, 0, .756],
  0x396: [.686, 0, .703],
  0x397: [.686, 0, .9],
  0x399: [.686, 0, .436],
  0x39A: [.686, 0, .901],
  0x39C: [.686, 0, 1.092],
  0x39D: [.686, 0, .9],
  0x39F: [.696, .01, .864],
  0x3A1: [.686, 0, .786],
  0x3A2: [.696, .01, .894],
  0x3A4: [.675, 0, .8],
  0x3A7: [.686, 0, .869],
  0x3D2: [.697, 0, .894],
  0x3DC: [.68, 0, .724]
};

/***/ }),
/* 338 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var tex_oldstyle_js_1 = __webpack_require__(339);

exports.texOldstyle = FontData_js_1.AddCSS(tex_oldstyle_js_1.texOldstyle, {
  0x20: {
    c: ' '
  },
  0x30: {
    c: '0'
  },
  0x31: {
    c: '1'
  },
  0x32: {
    c: '2'
  },
  0x33: {
    c: '3'
  },
  0x34: {
    c: '4'
  },
  0x35: {
    c: '5'
  },
  0x36: {
    c: '6'
  },
  0x37: {
    c: '7'
  },
  0x38: {
    c: '8'
  },
  0x39: {
    c: '9'
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x391: {
    c: 'A',
    f: ''
  },
  0x392: {
    c: 'B',
    f: ''
  },
  0x395: {
    c: 'E',
    f: ''
  },
  0x396: {
    c: 'Z',
    f: ''
  },
  0x397: {
    c: 'H',
    f: ''
  },
  0x399: {
    c: 'I',
    f: ''
  },
  0x39A: {
    c: 'K',
    f: ''
  },
  0x39C: {
    c: 'M',
    f: ''
  },
  0x39D: {
    c: 'N',
    f: ''
  },
  0x39F: {
    c: 'O',
    f: ''
  },
  0x3A1: {
    c: 'P',
    f: ''
  },
  0x3A2: {
    c: '\\398',
    f: ''
  },
  0x3A4: {
    c: 'T',
    f: ''
  },
  0x3A7: {
    c: 'X',
    f: ''
  },
  0x3D2: {
    c: '\\3A5',
    f: ''
  },
  0x3DC: {
    c: 'F',
    f: ''
  }
});

/***/ }),
/* 339 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.texOldstyle = {
  0x20: [0, 0, .25],
  0x30: [.452, .022, .5],
  0x31: [.453, 0, .5],
  0x32: [.453, 0, .5],
  0x33: [.452, .216, .5],
  0x34: [.464, .194, .5],
  0x35: [.453, .216, .5],
  0x36: [.665, .022, .5],
  0x37: [.463, .216, .5],
  0x38: [.666, .021, .5],
  0x39: [.453, .216, .5],
  0x41: [.728, .05, .798, {
    sk: 0.194
  }],
  0x42: [.705, .022, .657, {
    sk: 0.139
  }],
  0x43: [.705, .025, .527, {
    sk: 0.139
  }],
  0x44: [.683, 0, .771, {
    sk: 0.0833
  }],
  0x45: [.705, .022, .528, {
    sk: 0.111
  }],
  0x46: [.683, .032, .719, {
    ic: .11,
    sk: 0.111
  }],
  0x47: [.704, .119, .595, {
    sk: 0.111
  }],
  0x48: [.683, .048, .845, {
    sk: 0.111
  }],
  0x49: [.683, 0, .545, {
    ic: .097,
    sk: 0.0278
  }],
  0x4A: [.683, .119, .678, {
    ic: .161,
    sk: 0.167
  }],
  0x4B: [.705, .022, .762, {
    sk: 0.0556
  }],
  0x4C: [.705, .022, .69, {
    sk: 0.139
  }],
  0x4D: [.705, .05, 1.201, {
    sk: 0.139
  }],
  0x4E: [.789, .05, .82, {
    ic: .159,
    sk: 0.0833
  }],
  0x4F: [.705, .022, .796, {
    sk: 0.111
  }],
  0x50: [.683, .057, .696, {
    sk: 0.0833
  }],
  0x51: [.705, .131, .817, {
    sk: 0.111
  }],
  0x52: [.682, .022, .848, {
    sk: 0.0833
  }],
  0x53: [.705, .022, .606, {
    sk: 0.139
  }],
  0x54: [.717, .068, .545, {
    ic: .288,
    sk: 0.0278
  }],
  0x55: [.683, .028, .626, {
    ic: .061,
    sk: 0.0833
  }],
  0x56: [.683, .052, .613, {
    sk: 0.0278
  }],
  0x57: [.683, .053, .988, {
    sk: 0.0833
  }],
  0x58: [.683, 0, .713, {
    ic: .094,
    sk: 0.139
  }],
  0x59: [.683, .143, .668, {
    sk: 0.0833
  }],
  0x5A: [.683, 0, .725, {
    sk: 0.139
  }],
  0xA0: [0, 0, .25],
  0x391: [.716, 0, .75],
  0x392: [.683, 0, .708],
  0x395: [.68, 0, .681],
  0x396: [.683, 0, .611],
  0x397: [.683, 0, .75],
  0x399: [.683, 0, .361],
  0x39A: [.683, 0, .778],
  0x39C: [.683, 0, .917],
  0x39D: [.683, 0, .75],
  0x39F: [.705, .022, .778],
  0x3A1: [.683, 0, .681],
  0x3A2: [.705, .022, .778],
  0x3A4: [.677, 0, .722],
  0x3A7: [.683, 0, .75],
  0x3D2: [.705, 0, .778],
  0x3DC: [.68, 0, .653]
};

/***/ }),
/* 340 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var tex_size3_js_1 = __webpack_require__(341);

exports.texSize3 = FontData_js_1.AddCSS(tex_size3_js_1.texSize3, {
  0x20: {
    c: ' '
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2F: {
    c: '/'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x7B: {
    c: '{'
  },
  0x7D: {
    c: '}'
  },
  0x2044: {
    c: '/'
  },
  0x2329: {
    c: '\\27E8'
  },
  0x232A: {
    c: '\\27E9'
  },
  0x3008: {
    c: '\\27E8'
  },
  0x3009: {
    c: '\\27E9'
  }
});

/***/ }),
/* 341 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.texSize3 = {
  0x20: [0, 0, .25],
  0x28: [1.45, .949, .736],
  0x29: [1.45, .949, .736],
  0x2F: [1.45, .949, 1.044],
  0x5B: [1.45, .949, .528],
  0x5C: [1.45, .949, 1.044],
  0x5D: [1.45, .949, .528],
  0x7B: [1.45, .949, .75],
  0x7D: [1.45, .949, .75],
  0xA0: [0, 0, .25],
  0x2C6: [.772, -0.564, 1.444],
  0x2DC: [.749, -0.61, 1.444],
  0x302: [.772, -0.564, 0],
  0x303: [.749, -0.61, 0],
  0x2044: [1.45, .949, 1.044],
  0x221A: [1.45, .95, 1],
  0x2308: [1.45, .949, .583],
  0x2309: [1.45, .949, .583],
  0x230A: [1.45, .949, .583],
  0x230B: [1.45, .949, .583],
  0x2329: [1.45, .95, .75],
  0x232A: [1.45, .949, .75],
  0x27E8: [1.45, .95, .75],
  0x27E9: [1.45, .949, .75],
  0x3008: [1.45, .95, .75],
  0x3009: [1.45, .949, .75]
};

/***/ }),
/* 342 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var tex_size4_js_1 = __webpack_require__(343);

exports.texSize4 = FontData_js_1.AddCSS(tex_size4_js_1.texSize4, {
  0x20: {
    c: ' '
  },
  0x28: {
    c: '('
  },
  0x29: {
    c: ')'
  },
  0x2F: {
    c: '/'
  },
  0x5B: {
    c: '['
  },
  0x5D: {
    c: ']'
  },
  0x7B: {
    c: '{'
  },
  0x7D: {
    c: '}'
  },
  0x2044: {
    c: '/'
  },
  0x2329: {
    c: '\\27E8'
  },
  0x232A: {
    c: '\\27E9'
  },
  0x3008: {
    c: '\\27E8'
  },
  0x3009: {
    c: '\\27E9'
  },
  0xE155: {
    c: '\\E153\\E152'
  },
  0xE156: {
    c: '\\E151\\E150'
  }
});

/***/ }),
/* 343 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.texSize4 = {
  0x20: [0, 0, .25],
  0x28: [1.75, 1.249, .792],
  0x29: [1.75, 1.249, .792],
  0x2F: [1.75, 1.249, 1.278],
  0x5B: [1.75, 1.249, .583],
  0x5C: [1.75, 1.249, 1.278],
  0x5D: [1.75, 1.249, .583],
  0x7B: [1.75, 1.249, .806],
  0x7D: [1.75, 1.249, .806],
  0xA0: [0, 0, .25],
  0x2C6: [.845, -0.561, 1.889],
  0x2DC: [.823, -0.583, 1.889],
  0x302: [.845, -0.561, 0],
  0x303: [.823, -0.583, 0],
  0x2044: [1.75, 1.249, 1.278],
  0x221A: [1.75, 1.25, 1],
  0x2308: [1.75, 1.249, .639],
  0x2309: [1.75, 1.249, .639],
  0x230A: [1.75, 1.249, .639],
  0x230B: [1.75, 1.249, .639],
  0x2329: [1.75, 1.248, .806],
  0x232A: [1.75, 1.248, .806],
  0x239B: [1.154, .655, .875],
  0x239C: [.61, .01, .875],
  0x239D: [1.165, .644, .875],
  0x239E: [1.154, .655, .875],
  0x239F: [.61, .01, .875],
  0x23A0: [1.165, .644, .875],
  0x23A1: [1.154, .645, .667],
  0x23A2: [.602, 0, .667],
  0x23A3: [1.155, .644, .667],
  0x23A4: [1.154, .645, .667],
  0x23A5: [.602, 0, .667],
  0x23A6: [1.155, .644, .667],
  0x23A7: [.899, .01, .889],
  0x23A8: [1.16, .66, .889],
  0x23A9: [.01, .899, .889],
  0x23AA: [.29, .015, .889],
  0x23AB: [.899, .01, .889],
  0x23AC: [1.16, .66, .889],
  0x23AD: [.01, .899, .889],
  0x23B7: [.935, .885, 1.056],
  0x27E8: [1.75, 1.248, .806],
  0x27E9: [1.75, 1.248, .806],
  0x3008: [1.75, 1.248, .806],
  0x3009: [1.75, 1.248, .806],
  0xE000: [.625, .014, 1.056],
  0xE001: [.605, .014, 1.056],
  0xE150: [.12, .213, .45],
  0xE151: [.12, .213, .45],
  0xE152: [.333, 0, .45],
  0xE153: [.333, 0, .45],
  0xE154: [.32, .2, .4],
  0xE155: [.333, 0, .9],
  0xE156: [.12, .213, .9]
};

/***/ }),
/* 344 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(2);

var tex_variant_js_1 = __webpack_require__(345);

exports.texVariant = FontData_js_1.AddCSS(tex_variant_js_1.texVariant, {
  0x20: {
    c: ' '
  },
  0x41: {
    c: 'A'
  },
  0x42: {
    c: 'B'
  },
  0x43: {
    c: 'C'
  },
  0x44: {
    c: 'D'
  },
  0x45: {
    c: 'E'
  },
  0x46: {
    c: 'F'
  },
  0x47: {
    c: 'G'
  },
  0x48: {
    c: 'H'
  },
  0x49: {
    c: 'I'
  },
  0x4A: {
    c: 'J'
  },
  0x4B: {
    c: 'K'
  },
  0x4C: {
    c: 'L'
  },
  0x4D: {
    c: 'M'
  },
  0x4E: {
    c: 'N'
  },
  0x4F: {
    c: 'O'
  },
  0x50: {
    c: 'P'
  },
  0x51: {
    c: 'Q'
  },
  0x52: {
    c: 'R'
  },
  0x53: {
    c: 'S'
  },
  0x54: {
    c: 'T'
  },
  0x55: {
    c: 'U'
  },
  0x56: {
    c: 'V'
  },
  0x57: {
    c: 'W'
  },
  0x58: {
    c: 'X'
  },
  0x59: {
    c: 'Y'
  },
  0x5A: {
    c: 'Z'
  },
  0x6B: {
    c: 'k'
  },
  0x3DC: {
    c: '\\E008'
  },
  0x3F0: {
    c: '\\E009'
  },
  0x210F: {
    f: ''
  },
  0x2216: {
    f: ''
  },
  0x2224: {
    c: '\\E006'
  },
  0x2226: {
    c: '\\E007'
  },
  0x2268: {
    c: '\\E00C'
  },
  0x2269: {
    c: '\\E00D'
  },
  0x2270: {
    c: '\\E011'
  },
  0x2271: {
    c: '\\E00E'
  },
  0x2288: {
    c: '\\E016'
  },
  0x2289: {
    c: '\\E018'
  },
  0x228A: {
    c: '\\E01A'
  },
  0x228B: {
    c: '\\E01B'
  },
  0x2A87: {
    c: '\\E010'
  },
  0x2A88: {
    c: '\\E00F'
  },
  0x2ACB: {
    c: '\\E017'
  },
  0x2ACC: {
    c: '\\E019'
  }
});

/***/ }),
/* 345 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.texVariant = {
  0x20: [0, 0, .25],
  0x41: [.701, 0, .722],
  0x42: [.683, 0, .667],
  0x43: [.702, .019, .722],
  0x44: [.683, 0, .722],
  0x45: [.683, 0, .667],
  0x46: [.683, 0, .611],
  0x47: [.702, .019, .778],
  0x48: [.683, 0, .778],
  0x49: [.683, 0, .389],
  0x4A: [.683, .077, .5],
  0x4B: [.683, 0, .778],
  0x4C: [.683, 0, .667],
  0x4D: [.683, 0, .944],
  0x4E: [.683, .02, .722],
  0x4F: [.701, .019, .778],
  0x50: [.683, 0, .611],
  0x51: [.701, .181, .778],
  0x52: [.683, 0, .722],
  0x53: [.702, .012, .556],
  0x54: [.683, 0, .667],
  0x55: [.683, .019, .722],
  0x56: [.683, .02, .722],
  0x57: [.683, .019, 1],
  0x58: [.683, 0, .722],
  0x59: [.683, 0, .722],
  0x5A: [.683, 0, .667],
  0x6B: [.683, 0, .556],
  0xA0: [0, 0, .25],
  0xA5: [.683, 0, .75],
  0xAE: [.709, .175, .947],
  0xF0: [.749, .021, .556],
  0x127: [.695, .013, .54],
  0x2C6: [.845, -0.561, 2.333],
  0x2DC: [.899, -0.628, 2.333],
  0x302: [.845, -0.561, 0],
  0x303: [.899, -0.628, 0],
  0x3DC: [.605, .085, .778],
  0x3DD: [.605, .085, .778],
  0x3F0: [.434, .006, .667, {
    ic: .067
  }],
  0x2035: [.56, -0.043, .275],
  0x210F: [.695, .013, .54],
  0x2127: [.684, .022, .722],
  0x2132: [.695, 0, .556],
  0x2136: [.763, .021, .667],
  0x2137: [.764, .043, .444],
  0x2138: [.764, .043, .667],
  0x2141: [.705, .023, .639],
  0x2190: [.437, -0.064, .5],
  0x2192: [.437, -0.064, .5],
  0x219A: [.437, -0.06, 1],
  0x219B: [.437, -0.06, 1],
  0x219E: [.417, -0.083, 1],
  0x21A0: [.417, -0.083, 1],
  0x21A2: [.417, -0.083, 1.111],
  0x21A3: [.417, -0.083, 1.111],
  0x21AB: [.575, .041, 1],
  0x21AC: [.575, .041, 1],
  0x21AD: [.417, -0.083, 1.389],
  0x21AE: [.437, -0.06, 1],
  0x21B0: [.722, 0, .5],
  0x21B1: [.722, 0, .5],
  0x21B6: [.461, 0, 1],
  0x21B7: [.46, 0, 1],
  0x21BA: [.65, .083, .778],
  0x21BB: [.65, .083, .778],
  0x21BE: [.694, .194, .417],
  0x21BF: [.694, .194, .417],
  0x21C2: [.694, .194, .417],
  0x21C3: [.694, .194, .417],
  0x21C4: [.667, 0, 1],
  0x21C6: [.667, 0, 1],
  0x21C7: [.583, .083, 1],
  0x21C8: [.694, .193, .833],
  0x21C9: [.583, .083, 1],
  0x21CA: [.694, .194, .833],
  0x21CB: [.514, .014, 1],
  0x21CC: [.514, .014, 1],
  0x21CD: [.534, .035, 1],
  0x21CE: [.534, .037, 1],
  0x21CF: [.534, .035, 1],
  0x21DA: [.611, .111, 1],
  0x21DB: [.611, .111, 1],
  0x21DD: [.417, -0.083, 1],
  0x21E0: [.437, -0.064, 1.334],
  0x21E2: [.437, -0.064, 1.334],
  0x2201: [.846, .021, .5],
  0x2204: [.86, .166, .556],
  0x2205: [.587, 0, .778],
  0x220D: [.44, 0, .429],
  0x2212: [.27, -0.23, .5],
  0x2214: [.766, .093, .778],
  0x2216: [.43, .023, .778],
  0x221D: [.472, -0.028, .778],
  0x2220: [.694, 0, .722],
  0x2221: [.714, .02, .722],
  0x2222: [.551, .051, .722],
  0x2223: [.43, .023, .222],
  0x2224: [.43, .023, .222],
  0x2225: [.431, .023, .389],
  0x2226: [.431, .024, .389],
  0x2234: [.471, .082, .667],
  0x2235: [.471, .082, .667],
  0x223C: [.365, -0.132, .778],
  0x223D: [.367, -0.133, .778],
  0x2241: [.467, -0.032, .778],
  0x2242: [.463, -0.034, .778],
  0x2246: [.652, .155, .778],
  0x2248: [.481, -0.05, .778],
  0x224A: [.579, .039, .778],
  0x224E: [.492, -0.008, .778],
  0x224F: [.492, -0.133, .778],
  0x2251: [.609, .108, .778],
  0x2252: [.601, .101, .778],
  0x2253: [.601, .102, .778],
  0x2256: [.367, -0.133, .778],
  0x2257: [.721, -0.133, .778],
  0x225C: [.859, -0.133, .778],
  0x2266: [.753, .175, .778],
  0x2267: [.753, .175, .778],
  0x2268: [.752, .284, .778],
  0x2269: [.752, .284, .778],
  0x226C: [.75, .25, .5],
  0x226E: [.708, .209, .778],
  0x226F: [.708, .209, .778],
  0x2270: [.919, .421, .778],
  0x2271: [.919, .421, .778],
  0x2272: [.732, .228, .778],
  0x2273: [.732, .228, .778],
  0x2276: [.681, .253, .778],
  0x2277: [.681, .253, .778],
  0x227C: [.58, .153, .778],
  0x227D: [.58, .154, .778],
  0x227E: [.732, .228, .778],
  0x227F: [.732, .228, .778],
  0x2280: [.705, .208, .778],
  0x2281: [.705, .208, .778],
  0x2288: [.828, .33, .778],
  0x2289: [.828, .33, .778],
  0x228A: [.634, .255, .778],
  0x228B: [.634, .254, .778],
  0x228F: [.539, .041, .778],
  0x2290: [.539, .041, .778],
  0x229A: [.582, .082, .778],
  0x229B: [.582, .082, .778],
  0x229D: [.582, .082, .778],
  0x229E: [.689, 0, .778],
  0x229F: [.689, 0, .778],
  0x22A0: [.689, 0, .778],
  0x22A1: [.689, 0, .778],
  0x22A8: [.694, 0, .611],
  0x22A9: [.694, 0, .722],
  0x22AA: [.694, 0, .889],
  0x22AC: [.695, 0, .611],
  0x22AD: [.695, 0, .611],
  0x22AE: [.695, 0, .722],
  0x22AF: [.695, 0, .722],
  0x22B2: [.539, .041, .778],
  0x22B3: [.539, .041, .778],
  0x22B4: [.636, .138, .778],
  0x22B5: [.636, .138, .778],
  0x22B8: [.408, -0.092, 1.111],
  0x22BA: [.431, .212, .556],
  0x22BB: [.716, 0, .611],
  0x22BC: [.716, 0, .611],
  0x22C5: [.189, 0, .278],
  0x22C7: [.545, .044, .778],
  0x22C9: [.492, -0.008, .778],
  0x22CA: [.492, -0.008, .778],
  0x22CB: [.694, .022, .778],
  0x22CC: [.694, .022, .778],
  0x22CD: [.464, -0.036, .778],
  0x22CE: [.578, .021, .76],
  0x22CF: [.578, .022, .76],
  0x22D0: [.54, .04, .778],
  0x22D1: [.54, .04, .778],
  0x22D2: [.598, .022, .667],
  0x22D3: [.598, .022, .667],
  0x22D4: [.736, .022, .667],
  0x22D6: [.541, .041, .778],
  0x22D7: [.541, .041, .778],
  0x22D8: [.568, .067, 1.333],
  0x22D9: [.568, .067, 1.333],
  0x22DA: [.886, .386, .778],
  0x22DB: [.886, .386, .778],
  0x22DE: [.734, 0, .778],
  0x22DF: [.734, 0, .778],
  0x22E0: [.801, .303, .778],
  0x22E1: [.801, .303, .778],
  0x22E6: [.73, .359, .778],
  0x22E7: [.73, .359, .778],
  0x22E8: [.73, .359, .778],
  0x22E9: [.73, .359, .778],
  0x22EA: [.706, .208, .778],
  0x22EB: [.706, .208, .778],
  0x22EC: [.802, .303, .778],
  0x22ED: [.801, .303, .778],
  0x2322: [.378, -0.122, .778],
  0x2323: [.378, -0.143, .778],
  0x24C8: [.709, .175, .902],
  0x250C: [.694, -0.306, .5],
  0x2510: [.694, -0.306, .5],
  0x2514: [.366, .022, .5],
  0x2518: [.366, .022, .5],
  0x2571: [.694, .195, .889],
  0x2572: [.694, .195, .889],
  0x25A0: [.689, 0, .778],
  0x25A1: [.689, 0, .778],
  0x25B2: [.575, .02, .722],
  0x25B3: [.575, .02, .722],
  0x25B6: [.539, .041, .778],
  0x25BC: [.576, .019, .722],
  0x25BD: [.576, .019, .722],
  0x25C0: [.539, .041, .778],
  0x25CA: [.716, .132, .667],
  0x2605: [.694, .111, .944],
  0x2713: [.706, .034, .833],
  0x2720: [.716, .022, .833],
  0x29EB: [.716, .132, .667],
  0x2A5E: [.813, .097, .611],
  0x2A7D: [.636, .138, .778],
  0x2A7E: [.636, .138, .778],
  0x2A85: [.762, .29, .778],
  0x2A86: [.762, .29, .778],
  0x2A87: [.801, .303, .778],
  0x2A88: [.801, .303, .778],
  0x2A89: [.761, .387, .778],
  0x2A8A: [.761, .387, .778],
  0x2A8B: [1.003, .463, .778],
  0x2A8C: [1.003, .463, .778],
  0x2A95: [.636, .138, .778],
  0x2A96: [.636, .138, .778],
  0x2AB5: [.752, .286, .778],
  0x2AB6: [.752, .286, .778],
  0x2AB7: [.761, .294, .778],
  0x2AB8: [.761, .294, .778],
  0x2AB9: [.761, .337, .778],
  0x2ABA: [.761, .337, .778],
  0x2AC5: [.753, .215, .778],
  0x2AC6: [.753, .215, .778],
  0x2ACB: [.752, .332, .778],
  0x2ACC: [.752, .333, .778],
  0xE006: [.43, .023, .222],
  0xE007: [.431, .024, .389],
  0xE008: [.605, .085, .778],
  0xE009: [.434, .006, .667, {
    ic: .067
  }],
  0xE00C: [.752, .284, .778],
  0xE00D: [.752, .284, .778],
  0xE00E: [.919, .421, .778],
  0xE00F: [.801, .303, .778],
  0xE010: [.801, .303, .778],
  0xE011: [.919, .421, .778],
  0xE016: [.828, .33, .778],
  0xE017: [.752, .332, .778],
  0xE018: [.828, .33, .778],
  0xE019: [.752, .333, .778],
  0xE01A: [.634, .255, .778],
  0xE01B: [.634, .254, .778]
};

/***/ }),
/* 346 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var FontData_js_1 = __webpack_require__(29);

exports.HDW1 = [.75, .25, .875];
exports.HDW2 = [.583, .082, 1];
exports.HDW3 = [.583, .082, .5];
exports.VSIZES = [1, 1.2, 1.8, 2.4, 3];
var DELIM2F = {
  c: 0x2F,
  dir: FontData_js_1.V,
  sizes: exports.VSIZES
};
var DELIMAF = {
  c: 0xAF,
  dir: FontData_js_1.H,
  sizes: [.59],
  stretch: [0, 0xAF],
  HDW: [.59, -0.544, .5]
};
var DELIM2C6 = {
  c: 0x2C6,
  dir: FontData_js_1.H,
  sizes: [.517, .817, 1.335, 1.777, 1.909]
};
var DELIM2DC = {
  c: 0x2DC,
  dir: FontData_js_1.H,
  sizes: [.583, .805, 1.33, 1.773, 1.887]
};
var DELIM2013 = {
  c: 0x2013,
  dir: FontData_js_1.H,
  sizes: [.5],
  stretch: [0, 0x2013],
  HDW: [.285, -0.248, .5]
};
var DELIM2190 = {
  c: 0x2190,
  dir: FontData_js_1.H,
  sizes: [1],
  stretch: [0x2190, 0x2212],
  HDW: exports.HDW2
};
var DELIM2192 = {
  c: 0x2192,
  dir: FontData_js_1.H,
  sizes: [1],
  stretch: [0, 0x2212, 0x2192],
  HDW: exports.HDW2
};
var DELIM2194 = {
  c: 0x2194,
  dir: FontData_js_1.H,
  sizes: [1],
  stretch: [0x2190, 0x2212, 0x2192],
  HDW: exports.HDW2
};
var DELIM21A4 = {
  c: 0x21A4,
  dir: FontData_js_1.H,
  stretch: [0x2190, 0x2212, 0x2223],
  HDW: exports.HDW3,
  min: 1.278
};
var DELIM21A6 = {
  c: 0x21A6,
  dir: FontData_js_1.H,
  sizes: [1],
  stretch: [0x2223, 0x2212, 0x2192],
  HDW: exports.HDW2
};
var DELIM21D0 = {
  c: 0x21D0,
  dir: FontData_js_1.H,
  sizes: [1],
  stretch: [0x21D0, 0x3D],
  HDW: exports.HDW2
};
var DELIM21D2 = {
  c: 0x21D2,
  dir: FontData_js_1.H,
  sizes: [1],
  stretch: [0, 0x3D, 0x21D2],
  HDW: exports.HDW2
};
var DELIM21D4 = {
  c: 0x21D4,
  dir: FontData_js_1.H,
  sizes: [1],
  stretch: [0x21D0, 0x3D, 0x21D2],
  HDW: exports.HDW2
};
var DELIM2212 = {
  c: 0x2212,
  dir: FontData_js_1.H,
  sizes: [.778],
  stretch: [0, 0x2212],
  HDW: [.583, .082, .778]
};
var DELIM2223 = {
  c: 0x2223,
  dir: FontData_js_1.V,
  sizes: [1],
  stretch: [0, 0x2223],
  HDW: [.75, .249, .278]
};
var DELIM23DC = {
  c: 0x23DC,
  dir: FontData_js_1.H,
  sizes: [.778, 1],
  schar: [0x2322, 0x2322],
  stretch: [0xE150, 0xE154, 0xE151],
  HDW: [.32, .2, .5]
};
var DELIM23DD = {
  c: 0x23DD,
  dir: FontData_js_1.H,
  sizes: [.778, 1],
  schar: [0x2323, 0x2323],
  stretch: [0xE152, 0xE154, 0xE153],
  HDW: [.32, .2, .5]
};
var DELIM23DE = {
  c: 0x23DE,
  dir: FontData_js_1.H,
  stretch: [0xE150, 0xE154, 0xE151, 0xE155],
  HDW: [.32, .2, .5],
  min: 1.8
};
var DELIM23DF = {
  c: 0x23DF,
  dir: FontData_js_1.H,
  stretch: [0xE152, 0xE154, 0xE153, 0xE156],
  HDW: [.32, .2, .5],
  min: 1.8
};
var DELIM27E8 = {
  c: 0x27E8,
  dir: FontData_js_1.V,
  sizes: exports.VSIZES
};
var DELIM27E9 = {
  c: 0x27E9,
  dir: FontData_js_1.V,
  sizes: exports.VSIZES
};
var DELIM2906 = {
  c: 0x2906,
  dir: FontData_js_1.H,
  stretch: [0x21D0, 0x3D, 0x2223],
  HDW: exports.HDW3,
  min: 1.278
};
var DELIM2907 = {
  c: 0x2907,
  dir: FontData_js_1.H,
  stretch: [0x22A8, 0x3D, 0x21D2],
  HDW: exports.HDW3,
  min: 1.278
};
exports.delimiters = {
  0x28: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0x239B, 0x239C, 0x239D],
    HDW: [.75, .25, .875]
  },
  0x29: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0x239E, 0x239F, 0x23A0],
    HDW: [.75, .25, .875]
  },
  0x2D: DELIM2212,
  0x2F: DELIM2F,
  0x3D: {
    dir: FontData_js_1.H,
    sizes: [.767],
    stretch: [0, 0x3D],
    HDW: [.583, .082, .778]
  },
  0x5B: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0x23A1, 0x23A2, 0x23A3],
    HDW: exports.HDW1
  },
  0x5C: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES
  },
  0x5D: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0x23A4, 0x23A5, 0x23A6],
    HDW: exports.HDW1
  },
  0x5E: DELIM2C6,
  0x5F: DELIM2013,
  0x7B: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0x23A7, 0x23AA, 0x23A9, 0x23A8],
    HDW: [.75, .25, .889]
  },
  0x7C: {
    dir: FontData_js_1.V,
    sizes: [1],
    stretch: [0, 0x2223],
    HDW: [.75, .249, .278]
  },
  0x7D: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0x23AB, 0x23AA, 0x23AD, 0x23AC],
    HDW: [.75, .25, .889]
  },
  0x7E: DELIM2DC,
  0xAF: DELIMAF,
  0x2C6: DELIM2C6,
  0x2C9: DELIMAF,
  0x2DC: DELIM2DC,
  0x302: DELIM2C6,
  0x303: DELIM2DC,
  0x332: DELIM2013,
  0x2013: DELIM2013,
  0x2014: DELIM2013,
  0x2015: DELIM2013,
  0x2016: {
    dir: FontData_js_1.V,
    sizes: [.602, 1],
    schar: [0, 0x2225],
    stretch: [0, 0x2225],
    HDW: [.75, .25, .5]
  },
  0x2017: DELIM2013,
  0x203E: DELIMAF,
  0x20D7: DELIM2192,
  0x2190: DELIM2190,
  0x2191: {
    dir: FontData_js_1.V,
    sizes: [.888],
    stretch: [0x2191, 0x23D0],
    HDW: [.694, .193, .667]
  },
  0x2192: DELIM2192,
  0x2193: {
    dir: FontData_js_1.V,
    sizes: [.888],
    stretch: [0, 0x23D0, 0x2193],
    HDW: [.694, .194, .667]
  },
  0x2194: DELIM2194,
  0x2195: {
    dir: FontData_js_1.V,
    sizes: [1.044],
    stretch: [0x2191, 0x23D0, 0x2193],
    HDW: [.772, .272, .667]
  },
  0x219E: {
    dir: FontData_js_1.H,
    sizes: [1],
    stretch: [0x219E, 0x2212],
    HDW: exports.HDW2
  },
  0x21A0: {
    dir: FontData_js_1.H,
    sizes: [1],
    stretch: [0, 0x2212, 0x21A0],
    HDW: exports.HDW2
  },
  0x21A4: DELIM21A4,
  0x21A5: {
    dir: FontData_js_1.V,
    stretch: [0x2191, 0x23D0, 0x22A5],
    HDW: exports.HDW1,
    min: 1.555
  },
  0x21A6: DELIM21A6,
  0x21A7: {
    dir: FontData_js_1.V,
    stretch: [0x22A4, 0x23D0, 0x2193],
    HDW: exports.HDW1,
    min: 1.555
  },
  0x21B0: {
    dir: FontData_js_1.V,
    sizes: [.722],
    stretch: [0x21B0, 0x23D0],
    HDW: [.722, 0, .667]
  },
  0x21B1: {
    dir: FontData_js_1.V,
    sizes: [.722],
    stretch: [0x21B1, 0x23D0],
    HDW: [.722, 0, .667]
  },
  0x21BC: {
    dir: FontData_js_1.H,
    sizes: [1],
    stretch: [0x21BC, 0x2212],
    HDW: exports.HDW2
  },
  0x21BD: {
    dir: FontData_js_1.H,
    sizes: [1],
    stretch: [0x21BD, 0x2212],
    HDW: exports.HDW2
  },
  0x21BE: {
    dir: FontData_js_1.V,
    sizes: [.888],
    stretch: [0x21BE, 0x23D0],
    HDW: [.694, .194, .667]
  },
  0x21BF: {
    dir: FontData_js_1.V,
    sizes: [.888],
    stretch: [0x21BF, 0x23D0],
    HDW: [.694, .194, .667]
  },
  0x21C0: {
    dir: FontData_js_1.H,
    sizes: [1],
    stretch: [0, 0x2212, 0x21C0],
    HDW: exports.HDW2
  },
  0x21C1: {
    dir: FontData_js_1.H,
    sizes: [1],
    stretch: [0, 0x2212, 0x21C1],
    HDW: exports.HDW2
  },
  0x21C2: {
    dir: FontData_js_1.V,
    sizes: [.888],
    stretch: [0, 0x23D0, 0x21C2],
    HDW: [.694, .194, .667]
  },
  0x21C3: {
    dir: FontData_js_1.V,
    sizes: [.888],
    stretch: [0, 0x23D0, 0x21C3],
    HDW: [.694, .194, .667]
  },
  0x21D0: DELIM21D0,
  0x21D1: {
    dir: FontData_js_1.V,
    sizes: [.888],
    stretch: [0x21D1, 0x2016],
    HDW: [.694, .194, .778]
  },
  0x21D2: DELIM21D2,
  0x21D3: {
    dir: FontData_js_1.V,
    sizes: [.888],
    stretch: [0, 0x2016, 0x21D3],
    HDW: [.694, .194, .778]
  },
  0x21D4: DELIM21D4,
  0x21D5: {
    dir: FontData_js_1.V,
    sizes: [1.044],
    stretch: [0x21D1, 0x2016, 0x21D3],
    HDW: [.772, .272, .778]
  },
  0x21DA: {
    dir: FontData_js_1.H,
    sizes: [1],
    stretch: [0x21DA, 0x2261],
    HDW: [.464, -0.036, 1]
  },
  0x21DB: {
    dir: FontData_js_1.H,
    sizes: [1],
    stretch: [0, 0x2261, 0x21DB],
    HDW: [.464, -0.036, 1]
  },
  0x2212: DELIM2212,
  0x2215: DELIM2F,
  0x221A: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0xE001, 0xE000, 0x23B7],
    HDW: [.8, .2, 1.056]
  },
  0x2223: DELIM2223,
  0x2225: {
    dir: FontData_js_1.V,
    sizes: [1],
    stretch: [0, 0x2225],
    HDW: [.75, .25, .5]
  },
  0x2308: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0x23A1, 0x23A2],
    HDW: exports.HDW1
  },
  0x2309: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0x23A4, 0x23A5],
    HDW: exports.HDW1
  },
  0x230A: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0, 0x23A2, 0x23A3],
    HDW: exports.HDW1
  },
  0x230B: {
    dir: FontData_js_1.V,
    sizes: exports.VSIZES,
    stretch: [0, 0x23A5, 0x23A6],
    HDW: exports.HDW1
  },
  0x2312: DELIM23DC,
  0x2322: DELIM23DC,
  0x2323: DELIM23DD,
  0x2329: DELIM27E8,
  0x232A: DELIM27E9,
  0x23AA: {
    dir: FontData_js_1.V,
    sizes: [.32],
    stretch: [0x23AA, 0x23AA, 0x23AA],
    HDW: [.29, .015, .889]
  },
  0x23AF: DELIM2013,
  0x23B0: {
    dir: FontData_js_1.V,
    sizes: [.989],
    stretch: [0x23A7, 0x23AA, 0x23AD],
    HDW: [.744, .244, .889]
  },
  0x23B1: {
    dir: FontData_js_1.V,
    sizes: [.989],
    stretch: [0x23AB, 0x23AA, 0x23A9],
    HDW: [.744, .244, .889]
  },
  0x23B4: {
    dir: FontData_js_1.H,
    stretch: [0x250C, 0x2212, 0x2510],
    HDW: exports.HDW3,
    min: 1
  },
  0x23B5: {
    dir: FontData_js_1.H,
    stretch: [0x2514, 0x2212, 0x2518],
    HDW: exports.HDW3,
    min: 1
  },
  0x23D0: {
    dir: FontData_js_1.V,
    sizes: [.602, 1],
    schar: [0, 0x2223],
    stretch: [0, 0x2223],
    HDW: [.602, 0, .278]
  },
  0x23DC: DELIM23DC,
  0x23DD: DELIM23DD,
  0x23DE: DELIM23DE,
  0x23DF: DELIM23DF,
  0x23E0: {
    dir: FontData_js_1.H,
    stretch: [0x2CA, 0x2C9, 0x2CB],
    HDW: [.59, -0.544, .5],
    min: 1
  },
  0x23E1: {
    dir: FontData_js_1.H,
    stretch: [0x2CB, 0x2C9, 0x2CA],
    HDW: [.59, -0.544, .5],
    min: 1
  },
  0x2500: DELIM2013,
  0x2758: DELIM2223,
  0x27E8: DELIM27E8,
  0x27E9: DELIM27E9,
  0x27EE: {
    dir: FontData_js_1.V,
    sizes: [.989],
    stretch: [0x23A7, 0x23AA, 0x23A9],
    HDW: [.744, .244, .889]
  },
  0x27EF: {
    dir: FontData_js_1.V,
    sizes: [.989],
    stretch: [0x23AB, 0x23AA, 0x23AD],
    HDW: [.744, .244, .889]
  },
  0x27F5: DELIM2190,
  0x27F6: DELIM2192,
  0x27F7: DELIM2194,
  0x27F8: DELIM21D0,
  0x27F9: DELIM21D2,
  0x27FA: DELIM21D4,
  0x27FB: DELIM21A4,
  0x27FC: DELIM21A6,
  0x27FD: DELIM2906,
  0x27FE: DELIM2907,
  0x2906: DELIM2906,
  0x2907: DELIM2907,
  0x294E: {
    dir: FontData_js_1.H,
    stretch: [0x21BC, 0x2212, 0x21C0],
    HDW: exports.HDW3,
    min: 2
  },
  0x294F: {
    dir: FontData_js_1.V,
    stretch: [0x21BE, 0x23D0, 0x21C2],
    HDW: exports.HDW1,
    min: 1.776
  },
  0x2950: {
    dir: FontData_js_1.H,
    stretch: [0x21BD, 0x2212, 0x21C1],
    HDW: exports.HDW3,
    min: 2
  },
  0x2951: {
    dir: FontData_js_1.V,
    stretch: [0x21BF, 0x23D0, 0x21C3],
    HDW: exports.HDW1,
    min: .5
  },
  0x295A: {
    dir: FontData_js_1.H,
    stretch: [0x21BC, 0x2212, 0x2223],
    HDW: exports.HDW3,
    min: 1.278
  },
  0x295B: {
    dir: FontData_js_1.H,
    stretch: [0x2223, 0x2212, 0x21C0],
    HDW: exports.HDW3,
    min: 1.278
  },
  0x295C: {
    dir: FontData_js_1.V,
    stretch: [0x21BE, 0x23D0, 0x22A5],
    HDW: exports.HDW1,
    min: 1.556
  },
  0x295D: {
    dir: FontData_js_1.V,
    stretch: [0x22A4, 0x23D0, 0x21C2],
    HDW: exports.HDW1,
    min: 1.556
  },
  0x295E: {
    dir: FontData_js_1.H,
    stretch: [0x21BD, 0x2212, 0x2223],
    HDW: exports.HDW3,
    min: 1.278
  },
  0x295F: {
    dir: FontData_js_1.H,
    stretch: [0x2223, 0x2212, 0x21C1],
    HDW: exports.HDW3,
    min: 1.278
  },
  0x2960: {
    dir: FontData_js_1.V,
    stretch: [0x21BF, 0x23D0, 0x22A5],
    HDW: exports.HDW1,
    min: 1.776
  },
  0x2961: {
    dir: FontData_js_1.V,
    stretch: [0x22A4, 0x23D0, 0x21C3],
    HDW: exports.HDW1,
    min: 1.776
  },
  0x3008: DELIM27E8,
  0x3009: DELIM27E9,
  0xFE37: DELIM23DE,
  0xFE38: DELIM23DF
};

/***/ }),
/* 347 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var HTMLAdaptor_js_1 = __webpack_require__(348);

function browserAdaptor() {
  return new HTMLAdaptor_js_1.HTMLAdaptor(window);
}

exports.browserAdaptor = browserAdaptor;

/***/ }),
/* 348 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var DOMAdaptor_js_1 = __webpack_require__(349);

var HTMLAdaptor = function (_super) {
  __extends(HTMLAdaptor, _super);

  function HTMLAdaptor(window) {
    var _this = _super.call(this, window.document) || this;

    _this.window = window;
    _this.parser = new window.DOMParser();
    return _this;
  }

  HTMLAdaptor.prototype.parse = function (text, format) {
    if (format === void 0) {
      format = 'text/html';
    }

    return this.parser.parseFromString(text, format);
  };

  HTMLAdaptor.prototype.create = function (kind, ns) {
    return ns ? this.document.createElementNS(ns, kind) : this.document.createElement(kind);
  };

  HTMLAdaptor.prototype.text = function (text) {
    return this.document.createTextNode(text);
  };

  HTMLAdaptor.prototype.head = function (doc) {
    return doc.head;
  };

  HTMLAdaptor.prototype.body = function (doc) {
    return doc.body;
  };

  HTMLAdaptor.prototype.root = function (doc) {
    return doc.documentElement;
  };

  HTMLAdaptor.prototype.tags = function (node, name, ns) {
    if (ns === void 0) {
      ns = null;
    }

    var nodes = ns ? node.getElementsByTagNameNS(ns, name) : node.getElementsByTagName(name);
    return Array.from(nodes);
  };

  HTMLAdaptor.prototype.getElements = function (nodes, document) {
    var containers = [];

    try {
      for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
        var node = nodes_1_1.value;

        if (typeof node === 'string') {
          containers = containers.concat(Array.from(this.document.querySelectorAll(node)));
        } else if (Array.isArray(node)) {
          containers = containers.concat(Array.from(node));
        } else if (node instanceof this.window.NodeList || node instanceof this.window.HTMLCollection) {
          containers = containers.concat(Array.from(node));
        } else {
          containers.push(node);
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    return containers;

    var e_1, _a;
  };

  HTMLAdaptor.prototype.parent = function (node) {
    return node.parentNode;
  };

  HTMLAdaptor.prototype.append = function (node, child) {
    return node.appendChild(child);
  };

  HTMLAdaptor.prototype.insert = function (nchild, ochild) {
    return this.parent(ochild).insertBefore(nchild, ochild);
  };

  HTMLAdaptor.prototype.remove = function (child) {
    return this.parent(child).removeChild(child);
  };

  HTMLAdaptor.prototype.replace = function (nnode, onode) {
    return this.parent(onode).replaceChild(nnode, onode);
  };

  HTMLAdaptor.prototype.clone = function (node) {
    return node.cloneNode(true);
  };

  HTMLAdaptor.prototype.split = function (node, n) {
    return node.splitText(n);
  };

  HTMLAdaptor.prototype.next = function (node) {
    return node.nextSibling;
  };

  HTMLAdaptor.prototype.previous = function (node) {
    return node.previousSibling;
  };

  HTMLAdaptor.prototype.firstChild = function (node) {
    return node.firstChild;
  };

  HTMLAdaptor.prototype.lastChild = function (node) {
    return node.lastChild;
  };

  HTMLAdaptor.prototype.childNodes = function (node) {
    return Array.from(node.childNodes);
  };

  HTMLAdaptor.prototype.childNode = function (node, i) {
    return node.childNodes[i];
  };

  HTMLAdaptor.prototype.kind = function (node) {
    return node.nodeName.toLowerCase();
  };

  HTMLAdaptor.prototype.value = function (node) {
    return node.nodeValue || '';
  };

  HTMLAdaptor.prototype.textContent = function (node) {
    return node.textContent;
  };

  HTMLAdaptor.prototype.innerHTML = function (node) {
    return node.innerHTML;
  };

  HTMLAdaptor.prototype.outerHTML = function (node) {
    return node.outerHTML;
  };

  HTMLAdaptor.prototype.setAttribute = function (node, name, value, ns) {
    if (ns === void 0) {
      ns = null;
    }

    return ns ? node.setAttributeNS(ns, name, value) : node.setAttribute(name, value);
  };

  HTMLAdaptor.prototype.getAttribute = function (node, name) {
    return node.getAttribute(name);
  };

  HTMLAdaptor.prototype.removeAttribute = function (node, name) {
    return node.removeAttribute(name);
  };

  HTMLAdaptor.prototype.hasAttribute = function (node, name) {
    return node.hasAttribute(name);
  };

  HTMLAdaptor.prototype.allAttributes = function (node) {
    return Array.from(node.attributes).map(function (x) {
      return {
        name: x.name,
        value: x.value
      };
    });
  };

  HTMLAdaptor.prototype.addClass = function (node, name) {
    node.classList.add(name);
  };

  HTMLAdaptor.prototype.removeClass = function (node, name) {
    return node.classList.remove(name);
  };

  HTMLAdaptor.prototype.hasClass = function (node, name) {
    return node.classList.contains(name);
  };

  HTMLAdaptor.prototype.setStyle = function (node, name, value) {
    node.style[name] = value;
  };

  HTMLAdaptor.prototype.getStyle = function (node, name) {
    return node.style[name];
  };

  HTMLAdaptor.prototype.allStyles = function (node) {
    return node.style.cssText;
  };

  HTMLAdaptor.prototype.fontSize = function (node) {
    var style = this.window.getComputedStyle(node);
    return parseFloat(style.fontSize);
  };

  HTMLAdaptor.prototype.nodeSize = function (node, em, local) {
    if (em === void 0) {
      em = 1;
    }

    if (local === void 0) {
      local = false;
    }

    if (local && node.getBBox) {
      var _a = node.getBBox(),
          width = _a.width,
          height = _a.height;

      return [width / em, height / em];
    }

    return [node.offsetWidth / em, node.offsetHeight / em];
  };

  HTMLAdaptor.prototype.nodeBBox = function (node) {
    var _a = node.getBoundingClientRect(),
        left = _a.left,
        right = _a.right,
        top = _a.top,
        bottom = _a.bottom;

    return {
      left: left,
      right: right,
      top: top,
      bottom: bottom
    };
  };

  return HTMLAdaptor;
}(DOMAdaptor_js_1.AbstractDOMAdaptor);

exports.HTMLAdaptor = HTMLAdaptor;

/***/ }),
/* 349 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var AbstractDOMAdaptor = function () {
  function AbstractDOMAdaptor(document) {
    if (document === void 0) {
      document = null;
    }

    this.document = document;
  }

  AbstractDOMAdaptor.prototype.node = function (kind, def, children, ns) {
    if (def === void 0) {
      def = {};
    }

    if (children === void 0) {
      children = [];
    }

    var node = this.create(kind, ns);
    this.setAttributes(node, def);

    try {
      for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
        var child = children_1_1.value;
        this.append(node, child);
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    return node;

    var e_1, _a;
  };

  AbstractDOMAdaptor.prototype.setAttributes = function (node, def) {
    if (def.style && typeof def.style !== 'string') {
      try {
        for (var _a = __values(Object.keys(def.style)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var key = _b.value;
          this.setStyle(node, key.replace(/-([a-z])/g, function (m, c) {
            return c.toUpperCase();
          }), def.style[key]);
        }
      } catch (e_2_1) {
        e_2 = {
          error: e_2_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_2) throw e_2.error;
        }
      }
    }

    if (def.properties) {
      try {
        for (var _d = __values(Object.keys(def.properties)), _e = _d.next(); !_e.done; _e = _d.next()) {
          var key = _e.value;
          node[key] = def.properties[key];
        }
      } catch (e_3_1) {
        e_3 = {
          error: e_3_1
        };
      } finally {
        try {
          if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
        } finally {
          if (e_3) throw e_3.error;
        }
      }
    }

    try {
      for (var _g = __values(Object.keys(def)), _h = _g.next(); !_h.done; _h = _g.next()) {
        var key = _h.value;

        if ((key !== 'style' || typeof def.style === 'string') && key !== 'properties') {
          this.setAttribute(node, key, def[key]);
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_h && !_h.done && (_j = _g.return)) _j.call(_g);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    var e_2, _c, e_3, _f, e_4, _j;
  };

  AbstractDOMAdaptor.prototype.replace = function (nnode, onode) {
    this.insert(nnode, onode);
    this.remove(onode);
    return onode;
  };

  AbstractDOMAdaptor.prototype.childNode = function (node, i) {
    return this.childNodes(node)[i];
  };

  AbstractDOMAdaptor.prototype.allClasses = function (node) {
    var classes = this.getAttribute(node, 'class');
    return !classes ? [] : classes.replace(/  +/g, ' ').replace(/^ /, '').replace(/ $/, '').split(/ /);
  };

  return AbstractDOMAdaptor;
}();

exports.AbstractDOMAdaptor = AbstractDOMAdaptor;

/***/ }),
/* 350 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

__webpack_require__(47);

__webpack_require__(351);

__webpack_require__(352);

__webpack_require__(355);

__webpack_require__(358);

__webpack_require__(359);

__webpack_require__(360);

__webpack_require__(364);

__webpack_require__(365);

__webpack_require__(369);

__webpack_require__(370);

__webpack_require__(371);

__webpack_require__(374);

__webpack_require__(376);

__webpack_require__(103);

__webpack_require__(378);

__webpack_require__(379);

__webpack_require__(380);

__webpack_require__(384);

__webpack_require__(385);

if (typeof MathJax !== 'undefined' && MathJax.loader) {
  MathJax.loader.preLoad('[tex]/action', '[tex]/ams', '[tex]/amsCd', '[tex]/bbox', '[tex]/boldsymbol', '[tex]/braket', '[tex]/cancel', '[tex]/color', '[tex]/enclose', '[tex]/extpfeil', '[tex]/html', '[tex]/mhchem', '[tex]/newcommand', '[tex]/noerrors', '[tex]/noundefined', '[tex]/physics', '[tex]/unicode', '[tex]/verb', '[tex]/configMacros');
}

exports.AllPackages = ['base', 'action', 'ams', 'amsCd', 'bbox', 'boldsymbol', 'braket', 'cancel', 'color', 'enclose', 'extpfeil', 'html', 'mhchem', 'newcommand', 'noerrors', 'noundefined', 'unicode', 'verb', 'configMacros'];

/***/ }),
/* 351 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var TexParser_js_1 = __webpack_require__(15);

var SymbolMap_js_1 = __webpack_require__(5);

var BaseMethods_js_1 = __webpack_require__(19);

exports.ActionMethods = {};
exports.ActionMethods.Macro = BaseMethods_js_1.default.Macro;

exports.ActionMethods.Toggle = function (parser, name) {
  var children = [];
  var arg;

  while ((arg = parser.GetArgument(name)) !== '\\endtoggle') {
    children.push(new TexParser_js_1.default(arg, parser.stack.env, parser.configuration).mml());
  }

  parser.Push(parser.create('node', 'maction', children, {
    actiontype: 'toggle'
  }));
};

exports.ActionMethods.Mathtip = function (parser, name) {
  var arg = parser.ParseArg(name);
  var tip = parser.ParseArg(name);
  parser.Push(parser.create('node', 'maction', [arg, tip], {
    actiontype: 'tooltip'
  }));
};

new SymbolMap_js_1.CommandMap('action-macros', {
  toggle: 'Toggle',
  mathtip: 'Mathtip',
  texttip: ['Macro', '\\mathtip{#1}{\\text{#2}}', 2]
}, exports.ActionMethods);
exports.ActionConfiguration = Configuration_js_1.Configuration.create('action', {
  handler: {
    macro: ['action-macros']
  }
});

/***/ }),
/* 352 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var AmsItems_js_1 = __webpack_require__(353);

var Tags_js_1 = __webpack_require__(35);

__webpack_require__(354);

var AmsTags = function (_super) {
  __extends(AmsTags, _super);

  function AmsTags() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return AmsTags;
}(Tags_js_1.AbstractTags);

exports.AmsTags = AmsTags;

var init = function (config) {
  config.append(Configuration_js_1.Configuration.extension());
};

exports.AmsConfiguration = Configuration_js_1.Configuration.create('ams', {
  handler: {
    delimiter: ['AMSsymbols-delimiter', 'AMSmath-delimiter'],
    macro: ['AMSsymbols-mathchar0mi', 'AMSsymbols-mathchar0m0', 'AMSsymbols-delimiter', 'AMSsymbols-macros', 'AMSmath-mathchar0mo', 'AMSmath-macros', 'AMSmath-delimiter'],
    environment: ['AMSmath-environment']
  },
  items: (_a = {}, _a[AmsItems_js_1.MultlineItem.prototype.kind] = AmsItems_js_1.MultlineItem, _a),
  tags: {
    'AMS': AmsTags
  },
  init: init
});

var _a;

/***/ }),
/* 353 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var BaseItems_js_1 = __webpack_require__(48);

var ParseUtil_js_1 = __webpack_require__(9);

var NodeUtil_js_1 = __webpack_require__(8);

var TexError_js_1 = __webpack_require__(6);

var TexConstants_js_1 = __webpack_require__(14);

var MultlineItem = function (_super) {
  __extends(MultlineItem, _super);

  function MultlineItem(factory) {
    var args = [];

    for (var _i = 1; _i < arguments.length; _i++) {
      args[_i - 1] = arguments[_i];
    }

    var _this = _super.call(this, factory) || this;

    _this.factory.configuration.tags.start('multline', true, args[0]);

    return _this;
  }

  Object.defineProperty(MultlineItem.prototype, "kind", {
    get: function () {
      return 'multline';
    },
    enumerable: true,
    configurable: true
  });

  MultlineItem.prototype.EndEntry = function () {
    if (this.table.length) {
      ParseUtil_js_1.default.fixInitialMO(this.factory.configuration, this.nodes);
    }

    var shove = this.getProperty('shove');
    var mtd = this.create('node', 'mtd', this.nodes, shove ? {
      columnalign: shove
    } : {});
    this.setProperty('shove', null);
    this.row.push(mtd);
    this.Clear();
  };

  MultlineItem.prototype.EndRow = function () {
    if (this.row.length !== 1) {
      throw new TexError_js_1.default('MultlineRowsOneCol', 'The rows within the %1 environment must have exactly one column', 'multline');
    }

    var row = this.create('node', 'mtr', this.row);
    this.table.push(row);
    this.row = [];
  };

  MultlineItem.prototype.EndTable = function () {
    _super.prototype.EndTable.call(this);

    if (this.table.length) {
      var m = this.table.length - 1,
          i = void 0,
          label = -1;

      if (!NodeUtil_js_1.default.getAttribute(NodeUtil_js_1.default.getChildren(this.table[0])[0], 'columnalign')) {
        NodeUtil_js_1.default.setAttribute(NodeUtil_js_1.default.getChildren(this.table[0])[0], 'columnalign', TexConstants_js_1.TexConstant.Align.LEFT);
      }

      if (!NodeUtil_js_1.default.getAttribute(NodeUtil_js_1.default.getChildren(this.table[m])[0], 'columnalign')) {
        NodeUtil_js_1.default.setAttribute(NodeUtil_js_1.default.getChildren(this.table[m])[0], 'columnalign', TexConstants_js_1.TexConstant.Align.RIGHT);
      }

      var tag = this.factory.configuration.tags.getTag();

      if (tag) {
        label = this.arraydef.side === TexConstants_js_1.TexConstant.Align.LEFT ? 0 : this.table.length - 1;
        var mtr = this.table[label];
        var mlabel = this.create('node', 'mlabeledtr', [tag].concat(NodeUtil_js_1.default.getChildren(mtr)));
        NodeUtil_js_1.default.copyAttributes(mtr, mlabel);
        this.table[label] = mlabel;
      }
    }

    this.factory.configuration.tags.end();
  };

  return MultlineItem;
}(BaseItems_js_1.ArrayItem);

exports.MultlineItem = MultlineItem;

/***/ }),
/* 354 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var AmsMethods_js_1 = __webpack_require__(54);

var sm = __webpack_require__(5);

var TexConstants_js_1 = __webpack_require__(14);

var ParseMethods_js_1 = __webpack_require__(28);

var ParseUtil_js_1 = __webpack_require__(9);

var MmlNode_js_1 = __webpack_require__(0);

var COLS = function (W) {
  var WW = [];

  for (var i = 0, m = W.length; i < m; i++) {
    WW[i] = ParseUtil_js_1.default.Em(W[i]);
  }

  return WW.join(' ');
};

new sm.CharacterMap('AMSmath-mathchar0mo', ParseMethods_js_1.default.mathchar0mo, {
  iiiint: ['\u2A0C', {
    texClass: MmlNode_js_1.TEXCLASS.OP
  }]
});
new sm.CommandMap('AMSmath-macros', {
  mathring: ['Accent', '02DA'],
  nobreakspace: 'Tilde',
  negmedspace: ['Spacer', TexConstants_js_1.TexConstant.Length.NEGATIVEMEDIUMMATHSPACE],
  negthickspace: ['Spacer', TexConstants_js_1.TexConstant.Length.NEGATIVETHICKMATHSPACE],
  idotsint: ['MultiIntegral', '\\int\\cdots\\int'],
  dddot: ['Accent', '20DB'],
  ddddot: ['Accent', '20DC'],
  sideset: ['Macro', '\\mathop{\\mathop{\\rlap{\\phantom{#3}}}\\nolimits#1' + '\\!\\mathop{#3}\\nolimits#2}', 3],
  boxed: ['Macro', '\\fbox{$\\displaystyle{#1}$}', 1],
  tag: 'HandleTag',
  notag: 'HandleNoTag',
  eqref: ['HandleRef', true],
  substack: ['Macro', '\\begin{subarray}{c}#1\\end{subarray}', 1],
  injlim: ['NamedOp', 'inj&thinsp;lim'],
  projlim: ['NamedOp', 'proj&thinsp;lim'],
  varliminf: ['Macro', '\\mathop{\\underline{\\mmlToken{mi}{lim}}}'],
  varlimsup: ['Macro', '\\mathop{\\overline{\\mmlToken{mi}{lim}}}'],
  varinjlim: ['Macro', '\\mathop{\\underrightarrow{\\mmlToken{mi}{lim}}}'],
  varprojlim: ['Macro', '\\mathop{\\underleftarrow{\\mmlToken{mi}{lim}}}'],
  DeclareMathOperator: 'HandleDeclareOp',
  operatorname: 'HandleOperatorName',
  SkipLimits: 'SkipLimits',
  genfrac: 'Genfrac',
  frac: ['Genfrac', '', '', '', ''],
  tfrac: ['Genfrac', '', '', '', '1'],
  dfrac: ['Genfrac', '', '', '', '0'],
  binom: ['Genfrac', '(', ')', '0', ''],
  tbinom: ['Genfrac', '(', ')', '0', '1'],
  dbinom: ['Genfrac', '(', ')', '0', '0'],
  cfrac: 'CFrac',
  shoveleft: ['HandleShove', TexConstants_js_1.TexConstant.Align.LEFT],
  shoveright: ['HandleShove', TexConstants_js_1.TexConstant.Align.RIGHT],
  xrightarrow: ['xArrow', 0x2192, 5, 6],
  xleftarrow: ['xArrow', 0x2190, 7, 3]
}, AmsMethods_js_1.default);
new sm.EnvironmentMap('AMSmath-environment', ParseMethods_js_1.default.environment, {
  'eqnarray*': ['EqnArray', null, false, true, 'rcl', '0 ' + TexConstants_js_1.TexConstant.Length.THICKMATHSPACE, '.5em'],
  align: ['EqnArray', null, true, true, 'rlrlrlrlrlrl', COLS([0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0])],
  'align*': ['EqnArray', null, false, true, 'rlrlrlrlrlrl', COLS([0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0])],
  multline: ['Multline', null, true],
  'multline*': ['Multline', null, false],
  split: ['EqnArray', null, false, false, 'rl', COLS([0])],
  gather: ['EqnArray', null, true, true, 'c'],
  'gather*': ['EqnArray', null, false, true, 'c'],
  alignat: ['AlignAt', null, true, true],
  'alignat*': ['AlignAt', null, false, true],
  alignedat: ['AlignAt', null, false, false],
  aligned: ['AmsEqnArray', null, null, null, 'rlrlrlrlrlrl', COLS([0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0]), '.5em', 'D'],
  gathered: ['AmsEqnArray', null, null, null, 'c', null, '.5em', 'D'],
  subarray: ['Array', null, null, null, null, COLS([0]), '0.1em', 'S', 1],
  smallmatrix: ['Array', null, null, null, 'c', COLS([1 / 3]), '.2em', 'S', 1],
  matrix: ['Array', null, null, null, 'c'],
  pmatrix: ['Array', null, '(', ')', 'c'],
  bmatrix: ['Array', null, '[', ']', 'c'],
  Bmatrix: ['Array', null, '\\{', '\\}', 'c'],
  vmatrix: ['Array', null, '\\vert', '\\vert', 'c'],
  Vmatrix: ['Array', null, '\\Vert', '\\Vert', 'c'],
  cases: ['Array', null, '\\{', '.', 'll', null, '.2em', 'T']
}, AmsMethods_js_1.default);
new sm.DelimiterMap('AMSmath-delimiter', ParseMethods_js_1.default.delimiter, {
  '\\lvert': ['\u007C', {
    texClass: MmlNode_js_1.TEXCLASS.OPEN
  }],
  '\\rvert': ['\u007C', {
    texClass: MmlNode_js_1.TEXCLASS.CLOSE
  }],
  '\\lVert': ['\u2016', {
    texClass: MmlNode_js_1.TEXCLASS.OPEN
  }],
  '\\rVert': ['\u2016', {
    texClass: MmlNode_js_1.TEXCLASS.CLOSE
  }]
});
new sm.CharacterMap('AMSsymbols-mathchar0mi', ParseMethods_js_1.default.mathchar0mi, {
  digamma: '\u03DD',
  varkappa: '\u03F0',
  varGamma: ['\u0393', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varDelta: ['\u0394', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varTheta: ['\u0398', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varLambda: ['\u039B', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varXi: ['\u039E', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varPi: ['\u03A0', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varSigma: ['\u03A3', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varUpsilon: ['\u03A5', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varPhi: ['\u03A6', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varPsi: ['\u03A8', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  varOmega: ['\u03A9', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC
  }],
  beth: '\u2136',
  gimel: '\u2137',
  daleth: '\u2138',
  backprime: ['\u2035', {
    variantForm: true
  }],
  hslash: '\u210F',
  varnothing: ['\u2205', {
    variantForm: true
  }],
  blacktriangle: '\u25B4',
  triangledown: ['\u25BD', {
    variantForm: true
  }],
  blacktriangledown: '\u25BE',
  square: '\u25FB',
  Box: '\u25FB',
  blacksquare: '\u25FC',
  lozenge: '\u25CA',
  Diamond: '\u25CA',
  blacklozenge: '\u29EB',
  circledS: ['\u24C8', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  bigstar: '\u2605',
  sphericalangle: '\u2222',
  measuredangle: '\u2221',
  nexists: '\u2204',
  complement: '\u2201',
  mho: '\u2127',
  eth: ['\u00F0', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  Finv: '\u2132',
  diagup: '\u2571',
  Game: '\u2141',
  diagdown: '\u2572',
  Bbbk: ['\u006B', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.DOUBLESTRUCK
  }],
  yen: '\u00A5',
  circledR: '\u00AE',
  checkmark: '\u2713',
  maltese: '\u2720'
});
new sm.CharacterMap('AMSsymbols-mathchar0m0', ParseMethods_js_1.default.mathchar0mo, {
  dotplus: '\u2214',
  ltimes: '\u22C9',
  smallsetminus: '\u2216',
  rtimes: '\u22CA',
  Cap: '\u22D2',
  doublecap: '\u22D2',
  leftthreetimes: '\u22CB',
  Cup: '\u22D3',
  doublecup: '\u22D3',
  rightthreetimes: '\u22CC',
  barwedge: '\u22BC',
  curlywedge: '\u22CF',
  veebar: '\u22BB',
  curlyvee: '\u22CE',
  doublebarwedge: '\u2A5E',
  boxminus: '\u229F',
  circleddash: '\u229D',
  boxtimes: '\u22A0',
  circledast: '\u229B',
  boxdot: '\u22A1',
  circledcirc: '\u229A',
  boxplus: '\u229E',
  centerdot: ['\u22C5', {
    variantForm: true
  }],
  divideontimes: '\u22C7',
  intercal: '\u22BA',
  leqq: '\u2266',
  geqq: '\u2267',
  leqslant: '\u2A7D',
  geqslant: '\u2A7E',
  eqslantless: '\u2A95',
  eqslantgtr: '\u2A96',
  lesssim: '\u2272',
  gtrsim: '\u2273',
  lessapprox: '\u2A85',
  gtrapprox: '\u2A86',
  approxeq: '\u224A',
  lessdot: '\u22D6',
  gtrdot: '\u22D7',
  lll: '\u22D8',
  llless: '\u22D8',
  ggg: '\u22D9',
  gggtr: '\u22D9',
  lessgtr: '\u2276',
  gtrless: '\u2277',
  lesseqgtr: '\u22DA',
  gtreqless: '\u22DB',
  lesseqqgtr: '\u2A8B',
  gtreqqless: '\u2A8C',
  doteqdot: '\u2251',
  Doteq: '\u2251',
  eqcirc: '\u2256',
  risingdotseq: '\u2253',
  circeq: '\u2257',
  fallingdotseq: '\u2252',
  triangleq: '\u225C',
  backsim: '\u223D',
  thicksim: ['\u223C', {
    variantForm: true
  }],
  backsimeq: '\u22CD',
  thickapprox: ['\u2248', {
    variantForm: true
  }],
  subseteqq: '\u2AC5',
  supseteqq: '\u2AC6',
  Subset: '\u22D0',
  Supset: '\u22D1',
  sqsubset: '\u228F',
  sqsupset: '\u2290',
  preccurlyeq: '\u227C',
  succcurlyeq: '\u227D',
  curlyeqprec: '\u22DE',
  curlyeqsucc: '\u22DF',
  precsim: '\u227E',
  succsim: '\u227F',
  precapprox: '\u2AB7',
  succapprox: '\u2AB8',
  vartriangleleft: '\u22B2',
  lhd: '\u22B2',
  vartriangleright: '\u22B3',
  rhd: '\u22B3',
  trianglelefteq: '\u22B4',
  unlhd: '\u22B4',
  trianglerighteq: '\u22B5',
  unrhd: '\u22B5',
  vDash: '\u22A8',
  Vdash: '\u22A9',
  Vvdash: '\u22AA',
  smallsmile: ['\u2323', {
    variantForm: true
  }],
  shortmid: ['\u2223', {
    variantForm: true
  }],
  smallfrown: ['\u2322', {
    variantForm: true
  }],
  shortparallel: ['\u2225', {
    variantForm: true
  }],
  bumpeq: '\u224F',
  between: '\u226C',
  Bumpeq: '\u224E',
  pitchfork: '\u22D4',
  varpropto: '\u221D',
  backepsilon: '\u220D',
  blacktriangleleft: '\u25C2',
  blacktriangleright: '\u25B8',
  therefore: '\u2234',
  because: '\u2235',
  eqsim: '\u2242',
  vartriangle: ['\u25B3', {
    variantForm: true
  }],
  Join: '\u22C8',
  nless: '\u226E',
  ngtr: '\u226F',
  nleq: '\u2270',
  ngeq: '\u2271',
  nleqslant: ['\u2A87', {
    variantForm: true
  }],
  ngeqslant: ['\u2A88', {
    variantForm: true
  }],
  nleqq: ['\u2270', {
    variantForm: true
  }],
  ngeqq: ['\u2271', {
    variantForm: true
  }],
  lneq: '\u2A87',
  gneq: '\u2A88',
  lneqq: '\u2268',
  gneqq: '\u2269',
  lvertneqq: ['\u2268', {
    variantForm: true
  }],
  gvertneqq: ['\u2269', {
    variantForm: true
  }],
  lnsim: '\u22E6',
  gnsim: '\u22E7',
  lnapprox: '\u2A89',
  gnapprox: '\u2A8A',
  nprec: '\u2280',
  nsucc: '\u2281',
  npreceq: ['\u22E0', {
    variantForm: true
  }],
  nsucceq: ['\u22E1', {
    variantForm: true
  }],
  precneqq: '\u2AB5',
  succneqq: '\u2AB6',
  precnsim: '\u22E8',
  succnsim: '\u22E9',
  precnapprox: '\u2AB9',
  succnapprox: '\u2ABA',
  nsim: '\u2241',
  ncong: '\u2246',
  nshortmid: ['\u2224', {
    variantForm: true
  }],
  nshortparallel: ['\u2226', {
    variantForm: true
  }],
  nmid: '\u2224',
  nparallel: '\u2226',
  nvdash: '\u22AC',
  nvDash: '\u22AD',
  nVdash: '\u22AE',
  nVDash: '\u22AF',
  ntriangleleft: '\u22EA',
  ntriangleright: '\u22EB',
  ntrianglelefteq: '\u22EC',
  ntrianglerighteq: '\u22ED',
  nsubseteq: '\u2288',
  nsupseteq: '\u2289',
  nsubseteqq: ['\u2288', {
    variantForm: true
  }],
  nsupseteqq: ['\u2289', {
    variantForm: true
  }],
  subsetneq: '\u228A',
  supsetneq: '\u228B',
  varsubsetneq: ['\u228A', {
    variantForm: true
  }],
  varsupsetneq: ['\u228B', {
    variantForm: true
  }],
  subsetneqq: '\u2ACB',
  supsetneqq: '\u2ACC',
  varsubsetneqq: ['\u2ACB', {
    variantForm: true
  }],
  varsupsetneqq: ['\u2ACC', {
    variantForm: true
  }],
  leftleftarrows: '\u21C7',
  rightrightarrows: '\u21C9',
  leftrightarrows: '\u21C6',
  rightleftarrows: '\u21C4',
  Lleftarrow: '\u21DA',
  Rrightarrow: '\u21DB',
  twoheadleftarrow: '\u219E',
  twoheadrightarrow: '\u21A0',
  leftarrowtail: '\u21A2',
  rightarrowtail: '\u21A3',
  looparrowleft: '\u21AB',
  looparrowright: '\u21AC',
  leftrightharpoons: '\u21CB',
  rightleftharpoons: ['\u21CC', {
    variantForm: true
  }],
  curvearrowleft: '\u21B6',
  curvearrowright: '\u21B7',
  circlearrowleft: '\u21BA',
  circlearrowright: '\u21BB',
  Lsh: '\u21B0',
  Rsh: '\u21B1',
  upuparrows: '\u21C8',
  downdownarrows: '\u21CA',
  upharpoonleft: '\u21BF',
  upharpoonright: '\u21BE',
  downharpoonleft: '\u21C3',
  restriction: '\u21BE',
  multimap: '\u22B8',
  downharpoonright: '\u21C2',
  leftrightsquigarrow: '\u21AD',
  rightsquigarrow: '\u21DD',
  leadsto: '\u21DD',
  dashrightarrow: '\u21E2',
  dashleftarrow: '\u21E0',
  nleftarrow: '\u219A',
  nrightarrow: '\u219B',
  nLeftarrow: '\u21CD',
  nRightarrow: '\u21CF',
  nleftrightarrow: '\u21AE',
  nLeftrightarrow: '\u21CE'
});
new sm.DelimiterMap('AMSsymbols-delimiter', ParseMethods_js_1.default.delimiter, {
  '\\ulcorner': '\u231C',
  '\\urcorner': '\u231D',
  '\\llcorner': '\u231E',
  '\\lrcorner': '\u231F'
});
new sm.CommandMap('AMSsymbols-macros', {
  implies: ['Macro', '\\;\\Longrightarrow\\;'],
  impliedby: ['Macro', '\\;\\Longleftarrow\\;']
}, AmsMethods_js_1.default);

/***/ }),
/* 355 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

__webpack_require__(356);

exports.AmsCdConfiguration = Configuration_js_1.Configuration.create('amsCd', {
  handler: {
    character: ['amsCd_special'],
    macro: ['amsCd_macros'],
    environment: ['amsCd_environment']
  },
  options: {
    amsCd: {
      colspace: '5pt',
      rowspace: '5pt',
      harrowsize: '2.75em',
      varrowsize: '1.75em',
      hideHorizontalLabels: false
    }
  }
});

/***/ }),
/* 356 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var sm = __webpack_require__(5);

var ParseMethods_js_1 = __webpack_require__(28);

var AmsCdMethods_js_1 = __webpack_require__(357);

new sm.EnvironmentMap('amsCd_environment', ParseMethods_js_1.default.environment, {
  CD: 'CD'
}, AmsCdMethods_js_1.default);
new sm.CommandMap('amsCd_macros', {
  minCDarrowwidth: 'minCDarrowwidth',
  minCDarrowheight: 'minCDarrowheight'
}, AmsCdMethods_js_1.default);
new sm.MacroMap('amsCd_special', {
  '@': 'arrow'
}, AmsCdMethods_js_1.default);

/***/ }),
/* 357 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var TexParser_js_1 = __webpack_require__(15);

var BaseConfiguration_js_1 = __webpack_require__(47);

var MmlNode_js_1 = __webpack_require__(0);

var NodeUtil_js_1 = __webpack_require__(8);

var AmsCdMethods = {};

AmsCdMethods.CD = function (parser, begin) {
  parser.Push(begin);
  var item = parser.itemFactory.create('array');
  var options = parser.configuration.options.amsCd;
  item.setProperties({
    minw: parser.stack.env.CD_minw || options.harrowsize,
    minh: parser.stack.env.CD_minh || options.varrowsize
  });
  item.arraydef = {
    columnalign: 'center',
    columnspacing: options.colspace,
    rowspacing: options.rowspace,
    displaystyle: true
  };
  return item;
};

AmsCdMethods.arrow = function (parser, name) {
  var c = parser.string.charAt(parser.i);

  if (!c.match(/[><VA.|=]/)) {
    return BaseConfiguration_js_1.Other(parser, name);
  } else {
    parser.i++;
  }

  var first = parser.stack.Top();

  if (!first.isKind('array') || first.Size()) {
    AmsCdMethods.cell(parser, name);
    first = parser.stack.Top();
  }

  var top = first;
  var arrowRow = top.table.length % 2 === 1;
  var n = (top.row.length + (arrowRow ? 0 : 1)) % 2;

  while (n) {
    AmsCdMethods.cell(parser, name);
    n--;
  }

  var mml;
  var hdef = {
    minsize: top.getProperty('minw'),
    stretchy: true
  },
      vdef = {
    minsize: top.getProperty('minh'),
    stretchy: true,
    symmetric: true,
    lspace: 0,
    rspace: 0
  };

  if (c === '.') {} else if (c === '|') {
    mml = parser.create('token', 'mo', vdef, '\u2225');
  } else if (c === '=') {
    mml = parser.create('token', 'mo', hdef, '=');
  } else {
    var arrow = {
      '>': '\u2192',
      '<': '\u2190',
      'V': '\u2193',
      'A': '\u2191'
    }[c];
    var a = parser.GetUpTo(name + c, c);
    var b = parser.GetUpTo(name + c, c);

    if (c === '>' || c === '<') {
      mml = parser.create('token', 'mo', hdef, arrow);

      if (!a) {
        a = '\\kern ' + top.getProperty('minw');
      }

      if (a || b) {
        var pad = {
          width: '+11mu',
          lspace: '6mu'
        };
        mml = parser.create('node', 'munderover', [mml]);

        if (a) {
          var nodeA = new TexParser_js_1.default(a, parser.stack.env, parser.configuration).mml();
          var mpadded = parser.create('node', 'mpadded', [nodeA], pad);
          NodeUtil_js_1.default.setAttribute(mpadded, 'voffset', '.1em');
          NodeUtil_js_1.default.setChild(mml, mml.over, mpadded);
        }

        if (b) {
          var nodeB = new TexParser_js_1.default(b, parser.stack.env, parser.configuration).mml();
          NodeUtil_js_1.default.setChild(mml, mml.under, parser.create('node', 'mpadded', [nodeB], pad));
        }

        if (parser.configuration.options.amsCd.hideHorizontalLabels) {
          mml = parser.create('node', 'mpadded', mml, {
            depth: 0,
            height: '.67em'
          });
        }
      }
    } else {
      var arrowNode = parser.create('token', 'mo', vdef, arrow);
      mml = arrowNode;

      if (a || b) {
        mml = parser.create('node', 'mrow');

        if (a) {
          NodeUtil_js_1.default.appendChildren(mml, [new TexParser_js_1.default('\\scriptstyle\\llap{' + a + '}', parser.stack.env, parser.configuration).mml()]);
        }

        arrowNode.texClass = MmlNode_js_1.TEXCLASS.ORD;
        NodeUtil_js_1.default.appendChildren(mml, [arrowNode]);

        if (b) {
          NodeUtil_js_1.default.appendChildren(mml, [new TexParser_js_1.default('\\scriptstyle\\rlap{' + b + '}', parser.stack.env, parser.configuration).mml()]);
        }
      }
    }
  }

  if (mml) {
    parser.Push(mml);
  }

  AmsCdMethods.cell(parser, name);
};

AmsCdMethods.cell = function (parser, name) {
  var top = parser.stack.Top();

  if ((top.table || []).length % 2 === 0 && (top.row || []).length === 0) {
    parser.Push(parser.create('node', 'mpadded', [], {
      height: '8.5pt',
      depth: '2pt'
    }));
  }

  parser.Push(parser.itemFactory.create('cell').setProperties({
    isEntry: true,
    name: name
  }));
};

AmsCdMethods.minCDarrowwidth = function (parser, name) {
  parser.stack.env.CD_minw = parser.GetDimen(name);
};

AmsCdMethods.minCDarrowheight = function (parser, name) {
  parser.stack.env.CD_minh = parser.GetDimen(name);
};

exports.default = AmsCdMethods;

/***/ }),
/* 358 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var SymbolMap_js_1 = __webpack_require__(5);

var TexError_js_1 = __webpack_require__(6);

exports.BboxMethods = {};

exports.BboxMethods.BBox = function (parser, name) {
  var bbox = parser.GetBrackets(name, '');
  var math = parser.ParseArg(name);
  var parts = bbox.split(/,/);
  var def, background, style;

  for (var i = 0, m = parts.length; i < m; i++) {
    var part = parts[i].replace(/^\s+/, '').replace(/\s+$/, '');
    var match = part.match(/^(\.\d+|\d+(\.\d*)?)(pt|em|ex|mu|px|in|cm|mm)$/);

    if (match) {
      if (def) {
        throw new TexError_js_1.default('MultipleBBoxProperty', '%1 specified twice in %2', 'Padding', name);
      }

      var pad = BBoxPadding(match[1] + match[3]);

      if (pad) {
        def = {
          height: '+' + pad,
          depth: '+' + pad,
          lspace: pad,
          width: '+' + 2 * parseInt(match[1], 10) + match[3]
        };
      }
    } else if (part.match(/^([a-z0-9]+|\#[0-9a-f]{6}|\#[0-9a-f]{3})$/i)) {
      if (background) {
        throw new TexError_js_1.default('MultipleBBoxProperty', '%1 specified twice in %2', 'Background', name);
      }

      background = part;
    } else if (part.match(/^[-a-z]+:/i)) {
      if (style) {
        throw new TexError_js_1.default('MultipleBBoxProperty', '%1 specified twice in %2', 'Style', name);
      }

      style = BBoxStyle(part);
    } else if (part !== '') {
      throw new TexError_js_1.default('InvalidBBoxProperty', '"%1" doesn\'t look like a color, a padding dimension, or a style', part);
    }
  }

  if (def) {
    math = parser.create('node', 'mpadded', [math], def);
  }

  if (background || style) {
    def = {};

    if (background) {
      Object.assign(def, {
        mathbackground: background
      });
    }

    if (style) {
      Object.assign(def, {
        style: style
      });
    }

    math = parser.create('node', 'mstyle', [math], def);
  }

  parser.Push(math);
};

var BBoxStyle = function (styles) {
  return styles;
};

var BBoxPadding = function (pad) {
  return pad;
};

new SymbolMap_js_1.CommandMap('bbox', {
  bbox: 'BBox'
}, exports.BboxMethods);
exports.BboxConfiguration = Configuration_js_1.Configuration.create('bbox', {
  handler: {
    macro: ['bbox']
  }
});

/***/ }),
/* 359 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var NodeUtil_js_1 = __webpack_require__(8);

var TexConstants_js_1 = __webpack_require__(14);

var SymbolMap_js_1 = __webpack_require__(5);

var NodeFactory_js_1 = __webpack_require__(46);

var BOLDVARIANT = {};
BOLDVARIANT[TexConstants_js_1.TexConstant.Variant.NORMAL] = TexConstants_js_1.TexConstant.Variant.BOLD;
BOLDVARIANT[TexConstants_js_1.TexConstant.Variant.ITALIC] = TexConstants_js_1.TexConstant.Variant.BOLDITALIC;
BOLDVARIANT[TexConstants_js_1.TexConstant.Variant.FRAKTUR] = TexConstants_js_1.TexConstant.Variant.BOLDFRAKTUR;
BOLDVARIANT[TexConstants_js_1.TexConstant.Variant.SCRIPT] = TexConstants_js_1.TexConstant.Variant.BOLDSCRIPT;
BOLDVARIANT[TexConstants_js_1.TexConstant.Variant.SANSSERIF] = TexConstants_js_1.TexConstant.Variant.BOLDSANSSERIF;
BOLDVARIANT['-tex-caligraphic'] = '-tex-caligraphic-bold';
BOLDVARIANT['-tex-oldstyle'] = '-tex-oldstyle-bold';
exports.BoldsymbolMethods = {};

exports.BoldsymbolMethods.Boldsymbol = function (parser, name) {
  var boldsymbol = parser.stack.env['boldsymbol'];
  parser.stack.env['boldsymbol'] = true;
  var mml = parser.ParseArg(name);
  parser.stack.env['boldsymbol'] = boldsymbol;
  parser.Push(mml);
};

new SymbolMap_js_1.CommandMap('boldsymbol', {
  boldsymbol: 'Boldsymbol'
}, exports.BoldsymbolMethods);

function createBoldToken(factory, kind, def, text) {
  var token = NodeFactory_js_1.NodeFactory.createToken(factory, kind, def, text);

  if (kind !== 'mtext' && factory.configuration.parser.stack.env['boldsymbol']) {
    NodeUtil_js_1.default.setProperty(token, 'fixBold', true);
    factory.configuration.addNode('fixBold', token);
  }

  return token;
}

exports.createBoldToken = createBoldToken;

function rewriteBoldTokens(arg) {
  try {
    for (var _a = __values(arg.data.getList('fixBold')), _b = _a.next(); !_b.done; _b = _a.next()) {
      var node = _b.value;

      if (NodeUtil_js_1.default.getProperty(node, 'fixBold')) {
        var variant = NodeUtil_js_1.default.getAttribute(node, 'mathvariant');

        if (variant == null) {
          NodeUtil_js_1.default.setAttribute(node, 'mathvariant', TexConstants_js_1.TexConstant.Variant.BOLD);
        } else {
          NodeUtil_js_1.default.setAttribute(node, 'mathvariant', BOLDVARIANT[variant] || variant);
        }

        NodeUtil_js_1.default.removeProperties(node, 'fixBold');
      }
    }
  } catch (e_1_1) {
    e_1 = {
      error: e_1_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_1) throw e_1.error;
    }
  }

  var e_1, _c;
}

exports.rewriteBoldTokens = rewriteBoldTokens;
;
exports.BoldsymbolConfiguration = Configuration_js_1.Configuration.create('boldsymbol', {
  handler: {
    macro: ['boldsymbol']
  },
  nodes: {
    'token': createBoldToken
  },
  postprocessors: [rewriteBoldTokens]
});

/***/ }),
/* 360 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var BraketItems_js_1 = __webpack_require__(361);

__webpack_require__(362);

exports.BraketConfiguration = Configuration_js_1.Configuration.create('braket', {
  handler: {
    character: ['Braket-characters'],
    macro: ['Braket-macros']
  },
  items: (_a = {}, _a[BraketItems_js_1.BraketItem.prototype.kind] = BraketItems_js_1.BraketItem, _a)
});

var _a;

/***/ }),
/* 361 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var StackItem_js_1 = __webpack_require__(27);

var MmlNode_js_1 = __webpack_require__(0);

var ParseUtil_js_1 = __webpack_require__(9);

var BraketItem = function (_super) {
  __extends(BraketItem, _super);

  function BraketItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(BraketItem.prototype, "kind", {
    get: function () {
      return 'braket';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(BraketItem.prototype, "isOpen", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  BraketItem.prototype.checkItem = function (item) {
    if (item.isKind('close')) {
      return [[this.factory.create('mml', this.toMml())], true];
    }

    if (item.isKind('mml')) {
      this.Push(item.toMml());

      if (this.getProperty('single')) {
        return [[this.toMml()], true];
      }

      return StackItem_js_1.BaseItem.fail;
    }

    return _super.prototype.checkItem.call(this, item);
  };

  BraketItem.prototype.toMml = function () {
    var inner = _super.prototype.toMml.call(this);

    var open = this.getProperty('open');
    var close = this.getProperty('close');

    if (this.getProperty('stretchy')) {
      return ParseUtil_js_1.default.fenced(this.factory.configuration, open, inner, close);
    }

    var attrs = {
      fence: true,
      stretchy: false,
      symmetric: true,
      texClass: MmlNode_js_1.TEXCLASS.OPEN
    };
    var openNode = this.create('token', 'mo', attrs, open);
    attrs.texClass = MmlNode_js_1.TEXCLASS.CLOSE;
    var closeNode = this.create('token', 'mo', attrs, close);
    var mrow = this.create('node', 'mrow', [openNode, inner, closeNode], {
      open: open,
      close: close,
      texClass: MmlNode_js_1.TEXCLASS.INNER
    });
    return mrow;
  };

  return BraketItem;
}(StackItem_js_1.BaseItem);

exports.BraketItem = BraketItem;

/***/ }),
/* 362 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var SymbolMap_js_1 = __webpack_require__(5);

var BraketMethods_js_1 = __webpack_require__(363);

new SymbolMap_js_1.CommandMap('Braket-macros', {
  bra: ['Macro', '{\\langle {#1} \\vert}', 1],
  ket: ['Macro', '{\\vert {#1} \\rangle}', 1],
  braket: ['Braket', '\u27E8', '\u27E9', false, Infinity],
  'set': ['Braket', '{', '}', false, 1],
  Bra: ['Macro', '{\\left\\langle {#1} \\right\\vert}', 1],
  Ket: ['Macro', '{\\left\\vert {#1} \\right\\rangle}', 1],
  Braket: ['Braket', '\u27E8', '\u27E9', true, Infinity],
  Set: ['Braket', '{', '}', true, 1],
  ketbra: ['Macro', '{\\vert {#1} \\rangle\\langle {#2} \\vert}', 2],
  Ketbra: ['Macro', '{\\left\\vert {#1} \\right\\rangle\\left\\langle {#2} \\right\\vert}', 2],
  '|': 'Bar'
}, BraketMethods_js_1.default);
new SymbolMap_js_1.MacroMap('Braket-characters', {
  '|': 'Bar'
}, BraketMethods_js_1.default);

/***/ }),
/* 363 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var BaseMethods_js_1 = __webpack_require__(19);

var MmlNode_js_1 = __webpack_require__(0);

var BraketMethods = {};
BraketMethods.Macro = BaseMethods_js_1.default.Macro;

BraketMethods.Braket = function (parser, name, open, close, stretchy, barmax) {
  var next = parser.GetNext();
  var single = true;

  if (next === '{') {
    parser.i++;
    single = false;
  }

  parser.Push(parser.itemFactory.create('braket').setProperties({
    barmax: barmax,
    barcount: 0,
    open: open,
    close: close,
    stretchy: stretchy,
    single: single
  }));
};

BraketMethods.Bar = function (parser, name) {
  var c = name === '|' ? '|' : '\u2225';
  var top = parser.stack.Top();

  if (top.kind !== 'braket' || top.getProperty('barcount') >= top.getProperty('barmax')) {
    var mml = parser.create('token', 'mo', {
      texClass: MmlNode_js_1.TEXCLASS.ORD,
      stretchy: false
    }, c);
    parser.Push(mml);
    return;
  }

  if (c === '|' && parser.GetNext() === '|') {
    parser.i++;
    c = '\u2225';
  }

  var stretchy = top.getProperty('stretchy');

  if (!stretchy) {
    var node_1 = parser.create('token', 'mo', {
      stretchy: false,
      braketbar: true
    }, c);
    parser.Push(node_1);
    return;
  }

  var node = parser.create('node', 'TeXAtom', [], {
    texClass: MmlNode_js_1.TEXCLASS.CLOSE
  });
  parser.Push(node);
  top.setProperty('barcount', top.getProperty('barcount') + 1);
  node = parser.create('token', 'mo', {
    stretchy: true,
    braketbar: true
  }, c);
  parser.Push(node);
  node = parser.create('node', 'TeXAtom', [], {
    texClass: MmlNode_js_1.TEXCLASS.OPEN
  });
  parser.Push(node);
};

exports.default = BraketMethods;

/***/ }),
/* 364 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var TexConstants_js_1 = __webpack_require__(14);

var SymbolMap_js_1 = __webpack_require__(5);

var ParseUtil_js_1 = __webpack_require__(9);

var ALLOWED = {
  color: 1,
  mathcolor: 1,
  background: 1,
  mathbackground: 1,
  padding: 1,
  thickness: 1
};
exports.CancelMethods = {};

exports.CancelMethods.Cancel = function (parser, name, notation) {
  var attr = parser.GetBrackets(name, '');
  var math = parser.ParseArg(name);
  var def = ParseUtil_js_1.default.splitPackageOptions(attr, ALLOWED);
  def['notation'] = notation;
  parser.Push(parser.create('node', 'menclose', [math], def));
};

exports.CancelMethods.CancelTo = function (parser, name) {
  var attr = parser.GetBrackets(name, '');
  var value = parser.ParseArg(name);
  var math = parser.ParseArg(name);
  var def = ParseUtil_js_1.default.splitPackageOptions(attr, ALLOWED);
  def['notation'] = TexConstants_js_1.TexConstant.Notation.UPDIAGONALSTRIKE + ' ' + TexConstants_js_1.TexConstant.Notation.UPDIAGONALARROW;
  value = parser.create('node', 'mpadded', [value], {
    depth: '-.1em',
    height: ' + .1em',
    voffset: '.1em'
  });
  parser.Push(parser.create('node', 'msup', [parser.create('node', 'menclose', [math], def), value]));
};

new SymbolMap_js_1.CommandMap('cancel', {
  cancel: ['Cancel', TexConstants_js_1.TexConstant.Notation.UPDIAGONALSTRIKE],
  bcancel: ['Cancel', TexConstants_js_1.TexConstant.Notation.DOWNDIAGONALSTRIKE],
  xcancel: ['Cancel', TexConstants_js_1.TexConstant.Notation.UPDIAGONALSTRIKE + ' ' + TexConstants_js_1.TexConstant.Notation.DOWNDIAGONALSTRIKE],
  cancelto: 'CancelTo'
}, exports.CancelMethods);
exports.CancelConfiguration = Configuration_js_1.Configuration.create('cancel', {
  handler: {
    macro: ['cancel']
  }
});

/***/ }),
/* 365 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var SymbolMap_js_1 = __webpack_require__(5);

var Configuration_js_1 = __webpack_require__(4);

var ColorMethods_js_1 = __webpack_require__(366);

var ColorUtil_js_1 = __webpack_require__(367);

new SymbolMap_js_1.CommandMap('color', {
  color: 'Color',
  textcolor: 'TextColor',
  definecolor: 'DefineColor',
  colorbox: 'ColorBox',
  fcolorbox: 'FColorBox'
}, ColorMethods_js_1.ColorMethods);

var config = function (config, jax) {
  jax.parseOptions.options.color.model = new ColorUtil_js_1.ColorModel();
};

exports.ColorConfiguration = Configuration_js_1.Configuration.create('color', {
  handler: {
    macro: ['color']
  },
  options: {
    color: {
      padding: '5px',
      borderWidth: '2px'
    }
  },
  config: config
});

/***/ }),
/* 366 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var NodeUtil_js_1 = __webpack_require__(8);

var ParseUtil_js_1 = __webpack_require__(9);

function padding(colorPadding) {
  var pad = "+" + colorPadding;
  var unit = colorPadding.replace(/^.*?([a-z]*)$/, '$1');
  var pad2 = 2 * parseFloat(pad);
  return {
    width: "+" + pad2 + unit,
    height: pad,
    depth: pad,
    lspace: colorPadding
  };
}

;
exports.ColorMethods = {};

exports.ColorMethods.Color = function (parser, name) {
  var model = parser.GetBrackets(name, '');
  var colorDef = parser.GetArgument(name);
  var colorModel = parser.options.color.model;
  var color = colorModel.getColor(model, colorDef);
  var style = parser.itemFactory.create('style').setProperties({
    styles: {
      mathcolor: color
    }
  });
  parser.stack.env['color'] = color;
  parser.Push(style);
};

exports.ColorMethods.TextColor = function (parser, name) {
  var model = parser.GetBrackets(name, '');
  var colorDef = parser.GetArgument(name);
  var colorModel = parser.options.color.model;
  var color = colorModel.getColor(model, colorDef);
  var old = parser.stack.env['color'];
  parser.stack.env['color'] = color;
  var math = parser.ParseArg(name);

  if (old) {
    parser.stack.env['color'] = old;
  } else {
    delete parser.stack.env['color'];
  }

  var node = parser.create('node', 'mstyle', [math], {
    mathcolor: color
  });
  parser.Push(node);
};

exports.ColorMethods.DefineColor = function (parser, name) {
  var cname = parser.GetArgument(name);
  var model = parser.GetArgument(name);
  var def = parser.GetArgument(name);
  var colorModel = parser.options.color.model;
  colorModel.defineColor(model, cname, def);
};

exports.ColorMethods.ColorBox = function (parser, name) {
  var cname = parser.GetArgument(name);
  var math = ParseUtil_js_1.default.internalMath(parser, parser.GetArgument(name));
  var options = parser.options.color;
  var colorModel = options.model;
  var node = parser.create('node', 'mpadded', math, {
    mathbackground: colorModel.getColor('named', cname)
  });
  NodeUtil_js_1.default.setProperties(node, padding(options.padding));
  parser.Push(node);
};

exports.ColorMethods.FColorBox = function (parser, name) {
  var fname = parser.GetArgument(name);
  var cname = parser.GetArgument(name);
  var math = ParseUtil_js_1.default.internalMath(parser, parser.GetArgument(name));
  var options = parser.options.color;
  var colorModel = options.model;
  var node = parser.create('node', 'mpadded', math, {
    mathbackground: colorModel.getColor('named', cname),
    style: "border: " + options.borderWidth + " solid " + colorModel.getColor('named', fname)
  });
  NodeUtil_js_1.default.setProperties(node, padding(options.padding));
  parser.Push(node);
};

/***/ }),
/* 367 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var TexError_js_1 = __webpack_require__(6);

var ColorConstants_js_1 = __webpack_require__(368);

var ColorModelProcessors = new Map();

var ColorModel = function () {
  function ColorModel() {
    this.userColors = new Map();
  }

  ColorModel.prototype.normalizeColor = function (model, def) {
    if (!model || model === 'named') {
      return def;
    }

    if (ColorModelProcessors.has(model)) {
      var modelProcessor = ColorModelProcessors.get(model);
      return modelProcessor(def);
    }

    throw new TexError_js_1.default('UndefinedColorModel', 'Color model \'%1\' not defined', model);
  };

  ColorModel.prototype.getColor = function (model, def) {
    if (!model || model === 'named') {
      return this.getColorByName(def);
    }

    return this.normalizeColor(model, def);
  };

  ColorModel.prototype.getColorByName = function (name) {
    if (this.userColors.has(name)) {
      return this.userColors.get(name);
    }

    if (ColorConstants_js_1.COLORS.has(name)) {
      return ColorConstants_js_1.COLORS.get(name);
    }

    return name;
  };

  ColorModel.prototype.defineColor = function (model, name, def) {
    var normalized = this.normalizeColor(model, def);
    this.userColors.set(name, normalized);
  };

  return ColorModel;
}();

exports.ColorModel = ColorModel;
ColorModelProcessors.set('rgb', function (rgb) {
  var rgbParts = rgb.trim().split(/\s*,\s*/);
  var RGB = '#';

  if (rgbParts.length !== 3) {
    throw new TexError_js_1.default('ModelArg1', 'Color values for the %1 model require 3 numbers', 'rgb');
  }

  try {
    for (var rgbParts_1 = __values(rgbParts), rgbParts_1_1 = rgbParts_1.next(); !rgbParts_1_1.done; rgbParts_1_1 = rgbParts_1.next()) {
      var rgbPart = rgbParts_1_1.value;

      if (!rgbPart.match(/^(\d+(\.\d*)?|\.\d+)$/)) {
        throw new TexError_js_1.default('InvalidDecimalNumber', 'Invalid decimal number');
      }

      var n = parseFloat(rgbPart);

      if (n < 0 || n > 1) {
        throw new TexError_js_1.default('ModelArg2', 'Color values for the %1 model must be between %2 and %3', 'rgb', '0', '1');
      }

      var pn = Math.floor(n * 255).toString(16);

      if (pn.length < 2) {
        pn = '0' + pn;
      }

      RGB += pn;
    }
  } catch (e_1_1) {
    e_1 = {
      error: e_1_1
    };
  } finally {
    try {
      if (rgbParts_1_1 && !rgbParts_1_1.done && (_a = rgbParts_1.return)) _a.call(rgbParts_1);
    } finally {
      if (e_1) throw e_1.error;
    }
  }

  return RGB;

  var e_1, _a;
});
ColorModelProcessors.set('RGB', function (rgb) {
  var rgbParts = rgb.trim().split(/\s*,\s*/);
  var RGB = '#';

  if (rgbParts.length !== 3) {
    throw new TexError_js_1.default('ModelArg1', 'Color values for the %1 model require 3 numbers', 'RGB');
  }

  try {
    for (var rgbParts_2 = __values(rgbParts), rgbParts_2_1 = rgbParts_2.next(); !rgbParts_2_1.done; rgbParts_2_1 = rgbParts_2.next()) {
      var rgbPart = rgbParts_2_1.value;

      if (!rgbPart.match(/^\d+$/)) {
        throw new TexError_js_1.default('InvalidNumber', 'Invalid number');
      }

      var n = parseInt(rgbPart);

      if (n > 255) {
        throw new TexError_js_1.default('ModelArg2', 'Color values for the %1 model must be between %2 and %3', 'RGB', '0', '255');
      }

      var pn = n.toString(16);

      if (pn.length < 2) {
        pn = '0' + pn;
      }

      RGB += pn;
    }
  } catch (e_2_1) {
    e_2 = {
      error: e_2_1
    };
  } finally {
    try {
      if (rgbParts_2_1 && !rgbParts_2_1.done && (_a = rgbParts_2.return)) _a.call(rgbParts_2);
    } finally {
      if (e_2) throw e_2.error;
    }
  }

  return RGB;

  var e_2, _a;
});
ColorModelProcessors.set('gray', function (gray) {
  if (!gray.match(/^\s*(\d+(\.\d*)?|\.\d+)\s*$/)) {
    throw new TexError_js_1.default('InvalidDecimalNumber', 'Invalid decimal number');
  }

  var n = parseFloat(gray);

  if (n < 0 || n > 1) {
    throw new TexError_js_1.default('ModelArg2', 'Color values for the %1 model must be between %2 and %3', 'gray', '0', '1');
  }

  var pn = Math.floor(n * 255).toString(16);

  if (pn.length < 2) {
    pn = '0' + pn;
  }

  return "#" + pn + pn + pn;
});

/***/ }),
/* 368 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.COLORS = new Map([['Apricot', '#FBB982'], ['Aquamarine', '#00B5BE'], ['Bittersweet', '#C04F17'], ['Black', '#221E1F'], ['Blue', '#2D2F92'], ['BlueGreen', '#00B3B8'], ['BlueViolet', '#473992'], ['BrickRed', '#B6321C'], ['Brown', '#792500'], ['BurntOrange', '#F7921D'], ['CadetBlue', '#74729A'], ['CarnationPink', '#F282B4'], ['Cerulean', '#00A2E3'], ['CornflowerBlue', '#41B0E4'], ['Cyan', '#00AEEF'], ['Dandelion', '#FDBC42'], ['DarkOrchid', '#A4538A'], ['Emerald', '#00A99D'], ['ForestGreen', '#009B55'], ['Fuchsia', '#8C368C'], ['Goldenrod', '#FFDF42'], ['Gray', '#949698'], ['Green', '#00A64F'], ['GreenYellow', '#DFE674'], ['JungleGreen', '#00A99A'], ['Lavender', '#F49EC4'], ['LimeGreen', '#8DC73E'], ['Magenta', '#EC008C'], ['Mahogany', '#A9341F'], ['Maroon', '#AF3235'], ['Melon', '#F89E7B'], ['MidnightBlue', '#006795'], ['Mulberry', '#A93C93'], ['NavyBlue', '#006EB8'], ['OliveGreen', '#3C8031'], ['Orange', '#F58137'], ['OrangeRed', '#ED135A'], ['Orchid', '#AF72B0'], ['Peach', '#F7965A'], ['Periwinkle', '#7977B8'], ['PineGreen', '#008B72'], ['Plum', '#92268F'], ['ProcessBlue', '#00B0F0'], ['Purple', '#99479B'], ['RawSienna', '#974006'], ['Red', '#ED1B23'], ['RedOrange', '#F26035'], ['RedViolet', '#A1246B'], ['Rhodamine', '#EF559F'], ['RoyalBlue', '#0071BC'], ['RoyalPurple', '#613F99'], ['RubineRed', '#ED017D'], ['Salmon', '#F69289'], ['SeaGreen', '#3FBC9D'], ['Sepia', '#671800'], ['SkyBlue', '#46C5DD'], ['SpringGreen', '#C6DC67'], ['Tan', '#DA9D76'], ['TealBlue', '#00AEB3'], ['Thistle', '#D883B7'], ['Turquoise', '#00B4CE'], ['Violet', '#58429B'], ['VioletRed', '#EF58A0'], ['White', '#FFFFFF'], ['WildStrawberry', '#EE2967'], ['Yellow', '#FFF200'], ['YellowGreen', '#98CC70'], ['YellowOrange', '#FAA21A']]);

/***/ }),
/* 369 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var Options_js_1 = __webpack_require__(10);

var SymbolMap_js_1 = __webpack_require__(5);

var Symbol_js_1 = __webpack_require__(36);

var NewcommandMethods_js_1 = __webpack_require__(101);

function configMacrosConfig(config, jax) {
  var macros = config.options.macros;

  try {
    for (var _a = __values(Object.keys(macros)), _b = _a.next(); !_b.done; _b = _a.next()) {
      var cs = _b.value;
      var def = typeof macros[cs] === 'string' ? [macros[cs]] : macros[cs];
      var macro = Array.isArray(def[2]) ? new Symbol_js_1.Macro(cs, NewcommandMethods_js_1.default.MacroWithTemplate, def.slice(0, 2).concat(def[2])) : new Symbol_js_1.Macro(cs, NewcommandMethods_js_1.default.Macro, def);
      ConfigMacrosMap.add(cs, macro);
    }
  } catch (e_1_1) {
    e_1 = {
      error: e_1_1
    };
  } finally {
    try {
      if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
    } finally {
      if (e_1) throw e_1.error;
    }
  }

  var e_1, _c;
}

var ConfigMacrosMap = new SymbolMap_js_1.CommandMap('configMacros', {}, {});
exports.ConfigMacrosConfiguration = Configuration_js_1.Configuration.create('configMacros', {
  handler: {
    macro: ['configMacros']
  },
  config: configMacrosConfig,
  options: {
    macros: Options_js_1.expandable({})
  }
});

/***/ }),
/* 370 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var SymbolMap_js_1 = __webpack_require__(5);

var ParseUtil_js_1 = __webpack_require__(9);

var ALLOWED = {
  arrow: 1,
  color: 1,
  mathcolor: 1,
  background: 1,
  mathbackground: 1,
  padding: 1,
  thickness: 1
};
exports.EncloseMethods = {};

exports.EncloseMethods.Enclose = function (parser, name) {
  var notation = parser.GetArgument(name).replace(/,/g, ' ');
  var attr = parser.GetBrackets(name, '');
  var math = parser.ParseArg(name);
  var def = ParseUtil_js_1.default.splitPackageOptions(attr, ALLOWED);
  def.notation = notation;

  if (def.arrow) {
    def.notation += ' updiagonalarrow';
    delete def.arrow;
  }

  parser.Push(parser.create('node', 'menclose', [math], def));
};

new SymbolMap_js_1.CommandMap('enclose', {
  enclose: 'Enclose'
}, exports.EncloseMethods);
exports.EncloseConfiguration = Configuration_js_1.Configuration.create('enclose', {
  handler: {
    macro: ['enclose']
  }
});

/***/ }),
/* 371 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var SymbolMap_js_1 = __webpack_require__(5);

var AmsMethods_js_1 = __webpack_require__(54);

var NewcommandUtil_js_1 = __webpack_require__(102);

var NewcommandConfiguration_js_1 = __webpack_require__(103);

var TexError_js_1 = __webpack_require__(6);

exports.ExtpfeilMethods = {};
exports.ExtpfeilMethods.xArrow = AmsMethods_js_1.default.xArrow;

exports.ExtpfeilMethods.NewExtArrow = function (parser, name) {
  var cs = parser.GetArgument(name);
  var space = parser.GetArgument(name);
  var chr = parser.GetArgument(name);

  if (!cs.match(/^\\([a-z]+|.)$/i)) {
    throw new TexError_js_1.default('NewextarrowArg1', 'First argument to %1 must be a control sequence name', name);
  }

  if (!space.match(/^(\d+),(\d+)$/)) {
    throw new TexError_js_1.default('NewextarrowArg2', 'Second argument to %1 must be two integers separated by a comma', name);
  }

  if (!chr.match(/^(\d+|0x[0-9A-F]+)$/i)) {
    throw new TexError_js_1.default('NewextarrowArg3', 'Third argument to %1 must be a unicode character number', name);
  }

  cs = cs.substr(1);
  var spaces = space.split(',');
  NewcommandUtil_js_1.default.addMacro(parser, cs, exports.ExtpfeilMethods.xArrow, [parseInt(chr), parseInt(spaces[0]), parseInt(spaces[1])]);
};

new SymbolMap_js_1.CommandMap('extpfeil', {
  xtwoheadrightarrow: ['xArrow', 0x21A0, 12, 16],
  xtwoheadleftarrow: ['xArrow', 0x219E, 17, 13],
  xmapsto: ['xArrow', 0x21A6, 6, 7],
  xlongequal: ['xArrow', 0x003D, 7, 7],
  xtofrom: ['xArrow', 0x21C4, 12, 12],
  Newextarrow: 'NewExtArrow'
}, exports.ExtpfeilMethods);

var init = function (config) {
  NewcommandConfiguration_js_1.NewcommandConfiguration.init(config);
};

exports.ExtpfeilConfiguration = Configuration_js_1.Configuration.create('extpfeil', {
  handler: {
    macro: ['extpfeil']
  },
  init: init
});

/***/ }),
/* 372 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var TexError_js_1 = __webpack_require__(6);

var StackItem_js_1 = __webpack_require__(27);

var BeginEnvItem = function (_super) {
  __extends(BeginEnvItem, _super);

  function BeginEnvItem() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(BeginEnvItem.prototype, "kind", {
    get: function () {
      return 'beginEnv';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(BeginEnvItem.prototype, "isOpen", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  BeginEnvItem.prototype.checkItem = function (item) {
    if (item.isKind('end')) {
      if (item.getName() !== this.getName()) {
        throw new TexError_js_1.default('EnvBadEnd', '\\begin{%1} ended with \\end{%2}', this.getName(), item.getName());
      }

      return [[this.factory.create('mml', this.toMml())], true];
    }

    if (item.isKind('stop')) {
      throw new TexError_js_1.default('EnvMissingEnd', 'Missing \\end{%1}', this.getName());
    }

    return _super.prototype.checkItem.call(this, item);
  };

  return BeginEnvItem;
}(StackItem_js_1.BaseItem);

exports.BeginEnvItem = BeginEnvItem;

/***/ }),
/* 373 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var NewcommandMethods_js_1 = __webpack_require__(101);

var SymbolMap_js_1 = __webpack_require__(5);

new SymbolMap_js_1.CommandMap('Newcommand-macros', {
  newcommand: 'NewCommand',
  renewcommand: 'NewCommand',
  newenvironment: 'NewEnvironment',
  renewenvironment: 'NewEnvironment',
  def: 'MacroDef',
  'let': 'Let'
}, NewcommandMethods_js_1.default);

/***/ }),
/* 374 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var SymbolMap_js_1 = __webpack_require__(5);

var HtmlMethods_js_1 = __webpack_require__(375);

new SymbolMap_js_1.CommandMap('html_macros', {
  href: 'Href',
  'class': 'Class',
  style: 'Style',
  cssId: 'Id'
}, HtmlMethods_js_1.default);
exports.HtmlConfiguration = Configuration_js_1.Configuration.create('html', {
  handler: {
    macro: ['html_macros']
  }
});

/***/ }),
/* 375 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var NodeUtil_js_1 = __webpack_require__(8);

var HtmlMethods = {};

HtmlMethods.Href = function (parser, name) {
  var url = parser.GetArgument(name);
  var arg = GetArgumentMML(parser, name);
  NodeUtil_js_1.default.setAttribute(arg, 'href', url);
  parser.Push(arg);
};

HtmlMethods.Class = function (parser, name) {
  var CLASS = parser.GetArgument(name);
  var arg = GetArgumentMML(parser, name);
  var oldClass = NodeUtil_js_1.default.getAttribute(arg, 'class');

  if (oldClass) {
    CLASS = oldClass + ' ' + CLASS;
  }

  NodeUtil_js_1.default.setAttribute(arg, 'class', CLASS);
  parser.Push(arg);
};

HtmlMethods.Style = function (parser, name) {
  var style = parser.GetArgument(name);
  var arg = GetArgumentMML(parser, name);
  var oldStyle = NodeUtil_js_1.default.getAttribute(arg, 'style');

  if (oldStyle) {
    if (style.charAt(style.length - 1) !== ';') {
      style += ';';
    }

    style = oldStyle + ' ' + style;
  }

  NodeUtil_js_1.default.setAttribute(arg, 'style', style);
  parser.Push(arg);
};

HtmlMethods.Id = function (parser, name) {
  var ID = parser.GetArgument(name);
  var arg = GetArgumentMML(parser, name);
  NodeUtil_js_1.default.setAttribute(arg, 'id', ID);
  parser.Push(arg);
};

var GetArgumentMML = function (parser, name) {
  var arg = parser.ParseArg(name);

  if (!NodeUtil_js_1.default.isInferred(arg)) {
    return arg;
  }

  var children = NodeUtil_js_1.default.getChildren(arg);

  if (children.length === 1) {
    return children[0];
  }

  var mrow = parser.create('node', 'mrow');
  NodeUtil_js_1.default.copyChildren(arg, mrow);
  NodeUtil_js_1.default.copyAttributes(arg, mrow);
  return mrow;
};

exports.default = HtmlMethods;

/***/ }),
/* 376 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var SymbolMap_js_1 = __webpack_require__(5);

var TexError_js_1 = __webpack_require__(6);

var BaseMethods_js_1 = __webpack_require__(19);

var AmsMethods_js_1 = __webpack_require__(54);

var mhchem_parser_js_1 = __webpack_require__(377);

var MhchemMethods = {};
MhchemMethods.Macro = BaseMethods_js_1.default.Macro;
MhchemMethods.xArrow = AmsMethods_js_1.default.xArrow;

MhchemMethods.Machine = function (parser, name, machine) {
  try {
    var arg = parser.GetArgument(name);
    var data = mhchem_parser_js_1.mhchemParser.go(arg, machine);
    var tex = mhchem_parser_js_1.texify.go(data);
    parser.string = tex + parser.string.substr(parser.i);
    parser.i = 0;
  } catch (err) {
    throw new TexError_js_1.default(err[0], err[1], err.slice(2));
  }
};

new SymbolMap_js_1.CommandMap('mhchem', {
  ce: ['Machine', 'ce'],
  pu: ['Machine', 'pu'],
  longrightleftharpoons: ['Macro', '\\stackrel{\\textstyle{-}\\!\\!{\\rightharpoonup}}{\\smash{{\\leftharpoondown}\\!\\!{-}}}'],
  longRightleftharpoons: ['Macro', '\\stackrel{\\textstyle{-}\\!\\!{\\rightharpoonup}}{\\smash{\\leftharpoondown}}'],
  longLeftrightharpoons: ['Macro', '\\stackrel{\\textstyle\\vphantom{{-}}{\\rightharpoonup}}{\\smash{{\\leftharpoondown}\\!\\!{-}}}'],
  longleftrightarrows: ['Macro', '\\stackrel{\\longrightarrow}{\\smash{\\longleftarrow}\\Rule{0px}{.25em}{0px}}'],
  tripledash: ['Macro', '\\vphantom{-}\\raise2mu{\\kern2mu\\tiny\\text{-}\\kern1mu\\text{-}\\kern1mu\\text{-}\\kern2mu}'],
  xrightarrow: ['xArrow', 0x2192, 5, 6],
  xleftarrow: ['xArrow', 0x2190, 7, 3],
  xleftrightarrow: ['xArrow', 0x2194, 6, 6],
  xrightleftharpoons: ['xArrow', 0x21CC, 5, 7],
  xRightleftharpoons: ['xArrow', 0x21CC, 5, 7],
  xLeftrightharpoons: ['xArrow', 0x21CC, 5, 7]
}, MhchemMethods);
exports.MhchemConfiguration = Configuration_js_1.Configuration.create('mhchem', {
  handler: {
    macro: ['mhchem']
  }
});

/***/ }),
/* 377 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mhchemParser", function() { return mhchemParser; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "texify", function() { return texify; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "assertNever", function() { return assertNever; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "assertString", function() { return assertString; });
//
// Core parser for mhchem syntax  (recursive)
//

/** @type {MhchemParser} */
var mhchemParser = {
  //
  // Parses mchem \ce syntax
  //
  // Call like
  //   go("H2O");
  //
  go: function (input, stateMachine) {
    if (!input) {
      return [];
    }

    if (stateMachine === undefined) {
      stateMachine = 'ce';
    }

    var state = '0'; //
    // String buffers for parsing:
    //
    // buffer.a == amount
    // buffer.o == element
    // buffer.b == left-side superscript
    // buffer.p == left-side subscript
    // buffer.q == right-side subscript
    // buffer.d == right-side superscript
    //
    // buffer.r == arrow
    // buffer.rdt == arrow, script above, type
    // buffer.rd == arrow, script above, content
    // buffer.rqt == arrow, script below, type
    // buffer.rq == arrow, script below, content
    //
    // buffer.text_
    // buffer.rm
    // etc.
    //
    // buffer.parenthesisLevel == int, starting at 0
    // buffer.sb == bool, space before
    // buffer.beginsWithBond == bool
    //
    // These letters are also used as state names.
    //
    // Other states:
    // 0 == begin of main part (arrow/operator unlikely)
    // 1 == next entity
    // 2 == next entity (arrow/operator unlikely)
    // 3 == next atom
    // c == macro
    //

    /** @type {Buffer} */

    var buffer = {};
    buffer['parenthesisLevel'] = 0;
    input = input.replace(/\n/g, " ");
    input = input.replace(/[\u2212\u2013\u2014\u2010]/g, "-");
    input = input.replace(/[\u2026]/g, "..."); //
    // Looks through mhchemParser.transitions, to execute a matching action
    // (recursive)
    //

    var lastInput;
    var watchdog = 10;
    /** @type {ParserOutput[]} */

    var output = [];

    while (true) {
      if (lastInput !== input) {
        watchdog = 10;
        lastInput = input;
      } else {
        watchdog--;
      } //
      // Find actions in transition table
      //


      var machine = mhchemParser.stateMachines[stateMachine];
      var t = machine.transitions[state] || machine.transitions['*'];

      iterateTransitions: for (var i = 0; i < t.length; i++) {
        var matches = mhchemParser.patterns.match_(t[i].pattern, input);

        if (matches) {
          //
          // Execute actions
          //
          var task = t[i].task;

          for (var iA = 0; iA < task.action_.length; iA++) {
            var o; //
            // Find and execute action
            //

            if (machine.actions[task.action_[iA].type_]) {
              o = machine.actions[task.action_[iA].type_](buffer, matches.match_, task.action_[iA].option);
            } else if (mhchemParser.actions[task.action_[iA].type_]) {
              o = mhchemParser.actions[task.action_[iA].type_](buffer, matches.match_, task.action_[iA].option);
            } else {
              throw ["MhchemBugA", "mhchem bug A. Please report. (" + task.action_[iA].type_ + ")"]; // Trying to use non-existing action
            } //
            // Add output
            //


            mhchemParser.concatArray(output, o);
          } //
          // Set next state,
          // Shorten input,
          // Continue with next character
          //   (= apply only one transition per position)
          //


          state = task.nextState || state;

          if (input.length > 0) {
            if (!task.revisit) {
              input = matches.remainder;
            }

            if (!task.toContinue) {
              break iterateTransitions;
            }
          } else {
            return output;
          }
        }
      } //
      // Prevent infinite loop
      //


      if (watchdog <= 0) {
        throw ["MhchemBugU", "mhchem bug U. Please report."]; // Unexpected character
      }
    }
  },
  concatArray: function (a, b) {
    if (b) {
      if (Array.isArray(b)) {
        for (var iB = 0; iB < b.length; iB++) {
          a.push(b[iB]);
        }
      } else {
        a.push(b);
      }
    }
  },
  patterns: {
    //
    // Matching patterns
    // either regexps or function that return null or {match_:"a", remainder:"bc"}
    //
    patterns: {
      // property names must not look like integers ("2") for correct property traversal order, later on
      'empty': /^$/,
      'else': /^./,
      'else2': /^./,
      'space': /^\s/,
      'space A': /^\s(?=[A-Z\\$])/,
      'space$': /^\s$/,
      'a-z': /^[a-z]/,
      'x': /^x/,
      'x$': /^x$/,
      'i$': /^i$/,
      'letters': /^(?:[a-zA-Z\u03B1-\u03C9\u0391-\u03A9?@]|(?:\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))))+/,
      '\\greek': /^\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))/,
      'one lowercase latin letter $': /^(?:([a-z])(?:$|[^a-zA-Z]))$/,
      '$one lowercase latin letter$ $': /^\$(?:([a-z])(?:$|[^a-zA-Z]))\$$/,
      'one lowercase greek letter $': /^(?:\$?[\u03B1-\u03C9]\$?|\$?\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega)\s*\$?)(?:\s+|\{\}|(?![a-zA-Z]))$/,
      'digits': /^[0-9]+/,
      '-9.,9': /^[+\-]?(?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))/,
      '-9.,9 no missing 0': /^[+\-]?[0-9]+(?:[.,][0-9]+)?/,
      '(-)(9.,9)(e)(99)': function (input) {
        var m = input.match(/^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))?(\((?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))\))?(?:([eE]|\s*(\*|x|\\times|\u00D7)\s*10\^)([+\-]?[0-9]+|\{[+\-]?[0-9]+\}))?/);

        if (m && m[0]) {
          return {
            match_: m.splice(1),
            remainder: input.substr(m[0].length)
          };
        }

        return null;
      },
      '(-)(9)^(-9)': function (input) {
        var m = input.match(/^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+)?)\^([+\-]?[0-9]+|\{[+\-]?[0-9]+\})/);

        if (m && m[0]) {
          return {
            match_: m.splice(1),
            remainder: input.substr(m[0].length)
          };
        }

        return null;
      },
      'state of aggregation $': function (input) {
        // ... or crystal system
        var a = mhchemParser.patterns.findObserveGroups(input, "", /^\([a-z]{1,3}(?=[\),])/, ")", ""); // (aq), (aq,$\infty$), (aq, sat)

        if (a && a.remainder.match(/^($|[\s,;\)\]\}])/)) {
          return a;
        } //  AND end of 'phrase'


        var m = input.match(/^(?:\((?:\\ca\s?)?\$[amothc]\$\))/); // OR crystal system ($o$) (\ca$c$)

        if (m) {
          return {
            match_: m[0],
            remainder: input.substr(m[0].length)
          };
        }

        return null;
      },
      '_{(state of aggregation)}$': /^_\{(\([a-z]{1,3}\))\}/,
      '{[(': /^(?:\\\{|\[|\()/,
      ')]}': /^(?:\)|\]|\\\})/,
      ', ': /^[,;]\s*/,
      ',': /^[,;]/,
      '.': /^[.]/,
      '. ': /^([.\u22C5\u00B7\u2022])\s*/,
      '...': /^\.\.\.(?=$|[^.])/,
      '* ': /^([*])\s*/,
      '^{(...)}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "^{", "", "", "}");
      },
      '^($...$)': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "^", "$", "$", "");
      },
      '^a': /^\^([0-9]+|[^\\_])/,
      '^\\x{}{}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true);
      },
      '^\\x{}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", "");
      },
      '^\\x': /^\^(\\[a-zA-Z]+)\s*/,
      '^(-1)': /^\^(-?\d+)/,
      '\'': /^'/,
      '_{(...)}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "_{", "", "", "}");
      },
      '_($...$)': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "_", "$", "$", "");
      },
      '_9': /^_([+\-]?[0-9]+|[^\\])/,
      '_\\x{}{}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true);
      },
      '_\\x{}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", "");
      },
      '_\\x': /^_(\\[a-zA-Z]+)\s*/,
      '^_': /^(?:\^(?=_)|\_(?=\^)|[\^_]$)/,
      '{}': /^\{\}/,
      '{...}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "", "{", "}", "");
      },
      '{(...)}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "{", "", "", "}");
      },
      '$...$': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "", "$", "$", "");
      },
      '${(...)}$': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "${", "", "", "}$");
      },
      '$(...)$': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "$", "", "", "$");
      },
      '=<>': /^[=<>]/,
      '#': /^[#\u2261]/,
      '+': /^\+/,
      '-$': /^-(?=[\s_},;\]/]|$|\([a-z]+\))/,
      // -space -, -; -] -/ -$ -state-of-aggregation
      '-9': /^-(?=[0-9])/,
      '- orbital overlap': /^-(?=(?:[spd]|sp)(?:$|[\s,;\)\]\}]))/,
      '-': /^-/,
      'pm-operator': /^(?:\\pm|\$\\pm\$|\+-|\+\/-)/,
      'operator': /^(?:\+|(?:[\-=<>]|<<|>>|\\approx|\$\\approx\$)(?=\s|$|-?[0-9]))/,
      'arrowUpDown': /^(?:v|\(v\)|\^|\(\^\))(?=$|[\s,;\)\]\}])/,
      '\\bond{(...)}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "\\bond{", "", "", "}");
      },
      '->': /^(?:<->|<-->|->|<-|<=>>|<<=>|<=>|[\u2192\u27F6\u21CC])/,
      'CMT': /^[CMT](?=\[)/,
      '[(...)]': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "[", "", "", "]");
      },
      '1st-level escape': /^(&|\\\\|\\hline)\s*/,
      '\\,': /^(?:\\[,\ ;:])/,
      // \\x - but output no space before
      '\\x{}{}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true);
      },
      '\\x{}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", "");
      },
      '\\ca': /^\\ca(?:\s+|(?![a-zA-Z]))/,
      '\\x': /^(?:\\[a-zA-Z]+\s*|\\[_&{}%])/,
      'orbital': /^(?:[0-9]{1,2}[spdfgh]|[0-9]{0,2}sp)(?=$|[^a-zA-Z])/,
      // only those with numbers in front, because the others will be formatted correctly anyway
      'others': /^[\/~|]/,
      '\\frac{(...)}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "\\frac{", "", "", "}", "{", "", "", "}");
      },
      '\\overset{(...)}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "\\overset{", "", "", "}", "{", "", "", "}");
      },
      '\\underset{(...)}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "\\underset{", "", "", "}", "{", "", "", "}");
      },
      '\\underbrace{(...)}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "\\underbrace{", "", "", "}_", "{", "", "", "}");
      },
      '\\color{(...)}0': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}");
      },
      '\\color{(...)}{(...)}1': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}", "{", "", "", "}");
      },
      '\\color(...){(...)}2': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "\\color", "\\", "", /^(?=\{)/, "{", "", "", "}");
      },
      '\\ce{(...)}': function (input) {
        return mhchemParser.patterns.findObserveGroups(input, "\\ce{", "", "", "}");
      },
      'oxidation$': /^(?:[+-][IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
      'd-oxidation$': /^(?:[+-]?\s?[IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
      // 0 could be oxidation or charge
      'roman numeral': /^[IVX]+/,
      '1/2$': /^[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+(?:\$[a-z]\$|[a-z])?$/,
      'amount': function (input) {
        var match; // e.g. 2, 0.5, 1/2, -2, n/2, +;  $a$ could be added later in parsing

        match = input.match(/^(?:(?:(?:\([+\-]?[0-9]+\/[0-9]+\)|[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+|[+\-]?[0-9]+[.,][0-9]+|[+\-]?\.[0-9]+|[+\-]?[0-9]+)(?:[a-z](?=\s*[A-Z]))?)|[+\-]?[a-z](?=\s*[A-Z])|\+(?!\s))/);

        if (match) {
          return {
            match_: match[0],
            remainder: input.substr(match[0].length)
          };
        }

        var a = mhchemParser.patterns.findObserveGroups(input, "", "$", "$", "");

        if (a) {
          // e.g. $2n-1$, $-$
          match = a.match_.match(/^\$(?:\(?[+\-]?(?:[0-9]*[a-z]?[+\-])?[0-9]*[a-z](?:[+\-][0-9]*[a-z]?)?\)?|\+|-)\$$/);

          if (match) {
            return {
              match_: match[0],
              remainder: input.substr(match[0].length)
            };
          }
        }

        return null;
      },
      'amount2': function (input) {
        return this['amount'](input);
      },
      '(KV letters),': /^(?:[A-Z][a-z]{0,2}|i)(?=,)/,
      'formula$': function (input) {
        if (input.match(/^\([a-z]+\)$/)) {
          return null;
        } // state of aggregation = no formula


        var match = input.match(/^(?:[a-z]|(?:[0-9\ \+\-\,\.\(\)]+[a-z])+[0-9\ \+\-\,\.\(\)]*|(?:[a-z][0-9\ \+\-\,\.\(\)]+)+[a-z]?)$/);

        if (match) {
          return {
            match_: match[0],
            remainder: input.substr(match[0].length)
          };
        }

        return null;
      },
      'uprightEntities': /^(?:pH|pOH|pC|pK|iPr|iBu)(?=$|[^a-zA-Z])/,
      '/': /^\s*(\/)\s*/,
      '//': /^\s*(\/\/)\s*/,
      '*': /^\s*[*.]\s*/
    },
    findObserveGroups: function (input, begExcl, begIncl, endIncl, endExcl, beg2Excl, beg2Incl, end2Incl, end2Excl, combine) {
      /** @type {{(input: string, pattern: string | RegExp): string | string[] | null;}} */
      var _match = function (input, pattern) {
        if (typeof pattern === "string") {
          if (input.indexOf(pattern) !== 0) {
            return null;
          }

          return pattern;
        } else {
          var match = input.match(pattern);

          if (!match) {
            return null;
          }

          return match[0];
        }
      };
      /** @type {{(input: string, i: number, endChars: string | RegExp): {endMatchBegin: number, endMatchEnd: number} | null;}} */


      var _findObserveGroups = function (input, i, endChars) {
        var braces = 0;

        while (i < input.length) {
          var a = input.charAt(i);

          var match = _match(input.substr(i), endChars);

          if (match !== null && braces === 0) {
            return {
              endMatchBegin: i,
              endMatchEnd: i + match.length
            };
          } else if (a === "{") {
            braces++;
          } else if (a === "}") {
            if (braces === 0) {
              throw ["ExtraCloseMissingOpen", "Extra close brace or missing open brace"];
            } else {
              braces--;
            }
          }

          i++;
        }

        if (braces > 0) {
          return null;
        }

        return null;
      };

      var match = _match(input, begExcl);

      if (match === null) {
        return null;
      }

      input = input.substr(match.length);
      match = _match(input, begIncl);

      if (match === null) {
        return null;
      }

      var e = _findObserveGroups(input, match.length, endIncl || endExcl);

      if (e === null) {
        return null;
      }

      var match1 = input.substring(0, endIncl ? e.endMatchEnd : e.endMatchBegin);

      if (!(beg2Excl || beg2Incl)) {
        return {
          match_: match1,
          remainder: input.substr(e.endMatchEnd)
        };
      } else {
        var group2 = this.findObserveGroups(input.substr(e.endMatchEnd), beg2Excl, beg2Incl, end2Incl, end2Excl);

        if (group2 === null) {
          return null;
        }
        /** @type {string[]} */


        var matchRet = [match1, group2.match_];
        return {
          match_: combine ? matchRet.join("") : matchRet,
          remainder: group2.remainder
        };
      }
    },
    //
    // Matching function
    // e.g. match("a", input) will look for the regexp called "a" and see if it matches
    // returns null or {match_:"a", remainder:"bc"}
    //
    match_: function (m, input) {
      var pattern = mhchemParser.patterns.patterns[m];

      if (pattern === undefined) {
        throw ["MhchemBugP", "mhchem bug P. Please report. (" + m + ")"]; // Trying to use non-existing pattern
      } else if (typeof pattern === "function") {
        return mhchemParser.patterns.patterns[m](input); // cannot use cached var pattern here, because some pattern functions need this===mhchemParser
      } else {
        // RegExp
        var match = input.match(pattern);

        if (match) {
          var mm;

          if (match[2]) {
            mm = [match[1], match[2]];
          } else if (match[1]) {
            mm = match[1];
          } else {
            mm = match[0];
          }

          return {
            match_: mm,
            remainder: input.substr(match[0].length)
          };
        }

        return null;
      }
    }
  },
  //
  // Generic state machine actions
  //
  actions: {
    'a=': function (buffer, m) {
      buffer.a = (buffer.a || "") + m;
    },
    'b=': function (buffer, m) {
      buffer.b = (buffer.b || "") + m;
    },
    'p=': function (buffer, m) {
      buffer.p = (buffer.p || "") + m;
    },
    'o=': function (buffer, m) {
      buffer.o = (buffer.o || "") + m;
    },
    'q=': function (buffer, m) {
      buffer.q = (buffer.q || "") + m;
    },
    'd=': function (buffer, m) {
      buffer.d = (buffer.d || "") + m;
    },
    'rm=': function (buffer, m) {
      buffer.rm = (buffer.rm || "") + m;
    },
    'text=': function (buffer, m) {
      buffer.text_ = (buffer.text_ || "") + m;
    },
    'insert': function (buffer, m, a) {
      return {
        type_: a
      };
    },
    'insert+p1': function (buffer, m, a) {
      return {
        type_: a,
        p1: m
      };
    },
    'insert+p1+p2': function (buffer, m, a) {
      return {
        type_: a,
        p1: m[0],
        p2: m[1]
      };
    },
    'copy': function (buffer, m) {
      return m;
    },
    'rm': function (buffer, m) {
      return {
        type_: 'rm',
        p1: m || ""
      };
    },
    'text': function (buffer, m) {
      return mhchemParser.go(m, 'text');
    },
    '{text}': function (buffer, m) {
      var ret = ["{"];
      mhchemParser.concatArray(ret, mhchemParser.go(m, 'text'));
      ret.push("}");
      return ret;
    },
    'tex-math': function (buffer, m) {
      return mhchemParser.go(m, 'tex-math');
    },
    'tex-math tight': function (buffer, m) {
      return mhchemParser.go(m, 'tex-math tight');
    },
    'bond': function (buffer, m, k) {
      return {
        type_: 'bond',
        kind_: k || m
      };
    },
    'color0-output': function (buffer, m) {
      return {
        type_: 'color0',
        color: m[0]
      };
    },
    'ce': function (buffer, m) {
      return mhchemParser.go(m);
    },
    '1/2': function (buffer, m) {
      /** @type {ParserOutput[]} */
      var ret = [];

      if (m.match(/^[+\-]/)) {
        ret.push(m.substr(0, 1));
        m = m.substr(1);
      }

      var n = m.match(/^([0-9]+|\$[a-z]\$|[a-z])\/([0-9]+)(\$[a-z]\$|[a-z])?$/);
      n[1] = n[1].replace(/\$/g, "");
      ret.push({
        type_: 'frac',
        p1: n[1],
        p2: n[2]
      });

      if (n[3]) {
        n[3] = n[3].replace(/\$/g, "");
        ret.push({
          type_: 'tex-math',
          p1: n[3]
        });
      }

      return ret;
    },
    '9,9': function (buffer, m) {
      return mhchemParser.go(m, '9,9');
    }
  },
  //
  // createTransitions
  // convert  { 'letter': { 'state': { action_: 'output' } } }  to  { 'state' => [ { pattern: 'letter', task: { action_: [{type_: 'output'}] } } ] }
  // with expansion of 'a|b' to 'a' and 'b' (at 2 places)
  //
  createTransitions: function (o) {
    var pattern, state;
    /** @type {string[]} */

    var stateArray;
    var i; //
    // 1. Collect all states
    //

    /** @type {Transitions} */

    var transitions = {};

    for (pattern in o) {
      for (state in o[pattern]) {
        stateArray = state.split("|");
        o[pattern][state].stateArray = stateArray;

        for (i = 0; i < stateArray.length; i++) {
          transitions[stateArray[i]] = [];
        }
      }
    } //
    // 2. Fill states
    //


    for (pattern in o) {
      for (state in o[pattern]) {
        stateArray = o[pattern][state].stateArray || [];

        for (i = 0; i < stateArray.length; i++) {
          //
          // 2a. Normalize actions into array:  'text=' ==> [{type_:'text='}]
          // (Note to myself: Resolving the function here would be problematic. It would need .bind (for *this*) and currying (for *option*).)
          //

          /** @type {any} */
          var p = o[pattern][state];

          if (p.action_) {
            p.action_ = [].concat(p.action_);

            for (var k = 0; k < p.action_.length; k++) {
              if (typeof p.action_[k] === "string") {
                p.action_[k] = {
                  type_: p.action_[k]
                };
              }
            }
          } else {
            p.action_ = [];
          } //
          // 2.b Multi-insert
          //


          var patternArray = pattern.split("|");

          for (var j = 0; j < patternArray.length; j++) {
            if (stateArray[i] === '*') {
              // insert into all
              for (var t in transitions) {
                transitions[t].push({
                  pattern: patternArray[j],
                  task: p
                });
              }
            } else {
              transitions[stateArray[i]].push({
                pattern: patternArray[j],
                task: p
              });
            }
          }
        }
      }
    }

    return transitions;
  },
  stateMachines: {}
}; //
// Definition of state machines
//

mhchemParser.stateMachines = {
  //
  // \ce state machines
  //
  //#region ce
  'ce': {
    // main parser
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {
          action_: 'output'
        }
      },
      'else': {
        '0|1|2': {
          action_: 'beginsWithBond=false',
          revisit: true,
          toContinue: true
        }
      },
      'oxidation$': {
        '0': {
          action_: 'oxidation-output'
        }
      },
      'CMT': {
        'r': {
          action_: 'rdt=',
          nextState: 'rt'
        },
        'rd': {
          action_: 'rqt=',
          nextState: 'rdt'
        }
      },
      'arrowUpDown': {
        '0|1|2|as': {
          action_: ['sb=false', 'output', 'operator'],
          nextState: '1'
        }
      },
      'uprightEntities': {
        '0|1|2': {
          action_: ['o=', 'output'],
          nextState: '1'
        }
      },
      'orbital': {
        '0|1|2|3': {
          action_: 'o=',
          nextState: 'o'
        }
      },
      '->': {
        '0|1|2|3': {
          action_: 'r=',
          nextState: 'r'
        },
        'a|as': {
          action_: ['output', 'r='],
          nextState: 'r'
        },
        '*': {
          action_: ['output', 'r='],
          nextState: 'r'
        }
      },
      '+': {
        'o': {
          action_: 'd= kv',
          nextState: 'd'
        },
        'd|D': {
          action_: 'd=',
          nextState: 'd'
        },
        'q': {
          action_: 'd=',
          nextState: 'qd'
        },
        'qd|qD': {
          action_: 'd=',
          nextState: 'qd'
        },
        'dq': {
          action_: ['output', 'd='],
          nextState: 'd'
        },
        '3': {
          action_: ['sb=false', 'output', 'operator'],
          nextState: '0'
        }
      },
      'amount': {
        '0|2': {
          action_: 'a=',
          nextState: 'a'
        }
      },
      'pm-operator': {
        '0|1|2|a|as': {
          action_: ['sb=false', 'output', {
            type_: 'operator',
            option: '\\pm'
          }],
          nextState: '0'
        }
      },
      'operator': {
        '0|1|2|a|as': {
          action_: ['sb=false', 'output', 'operator'],
          nextState: '0'
        }
      },
      '-$': {
        'o|q': {
          action_: ['charge or bond', 'output'],
          nextState: 'qd'
        },
        'd': {
          action_: 'd=',
          nextState: 'd'
        },
        'D': {
          action_: ['output', {
            type_: 'bond',
            option: "-"
          }],
          nextState: '3'
        },
        'q': {
          action_: 'd=',
          nextState: 'qd'
        },
        'qd': {
          action_: 'd=',
          nextState: 'qd'
        },
        'qD|dq': {
          action_: ['output', {
            type_: 'bond',
            option: "-"
          }],
          nextState: '3'
        }
      },
      '-9': {
        '3|o': {
          action_: ['output', {
            type_: 'insert',
            option: 'hyphen'
          }],
          nextState: '3'
        }
      },
      '- orbital overlap': {
        'o': {
          action_: ['output', {
            type_: 'insert',
            option: 'hyphen'
          }],
          nextState: '2'
        },
        'd': {
          action_: ['output', {
            type_: 'insert',
            option: 'hyphen'
          }],
          nextState: '2'
        }
      },
      '-': {
        '0|1|2': {
          action_: [{
            type_: 'output',
            option: 1
          }, 'beginsWithBond=true', {
            type_: 'bond',
            option: "-"
          }],
          nextState: '3'
        },
        '3': {
          action_: {
            type_: 'bond',
            option: "-"
          }
        },
        'a': {
          action_: ['output', {
            type_: 'insert',
            option: 'hyphen'
          }],
          nextState: '2'
        },
        'as': {
          action_: [{
            type_: 'output',
            option: 2
          }, {
            type_: 'bond',
            option: "-"
          }],
          nextState: '3'
        },
        'b': {
          action_: 'b='
        },
        'o': {
          action_: {
            type_: '- after o/d',
            option: false
          },
          nextState: '2'
        },
        'q': {
          action_: {
            type_: '- after o/d',
            option: false
          },
          nextState: '2'
        },
        'd|qd|dq': {
          action_: {
            type_: '- after o/d',
            option: true
          },
          nextState: '2'
        },
        'D|qD|p': {
          action_: ['output', {
            type_: 'bond',
            option: "-"
          }],
          nextState: '3'
        }
      },
      'amount2': {
        '1|3': {
          action_: 'a=',
          nextState: 'a'
        }
      },
      'letters': {
        '0|1|2|3|a|as|b|p|bp|o': {
          action_: 'o=',
          nextState: 'o'
        },
        'q|dq': {
          action_: ['output', 'o='],
          nextState: 'o'
        },
        'd|D|qd|qD': {
          action_: 'o after d',
          nextState: 'o'
        }
      },
      'digits': {
        'o': {
          action_: 'q=',
          nextState: 'q'
        },
        'd|D': {
          action_: 'q=',
          nextState: 'dq'
        },
        'q': {
          action_: ['output', 'o='],
          nextState: 'o'
        },
        'a': {
          action_: 'o=',
          nextState: 'o'
        }
      },
      'space A': {
        'b|p|bp': {}
      },
      'space': {
        'a': {
          nextState: 'as'
        },
        '0': {
          action_: 'sb=false'
        },
        '1|2': {
          action_: 'sb=true'
        },
        'r|rt|rd|rdt|rdq': {
          action_: 'output',
          nextState: '0'
        },
        '*': {
          action_: ['output', 'sb=true'],
          nextState: '1'
        }
      },
      '1st-level escape': {
        '1|2': {
          action_: ['output', {
            type_: 'insert+p1',
            option: '1st-level escape'
          }]
        },
        '*': {
          action_: ['output', {
            type_: 'insert+p1',
            option: '1st-level escape'
          }],
          nextState: '0'
        }
      },
      '[(...)]': {
        'r|rt': {
          action_: 'rd=',
          nextState: 'rd'
        },
        'rd|rdt': {
          action_: 'rq=',
          nextState: 'rdq'
        }
      },
      '...': {
        'o|d|D|dq|qd|qD': {
          action_: ['output', {
            type_: 'bond',
            option: "..."
          }],
          nextState: '3'
        },
        '*': {
          action_: [{
            type_: 'output',
            option: 1
          }, {
            type_: 'insert',
            option: 'ellipsis'
          }],
          nextState: '1'
        }
      },
      '. |* ': {
        '*': {
          action_: ['output', {
            type_: 'insert',
            option: 'addition compound'
          }],
          nextState: '1'
        }
      },
      'state of aggregation $': {
        '*': {
          action_: ['output', 'state of aggregation'],
          nextState: '1'
        }
      },
      '{[(': {
        'a|as|o': {
          action_: ['o=', 'output', 'parenthesisLevel++'],
          nextState: '2'
        },
        '0|1|2|3': {
          action_: ['o=', 'output', 'parenthesisLevel++'],
          nextState: '2'
        },
        '*': {
          action_: ['output', 'o=', 'output', 'parenthesisLevel++'],
          nextState: '2'
        }
      },
      ')]}': {
        '0|1|2|3|b|p|bp|o': {
          action_: ['o=', 'parenthesisLevel--'],
          nextState: 'o'
        },
        'a|as|d|D|q|qd|qD|dq': {
          action_: ['output', 'o=', 'parenthesisLevel--'],
          nextState: 'o'
        }
      },
      ', ': {
        '*': {
          action_: ['output', 'comma'],
          nextState: '0'
        }
      },
      '^_': {
        // ^ and _ without a sensible argument
        '*': {}
      },
      '^{(...)}|^($...$)': {
        '0|1|2|as': {
          action_: 'b=',
          nextState: 'b'
        },
        'p': {
          action_: 'b=',
          nextState: 'bp'
        },
        '3|o': {
          action_: 'd= kv',
          nextState: 'D'
        },
        'q': {
          action_: 'd=',
          nextState: 'qD'
        },
        'd|D|qd|qD|dq': {
          action_: ['output', 'd='],
          nextState: 'D'
        }
      },
      '^a|^\\x{}{}|^\\x{}|^\\x|\'': {
        '0|1|2|as': {
          action_: 'b=',
          nextState: 'b'
        },
        'p': {
          action_: 'b=',
          nextState: 'bp'
        },
        '3|o': {
          action_: 'd= kv',
          nextState: 'd'
        },
        'q': {
          action_: 'd=',
          nextState: 'qd'
        },
        'd|qd|D|qD': {
          action_: 'd='
        },
        'dq': {
          action_: ['output', 'd='],
          nextState: 'd'
        }
      },
      '_{(state of aggregation)}$': {
        'd|D|q|qd|qD|dq': {
          action_: ['output', 'q='],
          nextState: 'q'
        }
      },
      '_{(...)}|_($...$)|_9|_\\x{}{}|_\\x{}|_\\x': {
        '0|1|2|as': {
          action_: 'p=',
          nextState: 'p'
        },
        'b': {
          action_: 'p=',
          nextState: 'bp'
        },
        '3|o': {
          action_: 'q=',
          nextState: 'q'
        },
        'd|D': {
          action_: 'q=',
          nextState: 'dq'
        },
        'q|qd|qD|dq': {
          action_: ['output', 'q='],
          nextState: 'q'
        }
      },
      '=<>': {
        '0|1|2|3|a|as|o|q|d|D|qd|qD|dq': {
          action_: [{
            type_: 'output',
            option: 2
          }, 'bond'],
          nextState: '3'
        }
      },
      '#': {
        '0|1|2|3|a|as|o': {
          action_: [{
            type_: 'output',
            option: 2
          }, {
            type_: 'bond',
            option: "#"
          }],
          nextState: '3'
        }
      },
      '{}': {
        '*': {
          action_: {
            type_: 'output',
            option: 1
          },
          nextState: '1'
        }
      },
      '{...}': {
        '0|1|2|3|a|as|b|p|bp': {
          action_: 'o=',
          nextState: 'o'
        },
        'o|d|D|q|qd|qD|dq': {
          action_: ['output', 'o='],
          nextState: 'o'
        }
      },
      '$...$': {
        'a': {
          action_: 'a='
        },
        // 2$n$
        '0|1|2|3|as|b|p|bp|o': {
          action_: 'o=',
          nextState: 'o'
        },
        // not 'amount'
        'as|o': {
          action_: 'o='
        },
        'q|d|D|qd|qD|dq': {
          action_: ['output', 'o='],
          nextState: 'o'
        }
      },
      '\\bond{(...)}': {
        '*': {
          action_: [{
            type_: 'output',
            option: 2
          }, 'bond'],
          nextState: "3"
        }
      },
      '\\frac{(...)}': {
        '*': {
          action_: [{
            type_: 'output',
            option: 1
          }, 'frac-output'],
          nextState: '3'
        }
      },
      '\\overset{(...)}': {
        '*': {
          action_: [{
            type_: 'output',
            option: 2
          }, 'overset-output'],
          nextState: '3'
        }
      },
      '\\underset{(...)}': {
        '*': {
          action_: [{
            type_: 'output',
            option: 2
          }, 'underset-output'],
          nextState: '3'
        }
      },
      '\\underbrace{(...)}': {
        '*': {
          action_: [{
            type_: 'output',
            option: 2
          }, 'underbrace-output'],
          nextState: '3'
        }
      },
      '\\color{(...)}{(...)}1|\\color(...){(...)}2': {
        '*': {
          action_: [{
            type_: 'output',
            option: 2
          }, 'color-output'],
          nextState: '3'
        }
      },
      '\\color{(...)}0': {
        '*': {
          action_: [{
            type_: 'output',
            option: 2
          }, 'color0-output']
        }
      },
      '\\ce{(...)}': {
        '*': {
          action_: [{
            type_: 'output',
            option: 2
          }, 'ce'],
          nextState: '3'
        }
      },
      '\\,': {
        '*': {
          action_: [{
            type_: 'output',
            option: 1
          }, 'copy'],
          nextState: '1'
        }
      },
      '\\x{}{}|\\x{}|\\x': {
        '0|1|2|3|a|as|b|p|bp|o|c0': {
          action_: ['o=', 'output'],
          nextState: '3'
        },
        '*': {
          action_: ['output', 'o=', 'output'],
          nextState: '3'
        }
      },
      'others': {
        '*': {
          action_: [{
            type_: 'output',
            option: 1
          }, 'copy'],
          nextState: '3'
        }
      },
      'else2': {
        'a': {
          action_: 'a to o',
          nextState: 'o',
          revisit: true
        },
        'as': {
          action_: ['output', 'sb=true'],
          nextState: '1',
          revisit: true
        },
        'r|rt|rd|rdt|rdq': {
          action_: ['output'],
          nextState: '0',
          revisit: true
        },
        '*': {
          action_: ['output', 'copy'],
          nextState: '3'
        }
      }
    }),
    actions: {
      'o after d': function (buffer, m) {
        var ret;

        if ((buffer.d || "").match(/^[0-9]+$/)) {
          var tmp = buffer.d;
          buffer.d = undefined;
          ret = this['output'](buffer);
          buffer.b = tmp;
        } else {
          ret = this['output'](buffer);
        }

        mhchemParser.actions['o='](buffer, m);
        return ret;
      },
      'd= kv': function (buffer, m) {
        buffer.d = m;
        buffer.dType = 'kv';
      },
      'charge or bond': function (buffer, m) {
        if (buffer['beginsWithBond']) {
          /** @type {ParserOutput[]} */
          var ret = [];
          mhchemParser.concatArray(ret, this['output'](buffer));
          mhchemParser.concatArray(ret, mhchemParser.actions['bond'](buffer, m, "-"));
          return ret;
        } else {
          buffer.d = m;
        }
      },
      '- after o/d': function (buffer, m, isAfterD) {
        var c1 = mhchemParser.patterns.match_('orbital', buffer.o || "");
        var c2 = mhchemParser.patterns.match_('one lowercase greek letter $', buffer.o || "");
        var c3 = mhchemParser.patterns.match_('one lowercase latin letter $', buffer.o || "");
        var c4 = mhchemParser.patterns.match_('$one lowercase latin letter$ $', buffer.o || "");
        var hyphenFollows = m === "-" && (c1 && c1.remainder === "" || c2 || c3 || c4);

        if (hyphenFollows && !buffer.a && !buffer.b && !buffer.p && !buffer.d && !buffer.q && !c1 && c3) {
          buffer.o = '$' + buffer.o + '$';
        }
        /** @type {ParserOutput[]} */


        var ret = [];

        if (hyphenFollows) {
          mhchemParser.concatArray(ret, this['output'](buffer));
          ret.push({
            type_: 'hyphen'
          });
        } else {
          c1 = mhchemParser.patterns.match_('digits', buffer.d || "");

          if (isAfterD && c1 && c1.remainder === '') {
            mhchemParser.concatArray(ret, mhchemParser.actions['d='](buffer, m));
            mhchemParser.concatArray(ret, this['output'](buffer));
          } else {
            mhchemParser.concatArray(ret, this['output'](buffer));
            mhchemParser.concatArray(ret, mhchemParser.actions['bond'](buffer, m, "-"));
          }
        }

        return ret;
      },
      'a to o': function (buffer) {
        buffer.o = buffer.a;
        buffer.a = undefined;
      },
      'sb=true': function (buffer) {
        buffer.sb = true;
      },
      'sb=false': function (buffer) {
        buffer.sb = false;
      },
      'beginsWithBond=true': function (buffer) {
        buffer['beginsWithBond'] = true;
      },
      'beginsWithBond=false': function (buffer) {
        buffer['beginsWithBond'] = false;
      },
      'parenthesisLevel++': function (buffer) {
        buffer['parenthesisLevel']++;
      },
      'parenthesisLevel--': function (buffer) {
        buffer['parenthesisLevel']--;
      },
      'state of aggregation': function (buffer, m) {
        return {
          type_: 'state of aggregation',
          p1: mhchemParser.go(m, 'o')
        };
      },
      'comma': function (buffer, m) {
        var a = m.replace(/\s*$/, '');
        var withSpace = a !== m;

        if (withSpace && buffer['parenthesisLevel'] === 0) {
          return {
            type_: 'comma enumeration L',
            p1: a
          };
        } else {
          return {
            type_: 'comma enumeration M',
            p1: a
          };
        }
      },
      'output': function (buffer, m, entityFollows) {
        // entityFollows:
        //   undefined = if we have nothing else to output, also ignore the just read space (buffer.sb)
        //   1 = an entity follows, never omit the space if there was one just read before (can only apply to state 1)
        //   2 = 1 + the entity can have an amount, so output a\, instead of converting it to o (can only apply to states a|as)

        /** @type {ParserOutput | ParserOutput[]} */
        var ret;

        if (!buffer.r) {
          ret = [];

          if (!buffer.a && !buffer.b && !buffer.p && !buffer.o && !buffer.q && !buffer.d && !entityFollows) {//ret = [];
          } else {
            if (buffer.sb) {
              ret.push({
                type_: 'entitySkip'
              });
            }

            if (!buffer.o && !buffer.q && !buffer.d && !buffer.b && !buffer.p && entityFollows !== 2) {
              buffer.o = buffer.a;
              buffer.a = undefined;
            } else if (!buffer.o && !buffer.q && !buffer.d && (buffer.b || buffer.p)) {
              buffer.o = buffer.a;
              buffer.d = buffer.b;
              buffer.q = buffer.p;
              buffer.a = buffer.b = buffer.p = undefined;
            } else {
              if (buffer.o && buffer.dType === 'kv' && mhchemParser.patterns.match_('d-oxidation$', buffer.d || "")) {
                buffer.dType = 'oxidation';
              } else if (buffer.o && buffer.dType === 'kv' && !buffer.q) {
                buffer.dType = undefined;
              }
            }

            ret.push({
              type_: 'chemfive',
              a: mhchemParser.go(buffer.a, 'a'),
              b: mhchemParser.go(buffer.b, 'bd'),
              p: mhchemParser.go(buffer.p, 'pq'),
              o: mhchemParser.go(buffer.o, 'o'),
              q: mhchemParser.go(buffer.q, 'pq'),
              d: mhchemParser.go(buffer.d, buffer.dType === 'oxidation' ? 'oxidation' : 'bd'),
              dType: buffer.dType
            });
          }
        } else {
          // r

          /** @type {ParserOutput[]} */
          var rd;

          if (buffer.rdt === 'M') {
            rd = mhchemParser.go(buffer.rd, 'tex-math');
          } else if (buffer.rdt === 'T') {
            rd = [{
              type_: 'text',
              p1: buffer.rd || ""
            }];
          } else {
            rd = mhchemParser.go(buffer.rd);
          }
          /** @type {ParserOutput[]} */


          var rq;

          if (buffer.rqt === 'M') {
            rq = mhchemParser.go(buffer.rq, 'tex-math');
          } else if (buffer.rqt === 'T') {
            rq = [{
              type_: 'text',
              p1: buffer.rq || ""
            }];
          } else {
            rq = mhchemParser.go(buffer.rq);
          }

          ret = {
            type_: 'arrow',
            r: buffer.r,
            rd: rd,
            rq: rq
          };
        }

        for (var p in buffer) {
          if (p !== 'parenthesisLevel' && p !== 'beginsWithBond') {
            delete buffer[p];
          }
        }

        return ret;
      },
      'oxidation-output': function (buffer, m) {
        var ret = ["{"];
        mhchemParser.concatArray(ret, mhchemParser.go(m, 'oxidation'));
        ret.push("}");
        return ret;
      },
      'frac-output': function (buffer, m) {
        return {
          type_: 'frac-ce',
          p1: mhchemParser.go(m[0]),
          p2: mhchemParser.go(m[1])
        };
      },
      'overset-output': function (buffer, m) {
        return {
          type_: 'overset',
          p1: mhchemParser.go(m[0]),
          p2: mhchemParser.go(m[1])
        };
      },
      'underset-output': function (buffer, m) {
        return {
          type_: 'underset',
          p1: mhchemParser.go(m[0]),
          p2: mhchemParser.go(m[1])
        };
      },
      'underbrace-output': function (buffer, m) {
        return {
          type_: 'underbrace',
          p1: mhchemParser.go(m[0]),
          p2: mhchemParser.go(m[1])
        };
      },
      'color-output': function (buffer, m) {
        return {
          type_: 'color',
          color1: m[0],
          color2: mhchemParser.go(m[1])
        };
      },
      'r=': function (buffer, m) {
        buffer.r = m;
      },
      'rdt=': function (buffer, m) {
        buffer.rdt = m;
      },
      'rd=': function (buffer, m) {
        buffer.rd = m;
      },
      'rqt=': function (buffer, m) {
        buffer.rqt = m;
      },
      'rq=': function (buffer, m) {
        buffer.rq = m;
      },
      'operator': function (buffer, m, p1) {
        return {
          type_: 'operator',
          kind_: p1 || m
        };
      }
    }
  },
  'a': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {}
      },
      '1/2$': {
        '0': {
          action_: '1/2'
        }
      },
      'else': {
        '0': {
          nextState: '1',
          revisit: true
        }
      },
      '$(...)$': {
        '*': {
          action_: 'tex-math tight',
          nextState: '1'
        }
      },
      ',': {
        '*': {
          action_: {
            type_: 'insert',
            option: 'commaDecimal'
          }
        }
      },
      'else2': {
        '*': {
          action_: 'copy'
        }
      }
    }),
    actions: {}
  },
  'o': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {}
      },
      '1/2$': {
        '0': {
          action_: '1/2'
        }
      },
      'else': {
        '0': {
          nextState: '1',
          revisit: true
        }
      },
      'letters': {
        '*': {
          action_: 'rm'
        }
      },
      '\\ca': {
        '*': {
          action_: {
            type_: 'insert',
            option: 'circa'
          }
        }
      },
      '\\x{}{}|\\x{}|\\x': {
        '*': {
          action_: 'copy'
        }
      },
      '${(...)}$|$(...)$': {
        '*': {
          action_: 'tex-math'
        }
      },
      '{(...)}': {
        '*': {
          action_: '{text}'
        }
      },
      'else2': {
        '*': {
          action_: 'copy'
        }
      }
    }),
    actions: {}
  },
  'text': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {
          action_: 'output'
        }
      },
      '{...}': {
        '*': {
          action_: 'text='
        }
      },
      '${(...)}$|$(...)$': {
        '*': {
          action_: 'tex-math'
        }
      },
      '\\greek': {
        '*': {
          action_: ['output', 'rm']
        }
      },
      '\\,|\\x{}{}|\\x{}|\\x': {
        '*': {
          action_: ['output', 'copy']
        }
      },
      'else': {
        '*': {
          action_: 'text='
        }
      }
    }),
    actions: {
      'output': function (buffer) {
        if (buffer.text_) {
          /** @type {ParserOutput} */
          var ret = {
            type_: 'text',
            p1: buffer.text_
          };

          for (var p in buffer) {
            delete buffer[p];
          }

          return ret;
        }
      }
    }
  },
  'pq': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {}
      },
      'state of aggregation $': {
        '*': {
          action_: 'state of aggregation'
        }
      },
      'i$': {
        '0': {
          nextState: '!f',
          revisit: true
        }
      },
      '(KV letters),': {
        '0': {
          action_: 'rm',
          nextState: '0'
        }
      },
      'formula$': {
        '0': {
          nextState: 'f',
          revisit: true
        }
      },
      '1/2$': {
        '0': {
          action_: '1/2'
        }
      },
      'else': {
        '0': {
          nextState: '!f',
          revisit: true
        }
      },
      '${(...)}$|$(...)$': {
        '*': {
          action_: 'tex-math'
        }
      },
      '{(...)}': {
        '*': {
          action_: 'text'
        }
      },
      'a-z': {
        'f': {
          action_: 'tex-math'
        }
      },
      'letters': {
        '*': {
          action_: 'rm'
        }
      },
      '-9.,9': {
        '*': {
          action_: '9,9'
        }
      },
      ',': {
        '*': {
          action_: {
            type_: 'insert+p1',
            option: 'comma enumeration S'
          }
        }
      },
      '\\color{(...)}{(...)}1|\\color(...){(...)}2': {
        '*': {
          action_: 'color-output'
        }
      },
      '\\color{(...)}0': {
        '*': {
          action_: 'color0-output'
        }
      },
      '\\ce{(...)}': {
        '*': {
          action_: 'ce'
        }
      },
      '\\,|\\x{}{}|\\x{}|\\x': {
        '*': {
          action_: 'copy'
        }
      },
      'else2': {
        '*': {
          action_: 'copy'
        }
      }
    }),
    actions: {
      'state of aggregation': function (buffer, m) {
        return {
          type_: 'state of aggregation subscript',
          p1: mhchemParser.go(m, 'o')
        };
      },
      'color-output': function (buffer, m) {
        return {
          type_: 'color',
          color1: m[0],
          color2: mhchemParser.go(m[1], 'pq')
        };
      }
    }
  },
  'bd': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {}
      },
      'x$': {
        '0': {
          nextState: '!f',
          revisit: true
        }
      },
      'formula$': {
        '0': {
          nextState: 'f',
          revisit: true
        }
      },
      'else': {
        '0': {
          nextState: '!f',
          revisit: true
        }
      },
      '-9.,9 no missing 0': {
        '*': {
          action_: '9,9'
        }
      },
      '.': {
        '*': {
          action_: {
            type_: 'insert',
            option: 'electron dot'
          }
        }
      },
      'a-z': {
        'f': {
          action_: 'tex-math'
        }
      },
      'x': {
        '*': {
          action_: {
            type_: 'insert',
            option: 'KV x'
          }
        }
      },
      'letters': {
        '*': {
          action_: 'rm'
        }
      },
      '\'': {
        '*': {
          action_: {
            type_: 'insert',
            option: 'prime'
          }
        }
      },
      '${(...)}$|$(...)$': {
        '*': {
          action_: 'tex-math'
        }
      },
      '{(...)}': {
        '*': {
          action_: 'text'
        }
      },
      '\\color{(...)}{(...)}1|\\color(...){(...)}2': {
        '*': {
          action_: 'color-output'
        }
      },
      '\\color{(...)}0': {
        '*': {
          action_: 'color0-output'
        }
      },
      '\\ce{(...)}': {
        '*': {
          action_: 'ce'
        }
      },
      '\\,|\\x{}{}|\\x{}|\\x': {
        '*': {
          action_: 'copy'
        }
      },
      'else2': {
        '*': {
          action_: 'copy'
        }
      }
    }),
    actions: {
      'color-output': function (buffer, m) {
        return {
          type_: 'color',
          color1: m[0],
          color2: mhchemParser.go(m[1], 'bd')
        };
      }
    }
  },
  'oxidation': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {}
      },
      'roman numeral': {
        '*': {
          action_: 'roman-numeral'
        }
      },
      '${(...)}$|$(...)$': {
        '*': {
          action_: 'tex-math'
        }
      },
      'else': {
        '*': {
          action_: 'copy'
        }
      }
    }),
    actions: {
      'roman-numeral': function (buffer, m) {
        return {
          type_: 'roman numeral',
          p1: m || ""
        };
      }
    }
  },
  'tex-math': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {
          action_: 'output'
        }
      },
      '\\ce{(...)}': {
        '*': {
          action_: ['output', 'ce']
        }
      },
      '{...}|\\,|\\x{}{}|\\x{}|\\x': {
        '*': {
          action_: 'o='
        }
      },
      'else': {
        '*': {
          action_: 'o='
        }
      }
    }),
    actions: {
      'output': function (buffer) {
        if (buffer.o) {
          /** @type {ParserOutput} */
          var ret = {
            type_: 'tex-math',
            p1: buffer.o
          };

          for (var p in buffer) {
            delete buffer[p];
          }

          return ret;
        }
      }
    }
  },
  'tex-math tight': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {
          action_: 'output'
        }
      },
      '\\ce{(...)}': {
        '*': {
          action_: ['output', 'ce']
        }
      },
      '{...}|\\,|\\x{}{}|\\x{}|\\x': {
        '*': {
          action_: 'o='
        }
      },
      '-|+': {
        '*': {
          action_: 'tight operator'
        }
      },
      'else': {
        '*': {
          action_: 'o='
        }
      }
    }),
    actions: {
      'tight operator': function (buffer, m) {
        buffer.o = (buffer.o || "") + "{" + m + "}";
      },
      'output': function (buffer) {
        if (buffer.o) {
          /** @type {ParserOutput} */
          var ret = {
            type_: 'tex-math',
            p1: buffer.o
          };

          for (var p in buffer) {
            delete buffer[p];
          }

          return ret;
        }
      }
    }
  },
  '9,9': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {}
      },
      ',': {
        '*': {
          action_: 'comma'
        }
      },
      'else': {
        '*': {
          action_: 'copy'
        }
      }
    }),
    actions: {
      'comma': function () {
        return {
          type_: 'commaDecimal'
        };
      }
    }
  },
  //#endregion
  //
  // \pu state machines
  //
  //#region pu
  'pu': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {
          action_: 'output'
        }
      },
      'space$': {
        '*': {
          action_: ['output', 'space']
        }
      },
      '{[(|)]}': {
        '0|a': {
          action_: 'copy'
        }
      },
      '(-)(9)^(-9)': {
        '0': {
          action_: 'number^',
          nextState: 'a'
        }
      },
      '(-)(9.,9)(e)(99)': {
        '0': {
          action_: 'enumber',
          nextState: 'a'
        }
      },
      'space': {
        '0|a': {}
      },
      'pm-operator': {
        '0|a': {
          action_: {
            type_: 'operator',
            option: '\\pm'
          },
          nextState: '0'
        }
      },
      'operator': {
        '0|a': {
          action_: 'copy',
          nextState: '0'
        }
      },
      '//': {
        'd': {
          action_: 'o=',
          nextState: '/'
        }
      },
      '/': {
        'd': {
          action_: 'o=',
          nextState: '/'
        }
      },
      '{...}|else': {
        '0|d': {
          action_: 'd=',
          nextState: 'd'
        },
        'a': {
          action_: ['space', 'd='],
          nextState: 'd'
        },
        '/|q': {
          action_: 'q=',
          nextState: 'q'
        }
      }
    }),
    actions: {
      'enumber': function (buffer, m) {
        /** @type {ParserOutput[]} */
        var ret = [];

        if (m[0] === "+-" || m[0] === "+/-") {
          ret.push("\\pm ");
        } else if (m[0]) {
          ret.push(m[0]);
        }

        if (m[1]) {
          mhchemParser.concatArray(ret, mhchemParser.go(m[1], 'pu-9,9'));

          if (m[2]) {
            if (m[2].match(/[,.]/)) {
              mhchemParser.concatArray(ret, mhchemParser.go(m[2], 'pu-9,9'));
            } else {
              ret.push(m[2]);
            }
          }

          m[3] = m[4] || m[3];

          if (m[3]) {
            m[3] = m[3].trim();

            if (m[3] === "e" || m[3].substr(0, 1) === "*") {
              ret.push({
                type_: 'cdot'
              });
            } else {
              ret.push({
                type_: 'times'
              });
            }
          }
        }

        if (m[3]) {
          ret.push("10^{" + m[5] + "}");
        }

        return ret;
      },
      'number^': function (buffer, m) {
        /** @type {ParserOutput[]} */
        var ret = [];

        if (m[0] === "+-" || m[0] === "+/-") {
          ret.push("\\pm ");
        } else if (m[0]) {
          ret.push(m[0]);
        }

        mhchemParser.concatArray(ret, mhchemParser.go(m[1], 'pu-9,9'));
        ret.push("^{" + m[2] + "}");
        return ret;
      },
      'operator': function (buffer, m, p1) {
        return {
          type_: 'operator',
          kind_: p1 || m
        };
      },
      'space': function () {
        return {
          type_: 'pu-space-1'
        };
      },
      'output': function (buffer) {
        /** @type {ParserOutput | ParserOutput[]} */
        var ret;
        var md = mhchemParser.patterns.match_('{(...)}', buffer.d || "");

        if (md && md.remainder === '') {
          buffer.d = md.match_;
        }

        var mq = mhchemParser.patterns.match_('{(...)}', buffer.q || "");

        if (mq && mq.remainder === '') {
          buffer.q = mq.match_;
        }

        if (buffer.d) {
          buffer.d = buffer.d.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C");
          buffer.d = buffer.d.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F");
        }

        if (buffer.q) {
          // fraction
          buffer.q = buffer.q.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C");
          buffer.q = buffer.q.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F");
          var b5 = {
            d: mhchemParser.go(buffer.d, 'pu'),
            q: mhchemParser.go(buffer.q, 'pu')
          };

          if (buffer.o === '//') {
            ret = {
              type_: 'pu-frac',
              p1: b5.d,
              p2: b5.q
            };
          } else {
            ret = b5.d;

            if (b5.d.length > 1 || b5.q.length > 1) {
              ret.push({
                type_: ' / '
              });
            } else {
              ret.push({
                type_: '/'
              });
            }

            mhchemParser.concatArray(ret, b5.q);
          }
        } else {
          // no fraction
          ret = mhchemParser.go(buffer.d, 'pu-2');
        }

        for (var p in buffer) {
          delete buffer[p];
        }

        return ret;
      }
    }
  },
  'pu-2': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '*': {
          action_: 'output'
        }
      },
      '*': {
        '*': {
          action_: ['output', 'cdot'],
          nextState: '0'
        }
      },
      '\\x': {
        '*': {
          action_: 'rm='
        }
      },
      'space': {
        '*': {
          action_: ['output', 'space'],
          nextState: '0'
        }
      },
      '^{(...)}|^(-1)': {
        '1': {
          action_: '^(-1)'
        }
      },
      '-9.,9': {
        '0': {
          action_: 'rm=',
          nextState: '0'
        },
        '1': {
          action_: '^(-1)',
          nextState: '0'
        }
      },
      '{...}|else': {
        '*': {
          action_: 'rm=',
          nextState: '1'
        }
      }
    }),
    actions: {
      'cdot': function () {
        return {
          type_: 'tight cdot'
        };
      },
      '^(-1)': function (buffer, m) {
        buffer.rm += "^{" + m + "}";
      },
      'space': function () {
        return {
          type_: 'pu-space-2'
        };
      },
      'output': function (buffer) {
        /** @type {ParserOutput | ParserOutput[]} */
        var ret = [];

        if (buffer.rm) {
          var mrm = mhchemParser.patterns.match_('{(...)}', buffer.rm || "");

          if (mrm && mrm.remainder === '') {
            ret = mhchemParser.go(mrm.match_, 'pu');
          } else {
            ret = {
              type_: 'rm',
              p1: buffer.rm
            };
          }
        }

        for (var p in buffer) {
          delete buffer[p];
        }

        return ret;
      }
    }
  },
  'pu-9,9': {
    transitions: mhchemParser.createTransitions({
      'empty': {
        '0': {
          action_: 'output-0'
        },
        'o': {
          action_: 'output-o'
        }
      },
      ',': {
        '0': {
          action_: ['output-0', 'comma'],
          nextState: 'o'
        }
      },
      '.': {
        '0': {
          action_: ['output-0', 'copy'],
          nextState: 'o'
        }
      },
      'else': {
        '*': {
          action_: 'text='
        }
      }
    }),
    actions: {
      'comma': function () {
        return {
          type_: 'commaDecimal'
        };
      },
      'output-0': function (buffer) {
        /** @type {ParserOutput[]} */
        var ret = [];
        buffer.text_ = buffer.text_ || "";

        if (buffer.text_.length > 4) {
          var a = buffer.text_.length % 3;

          if (a === 0) {
            a = 3;
          }

          for (var i = buffer.text_.length - 3; i > 0; i -= 3) {
            ret.push(buffer.text_.substr(i, 3));
            ret.push({
              type_: '1000 separator'
            });
          }

          ret.push(buffer.text_.substr(0, a));
          ret.reverse();
        } else {
          ret.push(buffer.text_);
        }

        for (var p in buffer) {
          delete buffer[p];
        }

        return ret;
      },
      'output-o': function (buffer) {
        /** @type {ParserOutput[]} */
        var ret = [];
        buffer.text_ = buffer.text_ || "";

        if (buffer.text_.length > 4) {
          var a = buffer.text_.length - 3;

          for (var i = 0; i < a; i += 3) {
            ret.push(buffer.text_.substr(i, 3));
            ret.push({
              type_: '1000 separator'
            });
          }

          ret.push(buffer.text_.substr(i));
        } else {
          ret.push(buffer.text_);
        }

        for (var p in buffer) {
          delete buffer[p];
        }

        return ret;
      }
    }
  } //#endregion

}; //
// texify: Take MhchemParser output and convert it to TeX
//

/** @type {Texify} */

var texify = {
  go: function (input, isInner) {
    // (recursive, max 4 levels)
    if (!input) {
      return "";
    }

    var res = "";
    var cee = false;

    for (var i = 0; i < input.length; i++) {
      var inputi = input[i];

      if (typeof inputi === "string") {
        res += inputi;
      } else {
        res += texify._go2(inputi);

        if (inputi.type_ === '1st-level escape') {
          cee = true;
        }
      }
    }

    if (!isInner && !cee && res) {
      res = "{" + res + "}";
    }

    return res;
  },
  _goInner: function (input) {
    if (!input) {
      return input;
    }

    return texify.go(input, true);
  },
  _go2: function (buf) {
    /** @type {undefined | string} */
    var res;

    switch (buf.type_) {
      case 'chemfive':
        res = "";
        var b5 = {
          a: texify._goInner(buf.a),
          b: texify._goInner(buf.b),
          p: texify._goInner(buf.p),
          o: texify._goInner(buf.o),
          q: texify._goInner(buf.q),
          d: texify._goInner(buf.d)
        }; //
        // a
        //

        if (b5.a) {
          if (b5.a.match(/^[+\-]/)) {
            b5.a = "{" + b5.a + "}";
          }

          res += b5.a + "\\,";
        } //
        // b and p
        //


        if (b5.b || b5.p) {
          res += "{\\vphantom{X}}";
          res += "^{\\hphantom{" + (b5.b || "") + "}}_{\\hphantom{" + (b5.p || "") + "}}";
          res += "{\\vphantom{X}}";
          res += "^{\\smash[t]{\\vphantom{2}}\\llap{" + (b5.b || "") + "}}";
          res += "_{\\vphantom{2}\\llap{\\smash[t]{" + (b5.p || "") + "}}}";
        } //
        // o
        //


        if (b5.o) {
          if (b5.o.match(/^[+\-]/)) {
            b5.o = "{" + b5.o + "}";
          }

          res += b5.o;
        } //
        // q and d
        //


        if (buf.dType === 'kv') {
          if (b5.d || b5.q) {
            res += "{\\vphantom{X}}";
          }

          if (b5.d) {
            res += "^{" + b5.d + "}";
          }

          if (b5.q) {
            res += "_{\\smash[t]{" + b5.q + "}}";
          }
        } else if (buf.dType === 'oxidation') {
          if (b5.d) {
            res += "{\\vphantom{X}}";
            res += "^{" + b5.d + "}";
          }

          if (b5.q) {
            res += "{\\vphantom{X}}";
            res += "_{\\smash[t]{" + b5.q + "}}";
          }
        } else {
          if (b5.q) {
            res += "{\\vphantom{X}}";
            res += "_{\\smash[t]{" + b5.q + "}}";
          }

          if (b5.d) {
            res += "{\\vphantom{X}}";
            res += "^{" + b5.d + "}";
          }
        }

        break;

      case 'rm':
        res = "\\mathrm{" + buf.p1 + "}";
        break;

      case 'text':
        if (buf.p1.match(/[\^_]/)) {
          buf.p1 = buf.p1.replace(" ", "~").replace("-", "\\text{-}");
          res = "\\mathrm{" + buf.p1 + "}";
        } else {
          res = "\\text{" + buf.p1 + "}";
        }

        break;

      case 'roman numeral':
        res = "\\mathrm{" + buf.p1 + "}";
        break;

      case 'state of aggregation':
        res = "\\mskip2mu " + texify._goInner(buf.p1);
        break;

      case 'state of aggregation subscript':
        res = "\\mskip1mu " + texify._goInner(buf.p1);
        break;

      case 'bond':
        res = texify._getBond(buf.kind_);

        if (!res) {
          throw ["MhchemErrorBond", "mhchem Error. Unknown bond type (" + buf.kind_ + ")"];
        }

        break;

      case 'frac':
        var c = "\\frac{" + buf.p1 + "}{" + buf.p2 + "}";
        res = "\\mathchoice{\\textstyle" + c + "}{" + c + "}{" + c + "}{" + c + "}";
        break;

      case 'pu-frac':
        var d = "\\frac{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
        res = "\\mathchoice{\\textstyle" + d + "}{" + d + "}{" + d + "}{" + d + "}";
        break;

      case 'tex-math':
        res = buf.p1 + " ";
        break;

      case 'frac-ce':
        res = "\\frac{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
        break;

      case 'overset':
        res = "\\overset{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
        break;

      case 'underset':
        res = "\\underset{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
        break;

      case 'underbrace':
        res = "\\underbrace{" + texify._goInner(buf.p1) + "}_{" + texify._goInner(buf.p2) + "}";
        break;

      case 'color':
        res = "{\\color{" + buf.color1 + "}{" + texify._goInner(buf.color2) + "}}";
        break;

      case 'color0':
        res = "\\color{" + buf.color + "}";
        break;

      case 'arrow':
        var b6 = {
          rd: texify._goInner(buf.rd),
          rq: texify._goInner(buf.rq)
        };

        var arrow = texify._getArrow(buf.r);

        if (b6.rd || b6.rq) {
          if (buf.r === "<=>" || buf.r === "<=>>" || buf.r === "<<=>" || buf.r === "<-->") {
            // arrows that cannot stretch correctly yet, https://github.com/mathjax/MathJax/issues/1491
            arrow = "\\long" + arrow;

            if (b6.rd) {
              arrow = "\\overset{" + b6.rd + "}{" + arrow + "}";
            }

            if (b6.rq) {
              arrow = "\\underset{\\lower7mu{" + b6.rq + "}}{" + arrow + "}";
            }

            arrow = " {}\\mathrel{" + arrow + "}{} ";
          } else {
            if (b6.rq) {
              arrow += "[{" + b6.rq + "}]";
            }

            arrow += "{" + b6.rd + "}";
            arrow = " {}\\mathrel{\\x" + arrow + "}{} ";
          }
        } else {
          arrow = " {}\\mathrel{\\long" + arrow + "}{} ";
        }

        res = arrow;
        break;

      case 'operator':
        res = texify._getOperator(buf.kind_);
        break;

      case '1st-level escape':
        res = buf.p1 + " "; // &, \\\\, \\hlin

        break;

      case 'space':
        res = " ";
        break;

      case 'entitySkip':
        res = "~";
        break;

      case 'pu-space-1':
        res = "~";
        break;

      case 'pu-space-2':
        res = "\\mkern3mu ";
        break;

      case '1000 separator':
        res = "\\mkern2mu ";
        break;

      case 'commaDecimal':
        res = "{,}";
        break;

      case 'comma enumeration L':
        res = "{" + buf.p1 + "}\\mkern6mu ";
        break;

      case 'comma enumeration M':
        res = "{" + buf.p1 + "}\\mkern3mu ";
        break;

      case 'comma enumeration S':
        res = "{" + buf.p1 + "}\\mkern1mu ";
        break;

      case 'hyphen':
        res = "\\text{-}";
        break;

      case 'addition compound':
        res = "\\,{\\cdot}\\,";
        break;

      case 'electron dot':
        res = "\\mkern1mu \\bullet\\mkern1mu ";
        break;

      case 'KV x':
        res = "{\\times}";
        break;

      case 'prime':
        res = "\\prime ";
        break;

      case 'cdot':
        res = "\\cdot ";
        break;

      case 'tight cdot':
        res = "\\mkern1mu{\\cdot}\\mkern1mu ";
        break;

      case 'times':
        res = "\\times ";
        break;

      case 'circa':
        res = "{\\sim}";
        break;

      case '^':
        res = "uparrow";
        break;

      case 'v':
        res = "downarrow";
        break;

      case 'ellipsis':
        res = "\\ldots ";
        break;

      case '/':
        res = "/";
        break;

      case ' / ':
        res = "\\,/\\,";
        break;

      default:
        assertNever(buf);
        throw ["MhchemBugT", "mhchem bug T. Please report."];
      // Missing texify rule or unknown MhchemParser output
    }

    assertString(res);
    return res;
  },
  _getArrow: function (a) {
    switch (a) {
      case "->":
        return "rightarrow";

      case "\u2192":
        return "rightarrow";

      case "\u27F6":
        return "rightarrow";

      case "<-":
        return "leftarrow";

      case "<->":
        return "leftrightarrow";

      case "<-->":
        return "leftrightarrows";

      case "<=>":
        return "rightleftharpoons";

      case "\u21CC":
        return "rightleftharpoons";

      case "<=>>":
        return "Rightleftharpoons";

      case "<<=>":
        return "Leftrightharpoons";

      default:
        assertNever(a);
        throw ["MhchemBugT", "mhchem bug T. Please report."];
    }
  },
  _getBond: function (a) {
    switch (a) {
      case "-":
        return "{-}";

      case "1":
        return "{-}";

      case "=":
        return "{=}";

      case "2":
        return "{=}";

      case "#":
        return "{\\equiv}";

      case "3":
        return "{\\equiv}";

      case "~":
        return "{\\tripledash}";

      case "~-":
        return "{\\rlap{\\lower.1em{-}}\\raise.1em{\\tripledash}}";

      case "~=":
        return "{\\rlap{\\lower.2em{-}}\\rlap{\\raise.2em{\\tripledash}}-}";

      case "~--":
        return "{\\rlap{\\lower.2em{-}}\\rlap{\\raise.2em{\\tripledash}}-}";

      case "-~-":
        return "{\\rlap{\\lower.2em{-}}\\rlap{\\raise.2em{-}}\\tripledash}";

      case "...":
        return "{{\\cdot}{\\cdot}{\\cdot}}";

      case "....":
        return "{{\\cdot}{\\cdot}{\\cdot}{\\cdot}}";

      case "->":
        return "{\\rightarrow}";

      case "<-":
        return "{\\leftarrow}";

      case "<":
        return "{<}";

      case ">":
        return "{>}";

      default:
        assertNever(a);
        throw ["MhchemBugT", "mhchem bug T. Please report."];
    }
  },
  _getOperator: function (a) {
    switch (a) {
      case "+":
        return " {}+{} ";

      case "-":
        return " {}-{} ";

      case "=":
        return " {}={} ";

      case "<":
        return " {}<{} ";

      case ">":
        return " {}>{} ";

      case "<<":
        return " {}\\ll{} ";

      case ">>":
        return " {}\\gg{} ";

      case "\\pm":
        return " {}\\pm{} ";

      case "\\approx":
        return " {}\\approx{} ";

      case "$\\approx$":
        return " {}\\approx{} ";

      case "v":
        return " \\downarrow{} ";

      case "(v)":
        return " \\downarrow{} ";

      case "^":
        return " \\uparrow{} ";

      case "(^)":
        return " \\uparrow{} ";

      default:
        assertNever(a);
        throw ["MhchemBugT", "mhchem bug T. Please report."];
    }
  }
}; //
// Helpers for code anaylsis
// Will show type error at calling position
//

/** @param {number} a */

function assertNever(a) {}
/** @param {string} a */

function assertString(a) {}

/***/ }),
/* 378 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

function noErrors(factory, message, id, expr) {
  var mtext = factory.create('token', 'mtext', {}, expr.replace(/\n/g, ' '));
  var error = factory.create('node', 'merror', [mtext], {
    'data-mjx-error': message
  });
  return error;
}

;
exports.NoErrorsConfiguration = Configuration_js_1.Configuration.create('noerrors', {
  nodes: {
    'error': noErrors
  }
});

/***/ }),
/* 379 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

function noUndefined(parser, name) {
  var textNode = parser.create('text', '\\' + name);
  parser.Push(parser.create('node', 'mtext', [], {
    mathcolor: 'red'
  }, textNode));
}

;
exports.NoUndefinedConfiguration = Configuration_js_1.Configuration.create('noundefined', {
  fallback: {
    macro: noUndefined
  }
});

/***/ }),
/* 380 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var PhysicsItems_js_1 = __webpack_require__(381);

__webpack_require__(382);

exports.PhysicsConfiguration = Configuration_js_1.Configuration.create('physics', {
  handler: {
    macro: ['Physics-automatic-bracing-macros', 'Physics-vector-macros', 'Physics-vector-chars', 'Physics-derivative-macros', 'Physics-expressions-macros', 'Physics-quick-quad-macros', 'Physics-bra-ket-macros', 'Physics-matrix-macros'],
    character: ['Physics-characters'],
    environment: ['Physics-aux-envs']
  },
  items: (_a = {}, _a[PhysicsItems_js_1.AutoOpen.prototype.kind] = PhysicsItems_js_1.AutoOpen, _a)
});

var _a;

/***/ }),
/* 381 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var StackItem_js_1 = __webpack_require__(27);

var ParseUtil_js_1 = __webpack_require__(9);

var TexParser_js_1 = __webpack_require__(15);

var AutoOpen = function (_super) {
  __extends(AutoOpen, _super);

  function AutoOpen() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(AutoOpen.prototype, "kind", {
    get: function () {
      return 'auto open';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(AutoOpen.prototype, "isOpen", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  AutoOpen.prototype.toMml = function () {
    var parser = this.factory.configuration.parser;
    var right = this.getProperty('right');

    if (this.getProperty('smash')) {
      var mml_1 = _super.prototype.toMml.call(this);

      var smash = parser.create('node', 'mpadded', [mml_1], {
        height: 0,
        depth: 0
      });
      this.Clear();
      this.Push(parser.create('node', 'TeXAtom', [smash]));
    }

    if (right) {
      this.Push(new TexParser_js_1.default(right, parser.stack.env, parser.configuration).mml());
    }

    var mml = _super.prototype.toMml.call(this);

    return ParseUtil_js_1.default.fenced(this.factory.configuration, this.getProperty('open'), mml, this.getProperty('close'), this.getProperty('big'));
  };

  AutoOpen.prototype.checkItem = function (item) {
    var close = item.getProperty('autoclose');

    if (close && close === this.getProperty('close')) {
      if (this.getProperty('ignore')) {
        this.Clear();
        return [[], true];
      }

      return [[this.toMml()], true];
    }

    return _super.prototype.checkItem.call(this, item);
  };

  return AutoOpen;
}(StackItem_js_1.BaseItem);

exports.AutoOpen = AutoOpen;

/***/ }),
/* 382 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var SymbolMap_js_1 = __webpack_require__(5);

var PhysicsMethods_js_1 = __webpack_require__(383);

var TexConstants_js_1 = __webpack_require__(14);

var ParseMethods_js_1 = __webpack_require__(28);

var MmlNode_js_1 = __webpack_require__(0);

new SymbolMap_js_1.CommandMap('Physics-automatic-bracing-macros', {
  'quantity': 'Quantity',
  'qty': 'Quantity',
  'pqty': ['Quantity', '(', ')', true],
  'bqty': ['Quantity', '[', ']', true],
  'vqty': ['Quantity', '|', '|', true],
  'Bqty': ['Quantity', '{', '}', true],
  'absolutevalue': ['Quantity', '|', '|', true],
  'abs': ['Quantity', '|', '|', true],
  'norm': ['Quantity', '\\|', '\\|', true],
  'evaluated': 'Eval',
  'eval': 'Eval',
  'order': ['Quantity', '(', ')', true, 'O', TexConstants_js_1.TexConstant.Variant.CALIGRAPHIC],
  'commutator': 'Commutator',
  'comm': 'Commutator',
  'anticommutator': ['Commutator', '\\{', '\\}'],
  'acomm': ['Commutator', '\\{', '\\}'],
  'poissonbracket': ['Commutator', '\\{', '\\}'],
  'pb': ['Commutator', '\\{', '\\}']
}, PhysicsMethods_js_1.default);
new SymbolMap_js_1.CharacterMap('Physics-vector-chars', ParseMethods_js_1.default.mathchar0mi, {
  dotproduct: ['\u22C5', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.BOLD
  }],
  vdot: ['\u22C5', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.BOLD
  }],
  crossproduct: '\u00D7',
  cross: '\u00D7',
  cp: '\u00D7',
  gradientnabla: ['\u2207', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.BOLD
  }],
  real: ['\u211C', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }],
  imaginary: ['\u2111', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL
  }]
});
new SymbolMap_js_1.CommandMap('Physics-vector-macros', {
  'vectorbold': 'VectorBold',
  'vb': 'VectorBold',
  'vectorarrow': ['StarMacro', 1, '\\vec{\\vb', '{#1}}'],
  'va': ['StarMacro', 1, '\\vec{\\vb', '{#1}}'],
  'vectorunit': ['StarMacro', 1, '\\hat{\\vb', '{#1}}'],
  'vu': ['StarMacro', 1, '\\hat{\\vb', '{#1}}'],
  'gradient': ['OperatorApplication', '\\gradientnabla', '(', '['],
  'grad': ['OperatorApplication', '\\gradientnabla', '(', '['],
  'divergence': ['VectorOperator', '\\gradientnabla\\vdot', '(', '['],
  'div': ['VectorOperator', '\\gradientnabla\\vdot', '(', '['],
  'curl': ['VectorOperator', '\\gradientnabla\\crossproduct', '(', '['],
  'laplacian': ['OperatorApplication', '\\nabla^2', '(', '[']
}, PhysicsMethods_js_1.default);
new SymbolMap_js_1.CommandMap('Physics-expressions-macros', {
  'sin': 'Expression',
  'sinh': 'Expression',
  'arcsin': 'Expression',
  'asin': 'Expression',
  'cos': 'Expression',
  'cosh': 'Expression',
  'arccos': 'Expression',
  'acos': 'Expression',
  'tan': 'Expression',
  'tanh': 'Expression',
  'arctan': 'Expression',
  'atan': 'Expression',
  'csc': 'Expression',
  'csch': 'Expression',
  'arccsc': 'Expression',
  'acsc': 'Expression',
  'sec': 'Expression',
  'sech': 'Expression',
  'arcsec': 'Expression',
  'asec': 'Expression',
  'cot': 'Expression',
  'coth': 'Expression',
  'arccot': 'Expression',
  'acot': 'Expression',
  'exp': ['Expression', false],
  'log': 'Expression',
  'ln': 'Expression',
  'det': ['Expression', false],
  'Pr': ['Expression', false],
  'tr': ['Expression', false],
  'trace': ['Expression', false, 'tr'],
  'Tr': ['Expression', false],
  'Trace': ['Expression', false, 'Tr'],
  'rank': 'NamedFn',
  'erf': ['Expression', false],
  'Res': ['OperatorApplication', '{\\rm Res}', '(', '[', '{'],
  'principalvalue': ['OperatorApplication', '{\\cal P}'],
  'pv': ['OperatorApplication', '{\\cal P}'],
  'PV': ['OperatorApplication', '{\\rm P.V.}'],
  'Re': ['OperatorApplication', '{\\rm Re}', '{'],
  'Im': ['OperatorApplication', '{\\rm Im}', '{'],
  'sine': ['NamedFn', 'sin'],
  'hypsine': ['NamedFn', 'sinh'],
  'arcsine': ['NamedFn', 'arcsin'],
  'asine': ['NamedFn', 'asin'],
  'cosine': ['NamedFn', 'cos'],
  'hypcosine': ['NamedFn', 'cosh'],
  'arccosine': ['NamedFn', 'arccos'],
  'acosine': ['NamedFn', 'acos'],
  'tangent': ['NamedFn', 'tan'],
  'hyptangent': ['NamedFn', 'tanh'],
  'arctangent': ['NamedFn', 'arctan'],
  'atangent': ['NamedFn', 'atan'],
  'cosecant': ['NamedFn', 'csc'],
  'hypcosecant': ['NamedFn', 'csch'],
  'arccosecant': ['NamedFn', 'arccsc'],
  'acosecant': ['NamedFn', 'acsc'],
  'secant': ['NamedFn', 'sec'],
  'hypsecant': ['NamedFn', 'sech'],
  'arcsecant': ['NamedFn', 'arcsec'],
  'asecant': ['NamedFn', 'asec'],
  'cotangent': ['NamedFn', 'cot'],
  'hypcotangent': ['NamedFn', 'coth'],
  'arccotangent': ['NamedFn', 'arccot'],
  'acotangent': ['NamedFn', 'acot'],
  'exponential': ['NamedFn', 'exp'],
  'logarithm': ['NamedFn', 'log'],
  'naturallogarithm': ['NamedFn', 'ln'],
  'determinant': ['NamedFn', 'det'],
  'Probability': ['NamedFn', 'Pr']
}, PhysicsMethods_js_1.default);
new SymbolMap_js_1.CommandMap('Physics-quick-quad-macros', {
  'qqtext': 'Qqtext',
  'qq': 'Qqtext',
  'qcomma': ['Macro', '\\qqtext*{,}'],
  'qc': ['Macro', '\\qqtext*{,}'],
  'qcc': ['Qqtext', 'c.c.'],
  'qif': ['Qqtext', 'if'],
  'qthen': ['Qqtext', 'then'],
  'qelse': ['Qqtext', 'else'],
  'qotherwise': ['Qqtext', 'otherwise'],
  'qunless': ['Qqtext', 'unless'],
  'qgiven': ['Qqtext', 'given'],
  'qusing': ['Qqtext', 'using'],
  'qassume': ['Qqtext', 'assume'],
  'qsince,': ['Qqtext', 'since,'],
  'qlet': ['Qqtext', 'let'],
  'qfor': ['Qqtext', 'for'],
  'qall': ['Qqtext', 'all'],
  'qeven': ['Qqtext', 'even'],
  'qodd': ['Qqtext', 'odd'],
  'qinteger': ['Qqtext', 'integer'],
  'qand': ['Qqtext', 'and'],
  'qor': ['Qqtext', 'or'],
  'qas': ['Qqtext', 'as'],
  'qin': ['Qqtext', 'in']
}, PhysicsMethods_js_1.default);
new SymbolMap_js_1.CommandMap('Physics-derivative-macros', {
  'flatfrac': ['Macro', '\\left.#1\\middle/#2\\right.', 2],
  'differential': ['Differential', '{\\rm d}'],
  'dd': ['Differential', '{\\rm d}'],
  'variation': ['Differential', '\\delta'],
  'var': ['Differential', '\\delta'],
  'derivative': ['Derivative', 2, '{\\rm d}'],
  'dv': ['Derivative', 2, '{\\rm d}'],
  'partialderivative': ['Derivative', 3, '\\partial'],
  'pderivative': ['Derivative', 3, '\\partial'],
  'pdv': ['Derivative', 3, '\\partial'],
  'functionalderivative': ['Derivative', 2, '\\delta'],
  'fderivative': ['Derivative', 2, '\\delta'],
  'fdv': ['Derivative', 2, '\\delta']
}, PhysicsMethods_js_1.default);
new SymbolMap_js_1.CommandMap('Physics-bra-ket-macros', {
  'bra': 'Bra',
  'ket': 'Ket',
  'innerproduct': 'BraKet',
  'braket': 'BraKet',
  'outerproduct': 'KetBra',
  'dyad': 'KetBra',
  'ketbra': 'KetBra',
  'op': 'KetBra',
  'expectationvalue': 'Expectation',
  'expval': 'Expectation',
  'ev': 'Expectation',
  'matrixelement': 'MatrixElement',
  'matrixel': 'MatrixElement',
  'mel': 'MatrixElement'
}, PhysicsMethods_js_1.default);
new SymbolMap_js_1.CommandMap('Physics-matrix-macros', {
  'matrixquantity': 'MatrixQuantity',
  'mqty': 'MatrixQuantity',
  'pmqty': ['Macro', '\\mqty(#1)', 1],
  'Pmqty': ['Macro', '\\mqty*(#1)', 1],
  'bmqty': ['Macro', '\\mqty[#1]', 1],
  'vmqty': ['Macro', '\\mqty|#1|', 1],
  'smallmatrixquantity': ['MatrixQuantity', true],
  'smqty': ['MatrixQuantity', true],
  'spmqty': ['Macro', '\\smqty(#1)', 1],
  'sPmqty': ['Macro', '\\smqty*(#1)', 1],
  'sbmqty': ['Macro', '\\smqty[#1]', 1],
  'svmqty': ['Macro', '\\smqty|#1|', 1],
  'matrixdeterminant': ['Macro', '\\vmqty{#1}', 1],
  'mdet': ['Macro', '\\vmqty{#1}', 1],
  'smdet': ['Macro', '\\svmqty{#1}', 1],
  'identitymatrix': 'IdentityMatrix',
  'imat': 'IdentityMatrix',
  'xmatrix': 'XMatrix',
  'xmat': 'XMatrix',
  'zeromatrix': ['Macro', '\\xmat{0}{#1}{#2}', 2],
  'zmat': ['Macro', '\\xmat{0}{#1}{#2}', 2],
  'paulimatrix': 'PauliMatrix',
  'pmat': 'PauliMatrix',
  'diagonalmatrix': 'DiagonalMatrix',
  'dmat': 'DiagonalMatrix',
  'antidiagonalmatrix': ['DiagonalMatrix', true],
  'admat': ['DiagonalMatrix', true]
}, PhysicsMethods_js_1.default);
new SymbolMap_js_1.EnvironmentMap('Physics-aux-envs', ParseMethods_js_1.default.environment, {
  smallmatrix: ['Array', null, null, null, 'c', '0.333em', '.2em', 'S', 1]
}, PhysicsMethods_js_1.default);
new SymbolMap_js_1.MacroMap('Physics-characters', {
  '|': ['AutoClose', MmlNode_js_1.TEXCLASS.ORD],
  ')': 'AutoClose',
  ']': 'AutoClose'
}, PhysicsMethods_js_1.default);

/***/ }),
/* 383 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var BaseMethods_js_1 = __webpack_require__(19);

var TexParser_js_1 = __webpack_require__(15);

var TexError_js_1 = __webpack_require__(6);

var MmlNode_js_1 = __webpack_require__(0);

var ParseUtil_js_1 = __webpack_require__(9);

var NodeUtil_js_1 = __webpack_require__(8);

var NodeFactory_js_1 = __webpack_require__(46);

var PhysicsMethods = {};
var pairs = {
  '(': ')',
  '[': ']',
  '{': '}',
  '|': '|'
};
var biggs = /^(b|B)i(g{1,2})$/;

PhysicsMethods.Quantity = function (parser, name, open, close, arg, named, variant) {
  if (open === void 0) {
    open = '(';
  }

  if (close === void 0) {
    close = ')';
  }

  if (arg === void 0) {
    arg = false;
  }

  if (named === void 0) {
    named = '';
  }

  if (variant === void 0) {
    variant = '';
  }

  var star = arg ? parser.GetStar() : false;
  var next = parser.GetNext();
  var position = parser.i;
  var big = null;

  if (next === '\\') {
    parser.i++;
    big = parser.GetCS();

    if (!big.match(biggs)) {
      var empty = parser.create('node', 'mrow');
      parser.Push(ParseUtil_js_1.default.fenced(parser.configuration, open, empty, close));
      parser.i = position;
      return;
    }

    next = parser.GetNext();
  }

  var right = pairs[next];

  if (arg && next !== '{') {
    throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', parser.currentCS);
  }

  if (!right) {
    var empty = parser.create('node', 'mrow');
    parser.Push(ParseUtil_js_1.default.fenced(parser.configuration, open, empty, close));
    parser.i = position;
    return;
  }

  if (named) {
    var mml = parser.create('token', 'mi', {
      texClass: MmlNode_js_1.TEXCLASS.OP
    }, named);

    if (variant) {
      NodeUtil_js_1.default.setAttribute(mml, 'mathvariant', variant);
    }

    parser.Push(parser.itemFactory.create('fn', mml));
  }

  if (next === '{') {
    var argument = parser.GetArgument(name);
    next = arg ? open : '\\{';
    right = arg ? close : '\\}';
    argument = star ? next + ' ' + argument + ' ' + right : big ? '\\' + big + 'l' + next + ' ' + argument + ' ' + '\\' + big + 'r' + right : '\\left' + next + ' ' + argument + ' ' + '\\right' + right;
    parser.Push(new TexParser_js_1.default(argument, parser.stack.env, parser.configuration).mml());
    return;
  }

  if (arg) {
    next = open;
    right = close;
  }

  parser.i++;
  parser.Push(parser.itemFactory.create('auto open').setProperties({
    open: next,
    close: right,
    big: big
  }));
};

PhysicsMethods.Eval = function (parser, name) {
  var star = parser.GetStar();
  var next = parser.GetNext();

  if (next === '{') {
    var arg = parser.GetArgument(name);
    var replace = '\\left. ' + (star ? '\\smash{' + arg + '}' : arg) + ' ' + '\\vphantom{\\int}\\right|';
    parser.string = parser.string.slice(0, parser.i) + replace + parser.string.slice(parser.i);
    return;
  }

  if (next === '(' || next === '[') {
    parser.i++;
    parser.Push(parser.itemFactory.create('auto open').setProperties({
      open: next,
      close: '|',
      smash: star,
      right: '\\vphantom{\\int}'
    }));
    return;
  }

  throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', parser.currentCS);
};

PhysicsMethods.Commutator = function (parser, name, open, close) {
  if (open === void 0) {
    open = '[';
  }

  if (close === void 0) {
    close = ']';
  }

  var star = parser.GetStar();
  var next = parser.GetNext();
  var big = null;

  if (next === '\\') {
    parser.i++;
    big = parser.GetCS();

    if (!big.match(biggs)) {
      throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', parser.currentCS);
    }

    next = parser.GetNext();
  }

  if (next !== '{') {
    throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', parser.currentCS);
  }

  var arg1 = parser.GetArgument(name);
  var arg2 = parser.GetArgument(name);
  var argument = arg1 + ',' + arg2;
  argument = star ? open + ' ' + argument + ' ' + close : big ? '\\' + big + 'l' + open + ' ' + argument + ' ' + '\\' + big + 'r' + close : '\\left' + open + ' ' + argument + ' ' + '\\right' + close;
  parser.Push(new TexParser_js_1.default(argument, parser.stack.env, parser.configuration).mml());
};

var latinCap = [0x41, 0x5A];
var latinSmall = [0x61, 0x7A];
var greekCap = [0x391, 0x3A9];
var greekSmall = [0x3B1, 0x3C9];
var digits = [0x30, 0x39];

function inRange(value, range) {
  return value >= range[0] && value <= range[1];
}

;

function createVectorToken(factory, kind, def, text) {
  var parser = factory.configuration.parser;
  var token = NodeFactory_js_1.NodeFactory.createToken(factory, kind, def, text);
  var code = text.charCodeAt(0);

  if (text.length === 1 && !parser.stack.env.font && parser.stack.env.vectorFont && (inRange(code, latinCap) || inRange(code, latinSmall) || inRange(code, greekCap) || inRange(code, digits) || inRange(code, greekSmall) && parser.stack.env.vectorStar || NodeUtil_js_1.default.getAttribute(token, 'accent'))) {
    NodeUtil_js_1.default.setAttribute(token, 'mathvariant', parser.stack.env.vectorFont);
  }

  return token;
}

PhysicsMethods.VectorBold = function (parser, name) {
  var star = parser.GetStar();
  var arg = parser.GetArgument(name);
  var oldToken = parser.configuration.nodeFactory.get('token');
  var oldFont = parser.stack.env.font;
  delete parser.stack.env.font;
  parser.configuration.nodeFactory.set('token', createVectorToken);
  parser.stack.env.vectorFont = star ? 'bold-italic' : 'bold';
  parser.stack.env.vectorStar = star;
  var node = new TexParser_js_1.default(arg, parser.stack.env, parser.configuration).mml();

  if (oldFont) {
    parser.stack.env.font = oldFont;
  }

  delete parser.stack.env.vectorFont;
  delete parser.stack.env.vectorStar;
  parser.configuration.nodeFactory.set('token', oldToken);
  parser.Push(node);
};

PhysicsMethods.StarMacro = function (parser, name, argcount) {
  var parts = [];

  for (var _i = 3; _i < arguments.length; _i++) {
    parts[_i - 3] = arguments[_i];
  }

  var star = parser.GetStar();
  var args = [];

  if (argcount) {
    for (var i = args.length; i < argcount; i++) {
      args.push(parser.GetArgument(name));
    }
  }

  var macro = parts.join(star ? '*' : '');
  macro = ParseUtil_js_1.default.substituteArgs(parser, args, macro);
  parser.string = ParseUtil_js_1.default.addArgs(parser, macro, parser.string.slice(parser.i));
  parser.i = 0;

  if (++parser.macroCount > parser.configuration.options['maxMacros']) {
    throw new TexError_js_1.default('MaxMacroSub1', 'MathJax maximum macro substitution count exceeded; ' + 'is there a recursive macro call?');
  }
};

var vectorApplication = function (parser, kind, name, operator, fences) {
  var op = new TexParser_js_1.default(operator, parser.stack.env, parser.configuration).mml();
  parser.Push(parser.itemFactory.create(kind, op));
  var left = parser.GetNext();
  var right = pairs[left];

  if (!right) {
    return;
  }

  var lfence = '',
      rfence = '',
      arg = '';
  var enlarge = fences.indexOf(left) !== -1;

  if (left === '{') {
    arg = parser.GetArgument(name);
    lfence = enlarge ? '\\left\\{' : '';
    rfence = enlarge ? '\\right\\}' : '';
    var macro = lfence + ' ' + arg + ' ' + rfence;
    parser.string = macro + parser.string.slice(parser.i);
    parser.i = 0;
    return;
  }

  if (!enlarge) {
    return;
  }

  parser.i++;
  parser.Push(parser.itemFactory.create('auto open').setProperties({
    open: left,
    close: right
  }));
};

PhysicsMethods.OperatorApplication = function (parser, name, operator) {
  var fences = [];

  for (var _i = 3; _i < arguments.length; _i++) {
    fences[_i - 3] = arguments[_i];
  }

  vectorApplication(parser, 'fn', name, operator, fences);
};

PhysicsMethods.VectorOperator = function (parser, name, operator) {
  var fences = [];

  for (var _i = 3; _i < arguments.length; _i++) {
    fences[_i - 3] = arguments[_i];
  }

  vectorApplication(parser, 'mml', name, operator, fences);
};

PhysicsMethods.Expression = function (parser, name, opt, id) {
  if (opt === void 0) {
    opt = true;
  }

  if (id === void 0) {
    id = '';
  }

  id = id || name.slice(1);
  var exp = opt ? parser.GetBrackets(name) : null;
  var mml = parser.create('token', 'mi', {
    texClass: MmlNode_js_1.TEXCLASS.OP
  }, id);

  if (exp) {
    var sup = new TexParser_js_1.default(exp, parser.stack.env, parser.configuration).mml();
    mml = parser.create('node', 'msup', [mml, sup]);
  }

  parser.Push(parser.itemFactory.create('fn', mml));

  if (parser.GetNext() !== '(') {
    return;
  }

  parser.i++;
  parser.Push(parser.itemFactory.create('auto open').setProperties({
    open: '(',
    close: ')'
  }));
};

PhysicsMethods.Qqtext = function (parser, name, text) {
  var star = parser.GetStar();
  var arg = text ? text : parser.GetArgument(name);
  var replace = (star ? '' : '\\quad') + '\\text{' + arg + '}\\quad ';
  parser.string = parser.string.slice(0, parser.i) + replace + parser.string.slice(parser.i);
};

PhysicsMethods.Differential = function (parser, name, op) {
  var optArg = parser.GetBrackets(name);
  var power = optArg != null ? '^{' + optArg + '}' : ' ';
  var parens = parser.GetNext() === '(';
  var braces = parser.GetNext() === '{';
  var macro = op + power;

  if (!(parens || braces)) {
    macro += parser.GetArgument(name, true) || '';
    var mml = new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml();
    parser.Push(mml);
    return;
  }

  if (braces) {
    macro += parser.GetArgument(name);
    var mml = new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml();
    parser.Push(parser.create('node', 'TeXAtom', [mml], {
      texClass: MmlNode_js_1.TEXCLASS.OP
    }));
    return;
  }

  parser.Push(new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml());
  parser.i++;
  parser.Push(parser.itemFactory.create('auto open').setProperties({
    open: '(',
    close: ')'
  }));
};

PhysicsMethods.Derivative = function (parser, name, argMax, op) {
  var star = parser.GetStar();
  var optArg = parser.GetBrackets(name);
  var argCounter = 1;
  var args = [];
  args.push(parser.GetArgument(name));

  while (parser.GetNext() === '{' && argCounter < argMax) {
    args.push(parser.GetArgument(name));
    argCounter++;
  }

  var ignore = false;
  var power1 = ' ';
  var power2 = ' ';

  if (argMax > 2 && args.length > 2) {
    power1 = '^{' + (args.length - 1) + '}';
    ignore = true;
  } else if (optArg != null) {
    if (argMax > 2 && args.length > 1) {
      ignore = true;
    }

    power1 = '^{' + optArg + '}';
    power2 = power1;
  }

  var frac = star ? '\\flatfrac' : '\\frac';
  var first = args.length > 1 ? args[0] : '';
  var second = args.length > 1 ? args[1] : args[0];
  var rest = '';

  for (var i = 2, arg = void 0; arg = args[i]; i++) {
    rest += op + ' ' + arg;
  }

  var macro = frac + '{' + op + power1 + first + '}' + '{' + op + ' ' + second + power2 + ' ' + rest + '}';
  parser.Push(new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml());

  if (parser.GetNext() === '(') {
    parser.i++;
    parser.Push(parser.itemFactory.create('auto open').setProperties({
      open: '(',
      close: ')',
      ignore: ignore
    }));
  }
};

PhysicsMethods.Bra = function (parser, name) {
  var starBra = parser.GetStar();
  var bra = parser.GetArgument(name);
  var ket = '';
  var hasKet = false;
  var starKet = false;

  if (parser.GetNext() === '\\') {
    var saveI = parser.i;
    parser.i++;
    var cs = parser.GetCS();
    var symbol = parser.lookup('macro', cs);

    if (symbol && symbol.symbol === 'ket') {
      hasKet = true;
      saveI = parser.i;
      starKet = parser.GetStar();

      if (parser.GetNext() === '{') {
        ket = parser.GetArgument(cs, true);
      } else {
        parser.i = saveI;
        starKet = false;
      }
    } else {
      parser.i = saveI;
    }
  }

  var macro = '';

  if (hasKet) {
    macro = starBra || starKet ? "\\langle{" + bra + "}\\vert{" + ket + "}\\rangle" : "\\left\\langle{" + bra + "}\\middle\\vert{" + ket + "}\\right\\rangle";
  } else {
    macro = starBra || starKet ? "\\langle{" + bra + "}\\vert" : "\\left\\langle{" + bra + "}\\right\\vert{" + ket + "}";
  }

  parser.Push(new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml());
};

PhysicsMethods.Ket = function (parser, name) {
  var star = parser.GetStar();
  var ket = parser.GetArgument(name);
  var macro = star ? "\\vert{" + ket + "}\\rangle" : "\\left\\vert{" + ket + "}\\right\\rangle";
  parser.Push(new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml());
};

PhysicsMethods.BraKet = function (parser, name) {
  var star = parser.GetStar();
  var bra = parser.GetArgument(name);
  var ket = null;

  if (parser.GetNext() === '{') {
    ket = parser.GetArgument(name, true);
  }

  var macro = '';

  if (ket == null) {
    macro = star ? "\\langle{" + bra + "}\\vert{" + bra + "}\\rangle" : "\\left\\langle{" + bra + "}\\middle\\vert{" + bra + "}\\right\\rangle";
  } else {
    macro = star ? "\\langle{" + bra + "}\\vert{" + ket + "}\\rangle" : "\\left\\langle{" + bra + "}\\middle\\vert{" + ket + "}\\right\\rangle";
  }

  parser.Push(new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml());
};

PhysicsMethods.KetBra = function (parser, name) {
  var star = parser.GetStar();
  var ket = parser.GetArgument(name);
  var bra = null;

  if (parser.GetNext() === '{') {
    bra = parser.GetArgument(name, true);
  }

  var macro = '';

  if (bra == null) {
    macro = star ? "\\vert{" + ket + "}\\rangle\\!\\langle{" + ket + "}\\vert" : "\\left\\vert{" + ket + "}\\middle\\rangle\\!\\middle\\langle{" + ket + "}\\right\\vert";
  } else {
    macro = star ? "\\vert{" + ket + "}\\rangle\\!\\langle{" + bra + "}\\vert" : "\\left\\vert{" + ket + "}\\middle\\rangle\\!\\middle\\langle{" + bra + "}\\right\\vert";
  }

  parser.Push(new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml());
};

function outputBraket(_a, star1, star2) {
  var _b = __read(_a, 3),
      arg1 = _b[0],
      arg2 = _b[1],
      arg3 = _b[2];

  return star1 && star2 ? "\\left\\langle{" + arg1 + "}\\middle\\vert{" + arg2 + "}\\middle\\vert{" + arg3 + "}\\right\\rangle" : star1 ? "\\langle{" + arg1 + "}\\vert{" + arg2 + "}\\vert{" + arg3 + "}\\rangle" : "\\left\\langle{" + arg1 + "}\\right\\vert{" + arg2 + "}\\left\\vert{" + arg3 + "}\\right\\rangle";
}

;

PhysicsMethods.Expectation = function (parser, name) {
  var star1 = parser.GetStar();
  var star2 = star1 && parser.GetStar();
  var braket = parser.GetNext() === '{';
  var arg1 = parser.GetArgument(name);
  var arg2 = null;

  if (parser.GetNext() === '{') {
    arg2 = parser.GetArgument(name, true);
  }

  var macro = arg1 && arg2 ? outputBraket([arg2, arg1, arg2], star1, star2) : star1 ? "\\langle {" + arg1 + "} \\rangle" : "\\left\\langle {" + arg1 + "} \\right\\rangle";
  parser.Push(new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml());
};

PhysicsMethods.MatrixElement = function (parser, name) {
  var star1 = parser.GetStar();
  var star2 = star1 && parser.GetStar();
  var braket = parser.GetNext() === '{';
  var arg1 = parser.GetArgument(name);
  var arg2 = parser.GetArgument(name);
  var arg3 = parser.GetArgument(name);
  var macro = outputBraket([arg1, arg2, arg3], star1, star2);
  parser.Push(new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml());
};

PhysicsMethods.MatrixQuantity = function (parser, name, small) {
  var star = parser.GetStar();
  var next = parser.GetNext();
  var array = small ? 'smallmatrix' : 'array';
  var arg = '';
  var open = '';
  var close = '';

  switch (next) {
    case '{':
      arg = parser.GetArgument(name);
      break;

    case '(':
      parser.i++;
      open = star ? '\\lgroup' : '(';
      close = star ? '\\rgroup' : ')';
      arg = parser.GetUpTo(name, ')');
      break;

    case '[':
      parser.i++;
      open = '[';
      close = ']';
      arg = parser.GetUpTo(name, ']');
      break;

    case '|':
      parser.i++;
      open = '|';
      close = '|';
      arg = parser.GetUpTo(name, '|');
      break;

    default:
      open = '(';
      close = ')';
      break;
  }

  var macro = (open ? '\\left' : '') + open + '\\begin{' + array + '}{} ' + arg + '\\end{' + array + '}' + (open ? '\\right' : '') + close;
  parser.Push(new TexParser_js_1.default(macro, parser.stack.env, parser.configuration).mml());
};

PhysicsMethods.IdentityMatrix = function (parser, name) {
  var arg = parser.GetArgument(name);
  var size = parseInt(arg, 10);

  if (isNaN(size)) {
    throw new TexError_js_1.default('InvalidNumber', 'Invalid number');
  }

  if (size <= 1) {
    parser.string = '1' + parser.string.slice(parser.i);
    parser.i = 0;
    return;
  }

  var zeros = Array(size).fill('0');
  var columns = [];

  for (var i = 0; i < size; i++) {
    var row = zeros.slice();
    row[i] = '1';
    columns.push(row.join(' & '));
  }

  parser.string = columns.join('\\\\ ') + parser.string.slice(parser.i);
  parser.i = 0;
};

PhysicsMethods.XMatrix = function (parser, name) {
  var star = parser.GetStar();
  var arg1 = parser.GetArgument(name);
  var arg2 = parser.GetArgument(name);
  var arg3 = parser.GetArgument(name);
  var n = parseInt(arg2, 10);
  var m = parseInt(arg3, 10);

  if (isNaN(n) || isNaN(m) || m.toString() !== arg3 || n.toString() !== arg2) {
    throw new TexError_js_1.default('InvalidNumber', 'Invalid number');
  }

  n = n < 1 ? 1 : n;
  m = m < 1 ? 1 : m;

  if (!star) {
    var row = Array(m).fill(arg1).join(' & ');
    var matrix_1 = Array(n).fill(row).join('\\\\ ');
    parser.string = matrix_1 + parser.string.slice(parser.i);
    parser.i = 0;
    return;
  }

  var matrix = '';

  if (n === 1 && m === 1) {
    matrix = arg1;
  } else if (n === 1) {
    var row = [];

    for (var i = 1; i <= m; i++) {
      row.push(arg1 + "_{" + i + "}");
    }

    matrix = row.join(' & ');
  } else if (m === 1) {
    var row = [];

    for (var i = 1; i <= n; i++) {
      row.push(arg1 + "_{" + i + "}");
    }

    matrix = row.join('\\\\ ');
  } else {
    var rows = [];

    for (var i = 1; i <= n; i++) {
      var row = [];

      for (var j = 1; j <= m; j++) {
        row.push(arg1 + "_{{" + i + "}{" + j + "}}");
      }

      rows.push(row.join(' & '));
    }

    matrix = rows.join('\\\\ ');
  }

  parser.string = matrix + parser.string.slice(parser.i);
  parser.i = 0;
  return;
};

PhysicsMethods.PauliMatrix = function (parser, name) {
  var arg = parser.GetArgument(name);
  var matrix = arg.slice(1);

  switch (arg[0]) {
    case '0':
      matrix += ' 1 & 0\\\\ 0 & 1';
      break;

    case '1':
    case 'x':
      matrix += ' 0 & 1\\\\ 1 & 0';
      break;

    case '2':
    case 'y':
      matrix += ' 0 & -i\\\\ i & 0';
      break;

    case '3':
    case 'z':
      matrix += ' 1 & 0\\\\ 0 & -1';
      break;

    default:
  }

  parser.string = matrix + parser.string.slice(parser.i);
  parser.i = 0;
};

PhysicsMethods.DiagonalMatrix = function (parser, name, anti) {
  if (parser.GetNext() !== '{') {
    return;
  }

  ;
  var startI = parser.i;
  var arg = parser.GetArgument(name);
  var endI = parser.i;
  parser.i = startI + 1;
  var elements = [];
  var element = '';
  var currentI = parser.i;

  while (currentI < endI) {
    try {
      element = parser.GetUpTo(name, ',');
    } catch (e) {
      parser.i = endI;
      elements.push(parser.string.slice(currentI, endI - 1));
      break;
    }

    if (parser.i >= endI) {
      elements.push(parser.string.slice(currentI, endI));
      break;
    }

    currentI = parser.i;
    elements.push(element);
  }

  parser.string = makeDiagMatrix(elements, anti) + parser.string.slice(endI);
  parser.i = 0;
};

function makeDiagMatrix(elements, anti) {
  var length = elements.length;
  var matrix = [];

  for (var i = 0; i < length; i++) {
    matrix.push(Array(anti ? length - i : i + 1).join('&') + '\\mqty{' + elements[i] + '}');
  }

  return matrix.join('\\\\ ');
}

PhysicsMethods.AutoClose = function (parser, fence, texclass) {
  var mo = parser.create('token', 'mo', {
    stretchy: false
  }, fence);
  var item = parser.itemFactory.create('mml', mo).setProperties({
    autoclose: fence
  });
  parser.Push(item);
};

PhysicsMethods.Macro = BaseMethods_js_1.default.Macro;
PhysicsMethods.NamedFn = BaseMethods_js_1.default.NamedFn;
PhysicsMethods.Array = BaseMethods_js_1.default.Array;
exports.default = PhysicsMethods;

/***/ }),
/* 384 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var TexError_js_1 = __webpack_require__(6);

var SymbolMap_js_1 = __webpack_require__(5);

var ParseUtil_js_1 = __webpack_require__(9);

var Entities_js_1 = __webpack_require__(18);

exports.UnicodeMethods = {};
var UnicodeCache = {};

exports.UnicodeMethods.Unicode = function (parser, name) {
  var HD = parser.GetBrackets(name);
  var HDsplit = null;
  var font = null;

  if (HD) {
    if (HD.replace(/ /g, '').match(/^(\d+(\.\d*)?|\.\d+),(\d+(\.\d*)?|\.\d+)$/)) {
      HDsplit = HD.replace(/ /g, '').split(/,/);
      font = parser.GetBrackets(name);
    } else {
      font = HD;
    }
  }

  var n = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name)).replace(/^0x/, 'x');

  if (!n.match(/^(x[0-9A-Fa-f]+|[0-9]+)$/)) {
    throw new TexError_js_1.default('BadUnicode', 'Argument to \\unicode must be a number');
  }

  var N = parseInt(n.match(/^x/) ? '0' + n : n);

  if (!UnicodeCache[N]) {
    UnicodeCache[N] = [800, 200, font, N];
  } else if (!font) {
    font = UnicodeCache[N][2];
  }

  if (HDsplit) {
    UnicodeCache[N][0] = Math.floor(parseFloat(HDsplit[0]) * 1000);
    UnicodeCache[N][1] = Math.floor(parseFloat(HDsplit[1]) * 1000);
  }

  var variant = parser.stack.env.font;
  var def = {};

  if (font) {
    UnicodeCache[N][2] = def.fontfamily = font.replace(/'/g, '\'');

    if (variant) {
      if (variant.match(/bold/)) {
        def.fontweight = 'bold';
      }

      if (variant.match(/italic|-mathit/)) {
        def.fontstyle = 'italic';
      }
    }
  } else if (variant) {
    def.mathvariant = variant;
  }

  parser.Push(parser.create('token', 'mtext', def, Entities_js_1.numeric(n)));
};

new SymbolMap_js_1.CommandMap('unicode', {
  unicode: 'Unicode'
}, exports.UnicodeMethods);
exports.UnicodeConfiguration = Configuration_js_1.Configuration.create('unicode', {
  handler: {
    macro: ['unicode']
  }
});

/***/ }),
/* 385 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var Configuration_js_1 = __webpack_require__(4);

var TexConstants_js_1 = __webpack_require__(14);

var SymbolMap_js_1 = __webpack_require__(5);

var TexError_js_1 = __webpack_require__(6);

exports.VerbMethods = {};

exports.VerbMethods.Verb = function (parser, name, notation) {
  var c = parser.GetNext();
  var start = ++parser.i;

  if (c === '') {
    throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', name);
  }

  while (parser.i < parser.string.length && parser.string.charAt(parser.i) !== c) {
    parser.i++;
  }

  if (parser.i === parser.string.length) {
    throw new TexError_js_1.default('NoClosingDelim', 'Can\'t find closing delimiter for %1', parser.currentCS);
  }

  var text = parser.string.slice(start, parser.i).replace(/ /g, '\u00A0');
  parser.i++;
  parser.Push(parser.create('token', 'mtext', {
    mathvariant: TexConstants_js_1.TexConstant.Variant.MONOSPACE
  }, text));
};

new SymbolMap_js_1.CommandMap('verb', {
  verb: 'Verb'
}, exports.VerbMethods);
exports.VerbConfiguration = Configuration_js_1.Configuration.create('verb', {
  handler: {
    macro: ['verb']
  }
});

/***/ }),
/* 386 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var mathjax_js_1 = __webpack_require__(42);

var HTMLHandler_js_1 = __webpack_require__(387);

function RegisterHTMLHandler(adaptor) {
  var handler = new HTMLHandler_js_1.HTMLHandler(adaptor);
  mathjax_js_1.MathJax.handlers.register(handler);
  return handler;
}

exports.RegisterHTMLHandler = RegisterHTMLHandler;

/***/ }),
/* 387 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Handler_js_1 = __webpack_require__(388);

var HTMLDocument_js_1 = __webpack_require__(401);

var HTMLHandler = function (_super) {
  __extends(HTMLHandler, _super);

  function HTMLHandler() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.documentClass = HTMLDocument_js_1.HTMLDocument;
    return _this;
  }

  HTMLHandler.prototype.handlesDocument = function (document) {
    var adaptor = this.adaptor;

    if (typeof document === 'string') {
      try {
        document = adaptor.parse(document, 'text/html');
      } catch (err) {}
    }

    if (document instanceof adaptor.window.Document || document instanceof adaptor.window.HTMLElement || document instanceof adaptor.window.DocumentFragment) {
      return true;
    }

    return false;
  };

  HTMLHandler.prototype.create = function (document, options) {
    var adaptor = this.adaptor;

    if (typeof document === 'string') {
      document = adaptor.parse(document, 'text/html');
    } else if (document instanceof adaptor.window.HTMLElement || document instanceof adaptor.window.DocumentFragment) {
      var child = document;
      document = adaptor.parse('', 'text/html');
      adaptor.append(adaptor.body(document), child);
    }

    return _super.prototype.create.call(this, document, options);
  };

  return HTMLHandler;
}(Handler_js_1.AbstractHandler);

exports.HTMLHandler = HTMLHandler;

/***/ }),
/* 388 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MathDocument_js_1 = __webpack_require__(104);

var DefaultMathDocument = function (_super) {
  __extends(DefaultMathDocument, _super);

  function DefaultMathDocument() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return DefaultMathDocument;
}(MathDocument_js_1.AbstractMathDocument);

var AbstractHandler = function () {
  function AbstractHandler(adaptor, priority) {
    if (priority === void 0) {
      priority = 5;
    }

    this.documentClass = DefaultMathDocument;
    this.adaptor = adaptor;
    this.priority = priority;
  }

  Object.defineProperty(AbstractHandler.prototype, "name", {
    get: function () {
      return this.constructor.NAME;
    },
    enumerable: true,
    configurable: true
  });

  AbstractHandler.prototype.handlesDocument = function (document) {
    return false;
  };

  AbstractHandler.prototype.create = function (document, options) {
    return new this.documentClass(document, this.adaptor, options);
  };

  return AbstractHandler;
}();

AbstractHandler.NAME = 'generic';
exports.AbstractHandler = AbstractHandler;

/***/ }),
/* 389 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});
var END = Symbol();

var ListItem = function () {
  function ListItem(data) {
    if (data === void 0) {
      data = null;
    }

    this.next = null;
    this.prev = null;
    this.data = data;
  }

  return ListItem;
}();

exports.ListItem = ListItem;

var LinkedList = function () {
  function LinkedList() {
    var args = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }

    this.list = new ListItem(END);
    this.list.next = this.list.prev = this.list;
    this.push.apply(this, __spread(args));
  }

  LinkedList.prototype.toArray = function () {
    return Array.from(this);
  };

  LinkedList.prototype.isBefore = function (a, b) {
    return a < b;
  };

  LinkedList.prototype.push = function () {
    var args = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }

    try {
      for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
        var data = args_1_1.value;
        var item = new ListItem(data);
        item.next = this.list;
        item.prev = this.list.prev;
        this.list.prev = item;
        item.prev.next = item;
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    return this;

    var e_1, _a;
  };

  LinkedList.prototype.pop = function () {
    var item = this.list.prev;

    if (item.data === END) {
      return null;
    }

    this.list.prev = item.prev;
    item.prev.next = this.list;
    item.next = item.prev = null;
    return item.data;
  };

  LinkedList.prototype.unshift = function () {
    var args = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }

    try {
      for (var _a = __values(args.slice(0).reverse()), _b = _a.next(); !_b.done; _b = _a.next()) {
        var data = _b.value;
        var item = new ListItem(data);
        item.next = this.list.next;
        item.prev = this.list;
        this.list.next = item;
        item.next.prev = item;
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    return this;

    var e_2, _c;
  };

  LinkedList.prototype.shift = function () {
    var item = this.list.next;

    if (item.data === END) {
      return null;
    }

    this.list.next = item.next;
    item.next.prev = this.list;
    item.next = item.prev = null;
    return item.data;
  };

  LinkedList.prototype.clear = function () {
    this.list.next.prev = this.list.prev.next = null;
    this.list.next = this.list.prev = this.list;
    return this;
  };

  LinkedList.prototype[Symbol.iterator] = function () {
    var current = this.list;
    return {
      next: function () {
        current = current.next;
        return current.data === END ? {
          value: null,
          done: true
        } : {
          value: current.data,
          done: false
        };
      }
    };
  };

  LinkedList.prototype.reversed = function () {
    var current = this.list;
    return _a = {}, _a[Symbol.iterator] = function () {
      return this;
    }, _a.next = function () {
      current = current.prev;
      return current.data === END ? {
        value: null,
        done: true
      } : {
        value: current.data,
        done: false
      };
    }, _a.toArray = function () {
      return Array.from(this);
    }, _a;

    var _a;
  };

  LinkedList.prototype.insert = function (data, isBefore) {
    if (isBefore === void 0) {
      isBefore = null;
    }

    if (isBefore === null) {
      isBefore = this.isBefore.bind(this);
    }

    var item = new ListItem(data);
    var cur = this.list.next;

    while (cur.data !== END && isBefore(cur.data, item.data)) {
      cur = cur.next;
    }

    item.prev = cur.prev;
    item.next = cur;
    cur.prev.next = cur.prev = item;
    return this;
  };

  LinkedList.prototype.sort = function (isBefore) {
    if (isBefore === void 0) {
      isBefore = null;
    }

    if (isBefore === null) {
      isBefore = this.isBefore.bind(this);
    }

    var lists = [];

    try {
      for (var _a = __values(this), _b = _a.next(); !_b.done; _b = _a.next()) {
        var item = _b.value;
        lists.push(new LinkedList(item));
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    this.list.next = this.list.prev = this.list;

    while (lists.length > 1) {
      var l1 = lists.shift();
      var l2 = lists.shift();
      l1.merge(l2, isBefore);
      lists.push(l1);
    }

    if (lists.length) {
      this.list = lists[0].list;
    }

    return this;

    var e_3, _c;
  };

  LinkedList.prototype.merge = function (list, isBefore) {
    if (isBefore === void 0) {
      isBefore = null;
    }

    if (isBefore === null) {
      isBefore = this.isBefore.bind(this);
    }

    var lcur = this.list.next;
    var mcur = list.list.next;

    while (lcur.data !== END && mcur.data !== END) {
      if (isBefore(mcur.data, lcur.data)) {
        _a = __read([lcur, mcur], 2), mcur.prev.next = _a[0], lcur.prev.next = _a[1];
        _b = __read([lcur.prev, mcur.prev], 2), mcur.prev = _b[0], lcur.prev = _b[1];
        _c = __read([list.list, this.list], 2), this.list.prev.next = _c[0], list.list.prev.next = _c[1];
        _d = __read([list.list.prev, this.list.prev], 2), this.list.prev = _d[0], list.list.prev = _d[1];
        _e = __read([mcur.next, lcur], 2), lcur = _e[0], mcur = _e[1];
      } else {
        lcur = lcur.next;
      }
    }

    if (mcur.data !== END) {
      this.list.prev.next = list.list.next;
      list.list.next.prev = this.list.prev;
      list.list.prev.next = this.list;
      this.list.prev = list.list.prev;
      list.list.next = list.list.prev = list.list;
    }

    return this;

    var _a, _b, _c, _d, _e;
  };

  return LinkedList;
}();

exports.LinkedList = LinkedList;

/***/ }),
/* 390 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var NodeFactory_js_1 = __webpack_require__(391);

var MML_js_1 = __webpack_require__(392);

var MmlFactory = function (_super) {
  __extends(MmlFactory, _super);

  function MmlFactory() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlFactory.prototype, "MML", {
    get: function () {
      return this.node;
    },
    enumerable: true,
    configurable: true
  });
  return MmlFactory;
}(NodeFactory_js_1.AbstractNodeFactory);

MmlFactory.defaultNodes = MML_js_1.MML;
exports.MmlFactory = MmlFactory;

/***/ }),
/* 391 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Factory_js_1 = __webpack_require__(45);

var AbstractNodeFactory = function (_super) {
  __extends(AbstractNodeFactory, _super);

  function AbstractNodeFactory() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  AbstractNodeFactory.prototype.create = function (kind, properties, children) {
    if (properties === void 0) {
      properties = {};
    }

    if (children === void 0) {
      children = [];
    }

    return this.node[kind](properties, children);
  };

  return AbstractNodeFactory;
}(Factory_js_1.AbstractFactory);

exports.AbstractNodeFactory = AbstractNodeFactory;

/***/ }),
/* 392 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var math_js_1 = __webpack_require__(76);

var mi_js_1 = __webpack_require__(77);

var mn_js_1 = __webpack_require__(78);

var mo_js_1 = __webpack_require__(34);

var mtext_js_1 = __webpack_require__(393);

var mspace_js_1 = __webpack_require__(80);

var ms_js_1 = __webpack_require__(79);

var mrow_js_1 = __webpack_require__(84);

var mfrac_js_1 = __webpack_require__(86);

var msqrt_js_1 = __webpack_require__(88);

var mroot_js_1 = __webpack_require__(89);

var mstyle_js_1 = __webpack_require__(394);

var merror_js_1 = __webpack_require__(395);

var mpadded_js_1 = __webpack_require__(81);

var mphantom_js_1 = __webpack_require__(396);

var mfenced_js_1 = __webpack_require__(85);

var menclose_js_1 = __webpack_require__(82);

var maction_js_1 = __webpack_require__(97);

var msubsup_js_1 = __webpack_require__(52);

var munderover_js_1 = __webpack_require__(90);

var mmultiscripts_js_1 = __webpack_require__(91);

var mtable_js_1 = __webpack_require__(92);

var mtr_js_1 = __webpack_require__(94);

var mtd_js_1 = __webpack_require__(95);

var maligngroup_js_1 = __webpack_require__(397);

var malignmark_js_1 = __webpack_require__(398);

var mglyph_js_1 = __webpack_require__(98);

var semantics_js_1 = __webpack_require__(99);

var TeXAtom_js_1 = __webpack_require__(100);

var mathchoice_js_1 = __webpack_require__(399);

exports.MML = (_a = {}, _a[math_js_1.MmlMath.prototype.kind] = math_js_1.MmlMath, _a[mi_js_1.MmlMi.prototype.kind] = mi_js_1.MmlMi, _a[mn_js_1.MmlMn.prototype.kind] = mn_js_1.MmlMn, _a[mo_js_1.MmlMo.prototype.kind] = mo_js_1.MmlMo, _a[mtext_js_1.MmlMtext.prototype.kind] = mtext_js_1.MmlMtext, _a[mspace_js_1.MmlMspace.prototype.kind] = mspace_js_1.MmlMspace, _a[ms_js_1.MmlMs.prototype.kind] = ms_js_1.MmlMs, _a[mrow_js_1.MmlMrow.prototype.kind] = mrow_js_1.MmlMrow, _a[mrow_js_1.MmlInferredMrow.prototype.kind] = mrow_js_1.MmlInferredMrow, _a[mfrac_js_1.MmlMfrac.prototype.kind] = mfrac_js_1.MmlMfrac, _a[msqrt_js_1.MmlMsqrt.prototype.kind] = msqrt_js_1.MmlMsqrt, _a[mroot_js_1.MmlMroot.prototype.kind] = mroot_js_1.MmlMroot, _a[mstyle_js_1.MmlMstyle.prototype.kind] = mstyle_js_1.MmlMstyle, _a[merror_js_1.MmlMerror.prototype.kind] = merror_js_1.MmlMerror, _a[mpadded_js_1.MmlMpadded.prototype.kind] = mpadded_js_1.MmlMpadded, _a[mphantom_js_1.MmlMphantom.prototype.kind] = mphantom_js_1.MmlMphantom, _a[mfenced_js_1.MmlMfenced.prototype.kind] = mfenced_js_1.MmlMfenced, _a[menclose_js_1.MmlMenclose.prototype.kind] = menclose_js_1.MmlMenclose, _a[maction_js_1.MmlMaction.prototype.kind] = maction_js_1.MmlMaction, _a[msubsup_js_1.MmlMsub.prototype.kind] = msubsup_js_1.MmlMsub, _a[msubsup_js_1.MmlMsup.prototype.kind] = msubsup_js_1.MmlMsup, _a[msubsup_js_1.MmlMsubsup.prototype.kind] = msubsup_js_1.MmlMsubsup, _a[munderover_js_1.MmlMunder.prototype.kind] = munderover_js_1.MmlMunder, _a[munderover_js_1.MmlMover.prototype.kind] = munderover_js_1.MmlMover, _a[munderover_js_1.MmlMunderover.prototype.kind] = munderover_js_1.MmlMunderover, _a[mmultiscripts_js_1.MmlMmultiscripts.prototype.kind] = mmultiscripts_js_1.MmlMmultiscripts, _a[mmultiscripts_js_1.MmlMprescripts.prototype.kind] = mmultiscripts_js_1.MmlMprescripts, _a[mmultiscripts_js_1.MmlNone.prototype.kind] = mmultiscripts_js_1.MmlNone, _a[mtable_js_1.MmlMtable.prototype.kind] = mtable_js_1.MmlMtable, _a[mtr_js_1.MmlMlabeledtr.prototype.kind] = mtr_js_1.MmlMlabeledtr, _a[mtr_js_1.MmlMtr.prototype.kind] = mtr_js_1.MmlMtr, _a[mtd_js_1.MmlMtd.prototype.kind] = mtd_js_1.MmlMtd, _a[maligngroup_js_1.MmlMaligngroup.prototype.kind] = maligngroup_js_1.MmlMaligngroup, _a[malignmark_js_1.MmlMalignmark.prototype.kind] = malignmark_js_1.MmlMalignmark, _a[mglyph_js_1.MmlMglyph.prototype.kind] = mglyph_js_1.MmlMglyph, _a[semantics_js_1.MmlSemantics.prototype.kind] = semantics_js_1.MmlSemantics, _a[semantics_js_1.MmlAnnotation.prototype.kind] = semantics_js_1.MmlAnnotation, _a[semantics_js_1.MmlAnnotationXML.prototype.kind] = semantics_js_1.MmlAnnotationXML, _a[TeXAtom_js_1.TeXAtom.prototype.kind] = TeXAtom_js_1.TeXAtom, _a[mathchoice_js_1.mathchoice.prototype.kind] = mathchoice_js_1.mathchoice, _a[MmlNode_js_1.TextNode.prototype.kind] = MmlNode_js_1.TextNode, _a[MmlNode_js_1.XMLNode.prototype.kind] = MmlNode_js_1.XMLNode, _a);

var _a;

/***/ }),
/* 393 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMtext = function (_super) {
  __extends(MmlMtext, _super);

  function MmlMtext() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMtext.prototype, "kind", {
    get: function () {
      return 'mtext';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMtext.prototype, "isSpacelike", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  return MmlMtext;
}(MmlNode_js_1.AbstractMmlTokenNode);

MmlMtext.defaults = __assign({}, MmlNode_js_1.AbstractMmlTokenNode.defaults);
exports.MmlMtext = MmlMtext;

/***/ }),
/* 394 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var Attributes_js_1 = __webpack_require__(26);

var MmlMstyle = function (_super) {
  __extends(MmlMstyle, _super);

  function MmlMstyle() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMstyle.prototype, "kind", {
    get: function () {
      return 'mstyle';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMstyle.prototype, "notParent", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMstyle.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    var scriptlevel = this.attributes.getExplicit('scriptlevel');

    if (scriptlevel != null) {
      scriptlevel = scriptlevel.toString();

      if (scriptlevel.match(/^\s*[-+]/)) {
        level += parseInt(scriptlevel);
      } else {
        level = parseInt(scriptlevel);
      }
    }

    var displaystyle = this.attributes.getExplicit('displaystyle');

    if (displaystyle != null) {
      display = displaystyle === true;
    }

    attributes = this.addInheritedAttributes(attributes, this.attributes.getAllAttributes());
    this.childNodes[0].setInheritedAttributes(attributes, display, level, prime);
  };

  return MmlMstyle;
}(MmlNode_js_1.AbstractMmlLayoutNode);

MmlMstyle.defaults = __assign({}, MmlNode_js_1.AbstractMmlLayoutNode.defaults, {
  scriptlevel: Attributes_js_1.INHERIT,
  displaystyle: Attributes_js_1.INHERIT,
  scriptsizemultiplier: 1 / Math.sqrt(2),
  scriptminsize: '8px',
  mathbackground: Attributes_js_1.INHERIT,
  mathcolor: Attributes_js_1.INHERIT,
  dir: Attributes_js_1.INHERIT,
  infixlinebreakstyle: 'before'
});
exports.MmlMstyle = MmlMstyle;

/***/ }),
/* 395 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMerror = function (_super) {
  __extends(MmlMerror, _super);

  function MmlMerror() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMerror.prototype, "kind", {
    get: function () {
      return 'merror';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMerror.prototype, "arity", {
    get: function () {
      return -1;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMerror.prototype, "linebreakContainer", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  return MmlMerror;
}(MmlNode_js_1.AbstractMmlNode);

MmlMerror.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults);
exports.MmlMerror = MmlMerror;

/***/ }),
/* 396 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMphantom = function (_super) {
  __extends(MmlMphantom, _super);

  function MmlMphantom() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.texClass = MmlNode_js_1.TEXCLASS.ORD;
    return _this;
  }

  Object.defineProperty(MmlMphantom.prototype, "kind", {
    get: function () {
      return 'mphantom';
    },
    enumerable: true,
    configurable: true
  });
  return MmlMphantom;
}(MmlNode_js_1.AbstractMmlLayoutNode);

MmlMphantom.defaults = __assign({}, MmlNode_js_1.AbstractMmlLayoutNode.defaults);
exports.MmlMphantom = MmlMphantom;

/***/ }),
/* 397 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var Attributes_js_1 = __webpack_require__(26);

var MmlMaligngroup = function (_super) {
  __extends(MmlMaligngroup, _super);

  function MmlMaligngroup() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMaligngroup.prototype, "kind", {
    get: function () {
      return 'maligngroup';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMaligngroup.prototype, "isSpacelike", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  MmlMaligngroup.prototype.setChildInheritedAttributes = function (attributes, display, level, prime) {
    attributes = this.addInheritedAttributes(attributes, this.attributes.getAllAttributes());

    _super.prototype.setChildInheritedAttributes.call(this, attributes, display, level, prime);
  };

  return MmlMaligngroup;
}(MmlNode_js_1.AbstractMmlNode);

MmlMaligngroup.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults, {
  groupalign: Attributes_js_1.INHERIT
});
exports.MmlMaligngroup = MmlMaligngroup;

/***/ }),
/* 398 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var MmlMalignmark = function (_super) {
  __extends(MmlMalignmark, _super);

  function MmlMalignmark() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(MmlMalignmark.prototype, "kind", {
    get: function () {
      return 'malignmark';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMalignmark.prototype, "arity", {
    get: function () {
      return 0;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(MmlMalignmark.prototype, "isSpacelike", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });
  return MmlMalignmark;
}(MmlNode_js_1.AbstractMmlNode);

MmlMalignmark.defaults = __assign({}, MmlNode_js_1.AbstractMmlNode.defaults, {
  edge: 'left'
});
exports.MmlMalignmark = MmlMalignmark;

/***/ }),
/* 399 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MmlNode_js_1 = __webpack_require__(0);

var mathchoice = function (_super) {
  __extends(mathchoice, _super);

  function mathchoice() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  Object.defineProperty(mathchoice.prototype, "kind", {
    get: function () {
      return 'mathchoice';
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(mathchoice.prototype, "arity", {
    get: function () {
      return 4;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(mathchoice.prototype, "notParent", {
    get: function () {
      return true;
    },
    enumerable: true,
    configurable: true
  });

  mathchoice.prototype.setInheritedAttributes = function (attributes, display, level, prime) {
    var selection = display ? 0 : Math.max(0, Math.min(level, 2)) + 1;
    var child = this.childNodes[selection] || this.factory.create('mrow');
    this.parent.replaceChild(child, this);
    child.setInheritedAttributes(attributes, display, level, prime);
  };

  return mathchoice;
}(MmlNode_js_1.AbstractMmlBaseNode);

mathchoice.defaults = __assign({}, MmlNode_js_1.AbstractMmlBaseNode.defaults);
exports.mathchoice = mathchoice;

/***/ }),
/* 400 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __spread = this && this.__spread || function () {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var BitField = function () {
  function BitField() {
    this.bits = 0;
  }

  BitField.allocate = function () {
    var names = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      names[_i] = arguments[_i];
    }

    try {
      for (var names_1 = __values(names), names_1_1 = names_1.next(); !names_1_1.done; names_1_1 = names_1.next()) {
        var name_1 = names_1_1.value;

        if (this.has(name_1)) {
          throw new Error('Bit already allocated for ' + name_1);
        }

        if (this.next === BitField.MAXBIT) {
          throw new Error('Maximum number of bits already allocated');
        }

        this.names.set(name_1, this.next);
        this.next <<= 1;
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (names_1_1 && !names_1_1.done && (_a = names_1.return)) _a.call(names_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var e_1, _a;
  };

  BitField.has = function (name) {
    return this.names.has(name);
  };

  BitField.prototype.set = function (name) {
    this.bits |= this.getBit(name);
  };

  BitField.prototype.clear = function (name) {
    this.bits &= ~this.getBit(name);
  };

  BitField.prototype.isSet = function (name) {
    return !!(this.bits & this.getBit(name));
  };

  BitField.prototype.reset = function () {
    this.bits = 0;
  };

  BitField.prototype.getBit = function (name) {
    var bit = this.constructor.names.get(name);

    if (!bit) {
      throw new Error('Unknown bit-field name: ' + name);
    }

    return bit;
  };

  return BitField;
}();

BitField.MAXBIT = 1 << 31;
BitField.next = 1;
BitField.names = new Map();
exports.BitField = BitField;

function BitFieldClass() {
  var names = [];

  for (var _i = 0; _i < arguments.length; _i++) {
    names[_i] = arguments[_i];
  }

  var Bits = function (_super) {
    __extends(class_1, _super);

    function class_1() {
      return _super !== null && _super.apply(this, arguments) || this;
    }

    return class_1;
  }(BitField);

  Bits.allocate.apply(Bits, __spread(names));
  return Bits;
}

exports.BitFieldClass = BitFieldClass;

/***/ }),
/* 401 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __assign = this && this.__assign || Object.assign || function (t) {
  for (var s, i = 1, n = arguments.length; i < n; i++) {
    s = arguments[i];

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  }

  return t;
};

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

var __values = this && this.__values || function (o) {
  var m = typeof Symbol === "function" && o[Symbol.iterator],
      i = 0;
  if (m) return m.call(o);
  return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MathDocument_js_1 = __webpack_require__(104);

var Options_js_1 = __webpack_require__(10);

var HTMLMathItem_js_1 = __webpack_require__(402);

var HTMLMathList_js_1 = __webpack_require__(403);

var HTMLDomStrings_js_1 = __webpack_require__(404);

var MathItem_js_1 = __webpack_require__(33);

var HTMLDocument = function (_super) {
  __extends(HTMLDocument, _super);

  function HTMLDocument(document, adaptor, options) {
    var _this = this;

    var _a = __read(Options_js_1.separateOptions(options, HTMLDomStrings_js_1.HTMLDomStrings.OPTIONS), 2),
        html = _a[0],
        dom = _a[1];

    _this = _super.call(this, document, adaptor, html) || this;
    _this.domStrings = _this.options['DomStrings'] || new HTMLDomStrings_js_1.HTMLDomStrings(dom);
    _this.domStrings.adaptor = adaptor;
    return _this;
  }

  HTMLDocument.prototype.findPosition = function (N, index, delim, nodes) {
    try {
      for (var _a = __values(nodes[N]), _b = _a.next(); !_b.done; _b = _a.next()) {
        var list = _b.value;

        var _c = __read(list, 2),
            node = _c[0],
            n = _c[1];

        if (index <= n) {
          return {
            node: node,
            n: index,
            delim: delim
          };
        }

        index -= n;
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    return {
      node: null,
      n: 0,
      delim: delim
    };

    var e_1, _d;
  };

  HTMLDocument.prototype.mathItem = function (item, jax, nodes) {
    var math = item.math;
    var start = this.findPosition(item.n, item.start.n, item.open, nodes);
    var end = this.findPosition(item.n, item.end.n, item.close, nodes);
    return new this.options.MathItem(math, jax, item.display, start, end);
  };

  HTMLDocument.prototype.findMath = function (options) {
    if (!this.processed.isSet('findMath')) {
      this.adaptor.document = this.document;
      options = Options_js_1.userOptions({
        elements: [this.adaptor.body(this.document)]
      }, options);

      try {
        for (var _a = __values(this.adaptor.getElements(options['elements'], this.document)), _b = _a.next(); !_b.done; _b = _a.next()) {
          var container = _b.value;

          var _c = __read([null, null], 2),
              strings = _c[0],
              nodes = _c[1];

          try {
            for (var _d = __values(this.inputJax), _e = _d.next(); !_e.done; _e = _d.next()) {
              var jax = _e.value;
              var list = new this.options['MathList']();

              if (jax.processStrings) {
                if (strings === null) {
                  _f = __read(this.domStrings.find(container), 2), strings = _f[0], nodes = _f[1];
                }

                try {
                  for (var _g = __values(jax.findMath(strings)), _h = _g.next(); !_h.done; _h = _g.next()) {
                    var math = _h.value;
                    list.push(this.mathItem(math, jax, nodes));
                  }
                } catch (e_2_1) {
                  e_2 = {
                    error: e_2_1
                  };
                } finally {
                  try {
                    if (_h && !_h.done && (_j = _g.return)) _j.call(_g);
                  } finally {
                    if (e_2) throw e_2.error;
                  }
                }
              } else {
                try {
                  for (var _k = __values(jax.findMath(container)), _l = _k.next(); !_l.done; _l = _k.next()) {
                    var math = _l.value;
                    var item = new this.options.MathItem(math.math, jax, math.display, math.start, math.end);
                    list.push(item);
                  }
                } catch (e_3_1) {
                  e_3 = {
                    error: e_3_1
                  };
                } finally {
                  try {
                    if (_l && !_l.done && (_m = _k.return)) _m.call(_k);
                  } finally {
                    if (e_3) throw e_3.error;
                  }
                }
              }

              this.math.merge(list);
            }
          } catch (e_4_1) {
            e_4 = {
              error: e_4_1
            };
          } finally {
            try {
              if (_e && !_e.done && (_o = _d.return)) _o.call(_d);
            } finally {
              if (e_4) throw e_4.error;
            }
          }
        }
      } catch (e_5_1) {
        e_5 = {
          error: e_5_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_p = _a.return)) _p.call(_a);
        } finally {
          if (e_5) throw e_5.error;
        }
      }

      this.processed.set('findMath');
    }

    return this;

    var e_5, _p, e_4, _o, _f, e_2, _j, e_3, _m;
  };

  HTMLDocument.prototype.updateDocument = function () {
    if (!this.processed.isSet('updateDocument')) {
      this.addPageElements();
      this.addStyleSheet();

      _super.prototype.updateDocument.call(this);

      this.processed.set('updateDocument');
    }

    return this;
  };

  HTMLDocument.prototype.addPageElements = function () {
    var body = this.adaptor.body(this.document);
    var node = this.documentPageElements();

    if (node) {
      this.adaptor.append(body, node);
    }
  };

  HTMLDocument.prototype.addStyleSheet = function () {
    var sheet = this.documentStyleSheet();

    if (sheet) {
      var head = this.adaptor.head(this.document);
      var styles = this.findSheet(head, this.adaptor.getAttribute(sheet, 'id'));

      if (styles) {
        this.adaptor.replace(sheet, styles);
      } else {
        this.adaptor.append(head, sheet);
      }
    }
  };

  HTMLDocument.prototype.findSheet = function (head, id) {
    if (id) {
      try {
        for (var _a = __values(this.adaptor.tags(head, 'style')), _b = _a.next(); !_b.done; _b = _a.next()) {
          var sheet = _b.value;

          if (this.adaptor.getAttribute(sheet, 'id') === id) {
            return sheet;
          }
        }
      } catch (e_6_1) {
        e_6 = {
          error: e_6_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_6) throw e_6.error;
        }
      }
    }

    return null;

    var e_6, _c;
  };

  HTMLDocument.prototype.removeFromDocument = function (restore) {
    if (restore === void 0) {
      restore = false;
    }

    if (this.processed.isSet('updateDocument')) {
      try {
        for (var _a = __values(this.math), _b = _a.next(); !_b.done; _b = _a.next()) {
          var math = _b.value;

          if (math.state() >= MathItem_js_1.STATE.INSERTED) {
            math.state(MathItem_js_1.STATE.TYPESET, restore);
          }
        }
      } catch (e_7_1) {
        e_7 = {
          error: e_7_1
        };
      } finally {
        try {
          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
        } finally {
          if (e_7) throw e_7.error;
        }
      }
    }

    this.processed.clear('updateDocument');
    return this;

    var e_7, _c;
  };

  HTMLDocument.prototype.documentStyleSheet = function () {
    return this.outputJax.styleSheet(this);
  };

  HTMLDocument.prototype.documentPageElements = function () {
    return this.outputJax.pageElements(this);
  };

  return HTMLDocument;
}(MathDocument_js_1.AbstractMathDocument);

HTMLDocument.KIND = 'HTML';
HTMLDocument.OPTIONS = __assign({}, MathDocument_js_1.AbstractMathDocument.OPTIONS, {
  renderActions: Options_js_1.expandable(__assign({}, MathDocument_js_1.AbstractMathDocument.OPTIONS.renderActions, {
    styles: [MathItem_js_1.STATE.INSERTED + 1, '', 'updateStyleSheet', false]
  })),
  MathList: HTMLMathList_js_1.HTMLMathList,
  MathItem: HTMLMathItem_js_1.HTMLMathItem,
  DomStrings: null
});
exports.HTMLDocument = HTMLDocument;

/***/ }),
/* 402 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MathItem_js_1 = __webpack_require__(33);

var HTMLMathItem = function (_super) {
  __extends(HTMLMathItem, _super);

  function HTMLMathItem(math, jax, display, start, end) {
    if (display === void 0) {
      display = true;
    }

    if (start === void 0) {
      start = {
        node: null,
        n: 0,
        delim: ''
      };
    }

    if (end === void 0) {
      end = {
        node: null,
        n: 0,
        delim: ''
      };
    }

    return _super.call(this, math, jax, display, start, end) || this;
  }

  Object.defineProperty(HTMLMathItem.prototype, "adaptor", {
    get: function () {
      return this.inputJax.adaptor;
    },
    enumerable: true,
    configurable: true
  });

  HTMLMathItem.prototype.updateDocument = function (html) {
    if (this.state() < MathItem_js_1.STATE.INSERTED) {
      if (this.inputJax.processStrings) {
        var node = this.start.node;

        if (node === this.end.node) {
          if (this.end.n && this.end.n < this.adaptor.value(this.end.node).length) {
            this.adaptor.split(this.end.node, this.end.n);
          }

          if (this.start.n) {
            node = this.adaptor.split(this.start.node, this.start.n);
          }

          this.adaptor.replace(this.typesetRoot, node);
        } else {
          if (this.start.n) {
            node = this.adaptor.split(node, this.start.n);
          }

          while (node !== this.end.node) {
            var next = this.adaptor.next(node);
            this.adaptor.remove(node);
            node = next;
          }

          this.adaptor.insert(this.typesetRoot, node);

          if (this.end.n < this.adaptor.value(node).length) {
            this.adaptor.split(node, this.end.n);
          }

          this.adaptor.remove(node);
        }
      } else {
        this.adaptor.replace(this.typesetRoot, this.start.node);
      }

      this.start.node = this.end.node = this.typesetRoot;
      this.start.n = this.end.n = 0;
      this.state(MathItem_js_1.STATE.INSERTED);
    }
  };

  HTMLMathItem.prototype.updateStyleSheet = function (document) {
    document.addStyleSheet();
  };

  HTMLMathItem.prototype.removeFromDocument = function (restore) {
    if (restore === void 0) {
      restore = false;
    }

    if (this.state() >= MathItem_js_1.STATE.TYPESET) {
      var node = this.start.node;
      var math = this.adaptor.text('');

      if (restore) {
        var text = this.start.delim + this.math + this.end.delim;

        if (this.inputJax.processStrings) {
          math = this.adaptor.text(text);
        } else {
          var doc = this.adaptor.parse(text, 'text/html');
          math = this.adaptor.firstChild(this.adaptor.body(doc));
        }
      }

      this.adaptor.replace(math, node);
      this.start.node = this.end.node = math;
      this.start.n = this.end.n = 0;
    }
  };

  return HTMLMathItem;
}(MathItem_js_1.AbstractMathItem);

exports.HTMLMathItem = HTMLMathItem;

/***/ }),
/* 403 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __extends = this && this.__extends || function () {
  var extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var MathList_js_1 = __webpack_require__(105);

var HTMLMathList = function (_super) {
  __extends(HTMLMathList, _super);

  function HTMLMathList() {
    return _super !== null && _super.apply(this, arguments) || this;
  }

  return HTMLMathList;
}(MathList_js_1.AbstractMathList);

exports.HTMLMathList = HTMLMathList;

/***/ }),
/* 404 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var Options_js_1 = __webpack_require__(10);

var HTMLDomStrings = function () {
  function HTMLDomStrings(options) {
    if (options === void 0) {
      options = null;
    }

    var CLASS = this.constructor;
    this.options = Options_js_1.userOptions(Options_js_1.defaultOptions({}, CLASS.OPTIONS), options);
    this.init();
    this.getPatterns();
  }

  HTMLDomStrings.prototype.init = function () {
    this.strings = [];
    this.string = '';
    this.snodes = [];
    this.nodes = [];
    this.stack = [];
  };

  HTMLDomStrings.prototype.getPatterns = function () {
    var skip = Options_js_1.makeArray(this.options['skipTags']);
    var ignore = Options_js_1.makeArray(this.options['ignoreClass']);
    var process = Options_js_1.makeArray(this.options['processClass']);
    this.skipTags = new RegExp('^(?:' + skip.join('|') + ')$', 'i');
    this.ignoreClass = new RegExp('(?:^| )(?:' + ignore.join('|') + ')(?: |$)');
    this.processClass = new RegExp('(?:^| )(?:' + process + ')(?: |$)');
  };

  HTMLDomStrings.prototype.pushString = function () {
    if (this.string.match(/\S/)) {
      this.strings.push(this.string);
      this.nodes.push(this.snodes);
    }

    this.string = '';
    this.snodes = [];
  };

  HTMLDomStrings.prototype.extendString = function (node, text) {
    this.snodes.push([node, text.length]);
    this.string += text;
  };

  HTMLDomStrings.prototype.handleText = function (node, ignore) {
    if (!ignore) {
      this.extendString(node, this.adaptor.value(node));
    }

    return this.adaptor.next(node);
  };

  HTMLDomStrings.prototype.handleTag = function (node, ignore) {
    if (!ignore) {
      var text = this.options['includeTags'][this.adaptor.kind(node)];
      this.extendString(node, text);
    }

    return this.adaptor.next(node);
  };

  HTMLDomStrings.prototype.handleContainer = function (node, ignore) {
    this.pushString();
    var cname = this.adaptor.getAttribute(node, 'class') || '';
    var tname = this.adaptor.kind(node) || '';
    var process = this.processClass.exec(cname);
    var next = node;

    if (this.adaptor.firstChild(node) && !this.adaptor.getAttribute(node, 'data-MJX') && (process || !this.skipTags.exec(tname))) {
      if (this.adaptor.next(node)) {
        this.stack.push([this.adaptor.next(node), ignore]);
      }

      next = this.adaptor.firstChild(node);
      ignore = (ignore || this.ignoreClass.exec(cname)) && !process;
    } else {
      next = this.adaptor.next(node);
    }

    return [next, ignore];
  };

  HTMLDomStrings.prototype.find = function (node) {
    this.init();
    var stop = this.adaptor.next(node);
    var ignore = false;
    var include = this.options['includeTags'];

    while (node && node !== stop) {
      if (this.adaptor.kind(node) === '#text') {
        node = this.handleText(node, ignore);
      } else if (include[this.adaptor.kind(node)] !== undefined) {
        node = this.handleTag(node, ignore);
      } else {
        _a = __read(this.handleContainer(node, ignore), 2), node = _a[0], ignore = _a[1];
      }

      if (!node && this.stack.length) {
        this.pushString();
        _b = __read(this.stack.pop(), 2), node = _b[0], ignore = _b[1];
      }
    }

    this.pushString();
    var result = [this.strings, this.nodes];
    this.init();
    return result;

    var _a, _b;
  };

  return HTMLDomStrings;
}();

HTMLDomStrings.OPTIONS = {
  skipTags: ['script', 'noscript', 'style', 'textarea', 'pre', 'code', 'annotation', 'annotation-xml'],
  includeTags: {
    br: '\n',
    wbr: '',
    '#comment': ''
  },
  ignoreClass: 'tex2jax_ignore',
  processClass: 'tex2jax_process'
};
exports.HTMLDomStrings = HTMLDomStrings;

/***/ }),
/* 405 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(406);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 406 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td,article,aside,canvas,details,embed,figure,figcaption,footer,header,hgroup,menu,nav,output,ruby,section,summary,time,mark,audio,video{margin:0;padding:0;border:0;font-size:100%;font:inherit;vertical-align:baseline}article,aside,details,figcaption,figure,footer,header,hgroup,menu,nav,section{display:block}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}table{border-collapse:collapse;border-spacing:0}", ""]);



/***/ }),
/* 407 */
/***/ (function(module, exports) {

/**
 * When source maps are enabled, `style-loader` uses a link element with a data-uri to
 * embed the css on the page. This breaks all relative urls because now they are relative to a
 * bundle instead of the current page.
 *
 * One solution is to only use full urls, but that may be impossible.
 *
 * Instead, this function "fixes" the relative urls to be absolute according to the current page location.
 *
 * A rudimentary test suite is located at `test/fixUrls.js` and can be run via the `npm test` command.
 *
 */
module.exports = function (css) {
  // get current location
  var location = typeof window !== "undefined" && window.location;

  if (!location) {
    throw new Error("fixUrls requires window.location");
  } // blank or null?


  if (!css || typeof css !== "string") {
    return css;
  }

  var baseUrl = location.protocol + "//" + location.host;
  var currentDir = baseUrl + location.pathname.replace(/\/[^\/]*$/, "/"); // convert each url(...)

  /*
  This regular expression is just a way to recursively match brackets within
  a string.
  	 /url\s*\(  = Match on the word "url" with any whitespace after it and then a parens
     (  = Start a capturing group
       (?:  = Start a non-capturing group
           [^)(]  = Match anything that isn't a parentheses
           |  = OR
           \(  = Match a start parentheses
               (?:  = Start another non-capturing groups
                   [^)(]+  = Match anything that isn't a parentheses
                   |  = OR
                   \(  = Match a start parentheses
                       [^)(]*  = Match anything that isn't a parentheses
                   \)  = Match a end parentheses
               )  = End Group
               *\) = Match anything and then a close parens
           )  = Close non-capturing group
           *  = Match anything
        )  = Close capturing group
   \)  = Match a close parens
  	 /gi  = Get all matches, not the first.  Be case insensitive.
   */

  var fixedCss = css.replace(/url\s*\(((?:[^)(]|\((?:[^)(]+|\([^)(]*\))*\))*)\)/gi, function (fullMatch, origUrl) {
    // strip quotes (if they exist)
    var unquotedOrigUrl = origUrl.trim().replace(/^"(.*)"$/, function (o, $1) {
      return $1;
    }).replace(/^'(.*)'$/, function (o, $1) {
      return $1;
    }); // already a full url? no change

    if (/^(#|data:|http:\/\/|https:\/\/|file:\/\/\/|\s*$)/i.test(unquotedOrigUrl)) {
      return fullMatch;
    } // convert the url to a full url


    var newUrl;

    if (unquotedOrigUrl.indexOf("//") === 0) {
      //TODO: should we add protocol?
      newUrl = unquotedOrigUrl;
    } else if (unquotedOrigUrl.indexOf("/") === 0) {
      // path should be relative to the base url
      newUrl = baseUrl + unquotedOrigUrl; // already starts with '/'
    } else {
      // path should be relative to current directory
      newUrl = currentDir + unquotedOrigUrl.replace(/^\.\//, ""); // Strip leading './'
    } // send back the fixed url(...)


    return "url(" + JSON.stringify(newUrl) + ")";
  }); // send back the fixed css

  return fixedCss;
};

/***/ }),
/* 408 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(409);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 409 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/*!\n * Bootstrap Reboot v4.0.0-beta.3 (https://getbootstrap.com)\n * Copyright 2011-2017 The Bootstrap Authors\n * Copyright 2011-2017 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)\n */*,::after,::before{box-sizing:border-box}html{font-family:sans-serif;line-height:1.15;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%;-ms-overflow-style:scrollbar;-webkit-tap-highlight-color:transparent}@-ms-viewport{width:device-width}article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}body{margin:0;font-family:-apple-system,BlinkMacSystemFont,\"Segoe UI\",Roboto,\"Helvetica Neue\",Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\",\"Segoe UI Symbol\";font-size:1rem;font-weight:400;line-height:1.5;color:#212529;text-align:left;background-color:#fff}[tabindex=\"-1\"]:focus{outline:0!important}hr{box-sizing:content-box;height:0;overflow:visible}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem}p{margin-top:0;margin-bottom:1rem}abbr[data-original-title],abbr[title]{text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted;cursor:help;border-bottom:0}address{margin-bottom:1rem;font-style:normal;line-height:inherit}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}dfn{font-style:italic}b,strong{font-weight:bolder}small{font-size:80%}sub,sup{position:relative;font-size:75%;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:#007bff;text-decoration:none;background-color:transparent;-webkit-text-decoration-skip:objects}a:hover{color:#0056b3;text-decoration:underline}a:not([href]):not([tabindex]){color:inherit;text-decoration:none}a:not([href]):not([tabindex]):focus,a:not([href]):not([tabindex]):hover{color:inherit;text-decoration:none}a:not([href]):not([tabindex]):focus{outline:0}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}pre{margin-top:0;margin-bottom:1rem;overflow:auto;-ms-overflow-style:scrollbar}figure{margin:0 0 1rem}img{vertical-align:middle;border-style:none}svg:not(:root){overflow:hidden}[role=button],a,area,button,input:not([type=range]),label,select,summary,textarea{-ms-touch-action:manipulation;touch-action:manipulation}table{border-collapse:collapse}caption{padding-top:.75rem;padding-bottom:.75rem;color:#868e96;text-align:left;caption-side:bottom}th{text-align:inherit}label{display:inline-block;margin-bottom:.5rem}button{border-radius:0}button:focus{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,input{overflow:visible}button,select{text-transform:none}[type=reset],[type=submit],button,html [type=button]{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{padding:0;border-style:none}input[type=checkbox],input[type=radio]{box-sizing:border-box;padding:0}input[type=date],input[type=datetime-local],input[type=month],input[type=time]{-webkit-appearance:listbox}textarea{overflow:auto;resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{display:block;width:100%;max-width:100%;padding:0;margin-bottom:.5rem;font-size:1.5rem;line-height:inherit;color:inherit;white-space:normal}progress{vertical-align:baseline}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:none}[type=search]::-webkit-search-cancel-button,[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}summary{display:list-item;cursor:pointer}template{display:none}[hidden]{display:none!important}", ""]);



/***/ }),
/* 410 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(411);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 411 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/*\n// css selectors\n// ref: [base css ~ sss.css] https://github.com/Thiht/sss/blob/master/sss.css\n// see http://www.cssfontstack.com for font stack info\n*/\n\n/* spell-checker:words bidirectionality frameset inlines nobr noframes */\n\n/* W3C recommended default CSS ~ from https://www.w3.org/TR/CSS21/sample.html @@ http://archive.is/U2UF */\nhtml, address,\nblockquote,\nbody, dd, div,\ndl, dt, fieldset, form,\nframe, frameset,\nh1, h2, h3, h4,\nh5, h6, noframes,\nol, p, ul, center,\ndir, hr, menu, pre   { display: block; unicode-bidi: embed }\nli              { display: list-item }\nhead            { display: none }\ntable           { display: table }\ntr              { display: table-row }\nthead           { display: table-header-group }\ntbody           { display: table-row-group }\ntfoot           { display: table-footer-group }\ncol             { display: table-column }\ncolgroup        { display: table-column-group }\ntd, th          { display: table-cell }\ncaption         { display: table-caption }\nth              { font-weight: bolder; text-align: center }\ncaption         { text-align: center }\nbody            { margin: 8px }\nh1              { font-size: 2em; margin: .67em 0 }\nh2              { font-size: 1.5em; margin: .75em 0 }\nh3              { font-size: 1.17em; margin: .83em 0 }\nh4, p,\nblockquote, ul,\nfieldset, form,\nol, dl, dir,\nmenu            { margin: 1.12em 0 }\nh5              { font-size: .83em; margin: 1.5em 0 }\nh6              { font-size: .75em; margin: 1.67em 0 }\nh1, h2, h3, h4,\nh5, h6, b,\nstrong          { font-weight: bolder }\nblockquote      { margin-left: 40px; margin-right: 40px }\ni, cite, em,\nvar, address    { font-style: italic }\npre, tt, code,\nkbd, samp       { font-family: monospace }\npre             { white-space: pre }\nbutton, textarea,\ninput, select   { display: inline-block }\nbig             { font-size: 1.17em }\nsmall, sub, sup { font-size: .83em }\nsub             { vertical-align: sub }\nsup             { vertical-align: super }\ntable           { border-spacing: 2px; }\nthead, tbody,\ntfoot           { vertical-align: middle }\ntd, th, tr      { vertical-align: inherit }\ns, strike, del  { text-decoration: line-through }\nhr              { border: 1px inset }\nol, ul, dir,\nmenu, dd        { margin-left: 40px }\nol              { list-style-type: decimal }\nol ul, ul ol,\nul ul, ol ol    { margin-top: 0; margin-bottom: 0 }\nu, ins          { text-decoration: underline }\nbr:before       { content: \"\\A\"; white-space: pre-line }\ncenter          { text-align: center }\n:link, :visited { text-decoration: underline }\n:focus          { outline: thin dotted invert }\n\n/* Begin bidirectionality settings (do not change) */\nBDO[DIR=\"ltr\"]  { direction: ltr; unicode-bidi: bidi-override }\nBDO[DIR=\"rtl\"]  { direction: rtl; unicode-bidi: bidi-override }\n\n*[DIR=\"ltr\"]    { direction: ltr; unicode-bidi: embed }\n*[DIR=\"rtl\"]    { direction: rtl; unicode-bidi: embed }\n\n@media print {\n  h1            { page-break-before: always }\n  h1, h2, h3,\n  h4, h5, h6    { page-break-after: avoid }\n  ul, ol, dl    { page-break-before: avoid }\n}\n\n/* from Firefox default CSS @ https://hg.mozilla.org/mozilla-central/file/tip/layout/style/res/html.css @@ http://archive.is/apSZc*/\n/* inlines */\n\nq:before {\n  content: open-quote;\n}\n\nq:after {\n  content: close-quote;\n}\n\nb, strong {\n  font-weight: bolder;\n}\n\ni, cite, em, var, dfn {\n  font-style: italic;\n}\n\ntt, code, kbd, samp {\n  font-family: -moz-fixed;\n}\n\nu, ins {\n  text-decoration: underline;\n}\n\ns, strike, del {\n  text-decoration: line-through;\n}\n\nbig {\n  font-size: larger;\n}\n\nsmall {\n  font-size: smaller;\n}\n\nsub {\n  vertical-align: sub;\n  font-size: smaller;\n  line-height: normal;\n}\n\nsup {\n  vertical-align: super;\n  font-size: smaller;\n  line-height: normal;\n}\n\nnobr {\n  white-space: nowrap;\n}\n\nmark {\n  background: yellow;\n  color: black;\n}\n", ""]);



/***/ }),
/* 412 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(413);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 413 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/* ## Fonts */\n\n/* spell-checker:ignore woff */\n\n/* ref: https://css-tricks.com/snippets/css/using-font-face @@ http://archive.is/WWoV9 */\n\n/*\nMerriweather\nMerriweather Sans\nFira Sans\nFira Sans Condensed\nFira Code\nLora\nInconsolata\n*/\n\n/* ### Merriweather ; from <https://fonts.googleapis.com/css?family=Merriweather:l,li,r,i,b,bi,black,blackitalic> */\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Merriweather Light'), local('Merriweather-Light'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6nrpPmMW7T3WCII-UZW2GGCw.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Merriweather Light'), local('Merriweather-Light'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6nqAAODQ6hKuKTT6yBk7tJss.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Merriweather Light'), local('Merriweather-Light'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6nhLwFvNxpkIoVzlXSkPSYkA.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Merriweather Light'), local('Merriweather-Light'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6nk4GofcKVZz6wtzX_QUIqsI.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Merriweather'), local('Merriweather-Regular'), url(https://fonts.gstatic.com/s/merriweather/v15/RFda8w1V0eDZheqfcyQ4EK-j2U0lmluP9RWlSytm3ho.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Merriweather'), local('Merriweather-Regular'), url(https://fonts.gstatic.com/s/merriweather/v15/RFda8w1V0eDZheqfcyQ4EJX5f-9o1vgP2EXwfjgl7AY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Merriweather'), local('Merriweather-Regular'), url(https://fonts.gstatic.com/s/merriweather/v15/RFda8w1V0eDZheqfcyQ4ED0LW-43aMEzIO6XUTLjad8.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Merriweather'), local('Merriweather-Regular'), url(https://fonts.gstatic.com/s/merriweather/v15/RFda8w1V0eDZheqfcyQ4EOgdm0LZdjqr5-oayXSOefg.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Merriweather Bold'), local('Merriweather-Bold'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6nrPaLDTSXeXFRL0dx0NiHII.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Merriweather Bold'), local('Merriweather-Bold'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6ntkZ6ofoXFVR94fBb90XSvU.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Merriweather Bold'), local('Merriweather-Bold'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6nuIaMZP5eRGvEWe_CNIU_oY.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Merriweather Bold'), local('Merriweather-Bold'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6nnNuWYKPzoeKl5tYj8yhly0.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Merriweather Black'), local('Merriweather-Black'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6npRmMktGnN9fECZcESJ2wdY.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Merriweather Black'), local('Merriweather-Black'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6nhYk6kXjxbl9hCl_j54B6tY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Merriweather Black'), local('Merriweather-Black'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6nu8B3NNHiE7lEpFTE0KxUWk.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Merriweather Black'), local('Merriweather-Black'), url(https://fonts.gstatic.com/s/merriweather/v15/ZvcMqxEwPfh2qDWBPxn6ntDLwwZd-mS_8JqJ_KGXwxs.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Merriweather Light Italic'), local('Merriweather-LightItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIFvxabc8-Ua_u_bDyl2V6ao.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Merriweather Light Italic'), local('Merriweather-LightItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwII_1JgVyIQZ7vlaYT5eo8zo.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Merriweather Light Italic'), local('Merriweather-LightItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIJpID8tihKRMKfpfDQ5OzSE.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Merriweather Light Italic'), local('Merriweather-LightItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIHM1hBkL4m68a-ReB_y0NYc.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Merriweather Italic'), local('Merriweather-Italic'), url(https://fonts.gstatic.com/s/merriweather/v15/So5lHxHT37p2SS4-t60SlJX7FfjVuZf3W7tKvrYzIk8.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Merriweather Italic'), local('Merriweather-Italic'), url(https://fonts.gstatic.com/s/merriweather/v15/So5lHxHT37p2SS4-t60SlOb988d5RHZc66psPc8fYGQ.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Merriweather Italic'), local('Merriweather-Italic'), url(https://fonts.gstatic.com/s/merriweather/v15/So5lHxHT37p2SS4-t60SlMAbIeegqMtwkwn2ZHUR4Nk.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Merriweather Italic'), local('Merriweather-Italic'), url(https://fonts.gstatic.com/s/merriweather/v15/So5lHxHT37p2SS4-t60SlBMBlNeli-0RcAdOFWWLdxQ.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Merriweather Bold Italic'), local('Merriweather-BoldItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIEVUTRPtBn3BSc_rW_ryx7U.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Merriweather Bold Italic'), local('Merriweather-BoldItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIDaggPqPUlqZtH2DnDrcMQE.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Merriweather Bold Italic'), local('Merriweather-BoldItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIOR3LJ09PnibSpWhv21tZ8w.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Merriweather Bold Italic'), local('Merriweather-BoldItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIEcqRxak6Wc5LUVz-l064SE.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Merriweather Black Italic'), local('Merriweather-BlackItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwICR62gPmgX9pXMEmx1A9y0c.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Merriweather Black Italic'), local('Merriweather-BlackItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIMbbw6pOSxajs_BxQ1hzVho.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Merriweather Black Italic'), local('Merriweather-BlackItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIOSQfM42FHfzkXTnQR6vRvg.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Merriweather Black Italic'), local('Merriweather-BlackItalic'), url(https://fonts.gstatic.com/s/merriweather/v15/EYh7Vl4ywhowqULgRdYwIN4rWrnaUG5GaGDO0TOZR8c.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n\n/* ### Merriweather Sans ; from <https://fonts.googleapis.com/css?family=Merriweather+Sans:l,li,r,i,b,bi,extrabold,extrabolditalic> */\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Merriweather Sans Light'), local('MerriweatherSans-Light'), url(https://fonts.gstatic.com/s/merriweathersans/v8/6LmGj5dOJopQKEkt88GowSenBolNkDBl6TBgAIdCkYw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Merriweather Sans Light'), local('MerriweatherSans-Light'), url(https://fonts.gstatic.com/s/merriweathersans/v8/6LmGj5dOJopQKEkt88GowQaqY1RzDqUCoj4OhtiyHDU.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Merriweather Sans'), local('MerriweatherSans-Regular'), url(https://fonts.gstatic.com/s/merriweathersans/v8/AKu1CjQ4qnV8MUltkAX3sD48MEBspdEKklcQvcIk8pU.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Merriweather Sans'), local('MerriweatherSans-Regular'), url(https://fonts.gstatic.com/s/merriweathersans/v8/AKu1CjQ4qnV8MUltkAX3sMZ4HySTEWshgORbPp2tk8k.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Merriweather Sans Bold'), local('MerriweatherSans-Bold'), url(https://fonts.gstatic.com/s/merriweathersans/v8/6LmGj5dOJopQKEkt88GowdqgfwRMvy6EDFppit6Do18.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Merriweather Sans Bold'), local('MerriweatherSans-Bold'), url(https://fonts.gstatic.com/s/merriweathersans/v8/6LmGj5dOJopQKEkt88GowbvMLSVzqOGkoxdgTSsKqWM.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Merriweather Sans ExtraBold'), local('MerriweatherSans-ExtraBold'), url(https://fonts.gstatic.com/s/merriweathersans/v8/6LmGj5dOJopQKEkt88GowSvX6IlkcPQx4hJX-sT8odI.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Merriweather Sans ExtraBold'), local('MerriweatherSans-ExtraBold'), url(https://fonts.gstatic.com/s/merriweathersans/v8/6LmGj5dOJopQKEkt88GowSdYkh4h72QvAQSOPbRA0ug.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Merriweather Sans Light Italic'), local('MerriweatherSans-LightItalic'), url(https://fonts.gstatic.com/s/merriweathersans/v8/nAqt4hiqwq3tzCecpgPmVZQnJ6jNVR5ny37t9nSm1vT3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Merriweather Sans Light Italic'), local('MerriweatherSans-LightItalic'), url(https://fonts.gstatic.com/s/merriweathersans/v8/nAqt4hiqwq3tzCecpgPmVVyxQjJdVDgrQF1Nc7eshrI.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Merriweather Sans Italic'), local('MerriweatherSans-Italic'), url(https://fonts.gstatic.com/s/merriweathersans/v8/3Mz4hOHzs2npRMG3B1ascb0czo27AklEAaHz4fJ0oZE.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Merriweather Sans Italic'), local('MerriweatherSans-Italic'), url(https://fonts.gstatic.com/s/merriweathersans/v8/3Mz4hOHzs2npRMG3B1ascefU2ka509O1odprhyXBUMU.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Merriweather Sans Bold Italic'), local('MerriweatherSans-BoldItalic'), url(https://fonts.gstatic.com/s/merriweathersans/v8/nAqt4hiqwq3tzCecpgPmVRmzdD2i0Yy32wXknJg7uXD3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Merriweather Sans Bold Italic'), local('MerriweatherSans-BoldItalic'), url(https://fonts.gstatic.com/s/merriweathersans/v8/nAqt4hiqwq3tzCecpgPmVafo0sDQ75c9ExQ-26lwTdA.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Merriweather Sans ExtraBold Italic'), local('MerriweatherSans-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/merriweathersans/v8/nAqt4hiqwq3tzCecpgPmVVXghct84AymK6x3dEzytIL3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Merriweather Sans';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Merriweather Sans ExtraBold Italic'), local('MerriweatherSans-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/merriweathersans/v8/nAqt4hiqwq3tzCecpgPmVfrUSW10CwTuVx9PepRx9ls.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n\n/* ### Fira Sans ; from <https://fonts.googleapis.com/css?family=Fira+Sans:extralight,extralightitalic,l,li,r,i,medium,mediumitalic,semibold,semibolditalic,b,bi,extrabold,extrabolditalic,black,blackitalic>\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight'), local('FiraSans-ExtraLight'), url(https://fonts.gstatic.com/s/firasans/v7/H2QtVYRshA1CFy63P7ykZ6-j2U0lmluP9RWlSytm3ho.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight'), local('FiraSans-ExtraLight'), url(https://fonts.gstatic.com/s/firasans/v7/H2QtVYRshA1CFy63P7ykZ5X5f-9o1vgP2EXwfjgl7AY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight'), local('FiraSans-ExtraLight'), url(https://fonts.gstatic.com/s/firasans/v7/H2QtVYRshA1CFy63P7ykZxWV49_lSm1NYrwo-zkhivY.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight'), local('FiraSans-ExtraLight'), url(https://fonts.gstatic.com/s/firasans/v7/H2QtVYRshA1CFy63P7ykZ6aRobkAwv3vxw3jMhVENGA.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight'), local('FiraSans-ExtraLight'), url(https://fonts.gstatic.com/s/firasans/v7/H2QtVYRshA1CFy63P7ykZ_8zf_FOSsgRmwsS7Aa9k2w.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight'), local('FiraSans-ExtraLight'), url(https://fonts.gstatic.com/s/firasans/v7/H2QtVYRshA1CFy63P7ykZz0LW-43aMEzIO6XUTLjad8.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight'), local('FiraSans-ExtraLight'), url(https://fonts.gstatic.com/s/firasans/v7/H2QtVYRshA1CFy63P7ykZ-gdm0LZdjqr5-oayXSOefg.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Light'), local('FiraSans-Light'), url(https://fonts.gstatic.com/s/firasans/v7/VTBnrK42EiOBncVyQXZ7j6-j2U0lmluP9RWlSytm3ho.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Light'), local('FiraSans-Light'), url(https://fonts.gstatic.com/s/firasans/v7/VTBnrK42EiOBncVyQXZ7j5X5f-9o1vgP2EXwfjgl7AY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Light'), local('FiraSans-Light'), url(https://fonts.gstatic.com/s/firasans/v7/VTBnrK42EiOBncVyQXZ7jxWV49_lSm1NYrwo-zkhivY.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Light'), local('FiraSans-Light'), url(https://fonts.gstatic.com/s/firasans/v7/VTBnrK42EiOBncVyQXZ7j6aRobkAwv3vxw3jMhVENGA.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Light'), local('FiraSans-Light'), url(https://fonts.gstatic.com/s/firasans/v7/VTBnrK42EiOBncVyQXZ7j_8zf_FOSsgRmwsS7Aa9k2w.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Light'), local('FiraSans-Light'), url(https://fonts.gstatic.com/s/firasans/v7/VTBnrK42EiOBncVyQXZ7jz0LW-43aMEzIO6XUTLjad8.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Light'), local('FiraSans-Light'), url(https://fonts.gstatic.com/s/firasans/v7/VTBnrK42EiOBncVyQXZ7j-gdm0LZdjqr5-oayXSOefg.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Regular'), local('FiraSans-Regular'), url(https://fonts.gstatic.com/s/firasans/v7/g5Sf_134cAtTKkNnIjIkXxJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Regular'), local('FiraSans-Regular'), url(https://fonts.gstatic.com/s/firasans/v7/T3abUOg4YgfjOby2l-QudhJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Regular'), local('FiraSans-Regular'), url(https://fonts.gstatic.com/s/firasans/v7/yB7tFp5j00CzdUIRV-khUhJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Regular'), local('FiraSans-Regular'), url(https://fonts.gstatic.com/s/firasans/v7/5jAMGMsBXS6xUYEytGcZdBJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Regular'), local('FiraSans-Regular'), url(https://fonts.gstatic.com/s/firasans/v7/BzUSZ4bBt2kmpGGQUA6ZQBJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Regular'), local('FiraSans-Regular'), url(https://fonts.gstatic.com/s/firasans/v7/MIPWVWI_mY_QERxcMVPEwBJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Regular'), local('FiraSans-Regular'), url(https://fonts.gstatic.com/s/firasans/v7/EjsrzDkQUQCDwsBtLpcVQVtXRa8TVwTICgirnJhmVJw.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Medium'), local('FiraSans-Medium'), url(https://fonts.gstatic.com/s/firasans/v7/zM2u8V3CuPVwAAXFQcDi4K-j2U0lmluP9RWlSytm3ho.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Medium'), local('FiraSans-Medium'), url(https://fonts.gstatic.com/s/firasans/v7/zM2u8V3CuPVwAAXFQcDi4JX5f-9o1vgP2EXwfjgl7AY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Medium'), local('FiraSans-Medium'), url(https://fonts.gstatic.com/s/firasans/v7/zM2u8V3CuPVwAAXFQcDi4BWV49_lSm1NYrwo-zkhivY.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Medium'), local('FiraSans-Medium'), url(https://fonts.gstatic.com/s/firasans/v7/zM2u8V3CuPVwAAXFQcDi4KaRobkAwv3vxw3jMhVENGA.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Medium'), local('FiraSans-Medium'), url(https://fonts.gstatic.com/s/firasans/v7/zM2u8V3CuPVwAAXFQcDi4P8zf_FOSsgRmwsS7Aa9k2w.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Medium'), local('FiraSans-Medium'), url(https://fonts.gstatic.com/s/firasans/v7/zM2u8V3CuPVwAAXFQcDi4D0LW-43aMEzIO6XUTLjad8.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Medium'), local('FiraSans-Medium'), url(https://fonts.gstatic.com/s/firasans/v7/zM2u8V3CuPVwAAXFQcDi4Ogdm0LZdjqr5-oayXSOefg.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold'), local('FiraSans-SemiBold'), url(https://fonts.gstatic.com/s/firasans/v7/TPhEsJuyxIEzWtby22btfq-j2U0lmluP9RWlSytm3ho.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold'), local('FiraSans-SemiBold'), url(https://fonts.gstatic.com/s/firasans/v7/TPhEsJuyxIEzWtby22btfpX5f-9o1vgP2EXwfjgl7AY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold'), local('FiraSans-SemiBold'), url(https://fonts.gstatic.com/s/firasans/v7/TPhEsJuyxIEzWtby22btfhWV49_lSm1NYrwo-zkhivY.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold'), local('FiraSans-SemiBold'), url(https://fonts.gstatic.com/s/firasans/v7/TPhEsJuyxIEzWtby22btfqaRobkAwv3vxw3jMhVENGA.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold'), local('FiraSans-SemiBold'), url(https://fonts.gstatic.com/s/firasans/v7/TPhEsJuyxIEzWtby22btfv8zf_FOSsgRmwsS7Aa9k2w.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold'), local('FiraSans-SemiBold'), url(https://fonts.gstatic.com/s/firasans/v7/TPhEsJuyxIEzWtby22btfj0LW-43aMEzIO6XUTLjad8.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold'), local('FiraSans-SemiBold'), url(https://fonts.gstatic.com/s/firasans/v7/TPhEsJuyxIEzWtby22btfugdm0LZdjqr5-oayXSOefg.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Bold'), local('FiraSans-Bold'), url(https://fonts.gstatic.com/s/firasans/v7/DugPdSljmOTocZOR2CItOq-j2U0lmluP9RWlSytm3ho.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Bold'), local('FiraSans-Bold'), url(https://fonts.gstatic.com/s/firasans/v7/DugPdSljmOTocZOR2CItOpX5f-9o1vgP2EXwfjgl7AY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Bold'), local('FiraSans-Bold'), url(https://fonts.gstatic.com/s/firasans/v7/DugPdSljmOTocZOR2CItOhWV49_lSm1NYrwo-zkhivY.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Bold'), local('FiraSans-Bold'), url(https://fonts.gstatic.com/s/firasans/v7/DugPdSljmOTocZOR2CItOqaRobkAwv3vxw3jMhVENGA.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Bold'), local('FiraSans-Bold'), url(https://fonts.gstatic.com/s/firasans/v7/DugPdSljmOTocZOR2CItOv8zf_FOSsgRmwsS7Aa9k2w.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Bold'), local('FiraSans-Bold'), url(https://fonts.gstatic.com/s/firasans/v7/DugPdSljmOTocZOR2CItOj0LW-43aMEzIO6XUTLjad8.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Bold'), local('FiraSans-Bold'), url(https://fonts.gstatic.com/s/firasans/v7/DugPdSljmOTocZOR2CItOugdm0LZdjqr5-oayXSOefg.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold'), local('FiraSans-ExtraBold'), url(https://fonts.gstatic.com/s/firasans/v7/htOw9f-chtELyJuFCkCrFq-j2U0lmluP9RWlSytm3ho.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold'), local('FiraSans-ExtraBold'), url(https://fonts.gstatic.com/s/firasans/v7/htOw9f-chtELyJuFCkCrFpX5f-9o1vgP2EXwfjgl7AY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold'), local('FiraSans-ExtraBold'), url(https://fonts.gstatic.com/s/firasans/v7/htOw9f-chtELyJuFCkCrFhWV49_lSm1NYrwo-zkhivY.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold'), local('FiraSans-ExtraBold'), url(https://fonts.gstatic.com/s/firasans/v7/htOw9f-chtELyJuFCkCrFqaRobkAwv3vxw3jMhVENGA.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold'), local('FiraSans-ExtraBold'), url(https://fonts.gstatic.com/s/firasans/v7/htOw9f-chtELyJuFCkCrFv8zf_FOSsgRmwsS7Aa9k2w.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold'), local('FiraSans-ExtraBold'), url(https://fonts.gstatic.com/s/firasans/v7/htOw9f-chtELyJuFCkCrFj0LW-43aMEzIO6XUTLjad8.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold'), local('FiraSans-ExtraBold'), url(https://fonts.gstatic.com/s/firasans/v7/htOw9f-chtELyJuFCkCrFugdm0LZdjqr5-oayXSOefg.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Black'), local('FiraSans-Black'), url(https://fonts.gstatic.com/s/firasans/v7/rowJfijyp23uW9P2J-sluK-j2U0lmluP9RWlSytm3ho.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Black'), local('FiraSans-Black'), url(https://fonts.gstatic.com/s/firasans/v7/rowJfijyp23uW9P2J-sluJX5f-9o1vgP2EXwfjgl7AY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Black'), local('FiraSans-Black'), url(https://fonts.gstatic.com/s/firasans/v7/rowJfijyp23uW9P2J-sluBWV49_lSm1NYrwo-zkhivY.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Black'), local('FiraSans-Black'), url(https://fonts.gstatic.com/s/firasans/v7/rowJfijyp23uW9P2J-sluKaRobkAwv3vxw3jMhVENGA.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Black'), local('FiraSans-Black'), url(https://fonts.gstatic.com/s/firasans/v7/rowJfijyp23uW9P2J-sluP8zf_FOSsgRmwsS7Aa9k2w.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Black'), local('FiraSans-Black'), url(https://fonts.gstatic.com/s/firasans/v7/rowJfijyp23uW9P2J-sluD0LW-43aMEzIO6XUTLjad8.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Black'), local('FiraSans-Black'), url(https://fonts.gstatic.com/s/firasans/v7/rowJfijyp23uW9P2J-sluOgdm0LZdjqr5-oayXSOefg.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight Italic'), local('FiraSans-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTeYgQyjEezIX6Gnbrx-2zro.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight Italic'), local('FiraSans-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTdRGK6TMhI1LnJLSifHgyso.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight Italic'), local('FiraSans-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTdK5rdWsmZOcDp6zv3b5Tu8.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight Italic'), local('FiraSans-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTdh8Y8tUKh-R-sIXM_PBMxE.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight Italic'), local('FiraSans-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTRvtcl9UNxaIptGTc9_XBNY.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight Italic'), local('FiraSans-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTdueeI3m3pPJrpcOgfCdhVs.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans ExtraLight Italic'), local('FiraSans-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTf-yvr_zg92NT13uHB6uFCI.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Light Italic'), local('FiraSans-LightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTRgVThLs8Y7ETJzDCYFCSLE.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Light Italic'), local('FiraSans-LightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTZiMaisvaUVUsYyVzOmndek.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Light Italic'), local('FiraSans-LightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTbBAWGjcah5Ky0jbCgIwDB8.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Light Italic'), local('FiraSans-LightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTf14vlcfyPYlAcQy2UfDRm4.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Light Italic'), local('FiraSans-LightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTafJul7RR1X4poJgi27uS4w.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Light Italic'), local('FiraSans-LightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTavyPXdneeGd26m9EmFSSWg.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Light Italic'), local('FiraSans-LightItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTUo2lTMeWA_kmIyWrkNCwPc.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Italic'), local('FiraSans-Italic'), url(https://fonts.gstatic.com/s/firasans/v7/QURAmFz4b80g324-oF-UjzTOQ_MqJVwkKsUn0wKzc2I.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Italic'), local('FiraSans-Italic'), url(https://fonts.gstatic.com/s/firasans/v7/QURAmFz4b80g324-oF-UjzUj_cnvWIuuBMVgbX098Mw.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Italic'), local('FiraSans-Italic'), url(https://fonts.gstatic.com/s/firasans/v7/QURAmFz4b80g324-oF-Uj0bcKLIaa1LC45dFaAfauRA.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Italic'), local('FiraSans-Italic'), url(https://fonts.gstatic.com/s/firasans/v7/QURAmFz4b80g324-oF-Uj2o_sUJ8uO4YLWRInS22T3Y.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Italic'), local('FiraSans-Italic'), url(https://fonts.gstatic.com/s/firasans/v7/QURAmFz4b80g324-oF-Uj76up8jxqWt8HVA3mDhkV_0.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Italic'), local('FiraSans-Italic'), url(https://fonts.gstatic.com/s/firasans/v7/QURAmFz4b80g324-oF-UjyYE0-AqJ3nfInTTiDXDjU4.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Italic'), local('FiraSans-Italic'), url(https://fonts.gstatic.com/s/firasans/v7/QURAmFz4b80g324-oF-Uj44P5ICox8Kq3LLUNMylGO4.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Medium Italic'), local('FiraSans-MediumItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTeKfXlfQjcwZMTeE7wI4WGI.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Medium Italic'), local('FiraSans-MediumItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTUtJuoiaQfPpa269V2FDaLo.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Medium Italic'), local('FiraSans-MediumItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTb_PilIG-AM4Aw-a0tUNcnA.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Medium Italic'), local('FiraSans-MediumItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTZ2u1fTOyc-e8Bt1FRZ8XII.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Medium Italic'), local('FiraSans-MediumItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTXdOSIwbEkyw5bZp8Nzw7hU.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Medium Italic'), local('FiraSans-MediumItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTbX8PDrklLOWyWIn-2-AqKA.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Medium Italic'), local('FiraSans-MediumItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTbBojE9J5UnpMtv5N3zfxwk.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold Italic'), local('FiraSans-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTWgpAmOCqD37_tyH_8Ri5MM.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold Italic'), local('FiraSans-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTcPNMTLbnS9uQzHQlYieHUU.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold Italic'), local('FiraSans-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTQyhumQnPMBCoGYhRaNxyyY.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold Italic'), local('FiraSans-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTRUVAXEdVvYDDqrz3aeR0Yc.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold Italic'), local('FiraSans-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTVf4y_3s5bcYyyLIFUSWYUU.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold Italic'), local('FiraSans-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTXywqdtBbUHn3VPgzuFrCy8.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans SemiBold Italic'), local('FiraSans-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTV2umOyRU7PgRiv8DXcgJjk.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Bold Italic'), local('FiraSans-BoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTZ6iIh_FvlUHQwED9Yt5Kbw.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Bold Italic'), local('FiraSans-BoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTS_vZmeiCMnoWNN9rHBYaTc.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Bold Italic'), local('FiraSans-BoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTSFaMxiho_5XQnyRZzQsrZs.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Bold Italic'), local('FiraSans-BoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTQalQocB-__pDVGhF3uS2Ks.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Bold Italic'), local('FiraSans-BoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTWhQUTDJGru-0vvUpABgH8I.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Bold Italic'), local('FiraSans-BoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTejkDdvhIIFj_YMdgqpnSB0.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Bold Italic'), local('FiraSans-BoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTYlIZu-HDpmDIZMigmsroc4.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold Italic'), local('FiraSans-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTSU8QAtQT9M0M1_mbVWrUPc.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold Italic'), local('FiraSans-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTUNaUOL0oYRolx8sebiIY9k.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold Italic'), local('FiraSans-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTYoGEx1DzoxsbCRd2IM2afI.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold Italic'), local('FiraSans-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTXPzCMEhbIaaYiFY6KPniws.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold Italic'), local('FiraSans-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTWqi69zMYkLa7XwlUIemKB4.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold Italic'), local('FiraSans-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTYwYyzpnB4tyYboSwKGmD2g.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans ExtraBold Italic'), local('FiraSans-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTXibbpXgLHK_uTT48UMyjSM.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Black Italic'), local('FiraSans-BlackItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTT3ms2ZYvNIk-NBT0TWd7d8.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Black Italic'), local('FiraSans-BlackItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTSSVcAiWRG34AZh10ouskJM.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Black Italic'), local('FiraSans-BlackItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTdMe8bR2ydf-7TTtdsqQSX8.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Black Italic'), local('FiraSans-BlackItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTcds_PxIKQVWhSolulHOiVA.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Black Italic'), local('FiraSans-BlackItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTbSYYZADbk_6PT7FzZ2GScM.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Black Italic'), local('FiraSans-BlackItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTblR9l3n4ZtVZdCvvDPwi9o.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Black Italic'), local('FiraSans-BlackItalic'), url(https://fonts.gstatic.com/s/firasans/v7/6s0YCA9oCTF6hM60YM-qTcpPZoEQdaDZ3o3Np19rzJk.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n\n/* ### Fira Sans Condensed ; from <https://fonts.googleapis.com/css?family=Fira+Sans+Condensed:extralight,extralightitalic,l,li,r,i,medium,mediumitalic,semibold,semibolditalic,b,bi,extrabold,extrabolditalic,black,blackitalic> */\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight'), local('FiraSansCondensed-ExtraLight'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993N_SeXXnjXSHHSTPhXLIee_3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight'), local('FiraSansCondensed-ExtraLight'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993Pqd12BJNnknoaHQt4QTUYH3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight'), local('FiraSansCondensed-ExtraLight'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993Nb0lkIiyjH6niyaTtd6na73rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight'), local('FiraSansCondensed-ExtraLight'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993JIMDs6isQJohI2icAmyGHr3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight'), local('FiraSansCondensed-ExtraLight'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993M9fvQ2V7dEH1zoXchDeofn3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight'), local('FiraSansCondensed-ExtraLight'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993MbYG2ZBhYH1FrgJUXP3F8v3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight'), local('FiraSansCondensed-ExtraLight'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993OdSs1uNNNgO8NnQSpFahZ0.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light'), local('FiraSansCondensed-Light'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993JwNa6kgmw9HIHjUBPkzL2f3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light'), local('FiraSansCondensed-Light'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993KdGPpWTn2kPFru4k7T0T-v3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light'), local('FiraSansCondensed-Light'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993N9i7v7U2vZkHC55NWxtqfn3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light'), local('FiraSansCondensed-Light'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993K1ueDcgZDcfV3TWANvdPLj3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light'), local('FiraSansCondensed-Light'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993C3qj1XlvLGj0jktnJzWu233rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light'), local('FiraSansCondensed-Light'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993C8hAQ4ocbp44gFQt8tMfcH3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light'), local('FiraSansCondensed-Light'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993BEur64QvLD-0IbiAdTUNXE.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Regular'), local('FiraSansCondensed-Regular'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/HQGj1o4-qj8agzakWWMQwyJu5ElxHeJ-vvsme566ePQ.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Regular'), local('FiraSansCondensed-Regular'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/HQGj1o4-qj8agzakWWMQw6FoLnwF7KSuE7fShf3XPXY.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Regular'), local('FiraSansCondensed-Regular'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/HQGj1o4-qj8agzakWWMQw_MOQxvR9ks1ZWdpVW9Vfbc.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Regular'), local('FiraSansCondensed-Regular'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/HQGj1o4-qj8agzakWWMQw9JOPqQcfY8HfjrYxzy8ynM.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Regular'), local('FiraSansCondensed-Regular'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/HQGj1o4-qj8agzakWWMQw7w-3sNdXKC_xvJoaenysPs.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Regular'), local('FiraSansCondensed-Regular'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/HQGj1o4-qj8agzakWWMQw4FThv727WfzSC0pMQlrPaM.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Regular'), local('FiraSansCondensed-Regular'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/HQGj1o4-qj8agzakWWMQw3beBvOnr03nAdLtAYthXTk.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium'), local('FiraSansCondensed-Medium'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993K-gkANSAdF0cRIlsjF6jQr3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium'), local('FiraSansCondensed-Medium'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993Nogx5r5H19GU1_QnEE9Yjv3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium'), local('FiraSansCondensed-Medium'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993NaRsv4IYoJ98IWYnToDlQn3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium'), local('FiraSansCondensed-Medium'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993MEIibDEd4QSfwATzZQMGbv3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium'), local('FiraSansCondensed-Medium'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993LWPfzCipnTyiJgnNzpvR3v3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium'), local('FiraSansCondensed-Medium'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993LA1_yMPiib_YcSJnfOKnJn3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium'), local('FiraSansCondensed-Medium'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993Aqucz1E_8CNctQpbMaP2yE.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold'), local('FiraSansCondensed-SemiBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993AZMrwrWUoQTrXl4nI5CJJz3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold'), local('FiraSansCondensed-SemiBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993EhsrcdjEz9u0kwjhjxTVd33rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold'), local('FiraSansCondensed-SemiBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993MvLJCzU1xDn6YYRQf2GHav3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold'), local('FiraSansCondensed-SemiBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993AcnXWABXSWPlz6apxEE9473rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold'), local('FiraSansCondensed-SemiBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993KDSTNyplolGSwai0StWuvL3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold'), local('FiraSansCondensed-SemiBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993FFIZ9WqzgF1z5ZyucCdTl_3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold'), local('FiraSansCondensed-SemiBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993J7sOVs_bSQrxKT1d0L_85g.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold'), local('FiraSansCondensed-Bold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993BrT1lp9IdZ6Q20XTtjH6Zv3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold'), local('FiraSansCondensed-Bold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993IS898UBCVj0FEntoasBk6P3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold'), local('FiraSansCondensed-Bold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993BkraXwpsr1uSZUhAAol_4_3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold'), local('FiraSansCondensed-Bold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993KTAHfCyYjmaKhz-jw4dXo73rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold'), local('FiraSansCondensed-Bold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993P1CsDU87ma3di2VmaZcPSr3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold'), local('FiraSansCondensed-Bold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993BztfhWvsElVqpbWxzFHK633rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold'), local('FiraSansCondensed-Bold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993IF8zhZCJ7x9Pr62cRgaVUA.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold'), local('FiraSansCondensed-ExtraBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993HBudInCa6a7UOdQDJzjPab3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold'), local('FiraSansCondensed-ExtraBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993HIG-acorGLftrCxMuO7aXT3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold'), local('FiraSansCondensed-ExtraBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993FR4Va0HZJj2uC1LF-OZu8T3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold'), local('FiraSansCondensed-ExtraBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993M-dcw0yA4XEozrxyWTlbR_3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold'), local('FiraSansCondensed-ExtraBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993KcvAP2FA12oyHa8P-zFQzf3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold'), local('FiraSansCondensed-ExtraBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993L4JaAHwQW1XB0CfysziN5P3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold'), local('FiraSansCondensed-ExtraBold'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993KYfU3KCQgHLJHpZ57PKdXE.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black'), local('FiraSansCondensed-Black'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993FdOWtvXbiXdgmY3x96A5GH3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black'), local('FiraSansCondensed-Black'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993H2npINS66GeUX5JDjqkwdH3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black'), local('FiraSansCondensed-Black'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993FeE044DXe-TR7vb5V7hD173rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black'), local('FiraSansCondensed-Black'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993IF0PoOMs2JzS0I3fNvgYFn3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black'), local('FiraSansCondensed-Black'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993KChNYA_oTin3Ou5bQcrpTX3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black'), local('FiraSansCondensed-Black'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993NsyJCwMLUAuzW_INf7EQeH3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: normal;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black'), local('FiraSansCondensed-Black'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/k1srRZ14gKpu4XGd0R993BklYdX73m7bOqxQv0tXTAE.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight Italic'), local('FiraSansCondensed-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD_cth7yuiMSreoQQlo6oUS8U24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight Italic'), local('FiraSansCondensed-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD5iahPsMKy3QQ4DhPUD-Yk8U24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight Italic'), local('FiraSansCondensed-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDzt6Iw30SPfjk2yMHgnXwqkU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight Italic'), local('FiraSansCondensed-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD-JkSgGxuaz9db34CH6AoqEU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight Italic'), local('FiraSansCondensed-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDyx0T08ybpHwJ_MQwx-p9HUU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight Italic'), local('FiraSansCondensed-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD2J8UsfyCiHoEmisdA1PG3cU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 200;\n  src: local('Fira Sans Condensed ExtraLight Italic'), local('FiraSansCondensed-ExtraLightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDwI8bQ2LInr_hpUxGaF1keH3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light Italic'), local('FiraSansCondensed-LightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDxzW2HGxJE-cxaore_4G_hYU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light Italic'), local('FiraSansCondensed-LightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD4zIibREM_xtIOs0xIJYzcAU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light Italic'), local('FiraSansCondensed-LightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD9WNSx_9Tm--PxC8nYzol_oU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light Italic'), local('FiraSansCondensed-LightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD4S1q5RGaHzzAAUgHklRNwMU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light Italic'), local('FiraSansCondensed-LightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD0RUj-8OE20lRl9GlTGRU-QU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light Italic'), local('FiraSansCondensed-LightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD12Cn97i9IlPbfrzIs7KZtAU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 300;\n  src: local('Fira Sans Condensed Light Italic'), local('FiraSansCondensed-LightItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDyqWG1TIildrkra2taUxHyT3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Italic'), local('FiraSansCondensed-Italic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/-hkH0zXsjNm-yd0g99LvtuwS83uxbbyt4YINUH7bkGM.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Italic'), local('FiraSansCondensed-Italic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/-hkH0zXsjNm-yd0g99LvtmoStt8kHCvWm41FzhVw0mg.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Italic'), local('FiraSansCondensed-Italic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/-hkH0zXsjNm-yd0g99Lvtrw1GtprQKmv_z8MTrJ1LrI.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Italic'), local('FiraSansCondensed-Italic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/-hkH0zXsjNm-yd0g99LvtnlhddewYewN_CDxPHLbDm0.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Italic'), local('FiraSansCondensed-Italic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/-hkH0zXsjNm-yd0g99LvtrTR5XhQfXJkQb_2mUKAj70.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Italic'), local('FiraSansCondensed-Italic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/-hkH0zXsjNm-yd0g99LvtqlyAWmyYNxrC6q94MEyPAE.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Fira Sans Condensed Italic'), local('FiraSansCondensed-Italic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/-hkH0zXsjNm-yd0g99Lvtma7JNZ_U4BOvHrsfjgI5HE.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium Italic'), local('FiraSansCondensed-MediumItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD_WneAHjY1PjlSiLtmNJfesU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium Italic'), local('FiraSansCondensed-MediumItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD1w-kXPPTMrvDjdnRxJGUM8U24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium Italic'), local('FiraSansCondensed-MediumItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD-zoqYXmamxBgmKhqbhWOcMU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium Italic'), local('FiraSansCondensed-MediumItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDxHuUVKKXpaYeFRw8WL4LYwU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium Italic'), local('FiraSansCondensed-MediumItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD9S9GDCwSW1m_RsLlve95vAU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium Italic'), local('FiraSansCondensed-MediumItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD6SWnOrUJHd-h8DRuxH8r8MU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 500;\n  src: local('Fira Sans Condensed Medium Italic'), local('FiraSansCondensed-MediumItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD-88seZ_a57qN2zp29oIdz33rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold Italic'), local('FiraSansCondensed-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD6kE51GTYFOQrF1fvKNnrT0U24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold Italic'), local('FiraSansCondensed-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDwFoMb1F-wYavrXizHdDmsoU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold Italic'), local('FiraSansCondensed-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDxM5xPDZDPLRDQTNTxeRBeoU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold Italic'), local('FiraSansCondensed-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD8KedmD3VBSrE5dIIjJRrQgU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold Italic'), local('FiraSansCondensed-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD_n5HdQnUgqERlXgTLMKqOEU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold Italic'), local('FiraSansCondensed-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDyXwUSmkrR1wPzfQcFo8nzAU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 600;\n  src: local('Fira Sans Condensed SemiBold Italic'), local('FiraSansCondensed-SemiBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD8D50Y0tcRZLJOQDyy4U45D3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold Italic'), local('FiraSansCondensed-BoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD0cUwpm2M51HGPEWIvj6QcgU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold Italic'), local('FiraSansCondensed-BoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD7ZqMny0-sMgS0yZVLds8MwU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold Italic'), local('FiraSansCondensed-BoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD-uyckmBb7VC-sv3cuDhNEIU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold Italic'), local('FiraSansCondensed-BoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD9KEatyQ-Cjd-7ULWJEDCN8U24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold Italic'), local('FiraSansCondensed-BoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD4QG450ggJe_K85r2oT9WB0U24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold Italic'), local('FiraSansCondensed-BoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD_UBuXnBUtbUtnSovT8C8LUU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Fira Sans Condensed Bold Italic'), local('FiraSansCondensed-BoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDxonZ4JUPj1cM9Awmw66V2T3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold Italic'), local('FiraSansCondensed-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD0a9L5pXXjEfdeJzX02t03gU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold Italic'), local('FiraSansCondensed-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD3xRLTzQRpqTyvD_TCoQSm4U24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold Italic'), local('FiraSansCondensed-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDzJJ5Kogy3-NMtFcY4sN9rYU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold Italic'), local('FiraSansCondensed-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD9DaxKu02cKGeMazjYUc4OAU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold Italic'), local('FiraSansCondensed-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD4UZZs9llZ-rGLEb9vJLPpYU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold Italic'), local('FiraSansCondensed-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD_W85HEHM-W4coaqv5O0ufkU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 800;\n  src: local('Fira Sans Condensed ExtraBold Italic'), local('FiraSansCondensed-ExtraBoldItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD5dhWTq8T5EHStIx2owSnX33rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black Italic'), local('FiraSansCondensed-BlackItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDxR6wFpqy8FZdscZDlu8U3cU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black Italic'), local('FiraSansCondensed-BlackItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD-i1cI9JpSvUAWq26Jxu4h8U24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* greek-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black Italic'), local('FiraSansCondensed-BlackItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD6zlrAQDrwoPIqad4xQpNRMU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+1F00-1FFF;\n}\n/* greek */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black Italic'), local('FiraSansCondensed-BlackItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDyfkTfS6mNNY6edD5NwrV9EU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0370-03FF;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black Italic'), local('FiraSansCondensed-BlackItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD9bTxtjT0OVjRgi7sECvgdYU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black Italic'), local('FiraSansCondensed-BlackItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjD1-FwJ-KUi-D4pbiwGHKaxQU24FapfJwyacJ6xNu5rm9.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Fira Sans Condensed';\n  font-style: italic;\n  font-weight: 900;\n  src: local('Fira Sans Condensed Black Italic'), local('FiraSansCondensed-BlackItalic'), url(https://fonts.gstatic.com/s/firasanscondensed/v1/Z87ZCYzj43dcQd7C-kCjDyb6uMyQnU_1T3n4meEBtWH3rGVtsTkPsbDajuO5ueQw.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n\n/* ## Fira Code ; modified from <https://raw.githubusercontent.com/tonsky/FiraCode/94f1d8fc761302d88f848ce5e6a4a3292717fad9/distr/fira_code.css>*/\n@font-face{\n  font-family: 'Fira Code';\n  font-style: normal;\n  font-weight: 300;\n  src: local('Fira Code Light'), local('FiraCode-Light'), url(https://cdn.rawgit.com/tonsky/FiraCode/436ac320b39184d91ea9b0e246223663a5f6fbf2/distr/woff2/FiraCode-Light.woff2) format('woff2');\n}\n@font-face{\n  font-family: 'Fira Code';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Fira Code'), local('FiraCode-Regular'), url(https://cdn.rawgit.com/tonsky/FiraCode/436ac320b39184d91ea9b0e246223663a5f6fbf2/distr/woff2/FiraCode-Regular.woff2) format('woff2');\n}\n@font-face{\n  font-family: 'Fira Code';\n  font-style: normal;\n  font-weight: 500;\n  src: local('Fira Code Medium'), local('FiraCode-Medium'), url(https://cdn.rawgit.com/tonsky/FiraCode/436ac320b39184d91ea9b0e246223663a5f6fbf2/distr/woff2/FiraCode-Medium.woff2) format('woff2');\n}\n@font-face{\n  font-family: 'Fira Code';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Fira Code Bold'), local('FiraCode-Bold'), url(https://cdn.rawgit.com/tonsky/FiraCode/436ac320b39184d91ea9b0e246223663a5f6fbf2/distr/woff2/FiraCode-Bold.woff2) format('woff2');\n}\n\n/* ### Lora ; from: <http://fonts.googleapis.com/css?family=Lora:regular,bold,bolditalic,italic> */\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Lora Regular'), local('Lora-Regular'), url(http://fonts.gstatic.com/s/lora/v10/Ukd0sOIY4JZgcODPuj2G3Q.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Lora Regular'), local('Lora-Regular'), url(http://fonts.gstatic.com/s/lora/v10/GsNxiN0oIzsS201cnUag6w.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Lora Regular'), local('Lora-Regular'), url(http://fonts.gstatic.com/s/lora/v10/ie2Ux11tIT0C_JTksRPlKA.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Lora Regular'), local('Lora-Regular'), url(http://fonts.gstatic.com/s/lora/v10/I0dEfRgGNE90_hXZq7bjyw.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Lora Regular'), local('Lora-Regular'), url(http://fonts.gstatic.com/s/lora/v10/4vqKRIwnQQGUQQh-PnvdMA.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Lora Bold'), local('Lora-Bold'), url(http://fonts.gstatic.com/s/lora/v10/sNXgpEOJ2Tz7WJSozSN6D_Y6323mHUZFJMgTvxaG2iE.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Lora Bold'), local('Lora-Bold'), url(http://fonts.gstatic.com/s/lora/v10/VZ-5ejr2fpt5l1RKkVxPr_Y6323mHUZFJMgTvxaG2iE.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Lora Bold'), local('Lora-Bold'), url(http://fonts.gstatic.com/s/lora/v10/gBru_9ER68jWAtTarLXr3_Y6323mHUZFJMgTvxaG2iE.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Lora Bold'), local('Lora-Bold'), url(http://fonts.gstatic.com/s/lora/v10/BYKAuswRIqh69412sen31PY6323mHUZFJMgTvxaG2iE.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Lora';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Lora Bold'), local('Lora-Bold'), url(http://fonts.gstatic.com/s/lora/v10/P18Nsu9EiYldSvHIj_0e5w.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Lora Italic'), local('Lora-Italic'), url(http://fonts.gstatic.com/s/lora/v10/HeAP0mHtiTx5JKQlc80wp_esZW2xOQ-xsNqO47m55DA.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Lora Italic'), local('Lora-Italic'), url(http://fonts.gstatic.com/s/lora/v10/OVZcBeQFqX1w7YhsLFAXp_esZW2xOQ-xsNqO47m55DA.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Lora Italic'), local('Lora-Italic'), url(http://fonts.gstatic.com/s/lora/v10/7zlcDWwHlSl_w5azaU2j3PesZW2xOQ-xsNqO47m55DA.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Lora Italic'), local('Lora-Italic'), url(http://fonts.gstatic.com/s/lora/v10/nRWuMjV9d7Qv7608EovOgfesZW2xOQ-xsNqO47m55DA.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 400;\n  src: local('Lora Italic'), local('Lora-Italic'), url(http://fonts.gstatic.com/s/lora/v10/_RSiB1sBuflZfa9fxV8cOg.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Lora Bold Italic'), local('Lora-BoldItalic'), url(http://fonts.gstatic.com/s/lora/v10/47861CGpECw31aszKPt4uhJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Lora Bold Italic'), local('Lora-BoldItalic'), url(http://fonts.gstatic.com/s/lora/v10/66KG1MDzU5Zo36weZ_yx-RJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Lora Bold Italic'), local('Lora-BoldItalic'), url(http://fonts.gstatic.com/s/lora/v10/GjWw5_K_Fhq8yNDkNV_ETRJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Lora Bold Italic'), local('Lora-BoldItalic'), url(http://fonts.gstatic.com/s/lora/v10/1wR3aOJ69QwyZ9B-WDmIqRJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Lora';\n  font-style: italic;\n  font-weight: 700;\n  src: local('Lora Bold Italic'), local('Lora-BoldItalic'), url(http://fonts.gstatic.com/s/lora/v10/_IxjUs2lbQSu0MyFEAfa7VtXRa8TVwTICgirnJhmVJw.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n\n/* ## Inconsolata ; from <http://fonts.googleapis.com/css?family=Inconsolata:regular,bold,bolditalic,italic>*/\n/* vietnamese */\n@font-face {\n  font-family: 'Inconsolata';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Inconsolata Regular'), local('Inconsolata-Regular'), url(http://fonts.gstatic.com/s/inconsolata/v15/BjAYBlHtW3CJxDcjzrnZCL6up8jxqWt8HVA3mDhkV_0.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Inconsolata';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Inconsolata Regular'), local('Inconsolata-Regular'), url(http://fonts.gstatic.com/s/inconsolata/v15/BjAYBlHtW3CJxDcjzrnZCCYE0-AqJ3nfInTTiDXDjU4.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Inconsolata';\n  font-style: normal;\n  font-weight: 400;\n  src: local('Inconsolata Regular'), local('Inconsolata-Regular'), url(http://fonts.gstatic.com/s/inconsolata/v15/BjAYBlHtW3CJxDcjzrnZCI4P5ICox8Kq3LLUNMylGO4.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Inconsolata';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Inconsolata Bold'), local('Inconsolata-Bold'), url(http://fonts.gstatic.com/s/inconsolata/v15/AIed271kqQlcIRSOnQH0yWhQUTDJGru-0vvUpABgH8I.woff2) format('woff2');\n  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Inconsolata';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Inconsolata Bold'), local('Inconsolata-Bold'), url(http://fonts.gstatic.com/s/inconsolata/v15/AIed271kqQlcIRSOnQH0yejkDdvhIIFj_YMdgqpnSB0.woff2) format('woff2');\n  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Inconsolata';\n  font-style: normal;\n  font-weight: 700;\n  src: local('Inconsolata Bold'), local('Inconsolata-Bold'), url(http://fonts.gstatic.com/s/inconsolata/v15/AIed271kqQlcIRSOnQH0yYlIZu-HDpmDIZMigmsroc4.woff2) format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;\n}\n\n/* ## FontAwesome ; via local or CDNjs; see <https://fontawesome.com/v4.7.0/cheatsheet> @@ <https://archive.is/JNTjE> */\n@font-face {\n  font-family: 'FontAwesome';\n  font-style: normal;\n  font-weight: normal;\n  src: local('Font Awesome'), url('https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/fonts/fontawesome-webfont.eot');\n  src: local('Font Awesome'), url('https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/fonts/fontawesome-webfont.eot') format('embedded-opentype'), url('https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/fonts/fontawesome-webfont.woff2') format('woff2'), url('https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/fonts/fontawesome-webfont.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/fonts/fontawesome-webfont.ttf') format('truetype'), url('https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/fonts/fontawesome-webfont.svg') format('svg');\n}\n", ""]);



/***/ }),
/* 414 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(415);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 415 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/* ## baseline CSS */\n\n/* spell-checker:words Calibri */\n/* spell-checker:ignore codeblock buttontext buttonface */\n\nbody { margin: /*8px*/ auto; }\nbody { font-family: Merriweather, Lora, \"Noto Serif\", \"DejaVu Serif\", Palatino, serif; font-size: 1.2rem; line-height: 1.4em; }\nbody { text-rendering: optimizeLegibility; -webkit-font-feature-settings: \"kern\"; -moz-font-feature-settings: \"kern\"; font-feature-settings: \"kern\"; }\nh1, h2, h3, h4, h5, h6 { font-family: \"Fira Sans Condensed\", \"Merriweather Sans\", \"Fira Sans\", \"Open Sans\", \"DejaVu Sans\", Calibri, Arial, sans-serif; }\n/* h1, h2, h3, h4, h5, h6 { font-family: \"Merriweather Sans\", \"Fira Sans\", \"Open Sans\", \"DejaVu Sans\", Calibri, Arial, sans-serif; letter-spacing: -0.05em; } */ /* ref: [Condensing a font with CSS](http://stackoverflow.com/questions/13786971/make-a-font-more-condensed-with-css) @@ <http://archive.is/BJDxg>; */\n/*\nh1 { font-size: 2.5em; margin-block-start: 0.67em; margin-block-end: 0.67em; line-height: 1.1em; }\nh2 { font-size: 2em; margin-block-start: 0.83em; margin-block-end: 0.83em; line-height: 1.1em; }\nh3 { font-size: 1.75em; margin-block-start: 1em; margin-block-end: 1em; line-height: 1.1em; }\nh4 { font-size: 1.5em; margin-block-start: 1.33em; margin-block-end: 1.33em; line-height: 1.1em; }\nh5 { font-size: 1.25em; margin-block-start: 1.67em; margin-block-end: 1.67em; line-height: 1.1em; }\nh6 { font-size: 1.25em; margin-block-start: 2.33em; margin-block-end: 2.33em; line-height: 1.1em; }\n*/\nh1 { font-size: 2.5em;  margin-top: 0.67em; margin-bottom: 0.67em; line-height: 1.1em; font-weight: 900; }\nh2 { font-size: 2em;    margin-top: 0.83em; margin-bottom: 0.33em; line-height: 1.1em; }\nh3 { font-size: 1.75em; margin-top: 1em;    margin-bottom: 0.2em;  line-height: 1.1em; letter-spacing: -0.025em; }\nh4 { font-size: 1.5em;  margin-top: 1.33em; margin-bottom: 0.2em;  line-height: 1.1em; }\nh5 { font-size: 1.25em; margin-top: 1.67em; margin-bottom: 0.1em;  line-height: 1.1em; }\nh6 { font-size: 1.25em; margin-top: 2.33em; margin-bottom: 0.1em;  line-height: 1.1em; letter-spacing: -0.025em; }\n\np, blockquote, ul, fieldset, form, ol, dl, dir, menu { margin-top: 0; margin-bottom: 1.12em; }\ntable, code, pre, .codeblock { margin-top: 1.12em; margin-bottom: 1.12em; }\n\ntable pre, /*table code,*/ table .codeblock { margin: 0; }\n\nli { margin-bottom: 0.2em; }\nli > p { margin-bottom: 0.2em; }\n\ntable {\n  border-collapse: collapse;\n  font-size: 1em;\n}\ntable + table {\n  margin-top: 1em;\n}\nthead {\n  background: /* #EEE */ gainsboro;\n  background: rgba(238,238,238,0.8);\n  text-align: left;\n}\nth, td, caption {\n  border: /* 1px */ 0.05em solid /* #EEE */ gainsboro;\n}\nth, td {\n  padding: /* 5px 10px */ 0.35em 0.7em;\n}\ncaption {\n  border-collapse: collapse;\n  padding: 0 0.7em;\n}\n\n/*ol, */ul, dir, menu, dd { margin-left: /*40px*/ 1em; }\nol { margin-left: 1.2em; }\n\nol { list-style-type: decimal; }\nol ol { list-style-type: lower-alpha; }\nol ol ol { list-style-type: lower-roman; }\n\nul { list-style-type: disc; }\n\nli { margin-left: 0.2em; padding-left: 0.1em; }\n\n:link, :visited { text-decoration: none; }\na:hover { text-decoration: underline; }\n\npre, code, .codeblock { font-family: /*Inconsolata,*/ \"Fira Code\", \"Open Sans Mono\", \"Anonymous Pro\", \"Consolas\", \"Lucida Console\", monospace; font-size: 1em; line-height: 1.3em; }\ncode { background: gainsboro; background: rgba(238,238,238,0.8); padding: 0 0.2em; }\ncode { border-radius: 0.1em; }\n\n/* ## page / media settings */\nbody { transition: width 0.3s ease-in-out; }\n/* continuously varying would be preferred over a transition but `calc()` is unable to calculate the fractional distance between a `100vw` and an `Nem` */\n@media all {\n    body { margin: auto; }\n}\n/* ref: [Practical Typography ~ Page Margins](http://practicaltypography.com/page-margins.html)@@<https://archive.is/sOEL6> */\n/* ref: <https://baymard.com/blog/line-length-readability>[`@`](http://archive.is/Dikhd) */\n/* ref: <http://bradfrost.com/blog/post/7-habits-of-highly-effective-media-queries>[`@`](https://archive.is/cv0mA) */\n/* ref: <http://webtypography.net/2.1.2>[`@`](https://archive.is/Rihn0) */\n/* seek optimum line length ~ 45-90 characters (or, 50-75 characters, from alternate references) */\n/* note: continuously varying would be preferred over a transition but `calc()` is unable to calculate the fractional distance between a `100vw` and an `Nem` */\n@media screen and (max-width: 24rem) {\n    body { width: 96%; }\n}\n@media screen and (min-width: 24rem) {\n    body { width: 90%; }\n}\n@media screen and (min-width: 46.8rem) {\n    body { width: 83%; }\n}\n@media screen and (min-width: 50rem) {\n    body { width: 75%; }\n}\n@media screen and (min-width: 60rem) {\n    body { width: 40em; /* (40em / line) / (0.5em / average char) => 80 average char / line */ }\n}\n@media print {\n    body { font-size: 0.8em; /*width: 75%; margin-left: 15%; margin-top:10%; margin-bottom: 10%;*/ }\n}\n\nbody { hyphens: auto; }\npre, code { hyphens: none; }\n\nblockquote { page-break-inside: avoid; }\ntable { page-break-inside:avoid; }\ntr    { page-break-after:auto; page-break-inside:avoid; }\n.codeblock { page-break-inside: avoid; }\n.no-page-break-inside { page-break-inside: avoid; }\n\n/* ## align button appearance between Chrome/Firefox */\n/*\nbutton {\n    align-items: flex-start;\n    text-align: center;\n    cursor: default;\n    color: buttontext;\n    background-color: buttonface;\n    box-sizing: border-box;\n    padding: 2px 6px 3px;\n    border-width: 2px;\n    border-style: outset;\n    border-color: buttonface;\n    border-image: initial;\n}\n*/\nbutton { border-width: 1px; }\n/* ref: https://www.templatemonster.com/help/how-to-create-browser-specific-css-rules-styles.html @@ https://archive.is/Bv6TZ */\nbutton { padding: 2px 6px 3px; }\n@supports (-webkit-appearance:none) { button { padding: 2px 6px 4px; } } /* Chrome-only */\n\n/* ## additional customization options (via classes) */\n.--border-bottom { border-bottom: 0.05em solid lightgrey; border-radius: 0.01em; }\n.--width-100percent { width: 100%; }\n\n/* header-anchor */\n.header-anchor { display: inline-block; margin-left: -1em; width: 1em; text-align: center; opacity: 0.075; transition: opacity 0.3s ease-in-out; }\nh1:hover > a.header-anchor, h2:hover > a.header-anchor, h3:hover > a.header-anchor , h4:hover > a.header-anchor , h5:hover > a.header-anchor, h6:hover > a.header-anchor, .header-anchor:hover { opacity: 1; }\na.header-anchor { text-decoration: none; }\n\n/* blockquotes with type modifiers */\nblockquote { font-size: 0.9em; }\nblockquote {\n  background: gainsboro;\n  border-left: 0.5em solid /* #EEE */ dimgray;\n  border-radius: 0.1em;\n  margin-left: 0em;\n  margin-right: 0em;\n  padding: 0.5em;\n  padding-left: 1em;\n}\n\nblockquote:before {\n  font-family: fontawesome;\n  font-style: normal;\n  font-size: 1em;\n  display: inline-block;\n  float: left;\n  position: relative;\n  margin: 0;\n  margin-left: -3em;\n  padding: 0;\n  color: white;\n  width: 2em;\n  text-align: center;\n}\n\nblockquote.--error { background: #FFBFBF; border-left: 2em solid crimson; margin-left: 0em; }\nblockquote.--error:before { content: \"\\F06a\"; margin-left: -3em; text-align: center; }\n\nblockquote.--info { background: #BFE9FF; border-left: 2em solid royalblue; margin-left: 0em; }\nblockquote.--info:before { content: \"\\F05a\"; margin-left: -3em; text-align: center; }\nblockquote.--information { background: #BFE9FF; border-left: 2em solid royalblue; margin-left: 0em; }\nblockquote.--information:before { content: \"\\F05a\"; margin-left: -3em; text-align: center; }\n\nblockquote.--warn { background: #FFF2BF; border-left: 2em solid darkorange; margin-left: 0em; }\nblockquote.--warn:before { content: \"\\F071\"; margin-left: -3em; text-align: center; }\nblockquote.--warning { background: #FFF2BF; border-left: 2em solid darkorange; margin-left: 0em; }\nblockquote.--warning:before { content: \"\\F071\"; margin-left: -3em; text-align: center; }\n\nblockquote.--success { background: #D7FFBF; border-left: 2em solid forestgreen; margin-left: 0em; }\nblockquote.--success:before { content: \"\\F058\"; margin-left: -3em; text-align: center; }\n\n/* # remove \"block-quote\" bulge */\n/* blockquote p:last-child { margin-bottom: 0; } *//* remove \"blockquote paragraph bulge\"; ref: <https://css-tricks.com/blockquote-bulge> @@ <https://archive.is/190Ba> */\nblockquote > :first-child { margin-top: 0; }\nblockquote > :last-child { margin-bottom: 0; }\n", ""]);



/***/ }),
/* 416 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(417);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 417 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/* tooltips */\n\n/* spell-checker:words tooltip tooltips tooltipped subpixel antialiased multiline Segoe FreeSans NimbusSansL LiberationSans */\n/* spell-checker:ignore */\n\n.tooltipped {\n    position: relative\n}\n\n.tooltipped:after {\n    position: absolute;\n    z-index: 1000000;\n    display: none;\n    padding: 5px 8px;\n    font: normal normal 11px/1.5 Helvetica,arial,nimbussansl,liberationsans,freesans,clean,sans-serif,\"Segoe UI Emoji\",\"Segoe UI Symbol\";\n    color: #fff;\n    text-align: center;\n    text-decoration: none;\n    text-shadow: none;\n    text-transform: none;\n    letter-spacing: normal;\n    word-wrap: break-word;\n    white-space: pre;\n    pointer-events: none;\n    content: attr(aria-label);\n    background: rgba(0,0,0,0.8);\n    border-radius: 3px;\n    -webkit-font-smoothing: subpixel-antialiased\n}\n\n.tooltipped:before {\n    position: absolute;\n    z-index: 1000001;\n    display: none;\n    width: 0;\n    height: 0;\n    color: rgba(0,0,0,0.8);\n    pointer-events: none;\n    content: \"\";\n    border: 5px solid transparent\n}\n\n.tooltipped:hover:before,.tooltipped:hover:after,.tooltipped:active:before,.tooltipped:active:after,.tooltipped:focus:before,.tooltipped:focus:after {\n    display: inline-block;\n    text-decoration: none\n}\n\n.tooltipped--multiline:hover:after,.tooltipped--multiline:active:after,.tooltipped--multiline:focus:after {\n    display: table-cell\n}\n\n.tooltipped--s:after,.tooltipped--se:after,.tooltipped--sw:after {\n    top: 100%;\n    right: 50%;\n    margin-top: 5px\n}\n\n.tooltipped--s:before,.tooltipped--se:before,.tooltipped--sw:before {\n    top: auto;\n    right: 50%;\n    bottom: -5px;\n    margin-right: -5px;\n    border-bottom-color: rgba(0,0,0,0.8)\n}\n\n.tooltipped--se:after {\n    right: auto;\n    left: 50%;\n    margin-left: -15px\n}\n\n.tooltipped--sw:after {\n    margin-right: -15px\n}\n\n.tooltipped--n:after,.tooltipped--ne:after,.tooltipped--nw:after {\n    right: 50%;\n    bottom: 100%;\n    margin-bottom: 5px\n}\n\n.tooltipped--n:before,.tooltipped--ne:before,.tooltipped--nw:before {\n    top: -5px;\n    right: 50%;\n    bottom: auto;\n    margin-right: -5px;\n    border-top-color: rgba(0,0,0,0.8)\n}\n\n.tooltipped--ne:after {\n    right: auto;\n    left: 50%;\n    margin-left: -15px\n}\n\n.tooltipped--nw:after {\n    margin-right: -15px\n}\n\n.tooltipped--s:after,.tooltipped--n:after {\n    -webkit-transform: translateX(50%);\n    -ms-transform: translateX(50%);\n    transform: translateX(50%)\n}\n\n.tooltipped--w:after {\n    right: 100%;\n    bottom: 50%;\n    margin-right: 5px;\n    -webkit-transform: translateY(50%);\n    -ms-transform: translateY(50%);\n    transform: translateY(50%)\n}\n\n.tooltipped--w:before {\n    top: 50%;\n    bottom: 50%;\n    left: -5px;\n    margin-top: -5px;\n    border-left-color: rgba(0,0,0,0.8)\n}\n\n.tooltipped--e:after {\n    bottom: 50%;\n    left: 100%;\n    margin-left: 5px;\n    -webkit-transform: translateY(50%);\n    -ms-transform: translateY(50%);\n    transform: translateY(50%)\n}\n\n.tooltipped--e:before {\n    top: 50%;\n    right: -5px;\n    bottom: 50%;\n    margin-top: -5px;\n    border-right-color: rgba(0,0,0,0.8)\n}\n\n.tooltipped--multiline:after {\n    width: -webkit-max-content;\n    width: -moz-max-content;\n    width: max-content;\n    max-width: 250px;\n    word-break: break-word;\n    word-wrap: normal;\n    white-space: pre-line;\n    border-collapse: separate\n}\n\n.tooltipped--multiline.tooltipped--s:after,.tooltipped--multiline.tooltipped--n:after {\n    right: auto;\n    left: 50%;\n    -webkit-transform: translateX(-50%);\n    -ms-transform: translateX(-50%);\n    transform: translateX(-50%)\n}\n\n.tooltipped--multiline.tooltipped--w:after,.tooltipped--multiline.tooltipped--e:after {\n    right: 100%\n}\n\n@media screen and (min-width: 0\\0) {\n    .tooltipped--multiline:after {\n        width:250px\n    }\n}\n\n.tooltipped--sticky:before,.tooltipped--sticky:after {\n    display: inline-block\n}\n\n.tooltipped--sticky.tooltipped--multiline:after {\n    display: table-cell\n}\n", ""]);



/***/ }),
/* 418 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(419);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 419 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/* BASICS */\n\n.CodeMirror {\n  /* Set height, width, borders, and global font properties here */\n  font-family: monospace;\n  height: 300px;\n  color: black;\n  direction: ltr;\n}\n\n/* PADDING */\n\n.CodeMirror-lines {\n  padding: 4px 0; /* Vertical padding around content */\n}\n.CodeMirror pre.CodeMirror-line,\n.CodeMirror pre.CodeMirror-line-like {\n  padding: 0 4px; /* Horizontal padding of content */\n}\n\n.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n  background-color: white; /* The little square between H and V scrollbars */\n}\n\n/* GUTTER */\n\n.CodeMirror-gutters {\n  border-right: 1px solid #ddd;\n  background-color: #f7f7f7;\n  white-space: nowrap;\n}\n.CodeMirror-linenumbers {}\n.CodeMirror-linenumber {\n  padding: 0 3px 0 5px;\n  min-width: 20px;\n  text-align: right;\n  color: #999;\n  white-space: nowrap;\n}\n\n.CodeMirror-guttermarker { color: black; }\n.CodeMirror-guttermarker-subtle { color: #999; }\n\n/* CURSOR */\n\n.CodeMirror-cursor {\n  border-left: 1px solid black;\n  border-right: none;\n  width: 0;\n}\n/* Shown when moving in bi-directional text */\n.CodeMirror div.CodeMirror-secondarycursor {\n  border-left: 1px solid silver;\n}\n.cm-fat-cursor .CodeMirror-cursor {\n  width: auto;\n  border: 0 !important;\n  background: #7e7;\n}\n.cm-fat-cursor div.CodeMirror-cursors {\n  z-index: 1;\n}\n.cm-fat-cursor-mark {\n  background-color: rgba(20, 255, 20, 0.5);\n  -webkit-animation: blink 1.06s steps(1) infinite;\n  -moz-animation: blink 1.06s steps(1) infinite;\n  animation: blink 1.06s steps(1) infinite;\n}\n.cm-animate-fat-cursor {\n  width: auto;\n  border: 0;\n  -webkit-animation: blink 1.06s steps(1) infinite;\n  -moz-animation: blink 1.06s steps(1) infinite;\n  animation: blink 1.06s steps(1) infinite;\n  background-color: #7e7;\n}\n@-moz-keyframes blink {\n  0% {}\n  50% { background-color: transparent; }\n  100% {}\n}\n@-webkit-keyframes blink {\n  0% {}\n  50% { background-color: transparent; }\n  100% {}\n}\n@keyframes blink {\n  0% {}\n  50% { background-color: transparent; }\n  100% {}\n}\n\n/* Can style cursor different in overwrite (non-insert) mode */\n.CodeMirror-overwrite .CodeMirror-cursor {}\n\n.cm-tab { display: inline-block; text-decoration: inherit; }\n\n.CodeMirror-rulers {\n  position: absolute;\n  left: 0; right: 0; top: -50px; bottom: 0;\n  overflow: hidden;\n}\n.CodeMirror-ruler {\n  border-left: 1px solid #ccc;\n  top: 0; bottom: 0;\n  position: absolute;\n}\n\n/* DEFAULT THEME */\n\n.cm-s-default .cm-header {color: blue;}\n.cm-s-default .cm-quote {color: #090;}\n.cm-negative {color: #d44;}\n.cm-positive {color: #292;}\n.cm-header, .cm-strong {font-weight: bold;}\n.cm-em {font-style: italic;}\n.cm-link {text-decoration: underline;}\n.cm-strikethrough {text-decoration: line-through;}\n\n.cm-s-default .cm-keyword {color: #708;}\n.cm-s-default .cm-atom {color: #219;}\n.cm-s-default .cm-number {color: #164;}\n.cm-s-default .cm-def {color: #00f;}\n.cm-s-default .cm-variable,\n.cm-s-default .cm-punctuation,\n.cm-s-default .cm-property,\n.cm-s-default .cm-operator {}\n.cm-s-default .cm-variable-2 {color: #05a;}\n.cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;}\n.cm-s-default .cm-comment {color: #a50;}\n.cm-s-default .cm-string {color: #a11;}\n.cm-s-default .cm-string-2 {color: #f50;}\n.cm-s-default .cm-meta {color: #555;}\n.cm-s-default .cm-qualifier {color: #555;}\n.cm-s-default .cm-builtin {color: #30a;}\n.cm-s-default .cm-bracket {color: #997;}\n.cm-s-default .cm-tag {color: #170;}\n.cm-s-default .cm-attribute {color: #00c;}\n.cm-s-default .cm-hr {color: #999;}\n.cm-s-default .cm-link {color: #00c;}\n\n.cm-s-default .cm-error {color: #f00;}\n.cm-invalidchar {color: #f00;}\n\n.CodeMirror-composing { border-bottom: 2px solid; }\n\n/* Default styles for common addons */\n\ndiv.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;}\ndiv.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;}\n.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }\n.CodeMirror-activeline-background {background: #e8f2ff;}\n\n/* STOP */\n\n/* The rest of this file contains styles related to the mechanics of\n   the editor. You probably shouldn't touch them. */\n\n.CodeMirror {\n  position: relative;\n  overflow: hidden;\n  background: white;\n}\n\n.CodeMirror-scroll {\n  overflow: scroll !important; /* Things will break if this is overridden */\n  /* 50px is the magic margin used to hide the element's real scrollbars */\n  /* See overflow: hidden in .CodeMirror */\n  margin-bottom: -50px; margin-right: -50px;\n  padding-bottom: 50px;\n  height: 100%;\n  outline: none; /* Prevent dragging from highlighting the element */\n  position: relative;\n}\n.CodeMirror-sizer {\n  position: relative;\n  border-right: 50px solid transparent;\n}\n\n/* The fake, visible scrollbars. Used to force redraw during scrolling\n   before actual scrolling happens, thus preventing shaking and\n   flickering artifacts. */\n.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n  position: absolute;\n  z-index: 6;\n  display: none;\n}\n.CodeMirror-vscrollbar {\n  right: 0; top: 0;\n  overflow-x: hidden;\n  overflow-y: scroll;\n}\n.CodeMirror-hscrollbar {\n  bottom: 0; left: 0;\n  overflow-y: hidden;\n  overflow-x: scroll;\n}\n.CodeMirror-scrollbar-filler {\n  right: 0; bottom: 0;\n}\n.CodeMirror-gutter-filler {\n  left: 0; bottom: 0;\n}\n\n.CodeMirror-gutters {\n  position: absolute; left: 0; top: 0;\n  min-height: 100%;\n  z-index: 3;\n}\n.CodeMirror-gutter {\n  white-space: normal;\n  height: 100%;\n  display: inline-block;\n  vertical-align: top;\n  margin-bottom: -50px;\n}\n.CodeMirror-gutter-wrapper {\n  position: absolute;\n  z-index: 4;\n  background: none !important;\n  border: none !important;\n}\n.CodeMirror-gutter-background {\n  position: absolute;\n  top: 0; bottom: 0;\n  z-index: 4;\n}\n.CodeMirror-gutter-elt {\n  position: absolute;\n  cursor: default;\n  z-index: 4;\n}\n.CodeMirror-gutter-wrapper ::selection { background-color: transparent }\n.CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent }\n\n.CodeMirror-lines {\n  cursor: text;\n  min-height: 1px; /* prevents collapsing before first draw */\n}\n.CodeMirror pre.CodeMirror-line,\n.CodeMirror pre.CodeMirror-line-like {\n  /* Reset some styles that the rest of the page might have set */\n  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;\n  border-width: 0;\n  background: transparent;\n  font-family: inherit;\n  font-size: inherit;\n  margin: 0;\n  white-space: pre;\n  word-wrap: normal;\n  line-height: inherit;\n  color: inherit;\n  z-index: 2;\n  position: relative;\n  overflow: visible;\n  -webkit-tap-highlight-color: transparent;\n  -webkit-font-variant-ligatures: contextual;\n  font-variant-ligatures: contextual;\n}\n.CodeMirror-wrap pre.CodeMirror-line,\n.CodeMirror-wrap pre.CodeMirror-line-like {\n  word-wrap: break-word;\n  white-space: pre-wrap;\n  word-break: normal;\n}\n\n.CodeMirror-linebackground {\n  position: absolute;\n  left: 0; right: 0; top: 0; bottom: 0;\n  z-index: 0;\n}\n\n.CodeMirror-linewidget {\n  position: relative;\n  z-index: 2;\n  padding: 0.1px; /* Force widget margins to stay inside of the container */\n}\n\n.CodeMirror-widget {}\n\n.CodeMirror-rtl pre { direction: rtl; }\n\n.CodeMirror-code {\n  outline: none;\n}\n\n/* Force content-box sizing for the elements where we expect it */\n.CodeMirror-scroll,\n.CodeMirror-sizer,\n.CodeMirror-gutter,\n.CodeMirror-gutters,\n.CodeMirror-linenumber {\n  -moz-box-sizing: content-box;\n  box-sizing: content-box;\n}\n\n.CodeMirror-measure {\n  position: absolute;\n  width: 100%;\n  height: 0;\n  overflow: hidden;\n  visibility: hidden;\n}\n\n.CodeMirror-cursor {\n  position: absolute;\n  pointer-events: none;\n}\n.CodeMirror-measure pre { position: static; }\n\ndiv.CodeMirror-cursors {\n  visibility: hidden;\n  position: relative;\n  z-index: 3;\n}\ndiv.CodeMirror-dragcursors {\n  visibility: visible;\n}\n\n.CodeMirror-focused div.CodeMirror-cursors {\n  visibility: visible;\n}\n\n.CodeMirror-selected { background: #d9d9d9; }\n.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }\n.CodeMirror-crosshair { cursor: crosshair; }\n.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }\n.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }\n\n.cm-searching {\n  background-color: #ffa;\n  background-color: rgba(255, 255, 0, .4);\n}\n\n/* Used to force a border model for a node */\n.cm-force-border { padding-right: .1px; }\n\n@media print {\n  /* Hide the cursor when printing */\n  .CodeMirror div.CodeMirror-cursors {\n    visibility: hidden;\n  }\n}\n\n/* See issue #2901 */\n.cm-tab-wrap-hack:after { content: ''; }\n\n/* Help users use markselection to safely style text background */\nspan.CodeMirror-selectedtext { background: none; }\n", ""]);



/***/ }),
/* 420 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(421);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 421 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/* ## override CSS */\n\n/* spell-checker:ignore selectedtext */\n\n/* ToDO: document useful CSS configuration/modifications (with examples below) */\n\n/* note: include this CSS as the last lexically in order to override without having to use increased CSS specificity */\n\n/* required CodeMirror CSS */\n/* minimally required gutter configuration */\n.CodeMirror-gutter-extra { min-width: 2em; }\n/* # minimally required prefix configuration */\n.CodeMirror-prefix { width: 1em; }\n.CodeMirror-prefix-text { padding-left: 0.25em; }\n.CodeMirror-prefix.CodeMirror-prefix-sizer { width: 0.5em; padding-left: 0; }\n\n/* ### .CodeMirror default customization */\n/* #* code block border configuration */\n.CodeMirror {\n  border: 1px solid gainsboro /* #f7f7f7 == default CodeMirror border color */;\n  border-radius: 0.2em;\n}\n/* #* gutter configuration */\n.CodeMirror-gutter-extra { background-color: hsla( 0, 0%, 50%, 0.1) /* #f5f5f5 == default CodeMirror color */; }\n/* #** prefix gutter customization */\n.CodeMirror-prefix { background-color: hsla( 0, 0%, 50%, 0.1); }\n.CodeMirror-prefix-text { color: hsla( 0, 0%, 50%, 0.75); }\n\n/*  CodeMirror CSS uses '.CodeMirror pre', use same here for specificity */\n/*.CodeMirror, .CodeMirror pre { font-family: \"Fira Code\", \"Open Sans Mono\", \"Anonymous Pro\", \"Consolas\", \"Lucida Console\", monospace;*/\n/*.CodeMirror, .CodeMirror pre { font-size: 1em; line-height: 1.3em; }*/\n/*.CodeMirror, .CodeMirror pre { font-family: inherit; font-size: 1em; line-height: 1.3em; }*/\n.CodeMirror { font: inherit; }\n.CodeMirror, .CodeMirror pre { font-variant-ligatures: none; -webkit-font-variant-ligatures: none; }\n/*.CodeMirror, .CodeMirror pre { font-variant-ligatures: contextual; -webkit-font-variant-ligatures: contextual; }*/\n\n/* enable visible selection (regardless of theme) */\n.CodeMirror-selected  { background-color: blue !important; }\n.CodeMirror-selectedtext { color: white !important; text-shadow: none; }\n\n.CodeMirror pre { padding: 0 0.33em; } /* default == 0 4px */\n.CodeMirror-lines { padding: 0.125em 1px; } /* vertical padding */\n", ""]);



/***/ }),
/* 422 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(423);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 423 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/* Based on Sublime Text's Monokai theme */\n\n.cm-s-monokai.CodeMirror { background: #272822; color: #f8f8f2; }\n.cm-s-monokai div.CodeMirror-selected { background: #49483E; }\n.cm-s-monokai .CodeMirror-line::selection, .cm-s-monokai .CodeMirror-line > span::selection, .cm-s-monokai .CodeMirror-line > span > span::selection { background: rgba(73, 72, 62, .99); }\n.cm-s-monokai .CodeMirror-line::-moz-selection, .cm-s-monokai .CodeMirror-line > span::-moz-selection, .cm-s-monokai .CodeMirror-line > span > span::-moz-selection { background: rgba(73, 72, 62, .99); }\n.cm-s-monokai .CodeMirror-gutters { background: #272822; border-right: 0px; }\n.cm-s-monokai .CodeMirror-guttermarker { color: white; }\n.cm-s-monokai .CodeMirror-guttermarker-subtle { color: #d0d0d0; }\n.cm-s-monokai .CodeMirror-linenumber { color: #d0d0d0; }\n.cm-s-monokai .CodeMirror-cursor { border-left: 1px solid #f8f8f0; }\n\n.cm-s-monokai span.cm-comment { color: #75715e; }\n.cm-s-monokai span.cm-atom { color: #ae81ff; }\n.cm-s-monokai span.cm-number { color: #ae81ff; }\n\n.cm-s-monokai span.cm-comment.cm-attribute { color: #97b757; }\n.cm-s-monokai span.cm-comment.cm-def { color: #bc9262; }\n.cm-s-monokai span.cm-comment.cm-tag { color: #bc6283; }\n.cm-s-monokai span.cm-comment.cm-type { color: #5998a6; }\n\n.cm-s-monokai span.cm-property, .cm-s-monokai span.cm-attribute { color: #a6e22e; }\n.cm-s-monokai span.cm-keyword { color: #f92672; }\n.cm-s-monokai span.cm-builtin { color: #66d9ef; }\n.cm-s-monokai span.cm-string { color: #e6db74; }\n\n.cm-s-monokai span.cm-variable { color: #f8f8f2; }\n.cm-s-monokai span.cm-variable-2 { color: #9effff; }\n.cm-s-monokai span.cm-variable-3, .cm-s-monokai span.cm-type { color: #66d9ef; }\n.cm-s-monokai span.cm-def { color: #fd971f; }\n.cm-s-monokai span.cm-bracket { color: #f8f8f2; }\n.cm-s-monokai span.cm-tag { color: #f92672; }\n.cm-s-monokai span.cm-header { color: #ae81ff; }\n.cm-s-monokai span.cm-link { color: #ae81ff; }\n.cm-s-monokai span.cm-error { background: #f92672; color: #f8f8f0; }\n\n.cm-s-monokai .CodeMirror-activeline-background { background: #373831; }\n.cm-s-monokai .CodeMirror-matchingbracket {\n  text-decoration: underline;\n  color: white !important;\n}\n", ""]);



/***/ }),
/* 424 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(425);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 425 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/*\nSolarized theme for code-mirror\nhttp://ethanschoonover.com/solarized\n*/\n\n/*\nSolarized color palette\nhttp://ethanschoonover.com/solarized/img/solarized-palette.png\n*/\n\n.solarized.base03 { color: #002b36; }\n.solarized.base02 { color: #073642; }\n.solarized.base01 { color: #586e75; }\n.solarized.base00 { color: #657b83; }\n.solarized.base0 { color: #839496; }\n.solarized.base1 { color: #93a1a1; }\n.solarized.base2 { color: #eee8d5; }\n.solarized.base3  { color: #fdf6e3; }\n.solarized.solar-yellow  { color: #b58900; }\n.solarized.solar-orange  { color: #cb4b16; }\n.solarized.solar-red { color: #dc322f; }\n.solarized.solar-magenta { color: #d33682; }\n.solarized.solar-violet  { color: #6c71c4; }\n.solarized.solar-blue { color: #268bd2; }\n.solarized.solar-cyan { color: #2aa198; }\n.solarized.solar-green { color: #859900; }\n\n/* Color scheme for code-mirror */\n\n.cm-s-solarized {\n  line-height: 1.45em;\n  color-profile: sRGB;\n  rendering-intent: auto;\n}\n.cm-s-solarized.cm-s-dark {\n  color: #839496;\n  background-color: #002b36;\n  text-shadow: #002b36 0 1px;\n}\n.cm-s-solarized.cm-s-light {\n  background-color: #fdf6e3;\n  color: #657b83;\n  text-shadow: #eee8d5 0 1px;\n}\n\n.cm-s-solarized .CodeMirror-widget {\n  text-shadow: none;\n}\n\n.cm-s-solarized .cm-header { color: #586e75; }\n.cm-s-solarized .cm-quote { color: #93a1a1; }\n\n.cm-s-solarized .cm-keyword { color: #cb4b16; }\n.cm-s-solarized .cm-atom { color: #d33682; }\n.cm-s-solarized .cm-number { color: #d33682; }\n.cm-s-solarized .cm-def { color: #2aa198; }\n\n.cm-s-solarized .cm-variable { color: #839496; }\n.cm-s-solarized .cm-variable-2 { color: #b58900; }\n.cm-s-solarized .cm-variable-3, .cm-s-solarized .cm-type { color: #6c71c4; }\n\n.cm-s-solarized .cm-property { color: #2aa198; }\n.cm-s-solarized .cm-operator { color: #6c71c4; }\n\n.cm-s-solarized .cm-comment { color: #586e75; font-style:italic; }\n\n.cm-s-solarized .cm-string { color: #859900; }\n.cm-s-solarized .cm-string-2 { color: #b58900; }\n\n.cm-s-solarized .cm-meta { color: #859900; }\n.cm-s-solarized .cm-qualifier { color: #b58900; }\n.cm-s-solarized .cm-builtin { color: #d33682; }\n.cm-s-solarized .cm-bracket { color: #cb4b16; }\n.cm-s-solarized .CodeMirror-matchingbracket { color: #859900; }\n.cm-s-solarized .CodeMirror-nonmatchingbracket { color: #dc322f; }\n.cm-s-solarized .cm-tag { color: #93a1a1; }\n.cm-s-solarized .cm-attribute { color: #2aa198; }\n.cm-s-solarized .cm-hr {\n  color: transparent;\n  border-top: 1px solid #586e75;\n  display: block;\n}\n.cm-s-solarized .cm-link { color: #93a1a1; cursor: pointer; }\n.cm-s-solarized .cm-special { color: #6c71c4; }\n.cm-s-solarized .cm-em {\n  color: #999;\n  text-decoration: underline;\n  text-decoration-style: dotted;\n}\n.cm-s-solarized .cm-error,\n.cm-s-solarized .cm-invalidchar {\n  color: #586e75;\n  border-bottom: 1px dotted #dc322f;\n}\n\n.cm-s-solarized.cm-s-dark div.CodeMirror-selected { background: #073642; }\n.cm-s-solarized.cm-s-dark.CodeMirror ::selection { background: rgba(7, 54, 66, 0.99); }\n.cm-s-solarized.cm-s-dark .CodeMirror-line::-moz-selection, .cm-s-dark .CodeMirror-line > span::-moz-selection, .cm-s-dark .CodeMirror-line > span > span::-moz-selection { background: rgba(7, 54, 66, 0.99); }\n\n.cm-s-solarized.cm-s-light div.CodeMirror-selected { background: #eee8d5; }\n.cm-s-solarized.cm-s-light .CodeMirror-line::selection, .cm-s-light .CodeMirror-line > span::selection, .cm-s-light .CodeMirror-line > span > span::selection { background: #eee8d5; }\n.cm-s-solarized.cm-s-light .CodeMirror-line::-moz-selection, .cm-s-ligh .CodeMirror-line > span::-moz-selection, .cm-s-ligh .CodeMirror-line > span > span::-moz-selection { background: #eee8d5; }\n\n/* Editor styling */\n\n\n\n/* Little shadow on the view-port of the buffer view */\n.cm-s-solarized.CodeMirror {\n  -moz-box-shadow: inset 7px 0 12px -6px #000;\n  -webkit-box-shadow: inset 7px 0 12px -6px #000;\n  box-shadow: inset 7px 0 12px -6px #000;\n}\n\n/* Remove gutter border */\n.cm-s-solarized .CodeMirror-gutters {\n  border-right: 0;\n}\n\n/* Gutter colors and line number styling based of color scheme (dark / light) */\n\n/* Dark */\n.cm-s-solarized.cm-s-dark .CodeMirror-gutters {\n  background-color: #073642;\n}\n\n.cm-s-solarized.cm-s-dark .CodeMirror-linenumber {\n  color: #586e75;\n  text-shadow: #021014 0 -1px;\n}\n\n/* Light */\n.cm-s-solarized.cm-s-light .CodeMirror-gutters {\n  background-color: #eee8d5;\n}\n\n.cm-s-solarized.cm-s-light .CodeMirror-linenumber {\n  color: #839496;\n}\n\n/* Common */\n.cm-s-solarized .CodeMirror-linenumber {\n  padding: 0 5px;\n}\n.cm-s-solarized .CodeMirror-guttermarker-subtle { color: #586e75; }\n.cm-s-solarized.cm-s-dark .CodeMirror-guttermarker { color: #ddd; }\n.cm-s-solarized.cm-s-light .CodeMirror-guttermarker { color: #cb4b16; }\n\n.cm-s-solarized .CodeMirror-gutter .CodeMirror-gutter-text {\n  color: #586e75;\n}\n\n/* Cursor */\n.cm-s-solarized .CodeMirror-cursor { border-left: 1px solid #819090; }\n\n/* Fat cursor */\n.cm-s-solarized.cm-s-light.cm-fat-cursor .CodeMirror-cursor { background: #77ee77; }\n.cm-s-solarized.cm-s-light .cm-animate-fat-cursor { background-color: #77ee77; }\n.cm-s-solarized.cm-s-dark.cm-fat-cursor .CodeMirror-cursor { background: #586e75; }\n.cm-s-solarized.cm-s-dark .cm-animate-fat-cursor { background-color: #586e75; }\n\n/* Active line */\n.cm-s-solarized.cm-s-dark .CodeMirror-activeline-background {\n  background: rgba(255, 255, 255, 0.06);\n}\n.cm-s-solarized.cm-s-light .CodeMirror-activeline-background {\n  background: rgba(0, 0, 0, 0.06);\n}\n", ""]);



/***/ }),
/* 426 */
/***/ (function(module, exports, __webpack_require__) {


var content = __webpack_require__(427);

if(typeof content === 'string') content = [[module.i, content, '']];

var transform;
var insertInto;



var options = {"hmr":true}

options.transform = transform
options.insertInto = undefined;

var update = __webpack_require__(13)(content, options);

if(content.locals) module.exports = content.locals;

if(false) {}

/***/ }),
/* 427 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(12)(false);
// Module
exports.push([module.i, "/**\n * \"\n *  Using Zenburn color palette from the Emacs Zenburn Theme\n *  https://github.com/bbatsov/zenburn-emacs/blob/master/zenburn-theme.el\n *\n *  Also using parts of https://github.com/xavi/coderay-lighttable-theme\n * \"\n * From: https://github.com/wisenomad/zenburn-lighttable-theme/blob/master/zenburn.css\n */\n\n.cm-s-zenburn .CodeMirror-gutters { background: #3f3f3f !important; }\n.cm-s-zenburn .CodeMirror-foldgutter-open, .CodeMirror-foldgutter-folded { color: #999; }\n.cm-s-zenburn .CodeMirror-cursor { border-left: 1px solid white; }\n.cm-s-zenburn.CodeMirror { background-color: #3f3f3f; color: #dcdccc; }\n.cm-s-zenburn span.cm-builtin { color: #dcdccc; font-weight: bold; }\n.cm-s-zenburn span.cm-comment { color: #7f9f7f; }\n.cm-s-zenburn span.cm-keyword { color: #f0dfaf; font-weight: bold; }\n.cm-s-zenburn span.cm-atom { color: #bfebbf; }\n.cm-s-zenburn span.cm-def { color: #dcdccc; }\n.cm-s-zenburn span.cm-variable { color: #dfaf8f; }\n.cm-s-zenburn span.cm-variable-2 { color: #dcdccc; }\n.cm-s-zenburn span.cm-string { color: #cc9393; }\n.cm-s-zenburn span.cm-string-2 { color: #cc9393; }\n.cm-s-zenburn span.cm-number { color: #dcdccc; }\n.cm-s-zenburn span.cm-tag { color: #93e0e3; }\n.cm-s-zenburn span.cm-property { color: #dfaf8f; }\n.cm-s-zenburn span.cm-attribute { color: #dfaf8f; }\n.cm-s-zenburn span.cm-qualifier { color: #7cb8bb; }\n.cm-s-zenburn span.cm-meta { color: #f0dfaf; }\n.cm-s-zenburn span.cm-header { color: #f0efd0; }\n.cm-s-zenburn span.cm-operator { color: #f0efd0; }\n.cm-s-zenburn span.CodeMirror-matchingbracket { box-sizing: border-box; background: transparent; border-bottom: 1px solid; }\n.cm-s-zenburn span.CodeMirror-nonmatchingbracket { border-bottom: 1px solid; background: none; }\n.cm-s-zenburn .CodeMirror-activeline { background: #000000; }\n.cm-s-zenburn .CodeMirror-activeline-background { background: #000000; }\n.cm-s-zenburn div.CodeMirror-selected { background: #545454; }\n.cm-s-zenburn .CodeMirror-focused div.CodeMirror-selected { background: #4f4f4f; }\n", ""]);



/***/ })
/******/ ]);
});
//# sourceMappingURL=markdown-render.user.js.map