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