bob-rails 0.0.1

data/app/assets/javascripts/bob.js

@@ -0,0 +1,1989 @@
+(function() {
+    "use strict";
+    var utils$bind$$bind;
+
+    if (typeof Function.prototype.bind === 'function') {
+      utils$bind$$bind = function(func, target) {
+        return func && func.bind(target);
+      };
+    } else {
+      utils$bind$$bind = function(func, target) {
+        return func && function() {
+          func.apply(target, arguments);
+        };
+      };
+    }
+
+    var utils$bind$$default = utils$bind$$bind;
+
+    function utils$logger$$NOOP() { }
+
+    function utils$logger$$consoleMethod(console, name, fallback) {
+      var method = typeof console === 'object' ? console[name] : null;
+
+      if (method) {
+        // Older IE doesn't support bind/apply, but Chrome needs it
+        if (typeof method.bind === 'function' || typeof method.apply === 'function') {
+          return utils$bind$$default(method, console);
+        } else {
+          return function(message) {
+            method(message);
+          };
+        }
+      } else if (fallback) {
+        return fallback;
+      } else {
+        // Use the log method with a tag (e.g. [WARN]) as a default fallback
+        var tag = '[' + name.toUpperCase() + '] ';
+        return function(message) {
+          this.log(tag + message);
+        }
+      }
+    }
+
+    var utils$logger$$LEVELS = {
+      debug: 0,
+      info:  1,
+      warn:  2,
+      error: 3,
+      all: 4
+    };
+
+    function utils$logger$$Logger(console, minLevel) {
+      minLevel = utils$logger$$LEVELS[minLevel] - 1;
+
+      /**
+       * Logs *message* to the console.
+       *
+       * @method log
+       * @params {Object} [message] The message to log.
+       */
+      this.log = utils$logger$$consoleMethod(console, 'log', utils$logger$$NOOP);
+
+      /**
+       * Logs *message* to the console at the `debug` level.
+       *
+       * @method debug
+       * @params {Object} [message] The message to log.
+       */
+      this.debug = (minLevel >= utils$logger$$LEVELS.debug) ? utils$logger$$NOOP : utils$logger$$consoleMethod(console, 'debug');
+
+      /**
+       * Logs *message* to the console at the `info` level.
+       *
+       * @method info
+       * @params {Object} [message] The message to log.
+       */
+      this.info = (minLevel >= utils$logger$$LEVELS.info) ? utils$logger$$NOOP : utils$logger$$consoleMethod(console, 'info');
+
+      /**
+       * Logs *message* to the console at the `warn` level.
+       *
+       * @method warn
+       * @params {Object} [message] The message to log.
+       */
+      this.warn = (minLevel >= utils$logger$$LEVELS.warn) ? utils$logger$$NOOP : utils$logger$$consoleMethod(console, 'warn');
+
+      /**
+       * Logs *message* to the console at the `error` level.
+       *
+       * @method log
+       * @params {Object} [message] The message to log.
+       */
+      this.error = (minLevel >= utils$logger$$LEVELS.error) ? utils$logger$$NOOP : utils$logger$$consoleMethod(console, 'error');
+    }
+    var utils$logger$$default = utils$logger$$Logger;
+    var utils$create$$create;
+
+    function utils$create$$Factory() {}
+
+    if (typeof Object.create === "function") {
+      utils$create$$create = Object.create;
+    } else {
+      utils$create$$create = function(proto) {
+        if (typeof proto !== "object" && typeof proto !== "function") {
+          throw new TypeError("Object prototype may only be an Object");
+        }
+
+        utils$create$$Factory.prototype = proto;
+
+        return new utils$create$$Factory();
+      }
+    }
+
+    var utils$create$$default = utils$create$$create;
+    function utils$object$$REQUIRED() {
+      return utils$object$$REQUIRED;
+    }
+
+    utils$object$$REQUIRED.toString = function() {
+      return "(Required Property)";
+    };
+
+    function utils$object$$LAZY(factory) {
+      if (this instanceof utils$object$$LAZY) {
+        this.factory = factory;
+      } else {
+        return new utils$object$$LAZY(factory);
+      }
+    }
+
+    utils$object$$LAZY.prototype.toString = function() {
+      return "(Lazy Property)";
+    };
+
+    /**
+     * The base class for other objects in Bob. The purpose of this base class is to
+     * facilate class-based inheritance in JavaScript by providing helpers for
+     * subclassing, overriding methods and introspecting the inheritance chain.
+     *
+     * @class Object
+     * @namespace Bob
+     */
+    var utils$object$$BobObject;
+
+    function utils$object$$NOOP() { }
+
+    function utils$object$$wrap(func, superFunc) {
+      if (
+        typeof superFunc === "undefined" ||
+        typeof superFunc !== "function" ||
+        superFunc.__class__ ||
+        superFunc.__interface__ ||
+        superFunc === utils$object$$REQUIRED ||
+        superFunc instanceof utils$object$$LAZY
+      ) {
+        return func;
+      }
+
+      function superWrapper() {
+        var ret;
+        var sup  = this && this.__nextSuper;
+        if(this) { this.__nextSuper = superFunc; }
+        ret = func.apply(this, arguments);
+        if(this) { this.__nextSuper = sup; }
+        return ret;
+      }
+
+      return superWrapper;
+    }
+
+    function utils$object$$mergeProtoProps(proto, protoProps) {
+      for (var key in protoProps) {
+        if (protoProps.hasOwnProperty(key)) {
+          if (typeof protoProps[key] === "function") {
+            proto[key] = utils$object$$wrap(protoProps[key], proto[key]);
+          } else {
+            proto[key] = protoProps[key];
+          }
+        }
+      }
+
+      return proto;
+    }
+
+    function utils$object$$classToString() {
+      if (this.__name__) {
+        return this.__name__;
+      } else {
+        var klass = this;
+
+        while (klass && !klass.__name__) {
+          klass = klass.superclass;
+        }
+
+        if (klass && klass.__name__) {
+          return "(subclass of " + klass.__name__ + ")";
+        } else {
+          return "(unknown class)";
+        }
+      }
+    }
+
+    function utils$object$$initializeLazyProperties(instance, props) {
+      props.forEach(function(key) {
+        if(instance[key] instanceof utils$object$$LAZY) {
+          instance[key] = instance[key].factory.call();
+        }
+      });
+    }
+
+    function utils$object$$ensureRequired(instance, props) {
+      props.forEach(function(key) {
+        if(instance[key] === utils$object$$REQUIRED) {
+          throw key + " is required for " + instance.constructor.toString();
+        }
+      });
+    }
+
+    /**
+     * Creates a subclass.
+     *
+     * ```javascript
+     * var Vehicle = Bob.Object.extend();
+     * var Car     = Vehicle.extend();
+     *
+     * var myBike = new Vehicle();
+     *
+     * myBike instanceof Object     // => true
+     * myBike instanceof Bob.Object // => true
+     * myBike instanceof Vehicle    // => true
+     * myBike instanceof Car        // => false
+     * ```
+     *
+     * You can also pass an object to `extend` that contains a set of properties to
+     * define on the class's prototype. Functions inside the object becomes methods
+     * on the subclass. If they override an existing method on the super class, then
+     * the superclass' implmentation will be available through `this._super` when
+     * the method is invoked (see its documentaion for details). Methods should only
+     * be defined on a class at `extend` time, otherwise `this._super` would not
+     * function correctly.
+     *
+     * @method extend
+     * @static
+     * @param {Object} [protoProps] A object containing the properties and methods
+     *   to define on the subclass.
+     *
+     * @return {Class} The constructor function for the newly created subclass.
+     */
+    function utils$object$$extend(protoProps) {
+      var SuperClass = this, required = [], lazy = [];
+
+      function Class() {
+        utils$object$$initializeLazyProperties(this, lazy);
+        this.init.apply(this, arguments);
+        utils$object$$ensureRequired(this, required);
+      };
+
+      /**
+       * @private
+       *
+       * @property __class__
+       * @type Boolean
+       * @static
+       */
+      Class.__class__ = true;
+
+      /**
+       * Points to the class' parent.
+       *
+       * @property superclass
+       * @type Class
+       * @static
+       */
+      Class.superclass = SuperClass;
+      Class.extend = utils$object$$extend;
+      Class.toString = utils$object$$classToString;
+
+      Class.prototype = utils$create$$default(SuperClass.prototype);
+      Class.prototype = utils$object$$mergeProtoProps(Class.prototype, protoProps);
+
+      /**
+       * Points to the class that created the instance.
+       *
+       * @property constructor
+       * @type Class
+       */
+      Class.prototype.constructor = Class;
+
+      // Cache the required & lazy attributes (they can only be added at `extend` time)
+      for (var key in Class.prototype) {
+        if(Class.prototype[key] === utils$object$$REQUIRED) {
+          required.push(key);
+        } else if (Class.prototype[key] instanceof utils$object$$LAZY) {
+          lazy.push(key);
+        }
+      }
+
+      return Class;
+    }
+
+    utils$object$$BobObject = utils$object$$extend.call(Object, {
+
+      /**
+       * Called when an instance is created with the same arguments that is passed to
+       * the constructor function.
+       *
+       * ```javascript
+       * var Person = Bob.Object.extend({
+       *   init: function(name) {
+       *     this.name = name;
+       *   }
+       * });
+       *
+       * var bob = new Person("Bob");
+       *
+       * bob.name // => "Bob"
+       * ```
+       *
+       * @method init
+       */
+      init: utils$object$$NOOP,
+
+      /**
+       * When invoking an overriden method on a subclass, use this method to access
+       * the original implementation:
+       *
+       * ```javascript
+       * var Person = Bob.Object.extend({
+       *   init: function(name) {
+       *     this.name = name;
+       *   },
+       *
+       *   sayGreeting: function() {
+       *     return "Hello from " + this.name;
+       *   }
+       * });
+       *
+       * var AngryPerson = Person.extend({
+       *   sayGreeting: function() {
+       *     return this._super().toUpperCase() + "!!!";
+       *   }
+       * });
+       *
+       * var bob = new Person("Bob");
+       *
+       * bob.sayGreeting() // => "Hello from Bob"
+       *
+       * var angryBob = new Person("Bob");
+       *
+       * angryBob.sayGreeting() // => "HELLO FROM BOB!!!"
+       * ```
+       *
+       * NOTE: For this feature to work properly, methods can only be added to a
+       * class' prototype at `extend` time.
+       *
+       * @method _super
+       */
+      _super: function() {
+        var func = this.__nextSuper;
+        var ret;
+        if (func) {
+          this.__nextSuper = null;
+          ret = func.apply(this, arguments);
+          this.__nextSuper = func;
+        }
+        return ret;
+      },
+
+      toString: function() {
+        return "<" + this.constructor.toString() + ">";
+      }
+
+    });
+
+    /**
+     * @private
+     *
+     * A descriptor for the class (used by `toString`).
+     *
+     * @property __name__
+     * @type String
+     * @static
+     */
+    utils$object$$BobObject.__name__ = "Bob.Object";
+
+    var utils$object$$default = utils$object$$BobObject;
+
+    /**
+     * The is somewhat inspired by the Ember container (since "container" has a
+     * different meaning in Bob, it's called a registry instead). As usual, we only
+     * implement a very small subset of features compared to the Ember-eqivilant.
+     */
+
+    var utils$registry$$NullRegistry = {
+      lookup: function() {
+        return undefined;
+      },
+
+      hasKey: function() {
+        return false;
+      }
+    };
+
+    var utils$registry$$default = utils$object$$default.extend({
+
+      init: function(parent) {
+        this.parent  = parent || utils$registry$$NullRegistry;
+        this.content = {};
+      },
+
+      /**
+       * Register an object under *key*.
+       *
+       * By convention, the format of *key* should be:
+       *
+       *   type:path
+       *
+       * Where `type` is an `identifier` and `path` is one or more `identifier`s
+       * joined by "/". An `identifer` should begin with a lowercase letter (a-z),
+       * followed by any number of lowercase letters (a-z), numbers (0-9) or the "-"
+       * character (a "-" should not be the last character of an `identifier`).
+       *
+       * Some examples:
+       *
+       * - "template:modern"
+       * - "view:container"
+       * - "view:container/sidebar"
+       * - "view:container/main/column-2"
+       *
+       * @method register
+       * @params {String} [key] See above.
+       * @params {*} [object] The object to register under *key*.
+       */
+      register: function(key, object) {
+        this.content[key] = object;
+        return object;
+      },
+
+      /**
+       * Unregister *key*.
+       *
+       * @method unregister
+       * @params {String} [key] See `register`.
+       * @return {*} The object previously registered under *key*, if any.
+       */
+      unregister: function(key) {
+        var object = this.content[key];
+        delete this.content[key];
+        return object;
+      },
+
+      /**
+       * Lookup the object registered under *key*.
+       *
+       * @method lookup
+       * @params {String} [key] See `register`.
+       * @return {*} The object registered under *key*, if any.
+       */
+      lookup: function(key) {
+        if(this.content.hasOwnProperty(key)) {
+          return this.content[key];
+        } else {
+          return this.parent.lookup(key);
+        }
+      },
+
+      /**
+       * Check if an object has been registered under *key*.
+       *
+       * @method hasKey
+       * @params {String} [key] See `register`.
+       * @params {Boolean} [checkParents=false] Also check if *key* is present on the parents.
+       * @return {Boolean} Whether *key* has been registered.
+       */
+      hasKey: function(key, checkParents) {
+        checkParents = checkParents || false;
+        return this.content.hasOwnProperty(key) || (checkParents && this.parent.hasKey(key, true));
+      }
+
+    });
+
+    /**
+     * The main Bob namespace.
+     *
+     * @class Bob
+     * @static
+     */
+    var core$$Bob = {
+
+      /**
+       * A shared logger instance. You can replace this with another logger to
+       * control what gets logged and where to log message goes.
+       *
+       * By default, this propoerty contains a `Bob.Logger` that logs to global
+       * `console` object at the `"info"` log level.
+       *
+       * @property logger
+       * @type Bob.Logger
+       */
+      logger: new utils$logger$$default(console, "info"),
+
+      /**
+       * @private
+       *
+       * The global registry.
+       *
+       * @property registry
+       * @type Registry
+       */
+      registry: new utils$registry$$default(null),
+
+      /**
+       * Register an object under *key*.
+       *
+       * By convention, the format of *key* should be:
+       *
+       *   type:path
+       *
+       * Where `type` is an `identifier` and `path` is one or more `identifier`s
+       * joined by "/". An `identifer` should begin with a lowercase letter (a-z),
+       * followed by any number of lowercase letters (a-z), numbers (0-9) or the "-"
+       * character (a "-" should not be the last character of an `identifier`).
+       *
+       * Some examples:
+       *
+       * - "template:modern"
+       * - "view:container"
+       * - "view:container/sidebar"
+       * - "view:container/main/column-2"
+       *
+       * @method register
+       * @params {String} [key] See above.
+       * @params {*} [object] The object to register under *key*.
+       */
+      register: function(key, object) {
+        this.registry.register(key, object);
+      }
+
+    };
+
+    var core$$default = core$$Bob;
+
+    function utils$hash$lookup$$test(value) {
+      return value !== null && value !== undefined && value !== "";
+    }
+
+    var utils$hash$lookup$$default = utils$object$$default.extend({
+
+      init: function(hash) {
+        this.hash = hash || {};
+      },
+
+      /**
+       * Lookup the given `path` on the hash. This performs a recurrsive lookup,
+       * i.e. if you pass `"some.nested.key"`, it will return the value stored at
+       * `hash.some.nested.key`. If the path or any intermediate keys along it is
+       * `undefined`, `null` or an empty string, the `fallback` value (defaults to
+       * an empty string) is returned instead.
+       *
+       * @method get
+       * @params {String} [path] The lookup path.
+       * @params {Object} [fallback=""] The fallback value.
+       * @return {Object} The value at the given `path` on the lookup hash, or the
+       *   `fallback` value if it does not exist.
+       */
+      get: function(path, fallback) {
+        if (arguments.length < 2) {
+          fallback = "";
+        }
+
+        var keys = path.split("."), lookup = this.hash;
+
+        while(true) {
+          if (!utils$hash$lookup$$test(lookup)) {
+            return fallback;
+          } else if(keys.length === 0) {
+            return lookup;
+          } else {
+            lookup = lookup[keys.shift()];
+          }
+        }
+      },
+
+      /**
+       * Set the given `path` to a specific value.This performs a recurrsive set,
+       * i.e. if you pass `"some.nested.key"`, it will set the value stored at
+       * `hash.some.nested.key`, creating  If any intermediate keys along the path
+       * is `undefined` or `null`, they will first be initialized to an empty
+       * object (`{}`).
+       *
+       * @method set
+       * @params {String} [path] The path to set.
+       * @params {Object} [value] The value to set.
+       * @return {Object} The value at the given `path` on the lookup hash, or the
+       *   `fallback` value if it does not exist.
+       */
+      set: function(path, value) {
+        var keys = path.split("."), lookup = this.hash;
+
+        while(keys.length > 1) {
+          if (!utils$hash$lookup$$test(lookup[keys[0]])) {
+            lookup[keys[0]] = {};
+          }
+
+          lookup = lookup[keys.shift()];
+        }
+
+        lookup[keys.shift()] = value;
+      }
+
+    });
+
+    function dom$document$$emptyNode(node) {
+      while (node && node.childNodes.length) {
+        node.removeChild(node.firstChild);
+      }
+
+      return node;
+    }
+
+    function dom$document$$doesItWork(func){
+      try {
+        return !! func.call();
+      } catch(e) {
+        return false;
+      }
+    }
+
+    var dom$document$$supportsCreateHTMLDocument = dom$document$$doesItWork(function() {
+      var doc = document.implementation.createHTMLDocument();
+
+      dom$document$$emptyNode(doc);
+
+      return doc &&
+        (doc.nodeType === Node.DOCUMENT_NODE) &&
+        (doc.compatMode === "CSS1Compat") &&
+        (doc.children.length === 0) &&
+        (doc.documentElement === null);
+    });
+
+    var dom$document$$createDocument;
+
+    if (dom$document$$supportsCreateHTMLDocument) {
+      dom$document$$createDocument = function() {
+        return dom$document$$emptyNode(document.implementation.createHTMLDocument());
+      };
+    } else {
+      dom$document$$createDocument = function() {
+        var iframe = document.createElement("iframe");
+        var parent = document.body || document.documentElement;
+
+        iframe.style.display = "none";
+        iframe.src = "about:blank";
+
+        try {
+          parent.appendChild(iframe);
+
+          iframe.contentDocument.open();
+          iframe.contentDocument.write("<!doctype HTML><html><head></head><body></body></html>");
+          iframe.contentDocument.close();
+
+          return dom$document$$emptyNode(iframe.contentDocument);
+        } finally {
+          try {
+            parent.removeChild(iframe);
+          } catch(e) {
+            // The insertion probably failed
+          }
+        }
+      };
+    }
+
+    function dom$document$$prepareDocument(doc) {
+      return dom$document$$emptyNode(doc);
+    }
+
+    var dom$dom$builder$$default = utils$object$$default.extend({
+
+      init: function(document) {
+        this.stack = [];
+
+        /**
+         * The underlying `Document` object.
+         *
+         * @property document
+         * @type Document
+         */
+        this.document = document;
+      },
+
+      /**
+       * Create an element and push it on to the stack.
+       *
+       * @method createElement
+       * @param {String} [tagName] The tag name for the element.
+       */
+      createElement: function(tagName) {
+        this.stack.push( this.document.createElement(tagName) );
+      },
+
+      /**
+       * Get the element on the top of the stack.
+       *
+       * @method getElement
+       * @return {Element} The element on the top of the stack.
+       */
+      getElement: function() {
+        return this.stack[ this.stack.length - 1 ];
+      },
+
+      /**
+       * Get the element on the top of the stack with an assertion.
+       *
+       * @private
+       * @method ensureElement
+       * @params {Integer} [count=1] Minimum number of elements on the stack.
+       * @return {Element} The element on the top of the stack.
+       */
+      ensureElement: function(count) {
+        count = count || 1;
+
+        if (count === 1 && this.stack.length === 0) {
+          throw "This operation requires an element on the stack but there are none.";
+        } else if(this.stack.length < count) {
+          throw "This operation requires "+ count + " elements on the stack but there are only " + this.stack.length + ".";
+        }
+
+        return this.getElement();
+      },
+
+      /**
+       * Set an attribute for the element on the top of the stack. Throws an error
+       * if the stack is empty.
+       *
+       * @method setAttribute
+       * @params {String} [name] The name of the attribute to set.
+       * @params {String} [value] The value of the attribute to set.
+       */
+      setAttribute: function(name, value) {
+        this.ensureElement().setAttribute(name, value);
+      },
+
+      /**
+       * Create a text node and immediately append it to the current element on the
+       * top of the stack.
+       *
+       * @method appendTextNode
+       * @params {String} [content] The content of the text node to append.
+       */
+      appendTextNode: function(content) {
+        this.ensureElement().appendChild( this.document.createTextNode(content) );
+      },
+
+      /**
+       * Create a comment node and immediately append it to the current element on
+       * the top of the stack.
+       *
+       * @method appendComment
+       * @params {String} [content] The content of the comment to append.
+       */
+      appendComment: function(content) {
+        this.ensureElement().appendChild( this.document.createComment(content) );
+      },
+
+      /**
+       * Append the top element on the stack to the previous element and pop the top
+       * element off the stack.
+       *
+       * @method appendElement
+       */
+      appendElement: function() {
+        this.ensureElement(2);
+        var child = this.stack.pop(), parent = this.getElement();
+        parent.appendChild( child );
+      }
+    });
+
+    function dom$serialize$$escapeHTML(text) {
+      return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/\//g, '&#x2F;');
+    }
+
+    // We can't apply the HTML entities escape inside a <style> tag
+    function dom$serialize$$escapeStyleTag(text) {
+      return text.replace(/<\//g, "\\00003C\\00002F");
+    }
+
+    function dom$serialize$$escapeAttribute(text) {
+      return text
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#x27;');
+    }
+
+    // See http://www.w3.org/TR/html-markup/spec.html#comments
+    function dom$serialize$$escapeComment(text) {
+      return text
+        .replace(/--/g, '')
+        .replace(/^-?>/g, '')
+        .replace(/-$/g, '');
+    }
+
+    var dom$serialize$$voidTags = [
+      "area", "base", "br", "col", "command", "embed", "hr", "img", "input",
+      "keygen", "link", "meta", "param", "source", "track", "wbr"
+    ];
+
+    function dom$serialize$$isVoid(element) {
+      return dom$serialize$$voidTags.indexOf(element.nodeName.toLowerCase()) >= 0;
+    }
+
+    function dom$serialize$$elementToString(element, xhtml) {
+      var i, buffer = [];
+
+      buffer.push("<");
+      buffer.push(element.nodeName.toLowerCase());
+
+      for (i=0; i<element.attributes.length; i++) {
+        buffer.push(" ");
+        buffer.push(element.attributes[i].name);
+        buffer.push("=\"");
+        buffer.push(dom$serialize$$escapeAttribute(element.attributes[i].value));
+        buffer.push("\"");
+      }
+
+      if (dom$serialize$$isVoid(element)) {
+        buffer.push( xhtml ? " />" : ">" );
+      } else {
+        buffer.push(">");
+
+        for (i=0; i<element.childNodes.length; i++) {
+          buffer.push(dom$serialize$$serialize(element.childNodes[i], xhtml, element));
+        }
+
+        buffer.push("</");
+        buffer.push(element.nodeName.toLowerCase());
+        buffer.push(">");
+      }
+
+      return buffer.join("");
+    }
+
+    function dom$serialize$$serialize(node, xhtml, context) {
+      switch(node.nodeType) {
+        case Node.DOCUMENT_NODE:
+          return dom$serialize$$serialize(node.documentElement, xhtml);
+
+        case Node.ELEMENT_NODE:
+          return dom$serialize$$elementToString(node, xhtml);
+
+        case Node.TEXT_NODE:
+          if (context && context.nodeName.toLowerCase() === "style") {
+            return dom$serialize$$escapeStyleTag(node.nodeValue);
+          } else {
+            return dom$serialize$$escapeHTML(node.nodeValue);
+          }
+
+        case Node.COMMENT_NODE:
+          return "<!--" + dom$serialize$$escapeComment(node.nodeValue) + "-->";
+
+        default:
+          return "";
+      }
+    }
+    var dom$serialize$$default = dom$serialize$$serialize;
+    function utils$interface$$Interface(name, properties) {
+      if (properties.hasOwnProperty("constructor")) {
+        throw "An interface cannot have a `constructor` property";
+      }
+
+      var required = [], lazy = [];
+
+      function __Interface__(obj) {
+        if (obj instanceof __Interface__) {
+          return obj;
+        } else if (this instanceof __Interface__) {
+          for (var key in obj) {
+            if (obj.hasOwnProperty(key)) {
+              this[key] = obj[key];
+            }
+          }
+
+          utils$object$$initializeLazyProperties(this, lazy);
+          utils$object$$ensureRequired(this, required);
+        } else {
+          return new __Interface__(obj);
+        }
+      }
+
+      __Interface__.prototype = utils$create$$default(utils$interface$$Interface.prototype);
+
+      __Interface__.prototype.constructor = __Interface__;
+
+      __Interface__.superclass = utils$interface$$Interface;
+
+      __Interface__.__interface__ = true;
+
+      __Interface__.__name__ = name;
+
+      __Interface__.toString = function() {
+        return name;
+      };
+
+      for (var key in properties) {
+        if (properties.hasOwnProperty(key)) {
+          __Interface__.prototype[key] = properties[key];
+
+          if(properties[key] === utils$object$$REQUIRED) {
+            required.push(key);
+          } else if (properties[key] instanceof utils$object$$LAZY) {
+            lazy.push(key);
+          }
+        }
+      }
+
+      return __Interface__;
+    }
+
+    var utils$interface$$default = utils$interface$$Interface;
+
+    utils$interface$$Interface.prototype = {};
+
+    utils$interface$$Interface.superclass = Object;
+
+    utils$interface$$Interface.__name__ = "Interface";
+
+    utils$interface$$Interface.toString = function() {
+      return "Interface";
+    };
+
+    utils$interface$$Interface.extend = function(name, props) {
+      return utils$interface$$Interface(name, props);
+    };
+
+    var template$layout$$default = utils$interface$$default("Layout", {
+
+      /**
+       * The root element of the layout. Must be an acceptable `documentElement` for
+       * the specified `doctype`.
+       *
+       * @property element
+       * @type Element
+       * @required
+       */
+      element: utils$object$$REQUIRED,
+
+      /**
+       * The main container that content blocks can be inserted into.
+       *
+       * @property container
+       * @type Container
+       * @required
+       */
+      container: utils$object$$REQUIRED,
+
+      /**
+       * The editable elements in the layout. These elements should be a child of
+       * `element` (or `element` itself) and they should not overlap (i.e. editable
+       * elements cannot be nested).
+       *
+       * @property editables
+       * @type Editable[]
+       * @default []
+       */
+      editables: utils$object$$LAZY(Array)
+
+    });
+
+    var template$block$$default = utils$interface$$default("Block", {
+
+      /**
+       * The type of the block.
+       *
+       * @property type
+       * @type String
+       * @required
+       */
+      type: utils$object$$REQUIRED,
+
+      /**
+       * The root element of the content block. Must be a block-level element.
+       *
+       * @property element
+       * @type Element
+       * @required
+       */
+      element: utils$object$$REQUIRED,
+
+      /**
+       * The editable elements in the block. These elements should be a child of
+       * `element` (or `element` itself) and they should not overlap (i.e. editable
+       * elements cannot be nested).
+       *
+       * @property editables
+       * @type Editable[]
+       * @default []
+       */
+      editables: utils$object$$LAZY(Array)
+
+    });
+
+    var template$editable$$default = utils$interface$$default("Editable", {
+
+      /**
+       * An identifier for the editable element.
+       *
+       * @property name
+       * @type String
+       * @required
+       */
+      name: utils$object$$REQUIRED,
+
+      /**
+       * The type of the editable content.
+       *
+       * @property type
+       * @type String
+       * @required
+       */
+      type: utils$object$$REQUIRED,
+
+      /**
+       * Options for the editor plugin.
+       *
+       * @property options
+       * @type Object
+       * @default {}
+       */
+      options: utils$object$$LAZY(Object),
+
+       /**
+        * The editable element.
+        *
+        * @property element
+        * @type Element
+        * @required
+        */
+       element: utils$object$$REQUIRED
+
+    });
+
+    var template$container$$default = utils$interface$$default("Container", {
+
+      /**
+       * The root element of the content block. The element should initially be
+       * empty and it should be a valid parent for block-level elements.
+       *
+       * @property element
+       * @type Element
+       * @required
+       */
+      element: utils$object$$REQUIRED
+
+    });
+
+    var views$states$$default = [
+      {
+        name: "hasElement",
+        transitions: [
+          {
+            name:   "insertElement",
+            next:   "inDOM",
+            before: "willInsertElement",
+            after:  "didInsertElement"
+          }
+        ]
+      },
+
+      {
+        name: "inDOM",
+        transitions: [
+          {
+            name:   "detachElement",
+            next:   "detached",
+            before: "willDetachElement"
+          },
+          {
+            name:    "destroyElement",
+            next:    "destroyed",
+            before:  "willDestroyElement",
+            cascade: true
+          }
+        ]
+      },
+
+      {
+        name: "detached",
+        transitions: [
+          {
+            name:   "reattachElement",
+            next:   "inDOM",
+            before: "willReattachElement",
+            after:  "didReattachElement",
+          },
+
+        ]
+      },
+
+      {
+        name: "destroyed"
+      }
+    ];
+
+    /**
+     * @private
+     *
+     * @class State
+     * @namespace Interface
+     */
+    var views$state$machine$$State = utils$interface$$default("State", {
+
+      /**
+       * @property name
+       * @type String
+       * @required
+       */
+      name: utils$object$$REQUIRED,
+
+      /**
+       * @property transitions
+       * @type Transition[]
+       * @default []
+       */
+      transitions: utils$object$$LAZY(Array)
+
+    });
+
+    /**
+     * @private
+     *
+     * @class Transition
+     * @namespace Interface
+     */
+    var views$state$machine$$Transition = utils$interface$$default("Transition", {
+
+      /**
+       * @property name
+       * @type String
+       * @required
+       */
+      name: utils$object$$REQUIRED,
+
+      /**
+       * @property next
+       * @type String
+       * @required
+       */
+      next: utils$object$$REQUIRED,
+
+      /**
+       * @property before
+       * @type String
+       * @default undefined
+       */
+      before: undefined,
+
+      /**
+       * @property after
+       * @type String
+       * @default undefined
+       */
+      after: undefined,
+
+      /**
+       * @property cascade
+       * @type Boolean
+       * @default false
+       */
+      cascade: utils$object$$LAZY(Boolean)
+
+    });
+
+    function views$state$machine$$setState(newState) {
+      this.state = newState;
+    }
+
+    function views$state$machine$$apply(instance, method, args) {
+      if (typeof method !== "function") {
+        method = instance[method];
+      }
+
+      if (args && args.length) {
+        return method.apply(instance, [].slice.call(args));
+      } else {
+        return method.call(instance);
+      }
+    }
+
+    function views$state$machine$$applyPreOrder(instance, method, args) {
+      var childViews = instance.childViews;
+
+      for (var i=0; i<childViews.length; i++) {
+        views$state$machine$$applyPreOrder(childViews[i], method, args);
+      }
+
+      return views$state$machine$$apply(instance, method, args);
+    }
+
+    function views$state$machine$$makeTransition(state, transition) {
+      return function() {
+        var rtn;
+
+        if (this.state !== state.name) {
+          throw "Cannot call " + transition.name + " from the " + this.state + " state: " + this.toString();
+        }
+
+        if (transition.before) {
+          views$state$machine$$applyPreOrder(this, transition.before);
+        }
+
+        if (transition.cascade) {
+          rtn = views$state$machine$$applyPreOrder(this, "_" + transition.name, arguments);
+        } else {
+          rtn = views$state$machine$$apply(this, "_" + transition.name, arguments);
+        }
+
+        views$state$machine$$applyPreOrder(this, views$state$machine$$setState, [transition.next]);
+
+        if (transition.after) {
+          views$state$machine$$applyPreOrder(this, transition.after);
+        }
+
+        return rtn;
+      }
+    }
+
+    var views$state$machine$$default = function(states, klass) {
+      if (states.length === 0) {
+        throw "Need at least one state";
+      }
+
+      var rootState = views$state$machine$$State(states[0]);
+
+      var protoProps = {};
+
+      protoProps.init = function() {
+        this._super.apply(this, arguments);
+        this.state = rootState.name;
+      }
+
+      var state, transition;
+
+      for (var i=0; i<states.length; i++) {
+        state = views$state$machine$$State(states[i]);
+
+        for (var j=0; j<state.transitions.length; j++) {
+          transition = views$state$machine$$Transition(state.transitions[j]);
+          protoProps[transition.name] = views$state$machine$$makeTransition(state, transition);
+        }
+      }
+
+      return klass.extend(protoProps);
+    };
+
+    function views$view$$NOOP() {}
+
+    function views$view$$NULL(value) {
+      if (typeof value === "undefined") {
+        return null;
+      } else {
+        return value;
+      }
+    }
+
+    var views$view$$default = views$state$machine$$default(views$states$$default, utils$object$$default.extend({
+
+      init: function(element, options, data) {
+        this.element = element;
+        this.options = options;
+
+        if (views$view$$NULL(data) === null) {
+          this.data = this.serialize();
+        } else {
+          this.data = data;
+          this.deserialize();
+        }
+      },
+
+      /**
+       * The element managed by this view.
+       *
+       * @property element
+       * @type Element
+       * @required
+       */
+      element: utils$object$$REQUIRED,
+
+      /**
+       * @private
+       *
+       * @property parentView
+       * @type View
+       * @default null
+       */
+      parentView: null,
+
+      /**
+       * @private
+       *
+       * A list of child views managed by this view.
+       *
+       * @property childViews
+       * @type View[]
+       * @default []
+       */
+      childViews: utils$object$$LAZY(Array),
+
+      /**
+       * @private
+       *
+       * Add *view* to the list of managed child views.
+       *
+       * @method addChildView
+       * @param {View} [view] The child view to add.
+       */
+      addChildView: function(view) {
+        this.childViews.push(view);
+        view.parentView = this;
+      },
+
+      /**
+       * @private
+       *
+       * Remove *view* from the list of managed child views.
+       *
+       * @method removeChildCiew
+       * @param {View} [view] The child view to remove.
+       */
+      removeChildView: function(view) {
+        var idx = this.childViews.indexOf(view);
+
+        if (idx < 0) {
+          throw view.toString() + " is not a child view of " + this.toString();
+        }
+
+        this.childViews.splice(idx, 1);
+        view.parentView = null;
+      },
+
+      /**
+       * @private
+       *
+       * Insert the view's `element` into the given *parent* element before the
+       * *reference* element. If no reference element is given, the element will be
+       * inserted at the end of the parent.
+       *
+       * @method insertElement
+       * @param {Element} [parent] The parent element.
+       * @param {Element} [reference] The reference element.
+       */
+      _insertElement: function(parent, reference) {
+        parent.insertBefore(this.element, reference || null);
+      },
+
+      /**
+       * @private
+       *
+       * Temporarily detach the element from its parent.
+       *
+       * @method detachElement
+       */
+      _detachElement: function() {
+        this.element.parentNode.removeChild(this.element);
+      },
+
+      /**
+       * @private
+       *
+       * Reattach the view's `element` into the given *parent* element before the
+       * *reference* element. If no reference element is given, the element will be
+       * inserted at the end of the parent.
+       *
+       * @method reattachElement
+       * @param {Element} [parent] The parent element.
+       * @param {Element} [reference] The reference element.
+       */
+      _reattachElement: function(parent, reference) {
+        this._insertElement(parent, reference);
+      },
+
+      /**
+       * @private
+       *
+       * Destroy a view's element.
+       *
+       * @method destroyElement
+       */
+      _destroyElement: function() {
+        this._detachElement();
+        this.element = null;
+      },
+
+      /**
+       * A hook that is called before the view's element has been inserted into the
+       * DOM.
+       *
+       * @method willInsertElement
+       */
+      willInsertElement: views$view$$NOOP,
+
+      /**
+       * A hook that will be called after the view's element has been inserted into
+       * the DOM.
+       *
+       * @method didInsertElement
+       */
+      didInsertElement: views$view$$NOOP,
+
+      /**
+       * A hook that is called before the view's element is temporarily removed from
+       * the DOM (e.g. before it is moved).
+       *
+       * The key difference between this hook and `willDestroyElement` is that the
+       * removal here is temporary and the same element will be re-inserted into the
+       * DOM at a later time. Because of that, you typically do not have to remove
+       * event listeners on the element itself, but if you have setup any listeners
+       * on the parent view/element, you should remove them here.
+       *
+       * @method willDetachElement
+       */
+      willDetachElement: views$view$$NOOP,
+
+      /**
+       * A hook that is called before a view's (previously detached) element is re-
+       * inserted into the DOM (e.g. after it has been moved).
+       *
+       * @method willReattachElement
+       */
+      willReattachElement: views$view$$NOOP,
+
+      /**
+       * A hook that is called after a view's (previously detached) element is re-
+       * inserted into the DOM (e.g. after it has been moved).
+       *
+       * If you removed any listeners in `willDetachElement`, this is the chance to
+       * set them up again.
+       *
+       * @method didReattachElement
+       */
+      didReattachElement: views$view$$NOOP,
+
+      /**
+       * A hook that is called before the view's element is permanently removed from
+       * the DOM.
+       *
+       * You should remove any listeners that you have set up on the element in
+       * `didInsertElement`, otherwise it might cause a memory leak.
+       *
+       * @method willDestroyElement
+       */
+      willDestroyElement: views$view$$NOOP,
+
+      deserialize: function() {
+        if (this.options && this.options.serializer) {
+          this.options.serializer.deserialize(this.element, this.options, this.data);
+        }
+      },
+
+      serialize: function() {
+        if (this.options && this.options.serializer) {
+          return this.options.serializer.serialize(this.element, this.options);
+        }
+      },
+
+      serializableChildren: function() {
+        return this.childViews;
+      },
+
+      toJSON: function() {
+        var json = {};
+
+        if (typeof this.options.role === "string") {
+          json.role = this.options.role;
+        }
+
+        if (typeof this.options.type === "string") {
+          json.type = this.options.type;
+        }
+
+        if (typeof this.options.name === "string") {
+          json.name = this.options.name;
+        }
+
+        json.data = views$view$$NULL(this.serialize());
+
+        json.children = [];
+
+        this.serializableChildren().forEach(function(child) {
+          json.children.push(child.toJSON());
+        });
+
+        return json;
+      }
+
+    }));
+
+    function views$container$view$$assertIdx(idx, length, insert) {
+      var max = insert ? length + 1 : length;
+
+      if (idx < 0 || idx >= max) {
+        throw "Index out of range: " + idx;
+      }
+    }
+
+    var views$container$view$$default = views$view$$default.extend({
+
+      init: function(element, options, data) {
+        this._super(element, options, data);
+        this.containerElement = this.element;
+      },
+
+      insertChildViewAt: function(view, idx) {
+        idx = idx || 0;
+
+        views$container$view$$assertIdx(idx, this.childViews.length, true);
+
+        this.childViews.splice(idx, 0, view);
+        view.parentView = this;
+
+        var referenceElement = this.containerElement.children[idx];
+
+        if (this.state === "inDOM") {
+          view.insertElement(this.containerElement, referenceElement);
+        } else {
+          this.containerElement.insertBefore(view.element, referenceElement || null);
+        }
+      },
+
+      appendChildView: function(view) {
+        this.insertChildViewAt(view, this.childViews.length);
+      },
+
+      moveChildView: function(fromIdx, toIdx) {
+        views$container$view$$assertIdx(fromIdx, this.childViews.length);
+        views$container$view$$assertIdx(toIdx, this.childViews.length);
+
+        if (fromIdx === toIdx) {
+          return;
+        }
+
+        var view = this.childViews.splice(fromIdx, 1)[0];
+        view.detachElement();
+
+        this.childViews.splice(toIdx, 0, view);
+        view.reattachElement(this.containerElement, this.containerElement.children[toIdx]);
+      },
+
+      removeChildViewAt: function(idx) {
+        views$container$view$$assertIdx(idx, this.childViews.length);
+        this.childViews.splice(idx, 1)[0].destroyElement();
+      }
+
+    });
+
+    function builder$builder$$ownKeys(object) {
+      var keys = [];
+
+      for (var key in object) {
+        if (object.hasOwnProperty(key)) {
+          keys.push(key);
+        }
+      }
+
+      return keys;
+    }
+
+    function builder$builder$$buildView(element, options, data, lookupPaths, parentView) {
+      if (!lookupPaths.shift) {
+        lookupPaths = [lookupPaths];
+      }
+
+      lookupPaths = lookupPaths.slice();
+
+      var ViewClass, path;
+
+      while (!ViewClass && lookupPaths.length) {
+        var path = lookupPaths.shift();
+
+        if (typeof path === "function") {
+          ViewClass = path;
+        } else {
+          ViewClass = core$$default.registry.lookup(path);
+        }
+      }
+
+      ViewClass = ViewClass || views$view$$default;
+
+      var placeholder;
+
+      // If element already has a parent, temporarily remove it so that the view
+      // has a chance to wrap the element at `init`
+      if (element.parentNode) {
+        placeholder = element.cloneNode(false);
+        element.parentNode.replaceChild(placeholder, element);
+      }
+
+      var view = new ViewClass(element, options, data);
+
+      if (placeholder) {
+        placeholder.parentNode.replaceChild(view.element, placeholder);
+      }
+
+      if (parentView) {
+        parentView.addChildView(view);
+      }
+
+      return view;
+    }
+
+    function builder$builder$$buildBlock(document, template, type, data, env, headless) {
+      var factory = template.blocks[type];
+
+      if (typeof factory !== "function") {
+        throw "The template does not define the block " + type;
+      }
+
+      var block = template$block$$default( factory.call(template, new dom$dom$builder$$default(document), env) );
+
+      var view = builder$builder$$buildView(
+        block.element,
+        {
+          role: "block",
+          type: type
+        },
+        data && data.data,
+        headless ? [] : ["view:block/" + type, "view:block"]
+      );
+
+      builder$builder$$initializeEditors(block.editables, view, data, headless);
+
+      return view;
+    }
+
+    function builder$builder$$findData(data, options) {
+      if (data && data.children.length) {
+        var entry;
+
+        for (var i=0; i<data.children.length; i++) {
+          entry = data.children[i];
+
+          if (typeof options.role === "string" && entry.role != options.role) {
+            continue;
+          }
+
+          if (typeof options.type === "string" && entry.type != options.type) {
+            continue;
+          }
+
+          if (typeof options.name === "string" && entry.name != options.name) {
+            continue;
+          }
+
+          return entry;
+        }
+      }
+    }
+
+    function builder$builder$$initializeEditors(editables, parentView, data, headless) {
+      editables.forEach(function(editable) {
+        var editable = template$editable$$default(editable);
+
+        var serializer = core$$default.registry.lookup("serializer:" + editable.type);
+
+        if (!serializer) {
+          core$$default.logger.error("No serializer were registered to handle " + editable.type);
+          return;
+        }
+
+        var options = {};
+
+        for (var key in editable.options) {
+          if (editable.options.hasOwnProperty(key)) {
+            options[key] = editable.options[key];
+          }
+        }
+
+        options.role = "editable";
+        options.type = editable.type;
+        options.name = editable.name;
+        options.serializer = serializer;
+
+        var editorData = builder$builder$$findData(data, options);
+
+        builder$builder$$buildView(editable.element, options, editorData && editorData.data, headless ? [] : ["view:editor/" + editable.type], parentView);
+      });
+    }
+
+    function builder$builder$$initializeBlocks(builder, data) {
+      if (data && data.children.length) {
+        var entry;
+
+        for (var i=0; i<data.children.length; i++) {
+          entry = data.children[i];
+
+          if (entry.role === "block") {
+            builder.appendBlock(entry.type, entry);
+          }
+        }
+      }
+    }
+
+    /**
+     * @class Builder
+     * @namespace Bob
+     * @param {String} [templateKey] The lookup key of the template to build from.
+     * @param {Document} [document] The `Document` to build on. If not provided, a
+     *   fresh document will be created.
+     */
+    var builder$builder$$Builder = utils$object$$default.extend({
+
+      init: function(template, window, data, env) {
+        var templateKey;
+
+        if (typeof template === "string") {
+          templateKey = template;
+          template = core$$default.registry.lookup("template:" + templateKey);
+        }
+
+        if (!template) {
+          throw "Template not found: " + templateKey;
+        }
+
+        if (window) {
+          this.headless = false;
+          this.contentWindow = window;
+          this.contentDocument = dom$document$$prepareDocument(window.document);
+        } else {
+          this.headless = true;
+          this.contentWindow = null;
+          this.contentDocument = dom$document$$createDocument();
+        }
+
+        if (env instanceof utils$hash$lookup$$default) {
+          this.env = env;
+        } else {
+          this.env = new utils$hash$lookup$$default(env);
+        }
+
+        /**
+         * The block types supported by the template.
+         *
+         * @property supportedBlockTypes
+         * @type String[]
+         */
+        this.supportedBlockTypes = builder$builder$$ownKeys(template.blocks);
+
+        var doc = this.contentDocument;
+
+        var layout = template$layout$$default( template.layout( new dom$dom$builder$$default(doc), this.env ) );
+
+        var layoutData = builder$builder$$findData(data, { role: "layout" });
+
+        var layoutView = builder$builder$$buildView(
+          layout.element,
+          { role: "layout" },
+          layoutData && layout.data,
+          this.headless ? [] : ["view:layout"]
+        );
+
+        builder$builder$$initializeEditors(layout.editables, layoutView, layoutData, this.headless);
+
+        var container = template$container$$default( layout.container );
+
+        var containerData = builder$builder$$findData(layoutData, { role: "container" });
+
+        var containerView = builder$builder$$buildView(
+          container.element,
+          { role: "container" },
+          containerData && containerData.data,
+          this.headless ? views$container$view$$default : ["view:container", views$container$view$$default],
+          layoutView
+        );
+
+        this.template      = template;
+        this.layoutView    = layoutView;
+        this.containerView = containerView;
+
+        builder$builder$$initializeBlocks(this, containerData);
+
+        layoutView.insertElement(doc);
+      },
+
+      blocks: utils$object$$LAZY(Array),
+
+      /**
+       * Insert a new block of *type* to the main container at the specific index.
+       * If the given index is out-of-range an error will be thrown.
+       *
+       * @method insertBlock
+       * @param {String} [type] The block type.
+       * @param {Integer} [idx=0] The index to insert at.
+       */
+      insertBlock: function(type, idx, data) {
+        var block = builder$builder$$buildBlock(this.contentDocument, this.template, type, data, this.env, this.headless);
+        this.containerView.insertChildViewAt(block, idx);
+      },
+
+      /**
+       * Append a new block of *type* to the end of the main container.
+       *
+       * @method appendBlock
+       * @param {String} [type] The block type.
+       */
+      appendBlock: function(type, data) {
+        var block = builder$builder$$buildBlock(this.contentDocument, this.template, type, data, this.env, this.headless);
+        this.containerView.appendChildView(block);
+      },
+
+      /**
+       * Move an existing block within the main container. If either of the indices
+       * are out-of-range, an error will be thrown.
+       *
+       * @method moveBlock
+       * @param {Integer} [fromIdx] The current index of the block.
+       * @param {Integer} [toIdx] The new index of the block.
+       */
+      moveBlock: function(fromIdx, toIdx) {
+        this.containerView.moveChildView(fromIdx, toIdx);
+      },
+
+      /**
+       * Remove an existing block from the main container. Any views and
+       * editors associated with the block will be deactivated and then destroyed.
+       * If the given index is out-of-range an error will be thrown.
+       *
+       * @method removeBlock
+       * @param {Integer} [idx] The index of the block.
+       */
+      removeBlock: function(idx) {
+        this.containerView.removeChildViewAt(idx);
+      },
+
+      /**
+       * Teardown the builder.
+       *
+       * @method destroy
+       */
+      destroy: function() {
+        this.layoutView.destroyElement();
+
+        dom$document$$prepareDocument(this.contentDocument);
+
+        this.contentWindow   = null;
+        this.contentDocument = null;
+        this.layoutView      = null;
+        this.containerView   = null;
+      },
+
+      /**
+       * Refresh the builder with an updated env hash.
+       *
+       * @method refresh
+       * @params {Object} [env] The updated env hash.
+       */
+      refresh: function(env) {
+        var template = this.template,
+            window   = this.contentWindow,
+            data     = this.toJSON(),
+            env      = env || this.env;
+
+        this.destroy();
+
+        this.init(template, window, data, env);
+      },
+
+      toJSON: function() {
+        return {
+          data: { version: 0 },
+          children: [
+            this.layoutView.toJSON()
+          ]
+        };
+      },
+
+      toHTML: function() {
+        var headless = new builder$builder$$Builder(this.template, null, this.toJSON(), this.env);
+        var root = headless.contentDocument.documentElement;
+
+        if (this.template.doctype) {
+          return this.template.doctype + "\n" + dom$serialize$$default(root);
+        } else {
+          return dom$serialize$$default(root);
+        }
+      }
+
+    });
+
+    var builder$builder$$default = builder$builder$$Builder;
+
+    /**
+     * Describes a template.
+     *
+     * @class Template
+     * @namespace Interface
+     */
+    var template$template$$Template = utils$interface$$default("Template", {
+
+      /**
+       * The doctype of the template.
+       *
+       * @property doctype
+       * @type String
+       * @default null
+       */
+      doctype: null,
+
+      /**
+       * A display name for the template.
+       *
+       * @property name
+       * @type String
+       * @required
+       */
+      name: utils$object$$REQUIRED,
+
+      /**
+       * A factory function to build the template's layout.
+       *
+       * @method layout
+       * @param {Document} [document] The `document` object to use.
+       * @return {Layout} The layout that was built.
+       * @required
+       */
+      layout: utils$object$$REQUIRED,
+
+      /**
+       * An object containing the blocks supported by the template keyed by their
+       * types. The functions should take a `Document` object as argument and return
+       * a `Block`.
+       *
+       * @property blocks
+       * @type Object
+       * @default {}
+       */
+      blocks: utils$object$$LAZY(Object)
+
+    });
+
+    var template$template$$default = template$template$$Template;
+    function template$template$$registerTemplate(key, template) {
+      key = "template:" + key;
+      template = template$template$$Template(template);
+
+      core$$default.register(key, template);
+    }
+
+    /**
+     * Exports all public classes and functions.
+     */
+
+    function bob$$exportAs(name, value) {
+      core$$default[name] = value;
+
+      if(value.__class__) {
+        value.__name__ = "Bob." + name;
+      }
+    }
+
+    bob$$exportAs("Logger", utils$logger$$default);
+
+    bob$$exportAs("Object", utils$object$$default);
+    bob$$exportAs("REQUIRED", utils$object$$REQUIRED);
+    bob$$exportAs("LAZY", utils$object$$LAZY);
+
+    bob$$exportAs("Builder", builder$builder$$default);
+
+    bob$$exportAs("registerTemplate", template$template$$registerTemplate);
+
+    bob$$exportAs("View", views$view$$default);
+
+    bob$$exportAs("ContainerView", views$container$view$$default);
+
+    bob$$exportAs("DomBuilder", dom$dom$builder$$default);
+
+    bob$$exportAs("HashLookup", utils$hash$lookup$$default);
+
+    // Global export
+    this.Bob = core$$default;
+
+    var bob$$default = core$$default;
+
+    var utils$required$$default = {
+      toString: function() {
+        return "(Required Property)";
+      }
+    };
+}).call(this);