var Mustache = function () {
    var Renderer = function () { };

    Renderer.prototype = {
        otag: "{{",
        ctag: "}}",
        pragmas: {},
        buffer: [],
        pragmas_implemented: {
            "IMPLICIT-ITERATOR": true
        },
        context: {},

        render: function (template, context, partials, in_recursion) {
            // reset buffer & set context
            if (!in_recursion) {
                this.context = context;
                this.buffer = []; // TODO: make this non-lazy
            }

            // fail fast
            if (!this.includes("", template)) {
                if (in_recursion) {
                    return template;
                } else {
                    this.send(template);
                    return;
                }
            }

            // get the pragmas together
            template = this.render_pragmas(template);

            // render the template
            var html = this.render_section(template, context, partials);

            // render_section did not find any sections, we still need to render the tags
            if (html === false) {
                html = this.render_tags(template, context, partials, in_recursion);
            }

            if (in_recursion) {
                return html;
            } else {
                this.sendLines(html);
            }
        },

        /*
        Sends parsed lines
        */
        send: function (line) {
            if (line != "") {
                this.buffer.push(line);
            }
        },

        sendLines: function (text) {
            if (text) {
                var lines = text.split("\n");
                for (var i = 0; i < lines.length; i++) {
                    this.send(lines[i]);
                }
            }
        },

        /*
        Looks for %PRAGMAS
        */
        render_pragmas: function (template) {
            // no pragmas
            if (!this.includes("%", template)) {
                return template;
            }

            var that = this;
            var regex = new RegExp(this.otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" +
            this.ctag);
            return template.replace(regex, function (match, pragma, options) {
                if (!that.pragmas_implemented[pragma]) {
                    throw ({ message:
            "This implementation of mustache doesn't understand the '" +
            pragma + "' pragma"
                    });
                }
                that.pragmas[pragma] = {};
                if (options) {
                    var opts = options.split("=");
                    that.pragmas[pragma][opts[0]] = opts[1];
                }
                return "";
                // ignore unknown pragmas silently
            });
        },

        /*
        Tries to find a partial in the curent scope and render it
        */
        render_partial: function (name, context, partials) {
            name = this.trim(name);
            if (!partials || partials[name] === undefined) {
                throw ({ message: "unknown_partial '" + name + "'" });
            }
            if (typeof (context[name]) != "object") {
                return this.render(partials[name], context, partials, true);
            }
            return this.render(partials[name], context[name], partials, true);
        },

        /*
        Renders inverted (^) and normal (#) sections
        */
        render_section: function (template, context, partials) {
            if (!this.includes("#", template) && !this.includes("^", template)) {
                // did not render anything, there were no sections
                return false;
            }

            var that = this;

            // This regex matches _the first_ section ({{#foo}}{{/foo}}), and captures the remainder
            var regex = new RegExp(
        "^([\\s\\S]*?)" +         // all the crap at the beginning that is not {{*}} ($1)

        this.otag +               // {{
        "(\\^|\\#)\\s*(.+)\\s*" + //  #foo (# == $2, foo == $3)
        this.ctag +               // }}

        "\n*([\\s\\S]*?)" +       // between the tag ($2). leading newlines are dropped

        this.otag +               // {{
        "\\/\\s*\\3\\s*" +        //  /foo (backreference to the opening tag).
        this.ctag +               // }}

        "\\s*([\\s\\S]*)$",       // everything else in the string ($4). leading whitespace is dropped.

      "g");

            // for each {{#foo}}{{/foo}} section do...
            return template.replace(regex, function (match, before, type, name, content, after) {
                // before contains only tags, no sections
                var renderedBefore = before ? that.render_tags(before, context, partials, true) : "",

                // after may contain both sections and tags, so use full rendering function
            renderedAfter = after ? that.render(after, context, partials, true) : "",

                // will be computed below
            renderedContent,

            value = that.find(name, context);

                if (type === "^") { // inverted section
                    if (!value || that.is_array(value) && value.length === 0) {
                        // false or empty list, render it
                        renderedContent = that.render(content, context, partials, true);
                    } else {
                        renderedContent = "";
                    }
                } else if (type === "#") { // normal section
                    if (that.is_array(value)) { // Enumerable, Let's loop!
                        renderedContent = that.map(value, function (row) {
                            return that.render(content, that.create_context(row), partials, true);
                        }).join("");
                    } else if (that.is_object(value)) { // Object, Use it as subcontext!
                        renderedContent = that.render(content, that.create_context(value),
              partials, true);
                    } else if (typeof value === "function") {
                        // higher order section
                        renderedContent = value.call(context, content, function (text) {
                            return that.render(text, context, partials, true);
                        });
                    } else if (value) { // boolean section
                        renderedContent = that.render(content, context, partials, true);
                    } else {
                        renderedContent = "";
                    }
                }

                return renderedBefore + renderedContent + renderedAfter;
            });
        },

        /*
        Replace {{foo}} and friends with values from our view
        */
        render_tags: function (template, context, partials, in_recursion) {
            // tit for tat
            var that = this;

            var new_regex = function () {
                return new RegExp(that.otag + "(=|!|>|\\{|%)?([^\\/#\\^]+?)\\1?" +
          that.ctag + "+", "g");
            };

            var regex = new_regex();
            var tag_replace_callback = function (match, operator, name) {
                switch (operator) {
                    case "!": // ignore comments
                        return "";
                    case "=": // set new delimiters, rebuild the replace regexp
                        that.set_delimiters(name);
                        regex = new_regex();
                        return "";
                    case ">": // render partial
                        return that.render_partial(name, context, partials);
                    case "{": // the triple mustache is unescaped
                        return that.find(name, context);
                    default: // escape the value
                        return that.escape(that.find(name, context));
                }
            };
            var lines = template.split("\n");
            for (var i = 0; i < lines.length; i++) {
                lines[i] = lines[i].replace(regex, tag_replace_callback, this);
                if (!in_recursion) {
                    this.send(lines[i]);
                }
            }

            if (in_recursion) {
                return lines.join("\n");
            }
        },

        set_delimiters: function (delimiters) {
            var dels = delimiters.split(" ");
            this.otag = this.escape_regex(dels[0]);
            this.ctag = this.escape_regex(dels[1]);
        },

        escape_regex: function (text) {
            // thank you Simon Willison
            if (!arguments.callee.sRE) {
                var specials = [
          '/', '.', '*', '+', '?', '|',
          '(', ')', '[', ']', '{', '}', '\\'
        ];
                arguments.callee.sRE = new RegExp(
          '(\\' + specials.join('|\\') + ')', 'g'
        );
            }
            return text.replace(arguments.callee.sRE, '\\$1');
        },

        /*
        find `name` in current `context`. That is find me a value
        from the view object
        */
        find: function (name, context) {
            name = this.trim(name);

            // Checks whether a value is thruthy or false or 0
            function is_kinda_truthy(bool) {
                return bool === false || bool === 0 || bool;
            }

            var value;
            if (is_kinda_truthy(context[name])) {
                value = context[name];
            } else if (is_kinda_truthy(this.context[name])) {
                value = this.context[name];
            }

            if (typeof value === "function") {
                return value.apply(context);
            }
            if (value !== undefined) {
                return value;
            }
            // silently ignore unkown variables
            return "";
        },

        // Utility methods

        /* includes tag */
        includes: function (needle, haystack) {
            return haystack.indexOf(this.otag + needle) != -1;
        },

        /*
        Does away with nasty characters
        */
        escape: function (s) {
            s = String(s === null ? "" : s);
            return s.replace(/&(?!\w+;)|["'<>\\]/g, function (s) {
                switch (s) {
                    case "&": return "&amp;";
                    case '"': return '&quot;';
                    case "'": return '&#39;';
                    case "<": return "&lt;";
                    case ">": return "&gt;";
                    default: return s;
                }
            });
        },

        // by @langalex, support for arrays of strings
        create_context: function (_context) {
            if (this.is_object(_context)) {
                return _context;
            } else {
                var iterator = ".";
                if (this.pragmas["IMPLICIT-ITERATOR"]) {
                    iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator;
                }
                var ctx = {};
                ctx[iterator] = _context;
                return ctx;
            }
        },

        is_object: function (a) {
            return a && typeof a == "object";
        },

        is_array: function (a) {
            return Object.prototype.toString.call(a) === '[object Array]';
        },

        /*
        Gets rid of leading and trailing whitespace
        */
        trim: function (s) {
            return s.replace(/^\s*|\s*$/g, "");
        },

        /*
        Why, why, why? Because IE. Cry, cry cry.
        */
        map: function (array, fn) {
            if (typeof array.map == "function") {
                return array.map(fn);
            } else {
                var r = [];
                var l = array.length;
                for (var i = 0; i < l; i++) {
                    r.push(fn(array[i]));
                }
                return r;
            }
        }
    };

    return ({
        name: "mustache.js",
        version: "0.3.1-dev-twitter",

        /*
        Turns a template and view into HTML
        */
        to_html: function (template, view, partials, send_fun) {
            var renderer = new Renderer();
            if (send_fun) {
                renderer.send = send_fun;
            }
            renderer.render(template, view || {}, partials);
            if (!send_fun) {
                return renderer.buffer.join("\n");
            }
        }
    });
} ();