{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./utils/isVisible.js","webpack:///./utils/clickOutside.js","webpack:///./utils/getViewportHeight.js","webpack:///./utils/isIEcheck.js","webpack:///./utils/isMobile.js","webpack:///./utils/openInNewTab.js","webpack:///./utils/addActiveLinkClass.js","webpack:///./utils/isIOS.js","webpack:///./utils/fetchCheckStatus.js","webpack:///./utils/isStorageAvailable.js","webpack:///./utils/fetch.js","webpack:///../node_modules/console-browserify/index.js","webpack:///../node_modules/util/util.js","webpack:///../node_modules/custom-event/index.js","webpack:///../node_modules/body-scroll-lock/lib/bodyScrollLock.min.js","webpack:///../node_modules/process/browser.js","webpack:///../node_modules/util/support/isBufferBrowser.js","webpack:///../node_modules/util/node_modules/inherits/inherits_browser.js","webpack:///../node_modules/assert/assert.js","webpack:///../node_modules/object-assign/index.js","webpack:///../node_modules/scrollingelement/scrollingelement.js","webpack:///./components/PseudoLinks/index.js","webpack:///../node_modules/disable-scroll/es/index.js","webpack:///./components/Header/index.js","webpack:///./pages/citation-generator/index.js","webpack:///./components/CitationGeneratorHeaderRebuilder/index.js","webpack:///../node_modules/webpack/buildin/global.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","isVisible","elem","offsetWidth","offsetHeight","getClientRects","length","clickOutside","element","callback","outsideClickListener","event","contains","target","removeClickListener","document","removeEventListener","addEventListener","getViewportHeight","Math","max","documentElement","clientHeight","window","innerHeight","isIEcheck","ua","navigator","userAgent","indexOf","isMobile","innerWidth","openInNewTab","url","open","focus","addActiveLinkClass","anchorSelector","activeClass","anchors","querySelectorAll","current","location","pathname","getAttribute","classList","add","isiOS","platform","test","checkFetchStatus","response","ok","status","json","type","setItem","removeItem","e","options","method","headers","body","credentials","fetch","Error","text","message","util","assert","now","Date","getTime","console","slice","Array","times","global","functions","log","apply","arguments","warn","label","time","duration","err","format","error","stack","inspect","expression","arr","tuple","f","getOwnPropertyDescriptors","obj","keys","descriptors","getOwnPropertyDescriptor","formatRegExp","isString","objects","push","join","args","len","str","String","replace","x","Number","JSON","stringify","_","isNull","isObject","deprecate","fn","msg","process","noDeprecation","this","warned","throwDeprecation","traceDeprecation","trace","debugEnviron","debugs","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","style","styles","recurseTimes","isFunction","constructor","ret","primitive","simple","isNumber","formatPrimitive","visibleKeys","array","hash","forEach","val","idx","arrayToHash","getOwnPropertyNames","isError","formatError","isRegExp","RegExp","toString","isDate","output","base","braces","isArray","toUTCString","formatProperty","match","formatArray","map","pop","reduce","prev","cur","numLinesEst","reduceToSingleString","desc","set","split","line","substr","ar","arg","re","objectToString","pad","debuglog","env","NODE_DEBUG","toUpperCase","pid","isNullOrUndefined","isSymbol","isPrimitive","isBuffer","months","timestamp","getHours","getMinutes","getSeconds","getDate","getMonth","prop","inherits","origin","kCustomPromisifiedSymbol","undefined","callbackifyOnRejected","reason","cb","newReason","promisify","original","TypeError","writable","configurable","promiseResolve","promiseReject","promise","Promise","resolve","reject","setPrototypeOf","getPrototypeOf","defineProperties","custom","callbackify","callbackified","maybeCb","self","then","nextTick","rej","NativeCustomEvent","CustomEvent","detail","foo","useNative","createEvent","params","initCustomEvent","bubbles","cancelable","createEventObject","Boolean","from","u","some","allowTouchMove","touches","preventDefault","setTimeout","paddingRight","overflow","a","maxTouchPoints","v","disableBodyScroll","targetElement","concat","ontouchstart","targetTouches","clientY","ontouchmove","scrollTop","scrollHeight","stopPropagation","passive","reserveScrollBarGap","clientWidth","clearAllBodyScrollLocks","enableBodyScroll","filter","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","noop","title","browser","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","copy","fill","readUInt8","ctor","superCtor","super_","TempCtor","objectAssign","compare","b","y","min","Buffer","_isBuffer","hasOwn","pSlice","functionsHaveNames","pToString","isView","arrbuf","ArrayBuffer","DataView","buffer","regex","getName","func","truncate","something","rawname","fail","actual","expected","operator","stackStartFunction","AssertionError","_deepEqual","strict","memos","source","multiline","lastIndex","ignoreCase","Float32Array","Float64Array","Uint8Array","actualIndex","actualVisitedObjects","aIsArgs","isArguments","bIsArgs","ka","objectKeys","kb","sort","objEquiv","expectedException","isPrototypeOf","_throws","shouldThrow","block","_tryBlock","userProvidedMessage","isUnexpectedException","generatedMessage","captureStackTrace","out","fn_name","next_line","substring","equal","notEqual","deepEqual","deepStrictEqual","notDeepEqual","notDeepStrictEqual","strictEqual","notStrictEqual","throws","doesNotThrow","ifError","getOwnPropertySymbols","propIsEnumerable","propertyIsEnumerable","toObject","assign","test1","test2","fromCharCode","test3","letter","shouldUseNative","symbols","to","computeStyle","getComputedStyle","currentStyle","isCompliantCached","isRendered","display","visibility","scrollingElement","compatMode","iframe","createElement","height","appendChild","doc","contentWindow","write","close","parentNode","removeChild","isCompliant","tagName","frameset","nextSibling","nodeType","HTMLBodyElement","getNextBodyElement","bodyStyle","htmlStyle","isScrollable","__defineGetter__","attachEvent","propertyName","pseudoLinks","link","which","ownKeys","enumerableOnly","sym","_toConsumableArray","arr2","_arrayWithoutHoles","iter","iterator","_iterableToArray","_nonIterableSpread","_defineProperties","props","descriptor","_defineProperty","canUseDOM","DisableScroll","_this","instance","Constructor","_classCallCheck","_window","scrollTo","lockToScrollPos","keyboardKeys","authorizedInInputs","keyCode","disableWheel","disableScroll","disableKeys","protoProps","staticProps","_objectSpread","_this$options","handleWheel","scrollLeft","scrollX","scrollY","handleScroll","handleKeydown","ToggleNav","header","querySelector","button","nav","navScrollSpace","state","isOpen","sel","showEvent","setNavScrollSpaceHeight","show","dispatchEvent","hide","remove","ToggleSubNav","navItems","subnavMenuItem","navSimpleItems","item","subnavButton","subnavBody","subnavScrollSpace","scrollEventsPrevented","subnavHeight","floor","getBoundingClientRect","top","onkeydown","toggleNav","toggleSubNav","scrollHandler","stickyHeader","infoIconContent","g","Function"],"mappings":"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","file":"js/citation-generator.min.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 = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 476);\n","/**\n *\n * @param elem\n * @returns {boolean}\n */\nconst isVisible = elem =>\n  !!elem && !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);\n\nexport default isVisible;\n","import isVisible from './isVisible';\n\n/**\n *\n * @param element\n * @param callback\n */\nconst clickOutside = (element, callback) => {\n  const outsideClickListener = event => {\n    if (!element.contains(event.target) && isVisible(element)) {\n      callback();\n      // eslint-disable-next-line no-use-before-define\n      removeClickListener();\n    }\n  };\n\n  const removeClickListener = () => {\n    document.removeEventListener('click', outsideClickListener);\n  };\n\n  document.addEventListener('click', outsideClickListener);\n};\n\nexport default clickOutside;\n","/**\n *\n * @returns {number}\n */\nconst getViewportHeight = () =>\n  Math.max(document.documentElement.clientHeight, window.innerHeight || 0);\n\nexport default getViewportHeight;\n","/**\n *\n * @returns {boolean}\n */\nconst isIEcheck = () => {\n  const ua = navigator.userAgent;\n  /* MSIE used to detect old browsers and Trident used to newer ones */\n  const isEI = ua.indexOf('MSIE ') > -1 || ua.indexOf('Trident/') > -1;\n\n  return isEI;\n};\n\nexport default isIEcheck;\n","/**\n *\n * @returns {boolean}\n */\nconst isMobile = () => window.innerWidth < 1024;\n\nexport default isMobile;\n","/**\n *\n * @param url\n */\nconst openInNewTab = url => {\n  const win = window.open(url, '_blank');\n  win.focus();\n};\n\nexport default openInNewTab;\n","/**\n *\n * @param anchorSelector\n * @param activeClass\n */\nconst addActiveLinkClass = ({ anchorSelector = 'a', activeClass = 'active' }) => {\n  const anchors = document.querySelectorAll(anchorSelector);\n  if (!anchors) return;\n\n  const current = window.location.pathname;\n\n  for (let i = 0; i < anchors.length; i += 1) {\n    if (\n      anchors[i].getAttribute('href') === current ||\n      anchors[i].getAttribute('data-href') === current\n    ) {\n      anchors[i].classList.add(activeClass);\n    }\n  }\n};\n\nexport default addActiveLinkClass;\n","const isiOS = !!navigator.platform && /iPad|iPhone|iPod/.test(navigator.platform);\n\nexport default isiOS;\n","const checkFetchStatus = response => {\n  if (!response.ok) {\n    throw response.status;\n  }\n  return response.json();\n};\n\nexport default checkFetchStatus;\n","export default type => {\n  const test = '__storageTest__';\n  try {\n    window[type].setItem(test, test);\n    window[type].removeItem(test);\n    return true;\n  } catch (e) {\n    return false;\n  }\n};\n","export default async (url, options = {}) => {\n  const { method = 'GET', headers, body = null, credentials = 'omit' } = options;\n\n  try {\n    const response = await fetch(url, {\n      method,\n      headers,\n      body,\n      credentials: credentials !== 'omit' ? 'include' : 'omit',\n    });\n\n    if (!response.ok) {\n      throw new Error('Bad request');\n    }\n\n    return {\n      json: () => response.json(),\n      text: () => response.text(),\n    };\n  } catch (error) {\n    throw new Error(`Request failed: ${error.message}`);\n  }\n};\n","/*global window, global*/\nvar util = require(\"util\")\nvar assert = require(\"assert\")\nfunction now() { return new Date().getTime() }\n\nvar slice = Array.prototype.slice\nvar console\nvar times = {}\n\nif (typeof global !== \"undefined\" && global.console) {\n    console = global.console\n} else if (typeof window !== \"undefined\" && window.console) {\n    console = window.console\n} else {\n    console = {}\n}\n\nvar functions = [\n    [log, \"log\"],\n    [info, \"info\"],\n    [warn, \"warn\"],\n    [error, \"error\"],\n    [time, \"time\"],\n    [timeEnd, \"timeEnd\"],\n    [trace, \"trace\"],\n    [dir, \"dir\"],\n    [consoleAssert, \"assert\"]\n]\n\nfor (var i = 0; i < functions.length; i++) {\n    var tuple = functions[i]\n    var f = tuple[0]\n    var name = tuple[1]\n\n    if (!console[name]) {\n        console[name] = f\n    }\n}\n\nmodule.exports = console\n\nfunction log() {}\n\nfunction info() {\n    console.log.apply(console, arguments)\n}\n\nfunction warn() {\n    console.log.apply(console, arguments)\n}\n\nfunction error() {\n    console.warn.apply(console, arguments)\n}\n\nfunction time(label) {\n    times[label] = now()\n}\n\nfunction timeEnd(label) {\n    var time = times[label]\n    if (!time) {\n        throw new Error(\"No such label: \" + label)\n    }\n\n    delete times[label]\n    var duration = now() - time\n    console.log(label + \": \" + duration + \"ms\")\n}\n\nfunction trace() {\n    var err = new Error()\n    err.name = \"Trace\"\n    err.message = util.format.apply(null, arguments)\n    console.error(err.stack)\n}\n\nfunction dir(object) {\n    console.log(util.inspect(object) + \"\\n\")\n}\n\nfunction consoleAssert(expression) {\n    if (!expression) {\n        var arr = slice.call(arguments, 1)\n        assert.ok(false, util.format.apply(null, arr))\n    }\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\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n  function getOwnPropertyDescriptors(obj) {\n    var keys = Object.keys(obj);\n    var descriptors = {};\n    for (var i = 0; i < keys.length; i++) {\n      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n    }\n    return descriptors;\n  };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\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    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\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  return str;\n};\n\n\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.\nexports.deprecate = function(fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  }\n\n  // Allow for deprecating things in the process of starting up.\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  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      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\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  return debugs[set];\n};\n\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/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\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  }\n  // set default options\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}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\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};\n\n// Don't use 'blue' not visible on cmd.exe\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\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\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 &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // 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    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\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    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\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\n  var output;\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\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\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,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\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  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\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      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  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\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, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\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] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\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 */\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\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\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')\n    throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn, enumerable: false, writable: false, 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\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\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\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn, enumerable: false, writable: false, configurable: true\n  });\n  return Object.defineProperties(\n    fn,\n    getOwnPropertyDescriptors(original)\n  );\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  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  }\n\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  function callbackified() {\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n    var self = this;\n    var cb = function() {\n      return maybeCb.apply(self, arguments);\n    };\n    // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n    original.apply(this, args)\n      .then(function(ret) { process.nextTick(cb, null, ret) },\n            function(rej) { process.nextTick(callbackifyOnRejected, rej, cb) });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified,\n                          getOwnPropertyDescriptors(original));\n  return callbackified;\n}\nexports.callbackify = callbackify;\n","\nvar NativeCustomEvent = global.CustomEvent;\n\nfunction useNative () {\n  try {\n    var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } });\n    return  'cat' === p.type && 'bar' === p.detail.foo;\n  } catch (e) {\n  }\n  return false;\n}\n\n/**\n * Cross-browser `CustomEvent` constructor.\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent\n *\n * @public\n */\n\nmodule.exports = useNative() ? NativeCustomEvent :\n\n// IE >= 9\n'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) {\n  var e = document.createEvent('CustomEvent');\n  if (params) {\n    e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail);\n  } else {\n    e.initCustomEvent(type, false, false, void 0);\n  }\n  return e;\n} :\n\n// IE <= 8\nfunction CustomEvent (type, params) {\n  var e = document.createEventObject();\n  e.type = type;\n  if (params) {\n    e.bubbles = Boolean(params.bubbles);\n    e.cancelable = Boolean(params.cancelable);\n    e.detail = params.detail;\n  } else {\n    e.bubbles = false;\n    e.cancelable = false;\n    e.detail = void 0;\n  }\n  return e;\n}\n","!function(e,t){if(\"function\"==typeof define&&define.amd)define([\"exports\"],t);else if(\"undefined\"!=typeof exports)t(exports);else{var o={};t(o),e.bodyScrollLock=o}}(this,function(exports){\"use strict\";function i(e){if(Array.isArray(e)){for(var t=0,o=Array(e.length);t<e.length;t++)o[t]=e[t];return o}return Array.from(e)}Object.defineProperty(exports,\"__esModule\",{value:!0});var l=!1;if(\"undefined\"!=typeof window){var e={get passive(){l=!0}};window.addEventListener(\"testPassive\",null,e),window.removeEventListener(\"testPassive\",null,e)}function d(t){return u.some(function(e){return!(!e.options.allowTouchMove||!e.options.allowTouchMove(t))})}function c(e){var t=e||window.event;return!!d(t.target)||(1<t.touches.length||(t.preventDefault&&t.preventDefault(),!1))}function o(){setTimeout(function(){void 0!==m&&(document.body.style.paddingRight=m,m=void 0),void 0!==f&&(document.body.style.overflow=f,f=void 0)})}var a=\"undefined\"!=typeof window&&window.navigator&&window.navigator.platform&&(/iP(ad|hone|od)/.test(window.navigator.platform)||\"MacIntel\"===window.navigator.platform&&1<window.navigator.maxTouchPoints),u=[],s=!1,v=-1,f=void 0,m=void 0;exports.disableBodyScroll=function(r,e){if(a){if(!r)return void console.error(\"disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.\");if(r&&!u.some(function(e){return e.targetElement===r})){var t={targetElement:r,options:e||{}};u=[].concat(i(u),[t]),r.ontouchstart=function(e){1===e.targetTouches.length&&(v=e.targetTouches[0].clientY)},r.ontouchmove=function(e){var t,o,n,i;1===e.targetTouches.length&&(o=r,i=(t=e).targetTouches[0].clientY-v,d(t.target)||(o&&0===o.scrollTop&&0<i||(n=o)&&n.scrollHeight-n.scrollTop<=n.clientHeight&&i<0?c(t):t.stopPropagation()))},s||(document.addEventListener(\"touchmove\",c,l?{passive:!1}:void 0),s=!0)}}else{n=e,setTimeout(function(){if(void 0===m){var e=!!n&&!0===n.reserveScrollBarGap,t=window.innerWidth-document.documentElement.clientWidth;e&&0<t&&(m=document.body.style.paddingRight,document.body.style.paddingRight=t+\"px\")}void 0===f&&(f=document.body.style.overflow,document.body.style.overflow=\"hidden\")});var o={targetElement:r,options:e||{}};u=[].concat(i(u),[o])}var n},exports.clearAllBodyScrollLocks=function(){a?(u.forEach(function(e){e.targetElement.ontouchstart=null,e.targetElement.ontouchmove=null}),s&&(document.removeEventListener(\"touchmove\",c,l?{passive:!1}:void 0),s=!1),u=[],v=-1):(o(),u=[])},exports.enableBodyScroll=function(t){if(a){if(!t)return void console.error(\"enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.\");t.ontouchstart=null,t.ontouchmove=null,u=u.filter(function(e){return e.targetElement!==t}),s&&0===u.length&&(document.removeEventListener(\"touchmove\",c,l?{passive:!1}:void 0),s=!1)}else(u=u.filter(function(e){return e.targetElement!==t})).length||o()}});\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// 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}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\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    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\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\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\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\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\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    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\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) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && 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    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","'use strict';\n\nvar objectAssign = require('object-assign');\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n//     node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all 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,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n  if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n  equal: assert.strictEqual,\n  deepEqual: assert.deepStrictEqual,\n  notEqual: assert.notStrictEqual,\n  notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","/*! https://mths.be/scrollingelement v1.5.2 by @diegoperini & @mathias | MIT license */\nif (!('scrollingElement' in document)) (function() {\n\n\tfunction computeStyle(element) {\n\t\tif (window.getComputedStyle) {\n\t\t\t// Support Firefox < 4 which throws on a single parameter.\n\t\t\treturn getComputedStyle(element, null);\n\t\t}\n\t\t// Support Internet Explorer < 9.\n\t\treturn element.currentStyle;\n\t}\n\n\tfunction isBodyElement(element) {\n\t\t// The `instanceof` check gives the correct result for e.g. `body` in a\n\t\t// non-HTML namespace.\n\t\tif (window.HTMLBodyElement) {\n\t\t\treturn element instanceof HTMLBodyElement;\n\t\t}\n\t\t// Fall back to a `tagName` check for old browsers.\n\t\treturn /body/i.test(element.tagName);\n\t}\n\n\tfunction getNextBodyElement(frameset) {\n\t\t// We use this function to be correct per spec in case `document.body` is\n\t\t// a `frameset` but there exists a later `body`. Since `document.body` is\n\t\t// a `frameset`, we know the root is an `html`, and there was no `body`\n\t\t// before the `frameset`, so we just need to look at siblings after the\n\t\t// `frameset`.\n\t\tvar current = frameset;\n\t\twhile (current = current.nextSibling) {\n\t\t\tif (current.nodeType == 1 && isBodyElement(current)) {\n\t\t\t\treturn current;\n\t\t\t}\n\t\t}\n\t\t// No `body` found.\n\t\treturn null;\n\t}\n\n\t// Note: standards mode / quirks mode can be toggled at runtime via\n\t// `document.write`.\n\tvar isCompliantCached;\n\tvar isCompliant = function() {\n\t\tvar isStandardsMode = /^CSS1/.test(document.compatMode);\n\t\tif (!isStandardsMode) {\n\t\t\t// In quirks mode, the result is equivalent to the non-compliant\n\t\t\t// standards mode behavior.\n\t\t\treturn false;\n\t\t}\n\t\tif (isCompliantCached === void 0) {\n\t\t\t// When called for the first time, check whether the browser is\n\t\t\t// standard-compliant, and cache the result.\n\t\t\tvar iframe = document.createElement('iframe');\n\t\t\tiframe.style.height = '1px';\n\t\t\t(document.body || document.documentElement || document).appendChild(iframe);\n\t\t\tvar doc = iframe.contentWindow.document;\n\t\t\tdoc.write('<!DOCTYPE html><div style=\"height:9999em\">x</div>');\n\t\t\tdoc.close();\n\t\t\tisCompliantCached = doc.documentElement.scrollHeight > doc.body.scrollHeight;\n\t\t\tiframe.parentNode.removeChild(iframe);\n\t\t}\n\t\treturn isCompliantCached;\n\t};\n\n\tfunction isRendered(style) {\n\t\treturn style.display != 'none' && !(style.visibility == 'collapse' &&\n\t\t\t/^table-(.+-group|row|column)$/.test(style.display));\n\t}\n\n\tfunction isScrollable(body) {\n\t\t// A `body` element is scrollable if `body` and `html` both have\n\t\t// non-`visible` overflow and are both being rendered.\n\t\tvar bodyStyle = computeStyle(body);\n\t\tvar htmlStyle = computeStyle(document.documentElement);\n\t\treturn bodyStyle.overflow != 'visible' && htmlStyle.overflow != 'visible' &&\n\t\t\tisRendered(bodyStyle) && isRendered(htmlStyle);\n\t}\n\n\tvar scrollingElement = function() {\n\t\tif (isCompliant()) {\n\t\t\treturn document.documentElement;\n\t\t}\n\t\tvar body = document.body;\n\t\t// Note: `document.body` could be a `frameset` element, or `null`.\n\t\t// `tagName` is uppercase in HTML, but lowercase in XML.\n\t\tvar isFrameset = body && !/body/i.test(body.tagName);\n\t\tbody = isFrameset ? getNextBodyElement(body) : body;\n\t\t// If `body` is itself scrollable, it is not the `scrollingElement`.\n\t\treturn body && isScrollable(body) ? null : body;\n\t};\n\n\tif (Object.defineProperty) {\n\t\t// Support modern browsers that lack a native implementation.\n\t\tObject.defineProperty(document, 'scrollingElement', {\n\t\t\t'get': scrollingElement\n\t\t});\n\t} else if (document.__defineGetter__) {\n\t\t// Support Firefox ≤ 3.6.9, Safari ≤ 4.1.3.\n\t\tdocument.__defineGetter__('scrollingElement', scrollingElement);\n\t} else {\n\t\t// IE ≤ 4 lacks `attachEvent`, so it only gets this one assignment. IE ≤ 7\n\t\t// gets it too, but the value is updated later (see `propertychange`).\n\t\tdocument.scrollingElement = scrollingElement();\n\t\tdocument.attachEvent && document.attachEvent('onpropertychange', function() {\n\t\t\t// This is for IE ≤ 7 only.\n\t\t\t// A `propertychange` event fires when `<body>` is parsed because\n\t\t\t// `document.activeElement` then changes.\n\t\t\tif (window.event.propertyName == 'activeElement') {\n\t\t\t\tdocument.scrollingElement = scrollingElement();\n\t\t\t}\n\t\t});\n\t}\n}());\n","import { openInNewTab } from '../../utils';\n\nfunction pseudoLinksInit() {\n  const pseudoLinks = document.querySelectorAll('[data-href]');\n\n  Array.from(pseudoLinks).forEach(link => {\n    link.addEventListener('click', e => {\n      e.preventDefault();\n      window.location = link.getAttribute('data-href');\n    });\n\n    link.addEventListener('mousedown', e => {\n      if (e.which === 2) openInNewTab(link.getAttribute('data-href'));\n    });\n  });\n}\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  pseudoLinksInit();\n});\n","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance\"); }\n\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n\nvar DisableScroll =\n/*#__PURE__*/\nfunction () {\n  function DisableScroll() {\n    var _this = this;\n\n    _classCallCheck(this, DisableScroll);\n\n    _defineProperty(this, \"handleWheel\", function (e) {\n      e.preventDefault();\n    });\n\n    _defineProperty(this, \"handleScroll\", function () {\n      var _window;\n\n      (_window = window).scrollTo.apply(_window, _toConsumableArray(_this.lockToScrollPos));\n    });\n\n    _defineProperty(this, \"handleKeydown\", function (e) {\n      var keys = _this.options.keyboardKeys;\n      /* istanbul ignore else */\n\n      if (['INPUT', 'TEXTAREA'].indexOf(e.target.tagName) !== -1) {\n        keys = _this.options.authorizedInInputs;\n      }\n      /* istanbul ignore else */\n\n\n      if (keys.indexOf(e.keyCode) !== -1) {\n        e.preventDefault();\n      }\n    });\n\n    this.element = null;\n    this.lockToScrollPos = [0, 0];\n    this.options = {\n      disableWheel: true,\n      disableScroll: true,\n      disableKeys: true,\n      keyboardKeys: [32, 33, 34, 35, 36, 37, 38, 39, 40],\n      authorizedInInputs: [32, 37, 38, 39, 40] // space: 32, page up: 33, page down: 34, end: 35, home: 36\n      // left: 37, up: 38, right: 39, down: 40\n\n    };\n    /* istanbul ignore else */\n\n    if (canUseDOM) {\n      require('scrollingelement');\n\n      this.element = document.scrollingElement;\n    }\n  }\n  /**\n   * Disable Page Scroll\n   * @external Node\n   *\n   * @param {HTMLElement} [element] - DOM Element, usually document.body\n   * @param {object} [options] - Change the initial options\n   */\n\n\n  _createClass(DisableScroll, [{\n    key: \"on\",\n    value: function on(element, options) {\n      if (!canUseDOM) return;\n      this.element = element || this.element;\n      this.options = _objectSpread({}, this.options, {}, options);\n      var _this$options = this.options,\n          disableKeys = _this$options.disableKeys,\n          disableScroll = _this$options.disableScroll,\n          disableWheel = _this$options.disableWheel;\n      /* istanbul ignore else */\n\n      if (disableWheel) {\n        document.addEventListener('wheel', this.handleWheel, {\n          passive: false\n        });\n        document.addEventListener('touchmove', this.handleWheel, {\n          passive: false\n        });\n      }\n      /* istanbul ignore else */\n\n\n      if (disableScroll) {\n        this.lockToScrollPos = [this.element.scrollLeft || this.element.scrollX, this.element.scrollTop || this.element.scrollY];\n        document.addEventListener('scroll', this.handleScroll, {\n          passive: false\n        });\n      }\n      /* istanbul ignore else */\n\n\n      if (disableKeys) {\n        document.addEventListener('keydown', this.handleKeydown, {\n          passive: false\n        });\n      }\n    }\n    /**\n     * Re-enable page scrolls\n     */\n\n  }, {\n    key: \"off\",\n    value: function off() {\n      if (!canUseDOM) return;\n      document.removeEventListener('wheel', this.handleWheel, {\n        passive: false\n      });\n      document.removeEventListener('touchmove', this.handleWheel, {\n        passive: false\n      });\n      document.removeEventListener('scroll', this.handleScroll, {\n        passive: false\n      });\n      document.removeEventListener('keydown', this.handleKeydown, {\n        passive: false\n      });\n    }\n  }]);\n\n  return DisableScroll;\n}();\n\nexport default new DisableScroll();","import { disableBodyScroll, enableBodyScroll, clearAllBodyScrollLocks } from 'body-scroll-lock';\nimport disableScroll from 'disable-scroll';\nimport CustomEvent from 'custom-event';\nimport { isMobile, getViewportHeight, isIEcheck, clickOutside } from '../../utils';\nimport './header-default.scss';\n\n/**\n * Sticky header\n */\nconst stickyHeader = () => {\n  const header = document.querySelector('.header');\n\n  if (!header) return;\n\n  const scrollHandler = () => {\n    const topPosition = header.getBoundingClientRect().top;\n\n    if (topPosition < 0) {\n      if (!header.classList.contains('sticky')) {\n        header.classList.add('sticky');\n      }\n    } else if (header.classList.contains('sticky')) {\n      header.classList.remove('sticky');\n    }\n  };\n\n  scrollHandler();\n  window.addEventListener('scroll', scrollHandler);\n};\n\n/**\n * Toggle Navigation\n */\n\nfunction ToggleNav() {\n  const header = document.querySelector('.header');\n  const button = header.querySelector('.header__nav-toggle');\n  const nav = header.querySelector('.header__nav');\n  const navScrollSpace = header.querySelector('.header__nav-inner');\n\n  if (!header || !button || !nav) return;\n\n  this.state = {\n    isOpen: false,\n  };\n  this.sel = nav;\n  const showEvent = new CustomEvent('show');\n\n  const setNavScrollSpaceHeight = () => {\n    nav.style.height = `${getViewportHeight() - header.offsetHeight}px`;\n  };\n\n  this.show = () => {\n    if (this.state.isOpen) return;\n\n    this.state.isOpen = true;\n\n    disableBodyScroll(navScrollSpace);\n\n    header.classList.add('nav-is-open');\n    setNavScrollSpaceHeight();\n\n    window.addEventListener('resize', setNavScrollSpaceHeight);\n\n    this.sel.dispatchEvent(showEvent);\n  };\n\n  this.hide = () => {\n    if (!this.state.isOpen) return;\n\n    this.state.isOpen = false;\n\n    enableBodyScroll(navScrollSpace);\n    clearAllBodyScrollLocks();\n\n    header.classList.remove('nav-is-open');\n    nav.style.height = '';\n\n    window.removeEventListener('resize', setNavScrollSpaceHeight);\n  };\n\n  button.addEventListener(\n    'click',\n    () => {\n      if (this.state.isOpen) {\n        this.hide();\n      } else {\n        this.show();\n      }\n    },\n    false,\n  );\n\n  window.addEventListener('orientationchange', this.hide);\n}\n\n/**\n * Toggle SubNavigation\n */\n\nfunction ToggleSubNav() {\n  const header = document.querySelector('.header');\n  const navScrollSpace = header.querySelector('.header__nav-inner');\n  const navItems = header.querySelectorAll('.header__nav-item');\n  const subnavMenuItem = header.querySelector('.header__nav-item--subnav');\n  const navSimpleItems = Array.prototype.slice\n    .call(navItems)\n    .filter(item => item !== subnavMenuItem);\n  const subnavButton = subnavMenuItem.querySelector('.header__nav-link');\n  const subnavBody = subnavMenuItem.querySelector('.header__subnav');\n  const subnavScrollSpace = subnavBody.querySelector('.subnav__inner');\n\n  if (!subnavMenuItem || !subnavButton || !subnavBody) return;\n\n  this.state = {\n    isOpen: false,\n    scrollEventsPrevented: false,\n  };\n\n  this.show = () => {\n    if (this.state.isOpen) return;\n\n    this.state.isOpen = true;\n\n    subnavMenuItem.classList.add('is-open');\n\n    if (!isMobile()) {\n      if (!isIEcheck()) {\n        disableScroll.on();\n      }\n\n      this.scrollEventsPrevented = true;\n      clickOutside(subnavBody, this.hide);\n    } else {\n      disableBodyScroll(subnavScrollSpace);\n      navScrollSpace.style.overflow = 'hidden';\n\n      const subnavHeight = Math.floor(\n        getViewportHeight() - subnavScrollSpace.getBoundingClientRect().top,\n      );\n\n      subnavBody.style.height = `${subnavHeight}px`;\n    }\n\n    navSimpleItems.forEach(item => {\n      item.classList.add('header__nav-item--hidden');\n    });\n  };\n\n  this.hide = () => {\n    if (!this.state.isOpen) return;\n\n    this.state.isOpen = false;\n\n    enableBodyScroll(subnavScrollSpace);\n\n    navSimpleItems.forEach(item => {\n      item.classList.remove('header__nav-item--hidden');\n    });\n    subnavMenuItem.classList.remove('is-open');\n\n    if (this.scrollEventsPrevented) {\n      disableScroll.off();\n    }\n\n    navScrollSpace.style.overflow = '';\n    subnavBody.style.height = '';\n  };\n\n  subnavButton.addEventListener(\n    'click',\n    e => {\n      e.stopPropagation();\n      if (this.state.isOpen) {\n        this.hide();\n      } else {\n        this.show();\n      }\n    },\n    false,\n  );\n\n  window.addEventListener('orientationchange', this.hide);\n\n  document.onkeydown = e => {\n    let isEscape = false;\n    if ('key' in e) {\n      isEscape = e.key === 'Escape' || e.key === 'Esc';\n    } else {\n      isEscape = e.keyCode === 27;\n    }\n    if (isEscape) {\n      this.hide();\n    }\n  };\n}\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  const toggleNav = new ToggleNav();\n  const toggleSubNav = new ToggleSubNav();\n  stickyHeader();\n\n  toggleNav.sel.addEventListener('show', () => {\n    toggleSubNav.hide();\n  });\n});\n","import '../../components/Header';\nimport '../../components/PseudoLinks';\nimport '../../components/CitationGeneratorHeaderRebuilder';\n","window.addEventListener('DOMContentLoaded', () => {\n  const title = document.querySelector('.citation-header-description');\n  const infoIconContent = document.querySelector('.citation-info');\n\n  title.appendChild(infoIconContent);\n});\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n"],"sourceRoot":""}