{"version":3,"sources":["webpack:///./node_modules/unist-util-visit-parents/color.browser.js","webpack:///./node_modules/unist-util-position/index.js","webpack:///./node_modules/trough/wrap.js","webpack:///./node_modules/stringify-entities/lib/encode.js","webpack:///./node_modules/vfile/index.js","webpack:///./node_modules/stringify-entities/lib/util/to-named.js","webpack:///./node_modules/vfile/lib/index.js","webpack:///./node_modules/space-separated-tokens/index.js","webpack:///./node_modules/stringify-entities/lib/constant/has-own-property.js","webpack:///./node_modules/xtend/immutable.js","webpack:///./node_modules/unist-util-generated/index.js","webpack:///./node_modules/stringify-entities/lib/util/to-decimal.js","webpack:///./node_modules/unist-util-is/convert.js","webpack:///./node_modules/unist-util-visit/index.js","webpack:///./node_modules/vfile-message/index.js","webpack:///./node_modules/zwitch/index.js","webpack:///./node_modules/unified/node_modules/is-plain-obj/index.js","webpack:///./node_modules/stringify-entities/lib/util/format-smart.js","webpack:///./node_modules/stringify-entities/index.js","webpack:///./node_modules/stringify-entities/lib/constant/from-char-code.js","webpack:///./node_modules/vfile/lib/core.js","webpack:///./node_modules/vfile/lib/minpath.browser.js","webpack:///./node_modules/unist-util-visit-parents/index.js","webpack:///./node_modules/unist-builder/index.js","webpack:///./node_modules/trough/index.js","webpack:///./node_modules/stringify-entities/lib/escape.js","webpack:///./node_modules/unified/index.js","webpack:///./node_modules/stringify-entities/lib/core.js","webpack:///./node_modules/stringify-entities/lib/index.js","webpack:///./node_modules/stringify-entities/lib/util/to-hexadecimal.js","webpack:///./src/views/About.vue","webpack:///src/views/About.vue","webpack:///./src/views/About.vue?269b","webpack:///./src/views/About.vue?1006","webpack:///./node_modules/vfile/lib/minproc.browser.js","webpack:///./node_modules/unist-util-stringify-position/index.js","webpack:///./node_modules/stringify-entities/lib/constant/characters.js"],"names":["identity","d","module","exports","start","factory","end","position","node","type","point","displayName","line","column","offset","isNaN","slice","wrap","fn","callback","invoked","wrapped","result","params","call","arguments","length","push","done","apply","error","then","Error","value","xtend","core","smart","encode","options","format","toNamed","legacy","characters","fromCharCode","own","dangerous","code","next","omit","attribute","name","character","indexOf","test","VMessage","VFile","message","reason","origin","this","path","file","fatal","messages","fail","info","prototype","parse","stringify","empty","space","whiteSpace","input","String","trim","split","values","join","hasOwnProperty","extend","Object","target","i","source","key","generated","toDecimalReference","convert","ok","typeFactory","anyFactory","allFactory","all","tests","checks","index","any","Boolean","visit","visitParents","CONTINUE","SKIP","EXIT","tree","visitor","reverse","overload","parents","parent","children","VMessagePrototype","proto","parts","range","location","parseOrigin","stack","ruleId","noop","Function","settings","one","invalid","handlers","unknown","toString","getPrototypeOf","formatPretty","toHexadecimal","toDecimal","named","numeric","decimal","useNamedReferences","useShortestReferences","omitOptionalSemicolons","p","proc","buffer","order","prop","contents","data","history","cwd","getPath","setPath","assertNonEmpty","getDirname","dirname","undefined","setDirname","assertPath","basename","getBasename","setBasename","assertPart","getExtname","extname","setExtname","charCodeAt","stem","getStem","setStem","encoding","part","sep","defineProperty","get","set","ext","firstNonSlashEnd","seenNonSlash","extIndex","TypeError","unmatchedSlash","startDot","startPart","preDotState","joined","normalize","absolute","normalizeString","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","lastIndexOf","JSON","color","step","is","tagName","subresult","grandparents","concat","toResult","u","props","Array","isArray","assign","trough","fns","middleware","run","use","err","pos","escape","escapeOnly","bail","plain","vfile","unified","freeze","pipeline","pipelineParse","pipelineRun","pipelineStringify","ctx","frozen","attachers","transformers","namespace","freezeIndex","processor","runSync","process","processSync","destination","transformer","Infinity","assertUnfrozen","addPlugin","addList","addPreset","plugins","add","plugin","entry","find","doc","Parser","assertParser","newable","cb","assertNode","Promise","executor","resolve","reject","complete","assertDone","Compiler","assertCompiler","compile","keys","asyncName","replace","subset","charactersToExpression","basic","surrogate","pair","groups","RegExp","toHexReference","toUpperCase","attrs","directives","_vm","aboutLoading","staticClass","domProps","staticRenderFns","aboutURL","VUE_APP_ABOUT_URL","beforeMount","loadAbout","methods","$store","dispatch","GET_ABOUT","computed","mapState","aboutMarkdown","about","defaultAbout","errorText","aboutError","aboutText","remark","html","component","entities"],"mappings":"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","file":"static/js/about~31ecd969.10cb2ff0.js","sourcesContent":["module.exports = identity\nfunction identity(d) {\n  return d\n}\n","'use strict'\n\nvar start = factory('start')\nvar end = factory('end')\n\nmodule.exports = position\n\nposition.start = start\nposition.end = end\n\nfunction position(node) {\n  return {start: start(node), end: end(node)}\n}\n\nfunction factory(type) {\n  point.displayName = type\n\n  return point\n\n  function point(node) {\n    var point = (node && node.position && node.position[type]) || {}\n\n    return {\n      line: point.line || null,\n      column: point.column || null,\n      offset: isNaN(point.offset) ? null : point.offset\n    }\n  }\n}\n","'use strict'\n\nvar slice = [].slice\n\nmodule.exports = wrap\n\n// Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\nfunction wrap(fn, callback) {\n  var invoked\n\n  return wrapped\n\n  function wrapped() {\n    var params = slice.call(arguments, 0)\n    var callback = fn.length > params.length\n    var result\n\n    if (callback) {\n      params.push(done)\n    }\n\n    try {\n      result = fn.apply(null, params)\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We’re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error\n      }\n\n      return done(error)\n    }\n\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  // Invoke `next`, only once.\n  function done() {\n    if (!invoked) {\n      invoked = true\n\n      callback.apply(null, arguments)\n    }\n  }\n\n  // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n  function then(value) {\n    done(null, value)\n  }\n}\n","'use strict'\n\nvar xtend = require('xtend')\nvar core = require('./core')\nvar smart = require('./util/format-smart')\n\nmodule.exports = encode\n\n// Encode special characters in `value`.\nfunction encode(value, options) {\n  // Note: Switch to `Object.assign` next major.\n  return core(value, xtend(options, {format: smart}))\n}\n","'use strict'\n\nmodule.exports = require('./lib')\n","module.exports = toNamed\n\nvar legacy = require('character-entities-legacy')\nvar characters = require('../constant/characters')\nvar fromCharCode = require('../constant/from-char-code')\nvar own = require('../constant/has-own-property')\nvar dangerous = require('../constant/dangerous.json')\n\n// Transform `code` into a named character reference.\nfunction toNamed(code, next, omit, attribute) {\n  var character = fromCharCode(code)\n  var name\n  var value\n\n  if (own.call(characters, character)) {\n    name = characters[character]\n    value = '&' + name\n\n    if (\n      omit &&\n      own.call(legacy, name) &&\n      dangerous.indexOf(name) === -1 &&\n      (!attribute ||\n        (next && next !== 61 /* `=` */ && /[^\\da-z]/i.test(fromCharCode(next))))\n    ) {\n      return value\n    }\n\n    return value + ';'\n  }\n\n  return ''\n}\n","'use strict'\n\nvar VMessage = require('vfile-message')\nvar VFile = require('./core.js')\n\nmodule.exports = VFile\n\nVFile.prototype.message = message\nVFile.prototype.info = info\nVFile.prototype.fail = fail\n\n// Create a message with `reason` at `position`.\n// When an error is passed in as `reason`, copies the stack.\nfunction message(reason, position, origin) {\n  var message = new VMessage(reason, position, origin)\n\n  if (this.path) {\n    message.name = this.path + ':' + message.name\n    message.file = this.path\n  }\n\n  message.fatal = false\n\n  this.messages.push(message)\n\n  return message\n}\n\n// Fail: creates a vmessage, associates it with the file, and throws it.\nfunction fail() {\n  var message = this.message.apply(this, arguments)\n\n  message.fatal = true\n\n  throw message\n}\n\n// Info: creates a vmessage, associates it with the file, and marks the fatality\n// as null.\nfunction info() {\n  var message = this.message.apply(this, arguments)\n\n  message.fatal = null\n\n  return message\n}\n","'use strict'\n\nexports.parse = parse\nexports.stringify = stringify\n\nvar empty = ''\nvar space = ' '\nvar whiteSpace = /[ \\t\\n\\r\\f]+/g\n\nfunction parse(value) {\n  var input = String(value || empty).trim()\n  return input === empty ? [] : input.split(whiteSpace)\n}\n\nfunction stringify(values) {\n  return values.join(space).trim()\n}\n","module.exports = {}.hasOwnProperty\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","'use strict'\n\nmodule.exports = generated\n\nfunction generated(node) {\n  return (\n    !node ||\n    !node.position ||\n    !node.position.start ||\n    !node.position.start.line ||\n    !node.position.start.column ||\n    !node.position.end ||\n    !node.position.end.line ||\n    !node.position.end.column\n  )\n}\n","module.exports = toDecimalReference\n\nvar fromCharCode = require('../constant/from-char-code')\n\n// Transform `code` into a decimal character reference.\nfunction toDecimalReference(code, next, omit) {\n  var value = '&#' + String(code)\n  return omit && next && !/\\d/.test(fromCharCode(next)) ? value : value + ';'\n}\n","'use strict'\n\nmodule.exports = convert\n\nfunction convert(test) {\n  if (test == null) {\n    return ok\n  }\n\n  if (typeof test === 'string') {\n    return typeFactory(test)\n  }\n\n  if (typeof test === 'object') {\n    return 'length' in test ? anyFactory(test) : allFactory(test)\n  }\n\n  if (typeof test === 'function') {\n    return test\n  }\n\n  throw new Error('Expected function, string, or object as test')\n}\n\n// Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\nfunction allFactory(test) {\n  return all\n\n  function all(node) {\n    var key\n\n    for (key in test) {\n      if (node[key] !== test[key]) return false\n    }\n\n    return true\n  }\n}\n\nfunction anyFactory(tests) {\n  var checks = []\n  var index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return any\n\n  function any() {\n    var index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, arguments)) {\n        return true\n      }\n    }\n\n    return false\n  }\n}\n\n// Utility to convert a string into a function which checks a given node’s type\n// for said string.\nfunction typeFactory(test) {\n  return type\n\n  function type(node) {\n    return Boolean(node && node.type === test)\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true\n}\n","'use strict'\n\nmodule.exports = visit\n\nvar visitParents = require('unist-util-visit-parents')\n\nvar CONTINUE = visitParents.CONTINUE\nvar SKIP = visitParents.SKIP\nvar EXIT = visitParents.EXIT\n\nvisit.CONTINUE = CONTINUE\nvisit.SKIP = SKIP\nvisit.EXIT = EXIT\n\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    visitor = test\n    test = null\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1]\n    var index = parent ? parent.children.indexOf(node) : null\n    return visitor(node, index, parent)\n  }\n}\n","'use strict'\n\nvar stringify = require('unist-util-stringify-position')\n\nmodule.exports = VMessage\n\n// Inherit from `Error#`.\nfunction VMessagePrototype() {}\nVMessagePrototype.prototype = Error.prototype\nVMessage.prototype = new VMessagePrototype()\n\n// Message properties.\nvar proto = VMessage.prototype\n\nproto.file = ''\nproto.name = ''\nproto.reason = ''\nproto.message = ''\nproto.stack = ''\nproto.fatal = null\nproto.column = null\nproto.line = null\n\n// Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\nfunction VMessage(reason, position, origin) {\n  var parts\n  var range\n  var location\n\n  if (typeof position === 'string') {\n    origin = position\n    position = null\n  }\n\n  parts = parseOrigin(origin)\n  range = stringify(position) || '1:1'\n\n  location = {\n    start: {line: null, column: null},\n    end: {line: null, column: null}\n  }\n\n  // Node.\n  if (position && position.position) {\n    position = position.position\n  }\n\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position\n      position = position.start\n    } else {\n      // Point.\n      location.start = position\n    }\n  }\n\n  if (reason.stack) {\n    this.stack = reason.stack\n    reason = reason.message\n  }\n\n  this.message = reason\n  this.name = range\n  this.reason = reason\n  this.line = position ? position.line : null\n  this.column = position ? position.column : null\n  this.location = location\n  this.source = parts[0]\n  this.ruleId = parts[1]\n}\n\nfunction parseOrigin(origin) {\n  var result = [null, null]\n  var index\n\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':')\n\n    if (index === -1) {\n      result[1] = origin\n    } else {\n      result[0] = origin.slice(0, index)\n      result[1] = origin.slice(index + 1)\n    }\n  }\n\n  return result\n}\n","'use strict'\n\nmodule.exports = factory\n\nvar noop = Function.prototype\nvar own = {}.hasOwnProperty\n\n// Handle values based on a property.\nfunction factory(key, options) {\n  var settings = options || {}\n\n  function one(value) {\n    var fn = one.invalid\n    var handlers = one.handlers\n\n    if (value && own.call(value, key)) {\n      fn = own.call(handlers, value[key]) ? handlers[value[key]] : one.unknown\n    }\n\n    return (fn || noop).apply(this, arguments)\n  }\n\n  one.handlers = settings.handlers || {}\n  one.invalid = settings.invalid\n  one.unknown = settings.unknown\n\n  return one\n}\n","'use strict';\n\nmodule.exports = value => {\n\tif (Object.prototype.toString.call(value) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn prototype === null || prototype === Object.prototype;\n};\n","module.exports = formatPretty\n\nvar toHexadecimal = require('./to-hexadecimal')\nvar toDecimal = require('./to-decimal')\nvar toNamed = require('./to-named')\n\n// Encode `character` according to `options`.\nfunction formatPretty(code, next, options) {\n  var named\n  var numeric\n  var decimal\n\n  if (options.useNamedReferences || options.useShortestReferences) {\n    named = toNamed(\n      code,\n      next,\n      options.omitOptionalSemicolons,\n      options.attribute\n    )\n  }\n\n  if (options.useShortestReferences || !named) {\n    numeric = toHexadecimal(code, next, options.omitOptionalSemicolons)\n\n    // Use the shortest numeric reference when requested.\n    // A simple algorithm would use decimal for all code points under 100, as\n    // those are shorter than hexadecimal:\n    //\n    // * `&#99;` vs `&#x63;` (decimal shorter)\n    // * `&#100;` vs `&#x64;` (equal)\n    //\n    // However, because we take `next` into consideration when `omit` is used,\n    // And it would be possible that decimals are shorter on bigger values as\n    // well if `next` is hexadecimal but not decimal, we instead compare both.\n    if (options.useShortestReferences) {\n      decimal = toDecimal(code, next, options.omitOptionalSemicolons)\n\n      if (decimal.length < numeric.length) {\n        numeric = decimal\n      }\n    }\n  }\n\n  return named &&\n    (!options.useShortestReferences || named.length < numeric.length)\n    ? named\n    : numeric\n}\n","'use strict'\n\nmodule.exports = require('./lib')\n","module.exports = String.fromCharCode\n","'use strict'\n\nvar p = require('./minpath')\nvar proc = require('./minproc')\nvar buffer = require('is-buffer')\n\nmodule.exports = VFile\n\nvar own = {}.hasOwnProperty\n\n// Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nVFile.prototype.toString = toString\n\n// Access full path (`~/index.min.js`).\nObject.defineProperty(VFile.prototype, 'path', {get: getPath, set: setPath})\n\n// Access parent path (`~`).\nObject.defineProperty(VFile.prototype, 'dirname', {\n  get: getDirname,\n  set: setDirname\n})\n\n// Access basename (`index.min.js`).\nObject.defineProperty(VFile.prototype, 'basename', {\n  get: getBasename,\n  set: setBasename\n})\n\n// Access extname (`.js`).\nObject.defineProperty(VFile.prototype, 'extname', {\n  get: getExtname,\n  set: setExtname\n})\n\n// Access stem (`index.min`).\nObject.defineProperty(VFile.prototype, 'stem', {get: getStem, set: setStem})\n\n// Construct a new file.\nfunction VFile(options) {\n  var prop\n  var index\n\n  if (!options) {\n    options = {}\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {contents: options}\n  } else if ('message' in options && 'messages' in options) {\n    return options\n  }\n\n  if (!(this instanceof VFile)) {\n    return new VFile(options)\n  }\n\n  this.data = {}\n  this.messages = []\n  this.history = []\n  this.cwd = proc.cwd()\n\n  // Set path related properties in the correct order.\n  index = -1\n\n  while (++index < order.length) {\n    prop = order[index]\n\n    if (own.call(options, prop)) {\n      this[prop] = options[prop]\n    }\n  }\n\n  // Set non-path related properties.\n  for (prop in options) {\n    if (order.indexOf(prop) < 0) {\n      this[prop] = options[prop]\n    }\n  }\n}\n\nfunction getPath() {\n  return this.history[this.history.length - 1]\n}\n\nfunction setPath(path) {\n  assertNonEmpty(path, 'path')\n\n  if (this.path !== path) {\n    this.history.push(path)\n  }\n}\n\nfunction getDirname() {\n  return typeof this.path === 'string' ? p.dirname(this.path) : undefined\n}\n\nfunction setDirname(dirname) {\n  assertPath(this.path, 'dirname')\n  this.path = p.join(dirname || '', this.basename)\n}\n\nfunction getBasename() {\n  return typeof this.path === 'string' ? p.basename(this.path) : undefined\n}\n\nfunction setBasename(basename) {\n  assertNonEmpty(basename, 'basename')\n  assertPart(basename, 'basename')\n  this.path = p.join(this.dirname || '', basename)\n}\n\nfunction getExtname() {\n  return typeof this.path === 'string' ? p.extname(this.path) : undefined\n}\n\nfunction setExtname(extname) {\n  assertPart(extname, 'extname')\n  assertPath(this.path, 'extname')\n\n  if (extname) {\n    if (extname.charCodeAt(0) !== 46 /* `.` */) {\n      throw new Error('`extname` must start with `.`')\n    }\n\n    if (extname.indexOf('.', 1) > -1) {\n      throw new Error('`extname` cannot contain multiple dots')\n    }\n  }\n\n  this.path = p.join(this.dirname, this.stem + (extname || ''))\n}\n\nfunction getStem() {\n  return typeof this.path === 'string'\n    ? p.basename(this.path, this.extname)\n    : undefined\n}\n\nfunction setStem(stem) {\n  assertNonEmpty(stem, 'stem')\n  assertPart(stem, 'stem')\n  this.path = p.join(this.dirname || '', stem + (this.extname || ''))\n}\n\n// Get the value of the file.\nfunction toString(encoding) {\n  return (this.contents || '').toString(encoding)\n}\n\n// Assert that `part` is not a path (i.e., does not contain `p.sep`).\nfunction assertPart(part, name) {\n  if (part && part.indexOf(p.sep) > -1) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + p.sep + '`'\n    )\n  }\n}\n\n// Assert that `part` is not empty.\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n// Assert `path` exists.\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n","'use strict'\n\n// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\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.\n\nexports.basename = basename\nexports.dirname = dirname\nexports.extname = extname\nexports.join = join\nexports.sep = '/'\n\nfunction basename(path, ext) {\n  var start = 0\n  var end = -1\n  var index\n  var firstNonSlashEnd\n  var seenNonSlash\n  var extIndex\n\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  index = path.length\n\n  if (ext === undefined || !ext.length || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1\n          break\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true\n        end = index + 1\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end)\n  }\n\n  if (ext === path) {\n    return ''\n  }\n\n  firstNonSlashEnd = -1\n  extIndex = ext.length - 1\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1\n        break\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true\n        firstNonSlashEnd = index + 1\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\nfunction dirname(path) {\n  var end\n  var unmatchedSlash\n  var index\n\n  assertPath(path)\n\n  if (!path.length) {\n    return '.'\n  }\n\n  end = -1\n  index = path.length\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      if (unmatchedSlash) {\n        end = index\n        break\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true\n    }\n  }\n\n  return end < 0\n    ? path.charCodeAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n    ? '//'\n    : path.slice(0, end)\n}\n\nfunction extname(path) {\n  var startDot = -1\n  var startPart = 0\n  var end = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  var preDotState = 0\n  var unmatchedSlash\n  var code\n  var index\n\n  assertPath(path)\n\n  index = path.length\n\n  while (index--) {\n    code = path.charCodeAt(index)\n\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1\n        break\n      }\n\n      continue\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true\n      end = index + 1\n    }\n\n    if (code === 46 /* `.` */) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index\n      } else if (preDotState !== 1) {\n        preDotState = 1\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1\n    }\n  }\n\n  if (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\nfunction join() {\n  var index = -1\n  var joined\n\n  while (++index < arguments.length) {\n    assertPath(arguments[index])\n\n    if (arguments[index]) {\n      joined =\n        joined === undefined\n          ? arguments[index]\n          : joined + '/' + arguments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n  var absolute\n  var value\n\n  assertPath(path)\n\n  absolute = path.charCodeAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  value = normalizeString(path, !absolute)\n\n  if (!value.length && !absolute) {\n    value = '.'\n  }\n\n  if (value.length && path.charCodeAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n// Resolve `.` and `..` elements in a path with directory names.\nfunction normalizeString(path, allowAboveRoot) {\n  var result = ''\n  var lastSegmentLength = 0\n  var lastSlash = -1\n  var dots = 0\n  var index = -1\n  var code\n  var lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n          result.charCodeAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\n\n            /* istanbul ignore else - No clue how to cover it. */\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = ''\n                lastSegmentLength = 0\n              } else {\n                result = result.slice(0, lastSlashIndex)\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n              }\n\n              lastSlash = index\n              dots = 0\n              continue\n            }\n          } else if (result.length) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length) {\n          result += '/' + path.slice(lastSlash + 1, index)\n        } else {\n          result = path.slice(lastSlash + 1, index)\n        }\n\n        lastSegmentLength = index - lastSlash - 1\n      }\n\n      lastSlash = index\n      dots = 0\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n","'use strict'\n\nmodule.exports = visitParents\n\nvar convert = require('unist-util-is/convert')\nvar color = require('./color')\n\nvar CONTINUE = true\nvar SKIP = 'skip'\nvar EXIT = false\n\nvisitParents.CONTINUE = CONTINUE\nvisitParents.SKIP = SKIP\nvisitParents.EXIT = EXIT\n\nfunction visitParents(tree, test, visitor, reverse) {\n  var step\n  var is\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    visitor = test\n    test = null\n  }\n\n  is = convert(test)\n  step = reverse ? -1 : 1\n\n  factory(tree, null, [])()\n\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {}\n    var name\n\n    if (typeof value.type === 'string') {\n      name =\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : typeof value.name === 'string'\n          ? value.name\n          : undefined\n\n      visit.displayName =\n        'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')'\n    }\n\n    return visit\n\n    function visit() {\n      var grandparents = parents.concat(node)\n      var result = []\n      var subresult\n      var offset\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step\n\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)()\n\n          if (subresult[0] === EXIT) {\n            return subresult\n          }\n\n          offset =\n            typeof subresult[1] === 'number' ? subresult[1] : offset + step\n        }\n      }\n\n      return result\n    }\n  }\n}\n\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return [value]\n}\n","'use strict'\n\nmodule.exports = u\n\nfunction u(type, props, value) {\n  var node\n\n  if (\n    (value === null || value === undefined) &&\n    (typeof props !== 'object' || Array.isArray(props))\n  ) {\n    value = props\n    props = {}\n  }\n\n  node = Object.assign({type: String(type)}, props)\n\n  if (Array.isArray(value)) {\n    node.children = value\n  } else if (value !== null && value !== undefined) {\n    node.value = String(value)\n  }\n\n  return node\n}\n","'use strict'\n\nvar wrap = require('./wrap.js')\n\nmodule.exports = trough\n\ntrough.wrap = wrap\n\nvar slice = [].slice\n\n// Create new middleware.\nfunction trough() {\n  var fns = []\n  var middleware = {}\n\n  middleware.run = run\n  middleware.use = use\n\n  return middleware\n\n  // Run `fns`.  Last argument must be a completion handler.\n  function run() {\n    var index = -1\n    var input = slice.call(arguments, 0, -1)\n    var done = arguments[arguments.length - 1]\n\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done)\n    }\n\n    next.apply(null, [null].concat(input))\n\n    // Run the next `fn`, if any.\n    function next(err) {\n      var fn = fns[++index]\n      var params = slice.call(arguments, 0)\n      var values = params.slice(1)\n      var length = input.length\n      var pos = -1\n\n      if (err) {\n        done(err)\n        return\n      }\n\n      // Copy non-nully input into values.\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos]\n        }\n      }\n\n      input = values\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next).apply(null, input)\n      } else {\n        done.apply(null, [null].concat(input))\n      }\n    }\n  }\n\n  // Add `fn` to the list.\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn)\n    }\n\n    fns.push(fn)\n\n    return middleware\n  }\n}\n","'use strict'\n\nvar core = require('./core')\nvar smart = require('./util/format-smart')\n\nmodule.exports = escape\n\n// Shortcut to escape special characters in HTML.\nfunction escape(value) {\n  return core(value, {\n    escapeOnly: true,\n    useNamedReferences: true,\n    format: smart\n  })\n}\n","'use strict'\n\nvar bail = require('bail')\nvar buffer = require('is-buffer')\nvar extend = require('extend')\nvar plain = require('is-plain-obj')\nvar trough = require('trough')\nvar vfile = require('vfile')\n\n// Expose a frozen processor.\nmodule.exports = unified().freeze()\n\nvar slice = [].slice\nvar own = {}.hasOwnProperty\n\n// Process pipeline.\nvar pipeline = trough()\n  .use(pipelineParse)\n  .use(pipelineRun)\n  .use(pipelineStringify)\n\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file)\n}\n\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done)\n\n  function done(error, tree, file) {\n    if (error) {\n      next(error)\n    } else {\n      ctx.tree = tree\n      ctx.file = file\n      next()\n    }\n  }\n}\n\nfunction pipelineStringify(p, ctx) {\n  var result = p.stringify(ctx.tree, ctx.file)\n\n  if (result === undefined || result === null) {\n    // Empty.\n  } else if (typeof result === 'string' || buffer(result)) {\n    if ('value' in ctx.file) {\n      ctx.file.value = result\n    }\n\n    ctx.file.contents = result\n  } else {\n    ctx.file.result = result\n  }\n}\n\n// Function to create the first processor.\nfunction unified() {\n  var attachers = []\n  var transformers = trough()\n  var namespace = {}\n  var freezeIndex = -1\n  var frozen\n\n  // Data management.\n  processor.data = data\n\n  // Lock.\n  processor.freeze = freeze\n\n  // Plugins.\n  processor.attachers = attachers\n  processor.use = use\n\n  // API.\n  processor.parse = parse\n  processor.stringify = stringify\n  processor.run = run\n  processor.runSync = runSync\n  processor.process = process\n  processor.processSync = processSync\n\n  // Expose.\n  return processor\n\n  // Create a new processor based on the processor in the current scope.\n  function processor() {\n    var destination = unified()\n    var index = -1\n\n    while (++index < attachers.length) {\n      destination.use.apply(null, attachers[index])\n    }\n\n    destination.data(extend(true, {}, namespace))\n\n    return destination\n  }\n\n  // Freeze: used to signal a processor that has finished configuration.\n  //\n  // For example, take unified itself: it’s frozen.\n  // Plugins should not be added to it.\n  // Rather, it should be extended, by invoking it, before modifying it.\n  //\n  // In essence, always invoke this when exporting a processor.\n  function freeze() {\n    var values\n    var transformer\n\n    if (frozen) {\n      return processor\n    }\n\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex]\n\n      if (values[1] === false) {\n        continue\n      }\n\n      if (values[1] === true) {\n        values[1] = undefined\n      }\n\n      transformer = values[0].apply(processor, values.slice(1))\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer)\n      }\n    }\n\n    frozen = true\n    freezeIndex = Infinity\n\n    return processor\n  }\n\n  // Data management.\n  // Getter / setter for processor-specific informtion.\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen)\n        namespace[key] = value\n        return processor\n      }\n\n      // Get `key`.\n      return (own.call(namespace, key) && namespace[key]) || null\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', frozen)\n      namespace = key\n      return processor\n    }\n\n    // Get space.\n    return namespace\n  }\n\n  // Plugin management.\n  //\n  // Pass it:\n  // *   an attacher and options,\n  // *   a preset,\n  // *   a list of presets, attachers, and arguments (list of attachers and\n  //     options).\n  function use(value) {\n    var settings\n\n    assertUnfrozen('use', frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments)\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`')\n    }\n\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings)\n    }\n\n    return processor\n\n    function addPreset(result) {\n      addList(result.plugins)\n\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings)\n      }\n    }\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value)\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    function addList(plugins) {\n      var index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        while (++index < plugins.length) {\n          add(plugins[index])\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    function addPlugin(plugin, value) {\n      var entry = find(plugin)\n\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(true, entry[1], value)\n        }\n\n        entry[1] = value\n      } else {\n        attachers.push(slice.call(arguments))\n      }\n    }\n  }\n\n  function find(plugin) {\n    var index = -1\n\n    while (++index < attachers.length) {\n      if (attachers[index][0] === plugin) {\n        return attachers[index]\n      }\n    }\n  }\n\n  // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor.\n  function parse(doc) {\n    var file = vfile(doc)\n    var Parser\n\n    freeze()\n    Parser = processor.Parser\n    assertParser('parse', Parser)\n\n    if (newable(Parser, 'parse')) {\n      return new Parser(String(file), file).parse()\n    }\n\n    return Parser(String(file), file) // eslint-disable-line new-cap\n  }\n\n  // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), async.\n  function run(node, file, cb) {\n    assertNode(node)\n    freeze()\n\n    if (!cb && typeof file === 'function') {\n      cb = file\n      file = null\n    }\n\n    if (!cb) {\n      return new Promise(executor)\n    }\n\n    executor(null, cb)\n\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done)\n\n      function done(error, tree, file) {\n        tree = tree || node\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(tree)\n        } else {\n          cb(null, tree, file)\n        }\n      }\n    }\n  }\n\n  // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), sync.\n  function runSync(node, file) {\n    var result\n    var complete\n\n    run(node, file, done)\n\n    assertDone('runSync', 'run', complete)\n\n    return result\n\n    function done(error, tree) {\n      complete = true\n      result = tree\n      bail(error)\n    }\n  }\n\n  // Stringify a unist node representation of a file (in string or vfile\n  // representation) into a string using the `Compiler` on the processor.\n  function stringify(node, doc) {\n    var file = vfile(doc)\n    var Compiler\n\n    freeze()\n    Compiler = processor.Compiler\n    assertCompiler('stringify', Compiler)\n    assertNode(node)\n\n    if (newable(Compiler, 'compile')) {\n      return new Compiler(node, file).compile()\n    }\n\n    return Compiler(node, file) // eslint-disable-line new-cap\n  }\n\n  // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor, then run transforms on that node, and\n  // compile the resulting node using the `Compiler` on the processor, and\n  // store that result on the vfile.\n  function process(doc, cb) {\n    freeze()\n    assertParser('process', processor.Parser)\n    assertCompiler('process', processor.Compiler)\n\n    if (!cb) {\n      return new Promise(executor)\n    }\n\n    executor(null, cb)\n\n    function executor(resolve, reject) {\n      var file = vfile(doc)\n\n      pipeline.run(processor, {file: file}, done)\n\n      function done(error) {\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          cb(null, file)\n        }\n      }\n    }\n  }\n\n  // Process the given document (in string or vfile representation), sync.\n  function processSync(doc) {\n    var file\n    var complete\n\n    freeze()\n    assertParser('processSync', processor.Parser)\n    assertCompiler('processSync', processor.Compiler)\n    file = vfile(doc)\n\n    process(file, done)\n\n    assertDone('processSync', 'process', complete)\n\n    return file\n\n    function done(error) {\n      complete = true\n      bail(error)\n    }\n  }\n}\n\n// Check if `value` is a constructor.\nfunction newable(value, name) {\n  return (\n    typeof value === 'function' &&\n    value.prototype &&\n    // A function with keys in its prototype is probably a constructor.\n    // Classes’ prototype methods are not enumerable, so we check if some value\n    // exists in the prototype.\n    (keys(value.prototype) || name in value.prototype)\n  )\n}\n\n// Check if `value` is an object with keys.\nfunction keys(value) {\n  var key\n  for (key in value) {\n    return true\n  }\n\n  return false\n}\n\n// Assert a parser is available.\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`')\n  }\n}\n\n// Assert a compiler is available.\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`')\n  }\n}\n\n// Assert the processor is not frozen.\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot invoke `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n// Assert `node` is a unist node.\nfunction assertNode(node) {\n  if (!node || typeof node.type !== 'string') {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n}\n\n// Assert that `complete` is `true`.\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n","'use strict'\n\nmodule.exports = encode\n\n// Encode special characters in `value`.\nfunction encode(value, options) {\n  value = value.replace(\n    options.subset ? charactersToExpression(options.subset) : /[\"&'<>`]/g,\n    basic\n  )\n\n  if (options.subset || options.escapeOnly) {\n    return value\n  }\n\n  return (\n    value\n      // Surrogate pairs.\n      .replace(/[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g, surrogate)\n      // BMP control characters (C0 except for LF, CR, SP; DEL; and some more\n      // non-ASCII ones).\n      .replace(\n        // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape\n        /[\\x01-\\t\\v\\f\\x0E-\\x1F\\x7F\\x81\\x8D\\x8F\\x90\\x9D\\xA0-\\uFFFF]/g,\n        basic\n      )\n  )\n\n  function surrogate(pair, index, all) {\n    return options.format(\n      (pair.charCodeAt(0) - 0xd800) * 0x400 +\n        pair.charCodeAt(1) -\n        0xdc00 +\n        0x10000,\n      all.charCodeAt(index + 2),\n      options\n    )\n  }\n\n  function basic(character, index, all) {\n    return options.format(\n      character.charCodeAt(0),\n      all.charCodeAt(index + 1),\n      options\n    )\n  }\n}\n\nfunction charactersToExpression(subset) {\n  var groups = []\n  var index = -1\n\n  while (++index < subset.length) {\n    groups.push(subset[index].replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&'))\n  }\n\n  return new RegExp('(?:' + groups.join('|') + ')', 'g')\n}\n","'use strict'\n\nvar encode = require('./encode')\nvar escape = require('./escape')\n\nmodule.exports = encode\nencode.escape = escape\n","module.exports = toHexReference\n\nvar fromCharCode = require('../constant/from-char-code')\n\n// Transform `code` into a hexadecimal character reference.\nfunction toHexReference(code, next, omit) {\n  var value = '&#x' + code.toString(16).toUpperCase()\n  return omit && next && !/[\\dA-Fa-f]/.test(fromCharCode(next))\n    ? value\n    : value + ';'\n}\n","var render = function render(){var _vm=this,_c=_vm._self._c;return _c('v-container',{attrs:{\"fluid\":\"\"}},[_c('v-row',[_c('v-col',{directives:[{name:\"show\",rawName:\"v-show\",value:(_vm.aboutLoading),expression:\"aboutLoading\"}],staticClass:\"pt-5\",attrs:{\"cols\":\"12\"}},[_vm._v(\" Loading about information... \")]),(!_vm.aboutLoading)?_c('v-col',{staticClass:\"pt-5\",attrs:{\"cols\":\"12\"},domProps:{\"innerHTML\":_vm._s(_vm.aboutText)}}):_vm._e(),(!_vm.aboutLoading && _vm.aboutError)?_c('v-col',{staticClass:\"pt-5\",attrs:{\"cols\":\"12\"}},[_c('NotificationCard',{attrs:{\"title\":\"About Not Loaded!\",\"message\":_vm.errorText}})],1):_vm._e()],1)],1)\n}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","<template>\r\n  <v-container fluid>\r\n    <v-row>\r\n      <v-col v-show=\"aboutLoading\" class=\"pt-5\" cols=\"12\">\r\n        Loading about information...\r\n      </v-col>\r\n\r\n      <v-col v-if=\"!aboutLoading\" cols=\"12\" class=\"pt-5\" v-html=\"aboutText\">\r\n      </v-col>\r\n\r\n      <v-col v-if=\"!aboutLoading && aboutError\" cols=\"12\" class=\"pt-5\">\r\n        <NotificationCard title=\"About Not Loaded!\" :message=\"errorText\" />\r\n      </v-col>\r\n    </v-row>\r\n  </v-container>\r\n</template>\r\n\r\n<script>\r\nimport { mapState } from 'vuex';\r\n\r\nimport { GET_ABOUT } from '@/store/mutationsConsts';\r\n\r\nimport remark from 'remark';\r\nimport html from 'remark-html';\r\n\r\nconst aboutURL = process.env.VUE_APP_ABOUT_URL;\r\n\r\nexport default {\r\n  name: 'About',\r\n  beforeMount() {\r\n    if (aboutURL) {\r\n      this.loadAbout();\r\n    }\r\n  },\r\n  methods: {\r\n    loadAbout() {\r\n      this.$store.dispatch(GET_ABOUT, aboutURL);\r\n    },\r\n  },\r\n  computed: {\r\n    ...mapState(['about', 'aboutLoading', 'aboutError']),\r\n    aboutMarkdown() {\r\n      return this.about || this.defaultAbout;\r\n    },\r\n    errorText() {\r\n      return `${this.aboutError}. If this error is consistent please report in on the Github page of the project.`;\r\n    },\r\n    aboutText() {\r\n      return remark().use(html).processSync(this.aboutMarkdown).toString();\r\n    },\r\n  },\r\n  data: () => ({\r\n    defaultAbout: `\r\n# About the S3 Browsing Web Frontend\n\nWelcome to the S3 Browsing Web Frontend! This application provides a convenient web interface to browse and download files from an S3 backend, arranged in an easy-to-navigate file tree structure.\n\n## Features of S3 Web Frontend\n- **Search Functionality**: Easily search through directories and files.\n- **Efficient Loading**: Contents of folders are lazy-loaded to enhance initial rendering times.\n- **Navigation**: Utilize the prefix query parameter to navigate directly to a specific folder.\n- **Accessibility**: Designed to access public S3 Buckets effectively.\n\n## Contact\n\nFor inquiries or support related to this frontend, feel free to reach out to us via email at [sewers@uwyo.edu](mailto:sewers@uwyo.edu). We're here to help!\r\n`,\r\n  }),\r\n};\r\n</script>\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--13-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./About.vue?vue&type=script&lang=js\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--13-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./About.vue?vue&type=script&lang=js\"","import { render, staticRenderFns } from \"./About.vue?vue&type=template&id=33dd9311\"\nimport script from \"./About.vue?vue&type=script&lang=js\"\nexport * from \"./About.vue?vue&type=script&lang=js\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","'use strict'\n\n// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexports.cwd = cwd\n\nfunction cwd() {\n  return '/'\n}\n","'use strict'\n\nvar own = {}.hasOwnProperty\n\nmodule.exports = stringify\n\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position)\n  }\n\n  // Position.\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value)\n  }\n\n  // Point.\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {}\n  }\n\n  return index(point.line) + ':' + index(point.column)\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {}\n  }\n\n  return point(pos.start) + '-' + point(pos.end)\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","var entities = require('character-entities-html4')\n\nvar characters = {}\nvar name\n\nmodule.exports = characters\n\nfor (name in entities) {\n  characters[entities[name]] = name\n}\n"],"sourceRoot":""}