{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/markdown/lib/markdown.js","webpack:///./node_modules/process/browser.js","webpack:///./vendor/assets/libs/markdown/markdown.js","webpack:///./node_modules/node-libs-browser/node_modules/util/util.js","webpack:///./node_modules/node-libs-browser/node_modules/util/support/isBufferBrowser.js","webpack:///./node_modules/node-libs-browser/node_modules/inherits/inherits_browser.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","_typeof","obj","iterator","constructor","expose","Markdown","dialect","this","dialects","Gruber","Error","String","em_state","strong_state","debug_indent","mk_block_toSource","uneval","toString","trailing","lineNumber","mk_block_inspect","util","inspect","parse","source","toTree","toHTML","options","input","toHTMLTree","renderJsonML","attrs","extract_attr","refs","references","html","convert_tree_to_html","tree","jsonml","slice","preprocessTreeNode","level","code","push","apply","splice","length","src","href","ref","original","title","merge_text_nodes","mk_block","block","trail","line","arguments","toSource","undefined","count_lines","str","indexOf","strong_em","tag","md","state_slot","other_slot","CloseTag","len","len_after","text","orig_match","shift","other","state","unshift","res","processInline","substr","last","pop","concat","split_blocks","startLine","replace","re","blocks","line_no","exec","lastIndex","processBlock","next","cbs","ord","__order__","__call__","isArray","debug","inline","custom_root","Array","old_tree","b","args","print","console","log","loop_re_over_block","cb","valueOf","atxHeader","match","header","setextHeader","ret","block_search","substring","join","horizRule","lists","bullet_list","is_list_re","RegExp","indent_re","add","li","loose","nl","add_to","what","get_contained_blocks","depth","x","paragraphify","stack","list","last_li","sublist","make_list","lines","split","li_accumulate","line_re","wanted_depth","Math","floor","found","indent","contained","forEach","next_block","hr","blockquote","prev","abutting","processedBlock","attr","isEmpty","referenceDefn","toLowerCase","para","__oneElement__","patterns_or_re","previous_nodes","__patterns__","index","patterns","out","__escape__","charAt","alt","orig","DialectHelpers","inline_until_char","link","consumed","children","url","open_parens","buildBlockOrder","buildInlinePatterns","fn","pattern","want","nodes","subclassDialect","Block","Inline","Maruku","processMetaHash","meta_string","meta","parts","in_quotes","letter","split_meta_hash","test","id","document_meta","pairs","block_meta","hash","node","a","result","definition_list","tight","terms","defns","table","_split_on_unescaped","ch","html_attrs","align","trim","row","html_row","matches","before","k","arr","thisp","escapeHTML","render_tree","attributes","content","tag_attrs","root","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","e","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","array","noop","nextTick","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","markdown","MarkdownCls","getOwnPropertyDescriptors","keys","descriptors","getOwnPropertyDescriptor","formatRegExp","format","f","isString","objects","Number","JSON","stringify","_","isNull","isObject","deprecate","msg","noDeprecation","warned","throwDeprecation","traceDeprecation","trace","error","debugEnviron","debugs","opts","ctx","seen","stylize","stylizeNoColor","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","style","styles","recurseTimes","isFunction","primitive","simple","isNumber","formatPrimitive","visibleKeys","val","idx","arrayToHash","getOwnPropertyNames","isError","formatError","isRegExp","isDate","Date","output","base","braces","toUTCString","formatProperty","formatArray","map","reduce","cur","numLinesEst","reduceToSingleString","desc","set","ar","arg","objectToString","pad","debuglog","NODE_DEBUG","toUpperCase","pid","isNullOrUndefined","isSymbol","isPrimitive","isBuffer","months","timestamp","time","getHours","getMinutes","getSeconds","getDate","getMonth","prop","inherits","origin","kCustomPromisifiedSymbol","callbackifyOnRejected","reason","newReason","promisify","TypeError","writable","configurable","promiseResolve","promiseReject","promise","Promise","resolve","reject","err","setPrototypeOf","getPrototypeOf","defineProperties","custom","callbackify","callbackified","maybeCb","self","then","rej","copy","fill","readUInt8","ctor","superCtor","super_","TempCtor"],"mappings":"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","file":"js/vendor/libs/markdown/markdown-bb5a9dc5efe5d61b2d93.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"https://optimal.seneris.com/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 867);\n","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n// Released under MIT license\n// Copyright (c) 2009-2010 Dominic Baggott\n// Copyright (c) 2009-2010 Ash Berlin\n// Copyright (c) 2011 Christoph Dorn <christoph@christophdorn.com> (http://www.christophdorn.com)\n\n/*jshint browser:true, devel:true */\n(function (expose) {\n  /**\n   *  class Markdown\n   *\n   *  Markdown processing in Javascript done right. We have very particular views\n   *  on what constitutes 'right' which include:\n   *\n   *  - produces well-formed HTML (this means that em and strong nesting is\n   *    important)\n   *\n   *  - has an intermediate representation to allow processing of parsed data (We\n   *    in fact have two, both as [JsonML]: a markdown tree and an HTML tree).\n   *\n   *  - is easily extensible to add new dialects without having to rewrite the\n   *    entire parsing mechanics\n   *\n   *  - has a good test suite\n   *\n   *  This implementation fulfills all of these (except that the test suite could\n   *  do with expanding to automatically run all the fixtures from other Markdown\n   *  implementations.)\n   *\n   *  ##### Intermediate Representation\n   *\n   *  *TODO* Talk about this :) Its JsonML, but document the node names we use.\n   *\n   *  [JsonML]: http://jsonml.org/ \"JSON Markup Language\"\n   **/\n  var Markdown = expose.Markdown = function (dialect) {\n    switch (_typeof(dialect)) {\n      case \"undefined\":\n        this.dialect = Markdown.dialects.Gruber;\n        break;\n\n      case \"object\":\n        this.dialect = dialect;\n        break;\n\n      default:\n        if (dialect in Markdown.dialects) {\n          this.dialect = Markdown.dialects[dialect];\n        } else {\n          throw new Error(\"Unknown Markdown dialect '\" + String(dialect) + \"'\");\n        }\n\n        break;\n    }\n\n    this.em_state = [];\n    this.strong_state = [];\n    this.debug_indent = \"\";\n  };\n  /**\n   *  parse( markdown, [dialect] ) -> JsonML\n   *  - markdown (String): markdown string to parse\n   *  - dialect (String | Dialect): the dialect to use, defaults to gruber\n   *\n   *  Parse `markdown` and return a markdown document as a Markdown.JsonML tree.\n   **/\n\n\n  expose.parse = function (source, dialect) {\n    // dialect will default if undefined\n    var md = new Markdown(dialect);\n    return md.toTree(source);\n  };\n  /**\n   *  toHTML( markdown, [dialect]  ) -> String\n   *  toHTML( md_tree ) -> String\n   *  - markdown (String): markdown string to parse\n   *  - md_tree (Markdown.JsonML): parsed markdown tree\n   *\n   *  Take markdown (either as a string or as a JsonML tree) and run it through\n   *  [[toHTMLTree]] then turn it into a well-formated HTML fragment.\n   **/\n\n\n  expose.toHTML = function toHTML(source, dialect, options) {\n    var input = expose.toHTMLTree(source, dialect, options);\n    return expose.renderJsonML(input);\n  };\n  /**\n   *  toHTMLTree( markdown, [dialect] ) -> JsonML\n   *  toHTMLTree( md_tree ) -> JsonML\n   *  - markdown (String): markdown string to parse\n   *  - dialect (String | Dialect): the dialect to use, defaults to gruber\n   *  - md_tree (Markdown.JsonML): parsed markdown tree\n   *\n   *  Turn markdown into HTML, represented as a JsonML tree. If a string is given\n   *  to this function, it is first parsed into a markdown tree by calling\n   *  [[parse]].\n   **/\n\n\n  expose.toHTMLTree = function toHTMLTree(input, dialect, options) {\n    // convert string input to an MD tree\n    if (typeof input === \"string\") input = this.parse(input, dialect); // Now convert the MD tree to an HTML tree\n    // remove references from the tree\n\n    var attrs = extract_attr(input),\n        refs = {};\n\n    if (attrs && attrs.references) {\n      refs = attrs.references;\n    }\n\n    var html = convert_tree_to_html(input, refs, options);\n    merge_text_nodes(html);\n    return html;\n  }; // For Spidermonkey based engines\n\n\n  function mk_block_toSource() {\n    return \"Markdown.mk_block( \" + uneval(this.toString()) + \", \" + uneval(this.trailing) + \", \" + uneval(this.lineNumber) + \" )\";\n  } // node\n\n\n  function mk_block_inspect() {\n    var util = require(\"util\");\n\n    return \"Markdown.mk_block( \" + util.inspect(this.toString()) + \", \" + util.inspect(this.trailing) + \", \" + util.inspect(this.lineNumber) + \" )\";\n  }\n\n  var mk_block = Markdown.mk_block = function (block, trail, line) {\n    // Be helpful for default case in tests.\n    if (arguments.length == 1) trail = \"\\n\\n\";\n    var s = new String(block);\n    s.trailing = trail; // To make it clear its not just a string\n\n    s.inspect = mk_block_inspect;\n    s.toSource = mk_block_toSource;\n    if (line != undefined) s.lineNumber = line;\n    return s;\n  };\n\n  function count_lines(str) {\n    var n = 0,\n        i = -1;\n\n    while ((i = str.indexOf(\"\\n\", i + 1)) !== -1) {\n      n++;\n    }\n\n    return n;\n  } // Internal - split source into rough blocks\n\n\n  Markdown.prototype.split_blocks = function splitBlocks(input, startLine) {\n    input = input.replace(/(\\r\\n|\\n|\\r)/g, \"\\n\"); // [\\s\\S] matches _anything_ (newline or space)\n    // [^] is equivalent but doesn't work in IEs.\n\n    var re = /([\\s\\S]+?)($|\\n#|\\n(?:\\s*\\n|$)+)/g,\n        blocks = [],\n        m;\n    var line_no = 1;\n\n    if ((m = /^(\\s*\\n)/.exec(input)) != null) {\n      // skip (but count) leading blank lines\n      line_no += count_lines(m[0]);\n      re.lastIndex = m[0].length;\n    }\n\n    while ((m = re.exec(input)) !== null) {\n      if (m[2] == \"\\n#\") {\n        m[2] = \"\\n\";\n        re.lastIndex--;\n      }\n\n      blocks.push(mk_block(m[1], m[2], line_no));\n      line_no += count_lines(m[0]);\n    }\n\n    return blocks;\n  };\n  /**\n   *  Markdown#processBlock( block, next ) -> undefined | [ JsonML, ... ]\n   *  - block (String): the block to process\n   *  - next (Array): the following blocks\n   *\n   * Process `block` and return an array of JsonML nodes representing `block`.\n   *\n   * It does this by asking each block level function in the dialect to process\n   * the block until one can. Succesful handling is indicated by returning an\n   * array (with zero or more JsonML nodes), failure by a false value.\n   *\n   * Blocks handlers are responsible for calling [[Markdown#processInline]]\n   * themselves as appropriate.\n   *\n   * If the blocks were split incorrectly or adjacent blocks need collapsing you\n   * can adjust `next` in place using shift/splice etc.\n   *\n   * If any of this default behaviour is not right for the dialect, you can\n   * define a `__call__` method on the dialect that will get invoked to handle\n   * the block processing.\n   */\n\n\n  Markdown.prototype.processBlock = function processBlock(block, next) {\n    var cbs = this.dialect.block,\n        ord = cbs.__order__;\n\n    if (\"__call__\" in cbs) {\n      return cbs.__call__.call(this, block, next);\n    }\n\n    for (var i = 0; i < ord.length; i++) {\n      //D:this.debug( \"Testing\", ord[i] );\n      var res = cbs[ord[i]].call(this, block, next);\n\n      if (res) {\n        //D:this.debug(\"  matched\");\n        if (!isArray(res) || res.length > 0 && !isArray(res[0])) this.debug(ord[i], \"didn't return a proper array\"); //D:this.debug( \"\" );\n\n        return res;\n      }\n    } // Uhoh! no match! Should we throw an error?\n\n\n    return [];\n  };\n\n  Markdown.prototype.processInline = function processInline(block) {\n    return this.dialect.inline.__call__.call(this, String(block));\n  };\n  /**\n   *  Markdown#toTree( source ) -> JsonML\n   *  - source (String): markdown source to parse\n   *\n   *  Parse `source` into a JsonML tree representing the markdown document.\n   **/\n  // custom_tree means set this.tree to `custom_tree` and restore old value on return\n\n\n  Markdown.prototype.toTree = function toTree(source, custom_root) {\n    var blocks = source instanceof Array ? source : this.split_blocks(source); // Make tree a member variable so its easier to mess with in extensions\n\n    var old_tree = this.tree;\n\n    try {\n      this.tree = custom_root || this.tree || [\"markdown\"];\n\n      blocks: while (blocks.length) {\n        var b = this.processBlock(blocks.shift(), blocks); // Reference blocks and the like won't return any content\n\n        if (!b.length) continue blocks;\n        this.tree.push.apply(this.tree, b);\n      }\n\n      return this.tree;\n    } finally {\n      if (custom_root) {\n        this.tree = old_tree;\n      }\n    }\n  }; // Noop by default\n\n\n  Markdown.prototype.debug = function () {\n    var args = Array.prototype.slice.call(arguments);\n    args.unshift(this.debug_indent);\n    if (typeof print !== \"undefined\") print.apply(print, args);\n    if (typeof console !== \"undefined\" && typeof console.log !== \"undefined\") console.log.apply(null, args);\n  };\n\n  Markdown.prototype.loop_re_over_block = function (re, block, cb) {\n    // Dont use /g regexps with this\n    var m,\n        b = block.valueOf();\n\n    while (b.length && (m = re.exec(b)) != null) {\n      b = b.substr(m[0].length);\n      cb.call(this, m);\n    }\n\n    return b;\n  };\n  /**\n   * Markdown.dialects\n   *\n   * Namespace of built-in dialects.\n   **/\n\n\n  Markdown.dialects = {};\n  /**\n   * Markdown.dialects.Gruber\n   *\n   * The default dialect that follows the rules set out by John Gruber's\n   * markdown.pl as closely as possible. Well actually we follow the behaviour of\n   * that script which in some places is not exactly what the syntax web page\n   * says.\n   **/\n\n  Markdown.dialects.Gruber = {\n    block: {\n      atxHeader: function atxHeader(block, next) {\n        var m = block.match(/^(#{1,6})\\s*(.*?)\\s*#*\\s*(?:\\n|$)/);\n        if (!m) return undefined;\n        var header = [\"header\", {\n          level: m[1].length\n        }];\n        Array.prototype.push.apply(header, this.processInline(m[2]));\n        if (m[0].length < block.length) next.unshift(mk_block(block.substr(m[0].length), block.trailing, block.lineNumber + 2));\n        return [header];\n      },\n      setextHeader: function setextHeader(block, next) {\n        var m = block.match(/^(.*)\\n([-=])\\2\\2+(?:\\n|$)/);\n        if (!m) return undefined;\n        var level = m[2] === \"=\" ? 1 : 2;\n        var header = [\"header\", {\n          level: level\n        }, m[1]];\n        if (m[0].length < block.length) next.unshift(mk_block(block.substr(m[0].length), block.trailing, block.lineNumber + 2));\n        return [header];\n      },\n      code: function code(block, next) {\n        // |    Foo\n        // |bar\n        // should be a code block followed by a paragraph. Fun\n        //\n        // There might also be adjacent code block to merge.\n        var ret = [],\n            re = /^(?: {0,3}\\t| {4})(.*)\\n?/,\n            lines; // 4 spaces + content\n\n        if (!block.match(re)) return undefined;\n\n        block_search: do {\n          // Now pull out the rest of the lines\n          var b = this.loop_re_over_block(re, block.valueOf(), function (m) {\n            ret.push(m[1]);\n          });\n\n          if (b.length) {\n            // Case alluded to in first comment. push it back on as a new block\n            next.unshift(mk_block(b, block.trailing));\n            break block_search;\n          } else if (next.length) {\n            // Check the next block - it might be code too\n            if (!next[0].match(re)) break block_search; // Pull how how many blanks lines follow - minus two to account for .join\n\n            ret.push(block.trailing.replace(/[^\\n]/g, \"\").substring(2));\n            block = next.shift();\n          } else {\n            break block_search;\n          }\n        } while (true);\n\n        return [[\"code_block\", ret.join(\"\\n\")]];\n      },\n      horizRule: function horizRule(block, next) {\n        // this needs to find any hr in the block to handle abutting blocks\n        var m = block.match(/^(?:([\\s\\S]*?)\\n)?[ \\t]*([-_*])(?:[ \\t]*\\2){2,}[ \\t]*(?:\\n([\\s\\S]*))?$/);\n\n        if (!m) {\n          return undefined;\n        }\n\n        var jsonml = [[\"hr\"]]; // if there's a leading abutting block, process it\n\n        if (m[1]) {\n          jsonml.unshift.apply(jsonml, this.processBlock(m[1], []));\n        } // if there's a trailing abutting block, stick it into next\n\n\n        if (m[3]) {\n          next.unshift(mk_block(m[3]));\n        }\n\n        return jsonml;\n      },\n      // There are two types of lists. Tight and loose. Tight lists have no whitespace\n      // between the items (and result in text just in the <li>) and loose lists,\n      // which have an empty line between list items, resulting in (one or more)\n      // paragraphs inside the <li>.\n      //\n      // There are all sorts weird edge cases about the original markdown.pl's\n      // handling of lists:\n      //\n      // * Nested lists are supposed to be indented by four chars per level. But\n      //   if they aren't, you can get a nested list by indenting by less than\n      //   four so long as the indent doesn't match an indent of an existing list\n      //   item in the 'nest stack'.\n      //\n      // * The type of the list (bullet or number) is controlled just by the\n      //    first item at the indent. Subsequent changes are ignored unless they\n      //    are for nested lists\n      //\n      lists: function () {\n        // Use a closure to hide a few variables.\n        var any_list = \"[*+-]|\\\\d+\\\\.\",\n            bullet_list = /[*+-]/,\n            number_list = /\\d+\\./,\n            // Capture leading indent as it matters for determining nested lists.\n        is_list_re = new RegExp(\"^( {0,3})(\" + any_list + \")[ \\t]+\"),\n            indent_re = \"(?: {0,3}\\\\t| {4})\"; // TODO: Cache this regexp for certain depths.\n        // Create a regexp suitable for matching an li for a given stack depth\n\n        function regex_for_depth(depth) {\n          return new RegExp( // m[1] = indent, m[2] = list_type\n          \"(?:^(\" + indent_re + \"{0,\" + depth + \"} {0,3})(\" + any_list + \")\\\\s+)|\" + // m[3] = cont\n          \"(^\" + indent_re + \"{0,\" + (depth - 1) + \"}[ ]{0,4})\");\n        }\n\n        function expand_tab(input) {\n          return input.replace(/ {0,3}\\t/g, \"    \");\n        } // Add inline content `inline` to `li`. inline comes from processInline\n        // so is an array of content\n\n\n        function add(li, loose, inline, nl) {\n          if (loose) {\n            li.push([\"para\"].concat(inline));\n            return;\n          } // Hmmm, should this be any block level element or just paras?\n\n\n          var add_to = li[li.length - 1] instanceof Array && li[li.length - 1][0] == \"para\" ? li[li.length - 1] : li; // If there is already some content in this list, add the new line in\n\n          if (nl && li.length > 1) inline.unshift(nl);\n\n          for (var i = 0; i < inline.length; i++) {\n            var what = inline[i],\n                is_str = typeof what == \"string\";\n\n            if (is_str && add_to.length > 1 && typeof add_to[add_to.length - 1] == \"string\") {\n              add_to[add_to.length - 1] += what;\n            } else {\n              add_to.push(what);\n            }\n          }\n        } // contained means have an indent greater than the current one. On\n        // *every* line in the block\n\n\n        function get_contained_blocks(depth, blocks) {\n          var re = new RegExp(\"^(\" + indent_re + \"{\" + depth + \"}.*?\\\\n?)*$\"),\n              replace = new RegExp(\"^\" + indent_re + \"{\" + depth + \"}\", \"gm\"),\n              ret = [];\n\n          while (blocks.length > 0) {\n            if (re.exec(blocks[0])) {\n              var b = blocks.shift(),\n                  // Now remove that indent\n              x = b.replace(replace, \"\");\n              ret.push(mk_block(x, b.trailing, b.lineNumber));\n            } else {\n              break;\n            }\n          }\n\n          return ret;\n        } // passed to stack.forEach to turn list items up the stack into paras\n\n\n        function paragraphify(s, i, stack) {\n          var list = s.list;\n          var last_li = list[list.length - 1];\n\n          if (last_li[1] instanceof Array && last_li[1][0] == \"para\") {\n            return;\n          }\n\n          if (i + 1 == stack.length) {\n            // Last stack frame\n            // Keep the same array, but replace the contents\n            last_li.push([\"para\"].concat(last_li.splice(1, last_li.length - 1)));\n          } else {\n            var sublist = last_li.pop();\n            last_li.push([\"para\"].concat(last_li.splice(1, last_li.length - 1)), sublist);\n          }\n        } // The matcher function\n\n\n        return function (block, next) {\n          var m = block.match(is_list_re);\n          if (!m) return undefined;\n\n          function make_list(m) {\n            var list = bullet_list.exec(m[2]) ? [\"bulletlist\"] : [\"numberlist\"];\n            stack.push({\n              list: list,\n              indent: m[1]\n            });\n            return list;\n          }\n\n          var stack = [],\n              // Stack of lists for nesting.\n          list = make_list(m),\n              last_li,\n              loose = false,\n              ret = [stack[0].list],\n              i; // Loop to search over block looking for inner block elements and loose lists\n\n          loose_search: while (true) {\n            // Split into lines preserving new lines at end of line\n            var lines = block.split(/(?=\\n)/); // We have to grab all lines for a li and call processInline on them\n            // once as there are some inline things that can span lines.\n\n            var li_accumulate = \"\"; // Loop over the lines in this block looking for tight lists.\n\n            tight_search: for (var line_no = 0; line_no < lines.length; line_no++) {\n              var nl = \"\",\n                  l = lines[line_no].replace(/^\\n/, function (n) {\n                nl = n;\n                return \"\";\n              }); // TODO: really should cache this\n\n              var line_re = regex_for_depth(stack.length);\n              m = l.match(line_re); //print( \"line:\", uneval(l), \"\\nline match:\", uneval(m) );\n              // We have a list item\n\n              if (m[1] !== undefined) {\n                // Process the previous list item, if any\n                if (li_accumulate.length) {\n                  add(last_li, loose, this.processInline(li_accumulate), nl); // Loose mode will have been dealt with. Reset it\n\n                  loose = false;\n                  li_accumulate = \"\";\n                }\n\n                m[1] = expand_tab(m[1]);\n                var wanted_depth = Math.floor(m[1].length / 4) + 1; //print( \"want:\", wanted_depth, \"stack:\", stack.length);\n\n                if (wanted_depth > stack.length) {\n                  // Deep enough for a nested list outright\n                  //print ( \"new nested list\" );\n                  list = make_list(m);\n                  last_li.push(list);\n                  last_li = list[1] = [\"listitem\"];\n                } else {\n                  // We aren't deep enough to be strictly a new level. This is\n                  // where Md.pl goes nuts. If the indent matches a level in the\n                  // stack, put it there, else put it one deeper then the\n                  // wanted_depth deserves.\n                  var found = false;\n\n                  for (i = 0; i < stack.length; i++) {\n                    if (stack[i].indent != m[1]) continue;\n                    list = stack[i].list;\n                    stack.splice(i + 1, stack.length - (i + 1));\n                    found = true;\n                    break;\n                  }\n\n                  if (!found) {\n                    //print(\"not found. l:\", uneval(l));\n                    wanted_depth++;\n\n                    if (wanted_depth <= stack.length) {\n                      stack.splice(wanted_depth, stack.length - wanted_depth); //print(\"Desired depth now\", wanted_depth, \"stack:\", stack.length);\n\n                      list = stack[wanted_depth - 1].list; //print(\"list:\", uneval(list) );\n                    } else {\n                      //print (\"made new stack for messy indent\");\n                      list = make_list(m);\n                      last_li.push(list);\n                    }\n                  } //print( uneval(list), \"last\", list === stack[stack.length-1].list );\n\n\n                  last_li = [\"listitem\"];\n                  list.push(last_li);\n                } // end depth of shenegains\n\n\n                nl = \"\";\n              } // Add content\n\n\n              if (l.length > m[0].length) {\n                li_accumulate += nl + l.substr(m[0].length);\n              }\n            } // tight_search\n\n\n            if (li_accumulate.length) {\n              add(last_li, loose, this.processInline(li_accumulate), nl); // Loose mode will have been dealt with. Reset it\n\n              loose = false;\n              li_accumulate = \"\";\n            } // Look at the next block - we might have a loose list. Or an extra\n            // paragraph for the current li\n\n\n            var contained = get_contained_blocks(stack.length, next); // Deal with code blocks or properly nested lists\n\n            if (contained.length > 0) {\n              // Make sure all listitems up the stack are paragraphs\n              forEach(stack, paragraphify, this);\n              last_li.push.apply(last_li, this.toTree(contained, []));\n            }\n\n            var next_block = next[0] && next[0].valueOf() || \"\";\n\n            if (next_block.match(is_list_re) || next_block.match(/^ /)) {\n              block = next.shift(); // Check for an HR following a list: features/lists/hr_abutting\n\n              var hr = this.dialect.block.horizRule(block, next);\n\n              if (hr) {\n                ret.push.apply(ret, hr);\n                break;\n              } // Make sure all listitems up the stack are paragraphs\n\n\n              forEach(stack, paragraphify, this);\n              loose = true;\n              continue loose_search;\n            }\n\n            break;\n          } // loose_search\n\n\n          return ret;\n        };\n      }(),\n      blockquote: function blockquote(block, next) {\n        if (!block.match(/^>/m)) return undefined;\n        var jsonml = []; // separate out the leading abutting block, if any. I.e. in this case:\n        //\n        //  a\n        //  > b\n        //\n\n        if (block[0] != \">\") {\n          var lines = block.split(/\\n/),\n              prev = [],\n              line_no = block.lineNumber; // keep shifting lines until you find a crotchet\n\n          while (lines.length && lines[0][0] != \">\") {\n            prev.push(lines.shift());\n            line_no++;\n          }\n\n          var abutting = mk_block(prev.join(\"\\n\"), \"\\n\", block.lineNumber);\n          jsonml.push.apply(jsonml, this.processBlock(abutting, [])); // reassemble new block of just block quotes!\n\n          block = mk_block(lines.join(\"\\n\"), block.trailing, line_no);\n        } // if the next block is also a blockquote merge it in\n\n\n        while (next.length && next[0][0] == \">\") {\n          var b = next.shift();\n          block = mk_block(block + block.trailing + b, b.trailing, block.lineNumber);\n        } // Strip off the leading \"> \" and re-process as a block.\n\n\n        var input = block.replace(/^> ?/gm, \"\"),\n            old_tree = this.tree,\n            processedBlock = this.toTree(input, [\"blockquote\"]),\n            attr = extract_attr(processedBlock); // If any link references were found get rid of them\n\n        if (attr && attr.references) {\n          delete attr.references; // And then remove the attribute object if it's empty\n\n          if (isEmpty(attr)) {\n            processedBlock.splice(1, 1);\n          }\n        }\n\n        jsonml.push(processedBlock);\n        return jsonml;\n      },\n      referenceDefn: function referenceDefn(block, next) {\n        var re = /^\\s*\\[(.*?)\\]:\\s*(\\S+)(?:\\s+(?:(['\"])(.*?)\\3|\\((.*?)\\)))?\\n?/; // interesting matches are [ , ref_id, url, , title, title ]\n\n        if (!block.match(re)) return undefined; // make an attribute node if it doesn't exist\n\n        if (!extract_attr(this.tree)) {\n          this.tree.splice(1, 0, {});\n        }\n\n        var attrs = extract_attr(this.tree); // make a references hash if it doesn't exist\n\n        if (attrs.references === undefined) {\n          attrs.references = {};\n        }\n\n        var b = this.loop_re_over_block(re, block, function (m) {\n          if (m[2] && m[2][0] == \"<\" && m[2][m[2].length - 1] == \">\") m[2] = m[2].substring(1, m[2].length - 1);\n          var ref = attrs.references[m[1].toLowerCase()] = {\n            href: m[2]\n          };\n          if (m[4] !== undefined) ref.title = m[4];else if (m[5] !== undefined) ref.title = m[5];\n        });\n        if (b.length) next.unshift(mk_block(b, block.trailing));\n        return [];\n      },\n      para: function para(block, next) {\n        // everything's a para!\n        return [[\"para\"].concat(this.processInline(block))];\n      }\n    }\n  };\n  Markdown.dialects.Gruber.inline = {\n    __oneElement__: function oneElement(text, patterns_or_re, previous_nodes) {\n      var m,\n          res,\n          lastIndex = 0;\n      patterns_or_re = patterns_or_re || this.dialect.inline.__patterns__;\n      var re = new RegExp(\"([\\\\s\\\\S]*?)(\" + (patterns_or_re.source || patterns_or_re) + \")\");\n      m = re.exec(text);\n\n      if (!m) {\n        // Just boring text\n        return [text.length, text];\n      } else if (m[1]) {\n        // Some un-interesting text matched. Return that first\n        return [m[1].length, m[1]];\n      }\n\n      var res;\n\n      if (m[2] in this.dialect.inline) {\n        res = this.dialect.inline[m[2]].call(this, text.substr(m.index), m, previous_nodes || []);\n      } // Default for now to make dev easier. just slurp special and output it.\n\n\n      res = res || [m[2].length, m[2]];\n      return res;\n    },\n    __call__: function inline(text, patterns) {\n      var out = [],\n          res;\n\n      function add(x) {\n        //D:self.debug(\"  adding output\", uneval(x));\n        if (typeof x == \"string\" && typeof out[out.length - 1] == \"string\") out[out.length - 1] += x;else out.push(x);\n      }\n\n      while (text.length > 0) {\n        res = this.dialect.inline.__oneElement__.call(this, text, patterns, out);\n        text = text.substr(res.shift());\n        forEach(res, add);\n      }\n\n      return out;\n    },\n    // These characters are intersting elsewhere, so have rules for them so that\n    // chunks of plain text blocks don't include them\n    \"]\": function _() {},\n    \"}\": function _() {},\n    __escape__: /^\\\\[\\\\`\\*_{}\\[\\]()#\\+.!\\-]/,\n    \"\\\\\": function escaped(text) {\n      // [ length of input processed, node/children to add... ]\n      // Only esacape: \\ ` * _ { } [ ] ( ) # * + - . !\n      if (this.dialect.inline.__escape__.exec(text)) return [2, text.charAt(1)];else // Not an esacpe\n        return [1, \"\\\\\"];\n    },\n    \"![\": function image(text) {\n      // Unlike images, alt text is plain text only. no other elements are\n      // allowed in there\n      // ![Alt text](/path/to/img.jpg \"Optional title\")\n      //      1          2            3       4         <--- captures\n      var m = text.match(/^!\\[(.*?)\\][ \\t]*\\([ \\t]*([^\")]*?)(?:[ \\t]+([\"'])(.*?)\\3)?[ \\t]*\\)/);\n\n      if (m) {\n        if (m[2] && m[2][0] == \"<\" && m[2][m[2].length - 1] == \">\") m[2] = m[2].substring(1, m[2].length - 1);\n        m[2] = this.dialect.inline.__call__.call(this, m[2], /\\\\/)[0];\n        var attrs = {\n          alt: m[1],\n          href: m[2] || \"\"\n        };\n        if (m[4] !== undefined) attrs.title = m[4];\n        return [m[0].length, [\"img\", attrs]];\n      } // ![Alt text][id]\n\n\n      m = text.match(/^!\\[(.*?)\\][ \\t]*\\[(.*?)\\]/);\n\n      if (m) {\n        // We can't check if the reference is known here as it likely wont be\n        // found till after. Check it in md tree->hmtl tree conversion\n        return [m[0].length, [\"img_ref\", {\n          alt: m[1],\n          ref: m[2].toLowerCase(),\n          original: m[0]\n        }]];\n      } // Just consume the '!['\n\n\n      return [2, \"![\"];\n    },\n    \"[\": function link(text) {\n      var orig = String(text); // Inline content is possible inside `link text`\n\n      var res = Markdown.DialectHelpers.inline_until_char.call(this, text.substr(1), \"]\"); // No closing ']' found. Just consume the [\n\n      if (!res) return [1, \"[\"];\n      var consumed = 1 + res[0],\n          children = res[1],\n          link,\n          attrs; // At this point the first [...] has been parsed. See what follows to find\n      // out which kind of link we are (reference or direct url)\n\n      text = text.substr(consumed); // [link text](/path/to/img.jpg \"Optional title\")\n      //                 1            2       3         <--- captures\n      // This will capture up to the last paren in the block. We then pull\n      // back based on if there a matching ones in the url\n      //    ([here](/url/(test))\n      // The parens have to be balanced\n\n      var m = text.match(/^\\s*\\([ \\t]*([^\"']*)(?:[ \\t]+([\"'])(.*?)\\2)?[ \\t]*\\)/);\n\n      if (m) {\n        var url = m[1];\n        consumed += m[0].length;\n        if (url && url[0] == \"<\" && url[url.length - 1] == \">\") url = url.substring(1, url.length - 1); // If there is a title we don't have to worry about parens in the url\n\n        if (!m[3]) {\n          var open_parens = 1; // One open that isn't in the capture\n\n          for (var len = 0; len < url.length; len++) {\n            switch (url[len]) {\n              case \"(\":\n                open_parens++;\n                break;\n\n              case \")\":\n                if (--open_parens == 0) {\n                  consumed -= url.length - len;\n                  url = url.substring(0, len);\n                }\n\n                break;\n            }\n          }\n        } // Process escapes only\n\n\n        url = this.dialect.inline.__call__.call(this, url, /\\\\/)[0];\n        attrs = {\n          href: url || \"\"\n        };\n        if (m[3] !== undefined) attrs.title = m[3];\n        link = [\"link\", attrs].concat(children);\n        return [consumed, link];\n      } // [Alt text][id]\n      // [Alt text] [id]\n\n\n      m = text.match(/^\\s*\\[(.*?)\\]/);\n\n      if (m) {\n        consumed += m[0].length; // [links][] uses links as its reference\n\n        attrs = {\n          ref: (m[1] || String(children)).toLowerCase(),\n          original: orig.substr(0, consumed)\n        };\n        link = [\"link_ref\", attrs].concat(children); // We can't check if the reference is known here as it likely wont be\n        // found till after. Check it in md tree->hmtl tree conversion.\n        // Store the original so that conversion can revert if the ref isn't found.\n\n        return [consumed, link];\n      } // [id]\n      // Only if id is plain (no formatting.)\n\n\n      if (children.length == 1 && typeof children[0] == \"string\") {\n        attrs = {\n          ref: children[0].toLowerCase(),\n          original: orig.substr(0, consumed)\n        };\n        link = [\"link_ref\", attrs, children[0]];\n        return [consumed, link];\n      } // Just consume the \"[\"\n\n\n      return [1, \"[\"];\n    },\n    \"<\": function autoLink(text) {\n      var m;\n\n      if ((m = text.match(/^<(?:((https?|ftp|mailto):[^>]+)|(.*?@.*?\\.[a-zA-Z]+))>/)) != null) {\n        if (m[3]) {\n          return [m[0].length, [\"link\", {\n            href: \"mailto:\" + m[3]\n          }, m[3]]];\n        } else if (m[2] == \"mailto\") {\n          return [m[0].length, [\"link\", {\n            href: m[1]\n          }, m[1].substr(\"mailto:\".length)]];\n        } else return [m[0].length, [\"link\", {\n          href: m[1]\n        }, m[1]]];\n      }\n\n      return [1, \"<\"];\n    },\n    \"`\": function inlineCode(text) {\n      // Inline code block. as many backticks as you like to start it\n      // Always skip over the opening ticks.\n      var m = text.match(/(`+)(([\\s\\S]*?)\\1)/);\n      if (m && m[2]) return [m[1].length + m[2].length, [\"inlinecode\", m[3]]];else {\n        // TODO: No matching end code found - warn!\n        return [1, \"`\"];\n      }\n    },\n    \"  \\n\": function lineBreak(text) {\n      return [3, [\"linebreak\"]];\n    }\n  }; // Meta Helper/generator method for em and strong handling\n\n  function strong_em(tag, md) {\n    var state_slot = tag + \"_state\",\n        other_slot = tag == \"strong\" ? \"em_state\" : \"strong_state\";\n\n    function CloseTag(len) {\n      this.len_after = len;\n      this.name = \"close_\" + md;\n    }\n\n    return function (text, orig_match) {\n      if (this[state_slot][0] == md) {\n        // Most recent em is of this type\n        //D:this.debug(\"closing\", md);\n        this[state_slot].shift(); // \"Consume\" everything to go back to the recrusion in the else-block below\n\n        return [text.length, new CloseTag(text.length - md.length)];\n      } else {\n        // Store a clone of the em/strong states\n        var other = this[other_slot].slice(),\n            state = this[state_slot].slice();\n        this[state_slot].unshift(md); //D:this.debug_indent += \"  \";\n        // Recurse\n\n        var res = this.processInline(text.substr(md.length)); //D:this.debug_indent = this.debug_indent.substr(2);\n\n        var last = res[res.length - 1]; //D:this.debug(\"processInline from\", tag + \": \", uneval( res ) );\n\n        var check = this[state_slot].shift();\n\n        if (last instanceof CloseTag) {\n          res.pop(); // We matched! Huzzah.\n\n          var consumed = text.length - last.len_after;\n          return [consumed, [tag].concat(res)];\n        } else {\n          // Restore the state of the other kind. We might have mistakenly closed it.\n          this[other_slot] = other;\n          this[state_slot] = state; // We can't reuse the processed result as it could have wrong parsing contexts in it.\n\n          return [md.length, md];\n        }\n      }\n    }; // End returned function\n  }\n\n  Markdown.dialects.Gruber.inline[\"**\"] = strong_em(\"strong\", \"**\");\n  Markdown.dialects.Gruber.inline[\"__\"] = strong_em(\"strong\", \"__\");\n  Markdown.dialects.Gruber.inline[\"*\"] = strong_em(\"em\", \"*\");\n  Markdown.dialects.Gruber.inline[\"_\"] = strong_em(\"em\", \"_\"); // Build default order from insertion order.\n\n  Markdown.buildBlockOrder = function (d) {\n    var ord = [];\n\n    for (var i in d) {\n      if (i == \"__order__\" || i == \"__call__\") continue;\n      ord.push(i);\n    }\n\n    d.__order__ = ord;\n  }; // Build patterns for inline matcher\n\n\n  Markdown.buildInlinePatterns = function (d) {\n    var patterns = [];\n\n    for (var i in d) {\n      // __foo__ is reserved and not a pattern\n      if (i.match(/^__.*__$/)) continue;\n      var l = i.replace(/([\\\\.*+?|()\\[\\]{}])/g, \"\\\\$1\").replace(/\\n/, \"\\\\n\");\n      patterns.push(i.length == 1 ? l : \"(?:\" + l + \")\");\n    }\n\n    patterns = patterns.join(\"|\");\n    d.__patterns__ = patterns; //print(\"patterns:\", uneval( patterns ) );\n\n    var fn = d.__call__;\n\n    d.__call__ = function (text, pattern) {\n      if (pattern != undefined) {\n        return fn.call(this, text, pattern);\n      } else {\n        return fn.call(this, text, patterns);\n      }\n    };\n  };\n\n  Markdown.DialectHelpers = {};\n\n  Markdown.DialectHelpers.inline_until_char = function (text, want) {\n    var consumed = 0,\n        nodes = [];\n\n    while (true) {\n      if (text.charAt(consumed) == want) {\n        // Found the character we were looking for\n        consumed++;\n        return [consumed, nodes];\n      }\n\n      if (consumed >= text.length) {\n        // No closing char found. Abort.\n        return null;\n      }\n\n      var res = this.dialect.inline.__oneElement__.call(this, text.substr(consumed));\n\n      consumed += res[0]; // Add any returned nodes.\n\n      nodes.push.apply(nodes, res.slice(1));\n    }\n  }; // Helper function to make sub-classing a dialect easier\n\n\n  Markdown.subclassDialect = function (d) {\n    function Block() {}\n\n    Block.prototype = d.block;\n\n    function Inline() {}\n\n    Inline.prototype = d.inline;\n    return {\n      block: new Block(),\n      inline: new Inline()\n    };\n  };\n\n  Markdown.buildBlockOrder(Markdown.dialects.Gruber.block);\n  Markdown.buildInlinePatterns(Markdown.dialects.Gruber.inline);\n  Markdown.dialects.Maruku = Markdown.subclassDialect(Markdown.dialects.Gruber);\n\n  Markdown.dialects.Maruku.processMetaHash = function processMetaHash(meta_string) {\n    var meta = split_meta_hash(meta_string),\n        attr = {};\n\n    for (var i = 0; i < meta.length; ++i) {\n      // id: #foo\n      if (/^#/.test(meta[i])) {\n        attr.id = meta[i].substring(1);\n      } // class: .foo\n      else if (/^\\./.test(meta[i])) {\n          // if class already exists, append the new one\n          if (attr[\"class\"]) {\n            attr[\"class\"] = attr[\"class\"] + meta[i].replace(/./, \" \");\n          } else {\n            attr[\"class\"] = meta[i].substring(1);\n          }\n        } // attribute: foo=bar\n        else if (/\\=/.test(meta[i])) {\n            var s = meta[i].split(/\\=/);\n            attr[s[0]] = s[1];\n          }\n    }\n\n    return attr;\n  };\n\n  function split_meta_hash(meta_string) {\n    var meta = meta_string.split(\"\"),\n        parts = [\"\"],\n        in_quotes = false;\n\n    while (meta.length) {\n      var letter = meta.shift();\n\n      switch (letter) {\n        case \" \":\n          // if we're in a quoted section, keep it\n          if (in_quotes) {\n            parts[parts.length - 1] += letter;\n          } // otherwise make a new part\n          else {\n              parts.push(\"\");\n            }\n\n          break;\n\n        case \"'\":\n        case '\"':\n          // reverse the quotes and move straight on\n          in_quotes = !in_quotes;\n          break;\n\n        case \"\\\\\":\n          // shift off the next letter to be used straight away.\n          // it was escaped so we'll keep it whatever it is\n          letter = meta.shift();\n\n        default:\n          parts[parts.length - 1] += letter;\n          break;\n      }\n    }\n\n    return parts;\n  }\n\n  Markdown.dialects.Maruku.block.document_meta = function document_meta(block, next) {\n    // we're only interested in the first block\n    if (block.lineNumber > 1) return undefined; // document_meta blocks consist of one or more lines of `Key: Value\\n`\n\n    if (!block.match(/^(?:\\w+:.*\\n)*\\w+:.*$/)) return undefined; // make an attribute node if it doesn't exist\n\n    if (!extract_attr(this.tree)) {\n      this.tree.splice(1, 0, {});\n    }\n\n    var pairs = block.split(/\\n/);\n\n    for (p in pairs) {\n      var m = pairs[p].match(/(\\w+):\\s*(.*)$/),\n          key = m[1].toLowerCase(),\n          value = m[2];\n      this.tree[1][key] = value;\n    } // document_meta produces no content!\n\n\n    return [];\n  };\n\n  Markdown.dialects.Maruku.block.block_meta = function block_meta(block, next) {\n    // check if the last line of the block is an meta hash\n    var m = block.match(/(^|\\n) {0,3}\\{:\\s*((?:\\\\\\}|[^\\}])*)\\s*\\}$/);\n    if (!m) return undefined; // process the meta hash\n\n    var attr = this.dialect.processMetaHash(m[2]);\n    var hash; // if we matched ^ then we need to apply meta to the previous block\n\n    if (m[1] === \"\") {\n      var node = this.tree[this.tree.length - 1];\n      hash = extract_attr(node); // if the node is a string (rather than JsonML), bail\n\n      if (typeof node === \"string\") return undefined; // create the attribute hash if it doesn't exist\n\n      if (!hash) {\n        hash = {};\n        node.splice(1, 0, hash);\n      } // add the attributes in\n\n\n      for (a in attr) {\n        hash[a] = attr[a];\n      } // return nothing so the meta hash is removed\n\n\n      return [];\n    } // pull the meta hash off the block and process what's left\n\n\n    var b = block.replace(/\\n.*$/, \"\"),\n        result = this.processBlock(b, []); // get or make the attributes hash\n\n    hash = extract_attr(result[0]);\n\n    if (!hash) {\n      hash = {};\n      result[0].splice(1, 0, hash);\n    } // attach the attributes to the block\n\n\n    for (a in attr) {\n      hash[a] = attr[a];\n    }\n\n    return result;\n  };\n\n  Markdown.dialects.Maruku.block.definition_list = function definition_list(block, next) {\n    // one or more terms followed by one or more definitions, in a single block\n    var tight = /^((?:[^\\s:].*\\n)+):\\s+([\\s\\S]+)$/,\n        list = [\"dl\"],\n        i,\n        m; // see if we're dealing with a tight or loose block\n\n    if (m = block.match(tight)) {\n      // pull subsequent tight DL blocks out of `next`\n      var blocks = [block];\n\n      while (next.length && tight.exec(next[0])) {\n        blocks.push(next.shift());\n      }\n\n      for (var b = 0; b < blocks.length; ++b) {\n        var m = blocks[b].match(tight),\n            terms = m[1].replace(/\\n$/, \"\").split(/\\n/),\n            defns = m[2].split(/\\n:\\s+/); // print( uneval( m ) );\n\n        for (i = 0; i < terms.length; ++i) {\n          list.push([\"dt\", terms[i]]);\n        }\n\n        for (i = 0; i < defns.length; ++i) {\n          // run inline processing over the definition\n          list.push([\"dd\"].concat(this.processInline(defns[i].replace(/(\\n)\\s+/, \"$1\"))));\n        }\n      }\n    } else {\n      return undefined;\n    }\n\n    return [list];\n  }; // splits on unescaped instances of @ch. If @ch is not a character the result\n  // can be unpredictable\n\n\n  Markdown.dialects.Maruku.block.table = function table(block, next) {\n    var _split_on_unescaped = function _split_on_unescaped(s, ch) {\n      ch = ch || '\\\\s';\n\n      if (ch.match(/^[\\\\|\\[\\]{}?*.+^$]$/)) {\n        ch = '\\\\' + ch;\n      }\n\n      var res = [],\n          r = new RegExp('^((?:\\\\\\\\.|[^\\\\\\\\' + ch + '])*)' + ch + '(.*)'),\n          m;\n\n      while (m = s.match(r)) {\n        res.push(m[1]);\n        s = m[2];\n      }\n\n      res.push(s);\n      return res;\n    };\n\n    var leading_pipe = /^ {0,3}\\|(.+)\\n {0,3}\\|\\s*([\\-:]+[\\-| :]*)\\n((?:\\s*\\|.*(?:\\n|$))*)(?=\\n|$)/,\n        // find at least an unescaped pipe in each line\n    no_leading_pipe = /^ {0,3}(\\S(?:\\\\.|[^\\\\|])*\\|.*)\\n {0,3}([\\-:]+\\s*\\|[\\-| :]*)\\n((?:(?:\\\\.|[^\\\\|])*\\|.*(?:\\n|$))*)(?=\\n|$)/,\n        i,\n        m;\n\n    if (m = block.match(leading_pipe)) {\n      // remove leading pipes in contents\n      // (header and horizontal rule already have the leading pipe left out)\n      m[3] = m[3].replace(/^\\s*\\|/gm, '');\n    } else if (!(m = block.match(no_leading_pipe))) {\n      return undefined;\n    }\n\n    var table = [\"table\", [\"thead\", [\"tr\"]], [\"tbody\"]]; // remove trailing pipes, then split on pipes\n    // (no escaped pipes are allowed in horizontal rule)\n\n    m[2] = m[2].replace(/\\|\\s*$/, '').split('|'); // process alignment\n\n    var html_attrs = [];\n    forEach(m[2], function (s) {\n      if (s.match(/^\\s*-+:\\s*$/)) html_attrs.push({\n        align: \"right\"\n      });else if (s.match(/^\\s*:-+\\s*$/)) html_attrs.push({\n        align: \"left\"\n      });else if (s.match(/^\\s*:-+:\\s*$/)) html_attrs.push({\n        align: \"center\"\n      });else html_attrs.push({});\n    }); // now for the header, avoid escaped pipes\n\n    m[1] = _split_on_unescaped(m[1].replace(/\\|\\s*$/, ''), '|');\n\n    for (i = 0; i < m[1].length; i++) {\n      table[1][1].push(['th', html_attrs[i] || {}].concat(this.processInline(m[1][i].trim())));\n    } // now for body contents\n\n\n    forEach(m[3].replace(/\\|\\s*$/mg, '').split('\\n'), function (row) {\n      var html_row = ['tr'];\n      row = _split_on_unescaped(row, '|');\n\n      for (i = 0; i < row.length; i++) {\n        html_row.push(['td', html_attrs[i] || {}].concat(this.processInline(row[i].trim())));\n      }\n\n      table[2].push(html_row);\n    }, this);\n    return [table];\n  };\n\n  Markdown.dialects.Maruku.inline[\"{:\"] = function inline_meta(text, matches, out) {\n    if (!out.length) {\n      return [2, \"{:\"];\n    } // get the preceeding element\n\n\n    var before = out[out.length - 1];\n\n    if (typeof before === \"string\") {\n      return [2, \"{:\"];\n    } // match a meta hash\n\n\n    var m = text.match(/^\\{:\\s*((?:\\\\\\}|[^\\}])*)\\s*\\}/); // no match, false alarm\n\n    if (!m) {\n      return [2, \"{:\"];\n    } // attach the attributes to the preceeding element\n\n\n    var meta = this.dialect.processMetaHash(m[1]),\n        attr = extract_attr(before);\n\n    if (!attr) {\n      attr = {};\n      before.splice(1, 0, attr);\n    }\n\n    for (var k in meta) {\n      attr[k] = meta[k];\n    } // cut out the string and replace it with nothing\n\n\n    return [m[0].length, \"\"];\n  };\n\n  Markdown.dialects.Maruku.inline.__escape__ = /^\\\\[\\\\`\\*_{}\\[\\]()#\\+.!\\-|:]/;\n  Markdown.buildBlockOrder(Markdown.dialects.Maruku.block);\n  Markdown.buildInlinePatterns(Markdown.dialects.Maruku.inline);\n\n  var isArray = Array.isArray || function (obj) {\n    return Object.prototype.toString.call(obj) == \"[object Array]\";\n  };\n\n  var forEach; // Don't mess with Array.prototype. Its not friendly\n\n  if (Array.prototype.forEach) {\n    forEach = function forEach(arr, cb, thisp) {\n      return arr.forEach(cb, thisp);\n    };\n  } else {\n    forEach = function forEach(arr, cb, thisp) {\n      for (var i = 0; i < arr.length; i++) {\n        cb.call(thisp || arr, arr[i], i, arr);\n      }\n    };\n  }\n\n  var isEmpty = function isEmpty(obj) {\n    for (var key in obj) {\n      if (hasOwnProperty.call(obj, key)) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  function extract_attr(jsonml) {\n    return isArray(jsonml) && jsonml.length > 1 && _typeof(jsonml[1]) === \"object\" && !isArray(jsonml[1]) ? jsonml[1] : undefined;\n  }\n  /**\n   *  renderJsonML( jsonml[, options] ) -> String\n   *  - jsonml (Array): JsonML array to render to XML\n   *  - options (Object): options\n   *\n   *  Converts the given JsonML into well-formed XML.\n   *\n   *  The options currently understood are:\n   *\n   *  - root (Boolean): wether or not the root node should be included in the\n   *    output, or just its children. The default `false` is to not include the\n   *    root itself.\n   */\n\n\n  expose.renderJsonML = function (jsonml, options) {\n    options = options || {}; // include the root element in the rendered output?\n\n    options.root = options.root || false;\n    var content = [];\n\n    if (options.root) {\n      content.push(render_tree(jsonml));\n    } else {\n      jsonml.shift(); // get rid of the tag\n\n      if (jsonml.length && _typeof(jsonml[0]) === \"object\" && !(jsonml[0] instanceof Array)) {\n        jsonml.shift(); // get rid of the attributes\n      }\n\n      while (jsonml.length) {\n        content.push(render_tree(jsonml.shift()));\n      }\n    }\n\n    return content.join(\"\\n\\n\");\n  };\n\n  function escapeHTML(text) {\n    return text.replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\").replace(/\"/g, \"&quot;\").replace(/'/g, \"&#39;\");\n  }\n\n  function render_tree(jsonml) {\n    // basic case\n    if (typeof jsonml === \"string\") {\n      return escapeHTML(jsonml);\n    }\n\n    var tag = jsonml.shift(),\n        attributes = {},\n        content = [];\n\n    if (jsonml.length && _typeof(jsonml[0]) === \"object\" && !(jsonml[0] instanceof Array)) {\n      attributes = jsonml.shift();\n    }\n\n    while (jsonml.length) {\n      content.push(render_tree(jsonml.shift()));\n    }\n\n    var tag_attrs = \"\";\n\n    for (var a in attributes) {\n      tag_attrs += \" \" + a + '=\"' + escapeHTML(attributes[a]) + '\"';\n    } // be careful about adding whitespace here for inline elements\n\n\n    if (tag == \"img\" || tag == \"br\" || tag == \"hr\") {\n      return \"<\" + tag + tag_attrs + \"/>\";\n    } else {\n      return \"<\" + tag + tag_attrs + \">\" + content.join(\"\") + \"</\" + tag + \">\";\n    }\n  }\n\n  function convert_tree_to_html(tree, references, options) {\n    var i;\n    options = options || {}; // shallow clone\n\n    var jsonml = tree.slice(0);\n\n    if (typeof options.preprocessTreeNode === \"function\") {\n      jsonml = options.preprocessTreeNode(jsonml, references);\n    } // Clone attributes if they exist\n\n\n    var attrs = extract_attr(jsonml);\n\n    if (attrs) {\n      jsonml[1] = {};\n\n      for (i in attrs) {\n        jsonml[1][i] = attrs[i];\n      }\n\n      attrs = jsonml[1];\n    } // basic case\n\n\n    if (typeof jsonml === \"string\") {\n      return jsonml;\n    } // convert this node\n\n\n    switch (jsonml[0]) {\n      case \"header\":\n        jsonml[0] = \"h\" + jsonml[1].level;\n        delete jsonml[1].level;\n        break;\n\n      case \"bulletlist\":\n        jsonml[0] = \"ul\";\n        break;\n\n      case \"numberlist\":\n        jsonml[0] = \"ol\";\n        break;\n\n      case \"listitem\":\n        jsonml[0] = \"li\";\n        break;\n\n      case \"para\":\n        jsonml[0] = \"p\";\n        break;\n\n      case \"markdown\":\n        jsonml[0] = \"html\";\n        if (attrs) delete attrs.references;\n        break;\n\n      case \"code_block\":\n        jsonml[0] = \"pre\";\n        i = attrs ? 2 : 1;\n        var code = [\"code\"];\n        code.push.apply(code, jsonml.splice(i, jsonml.length - i));\n        jsonml[i] = code;\n        break;\n\n      case \"inlinecode\":\n        jsonml[0] = \"code\";\n        break;\n\n      case \"img\":\n        jsonml[1].src = jsonml[1].href;\n        delete jsonml[1].href;\n        break;\n\n      case \"linebreak\":\n        jsonml[0] = \"br\";\n        break;\n\n      case \"link\":\n        jsonml[0] = \"a\";\n        break;\n\n      case \"link_ref\":\n        jsonml[0] = \"a\"; // grab this ref and clean up the attribute node\n\n        var ref = references[attrs.ref]; // if the reference exists, make the link\n\n        if (ref) {\n          delete attrs.ref; // add in the href and title, if present\n\n          attrs.href = ref.href;\n\n          if (ref.title) {\n            attrs.title = ref.title;\n          } // get rid of the unneeded original text\n\n\n          delete attrs.original;\n        } // the reference doesn't exist, so revert to plain text\n        else {\n            return attrs.original;\n          }\n\n        break;\n\n      case \"img_ref\":\n        jsonml[0] = \"img\"; // grab this ref and clean up the attribute node\n\n        var ref = references[attrs.ref]; // if the reference exists, make the link\n\n        if (ref) {\n          delete attrs.ref; // add in the href and title, if present\n\n          attrs.src = ref.href;\n\n          if (ref.title) {\n            attrs.title = ref.title;\n          } // get rid of the unneeded original text\n\n\n          delete attrs.original;\n        } // the reference doesn't exist, so revert to plain text\n        else {\n            return attrs.original;\n          }\n\n        break;\n    } // convert all the children\n\n\n    i = 1; // deal with the attribute node, if it exists\n\n    if (attrs) {\n      // if there are keys, skip over it\n      for (var key in jsonml[1]) {\n        i = 2;\n        break;\n      } // if there aren't, remove it\n\n\n      if (i === 1) {\n        jsonml.splice(i, 1);\n      }\n    }\n\n    for (; i < jsonml.length; ++i) {\n      jsonml[i] = convert_tree_to_html(jsonml[i], references, options);\n    }\n\n    return jsonml;\n  } // merges adjacent text nodes into a single node\n\n\n  function merge_text_nodes(jsonml) {\n    // skip the tag name and attribute hash\n    var i = extract_attr(jsonml) ? 2 : 1;\n\n    while (i < jsonml.length) {\n      // if it's a string check the next item too\n      if (typeof jsonml[i] === \"string\") {\n        if (i + 1 < jsonml.length && typeof jsonml[i + 1] === \"string\") {\n          // merge the second string into the first and remove it\n          jsonml[i] += jsonml.splice(i + 1, 1)[0];\n        } else {\n          ++i;\n        }\n      } // if it's not a string recurse\n      else {\n          merge_text_nodes(jsonml[i]);\n          ++i;\n        }\n    }\n  }\n})(function () {\n  if (typeof exports === \"undefined\") {\n    window.markdown = {};\n    return window.markdown;\n  } else {\n    return exports;\n  }\n}());","// shim for using process in browser\nvar process = module.exports = {}; // cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n  throw new Error('setTimeout has not been defined');\n}\n\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\n\n(function () {\n  try {\n    if (typeof setTimeout === 'function') {\n      cachedSetTimeout = setTimeout;\n    } else {\n      cachedSetTimeout = defaultSetTimout;\n    }\n  } catch (e) {\n    cachedSetTimeout = defaultSetTimout;\n  }\n\n  try {\n    if (typeof clearTimeout === 'function') {\n      cachedClearTimeout = clearTimeout;\n    } else {\n      cachedClearTimeout = defaultClearTimeout;\n    }\n  } catch (e) {\n    cachedClearTimeout = defaultClearTimeout;\n  }\n})();\n\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  } // if setTimeout wasn't available but was latter defined\n\n\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedSetTimeout(fun, 0);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n      return cachedSetTimeout.call(null, fun, 0);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n      return cachedSetTimeout.call(this, fun, 0);\n    }\n  }\n}\n\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  } // if clearTimeout wasn't available but was latter defined\n\n\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedClearTimeout(marker);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n      return cachedClearTimeout.call(null, marker);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n      return cachedClearTimeout.call(this, marker);\n    }\n  }\n}\n\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n\n  draining = false;\n\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n\n  if (queue.length) {\n    drainQueue();\n  }\n}\n\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n\n    queueIndex = -1;\n    len = queue.length;\n  }\n\n  currentQueue = null;\n  draining = false;\n  runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n  var args = new Array(arguments.length - 1);\n\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n\n  queue.push(new Item(fun, args));\n\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n}; // v8 likes predictible objects\n\n\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\n\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\n\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) {\n  return [];\n};\n\nprocess.binding = function (name) {\n  throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n  return '/';\n};\n\nprocess.chdir = function (dir) {\n  throw new Error('process.chdir is not supported');\n};\n\nprocess.umask = function () {\n  return 0;\n};","import * as MarkdownCls from 'markdown/lib/markdown.js'\n\nconst markdown = {\n  Markdown: MarkdownCls,\n  parse: MarkdownCls.parse,\n  toHTML: MarkdownCls.toHTML,\n  toHTMLTree: MarkdownCls.toHTMLTree,\n  renderJsonML: MarkdownCls.renderJsonML\n}\n\nexport { markdown }\n","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors(obj) {\n  var keys = Object.keys(obj);\n  var descriptors = {};\n\n  for (var i = 0; i < keys.length; i++) {\n    descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n  }\n\n  return descriptors;\n};\n\nvar formatRegExp = /%[sdj%]/g;\n\nexports.format = function (f) {\n  if (!isString(f)) {\n    var objects = [];\n\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function (x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n\n    switch (x) {\n      case '%s':\n        return String(args[i++]);\n\n      case '%d':\n        return Number(args[i++]);\n\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n\n      default:\n        return x;\n    }\n  });\n\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n\n  return str;\n}; // Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\n\n\nexports.deprecate = function (fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  } // Allow for deprecating things in the process of starting up.\n\n\n  if (typeof process === 'undefined') {\n    return function () {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  var warned = false;\n\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n\n      warned = true;\n    }\n\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\nvar debugs = {};\nvar debugEnviron;\n\nexports.debuglog = function (set) {\n  if (isUndefined(debugEnviron)) debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n\n      debugs[set] = function () {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function () {};\n    }\n  }\n\n  return debugs[set];\n};\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n\n/* legacy: obj, showHidden, depth, colors*/\n\n\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  }; // legacy...\n\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  } // set default options\n\n\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\n\nexports.inspect = inspect; // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\n\ninspect.colors = {\n  'bold': [1, 22],\n  'italic': [3, 23],\n  'underline': [4, 24],\n  'inverse': [7, 27],\n  'white': [37, 39],\n  'grey': [90, 39],\n  'black': [30, 39],\n  'blue': [34, 39],\n  'cyan': [36, 39],\n  'green': [32, 39],\n  'magenta': [35, 39],\n  'red': [31, 39],\n  'yellow': [33, 39]\n}; // Don't use 'blue' not visible on cmd.exe\n\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return \"\\x1B[\" + inspect.colors[style][0] + 'm' + str + \"\\x1B[\" + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\nfunction arrayToHash(array) {\n  var hash = {};\n  array.forEach(function (val, idx) {\n    hash[val] = true;\n  });\n  return hash;\n}\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect && value && isFunction(value.inspect) && // Filter out the util module, it's inspect function is special\n  value.inspect !== exports.inspect && // Also filter out any prototype objects using the circular check.\n  !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n\n    return ret;\n  } // Primitive types cannot have properties\n\n\n  var primitive = formatPrimitive(ctx, value);\n\n  if (primitive) {\n    return primitive;\n  } // Look up the keys of the object.\n\n\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  } // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n\n\n  if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  } // Some type of object without properties can be shortcutted.\n\n\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '',\n      array = false,\n      braces = ['{', '}']; // Make Array say that they are Array\n\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  } // Make functions say that they are functions\n\n\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  } // Make RegExps say that they are RegExps\n\n\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  } // Make dates with properties first say the date\n\n\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  } // Make error with message first say the error\n\n\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n  var output;\n\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function (key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n  return reduceToSingleString(output, base, braces);\n}\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');\n\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '').replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n\n  if (isNumber(value)) return ctx.stylize('' + value, 'number');\n  if (isBoolean(value)) return ctx.stylize('' + value, 'boolean'); // For some reason typeof null is \"object\", so special case here.\n\n  if (isNull(value)) return ctx.stylize('null', 'null');\n}\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n\n  keys.forEach(function (key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));\n    }\n  });\n  return output;\n}\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || {\n    value: value[key]\n  };\n\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function (line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function (line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n\n    name = JSON.stringify('' + key);\n\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"').replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function (prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] + (base === '' ? '' : base + '\\n ') + ' ' + output.join(',\\n  ') + ' ' + braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n} // NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\n\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\n\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\n\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\n\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\n\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\n\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return _typeof(arg) === 'symbol';\n}\n\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\n\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return _typeof(arg) === 'object' && arg !== null;\n}\n\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\n\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);\n}\n\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || _typeof(arg) === 'symbol' || // ES6 symbol\n  typeof arg === 'undefined';\n}\n\nexports.isPrimitive = isPrimitive;\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; // 26 Feb 16:19:34\n\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n} // log is just a thin wrapper to console.log that prepends a timestamp\n\n\nexports.log = function () {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\n\n\nexports.inherits = require('inherits');\n\nexports._extend = function (origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n  var keys = Object.keys(add);\n  var i = keys.length;\n\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n  if (typeof original !== 'function') throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn,\n      enumerable: false,\n      writable: false,\n      configurable: true\n    });\n    return fn;\n  }\n\n  function fn() {\n    var promiseResolve, promiseReject;\n    var promise = new Promise(function (resolve, reject) {\n      promiseResolve = resolve;\n      promiseReject = reject;\n    });\n    var args = [];\n\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    args.push(function (err, value) {\n      if (err) {\n        promiseReject(err);\n      } else {\n        promiseResolve(value);\n      }\n    });\n\n    try {\n      original.apply(this, args);\n    } catch (err) {\n      promiseReject(err);\n    }\n\n    return promise;\n  }\n\n  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn,\n    enumerable: false,\n    writable: false,\n    configurable: true\n  });\n  return Object.defineProperties(fn, getOwnPropertyDescriptors(original));\n};\n\nexports.promisify.custom = kCustomPromisifiedSymbol;\n\nfunction callbackifyOnRejected(reason, cb) {\n  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n  // Because `null` is a special error value in callbacks which means \"no error\n  // occurred\", we error-wrap so the callback consumer can distinguish between\n  // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n  if (!reason) {\n    var newReason = new Error('Promise was rejected with a falsy value');\n    newReason.reason = reason;\n    reason = newReason;\n  }\n\n  return cb(reason);\n}\n\nfunction callbackify(original) {\n  if (typeof original !== 'function') {\n    throw new TypeError('The \"original\" argument must be of type Function');\n  } // We DO NOT return the promise as it gives the user a false sense that\n  // the promise is actually somehow related to the callback's execution\n  // and that the callback throwing will reject the promise.\n\n\n  function callbackified() {\n    var args = [];\n\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n\n    var self = this;\n\n    var cb = function cb() {\n      return maybeCb.apply(self, arguments);\n    }; // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n\n\n    original.apply(this, args).then(function (ret) {\n      process.nextTick(cb, null, ret);\n    }, function (rej) {\n      process.nextTick(callbackifyOnRejected, rej, cb);\n    });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified, getOwnPropertyDescriptors(original));\n  return callbackified;\n}\n\nexports.callbackify = callbackify;","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nmodule.exports = function isBuffer(arg) {\n  return arg && _typeof(arg) === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function';\n};","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor;\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor;\n\n    var TempCtor = function TempCtor() {};\n\n    TempCtor.prototype = superCtor.prototype;\n    ctor.prototype = new TempCtor();\n    ctor.prototype.constructor = ctor;\n  };\n}"],"sourceRoot":""}