{"version":3,"sources":["../node_modules/@babel/runtime/helpers/esm/classCallCheck.js","js/include/before-you-go.js","../node_modules/mustache/mustache.js","../node_modules/@babel/runtime/helpers/esm/createClass.js"],"names":["_classCallCheck","instance","Constructor","TypeError","BeforeYouGo","this","template","document","getElementById","innerHTML","config","variant","COOKIE_BEFORE_YOU_GO","mouseOut","bind","e","popupFound","querySelector","popupCookieFound","Cookies","get","shouldShowPopup","toElement","relatedTarget","clientY","showPopup","data","Mustache","render","then","$","featherlight","set","expires","setTimeout","addEventListener","module","exports","objectToString","Object","prototype","toString","isArray","Array","object","call","isFunction","escapeRegExp","string","replace","hasProperty","obj","propName","regExpTest","RegExp","test","nonSpaceRe","isWhitespace","re","testRegExp","entityMap","whiteRe","spaceRe","equalsRe","curlyRe","tagRe","Scanner","tail","pos","Context","view","parentContext","cache","parent","Writer","templateCache","_cache","key","value","clear","eos","scan","match","index","substring","length","scanUntil","search","push","lookup","name","primitive","hasOwnProperty","intermediateValue","names","context","lookupHit","indexOf","split","clearCache","parse","tags","cacheKey","mustache","join","isCacheEnabled","tokens","undefined","openingTagRe","closingTagRe","closingCurlyRe","lineHasNonSpace","sections","spaces","hasTag","nonSpace","indentation","tagIndex","stripSpace","pop","compileTags","tagsToCompile","Error","start","type","chr","token","openSection","scanner","i","valueLength","charAt","nestedTokens","collector","numTokens","nestTokens","lastToken","squashedTokens","squashTokens","parseTemplate","partials","getConfigTags","renderTokens","originalTemplate","symbol","buffer","renderSection","renderInverted","renderPartial","unescapedValue","escapedValue","rawValue","self","j","slice","indentPartial","partial","filteredIndentation","partialByNl","indentedValue","escape","getConfigEscape","String","version","defaultWriter","s","factory","_defineProperties","target","props","descriptor","enumerable","configurable","writable","defineProperty","_createClass","protoProps","staticProps"],"mappings":"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","file":"hashed/7.f55cab3b.chunk.js","sourcesContent":["export default function _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}","import Mustache from 'mustache';\nimport Cookies from '../vendor/cookie'; // Static\nimport $ from 'jquery';\n\n/*\n * BeforeYouGo popUp. Show popUp if user is leaving the page\n*/\nclass BeforeYouGo {\n constructor() {\n this.template = document.getElementById('before-you-go').innerHTML\n this.config = {\n variant: 'before-you-go'\n }\n this.COOKIE_BEFORE_YOU_GO = 'beforeYouGoPopUp'\n this.mouseOut = this.mouseOut.bind(this)\n }\n\n /*\n * Show PopUp, checks cookie and mouse event\n * @param {event} e Mouse event.\n * @return {boolean}\n */\n showPopup(e = false) {\n const popupFound = document.querySelector('.featherlight.before-you-go');\n if (popupFound) {\n return false;\n }\n const popupCookieFound = typeof Cookies.get(this.COOKIE_BEFORE_YOU_GO) !== 'undefined' ? false : true\n const shouldShowPopup =\n !e.toElement &&\n !e.relatedTarget &&\n e.clientY < 10 &&\n popupCookieFound\n\n return e ? shouldShowPopup : popupCookieFound\n }\n\n /*\n * Checks mouse event and displays popUp and sets Cookie\n * @param {event} e mouse event\n */\n mouseOut(e) {\n const shouldShowPopup = this.showPopup(e)\n\n if (shouldShowPopup) {\n const data = Mustache.render(this.template)\n import('featherlight').then(() => {\n $.featherlight(data, this.config);\n });\n\n // Set cookie\n Cookies.set(this.COOKIE_BEFORE_YOU_GO, 'true', { expires: 1 });\n }\n }\n\n /*\n * Init before-you-go popUp\n */\n init() {\n const shouldShowPopup = this.showPopup();\n if (shouldShowPopup) {\n setTimeout( () => {\n document.addEventListener('mouseout', this.mouseOut, true)\n }, 5_000)\n }\n }\n}\n\nexport default new BeforeYouGo\n","// This file has been generated from mustache.mjs\n(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n typeof define === 'function' && define.amd ? define(factory) :\n (global = global || self, global.Mustache = factory());\n}(this, (function () { 'use strict';\n\n /*!\n * mustache.js - Logic-less {{mustache}} templates with JavaScript\n * http://github.com/janl/mustache.js\n */\n\n var objectToString = Object.prototype.toString;\n var isArray = Array.isArray || function isArrayPolyfill (object) {\n return objectToString.call(object) === '[object Array]';\n };\n\n function isFunction (object) {\n return typeof object === 'function';\n }\n\n /**\n * More correct typeof string handling array\n * which normally returns typeof 'object'\n */\n function typeStr (obj) {\n return isArray(obj) ? 'array' : typeof obj;\n }\n\n function escapeRegExp (string) {\n return string.replace(/[\\-\\[\\]{}()*+?.,\\\\\\^$|#\\s]/g, '\\\\$&');\n }\n\n /**\n * Null safe way of checking whether or not an object,\n * including its prototype, has a given property\n */\n function hasProperty (obj, propName) {\n return obj != null && typeof obj === 'object' && (propName in obj);\n }\n\n /**\n * Safe way of detecting whether or not the given thing is a primitive and\n * whether it has the given property\n */\n function primitiveHasOwnProperty (primitive, propName) {\n return (\n primitive != null\n && typeof primitive !== 'object'\n && primitive.hasOwnProperty\n && primitive.hasOwnProperty(propName)\n );\n }\n\n // Workaround for https://issues.apache.org/jira/browse/COUCHDB-577\n // See https://github.com/janl/mustache.js/issues/189\n var regExpTest = RegExp.prototype.test;\n function testRegExp (re, string) {\n return regExpTest.call(re, string);\n }\n\n var nonSpaceRe = /\\S/;\n function isWhitespace (string) {\n return !testRegExp(nonSpaceRe, string);\n }\n\n var entityMap = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": ''',\n '/': '/',\n '`': '`',\n '=': '='\n };\n\n function escapeHtml (string) {\n return String(string).replace(/[&<>\"'`=\\/]/g, function fromEntityMap (s) {\n return entityMap[s];\n });\n }\n\n var whiteRe = /\\s*/;\n var spaceRe = /\\s+/;\n var equalsRe = /\\s*=/;\n var curlyRe = /\\s*\\}/;\n var tagRe = /#|\\^|\\/|>|\\{|&|=|!/;\n\n /**\n * Breaks up the given `template` string into a tree of tokens. If the `tags`\n * argument is given here it must be an array with two string values: the\n * opening and closing tags used in the template (e.g. [ \"<%\", \"%>\" ]). Of\n * course, the default is to use mustaches (i.e. mustache.tags).\n *\n * A token is an array with at least 4 elements. The first element is the\n * mustache symbol that was used inside the tag, e.g. \"#\" or \"&\". If the tag\n * did not contain a symbol (i.e. {{myValue}}) this element is \"name\". For\n * all text that appears outside a symbol this element is \"text\".\n *\n * The second element of a token is its \"value\". For mustache tags this is\n * whatever else was inside the tag besides the opening symbol. For text tokens\n * this is the text itself.\n *\n * The third and fourth elements of the token are the start and end indices,\n * respectively, of the token in the original template.\n *\n * Tokens that are the root node of a subtree contain two more elements: 1) an\n * array of tokens in the subtree and 2) the index in the original template at\n * which the closing tag for that section begins.\n *\n * Tokens for partials also contain two more elements: 1) a string value of\n * indendation prior to that tag and 2) the index of that tag on that line -\n * eg a value of 2 indicates the partial is the third tag on this line.\n */\n function parseTemplate (template, tags) {\n if (!template)\n return [];\n var lineHasNonSpace = false;\n var sections = []; // Stack to hold section tokens\n var tokens = []; // Buffer to hold the tokens\n var spaces = []; // Indices of whitespace tokens on the current line\n var hasTag = false; // Is there a {{tag}} on the current line?\n var nonSpace = false; // Is there a non-space char on the current line?\n var indentation = ''; // Tracks indentation for tags that use it\n var tagIndex = 0; // Stores a count of number of tags encountered on a line\n\n // Strips all whitespace tokens array for the current line\n // if there was a {{#tag}} on it and otherwise only space.\n function stripSpace () {\n if (hasTag && !nonSpace) {\n while (spaces.length)\n delete tokens[spaces.pop()];\n } else {\n spaces = [];\n }\n\n hasTag = false;\n nonSpace = false;\n }\n\n var openingTagRe, closingTagRe, closingCurlyRe;\n function compileTags (tagsToCompile) {\n if (typeof tagsToCompile === 'string')\n tagsToCompile = tagsToCompile.split(spaceRe, 2);\n\n if (!isArray(tagsToCompile) || tagsToCompile.length !== 2)\n throw new Error('Invalid tags: ' + tagsToCompile);\n\n openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + '\\\\s*');\n closingTagRe = new RegExp('\\\\s*' + escapeRegExp(tagsToCompile[1]));\n closingCurlyRe = new RegExp('\\\\s*' + escapeRegExp('}' + tagsToCompile[1]));\n }\n\n compileTags(tags || mustache.tags);\n\n var scanner = new Scanner(template);\n\n var start, type, value, chr, token, openSection;\n while (!scanner.eos()) {\n start = scanner.pos;\n\n // Match any text between tags.\n value = scanner.scanUntil(openingTagRe);\n\n if (value) {\n for (var i = 0, valueLength = value.length; i < valueLength; ++i) {\n chr = value.charAt(i);\n\n if (isWhitespace(chr)) {\n spaces.push(tokens.length);\n indentation += chr;\n } else {\n nonSpace = true;\n lineHasNonSpace = true;\n indentation += ' ';\n }\n\n tokens.push([ 'text', chr, start, start + 1 ]);\n start += 1;\n\n // Check for whitespace on the current line.\n if (chr === '\\n') {\n stripSpace();\n indentation = '';\n tagIndex = 0;\n lineHasNonSpace = false;\n }\n }\n }\n\n // Match the opening tag.\n if (!scanner.scan(openingTagRe))\n break;\n\n hasTag = true;\n\n // Get the tag type.\n type = scanner.scan(tagRe) || 'name';\n scanner.scan(whiteRe);\n\n // Get the tag value.\n if (type === '=') {\n value = scanner.scanUntil(equalsRe);\n scanner.scan(equalsRe);\n scanner.scanUntil(closingTagRe);\n } else if (type === '{') {\n value = scanner.scanUntil(closingCurlyRe);\n scanner.scan(curlyRe);\n scanner.scanUntil(closingTagRe);\n type = '&';\n } else {\n value = scanner.scanUntil(closingTagRe);\n }\n\n // Match the closing tag.\n if (!scanner.scan(closingTagRe))\n throw new Error('Unclosed tag at ' + scanner.pos);\n\n if (type == '>') {\n token = [ type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace ];\n } else {\n token = [ type, value, start, scanner.pos ];\n }\n tagIndex++;\n tokens.push(token);\n\n if (type === '#' || type === '^') {\n sections.push(token);\n } else if (type === '/') {\n // Check section nesting.\n openSection = sections.pop();\n\n if (!openSection)\n throw new Error('Unopened section \"' + value + '\" at ' + start);\n\n if (openSection[1] !== value)\n throw new Error('Unclosed section \"' + openSection[1] + '\" at ' + start);\n } else if (type === 'name' || type === '{' || type === '&') {\n nonSpace = true;\n } else if (type === '=') {\n // Set the tags for the next time around.\n compileTags(value);\n }\n }\n\n stripSpace();\n\n // Make sure there are no open sections when we're done.\n openSection = sections.pop();\n\n if (openSection)\n throw new Error('Unclosed section \"' + openSection[1] + '\" at ' + scanner.pos);\n\n return nestTokens(squashTokens(tokens));\n }\n\n /**\n * Combines the values of consecutive text tokens in the given `tokens` array\n * to a single token.\n */\n function squashTokens (tokens) {\n var squashedTokens = [];\n\n var token, lastToken;\n for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {\n token = tokens[i];\n\n if (token) {\n if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {\n lastToken[1] += token[1];\n lastToken[3] = token[3];\n } else {\n squashedTokens.push(token);\n lastToken = token;\n }\n }\n }\n\n return squashedTokens;\n }\n\n /**\n * Forms the given array of `tokens` into a nested tree structure where\n * tokens that represent a section have two additional items: 1) an array of\n * all tokens that appear in that section and 2) the index in the original\n * template that represents the end of that section.\n */\n function nestTokens (tokens) {\n var nestedTokens = [];\n var collector = nestedTokens;\n var sections = [];\n\n var token, section;\n for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {\n token = tokens[i];\n\n switch (token[0]) {\n case '#':\n case '^':\n collector.push(token);\n sections.push(token);\n collector = token[4] = [];\n break;\n case '/':\n section = sections.pop();\n section[5] = token[2];\n collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;\n break;\n default:\n collector.push(token);\n }\n }\n\n return nestedTokens;\n }\n\n /**\n * A simple string scanner that is used by the template parser to find\n * tokens in template strings.\n */\n function Scanner (string) {\n this.string = string;\n this.tail = string;\n this.pos = 0;\n }\n\n /**\n * Returns `true` if the tail is empty (end of string).\n */\n Scanner.prototype.eos = function eos () {\n return this.tail === '';\n };\n\n /**\n * Tries to match the given regular expression at the current position.\n * Returns the matched text if it can match, the empty string otherwise.\n */\n Scanner.prototype.scan = function scan (re) {\n var match = this.tail.match(re);\n\n if (!match || match.index !== 0)\n return '';\n\n var string = match[0];\n\n this.tail = this.tail.substring(string.length);\n this.pos += string.length;\n\n return string;\n };\n\n /**\n * Skips all text until the given regular expression can be matched. Returns\n * the skipped string, which is the entire tail if no match can be made.\n */\n Scanner.prototype.scanUntil = function scanUntil (re) {\n var index = this.tail.search(re), match;\n\n switch (index) {\n case -1:\n match = this.tail;\n this.tail = '';\n break;\n case 0:\n match = '';\n break;\n default:\n match = this.tail.substring(0, index);\n this.tail = this.tail.substring(index);\n }\n\n this.pos += match.length;\n\n return match;\n };\n\n /**\n * Represents a rendering context by wrapping a view object and\n * maintaining a reference to the parent context.\n */\n function Context (view, parentContext) {\n this.view = view;\n this.cache = { '.': this.view };\n this.parent = parentContext;\n }\n\n /**\n * Creates a new context using the given view with this context\n * as the parent.\n */\n Context.prototype.push = function push (view) {\n return new Context(view, this);\n };\n\n /**\n * Returns the value of the given name in this context, traversing\n * up the context hierarchy if the value is absent in this context's view.\n */\n Context.prototype.lookup = function lookup (name) {\n var cache = this.cache;\n\n var value;\n if (cache.hasOwnProperty(name)) {\n value = cache[name];\n } else {\n var context = this, intermediateValue, names, index, lookupHit = false;\n\n while (context) {\n if (name.indexOf('.') > 0) {\n intermediateValue = context.view;\n names = name.split('.');\n index = 0;\n\n /**\n * Using the dot notion path in `name`, we descend through the\n * nested objects.\n *\n * To be certain that the lookup has been successful, we have to\n * check if the last object in the path actually has the property\n * we are looking for. We store the result in `lookupHit`.\n *\n * This is specially necessary for when the value has been set to\n * `undefined` and we want to avoid looking up parent contexts.\n *\n * In the case where dot notation is used, we consider the lookup\n * to be successful even if the last \"object\" in the path is\n * not actually an object but a primitive (e.g., a string, or an\n * integer), because it is sometimes useful to access a property\n * of an autoboxed primitive, such as the length of a string.\n **/\n while (intermediateValue != null && index < names.length) {\n if (index === names.length - 1)\n lookupHit = (\n hasProperty(intermediateValue, names[index])\n || primitiveHasOwnProperty(intermediateValue, names[index])\n );\n\n intermediateValue = intermediateValue[names[index++]];\n }\n } else {\n intermediateValue = context.view[name];\n\n /**\n * Only checking against `hasProperty`, which always returns `false` if\n * `context.view` is not an object. Deliberately omitting the check\n * against `primitiveHasOwnProperty` if dot notation is not used.\n *\n * Consider this example:\n * ```\n * Mustache.render(\"The length of a football field is {{#length}}{{length}}{{/length}}.\", {length: \"100 yards\"})\n * ```\n *\n * If we were to check also against `primitiveHasOwnProperty`, as we do\n * in the dot notation case, then render call would return:\n *\n * \"The length of a football field is 9.\"\n *\n * rather than the expected:\n *\n * \"The length of a football field is 100 yards.\"\n **/\n lookupHit = hasProperty(context.view, name);\n }\n\n if (lookupHit) {\n value = intermediateValue;\n break;\n }\n\n context = context.parent;\n }\n\n cache[name] = value;\n }\n\n if (isFunction(value))\n value = value.call(this.view);\n\n return value;\n };\n\n /**\n * A Writer knows how to take a stream of tokens and render them to a\n * string, given a context. It also maintains a cache of templates to\n * avoid the need to parse the same template twice.\n */\n function Writer () {\n this.templateCache = {\n _cache: {},\n set: function set (key, value) {\n this._cache[key] = value;\n },\n get: function get (key) {\n return this._cache[key];\n },\n clear: function clear () {\n this._cache = {};\n }\n };\n }\n\n /**\n * Clears all cached templates in this writer.\n */\n Writer.prototype.clearCache = function clearCache () {\n if (typeof this.templateCache !== 'undefined') {\n this.templateCache.clear();\n }\n };\n\n /**\n * Parses and caches the given `template` according to the given `tags` or\n * `mustache.tags` if `tags` is omitted, and returns the array of tokens\n * that is generated from the parse.\n */\n Writer.prototype.parse = function parse (template, tags) {\n var cache = this.templateCache;\n var cacheKey = template + ':' + (tags || mustache.tags).join(':');\n var isCacheEnabled = typeof cache !== 'undefined';\n var tokens = isCacheEnabled ? cache.get(cacheKey) : undefined;\n\n if (tokens == undefined) {\n tokens = parseTemplate(template, tags);\n isCacheEnabled && cache.set(cacheKey, tokens);\n }\n return tokens;\n };\n\n /**\n * High-level method that is used to render the given `template` with\n * the given `view`.\n *\n * The optional `partials` argument may be an object that contains the\n * names and templates of partials that are used in the template. It may\n * also be a function that is used to load partial templates on the fly\n * that takes a single argument: the name of the partial.\n *\n * If the optional `config` argument is given here, then it should be an\n * object with a `tags` attribute or an `escape` attribute or both.\n * If an array is passed, then it will be interpreted the same way as\n * a `tags` attribute on a `config` object.\n *\n * The `tags` attribute of a `config` object must be an array with two\n * string values: the opening and closing tags used in the template (e.g.\n * [ \"<%\", \"%>\" ]). The default is to mustache.tags.\n *\n * The `escape` attribute of a `config` object must be a function which\n * accepts a string as input and outputs a safely escaped string.\n * If an `escape` function is not provided, then an HTML-safe string\n * escaping function is used as the default.\n */\n Writer.prototype.render = function render (template, view, partials, config) {\n var tags = this.getConfigTags(config);\n var tokens = this.parse(template, tags);\n var context = (view instanceof Context) ? view : new Context(view, undefined);\n return this.renderTokens(tokens, context, partials, template, config);\n };\n\n /**\n * Low-level method that renders the given array of `tokens` using\n * the given `context` and `partials`.\n *\n * Note: The `originalTemplate` is only ever used to extract the portion\n * of the original template that was contained in a higher-order section.\n * If the template doesn't use higher-order sections, this argument may\n * be omitted.\n */\n Writer.prototype.renderTokens = function renderTokens (tokens, context, partials, originalTemplate, config) {\n var buffer = '';\n\n var token, symbol, value;\n for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {\n value = undefined;\n token = tokens[i];\n symbol = token[0];\n\n if (symbol === '#') value = this.renderSection(token, context, partials, originalTemplate, config);\n else if (symbol === '^') value = this.renderInverted(token, context, partials, originalTemplate, config);\n else if (symbol === '>') value = this.renderPartial(token, context, partials, config);\n else if (symbol === '&') value = this.unescapedValue(token, context);\n else if (symbol === 'name') value = this.escapedValue(token, context, config);\n else if (symbol === 'text') value = this.rawValue(token);\n\n if (value !== undefined)\n buffer += value;\n }\n\n return buffer;\n };\n\n Writer.prototype.renderSection = function renderSection (token, context, partials, originalTemplate, config) {\n var self = this;\n var buffer = '';\n var value = context.lookup(token[1]);\n\n // This function is used to render an arbitrary template\n // in the current context by higher-order sections.\n function subRender (template) {\n return self.render(template, context, partials, config);\n }\n\n if (!value) return;\n\n if (isArray(value)) {\n for (var j = 0, valueLength = value.length; j < valueLength; ++j) {\n buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config);\n }\n } else if (typeof value === 'object' || typeof value === 'string' || typeof value === 'number') {\n buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config);\n } else if (isFunction(value)) {\n if (typeof originalTemplate !== 'string')\n throw new Error('Cannot use higher-order sections without the original template');\n\n // Extract the portion of the original template that the section contains.\n value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);\n\n if (value != null)\n buffer += value;\n } else {\n buffer += this.renderTokens(token[4], context, partials, originalTemplate, config);\n }\n return buffer;\n };\n\n Writer.prototype.renderInverted = function renderInverted (token, context, partials, originalTemplate, config) {\n var value = context.lookup(token[1]);\n\n // Use JavaScript's definition of falsy. Include empty arrays.\n // See https://github.com/janl/mustache.js/issues/186\n if (!value || (isArray(value) && value.length === 0))\n return this.renderTokens(token[4], context, partials, originalTemplate, config);\n };\n\n Writer.prototype.indentPartial = function indentPartial (partial, indentation, lineHasNonSpace) {\n var filteredIndentation = indentation.replace(/[^ \\t]/g, '');\n var partialByNl = partial.split('\\n');\n for (var i = 0; i < partialByNl.length; i++) {\n if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) {\n partialByNl[i] = filteredIndentation + partialByNl[i];\n }\n }\n return partialByNl.join('\\n');\n };\n\n Writer.prototype.renderPartial = function renderPartial (token, context, partials, config) {\n if (!partials) return;\n var tags = this.getConfigTags(config);\n\n var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];\n if (value != null) {\n var lineHasNonSpace = token[6];\n var tagIndex = token[5];\n var indentation = token[4];\n var indentedValue = value;\n if (tagIndex == 0 && indentation) {\n indentedValue = this.indentPartial(value, indentation, lineHasNonSpace);\n }\n var tokens = this.parse(indentedValue, tags);\n return this.renderTokens(tokens, context, partials, indentedValue, config);\n }\n };\n\n Writer.prototype.unescapedValue = function unescapedValue (token, context) {\n var value = context.lookup(token[1]);\n if (value != null)\n return value;\n };\n\n Writer.prototype.escapedValue = function escapedValue (token, context, config) {\n var escape = this.getConfigEscape(config) || mustache.escape;\n var value = context.lookup(token[1]);\n if (value != null)\n return (typeof value === 'number' && escape === mustache.escape) ? String(value) : escape(value);\n };\n\n Writer.prototype.rawValue = function rawValue (token) {\n return token[1];\n };\n\n Writer.prototype.getConfigTags = function getConfigTags (config) {\n if (isArray(config)) {\n return config;\n }\n else if (config && typeof config === 'object') {\n return config.tags;\n }\n else {\n return undefined;\n }\n };\n\n Writer.prototype.getConfigEscape = function getConfigEscape (config) {\n if (config && typeof config === 'object' && !isArray(config)) {\n return config.escape;\n }\n else {\n return undefined;\n }\n };\n\n var mustache = {\n name: 'mustache.js',\n version: '4.1.0',\n tags: [ '{{', '}}' ],\n clearCache: undefined,\n escape: undefined,\n parse: undefined,\n render: undefined,\n Scanner: undefined,\n Context: undefined,\n Writer: undefined,\n /**\n * Allows a user to override the default caching strategy, by providing an\n * object with set, get and clear methods. This can also be used to disable\n * the cache by setting it to the literal `undefined`.\n */\n set templateCache (cache) {\n defaultWriter.templateCache = cache;\n },\n /**\n * Gets the default or overridden caching object from the default writer.\n */\n get templateCache () {\n return defaultWriter.templateCache;\n }\n };\n\n // All high-level mustache.* functions use this writer.\n var defaultWriter = new Writer();\n\n /**\n * Clears all cached templates in the default writer.\n */\n mustache.clearCache = function clearCache () {\n return defaultWriter.clearCache();\n };\n\n /**\n * Parses and caches the given template in the default writer and returns the\n * array of tokens it contains. Doing this ahead of time avoids the need to\n * parse templates on the fly as they are rendered.\n */\n mustache.parse = function parse (template, tags) {\n return defaultWriter.parse(template, tags);\n };\n\n /**\n * Renders the `template` with the given `view`, `partials`, and `config`\n * using the default writer.\n */\n mustache.render = function render (template, view, partials, config) {\n if (typeof template !== 'string') {\n throw new TypeError('Invalid template! Template should be a \"string\" ' +\n 'but \"' + typeStr(template) + '\" was given as the first ' +\n 'argument for mustache#render(template, view, partials)');\n }\n\n return defaultWriter.render(template, view, partials, config);\n };\n\n // Export the escaping function so that the user may override it.\n // See https://github.com/janl/mustache.js/issues/244\n mustache.escape = escapeHtml;\n\n // Export these mainly for testing, but also for advanced usage.\n mustache.Scanner = Scanner;\n mustache.Context = Context;\n mustache.Writer = Writer;\n\n return mustache;\n\n})));\n","function _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nexport default function _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}"],"sourceRoot":""}