text: (function(){function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}return e})()({1:[function(require,module,exports){
  /*!
    Copyright (c) 2016 Jed Watson.
    Licensed under the MIT License (MIT), see
    http://jedwatson.github.io/classnames
  */
  /* global define */
  
  (function () {
  	'use strict';
  
  	var hasOwn = {}.hasOwnProperty;
  
  	function classNames () {
  		var classes = [];
  
  		for (var i = 0; i < arguments.length; i++) {
  			var arg = arguments[i];
  			if (!arg) continue;
  
  			var argType = typeof arg;
  
  			if (argType === 'string' || argType === 'number') {
  				classes.push(arg);
  			} else if (Array.isArray(arg)) {
  				classes.push(classNames.apply(null, arg));
  			} else if (argType === 'object') {
  				for (var key in arg) {
  					if (hasOwn.call(arg, key) && arg[key]) {
  						classes.push(key);
  					}
  				}
  			}
  		}
  
  		return classes.join(' ');
  	}
  
  	if (typeof module !== 'undefined' && module.exports) {
  		module.exports = classNames;
  	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
  		// register as 'classnames', consistent with npm package name
  		define('classnames', [], function () {
  			return classNames;
  		});
  	} else {
  		window.classNames = classNames;
  	}
  }());
  
  },{}],2:[function(require,module,exports){
  /**
   * Copyright Marc J. Schmidt. See the LICENSE file at the top-level
   * directory of this distribution and at
   * https://github.com/marcj/css-element-queries/blob/master/LICENSE.
   */
  ;
  (function() {
  
      var ResizeSensor = window.ResizeSensor;
  
      if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
          ResizeSensor = require('./ResizeSensor');
      }
  
      /**
       *
       * @type {Function}
       * @constructor
       */
      var ElementQueries = this.ElementQueries = function() {
  
          var trackingActive = false;
          var elements = [];
  
          /**
           *
           * @param element
           * @returns {Number}
           */
          function getEmSize(element) {
              if (!element) {
                  element = document.documentElement;
              }
              var fontSize = getComputedStyle(element, 'fontSize');
              return parseFloat(fontSize) || 16;
          }
  
          /**
           *
           * @copyright https://github.com/Mr0grog/element-query/blob/master/LICENSE
           *
           * @param {HTMLElement} element
           * @param {*} value
           * @returns {*}
           */
          function convertToPx(element, value) {
              var units = value.replace(/[0-9]*/, '');
              value = parseFloat(value);
              switch (units) {
                  case "px":
                      return value;
                  case "em":
                      return value * getEmSize(element);
                  case "rem":
                      return value * getEmSize();
                  // Viewport units!
                  // According to http://quirksmode.org/mobile/tableViewport.html
                  // documentElement.clientWidth/Height gets us the most reliable info
                  case "vw":
                      return value * document.documentElement.clientWidth / 100;
                  case "vh":
                      return value * document.documentElement.clientHeight / 100;
                  case "vmin":
                  case "vmax":
                      var vw = document.documentElement.clientWidth / 100;
                      var vh = document.documentElement.clientHeight / 100;
                      var chooser = Math[units === "vmin" ? "min" : "max"];
                      return value * chooser(vw, vh);
                  default:
                      return value;
                  // for now, not supporting physical units (since they are just a set number of px)
                  // or ex/ch (getting accurate measurements is hard)
              }
          }
  
          /**
           *
           * @param {HTMLElement} element
           * @constructor
           */
          function SetupInformation(element) {
              this.element = element;
              this.options = {};
              var key, option, width = 0, height = 0, value, actualValue, attrValues, attrValue, attrName;
  
              /**
               * @param {Object} option {mode: 'min|max', property: 'width|height', value: '123px'}
               */
              this.addOption = function(option) {
                  var idx = [option.mode, option.property, option.value].join(',');
                  this.options[idx] = option;
              };
  
              var attributes = ['min-width', 'min-height', 'max-width', 'max-height'];
  
              /**
               * Extracts the computed width/height and sets to min/max- attribute.
               */
              this.call = function() {
                  // extract current dimensions
                  width = this.element.offsetWidth;
                  height = this.element.offsetHeight;
  
                  attrValues = {};
  
                  for (key in this.options) {
                      if (!this.options.hasOwnProperty(key)){
                          continue;
                      }
                      option = this.options[key];
  
                      value = convertToPx(this.element, option.value);
  
                      actualValue = option.property == 'width' ? width : height;
                      attrName = option.mode + '-' + option.property;
                      attrValue = '';
  
                      if (option.mode == 'min' && actualValue >= value) {
                          attrValue += option.value;
                      }
  
                      if (option.mode == 'max' && actualValue <= value) {
                          attrValue += option.value;
                      }
  
                      if (!attrValues[attrName]) attrValues[attrName] = '';
                      if (attrValue && -1 === (' '+attrValues[attrName]+' ').indexOf(' ' + attrValue + ' ')) {
                          attrValues[attrName] += ' ' + attrValue;
                      }
                  }
  
                  for (var k in attributes) {
                      if(!attributes.hasOwnProperty(k)) continue;
  
                      if (attrValues[attributes[k]]) {
                          this.element.setAttribute(attributes[k], attrValues[attributes[k]].substr(1));
                      } else {
                          this.element.removeAttribute(attributes[k]);
                      }
                  }
              };
          }
  
          /**
           * @param {HTMLElement} element
           * @param {Object}      options
           */
          function setupElement(element, options) {
              if (element.elementQueriesSetupInformation) {
                  element.elementQueriesSetupInformation.addOption(options);
              } else {
                  element.elementQueriesSetupInformation = new SetupInformation(element);
                  element.elementQueriesSetupInformation.addOption(options);
                  element.elementQueriesSensor = new ResizeSensor(element, function() {
                      element.elementQueriesSetupInformation.call();
                  });
              }
              element.elementQueriesSetupInformation.call();
  
              if (trackingActive && elements.indexOf(element) < 0) {
                  elements.push(element);
              }
          }
  
          /**
           * @param {String} selector
           * @param {String} mode min|max
           * @param {String} property width|height
           * @param {String} value
           */
          var allQueries = {};
          function queueQuery(selector, mode, property, value) {
              if (typeof(allQueries[mode]) == 'undefined') allQueries[mode] = {};
              if (typeof(allQueries[mode][property]) == 'undefined') allQueries[mode][property] = {};
              if (typeof(allQueries[mode][property][value]) == 'undefined') allQueries[mode][property][value] = selector;
              else allQueries[mode][property][value] += ','+selector;
          }
  
          function getQuery() {
              var query;
              if (document.querySelectorAll) query = document.querySelectorAll.bind(document);
              if (!query && 'undefined' !== typeof $$) query = $$;
              if (!query && 'undefined' !== typeof jQuery) query = jQuery;
  
              if (!query) {
                  throw 'No document.querySelectorAll, jQuery or Mootools\'s $$ found.';
              }
  
              return query;
          }
  
          /**
           * Start the magic. Go through all collected rules (readRules()) and attach the resize-listener.
           */
          function findElementQueriesElements() {
              var query = getQuery();
  
              for (var mode in allQueries) if (allQueries.hasOwnProperty(mode)) {
  
                  for (var property in allQueries[mode]) if (allQueries[mode].hasOwnProperty(property)) {
                      for (var value in allQueries[mode][property]) if (allQueries[mode][property].hasOwnProperty(value)) {
                          var elements = query(allQueries[mode][property][value]);
                          for (var i = 0, j = elements.length; i < j; i++) {
                              setupElement(elements[i], {
                                  mode: mode,
                                  property: property,
                                  value: value
                              });
                          }
                      }
                  }
  
              }
          }
  
          /**
           *
           * @param {HTMLElement} element
           */
          function attachResponsiveImage(element) {
              var children = [];
              var rules = [];
              var sources = [];
              var defaultImageId = 0;
              var lastActiveImage = -1;
              var loadedImages = [];
  
              for (var i in element.children) {
                  if(!element.children.hasOwnProperty(i)) continue;
  
                  if (element.children[i].tagName && element.children[i].tagName.toLowerCase() === 'img') {
                      children.push(element.children[i]);
  
                      var minWidth = element.children[i].getAttribute('min-width') || element.children[i].getAttribute('data-min-width');
                      //var minHeight = element.children[i].getAttribute('min-height') || element.children[i].getAttribute('data-min-height');
                      var src = element.children[i].getAttribute('data-src') || element.children[i].getAttribute('url');
  
                      sources.push(src);
  
                      var rule = {
                          minWidth: minWidth
                      };
  
                      rules.push(rule);
  
                      if (!minWidth) {
                          defaultImageId = children.length - 1;
                          element.children[i].style.display = 'block';
                      } else {
                          element.children[i].style.display = 'none';
                      }
                  }
              }
  
              lastActiveImage = defaultImageId;
  
              function check() {
                  var imageToDisplay = false, i;
  
                  for (i in children){
                      if(!children.hasOwnProperty(i)) continue;
  
                      if (rules[i].minWidth) {
                          if (element.offsetWidth > rules[i].minWidth) {
                              imageToDisplay = i;
                          }
                      }
                  }
  
                  if (!imageToDisplay) {
                      //no rule matched, show default
                      imageToDisplay = defaultImageId;
                  }
  
                  if (lastActiveImage != imageToDisplay) {
                      //image change
  
                      if (!loadedImages[imageToDisplay]){
                          //image has not been loaded yet, we need to load the image first in memory to prevent flash of
                          //no content
  
                          var image = new Image();
                          image.onload = function() {
                              children[imageToDisplay].src = sources[imageToDisplay];
  
                              children[lastActiveImage].style.display = 'none';
                              children[imageToDisplay].style.display = 'block';
  
                              loadedImages[imageToDisplay] = true;
  
                              lastActiveImage = imageToDisplay;
                          };
  
                          image.src = sources[imageToDisplay];
                      } else {
                          children[lastActiveImage].style.display = 'none';
                          children[imageToDisplay].style.display = 'block';
                          lastActiveImage = imageToDisplay;
                      }
                  } else {
                      //make sure for initial check call the .src is set correctly
                      children[imageToDisplay].src = sources[imageToDisplay];
                  }
              }
  
              element.resizeSensor = new ResizeSensor(element, check);
              check();
  
              if (trackingActive) {
                  elements.push(element);
              }
          }
  
          function findResponsiveImages(){
              var query = getQuery();
  
              var elements = query('[data-responsive-image],[responsive-image]');
              for (var i = 0, j = elements.length; i < j; i++) {
                  attachResponsiveImage(elements[i]);
              }
          }
  
          var regex = /,?[\s\t]*([^,\n]*?)((?:\[[\s\t]*?(?:min|max)-(?:width|height)[\s\t]*?[~$\^]?=[\s\t]*?"[^"]*?"[\s\t]*?])+)([^,\n\s\{]*)/mgi;
          var attrRegex = /\[[\s\t]*?(min|max)-(width|height)[\s\t]*?[~$\^]?=[\s\t]*?"([^"]*?)"[\s\t]*?]/mgi;
          /**
           * @param {String} css
           */
          function extractQuery(css) {
              var match;
              var smatch;
              css = css.replace(/'/g, '"');
              while (null !== (match = regex.exec(css))) {
                  smatch = match[1] + match[3];
                  attrs = match[2];
  
                  while (null !== (attrMatch = attrRegex.exec(attrs))) {
                      queueQuery(smatch, attrMatch[1], attrMatch[2], attrMatch[3]);
                  }
              }
          }
  
          /**
           * @param {CssRule[]|String} rules
           */
          function readRules(rules) {
              var selector = '';
              if (!rules) {
                  return;
              }
              if ('string' === typeof rules) {
                  rules = rules.toLowerCase();
                  if (-1 !== rules.indexOf('min-width') || -1 !== rules.indexOf('max-width')) {
                      extractQuery(rules);
                  }
              } else {
                  for (var i = 0, j = rules.length; i < j; i++) {
                      if (1 === rules[i].type) {
                          selector = rules[i].selectorText || rules[i].cssText;
                          if (-1 !== selector.indexOf('min-height') || -1 !== selector.indexOf('max-height')) {
                              extractQuery(selector);
                          }else if(-1 !== selector.indexOf('min-width') || -1 !== selector.indexOf('max-width')) {
                              extractQuery(selector);
                          }
                      } else if (4 === rules[i].type) {
                          readRules(rules[i].cssRules || rules[i].rules);
                      }
                  }
              }
          }
  
          var defaultCssInjected = false;
  
          /**
           * Searches all css rules and setups the event listener to all elements with element query rules..
           *
           * @param {Boolean} withTracking allows and requires you to use detach, since we store internally all used elements
           *                               (no garbage collection possible if you don not call .detach() first)
           */
          this.init = function(withTracking) {
              trackingActive = typeof withTracking === 'undefined' ? false : withTracking;
  
              for (var i = 0, j = document.styleSheets.length; i < j; i++) {
                  try {
                      readRules(document.styleSheets[i].cssRules || document.styleSheets[i].rules || document.styleSheets[i].cssText);
                  } catch(e) {
                      if (e.name !== 'SecurityError') {
                          throw e;
                      }
                  }
              }
  
              if (!defaultCssInjected) {
                  var style = document.createElement('style');
                  style.type = 'text/css';
                  style.innerHTML = '[responsive-image] > img, [data-responsive-image] {overflow: hidden; padding: 0; } [responsive-image] > img, [data-responsive-image] > img { width: 100%;}';
                  document.getElementsByTagName('head')[0].appendChild(style);
                  defaultCssInjected = true;
              }
  
              findElementQueriesElements();
              findResponsiveImages();
          };
  
          /**
           *
           * @param {Boolean} withTracking allows and requires you to use detach, since we store internally all used elements
           *                               (no garbage collection possible if you don not call .detach() first)
           */
          this.update = function(withTracking) {
              this.init(withTracking);
          };
  
          this.detach = function() {
              if (!this.withTracking) {
                  throw 'withTracking is not enabled. We can not detach elements since we don not store it.' +
                  'Use ElementQueries.withTracking = true; before domready or call ElementQueryes.update(true).';
              }
  
              var element;
              while (element = elements.pop()) {
                  ElementQueries.detach(element);
              }
  
              elements = [];
          };
      };
  
      /**
       *
       * @param {Boolean} withTracking allows and requires you to use detach, since we store internally all used elements
       *                               (no garbage collection possible if you don not call .detach() first)
       */
      ElementQueries.update = function(withTracking) {
          ElementQueries.instance.update(withTracking);
      };
  
      /**
       * Removes all sensor and elementquery information from the element.
       *
       * @param {HTMLElement} element
       */
      ElementQueries.detach = function(element) {
          if (element.elementQueriesSetupInformation) {
              //element queries
              element.elementQueriesSensor.detach();
              delete element.elementQueriesSetupInformation;
              delete element.elementQueriesSensor;
  
          } else if (element.resizeSensor) {
              //responsive image
  
              element.resizeSensor.detach();
              delete element.resizeSensor;
          } else {
              //console.log('detached already', element);
          }
      };
  
      ElementQueries.withTracking = false;
  
      ElementQueries.init = function() {
          if (!ElementQueries.instance) {
              ElementQueries.instance = new ElementQueries();
          }
  
          ElementQueries.instance.init(ElementQueries.withTracking);
      };
  
      var domLoaded = function (callback) {
          /* Internet Explorer */
          /*@cc_on
           @if (@_win32 || @_win64)
           document.write('<script id="ieScriptLoad" defer src="//:"><\/script>');
           document.getElementById('ieScriptLoad').onreadystatechange = function() {
           if (this.readyState == 'complete') {
           callback();
           }
           };
           @end @*/
          /* Mozilla, Chrome, Opera */
          if (document.addEventListener) {
              document.addEventListener('DOMContentLoaded', callback, false);
          }
          /* Safari, iCab, Konqueror */
          else if (/KHTML|WebKit|iCab/i.test(navigator.userAgent)) {
              var DOMLoadTimer = setInterval(function () {
                  if (/loaded|complete/i.test(document.readyState)) {
                      callback();
                      clearInterval(DOMLoadTimer);
                  }
              }, 10);
          }
          /* Other web browsers */
          else window.onload = callback;
      };
  
      ElementQueries.listen = function() {
          domLoaded(ElementQueries.init);
      };
  
      // make available to common module loader
      if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
          module.exports = ElementQueries;
      }
      else {
          window.ElementQueries = ElementQueries;
          ElementQueries.listen();
      }
  })();
  },{"./ResizeSensor":3}],3:[function(require,module,exports){
  /**
   * Copyright Marc J. Schmidt. See the LICENSE file at the top-level
   * directory of this distribution and at
   * https://github.com/marcj/css-element-queries/blob/master/LICENSE.
   */
  ;
  (function() {
  
      /**
       * Class for dimension change detection.
       *
       * @param {Element|Element[]|Elements|jQuery} element
       * @param {Function} callback
       *
       * @constructor
       */
      var ResizeSensor = function(element, callback) {
          /**
           *
           * @constructor
           */
          function EventQueue() {
              this.q = [];
              this.add = function(ev) {
                  this.q.push(ev);
              };
  
              var i, j;
              this.call = function() {
                  for (i = 0, j = this.q.length; i < j; i++) {
                      this.q[i].call();
                  }
              };
          }
  
          /**
           * @param {HTMLElement} element
           * @param {String}      prop
           * @returns {String|Number}
           */
          function getComputedStyle(element, prop) {
              if (element.currentStyle) {
                  return element.currentStyle[prop];
              } else if (window.getComputedStyle) {
                  return window.getComputedStyle(element, null).getPropertyValue(prop);
              } else {
                  return element.style[prop];
              }
          }
  
          /**
           *
           * @param {HTMLElement} element
           * @param {Function}    resized
           */
          function attachResizeEvent(element, resized) {
              if (!element.resizedAttached) {
                  element.resizedAttached = new EventQueue();
                  element.resizedAttached.add(resized);
              } else if (element.resizedAttached) {
                  element.resizedAttached.add(resized);
                  return;
              }
  
              element.resizeSensor = document.createElement('div');
              element.resizeSensor.className = 'resize-sensor';
              var style = 'position: absolute; left: 0; top: 0; right: 0; bottom: 0; overflow: hidden; z-index: -1; visibility: hidden;';
              var styleChild = 'position: absolute; left: 0; top: 0; transition: 0s;';
  
              element.resizeSensor.style.cssText = style;
              element.resizeSensor.innerHTML =
                  '<div class="resize-sensor-expand" style="' + style + '">' +
                      '<div style="' + styleChild + '"></div>' +
                  '</div>' +
                  '<div class="resize-sensor-shrink" style="' + style + '">' +
                      '<div style="' + styleChild + ' width: 200%; height: 200%"></div>' +
                  '</div>';
              element.appendChild(element.resizeSensor);
  
              if (!{fixed: 1, absolute: 1}[getComputedStyle(element, 'position')]) {
                  element.style.position = 'relative';
              }
  
              var expand = element.resizeSensor.childNodes[0];
              var expandChild = expand.childNodes[0];
              var shrink = element.resizeSensor.childNodes[1];
              var shrinkChild = shrink.childNodes[0];
  
              var lastWidth, lastHeight;
  
              var reset = function() {
                  expandChild.style.width = expand.offsetWidth + 10 + 'px';
                  expandChild.style.height = expand.offsetHeight + 10 + 'px';
                  expand.scrollLeft = expand.scrollWidth;
                  expand.scrollTop = expand.scrollHeight;
                  shrink.scrollLeft = shrink.scrollWidth;
                  shrink.scrollTop = shrink.scrollHeight;
                  lastWidth = element.offsetWidth;
                  lastHeight = element.offsetHeight;
              };
  
              reset();
  
              var changed = function() {
                  if (element.resizedAttached) {
                      element.resizedAttached.call();
                  }
              };
  
              var addEvent = function(el, name, cb) {
                  if (el.attachEvent) {
                      el.attachEvent('on' + name, cb);
                  } else {
                      el.addEventListener(name, cb);
                  }
              };
  
              var onScroll = function() {
                if (element.offsetWidth != lastWidth || element.offsetHeight != lastHeight) {
                    changed();
                }
                reset();
              };
  
              addEvent(expand, 'scroll', onScroll);
              addEvent(shrink, 'scroll', onScroll);
          }
  
          var elementType = Object.prototype.toString.call(element);
          var isCollectionTyped = ('[object Array]' === elementType
              || ('[object NodeList]' === elementType)
              || ('[object HTMLCollection]' === elementType)
              || ('undefined' !== typeof jQuery && element instanceof jQuery) //jquery
              || ('undefined' !== typeof Elements && element instanceof Elements) //mootools
          );
  
          if (isCollectionTyped) {
              var i = 0, j = element.length;
              for (; i < j; i++) {
                  attachResizeEvent(element[i], callback);
              }
          } else {
              attachResizeEvent(element, callback);
          }
  
          this.detach = function() {
              if (isCollectionTyped) {
                  var i = 0, j = element.length;
                  for (; i < j; i++) {
                      ResizeSensor.detach(element[i]);
                  }
              } else {
                  ResizeSensor.detach(element);
              }
          };
      };
  
      ResizeSensor.detach = function(element) {
          if (element.resizeSensor) {
              element.removeChild(element.resizeSensor);
              delete element.resizeSensor;
              delete element.resizedAttached;
          }
      };
  
      // make available to common module loader
      if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
          module.exports = ResizeSensor;
      }
      else {
          window.ResizeSensor = ResizeSensor;
      }
  
  })();
  
  },{}],4:[function(require,module,exports){
  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"}
  },{}],5:[function(require,module,exports){
  // 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.
  
  function EventEmitter() {
    this._events = this._events || {};
    this._maxListeners = this._maxListeners || undefined;
  }
  module.exports = EventEmitter;
  
  // Backwards-compat with node 0.10.x
  EventEmitter.EventEmitter = EventEmitter;
  
  EventEmitter.prototype._events = undefined;
  EventEmitter.prototype._maxListeners = undefined;
  
  // By default EventEmitters will print a warning if more than 10 listeners are
  // added to it. This is a useful default which helps finding memory leaks.
  EventEmitter.defaultMaxListeners = 10;
  
  // Obviously not all Emitters should be limited to 10. This function allows
  // that to be increased. Set to zero for unlimited.
  EventEmitter.prototype.setMaxListeners = function(n) {
    if (!isNumber(n) || n < 0 || isNaN(n))
      throw TypeError('n must be a positive number');
    this._maxListeners = n;
    return this;
  };
  
  EventEmitter.prototype.emit = function(type) {
    var er, handler, len, args, i, listeners;
  
    if (!this._events)
      this._events = {};
  
    // If there is no 'error' event listener then throw.
    if (type === 'error') {
      if (!this._events.error ||
          (isObject(this._events.error) && !this._events.error.length)) {
        er = arguments[1];
        if (er instanceof Error) {
          throw er; // Unhandled 'error' event
        } else {
          // At least give some kind of context to the user
          var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
          err.context = er;
          throw err;
        }
      }
    }
  
    handler = this._events[type];
  
    if (isUndefined(handler))
      return false;
  
    if (isFunction(handler)) {
      switch (arguments.length) {
        // fast cases
        case 1:
          handler.call(this);
          break;
        case 2:
          handler.call(this, arguments[1]);
          break;
        case 3:
          handler.call(this, arguments[1], arguments[2]);
          break;
        // slower
        default:
          args = Array.prototype.slice.call(arguments, 1);
          handler.apply(this, args);
      }
    } else if (isObject(handler)) {
      args = Array.prototype.slice.call(arguments, 1);
      listeners = handler.slice();
      len = listeners.length;
      for (i = 0; i < len; i++)
        listeners[i].apply(this, args);
    }
  
    return true;
  };
  
  EventEmitter.prototype.addListener = function(type, listener) {
    var m;
  
    if (!isFunction(listener))
      throw TypeError('listener must be a function');
  
    if (!this._events)
      this._events = {};
  
    // To avoid recursion in the case that type === "newListener"! Before
    // adding it to the listeners, first emit "newListener".
    if (this._events.newListener)
      this.emit('newListener', type,
                isFunction(listener.listener) ?
                listener.listener : listener);
  
    if (!this._events[type])
      // Optimize the case of one listener. Don't need the extra array object.
      this._events[type] = listener;
    else if (isObject(this._events[type]))
      // If we've already got an array, just append.
      this._events[type].push(listener);
    else
      // Adding the second element, need to change to array.
      this._events[type] = [this._events[type], listener];
  
    // Check for listener leak
    if (isObject(this._events[type]) && !this._events[type].warned) {
      if (!isUndefined(this._maxListeners)) {
        m = this._maxListeners;
      } else {
        m = EventEmitter.defaultMaxListeners;
      }
  
      if (m && m > 0 && this._events[type].length > m) {
        this._events[type].warned = true;
        console.error('(node) warning: possible EventEmitter memory ' +
                      'leak detected. %d listeners added. ' +
                      'Use emitter.setMaxListeners() to increase limit.',
                      this._events[type].length);
        if (typeof console.trace === 'function') {
          // not supported in IE 10
          console.trace();
        }
      }
    }
  
    return this;
  };
  
  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
  
  EventEmitter.prototype.once = function(type, listener) {
    if (!isFunction(listener))
      throw TypeError('listener must be a function');
  
    var fired = false;
  
    function g() {
      this.removeListener(type, g);
  
      if (!fired) {
        fired = true;
        listener.apply(this, arguments);
      }
    }
  
    g.listener = listener;
    this.on(type, g);
  
    return this;
  };
  
  // emits a 'removeListener' event iff the listener was removed
  EventEmitter.prototype.removeListener = function(type, listener) {
    var list, position, length, i;
  
    if (!isFunction(listener))
      throw TypeError('listener must be a function');
  
    if (!this._events || !this._events[type])
      return this;
  
    list = this._events[type];
    length = list.length;
    position = -1;
  
    if (list === listener ||
        (isFunction(list.listener) && list.listener === listener)) {
      delete this._events[type];
      if (this._events.removeListener)
        this.emit('removeListener', type, listener);
  
    } else if (isObject(list)) {
      for (i = length; i-- > 0;) {
        if (list[i] === listener ||
            (list[i].listener && list[i].listener === listener)) {
          position = i;
          break;
        }
      }
  
      if (position < 0)
        return this;
  
      if (list.length === 1) {
        list.length = 0;
        delete this._events[type];
      } else {
        list.splice(position, 1);
      }
  
      if (this._events.removeListener)
        this.emit('removeListener', type, listener);
    }
  
    return this;
  };
  
  EventEmitter.prototype.removeAllListeners = function(type) {
    var key, listeners;
  
    if (!this._events)
      return this;
  
    // not listening for removeListener, no need to emit
    if (!this._events.removeListener) {
      if (arguments.length === 0)
        this._events = {};
      else if (this._events[type])
        delete this._events[type];
      return this;
    }
  
    // emit removeListener for all listeners on all events
    if (arguments.length === 0) {
      for (key in this._events) {
        if (key === 'removeListener') continue;
        this.removeAllListeners(key);
      }
      this.removeAllListeners('removeListener');
      this._events = {};
      return this;
    }
  
    listeners = this._events[type];
  
    if (isFunction(listeners)) {
      this.removeListener(type, listeners);
    } else if (listeners) {
      // LIFO order
      while (listeners.length)
        this.removeListener(type, listeners[listeners.length - 1]);
    }
    delete this._events[type];
  
    return this;
  };
  
  EventEmitter.prototype.listeners = function(type) {
    var ret;
    if (!this._events || !this._events[type])
      ret = [];
    else if (isFunction(this._events[type]))
      ret = [this._events[type]];
    else
      ret = this._events[type].slice();
    return ret;
  };
  
  EventEmitter.prototype.listenerCount = function(type) {
    if (this._events) {
      var evlistener = this._events[type];
  
      if (isFunction(evlistener))
        return 1;
      else if (evlistener)
        return evlistener.length;
    }
    return 0;
  };
  
  EventEmitter.listenerCount = function(emitter, type) {
    return emitter.listenerCount(type);
  };
  
  function isFunction(arg) {
    return typeof arg === 'function';
  }
  
  function isNumber(arg) {
    return typeof arg === 'number';
  }
  
  function isObject(arg) {
    return typeof arg === 'object' && arg !== null;
  }
  
  function isUndefined(arg) {
    return arg === void 0;
  }
  
  },{}],6:[function(require,module,exports){
  "use strict";
  
  /**
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *
   * 
   */
  
  function makeEmptyFunction(arg) {
    return function () {
      return arg;
    };
  }
  
  /**
   * This function accepts and discards inputs; it has no side effects. This is
   * primarily useful idiomatically for overridable function endpoints which
   * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
   */
  var emptyFunction = function emptyFunction() {};
  
  emptyFunction.thatReturns = makeEmptyFunction;
  emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
  emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
  emptyFunction.thatReturnsNull = makeEmptyFunction(null);
  emptyFunction.thatReturnsThis = function () {
    return this;
  };
  emptyFunction.thatReturnsArgument = function (arg) {
    return arg;
  };
  
  module.exports = emptyFunction;
  },{}],7:[function(require,module,exports){
  /**
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *
   */
  
  'use strict';
  
  /**
   * Use invariant() to assert state which your program assumes to be true.
   *
   * Provide sprintf-style format (only %s is supported) and arguments
   * to provide information about what broke and what you were
   * expecting.
   *
   * The invariant message will be stripped in production, but the invariant
   * will remain to ensure logic does not differ in production.
   */
  
  var validateFormat = function validateFormat(format) {};
  
  if ("development" !== 'production') {
    validateFormat = function validateFormat(format) {
      if (format === undefined) {
        throw new Error('invariant requires an error message argument');
      }
    };
  }
  
  function invariant(condition, format, a, b, c, d, e, f) {
    validateFormat(format);
  
    if (!condition) {
      var error;
      if (format === undefined) {
        error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
      } else {
        var args = [a, b, c, d, e, f];
        var argIndex = 0;
        error = new Error(format.replace(/%s/g, function () {
          return args[argIndex++];
        }));
        error.name = 'Invariant Violation';
      }
  
      error.framesToPop = 1; // we don't care about invariant's own frame
      throw error;
    }
  }
  
  module.exports = invariant;
  },{}],8:[function(require,module,exports){
  /**
   * Copyright (c) 2014-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *
   */
  
  'use strict';
  
  var emptyFunction = require('./emptyFunction');
  
  /**
   * Similar to invariant but only logs a warning if the condition is not met.
   * This can be used to log issues in development environments in critical
   * paths. Removing the logging code for production environments will keep the
   * same logic and follow the same code paths.
   */
  
  var warning = emptyFunction;
  
  if ("development" !== 'production') {
    var printWarning = function printWarning(format) {
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }
  
      var argIndex = 0;
      var message = 'Warning: ' + format.replace(/%s/g, function () {
        return args[argIndex++];
      });
      if (typeof console !== 'undefined') {
        console.error(message);
      }
      try {
        // --- Welcome to debugging React ---
        // This error was thrown as a convenience so that you can use this stack
        // to find the callsite that caused this warning to fire.
        throw new Error(message);
      } catch (x) {}
    };
  
    warning = function warning(condition, format) {
      if (format === undefined) {
        throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
      }
  
      if (format.indexOf('Failed Composite propType: ') === 0) {
        return; // Ignore CompositeComponent proptype check.
      }
  
      if (!condition) {
        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
          args[_key2 - 2] = arguments[_key2];
        }
  
        printWarning.apply(undefined, [format].concat(args));
      }
    };
  }
  
  module.exports = warning;
  },{"./emptyFunction":6}],9:[function(require,module,exports){
  '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 = assign({}, require('./lib/re'));
  
    // Define dynamic patterns
    var tlds = self.__tlds__.slice();
  
    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('(^|(?!_)(?:[><]|' + re.src_ZPCc + '))(' + slist + ')', 'i');
    self.re.schema_search = RegExp('(^|(?!_)(?:[><]|' + 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;
    }
  };
  
  
  module.exports = LinkifyIt;
  
  },{"./lib/re":10}],10:[function(require,module,exports){
  'use strict';
  
  // Use direct extract instead of `regenerate` to reduse browserified size
  var src_Any = exports.src_Any = require('uc.micro/properties/Any/regex').source;
  var src_Cc  = exports.src_Cc = require('uc.micro/categories/Cc/regex').source;
  var src_Z   = exports.src_Z  = require('uc.micro/categories/Z/regex').source;
  var src_P   = exports.src_P  = require('uc.micro/categories/P/regex').source;
  
  // \p{\Z\P\Cc\CF} (white spaces + control + format + punctuation)
  var src_ZPCc = exports.src_ZPCc = [ src_Z, src_P, src_Cc ].join('|');
  
  // \p{\Z\Cc} (white spaces + control)
  var src_ZCc = exports.src_ZCc = [ src_Z, src_Cc ].join('|');
  
  // 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 `_`)
  var src_pseudo_letter       = '(?:(?!>|<|' + src_ZPCc + ')' + src_Any + ')';
  // The same as abothe but without [0-9]
  // var src_pseudo_letter_non_d = '(?:(?![0-9]|' + src_ZPCc + ')' + src_Any + ')';
  
  ////////////////////////////////////////////////////////////////////////////////
  
  var src_ip4 = exports.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 [@/] in user/pass to avoid wrong domain fetch.
  exports.src_auth    = '(?:(?:(?!' + src_ZCc + '|[@/]).)+@)?';
  
  var src_port = exports.src_port =
  
    '(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?';
  
  var src_host_terminator = exports.src_host_terminator =
  
    '(?=$|>|<|' + src_ZPCc + ')(?!-|_|:\\d|\\.-|\\.(?!$|' + src_ZPCc + '))';
  
  var src_path = exports.src_path =
  
    '(?:' +
      '[/?#]' +
        '(?:' +
          '(?!' + src_ZCc + '|[()[\\]{}.,"\'?!\\-<>]).|' +
          '\\[(?:(?!' + src_ZCc + '|\\]).)*\\]|' +
          '\\((?:(?!' + src_ZCc + '|[)]).)*\\)|' +
          '\\{(?:(?!' + src_ZCc + '|[}]).)*\\}|' +
          '\\"(?:(?!' + src_ZCc + '|["]).)+\\"|' +
          "\\'(?:(?!" + src_ZCc + "|[']).)+\\'|" +
          "\\'(?=" + src_pseudo_letter + ').|' +  // allow `I'm_king` if no pair found
          '\\.{2,3}[a-zA-Z0-9%/]|' + // github has ... in commit range links. Restrict to
                                     // - english
                                     // - percent-encoded
                                     // - parts of file path
                                     // until more examples found.
          '\\.(?!' + src_ZCc + '|[.]).|' +
          '\\-(?!--(?:[^-]|$))(?:-*)|' +  // `---` => long dash, terminate
          '\\,(?!' + src_ZCc + ').|' +      // allow `,,,` in paths
          '\\!(?!' + src_ZCc + '|[!]).|' +
          '\\?(?!' + src_ZCc + '|[?]).' +
        ')+' +
      '|\\/' +
    ')?';
  
  var src_email_name = exports.src_email_name =
  
    '[\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]+';
  
  var src_xn = exports.src_xn =
  
    'xn--[a-z0-9\\-]{1,59}';
  
  // More to read about domain names
  // http://serverfault.com/questions/638260/
  
  var src_domain_root = exports.src_domain_root =
  
    // Allow letters & digits (http://test1)
    '(?:' +
      src_xn +
      '|' +
      src_pseudo_letter + '{1,63}' +
    ')';
  
  var src_domain = exports.src_domain =
  
    '(?:' +
      src_xn +
      '|' +
      '(?:' + src_pseudo_letter + ')' +
      '|' +
      // don't allow `--` in domain names, because:
      // - that can conflict with markdown &mdash; / &ndash;
      // - nobody use those anyway
      '(?:' + src_pseudo_letter + '(?:-(?!-)|' + src_pseudo_letter + '){0,61}' + src_pseudo_letter + ')' +
    ')';
  
  var src_host = exports.src_host =
  
    '(?:' +
    // Don't need IP check, because digits are already allowed in normal domain names
    //   src_ip4 +
    // '|' +
      '(?:(?:(?:' + src_domain + ')\\.)*' + src_domain_root + ')' +
    ')';
  
  var tpl_host_fuzzy = exports.tpl_host_fuzzy =
  
    '(?:' +
      src_ip4 +
    '|' +
      '(?:(?:(?:' + src_domain + ')\\.)+(?:%TLDS%))' +
    ')';
  
  var tpl_host_no_ip_fuzzy = exports.tpl_host_no_ip_fuzzy =
  
    '(?:(?:(?:' + src_domain + ')\\.)+(?:%TLDS%))';
  
  exports.src_host_strict =
  
    src_host + src_host_terminator;
  
  var tpl_host_fuzzy_strict = exports.tpl_host_fuzzy_strict =
  
    tpl_host_fuzzy + src_host_terminator;
  
  exports.src_host_port_strict =
  
    src_host + src_port + src_host_terminator;
  
  var tpl_host_port_fuzzy_strict = exports.tpl_host_port_fuzzy_strict =
  
    tpl_host_fuzzy + src_port + src_host_terminator;
  
  var tpl_host_port_no_ip_fuzzy_strict = exports.tpl_host_port_no_ip_fuzzy_strict =
  
    tpl_host_no_ip_fuzzy + src_port + src_host_terminator;
  
  
  ////////////////////////////////////////////////////////////////////////////////
  // Main rules
  
  // Rude test fuzzy links by host, for quick deny
  exports.tpl_host_fuzzy_test =
  
    'localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:' + src_ZPCc + '|>|$))';
  
  exports.tpl_email_fuzzy =
  
      '(^|<|>|\\(|' + src_ZCc + ')(' + src_email_name + '@' + tpl_host_fuzzy_strict + ')';
  
  exports.tpl_link_fuzzy =
      // Fuzzy link can't be prepended with .:/\- and non punctuation.
      // but can start with > (markdown blockquote)
      '(^|(?![.:/\\-_@])(?:[$+<=>^`|]|' + src_ZPCc + '))' +
      '((?![$+<=>^`|])' + tpl_host_port_fuzzy_strict + src_path + ')';
  
  exports.tpl_link_no_ip_fuzzy =
      // Fuzzy link can't be prepended with .:/\- and non punctuation.
      // but can start with > (markdown blockquote)
      '(^|(?![.:/\\-_@])(?:[$+<=>^`|]|' + src_ZPCc + '))' +
      '((?![$+<=>^`|])' + tpl_host_port_no_ip_fuzzy_strict + src_path + ')';
  
  },{"uc.micro/categories/Cc/regex":75,"uc.micro/categories/P/regex":77,"uc.micro/categories/Z/regex":78,"uc.micro/properties/Any/regex":80}],11:[function(require,module,exports){
  'use strict';
  
  
  module.exports = require('./lib/');
  
  },{"./lib/":20}],12:[function(require,module,exports){
  // HTML5 entities map: { name -> utf16string }
  //
  'use strict';
  
  /*eslint quotes:0*/
  module.exports = require('entities/maps/entities.json');
  
  },{"entities/maps/entities.json":4}],13:[function(require,module,exports){
  // List of valid html blocks names, accorting to commonmark spec
  // http://jgm.github.io/CommonMark/spec.html#html-blocks
  
  'use strict';
  
  
  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',
    'head',
    'header',
    'hr',
    'html',
    'iframe',
    'legend',
    'li',
    'link',
    'main',
    'menu',
    'menuitem',
    'meta',
    'nav',
    'noframes',
    'ol',
    'optgroup',
    'option',
    'p',
    'param',
    'pre',
    'section',
    'source',
    'title',
    'summary',
    'table',
    'tbody',
    'td',
    'tfoot',
    'th',
    'thead',
    'title',
    'tr',
    'track',
    'ul'
  ];
  
  },{}],14:[function(require,module,exports){
  // Regexps to match html elements
  
  'use strict';
  
  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;
  
  },{}],15:[function(require,module,exports){
  // Utilities
  //
  'use strict';
  
  
  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 = require('./entities');
  
  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 = require('uc.micro/categories/P/regex');
  
  // 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) {
    // use .toUpperCase() instead of .toLowerCase()
    // here to avoid a conflict with Object.prototype
    // members (most notably, `__proto__`)
    return str.trim().replace(/\s+/g, ' ').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           = require('mdurl');
  exports.lib.ucmicro         = require('uc.micro');
  
  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;
  
  },{"./entities":12,"mdurl":66,"uc.micro":79,"uc.micro/categories/P/regex":77}],16:[function(require,module,exports){
  // Just a shortcut for bulk export
  'use strict';
  
  
  exports.parseLinkLabel       = require('./parse_link_label');
  exports.parseLinkDestination = require('./parse_link_destination');
  exports.parseLinkTitle       = require('./parse_link_title');
  
  },{"./parse_link_destination":17,"./parse_link_label":18,"./parse_link_title":19}],17:[function(require,module,exports){
  // Parse link destination
  //
  'use strict';
  
  
  var isSpace     = require('../common/utils').isSpace;
  var unescapeAll = require('../common/utils').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 */ || isSpace(code)) { 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 (level > 1) { break; }
      }
  
      if (code === 0x29 /* ) */) {
        level--;
        if (level < 0) { break; }
      }
  
      pos++;
    }
  
    if (start === pos) { return result; }
  
    result.str = unescapeAll(str.slice(start, pos));
    result.lines = lines;
    result.pos = pos;
    result.ok = true;
    return result;
  };
  
  },{"../common/utils":15}],18:[function(require,module,exports){
  // Parse link label
  //
  // this function assumes that first character ("[") already matches;
  // returns the end of the label
  //
  'use strict';
  
  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;
  };
  
  },{}],19:[function(require,module,exports){
  // Parse link title
  //
  'use strict';
  
  
  var unescapeAll = require('../common/utils').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;
  };
  
  },{"../common/utils":15}],20:[function(require,module,exports){
  // Main parser class
  
  'use strict';
  
  
  var utils        = require('./common/utils');
  var helpers      = require('./helpers');
  var Renderer     = require('./renderer');
  var ParserCore   = require('./parser_core');
  var ParserBlock  = require('./parser_block');
  var ParserInline = require('./parser_inline');
  var LinkifyIt    = require('linkify-it');
  var mdurl        = require('mdurl');
  var punycode     = require('punycode');
  
  
  var config = {
    'default': require('./presets/default'),
    zero: require('./presets/zero'),
    commonmark: require('./presets/commonmark')
  };
  
  ////////////////////////////////////////////////////////////////////////////////
  //
  // 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 = 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) {
    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;
  
  },{"./common/utils":15,"./helpers":16,"./parser_block":21,"./parser_core":22,"./parser_inline":23,"./presets/commonmark":24,"./presets/default":25,"./presets/zero":26,"./renderer":27,"linkify-it":9,"mdurl":66,"punycode":74}],21:[function(require,module,exports){
  /** internal
   * class ParserBlock
   *
   * Block-level tokenizer.
   **/
  'use strict';
  
  
  var Ruler           = require('./ruler');
  
  
  var _rules = [
    // First 2 params - rule name & source. Secondary array - list of rules,
    // which can be terminated by this one.
    [ 'table',      require('./rules_block/table'),      [ 'paragraph', 'reference' ] ],
    [ 'code',       require('./rules_block/code') ],
    [ 'fence',      require('./rules_block/fence'),      [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
    [ 'blockquote', require('./rules_block/blockquote'), [ 'paragraph', 'reference', 'list' ] ],
    [ 'hr',         require('./rules_block/hr'),         [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
    [ 'list',       require('./rules_block/list'),       [ 'paragraph', 'reference', 'blockquote' ] ],
    [ 'reference',  require('./rules_block/reference') ],
    [ 'heading',    require('./rules_block/heading'),    [ 'paragraph', 'reference', 'blockquote' ] ],
    [ 'lheading',   require('./rules_block/lheading') ],
    [ 'html_block', require('./rules_block/html_block'), [ 'paragraph', 'reference', 'blockquote' ] ],
    [ 'paragraph',  require('./rules_block/paragraph') ]
  ];
  
  
  /**
   * 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 iff 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++;
  
        // two empty lines should stop the parser in list mode
        if (line < endLine && state.parentType === 'list' && state.isEmpty(line)) { break; }
        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 = require('./rules_block/state_block');
  
  
  module.exports = ParserBlock;
  
  },{"./ruler":28,"./rules_block/blockquote":29,"./rules_block/code":30,"./rules_block/fence":31,"./rules_block/heading":32,"./rules_block/hr":33,"./rules_block/html_block":34,"./rules_block/lheading":35,"./rules_block/list":36,"./rules_block/paragraph":37,"./rules_block/reference":38,"./rules_block/state_block":39,"./rules_block/table":40}],22:[function(require,module,exports){
  /** internal
   * class Core
   *
   * Top-level rules executor. Glues block/inline parsers and does intermediate
   * transformations.
   **/
  'use strict';
  
  
  var Ruler  = require('./ruler');
  
  
  var _rules = [
    [ 'normalize',      require('./rules_core/normalize')      ],
    [ 'block',          require('./rules_core/block')          ],
    [ 'inline',         require('./rules_core/inline')         ],
    [ 'linkify',        require('./rules_core/linkify')        ],
    [ 'replacements',   require('./rules_core/replacements')   ],
    [ 'smartquotes',    require('./rules_core/smartquotes')    ]
  ];
  
  
  /**
   * 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 = require('./rules_core/state_core');
  
  
  module.exports = Core;
  
  },{"./ruler":28,"./rules_core/block":41,"./rules_core/inline":42,"./rules_core/linkify":43,"./rules_core/normalize":44,"./rules_core/replacements":45,"./rules_core/smartquotes":46,"./rules_core/state_core":47}],23:[function(require,module,exports){
  /** internal
   * class ParserInline
   *
   * Tokenizes paragraph content.
   **/
  'use strict';
  
  
  var Ruler           = require('./ruler');
  
  
  ////////////////////////////////////////////////////////////////////////////////
  // Parser rules
  
  var _rules = [
    [ 'text',            require('./rules_inline/text') ],
    [ 'newline',         require('./rules_inline/newline') ],
    [ 'escape',          require('./rules_inline/escape') ],
    [ 'backticks',       require('./rules_inline/backticks') ],
    [ 'strikethrough',   require('./rules_inline/strikethrough').tokenize ],
    [ 'emphasis',        require('./rules_inline/emphasis').tokenize ],
    [ 'link',            require('./rules_inline/link') ],
    [ 'image',           require('./rules_inline/image') ],
    [ 'autolink',        require('./rules_inline/autolink') ],
    [ 'html_inline',     require('./rules_inline/html_inline') ],
    [ 'entity',          require('./rules_inline/entity') ]
  ];
  
  var _rules2 = [
    [ 'balance_pairs',   require('./rules_inline/balance_pairs') ],
    [ 'strikethrough',   require('./rules_inline/strikethrough').postProcess ],
    [ 'emphasis',        require('./rules_inline/emphasis').postProcess ],
    [ 'text_collapse',   require('./rules_inline/text_collapse') ]
  ];
  
  
  /**
   * 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 = require('./rules_inline/state_inline');
  
  
  module.exports = ParserInline;
  
  },{"./ruler":28,"./rules_inline/autolink":48,"./rules_inline/backticks":49,"./rules_inline/balance_pairs":50,"./rules_inline/emphasis":51,"./rules_inline/entity":52,"./rules_inline/escape":53,"./rules_inline/html_inline":54,"./rules_inline/image":55,"./rules_inline/link":56,"./rules_inline/newline":57,"./rules_inline/state_inline":58,"./rules_inline/strikethrough":59,"./rules_inline/text":60,"./rules_inline/text_collapse":61}],24:[function(require,module,exports){
  // Commonmark default options
  
  'use strict';
  
  
  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'
        ]
      }
    }
  };
  
  },{}],25:[function(require,module,exports){
  // markdown-it default options
  
  'use strict';
  
  
  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: {}
    }
  };
  
  },{}],26:[function(require,module,exports){
  // "Zero" preset, with nothing enabled. Useful for manual configuring of simple
  // modes. For example, to parse bold/italic only.
  
  'use strict';
  
  
  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'
        ]
      }
    }
  };
  
  },{}],27:[function(require,module,exports){
  /**
   * 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.
   **/
  'use strict';
  
  
  var assign          = require('./common/utils').assign;
  var unescapeAll     = require('./common/utils').unescapeAll;
  var escapeHtml      = require('./common/utils').escapeHtml;
  
  
  ////////////////////////////////////////////////////////////////////////////////
  
  var default_rules = {};
  
  
  default_rules.code_inline = function (tokens, idx, options, env, slf) {
    var token = tokens[idx],
        attrs = slf.renderAttrs(token);
  
    return  '<code' + (attrs ? ' ' + attrs : '') + '>' +
            escapeHtml(tokens[idx].content) +
            '</code>';
  };
  
  
  default_rules.code_block = function (tokens, idx, options, env, slf) {
    var token = tokens[idx],
        attrs = slf.renderAttrs(token);
  
    return  '<pre' + (attrs ? ' ' + attrs : '') + '><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 mudofying 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] += ' ' + 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 independed 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;
  
  },{"./common/utils":15}],28:[function(require,module,exports){
  /**
   * 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]].
   **/
  'use strict';
  
  
  /**
   * 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 typorgapher 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;
  
  },{}],29:[function(require,module,exports){
  // Block quotes
  
  'use strict';
  
  var isSpace = require('../common/utils').isSpace;
  
  
  module.exports = function blockquote(state, startLine, endLine, silent) {
    var nextLine, lastLineEmpty, oldTShift, oldSCount, oldBMarks, oldIndent, oldParentType, lines, initial, offset, ch,
        terminatorRules, token,
        i, l, terminate,
        pos = state.bMarks[startLine] + state.tShift[startLine],
        max = state.eMarks[startLine];
  
    // 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 one optional space (but not tab, check cmark impl) after '>'
    if (state.src.charCodeAt(pos) === 0x20) { pos++; }
  
    oldIndent = state.blkIndent;
    state.blkIndent = 0;
  
    // skip spaces after ">" and re-calculate offset
    initial = offset = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine]);
  
    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 % 4;
        } else {
          offset++;
        }
      } else {
        break;
      }
  
      pos++;
    }
  
    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');
  
    // 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++) {
      if (state.sCount[nextLine] < oldIndent) { break; }
  
      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/* > */) {
        // This line is inside the blockquote.
  
        // skip one optional space (but not tab, check cmark impl) after '>'
        if (state.src.charCodeAt(pos) === 0x20) { pos++; }
  
        // skip spaces after ">" and re-calculate offset
        initial = offset = state.sCount[nextLine] + pos - (state.bMarks[nextLine] + state.tShift[nextLine]);
  
        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 % 4;
            } else {
              offset++;
            }
          } else {
            break;
          }
  
          pos++;
        }
  
        lastLineEmpty = pos >= max;
  
        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) { break; }
  
      oldBMarks.push(state.bMarks[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;
    }
  
    oldParentType = state.parentType;
    state.parentType = 'blockquote';
  
    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.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.blkIndent = oldIndent;
  
    return true;
  };
  
  },{"../common/utils":15}],30:[function(require,module,exports){
  // Code block (4 spaces padded)
  
  'use strict';
  
  
  module.exports = function code(state, startLine, endLine/*, silent*/) {
    var nextLine, last, token, emptyLines = 0;
  
    if (state.sCount[startLine] - state.blkIndent < 4) { return false; }
  
    last = nextLine = startLine + 1;
  
    while (nextLine < endLine) {
      if (state.isEmpty(nextLine)) {
        emptyLines++;
  
        // workaround for lists: 2 blank lines should terminate indented
        // code block, but not fenced code block
        if (emptyLines >= 2 && state.parentType === 'list') {
          break;
        }
  
        nextLine++;
        continue;
      }
  
      emptyLines = 0;
  
      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;
  };
  
  },{}],31:[function(require,module,exports){
  // fences (``` lang, ~~~ lang)
  
  'use strict';
  
  
  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 (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 (params.indexOf('`') >= 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;
  };
  
  },{}],32:[function(require,module,exports){
  // heading (#, ##, ...)
  
  'use strict';
  
  var isSpace = require('../common/utils').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];
  
    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 && ch !== 0x20/* space */)) { 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;
  };
  
  },{"../common/utils":15}],33:[function(require,module,exports){
  // Horizontal rule
  
  'use strict';
  
  var isSpace = require('../common/utils').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];
  
    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;
  };
  
  },{"../common/utils":15}],34:[function(require,module,exports){
  // HTML block
  
  'use strict';
  
  
  var block_names = require('../common/html_blocks');
  var HTML_OPEN_CLOSE_TAG_RE = require('../common/html_re').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 (!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;
  };
  
  },{"../common/html_blocks":13,"../common/html_re":14}],35:[function(require,module,exports){
  // lheading (---, ===)
  
  'use strict';
  
  
  module.exports = function lheading(state, startLine, endLine/*, silent*/) {
    var content, terminate, i, l, token, pos, max, level, marker,
        nextLine = startLine + 1,
        terminatorRules = state.md.block.ruler.getRules('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; }
  
      //
      // 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);
  
    return true;
  };
  
  },{}],36:[function(require,module,exports){
  // Lists
  
  'use strict';
  
  var isSpace = require('../common/utils').isSpace;
  
  
  // Search `[-+*][\n ]`, returns next pos arter 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 arter 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 nextLine,
        initial,
        offset,
        indent,
        oldTShift,
        oldIndent,
        oldLIndent,
        oldTight,
        oldParentType,
        start,
        posAfterMarker,
        ch,
        pos,
        max,
        indentAfterMarker,
        markerValue,
        markerCharCode,
        isOrdered,
        contentStart,
        listTokIdx,
        prevEmptyEnd,
        listLines,
        itemLines,
        tight = true,
        terminatorRules,
        token,
        i, l, terminate;
  
    // Detect list type and position after marker
    if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {
      isOrdered = true;
    } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {
      isOrdered = false;
    } else {
      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) {
      start = state.bMarks[startLine] + state.tShift[startLine];
      markerValue = Number(state.src.substr(start, posAfterMarker - start - 1));
  
      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');
  
    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 (isSpace(ch)) {
          if (ch === 0x09) {
            offset += 4 - offset % 4;
          } else {
            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 ];
  
      oldIndent = state.blkIndent;
      oldTight = state.tight;
      oldTShift = state.tShift[startLine];
      oldLIndent = state.sCount[startLine];
      oldParentType = state.parentType;
      state.blkIndent = indent;
      state.tight = true;
      state.parentType = 'list';
      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 = oldIndent;
      state.tShift[startLine] = oldTShift;
      state.sCount[startLine] = oldLIndent;
      state.tight = oldTight;
      state.parentType = oldParentType;
  
      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; }
  
      if (state.isEmpty(nextLine)) {
        break;
      }
  
      //
      // Try to check if list is terminated or continued.
      //
      if (state.sCount[nextLine] < state.blkIndent) { 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; }
    }
  
    // Finilize 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;
  
    // mark paragraphs tight if needed
    if (tight) {
      markTightParagraphs(state, listTokIdx);
    }
  
    return true;
  };
  
  },{"../common/utils":15}],37:[function(require,module,exports){
  // Paragraph
  
  'use strict';
  
  
  module.exports = function paragraph(state, startLine/*, endLine*/) {
    var content, terminate, i, l, token,
        nextLine = startLine + 1,
        terminatorRules = state.md.block.ruler.getRules('paragraph'),
        endLine = state.lineMax;
  
    // 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);
  
    return true;
  };
  
  },{}],38:[function(require,module,exports){
  'use strict';
  
  
  var parseLinkDestination = require('../helpers/parse_link_destination');
  var parseLinkTitle       = require('../helpers/parse_link_title');
  var normalizeReference   = require('../common/utils').normalizeReference;
  var isSpace              = require('../common/utils').isSpace;
  
  
  module.exports = function reference(state, startLine, _endLine, silent) {
    var ch,
        destEndPos,
        destEndLineNo,
        endLine,
        href,
        i,
        l,
        label,
        labelEnd,
        res,
        start,
        str,
        terminate,
        terminatorRules,
        title,
        lines = 0,
        pos = state.bMarks[startLine] + state.tShift[startLine],
        max = state.eMarks[startLine],
        nextLine = startLine + 1;
  
    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');
  
    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 = 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 = 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.line = startLine + lines + 1;
    return true;
  };
  
  },{"../common/utils":15,"../helpers/parse_link_destination":17,"../helpers/parse_link_title":19}],39:[function(require,module,exports){
  // Parser state class
  
  'use strict';
  
  var Token = require('../token');
  var isSpace = require('../common/utils').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)
  
    // block parser variables
    this.blkIndent  = 0; // required block content indent
                         // (for example, if we are in list)
    this.line       = 0; // line index in src
    this.lineMax    = 0; // lines count
    this.tight      = false;  // loose/tight mode for lists
    this.parentType = 'root'; // if `list`, block parser stops on two newlines
    this.ddIndent   = -1; // indent of the current dd block (-1 if there isn't any)
  
    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);
  
        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.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--; }
    token.level = this.level;
    if (nesting > 0) { this.level++; }
  
    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 % 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++;
      }
  
      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;
  
  },{"../common/utils":15,"../token":62}],40:[function(require,module,exports){
  // GFM table, non-standard
  
  'use strict';
  
  
  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/* ` */ && (escapes % 2 === 0)) {
        backTicked = !backTicked;
        lastBackTick = pos;
      } else if (ch === 0x7c/* | */ && (escapes % 2 === 0) && !backTicked) {
        result.push(str.substring(lastPos, pos));
        lastPos = pos + 1;
      } else 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 three lines
    if (startLine + 2 > endLine) { return false; }
  
    nextLine = startLine + 1;
  
    if (state.sCount[nextLine] < state.blkIndent) { return false; }
  
    // first character of the second line should be '|' or '-'
  
    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; }
  
    lineText = getLine(state, startLine + 1);
    if (!/^[-:| ]+$/.test(lineText)) { return false; }
  
    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; }
    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);
      if (lineText.indexOf('|') === -1) { break; }
  
      // keep spaces at beginning of line to indicate an empty first cell, but
      // strip trailing whitespace
      columns = escapedSplit(lineText.replace(/^\||\|\s*$/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;
  };
  
  },{}],41:[function(require,module,exports){
  '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);
    }
  };
  
  },{}],42:[function(require,module,exports){
  '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);
      }
    }
  };
  
  },{}],43:[function(require,module,exports){
  // Replace link-like texts with link nodes.
  //
  // Currently restricted by `md.validateLink()` to http/https/ftp
  //
  'use strict';
  
  
  var arrayReplaceAt = require('../common/utils').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);
        }
      }
    }
  };
  
  },{"../common/utils":15}],44:[function(require,module,exports){
  // Normalize input string
  
  'use strict';
  
  
  var NEWLINES_RE  = /\r[\n\u0085]?|[\u2424\u2028\u0085]/g;
  var NULL_RE      = /\u0000/g;
  
  
  module.exports = function inline(state) {
    var str;
  
    // Normalize newlines
    str = state.src.replace(NEWLINES_RE, '\n');
  
    // Replace NULL characters
    str = str.replace(NULL_RE, '\uFFFD');
  
    state.src = str;
  };
  
  },{}],45:[function(require,module,exports){
  // Simple typographyc replacements
  //
  // (c) (C) → ©
  // (tm) (TM) → ™
  // (r) (R) → ®
  // +- → ±
  // (p) (P) -> §
  // ... → … (also ?.... → ?.., !.... → !..)
  // ???????? → ???, !!!!! → !!!, `,,` → `,`
  // -- → &ndash;, --- → &mdash;
  //
  'use strict';
  
  // 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;
  
    for (i = inlineTokens.length - 1; i >= 0; i--) {
      token = inlineTokens[i];
      if (token.type === 'text') {
        token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
      }
    }
  }
  
  function replace_rare(inlineTokens) {
    var i, token;
  
    for (i = inlineTokens.length - 1; i >= 0; i--) {
      token = inlineTokens[i];
      if (token.type === 'text') {
        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');
        }
      }
    }
  }
  
  
  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);
      }
  
    }
  };
  
  },{}],46:[function(require,module,exports){
  // Convert straight quotation marks to typographic ones
  //
  'use strict';
  
  
  var isWhiteSpace   = require('../common/utils').isWhiteSpace;
  var isPunctChar    = require('../common/utils').isPunctChar;
  var isMdAsciiPunct = require('../common/utils').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 !== '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 !== '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);
    }
  };
  
  },{"../common/utils":15}],47:[function(require,module,exports){
  // Core state object
  //
  'use strict';
  
  var Token = require('../token');
  
  
  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;
  
  },{"../token":62}],48:[function(require,module,exports){
  // Process autolinks '<protocol:...>'
  
  'use strict';
  
  
  /*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;
  };
  
  },{}],49:[function(require,module,exports){
  // Parse backticks
  
  'use strict';
  
  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, ' ')
                                   .trim();
        }
        state.pos = matchEnd;
        return true;
      }
    }
  
    if (!silent) { state.pending += marker; }
    state.pos += marker.length;
    return true;
  };
  
  },{}],50:[function(require,module,exports){
  // For each opening emphasis-like marker find a matching closing one
  //
  'use strict';
  
  
  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) {
  
          lastDelim.jump = i - j;
          lastDelim.open = false;
          currDelim.end  = i;
          currDelim.jump = 0;
          break;
        }
  
        j -= currDelim.jump + 1;
      }
    }
  };
  
  },{}],51:[function(require,module,exports){
  // Process *this* and _that_
  //
  'use strict';
  
  
  // 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,
  
        // 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 = 0; i < max; 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 next 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 + 1 < max &&
                 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++;
      }
    }
  };
  
  },{}],52:[function(require,module,exports){
  // Process html entity - &#123;, &#xAF;, &quot;, ...
  
  'use strict';
  
  var entities          = require('../common/entities');
  var has               = require('../common/utils').has;
  var isValidEntityCode = require('../common/utils').isValidEntityCode;
  var fromCodePoint     = require('../common/utils').fromCodePoint;
  
  
  var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,8}|[0-9]{1,8}));/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;
  };
  
  },{"../common/entities":12,"../common/utils":15}],53:[function(require,module,exports){
  // Proceess escaped chars and hardbreaks
  
  'use strict';
  
  var isSpace = require('../common/utils').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;
  };
  
  },{"../common/utils":15}],54:[function(require,module,exports){
  // Process html tags
  
  'use strict';
  
  
  var HTML_TAG_RE = require('../common/html_re').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;
  };
  
  },{"../common/html_re":14}],55:[function(require,module,exports){
  // Process ![image](<src> "title")
  
  'use strict';
  
  var parseLinkLabel       = require('../helpers/parse_link_label');
  var parseLinkDestination = require('../helpers/parse_link_destination');
  var parseLinkTitle       = require('../helpers/parse_link_title');
  var normalizeReference   = require('../common/utils').normalizeReference;
  var isSpace              = require('../common/utils').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 = 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 = 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 = 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 = 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;
  };
  
  },{"../common/utils":15,"../helpers/parse_link_destination":17,"../helpers/parse_link_label":18,"../helpers/parse_link_title":19}],56:[function(require,module,exports){
  // Process [link](<to> "stuff")
  
  'use strict';
  
  var parseLinkLabel       = require('../helpers/parse_link_label');
  var parseLinkDestination = require('../helpers/parse_link_destination');
  var parseLinkTitle       = require('../helpers/parse_link_title');
  var normalizeReference   = require('../common/utils').normalizeReference;
  var isSpace              = require('../common/utils').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;
  
    if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { return false; }
  
    labelStart = state.pos + 1;
    labelEnd = 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
      //
  
      // [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 = 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 = 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 = 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;
  };
  
  },{"../common/utils":15,"../helpers/parse_link_destination":17,"../helpers/parse_link_label":18,"../helpers/parse_link_title":19}],57:[function(require,module,exports){
  // Proceess '\n'
  
  'use strict';
  
  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 && state.src.charCodeAt(pos) === 0x20) { pos++; }
  
    state.pos = pos;
    return true;
  };
  
  },{}],58:[function(require,module,exports){
  // Inline parser state
  
  'use strict';
  
  
  var Token          = require('../token');
  var isWhiteSpace   = require('../common/utils').isWhiteSpace;
  var isPunctChar    = require('../common/utils').isPunctChar;
  var isMdAsciiPunct = require('../common/utils').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--; }
    token.level = this.level;
    if (nesting > 0) { this.level++; }
  
    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;
  
  },{"../common/utils":15,"../token":62}],59:[function(require,module,exports){
  // ~~strike through~~
  //
  'use strict';
  
  
  // 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;
      }
    }
  };
  
  },{}],60:[function(require,module,exports){
  // Skip text characters for text token, place those to pending buffer
  // and increment current pos
  
  'use strict';
  
  
  // 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;
  };*/
  
  },{}],61:[function(require,module,exports){
  // Merge adjacent text nodes into one, and re-calculate all token levels
  //
  'use strict';
  
  
  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
      level += tokens[curr].nesting;
      tokens[curr].level = level;
  
      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;
    }
  };
  
  },{}],62:[function(require,module,exports){
  // Token class
  
  'use strict';
  
  
  /**
   * 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;
  
  },{}],63:[function(require,module,exports){
  
  '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;
  
  },{}],64:[function(require,module,exports){
  
  '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;
  
  },{}],65:[function(require,module,exports){
  
  '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;
  };
  
  },{}],66:[function(require,module,exports){
  'use strict';
  
  
  module.exports.encode = require('./encode');
  module.exports.decode = require('./decode');
  module.exports.format = require('./format');
  module.exports.parse  = require('./parse');
  
  },{"./decode":63,"./encode":64,"./format":65,"./parse":67}],67:[function(require,module,exports){
  // 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.
  
  'use strict';
  
  //
  // 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;
  
  },{}],68:[function(require,module,exports){
  /*
  object-assign
  (c) Sindre Sorhus
  @license MIT
  */
  
  'use strict';
  /* eslint-disable no-unused-vars */
  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  var propIsEnumerable = Object.prototype.propertyIsEnumerable;
  
  function toObject(val) {
  	if (val === null || val === undefined) {
  		throw new TypeError('Object.assign cannot be called with null or undefined');
  	}
  
  	return Object(val);
  }
  
  function shouldUseNative() {
  	try {
  		if (!Object.assign) {
  			return false;
  		}
  
  		// Detect buggy property enumeration order in older V8 versions.
  
  		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
  		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
  		test1[5] = 'de';
  		if (Object.getOwnPropertyNames(test1)[0] === '5') {
  			return false;
  		}
  
  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  		var test2 = {};
  		for (var i = 0; i < 10; i++) {
  			test2['_' + String.fromCharCode(i)] = i;
  		}
  		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
  			return test2[n];
  		});
  		if (order2.join('') !== '0123456789') {
  			return false;
  		}
  
  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  		var test3 = {};
  		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
  			test3[letter] = letter;
  		});
  		if (Object.keys(Object.assign({}, test3)).join('') !==
  				'abcdefghijklmnopqrst') {
  			return false;
  		}
  
  		return true;
  	} catch (err) {
  		// We don't expect any of the above to throw, but better to be safe.
  		return false;
  	}
  }
  
  module.exports = shouldUseNative() ? Object.assign : function (target, source) {
  	var from;
  	var to = toObject(target);
  	var symbols;
  
  	for (var s = 1; s < arguments.length; s++) {
  		from = Object(arguments[s]);
  
  		for (var key in from) {
  			if (hasOwnProperty.call(from, key)) {
  				to[key] = from[key];
  			}
  		}
  
  		if (getOwnPropertySymbols) {
  			symbols = getOwnPropertySymbols(from);
  			for (var i = 0; i < symbols.length; i++) {
  				if (propIsEnumerable.call(from, symbols[i])) {
  					to[symbols[i]] = from[symbols[i]];
  				}
  			}
  		}
  	}
  
  	return to;
  };
  
  },{}],69:[function(require,module,exports){
  /**
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   */
  
  'use strict';
  
  if ("development" !== 'production') {
    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');
    var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');
    var loggedTypeFailures = {};
  }
  
  /**
   * Assert that the values match with the type specs.
   * Error messages are memorized and will only be shown once.
   *
   * @param {object} typeSpecs Map of name to a ReactPropType
   * @param {object} values Runtime values that need to be type-checked
   * @param {string} location e.g. "prop", "context", "child context"
   * @param {string} componentName Name of the component for error messages.
   * @param {?Function} getStack Returns the component stack.
   * @private
   */
  function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
    if ("development" !== 'production') {
      for (var typeSpecName in typeSpecs) {
        if (typeSpecs.hasOwnProperty(typeSpecName)) {
          var error;
          // Prop type validation may throw. In case they do, we don't want to
          // fail the render phase where it didn't fail before. So we log it.
          // After these have been cleaned up, we'll let them throw.
          try {
            // This is intentionally an invariant that gets caught. It's the same
            // behavior as without this statement except with a better message.
            invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]);
            error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
          } catch (ex) {
            error = ex;
          }
          warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);
          if (error instanceof Error && !(error.message in loggedTypeFailures)) {
            // Only monitor this failure once because there tends to be a lot of the
            // same error.
            loggedTypeFailures[error.message] = true;
  
            var stack = getStack ? getStack() : '';
  
            warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');
          }
        }
      }
    }
  }
  
  module.exports = checkPropTypes;
  
  },{"./lib/ReactPropTypesSecret":73,"fbjs/lib/invariant":7,"fbjs/lib/warning":8}],70:[function(require,module,exports){
  /**
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   */
  
  'use strict';
  
  var emptyFunction = require('fbjs/lib/emptyFunction');
  var invariant = require('fbjs/lib/invariant');
  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');
  
  module.exports = function() {
    function shim(props, propName, componentName, location, propFullName, secret) {
      if (secret === ReactPropTypesSecret) {
        // It is still safe when called from React.
        return;
      }
      invariant(
        false,
        'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
        'Use PropTypes.checkPropTypes() to call them. ' +
        'Read more at http://fb.me/use-check-prop-types'
      );
    };
    shim.isRequired = shim;
    function getShim() {
      return shim;
    };
    // Important!
    // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
    var ReactPropTypes = {
      array: shim,
      bool: shim,
      func: shim,
      number: shim,
      object: shim,
      string: shim,
      symbol: shim,
  
      any: shim,
      arrayOf: getShim,
      element: shim,
      instanceOf: getShim,
      node: shim,
      objectOf: getShim,
      oneOf: getShim,
      oneOfType: getShim,
      shape: getShim,
      exact: getShim
    };
  
    ReactPropTypes.checkPropTypes = emptyFunction;
    ReactPropTypes.PropTypes = ReactPropTypes;
  
    return ReactPropTypes;
  };
  
  },{"./lib/ReactPropTypesSecret":73,"fbjs/lib/emptyFunction":6,"fbjs/lib/invariant":7}],71:[function(require,module,exports){
  /**
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   */
  
  'use strict';
  
  var emptyFunction = require('fbjs/lib/emptyFunction');
  var invariant = require('fbjs/lib/invariant');
  var warning = require('fbjs/lib/warning');
  var assign = require('object-assign');
  
  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');
  var checkPropTypes = require('./checkPropTypes');
  
  module.exports = function(isValidElement, throwOnDirectAccess) {
    /* global Symbol */
    var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
    var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
  
    /**
     * Returns the iterator method function contained on the iterable object.
     *
     * Be sure to invoke the function with the iterable as context:
     *
     *     var iteratorFn = getIteratorFn(myIterable);
     *     if (iteratorFn) {
     *       var iterator = iteratorFn.call(myIterable);
     *       ...
     *     }
     *
     * @param {?object} maybeIterable
     * @return {?function}
     */
    function getIteratorFn(maybeIterable) {
      var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
      if (typeof iteratorFn === 'function') {
        return iteratorFn;
      }
    }
  
    /**
     * Collection of methods that allow declaration and validation of props that are
     * supplied to React components. Example usage:
     *
     *   var Props = require('ReactPropTypes');
     *   var MyArticle = React.createClass({
     *     propTypes: {
     *       // An optional string prop named "description".
     *       description: Props.string,
     *
     *       // A required enum prop named "category".
     *       category: Props.oneOf(['News','Photos']).isRequired,
     *
     *       // A prop named "dialog" that requires an instance of Dialog.
     *       dialog: Props.instanceOf(Dialog).isRequired
     *     },
     *     render: function() { ... }
     *   });
     *
     * A more formal specification of how these methods are used:
     *
     *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
     *   decl := ReactPropTypes.{type}(.isRequired)?
     *
     * Each and every declaration produces a function with the same signature. This
     * allows the creation of custom validation functions. For example:
     *
     *  var MyLink = React.createClass({
     *    propTypes: {
     *      // An optional string or URI prop named "href".
     *      href: function(props, propName, componentName) {
     *        var propValue = props[propName];
     *        if (propValue != null && typeof propValue !== 'string' &&
     *            !(propValue instanceof URI)) {
     *          return new Error(
     *            'Expected a string or an URI for ' + propName + ' in ' +
     *            componentName
     *          );
     *        }
     *      }
     *    },
     *    render: function() {...}
     *  });
     *
     * @internal
     */
  
    var ANONYMOUS = '<<anonymous>>';
  
    // Important!
    // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
    var ReactPropTypes = {
      array: createPrimitiveTypeChecker('array'),
      bool: createPrimitiveTypeChecker('boolean'),
      func: createPrimitiveTypeChecker('function'),
      number: createPrimitiveTypeChecker('number'),
      object: createPrimitiveTypeChecker('object'),
      string: createPrimitiveTypeChecker('string'),
      symbol: createPrimitiveTypeChecker('symbol'),
  
      any: createAnyTypeChecker(),
      arrayOf: createArrayOfTypeChecker,
      element: createElementTypeChecker(),
      instanceOf: createInstanceTypeChecker,
      node: createNodeChecker(),
      objectOf: createObjectOfTypeChecker,
      oneOf: createEnumTypeChecker,
      oneOfType: createUnionTypeChecker,
      shape: createShapeTypeChecker,
      exact: createStrictShapeTypeChecker,
    };
  
    /**
     * inlined Object.is polyfill to avoid requiring consumers ship their own
     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
     */
    /*eslint-disable no-self-compare*/
    function is(x, y) {
      // SameValue algorithm
      if (x === y) {
        // Steps 1-5, 7-10
        // Steps 6.b-6.e: +0 != -0
        return x !== 0 || 1 / x === 1 / y;
      } else {
        // Step 6.a: NaN == NaN
        return x !== x && y !== y;
      }
    }
    /*eslint-enable no-self-compare*/
  
    /**
     * We use an Error-like object for backward compatibility as people may call
     * PropTypes directly and inspect their output. However, we don't use real
     * Errors anymore. We don't inspect their stack anyway, and creating them
     * is prohibitively expensive if they are created too often, such as what
     * happens in oneOfType() for any type before the one that matched.
     */
    function PropTypeError(message) {
      this.message = message;
      this.stack = '';
    }
    // Make `instanceof Error` still work for returned errors.
    PropTypeError.prototype = Error.prototype;
  
    function createChainableTypeChecker(validate) {
      if ("development" !== 'production') {
        var manualPropTypeCallCache = {};
        var manualPropTypeWarningCount = 0;
      }
      function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
        componentName = componentName || ANONYMOUS;
        propFullName = propFullName || propName;
  
        if (secret !== ReactPropTypesSecret) {
          if (throwOnDirectAccess) {
            // New behavior only for users of `prop-types` package
            invariant(
              false,
              'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
              'Use `PropTypes.checkPropTypes()` to call them. ' +
              'Read more at http://fb.me/use-check-prop-types'
            );
          } else if ("development" !== 'production' && typeof console !== 'undefined') {
            // Old behavior for people using React.PropTypes
            var cacheKey = componentName + ':' + propName;
            if (
              !manualPropTypeCallCache[cacheKey] &&
              // Avoid spamming the console because they are often not actionable except for lib authors
              manualPropTypeWarningCount < 3
            ) {
              warning(
                false,
                'You are manually calling a React.PropTypes validation ' +
                'function for the `%s` prop on `%s`. This is deprecated ' +
                'and will throw in the standalone `prop-types` package. ' +
                'You may be seeing this warning due to a third-party PropTypes ' +
                'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',
                propFullName,
                componentName
              );
              manualPropTypeCallCache[cacheKey] = true;
              manualPropTypeWarningCount++;
            }
          }
        }
        if (props[propName] == null) {
          if (isRequired) {
            if (props[propName] === null) {
              return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
            }
            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
          }
          return null;
        } else {
          return validate(props, propName, componentName, location, propFullName);
        }
      }
  
      var chainedCheckType = checkType.bind(null, false);
      chainedCheckType.isRequired = checkType.bind(null, true);
  
      return chainedCheckType;
    }
  
    function createPrimitiveTypeChecker(expectedType) {
      function validate(props, propName, componentName, location, propFullName, secret) {
        var propValue = props[propName];
        var propType = getPropType(propValue);
        if (propType !== expectedType) {
          // `propValue` being instance of, say, date/regexp, pass the 'object'
          // check, but we can offer a more precise error message here rather than
          // 'of type `object`'.
          var preciseType = getPreciseType(propValue);
  
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
        }
        return null;
      }
      return createChainableTypeChecker(validate);
    }
  
    function createAnyTypeChecker() {
      return createChainableTypeChecker(emptyFunction.thatReturnsNull);
    }
  
    function createArrayOfTypeChecker(typeChecker) {
      function validate(props, propName, componentName, location, propFullName) {
        if (typeof typeChecker !== 'function') {
          return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
        }
        var propValue = props[propName];
        if (!Array.isArray(propValue)) {
          var propType = getPropType(propValue);
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
        }
        for (var i = 0; i < propValue.length; i++) {
          var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
          if (error instanceof Error) {
            return error;
          }
        }
        return null;
      }
      return createChainableTypeChecker(validate);
    }
  
    function createElementTypeChecker() {
      function validate(props, propName, componentName, location, propFullName) {
        var propValue = props[propName];
        if (!isValidElement(propValue)) {
          var propType = getPropType(propValue);
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
        }
        return null;
      }
      return createChainableTypeChecker(validate);
    }
  
    function createInstanceTypeChecker(expectedClass) {
      function validate(props, propName, componentName, location, propFullName) {
        if (!(props[propName] instanceof expectedClass)) {
          var expectedClassName = expectedClass.name || ANONYMOUS;
          var actualClassName = getClassName(props[propName]);
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
        }
        return null;
      }
      return createChainableTypeChecker(validate);
    }
  
    function createEnumTypeChecker(expectedValues) {
      if (!Array.isArray(expectedValues)) {
        "development" !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
        return emptyFunction.thatReturnsNull;
      }
  
      function validate(props, propName, componentName, location, propFullName) {
        var propValue = props[propName];
        for (var i = 0; i < expectedValues.length; i++) {
          if (is(propValue, expectedValues[i])) {
            return null;
          }
        }
  
        var valuesString = JSON.stringify(expectedValues);
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
      }
      return createChainableTypeChecker(validate);
    }
  
    function createObjectOfTypeChecker(typeChecker) {
      function validate(props, propName, componentName, location, propFullName) {
        if (typeof typeChecker !== 'function') {
          return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
        }
        var propValue = props[propName];
        var propType = getPropType(propValue);
        if (propType !== 'object') {
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
        }
        for (var key in propValue) {
          if (propValue.hasOwnProperty(key)) {
            var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
            if (error instanceof Error) {
              return error;
            }
          }
        }
        return null;
      }
      return createChainableTypeChecker(validate);
    }
  
    function createUnionTypeChecker(arrayOfTypeCheckers) {
      if (!Array.isArray(arrayOfTypeCheckers)) {
        "development" !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
        return emptyFunction.thatReturnsNull;
      }
  
      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
        var checker = arrayOfTypeCheckers[i];
        if (typeof checker !== 'function') {
          warning(
            false,
            'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
            'received %s at index %s.',
            getPostfixForTypeWarning(checker),
            i
          );
          return emptyFunction.thatReturnsNull;
        }
      }
  
      function validate(props, propName, componentName, location, propFullName) {
        for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
          var checker = arrayOfTypeCheckers[i];
          if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
            return null;
          }
        }
  
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
      }
      return createChainableTypeChecker(validate);
    }
  
    function createNodeChecker() {
      function validate(props, propName, componentName, location, propFullName) {
        if (!isNode(props[propName])) {
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
        }
        return null;
      }
      return createChainableTypeChecker(validate);
    }
  
    function createShapeTypeChecker(shapeTypes) {
      function validate(props, propName, componentName, location, propFullName) {
        var propValue = props[propName];
        var propType = getPropType(propValue);
        if (propType !== 'object') {
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
        }
        for (var key in shapeTypes) {
          var checker = shapeTypes[key];
          if (!checker) {
            continue;
          }
          var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
          if (error) {
            return error;
          }
        }
        return null;
      }
      return createChainableTypeChecker(validate);
    }
  
    function createStrictShapeTypeChecker(shapeTypes) {
      function validate(props, propName, componentName, location, propFullName) {
        var propValue = props[propName];
        var propType = getPropType(propValue);
        if (propType !== 'object') {
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
        }
        // We need to check all keys in case some are required but missing from
        // props.
        var allKeys = assign({}, props[propName], shapeTypes);
        for (var key in allKeys) {
          var checker = shapeTypes[key];
          if (!checker) {
            return new PropTypeError(
              'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
              '\nBad object: ' + JSON.stringify(props[propName], null, '  ') +
              '\nValid keys: ' +  JSON.stringify(Object.keys(shapeTypes), null, '  ')
            );
          }
          var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
          if (error) {
            return error;
          }
        }
        return null;
      }
  
      return createChainableTypeChecker(validate);
    }
  
    function isNode(propValue) {
      switch (typeof propValue) {
        case 'number':
        case 'string':
        case 'undefined':
          return true;
        case 'boolean':
          return !propValue;
        case 'object':
          if (Array.isArray(propValue)) {
            return propValue.every(isNode);
          }
          if (propValue === null || isValidElement(propValue)) {
            return true;
          }
  
          var iteratorFn = getIteratorFn(propValue);
          if (iteratorFn) {
            var iterator = iteratorFn.call(propValue);
            var step;
            if (iteratorFn !== propValue.entries) {
              while (!(step = iterator.next()).done) {
                if (!isNode(step.value)) {
                  return false;
                }
              }
            } else {
              // Iterator will provide entry [k,v] tuples rather than values.
              while (!(step = iterator.next()).done) {
                var entry = step.value;
                if (entry) {
                  if (!isNode(entry[1])) {
                    return false;
                  }
                }
              }
            }
          } else {
            return false;
          }
  
          return true;
        default:
          return false;
      }
    }
  
    function isSymbol(propType, propValue) {
      // Native Symbol.
      if (propType === 'symbol') {
        return true;
      }
  
      // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
      if (propValue['@@toStringTag'] === 'Symbol') {
        return true;
      }
  
      // Fallback for non-spec compliant Symbols which are polyfilled.
      if (typeof Symbol === 'function' && propValue instanceof Symbol) {
        return true;
      }
  
      return false;
    }
  
    // Equivalent of `typeof` but with special handling for array and regexp.
    function getPropType(propValue) {
      var propType = typeof propValue;
      if (Array.isArray(propValue)) {
        return 'array';
      }
      if (propValue instanceof RegExp) {
        // Old webkits (at least until Android 4.0) return 'function' rather than
        // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
        // passes PropTypes.object.
        return 'object';
      }
      if (isSymbol(propType, propValue)) {
        return 'symbol';
      }
      return propType;
    }
  
    // This handles more types than `getPropType`. Only used for error messages.
    // See `createPrimitiveTypeChecker`.
    function getPreciseType(propValue) {
      if (typeof propValue === 'undefined' || propValue === null) {
        return '' + propValue;
      }
      var propType = getPropType(propValue);
      if (propType === 'object') {
        if (propValue instanceof Date) {
          return 'date';
        } else if (propValue instanceof RegExp) {
          return 'regexp';
        }
      }
      return propType;
    }
  
    // Returns a string that is postfixed to a warning about an invalid type.
    // For example, "undefined" or "of type array"
    function getPostfixForTypeWarning(value) {
      var type = getPreciseType(value);
      switch (type) {
        case 'array':
        case 'object':
          return 'an ' + type;
        case 'boolean':
        case 'date':
        case 'regexp':
          return 'a ' + type;
        default:
          return type;
      }
    }
  
    // Returns class name of the object, if any.
    function getClassName(propValue) {
      if (!propValue.constructor || !propValue.constructor.name) {
        return ANONYMOUS;
      }
      return propValue.constructor.name;
    }
  
    ReactPropTypes.checkPropTypes = checkPropTypes;
    ReactPropTypes.PropTypes = ReactPropTypes;
  
    return ReactPropTypes;
  };
  
  },{"./checkPropTypes":69,"./lib/ReactPropTypesSecret":73,"fbjs/lib/emptyFunction":6,"fbjs/lib/invariant":7,"fbjs/lib/warning":8,"object-assign":68}],72:[function(require,module,exports){
  /**
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   */
  
  if ("development" !== 'production') {
    var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&
      Symbol.for &&
      Symbol.for('react.element')) ||
      0xeac7;
  
    var isValidElement = function(object) {
      return typeof object === 'object' &&
        object !== null &&
        object.$$typeof === REACT_ELEMENT_TYPE;
    };
  
    // By explicitly using `prop-types` you are opting into new development behavior.
    // http://fb.me/prop-types-in-prod
    var throwOnDirectAccess = true;
    module.exports = require('./factoryWithTypeCheckers')(isValidElement, throwOnDirectAccess);
  } else {
    // By explicitly using `prop-types` you are opting into new production behavior.
    // http://fb.me/prop-types-in-prod
    module.exports = require('./factoryWithThrowingShims')();
  }
  
  },{"./factoryWithThrowingShims":70,"./factoryWithTypeCheckers":71}],73:[function(require,module,exports){
  /**
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   */
  
  'use strict';
  
  var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
  
  module.exports = ReactPropTypesSecret;
  
  },{}],74:[function(require,module,exports){
  (function (global){
  /*! https://mths.be/punycode v1.4.1 by @mathias */
  ;(function(root) {
  
  	/** Detect free variables */
  	var freeExports = typeof exports == 'object' && exports &&
  		!exports.nodeType && exports;
  	var freeModule = typeof module == 'object' && 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 (
  		typeof define == 'function' &&
  		typeof define.amd == 'object' &&
  		define.amd
  	) {
  		define('punycode', function() {
  			return punycode;
  		});
  	} else if (freeExports && freeModule) {
  		if (module.exports == freeExports) {
  			// in Node.js, io.js, or RingoJS v0.8.0+
  			freeModule.exports = punycode;
  		} else {
  			// in Narwhal or RingoJS v0.7.0-
  			for (key in punycode) {
  				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
  			}
  		}
  	} else {
  		// in Rhino or a web browser
  		root.punycode = punycode;
  	}
  
  }(this));
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{}],75:[function(require,module,exports){
  module.exports=/[\0-\x1F\x7F-\x9F]/
  },{}],76:[function(require,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|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/
  },{}],77:[function(require,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\u0AF0\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-\u2E49\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]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC9\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/
  },{}],78:[function(require,module,exports){
  module.exports=/[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/
  },{}],79:[function(require,module,exports){
  'use strict';
  
  exports.Any = require('./properties/Any/regex');
  exports.Cc  = require('./categories/Cc/regex');
  exports.Cf  = require('./categories/Cf/regex');
  exports.P   = require('./categories/P/regex');
  exports.Z   = require('./categories/Z/regex');
  
  },{"./categories/Cc/regex":75,"./categories/Cf/regex":76,"./categories/P/regex":77,"./categories/Z/regex":78,"./properties/Any/regex":80}],80:[function(require,module,exports){
  module.exports=/[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/
  },{}],81:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = undefined;
  
  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;
    };
  }();
  
  var _get = function get(object, property, receiver) {
    if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
      var parent = Object.getPrototypeOf(object);if (parent === null) {
        return undefined;
      } else {
        return get(parent, property, receiver);
      }
    } else if ("value" in desc) {
      return desc.value;
    } else {
      var getter = desc.get;if (getter === undefined) {
        return undefined;
      }return getter.call(receiver);
    }
  };
  
  var _desc, _value, _class, _descriptor, _descriptor2;
  
  var _mobx = require('mobx');
  
  var _instrumentModel = require('../instruments/instrument-model');
  
  var _instrumentModel2 = _interopRequireDefault(_instrumentModel);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var Agent = (_class = function (_Instrument) {
    _inherits(Agent, _Instrument);
  
    function Agent(props) {
      _classCallCheck(this, Agent);
  
      var _this = _possibleConstructorReturn(this, (Agent.__proto__ || Object.getPrototypeOf(Agent)).call(this, props));
  
      _initDefineProp(_this, 'callCount', _descriptor, _this);
  
      _initDefineProp(_this, 'functionName', _descriptor2, _this);
  
      _this.callCount = props.callCount;
      _this.functionName = props.functionName;
      return _this;
    }
  
    _createClass(Agent, [{
      key: 'update',
      value: function update(props) {
        _get(Agent.prototype.__proto__ || Object.getPrototypeOf(Agent.prototype), 'update', this).call(this, props);
  
        this.callCount = props.callCount;
        this.functionName = props.functionName;
      }
    }]);
  
    return Agent;
  }(_instrumentModel2.default), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'callCount', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return 0;
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'functionName', [_mobx.observable], {
    enumerable: true,
    initializer: null
  })), _class);
  exports.default = Agent;
  module.exports = exports['default'];
  
  },{"../instruments/instrument-model":93,"mobx":"mobx"}],82:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.AgentsList = exports.Agent = undefined;
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _collapsible = require('../collapsible/collapsible');
  
  var _collapsible2 = _interopRequireDefault(_collapsible);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  var Agent = (0, _mobxReact.observer)(function (_ref) {
    var model = _ref.model;
    return _react2.default.createElement('tr', { className: (0, _classnames2.default)({ 'no-calls': !model.callCount }) }, _react2.default.createElement('td', null, model.type), _react2.default.createElement('td', null, model.functionName), _react2.default.createElement('td', null, [].concat(model.alias).join(', ')), _react2.default.createElement('td', { className: 'call-count' }, model.callCount || '-'));
  });
  
  var AgentsList = (0, _mobxReact.observer)(function (_ref2) {
    var model = _ref2.model;
    return _react2.default.createElement('tbody', null, _lodash2.default.map(model.agents, function (agent) {
      return _react2.default.createElement(Agent, { key: agent.id, model: agent });
    }));
  });
  
  var Agents = (0, _mobxReact.observer)(function (_ref3) {
    var model = _ref3.model;
    return _react2.default.createElement('div', {
      className: (0, _classnames2.default)('runnable-agents-region', {
        'no-agents': !model.agents.length
      })
    }, _react2.default.createElement('div', { className: 'instruments-container' }, _react2.default.createElement('ul', { className: 'hooks-container' }, _react2.default.createElement('li', { className: 'hook-item' }, _react2.default.createElement(_collapsible2.default, {
      header: 'Spies / Stubs (' + model.agents.length + ')',
      headerClass: 'hook-name',
      contentClass: 'instrument-content'
    }, _react2.default.createElement('table', null, _react2.default.createElement('thead', null, _react2.default.createElement('tr', null, _react2.default.createElement('th', null, 'Type'), _react2.default.createElement('th', null, 'Function'), _react2.default.createElement('th', null, 'Alias(es)'), _react2.default.createElement('th', null, '# Calls'))), _react2.default.createElement(AgentsList, { model: model })))))));
  });
  
  exports.Agent = Agent;
  exports.AgentsList = AgentsList;
  exports.default = Agents;
  
  },{"../collapsible/collapsible":83,"classnames":1,"lodash":"lodash","mobx-react":"mobx-react","react":"react"}],83:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  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;
    };
  }();
  
  var _class, _temp;
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  var Collapsible = (_temp = _class = function (_Component) {
    _inherits(Collapsible, _Component);
  
    function Collapsible(props) {
      _classCallCheck(this, Collapsible);
  
      var _this = _possibleConstructorReturn(this, (Collapsible.__proto__ || Object.getPrototypeOf(Collapsible)).call(this, props));
  
      _this._toggleOpen = function () {
        _this.setState({ isOpen: !_this.state.isOpen });
      };
  
      _this.state = { isOpen: props.isOpen };
      return _this;
    }
  
    _createClass(Collapsible, [{
      key: 'componentDidUpdate',
      value: function componentDidUpdate(prevProps) {
        if (this.props.isOpen != null && this.props.isOpen !== prevProps.isOpen) {
          this.setState({ isOpen: this.props.isOpen });
        }
      }
    }, {
      key: 'render',
      value: function render() {
        return _react2.default.createElement('div', { className: (0, _classnames2.default)('collapsible', { 'is-open': this.state.isOpen }) }, _react2.default.createElement('div', { className: (0, _classnames2.default)('collapsible-header', this.props.headerClass), style: this.props.headerStyle, onClick: this._toggleOpen }, _react2.default.createElement('i', { className: 'collapsible-indicator fa-fw fa' }), this.props.header, _react2.default.createElement('i', { className: 'collapsible-more fa fa-ellipsis-h' })), _react2.default.createElement('div', { className: (0, _classnames2.default)('collapsible-content', this.props.contentClass) }, this.props.children));
      }
    }]);
  
    return Collapsible;
  }(_react.Component), _class.defaultProps = {
    isOpen: false,
    headerClass: '',
    headerStyle: {},
    contentClass: ''
  }, _temp);
  exports.default = Collapsible;
  module.exports = exports['default'];
  
  },{"classnames":1,"react":"react"}],84:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = undefined;
  
  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;
    };
  }();
  
  var _get = function get(object, property, receiver) {
    if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
      var parent = Object.getPrototypeOf(object);if (parent === null) {
        return undefined;
      } else {
        return get(parent, property, receiver);
      }
    } else if ("value" in desc) {
      return desc.value;
    } else {
      var getter = desc.get;if (getter === undefined) {
        return undefined;
      }return getter.call(receiver);
    }
  };
  
  var _dec, _desc, _value, _class, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5, _descriptor6, _descriptor7;
  
  var _mobx = require('mobx');
  
  var _errModel = require('../lib/err-model');
  
  var _errModel2 = _interopRequireDefault(_errModel);
  
  var _instrumentModel = require('../instruments/instrument-model');
  
  var _instrumentModel2 = _interopRequireDefault(_instrumentModel);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var LONG_RUNNING_THRESHOLD = 1000;
  
  var Command = (_dec = _mobx.observable.struct, (_class = function (_Instrument) {
    _inherits(Command, _Instrument);
  
    function Command(props) {
      _classCallCheck(this, Command);
  
      var _this = _possibleConstructorReturn(this, (Command.__proto__ || Object.getPrototypeOf(Command)).call(this, props));
  
      _initDefineProp(_this, 'renderProps', _descriptor, _this);
  
      _initDefineProp(_this, 'err', _descriptor2, _this);
  
      _initDefineProp(_this, 'event', _descriptor3, _this);
  
      _initDefineProp(_this, 'isLongRunning', _descriptor4, _this);
  
      _initDefineProp(_this, 'number', _descriptor5, _this);
  
      _initDefineProp(_this, 'numElements', _descriptor6, _this);
  
      _initDefineProp(_this, 'visible', _descriptor7, _this);
  
      _this._prevState = null;
  
      _this.err.update(props.err);
      _this.event = props.event;
      _this.number = props.number;
      _this.numElements = props.numElements;
      _this.renderProps = props.renderProps || {};
      _this.visible = props.visible;
  
      _this._checkLongRunning();
      return _this;
    }
  
    _createClass(Command, [{
      key: 'update',
      value: function update(props) {
        _get(Command.prototype.__proto__ || Object.getPrototypeOf(Command.prototype), 'update', this).call(this, props);
  
        this.err.update(props.err);
        this.event = props.event;
        this.numElements = props.numElements;
        this.renderProps = props.renderProps || {};
        this.visible = props.visible;
  
        this._checkLongRunning();
      }
  
      // the following several methods track if the command's state has been
      // active for more than the LONG_RUNNING_THRESHOLD and set the
      // isLongRunning flag to true, which propagates up to the test to
      // auto-expand it
  
    }, {
      key: '_checkLongRunning',
      value: function _checkLongRunning() {
        var _this2 = this;
  
        if (this._becamePending()) {
          this._startTimingPending();
        }
  
        if (this._becameNonPending()) {
          clearTimeout(this._pendingTimeout);
          (0, _mobx.action)('became:inactive', function () {
            return _this2.isLongRunning = false;
          })();
        }
  
        this._prevState = this.state;
      }
    }, {
      key: '_startTimingPending',
      value: function _startTimingPending() {
        var _this3 = this;
  
        this._pendingTimeout = setTimeout((0, _mobx.action)('became:long:running', function () {
          if (_this3._isPending()) {
            _this3.isLongRunning = true;
          }
        }), LONG_RUNNING_THRESHOLD);
      }
    }, {
      key: '_becamePending',
      value: function _becamePending() {
        return !this._wasPending() && this._isPending();
      }
    }, {
      key: '_becameNonPending',
      value: function _becameNonPending() {
        return this._wasPending() && !this._isPending();
      }
    }, {
      key: '_wasPending',
      value: function _wasPending() {
        return this._prevState === 'pending';
      }
    }, {
      key: '_isPending',
      value: function _isPending() {
        return this.state === 'pending';
      }
    }]);
  
    return Command;
  }(_instrumentModel2.default), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'renderProps', [_dec], {
    enumerable: true,
    initializer: function initializer() {
      return {};
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'err', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return new _errModel2.default({});
    }
  }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'event', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return false;
    }
  }), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, 'isLongRunning', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return false;
    }
  }), _descriptor5 = _applyDecoratedDescriptor(_class.prototype, 'number', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor6 = _applyDecoratedDescriptor(_class.prototype, 'numElements', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor7 = _applyDecoratedDescriptor(_class.prototype, 'visible', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return true;
    }
  })), _class));
  exports.default = Command;
  module.exports = exports['default'];
  
  },{"../instruments/instrument-model":93,"../lib/err-model":95,"mobx":"mobx"}],85:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.Message = exports.AliasesReferences = exports.Aliases = undefined;
  
  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;
    };
  }();
  
  var _class, _desc, _value, _class2, _descriptor, _class3, _temp2;
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _markdownIt = require('markdown-it');
  
  var _markdownIt2 = _interopRequireDefault(_markdownIt);
  
  var _mobx = require('mobx');
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _reactTooltip = require('@cypress/react-tooltip');
  
  var _reactTooltip2 = _interopRequireDefault(_reactTooltip);
  
  var _appState = require('../lib/app-state');
  
  var _appState2 = _interopRequireDefault(_appState);
  
  var _events = require('../lib/events');
  
  var _events2 = _interopRequireDefault(_events);
  
  var _flashOnClick = require('../lib/flash-on-click');
  
  var _flashOnClick2 = _interopRequireDefault(_flashOnClick);
  
  var _runnablesStore = require('../runnables/runnables-store');
  
  var _runnablesStore2 = _interopRequireDefault(_runnablesStore);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var md = new _markdownIt2.default();
  
  var displayName = function displayName(model) {
    return model.displayName || model.name;
  };
  var nameClassName = function nameClassName(name) {
    return name.replace(/(\s+)/g, '-');
  };
  var getMessage = function getMessage(model) {
    return model.renderProps.message || model.message;
  };
  var formattedMessage = function formattedMessage(message) {
    return message ? md.renderInline(message) : '';
  };
  var visibleMessage = function visibleMessage(model) {
    if (model.visible) return '';
  
    return model.numElements > 1 ? 'One or more matched elements are not visible.' : 'This element is not visible.';
  };
  
  var AliasesReferences = (0, _mobxReact.observer)(function (_ref) {
    var model = _ref.model;
    return _react2.default.createElement('span', null, _lodash2.default.map([].concat(model.referencesAlias), function (alias) {
      return _react2.default.createElement(_reactTooltip2.default, { key: alias, placement: 'top', title: 'Found an alias for: \'' + alias + '\'' }, _react2.default.createElement('span', { className: 'command-alias ' + model.aliasType }, '@', alias));
    }));
  });
  
  var Aliases = (0, _mobxReact.observer)(function (_ref2) {
    var model = _ref2.model;
  
    if (!model.alias) return null;
  
    return _react2.default.createElement('span', null, _lodash2.default.map([].concat(model.alias), function (alias) {
      return _react2.default.createElement(_reactTooltip2.default, { key: alias, placement: 'top', title: model.message + ' aliased as: \'' + alias + '\'' }, _react2.default.createElement('span', { className: 'command-alias ' + model.aliasType }, alias));
    }));
  });
  
  var Message = (0, _mobxReact.observer)(function (_ref3) {
    var model = _ref3.model;
    return _react2.default.createElement('span', null, _react2.default.createElement('i', { className: 'fa fa-circle ' + model.renderProps.indicator }), _react2.default.createElement('span', { className: 'command-message-text', dangerouslySetInnerHTML: { __html: formattedMessage(getMessage(model)) } }));
  });
  
  var Command = (0, _mobxReact.observer)(_class = (_class2 = (_temp2 = _class3 = function (_Component) {
    _inherits(Command, _Component);
  
    function Command() {
      var _ref4;
  
      var _temp, _this, _ret;
  
      _classCallCheck(this, Command);
  
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
  
      return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref4 = Command.__proto__ || Object.getPrototypeOf(Command)).call.apply(_ref4, [this].concat(args))), _this), _this._shouldShowClickMessage = function () {
        return !_this.props.appState.isRunning && _this._isPinned();
      }, _initDefineProp(_this, '_onClick', _descriptor, _this), _temp), _possibleConstructorReturn(_this, _ret);
    }
  
    _createClass(Command, [{
      key: 'render',
      value: function render() {
        var _this2 = this;
  
        var model = this.props.model;
  
        var message = getMessage(model);
  
        return _react2.default.createElement('li', {
          className: (0, _classnames2.default)('command', 'command-name-' + nameClassName(model.name), 'command-state-' + model.state, 'command-type-' + model.type, {
            'command-is-event': !!model.event,
            'command-is-invisible': model.visible != null && !model.visible,
            'command-has-num-elements': model.state !== 'pending' && model.numElements != null,
            'command-other-pinned': this._isOtherCommandPinned(),
            'command-is-pinned': this._isPinned(),
            'command-with-indicator': !!model.renderProps.indicator,
            'command-scaled': message && message.length > 100,
            'no-elements': !model.numElements,
            'multiple-elements': model.numElements > 1
          }),
          onMouseOver: function onMouseOver() {
            return _this2._snapshot(true);
          },
          onMouseOut: function onMouseOut() {
            return _this2._snapshot(false);
          }
        }, _react2.default.createElement(_flashOnClick2.default, {
          message: 'Printed output to your console',
          onClick: this._onClick,
          shouldShowMessage: this._shouldShowClickMessage
        }, _react2.default.createElement('div', { className: 'command-wrapper' }, _react2.default.createElement('span', { className: 'command-number' }, _react2.default.createElement('i', { className: 'fa fa-spinner fa-spin' }), _react2.default.createElement('span', null, model.number || '')), _react2.default.createElement('span', { className: 'command-pin' }, _react2.default.createElement('i', { className: 'fa fa-thumb-tack' })), _react2.default.createElement('span', { className: 'command-method' }, _react2.default.createElement('span', null, model.event ? '(' + displayName(model) + ')' : displayName(model))), _react2.default.createElement('span', { className: 'command-message' }, model.referencesAlias ? _react2.default.createElement(AliasesReferences, { model: model }) : _react2.default.createElement(Message, { model: model })), _react2.default.createElement('span', { className: 'command-controls' }, _react2.default.createElement(Aliases, { model: model }), _react2.default.createElement(_reactTooltip2.default, { placement: 'top', title: visibleMessage(model) }, _react2.default.createElement('i', { className: 'command-invisible fa fa-eye-slash' })), _react2.default.createElement(_reactTooltip2.default, { placement: 'top', title: model.numElements + ' matched elements' }, _react2.default.createElement('span', { className: 'num-elements' }, model.numElements))))));
      }
    }, {
      key: '_isPinned',
      value: function _isPinned() {
        return this.props.appState.pinnedSnapshotId === this.props.model.id;
      }
    }, {
      key: '_isOtherCommandPinned',
      value: function _isOtherCommandPinned() {
        var pinnedId = this.props.appState.pinnedSnapshotId;
        return pinnedId != null && pinnedId !== this.props.model.id;
      }
    }, {
      key: '_snapshot',
  
      // snapshot rules
      //
      // 1. when we hover over a command, wait 50 ms
      // if we're still hovering, send show:snapshot
      //
      // 2. when we hover off a command, wait 50 ms
      // and if we are still in a non-showing state
      // meaning we have moused over nothing instead
      // of a different command, send hide:snapshot
      //
      // this prevents heavy CPU usage when hovering
      // up and down over commands. it also prevents
      // restoring to the original through all of that.
      // additionally when quickly moving your mouse
      // over many commands, unless you're hovered for
      // 50ms, it won't show the snapshot at all. so we
      // optimize for both snapshot showing + restoring
      value: function _snapshot(show) {
        var _this3 = this;
  
        var runnablesStore = this.props.runnablesStore;
  
        if (show) {
          runnablesStore.attemptingShowSnapshot = true;
  
          this._showTimeout = setTimeout(function () {
            runnablesStore.showingSnapshot = true;
            _this3.props.events.emit('show:snapshot', _this3.props.model.id);
          }, 50);
        } else {
          runnablesStore.attemptingShowSnapshot = false;
          clearTimeout(this._showTimeout);
  
          setTimeout(function () {
            // if we are currently showing a snapshot but
            // we aren't trying to show a different snapshot
            if (runnablesStore.showingSnapshot && !runnablesStore.attemptingShowSnapshot) {
              runnablesStore.showingSnapshot = false;
              _this3.props.events.emit('hide:snapshot', _this3.props.model.id);
            }
          }, 50);
        }
      }
    }]);
  
    return Command;
  }(_react.Component), _class3.defaultProps = {
    appState: _appState2.default,
    events: _events2.default,
    runnablesStore: _runnablesStore2.default
  }, _temp2), _descriptor = _applyDecoratedDescriptor(_class2.prototype, '_onClick', [_mobx.action], {
    enumerable: true,
    initializer: function initializer() {
      var _this4 = this;
  
      return function () {
        if (_this4.props.appState.isRunning) return;
  
        var id = _this4.props.model.id;
  
        if (_this4._isPinned()) {
          _this4.props.appState.pinnedSnapshotId = null;
          _this4.props.events.emit('unpin:snapshot', id);
          _this4._snapshot(true);
        } else {
          _this4.props.appState.pinnedSnapshotId = id;
          _this4.props.events.emit('pin:snapshot', id);
          _this4.props.events.emit('show:command', _this4.props.model.id);
        }
      };
    }
  }), _class2)) || _class;
  
  exports.Aliases = Aliases;
  exports.AliasesReferences = AliasesReferences;
  exports.Message = Message;
  exports.default = Command;
  
  },{"../lib/app-state":94,"../lib/events":96,"../lib/flash-on-click":97,"../runnables/runnables-store":105,"@cypress/react-tooltip":"@cypress/react-tooltip","classnames":1,"lodash":"lodash","markdown-it":11,"mobx":"mobx","mobx-react":"mobx-react","react":"react"}],86:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _mobxReact = require('mobx-react');
  
  var _markdownIt = require('markdown-it');
  
  var _markdownIt2 = _interopRequireDefault(_markdownIt);
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  var md = new _markdownIt2.default({ html: true });
  
  var AnError = (0, _mobxReact.observer)(function (_ref) {
    var error = _ref.error;
    return _react2.default.createElement('div', { className: 'error' }, _react2.default.createElement('h2', null, _react2.default.createElement('i', { className: 'fa fa-warning' }), ' ', error.title, error.link && _react2.default.createElement('a', { href: error.link, target: '_blank', rel: 'noopener noreferrer' }, _react2.default.createElement('i', { className: 'fa fa-question-circle' }))), error.callout && _react2.default.createElement('pre', null, error.callout), _react2.default.createElement('div', { dangerouslySetInnerHTML: { __html: md.render(error.message) } }));
  });
  
  exports.default = AnError;
  module.exports = exports['default'];
  
  },{"markdown-it":11,"mobx-react":"mobx-react","react":"react"}],87:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _mobx = require('mobx');
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _reactTooltip = require('@cypress/react-tooltip');
  
  var _reactTooltip2 = _interopRequireDefault(_reactTooltip);
  
  var _events = require('../lib/events');
  
  var _events2 = _interopRequireDefault(_events);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  var ifThen = function ifThen(condition, component) {
    return condition ? component : null;
  };
  
  var Controls = (0, _mobxReact.observer)(function (_ref) {
    var events = _ref.events,
        appState = _ref.appState;
  
    var emit = function emit(event) {
      return function () {
        return events.emit(event);
      };
    };
    var toggleAutoScrolling = function toggleAutoScrolling() {
      appState.toggleAutoScrolling();
      events.emit('save:state');
    };
  
    return _react2.default.createElement('div', { className: 'controls' }, ifThen(appState.isPaused, _react2.default.createElement('span', { className: 'paused-label' }, _react2.default.createElement('label', null, 'Paused'))), ifThen(appState.isPaused, _react2.default.createElement(_reactTooltip2.default, { placement: 'bottom', title: 'Resume' }, _react2.default.createElement('button', { className: 'play', onClick: emit('resume') }, _react2.default.createElement('i', { className: 'fa fa-play' })))), ifThen(!appState.isPaused, _react2.default.createElement(_reactTooltip2.default, { placement: 'bottom', title: (appState.autoScrollingEnabled ? 'Disable' : 'Enable') + ' Auto-scrolling' }, _react2.default.createElement('button', {
      className: (0, _classnames2.default)('toggle-auto-scrolling', { 'auto-scrolling-enabled': appState.autoScrollingEnabled }),
      onClick: (0, _mobx.action)('toggle:auto:scrolling', toggleAutoScrolling)
    }, _react2.default.createElement('i', { className: 'fa' }), _react2.default.createElement('i', { className: 'fa fa-arrows-v' })))), ifThen(appState.isRunning && !appState.isPaused, _react2.default.createElement(_reactTooltip2.default, { placement: 'bottom', title: 'Stop Running' }, _react2.default.createElement('button', { className: 'stop', onClick: emit('stop') }, _react2.default.createElement('i', { className: 'fa fa-stop' })))), ifThen(!appState.isRunning, _react2.default.createElement(_reactTooltip2.default, { placement: 'bottom', title: 'Run All Tests' }, _react2.default.createElement('button', { className: 'restart', onClick: emit('restart') }, _react2.default.createElement('i', { className: 'fa fa-repeat' })))), ifThen(!!appState.nextCommandName, _react2.default.createElement(_reactTooltip2.default, { placement: 'bottom', title: 'Next: \'' + appState.nextCommandName + '\'' }, _react2.default.createElement('button', { className: 'next', onClick: emit('next') }, _react2.default.createElement('i', { className: 'fa fa-step-forward' })))));
  });
  
  Controls.defaultProps = {
    events: _events2.default
  };
  
  exports.default = Controls;
  module.exports = exports['default'];
  
  },{"../lib/events":96,"@cypress/react-tooltip":"@cypress/react-tooltip","classnames":1,"mobx":"mobx","mobx-react":"mobx-react","react":"react"}],88:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _reactTooltip = require('@cypress/react-tooltip');
  
  var _reactTooltip2 = _interopRequireDefault(_reactTooltip);
  
  var _events = require('../lib/events');
  
  var _events2 = _interopRequireDefault(_events);
  
  var _controls = require('./controls');
  
  var _controls2 = _interopRequireDefault(_controls);
  
  var _stats = require('./stats');
  
  var _stats2 = _interopRequireDefault(_stats);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  var Header = (0, _mobxReact.observer)(function (_ref) {
    var appState = _ref.appState,
        events = _ref.events,
        statsStore = _ref.statsStore;
    return _react2.default.createElement('header', null, _react2.default.createElement(_reactTooltip2.default, { placement: 'bottom', title: 'View All Tests', wrapperClassName: 'focus-tests' }, _react2.default.createElement('button', { onClick: function onClick() {
        return events.emit('focus:tests');
      } }, _react2.default.createElement('i', { className: 'fa fa-chevron-left' }), _react2.default.createElement('span', null, 'Tests'))), _react2.default.createElement(_stats2.default, { stats: statsStore }), _react2.default.createElement('div', { className: 'spacer' }), _react2.default.createElement(_controls2.default, { appState: appState }));
  });
  
  Header.defaultProps = {
    events: _events2.default
  };
  
  exports.default = Header;
  module.exports = exports['default'];
  
  },{"../lib/events":96,"./controls":87,"./stats":90,"@cypress/react-tooltip":"@cypress/react-tooltip","mobx-react":"mobx-react","react":"react"}],89:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.StatsStore = undefined;
  
  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;
    };
  }();
  
  var _desc, _value, _class, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5;
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobx = require('mobx');
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var defaults = {
    numPassed: 0,
    numFailed: 0,
    numPending: 0,
  
    _startTime: null,
    _currentTime: null
  };
  
  var StatsStore = (_class = function () {
    function StatsStore() {
      _classCallCheck(this, StatsStore);
  
      _initDefineProp(this, 'numPassed', _descriptor, this);
  
      _initDefineProp(this, 'numFailed', _descriptor2, this);
  
      _initDefineProp(this, 'numPending', _descriptor3, this);
  
      _initDefineProp(this, '_startTime', _descriptor4, this);
  
      _initDefineProp(this, '_currentTime', _descriptor5, this);
    }
  
    _createClass(StatsStore, [{
      key: 'start',
      value: function start(_ref) {
        var startTime = _ref.startTime,
            _ref$numPassed = _ref.numPassed,
            numPassed = _ref$numPassed === undefined ? 0 : _ref$numPassed,
            _ref$numFailed = _ref.numFailed,
            numFailed = _ref$numFailed === undefined ? 0 : _ref$numFailed,
            _ref$numPending = _ref.numPending,
            numPending = _ref$numPending === undefined ? 0 : _ref$numPending;
  
        if (this._startTime) return;
  
        this.numPassed = numPassed;
        this.numFailed = numFailed;
        this.numPending = numPending;
  
        this._startTime = new Date(startTime).getTime();
        this._updateCurrentTime();
  
        this._startTimer();
      }
    }, {
      key: '_startTimer',
      value: function _startTimer() {
        this._interval = setInterval((0, _mobx.action)('duration:interval', this._updateCurrentTime.bind(this)), 100);
      }
    }, {
      key: '_stopTimer',
      value: function _stopTimer() {
        clearInterval(this._interval);
      }
    }, {
      key: '_updateCurrentTime',
      value: function _updateCurrentTime() {
        this._currentTime = Date.now();
      }
    }, {
      key: 'incrementCount',
      value: function incrementCount(type) {
        var countKey = 'num' + _lodash2.default.capitalize(type);
        this[countKey] = this[countKey] + 1;
      }
    }, {
      key: 'pause',
      value: function pause() {
        this._stopTimer();
      }
    }, {
      key: 'resume',
      value: function resume() {
        this._startTimer();
      }
    }, {
      key: 'end',
      value: function end() {
        this._stopTimer();
        this._updateCurrentTime();
      }
    }, {
      key: 'reset',
      value: function reset() {
        var _this = this;
  
        this._stopTimer();
        _lodash2.default.each(defaults, function (value, key) {
          _this[key] = value;
        });
      }
    }, {
      key: 'duration',
      get: function get() {
        if (!this._startTime) return 0;
  
        return this._currentTime - this._startTime;
      }
    }]);
  
    return StatsStore;
  }(), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'numPassed', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults.numPassed;
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'numFailed', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults.numFailed;
    }
  }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'numPending', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults.numPending;
    }
  }), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, '_startTime', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults._startTime;
    }
  }), _descriptor5 = _applyDecoratedDescriptor(_class.prototype, '_currentTime', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults._startTime;
    }
  }), _applyDecoratedDescriptor(_class.prototype, 'duration', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, 'duration'), _class.prototype)), _class);
  exports.StatsStore = StatsStore;
  exports.default = new StatsStore();
  
  },{"lodash":"lodash","mobx":"mobx"}],90:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  var count = function count(num) {
    return num > 0 ? num : '--';
  };
  var formatDuration = function formatDuration(duration) {
    return duration > 0 ? (duration / 1000).toFixed(2) : 0;
  };
  
  var Stats = (0, _mobxReact.observer)(function (_ref) {
    var stats = _ref.stats;
    return _react2.default.createElement('ul', { className: 'stats' }, _react2.default.createElement('li', { className: 'passed' }, _react2.default.createElement('i', { className: 'fa fa-check' }), _react2.default.createElement('span', { className: 'num' }, count(stats.numPassed))), _react2.default.createElement('li', { className: 'failed' }, _react2.default.createElement('i', { className: 'fa fa-times' }), _react2.default.createElement('span', { className: 'num' }, count(stats.numFailed))), _react2.default.createElement('li', { className: 'pending' }, _react2.default.createElement('i', { className: 'fa fa-circle-o-notch' }), _react2.default.createElement('span', { className: 'num' }, count(stats.numPending))), _react2.default.createElement('li', { className: 'duration' }, _react2.default.createElement('span', { className: 'num' }, count(formatDuration(stats.duration)))));
  });
  
  exports.default = Stats;
  module.exports = exports['default'];
  
  },{"mobx-react":"mobx-react","react":"react"}],91:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = undefined;
  
  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;
    };
  }();
  
  var _desc, _value, _class, _descriptor, _descriptor2, _descriptor3, _descriptor4;
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobx = require('mobx');
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var Hook = (_class = function () {
    function Hook(props) {
      _classCallCheck(this, Hook);
  
      _initDefineProp(this, 'id', _descriptor, this);
  
      _initDefineProp(this, 'name', _descriptor2, this);
  
      _initDefineProp(this, 'commands', _descriptor3, this);
  
      _initDefineProp(this, 'failed', _descriptor4, this);
  
      this._currentNumber = 1;
  
      this.id = _lodash2.default.uniqueId('h');
      this.name = props.name;
    }
  
    _createClass(Hook, [{
      key: 'addCommand',
      value: function addCommand(command) {
        if (!command.event) {
          command.number = this._currentNumber;
          this._currentNumber++;
        }
        this.commands.push(command);
      }
    }, {
      key: 'commandMatchingErr',
      value: function commandMatchingErr(errToMatch) {
        return (0, _lodash2.default)(this.commands).filter(function (_ref) {
          var err = _ref.err;
          return err.displayMessage === errToMatch.displayMessage;
        }).last();
      }
    }]);
  
    return Hook;
  }(), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'id', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'name', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'commands', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return [];
    }
  }), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, 'failed', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return false;
    }
  })), _class);
  exports.default = Hook;
  module.exports = exports['default'];
  
  },{"lodash":"lodash","mobx":"mobx"}],92:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.HookHeader = exports.Hook = undefined;
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _command = require('../commands/command');
  
  var _command2 = _interopRequireDefault(_command);
  
  var _collapsible = require('../collapsible/collapsible');
  
  var _collapsible2 = _interopRequireDefault(_collapsible);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  var HookHeader = function HookHeader(_ref) {
    var name = _ref.name;
    return _react2.default.createElement('span', null, name, ' ', _react2.default.createElement('span', { className: 'hook-failed-message' }, '(failed)'));
  };
  
  var Hook = (0, _mobxReact.observer)(function (_ref2) {
    var model = _ref2.model;
    return _react2.default.createElement('li', { className: (0, _classnames2.default)('hook-item', { 'hook-failed': model.failed }) }, _react2.default.createElement(_collapsible2.default, {
      header: _react2.default.createElement(HookHeader, { name: model.name }),
      headerClass: 'hook-name',
      isOpen: true
    }, _react2.default.createElement('ul', { className: 'commands-container' }, _lodash2.default.map(model.commands, function (command) {
      return _react2.default.createElement(_command2.default, { key: command.id, model: command });
    }))));
  });
  
  var Hooks = (0, _mobxReact.observer)(function (_ref3) {
    var model = _ref3.model;
    return _react2.default.createElement('ul', { className: 'hooks-container' }, _lodash2.default.map(model.hooks, function (hook) {
      return _react2.default.createElement(Hook, { key: hook.id, model: hook });
    }));
  });
  
  exports.Hook = Hook;
  exports.HookHeader = HookHeader;
  exports.default = Hooks;
  
  },{"../collapsible/collapsible":83,"../commands/command":85,"classnames":1,"lodash":"lodash","mobx-react":"mobx-react","react":"react"}],93:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = undefined;
  
  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;
    };
  }();
  
  var _dec, _dec2, _desc, _value, _class, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5, _descriptor6, _descriptor7, _descriptor8, _descriptor9;
  
  var _mobx = require('mobx');
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var Log = (_dec = _mobx.observable.ref, _dec2 = _mobx.observable.ref, (_class = function () {
    function Log(props) {
      _classCallCheck(this, Log);
  
      _initDefineProp(this, 'alias', _descriptor, this);
  
      _initDefineProp(this, 'aliasType', _descriptor2, this);
  
      _initDefineProp(this, 'displayName', _descriptor3, this);
  
      _initDefineProp(this, 'id', _descriptor4, this);
  
      _initDefineProp(this, 'name', _descriptor5, this);
  
      _initDefineProp(this, 'message', _descriptor6, this);
  
      _initDefineProp(this, 'type', _descriptor7, this);
  
      _initDefineProp(this, 'state', _descriptor8, this);
  
      _initDefineProp(this, 'referencesAlias', _descriptor9, this);
  
      this.id = props.id;
      this.alias = props.alias;
      this.aliasType = props.aliasType;
      this.displayName = props.displayName;
      this.name = props.name;
      this.message = props.message;
      this.type = props.type;
      this.state = props.state;
      this.referencesAlias = props.referencesAlias;
    }
  
    _createClass(Log, [{
      key: 'update',
      value: function update(props) {
        this.alias = props.alias;
        this.aliasType = props.aliasType;
        this.displayName = props.displayName;
        this.name = props.name;
        this.message = props.message;
        this.type = props.type;
        this.state = props.state;
        this.referencesAlias = props.referencesAlias;
      }
    }]);
  
    return Log;
  }(), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'alias', [_dec], {
    enumerable: true,
    initializer: function initializer() {
      return null;
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'aliasType', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return null;
    }
  }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'displayName', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, 'id', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor5 = _applyDecoratedDescriptor(_class.prototype, 'name', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor6 = _applyDecoratedDescriptor(_class.prototype, 'message', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor7 = _applyDecoratedDescriptor(_class.prototype, 'type', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor8 = _applyDecoratedDescriptor(_class.prototype, 'state', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor9 = _applyDecoratedDescriptor(_class.prototype, 'referencesAlias', [_dec2], {
    enumerable: true,
    initializer: function initializer() {
      return null;
    }
  })), _class));
  exports.default = Log;
  module.exports = exports['default'];
  
  },{"mobx":"mobx"}],94:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.AppState = undefined;
  
  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;
    };
  }();
  
  var _desc, _value, _class, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5;
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobx = require('mobx');
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var defaults = {
    isPaused: false,
    isRunning: false,
    nextCommandName: null,
    pinnedSnapshotId: null
  };
  
  var AppState = (_class = function () {
    function AppState() {
      _classCallCheck(this, AppState);
  
      _initDefineProp(this, 'autoScrollingEnabled', _descriptor, this);
  
      _initDefineProp(this, 'isPaused', _descriptor2, this);
  
      _initDefineProp(this, 'isRunning', _descriptor3, this);
  
      _initDefineProp(this, 'nextCommandName', _descriptor4, this);
  
      _initDefineProp(this, 'pinnedSnapshotId', _descriptor5, this);
  
      this.isStopped = false;
      this._resetAutoScrollingEnabledTo = true;
    }
  
    _createClass(AppState, [{
      key: 'startRunning',
      value: function startRunning() {
        this.isRunning = true;
        this.isStopped = false;
      }
    }, {
      key: 'pause',
      value: function pause(nextCommandName) {
        this.isPaused = true;
        this.nextCommandName = nextCommandName;
      }
    }, {
      key: 'resume',
      value: function resume() {
        this.isPaused = false;
        this.nextCommandName = null;
      }
    }, {
      key: 'stop',
      value: function stop() {
        this.isStopped = true;
      }
    }, {
      key: 'end',
      value: function end() {
        this.isRunning = false;
        this._resetAutoScrolling();
      }
    }, {
      key: 'temporarilySetAutoScrolling',
      value: function temporarilySetAutoScrolling(isEnabled) {
        if (isEnabled != null) {
          this.autoScrollingEnabled = isEnabled;
        }
      }
    }, {
      key: 'toggleAutoScrolling',
      value: function toggleAutoScrolling() {
        this.setAutoScrolling(!this.autoScrollingEnabled);
      }
    }, {
      key: 'setAutoScrolling',
      value: function setAutoScrolling(isEnabled) {
        if (isEnabled != null) {
          this._resetAutoScrollingEnabledTo = isEnabled;
          this.autoScrollingEnabled = isEnabled;
        }
      }
    }, {
      key: 'reset',
      value: function reset() {
        var _this = this;
  
        _lodash2.default.each(defaults, function (value, key) {
          _this[key] = value;
        });
        this._resetAutoScrolling();
      }
    }, {
      key: '_resetAutoScrolling',
      value: function _resetAutoScrolling() {
        this.autoScrollingEnabled = this._resetAutoScrollingEnabledTo;
      }
    }]);
  
    return AppState;
  }(), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'autoScrollingEnabled', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return true;
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'isPaused', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults.isPaused;
    }
  }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'isRunning', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults.isRunning;
    }
  }), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, 'nextCommandName', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults.nextCommandName;
    }
  }), _descriptor5 = _applyDecoratedDescriptor(_class.prototype, 'pinnedSnapshotId', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults.pinnedSnapshotId;
    }
  })), _class);
  exports.AppState = AppState;
  exports.default = new AppState();
  
  },{"lodash":"lodash","mobx":"mobx"}],95:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = undefined;
  
  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;
    };
  }();
  
  var _desc, _value, _class, _descriptor, _descriptor2, _descriptor3;
  
  var _mobx = require('mobx');
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var Err = (_class = function () {
    function Err(props) {
      _classCallCheck(this, Err);
  
      _initDefineProp(this, 'name', _descriptor, this);
  
      _initDefineProp(this, 'message', _descriptor2, this);
  
      _initDefineProp(this, 'stack', _descriptor3, this);
  
      this.update(props);
    }
  
    _createClass(Err, [{
      key: 'update',
      value: function update(props) {
        if (!props) return;
  
        this.name = props.name;
        this.message = props.message;
        this.stack = props.stack;
      }
    }, {
      key: 'displayMessage',
      get: function get() {
        if (!this.name && !this.message) return '';
  
        return this.name + ': ' + this.message;
      }
    }, {
      key: 'isCommandErr',
      get: function get() {
        return (/(AssertionError|CypressError)/.test(this.name)
        );
      }
    }]);
  
    return Err;
  }(), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'name', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return '';
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'message', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return '';
    }
  }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'stack', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return '';
    }
  }), _applyDecoratedDescriptor(_class.prototype, 'displayMessage', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, 'displayMessage'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, 'isCommandErr', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, 'isCommandErr'), _class.prototype)), _class);
  exports.default = Err;
  module.exports = exports['default'];
  
  },{"mobx":"mobx"}],96:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _events = require('events');
  
  var _mobx = require('mobx');
  
  function _toConsumableArray(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
        arr2[i] = arr[i];
      }return arr2;
    } else {
      return Array.from(arr);
    }
  }
  
  var localBus = new _events.EventEmitter();
  
  exports.default = {
    init: function init(_ref) {
      var appState = _ref.appState,
          runnablesStore = _ref.runnablesStore,
          statsStore = _ref.statsStore,
          scroller = _ref.scroller;
  
      this.appState = appState;
      this.runnablesStore = runnablesStore;
      this.statsStore = statsStore;
      this.scroller = scroller;
    },
    listen: function listen(runner) {
      var appState = this.appState,
          runnablesStore = this.runnablesStore,
          scroller = this.scroller,
          statsStore = this.statsStore;
  
      runner.on('runnables:ready', (0, _mobx.action)('runnables:ready', function () {
        var rootRunnable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  
        runnablesStore.setRunnables(rootRunnable);
      }));
  
      runner.on('reporter:log:add', (0, _mobx.action)('log:add', function (log) {
        runnablesStore.addLog(log);
      }));
  
      runner.on('reporter:log:state:changed', (0, _mobx.action)('log:update', function (log) {
        runnablesStore.updateLog(log);
      }));
  
      runner.on('reporter:restart:test:run', (0, _mobx.action)('restart:test:run', function () {
        appState.reset();
        runnablesStore.reset();
        statsStore.reset();
        runner.emit('reporter:restarted');
      }));
  
      runner.on('run:start', (0, _mobx.action)('run:start', function () {
        if (runnablesStore.hasTests) {
          appState.startRunning();
        }
      }));
  
      runner.on('reporter:start', (0, _mobx.action)('start', function (startInfo) {
        appState.temporarilySetAutoScrolling(startInfo.autoScrollingEnabled);
        runnablesStore.setInitialScrollTop(startInfo.scrollTop);
        if (runnablesStore.hasTests) {
          statsStore.start(startInfo);
        }
      }));
  
      runner.on('test:before:run:async', (0, _mobx.action)('test:before:run:async', function (runnable) {
        runnablesStore.runnableStarted(runnable);
      }));
  
      runner.on('test:after:run', (0, _mobx.action)('test:after:run', function (runnable) {
        runnablesStore.runnableFinished(runnable);
        statsStore.incrementCount(runnable.state);
      }));
  
      runner.on('test:set:state', (0, _mobx.action)('test:set:state', function (runnable, cb) {
        runnablesStore.updateTest(runnable, cb);
      }));
  
      runner.on('paused', (0, _mobx.action)('paused', function (nextCommandName) {
        appState.pause(nextCommandName);
        statsStore.pause();
      }));
  
      runner.on('run:end', (0, _mobx.action)('run:end', function () {
        appState.end();
        statsStore.end();
      }));
  
      runner.on('reporter:collect:run:state', function (cb) {
        cb({
          autoScrollingEnabled: appState.autoScrollingEnabled,
          scrollTop: scroller.getScrollTop()
        });
      });
  
      runner.on('reporter:snapshot:unpinned', (0, _mobx.action)('snapshot:unpinned', function () {
        appState.pinnedSnapshotId = null;
      }));
  
      localBus.on('resume', (0, _mobx.action)('resume', function () {
        appState.resume();
        statsStore.resume();
        runner.emit('runner:resume');
      }));
  
      localBus.on('next', (0, _mobx.action)('next', function () {
        runner.emit('runner:next');
      }));
  
      localBus.on('stop', (0, _mobx.action)('stop', function () {
        appState.stop();
        runner.emit('runner:stop');
      }));
  
      localBus.on('restart', (0, _mobx.action)('restart', function () {
        runner.emit('runner:restart');
      }));
  
      localBus.on('show:command', function (commandId) {
        runner.emit('runner:console:log', commandId);
      });
  
      localBus.on('show:error', function (testId) {
        var test = runnablesStore.testById(testId);
        if (test.err.isCommandErr) {
          var command = test.commandMatchingErr();
          if (!command) return;
          runner.emit('runner:console:log', command.id);
        } else {
          runner.emit('runner:console:error', testId);
        }
      });
  
      localBus.on('show:snapshot', function (commandId) {
        runner.emit('runner:show:snapshot', commandId);
      });
  
      localBus.on('hide:snapshot', function (commandId) {
        runner.emit('runner:hide:snapshot', commandId);
      });
  
      localBus.on('pin:snapshot', function (commandId) {
        runner.emit('runner:pin:snapshot', commandId);
      });
  
      localBus.on('unpin:snapshot', function (commandId) {
        runner.emit('runner:unpin:snapshot', commandId);
      });
  
      localBus.on('focus:tests', function () {
        runner.emit('focus:tests');
      });
  
      localBus.on('save:state', function () {
        runner.emit('save:state', {
          autoScrollingEnabled: appState.autoScrollingEnabled
        });
      });
    },
    emit: function emit(event) {
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }
  
      localBus.emit.apply(localBus, [event].concat(_toConsumableArray(args)));
    },
  
    // for testing purposes
    __off: function __off() {
      localBus.removeAllListeners();
    }
  };
  module.exports = exports['default'];
  
  },{"events":5,"mobx":"mobx"}],97:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  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;
    };
  }();
  
  var _class, _desc, _value, _class2, _descriptor, _descriptor2, _class3, _temp2;
  
  var _mobx = require('mobx');
  
  var _mobxReact = require('mobx-react');
  
  var _propTypes = require('prop-types');
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _reactTooltip = require('@cypress/react-tooltip');
  
  var _reactTooltip2 = _interopRequireDefault(_reactTooltip);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var FlashOnClick = (0, _mobxReact.observer)(_class = (_class2 = (_temp2 = _class3 = function (_Component) {
    _inherits(FlashOnClick, _Component);
  
    function FlashOnClick() {
      var _ref;
  
      var _temp, _this, _ret;
  
      _classCallCheck(this, FlashOnClick);
  
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
  
      return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = FlashOnClick.__proto__ || Object.getPrototypeOf(FlashOnClick)).call.apply(_ref, [this].concat(args))), _this), _initDefineProp(_this, '_show', _descriptor, _this), _initDefineProp(_this, '_onClick', _descriptor2, _this), _temp), _possibleConstructorReturn(_this, _ret);
    }
  
    _createClass(FlashOnClick, [{
      key: 'render',
      value: function render() {
        var child = _react.Children.only(this.props.children);
  
        return _react2.default.createElement(_reactTooltip2.default, { placement: 'top', title: this.props.message, visible: this._show }, (0, _react.cloneElement)(child, { onClick: this._onClick }));
      }
    }]);
  
    return FlashOnClick;
  }(_react.Component), _class3.propTypes = {
    message: _propTypes2.default.string.isRequired,
    onClick: _propTypes2.default.func.isRequired,
    shouldShowMessage: _propTypes2.default.func
  }, _class3.defaultProps = {
    shouldShowMessage: function shouldShowMessage() {
      return true;
    }
  }, _temp2), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, '_show', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return false;
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, '_onClick', [_mobx.action], {
    enumerable: true,
    initializer: function initializer() {
      var _this2 = this;
  
      return function (e) {
        _this2.props.onClick(e);
        if (!_this2.props.shouldShowMessage()) return;
  
        _this2._show = true;
        setTimeout((0, _mobx.action)('hide:console:message', function () {
          _this2._show = false;
        }), 1500);
      };
    }
  })), _class2)) || _class;
  
  exports.default = FlashOnClick;
  module.exports = exports['default'];
  
  },{"@cypress/react-tooltip":"@cypress/react-tooltip","mobx":"mobx","mobx-react":"mobx-react","prop-types":72,"react":"react"}],98:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  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");
    }
  }
  
  /**
   container.clientHeight:
   - container visible area height ("viewport")
   - includes padding, but not margin or border
   container.scrollTop:
   - container scroll position:
   container.scrollHeight:
   - total container height (visible + not visible)
   element.clientHeight:
   - element height
   - includes padding, but not margin or border
   element.offsetTop:
   - element distance from top of container
  */
  
  var PADDING = 100;
  
  var Scroller = function () {
    function Scroller() {
      _classCallCheck(this, Scroller);
    }
  
    _createClass(Scroller, [{
      key: 'setContainer',
      value: function setContainer(container, onUserScroll) {
        this._container = container;
  
        this._userScroll = true;
        this._userScrollCount = 0;
  
        this._listenToScrolls(onUserScroll);
      }
    }, {
      key: '_listenToScrolls',
      value: function _listenToScrolls(onUserScroll) {
        var _this = this;
  
        this._container.addEventListener('scroll', function () {
          if (!_this._userScroll) {
            // programmatic scroll
            _this._userScroll = true;
            return;
          }
  
          // there can be false positives for user scrolls, so make sure we get 3
          // or more scroll events within 50ms to count it as a user intending to scroll
          _this._userScrollCount++;
          if (_this._userScrollCount >= 3) {
            onUserScroll();
            clearTimeout(_this._countUserScrollsTimeout);
            _this._countUserScrollsTimeout = null;
            _this._userScrollCount = 0;
            return;
          }
          if (_this._countUserScrollsTimeout) return;
  
          _this._countUserScrollsTimeout = setTimeout(function () {
            _this._countUserScrollsTimeout = null;
            _this._userScrollCount = 0;
          }, 50);
        });
      }
    }, {
      key: 'scrollIntoView',
      value: function scrollIntoView(element) {
        if (!this._container) {
          throw new Error('A container must be set on the scroller with `scroller.setContainer(container)` before trying to scroll an element into view');
        }
  
        if (this._isFullyVisible(element)) {
          return;
        }
  
        // aim to scroll just into view, so that the bottom of the element
        // is just above the bottom of the container
        var scrollTopGoal = this._aboveBottom(element);
        // can't have a negative scroll, so put it to the top
        if (scrollTopGoal < 0) {
          scrollTopGoal = 0;
        }
  
        this._userScroll = false;
        this._container.scrollTop = scrollTopGoal;
      }
    }, {
      key: '_isFullyVisible',
      value: function _isFullyVisible(element) {
        return element.offsetTop - this._container.scrollTop > 0 && this._container.scrollTop > this._aboveBottom(element);
      }
    }, {
      key: '_aboveBottom',
      value: function _aboveBottom(element) {
        // add padding, since commands expanding and collapsing can mess with
        // the offset, causing the running command to be half cut off
        // https://github.com/cypress-io/cypress/issues/228
        return element.offsetTop + element.clientHeight - this._container.clientHeight + PADDING;
      }
    }, {
      key: 'getScrollTop',
      value: function getScrollTop() {
        return this._container ? this._container.scrollTop : 0;
      }
    }, {
      key: 'setScrollTop',
      value: function setScrollTop(scrollTop) {
        if (this._container && scrollTop != null) {
          this._container.scrollTop = scrollTop;
        }
      }
    }, {
      key: 'scrollToEnd',
      value: function scrollToEnd() {
        this.setScrollTop(this._container.scrollHeight - this._container.clientHeight);
      }
  
      // for testing purposes
  
    }, {
      key: '__reset',
      value: function __reset() {
        this._container = null;
        this._userScroll = true;
        this._userScrollCount = 0;
        clearTimeout(this._countUserScrollsTimeout);
        this._countUserScrollsTimeout = null;
      }
    }]);
  
    return Scroller;
  }();
  
  exports.default = new Scroller();
  module.exports = exports['default'];
  
  },{}],99:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var INDENT_BASE = 5;
  var INDENT_AMOUNT = 15;
  
  function indent(level) {
    return INDENT_BASE + level * INDENT_AMOUNT;
  }
  
  exports.indent = indent;
  
  },{}],100:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  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;
    };
  }();
  
  var _class, _class2, _temp;
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _mobx = require('mobx');
  
  var _mobxReact = require('mobx-react');
  
  var _propTypes = require('prop-types');
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _reactDom = require('react-dom');
  
  var _ElementQueries = require('css-element-queries/src/ElementQueries');
  
  var _ElementQueries2 = _interopRequireDefault(_ElementQueries);
  
  var _appState = require('./lib/app-state');
  
  var _appState2 = _interopRequireDefault(_appState);
  
  var _events = require('./lib/events');
  
  var _events2 = _interopRequireDefault(_events);
  
  var _runnablesStore = require('./runnables/runnables-store');
  
  var _runnablesStore2 = _interopRequireDefault(_runnablesStore);
  
  var _scroller = require('./lib/scroller');
  
  var _scroller2 = _interopRequireDefault(_scroller);
  
  var _statsStore = require('./header/stats-store');
  
  var _statsStore2 = _interopRequireDefault(_statsStore);
  
  var _header = require('./header/header');
  
  var _header2 = _interopRequireDefault(_header);
  
  var _runnables = require('./runnables/runnables');
  
  var _runnables2 = _interopRequireDefault(_runnables);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  var Reporter = (0, _mobxReact.observer)(_class = (_temp = _class2 = function (_Component) {
    _inherits(Reporter, _Component);
  
    function Reporter() {
      _classCallCheck(this, Reporter);
  
      return _possibleConstructorReturn(this, (Reporter.__proto__ || Object.getPrototypeOf(Reporter)).apply(this, arguments));
    }
  
    _createClass(Reporter, [{
      key: 'componentWillMount',
      value: function componentWillMount() {
        var _props = this.props,
            appState = _props.appState,
            autoScrollingEnabled = _props.autoScrollingEnabled,
            runnablesStore = _props.runnablesStore,
            runner = _props.runner,
            scroller = _props.scroller,
            statsStore = _props.statsStore;
  
        (0, _mobx.action)('set:scrolling', function () {
          appState.setAutoScrolling(autoScrollingEnabled);
        })();
  
        this.props.events.init({
          appState: appState,
          runnablesStore: runnablesStore,
          scroller: scroller,
          statsStore: statsStore
        });
        this.props.events.listen(runner);
      }
    }, {
      key: 'render',
      value: function render() {
        var appState = this.props.appState;
  
        return _react2.default.createElement('div', { className: (0, _classnames2.default)('reporter', { 'is-running': appState.isRunning }) }, _react2.default.createElement(_header2.default, { appState: appState, statsStore: this.props.statsStore }), _react2.default.createElement(_runnables2.default, {
          appState: appState,
          error: this.props.error,
          runnablesStore: this.props.runnablesStore,
          scroller: this.props.scroller,
          specPath: this.props.specPath
        }));
      }
    }, {
      key: 'componentDidMount',
      value: function componentDidMount() {
        _ElementQueries2.default.init();
      }
    }]);
  
    return Reporter;
  }(_react.Component), _class2.propTypes = {
    autoScrollingEnabled: _propTypes2.default.bool,
    error: _propTypes2.default.shape({
      title: _propTypes2.default.string.isRequired,
      link: _propTypes2.default.string,
      callout: _propTypes2.default.string,
      message: _propTypes2.default.string.isRequired
    }),
    runner: _propTypes2.default.shape({
      emit: _propTypes2.default.func.isRequired,
      on: _propTypes2.default.func.isRequired
    }).isRequired,
    specPath: _propTypes2.default.string.isRequired
  }, _class2.defaultProps = {
    appState: _appState2.default,
    events: _events2.default,
    runnablesStore: _runnablesStore2.default,
    scroller: _scroller2.default,
    statsStore: _statsStore2.default
  }, _temp)) || _class;
  
  if (window.Cypress) {
    window.render = function (props) {
      (0, _reactDom.render)(_react2.default.createElement(Reporter, props), document.getElementById('app'));
    };
  }
  
  exports.default = { Reporter: Reporter };
  module.exports = exports['default'];
  
  },{"./header/header":88,"./header/stats-store":89,"./lib/app-state":94,"./lib/events":96,"./lib/scroller":98,"./runnables/runnables":106,"./runnables/runnables-store":105,"classnames":1,"css-element-queries/src/ElementQueries":2,"mobx":"mobx","mobx-react":"mobx-react","prop-types":72,"react":"react","react-dom":"react-dom"}],101:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = undefined;
  
  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;
    };
  }();
  
  var _get = function get(object, property, receiver) {
    if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
      var parent = Object.getPrototypeOf(object);if (parent === null) {
        return undefined;
      } else {
        return get(parent, property, receiver);
      }
    } else if ("value" in desc) {
      return desc.value;
    } else {
      var getter = desc.get;if (getter === undefined) {
        return undefined;
      }return getter.call(receiver);
    }
  };
  
  var _desc, _value, _class, _descriptor, _descriptor2, _descriptor3, _descriptor4;
  
  var _mobx = require('mobx');
  
  var _instrumentModel = require('../instruments/instrument-model');
  
  var _instrumentModel2 = _interopRequireDefault(_instrumentModel);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var Route = (_class = function (_Instrument) {
    _inherits(Route, _Instrument);
  
    function Route(props) {
      _classCallCheck(this, Route);
  
      var _this = _possibleConstructorReturn(this, (Route.__proto__ || Object.getPrototypeOf(Route)).call(this, props));
  
      _initDefineProp(_this, 'isStubbed', _descriptor, _this);
  
      _initDefineProp(_this, 'method', _descriptor2, _this);
  
      _initDefineProp(_this, 'numResponses', _descriptor3, _this);
  
      _initDefineProp(_this, 'url', _descriptor4, _this);
  
      _this.isStubbed = props.isStubbed;
      _this.method = props.method;
      _this.numResponses = props.numResponses;
      _this.url = props.url;
      return _this;
    }
  
    _createClass(Route, [{
      key: 'update',
      value: function update(props) {
        _get(Route.prototype.__proto__ || Object.getPrototypeOf(Route.prototype), 'update', this).call(this, props);
  
        this.isStubbed = props.isStubbed;
        this.method = props.method;
        this.numResponses = props.numResponses;
        this.url = props.url;
      }
    }]);
  
    return Route;
  }(_instrumentModel2.default), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'isStubbed', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'method', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'numResponses', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return 0;
    }
  }), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, 'url', [_mobx.observable], {
    enumerable: true,
    initializer: null
  })), _class);
  exports.default = Route;
  module.exports = exports['default'];
  
  },{"../instruments/instrument-model":93,"mobx":"mobx"}],102:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.RoutesList = exports.Route = undefined;
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _reactTooltip = require('@cypress/react-tooltip');
  
  var _reactTooltip2 = _interopRequireDefault(_reactTooltip);
  
  var _collapsible = require('../collapsible/collapsible');
  
  var _collapsible2 = _interopRequireDefault(_collapsible);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  var Route = (0, _mobxReact.observer)(function (_ref) {
    var model = _ref.model;
    return _react2.default.createElement('tr', { className: (0, _classnames2.default)({ 'no-responses': !model.numResponses }) }, _react2.default.createElement('td', null, model.method), _react2.default.createElement('td', null, model.url), _react2.default.createElement('td', null, model.isStubbed ? 'Yes' : 'No'), _react2.default.createElement('td', null, _react2.default.createElement(_reactTooltip2.default, { placement: 'top', title: 'Aliased this route as: \'' + model.alias + '\'' }, _react2.default.createElement('span', { className: 'route-alias' }, model.alias))), _react2.default.createElement('td', { className: 'response-count' }, model.numResponses || '-'));
  });
  
  var RoutesList = (0, _mobxReact.observer)(function (_ref2) {
    var model = _ref2.model;
    return _react2.default.createElement('tbody', null, _lodash2.default.map(model.routes, function (route) {
      return _react2.default.createElement(Route, { key: route.id, model: route });
    }));
  });
  
  var Routes = (0, _mobxReact.observer)(function (_ref3) {
    var model = _ref3.model;
    return _react2.default.createElement('div', {
      className: (0, _classnames2.default)('runnable-routes-region', {
        'no-routes': !model.routes.length
      })
    }, _react2.default.createElement('div', { className: 'instruments-container' }, _react2.default.createElement('ul', { className: 'hooks-container' }, _react2.default.createElement('li', { className: 'hook-item' }, _react2.default.createElement(_collapsible2.default, {
      header: 'Routes (' + model.routes.length + ')',
      headerClass: 'hook-name',
      contentClass: 'instrument-content'
    }, _react2.default.createElement('table', null, _react2.default.createElement('thead', null, _react2.default.createElement('tr', null, _react2.default.createElement('th', null, 'Method'), _react2.default.createElement('th', null, 'Url'), _react2.default.createElement('th', null, 'Stubbed'), _react2.default.createElement('th', null, 'Alias'), _react2.default.createElement('th', null, _react2.default.createElement(_reactTooltip2.default, { placement: 'top', title: 'Number of responses which matched this route' }, _react2.default.createElement('span', null, '#'))))), _react2.default.createElement(RoutesList, { model: model })))))));
  });
  
  exports.Route = Route;
  exports.RoutesList = RoutesList;
  exports.default = Routes;
  
  },{"../collapsible/collapsible":83,"@cypress/react-tooltip":"@cypress/react-tooltip","classnames":1,"lodash":"lodash","mobx-react":"mobx-react","react":"react"}],103:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.Suite = undefined;
  
  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;
    };
  }();
  
  var _class, _desc, _value, _class2, _descriptor;
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobx = require('mobx');
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _util = require('../lib/util');
  
  var _test = require('../test/test');
  
  var _test2 = _interopRequireDefault(_test);
  
  var _collapsible = require('../collapsible/collapsible');
  
  var _collapsible2 = _interopRequireDefault(_collapsible);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var Suite = (0, _mobxReact.observer)(function (_ref) {
    var model = _ref.model;
  
    if (!model.shouldRender) return null;
  
    return _react2.default.createElement(_collapsible2.default, {
      header: _react2.default.createElement('span', { className: 'runnable-title' }, model.title),
      headerClass: 'runnable-wrapper',
      headerStyle: { paddingLeft: (0, _util.indent)(model.level) },
      contentClass: 'runnables-region',
      isOpen: true
    }, _react2.default.createElement('ul', { className: 'runnables' }, _lodash2.default.map(model.children, function (runnable) {
      return _react2.default.createElement(Runnable, { key: runnable.id, model: runnable });
    })));
  });
  
  var Runnable = (0, _mobxReact.observer)(_class = (_class2 = function (_Component) {
    _inherits(Runnable, _Component);
  
    function Runnable() {
      var _ref2;
  
      var _temp, _this, _ret;
  
      _classCallCheck(this, Runnable);
  
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
  
      return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref2 = Runnable.__proto__ || Object.getPrototypeOf(Runnable)).call.apply(_ref2, [this].concat(args))), _this), _initDefineProp(_this, 'isHovering', _descriptor, _this), _this._hover = function (shouldHover) {
        return (0, _mobx.action)('runnable:hover', function (e) {
          e.stopPropagation();
          _this.isHovering = shouldHover;
        });
      }, _temp), _possibleConstructorReturn(_this, _ret);
    }
  
    _createClass(Runnable, [{
      key: 'render',
      value: function render() {
        var model = this.props.model;
  
        return _react2.default.createElement('li', {
          className: (0, _classnames2.default)(model.type + ' runnable runnable-' + model.state, {
            hover: this.isHovering
          }),
          onMouseOver: this._hover(true),
          onMouseOut: this._hover(false)
        }, model.type === 'test' ? _react2.default.createElement(_test2.default, { model: model }) : _react2.default.createElement(Suite, { model: model }));
      }
    }]);
  
    return Runnable;
  }(_react.Component), _descriptor = _applyDecoratedDescriptor(_class2.prototype, 'isHovering', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return false;
    }
  }), _class2)) || _class;
  
  exports.Suite = Suite;
  exports.default = Runnable;
  
  },{"../collapsible/collapsible":83,"../lib/util":99,"../test/test":109,"classnames":1,"lodash":"lodash","mobx":"mobx","mobx-react":"mobx-react","react":"react"}],104:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = undefined;
  
  var _desc, _value, _class, _descriptor, _descriptor2, _descriptor3, _descriptor4;
  
  var _mobx = require('mobx');
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var Runnable = (_class = function Runnable(props, level) {
    _classCallCheck(this, Runnable);
  
    _initDefineProp(this, 'id', _descriptor, this);
  
    _initDefineProp(this, 'shouldRender', _descriptor2, this);
  
    _initDefineProp(this, 'title', _descriptor3, this);
  
    _initDefineProp(this, 'level', _descriptor4, this);
  
    this.id = props.id;
    this.title = props.title;
    this.level = level;
  }, (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'id', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'shouldRender', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return false;
    }
  }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'title', [_mobx.observable], {
    enumerable: true,
    initializer: null
  }), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, 'level', [_mobx.observable], {
    enumerable: true,
    initializer: null
  })), _class);
  exports.default = Runnable;
  module.exports = exports['default'];
  
  },{"mobx":"mobx"}],105:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.RunnablesStore = undefined;
  
  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;
    };
  }();
  
  var _desc, _value, _class, _descriptor, _descriptor2;
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobx = require('mobx');
  
  var _appState = require('../lib/app-state');
  
  var _appState2 = _interopRequireDefault(_appState);
  
  var _agentModel = require('../agents/agent-model');
  
  var _agentModel2 = _interopRequireDefault(_agentModel);
  
  var _commandModel = require('../commands/command-model');
  
  var _commandModel2 = _interopRequireDefault(_commandModel);
  
  var _routeModel = require('../routes/route-model');
  
  var _routeModel2 = _interopRequireDefault(_routeModel);
  
  var _scroller = require('../lib/scroller');
  
  var _scroller2 = _interopRequireDefault(_scroller);
  
  var _suiteModel = require('./suite-model');
  
  var _suiteModel2 = _interopRequireDefault(_suiteModel);
  
  var _testModel = require('../test/test-model');
  
  var _testModel2 = _interopRequireDefault(_testModel);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var defaults = {
    hasSingleTest: false,
    hasTests: false,
    isReady: false,
  
    attemptingShowSnapshot: false,
    showingSnapshot: false
  };
  
  var RunnablesStore = (_class = function () {
    function RunnablesStore(_ref) {
      var appState = _ref.appState,
          scroller = _ref.scroller;
  
      _classCallCheck(this, RunnablesStore);
  
      _initDefineProp(this, 'isReady', _descriptor, this);
  
      _initDefineProp(this, 'runnables', _descriptor2, this);
  
      this._tests = {};
      this._logs = {};
      this._runnablesQueue = [];
      this.attemptingShowSnapshot = defaults.attemptingShowSnapshot;
      this.showingSnapshot = defaults.showingSnapshot;
  
      this.appState = appState;
      this.scroller = scroller;
    }
  
    _createClass(RunnablesStore, [{
      key: 'setRunnables',
      value: function setRunnables(rootRunnable) {
        this.runnables = this._createRunnableChildren(rootRunnable, 0);
        this.isReady = true;
  
        var numTests = _lodash2.default.keys(this._tests).length;
        this.hasTests = numTests > 0;
        this.hasSingleTest = numTests === 1;
  
        this._startRendering();
      }
    }, {
      key: '_createRunnableChildren',
      value: function _createRunnableChildren(runnableProps, level) {
        return this._createRunnables('test', runnableProps.tests, level).concat(this._createRunnables('suite', runnableProps.suites, level));
      }
    }, {
      key: '_createRunnables',
      value: function _createRunnables(type, runnables, level) {
        var _this = this;
  
        return _lodash2.default.map(runnables, function (runnableProps) {
          return _this._createRunnable(type, runnableProps, level);
        });
      }
    }, {
      key: '_createRunnable',
      value: function _createRunnable(type, props, level) {
        return type === 'suite' ? this._createSuite(props, level) : this._createTest(props, level);
      }
    }, {
      key: '_createSuite',
      value: function _createSuite(props, level) {
        var suite = new _suiteModel2.default(props, level);
        this._runnablesQueue.push(suite);
        suite.children = this._createRunnableChildren(props, ++level);
        return suite;
      }
    }, {
      key: '_createTest',
      value: function _createTest(props, level) {
        var test = new _testModel2.default(props, level);
        this._runnablesQueue.push(test);
        this._tests[test.id] = test;
  
        _lodash2.default.each(props.agents, this.addLog.bind(this));
        _lodash2.default.each(props.commands, this.addLog.bind(this));
        _lodash2.default.each(props.routes, this.addLog.bind(this));
  
        return test;
      }
  
      // progressively renders the runnables instead of all of them being rendered
      // at once. this prevents a noticeable lag in initial rendering when there
      // is a large number of tests
  
    }, {
      key: '_startRendering',
      value: function _startRendering() {
        var _this2 = this;
  
        var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
  
        requestAnimationFrame((0, _mobx.action)('start:rendering', function () {
          var runnable = _this2._runnablesQueue[index];
          if (!runnable) {
            _this2._finishedInitialRendering();
            return;
          }
  
          runnable.shouldRender = true;
          _this2._startRendering(index + 1);
        }));
      }
    }, {
      key: '_finishedInitialRendering',
      value: function _finishedInitialRendering() {
        if (this.appState.isRunning) {
          // have an initial scrollTop set, meaning we reloaded from a domain change
          // so reset to the saved scrollTop
          if (this._initialScrollTop) this.scroller.setScrollTop(this._initialScrollTop);
        } else {
          // finished running before initial rendering complete (but wasn't manually
          // stopped), meaning some tests didn't get a chance to get scrolled to
          // scroll to the end since that's the right place to be
          if (this.appState.autoScrollingEnabled && !this.appState.isStopped) {
            this.scroller.scrollToEnd();
          }
        }
      }
    }, {
      key: 'setInitialScrollTop',
      value: function setInitialScrollTop(initialScrollTop) {
        this._initialScrollTop = initialScrollTop;
      }
    }, {
      key: 'updateTest',
      value: function updateTest(props, cb) {
        this._withTest(props.id, function (test) {
          return test.update(props, cb);
        });
      }
    }, {
      key: 'runnableStarted',
      value: function runnableStarted(_ref2) {
        var id = _ref2.id;
  
        this._withTest(id, function (test) {
          return test.start();
        });
      }
    }, {
      key: 'runnableFinished',
      value: function runnableFinished(props) {
        this._withTest(props.id, function (test) {
          return test.finish(props);
        });
      }
    }, {
      key: 'testById',
      value: function testById(id) {
        return this._tests[id];
      }
    }, {
      key: 'addLog',
      value: function addLog(log) {
        switch (log.instrument) {
          case 'command':
            {
              var command = new _commandModel2.default(log);
              this._logs[log.id] = command;
              this._withTest(log.testId, function (test) {
                return test.addCommand(command, log.hookName);
              });
              break;
            }
          case 'agent':
            {
              var agent = new _agentModel2.default(log);
              this._logs[log.id] = agent;
              this._withTest(log.testId, function (test) {
                return test.addAgent(agent);
              });
              break;
            }
          case 'route':
            {
              var route = new _routeModel2.default(log);
              this._logs[log.id] = route;
              this._withTest(log.testId, function (test) {
                return test.addRoute(route);
              });
              break;
            }
          default:
            throw new Error('Attempted to add log for unknown instrument: ' + log.instrument);
        }
      }
    }, {
      key: '_withTest',
      value: function _withTest(id, cb) {
        // we get events for suites and tests, but only tests change during a run,
        // so if the id isn't found in this._tests, we ignore it b/c it's a suite
        var test = this._tests[id];
        if (test) cb(test);
      }
    }, {
      key: 'updateLog',
      value: function updateLog(log) {
        var found = this._logs[log.id];
  
        if (found) {
          found.update(log);
        }
      }
    }, {
      key: 'reset',
      value: function reset() {
        var _this3 = this;
  
        _lodash2.default.each(defaults, function (value, key) {
          _this3[key] = value;
        });
        this.runnables = [];
        this._tests = {};
        this._logs = {};
        this._runnablesQueue = [];
      }
    }]);
  
    return RunnablesStore;
  }(), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'isReady', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return defaults.isReady;
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'runnables', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return [];
    }
  })), _class);
  exports.RunnablesStore = RunnablesStore;
  exports.default = new RunnablesStore({ appState: _appState2.default, scroller: _scroller2.default });
  
  },{"../agents/agent-model":81,"../commands/command-model":84,"../lib/app-state":94,"../lib/scroller":98,"../routes/route-model":101,"../test/test-model":108,"./suite-model":107,"lodash":"lodash","mobx":"mobx"}],106:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.RunnablesList = undefined;
  
  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;
    };
  }();
  
  var _class;
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobx = require('mobx');
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _anError = require('../errors/an-error');
  
  var _anError2 = _interopRequireDefault(_anError);
  
  var _runnableAndSuite = require('./runnable-and-suite');
  
  var _runnableAndSuite2 = _interopRequireDefault(_runnableAndSuite);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  var noTestsError = function noTestsError(specPath) {
    return {
      title: 'No tests found in your file:',
      link: 'https://on.cypress.io/no-tests-found-in-your-file',
      callout: specPath,
      message: 'We could not detect any tests in the above file. Write some tests and re-run.'
    };
  };
  
  var RunnablesList = (0, _mobxReact.observer)(function (_ref) {
    var runnables = _ref.runnables;
    return _react2.default.createElement('div', { className: 'wrap' }, _react2.default.createElement('ul', { className: 'runnables' }, _lodash2.default.map(runnables, function (runnable) {
      return _react2.default.createElement(_runnableAndSuite2.default, { key: runnable.id, model: runnable });
    })));
  });
  
  function content(_ref2, specPath, error) {
    var isReady = _ref2.isReady,
        runnables = _ref2.runnables;
  
    if (!isReady) return null;
  
    // show error if there are no tests, but only if there
    // there isn't an error passed down that supercedes it
    if (!error && !runnables.length) {
      error = noTestsError(specPath);
    }
  
    return error ? _react2.default.createElement(_anError2.default, { error: error }) : _react2.default.createElement(RunnablesList, { runnables: runnables });
  }
  
  var Runnables = (0, _mobxReact.observer)(_class = function (_Component) {
    _inherits(Runnables, _Component);
  
    function Runnables() {
      _classCallCheck(this, Runnables);
  
      return _possibleConstructorReturn(this, (Runnables.__proto__ || Object.getPrototypeOf(Runnables)).apply(this, arguments));
    }
  
    _createClass(Runnables, [{
      key: 'render',
      value: function render() {
        var _props = this.props,
            error = _props.error,
            runnablesStore = _props.runnablesStore,
            specPath = _props.specPath;
  
        return _react2.default.createElement('div', { ref: 'container', className: 'container' }, content(runnablesStore, specPath, error));
      }
    }, {
      key: 'componentDidMount',
      value: function componentDidMount() {
        var _this2 = this;
  
        this.props.scroller.setContainer(this.refs.container, (0, _mobx.action)('user:scroll:detected', function () {
          if (_this2.props.appState.isRunning) {
            _this2.props.appState.temporarilySetAutoScrolling(false);
          }
        }));
      }
    }]);
  
    return Runnables;
  }(_react.Component)) || _class;
  
  exports.RunnablesList = RunnablesList;
  exports.default = Runnables;
  
  },{"../errors/an-error":86,"./runnable-and-suite":103,"lodash":"lodash","mobx":"mobx","mobx-react":"mobx-react","react":"react"}],107:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = undefined;
  
  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;
    };
  }();
  
  var _desc, _value, _class, _descriptor;
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobx = require('mobx');
  
  var _runnableModel = require('../runnables/runnable-model');
  
  var _runnableModel2 = _interopRequireDefault(_runnableModel);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var Suite = (_class = function (_Runnable) {
    _inherits(Suite, _Runnable);
  
    function Suite() {
      var _ref;
  
      var _temp, _this, _ret;
  
      _classCallCheck(this, Suite);
  
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
  
      return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Suite.__proto__ || Object.getPrototypeOf(Suite)).call.apply(_ref, [this].concat(args))), _this), _initDefineProp(_this, 'children', _descriptor, _this), _this.type = 'suite', _temp), _possibleConstructorReturn(_this, _ret);
    }
  
    _createClass(Suite, [{
      key: 'state',
      get: function get() {
        if (this._anyChildrenFailed) {
          return 'failed';
        } else if (this._allChildrenPending) {
          return 'pending';
        } else if (this._allChildrenPassedOrPending) {
          return 'passed';
        } else {
          return 'processing';
        }
      }
    }, {
      key: '_childStates',
      get: function get() {
        return _lodash2.default.map(this.children, 'state');
      }
    }, {
      key: '_anyChildrenFailed',
      get: function get() {
        return _lodash2.default.some(this._childStates, function (state) {
          return state === 'failed';
        });
      }
    }, {
      key: '_allChildrenPassedOrPending',
      get: function get() {
        return !this._childStates.length || _lodash2.default.every(this._childStates, function (state) {
          return state === 'passed' || state === 'pending';
        });
      }
    }, {
      key: '_allChildrenPending',
      get: function get() {
        return !!this._childStates.length && _lodash2.default.every(this._childStates, function (state) {
          return state === 'pending';
        });
      }
    }]);
  
    return Suite;
  }(_runnableModel2.default), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'children', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return [];
    }
  }), _applyDecoratedDescriptor(_class.prototype, 'state', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, 'state'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, '_childStates', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, '_childStates'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, '_anyChildrenFailed', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, '_anyChildrenFailed'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, '_allChildrenPassedOrPending', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, '_allChildrenPassedOrPending'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, '_allChildrenPending', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, '_allChildrenPending'), _class.prototype)), _class);
  exports.default = Suite;
  module.exports = exports['default'];
  
  },{"../runnables/runnable-model":104,"lodash":"lodash","mobx":"mobx"}],108:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = undefined;
  
  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;
    };
  }();
  
  var _desc, _value, _class, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5, _descriptor6, _descriptor7, _descriptor8, _descriptor9;
  
  var _lodash = require('lodash');
  
  var _lodash2 = _interopRequireDefault(_lodash);
  
  var _mobx = require('mobx');
  
  var _errModel = require('../lib/err-model');
  
  var _errModel2 = _interopRequireDefault(_errModel);
  
  var _hookModel = require('../hooks/hook-model');
  
  var _hookModel2 = _interopRequireDefault(_hookModel);
  
  var _runnableModel = require('../runnables/runnable-model');
  
  var _runnableModel2 = _interopRequireDefault(_runnableModel);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var Test = (_class = function (_Runnable) {
    _inherits(Test, _Runnable);
  
    // TODO: make this an enum with states: 'QUEUED, ACTIVE, INACTIVE'
    function Test(props, level) {
      _classCallCheck(this, Test);
  
      var _this = _possibleConstructorReturn(this, (Test.__proto__ || Object.getPrototypeOf(Test)).call(this, props, level));
  
      _initDefineProp(_this, 'agents', _descriptor, _this);
  
      _initDefineProp(_this, 'commands', _descriptor2, _this);
  
      _initDefineProp(_this, 'err', _descriptor3, _this);
  
      _initDefineProp(_this, 'hooks', _descriptor4, _this);
  
      _initDefineProp(_this, 'isActive', _descriptor5, _this);
  
      _initDefineProp(_this, 'isLongRunning', _descriptor6, _this);
  
      _initDefineProp(_this, 'isOpen', _descriptor7, _this);
  
      _initDefineProp(_this, 'routes', _descriptor8, _this);
  
      _initDefineProp(_this, '_state', _descriptor9, _this);
  
      _this.type = 'test';
  
      _this._state = props.state;
      _this.err.update(props.err);
  
      (0, _mobx.autorun)(function () {
        // if at any point, a command goes long running, set isLongRunning
        // to true until the test becomes inactive
        if (!_this.isActive) {
          (0, _mobx.action)('became:inactive', function () {
            return _this.isLongRunning = false;
          })();
        } else if (_this._hasLongRunningCommand) {
          (0, _mobx.action)('became:long:running', function () {
            return _this.isLongRunning = true;
          })();
        }
      });
      return _this;
    }
  
    _createClass(Test, [{
      key: 'addAgent',
      value: function addAgent(agent) {
        this.agents.push(agent);
      }
    }, {
      key: 'addRoute',
      value: function addRoute(route) {
        this.routes.push(route);
      }
    }, {
      key: 'addCommand',
      value: function addCommand(command, hookName) {
        var hook = this._findOrCreateHook(hookName);
        this.commands.push(command);
        hook.addCommand(command);
      }
    }, {
      key: 'start',
      value: function start() {
        this.isActive = true;
      }
    }, {
      key: 'update',
      value: function update(_ref, cb) {
        var _this2 = this;
  
        var state = _ref.state,
            err = _ref.err,
            hookName = _ref.hookName,
            isOpen = _ref.isOpen;
  
        var hadChanges = false;
  
        var disposer = (0, _mobx.observe)(this, function (change) {
          hadChanges = true;
  
          disposer();
  
          // apply change as-is
          return change;
        });
  
        if (cb) {
          this.callbackAfterUpdate = function () {
            _this2.callbackAfterUpdate = null;
            cb();
          };
        }
  
        this._state = state;
        this.err.update(err);
        if (isOpen != null) {
          this.isOpen = isOpen;
        }
  
        if (hookName) {
          var hook = _lodash2.default.find(this.hooks, { name: hookName });
          if (hook) {
            hook.failed = true;
          }
        }
  
        // if we had no changes then react will
        // never fire componentDidUpdate and
        // so we need to manually call our callback
        // https://github.com/cypress-io/cypress/issues/674#issuecomment-366495057
        if (!hadChanges) {
          // unbind the listener if no changes
          disposer();
  
          // if we had a callback, invoke it
          if (this.callbackAfterUpdate) {
            this.callbackAfterUpdate();
          }
        }
      }
    }, {
      key: 'finish',
      value: function finish(props) {
        this.update(props);
        this.isActive = false;
      }
    }, {
      key: 'commandMatchingErr',
      value: function commandMatchingErr() {
        var _this3 = this;
  
        return (0, _lodash2.default)(this.hooks).map(function (hook) {
          return hook.commandMatchingErr(_this3.err);
        }).compact().last();
      }
    }, {
      key: '_findOrCreateHook',
      value: function _findOrCreateHook(name) {
        var hook = _lodash2.default.find(this.hooks, { name: name });
        if (hook) return hook;
  
        var newHook = new _hookModel2.default({ name: name });
        this.hooks.push(newHook);
        return newHook;
      }
    }, {
      key: '_hasLongRunningCommand',
      get: function get() {
        return _lodash2.default.some(this.commands, function (command) {
          return command.isLongRunning;
        });
      }
    }, {
      key: 'state',
      get: function get() {
        return this._state || (this.isActive ? 'active' : 'processing');
      }
    }]);
  
    return Test;
  }(_runnableModel2.default), (_descriptor = _applyDecoratedDescriptor(_class.prototype, 'agents', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return [];
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'commands', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return [];
    }
  }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'err', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return new _errModel2.default({});
    }
  }), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, 'hooks', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return [];
    }
  }), _descriptor5 = _applyDecoratedDescriptor(_class.prototype, 'isActive', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return null;
    }
  }), _descriptor6 = _applyDecoratedDescriptor(_class.prototype, 'isLongRunning', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return false;
    }
  }), _descriptor7 = _applyDecoratedDescriptor(_class.prototype, 'isOpen', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return false;
    }
  }), _descriptor8 = _applyDecoratedDescriptor(_class.prototype, 'routes', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return [];
    }
  }), _descriptor9 = _applyDecoratedDescriptor(_class.prototype, '_state', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return null;
    }
  }), _applyDecoratedDescriptor(_class.prototype, '_hasLongRunningCommand', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, '_hasLongRunningCommand'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, 'state', [_mobx.computed], Object.getOwnPropertyDescriptor(_class.prototype, 'state'), _class.prototype)), _class);
  exports.default = Test;
  module.exports = exports['default'];
  
  },{"../hooks/hook-model":91,"../lib/err-model":95,"../runnables/runnable-model":104,"lodash":"lodash","mobx":"mobx"}],109:[function(require,module,exports){
  'use strict';
  
  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; };
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.NoCommands = undefined;
  
  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;
    };
  }();
  
  var _class, _desc, _value, _class2, _descriptor, _descriptor2, _class3, _temp2;
  
  var _classnames = require('classnames');
  
  var _classnames2 = _interopRequireDefault(_classnames);
  
  var _mobx = require('mobx');
  
  var _mobxReact = require('mobx-react');
  
  var _react = require('react');
  
  var _react2 = _interopRequireDefault(_react);
  
  var _reactTooltip = require('@cypress/react-tooltip');
  
  var _reactTooltip2 = _interopRequireDefault(_reactTooltip);
  
  var _appState = require('../lib/app-state');
  
  var _appState2 = _interopRequireDefault(_appState);
  
  var _events = require('../lib/events');
  
  var _events2 = _interopRequireDefault(_events);
  
  var _util = require('../lib/util');
  
  var _runnablesStore = require('../runnables/runnables-store');
  
  var _runnablesStore2 = _interopRequireDefault(_runnablesStore);
  
  var _scroller = require('../lib/scroller');
  
  var _scroller2 = _interopRequireDefault(_scroller);
  
  var _hooks = require('../hooks/hooks');
  
  var _hooks2 = _interopRequireDefault(_hooks);
  
  var _agents = require('../agents/agents');
  
  var _agents2 = _interopRequireDefault(_agents);
  
  var _routes = require('../routes/routes');
  
  var _routes2 = _interopRequireDefault(_routes);
  
  var _flashOnClick = require('../lib/flash-on-click');
  
  var _flashOnClick2 = _interopRequireDefault(_flashOnClick);
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
  
  function _initDefineProp(target, property, descriptor, context) {
    if (!descriptor) return;
    Object.defineProperty(target, property, {
      enumerable: descriptor.enumerable,
      configurable: descriptor.configurable,
      writable: descriptor.writable,
      value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
    });
  }
  
  function _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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
  }
  
  function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {};
    Object['ke' + 'ys'](descriptor).forEach(function (key) {
      desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
  
    if ('value' in desc || desc.initializer) {
      desc.writable = true;
    }
  
    desc = decorators.slice().reverse().reduce(function (desc, decorator) {
      return decorator(target, property, desc) || desc;
    }, desc);
  
    if (context && desc.initializer !== void 0) {
      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
      desc.initializer = undefined;
    }
  
    if (desc.initializer === void 0) {
      Object['define' + 'Property'](target, property, desc);
      desc = null;
    }
  
    return desc;
  }
  
  function _initializerWarningHelper(descriptor, context) {
    throw new Error('Decorating class property failed. Please ensure that transform-class-properties is enabled.');
  }
  
  var NoCommands = (0, _mobxReact.observer)(function () {
    return _react2.default.createElement('ul', { className: 'hooks-container' }, _react2.default.createElement('li', { className: 'no-commands' }, 'No commands were issued in this test.'));
  });
  
  var Test = (0, _mobxReact.observer)(_class = (_class2 = (_temp2 = _class3 = function (_Component) {
    _inherits(Test, _Component);
  
    function Test() {
      var _ref;
  
      var _temp, _this, _ret;
  
      _classCallCheck(this, Test);
  
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
  
      return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Test.__proto__ || Object.getPrototypeOf(Test)).call.apply(_ref, [this].concat(args))), _this), _initDefineProp(_this, 'isOpen', _descriptor, _this), _initDefineProp(_this, '_toggleOpen', _descriptor2, _this), _this._onErrorClick = function (e) {
        e.stopPropagation();
        _this.props.events.emit('show:error', _this.props.model.id);
      }, _temp), _possibleConstructorReturn(_this, _ret);
    }
  
    _createClass(Test, [{
      key: 'componentDidMount',
      value: function componentDidMount() {
        this._scrollIntoView();
      }
    }, {
      key: 'componentDidUpdate',
      value: function componentDidUpdate() {
        this._scrollIntoView();
  
        var cb = this.props.model.callbackAfterUpdate;
        if (cb) {
          cb();
        }
      }
    }, {
      key: '_scrollIntoView',
      value: function _scrollIntoView() {
        var _props = this.props,
            appState = _props.appState,
            model = _props.model,
            scroller = _props.scroller;
        var isActive = model.isActive,
            shouldRender = model.shouldRender;
  
        if (appState.autoScrollingEnabled && appState.isRunning && shouldRender && isActive != null) {
          scroller.scrollIntoView(this.refs.container);
        }
      }
    }, {
      key: 'render',
      value: function render() {
        var model = this.props.model;
  
        if (!model.shouldRender) return null;
  
        return _react2.default.createElement('div', {
          ref: 'container',
          className: (0, _classnames2.default)('runnable-wrapper', { 'is-open': this._shouldBeOpen() }),
          onClick: this._toggleOpen,
          style: { paddingLeft: (0, _util.indent)(model.level) }
        }, _react2.default.createElement('div', { className: 'runnable-content-region' }, _react2.default.createElement('i', { className: 'runnable-state fa' }), _react2.default.createElement('span', { className: 'runnable-title' }, model.title), _react2.default.createElement('div', { className: 'runnable-controls' }, _react2.default.createElement(_reactTooltip2.default, { placement: 'top', title: 'One or more commands failed' }, _react2.default.createElement('i', { className: 'fa fa-warning' })))), this._contents(), _react2.default.createElement(_flashOnClick2.default, {
          message: 'Printed output to your console',
          onClick: this._onErrorClick
        }, _react2.default.createElement('pre', { className: 'test-error' }, model.err.displayMessage)));
      }
    }, {
      key: '_contents',
      value: function _contents() {
        // performance optimization - don't render contents if not open
        if (!this._shouldBeOpen()) return null;
  
        var model = this.props.model;
  
        return _react2.default.createElement('div', {
          className: 'runnable-instruments collapsible-content',
          onClick: function onClick(e) {
            e.stopPropagation();
          }
        }, _react2.default.createElement(_agents2.default, { model: model }), _react2.default.createElement(_routes2.default, { model: model }), _react2.default.createElement('div', { className: 'runnable-commands-region' }, model.commands.length ? _react2.default.createElement(_hooks2.default, { model: model }) : _react2.default.createElement(NoCommands, null)));
      }
    }, {
      key: '_shouldBeOpen',
      value: function _shouldBeOpen() {
        // if this.isOpen is non-null, prefer that since the user has
        // explicity chosen to open or close the test
        if (this.isOpen !== null) return this.isOpen;
  
        // otherwise, look at reasons to auto-open the test
        return this.props.model.state === 'failed' || this.props.model.isOpen || this.props.model.isLongRunning || this.props.runnablesStore.hasSingleTest;
      }
    }]);
  
    return Test;
  }(_react.Component), _class3.defaultProps = {
    appState: _appState2.default,
    events: _events2.default,
    runnablesStore: _runnablesStore2.default,
    scroller: _scroller2.default
  }, _temp2), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, 'isOpen', [_mobx.observable], {
    enumerable: true,
    initializer: function initializer() {
      return null;
    }
  }), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, '_toggleOpen', [_mobx.action], {
    enumerable: true,
    initializer: function initializer() {
      var _this2 = this;
  
      return function () {
        if (_this2.isOpen === null) {
          _this2.isOpen = !_this2._shouldBeOpen();
        } else {
          _this2.isOpen = !_this2.isOpen;
        }
      };
    }
  })), _class2)) || _class;
  
  exports.NoCommands = NoCommands;
  exports.default = Test;
  
  },{"../agents/agents":82,"../hooks/hooks":92,"../lib/app-state":94,"../lib/events":96,"../lib/flash-on-click":97,"../lib/scroller":98,"../lib/util":99,"../routes/routes":102,"../runnables/runnables-store":105,"@cypress/react-tooltip":"@cypress/react-tooltip","classnames":1,"mobx":"mobx","mobx-react":"mobx-react","react":"react"}]},{},[100]);
  