{"version":3,"sources":["AX6Mustache.js"],"names":["AX6","global","factory","mustache","isArray","call","objectToString","typeStr","obj","_typeof","string","hasProperty","propName","testRegExp","re","regExpTest","isWhitespace","nonSpaceRe","parseTemplate","template","tags","compileTags","tagsToCompile","openingTagRe","split","spaceRe","Error","RegExp","escapeRegExp","closingTagRe","nonSpace","closingCurlyRe","sections","tokens","spaces","start","type","value","chr","token","openSection","scanner","Scanner","eos","scanUntil","i","valueLength","length","charAt","push","hasTag","stripSpace","pop","scan","tagRe","whiteRe","curlyRe","pos","nestTokens","numTokens","squashTokens","lastToken","squashedTokens","collector","section","nestedTokens","this","tail","parent","parentContext","view","cache",".","@each","returns","k","prototype","@key","@value","Writer","Object","toString","object","mustacheFactory","test","entityMap","&","\"","'","/","equalsRe","match","index","substring","Context","hasOwnProperty","name","lookup","names","indexOf","context","lookupHit","isFunction","clearCache","parse","renderTokens","buffer","symbol","partials","originalTemplate","self","undefined","renderSection","subRender","renderInverted","unescapedValue","escapedValue","rawValue","j","renderPartial","render","defaultWriter","escape","version","result","TypeError","to_html","send","String","replace","s"],"mappings":"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","file":"AX6Mustache.js","sourcesContent":["/*!\n * mustache.js - Logic-less {{mustache}} templates with JavaScript\n * http://github.com/janl/mustache.js\n * https://github.com/thomasJang/mustache.js -- imporove some variables\n */\n\n\n/**\n * AX6Mustache는 http://github.com/janl/mustache.js에 몇가지 최소한의 기능을 튜닝하여 사용하는 템플릿 엔진입니다.\n * @namespace AX6Mustache\n */\n\n/**\n * @method AX6Mustache.render\n * @example\n * ```js\n * ax5.mustache.render(template, view)\n *\n *\n * //Array @i\n * //{{#beatles}}\n * //{{firstName}} {{lastName}} ({{@i}}) ({{@first}})\n * //{{/beatles}}\n *\n * //Object @each\n * {{#beatles}}\n * {{#@each}}\n * {{@key}} : {{@value.firstName}} {{@value.lastName}}\n * {{/@each}}\n * {{/beatles}}\n *\n * ```\n */\n\n\n\nlet AX6 = {};\n\n(function defineMustache(global, factory) {\n\n factory(global.mustache = {});\n\n}(AX6, 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 // 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\n function testRegExp(re, string) {\n return regExpTest.call(re, string);\n }\n\n var nonSpaceRe = /\\S/;\n\n function isWhitespace(string) {\n return !testRegExp(nonSpaceRe, string);\n }\n\n var entityMap = {\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 function parseTemplate(template, tags) {\n if (!template)\n return [];\n\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\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 }\n else {\n spaces = [];\n }\n\n hasTag = false;\n nonSpace = false;\n }\n\n var openingTagRe, closingTagRe, closingCurlyRe;\n\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 }\n else {\n nonSpace = true;\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 }\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 }\n else if (type === '{') {\n value = scanner.scanUntil(closingCurlyRe);\n scanner.scan(curlyRe);\n scanner.scanUntil(closingTagRe);\n type = '&';\n }\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 token = [type, value, start, scanner.pos];\n tokens.push(token);\n\n if (type === '#' || type === '^') {\n sections.push(token);\n }\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 }\n else if (type === 'name' || type === '{' || type === '&') {\n nonSpace = true;\n }\n else if (type === '=') {\n // Set the tags for the next time around.\n compileTags(value);\n }\n }\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 }\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 = {\n '.': this.view,\n '@each': function () {\n var returns = [];\n for (var k in this) {\n returns.push({'@key': k, '@value': this[k]});\n }\n return returns;\n }\n };\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 }\n else {\n var context = this, names, index, lookupHit = false;\n\n while (context) {\n if (name.indexOf('.') > 0) {\n value = 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 while (value != null && index < names.length) {\n if (index === names.length - 1)\n lookupHit = hasProperty(value, names[index]);\n\n value = value[names[index++]];\n }\n }\n else {\n value = context.view[name];\n lookupHit = hasProperty(context.view, name);\n }\n\n if (lookupHit)\n break;\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` 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 tokens = cache[template];\n\n if (tokens == null)\n tokens = cache[template] = 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 Writer.prototype.render = function render(template, view, partials) {\n var tokens = this.parse(template);\n var context = (view instanceof Context) ? view : new Context(view);\n return this.renderTokens(tokens, context, partials, template);\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) {\n var buffer = '';\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, 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\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 if (value[j]) {\n if (typeof value[j] === 'object') {\n value[j]['@i'] = j;\n value[j]['@first'] = (j === 0);\n }\n\n buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate);\n }\n }\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 }\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 }\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.renderPartial = function renderPartial(token, context, partials) {\n if (!partials) return;\n\n var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];\n if (value != null)\n return this.renderTokens(this.parse(value), context, partials, value);\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 = '2.1.3';\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.\n */\n mustache.render = function render(template, view, partials) {\n if (typeof template !== 'string') {\n throw new TypeError('Invalid template! Template should be a \"string\" ' + 'but \"' + typeStr(template) + '\" was given as the first ' + 'argument for mustache#render(template, view, partials)');\n }\n\n return defaultWriter.render(template, view, partials);\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 }\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}));\n\nexport default AX6.mustache;"]}