{"version":3,"file":"mustache.min.js","sources":["https:\/\/formacion.cordoba-acoge.com\/lib\/amd\/src\/mustache.js"],"sourcesContent":["\/\/ The MIT License\n\/\/\n\/\/ Copyright (c) 2009 Chris Wanstrath (Ruby)\n\/\/ Copyright (c) 2010-2014 Jan Lehnardt (JavaScript)\n\/\/ Copyright (c) 2010-2015 The mustache.js community\n\/\/\n\/\/ Permission is hereby granted, free of charge, to any person obtaining\n\/\/ a 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\n\/\/ permit persons to whom the Software is furnished to do so, subject to\n\/\/ the following conditions:\n\/\/\n\/\/ The above copyright notice and this permission notice shall be\n\/\/ included in all copies or substantial portions of the Software.\n\/\/\n\/\/ THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n\/\/ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\/\/ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n\/\/ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n\/\/ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n\/\/ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n\/\/ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\/\/\n\n\/\/ Description of import into Moodle:\n\/\/ Checkout from https:\/\/github.com\/moodle\/custom-mustache.js Branch: LAMBDA_ARGS\n\/\/ Rebase onto latest release tag from https:\/\/github.com\/janl\/mustache.js\n\/\/ Copy mustache.js into lib\/amd\/src\/ in Moodle folder.\n\/\/ Add the license as a comment to the file and these instructions.\n\/\/ Add jshint tags so this file is not linted.\n\/\/ Remove the \"global define:\" comment (hint for linter)\n\/\/ Make sure that you have not removed the custom code for '$' and '<'.\n\n\/*!\n * mustache.js - Logic-less {{mustache}} templates with JavaScript\n * http:\/\/github.com\/janl\/mustache.js\n *\/\n\n\/* jshint ignore:start *\/\n\n(function defineMustache (global, factory) {\n if (typeof exports === 'object' && exports && typeof exports.nodeName !== 'string') {\n factory(exports); \/\/ CommonJS\n } else if (typeof define === 'function' && define.amd) {\n define(['exports'], factory); \/\/ AMD\n } else {\n global.Mustache = {};\n factory(global.Mustache); \/\/ script, wsh, asp\n }\n}(this, function mustacheFactory (mustache) {\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 === '^' || 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 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.blocks = {};\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 * Set a value in the current block context.\n *\/\n Context.prototype.setBlockVar = function set (name, value) {\n var blocks = this.blocks;\n\n blocks[name] = value;\n\n return value;\n };\n\n \/**\n * Clear all current block vars.\n *\/\n Context.prototype.clearBlockVars = function clearBlockVars () {\n this.blocks = {};\n };\n\n \/**\n * Get a value only from the current block context.\n *\/\n Context.prototype.getBlockVar = function getBlockVar (name) {\n var blocks = this.blocks;\n\n var value;\n if (blocks.hasOwnProperty(name)) {\n value = blocks[name];\n } else {\n if (this.parent) {\n value = this.parent.getBlockVar(name);\n }\n }\n \/\/ Can return undefined.\n return value;\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.cache = {};\n }\n\n \/**\n * Clears all cached templates in this writer.\n *\/\n Writer.prototype.clearCache = function clearCache () {\n this.cache = {};\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.cache;\n var cacheKey = template + ':' + (tags || mustache.tags).join(':');\n var tokens = cache[cacheKey];\n\n if (tokens == null)\n tokens = cache[cacheKey] = parseTemplate(template, tags);\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 `tags` argument is given here it 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 Writer.prototype.render = function render (template, view, partials, tags) {\n var tokens = this.parse(template, tags);\n var context = (view instanceof Context) ? view : new Context(view);\n return this.renderTokens(tokens, context, partials, template, tags);\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, tags) {\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);\n else if (symbol === '^') value = this.renderInverted(token, context, partials, originalTemplate);\n else if (symbol === '>') value = this.renderPartial(token, context, partials, tags);\n else if (symbol === '<') value = this.renderBlock(token, context, partials, originalTemplate);\n else if (symbol === '$') value = this.renderBlockVariable(token, context, partials, originalTemplate);\n else if (symbol === '&') value = this.unescapedValue(token, context);\n else if (symbol === 'name') value = this.escapedValue(token, context);\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) {\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);\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);\n }\n } else if (typeof value === 'object' || typeof value === 'string' || typeof value === 'number') {\n buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate);\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);\n }\n return buffer;\n };\n\n Writer.prototype.renderInverted = function renderInverted (token, context, partials, originalTemplate) {\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);\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, tags) {\n if (!partials) return;\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 return this.renderTokens(this.parse(indentedValue, tags), context, partials, indentedValue);\n }\n };\n\n Writer.prototype.renderBlock = function renderBlock (token, context, partials, originalTemplate) {\n if (!partials) return;\n\n var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];\n if (value != null)\n \/\/ Ignore any wrongly set block vars before we started.\n context.clearBlockVars();\n \/\/ We are only rendering to record the default block variables.\n this.renderTokens(token[4], context, partials, originalTemplate);\n \/\/ Now we render and return the result.\n var result = this.renderTokens(this.parse(value), context, partials, value);\n \/\/ Don't leak the block variables outside this include.\n context.clearBlockVars();\n return result;\n };\n\n Writer.prototype.renderBlockVariable = function renderBlockVariable (token, context, partials, originalTemplate) {\n var value = token[1];\n\n var exists = context.getBlockVar(value);\n if (!exists) {\n context.setBlockVar(value, originalTemplate.slice(token[3], token[5]));\n return this.renderTokens(token[4], context, partials, originalTemplate);\n } else {\n return this.renderTokens(this.parse(exists), context, partials, exists);\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) {\n var value = context.lookup(token[1]);\n if (value != null)\n return mustache.escape(value);\n };\n\n Writer.prototype.rawValue = function rawValue (token) {\n return token[1];\n };\n\n mustache.name = 'mustache.js';\n mustache.version = '3.1.0';\n mustache.tags = [ '{{', '}}' ];\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` and `partials` using the\n * default writer. If the optional `tags` argument is given here it must be an\n * array with two string values: the opening and closing tags used in the\n * template (e.g. [ \"<%\", \"%>\" ]). The default is to mustache.tags.\n *\/\n mustache.render = function render (template, view, partials, tags) {\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, tags);\n };\n\n \/\/ This is here for backwards compatibility with 0.4.x.,\n \/*eslint-disable *\/ \/\/ eslint wants camel cased function name\n mustache.to_html = function to_html (template, view, partials, send) {\n \/*eslint-enable*\/\n\n var result = mustache.render(template, view, partials);\n\n if (isFunction(send)) {\n send(result);\n } else {\n return result;\n }\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\/* jshint ignore:end *\/\n"],"names":["global","factory","this","mustache","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","blocks","cache","parent","Writer","eos","scan","match","index","substring","length","scanUntil","search","push","setBlockVar","name","value","clearBlockVars","getBlockVar","hasOwnProperty","lookup","primitive","intermediateValue","names","context","lookupHit","indexOf","split","clearCache","parse","template","tags","cacheKey","join","tokens","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","render","partials","renderTokens","originalTemplate","symbol","buffer","undefined","renderSection","renderInverted","renderPartial","renderBlock","renderBlockVariable","unescapedValue","escapedValue","rawValue","self","j","slice","indentPartial","partial","filteredIndentation","partialByNl","indentedValue","result","exists","escape","version","defaultWriter","TypeError","to_html","send","String","s","exports","nodeName","define","amd","Mustache"],"mappings":"AA0CC,IAAyBA,OAAQC,QAARD,OASxBE,OATgCD,QAS1B,SAA0BE,cAE5BC,eAAiBC,OAAOC,UAAUC,SAClCC,QAAUC,MAAMD,SAAW,SAA0BE,cAChB,mBAAhCN,eAAeO,KAAKD,kBAGpBE,WAAYF,cACM,mBAAXA,gBAWPG,aAAcC,eACdA,OAAOC,QAAQ,8BAA+B,iBAO9CC,YAAaC,IAAKC,iBACX,MAAPD,KAA8B,iBAARA,KAAqBC,YAAYD,QAkB5DE,WAAaC,OAAOd,UAAUe,KAK9BC,WAAa,cACRC,aAAcT,wBALFU,GAAIV,eAChBK,WAAWR,KAAKa,GAAIV,QAKnBW,CAAWH,WAAYR,YAG7BY,UAAY,KACT,YACA,WACA,WACA,aACA,YACA,aACA,aACA,UASHC,QAAU,MACVC,QAAU,MACVC,SAAW,OACXC,QAAU,QACVC,MAAQ,mCA4OHC,QAASlB,aACXA,OAASA,YACTmB,KAAOnB,YACPoB,IAAM,WAyDJC,QAASC,KAAMC,oBACjBD,KAAOA,UACPE,OAAS,QACTC,MAAQ,KAAOrC,KAAKkC,WACpBI,OAASH,uBA2IPI,cACFF,MAAQ,GAnMfP,QAAQ1B,UAAUoC,IAAM,iBACD,KAAdxC,KAAK+B,MAOdD,QAAQ1B,UAAUqC,KAAO,SAAenB,QAClCoB,MAAQ1C,KAAK+B,KAAKW,MAAMpB,QAEvBoB,OAAyB,IAAhBA,MAAMC,MAClB,MAAO,OAEL\/B,OAAS8B,MAAM,eAEdX,KAAO\/B,KAAK+B,KAAKa,UAAUhC,OAAOiC,aAClCb,KAAOpB,OAAOiC,OAEZjC,QAOTkB,QAAQ1B,UAAU0C,UAAY,SAAoBxB,QACdoB,MAA9BC,MAAQ3C,KAAK+B,KAAKgB,OAAOzB,WAErBqB,YACA,EACJD,MAAQ1C,KAAK+B,UACRA,KAAO,cAET,EACHW,MAAQ,iBAGRA,MAAQ1C,KAAK+B,KAAKa,UAAU,EAAGD,YAC1BZ,KAAO\/B,KAAK+B,KAAKa,UAAUD,mBAG\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\/B,KAAMqE,SAAUrC,UAC\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"}