PERF: stop loading handlebars and ember compilers in prod

(this removes a nice 50K from our initial payload and saves memory)

Also fixes invalid HTML automatically if added to HEAD or /BODY

app/assets/javascripts/discourse/initializers/live-development.js.es6

@@ -32,7 +32,10 @@ export default {
 
     // Observe file changes
     messageBus.subscribe("/file-change", function(data) {
-      Ember.TEMPLATES.empty = Handlebars.compile("<div></div>");
+      if (Handlebars.compile && !Ember.TEMPLATES.empty) {
+        // hbs notifications only happen in dev
+        Ember.TEMPLATES.empty = Handlebars.compile("<div></div>");
+      }
       _.each(data,function(me) {
 
         if (me === "refresh") {

app/assets/javascripts/discourse/lib/ember_compat_handlebars.js

@@ -57,57 +57,59 @@
   stringCompatHelper("with");
 
 
-  RawHandlebars.Compiler = function() {};
+  if (Handlebars.Compiler) {
-  RawHandlebars.Compiler.prototype = objectCreate(Handlebars.Compiler.prototype);
+    RawHandlebars.Compiler = function() {};
-  RawHandlebars.Compiler.prototype.compiler = RawHandlebars.Compiler;
+    RawHandlebars.Compiler.prototype = objectCreate(Handlebars.Compiler.prototype);
+    RawHandlebars.Compiler.prototype.compiler = RawHandlebars.Compiler;
 
-  RawHandlebars.JavaScriptCompiler = function() {};
+    RawHandlebars.JavaScriptCompiler = function() {};
 
-  RawHandlebars.JavaScriptCompiler.prototype = objectCreate(Handlebars.JavaScriptCompiler.prototype);
+    RawHandlebars.JavaScriptCompiler.prototype = objectCreate(Handlebars.JavaScriptCompiler.prototype);
-  RawHandlebars.JavaScriptCompiler.prototype.compiler = RawHandlebars.JavaScriptCompiler;
+    RawHandlebars.JavaScriptCompiler.prototype.compiler = RawHandlebars.JavaScriptCompiler;
-  RawHandlebars.JavaScriptCompiler.prototype.namespace = "Discourse.EmberCompatHandlebars";
+    RawHandlebars.JavaScriptCompiler.prototype.namespace = "Discourse.EmberCompatHandlebars";
 
 
-  RawHandlebars.Compiler.prototype.mustache = function(mustache) {
+    RawHandlebars.Compiler.prototype.mustache = function(mustache) {
-    if ( !(mustache.params.length || mustache.hash)) {
+      if ( !(mustache.params.length || mustache.hash)) {
 
-      var id = new Handlebars.AST.IdNode([{ part: 'get' }]);
+        var id = new Handlebars.AST.IdNode([{ part: 'get' }]);
-      mustache = new Handlebars.AST.MustacheNode([id].concat([mustache.id]), mustache.hash, mustache.escaped);
+        mustache = new Handlebars.AST.MustacheNode([id].concat([mustache.id]), mustache.hash, mustache.escaped);
-    }
+      }
 
-    return Handlebars.Compiler.prototype.mustache.call(this, mustache);
+      return Handlebars.Compiler.prototype.mustache.call(this, mustache);
-  };
-
-  RawHandlebars.precompile = function(value, asObject) {
-    var ast = Handlebars.parse(value);
-
-    var options = {
-      knownHelpers: {
-        get: true
-      },
-      data: true,
-      stringParams: true
     };
 
-    asObject = asObject === undefined ? true : asObject;
+    RawHandlebars.precompile = function(value, asObject) {
+      var ast = Handlebars.parse(value);
 
-    var environment = new RawHandlebars.Compiler().compile(ast, options);
+      var options = {
-    return new RawHandlebars.JavaScriptCompiler().compile(environment, options, undefined, asObject);
+        knownHelpers: {
-  };
+          get: true
+        },
+        data: true,
+        stringParams: true
+      };
+
+      asObject = asObject === undefined ? true : asObject;
+
+      var environment = new RawHandlebars.Compiler().compile(ast, options);
+      return new RawHandlebars.JavaScriptCompiler().compile(environment, options, undefined, asObject);
+    };
 
 
-  RawHandlebars.compile = function(string) {
+    RawHandlebars.compile = function(string) {
-    var ast = Handlebars.parse(string);
+      var ast = Handlebars.parse(string);
-    // this forces us to rewrite helpers
+      // this forces us to rewrite helpers
-    var options = {  data: true, stringParams: true };
+      var options = {  data: true, stringParams: true };
-    var environment = new RawHandlebars.Compiler().compile(ast, options);
+      var environment = new RawHandlebars.Compiler().compile(ast, options);
-    var templateSpec = new RawHandlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
+      var templateSpec = new RawHandlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
 
-    var template = RawHandlebars.template(templateSpec);
+      var template = RawHandlebars.template(templateSpec);
-    template.isMethod = false;
+      template.isMethod = false;
 
-    return template;
+      return template;
-  };
+    };
+  }
 
   RawHandlebars.get = function(ctx, property, options){
     if (options.types && options.data.view) {

app/assets/javascripts/discourse/pre-initializers/register-dom-templates.js.es6

@@ -2,16 +2,14 @@ export default {
   name: "register-discourse-dom-templates",
   before: 'domTemplates',
 
-  // a bit smarter than the default one (domTemplates)
-  // figures out raw vs non-raw automatically
-  // allows overriding
   initialize: function() {
     $('script[type="text/x-handlebars"]').each(function(){
       var $this = $(this);
       var name = $this.attr("name") || $this.data("template-name");
-      Ember.TEMPLATES[name] = name.match(/\.raw$/) ?
+
-        Discourse.EmberCompatHandlebars.compile($this.text()) :
+      if (window.console) {
-        Ember.Handlebars.compile($this.text());
+        window.console.log("WARNING: you have a handlebars template named " + name + " this is an unsupported setup, precompile your templates");
+      }
       $this.remove();
     });
   }

app/assets/javascripts/template_include.js.erb

@@ -0,0 +1,8 @@
+<%
+if Rails.env.development? || Rails.env.test?
+  require_asset ("handlebars.js")
+  require_asset ("ember-template-compiler.js")
+else
+  require_asset ("handlebars.runtime.js")
+end
+%>

app/assets/javascripts/vendor.js

@@ -2,8 +2,7 @@
 //= require ./env
 //= require probes.js
 
-//= require ember-template-compiler
+//= require template_include.js
-//= require handlebars.js
 //= require i18n-patches
 
 //= require loader

app/models/site_customization.rb

@@ -10,6 +10,10 @@ class SiteCustomization < ActiveRecord::Base
     %w(stylesheet mobile_stylesheet embedded_css)
   end
 
+  def self.html_fields
+    %w(body_tag head_tag)
+  end
+
   before_create do
     self.enabled ||= false
     self.key ||= SecureRandom.uuid
@@ -23,7 +27,32 @@ class SiteCustomization < ActiveRecord::Base
     raise e
   end
 
+  def process_html(html)
+    doc = Nokogiri::HTML.fragment(html)
+    doc.css('script[type="text/x-handlebars"]').each do |node|
+      name = node["name"] || node["data-template-name"] || "broken"
+      precompiled =
+        if name =~ /\.raw$/
+          "Discourse.EmberCompatHandlebars.template(#{Barber::EmberCompatPrecompiler.compile(node.inner_html)})"
+        else
+          "Ember.HTMLBars.template(#{Barber::Ember::Precompiler.compile(node.inner_html)})"
+        end
+      compiled = <<SCRIPT
+  Ember.TEMPLATES[#{name.inspect}] = #{precompiled};
+SCRIPT
+      node.replace("<script>#{compiled}</script>")
+    end
+
+    doc.to_s
+  end
+
   before_save do
+    SiteCustomization.html_fields.each do |html_attr|
+      if self.send("#{html_attr}_changed?")
+        self.send("#{html_attr}_baked=", process_html(self.send(html_attr)))
+      end
+    end
+
     SiteCustomization.css_fields.each do |stylesheet_attr|
       if self.send("#{stylesheet_attr}_changed?")
         begin
@@ -126,7 +155,12 @@ class SiteCustomization < ActiveRecord::Base
     val = if styles.present?
       styles.map do |style|
         lookup = target == :mobile ? "mobile_#{field}" : field
-        style.send(lookup)
+        if html_fields.include?(lookup.to_s)
+          style.ensure_baked!(lookup)
+          style.send("#{lookup}_baked")
+        else
+          style.send(lookup)
+        end
       end.compact.join("\n")
     end
 
@@ -142,6 +176,15 @@ class SiteCustomization < ActiveRecord::Base
     @cache.clear
   end
 
+  def ensure_baked!(field)
+    unless self.send("#{field}_baked")
+      if val = self.send(field)
+        val = process_html(val) rescue ""
+        self.update_columns("#{field}_baked" => val)
+      end
+    end
+  end
+
   def remove_from_cache!
     self.class.remove_from_cache!(self.class.enabled_key)
     self.class.remove_from_cache!(key)
@@ -190,6 +233,8 @@ end
 #  mobile_footer           :text
 #  head_tag                :text
 #  body_tag                :text
+#  head_tag_baked          :text
+#  body_tag_baked          :text
 #  top                     :text
 #  mobile_top              :text
 #  embedded_css            :text

db/migrate/20151126233623_add_baked_head_and_body_to_site_customizations.rb

@@ -0,0 +1,6 @@
+class AddBakedHeadAndBodyToSiteCustomizations < ActiveRecord::Migration
+  def change
+    add_column :site_customizations, :head_tag_baked, :text
+    add_column :site_customizations, :body_tag_baked, :text
+  end
+end

spec/models/site_customization_spec.rb

@@ -91,5 +91,32 @@ describe SiteCustomization do
     expect(c.stylesheet_baked).not_to be_present
   end
 
+  it 'should correct bad html in body_tag_baked and head_tag_baked' do
+    c = SiteCustomization.create!(user_id: -1, name: "test", head_tag: "<b>I am bold", body_tag: "<b>I am bold")
+    expect(c.head_tag_baked).to eq("<b>I am bold</b>")
+    expect(c.body_tag_baked).to eq("<b>I am bold</b>")
+  end
+
+  it 'should precompile fragments in body and head tags' do
+    with_template = <<HTML
+    <script type='text/x-handlebars' name='template'>
+      {{hello}}
+    </script>
+    <script type='text/x-handlebars' data-template-name='raw_template.raw'>
+      {{hello}}
+    </script>
+HTML
+    c = SiteCustomization.create!(user_id: -1, name: "test", head_tag: with_template, body_tag: with_template)
+    expect(c.head_tag_baked).to match(/HTMLBars/)
+    expect(c.body_tag_baked).to match(/HTMLBars/)
+    expect(c.body_tag_baked).to match(/EmberCompatHandlebars/)
+    expect(c.head_tag_baked).to match(/EmberCompatHandlebars/)
+  end
+
+  it 'should create body_tag_baked on demand if needed' do
+    c = SiteCustomization.create!(user_id: -1, name: "test", head_tag: "<b>test", enabled: true)
+    c.update_columns(head_tag_baked: nil)
+    expect(SiteCustomization.custom_head_tag).to match(/<b>test<\/b>/)
+  end
 
 end

vendor/assets/javascripts/handlebars.runtime.js

@@ -0,0 +1,666 @@
+/*!
+
+ handlebars v2.0.0
+
+Copyright (C) 2011-2014 by Yehuda Katz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+@license
+*/
+/* exported Handlebars */
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define([], factory);
+  } else if (typeof exports === 'object') {
+    module.exports = factory();
+  } else {
+    root.Handlebars = root.Handlebars || factory();
+  }
+}(this, function () {
+// handlebars/safe-string.js
+var __module3__ = (function() {
+  "use strict";
+  var __exports__;
+  // Build out our basic SafeString type
+  function SafeString(string) {
+    this.string = string;
+  }
+
+  SafeString.prototype.toString = function() {
+    return "" + this.string;
+  };
+
+  __exports__ = SafeString;
+  return __exports__;
+})();
+
+// handlebars/utils.js
+var __module2__ = (function(__dependency1__) {
+  "use strict";
+  var __exports__ = {};
+  /*jshint -W004 */
+  var SafeString = __dependency1__;
+
+  var escape = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "`": "&#x60;",
+    '\n' : '\\n',   // NewLine
+    '\r' : '\\n',   // Return
+    '\b' : '\\b',   // Backspace
+    '\f' : '\\f',   // Form fee
+    '\t' : '\\t',   // Tab
+    '\v' : '\\v'   // Vertical Tab
+  };
+  var badChars = /[&<>"'`\b\f\n\r\t\v]/g;
+  var possible = /[&<>"'`\b\f\n\r\t\v]/;
+
+
+  function escapeChar(chr) {
+    return escape[chr];
+  }
+
+  function extend(obj /* , ...source */) {
+    for (var i = 1; i < arguments.length; i++) {
+      for (var key in arguments[i]) {
+        if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
+          obj[key] = arguments[i][key];
+        }
+      }
+    }
+
+    return obj;
+  }
+
+  __exports__.extend = extend;var toString = Object.prototype.toString;
+  __exports__.toString = toString;
+  // Sourced from lodash
+  // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
+  var isFunction = function(value) {
+    return typeof value === 'function';
+  };
+  // fallback for older versions of Chrome and Safari
+  /* istanbul ignore next */
+  if (isFunction(/x/)) {
+    isFunction = function(value) {
+      return typeof value === 'function' && toString.call(value) === '[object Function]';
+    };
+  }
+  var isFunction;
+  __exports__.isFunction = isFunction;
+  /* istanbul ignore next */
+  var isArray = Array.isArray || function(value) {
+    return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
+  };
+  __exports__.isArray = isArray;
+
+  function escapeExpression(string) {
+    // don't escape SafeStrings, since they're already safe
+    if (string instanceof SafeString) {
+      return string.toString();
+    } else if (string == null) {
+      return "";
+    } else if (!string) {
+      return string + '';
+    }
+
+    // Force a string conversion as this will be done by the append regardless and
+    // the regex test will do this transparently behind the scenes, causing issues if
+    // an object's to string has escaped characters in it.
+    string = "" + string;
+
+    if(!possible.test(string)) { return string; }
+    return string.replace(badChars, escapeChar);
+  }
+
+  __exports__.escapeExpression = escapeExpression;function isEmpty(value) {
+    if (!value && value !== 0) {
+      return true;
+    } else if (isArray(value) && value.length === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  __exports__.isEmpty = isEmpty;function appendContextPath(contextPath, id) {
+    return (contextPath ? contextPath + '.' : '') + id;
+  }
+
+  __exports__.appendContextPath = appendContextPath;
+  return __exports__;
+})(__module3__);
+
+// handlebars/exception.js
+var __module4__ = (function() {
+  "use strict";
+  var __exports__;
+
+  var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
+
+  function Exception(message, node) {
+    var line;
+    if (node && node.firstLine) {
+      line = node.firstLine;
+
+      message += ' - ' + line + ':' + node.firstColumn;
+    }
+
+    var tmp = Error.prototype.constructor.call(this, message);
+
+    // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
+    for (var idx = 0; idx < errorProps.length; idx++) {
+      this[errorProps[idx]] = tmp[errorProps[idx]];
+    }
+
+    if (line) {
+      this.lineNumber = line;
+      this.column = node.firstColumn;
+    }
+  }
+
+  Exception.prototype = new Error();
+
+  __exports__ = Exception;
+  return __exports__;
+})();
+
+// handlebars/base.js
+var __module1__ = (function(__dependency1__, __dependency2__) {
+  "use strict";
+  var __exports__ = {};
+  var Utils = __dependency1__;
+  var Exception = __dependency2__;
+
+  var VERSION = "2.0.0";
+  __exports__.VERSION = VERSION;var COMPILER_REVISION = 6;
+  __exports__.COMPILER_REVISION = COMPILER_REVISION;
+  var REVISION_CHANGES = {
+    1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
+    2: '== 1.0.0-rc.3',
+    3: '== 1.0.0-rc.4',
+    4: '== 1.x.x',
+    5: '== 2.0.0-alpha.x',
+    6: '>= 2.0.0-beta.1'
+  };
+  __exports__.REVISION_CHANGES = REVISION_CHANGES;
+  var isArray = Utils.isArray,
+      isFunction = Utils.isFunction,
+      toString = Utils.toString,
+      objectType = '[object Object]';
+
+  function HandlebarsEnvironment(helpers, partials) {
+    this.helpers = helpers || {};
+    this.partials = partials || {};
+
+    registerDefaultHelpers(this);
+  }
+
+  __exports__.HandlebarsEnvironment = HandlebarsEnvironment;HandlebarsEnvironment.prototype = {
+    constructor: HandlebarsEnvironment,
+
+    logger: logger,
+    log: log,
+
+    registerHelper: function(name, fn) {
+      if (toString.call(name) === objectType) {
+        if (fn) { throw new Exception('Arg not supported with multiple helpers'); }
+        Utils.extend(this.helpers, name);
+      } else {
+        this.helpers[name] = fn;
+      }
+    },
+    unregisterHelper: function(name) {
+      delete this.helpers[name];
+    },
+
+    registerPartial: function(name, partial) {
+      if (toString.call(name) === objectType) {
+        Utils.extend(this.partials,  name);
+      } else {
+        this.partials[name] = partial;
+      }
+    },
+    unregisterPartial: function(name) {
+      delete this.partials[name];
+    }
+  };
+
+  function registerDefaultHelpers(instance) {
+    instance.registerHelper('helperMissing', function(/* [args, ]options */) {
+      if(arguments.length === 1) {
+        // A missing field in a {{foo}} constuct.
+        return undefined;
+      } else {
+        // Someone is actually trying to call something, blow up.
+        throw new Exception("Missing helper: '" + arguments[arguments.length-1].name + "'");
+      }
+    });
+
+    instance.registerHelper('blockHelperMissing', function(context, options) {
+      var inverse = options.inverse,
+          fn = options.fn;
+
+      if(context === true) {
+        return fn(this);
+      } else if(context === false || context == null) {
+        return inverse(this);
+      } else if (isArray(context)) {
+        if(context.length > 0) {
+          if (options.ids) {
+            options.ids = [options.name];
+          }
+
+          return instance.helpers.each(context, options);
+        } else {
+          return inverse(this);
+        }
+      } else {
+        if (options.data && options.ids) {
+          var data = createFrame(options.data);
+          data.contextPath = Utils.appendContextPath(options.data.contextPath, options.name);
+          options = {data: data};
+        }
+
+        return fn(context, options);
+      }
+    });
+
+    instance.registerHelper('each', function(context, options) {
+      if (!options) {
+        throw new Exception('Must pass iterator to #each');
+      }
+
+      var fn = options.fn, inverse = options.inverse;
+      var i = 0, ret = "", data;
+
+      var contextPath;
+      if (options.data && options.ids) {
+        contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
+      }
+
+      if (isFunction(context)) { context = context.call(this); }
+
+      if (options.data) {
+        data = createFrame(options.data);
+      }
+
+      if(context && typeof context === 'object') {
+        if (isArray(context)) {
+          for(var j = context.length; i<j; i++) {
+            if (data) {
+              data.index = i;
+              data.first = (i === 0);
+              data.last  = (i === (context.length-1));
+
+              if (contextPath) {
+                data.contextPath = contextPath + i;
+              }
+            }
+            ret = ret + fn(context[i], { data: data });
+          }
+        } else {
+          for(var key in context) {
+            if(context.hasOwnProperty(key)) {
+              if(data) {
+                data.key = key;
+                data.index = i;
+                data.first = (i === 0);
+
+                if (contextPath) {
+                  data.contextPath = contextPath + key;
+                }
+              }
+              ret = ret + fn(context[key], {data: data});
+              i++;
+            }
+          }
+        }
+      }
+
+      if(i === 0){
+        ret = inverse(this);
+      }
+
+      return ret;
+    });
+
+    instance.registerHelper('if', function(conditional, options) {
+      if (isFunction(conditional)) { conditional = conditional.call(this); }
+
+      // Default behavior is to render the positive path if the value is truthy and not empty.
+      // The `includeZero` option may be set to treat the condtional as purely not empty based on the
+      // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
+      if ((!options.hash.includeZero && !conditional) || Utils.isEmpty(conditional)) {
+        return options.inverse(this);
+      } else {
+        return options.fn(this);
+      }
+    });
+
+    instance.registerHelper('unless', function(conditional, options) {
+      return instance.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn, hash: options.hash});
+    });
+
+    instance.registerHelper('with', function(context, options) {
+      if (isFunction(context)) { context = context.call(this); }
+
+      var fn = options.fn;
+
+      if (!Utils.isEmpty(context)) {
+        if (options.data && options.ids) {
+          var data = createFrame(options.data);
+          data.contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]);
+          options = {data:data};
+        }
+
+        return fn(context, options);
+      } else {
+        return options.inverse(this);
+      }
+    });
+
+    instance.registerHelper('log', function(message, options) {
+      var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
+      instance.log(level, message);
+    });
+
+    instance.registerHelper('lookup', function(obj, field) {
+      return obj && obj[field];
+    });
+  }
+
+  var logger = {
+    methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' },
+
+    // State enum
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+    level: 3,
+
+    // can be overridden in the host environment
+    log: function(level, message) {
+      if (logger.level <= level) {
+        var method = logger.methodMap[level];
+        if (typeof console !== 'undefined' && console[method]) {
+          console[method].call(console, message);
+        }
+      }
+    }
+  };
+  __exports__.logger = logger;
+  var log = logger.log;
+  __exports__.log = log;
+  var createFrame = function(object) {
+    var frame = Utils.extend({}, object);
+    frame._parent = object;
+    return frame;
+  };
+  __exports__.createFrame = createFrame;
+  return __exports__;
+})(__module2__, __module4__);
+
+// handlebars/runtime.js
+var __module5__ = (function(__dependency1__, __dependency2__, __dependency3__) {
+  "use strict";
+  var __exports__ = {};
+  var Utils = __dependency1__;
+  var Exception = __dependency2__;
+  var COMPILER_REVISION = __dependency3__.COMPILER_REVISION;
+  var REVISION_CHANGES = __dependency3__.REVISION_CHANGES;
+  var createFrame = __dependency3__.createFrame;
+
+  function checkRevision(compilerInfo) {
+    var compilerRevision = compilerInfo && compilerInfo[0] || 1,
+        currentRevision = COMPILER_REVISION;
+
+    if (compilerRevision !== currentRevision) {
+      if (compilerRevision < currentRevision) {
+        var runtimeVersions = REVISION_CHANGES[currentRevision],
+            compilerVersions = REVISION_CHANGES[compilerRevision];
+        throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. "+
+              "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").");
+      } else {
+        // Use the embedded version info since the runtime doesn't know about this revision yet
+        throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. "+
+              "Please update your runtime to a newer version ("+compilerInfo[1]+").");
+      }
+    }
+  }
+
+  __exports__.checkRevision = checkRevision;// TODO: Remove this line and break up compilePartial
+
+  function template(templateSpec, env) {
+    /* istanbul ignore next */
+    if (!env) {
+      throw new Exception("No environment passed to template");
+    }
+    if (!templateSpec || !templateSpec.main) {
+      throw new Exception('Unknown template object: ' + typeof templateSpec);
+    }
+
+    // Note: Using env.VM references rather than local var references throughout this section to allow
+    // for external users to override these as psuedo-supported APIs.
+    env.VM.checkRevision(templateSpec.compiler);
+
+    var invokePartialWrapper = function(partial, indent, name, context, hash, helpers, partials, data, depths) {
+      if (hash) {
+        context = Utils.extend({}, context, hash);
+      }
+
+      var result = env.VM.invokePartial.call(this, partial, name, context, helpers, partials, data, depths);
+
+      if (result == null && env.compile) {
+        var options = { helpers: helpers, partials: partials, data: data, depths: depths };
+        partials[name] = env.compile(partial, { data: data !== undefined, compat: templateSpec.compat }, env);
+        result = partials[name](context, options);
+      }
+      if (result != null) {
+        if (indent) {
+          var lines = result.split('\n');
+          for (var i = 0, l = lines.length; i < l; i++) {
+            if (!lines[i] && i + 1 === l) {
+              break;
+            }
+
+            lines[i] = indent + lines[i];
+          }
+          result = lines.join('\n');
+        }
+        return result;
+      } else {
+        throw new Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
+      }
+    };
+
+    // Just add water
+    var container = {
+      lookup: function(depths, name) {
+        var len = depths.length;
+        for (var i = 0; i < len; i++) {
+          if (depths[i] && depths[i][name] != null) {
+            return depths[i][name];
+          }
+        }
+      },
+      lambda: function(current, context) {
+        return typeof current === 'function' ? current.call(context) : current;
+      },
+
+      escapeExpression: Utils.escapeExpression,
+      invokePartial: invokePartialWrapper,
+
+      fn: function(i) {
+        return templateSpec[i];
+      },
+
+      programs: [],
+      program: function(i, data, depths) {
+        var programWrapper = this.programs[i],
+            fn = this.fn(i);
+        if (data || depths) {
+          programWrapper = program(this, i, fn, data, depths);
+        } else if (!programWrapper) {
+          programWrapper = this.programs[i] = program(this, i, fn);
+        }
+        return programWrapper;
+      },
+
+      data: function(data, depth) {
+        while (data && depth--) {
+          data = data._parent;
+        }
+        return data;
+      },
+      merge: function(param, common) {
+        var ret = param || common;
+
+        if (param && common && (param !== common)) {
+          ret = Utils.extend({}, common, param);
+        }
+
+        return ret;
+      },
+
+      noop: env.VM.noop,
+      compilerInfo: templateSpec.compiler
+    };
+
+    var ret = function(context, options) {
+      options = options || {};
+      var data = options.data;
+
+      ret._setup(options);
+      if (!options.partial && templateSpec.useData) {
+        data = initData(context, data);
+      }
+      var depths;
+      if (templateSpec.useDepths) {
+        depths = options.depths ? [context].concat(options.depths) : [context];
+      }
+
+      return templateSpec.main.call(container, context, container.helpers, container.partials, data, depths);
+    };
+    ret.isTop = true;
+
+    ret._setup = function(options) {
+      if (!options.partial) {
+        container.helpers = container.merge(options.helpers, env.helpers);
+
+        if (templateSpec.usePartial) {
+          container.partials = container.merge(options.partials, env.partials);
+        }
+      } else {
+        container.helpers = options.helpers;
+        container.partials = options.partials;
+      }
+    };
+
+    ret._child = function(i, data, depths) {
+      if (templateSpec.useDepths && !depths) {
+        throw new Exception('must pass parent depths');
+      }
+
+      return program(container, i, templateSpec[i], data, depths);
+    };
+    return ret;
+  }
+
+  __exports__.template = template;function program(container, i, fn, data, depths) {
+    var prog = function(context, options) {
+      options = options || {};
+
+      return fn.call(container, context, container.helpers, container.partials, options.data || data, depths && [context].concat(depths));
+    };
+    prog.program = i;
+    prog.depth = depths ? depths.length : 0;
+    return prog;
+  }
+
+  __exports__.program = program;function invokePartial(partial, name, context, helpers, partials, data, depths) {
+    var options = { partial: true, helpers: helpers, partials: partials, data: data, depths: depths };
+
+    if(partial === undefined) {
+      throw new Exception("The partial " + name + " could not be found");
+    } else if(partial instanceof Function) {
+      return partial(context, options);
+    }
+  }
+
+  __exports__.invokePartial = invokePartial;function noop() { return ""; }
+
+  __exports__.noop = noop;function initData(context, data) {
+    if (!data || !('root' in data)) {
+      data = data ? createFrame(data) : {};
+      data.root = context;
+    }
+    return data;
+  }
+  return __exports__;
+})(__module2__, __module4__, __module1__);
+
+// handlebars.runtime.js
+var __module0__ = (function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
+  "use strict";
+  var __exports__;
+  /*globals Handlebars: true */
+  var base = __dependency1__;
+
+  // Each of these augment the Handlebars object. No need to setup here.
+  // (This is done to easily share code between commonjs and browse envs)
+  var SafeString = __dependency2__;
+  var Exception = __dependency3__;
+  var Utils = __dependency4__;
+  var runtime = __dependency5__;
+
+  // For compatibility and usage outside of module systems, make the Handlebars object a namespace
+  var create = function() {
+    var hb = new base.HandlebarsEnvironment();
+
+    Utils.extend(hb, base);
+    hb.SafeString = SafeString;
+    hb.Exception = Exception;
+    hb.Utils = Utils;
+    hb.escapeExpression = Utils.escapeExpression;
+
+    hb.VM = runtime;
+    hb.template = function(spec) {
+      return runtime.template(spec, hb);
+    };
+
+    return hb;
+  };
+
+  var Handlebars = create();
+  Handlebars.create = create;
+
+  Handlebars['default'] = Handlebars;
+
+  __exports__ = Handlebars;
+  return __exports__;
+})(__module1__, __module3__, __module4__, __module2__, __module5__);
+
+  return __module0__;
+}));