/******/ (() => { // webpackBootstrap

/******/ 	var __webpack_modules__ = ({

/***/ 1030:

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

var __WEBPACK_AMD_DEFINE_RESULT__;;/*! showdown v 1.9.1 - 02-11-2019 */

(function(){

/**

 * Created by Tivie on 13-07-2015.

 */

function getDefaultOpts (simple) {

  'use strict';

  var defaultOptions = {

    omitExtraWLInCodeBlocks: {

      defaultValue: false,

      describe: 'Omit the default extra whiteline added to code blocks',

      type: 'boolean'

    },

    noHeaderId: {

      defaultValue: false,

      describe: 'Turn on/off generated header id',

      type: 'boolean'

    },

    prefixHeaderId: {

      defaultValue: false,

      describe: 'Add a prefix to the generated header ids. Passing a string will prefix that string to the header id. Setting to true will add a generic \'section-\' prefix',

      type: 'string'

    },

    rawPrefixHeaderId: {

      defaultValue: false,

      describe: 'Setting this option to true will prevent showdown from modifying the prefix. This might result in malformed IDs (if, for instance, the " char is used in the prefix)',

      type: 'boolean'

    },

    ghCompatibleHeaderId: {

      defaultValue: false,

      describe: 'Generate header ids compatible with github style (spaces are replaced with dashes, a bunch of non alphanumeric chars are removed)',

      type: 'boolean'

    },

    rawHeaderId: {

      defaultValue: false,

      describe: 'Remove only spaces, \' and " from generated header ids (including prefixes), replacing them with dashes (-). WARNING: This might result in malformed ids',

      type: 'boolean'

    },

    headerLevelStart: {

      defaultValue: false,

      describe: 'The header blocks level start',

      type: 'integer'

    },

    parseImgDimensions: {

      defaultValue: false,

      describe: 'Turn on/off image dimension parsing',

      type: 'boolean'

    },

    simplifiedAutoLink: {

      defaultValue: false,

      describe: 'Turn on/off GFM autolink style',

      type: 'boolean'

    },

    excludeTrailingPunctuationFromURLs: {

      defaultValue: false,

      describe: 'Excludes trailing punctuation from links generated with autoLinking',

      type: 'boolean'

    },

    literalMidWordUnderscores: {

      defaultValue: false,

      describe: 'Parse midword underscores as literal underscores',

      type: 'boolean'

    },

    literalMidWordAsterisks: {

      defaultValue: false,

      describe: 'Parse midword asterisks as literal asterisks',

      type: 'boolean'

    },

    strikethrough: {

      defaultValue: false,

      describe: 'Turn on/off strikethrough support',

      type: 'boolean'

    },

    tables: {

      defaultValue: false,

      describe: 'Turn on/off tables support',

      type: 'boolean'

    },

    tablesHeaderId: {

      defaultValue: false,

      describe: 'Add an id to table headers',

      type: 'boolean'

    },

    ghCodeBlocks: {

      defaultValue: true,

      describe: 'Turn on/off GFM fenced code blocks support',

      type: 'boolean'

    },

    tasklists: {

      defaultValue: false,

      describe: 'Turn on/off GFM tasklist support',

      type: 'boolean'

    },

    smoothLivePreview: {

      defaultValue: false,

      describe: 'Prevents weird effects in live previews due to incomplete input',

      type: 'boolean'

    },

    smartIndentationFix: {

      defaultValue: false,

      description: 'Tries to smartly fix indentation in es6 strings',

      type: 'boolean'

    },

    disableForced4SpacesIndentedSublists: {

      defaultValue: false,

      description: 'Disables the requirement of indenting nested sublists by 4 spaces',

      type: 'boolean'

    },

    simpleLineBreaks: {

      defaultValue: false,

      description: 'Parses simple line breaks as <br> (GFM Style)',

      type: 'boolean'

    },

    requireSpaceBeforeHeadingText: {

      defaultValue: false,

      description: 'Makes adding a space between `#` and the header text mandatory (GFM Style)',

      type: 'boolean'

    },

    ghMentions: {

      defaultValue: false,

      description: 'Enables github @mentions',

      type: 'boolean'

    },

    ghMentionsLink: {

      defaultValue: 'https://github.com/{u}',

      description: 'Changes the link generated by @mentions. Only applies if ghMentions option is enabled.',

      type: 'string'

    },

    encodeEmails: {

      defaultValue: true,

      description: 'Encode e-mail addresses through the use of Character Entities, transforming ASCII e-mail addresses into its equivalent decimal entities',

      type: 'boolean'

    },

    openLinksInNewWindow: {

      defaultValue: false,

      description: 'Open all links in new windows',

      type: 'boolean'

    },

    backslashEscapesHTMLTags: {

      defaultValue: false,

      description: 'Support for HTML Tag escaping. ex: \<div>foo\</div>',

      type: 'boolean'

    },

    emoji: {

      defaultValue: false,

      description: 'Enable emoji support. Ex: `this is a :smile: emoji`',

      type: 'boolean'

    },

    underline: {

      defaultValue: false,

      description: 'Enable support for underline. Syntax is double or triple underscores: `__underline word__`. With this option enabled, underscores no longer parses into `<em>` and `<strong>`',

      type: 'boolean'

    },

    completeHTMLDocument: {

      defaultValue: false,

      description: 'Outputs a complete html document, including `<html>`, `<head>` and `<body>` tags',

      type: 'boolean'

    },

    metadata: {

      defaultValue: false,

      description: 'Enable support for document metadata (defined at the top of the document between `«««` and `»»»` or between `---` and `---`).',

      type: 'boolean'

    },

    splitAdjacentBlockquotes: {

      defaultValue: false,

      description: 'Split adjacent blockquote blocks',

      type: 'boolean'

    }

  };

  if (simple === false) {

    return JSON.parse(JSON.stringify(defaultOptions));

  }

  var ret = {};

  for (var opt in defaultOptions) {

    if (defaultOptions.hasOwnProperty(opt)) {

      ret[opt] = defaultOptions[opt].defaultValue;

    }

  }

  return ret;

}

function allOptionsOn () {

  'use strict';

  var options = getDefaultOpts(true),

      ret = {};

  for (var opt in options) {

    if (options.hasOwnProperty(opt)) {

      ret[opt] = true;

    }

  }

  return ret;

}

/**

 * Created by Tivie on 06-01-2015.

 */

// Private properties

var showdown = {},

    parsers = {},

    extensions = {},

    globalOptions = getDefaultOpts(true),

    setFlavor = 'vanilla',

    flavor = {

      github: {

        omitExtraWLInCodeBlocks:              true,

        simplifiedAutoLink:                   true,

        excludeTrailingPunctuationFromURLs:   true,

        literalMidWordUnderscores:            true,

        strikethrough:                        true,

        tables:                               true,

        tablesHeaderId:                       true,

        ghCodeBlocks:                         true,

        tasklists:                            true,

        disableForced4SpacesIndentedSublists: true,

        simpleLineBreaks:                     true,

        requireSpaceBeforeHeadingText:        true,

        ghCompatibleHeaderId:                 true,

        ghMentions:                           true,

        backslashEscapesHTMLTags:             true,

        emoji:                                true,

        splitAdjacentBlockquotes:             true

      },

      original: {

        noHeaderId:                           true,

        ghCodeBlocks:                         false

      },

      ghost: {

        omitExtraWLInCodeBlocks:              true,

        parseImgDimensions:                   true,

        simplifiedAutoLink:                   true,

        excludeTrailingPunctuationFromURLs:   true,

        literalMidWordUnderscores:            true,

        strikethrough:                        true,

        tables:                               true,

        tablesHeaderId:                       true,

        ghCodeBlocks:                         true,

        tasklists:                            true,

        smoothLivePreview:                    true,

        simpleLineBreaks:                     true,

        requireSpaceBeforeHeadingText:        true,

        ghMentions:                           false,

        encodeEmails:                         true

      },

      vanilla: getDefaultOpts(true),

      allOn: allOptionsOn()

    };

/**

 * helper namespace

 * @type {{}}

 */

showdown.helper = {};

/**

 * TODO LEGACY SUPPORT CODE

 * @type {{}}

 */

showdown.extensions = {};

/**

 * Set a global option

 * @static

 * @param {string} key

 * @param {*} value

 * @returns {showdown}

 */

showdown.setOption = function (key, value) {

  'use strict';

  globalOptions[key] = value;

  return this;

};

/**

 * Get a global option

 * @static

 * @param {string} key

 * @returns {*}

 */

showdown.getOption = function (key) {

  'use strict';

  return globalOptions[key];

};

/**

 * Get the global options

 * @static

 * @returns {{}}

 */

showdown.getOptions = function () {

  'use strict';

  return globalOptions;

};

/**

 * Reset global options to the default values

 * @static

 */

showdown.resetOptions = function () {

  'use strict';

  globalOptions = getDefaultOpts(true);

};

/**

 * Set the flavor showdown should use as default

 * @param {string} name

 */

showdown.setFlavor = function (name) {

  'use strict';

  if (!flavor.hasOwnProperty(name)) {

    throw Error(name + ' flavor was not found');

  }

  showdown.resetOptions();

  var preset = flavor[name];

  setFlavor = name;

  for (var option in preset) {

    if (preset.hasOwnProperty(option)) {

      globalOptions[option] = preset[option];

    }

  }

};

/**

 * Get the currently set flavor

 * @returns {string}

 */

showdown.getFlavor = function () {

  'use strict';

  return setFlavor;

};

/**

 * Get the options of a specified flavor. Returns undefined if the flavor was not found

 * @param {string} name Name of the flavor

 * @returns {{}|undefined}

 */

showdown.getFlavorOptions = function (name) {

  'use strict';

  if (flavor.hasOwnProperty(name)) {

    return flavor[name];

  }

};

/**

 * Get the default options

 * @static

 * @param {boolean} [simple=true]

 * @returns {{}}

 */

showdown.getDefaultOptions = function (simple) {

  'use strict';

  return getDefaultOpts(simple);

};

/**

 * Get or set a subParser

 *

 * subParser(name)       - Get a registered subParser

 * subParser(name, func) - Register a subParser

 * @static

 * @param {string} name

 * @param {function} [func]

 * @returns {*}

 */

showdown.subParser = function (name, func) {

  'use strict';

  if (showdown.helper.isString(name)) {

    if (typeof func !== 'undefined') {

      parsers[name] = func;

    } else {

      if (parsers.hasOwnProperty(name)) {

        return parsers[name];

      } else {

        throw Error('SubParser named ' + name + ' not registered!');

      }

    }

  }

};

/**

 * Gets or registers an extension

 * @static

 * @param {string} name

 * @param {object|function=} ext

 * @returns {*}

 */

showdown.extension = function (name, ext) {

  'use strict';

  if (!showdown.helper.isString(name)) {

    throw Error('Extension \'name\' must be a string');

  }

  name = showdown.helper.stdExtName(name);

  // Getter

  if (showdown.helper.isUndefined(ext)) {

    if (!extensions.hasOwnProperty(name)) {

      throw Error('Extension named ' + name + ' is not registered!');

    }

    return extensions[name];

    // Setter

  } else {

    // Expand extension if it's wrapped in a function

    if (typeof ext === 'function') {

      ext = ext();

    }

    // Ensure extension is an array

    if (!showdown.helper.isArray(ext)) {

      ext = [ext];

    }

    var validExtension = validate(ext, name);

    if (validExtension.valid) {

      extensions[name] = ext;

    } else {

      throw Error(validExtension.error);

    }

  }

};

/**

 * Gets all extensions registered

 * @returns {{}}

 */

showdown.getAllExtensions = function () {

  'use strict';

  return extensions;

};

/**

 * Remove an extension

 * @param {string} name

 */

showdown.removeExtension = function (name) {

  'use strict';

  delete extensions[name];

};

/**

 * Removes all extensions

 */

showdown.resetExtensions = function () {

  'use strict';

  extensions = {};

};

/**

 * Validate extension

 * @param {array} extension

 * @param {string} name

 * @returns {{valid: boolean, error: string}}

 */

function validate (extension, name) {

  'use strict';

  var errMsg = (name) ? 'Error in ' + name + ' extension->' : 'Error in unnamed extension',

      ret = {

        valid: true,

        error: ''

      };

  if (!showdown.helper.isArray(extension)) {

    extension = [extension];

  }

  for (var i = 0; i < extension.length; ++i) {

    var baseMsg = errMsg + ' sub-extension ' + i + ': ',

        ext = extension[i];

    if (typeof ext !== 'object') {

      ret.valid = false;

      ret.error = baseMsg + 'must be an object, but ' + typeof ext + ' given';

      return ret;

    }

    if (!showdown.helper.isString(ext.type)) {

      ret.valid = false;

      ret.error = baseMsg + 'property "type" must be a string, but ' + typeof ext.type + ' given';

      return ret;

    }

    var type = ext.type = ext.type.toLowerCase();

    // normalize extension type

    if (type === 'language') {

      type = ext.type = 'lang';

    }

    if (type === 'html') {

      type = ext.type = 'output';

    }

    if (type !== 'lang' && type !== 'output' && type !== 'listener') {

      ret.valid = false;

      ret.error = baseMsg + 'type ' + type + ' is not recognized. Valid values: "lang/language", "output/html" or "listener"';

      return ret;

    }

    if (type === 'listener') {

      if (showdown.helper.isUndefined(ext.listeners)) {

        ret.valid = false;

        ret.error = baseMsg + '. Extensions of type "listener" must have a property called "listeners"';

        return ret;

      }

    } else {

      if (showdown.helper.isUndefined(ext.filter) && showdown.helper.isUndefined(ext.regex)) {

        ret.valid = false;

        ret.error = baseMsg + type + ' extensions must define either a "regex" property or a "filter" method';

        return ret;

      }

    }

    if (ext.listeners) {

      if (typeof ext.listeners !== 'object') {

        ret.valid = false;

        ret.error = baseMsg + '"listeners" property must be an object but ' + typeof ext.listeners + ' given';

        return ret;