/*global define: false Mustache: true*/

(function defineMustache (global, factory) {

  if (typeof exports === 'object' && exports && typeof exports.nodeName !== 'string') {

  } else if (typeof define === 'function' && define.amd) {

    define(['exports'], factory); // AMD

    global.Mustache = {};

    factory(Mustache); // script, wsh, asp

  }

}(this, function mustacheFactory (mustache) {

  var objectToString = Object.prototype.toString;

  var isArray = Array.isArray || function isArrayPolyfill (object) {

    return objectToString.call(object) === '[object Array]';

  };

  function isFunction (object) {

    return typeof object === 'function';

  /**

   * More correct typeof string handling array

   * which normally returns typeof 'object'

   */

  function typeStr (obj) {

    return isArray(obj) ? 'array' : typeof obj;

  }

  function escapeRegExp (string) {

    return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&');

  }

  /**

   * Null safe way of checking whether or not an object,

   * including its prototype, has a given property

   */

  function hasProperty (obj, propName) {

    return obj != null && typeof obj === 'object' && (propName in obj);

  }

  var regExpTest = RegExp.prototype.test;

  function testRegExp (re, string) {

    return regExpTest.call(re, string);

  var nonSpaceRe = /\S/;

  function isWhitespace (string) {

  var entityMap = {

    '&': '&',

    '<': '&lt;',

    '>': '>',

    '"': '"',

    "'": ''',

    '/': '/'

  function escapeHtml (string) {

    return String(string).replace(/[&<>"'\/]/g, function fromEntityMap (s) {

  var whiteRe = /\s*/;

  var spaceRe = /\s+/;

  var equalsRe = /\s*=/;

  var curlyRe = /\s*\}/;

  var tagRe = /#|\^|\/|>|\{|&|=|!/;

   * Breaks up the given `template` string into a tree of tokens. If the `tags`

   * argument is given here it must be an array with two string values: the

   * opening and closing tags used in the template (e.g. [ "<%", "%>" ]). Of

   * course, the default is to use mustaches (i.e. mustache.tags).

   *

   * A token is an array with at least 4 elements. The first element is the

   * mustache symbol that was used inside the tag, e.g. "#" or "&". If the tag

   * did not contain a symbol (i.e. {{myValue}}) this element is "name". For

   * all text that appears outside a symbol this element is "text".

   *

   * The second element of a token is its "value". For mustache tags this is

   * whatever else was inside the tag besides the opening symbol. For text tokens

   * this is the text itself.

   *

   * The third and fourth elements of the token are the start and end indices,

   * respectively, of the token in the original template.

   *

   * Tokens that are the root node of a subtree contain two more elements: 1) an

   * array of tokens in the subtree and 2) the index in the original template at

   * which the closing tag for that section begins.

  function parseTemplate (template, tags) {

    if (!template)

      return [];

    function stripSpace () {

        while (spaces.length)

    var openingTagRe, closingTagRe, closingCurlyRe;

    function compileTags (tagsToCompile) {

      if (typeof tagsToCompile === 'string')

        tagsToCompile = tagsToCompile.split(spaceRe, 2);

      if (!isArray(tagsToCompile) || tagsToCompile.length !== 2)

        throw new Error('Invalid tags: ' + tagsToCompile);

      openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + '\\s*');

      closingTagRe = new RegExp('\\s*' + escapeRegExp(tagsToCompile[1]));

      closingCurlyRe = new RegExp('\\s*' + escapeRegExp('}' + tagsToCompile[1]));

    }

    compileTags(tags || mustache.tags);

    var scanner = new Scanner(template);

    var start, type, value, chr, token, openSection;

      value = scanner.scanUntil(openingTagRe);

        for (var i = 0, valueLength = value.length; i < valueLength; ++i) {

          tokens.push([ 'text', chr, start, start + 1 ]);

          if (chr === '\n')

            stripSpace();

      if (!scanner.scan(openingTagRe))

        break;

        value = scanner.scanUntil(equalsRe);

        scanner.scan(equalsRe);

        scanner.scanUntil(closingTagRe);

        value = scanner.scanUntil(closingCurlyRe);

        scanner.scanUntil(closingTagRe);

        value = scanner.scanUntil(closingTagRe);

      if (!scanner.scan(closingTagRe))

        throw new Error('Unclosed tag at ' + scanner.pos);

      token = [ type, value, start, scanner.pos ];

        openSection = sections.pop();

        if (!openSection)

          throw new Error('Unopened section "' + value + '" at ' + start);

        if (openSection[1] !== value)

          throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);

        compileTags(value);

    openSection = sections.pop();

    if (openSection)

      throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);

    return nestTokens(squashTokens(tokens));

  }

  /**

   * Combines the values of consecutive text tokens in the given `tokens` array

   * to a single token.

   */

  function squashTokens (tokens) {

    var squashedTokens = [];

    var token, lastToken;

    for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {

      token = tokens[i];

      if (token) {

        if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {

          lastToken[1] += token[1];

          lastToken[3] = token[3];

        } else {

          squashedTokens.push(token);

          lastToken = token;

        }

      }

    }

    return squashedTokens;

  }

  /**

   * Forms the given array of `tokens` into a nested tree structure where

   * tokens that represent a section have two additional items: 1) an array of

   * all tokens that appear in that section and 2) the index in the original

   * template that represents the end of that section.

   */

  function nestTokens (tokens) {

    var nestedTokens = [];

    var collector = nestedTokens;

    var sections = [];

    var token, section;

    for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {

      token = tokens[i];

      switch (token[0]) {

      case '#':

      case '^':

        collector.push(token);

        sections.push(token);

        collector = token[4] = [];

        break;

      case '/':

        section = sections.pop();

        section[5] = token[2];

        collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;

        break;

      default:

        collector.push(token);

      }

    }

    return nestedTokens;

  }

  /**

   * A simple string scanner that is used by the template parser to find

   * tokens in template strings.

   */

  function Scanner (string) {

    this.string = string;

    this.tail = string;

    this.pos = 0;

  }

  /**

   * Returns `true` if the tail is empty (end of string).

   */

  Scanner.prototype.eos = function eos () {

    return this.tail === '';

  };

  /**

   * Tries to match the given regular expression at the current position.

   * Returns the matched text if it can match, the empty string otherwise.

   */

  Scanner.prototype.scan = function scan (re) {

    var match = this.tail.match(re);

    if (!match || match.index !== 0)

      return '';

    var string = match[0];

    this.tail = this.tail.substring(string.length);

    this.pos += string.length;

    return string;

  };

  /**

   * Skips all text until the given regular expression can be matched. Returns

   * the skipped string, which is the entire tail if no match can be made.

   */

  Scanner.prototype.scanUntil = function scanUntil (re) {

    var index = this.tail.search(re), match;

    switch (index) {

    case -1:

      match = this.tail;

      this.tail = '';

      break;

    case 0:

      match = '';

      break;

    default:

      match = this.tail.substring(0, index);

      this.tail = this.tail.substring(index);

    }

    this.pos += match.length;

    return match;

  };

  /**

   * Represents a rendering context by wrapping a view object and

   * maintaining a reference to the parent context.

   */